]> git.openstreetmap.org Git - nominatim.git/blob - utils/setup.php
Merge branch 'tetris' of https://github.com/roques/Nominatim into roques-tetris
[nominatim.git] / utils / setup.php
1 #!/usr/bin/php -Cq
2 <?php
3
4 require_once(dirname(dirname(__FILE__)).'/settings/settings.php');
5 require_once(CONST_BasePath.'/lib/init-cmd.php');
6 ini_set('memory_limit', '800M');
7
8 $aCMDOptions
9 = array(
10    "Create and setup nominatim search system",
11    array('help', 'h', 0, 1, 0, 0, false, 'Show Help'),
12    array('quiet', 'q', 0, 1, 0, 0, 'bool', 'Quiet output'),
13    array('verbose', 'v', 0, 1, 0, 0, 'bool', 'Verbose output'),
14
15    array('osm-file', '', 0, 1, 1, 1, 'realpath', 'File to import'),
16    array('threads', '', 0, 1, 1, 1, 'int', 'Number of threads (where possible)'),
17
18    array('all', '', 0, 1, 0, 0, 'bool', 'Do the complete process'),
19
20    array('create-db', '', 0, 1, 0, 0, 'bool', 'Create nominatim db'),
21    array('setup-db', '', 0, 1, 0, 0, 'bool', 'Build a blank nominatim db'),
22    array('import-data', '', 0, 1, 0, 0, 'bool', 'Import a osm file'),
23    array('osm2pgsql-cache', '', 0, 1, 1, 1, 'int', 'Cache size used by osm2pgsql'),
24    array('create-functions', '', 0, 1, 0, 0, 'bool', 'Create functions'),
25    array('enable-diff-updates', '', 0, 1, 0, 0, 'bool', 'Turn on the code required to make diff updates work'),
26    array('enable-debug-statements', '', 0, 1, 0, 0, 'bool', 'Include debug warning statements in pgsql commands'),
27    array('ignore-errors', '', 0, 1, 0, 0, 'bool', 'Continue import even when errors in SQL are present (EXPERT)'),
28    array('create-tables', '', 0, 1, 0, 0, 'bool', 'Create main tables'),
29    array('create-partition-tables', '', 0, 1, 0, 0, 'bool', 'Create required partition tables'),
30    array('create-partition-functions', '', 0, 1, 0, 0, 'bool', 'Create required partition triggers'),
31    array('no-partitions', '', 0, 1, 0, 0, 'bool', "Do not partition search indices (speeds up import of single country extracts)"),
32    array('import-wikipedia-articles', '', 0, 1, 0, 0, 'bool', 'Import wikipedia article dump'),
33    array('load-data', '', 0, 1, 0, 0, 'bool', 'Copy data to live tables from import table'),
34    array('disable-token-precalc', '', 0, 1, 0, 0, 'bool', 'Disable name precalculation (EXPERT)'),
35    array('import-tiger-data', '', 0, 1, 0, 0, 'bool', 'Import tiger data (not included in \'all\')'),
36    array('calculate-postcodes', '', 0, 1, 0, 0, 'bool', 'Calculate postcode centroids'),
37    array('osmosis-init', '', 0, 1, 0, 0, 'bool', 'Generate default osmosis configuration'),
38    array('index', '', 0, 1, 0, 0, 'bool', 'Index the data'),
39    array('index-noanalyse', '', 0, 1, 0, 0, 'bool', 'Do not perform analyse operations during index (EXPERT)'),
40    array('create-search-indices', '', 0, 1, 0, 0, 'bool', 'Create additional indices required for search and update'),
41    array('create-country-names', '', 0, 1, 0, 0, 'bool', 'Create default list of searchable country names'),
42    array('drop', '', 0, 1, 0, 0, 'bool', 'Drop tables needed for updates, making the database readonly (EXPERIMENTAL)'),
43   );
44 getCmdOpt($_SERVER['argv'], $aCMDOptions, $aCMDResult, true, true);
45
46 $bDidSomething = false;
47
48 // Check if osm-file is set and points to a valid file if --all or --import-data is given
49 if ($aCMDResult['import-data'] || $aCMDResult['all']) {
50     if (!isset($aCMDResult['osm-file'])) {
51         fail('missing --osm-file for data import');
52     }
53
54     if (!file_exists($aCMDResult['osm-file'])) {
55         fail('the path supplied to --osm-file does not exist');
56     }
57
58     if (!is_readable($aCMDResult['osm-file'])) {
59         fail('osm-file "'.$aCMDResult['osm-file'].'" not readable');
60     }
61 }
62
63
64 // This is a pretty hard core default - the number of processors in the box - 1
65 $iInstances = isset($aCMDResult['threads'])?$aCMDResult['threads']:(getProcessorCount()-1);
66 if ($iInstances < 1) {
67     $iInstances = 1;
68     echo "WARNING: resetting threads to $iInstances\n";
69 }
70 if ($iInstances > getProcessorCount()) {
71     $iInstances = getProcessorCount();
72     echo "WARNING: resetting threads to $iInstances\n";
73 }
74
75 // Assume we can steal all the cache memory in the box (unless told otherwise)
76 if (isset($aCMDResult['osm2pgsql-cache'])) {
77     $iCacheMemory = $aCMDResult['osm2pgsql-cache'];
78 } else {
79     $iCacheMemory = getCacheMemoryMB();
80 }
81
82 $aDSNInfo = DB::parseDSN(CONST_Database_DSN);
83 if (!isset($aDSNInfo['port']) || !$aDSNInfo['port']) $aDSNInfo['port'] = 5432;
84
85 if ($aCMDResult['create-db'] || $aCMDResult['all']) {
86     echo "Create DB\n";
87     $bDidSomething = true;
88     $oDB = DB::connect(CONST_Database_DSN, false);
89     if (!PEAR::isError($oDB)) {
90         fail('database already exists ('.CONST_Database_DSN.')');
91     }
92     passthruCheckReturn('createdb -E UTF-8 -p '.$aDSNInfo['port'].' '.$aDSNInfo['database']);
93 }
94
95 if ($aCMDResult['setup-db'] || $aCMDResult['all']) {
96     echo "Setup DB\n";
97     $bDidSomething = true;
98
99     // TODO: path detection, detection memory, etc.
100     //
101     $oDB =& getDB();
102
103     $fPostgresVersion = getPostgresVersion($oDB);
104     echo 'Postgres version found: '.$fPostgresVersion."\n";
105
106     if ($fPostgresVersion < 9.1) {
107         fail("Minimum supported version of Postgresql is 9.1.");
108     }
109
110     pgsqlRunScript('CREATE EXTENSION IF NOT EXISTS hstore');
111     pgsqlRunScript('CREATE EXTENSION IF NOT EXISTS postgis');
112
113     // For extratags and namedetails the hstore_to_json converter is
114     // needed which is only available from Postgresql 9.3+. For older
115     // versions add a dummy function that returns nothing.
116     $iNumFunc = chksql($oDB->getOne("select count(*) from pg_proc where proname = 'hstore_to_json'"));
117
118     if ($iNumFunc == 0) {
119         pgsqlRunScript("create function hstore_to_json(dummy hstore) returns text AS 'select null::text' language sql immutable");
120         echo "WARNING: Postgresql is too old. extratags and namedetails API not available.";
121     }
122
123     $fPostgisVersion = getPostgisVersion($oDB);
124     echo 'Postgis version found: '.$fPostgisVersion."\n";
125
126     if ($fPostgisVersion < 2.1) {
127         // Functions were renamed in 2.1 and throw an annoying deprecation warning
128         pgsqlRunScript('ALTER FUNCTION st_line_interpolate_point(geometry, double precision) RENAME TO ST_LineInterpolatePoint');
129         pgsqlRunScript('ALTER FUNCTION ST_Line_Locate_Point(geometry, geometry) RENAME TO ST_LineLocatePoint');
130     }
131     if ($fPostgisVersion < 2.2) {
132         pgsqlRunScript('ALTER FUNCTION ST_Distance_Spheroid(geometry, geometry, spheroid) RENAME TO ST_DistanceSpheroid');
133     }
134
135     pgsqlRunScriptFile(CONST_BasePath.'/data/country_name.sql');
136     pgsqlRunScriptFile(CONST_BasePath.'/data/country_naturalearthdata.sql');
137     pgsqlRunScriptFile(CONST_BasePath.'/data/country_osm_grid.sql');
138     pgsqlRunScriptFile(CONST_BasePath.'/data/gb_postcode_table.sql');
139     if (file_exists(CONST_BasePath.'/data/gb_postcode_data.sql.gz')) {
140         pgsqlRunScriptFile(CONST_BasePath.'/data/gb_postcode_data.sql.gz');
141     } else {
142         echo "WARNING: external UK postcode table not found.\n";
143     }
144     if (CONST_Use_Extra_US_Postcodes) {
145         pgsqlRunScriptFile(CONST_BasePath.'/data/us_postcode.sql');
146     }
147
148     if ($aCMDResult['no-partitions']) {
149         pgsqlRunScript('update country_name set partition = 0');
150     }
151
152     // the following will be needed by create_functions later but
153     // is only defined in the subsequently called create_tables.
154     // Create dummies here that will be overwritten by the proper
155     // versions in create-tables.
156     pgsqlRunScript('CREATE TABLE place_boundingbox ()');
157     pgsqlRunScript('create type wikipedia_article_match as ()');
158 }
159
160 if ($aCMDResult['import-data'] || $aCMDResult['all']) {
161     echo "Import\n";
162     $bDidSomething = true;
163
164     $osm2pgsql = CONST_Osm2pgsql_Binary;
165     if (!file_exists($osm2pgsql)) {
166         echo "Check CONST_Osm2pgsql_Binary in your local settings file.\n";
167         echo "Normally you should not need to set this manually.\n";
168         fail("osm2pgsql not found in '$osm2pgsql'");
169     }
170
171     if (!is_null(CONST_Osm2pgsql_Flatnode_File)) {
172         $osm2pgsql .= ' --flat-nodes '.CONST_Osm2pgsql_Flatnode_File;
173     }
174     if (CONST_Tablespace_Osm2pgsql_Data)
175         $osm2pgsql .= ' --tablespace-slim-data '.CONST_Tablespace_Osm2pgsql_Data;
176     if (CONST_Tablespace_Osm2pgsql_Index)
177         $osm2pgsql .= ' --tablespace-slim-index '.CONST_Tablespace_Osm2pgsql_Index;
178     if (CONST_Tablespace_Place_Data)
179         $osm2pgsql .= ' --tablespace-main-data '.CONST_Tablespace_Place_Data;
180     if (CONST_Tablespace_Place_Index)
181         $osm2pgsql .= ' --tablespace-main-index '.CONST_Tablespace_Place_Index;
182     $osm2pgsql .= ' -lsc -O gazetteer --hstore --number-processes 1';
183     $osm2pgsql .= ' -C '.$iCacheMemory;
184     $osm2pgsql .= ' -P '.$aDSNInfo['port'];
185     $osm2pgsql .= ' -d '.$aDSNInfo['database'].' '.$aCMDResult['osm-file'];
186     passthruCheckReturn($osm2pgsql);
187
188     $oDB =& getDB();
189     if (!$aCMDResult['ignore-errors'] && !chksql($oDB->getRow('select * from place limit 1'))) {
190         fail('No Data');
191     }
192 }
193
194 if ($aCMDResult['create-functions'] || $aCMDResult['all']) {
195     echo "Functions\n";
196     $bDidSomething = true;
197     if (!file_exists(CONST_InstallPath.'/module/nominatim.so')) fail("nominatim module not built");
198     create_sql_functions($aCMDResult);
199 }
200
201 if ($aCMDResult['create-tables'] || $aCMDResult['all']) {
202     $bDidSomething = true;
203
204     echo "Tables\n";
205     $sTemplate = file_get_contents(CONST_BasePath.'/sql/tables.sql');
206     $sTemplate = str_replace('{www-user}', CONST_Database_Web_User, $sTemplate);
207     $sTemplate = replace_tablespace(
208         '{ts:address-data}',
209         CONST_Tablespace_Address_Data,
210         $sTemplate
211     );
212     $sTemplate = replace_tablespace(
213         '{ts:address-index}',
214         CONST_Tablespace_Address_Index,
215         $sTemplate
216     );
217     $sTemplate = replace_tablespace(
218         '{ts:search-data}',
219         CONST_Tablespace_Search_Data,
220         $sTemplate
221     );
222     $sTemplate = replace_tablespace(
223         '{ts:search-index}',
224         CONST_Tablespace_Search_Index,
225         $sTemplate
226     );
227     $sTemplate = replace_tablespace(
228         '{ts:aux-data}',
229         CONST_Tablespace_Aux_Data,
230         $sTemplate
231     );
232     $sTemplate = replace_tablespace(
233         '{ts:aux-index}',
234         CONST_Tablespace_Aux_Index,
235         $sTemplate
236     );
237     pgsqlRunScript($sTemplate, false);
238
239     // re-run the functions
240     echo "Functions\n";
241     create_sql_functions($aCMDResult);
242 }
243
244 if ($aCMDResult['create-partition-tables'] || $aCMDResult['all']) {
245     echo "Partition Tables\n";
246     $bDidSomething = true;
247
248     $sTemplate = file_get_contents(CONST_BasePath.'/sql/partition-tables.src.sql');
249     $sTemplate = replace_tablespace(
250         '{ts:address-data}',
251         CONST_Tablespace_Address_Data,
252         $sTemplate
253     );
254     $sTemplate = replace_tablespace(
255         '{ts:address-index}',
256         CONST_Tablespace_Address_Index,
257         $sTemplate
258     );
259     $sTemplate = replace_tablespace(
260         '{ts:search-data}',
261         CONST_Tablespace_Search_Data,
262         $sTemplate
263     );
264     $sTemplate = replace_tablespace(
265         '{ts:search-index}',
266         CONST_Tablespace_Search_Index,
267         $sTemplate
268     );
269     $sTemplate = replace_tablespace(
270         '{ts:aux-data}',
271         CONST_Tablespace_Aux_Data,
272         $sTemplate
273     );
274     $sTemplate = replace_tablespace(
275         '{ts:aux-index}',
276         CONST_Tablespace_Aux_Index,
277         $sTemplate
278     );
279
280     pgsqlRunPartitionScript($sTemplate);
281 }
282
283
284 if ($aCMDResult['create-partition-functions'] || $aCMDResult['all']) {
285     echo "Partition Functions\n";
286     $bDidSomething = true;
287
288     $sTemplate = file_get_contents(CONST_BasePath.'/sql/partition-functions.src.sql');
289
290     pgsqlRunPartitionScript($sTemplate);
291 }
292
293 if ($aCMDResult['import-wikipedia-articles'] || $aCMDResult['all']) {
294     $bDidSomething = true;
295     $sWikiArticlesFile = CONST_Wikipedia_Data_Path.'/wikipedia_article.sql.bin';
296     $sWikiRedirectsFile = CONST_Wikipedia_Data_Path.'/wikipedia_redirect.sql.bin';
297     if (file_exists($sWikiArticlesFile)) {
298         echo "Importing wikipedia articles...";
299         pgsqlRunDropAndRestore($sWikiArticlesFile);
300         echo "...done\n";
301     } else {
302         echo "WARNING: wikipedia article dump file not found - places will have default importance\n";
303     }
304     if (file_exists($sWikiRedirectsFile)) {
305         echo "Importing wikipedia redirects...";
306         pgsqlRunDropAndRestore($sWikiRedirectsFile);
307         echo "...done\n";
308     } else {
309         echo "WARNING: wikipedia redirect dump file not found - some place importance values may be missing\n";
310     }
311 }
312
313
314 if ($aCMDResult['load-data'] || $aCMDResult['all']) {
315     echo "Drop old Data\n";
316     $bDidSomething = true;
317
318     $oDB =& getDB();
319     if (!pg_query($oDB->connection, 'TRUNCATE word')) fail(pg_last_error($oDB->connection));
320     echo '.';
321     if (!pg_query($oDB->connection, 'TRUNCATE placex')) fail(pg_last_error($oDB->connection));
322     echo '.';
323     if (!pg_query($oDB->connection, 'TRUNCATE location_property_osmline')) fail(pg_last_error($oDB->connection));
324     echo '.';
325     if (!pg_query($oDB->connection, 'TRUNCATE place_addressline')) fail(pg_last_error($oDB->connection));
326     echo '.';
327     if (!pg_query($oDB->connection, 'TRUNCATE place_boundingbox')) fail(pg_last_error($oDB->connection));
328     echo '.';
329     if (!pg_query($oDB->connection, 'TRUNCATE location_area')) fail(pg_last_error($oDB->connection));
330     echo '.';
331     if (!pg_query($oDB->connection, 'TRUNCATE search_name')) fail(pg_last_error($oDB->connection));
332     echo '.';
333     if (!pg_query($oDB->connection, 'TRUNCATE search_name_blank')) fail(pg_last_error($oDB->connection));
334     echo '.';
335     if (!pg_query($oDB->connection, 'DROP SEQUENCE seq_place')) fail(pg_last_error($oDB->connection));
336     echo '.';
337     if (!pg_query($oDB->connection, 'CREATE SEQUENCE seq_place start 100000')) fail(pg_last_error($oDB->connection));
338     echo '.';
339
340     $sSQL = 'select distinct partition from country_name';
341     $aPartitions = chksql($oDB->getCol($sSQL));
342     if (!$aCMDResult['no-partitions']) $aPartitions[] = 0;
343     foreach ($aPartitions as $sPartition) {
344         if (!pg_query($oDB->connection, 'TRUNCATE location_road_'.$sPartition)) fail(pg_last_error($oDB->connection));
345         echo '.';
346     }
347
348     // used by getorcreate_word_id to ignore frequent partial words
349     $sSQL = 'CREATE OR REPLACE FUNCTION get_maxwordfreq() RETURNS integer AS ';
350     $sSQL .= '$$ SELECT '.CONST_Max_Word_Frequency.' as maxwordfreq; $$ LANGUAGE SQL IMMUTABLE';
351     if (!pg_query($oDB->connection, $sSQL)) {
352         fail(pg_last_error($oDB->connection));
353     }
354     echo ".\n";
355
356     // pre-create the word list
357     if (!$aCMDResult['disable-token-precalc']) {
358         echo "Loading word list\n";
359         pgsqlRunScriptFile(CONST_BasePath.'/data/words.sql');
360     }
361
362     echo "Load Data\n";
363     $sColumns = 'osm_type, osm_id, class, type, name, admin_level, address, extratags, geometry';
364
365     $aDBInstances = array();
366     $iLoadThreads = max(1, $iInstances - 1);
367     for ($i = 0; $i < $iLoadThreads; $i++) {
368         $aDBInstances[$i] =& getDB(true);
369         $sSQL = "INSERT INTO placex ($sColumns) SELECT $sColumns FROM place WHERE osm_id % $iLoadThreads = $i";
370         $sSQL .= " and not (class='place' and type='houses' and osm_type='W' and ST_GeometryType(geometry) = 'ST_LineString')";
371         if ($aCMDResult['verbose']) echo "$sSQL\n";
372         if (!pg_send_query($aDBInstances[$i]->connection, $sSQL)) {
373             fail(pg_last_error($aDBInstances[$i]->connection));
374         }
375     }
376     // last thread for interpolation lines
377     $aDBInstances[$iLoadThreads] =& getDB(true);
378     $sSQL = 'insert into location_property_osmline';
379     $sSQL .= ' (osm_id, address, linegeo)';
380     $sSQL .= ' SELECT osm_id, address, geometry from place where ';
381     $sSQL .= "class='place' and type='houses' and osm_type='W' and ST_GeometryType(geometry) = 'ST_LineString'";
382     if ($aCMDResult['verbose']) echo "$sSQL\n";
383     if (!pg_send_query($aDBInstances[$iLoadThreads]->connection, $sSQL)) {
384         fail(pg_last_error($aDBInstances[$iLoadThreads]->connection));
385     }
386
387     $bAnyBusy = true;
388     while ($bAnyBusy) {
389         $bAnyBusy = false;
390         for ($i = 0; $i <= $iLoadThreads; $i++) {
391             if (pg_connection_busy($aDBInstances[$i]->connection)) $bAnyBusy = true;
392         }
393         sleep(1);
394         echo '.';
395     }
396     echo "\n";
397     echo "Reanalysing database...\n";
398     pgsqlRunScript('ANALYSE');
399 }
400
401 if ($aCMDResult['import-tiger-data']) {
402     $bDidSomething = true;
403
404     $sTemplate = file_get_contents(CONST_BasePath.'/sql/tiger_import_start.sql');
405     $sTemplate = str_replace('{www-user}', CONST_Database_Web_User, $sTemplate);
406     $sTemplate = replace_tablespace(
407         '{ts:aux-data}',
408         CONST_Tablespace_Aux_Data,
409         $sTemplate
410     );
411     $sTemplate = replace_tablespace(
412         '{ts:aux-index}',
413         CONST_Tablespace_Aux_Index,
414         $sTemplate
415     );
416     pgsqlRunScript($sTemplate, false);
417
418     $aDBInstances = array();
419     for ($i = 0; $i < $iInstances; $i++) {
420         $aDBInstances[$i] =& getDB(true);
421     }
422
423     foreach (glob(CONST_Tiger_Data_Path.'/*.sql') as $sFile) {
424         echo $sFile.': ';
425         $hFile = fopen($sFile, "r");
426         $sSQL = fgets($hFile, 100000);
427         $iLines = 0;
428
429         while (true) {
430             for ($i = 0; $i < $iInstances; $i++) {
431                 if (!pg_connection_busy($aDBInstances[$i]->connection)) {
432                     while (pg_get_result($aDBInstances[$i]->connection));
433                     $sSQL = fgets($hFile, 100000);
434                     if (!$sSQL) break 2;
435                     if (!pg_send_query($aDBInstances[$i]->connection, $sSQL)) fail(pg_last_error($oDB->connection));
436                     $iLines++;
437                     if ($iLines == 1000) {
438                         echo ".";
439                         $iLines = 0;
440                     }
441                 }
442             }
443             usleep(10);
444         }
445
446         fclose($hFile);
447
448         $bAnyBusy = true;
449         while ($bAnyBusy) {
450             $bAnyBusy = false;
451             for ($i = 0; $i < $iInstances; $i++) {
452                 if (pg_connection_busy($aDBInstances[$i]->connection)) $bAnyBusy = true;
453             }
454             usleep(10);
455         }
456         echo "\n";
457     }
458
459     echo "Creating indexes\n";
460     $sTemplate = file_get_contents(CONST_BasePath.'/sql/tiger_import_finish.sql');
461     $sTemplate = str_replace('{www-user}', CONST_Database_Web_User, $sTemplate);
462     $sTemplate = replace_tablespace(
463         '{ts:aux-data}',
464         CONST_Tablespace_Aux_Data,
465         $sTemplate
466     );
467     $sTemplate = replace_tablespace(
468         '{ts:aux-index}',
469         CONST_Tablespace_Aux_Index,
470         $sTemplate
471     );
472     pgsqlRunScript($sTemplate, false);
473 }
474
475 if ($aCMDResult['calculate-postcodes'] || $aCMDResult['all']) {
476     $bDidSomething = true;
477     $oDB =& getDB();
478     if (!pg_query($oDB->connection, 'DELETE from placex where osm_type=\'P\'')) fail(pg_last_error($oDB->connection));
479     $sSQL = "insert into placex (osm_type,osm_id,class,type,postcode,country_code,geometry) ";
480     $sSQL .= "select 'P',nextval('seq_postcodes'),'place','postcode',postcode,country_code,";
481     $sSQL .= "ST_SetSRID(ST_Point(x,y),4326) as geometry from (select country_code,postcode,";
482     $sSQL .= "avg(st_x(st_centroid(geometry))) as x,avg(st_y(st_centroid(geometry))) as y ";
483     $sSQL .= "from placex where postcode is not null group by country_code,postcode) as x ";
484     $sSQL .= "where ST_Point(x,y) is not null";
485     if (!pg_query($oDB->connection, $sSQL)) fail(pg_last_error($oDB->connection));
486
487     if (CONST_Use_Extra_US_Postcodes) {
488         $sSQL = "insert into placex (osm_type,osm_id,class,type,postcode,country_code,geometry) ";
489         $sSQL .= "select 'P',nextval('seq_postcodes'),'place','postcode',postcode,'us',";
490         $sSQL .= "ST_SetSRID(ST_Point(x,y),4326) as geometry from us_postcode";
491         if (!pg_query($oDB->connection, $sSQL)) fail(pg_last_error($oDB->connection));
492     }
493 }
494
495 if ($aCMDResult['osmosis-init'] || ($aCMDResult['all'] && !$aCMDResult['drop'])) { // no use doing osmosis-init when dropping update tables
496     $bDidSomething = true;
497     $oDB =& getDB();
498
499     if (!file_exists(CONST_Osmosis_Binary)) {
500         echo "Please download osmosis.\nIf it is already installed, check the path in your local settings (settings/local.php) file.\n";
501         if (!$aCMDResult['all']) {
502             fail("osmosis not found in '".CONST_Osmosis_Binary."'");
503         }
504     } else {
505         if (file_exists(CONST_InstallPath.'/settings/configuration.txt')) {
506             echo "settings/configuration.txt already exists\n";
507         } else {
508             passthru(CONST_Osmosis_Binary.' --read-replication-interval-init '.CONST_InstallPath.'/settings');
509             // update osmosis configuration.txt with our settings
510             passthru("sed -i 's!baseUrl=.*!baseUrl=".CONST_Replication_Url."!' ".CONST_InstallPath.'/settings/configuration.txt');
511             passthru("sed -i 's:maxInterval = .*:maxInterval = ".CONST_Replication_MaxInterval.":' ".CONST_InstallPath.'/settings/configuration.txt');
512         }
513
514         // Find the last node in the DB
515         $iLastOSMID = $oDB->getOne("select max(osm_id) from place where osm_type = 'N'");
516
517         // Lookup the timestamp that node was created (less 3 hours for margin for changsets to be closed)
518         $sLastNodeURL = 'http://www.openstreetmap.org/api/0.6/node/'.$iLastOSMID."/1";
519         $sLastNodeXML = file_get_contents($sLastNodeURL);
520         preg_match('#timestamp="(([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})Z)"#', $sLastNodeXML, $aLastNodeDate);
521         $iLastNodeTimestamp = strtotime($aLastNodeDate[1]) - (3*60*60);
522
523         // Search for the correct state file - uses file timestamps so need to sort by date descending
524         $sRepURL = CONST_Replication_Url."/";
525         $sRep = file_get_contents($sRepURL."?C=M;O=D;F=1");
526         // download.geofabrik.de:    <a href="000/">000/</a></td><td align="right">26-Feb-2013 11:53  </td>
527         // planet.openstreetmap.org: <a href="273/">273/</a>                    2013-03-11 07:41    -
528         preg_match_all('#<a href="[0-9]{3}/">([0-9]{3}/)</a>\s*([-0-9a-zA-Z]+ [0-9]{2}:[0-9]{2})#', $sRep, $aRepMatches, PREG_SET_ORDER);
529         if ($aRepMatches) {
530             $aPrevRepMatch = false;
531             foreach ($aRepMatches as $aRepMatch) {
532                 if (strtotime($aRepMatch[2]) < $iLastNodeTimestamp) break;
533                 $aPrevRepMatch = $aRepMatch;
534             }
535             if ($aPrevRepMatch) $aRepMatch = $aPrevRepMatch;
536
537             $sRepURL .= $aRepMatch[1];
538             $sRep = file_get_contents($sRepURL."?C=M;O=D;F=1");
539             preg_match_all('#<a href="[0-9]{3}/">([0-9]{3}/)</a>\s*([-0-9a-zA-Z]+ [0-9]{2}:[0-9]{2})#', $sRep, $aRepMatches, PREG_SET_ORDER);
540             $aPrevRepMatch = false;
541             foreach ($aRepMatches as $aRepMatch) {
542                 if (strtotime($aRepMatch[2]) < $iLastNodeTimestamp) break;
543                 $aPrevRepMatch = $aRepMatch;
544             }
545             if ($aPrevRepMatch) $aRepMatch = $aPrevRepMatch;
546
547             $sRepURL .= $aRepMatch[1];
548             $sRep = file_get_contents($sRepURL."?C=M;O=D;F=1");
549             preg_match_all('#<a href="[0-9]{3}.state.txt">([0-9]{3}).state.txt</a>\s*([-0-9a-zA-Z]+ [0-9]{2}:[0-9]{2})#', $sRep, $aRepMatches, PREG_SET_ORDER);
550             $aPrevRepMatch = false;
551             foreach ($aRepMatches as $aRepMatch) {
552                 if (strtotime($aRepMatch[2]) < $iLastNodeTimestamp) break;
553                 $aPrevRepMatch = $aRepMatch;
554             }
555             if ($aPrevRepMatch) $aRepMatch = $aPrevRepMatch;
556
557             $sRepURL .= $aRepMatch[1].'.state.txt';
558             echo "Getting state file: $sRepURL\n";
559             $sStateFile = file_get_contents($sRepURL);
560             if (!$sStateFile || strlen($sStateFile) > 1000) fail("unable to obtain state file");
561             file_put_contents(CONST_InstallPath.'/settings/state.txt', $sStateFile);
562             echo "Updating DB status\n";
563             pg_query($oDB->connection, 'TRUNCATE import_status');
564             $sSQL = "INSERT INTO import_status VALUES('".$aRepMatch[2]."')";
565             pg_query($oDB->connection, $sSQL);
566         } else {
567             if (!$aCMDResult['all']) {
568                 fail("Cannot read state file directory.");
569             }
570         }
571     }
572 }
573
574 if ($aCMDResult['index'] || $aCMDResult['all']) {
575     $bDidSomething = true;
576     $sOutputFile = '';
577     $sBaseCmd = CONST_InstallPath.'/nominatim/nominatim -i -d '.$aDSNInfo['database'].' -P '.$aDSNInfo['port'].' -t '.$iInstances.$sOutputFile;
578     passthruCheckReturn($sBaseCmd.' -R 4');
579     if (!$aCMDResult['index-noanalyse']) pgsqlRunScript('ANALYSE');
580     passthruCheckReturn($sBaseCmd.' -r 5 -R 25');
581     if (!$aCMDResult['index-noanalyse']) pgsqlRunScript('ANALYSE');
582     passthruCheckReturn($sBaseCmd.' -r 26');
583 }
584
585 if ($aCMDResult['create-search-indices'] || $aCMDResult['all']) {
586     echo "Search indices\n";
587     $bDidSomething = true;
588
589     $sTemplate = file_get_contents(CONST_BasePath.'/sql/indices.src.sql');
590     $sTemplate = replace_tablespace(
591         '{ts:address-index}',
592         CONST_Tablespace_Address_Index,
593         $sTemplate
594     );
595     $sTemplate = replace_tablespace(
596         '{ts:search-index}',
597         CONST_Tablespace_Search_Index,
598         $sTemplate
599     );
600     $sTemplate = replace_tablespace(
601         '{ts:aux-index}',
602         CONST_Tablespace_Aux_Index,
603         $sTemplate
604     );
605
606     pgsqlRunScript($sTemplate);
607 }
608
609 if ($aCMDResult['create-country-names'] || $aCMDResult['all']) {
610     echo 'Creating search index for default country names';
611     $bDidSomething = true;
612
613     pgsqlRunScript("select getorcreate_country(make_standard_name('uk'), 'gb')");
614     pgsqlRunScript("select getorcreate_country(make_standard_name('united states'), 'us')");
615     pgsqlRunScript("select count(*) from (select getorcreate_country(make_standard_name(country_code), country_code) from country_name where country_code is not null) as x");
616     pgsqlRunScript("select count(*) from (select getorcreate_country(make_standard_name(name->'name'), country_code) from country_name where name ? 'name') as x");
617
618     $sSQL = 'select count(*) from (select getorcreate_country(make_standard_name(v), country_code) from (select country_code, skeys(name) as k, svals(name) as v from country_name) x where k ';
619     if (CONST_Languages) {
620         $sSQL .= 'in ';
621         $sDelim = '(';
622         foreach (explode(',', CONST_Languages) as $sLang) {
623             $sSQL .= $sDelim."'name:$sLang'";
624             $sDelim = ',';
625         }
626         $sSQL .= ')';
627     } else {
628         // all include all simple name tags
629         $sSQL .= "like 'name:%'";
630     }
631     $sSQL .= ') v';
632     pgsqlRunScript($sSQL);
633 }
634
635 if ($aCMDResult['drop']) {
636     // The implementation is potentially a bit dangerous because it uses
637     // a positive selection of tables to keep, and deletes everything else.
638     // Including any tables that the unsuspecting user might have manually
639     // created. USE AT YOUR OWN PERIL.
640     $bDidSomething = true;
641
642     // tables we want to keep. everything else goes.
643     $aKeepTables = array(
644                     "*columns",
645                     "import_polygon_*",
646                     "import_status",
647                     "place_addressline",
648                     "location_property*",
649                     "placex",
650                     "search_name",
651                     "seq_*",
652                     "word",
653                     "query_log",
654                     "new_query_log",
655                     "gb_postcode",
656                     "spatial_ref_sys",
657                     "country_name",
658                     "place_classtype_*"
659                    );
660
661     $oDB =& getDB();
662     $aDropTables = array();
663     $aHaveTables = chksql($oDB->getCol("SELECT tablename FROM pg_tables WHERE schemaname='public'"));
664
665     foreach ($aHaveTables as $sTable) {
666         $bFound = false;
667         foreach ($aKeepTables as $sKeep) {
668             if (fnmatch($sKeep, $sTable)) {
669                 $bFound = true;
670                 break;
671             }
672         }
673         if (!$bFound) array_push($aDropTables, $sTable);
674     }
675
676     foreach ($aDropTables as $sDrop) {
677         if ($aCMDResult['verbose']) echo "dropping table $sDrop\n";
678         @pg_query($oDB->connection, "DROP TABLE $sDrop CASCADE");
679         // ignore warnings/errors as they might be caused by a table having
680         // been deleted already by CASCADE
681     }
682
683     if (!is_null(CONST_Osm2pgsql_Flatnode_File)) {
684         if ($aCMDResult['verbose']) echo "deleting ".CONST_Osm2pgsql_Flatnode_File."\n";
685         unlink(CONST_Osm2pgsql_Flatnode_File);
686     }
687 }
688
689 if (!$bDidSomething) {
690     showUsage($aCMDOptions, true);
691 } else {
692     echo "Setup finished.\n";
693 }
694
695
696 function pgsqlRunScriptFile($sFilename)
697 {
698     if (!file_exists($sFilename)) fail('unable to find '.$sFilename);
699
700     // Convert database DSN to psql parameters
701     $aDSNInfo = DB::parseDSN(CONST_Database_DSN);
702     if (!isset($aDSNInfo['port']) || !$aDSNInfo['port']) $aDSNInfo['port'] = 5432;
703     $sCMD = 'psql -p '.$aDSNInfo['port'].' -d '.$aDSNInfo['database'];
704
705     $ahGzipPipes = null;
706     if (preg_match('/\\.gz$/', $sFilename)) {
707         $aDescriptors = array(
708                          0 => array('pipe', 'r'),
709                          1 => array('pipe', 'w'),
710                          2 => array('file', '/dev/null', 'a')
711                         );
712         $hGzipProcess = proc_open('zcat '.$sFilename, $aDescriptors, $ahGzipPipes);
713         if (!is_resource($hGzipProcess)) fail('unable to start zcat');
714         $aReadPipe = $ahGzipPipes[1];
715         fclose($ahGzipPipes[0]);
716     } else {
717         $sCMD .= ' -f '.$sFilename;
718         $aReadPipe = array('pipe', 'r');
719     }
720
721     $aDescriptors = array(
722                      0 => $aReadPipe,
723                      1 => array('pipe', 'w'),
724                      2 => array('file', '/dev/null', 'a')
725                     );
726     $ahPipes = null;
727     $hProcess = proc_open($sCMD, $aDescriptors, $ahPipes);
728     if (!is_resource($hProcess)) fail('unable to start pgsql');
729
730
731     // TODO: error checking
732     while (!feof($ahPipes[1])) {
733         echo fread($ahPipes[1], 4096);
734     }
735     fclose($ahPipes[1]);
736
737     $iReturn = proc_close($hProcess);
738     if ($iReturn > 0) {
739         fail("pgsql returned with error code ($iReturn)");
740     }
741     if ($ahGzipPipes) {
742         fclose($ahGzipPipes[1]);
743         proc_close($hGzipProcess);
744     }
745 }
746
747 function pgsqlRunScript($sScript, $bfatal = true)
748 {
749     global $aCMDResult;
750     // Convert database DSN to psql parameters
751     $aDSNInfo = DB::parseDSN(CONST_Database_DSN);
752     if (!isset($aDSNInfo['port']) || !$aDSNInfo['port']) $aDSNInfo['port'] = 5432;
753     $sCMD = 'psql -p '.$aDSNInfo['port'].' -d '.$aDSNInfo['database'];
754     if ($bfatal && !$aCMDResult['ignore-errors'])
755         $sCMD .= ' -v ON_ERROR_STOP=1';
756     $aDescriptors = array(
757                      0 => array('pipe', 'r'),
758                      1 => STDOUT,
759                      2 => STDERR
760                     );
761     $ahPipes = null;
762     $hProcess = @proc_open($sCMD, $aDescriptors, $ahPipes);
763     if (!is_resource($hProcess)) fail('unable to start pgsql');
764
765     while (strlen($sScript)) {
766         $written = fwrite($ahPipes[0], $sScript);
767         if ($written <= 0) break;
768         $sScript = substr($sScript, $written);
769     }
770     fclose($ahPipes[0]);
771     $iReturn = proc_close($hProcess);
772     if ($bfatal && $iReturn > 0) {
773         fail("pgsql returned with error code ($iReturn)");
774     }
775 }
776
777 function pgsqlRunPartitionScript($sTemplate)
778 {
779     global $aCMDResult;
780     $oDB =& getDB();
781
782     $sSQL = 'select distinct partition from country_name';
783     $aPartitions = chksql($oDB->getCol($sSQL));
784     if (!$aCMDResult['no-partitions']) $aPartitions[] = 0;
785
786     preg_match_all('#^-- start(.*?)^-- end#ms', $sTemplate, $aMatches, PREG_SET_ORDER);
787     foreach ($aMatches as $aMatch) {
788         $sResult = '';
789         foreach ($aPartitions as $sPartitionName) {
790             $sResult .= str_replace('-partition-', $sPartitionName, $aMatch[1]);
791         }
792         $sTemplate = str_replace($aMatch[0], $sResult, $sTemplate);
793     }
794
795     pgsqlRunScript($sTemplate);
796 }
797
798 function pgsqlRunRestoreData($sDumpFile)
799 {
800     // Convert database DSN to psql parameters
801     $aDSNInfo = DB::parseDSN(CONST_Database_DSN);
802     if (!isset($aDSNInfo['port']) || !$aDSNInfo['port']) $aDSNInfo['port'] = 5432;
803     $sCMD = 'pg_restore -p '.$aDSNInfo['port'].' -d '.$aDSNInfo['database'].' -Fc -a '.$sDumpFile;
804
805     $aDescriptors = array(
806                      0 => array('pipe', 'r'),
807                      1 => array('pipe', 'w'),
808                      2 => array('file', '/dev/null', 'a')
809                     );
810     $ahPipes = null;
811     $hProcess = proc_open($sCMD, $aDescriptors, $ahPipes);
812     if (!is_resource($hProcess)) fail('unable to start pg_restore');
813
814     fclose($ahPipes[0]);
815
816     // TODO: error checking
817     while (!feof($ahPipes[1])) {
818         echo fread($ahPipes[1], 4096);
819     }
820     fclose($ahPipes[1]);
821
822     $iReturn = proc_close($hProcess);
823 }
824
825 function pgsqlRunDropAndRestore($sDumpFile)
826 {
827     // Convert database DSN to psql parameters
828     $aDSNInfo = DB::parseDSN(CONST_Database_DSN);
829     if (!isset($aDSNInfo['port']) || !$aDSNInfo['port']) $aDSNInfo['port'] = 5432;
830     $sCMD = 'pg_restore -p '.$aDSNInfo['port'].' -d '.$aDSNInfo['database'].' -Fc --clean '.$sDumpFile;
831
832     $aDescriptors = array(
833                      0 => array('pipe', 'r'),
834                      1 => array('pipe', 'w'),
835                      2 => array('file', '/dev/null', 'a')
836                     );
837     $ahPipes = null;
838     $hProcess = proc_open($sCMD, $aDescriptors, $ahPipes);
839     if (!is_resource($hProcess)) fail('unable to start pg_restore');
840
841     fclose($ahPipes[0]);
842
843     // TODO: error checking
844     while (!feof($ahPipes[1])) {
845         echo fread($ahPipes[1], 4096);
846     }
847     fclose($ahPipes[1]);
848
849     $iReturn = proc_close($hProcess);
850 }
851
852 function passthruCheckReturn($cmd)
853 {
854     $result = -1;
855     passthru($cmd, $result);
856     if ($result != 0) fail('Error executing external command: '.$cmd);
857 }
858
859 function replace_tablespace($sTemplate, $sTablespace, $sSql)
860 {
861     if ($sTablespace) {
862         $sSql = str_replace($sTemplate, 'TABLESPACE "'.$sTablespace.'"', $sSql);
863     } else {
864         $sSql = str_replace($sTemplate, '', $sSql);
865     }
866
867     return $sSql;
868 }
869
870 function create_sql_functions($aCMDResult)
871 {
872     $sTemplate = file_get_contents(CONST_BasePath.'/sql/functions.sql');
873     $sTemplate = str_replace('{modulepath}', CONST_InstallPath.'/module', $sTemplate);
874     if ($aCMDResult['enable-diff-updates']) {
875         $sTemplate = str_replace('RETURN NEW; -- %DIFFUPDATES%', '--', $sTemplate);
876     }
877     if ($aCMDResult['enable-debug-statements']) {
878         $sTemplate = str_replace('--DEBUG:', '', $sTemplate);
879     }
880     if (CONST_Limit_Reindexing) {
881         $sTemplate = str_replace('--LIMIT INDEXING:', '', $sTemplate);
882     }
883     if (!CONST_Use_US_Tiger_Data) {
884         $sTemplate = str_replace('-- %NOTIGERDATA% ', '', $sTemplate);
885     }
886     if (!CONST_Use_Aux_Location_data) {
887         $sTemplate = str_replace('-- %NOAUXDATA% ', '', $sTemplate);
888     }
889     pgsqlRunScript($sTemplate);
890 }