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