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