PoolCounter.php

Go to the documentation of this file.

<?php

abstract class PoolCounter {

        /* Return codes */
        const LOCKED   = 1; /* Lock acquired */
        const RELEASED = 2; /* Lock released */
        const DONE     = 3; /* Another worker did the work for you */

        const ERROR      = -1; /* Indeterminate error */
        const NOT_LOCKED = -2; /* Called release() with no lock held */
        const QUEUE_FULL = -3; /* There are already maxqueue workers on this lock */
        const TIMEOUT    = -4; /* Timeout exceeded */
        const LOCK_HELD  = -5; /* Cannot acquire another lock while you have one lock held */

        abstract function acquireForMe();

        abstract function acquireForAnyone();

        abstract function release();

        protected $key, $workers, $maxqueue, $timeout;

        public static function factory( $type, $key ) {
                global $wgPoolCounterConf;
                if ( !isset( $wgPoolCounterConf[$type] ) ) {
                        return new PoolCounter_Stub;
                }
                $conf = $wgPoolCounterConf[$type];
                $class = $conf['class'];

                return new $class( $conf, $type, $key );
        }

        protected function __construct( $conf, $type, $key ) {
                $this->key = $key;
                $this->workers  = $conf['workers'];
                $this->maxqueue = $conf['maxqueue'];
                $this->timeout  = $conf['timeout'];
        }
}

class PoolCounter_Stub extends PoolCounter {

        function acquireForMe() {
                return Status::newGood( PoolCounter::LOCKED );
        }

        function acquireForAnyone() {
                return Status::newGood( PoolCounter::LOCKED );
        }

        function release() {
                return Status::newGood( PoolCounter::RELEASED );
        }

        public function __construct() {
                /* No parameters needed */
        }
}

abstract class PoolCounterWork {
        protected $cacheable = false; //Does this override getCachedWork() ?

        abstract function doWork();

        function getCachedWork() {
                return false;
        }

        function fallback() {
                return false;
        }

        function error( $status ) {
                return false;
        }

        function logError( $status ) {
                wfDebugLog( 'poolcounter', $status->getWikiText() );
        }

        function execute( $skipcache = false ) {
                if ( $this->cacheable && !$skipcache ) {
                        $status = $this->poolCounter->acquireForAnyone();
                } else {
                        $status = $this->poolCounter->acquireForMe();
                }

                if ( !$status->isOK() ) {
                        // Respond gracefully to complete server breakage: just log it and do the work
                        $this->logError( $status );
                        return $this->doWork();
                }

                switch ( $status->value ) {
                        case PoolCounter::LOCKED:
                                $result = $this->doWork();
                                $this->poolCounter->release();
                                return $result;

                        case PoolCounter::DONE:
                                $result = $this->getCachedWork();
                                if ( $result === false ) {
                                        /* That someone else work didn't serve us.
                                         * Acquire the lock for me
                                         */
                                        return $this->execute( true );
                                }
                                return $result;

                        case PoolCounter::QUEUE_FULL:
                        case PoolCounter::TIMEOUT:
                                $result = $this->fallback();

                                if ( $result !== false ) {
                                        return $result;
                                }
                                /* no break */

                        /* These two cases should never be hit... */
                        case PoolCounter::ERROR:
                        default:
                                $errors = array( PoolCounter::QUEUE_FULL => 'pool-queuefull', PoolCounter::TIMEOUT => 'pool-timeout' );

                                $status = Status::newFatal( isset( $errors[$status->value] ) ? $errors[$status->value] : 'pool-errorunknown' );
                                $this->logError( $status );
                                return $this->error( $status );
                }
        }

        function __construct( $type, $key ) {
                $this->poolCounter = PoolCounter::factory( $type, $key );
        }
}