1<?php
2/**
3 * Compress the text of a wiki.
4 *
5 * Usage:
6 *
7 * Non-wikimedia
8 * php compressOld.php [options...]
9 *
10 * Wikimedia
11 * php compressOld.php <database> [options...]
12 *
13 * Options are:
14 *  -t <type>           set compression type to either:
15 *                          gzip: compress revisions independently
16 *                          concat: concatenate revisions and compress in chunks (default)
17 *  -c <chunk-size>     maximum number of revisions in a concat chunk
18 *  -b <begin-date>     earliest date to check for uncompressed revisions
19 *  -e <end-date>       latest revision date to compress
20 *  -s <startid>        the id to start from (referring to the text table for
21 *                      type gzip, and to the page table for type concat)
22 *  -n <endid>          the page_id to stop at (only when using concat compression type)
23 *  --extdb <cluster>   store specified revisions in an external cluster (untested)
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 * @file
41 * @ingroup Maintenance ExternalStorage
42 */
43use MediaWiki\MediaWikiServices;
44use MediaWiki\Revision\SlotRecord;
45
46require_once __DIR__ . '/../Maintenance.php';
47
48/**
49 * Maintenance script that compress the text of a wiki.
50 *
51 * @ingroup Maintenance ExternalStorage
52 */
53class CompressOld extends Maintenance {
54	public function __construct() {
55		parent::__construct();
56		$this->addDescription( 'Compress the text of a wiki' );
57		$this->addOption( 'type', 'Set compression type to either: gzip|concat', false, true, 't' );
58		$this->addOption(
59			'chunksize',
60			'Maximum number of revisions in a concat chunk',
61			false,
62			true,
63			'c'
64		);
65		$this->addOption(
66			'begin-date',
67			'Earliest date to check for uncompressed revisions',
68			false,
69			true,
70			'b'
71		);
72		$this->addOption( 'end-date', 'Latest revision date to compress', false, true, 'e' );
73		$this->addOption(
74			'startid',
75			'The id to start from (gzip -> text table, concat -> page table)',
76			false,
77			true,
78			's'
79		);
80		$this->addOption(
81			'extdb',
82			'Store specified revisions in an external cluster (untested)',
83			false,
84			true
85		);
86		$this->addOption(
87			'endid',
88			'The page_id to stop at (only when using concat compression type)',
89			false,
90			true,
91			'n'
92		);
93	}
94
95	public function execute() {
96		global $wgDBname;
97		if ( !function_exists( "gzdeflate" ) ) {
98			$this->fatalError( "You must enable zlib support in PHP to compress old revisions!\n" .
99				"Please see https://www.php.net/manual/en/ref.zlib.php\n" );
100		}
101
102		$type = $this->getOption( 'type', 'concat' );
103		$chunkSize = $this->getOption( 'chunksize', 20 );
104		$startId = $this->getOption( 'startid', 0 );
105		$beginDate = $this->getOption( 'begin-date', '' );
106		$endDate = $this->getOption( 'end-date', '' );
107		$extDB = $this->getOption( 'extdb', '' );
108		$endId = $this->getOption( 'endid', false );
109
110		if ( $type != 'concat' && $type != 'gzip' ) {
111			$this->error( "Type \"{$type}\" not supported" );
112		}
113
114		if ( $extDB != '' ) {
115			$this->output( "Compressing database {$wgDBname} to external cluster {$extDB}\n"
116				. str_repeat( '-', 76 ) . "\n\n" );
117		} else {
118			$this->output( "Compressing database {$wgDBname}\n"
119				. str_repeat( '-', 76 ) . "\n\n" );
120		}
121
122		$success = true;
123		if ( $type == 'concat' ) {
124			$success = $this->compressWithConcat( $startId, $chunkSize, $beginDate,
125				$endDate, $extDB, $endId );
126		} else {
127			$this->compressOldPages( $startId, $extDB );
128		}
129
130		if ( $success ) {
131			$this->output( "Done.\n" );
132		}
133	}
134
135	/**
136	 * Fetch the text row-by-row to 'compressPage' function for compression.
137	 *
138	 * @param int $start
139	 * @param string $extdb
140	 */
141	private function compressOldPages( $start = 0, $extdb = '' ) {
142		$chunksize = 50;
143		$this->output( "Starting from old_id $start...\n" );
144		$dbw = $this->getDB( DB_MASTER );
145		do {
146			$res = $dbw->select(
147				'text',
148				[ 'old_id', 'old_flags', 'old_text' ],
149				"old_id>=$start",
150				__METHOD__,
151				[ 'ORDER BY' => 'old_id', 'LIMIT' => $chunksize, 'FOR UPDATE' ]
152			);
153
154			if ( $res->numRows() == 0 ) {
155				break;
156			}
157
158			$last = $start;
159
160			foreach ( $res as $row ) {
161				# print "  {$row->old_id} - {$row->old_namespace}:{$row->old_title}\n";
162				$this->compressPage( $row, $extdb );
163				$last = $row->old_id;
164			}
165
166			$start = $last + 1; # Deletion may leave long empty stretches
167			$this->output( "$start...\n" );
168		} while ( true );
169	}
170
171	/**
172	 * Compress the text in gzip format.
173	 *
174	 * @param stdClass $row
175	 * @param string $extdb
176	 * @return bool
177	 */
178	private function compressPage( $row, $extdb ) {
179		if ( strpos( $row->old_flags, 'gzip' ) !== false
180			|| strpos( $row->old_flags, 'object' ) !== false
181		) {
182			# print "Already compressed row {$row->old_id}\n";
183			return false;
184		}
185		$dbw = $this->getDB( DB_MASTER );
186		$flags = $row->old_flags ? "{$row->old_flags},gzip" : "gzip";
187		$compress = gzdeflate( $row->old_text );
188
189		# Store in external storage if required
190		if ( $extdb !== '' ) {
191			$esFactory = MediaWikiServices::getInstance()->getExternalStoreFactory();
192			/** @var ExternalStoreDB $storeObj */
193			$storeObj = $esFactory->getStore( 'DB' );
194			$compress = $storeObj->store( $extdb, $compress );
195			if ( $compress === false ) {
196				$this->error( "Unable to store object" );
197
198				return false;
199			}
200		}
201
202		# Update text row
203		$dbw->update( 'text',
204			[ /* SET */
205				'old_flags' => $flags,
206				'old_text' => $compress
207			], [ /* WHERE */
208				'old_id' => $row->old_id
209			], __METHOD__,
210			[ 'LIMIT' => 1 ]
211		);
212
213		return true;
214	}
215
216	/**
217	 * Compress the text in chunks after concatenating the revisions.
218	 *
219	 * @param int $startId
220	 * @param int $maxChunkSize
221	 * @param string $beginDate
222	 * @param string $endDate
223	 * @param string $extdb
224	 * @param bool|int $maxPageId
225	 * @return bool
226	 */
227	private function compressWithConcat( $startId, $maxChunkSize, $beginDate,
228		$endDate, $extdb = "", $maxPageId = false
229	) {
230		$dbr = $this->getDB( DB_REPLICA );
231		$dbw = $this->getDB( DB_MASTER );
232
233		# Set up external storage
234		if ( $extdb != '' ) {
235			$esFactory = MediaWikiServices::getInstance()->getExternalStoreFactory();
236			/** @var ExternalStoreDB $storeObj */
237			$storeObj = $esFactory->getStore( 'DB' );
238		}
239
240		$blobStore = MediaWikiServices::getInstance()
241			->getBlobStoreFactory()
242			->newSqlBlobStore();
243
244		# Get all articles by page_id
245		if ( !$maxPageId ) {
246			$maxPageId = $dbr->selectField( 'page', 'max(page_id)', '', __METHOD__ );
247		}
248		$this->output( "Starting from $startId of $maxPageId\n" );
249		$pageConds = [];
250
251		/*
252		if ( $exclude_ns0 ) {
253			print "Excluding main namespace\n";
254			$pageConds[] = 'page_namespace<>0';
255		}
256		if ( $queryExtra ) {
257					$pageConds[] = $queryExtra;
258		}
259		 */
260
261		# For each article, get a list of revisions which fit the criteria
262
263		# No recompression, use a condition on old_flags
264		# Don't compress object type entities, because that might produce data loss when
265		# overwriting bulk storage concat rows. Don't compress external references, because
266		# the script doesn't yet delete rows from external storage.
267		$conds = [
268			'old_flags NOT ' . $dbr->buildLike( $dbr->anyString(), 'object', $dbr->anyString() )
269			. ' AND old_flags NOT '
270			. $dbr->buildLike( $dbr->anyString(), 'external', $dbr->anyString() )
271		];
272
273		if ( $beginDate ) {
274			if ( !preg_match( '/^\d{14}$/', $beginDate ) ) {
275				$this->error( "Invalid begin date \"$beginDate\"\n" );
276
277				return false;
278			}
279			$conds[] = "rev_timestamp>'" . $beginDate . "'";
280		}
281		if ( $endDate ) {
282			if ( !preg_match( '/^\d{14}$/', $endDate ) ) {
283				$this->error( "Invalid end date \"$endDate\"\n" );
284
285				return false;
286			}
287			$conds[] = "rev_timestamp<'" . $endDate . "'";
288		}
289
290		$slotRoleStore = MediaWikiServices::getInstance()->getSlotRoleStore();
291		$tables = [ 'revision', 'slots', 'content', 'text' ];
292		$conds = array_merge( [
293			'rev_id=slot_revision_id',
294			'slot_role_id=' . $slotRoleStore->getId( SlotRecord::MAIN ),
295			'content_id=slot_content_id',
296			'SUBSTRING(content_address, 1, 3)=' . $dbr->addQuotes( 'tt:' ),
297			'SUBSTRING(content_address, 4)=old_id',
298		], $conds );
299
300		$fields = [ 'rev_id', 'old_id', 'old_flags', 'old_text' ];
301		$revLoadOptions = 'FOR UPDATE';
302
303		# Don't work with current revisions
304		# Don't lock the page table for update either -- TS 2006-04-04
305		# $tables[] = 'page';
306		# $conds[] = 'page_id=rev_page AND rev_id != page_latest';
307
308		$lbFactory = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
309
310		for ( $pageId = $startId; $pageId <= $maxPageId; $pageId++ ) {
311			$lbFactory->waitForReplication();
312
313			# Wake up
314			$dbr->ping();
315
316			# Get the page row
317			$pageRes = $dbr->select( 'page',
318				[ 'page_id', 'page_namespace', 'page_title', 'page_latest' ],
319				$pageConds + [ 'page_id' => $pageId ], __METHOD__ );
320			if ( $pageRes->numRows() == 0 ) {
321				continue;
322			}
323			$pageRow = $dbr->fetchObject( $pageRes );
324
325			# Display progress
326			$titleObj = Title::makeTitle( $pageRow->page_namespace, $pageRow->page_title );
327			$this->output( "$pageId\t" . $titleObj->getPrefixedDBkey() . " " );
328
329			# Load revisions
330			$revRes = $dbw->select( $tables, $fields,
331				array_merge( [
332					'rev_page' => $pageRow->page_id,
333					# Don't operate on the current revision
334					# Use < instead of <> in case the current revision has changed
335					# since the page select, which wasn't locking
336					'rev_id < ' . (int)$pageRow->page_latest
337				], $conds ),
338				__METHOD__,
339				$revLoadOptions
340			);
341			$revs = [];
342			foreach ( $revRes as $revRow ) {
343				$revs[] = $revRow;
344			}
345
346			if ( count( $revs ) < 2 ) {
347				# No revisions matching, no further processing
348				$this->output( "\n" );
349				continue;
350			}
351
352			# For each chunk
353			$i = 0;
354			while ( $i < count( $revs ) ) {
355				if ( $i < count( $revs ) - $maxChunkSize ) {
356					$thisChunkSize = $maxChunkSize;
357				} else {
358					$thisChunkSize = count( $revs ) - $i;
359				}
360
361				$chunk = new ConcatenatedGzipHistoryBlob();
362				$stubs = [];
363				$this->beginTransaction( $dbw, __METHOD__ );
364				$usedChunk = false;
365				$primaryOldid = $revs[$i]->old_id;
366
367				# Get the text of each revision and add it to the object
368				for ( $j = 0; $j < $thisChunkSize && $chunk->isHappy(); $j++ ) {
369					$oldid = $revs[$i + $j]->old_id;
370
371					# Get text. We do not need the full `extractBlob` since the query is built
372					# to fetch non-externalstore blobs.
373					$text = $blobStore->decompressData(
374						$revs[$i + $j]->old_text,
375						explode( ',', $revs[$i + $j]->old_flags )
376					);
377
378					if ( $text === false ) {
379						$this->error( "\nError, unable to get text in old_id $oldid" );
380						# $dbw->delete( 'old', [ 'old_id' => $oldid ] );
381					}
382
383					if ( $extdb == "" && $j == 0 ) {
384						$chunk->setText( $text );
385						$this->output( '.' );
386					} else {
387						# Don't make a stub if it's going to be longer than the article
388						# Stubs are typically about 100 bytes
389						if ( strlen( $text ) < 120 ) {
390							$stub = false;
391							$this->output( 'x' );
392						} else {
393							$stub = new HistoryBlobStub( $chunk->addItem( $text ) );
394							$stub->setLocation( $primaryOldid );
395							$stub->setReferrer( $oldid );
396							$this->output( '.' );
397							$usedChunk = true;
398						}
399						$stubs[$j] = $stub;
400					}
401				}
402				$thisChunkSize = $j;
403
404				# If we couldn't actually use any stubs because the pages were too small, do nothing
405				if ( $usedChunk ) {
406					if ( $extdb != "" ) {
407						# Move blob objects to External Storage
408						$stored = $storeObj->store( $extdb, serialize( $chunk ) );
409						if ( $stored === false ) {
410							$this->error( "Unable to store object" );
411
412							return false;
413						}
414						# Store External Storage URLs instead of Stub placeholders
415						foreach ( $stubs as $stub ) {
416							if ( $stub === false ) {
417								continue;
418							}
419							# $stored should provide base path to a BLOB
420							$url = $stored . "/" . $stub->getHash();
421							$dbw->update( 'text',
422								[ /* SET */
423									'old_text' => $url,
424									'old_flags' => 'external,utf-8',
425								], [ /* WHERE */
426									'old_id' => $stub->getReferrer(),
427								],
428								__METHOD__
429							);
430						}
431					} else {
432						# Store the main object locally
433						$dbw->update( 'text',
434							[ /* SET */
435								'old_text' => serialize( $chunk ),
436								'old_flags' => 'object,utf-8',
437							], [ /* WHERE */
438								'old_id' => $primaryOldid
439							],
440							__METHOD__
441						);
442
443						# Store the stub objects
444						for ( $j = 1; $j < $thisChunkSize; $j++ ) {
445							# Skip if not compressing and don't overwrite the first revision
446							if ( $stubs[$j] !== false && $revs[$i + $j]->old_id != $primaryOldid ) {
447								$dbw->update( 'text',
448									[ /* SET */
449										'old_text' => serialize( $stubs[$j] ),
450										'old_flags' => 'object,utf-8',
451									], [ /* WHERE */
452										'old_id' => $revs[$i + $j]->old_id
453									],
454									__METHOD__
455								);
456							}
457						}
458					}
459				}
460				# Done, next
461				$this->output( "/" );
462				$this->commitTransaction( $dbw, __METHOD__ );
463				$i += $thisChunkSize;
464			}
465			$this->output( "\n" );
466		}
467
468		return true;
469	}
470}
471
472$maintClass = CompressOld::class;
473require_once RUN_MAINTENANCE_IF_MAIN;
474