33 require_once __DIR__ .
'/../../maintenance/Maintenance.php';
87 DeleteDefaultMessages::class,
88 PopulateRevisionLength::class,
89 PopulateRevisionSha1::class,
90 PopulateImageSha1::class,
91 FixExtLinksProtocolRelative::class,
92 PopulateFilearchiveSha1::class,
93 PopulateBacklinkNamespace::class,
94 FixDefaultJsonContentPages::class,
95 CleanupEmptyCategories::class,
96 AddRFCandPMIDInterwiki::class,
97 PopulatePPSortKey::class,
98 PopulateIpChanges::class,
99 RefreshExternallinksIndex::class,
142 private function loadExtensionSchemaUpdates() {
143 $hookContainer = $this->loadExtensions();
144 (
new HookRunner( $hookContainer ) )->onLoadExtensionSchemaUpdates( $this );
153 private function loadExtensions() {
154 if ( $this->autoExtensionHookContainer ) {
158 if ( defined(
'MW_EXTENSIONS_LOADED' ) ) {
159 throw new Exception( __METHOD__ .
160 ' apparently called from installer but no hook container was injected' );
162 if ( !defined(
'MEDIAWIKI_INSTALL' ) ) {
164 return MediaWikiServices::getInstance()->getHookContainer();
169 $queue = $registry->getQueue();
171 $registry->clearQueue();
174 $extInfo = $registry->readFromQueue(
$queue );
178 $legacySchemaHooks = $extInfo[
'globals'][
'wgHooks'][
'LoadExtensionSchemaUpdates'] ?? [];
179 if ( $vars && isset( $vars[
'wgHooks'][
'LoadExtensionSchemaUpdates'] ) ) {
180 $legacySchemaHooks = array_merge( $legacySchemaHooks, $vars[
'wgHooks'][
'LoadExtensionSchemaUpdates'] );
185 if ( $vars && isset( $vars[
'wgAutoloadClasses'] ) ) {
186 AutoLoader::registerClasses( $vars[
'wgAutoloadClasses'] );
190 if ( !isset( $extInfo[
'autoloaderPaths'] )
191 || !isset( $extInfo[
'autoloaderClasses'] )
192 || !isset( $extInfo[
'autoloaderNS'] )
195 throw new LogicException(
'Missing autoloader keys from extracted extension info' );
197 AutoLoader::loadFiles( $extInfo[
'autoloaderPaths'] );
198 AutoLoader::registerClasses( $extInfo[
'autoloaderClasses'] );
199 AutoLoader::registerNamespaces( $extInfo[
'autoloaderNS'] );
203 [
'LoadExtensionSchemaUpdates' => $legacySchemaHooks ],
204 $extInfo[
'attributes'][
'Hooks'] ?? [],
205 $extInfo[
'attributes'][
'DeprecatedHooks'] ?? []
207 MediaWikiServices::getInstance()->getObjectFactory()
226 $class = ucfirst(
$type ) .
'Updater';
230 throw new MWException( __METHOD__ .
' called for unsupported $wgDBtype' );
242 $this->autoExtensionHookContainer = $hookContainer;
261 if ( $this->maintenance->isQuiet() ) {
266 $str = htmlspecialchars( $str );
285 $this->extensionUpdates[] = $update;
299 $this->extensionUpdates[] = [
'addTable', $tableName, $sqlPath,
true ];
313 $this->extensionUpdates[] = [
'addIndex', $tableName, $indexName, $sqlPath,
true ];
327 $this->extensionUpdates[] = [
'addField', $tableName, $columnName, $sqlPath,
true ];
341 $this->extensionUpdates[] = [
'dropField', $tableName, $columnName, $sqlPath,
true ];
355 $this->extensionUpdates[] = [
'dropIndex', $tableName, $indexName, $sqlPath,
true ];
368 $this->extensionUpdates[] = [
'dropTable', $tableName, $sqlPath,
true ];
385 $sqlPath, $skipBothIndexExistWarning =
false
387 $this->extensionUpdates[] = [
392 $skipBothIndexExistWarning,
409 $this->extensionUpdates[] = [
'modifyField', $tableName, $fieldName, $sqlPath,
true ];
422 $this->extensionUpdates[] = [
'modifyTable', $tableName, $sqlPath,
true ];
432 return ( $this->db->tableExists( $tableName, __METHOD__ ) );
445 $this->postDatabaseUpdateMaintenance[] = $class;
472 private function writeSchemaUpdateFile( array $schemaUpdate = [] ) {
474 $this->updatesSkipped = [];
476 foreach (
$updates as [ $func, $args, $origParams ] ) {
480 $this->updatesSkipped[] = $origParams;
504 public function doUpdates( array $what = [
'core',
'extensions',
'stats' ] ) {
507 $what = array_fill_keys( $what,
true );
508 $this->skipSchema = isset( $what[
'noschema'] ) || $this->fileHandle !==
null;
509 if ( isset( $what[
'core'] ) ) {
513 if ( isset( $what[
'extensions'] ) ) {
514 $this->loadExtensionSchemaUpdates();
518 if ( isset( $what[
'stats'] ) ) {
522 if ( $this->fileHandle ) {
523 $this->skipSchema =
false;
524 $this->writeSchemaUpdateFile();
534 private function runUpdates( array
$updates, $passSelf ) {
535 $lbFactory = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
540 $origParams = $params;
541 $func = array_shift( $params );
542 if ( !is_array( $func ) && method_exists( $this, $func ) ) {
543 $func = [ $this, $func ];
544 } elseif ( $passSelf ) {
545 array_unshift( $params, $this );
547 $ret = $func( ...$params );
549 if ( $ret !==
false ) {
550 $updatesDone[] = $origParams;
551 $lbFactory->waitForReplication( [
'timeout' => self::REPLICATION_WAIT_TIMEOUT ] );
556 $this->updatesSkipped = array_merge( $this->updatesSkipped,
$updatesSkipped );
557 $this->updates = array_merge( $this->updates, $updatesDone );
568 $row = $this->db->selectRow(
572 [
'ul_key' => $key ],
594 $values = [
'ul_key' => $key ];
596 $values[
'ul_value'] = $val;
598 $this->db->insert(
'updatelog', $values, __METHOD__, [
'IGNORE' ] );
611 return $this->db->tableExists(
'updatelog', __METHOD__ ) &&
612 $this->db->fieldExists(
'updatelog',
'ul_value', __METHOD__ );
633 $this->
output(
"...skipping update to shared table $name.\n" );
657 $this->db->sourceFile(
681 $line = rtrim( $line ) .
";\n";
682 if ( fwrite( $this->fileHandle, $line ) ===
false ) {
701 $msg ??=
"Applying $path patch";
702 if ( $this->skipSchema ) {
703 $this->
output(
"...skipping schema change ($msg).\n" );
708 $this->
output(
"{$msg}..." );
710 if ( !$isFullPath ) {
713 if ( $this->fileHandle !==
null ) {
716 $this->db->sourceFile(
$path );
718 $this->
output(
"done.\n" );
732 $baseDir = MediaWikiServices::getInstance()->getMainConfig()->get( MainConfigNames::BaseDirectory );
735 if ( file_exists(
"$baseDir/maintenance/$dbType/archives/$patch" ) ) {
736 return "$baseDir/maintenance/$dbType/archives/$patch";
738 return "$baseDir/maintenance/archives/$patch";
753 protected function addTable( $name, $patch, $fullpath =
false ) {
754 if ( !$this->
doTable( $name ) ) {
758 if ( $this->db->tableExists( $name, __METHOD__ ) ) {
759 $this->
output(
"...$name table already exists.\n" );
761 return $this->
applyPatch( $patch, $fullpath,
"Creating $name table" );
779 protected function addField( $table, $field, $patch, $fullpath =
false ) {
780 if ( !$this->
doTable( $table ) ) {
784 if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
785 $this->
output(
"...$table table does not exist, skipping new field patch.\n" );
786 } elseif ( $this->db->fieldExists( $table, $field, __METHOD__ ) ) {
787 $this->
output(
"...have $field field in $table table.\n" );
789 return $this->
applyPatch( $patch, $fullpath,
"Adding $field field to table $table" );
807 protected function addIndex( $table, $index, $patch, $fullpath =
false ) {
808 if ( !$this->
doTable( $table ) ) {
812 if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
813 $this->
output(
"...skipping: '$table' table doesn't exist yet.\n" );
814 } elseif ( $this->db->indexExists( $table, $index, __METHOD__ ) ) {
815 $this->
output(
"...index $index already set on $table table.\n" );
817 return $this->
applyPatch( $patch, $fullpath,
"Adding index $index to table $table" );
835 protected function dropField( $table, $field, $patch, $fullpath =
false ) {
836 if ( !$this->
doTable( $table ) ) {
840 if ( $this->db->fieldExists( $table, $field, __METHOD__ ) ) {
841 return $this->
applyPatch( $patch, $fullpath,
"Table $table contains $field field. Dropping" );
843 $this->
output(
"...$table table does not contain $field field.\n" );
861 protected function dropIndex( $table, $index, $patch, $fullpath =
false ) {
862 if ( !$this->
doTable( $table ) ) {
866 if ( $this->db->indexExists( $table, $index, __METHOD__ ) ) {
867 return $this->
applyPatch( $patch, $fullpath,
"Dropping $index index from table $table" );
869 $this->
output(
"...$index key doesn't exist.\n" );
892 $skipBothIndexExistWarning, $patch, $fullpath =
false
894 if ( !$this->
doTable( $table ) ) {
899 if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
900 $this->
output(
"...skipping: '$table' table doesn't exist yet.\n" );
906 if ( $this->db->indexExists( $table, $newIndex, __METHOD__ ) ) {
907 $this->
output(
"...index $newIndex already set on $table table.\n" );
908 if ( !$skipBothIndexExistWarning &&
909 $this->db->indexExists( $table, $oldIndex, __METHOD__ )
911 $this->
output(
"...WARNING: $oldIndex still exists, despite it has " .
912 "been renamed into $newIndex (which also exists).\n" .
913 " $oldIndex should be manually removed if not needed anymore.\n" );
920 if ( !$this->db->indexExists( $table, $oldIndex, __METHOD__ ) ) {
921 $this->
output(
"...skipping: index $oldIndex doesn't exist.\n" );
930 "Renaming index $oldIndex into $newIndex to table $table"
948 protected function dropTable( $table, $patch =
false, $fullpath =
false ) {
949 if ( !$this->
doTable( $table ) ) {
953 if ( $this->db->tableExists( $table, __METHOD__ ) ) {
954 $msg =
"Dropping table $table";
956 if ( $patch ===
false ) {
957 $this->
output(
"$msg ..." );
958 $this->db->dropTable( $table, __METHOD__ );
959 $this->
output(
"done.\n" );
961 return $this->
applyPatch( $patch, $fullpath, $msg );
964 $this->
output(
"...$table doesn't exist.\n" );
984 protected function modifyField( $table, $field, $patch, $fullpath =
false ) {
985 if ( !$this->
doTable( $table ) ) {
989 $updateKey =
"$table-$field-$patch";
990 if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
991 $this->
output(
"...$table table does not exist, skipping modify field patch.\n" );
992 } elseif ( !$this->db->fieldExists( $table, $field, __METHOD__ ) ) {
993 $this->
output(
"...$field field does not exist in $table table, " .
994 "skipping modify field patch.\n" );
996 $this->
output(
"...$field in table $table already modified by patch $patch.\n" );
998 $apply = $this->
applyPatch( $patch, $fullpath,
"Modifying $field field of table $table" );
1022 if ( !$this->
doTable( $table ) ) {
1026 $updateKey =
"$table-$patch";
1027 if ( !$this->db->tableExists( $table, __METHOD__ ) ) {
1028 $this->
output(
"...$table table does not exist, skipping modify table patch.\n" );
1030 $this->
output(
"...table $table already modified by patch $patch.\n" );
1032 $apply = $this->
applyPatch( $patch, $fullpath,
"Modifying table $table" );
1062 $this->
output(
"Running $script...\n" );
1063 $task = $this->maintenance->runChild( $class );
1064 $ok = $task->execute();
1066 throw new RuntimeException(
"Execution of $script did not complete successfully." );
1068 $this->
output(
"done.\n" );
1077 $repo = MediaWikiServices::getInstance()->getRepoGroup()->getLocalRepo();
1078 $zonePath = $repo->getZonePath(
'temp' );
1079 if ( $repo->getBackend()->directoryExists( [
'dir' => $zonePath ] ) ) {
1081 $status = $repo->getBackend()->secure( [
1086 if ( $status->isOK() ) {
1087 $this->
output(
"Set the local repo temp zone container to be private.\n" );
1089 $this->
output(
"Failed to set the local repo temp zone container to be private.\n" );
1101 $this->
output(
"Purging caches..." );
1104 $this->db->delete(
'objectcache',
'*', __METHOD__ );
1112 $services = MediaWikiServices::getInstance();
1113 MessageBlobStore::clearGlobalCacheEntry(
1114 $services->getMainWANObjectCache()
1118 $this->db->delete(
'module_deps',
'*', __METHOD__ );
1119 $this->
output(
"done.\n" );
1126 $this->
output(
"...site_stats is populated..." );
1127 $row = $this->db->selectRow(
'site_stats',
'*', [
'ss_row_id' => 1 ], __METHOD__ );
1128 if ( $row ===
false ) {
1129 $this->
output(
"data is missing! rebuilding...\n" );
1130 } elseif ( isset( $row->site_stats ) && $row->ss_total_pages == -1 ) {
1131 $this->
output(
"missing ss_total_pages, rebuilding...\n" );
1133 $this->
output(
"done.\n" );
1140 # Common updater functions
1147 if ( $this->db->selectField(
1154 $this->
output(
"...collations up-to-date.\n" );
1159 $this->
output(
"Updating category collations..." );
1160 $task = $this->maintenance->runChild( UpdateCollation::class );
1162 $this->
output(
"...done.\n" );
1169 $this->
output(
"Converting djvu metadata..." );
1170 $task = $this->maintenance->runChild( RefreshImageMetadata::class );
1171 '@phan-var RefreshImageMetadata $task';
1172 $task->loadParamsAndArgs( RefreshImageMetadata::class, [
1174 'mediatype' =>
'OFFICE',
1175 'mime' =>
'image/*',
1179 $ok = $task->execute();
1180 if ( $ok !==
false ) {
1181 $this->
output(
"...done.\n" );
1193 $cl = $this->maintenance->runChild(
1194 RebuildLocalisationCache::class,
'rebuildLocalisationCache.php'
1196 '@phan-var RebuildLocalisationCache $cl';
1197 $this->
output(
"Rebuilding localisation cache...\n" );
1200 $this->
output(
"done.\n" );
1204 if ( $this->
updateRowExists( MigrateLinksTable::class .
'templatelinks' ) ) {
1205 $this->
output(
"...templatelinks table has already been migrated.\n" );
1211 $task = $this->maintenance->runChild(
1212 MigrateLinksTable::class,
'migrateLinksTable.php'
1214 '@phan-var MigrateLinksTable $task';
1215 $task->loadParamsAndArgs( MigrateLinksTable::class, [
1217 'table' =>
'templatelinks'
1219 $this->
output(
"Running migrateLinksTable.php on templatelinks...\n" );
1221 $this->
output(
"done.\n" );
1240 if ( $table === $this ) {
1243 $func = array_shift( $params );
1246 if ( $this->db->tableExists( $table, __METHOD__ ) ) {
1250 if ( !is_array( $func ) && method_exists( $this, $func ) ) {
1251 $func = [ $this, $func ];
1252 } elseif ( $passSelf ) {
1253 array_unshift( $params, $this );
1257 return $func( ...$params );
1277 if ( $table === $this ) {
1281 $func = array_shift( $params );
1284 if ( !$this->db->tableExists( $table, __METHOD__ ) ||
1285 !$this->db->fieldExists( $table, $field, __METHOD__ )
1290 if ( !is_array( $func ) && method_exists( $this, $func ) ) {
1291 $func = [ $this, $func ];
1292 } elseif ( $passSelf ) {
1293 array_unshift( $params, $this );
1297 return $func( ...$params );
global $wgCommandLineMode
Class for handling database updates.
purgeCache()
Purge various database caches.
addExtensionTable( $tableName, $sqlPath)
Convenience wrapper for addExtensionUpdate() when adding a new table (which is the most common usage ...
getDB()
Get a database connection to run updates.
setFileAccess()
Set any .htaccess files or equivalent for storage repos.
addIndex( $table, $index, $patch, $fullpath=false)
Add a new index to an existing table.
array $updates
Array of updates to perform on the database.
modifyExtensionTable( $tableName, $sqlPath)
Modify an existing extension table.
bool $skipSchema
Flag specifying whether or not to skip schema (e.g.
runMaintenance( $class, $script)
Run a maintenance script.
addField( $table, $field, $patch, $fullpath=false)
Add a new field to an existing table.
addExtensionIndex( $tableName, $indexName, $sqlPath)
Add an index to an existing extension table.
modifyTable( $table, $patch, $fullpath=false)
Modify an existing table, similar to modifyField.
doUpdates(array $what=[ 'core', 'extensions', 'stats'])
Do all the updates.
ifTableNotExists( $table, $func,... $params)
Only run a function if a table does not exist.
updateRowExists( $key)
Helper function: check if the given key is present in the updatelog table.
const REPLICATION_WAIT_TIMEOUT
getCoreUpdateList()
Get an array of updates to perform on the database.
output( $str)
Output some text.
getPostDatabaseUpdateMaintenance()
getExtensionUpdates()
Get the list of extension-defined updates.
insertUpdateRow( $key, $val=null)
Helper function: Add a key to the updatelog table.
setAutoExtensionHookContainer(HookContainer $hookContainer)
Set the HookContainer to use for loading extension schema updates.
canUseNewUpdatelog()
Updatelog was changed in 1.17 to have a ul_value column so we can record more information about what ...
patchPath(IDatabase $db, $patch)
Get the full path of a patch file.
copyFile( $filename)
Append an SQL fragment to the open file handle.
string[] $postDatabaseUpdateMaintenance
Scripts to run after database update Should be a subclass of LoggedUpdateMaintenance.
HookContainer null $autoExtensionHookContainer
dropExtensionTable( $tableName, $sqlPath=false)
Drop an extension table.
resource null $fileHandle
File handle for SQL output.
renameIndex( $table, $oldIndex, $newIndex, $skipBothIndexExistWarning, $patch, $fullpath=false)
Rename an index from an existing table.
rebuildLocalisationCache()
Rebuilds the localisation cache.
addExtensionField( $tableName, $columnName, $sqlPath)
Add a field to an existing extension table.
IMaintainableDatabase $db
Handle to the database subclass.
ifFieldExists( $table, $field, $func,... $params)
Only run a function if the named field exists.
addTable( $name, $patch, $fullpath=false)
Add a new table to the database.
modifyField( $table, $field, $patch, $fullpath=false)
Modify an existing field.
dropExtensionField( $tableName, $columnName, $sqlPath)
Drop a field from an extension table.
static newForDB(IMaintainableDatabase $db, $shared=false, Maintenance $maintenance=null)
addPostDatabaseUpdateMaintenance( $class)
Add a maintenance script to be run after the database updates are complete.
dropField( $table, $field, $patch, $fullpath=false)
Drop a field from an existing table.
doCollationUpdate()
Update CategoryLinks collation.
renameExtensionIndex( $tableName, $oldIndexName, $newIndexName, $sqlPath, $skipBothIndexExistWarning=false)
Rename an index on an extension table Intended for use in LoadExtensionSchemaUpdates hook handlers.
addExtensionUpdate(array $update)
Add a new update coming from an extension.
array $updatesSkipped
Array of updates that were skipped.
appendLine( $line)
Append a line to the open filehandle.
dropExtensionIndex( $tableName, $indexName, $sqlPath)
Drop an index from an extension table Intended for use in LoadExtensionSchemaUpdates hook handlers.
array $extensionUpdates
List of extension-provided database updates.
checkStats()
Check the site_stats table is not properly populated.
modifyExtensionField( $tableName, $fieldName, $sqlPath)
Modify an existing field in an extension table.
applyPatch( $path, $isFullPath=false, $msg=null)
Applies a SQL patch.
dropIndex( $table, $index, $patch, $fullpath=false)
Drop an index from an existing table.
__construct(IMaintainableDatabase &$db, $shared, Maintenance $maintenance=null)
dropTable( $table, $patch=false, $fullpath=false)
If the specified table exists, drop it, or execute the patch if one is provided.
getSchemaVars()
Get appropriate schema variables in the current database connection.
doTable( $name)
Returns whether updates should be executed on the database table $name.
Fake maintenance wrapper, mostly used for the web installer/updater.
static getExistingLocalSettings()
Determine if LocalSettings.php exists.
static getDBTypes()
Get a list of known DB types.
Abstract maintenance class for quickly writing and churning out maintenance scripts with minimal effo...
setDB(IMaintainableDatabase $db)
Sets database object to be returned by getDB().
A class containing constants representing the names of configuration variables.
static doAllAndCommit( $database, array $options=[])
Do all updates and commit them.
$wgSharedTables
Config variable stub for the SharedTables setting, for use by phpdoc and IDEs.
$wgCategoryCollation
Config variable stub for the CategoryCollation setting, for use by phpdoc and IDEs.
$wgSharedDB
Config variable stub for the SharedDB setting, for use by phpdoc and IDEs.
$wgLocalisationCacheConf
Config variable stub for the LocalisationCacheConf setting, for use by phpdoc and IDEs.
Advanced database interface for IDatabase handles that include maintenance methods.