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