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_mutually_exclusive_group(required=True)
  44         group1.add_argument('--osm-file', metavar='FILE', action='append',
  45                            help='OSM file to be imported'
  46                                 ' (repeat for importing multiple files)')
  47         group1.add_argument('--continue', dest='continue_at',
  48                            choices=['load-data', 'indexing', 'db-postprocess'],
  49                            help='Continue an import that was interrupted')
  50         group2 = parser.add_argument_group('Optional arguments')
  51         group2.add_argument('--osm2pgsql-cache', metavar='SIZE', type=int,
  52                            help='Size of cache to be used by osm2pgsql (in MB)')
  53         group2.add_argument('--reverse-only', action='store_true',
  54                            help='Do not create tables and indexes for searching')
  55         group2.add_argument('--no-partitions', action='store_true',
  56                            help=("Do not partition search indices "
  57                                  "(speeds up import of single country extracts)"))
  58         group2.add_argument('--no-updates', action='store_true',
  59                            help="Do not keep tables that are only needed for "
  60                                 "updating the database later")
  61         group2.add_argument('--offline', action='store_true',
  62                             help="Do not attempt to load any additional data from the internet")
  63         group3 = parser.add_argument_group('Expert options')
  64         group3.add_argument('--ignore-errors', action='store_true',
  65                            help='Continue import even when errors in SQL are present')
  66         group3.add_argument('--index-noanalyse', action='store_true',
  67                            help='Do not perform analyse operations during index (expert only)')
  68         group3.add_argument('--only-import-data', action='store_true',
  69                             help='Do not attempt to create the database')
  70         group3.add_argument('--only-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         if args.continue_at is None:
  84             files = args.get_osm_file_list()
  85             if not files and not args.only_prepare_database:
  86                 raise UsageError("No input files (use --osm-file).")
  87
  88             if args.only_import_data and args.only_prepare_database:
  89                 raise UsageError(
  90                     "Cannot use --only-import-data and --only-prepare-database together."
  91                 )
  92
  93             if args.only_prepare_database or self._is_complete_import(args):
  94                 LOG.warning('Creating database')
  95                 database_import.setup_database_skeleton(args.config.get_libpq_dsn(),
  96                                                         rouser=args.config.DATABASE_WEBUSER)
  97
  98                 if not self._is_complete_import(args):
  99                     return 0
 100
 101             if not args.only_prepare_database or \
 102                     args.only_import_data or \
 103                     self._is_complete_import(args):
 104                 # Check if the correct plugins are installed
 105                 database_import.check_existing_database_plugins(args.config.get_libpq_dsn())
 106                 LOG.warning('Setting up country tables')
 107                 country_info.setup_country_tables(args.config.get_libpq_dsn(),
 108                                                 args.config.lib_dir.data,
 109                                                 args.no_partitions)
 110
 111                 LOG.warning('Importing OSM data file')
 112                 database_import.import_osm_data(files,
 113                                                 args.osm2pgsql_options(0, 1),
 114                                                 drop=args.no_updates,
 115                                                 ignore_errors=args.ignore_errors)
 116
 117                 LOG.warning('Importing wikipedia importance data')
 118                 data_path = Path(args.config.WIKIPEDIA_DATA_PATH or args.project_dir)
 119                 if refresh.import_wikipedia_articles(args.config.get_libpq_dsn(),
 120                                                     data_path) > 0:
 121                     LOG.error('Wikipedia importance dump file not found. '
 122                             'Calculating importance values of locations will not '
 123                             'use Wikipedia importance data.')
 124
 125                 LOG.warning('Importing secondary importance raster data')
 126                 if refresh.import_secondary_importance(args.config.get_libpq_dsn(),
 127                                                     args.project_dir) != 0:
 128                     LOG.error('Secondary importance file not imported. '
 129                             'Falling back to default ranking.')
 130
 131                 self._setup_tables(args.config, args.reverse_only)
 132
 133         if args.continue_at is None or args.continue_at == 'load-data':
 134             LOG.warning('Initialise tables')
 135             with connect(args.config.get_libpq_dsn()) as conn:
 136                 database_import.truncate_data_tables(conn)
 137
 138             LOG.warning('Load data into placex table')
 139             database_import.load_data(args.config.get_libpq_dsn(), num_threads)
 140
 141         LOG.warning("Setting up tokenizer")
 142         tokenizer = self._get_tokenizer(args.continue_at, args.config)
 143
 144         if args.continue_at is None or args.continue_at == 'load-data':
 145             LOG.warning('Calculate postcodes')
 146             postcodes.update_postcodes(args.config.get_libpq_dsn(),
 147                                        args.project_dir, tokenizer)
 148
 149         if args.continue_at is None or args.continue_at in ('load-data', 'indexing'):
 150             LOG.warning('Indexing places')
 151             indexer = Indexer(args.config.get_libpq_dsn(), tokenizer, num_threads)
 152             indexer.index_full(analyse=not args.index_noanalyse)
 153
 154         LOG.warning('Post-process tables')
 155         with connect(args.config.get_libpq_dsn()) as conn:
 156             database_import.create_search_indices(conn, args.config,
 157                                                   drop=args.no_updates,
 158                                                   threads=num_threads)
 159             LOG.warning('Create search index for default country names.')
 160             country_info.create_country_names(conn, tokenizer,
 161                                               args.config.get_str_list('LANGUAGES'))
 162             if args.no_updates:
 163                 freeze.drop_update_tables(conn)
 164         tokenizer.finalize_import(args.config)
 165
 166         LOG.warning('Recompute word counts')
 167         tokenizer.update_statistics()
 168
 169         webdir = args.project_dir / 'website'
 170         LOG.warning('Setup website at %s', webdir)
 171         with connect(args.config.get_libpq_dsn()) as conn:
 172             refresh.setup_website(webdir, args.config, conn)
 173
 174         self._finalize_database(args.config.get_libpq_dsn(), args.offline)
 175
 176         return 0
 177
 178     def _is_complete_import(self, args: NominatimArgs) -> bool:
 179         """ Determine if the import is complete or if only the database should be prepared.
 180         """
 181         return not args.only_import_data and not args.only_prepare_database
 182
 183
 184     def _setup_tables(self, config: Configuration, reverse_only: bool) -> None:
 185         """ Set up the basic database layout: tables, indexes and functions.
 186         """
 187         from ..tools import database_import, refresh
 188
 189         with connect(config.get_libpq_dsn()) as conn:
 190             LOG.warning('Create functions (1st pass)')
 191             refresh.create_functions(conn, config, False, False)
 192             LOG.warning('Create tables')
 193             database_import.create_tables(conn, config, reverse_only=reverse_only)
 194             refresh.load_address_levels_from_config(conn, config)
 195             LOG.warning('Create functions (2nd pass)')
 196             refresh.create_functions(conn, config, False, False)
 197             LOG.warning('Create table triggers')
 198             database_import.create_table_triggers(conn, config)
 199             LOG.warning('Create partition tables')
 200             database_import.create_partition_tables(conn, config)
 201             LOG.warning('Create functions (3rd pass)')
 202             refresh.create_functions(conn, config, False, False)
 203
 204
 205     def _get_tokenizer(self, continue_at: Optional[str],
 206                        config: Configuration) -> AbstractTokenizer:
 207         """ Set up a new tokenizer or load an already initialised one.
 208         """
 209         from ..tokenizer import factory as tokenizer_factory
 210
 211         if continue_at is None or continue_at == 'load-data':
 212             # (re)initialise the tokenizer data
 213             return tokenizer_factory.create_tokenizer(config)
 214
 215         # just load the tokenizer
 216         return tokenizer_factory.get_tokenizer_for_db(config)
 217
 218
 219     def _finalize_database(self, dsn: str, offline: bool) -> None:
 220         """ Determine the database date and set the status accordingly.
 221         """
 222         with connect(dsn) as conn:
 223             if not offline:
 224                 try:
 225                     dbdate = status.compute_database_date(conn)
 226                     status.set_status(conn, dbdate)
 227                     LOG.info('Database is at %s.', dbdate)
 228                 except Exception as exc: # pylint: disable=broad-except
 229                     LOG.error('Cannot determine date of database: %s', exc)
 230
 231             properties.set_property(conn, 'database_version', str(NOMINATIM_VERSION))