X-Git-Url: http://git.cyclocoop.org/%7B%7B%20url_for%28%27admin_vote_del%27%2C%20idvote=vote.voteid%29%20%7D%7D?a=blobdiff_plain;f=includes%2Finstaller%2FDatabaseUpdater.php;h=f2e36aec2b27a024c4eb87e7a4ba21d099fd57f5;hb=1a40d939490097b00b27acfcef6a4dba0e13a94b;hp=33b5cb629dc55fde8b200fb5796a9c5a4aa9b2f4;hpb=12d2c3af0da88956cce09622c16f6403c11e506e;p=lhc%2Fweb%2Fwiklou.git diff --git a/includes/installer/DatabaseUpdater.php b/includes/installer/DatabaseUpdater.php index 33b5cb629d..f2e36aec2b 100644 --- a/includes/installer/DatabaseUpdater.php +++ b/includes/installer/DatabaseUpdater.php @@ -5,11 +5,13 @@ * @file * @ingroup Deployment */ - -/* + +require_once( dirname(__FILE__) . '/../../maintenance/Maintenance.php' ); + +/** * Class for handling database updates. Roughly based off of updaters.inc, with * a few improvements :) - * + * * @ingroup Deployment * @since 1.17 */ @@ -22,14 +24,27 @@ abstract class DatabaseUpdater { */ protected $updates = array(); + /** + * List of extension-provided database updates + * @var array + */ protected $extensionUpdates = array(); + /** + * Handle to the database subclass + * + * @var DatabaseBase + */ protected $db; protected $shared = false; protected $postDatabaseUpdateMaintenance = array( - 'DeleteDefaultMessages' + 'DeleteDefaultMessages', + 'PopulateRevisionLength', + 'PopulateRevisionSha1', + 'PopulateImageSha1', + 'FixExtLinksProtocolRelative', ); /** @@ -37,15 +52,20 @@ abstract class DatabaseUpdater { * * @param $db DatabaseBase object to perform updates on * @param $shared bool Whether to perform updates on shared tables - * - * @TODO @FIXME Make $wgDatabase go away. + * @param $maintenance Maintenance Maintenance object which created us */ - protected function __construct( DatabaseBase &$db, $shared ) { - global $wgDatabase; - $wgDatabase = $db; + protected function __construct( DatabaseBase &$db, $shared, Maintenance $maintenance = null ) { $this->db = $db; + $this->db->setFlag( DBO_DDLMODE ); // For Oracle's handling of schema files $this->shared = $shared; + if ( $maintenance ) { + $this->maintenance = $maintenance; + } else { + $this->maintenance = new FakeMaintenance; + } + $this->maintenance->setDB( $db ); $this->initOldGlobals(); + $this->loadExtensions(); wfRunHooks( 'LoadExtensionSchemaUpdates', array( $this ) ); } @@ -54,12 +74,9 @@ abstract class DatabaseUpdater { * something much nicer */ private function initOldGlobals() { - global $wgUpdates, $wgExtNewTables, $wgExtNewFields, $wgExtPGNewFields, + global $wgExtNewTables, $wgExtNewFields, $wgExtPGNewFields, $wgExtPGAlteredFields, $wgExtNewIndexes, $wgExtModifiedFields; - // Deprecated. Do not use, ever. - $wgUpdates = array(); - # For extensions only, should be populated via hooks # $wgDBtype should be checked to specifiy the proper file $wgExtNewTables = array(); // table, dir @@ -70,11 +87,37 @@ abstract class DatabaseUpdater { $wgExtModifiedFields = array(); // table, index, dir } - public static function newForDB( &$db, $shared = false ) { + /** + * Loads LocalSettings.php, if needed, and initialises everything needed for LoadExtensionSchemaUpdates hook + */ + private function loadExtensions() { + if ( !defined( 'MEDIAWIKI_INSTALL' ) ) { + return; // already loaded + } + $vars = Installer::getExistingLocalSettings(); + if ( !$vars ) { + return; // no LocalSettings found + } + if ( !isset( $vars['wgHooks'] ) || !isset( $vars['wgHooks']['LoadExtensionSchemaUpdates'] ) ) { + return; + } + global $wgHooks, $wgAutoloadClasses; + $wgHooks['LoadExtensionSchemaUpdates'] = $vars['wgHooks']['LoadExtensionSchemaUpdates']; + $wgAutoloadClasses = $wgAutoloadClasses + $vars['wgAutoloadClasses']; + } + + /** + * @throws MWException + * @param DatabaseBase $db + * @param bool $shared + * @param null $maintenance + * @return DatabaseUpdater + */ + public static function newForDB( &$db, $shared = false, $maintenance = null ) { $type = $db->getType(); if( in_array( $type, Installer::getDBTypes() ) ) { $class = ucfirst( $type ) . 'Updater'; - return new $class( $db, $shared ); + return new $class( $db, $shared, $maintenance ); } else { throw new MWException( __METHOD__ . ' called for unsupported $wgDBtype' ); } @@ -83,27 +126,93 @@ abstract class DatabaseUpdater { /** * Get a database connection to run updates * - * @return DatabasBase object + * @return DatabaseBase */ public function getDB() { return $this->db; } + /** + * Output some text. If we're running from web, escape the text first. + * + * @param $str String: Text to output + */ + public function output( $str ) { + if ( $this->maintenance->isQuiet() ) { + return; + } + global $wgCommandLineMode; + if( !$wgCommandLineMode ) { + $str = htmlspecialchars( $str ); + } + echo $str; + flush(); + } + /** * Add a new update coming from an extension. This should be called by * extensions while executing the LoadExtensionSchemaUpdates hook. * + * @since 1.17 + * * @param $update Array: the update to run. Format is the following: * first item is the callback function, it also can be a * simple string with the name of a function in this class, * following elements are parameters to the function. - * Note that callback functions will recieve this object as + * Note that callback functions will receive this object as * first parameter. */ - public function addExtensionUpdate( $update ) { + public function addExtensionUpdate( Array $update ) { $this->extensionUpdates[] = $update; } + /** + * Convenience wrapper for addExtensionUpdate() when adding a new table (which + * is the most common usage of updaters in an extension) + * + * @since 1.18 + * + * @param $tableName String Name of table to create + * @param $sqlPath String Full path to the schema file + */ + public function addExtensionTable( $tableName, $sqlPath ) { + $this->extensionUpdates[] = array( 'addTable', $tableName, $sqlPath, true ); + } + + /** + * @since 1.19 + * + * @param $tableName string + * @param $indexName string + * @param $sqlPath string + */ + public function addExtensionIndex( $tableName, $indexName, $sqlPath ) { + $this->extensionUpdates[] = array( 'addIndex', $tableName, $indexName, $sqlPath, true ); + } + + /** + * + * @since 1.19 + * + * @param $tableName string + * @param $columnName string + * @param $sqlPath string + */ + public function addExtensionField( $tableName, $columnName, $sqlPath ) { + $this->extensionUpdates[] = array( 'addField', $tableName, $columnName, $sqlPath, true ); + } + + /** + * Add a maintenance script to be run after the database updates are complete. + * + * @since 1.19 + * + * @param $class string Name of a Maintenance subclass + */ + public function addPostDatabaseUpdateMaintenance( $class ) { + $this->postDatabaseUpdateMaintenance[] = $class; + } + /** * Get the list of extension-defined updates * @@ -113,6 +222,11 @@ abstract class DatabaseUpdater { return $this->extensionUpdates; } + /** + * @since 1.17 + * + * @return array + */ public function getPostDatabaseUpdateMaintenance() { return $this->postDatabaseUpdateMaintenance; } @@ -120,20 +234,32 @@ abstract class DatabaseUpdater { /** * Do all the updates * - * @param $purge Boolean: whether to clear the objectcache table after updates + * @param $what Array: what updates to perform */ - public function doUpdates( $purge = true ) { - global $IP, $wgVersion; - require_once( "$IP/maintenance/updaters.inc" ); + public function doUpdates( $what = array( 'core', 'extensions', 'purge', 'stats' ) ) { + global $wgLocalisationCacheConf, $wgVersion; - $this->runUpdates( $this->getCoreUpdateList(), false ); - $this->runUpdates( $this->getOldGlobalUpdates(), false ); - $this->runUpdates( $this->getExtensionUpdates(), true ); + $what = array_flip( $what ); + if ( isset( $what['core'] ) ) { + $this->runUpdates( $this->getCoreUpdateList(), false ); + } + if ( isset( $what['extensions'] ) ) { + $this->runUpdates( $this->getOldGlobalUpdates(), false ); + $this->runUpdates( $this->getExtensionUpdates(), true ); + } $this->setAppliedUpdates( $wgVersion, $this->updates ); - if( $purge ) { + if ( isset( $what['stats'] ) ) { + $this->checkStats(); + } + + if ( isset( $what['purge'] ) ) { $this->purgeCache(); + + if ( $wgLocalisationCacheConf['manualRecache'] ) { + $this->rebuildLocalisationCache(); + } } } @@ -158,7 +284,12 @@ abstract class DatabaseUpdater { $this->updates = array_merge( $this->updates, $updates ); } + /** + * @param $version + * @param $updates array + */ protected function setAppliedUpdates( $version, $updates = array() ) { + $this->db->clearFlag( DBO_DDLMODE ); if( !$this->canUseNewUpdatelog() ) { return; } @@ -166,6 +297,42 @@ abstract class DatabaseUpdater { $this->db->insert( 'updatelog', array( 'ul_key' => $key, 'ul_value' => serialize( $updates ) ), __METHOD__ ); + $this->db->setFlag( DBO_DDLMODE ); + } + + /** + * Helper function: check if the given key is present in the updatelog table. + * Obviously, only use this for updates that occur after the updatelog table was + * created! + * @param $key String Name of the key to check for + * + * @return bool + */ + public function updateRowExists( $key ) { + $row = $this->db->selectRow( + 'updatelog', + '1', + array( 'ul_key' => $key ), + __METHOD__ + ); + return (bool)$row; + } + + /** + * Helper function: Add a key to the updatelog table + * Obviously, only use this for updates that occur after the updatelog table was + * created! + * @param $key String Name of key to insert + * @param $val String [optional] value to insert along with the key + */ + public function insertUpdateRow( $key, $val = null ) { + $this->db->clearFlag( DBO_DDLMODE ); + $values = array( 'ul_key' => $key ); + if( $val && $this->canUseNewUpdatelog() ) { + $values['ul_value'] = $val; + } + $this->db->insert( 'updatelog', $values, __METHOD__, 'IGNORE' ); + $this->db->setFlag( DBO_DDLMODE ); } /** @@ -177,19 +344,21 @@ abstract class DatabaseUpdater { * @return boolean */ protected function canUseNewUpdatelog() { - return $this->db->tableExists( 'updatelog' ) && - $this->db->fieldExists( 'updatelog', 'ul_value' ); + return $this->db->tableExists( 'updatelog', __METHOD__ ) && + $this->db->fieldExists( 'updatelog', 'ul_value', __METHOD__ ); } /** - * Before 1.17, we used to handle updates via stuff like $wgUpdates, + * Before 1.17, we used to handle updates via stuff like * $wgExtNewTables/Fields/Indexes. This is nasty :) We refactored a lot - * of this in 1.17 but we want to remain back-compatible for awhile. So + * of this in 1.17 but we want to remain back-compatible for a while. So * load up these old global-based things into our update list. + * + * @return array */ protected function getOldGlobalUpdates() { - global $wgUpdates, $wgExtNewFields, $wgExtNewTables, - $wgExtModifiedFields, $wgExtNewIndexes, $wgSharedDB, $wgSharedTables; + global $wgExtNewFields, $wgExtNewTables, $wgExtModifiedFields, + $wgExtNewIndexes, $wgSharedDB, $wgSharedTables; $doUser = $this->shared ? $wgSharedDB && in_array( 'user', $wgSharedTables ) : @@ -197,12 +366,6 @@ abstract class DatabaseUpdater { $updates = array(); - if( isset( $wgUpdates[ $this->db->getType() ] ) ) { - foreach( $wgUpdates[ $this->db->getType() ] as $upd ) { - $updates[] = $upd; - } - } - foreach ( $wgExtNewTables as $tableRecord ) { $updates[] = array( 'addTable', $tableRecord[0], $tableRecord[1], true @@ -227,7 +390,7 @@ abstract class DatabaseUpdater { foreach ( $wgExtModifiedFields as $fieldRecord ) { $updates[] = array( - 'modify_field', $fieldRecord[0], $fieldRecord[1], + 'modifyField', $fieldRecord[0], $fieldRecord[1], $fieldRecord[2], true ); } @@ -237,7 +400,7 @@ abstract class DatabaseUpdater { /** * Get an array of updates to perform on the database. Should return a - * mutli-dimensional array. The main key is the MediaWiki version (1.12, + * multi-dimensional array. The main key is the MediaWiki version (1.12, * 1.13...) with the values being arrays of updates, identical to how * updaters.inc did it (for now) * @@ -254,7 +417,7 @@ abstract class DatabaseUpdater { if ( $isFullPath ) { $this->db->sourceFile( $path ); } else { - $this->db->sourceFile( DatabaseBase::patchPath( $path ) ); + $this->db->sourceFile( $this->db->patchPath( $path ) ); } } @@ -265,12 +428,12 @@ abstract class DatabaseUpdater { * @param $fullpath Boolean Whether to treat $patch path as a relative or not */ protected function addTable( $name, $patch, $fullpath = false ) { - if ( $this->db->tableExists( $name ) ) { - wfOut( "...$name table already exists.\n" ); + if ( $this->db->tableExists( $name, __METHOD__ ) ) { + $this->output( "...$name table already exists.\n" ); } else { - wfOut( "Creating $name table..." ); + $this->output( "Creating $name table..." ); $this->applyPatch( $patch, $fullpath ); - wfOut( "ok\n" ); + $this->output( "done.\n" ); } } @@ -282,14 +445,14 @@ abstract class DatabaseUpdater { * @param $fullpath Boolean Whether to treat $patch path as a relative or not */ protected function addField( $table, $field, $patch, $fullpath = false ) { - if ( !$this->db->tableExists( $table ) ) { - wfOut( "...$table table does not exist, skipping new field patch\n" ); - } elseif ( $this->db->fieldExists( $table, $field ) ) { - wfOut( "...have $field field in $table table.\n" ); + if ( !$this->db->tableExists( $table, __METHOD__ ) ) { + $this->output( "...$table table does not exist, skipping new field patch.\n" ); + } elseif ( $this->db->fieldExists( $table, $field, __METHOD__ ) ) { + $this->output( "...have $field field in $table table.\n" ); } else { - wfOut( "Adding $field field to table $table..." ); + $this->output( "Adding $field field to table $table..." ); $this->applyPatch( $patch, $fullpath ); - wfOut( "ok\n" ); + $this->output( "done.\n" ); } } @@ -300,13 +463,13 @@ abstract class DatabaseUpdater { * @param $patch String Path to the patch file * @param $fullpath Boolean Whether to treat $patch path as a relative or not */ - function addIndex( $table, $index, $patch, $fullpath = false ) { - if ( $this->db->indexExists( $table, $index ) ) { - wfOut( "...$index key already set on $table table.\n" ); + protected function addIndex( $table, $index, $patch, $fullpath = false ) { + if ( $this->db->indexExists( $table, $index, __METHOD__ ) ) { + $this->output( "...index $index already set on $table table.\n" ); } else { - wfOut( "Adding $index key to table $table... " ); + $this->output( "Adding index $index to table $table... " ); $this->applyPatch( $patch, $fullpath ); - wfOut( "ok\n" ); + $this->output( "done.\n" ); } } @@ -318,13 +481,70 @@ abstract class DatabaseUpdater { * @param $patch String Path to the patch file * @param $fullpath Boolean Whether to treat $patch path as a relative or not */ - function dropField( $table, $field, $patch, $fullpath = false ) { - if ( $this->db->fieldExists( $table, $field ) ) { - wfOut( "Table $table contains $field field. Dropping... " ); + protected function dropField( $table, $field, $patch, $fullpath = false ) { + if ( $this->db->fieldExists( $table, $field, __METHOD__ ) ) { + $this->output( "Table $table contains $field field. Dropping... " ); + $this->applyPatch( $patch, $fullpath ); + $this->output( "done.\n" ); + } else { + $this->output( "...$table table does not contain $field field.\n" ); + } + } + + /** + * Drop an index from an existing table + * + * @param $table String: Name of the table to modify + * @param $index String: Name of the old index + * @param $patch String: Path to the patch file + * @param $fullpath Boolean: Whether to treat $patch path as a relative or not + */ + protected function dropIndex( $table, $index, $patch, $fullpath = false ) { + if ( $this->db->indexExists( $table, $index, __METHOD__ ) ) { + $this->output( "Dropping $index index from table $table... " ); + $this->applyPatch( $patch, $fullpath ); + $this->output( "done.\n" ); + } else { + $this->output( "...$index key doesn't exist.\n" ); + } + } + + /** + * @param $table string + * @param $patch string + * @param $fullpath bool + */ + protected function dropTable( $table, $patch, $fullpath = false ) { + if ( $this->db->tableExists( $table, __METHOD__ ) ) { + $this->output( "Dropping table $table... " ); $this->applyPatch( $patch, $fullpath ); - wfOut( "ok\n" ); + $this->output( "done.\n" ); } else { - wfOut( "...$table table does not contain $field field.\n" ); + $this->output( "...$table doesn't exist.\n" ); + } + } + + /** + * Modify an existing field + * + * @param $table String: name of the table to which the field belongs + * @param $field String: name of the field to modify + * @param $patch String: path to the patch file + * @param $fullpath Boolean: whether to treat $patch path as a relative or not + */ + public function modifyField( $table, $field, $patch, $fullpath = false ) { + $updateKey = "$table-$field-$patch"; + if ( !$this->db->tableExists( $table, __METHOD__ ) ) { + $this->output( "...$table table does not exist, skipping modify field patch.\n" ); + } elseif ( !$this->db->fieldExists( $table, $field, __METHOD__ ) ) { + $this->output( "...$field field does not exist in $table table, skipping modify field patch.\n" ); + } elseif( $this->updateRowExists( $updateKey ) ) { + $this->output( "...$field in table $table already modified by patch $patch.\n" ); + } else { + $this->output( "Modifying $field field of table $table..." ); + $this->applyPatch( $patch, $fullpath ); + $this->insertUpdateRow( $updateKey ); + $this->output( "done.\n" ); } } @@ -334,8 +554,135 @@ abstract class DatabaseUpdater { protected function purgeCache() { # We can't guarantee that the user will be able to use TRUNCATE, # but we know that DELETE is available to us - wfOut( "Purging caches..." ); + $this->output( "Purging caches..." ); $this->db->delete( 'objectcache', '*', __METHOD__ ); - wfOut( "done.\n" ); + $this->output( "done.\n" ); + } + + /** + * Check the site_stats table is not properly populated. + */ + protected function checkStats() { + $this->output( "...site_stats is populated..." ); + $row = $this->db->selectRow( 'site_stats', '*', array( 'ss_row_id' => 1 ), __METHOD__ ); + if ( $row === false ) { + $this->output( "data is missing! rebuilding...\n" ); + } elseif ( isset( $row->site_stats ) && $row->ss_total_pages == -1 ) { + $this->output( "missing ss_total_pages, rebuilding...\n" ); + } else { + $this->output( "done.\n" ); + return; + } + SiteStatsInit::doAllAndCommit( $this->db ); + } + + # Common updater functions + + /** + * Sets the number of active users in the site_stats table + */ + protected function doActiveUsersInit() { + $activeUsers = $this->db->selectField( 'site_stats', 'ss_active_users', false, __METHOD__ ); + if ( $activeUsers == -1 ) { + $activeUsers = $this->db->selectField( 'recentchanges', + 'COUNT( DISTINCT rc_user_text )', + array( 'rc_user != 0', 'rc_bot' => 0, "rc_log_type != 'newusers'" ), __METHOD__ + ); + $this->db->update( 'site_stats', + array( 'ss_active_users' => intval( $activeUsers ) ), + array( 'ss_row_id' => 1 ), __METHOD__, array( 'LIMIT' => 1 ) + ); + } + $this->output( "...ss_active_users user count set...\n" ); + } + + /** + * Populates the log_user_text field in the logging table + */ + protected function doLogUsertextPopulation() { + if ( !$this->updateRowExists( 'populate log_usertext' ) ) { + $this->output( + "Populating log_user_text field, printing progress markers. For large\n" . + "databases, you may want to hit Ctrl-C and do this manually with\n" . + "maintenance/populateLogUsertext.php.\n" ); + + $task = $this->maintenance->runChild( 'PopulateLogUsertext' ); + $task->execute(); + $this->output( "done.\n" ); + } + } + + /** + * Migrate log params to new table and index for searching + */ + protected function doLogSearchPopulation() { + if ( !$this->updateRowExists( 'populate log_search' ) ) { + $this->output( + "Populating log_search table, printing progress markers. For large\n" . + "databases, you may want to hit Ctrl-C and do this manually with\n" . + "maintenance/populateLogSearch.php.\n" ); + + $task = $this->maintenance->runChild( 'PopulateLogSearch' ); + $task->execute(); + $this->output( "done.\n" ); + } + } + + /** + * Updates the timestamps in the transcache table + */ + protected function doUpdateTranscacheField() { + if ( $this->updateRowExists( 'convert transcache field' ) ) { + $this->output( "...transcache tc_time already converted.\n" ); + return; + } + + $this->output( "Converting tc_time from UNIX epoch to MediaWiki timestamp... " ); + $this->applyPatch( 'patch-tc-timestamp.sql' ); + $this->output( "done.\n" ); + } + + /** + * Update CategoryLinks collation + */ + protected function doCollationUpdate() { + global $wgCategoryCollation; + if ( $this->db->selectField( + 'categorylinks', + 'COUNT(*)', + 'cl_collation != ' . $this->db->addQuotes( $wgCategoryCollation ), + __METHOD__ + ) == 0 ) { + $this->output( "...collations up-to-date.\n" ); + return; + } + + $this->output( "Updating category collations..." ); + $task = $this->maintenance->runChild( 'UpdateCollation' ); + $task->execute(); + $this->output( "...done.\n" ); + } + + /** + * Migrates user options from the user table blob to user_properties + */ + protected function doMigrateUserOptions() { + $cl = $this->maintenance->runChild( 'ConvertUserOptions', 'convertUserOptions.php' ); + $cl->execute(); + $this->output( "done.\n" ); + } + + /** + * Rebuilds the localisation cache + */ + protected function rebuildLocalisationCache() { + /** + * @var $cl RebuildLocalisationCache + */ + $cl = $this->maintenance->runChild( 'RebuildLocalisationCache', 'rebuildLocalisationCache.php' ); + $this->output( "Rebuilding localisation cache...\n" ); + $cl->setForce(); + $cl->execute(); + $this->output( "done.\n" ); } }