Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
0.00% covered (danger)
0.00%
0 / 375
0.00% covered (danger)
0.00%
0 / 19
CRAP
0.00% covered (danger)
0.00%
0 / 1
ForceSearchIndex
0.00% covered (danger)
0.00%
0 / 368
0.00% covered (danger)
0.00%
0 / 19
8190
0.00% covered (danger)
0.00%
0 / 1
 __construct
0.00% covered (danger)
0.00%
0 / 60
0.00% covered (danger)
0.00%
0 / 1
2
 execute
0.00% covered (danger)
0.00%
0 / 78
0.00% covered (danger)
0.00%
0 / 1
702
 buildPageIdBatches
0.00% covered (danger)
0.00%
0 / 17
0.00% covered (danger)
0.00%
0 / 1
72
 buildUpdateFlags
0.00% covered (danger)
0.00%
0 / 10
0.00% covered (danger)
0.00%
0 / 1
30
 waitForQueueToShrink
0.00% covered (danger)
0.00%
0 / 14
0.00% covered (danger)
0.00%
0 / 1
20
 waitForQueueToDrain
0.00% covered (danger)
0.00%
0 / 17
0.00% covered (danger)
0.00%
0 / 1
42
 calculateIndexingRate
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
6
 simpleCheckIndexes
0.00% covered (danger)
0.00%
0 / 7
0.00% covered (danger)
0.00%
0 / 1
20
 getDeletesIterator
0.00% covered (danger)
0.00%
0 / 39
0.00% covered (danger)
0.00%
0 / 1
12
 getIdsIterator
0.00% covered (danger)
0.00%
0 / 9
0.00% covered (danger)
0.00%
0 / 1
2
 getUpdatesByDateIterator
0.00% covered (danger)
0.00%
0 / 17
0.00% covered (danger)
0.00%
0 / 1
2
 getUpdatesByIdIterator
0.00% covered (danger)
0.00%
0 / 17
0.00% covered (danger)
0.00%
0 / 1
12
 attachTimestampConditions
0.00% covered (danger)
0.00%
0 / 7
0.00% covered (danger)
0.00%
0 / 1
6
 attachPageConditions
0.00% covered (danger)
0.00%
0 / 12
0.00% covered (danger)
0.00%
0 / 1
20
 wrapDecodeResults
0.00% covered (danger)
0.00%
0 / 20
0.00% covered (danger)
0.00%
0 / 1
30
 decidePage
0.00% covered (danger)
0.00%
0 / 22
0.00% covered (danger)
0.00%
0 / 1
56
 buildChunks
0.00% covered (danger)
0.00%
0 / 16
0.00% covered (danger)
0.00%
0 / 1
42
 getUpdatesInQueue
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 createUpdater
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
1<?php
2
3namespace CirrusSearch\Maintenance;
4
5use BatchRowIterator;
6use CirrusSearch\BuildDocument\BuildDocument;
7use CirrusSearch\Iterator\CallbackIterator;
8use CirrusSearch\Job;
9use CirrusSearch\SearchConfig;
10use CirrusSearch\Updater;
11use IDBAccessObject;
12use MediaWiki\Logger\LoggerFactory;
13use MediaWiki\MediaWikiServices;
14use MediaWiki\Title\Title;
15use MediaWiki\Utils\MWTimestamp;
16use MediaWiki\WikiMap\WikiMap;
17use Throwable;
18use UnexpectedValueException;
19use Wikimedia\Rdbms\IDatabase;
20use WikiPage;
21
22/**
23 * Force reindexing change to the wiki.
24 *
25 * This program is free software; you can redistribute it and/or modify
26 * it under the terms of the GNU General Public License as published by
27 * the Free Software Foundation; either version 2 of the License, or
28 * (at your option) any later version.
29 *
30 * This program is distributed in the hope that it will be useful,
31 * but WITHOUT ANY WARRANTY; without even the implied warranty of
32 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33 * GNU General Public License for more details.
34 *
35 * You should have received a copy of the GNU General Public License along
36 * with this program; if not, write to the Free Software Foundation, Inc.,
37 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
38 * http://www.gnu.org/copyleft/gpl.html
39 */
40
41$IP = getenv( 'MW_INSTALL_PATH' );
42if ( $IP === false ) {
43    $IP = __DIR__ . '/../../..';
44}
45require_once "$IP/maintenance/Maintenance.php";
46require_once __DIR__ . '/../includes/Maintenance/Maintenance.php';
47
48class ForceSearchIndex extends Maintenance {
49    private const SECONDS_BETWEEN_JOB_QUEUE_LENGTH_CHECKS = 3;
50    /** @var MWTimestamp|null */
51    public $fromDate = null;
52    /** @var MWTimestamp|null */
53    public $toDate = null;
54    public $toId = null;
55    public $indexUpdates;
56    public $archive;
57    public $limit;
58    public $queue;
59    public $maxJobs;
60    public $pauseForJobs;
61    public $namespace;
62    public $excludeContentTypes;
63    public $lastJobQueueCheckTime = 0;
64
65    /**
66     * @var bool true if the script is run with --ids
67     */
68    private $runWithIds;
69
70    /**
71     * @var int[] list of page ids to reindex when --ids is used
72     */
73    private $pageIds;
74
75    public function __construct() {
76        parent::__construct();
77        $this->addDescription( "Force indexing some pages.  Setting --from or --to will switch "
78            . "from page id based indexing to "
79            . "date based indexing which uses less efficient queries and follows redirects.\n\n"
80            . "Note: All froms are _exclusive_ and all tos are _inclusive_.\n"
81            . "Note 2: Setting fromId and toId use the efficient query so those are ok.\n"
82            . "Note 3: Operates on all clusters unless --cluster is provided.\n"
83        );
84        $this->setBatchSize( 10 );
85        $this->addOption( 'from', 'Start date of reindex in YYYY-mm-ddTHH:mm:ssZ (exc.  Defaults ' .
86            'to 0 epoch.', false, true );
87        $this->addOption( 'to', 'Stop date of reindex in YYYY-mm-ddTHH:mm:ssZ.  Defaults to now.',
88            false, true );
89        $this->addOption( 'fromId', 'Start indexing at a specific page_id.  ' .
90            'Not useful with --deletes.', false, true );
91        $this->addOption( 'toId', 'Stop indexing at a specific page_id.  ' .
92            'Not useful with --deletes or --from or --to.', false, true );
93        $this->addOption( 'ids', 'List of page ids (comma separated) to reindex. ' .
94            'Not allowed with deletes/from/to/fromId/toId/limit.', false, true );
95        $this->addOption( 'deletes',
96            'If this is set then just index deletes, not updates or creates.', false );
97        $this->addOption( 'archive',
98            'Don\'t delete pages, only index them into the archive.', false, false );
99        $this->addOption( 'limit',
100            'Maximum number of pages to process before exiting the script. Default to unlimited.',
101            false, true );
102        $this->addOption( 'buildChunks', 'Instead of running the script spit out commands that ' .
103            'can be farmed out to different processes or machines to rebuild the index.  Works ' .
104            'with fromId and toId, not from and to.  If specified as a number then chunks no ' .
105            'larger than that size are spat out.  If specified as a number followed by the word ' .
106            '"total" without a space between them then that many chunks will be spat out sized ' .
107            'to cover the entire wiki.', false, true );
108        $this->addOption( 'queue', 'Rather than perform the indexes in process add them to the ' .
109            'job queue.  Ignored for delete.' );
110        $this->addOption( 'maxJobs', 'If there are more than this many index jobs in the queue ' .
111            'then pause before adding more.  This is only checked every ' .
112            self::SECONDS_BETWEEN_JOB_QUEUE_LENGTH_CHECKS .
113            ' seconds.  Not meaningful without --queue.', false, true );
114        $this->addOption( 'pauseForJobs', 'If paused adding jobs then wait for there to be less ' .
115            'than this many before starting again.  Defaults to the value specified for ' .
116            '--maxJobs.  Not meaningful without --queue.', false, true );
117        $this->addOption( 'indexOnSkip', 'When skipping either parsing or links send the document' .
118            ' as an index.  This replaces the contents of the index for that entry with the entry' .
119            ' built from a skipped process. Without this if the entry does not exist then it will' .
120            ' be skipped entirely.  Only set this when running the first pass of building the' .
121            ' index.  Otherwise, don\'t tempt fate by indexing half complete documents.' );
122        $this->addOption( 'forceParse', '(deprecated)' );
123        $this->addOption( 'skipParse',
124            'Skip parsing the page.  This is really only good for running the second half ' .
125            'of the two phase index build.  If this is specified then the default batch size ' .
126            'is actually 50.' );
127        $this->addOption( 'skipLinks',
128            'Skip looking for links to the page (counting and finding redirects).  Use ' .
129            'this with --indexOnSkip for the first half of the two phase index build.' );
130        $this->addOption( 'namespace', 'Only index pages in this given namespace', false, true );
131        $this->addOption( 'excludeContentTypes', 'Exclude pages of the specified content types. ' .
132            'These must be a comma separated list of strings such as "wikitext" or "json" ' .
133            'matching the CONTENT_MODEL_* constants.', false, true, false );
134        $this->addOption( 'useDbIndex',
135            'Use specific index when fetching IDs from the database.', false, true, false );
136    }
137
138    public function execute() {
139        $this->disablePoolCountersAndLogging();
140        $wiki = sprintf( "[%20s]", WikiMap::getCurrentWikiId() );
141
142        // Make sure we've actually got indices to populate
143        if ( !$this->simpleCheckIndexes() ) {
144            $this->fatalError(
145                "$wiki index(es) do not exist. Did you forget to run updateSearchIndexConfig?"
146            );
147        }
148
149        $this->indexUpdates = !$this->getOption( 'deletes', false );
150        // We need to check ids options early otherwise hasOption may return
151        // true even if the user did not set the option on the commandline
152        if ( $this->hasOption( 'ids' ) ) {
153            $this->runWithIds = true;
154            $this->pageIds = $this->buildPageIdBatches();
155        }
156
157        if ( $this->getOption( 'from' ) !== null || $this->getOption( 'to' ) !== null ) {
158            // 0 is falsy so MWTimestamp makes that `now`.  '00' is epoch 0.
159            $this->fromDate = new MWTimestamp( $this->getOption( 'from', '00' ) );
160            $this->toDate = new MWTimestamp( $this->getOption( 'to', false ) );
161        }
162        $this->toId = $this->getOption( 'toId' );
163        $this->archive = (bool)$this->getOption( 'archive', false );
164        if ( $this->archive ) {
165            // If we're indexing only for archive, this implies deletes
166            $this->indexUpdates = false;
167        }
168        $this->limit = $this->getOption( 'limit' );
169        $buildChunks = $this->getOption( 'buildChunks' );
170        if ( $buildChunks !== null ) {
171            $this->buildChunks( $buildChunks );
172            return null;
173        }
174        $this->queue = $this->getOption( 'queue' );
175        $this->maxJobs = $this->getOption( 'maxJobs' )
176            ? intval( $this->getOption( 'maxJobs' ) )
177            : null;
178        $this->pauseForJobs = $this->getOption( 'pauseForJobs' ) ?
179            intval( $this->getOption( 'pauseForJobs' ) ) : $this->maxJobs;
180        $updateFlags = $this->buildUpdateFlags();
181
182        if ( !$this->getOption( 'batch-size' ) &&
183            ( $this->getOption( 'queue' ) || !$this->indexUpdates )
184        ) {
185            $this->setBatchSize( 100 );
186        }
187
188        $this->namespace = $this->hasOption( 'namespace' ) ?
189            intval( $this->getOption( 'namespace' ) ) : null;
190
191        $this->excludeContentTypes = array_filter( array_map(
192            'trim',
193            explode( ',', $this->getOption( 'excludeContentTypes', '' ) )
194        ) );
195
196        $operationName = $this->indexUpdates
197            ? ( $this->queue ? 'Queued' : 'Indexed' )
198            : ( $this->archive ? 'Archived' : 'Deleted' );
199
200        $operationStartTime = microtime( true );
201        $completed = 0;
202        $rate = 0;
203
204        if ( $this->runWithIds ) {
205            $it = $this->getIdsIterator();
206            // @phan-suppress-next-line PhanImpossibleTypeComparison
207        } elseif ( $this->indexUpdates && $this->fromDate === null ) {
208            $it = $this->getUpdatesByIdIterator();
209        } elseif ( $this->indexUpdates ) {
210            $it = $this->getUpdatesByDateIterator();
211        } else {
212            $it = $this->getDeletesIterator();
213        }
214        $jobQueueGroup = MediaWikiServices::getInstance()->getJobQueueGroup();
215
216        foreach ( $it as $batch ) {
217            if ( $this->indexUpdates ) {
218                $size = count( $batch['updates'] );
219                $updates = array_filter( $batch['updates'] );
220                if ( $this->queue ) {
221                    $this->waitForQueueToShrink( $wiki );
222                    $jobQueueGroup->push( Job\MassIndex::build(
223                        $updates, $updateFlags, $this->getOption( 'cluster' )
224                    ) );
225                } else {
226                    // Update size with the actual number of updated documents.
227                    $updater = $this->createUpdater();
228                    $size = $updater->updatePages( $updates, $updateFlags );
229                }
230            } else {
231                $size = count( $batch['titlesToDelete'] );
232                $updater = $this->createUpdater();
233                $updater->archivePages( $batch['archive'] );
234                if ( !$this->archive ) {
235                    $updater->deletePages( $batch['titlesToDelete'], $batch['docIdsToDelete'] );
236                }
237            }
238
239            $completed += $size;
240            $rate = $this->calculateIndexingRate( $completed, $operationStartTime );
241
242            $this->output(
243                "$wiki $operationName $size pages ending at {$batch['endingAt']} at $rate/second\n"
244            );
245            if ( $this->limit !== null && $completed > $this->limit ) {
246                break;
247            }
248        }
249        $this->output( "$operationName a total of {$completed} pages at $rate/second\n" );
250        $this->waitForQueueToDrain( $wiki );
251
252        return true;
253    }
254
255    private function buildPageIdBatches() {
256        if ( !$this->indexUpdates || $this->hasOption( 'limit' )
257            || $this->hasOption( 'from' ) || $this->hasOption( 'to' )
258            || $this->hasOption( 'fromId' ) || $this->hasOption( 'toId' )
259        ) {
260            $this->fatalError(
261                '--ids cannot be used with deletes/archive/from/to/fromId/toId/limit'
262            );
263        }
264
265        $pageIds = array_map(
266            function ( $pageId ) {
267                $pageId = trim( $pageId );
268                if ( !ctype_digit( $pageId ) ) {
269                    $this->fatalError( "Invalid page id provided in --ids, got '$pageId', " .
270                        "expected a positive integer" );
271                }
272                return intval( $pageId );
273            },
274            explode( ',', $this->getOption( 'ids' ) )
275        );
276        return array_unique( $pageIds, SORT_REGULAR );
277    }
278
279    private function buildUpdateFlags() {
280        $updateFlags = 0;
281        if ( $this->getOption( 'indexOnSkip' ) ) {
282            $updateFlags |= BuildDocument::INDEX_ON_SKIP;
283        }
284        if ( $this->getOption( 'skipParse' ) ) {
285            $updateFlags |= BuildDocument::SKIP_PARSE;
286            if ( !$this->getOption( 'batch-size' ) ) {
287                $this->setBatchSize( 50 );
288            }
289        }
290        if ( $this->getOption( 'skipLinks' ) ) {
291            $updateFlags |= BuildDocument::SKIP_LINKS;
292        }
293
294        return $updateFlags;
295    }
296
297    private function waitForQueueToShrink( $wiki ) {
298        $now = microtime( true );
299        if ( $now - $this->lastJobQueueCheckTime <=
300            self::SECONDS_BETWEEN_JOB_QUEUE_LENGTH_CHECKS
301        ) {
302            return;
303        }
304
305        $this->lastJobQueueCheckTime = $now;
306        $queueSize = $this->getUpdatesInQueue();
307        if ( $this->maxJobs === null || $this->maxJobs >= $queueSize ) {
308            return;
309        }
310
311        do {
312            $this->output(
313                "$wiki Waiting while job queue shrinks: $this->pauseForJobs > $queueSize\n"
314            );
315            usleep( self::SECONDS_BETWEEN_JOB_QUEUE_LENGTH_CHECKS * 1000000 );
316            $queueSize = $this->getUpdatesInQueue();
317        } while ( $this->pauseForJobs < $queueSize );
318    }
319
320    private function waitForQueueToDrain( $wiki ) {
321        if ( !$this->queue ) {
322            return;
323        }
324
325        $lastQueueSizeForOurJob = PHP_INT_MAX;
326        $waitStartTime = microtime( true );
327        $this->output( "Waiting for jobs to drain from the queue\n" );
328        while ( true ) {
329            $queueSizeForOurJob = $this->getUpdatesInQueue();
330            if ( $queueSizeForOurJob === 0 ) {
331                return;
332            }
333            // We subtract 5 because we some jobs may be added by deletes
334            if ( $queueSizeForOurJob > $lastQueueSizeForOurJob ) {
335                $this->output( "Queue size went up.  Another script is likely adding jobs " .
336                    "and it'll wait for them to empty.\n" );
337                return;
338            }
339            if ( microtime( true ) - $waitStartTime > 120 ) {
340                // Wait at least two full minutes before we check if the job count went down.
341                // Less then that and we might be seeing lag from redis's counts.
342                $lastQueueSizeForOurJob = $queueSizeForOurJob;
343            }
344            $this->output( "$wiki $queueSizeForOurJob jobs left on the queue.\n" );
345            usleep( self::SECONDS_BETWEEN_JOB_QUEUE_LENGTH_CHECKS * 1000000 );
346        }
347    }
348
349    /**
350     * @param int $completed
351     * @param double $operationStartTime
352     *
353     * @return double
354     */
355    private function calculateIndexingRate( $completed, $operationStartTime ) {
356        $rate = $completed / ( microtime( true ) - $operationStartTime );
357
358        if ( $rate < 1 ) {
359            return round( $rate, 1 );
360        }
361
362        return round( $rate );
363    }
364
365    /**
366     * Do some simple sanity checking to make sure we've got indexes to populate.
367     * Note this isn't nearly as robust as updateSearchIndexConfig is, but it's
368     * not designed to be.
369     *
370     * @return bool
371     */
372    private function simpleCheckIndexes() {
373        $indexBaseName = $this->getSearchConfig()->get( SearchConfig::INDEX_BASE_NAME );
374
375        // Top-level alias needs to exist
376        if ( !$this->getConnection()->getIndex( $indexBaseName )->exists() ) {
377            return false;
378        }
379
380        // Now check all index types to see if they exist
381        foreach ( $this->getConnection()->getAllIndexSuffixes() as $indexSuffix ) {
382            // If the alias for this type doesn't exist, fail
383            if ( !$this->getConnection()->getIndex( $indexBaseName, $indexSuffix )->exists() ) {
384                return false;
385            }
386        }
387
388        return true;
389    }
390
391    protected function getDeletesIterator() {
392        $dbr = $this->getDB( DB_REPLICA, [ 'vslow' ] );
393        $it = new BatchRowIterator(
394            $dbr,
395            'logging',
396            [ 'log_timestamp' ],
397            $this->getBatchSize()
398        );
399
400        $this->attachPageConditions( $dbr, $it, 'log' );
401        $this->attachTimestampConditions( $dbr, $it, 'log' );
402        $it->addConditions( [
403            'log_type' => 'delete',
404            'log_action' => 'delete',
405            'EXISTS(select * from archive where ar_title = log_title and ar_namespace = log_namespace)',
406            // Prior to 2010 the logging table contains nulls. As the docs in elasticsearch use the page id
407            // as the document id we cannot handle these old rows.
408            'log_page IS NOT NULL',
409        ] );
410
411        $it->setFetchColumns( [ 'log_timestamp', 'log_namespace', 'log_title', 'log_page' ] );
412
413        $it->setCaller( __METHOD__ );
414
415        return new CallbackIterator( $it, function ( $batch ) {
416            $titlesToDelete = [];
417            $docIdsToDelete = [];
418            $archive = [];
419            foreach ( $batch as $row ) {
420                $title = Title::makeTitle( $row->log_namespace, $row->log_title );
421                $id = $this->getSearchConfig()->makeId( $row->log_page );
422                $titlesToDelete[] = $title;
423                $docIdsToDelete[] = $id;
424                $archive[] = [
425                    'title' => $title,
426                    'page' => $id,
427                ];
428            }
429
430            return [
431                'titlesToDelete' => $titlesToDelete,
432                'docIdsToDelete' => $docIdsToDelete,
433                'archive' => $archive,
434                'endingAt' => isset( $row )
435                    ? ( new MWTimestamp( $row->log_timestamp ) )->getTimestamp( TS_ISO_8601 )
436                    : 'unknown',
437            ];
438        } );
439    }
440
441    protected function getIdsIterator() {
442        $dbr = $this->getDB( DB_REPLICA, [ 'vslow' ] );
443        $pageQuery = WikiPage::getQueryInfo();
444        $it = new BatchRowIterator( $dbr, $pageQuery['tables'], 'page_id', $this->getBatchSize() );
445        $it->setFetchColumns( $pageQuery['fields'] );
446        $it->addJoinConditions( $pageQuery['joins'] );
447        $it->addConditions( [ 'page_id' => $this->pageIds ] );
448        $it->setCaller( __METHOD__ );
449        $this->attachPageConditions( $dbr, $it, 'page' );
450
451        return $this->wrapDecodeResults( $it, 'page_id' );
452    }
453
454    protected function getUpdatesByDateIterator() {
455        $dbr = $this->getDB( DB_REPLICA, [ 'vslow' ] );
456        $pageQuery = WikiPage::getQueryInfo();
457        $it = new BatchRowIterator(
458            $dbr,
459            array_merge( $pageQuery['tables'], [ 'revision' ] ),
460            [ 'rev_timestamp', 'page_id' ],
461            $this->getBatchSize()
462        );
463        $it->setFetchColumns( $pageQuery['fields'] );
464        $it->addJoinConditions( $pageQuery['joins'] );
465        $it->addJoinConditions( [
466            'revision' => [ 'JOIN', [ 'rev_page = page_id', 'rev_id = page_latest' ] ]
467        ] );
468        $it->setCaller( __METHOD__ );
469
470        $this->attachTimestampConditions( $dbr, $it, 'rev' );
471        $this->attachPageConditions( $dbr, $it, 'page' );
472
473        return $this->wrapDecodeResults( $it, 'rev_timestamp' );
474    }
475
476    protected function getUpdatesByIdIterator() {
477        $dbr = $this->getDB( DB_REPLICA, [ 'vslow' ] );
478        $pageQuery = WikiPage::getQueryInfo();
479        $it = new BatchRowIterator( $dbr,  $pageQuery['tables'], 'page_id', $this->getBatchSize() );
480        $it->setFetchColumns( $pageQuery['fields'] );
481        $it->addJoinConditions( $pageQuery['joins'] );
482        $it->setCaller( __METHOD__ );
483        $fromId = $this->getOption( 'fromId', 0 );
484        if ( $fromId > 0 ) {
485            $it->addConditions( [
486                'page_id >= ' . $dbr->addQuotes( $fromId ),
487            ] );
488        }
489        if ( $this->toId ) {
490            $it->addConditions( [
491                'page_id <= ' . $dbr->addQuotes( $this->toId ),
492            ] );
493        }
494
495        $this->attachPageConditions( $dbr, $it, 'page' );
496
497        return $this->wrapDecodeResults( $it, 'page_id' );
498    }
499
500    private function attachTimestampConditions(
501        IDatabase $dbr, BatchRowIterator $it, $columnPrefix
502    ) {
503        // When initializing we guarantee that if either fromDate or toDate are provided
504        // the other has a sane default value.
505        if ( $this->fromDate !== null ) {
506            $it->addConditions( [
507                "{$columnPrefix}_timestamp >= " .
508                    $dbr->addQuotes( $dbr->timestamp( $this->fromDate ) ),
509                "{$columnPrefix}_timestamp <= " .
510                    $dbr->addQuotes( $dbr->timestamp( $this->toDate ) ),
511            ] );
512        }
513    }
514
515    private function attachPageConditions( IDatabase $dbr, BatchRowIterator $it, $columnPrefix ) {
516        if ( $this->namespace !== null ) {
517            $it->addConditions( [
518                "{$columnPrefix}_namespace" => $this->namespace,
519            ] );
520        }
521        if ( $this->excludeContentTypes ) {
522            $list = $dbr->makeList( $this->excludeContentTypes, LIST_COMMA );
523            $it->addConditions( [
524                "{$columnPrefix}_content_model NOT IN ($list)",
525            ] );
526        }
527        if ( $this->hasOption( 'useDbIndex' ) ) {
528            $index = $this->getOption( 'useDbIndex' );
529            $it->addOptions( [ 'USE INDEX' => $index ] );
530        }
531    }
532
533    /**
534     * @param BatchRowIterator $it
535     * @param string $endingAtColumn
536     * @return CallbackIterator
537     */
538    private function wrapDecodeResults( BatchRowIterator $it, $endingAtColumn ) {
539        return new CallbackIterator( $it, function ( $batch ) use ( $endingAtColumn ) {
540            // Build the updater outside the loop because it stores the redirects it hits.
541            // Don't build it at the top level so those are stored when it is freed.
542            $updater = $this->createUpdater();
543
544            $pages = [];
545            $wikiPageFactory = MediaWikiServices::getInstance()->getWikiPageFactory();
546            foreach ( $batch as $row ) {
547                // No need to call Updater::traceRedirects here because we know this is a valid page
548                // because it is in the database.
549                $page = $wikiPageFactory->newFromRow( $row, IDBAccessObject::READ_LATEST );
550
551                // null pages still get attached to keep the counts the same. They will be filtered
552                // later on.
553                $pages[] = $this->decidePage( $updater, $page );
554            }
555
556            if ( isset( $row ) ) {
557                if ( $endingAtColumn === 'rev_timestamp' ) {
558                    $ts = new MWTimestamp( $row->rev_timestamp );
559                    $endingAt = $ts->getTimestamp( TS_ISO_8601 );
560                } elseif ( $endingAtColumn === 'page_id' ) {
561                    $endingAt = $row->page_id;
562                } else {
563                    throw new UnexpectedValueException( 'Unknown $endingAtColumn: ' . $endingAtColumn );
564                }
565            } else {
566                $endingAt = 'unknown';
567            }
568
569            return [
570                'updates' => $pages,
571                'endingAt' => $endingAt,
572            ];
573        } );
574    }
575
576    /**
577     * Determine the actual page in the index that needs to be updated, based on a
578     * source page.
579     *
580     * @param Updater $updater
581     * @param WikiPage $page
582     * @return WikiPage|null WikiPage to be updated, or null if none.
583     */
584    private function decidePage( Updater $updater, WikiPage $page ) {
585        try {
586            $content = $page->getContent();
587        } catch ( Throwable $ex ) {
588            LoggerFactory::getInstance( 'CirrusSearch' )->warning(
589                "Error deserializing content, skipping page: {pageId}",
590                [ 'pageId' => $page->getTitle()->getArticleID() ]
591            );
592            return null;
593        }
594
595        if ( $content === null ) {
596            // Skip pages without content.  Pages have no content because their latest revision
597            // as loaded by the query above doesn't exist.
598            $this->output(
599                'Skipping page with no content: ' . $page->getTitle()->getArticleID() . "\n"
600            );
601            return null;
602        }
603
604        if ( !$content->isRedirect() ) {
605            return $page;
606        }
607
608        if ( $this->toDate === null ) {
609            // Looks like we accidentally picked up a redirect when we were indexing by id and thus
610            // trying to ignore redirects!  Just ignore it!  We would filter them out at the db
611            // level but that is slow for large wikis.
612            return null;
613        }
614
615        // We found a redirect.  Great.  Since we can't index special pages and redirects to special
616        // pages are totally possible, as well as fun stuff like redirect loops, we need to use
617        // Updater's redirect tracing logic which is very complete.  Also, it returns null on
618        // self redirects.  Great!
619        list( $page, ) = $updater->traceRedirects( $page->getTitle() );
620
621        if ( $page != null &&
622            Title::makeTitleSafe( $page->getTitle()->getNamespace(), $page->getTitle()->getText() ) === null
623        ) {
624            // The title cannot be rebuilt from its ns_prefix + text.
625            // It happens if an invalid title is present in the DB
626            // We may prefer to not index them as they are hardly viewable
627            $this->output( 'Skipping page with invalid title: ' . $page->getTitle()->getPrefixedText() );
628            return null;
629        }
630
631        return $page;
632    }
633
634    /**
635     * @param string|int $buildChunks If specified as a number then chunks no
636     *  larger than that size are spat out.  If specified as a number followed
637     *  by the word "total" without a space between them then that many chunks
638     *  will be spat out sized to cover the entire wiki.
639     */
640    private function buildChunks( $buildChunks ) {
641        $dbr = $this->getDB( DB_REPLICA, [ 'vslow' ] );
642        if ( $this->toId === null ) {
643            $this->toId = $dbr->selectField( 'page', 'MAX(page_id)', [], __METHOD__ );
644            if ( $this->toId === false ) {
645                $this->fatalError( "Couldn't find any pages to index." );
646            }
647        }
648        $fromId = $this->getOption( 'fromId' );
649        if ( $fromId === null ) {
650            $fromId = $dbr->selectField( 'page', 'MIN(page_id) - 1', [], __METHOD__ );
651            if ( $fromId === false ) {
652                $this->fatalError( "Couldn't find any pages to index." );
653            }
654        }
655        if ( $fromId === $this->toId ) {
656            $this->fatalError(
657                "Couldn't find any pages to index.  fromId = $fromId = $this->toId = toId."
658            );
659        }
660        $builder = new \CirrusSearch\Maintenance\ChunkBuilder();
661        $builder->build( $this->mSelf, $this->mOptions, $buildChunks, $fromId, $this->toId );
662    }
663
664    /**
665     * Get the number of cirrusSearchMassIndex jobs in the queue.
666     * @return int length
667     */
668    private function getUpdatesInQueue() {
669        return MediaWikiServices::getInstance()->getJobQueueGroup()->get( 'cirrusSearchMassIndex' )->getSize();
670    }
671
672    /**
673     * @return Updater
674     */
675    private function createUpdater() {
676        return Updater::build( $this->getSearchConfig(), $this->getOption( 'cluster', null ) );
677    }
678}
679
680$maintClass = ForceSearchIndex::class;
681require_once RUN_MAINTENANCE_IF_MAIN;