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