DeferredUpdates.php

Go to the documentation of this file.

<?php
use Wikimedia\Rdbms\IDatabase;
use MediaWiki\MediaWikiServices;
use Wikimedia\Rdbms\LBFactory;
use Wikimedia\Rdbms\LoadBalancer;
 
class DeferredUpdates {
    private static $preSendUpdates = [];
    private static $postSendUpdates = [];
 
    const ALL = 0; // all updates; in web requests, use only after flushing the output buffer
    const PRESEND = 1; // for updates that should run before flushing output buffer
    const POSTSEND = 2; // for updates that should run after flushing output buffer
 
    const BIG_QUEUE_SIZE = 100;
 
    private static $executeContext;
 
    public static function addUpdate( DeferrableUpdate $update, $stage = self::POSTSEND ) {
        global $wgCommandLineMode;
 
        if (
            self::$executeContext &&
            self::$executeContext['stage'] >= $stage &&
            !( $update instanceof MergeableUpdate )
        ) {
            // This is a sub-DeferredUpdate; run it right after its parent update.
            // Also, while post-send updates are running, push any "pre-send" jobs to the
            // active post-send queue to make sure they get run this round (or at all).
            self::$executeContext['subqueue'][] = $update;
 
            return;
        }
 
        if ( $stage === self::PRESEND ) {
            self::push( self::$preSendUpdates, $update );
        } else {
            self::push( self::$postSendUpdates, $update );
        }
 
        // Try to run the updates now if in CLI mode and no transaction is active.
        // This covers scripts that don't/barely use the DB but make updates to other stores.
        if ( $wgCommandLineMode ) {
            self::tryOpportunisticExecute( 'run' );
        }
    }
 
    public static function addCallableUpdate(
        $callable, $stage = self::POSTSEND, $dbw = null
    ) {
        self::addUpdate( new MWCallableUpdate( $callable, wfGetCaller(), $dbw ), $stage );
    }
 
    public static function doUpdates( $mode = 'run', $stage = self::ALL ) {
        $stageEffective = ( $stage === self::ALL ) ? self::POSTSEND : $stage;
        // For ALL mode, make sure that any PRESEND updates added along the way get run.
        // Normally, these use the subqueue, but that isn't true for MergeableUpdate items.
        do {
            if ( $stage === self::ALL || $stage === self::PRESEND ) {
                self::execute( self::$preSendUpdates, $mode, $stageEffective );
            }
 
            if ( $stage === self::ALL || $stage == self::POSTSEND ) {
                self::execute( self::$postSendUpdates, $mode, $stageEffective );
            }
        } while ( $stage === self::ALL && self::$preSendUpdates );
    }
 
    private static function push( array &$queue, DeferrableUpdate $update ) {
        if ( $update instanceof MergeableUpdate ) {
            $class = get_class( $update ); // fully-qualified class
            if ( isset( $queue[$class] ) ) {
                $existingUpdate = $queue[$class];
                $existingUpdate->merge( $update );
                // Move the update to the end to handle things like mergeable purge
                // updates that might depend on the prior updates in the queue running
                unset( $queue[$class] );
                $queue[$class] = $existingUpdate;
            } else {
                $queue[$class] = $update;
            }
        } else {
            $queue[] = $update;
        }
    }
 
    protected static function execute( array &$queue, $mode, $stage ) {
        $services = MediaWikiServices::getInstance();
        $stats = $services->getStatsdDataFactory();
        $lbFactory = $services->getDBLoadBalancerFactory();
        $method = RequestContext::getMain()->getRequest()->getMethod();
 
        $ticket = $lbFactory->getEmptyTransactionTicket( __METHOD__ );
 
        $reportableError = null;
        $updates = $queue;
 
        // Keep doing rounds of updates until none get enqueued...
        while ( $updates ) {
            $queue = []; // clear the queue
 
            // Order will be DataUpdate followed by generic DeferrableUpdate tasks
            $updatesByType = [ 'data' => [], 'generic' => [] ];
            foreach ( $updates as $du ) {
                if ( $du instanceof DataUpdate ) {
                    $du->setTransactionTicket( $ticket );
                    $updatesByType['data'][] = $du;
                } else {
                    $updatesByType['generic'][] = $du;
                }
 
                $name = ( $du instanceof DeferrableCallback )
                    ? get_class( $du ) . '-' . $du->getOrigin()
                    : get_class( $du );
                $stats->increment( 'deferred_updates.' . $method . '.' . $name );
            }
 
            // Execute all remaining tasks...
            foreach ( $updatesByType as $updatesForType ) {
                foreach ( $updatesForType as $update ) {
                    self::$executeContext = [ 'stage' => $stage, 'subqueue' => [] ];
                    try {
                        $guiError = self::runUpdate( $update, $lbFactory, $mode, $stage );
                        $reportableError = $reportableError ?: $guiError;
                        // Do the subqueue updates for $update until there are none
                        while ( self::$executeContext['subqueue'] ) {
                            $subUpdate = reset( self::$executeContext['subqueue'] );
                            $firstKey = key( self::$executeContext['subqueue'] );
                            unset( self::$executeContext['subqueue'][$firstKey] );
 
                            if ( $subUpdate instanceof DataUpdate ) {
                                $subUpdate->setTransactionTicket( $ticket );
                            }
 
                            $guiError = self::runUpdate( $subUpdate, $lbFactory, $mode, $stage );
                            $reportableError = $reportableError ?: $guiError;
                        }
                    } finally {
                        // Make sure we always clean up the context.
                        // Losing updates while rewinding the stack is acceptable,
                        // losing updates that are added later is not.
                        self::$executeContext = null;
                    }
                }
            }
 
            $updates = $queue; // new snapshot of queue (check for new entries)
        }
 
        if ( $reportableError ) {
            throw $reportableError; // throw the first of any GUI errors
        }
    }
 
    private static function runUpdate(
        DeferrableUpdate $update, LBFactory $lbFactory, $mode, $stage
    ) {
        $guiError = null;
        try {
            if ( $mode === 'enqueue' && $update instanceof EnqueueableDataUpdate ) {
                // Run only the job enqueue logic to complete the update later
                $spec = $update->getAsJobSpecification();
                JobQueueGroup::singleton( $spec['wiki'] )->push( $spec['job'] );
            } elseif ( $update instanceof TransactionRoundDefiningUpdate ) {
                $update->doUpdate();
            } else {
                // Run the bulk of the update now
                $fnameTrxOwner = get_class( $update ) . '::doUpdate';
                $lbFactory->beginMasterChanges( $fnameTrxOwner );
                $update->doUpdate();
                $lbFactory->commitMasterChanges( $fnameTrxOwner );
            }
        } catch ( Exception $e ) {
            // Reporting GUI exceptions does not work post-send
            if ( $e instanceof ErrorPageError && $stage === self::PRESEND ) {
                $guiError = $e;
            }
            MWExceptionHandler::rollbackMasterChangesAndLog( $e );
 
            // VW-style hack to work around T190178, so we can make sure
            // PageMetaDataUpdater doesn't throw exceptions.
            if ( defined( 'MW_PHPUNIT_TEST' ) ) {
                throw $e;
            }
        }
 
        return $guiError;
    }
 
    public static function tryOpportunisticExecute( $mode = 'run' ) {
        // execute() loop is already running
        if ( self::$executeContext ) {
            return false;
        }
 
        // Avoiding running updates without them having outer scope
        if ( !self::areDatabaseTransactionsActive() ) {
            self::doUpdates( $mode );
            return true;
        }
 
        if ( self::pendingUpdatesCount() >= self::BIG_QUEUE_SIZE ) {
            // If we cannot run the updates with outer transaction context, try to
            // at least enqueue all the updates that support queueing to job queue
            self::$preSendUpdates = self::enqueueUpdates( self::$preSendUpdates );
            self::$postSendUpdates = self::enqueueUpdates( self::$postSendUpdates );
        }
 
        return !self::pendingUpdatesCount();
    }
 
    private static function enqueueUpdates( array $updates ) {
        $remaining = [];
 
        foreach ( $updates as $update ) {
            if ( $update instanceof EnqueueableDataUpdate ) {
                $spec = $update->getAsJobSpecification();
                JobQueueGroup::singleton( $spec['wiki'] )->push( $spec['job'] );
            } else {
                $remaining[] = $update;
            }
        }
 
        return $remaining;
    }
 
    public static function pendingUpdatesCount() {
        return count( self::$preSendUpdates ) + count( self::$postSendUpdates );
    }
 
    public static function getPendingUpdates( $stage = self::ALL ) {
        $updates = [];
        if ( $stage === self::ALL || $stage === self::PRESEND ) {
            $updates = array_merge( $updates, self::$preSendUpdates );
        }
        if ( $stage === self::ALL || $stage === self::POSTSEND ) {
            $updates = array_merge( $updates, self::$postSendUpdates );
        }
        return $updates;
    }
 
    public static function clearPendingUpdates() {
        self::$preSendUpdates = [];
        self::$postSendUpdates = [];
    }
 
    private static function areDatabaseTransactionsActive() {
        $lbFactory = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
        if ( $lbFactory->hasTransactionRound() || !$lbFactory->isReadyForRoundOperations() ) {
            return true;
        }
 
        $connsBusy = false;
        $lbFactory->forEachLB( function ( LoadBalancer $lb ) use ( &$connsBusy ) {
            $lb->forEachOpenMasterConnection( function ( IDatabase $conn ) use ( &$connsBusy ) {
                if ( $conn->writesOrCallbacksPending() || $conn->explicitTrxActive() ) {
                    $connsBusy = true;
                }
            } );
        } );
 
        return $connsBusy;
    }
}