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