JobQueueSecondTestQueue.php

Go to the documentation of this file.

<?php
 
class JobQueueSecondTestQueue extends JobQueue {
 
    private $mainQueue;
 
    private $debugQueue;
 
    private $onlyWriteToDebugQueue;
 
    protected function __construct( array $params ) {
        if ( !isset( $params['mainqueue'] ) ) {
            throw new MWException( "mainqueue parameter must be provided to the debug queue" );
        }
 
        if ( !isset( $params['debugqueue'] ) ) {
            throw new MWException( "debugqueue parameter must be provided to the debug queue" );
        }
 
        $conf = [ 'wiki' => $params['wiki'], 'type' => $params['type'] ];
        $this->mainQueue = JobQueue::factory( $params['mainqueue'] + $conf );
        $this->debugQueue = JobQueue::factory( $params['debugqueue'] + $conf );
        $this->onlyWriteToDebugQueue = isset( $params['readonly'] ) ? $params['readonly'] : false;
 
        // We need to construct parent after creating the main and debug queue
        // because super constructor calls some methods we delegate to the main queue.
        parent::__construct( $params );
    }
 
    protected function supportedOrders() {
        return $this->mainQueue->supportedOrders();
    }
 
    protected function optimalOrder() {
        return $this->mainQueue->optimalOrder();
    }
 
    protected function supportsDelayedJobs() {
        return $this->mainQueue->supportsDelayedJobs();
    }
 
    protected function doIsEmpty() {
        return $this->mainQueue->doIsEmpty();
    }
 
    protected function doGetSize() {
        return $this->mainQueue->doGetSize();
    }
 
    protected function doGetAcquiredCount() {
        return $this->mainQueue->doGetAcquiredCount();
    }
 
    protected function doGetDelayedCount() {
        return $this->mainQueue->doGetDelayedCount();
    }
 
    protected function doGetAbandonedCount() {
        return $this->mainQueue->doGetAbandonedCount();
    }
 
    protected function doBatchPush( array $jobs, $flags ) {
        if ( !$this->onlyWriteToDebugQueue ) {
            $this->mainQueue->doBatchPush( $jobs, $flags );
        }
 
        try {
            $this->debugQueue->doBatchPush( $jobs, $flags );
        } catch ( Exception $exception ) {
            MWExceptionHandler::logException( $exception );
        }
    }
 
    protected function doPop() {
        return $this->mainQueue->doPop();
    }
 
    protected function doAck( Job $job ) {
        return $this->mainQueue->doAck( $job );
    }
 
    protected function doDeduplicateRootJob( IJobSpecification $job ) {
        return $this->mainQueue->doDeduplicateRootJob( $job );
    }
 
    protected function doIsRootJobOldDuplicate( Job $job ) {
        return $this->mainQueue->doIsRootJobOldDuplicate( $job );
    }
 
    protected function getRootJobCacheKey( $signature ) {
        return $this->mainQueue->getRootJobCacheKey( $signature );
    }
 
    protected function doDelete() {
        return $this->mainQueue->doDelete();
    }
 
    protected function doWaitForBackups() {
        $this->mainQueue->doWaitForBackups();
    }
 
    protected function doFlushCaches() {
        $this->mainQueue->doFlushCaches();
    }
 
    public function getAllQueuedJobs() {
        return $this->mainQueue->getAllQueuedJobs();
    }
 
    public function getAllDelayedJobs() {
        return $this->mainQueue->getAllDelayedJobs();
    }
 
    public function getAllAcquiredJobs() {
        return $this->mainQueue->getAllAcquiredJobs();
    }
 
    public function getAllAbandonedJobs() {
        return $this->mainQueue->getAllAbandonedJobs();
    }
 
    public function getCoalesceLocationInternal() {
        return $this->mainQueue->getCoalesceLocationInternal();
    }
 
    protected function doGetSiblingQueuesWithJobs( array $types ) {
        return $this->mainQueue->doGetSiblingQueuesWithJobs( $types );
    }
 
    protected function doGetSiblingQueueSizes( array $types ) {
        return $this->mainQueue->doGetSiblingQueueSizes( $types );
    }
 
    protected function assertNotReadOnly() {
        $this->mainQueue->assertNotReadOnly();
    }
}