pybatmesh/naxalnet/config.py

# This file is part of naxalnet.
# Copyright (C) 2021 The naxalnet Authors

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""
config.py
---------

This file contains functions to parse configuration files
and arguments. Most of these functions are meant to be used
by parse_args() internally, so only parse_args() should
be imported outside this file.

Some parts of naxalnet can be configured by configuration
files and arguments. First, the default values from
default.py is taken. Then, key-value pairs from the
configuration files are read, if they exist, in the
following order:

- First it reads /usr/share/naxalnet/naxalnet.conf
  and then from /usr/share/naxalnet/naxalnet.conf.d/*.conf
  where *.conf means any file with the name ending with
  ".conf". The files in this directory are intended
  to be used by distribution and package maintainers.
- Next, it does the same with /usr/local/share/naxalnet
- Then, it looks for the files naxalnet.conf and
  naxalnet.conf.d/*.conf from the directory
  /etc/naxalnet, like it did up above. This directory is where
  the user creates and stores the config file.
- Then it parses the arguments from the commandline,
  storing the values in the files parsed until now
  as fallback. Finally you get an argpase.Namespace object
  from parse_args().
  Because of the way this is implemented, all key-value
  pairs in the configuration should have an argument
  too, or they won't be parsed.

All the key-value pairs are replaced successively if they exist
by each new configuration file parsed, similar
to how systemd parses configuration and service files.
If any of the files checked does not exist, then they are
ignored and the next combination is checked. If none of
the config files exist and no arguments are given, the
fallback data from default.py is used.
"""

from pathlib import Path
from configparser import ConfigParser
from argparse import ArgumentParser, Namespace
from naxalnet.default import CONFIG, CONFIG_FILES, CONFIG_DIRS


def get_config_files():
    """
    Read list of configuration files and return a list
    of files that exists as pathlib.Path objects
    """
    config_files = []

    for directory in CONFIG_DIRS:
        path = Path(directory)
        if path.exists():
            for i in CONFIG_FILES:
                glob = path.glob(i)
                config_files.extend(glob)
    return config_files


def parse_config():
    """
    Parse all configuration files, with the values in
    default.py as fallback
    """
    # logger.debug("Parsing config files")
    parser = ConfigParser()
    # encoded defaults
    parser.read_dict(CONFIG)
    # read config files
    files = get_config_files()
    for i in files:
        # logger.debug("Reading config file %s", str(i))
        parser.read_file(i.open())
    return parser


def parse_args() -> Namespace:
    """
    Parse all arguments and return ArgumentParser.parse_args(),
    with values in config files as fallback. Ideally, only this
    function should be used by naxalnet to get arguments and
    configuration.
    """
    config = parse_config()
    parser = ArgumentParser(
        description="setup batman-adv networks with systemd and iwd"
    )
    parser.add_argument(
        "--ap-ssid",
        "-n",
        type=str,
        help="SSID of the WiFi AP",
        default=config["ap"]["ssid"],
    )
    parser.add_argument(
        "--ap-passwd",
        "-p",
        "--ap-password",
        type=str,
        help="password of the WiFi AP",
        default=config["ap"]["passwd"],
    )

    parser.add_argument(
        "--adhoc-name",
        "-a",
        type=str,
        default=config["adhoc"]["name"],
        help="name of adhoc network",
    )

    parser.add_argument(
        "--print-wifi",
        action="store_true",
        default=False,
        help="prints the ssid and password of the WiFi network and exit",
    )

    parser.add_argument(
        "--networkd-config-dir",
        type=str,
        default=config["networkd"]["confdir"],
        help="the directory where systemd-networkd configuration files are stored",
    )

    parser.add_argument(
        "--networkd-runtime-dir",
        type=str,
        default=config["networkd"]["runtimedir"],
        help="volatile directory where configuration files of systemd-networkd should be copied",
    )

    parser.add_argument(
        "--systemd",
        action="store_true",
        default=False,
        help="send log messages to systemd journal",
    )

    parser.add_argument(
        "--version",
        "-V",
        default=False,
        action="store_true",
        help="prints the version and exit",
    )

    parser.add_argument(
        "-v", "--verbose", action="count", default=0, help="increase output verbosity"
    )

    # logger.debug("Parsing arguments")
    return parser.parse_args()


args = parse_args()