TTMServerMessageUpdateJob.php

Go to the documentation of this file.

<?php
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
 
class TTMServerMessageUpdateJob extends Job {
    protected const MAX_ERROR_RETRY = 4;
 
    protected const WRITE_BACKOFF_EXPONENT = 7;
    private $jobQueueGroup;
 
    public static function newJob( MessageHandle $handle, $command ) {
        $job = new self( $handle->getTitle(), [ 'command' => $command ] );
 
        return $job;
    }
 
    public function __construct( $title, $params = [] ) {
        parent::__construct(
            __CLASS__,
            $title,
            $params + [
                'command' => 'rebuild',
                'service' => null,
                'errorCount' => 0,
            ]
        );
 
        $this->jobQueueGroup = MediaWikiServices::getInstance()->getJobQueueGroup();
    }
 
    public function run() {
        global $wgTranslateTranslationServices,
            $wgTranslateTranslationDefaultService;
 
        $service = $this->params['service'];
        $writeToMirrors = false;
 
        if ( $service === null ) {
            $service = $wgTranslateTranslationDefaultService;
            $writeToMirrors = true;
        }
 
        if ( !isset( $wgTranslateTranslationServices[$service] ) ) {
            LoggerFactory::getInstance( 'TTMServerUpdates' )->warning(
                'Received update job for a an unknown service {service}.',
                [ 'service' => $service ]
            );
            return true;
        }
 
        $services = [ $service ];
        if ( $writeToMirrors ) {
            $config = $wgTranslateTranslationServices[$service];
            $server = TTMServer::factory( $config );
            $services = array_unique(
                array_merge( $services, $server->getMirrors() )
            );
        }
 
        foreach ( $services as $service ) {
            $this->runCommandWithRetry( $service );
        }
        return true;
    }
 
    public function allowRetries() {
        return false;
    }
 
    private function runCommandWithRetry( $serviceName ) {
        global $wgTranslateTranslationServices;
 
        if ( !isset( $wgTranslateTranslationServices[$serviceName] ) ) {
            LoggerFactory::getInstance( 'TTMServerUpdates' )->warning(
                'Cannot write to {service}: service is unknown.',
                [ 'service' => $serviceName ]
            );
            return;
        }
        $ttmserver = TTMServer::factory( $wgTranslateTranslationServices[$serviceName] );
 
        if ( $serviceName === null || !( $ttmserver instanceof WritableTTMServer ) ) {
            LoggerFactory::getInstance( 'TTMServerUpdates' )->warning(
                'Received update job for a service that does not implement ' .
                'WritableTTMServer, please check config for {service}.',
                [ 'service' => $serviceName ]
            );
            return;
        }
 
        try {
            $this->runCommand( $ttmserver );
        } catch ( Exception $e ) {
            $this->requeueError( $serviceName, $e );
        }
    }
 
    private function requeueError( $serviceName, $e ) {
        LoggerFactory::getInstance( 'TTMServerUpdates' )->warning(
            'Exception thrown while running {command} on ' .
            'service {service}: {errorMessage}',
            [
                'command' => $this->params['command'],
                'service' => $serviceName,
                'errorMessage' => $e->getMessage(),
                'exception' => $e,
            ]
        );
        if ( $this->params['errorCount'] >= self::MAX_ERROR_RETRY ) {
            LoggerFactory::getInstance( 'TTMServerUpdates' )->warning(
                'Dropping failing job {command} for service {service} ' .
                'after repeated failure',
                [
                    'command' => $this->params['command'],
                    'service' => $serviceName,
                ]
            );
            return;
        }
 
        $delay = self::backoffDelay( $this->params['errorCount'] );
        $job = clone $this;
        $job->params['errorCount']++;
        $job->params['service'] = $serviceName;
        $job->setDelay( $delay );
        LoggerFactory::getInstance( 'TTMServerUpdates' )->info(
            'Update job reported failure on service {service}. ' .
            'Requeueing job with delay of {delay}.',
            [
                'service' => $serviceName,
                'delay' => $delay
            ]
        );
        $this->resend( $job );
    }
 
    protected function resend( self $job ) {
        $this->jobQueueGroup->push( $job );
    }
 
    private function runCommand( WritableTTMServer $ttmserver ) {
        $handle = $this->getHandle();
        $command = $this->params['command'];
 
        if ( $command === 'delete' ) {
            $this->updateItem( $ttmserver, $handle, null, false );
        } elseif ( $command === 'rebuild' ) {
            $this->updateMessage( $ttmserver, $handle );
        } elseif ( $command === 'refresh' ) {
            $this->updateTranslation( $ttmserver, $handle );
        }
    }
 
    protected function getHandle() {
        return new MessageHandle( $this->title );
    }
 
    protected function getTranslation( MessageHandle $handle ) {
        return TranslateUtils::getMessageContent(
            $handle->getKey(),
            $handle->getCode(),
            $handle->getTitle()->getNamespace()
        );
    }
 
    private function updateMessage( WritableTTMServer $ttmserver, MessageHandle $handle ) {
        // Base page update, e.g. group change. Update everything.
        $translations = TranslateUtils::getTranslations( $handle );
        foreach ( $translations as $page => $data ) {
            $tTitle = Title::makeTitle( $this->title->getNamespace(), $page );
            $tHandle = new MessageHandle( $tTitle );
            $this->updateItem( $ttmserver, $tHandle, $data[0], $tHandle->isFuzzy() );
        }
    }
 
    private function updateTranslation( WritableTTMServer $ttmserver, MessageHandle $handle ) {
        // Update only this translation
        $translation = $this->getTranslation( $handle );
        $this->updateItem( $ttmserver, $handle, $translation, $handle->isFuzzy() );
    }
 
    private function updateItem( WritableTTMServer $ttmserver, MessageHandle $handle, $text, $fuzzy ) {
        if ( $fuzzy ) {
            $text = null;
        }
        $ttmserver->update( $handle, $text );
    }
 
    public function setDelay( $delay ) {
        $jobQueue = $this->jobQueueGroup->get( $this->getType() );
        if ( !$delay || !$jobQueue->delayedJobsEnabled() ) {
            return;
        }
        $oldTime = $this->getReleaseTimestamp();
        $newTime = time() + $delay;
        if ( $oldTime !== null && $oldTime >= $newTime ) {
            return;
        }
        $this->params[ 'jobReleaseTimestamp' ] = $newTime;
    }
 
    public static function backoffDelay( $errorCount ) {
        return ceil( pow(
            2,
            static::WRITE_BACKOFF_EXPONENT + rand( 0, min( $errorCount, 4 ) )
        ) );
    }
}