nominatim/config.py

   1 """
   2 Nominatim configuration accessor.
   3 """
   4 import logging
   5 import os
   6 from pathlib import Path
   7 import json
   8 import yaml
   9
  10 from dotenv import dotenv_values
  11
  12 from nominatim.errors import UsageError
  13
  14 LOG = logging.getLogger()
  15
  16
  17 def flatten_config_list(content, section=''):
  18     """ Flatten YAML configuration lists that contain include sections
  19         which are lists themselves.
  20     """
  21     if not content:
  22         return []
  23
  24     if not isinstance(content, list):
  25         raise UsageError(f"List expected in section '{section}'.")
  26
  27     output = []
  28     for ele in content:
  29         if isinstance(ele, list):
  30             output.extend(flatten_config_list(ele, section))
  31         else:
  32             output.append(ele)
  33
  34     return output
  35
  36
  37 class Configuration:
  38     """ Load and manage the project configuration.
  39
  40         Nominatim uses dotenv to configure the software. Configuration options
  41         are resolved in the following order:
  42
  43          * from the OS environment (or the dirctionary given in `environ`
  44          * from the .env file in the project directory of the installation
  45          * from the default installation in the configuration directory
  46
  47         All Nominatim configuration options are prefixed with 'NOMINATIM_' to
  48         avoid conflicts with other environment variables.
  49     """
  50
  51     def __init__(self, project_dir, config_dir, environ=None):
  52         self.environ = environ or os.environ
  53         self.project_dir = project_dir
  54         self.config_dir = config_dir
  55         self._config = dotenv_values(str((config_dir / 'env.defaults').resolve()))
  56         if project_dir is not None and (project_dir / '.env').is_file():
  57             self._config.update(dotenv_values(str((project_dir / '.env').resolve())))
  58
  59         class _LibDirs:
  60             pass
  61
  62         self.lib_dir = _LibDirs()
  63
  64     def set_libdirs(self, **kwargs):
  65         """ Set paths to library functions and data.
  66         """
  67         for key, value in kwargs.items():
  68             setattr(self.lib_dir, key, Path(value).resolve())
  69
  70     def __getattr__(self, name):
  71         name = 'NOMINATIM_' + name
  72
  73         if name in self.environ:
  74             return self.environ[name]
  75
  76         return self._config[name]
  77
  78     def get_bool(self, name):
  79         """ Return the given configuration parameter as a boolean.
  80             Values of '1', 'yes' and 'true' are accepted as truthy values,
  81             everything else is interpreted as false.
  82         """
  83         return self.__getattr__(name).lower() in ('1', 'yes', 'true')
  84
  85
  86     def get_int(self, name):
  87         """ Return the given configuration parameter as an int.
  88         """
  89         try:
  90             return int(self.__getattr__(name))
  91         except ValueError as exp:
  92             LOG.fatal("Invalid setting NOMINATIM_%s. Needs to be a number.", name)
  93             raise UsageError("Configuration error.") from exp
  94
  95
  96     def get_libpq_dsn(self):
  97         """ Get configured database DSN converted into the key/value format
  98             understood by libpq and psycopg.
  99         """
 100         dsn = self.DATABASE_DSN
 101
 102         def quote_param(param):
 103             key, val = param.split('=')
 104             val = val.replace('\\', '\\\\').replace("'", "\\'")
 105             if ' ' in val:
 106                 val = "'" + val + "'"
 107             return key + '=' + val
 108
 109         if dsn.startswith('pgsql:'):
 110             # Old PHP DSN format. Convert before returning.
 111             return ' '.join([quote_param(p) for p in dsn[6:].split(';')])
 112
 113         return dsn
 114
 115
 116     def get_import_style_file(self):
 117         """ Return the import style file as a path object. Translates the
 118             name of the standard styles automatically into a file in the
 119             config style.
 120         """
 121         style = self.__getattr__('IMPORT_STYLE')
 122
 123         if style in ('admin', 'street', 'address', 'full', 'extratags'):
 124             return self.config_dir / 'import-{}.style'.format(style)
 125
 126         return Path(style)
 127
 128
 129     def get_os_env(self):
 130         """ Return a copy of the OS environment with the Nominatim configuration
 131             merged in.
 132         """
 133         env = dict(self._config)
 134         env.update(self.environ)
 135
 136         return env
 137
 138
 139     def load_sub_configuration(self, filename, config=None):
 140         """ Load additional configuration from a file. `filename` is the name
 141             of the configuration file. The file is first searched in the
 142             project directory and then in the global settings dirctory.
 143
 144             If `config` is set, then the name of the configuration file can
 145             be additionally given through a .env configuration option. When
 146             the option is set, then the file will be exclusively loaded as set:
 147             if the name is an absolute path, the file name is taken as is,
 148             if the name is relative, it is taken to be relative to the
 149             project directory.
 150
 151             The format of the file is determined from the filename suffix.
 152             Currently only files with extension '.yaml' are supported.
 153
 154             YAML files support a special '!include' construct. When the
 155             directive is given, the value is taken to be a filename, the file
 156             is loaded using this function and added at the position in the
 157             configuration tree.
 158         """
 159         configfile = self.find_config_file(filename, config)
 160
 161         if configfile.suffix in ('.yaml', '.yml'):
 162             return self._load_from_yaml(configfile)
 163
 164         if configfile.suffix == '.json':
 165             with configfile.open('r') as cfg:
 166                 return json.load(cfg)
 167
 168         raise UsageError(f"Config file '{configfile}' has unknown format.")
 169
 170
 171     def find_config_file(self, filename, config=None):
 172         """ Resolve the location of a configuration file given a filename and
 173             an optional configuration option with the file name.
 174             Raises a UsageError when the file cannot be found or is not
 175             a regular file.
 176         """
 177         if config is not None:
 178             cfg_filename = self.__getattr__(config)
 179             if cfg_filename:
 180                 cfg_filename = Path(cfg_filename)
 181
 182                 if cfg_filename.is_absolute():
 183                     cfg_filename = cfg_filename.resolve()
 184
 185                     if not cfg_filename.is_file():
 186                         LOG.fatal("Cannot find config file '%s'.", cfg_filename)
 187                         raise UsageError("Config file not found.")
 188
 189                     return cfg_filename
 190
 191                 filename = cfg_filename
 192
 193
 194         search_paths = [self.project_dir, self.config_dir]
 195         for path in search_paths:
 196             if path is not None and (path / filename).is_file():
 197                 return path / filename
 198
 199         LOG.fatal("Configuration file '%s' not found.\nDirectories searched: %s",
 200                   filename, search_paths)
 201         raise UsageError("Config file not found.")
 202
 203
 204     def _load_from_yaml(self, cfgfile):
 205         """ Load a YAML configuration file. This installs a special handler that
 206             allows to include other YAML files using the '!include' operator.
 207         """
 208         yaml.add_constructor('!include', self._yaml_include_representer,
 209                              Loader=yaml.SafeLoader)
 210         return yaml.safe_load(cfgfile.read_text(encoding='utf-8'))
 211
 212
 213     def _yaml_include_representer(self, loader, node):
 214         """ Handler for the '!include' operator in YAML files.
 215
 216             When the filename is relative, then the file is first searched in the
 217             project directory and then in the global settings dirctory.
 218         """
 219         fname = loader.construct_scalar(node)
 220
 221         if Path(fname).is_absolute():
 222             configfile = Path(fname)
 223         else:
 224             configfile = self.find_config_file(loader.construct_scalar(node))
 225
 226         if configfile.suffix != '.yaml':
 227             LOG.fatal("Format error while reading '%s': only YAML format supported.",
 228                       configfile)
 229             raise UsageError("Cannot handle config file format.")
 230
 231         return yaml.safe_load(configfile.read_text(encoding='utf-8'))