RenameuserSQL.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\RenameUser;
 
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\JobQueue\JobQueueGroup;
use MediaWiki\JobQueue\JobSpecification;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\Logging\ManualLogEntry;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\RecentChanges\RecentChange;
use MediaWiki\Specials\SpecialLog;
use MediaWiki\Status\Status;
use MediaWiki\Title\TitleFactory;
use MediaWiki\User\User;
use MediaWiki\User\UserFactory;
use Psr\Log\LoggerInterface;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IDBAccessObject;
use Wikimedia\Rdbms\SelectQueryBuilder;
 
class RenameuserSQL {
    public $old;
 
    public $new;
 
    public $uid;
 
    public $tables;
 
    public $tablesJob;
 
    public $checkIfUserExists;
 
    private $renamer;
 
    private $reason = '';
 
    private $debugPrefix = '';
 
    private $derived = false;
 
    // B/C constants for tablesJob field
    public const NAME_COL = 0;
    public const UID_COL  = 1;
    public const TIME_COL = 2;
 
    private $hookRunner;
 
    private $dbProvider;
 
    private $userFactory;
 
    private $jobQueueGroup;
 
    private $titleFactory;
 
    private $logger;
 
    private $updateRowsPerJob;
 
    public function __construct( string $old, string $new, int $uid, User $renamer, $options = [] ) {
        $services = MediaWikiServices::getInstance();
        $this->hookRunner = new HookRunner( $services->getHookContainer() );
        $this->dbProvider = $services->getConnectionProvider();
        $this->userFactory = $services->getUserFactory();
        $this->jobQueueGroup = $services->getJobQueueGroup();
        $this->titleFactory = $services->getTitleFactory();
        $this->logger = LoggerFactory::getInstance( 'Renameuser' );
 
        $config = $services->getMainConfig();
        $this->updateRowsPerJob = $config->get( MainConfigNames::UpdateRowsPerJob );
 
        $this->old = $old;
        $this->new = $new;
        $this->uid = $uid;
        $this->renamer = $renamer;
        $this->checkIfUserExists = true;
 
        if ( isset( $options['checkIfUserExists'] ) ) {
            $this->checkIfUserExists = $options['checkIfUserExists'];
        }
 
        if ( isset( $options['debugPrefix'] ) ) {
            $this->debugPrefix = $options['debugPrefix'];
        }
 
        if ( isset( $options['reason'] ) ) {
            $this->reason = $options['reason'];
        }
 
        if ( isset( $options['derived'] ) ) {
            $this->derived = $options['derived'];
        }
 
        $this->tables = []; // Immediate updates
        $this->tablesJob = []; // Slow updates
 
        $this->hookRunner->onRenameUserSQL( $this );
    }
 
    protected function debug( string $msg ) {
        if ( $this->debugPrefix ) {
            $msg = "{$this->debugPrefix}: $msg";
        }
        $this->logger->debug( $msg );
    }
 
    public function rename() {
        wfDeprecated( __METHOD__, '1.44' );
        return $this->renameUser()->isOK();
    }
 
    public function renameUser(): Status {
        $dbw = $this->dbProvider->getPrimaryDatabase();
        $atomicId = $dbw->startAtomic( __METHOD__, $dbw::ATOMIC_CANCELABLE );
 
        $this->hookRunner->onRenameUserPreRename( $this->uid, $this->old, $this->new );
 
        // Make sure the user exists if needed
        if ( $this->checkIfUserExists ) {
            // if derived is true and 'user' table is shared,
            // then 'user.user_name' should already be updated
            $userRenamed = $this->derived && self::isTableShared( 'user' );
            $currentName = $userRenamed ? $this->new : $this->old;
            if ( !$this->lockUserAndGetId( $currentName ) ) {
                $this->debug( "User $currentName does not exist, bailing out" );
                $dbw->cancelAtomic( __METHOD__, $atomicId );
 
                return Status::newFatal( 'renameusererrordoesnotexist', $this->new );
            }
        }
 
        // Grab the user's edit count before any updates are made; used later in a log entry
        $contribs = $this->userFactory->newFromId( $this->uid )->getEditCount();
 
        // Rename and touch the user before re-attributing edits to avoid users still being
        // logged in and making new edits (under the old name) while being renamed.
        $this->debug( "Starting rename of {$this->old} to {$this->new}" );
        if ( !$this->derived ) {
            $this->debug( "Rename of {$this->old} to {$this->new} will update shared tables" );
        }
        if ( $this->shouldUpdate( 'user' ) ) {
            $this->debug( "Updating user table for {$this->old} to {$this->new}" );
            $dbw->newUpdateQueryBuilder()
                ->update( 'user' )
                ->set( [ 'user_name' => $this->new, 'user_touched' => $dbw->timestamp() ] )
                ->where( [ 'user_name' => $this->old, 'user_id' => $this->uid ] )
                ->caller( __METHOD__ )->execute();
        } else {
            $this->debug( "Skipping user table for rename from {$this->old} to {$this->new}" );
        }
        if ( $this->shouldUpdate( 'actor' ) ) {
            $this->debug( "Updating actor table for {$this->old} to {$this->new}" );
            $dbw->newUpdateQueryBuilder()
                ->update( 'actor' )
                ->set( [ 'actor_name' => $this->new ] )
                ->where( [ 'actor_name' => $this->old, 'actor_user' => $this->uid ] )
                ->caller( __METHOD__ )->execute();
        } else {
            $this->debug( "Skipping actor table for rename from {$this->old} to {$this->new}" );
        }
 
        // If this user is renaming themself, make sure that code below uses a proper name
        if ( $this->renamer->getId() === $this->uid ) {
            $this->renamer->setName( $this->new );
        }
 
        // Reset token to break login with central auth systems.
        // Again, avoids user being logged in with old name.
        $user = $this->userFactory->newFromId( $this->uid );
 
        $user->load( IDBAccessObject::READ_LATEST );
        MediaWikiServices::getInstance()->getSessionManager()->invalidateSessionsForUser( $user );
 
        // Purge user cache
        $user->invalidateCache();
 
        // Update the block_target table rows if this user has a block in there.
        if ( $this->shouldUpdate( 'block_target' ) ) {
            $this->debug( "Updating block_target table for {$this->old} to {$this->new}" );
            $dbw->newUpdateQueryBuilder()
                ->update( 'block_target' )
                ->set( [ 'bt_user_text' => $this->new ] )
                ->where( [ 'bt_user' => $this->uid, 'bt_user_text' => $this->old ] )
                ->caller( __METHOD__ )->execute();
        } else {
            $this->debug( "Skipping block_target table for rename from {$this->old} to {$this->new}" );
        }
 
        // Update this users block/rights log. Ideally, the logs would be historical,
        // but it is really annoying when users have "clean" block logs by virtue of
        // being renamed, which makes admin tasks more of a pain...
        $oldTitle = $this->titleFactory->makeTitle( NS_USER, $this->old );
        $newTitle = $this->titleFactory->makeTitle( NS_USER, $this->new );
 
        // Exclude user renames per T200731
        $logTypesOnUser = array_diff( SpecialLog::getLogTypesOnUser(), [ 'renameuser' ] );
 
        if ( $this->shouldUpdate( 'logging' ) ) {
            $this->debug( "Updating logging table for {$this->old} to {$this->new}" );
            $dbw->newUpdateQueryBuilder()
                ->update( 'logging' )
                ->set( [ 'log_title' => $newTitle->getDBkey() ] )
                ->where( [
                    'log_type' => $logTypesOnUser,
                    'log_namespace' => NS_USER,
                    'log_title' => $oldTitle->getDBkey()
                ] )
                ->caller( __METHOD__ )->execute();
        } else {
            $this->debug( "Skipping logging table for rename from {$this->old} to {$this->new}" );
        }
 
        if ( $this->shouldUpdate( 'recentchanges' ) ) {
            $this->debug( "Updating recentchanges table for rename from {$this->old} to {$this->new}" );
            $dbw->newUpdateQueryBuilder()
                ->update( 'recentchanges' )
                ->set( [ 'rc_title' => $newTitle->getDBkey() ] )
                ->where( [
                    'rc_source' => RecentChange::SRC_LOG,
                    'rc_log_type' => $logTypesOnUser,
                    'rc_namespace' => NS_USER,
                    'rc_title' => $oldTitle->getDBkey()
                ] )
                ->caller( __METHOD__ )->execute();
        } else {
            $this->debug( "Skipping recentchanges table for rename from {$this->old} to {$this->new}" );
        }
 
        // Do immediate re-attribution table updates...
        foreach ( $this->tables as $table => $fieldSet ) {
            [ $nameCol, $userCol ] = $fieldSet;
            if ( $this->shouldUpdate( $table ) ) {
                $this->debug( "Updating {$table} table for rename from {$this->old} to {$this->new}" );
                $dbw->newUpdateQueryBuilder()
                    ->update( $table )
                    ->set( [ $nameCol => $this->new ] )
                    ->where( [ $nameCol => $this->old, $userCol => $this->uid ] )
                    ->caller( __METHOD__ )->execute();
            } else {
                $this->debug( "Skipping {$table} table for rename from {$this->old} to {$this->new}" );
            }
        }
 
        $jobs = []; // jobs for all tables
        // Construct jobqueue updates...
        // FIXME: if a bureaucrat renames a user in error, they
        // must be careful to wait until the rename finishes before
        // renaming back. This is due to the fact the job "queue"
        // is not really FIFO, so we might end up with a bunch of edits
        // randomly mixed between the two new names. Some sort of rename
        // lock might be in order...
        foreach ( $this->tablesJob as $table => $params ) {
            if ( !$this->shouldUpdate( $table ) ) {
                $this->debug( "Skipping {$table} table for rename from {$this->old} to {$this->new}" );
                continue;
            }
            $this->debug( "Updating {$table} table for rename from {$this->old} to {$this->new}" );
 
            $userTextC = $params[self::NAME_COL]; // some *_user_text column
            $userIDC = $params[self::UID_COL]; // some *_user column
            $timestampC = $params[self::TIME_COL]; // some *_timestamp column
 
            $res = $dbw->newSelectQueryBuilder()
                ->select( [ $timestampC ] )
                ->from( $table )
                ->where( [ $userTextC => $this->old, $userIDC => $this->uid ] )
                ->orderBy( $timestampC, SelectQueryBuilder::SORT_ASC )
                ->caller( __METHOD__ )->fetchResultSet();
 
            $jobParams = [
                'table' => $table,
                'column' => $userTextC,
                'uidColumn' => $userIDC,
                'timestampColumn' => $timestampC,
                'oldname' => $this->old,
                'newname' => $this->new,
                'userID' => $this->uid,
                // Timestamp column data for index optimizations
                'minTimestamp' => '0',
                'maxTimestamp' => '0',
                'count' => 0,
            ];
            // Unique column for replica lag avoidance
            if ( isset( $params['uniqueKey'] ) ) {
                $jobParams['uniqueKey'] = $params['uniqueKey'];
            }
 
            // Insert jobs into queue!
            foreach ( $res as $row ) {
                // Since the ORDER BY is ASC, set the min timestamp with first row
                if ( $jobParams['count'] === 0 ) {
                    $jobParams['minTimestamp'] = $row->$timestampC;
                }
                // Keep updating the last timestamp, so it should be correct
                // when the last item is added.
                $jobParams['maxTimestamp'] = $row->$timestampC;
                // Update row counter
                $jobParams['count']++;
                // Once a job has $wgUpdateRowsPerJob rows, add it to the queue
                if ( $jobParams['count'] >= $this->updateRowsPerJob ) {
                    $jobs[] = new JobSpecification( 'renameUserTable', $jobParams, [], $oldTitle );
                    $jobParams['minTimestamp'] = '0';
                    $jobParams['maxTimestamp'] = '0';
                    $jobParams['count'] = 0;
                }
            }
            // If there are any job rows left, add it to the queue as one job
            if ( $jobParams['count'] > 0 ) {
                $jobs[] = new JobSpecification( 'renameUserTable', $jobParams, [], $oldTitle );
            }
        }
 
        // Log it!
        $logEntry = new ManualLogEntry( 'renameuser', 'renameuser' );
        $logEntry->setPerformer( $this->renamer );
        $logEntry->setTarget( $oldTitle );
        $logEntry->setComment( $this->reason );
        $logEntry->setParameters( [
            '4::olduser' => $this->old,
            '5::newuser' => $this->new,
            '6::edits' => $contribs,
            'derived' => $this->derived
        ] );
        $logid = $logEntry->insert();
 
        // Insert any jobs as needed. If this fails, then an exception will be thrown and the
        // DB transaction will be rolled back. If it succeeds but the DB commit fails, then the
        // jobs will see that the transaction was not committed and will cancel themselves.
        $count = count( $jobs );
        if ( $count > 0 ) {
            $this->jobQueueGroup->push( $jobs );
            $this->debug( "Queued $count jobs for rename from {$this->old} to {$this->new}" );
        }
 
        // Commit the transaction
        $dbw->endAtomic( __METHOD__ );
 
        $fname = __METHOD__;
        $dbw->onTransactionCommitOrIdle(
            function () use ( $dbw, $logEntry, $logid, $fname ) {
                $dbw->startAtomic( $fname );
                // Clear caches and inform authentication plugins
                $user = $this->userFactory->newFromId( $this->uid );
                $user->load( IDBAccessObject::READ_LATEST );
                // Trigger the UserSaveSettings hook
                $user->saveSettings();
                $this->hookRunner->onRenameUserComplete( $this->uid, $this->old, $this->new );
                // Publish to RC
                $logEntry->publish( $logid );
                $dbw->endAtomic( $fname );
            },
            $fname
        );
 
        $this->debug( "Finished rename from {$this->old} to {$this->new}" );
 
        return Status::newGood();
    }
 
    private function lockUserAndGetId( $name ) {
        return (int)$this->dbProvider->getPrimaryDatabase()->newSelectQueryBuilder()
            ->select( 'user_id' )
            ->forUpdate()
            ->from( 'user' )
            ->where( [ 'user_name' => $name ] )
            ->caller( __METHOD__ )->fetchField();
    }
 
    private function shouldUpdate( string $table ) {
        return !$this->derived || !self::isTableShared( $table );
    }
 
    private static function isTableShared( string $table ) {
        global $wgSharedTables, $wgSharedDB;
        return $wgSharedDB && in_array( $table, $wgSharedTables, true );
    }
}