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