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:
 103                 LOG.warning('Creating database')
 104                 database_import.setup_database_skeleton(args.config.get_libpq_dsn(),
 105                                                         rouser=args.config.DATABASE_WEBUSER)
 106                 return 0
 107
 108             if not args.prepare_database or \
 109                     args.continue_at == 'import-from-file':
 110                 # Check if the correct plugins are installed
 111                 database_import.check_existing_database_plugins(args.config.get_libpq_dsn())
 112                 LOG.warning('Setting up country tables')
 113                 country_info.setup_country_tables(args.config.get_libpq_dsn(),
 114                                                 args.config.lib_dir.data,
 115                                                 args.no_partitions)
 116
 117                 LOG.warning('Importing OSM data file')
 118                 database_import.import_osm_data(files,
 119                                                 args.osm2pgsql_options(0, 1),
 120                                                 drop=args.no_updates,
 121                                                 ignore_errors=args.ignore_errors)
 122
 123                 LOG.warning('Importing wikipedia importance data')
 124                 data_path = Path(args.config.WIKIPEDIA_DATA_PATH or args.project_dir)
 125                 if refresh.import_wikipedia_articles(args.config.get_libpq_dsn(),
 126                                                     data_path) > 0:
 127                     LOG.error('Wikipedia importance dump file not found. '
 128                             'Calculating importance values of locations will not '
 129                             'use Wikipedia importance data.')
 130
 131                 LOG.warning('Importing secondary importance raster data')
 132                 if refresh.import_secondary_importance(args.config.get_libpq_dsn(),
 133                                                     args.project_dir) != 0:
 134                     LOG.error('Secondary importance file not imported. '
 135                             'Falling back to default ranking.')
 136
 137                 self._setup_tables(args.config, args.reverse_only)
 138
 139         if args.continue_at in ('import-from-file', 'load-data', None):
 140             LOG.warning('Initialise tables')
 141             with connect(args.config.get_libpq_dsn()) as conn:
 142                 database_import.truncate_data_tables(conn)
 143
 144             LOG.warning('Load data into placex table')
 145             database_import.load_data(args.config.get_libpq_dsn(), num_threads)
 146
 147         LOG.warning("Setting up tokenizer")
 148         tokenizer = self._get_tokenizer(args.continue_at, args.config)
 149
 150         if args.continue_at in ('import-from-file', 'load-data', None):
 151             LOG.warning('Calculate postcodes')
 152             postcodes.update_postcodes(args.config.get_libpq_dsn(),
 153                                        args.project_dir, tokenizer)
 154
 155         if args.continue_at in \
 156             ('import-from-file', 'load-data', 'indexing', None):
 157             LOG.warning('Indexing places')
 158             indexer = Indexer(args.config.get_libpq_dsn(), tokenizer, num_threads)
 159             indexer.index_full(analyse=not args.index_noanalyse)
 160
 161         LOG.warning('Post-process tables')
 162         with connect(args.config.get_libpq_dsn()) as conn:
 163             database_import.create_search_indices(conn, args.config,
 164                                                   drop=args.no_updates,
 165                                                   threads=num_threads)
 166             LOG.warning('Create search index for default country names.')
 167             country_info.create_country_names(conn, tokenizer,
 168                                               args.config.get_str_list('LANGUAGES'))
 169             if args.no_updates:
 170                 freeze.drop_update_tables(conn)
 171         tokenizer.finalize_import(args.config)
 172
 173         LOG.warning('Recompute word counts')
 174         tokenizer.update_statistics()
 175
 176         webdir = args.project_dir / 'website'
 177         LOG.warning('Setup website at %s', webdir)
 178         with connect(args.config.get_libpq_dsn()) as conn:
 179             refresh.setup_website(webdir, args.config, conn)
 180
 181         self._finalize_database(args.config.get_libpq_dsn(), args.offline)
 182
 183         return 0
 184
 185
 186     def _setup_tables(self, config: Configuration, reverse_only: bool) -> None:
 187         """ Set up the basic database layout: tables, indexes and functions.
 188         """
 189         from ..tools import database_import, refresh
 190
 191         with connect(config.get_libpq_dsn()) as conn:
 192             LOG.warning('Create functions (1st pass)')
 193             refresh.create_functions(conn, config, False, False)
 194             LOG.warning('Create tables')
 195             database_import.create_tables(conn, config, reverse_only=reverse_only)
 196             refresh.load_address_levels_from_config(conn, config)
 197             LOG.warning('Create functions (2nd pass)')
 198             refresh.create_functions(conn, config, False, False)
 199             LOG.warning('Create table triggers')
 200             database_import.create_table_triggers(conn, config)
 201             LOG.warning('Create partition tables')
 202             database_import.create_partition_tables(conn, config)
 203             LOG.warning('Create functions (3rd pass)')
 204             refresh.create_functions(conn, config, False, False)
 205
 206
 207     def _get_tokenizer(self, continue_at: Optional[str],
 208                        config: Configuration) -> AbstractTokenizer:
 209         """ Set up a new tokenizer or load an already initialised one.
 210         """
 211         from ..tokenizer import factory as tokenizer_factory
 212
 213         if continue_at is None or continue_at == 'load-data':
 214             # (re)initialise the tokenizer data
 215             return tokenizer_factory.create_tokenizer(config)
 216
 217         # just load the tokenizer
 218         return tokenizer_factory.get_tokenizer_for_db(config)
 219
 220
 221     def _finalize_database(self, dsn: str, offline: bool) -> None:
 222         """ Determine the database date and set the status accordingly.
 223         """
 224         with connect(dsn) as conn:
 225             if not offline:
 226                 try:
 227                     dbdate = status.compute_database_date(conn)
 228                     status.set_status(conn, dbdate)
 229                     LOG.info('Database is at %s.', dbdate)
 230                 except Exception as exc: # pylint: disable=broad-except
 231                     LOG.error('Cannot determine date of database: %s', exc)
 232
 233             properties.set_property(conn, 'database_version', str(NOMINATIM_VERSION))