nominatim/clicmd/setup.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 Implementation of the 'import' subcommand.
   9 """
  10 from typing import Optional
  11 import argparse
  12 import logging
  13 from pathlib import Path
  14
  15 import psutil
  16
  17 from nominatim.config import Configuration
  18 from nominatim.db.connection import connect
  19 from nominatim.db import status, properties
  20 from nominatim.tokenizer.base import AbstractTokenizer
  21 from nominatim.version import NOMINATIM_VERSION
  22 from nominatim.clicmd.args import NominatimArgs
  23 from nominatim.errors import UsageError
  24
  25 # Do not repeat documentation of subcommand classes.
  26 # pylint: disable=C0111
  27 # Using non-top-level imports to avoid eventually unused imports.
  28 # pylint: disable=C0415
  29
  30 LOG = logging.getLogger()
  31
  32 class SetupAll:
  33     """\
  34     Create a new Nominatim database from an OSM file.
  35
  36     This sub-command sets up a new Nominatim database from scratch starting
  37     with creating a new database in Postgresql. The user running this command
  38     needs superuser rights on the database.
  39     """
  40
  41     def add_args(self, parser: argparse.ArgumentParser) -> None:
  42         group_name = parser.add_argument_group('Required arguments')
  43         group1 = group_name.add_argument_group()
  44         group1.add_argument('--osm-file', metavar='FILE', action='append',
  45                            help='OSM file to be imported'
  46                                 ' (repeat for importing multiple files)',
  47                                 default=None)
  48         group1.add_argument('--continue', dest='continue_at',
  49                            choices=['import-from-file', 'load-data', 'indexing', 'db-postprocess'],
  50                            help='Continue an import that was interrupted',
  51                            default=None)
  52         group2 = parser.add_argument_group('Optional arguments')
  53         group2.add_argument('--osm2pgsql-cache', metavar='SIZE', type=int,
  54                            help='Size of cache to be used by osm2pgsql (in MB)')
  55         group2.add_argument('--reverse-only', action='store_true',
  56                            help='Do not create tables and indexes for searching')
  57         group2.add_argument('--no-partitions', action='store_true',
  58                            help=("Do not partition search indices "
  59                                  "(speeds up import of single country extracts)"))
  60         group2.add_argument('--no-updates', action='store_true',
  61                            help="Do not keep tables that are only needed for "
  62                                 "updating the database later")
  63         group2.add_argument('--offline', action='store_true',
  64                             help="Do not attempt to load any additional data from the internet")
  65         group3 = parser.add_argument_group('Expert options')
  66         group3.add_argument('--ignore-errors', action='store_true',
  67                            help='Continue import even when errors in SQL are present')
  68         group3.add_argument('--index-noanalyse', action='store_true',
  69                            help='Do not perform analyse operations during index (expert only)')
  70         group3.add_argument('--prepare-database', action='store_true',
  71                             help='Create the database but do not import any data')
  72
  73
  74     def run(self, args: NominatimArgs) -> int: # pylint: disable=too-many-statements
  75         from ..data import country_info
  76         from ..tools import database_import, refresh, postcodes, freeze
  77         from ..indexer.indexer import Indexer
  78
  79         num_threads = args.threads or psutil.cpu_count() or 1
  80
  81         country_info.setup_country_config(args.config)
  82
  83         # Check if osm-file or continue_at is set, if both are set, or none are set, throw an error
  84         if args.osm_file is None and args.continue_at is None:
  85             raise UsageError("No input files (use --osm-file).")
  86
  87         if args.osm_file is not None and args.continue_at not in ('import-from-file', None):
  88             raise UsageError(f"Cannot use --continue {args.continue_at} and --osm-file together.")
  89
  90         if args.continue_at is not None and args.prepare_database:
  91             raise UsageError(
  92                 "Cannot use --continue and --prepare-database together."
  93             )
  94
  95
  96
  97         if args.continue_at in (None, 'import-from-file'):
  98             files = args.get_osm_file_list()
  99             if not files and not args.prepare_database:
 100                 raise UsageError("No input files (use --osm-file).")
 101
 102             if args.prepare_database or self._is_complete_import(args):
 103                 LOG.warning('Creating database')
 104                 database_import.setup_database_skeleton(args.config.get_libpq_dsn(),
 105                                                         rouser=args.config.DATABASE_WEBUSER)
 106
 107                 if not self._is_complete_import(args):
 108                     return 0
 109
 110             if not args.prepare_database or \
 111                     args.continue_at == 'import-from-file' or \
 112                     self._is_complete_import(args):
 113                 # Check if the correct plugins are installed
 114                 database_import.check_existing_database_plugins(args.config.get_libpq_dsn())
 115                 LOG.warning('Setting up country tables')
 116                 country_info.setup_country_tables(args.config.get_libpq_dsn(),
 117                                                 args.config.lib_dir.data,
 118                                                 args.no_partitions)
 119
 120                 LOG.warning('Importing OSM data file')
 121                 database_import.import_osm_data(files,
 122                                                 args.osm2pgsql_options(0, 1),
 123                                                 drop=args.no_updates,
 124                                                 ignore_errors=args.ignore_errors)
 125
 126                 LOG.warning('Importing wikipedia importance data')
 127                 data_path = Path(args.config.WIKIPEDIA_DATA_PATH or args.project_dir)
 128                 if refresh.import_wikipedia_articles(args.config.get_libpq_dsn(),
 129                                                     data_path) > 0:
 130                     LOG.error('Wikipedia importance dump file not found. '
 131                             'Calculating importance values of locations will not '
 132                             'use Wikipedia importance data.')
 133
 134                 LOG.warning('Importing secondary importance raster data')
 135                 if refresh.import_secondary_importance(args.config.get_libpq_dsn(),
 136                                                     args.project_dir) != 0:
 137                     LOG.error('Secondary importance file not imported. '
 138                             'Falling back to default ranking.')
 139
 140                 self._setup_tables(args.config, args.reverse_only)
 141
 142         if args.continue_at is None or args.continue_at in ('import-from-file', 'load-data'):
 143             LOG.warning('Initialise tables')
 144             with connect(args.config.get_libpq_dsn()) as conn:
 145                 database_import.truncate_data_tables(conn)
 146
 147             LOG.warning('Load data into placex table')
 148             database_import.load_data(args.config.get_libpq_dsn(), num_threads)
 149
 150         LOG.warning("Setting up tokenizer")
 151         tokenizer = self._get_tokenizer(args.continue_at, args.config)
 152
 153         if args.continue_at in ('import-from-file', 'load-data', None):
 154             LOG.warning('Calculate postcodes')
 155             postcodes.update_postcodes(args.config.get_libpq_dsn(),
 156                                        args.project_dir, tokenizer)
 157
 158         if args.continue_at in \
 159             ('import-from-file', 'load-data', 'indexing', None):
 160             LOG.warning('Indexing places')
 161             indexer = Indexer(args.config.get_libpq_dsn(), tokenizer, num_threads)
 162             indexer.index_full(analyse=not args.index_noanalyse)
 163
 164         LOG.warning('Post-process tables')
 165         with connect(args.config.get_libpq_dsn()) as conn:
 166             database_import.create_search_indices(conn, args.config,
 167                                                   drop=args.no_updates,
 168                                                   threads=num_threads)
 169             LOG.warning('Create search index for default country names.')
 170             country_info.create_country_names(conn, tokenizer,
 171                                               args.config.get_str_list('LANGUAGES'))
 172             if args.no_updates:
 173                 freeze.drop_update_tables(conn)
 174         tokenizer.finalize_import(args.config)
 175
 176         LOG.warning('Recompute word counts')
 177         tokenizer.update_statistics()
 178
 179         webdir = args.project_dir / 'website'
 180         LOG.warning('Setup website at %s', webdir)
 181         with connect(args.config.get_libpq_dsn()) as conn:
 182             refresh.setup_website(webdir, args.config, conn)
 183
 184         self._finalize_database(args.config.get_libpq_dsn(), args.offline)
 185
 186         return 0
 187
 188     def _is_complete_import(self, args: NominatimArgs) -> bool:
 189         """ Determine if the import is complete or if only the database should be prepared.
 190         """
 191         return args.continue_at is None and not args.prepare_database
 192
 193
 194     def _setup_tables(self, config: Configuration, reverse_only: bool) -> None:
 195         """ Set up the basic database layout: tables, indexes and functions.
 196         """
 197         from ..tools import database_import, refresh
 198
 199         with connect(config.get_libpq_dsn()) as conn:
 200             LOG.warning('Create functions (1st pass)')
 201             refresh.create_functions(conn, config, False, False)
 202             LOG.warning('Create tables')
 203             database_import.create_tables(conn, config, reverse_only=reverse_only)
 204             refresh.load_address_levels_from_config(conn, config)
 205             LOG.warning('Create functions (2nd pass)')
 206             refresh.create_functions(conn, config, False, False)
 207             LOG.warning('Create table triggers')
 208             database_import.create_table_triggers(conn, config)
 209             LOG.warning('Create partition tables')
 210             database_import.create_partition_tables(conn, config)
 211             LOG.warning('Create functions (3rd pass)')
 212             refresh.create_functions(conn, config, False, False)
 213
 214
 215     def _get_tokenizer(self, continue_at: Optional[str],
 216                        config: Configuration) -> AbstractTokenizer:
 217         """ Set up a new tokenizer or load an already initialised one.
 218         """
 219         from ..tokenizer import factory as tokenizer_factory
 220
 221         if continue_at is None or continue_at == 'load-data':
 222             # (re)initialise the tokenizer data
 223             return tokenizer_factory.create_tokenizer(config)
 224
 225         # just load the tokenizer
 226         return tokenizer_factory.get_tokenizer_for_db(config)
 227
 228
 229     def _finalize_database(self, dsn: str, offline: bool) -> None:
 230         """ Determine the database date and set the status accordingly.
 231         """
 232         with connect(dsn) as conn:
 233             if not offline:
 234                 try:
 235                     dbdate = status.compute_database_date(conn)
 236                     status.set_status(conn, dbdate)
 237                     LOG.info('Database is at %s.', dbdate)
 238                 except Exception as exc: # pylint: disable=broad-except
 239                     LOG.error('Cannot determine date of database: %s', exc)
 240
 241             properties.set_property(conn, 'database_version', str(NOMINATIM_VERSION))