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