TranslationWebService.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\WebService;
 
use Exception;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
use ObjectCache;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
 
abstract class TranslationWebService implements LoggerAwareInterface {
    /* Public api */
 
    public static function factory( string $serviceName, array $config ): ?TranslationWebService {
        $handlers = [
            'microsoft' => [
                'class' => MicrosoftWebService::class,
                'deps' => [ 'HttpRequestFactory' ]
            ],
            'apertium' => [
                'class' => ApertiumWebService::class,
                'deps' => [ 'HttpRequestFactory' ]
            ],
            'yandex' => [
                'class' => YandexWebService::class,
                'deps' => [ 'HttpRequestFactory' ]
            ],
            'google' => [
                'class' => GoogleTranslateWebService::class,
                'deps' => [ 'HttpRequestFactory' ]
            ],
            'remote-ttmserver' => [
                'class' => RemoteTTMServerWebService::class
            ],
            'cxserver' => [
                'class' => ApertiumCxserverWebService::class,
                'deps' => [ 'HttpRequestFactory' ]
            ],
            'restbase' => [
                'class' => RESTBaseWebService::class,
                'deps' => [ 'HttpRequestFactory' ]
            ],
            'caighdean' => [
                'class' => CaighdeanWebService::class
            ],
            'mint' => [
                'class' => MintCxserverWebService::class,
                'deps' => [ 'HttpRequestFactory' ]
            ]
        ];
 
        if ( !isset( $config['timeout'] ) ) {
            $config['timeout'] = 3;
        }
 
        $serviceDetails = $handlers[$config['type']] ?? null;
        if ( $serviceDetails ) {
            $objectFactory = MediaWikiServices::getInstance()->getObjectFactory();
            $spec = [
                'class' => $serviceDetails['class'],
                'args' => [ $serviceName, $config ],
                'services' => $serviceDetails['deps'] ?? [],
            ];
 
            // @phan-suppress-next-line PhanTypeInvalidCallableArraySize due to annotations on createObject?
            $serviceObject = $objectFactory->createObject( $spec );
            if ( $serviceObject instanceof LoggerAwareInterface ) {
                $serviceObject->setLogger( LoggerFactory::getInstance( 'translationservices' ) );
            }
 
            return $serviceObject;
        }
 
        return null;
    }
 
    public function getName(): string {
        return $this->service;
    }
 
    public function getQueries( string $text, string $sourceLanguage, string $targetLanguage ): array {
        $from = $this->mapCode( $sourceLanguage );
        $to = $this->mapCode( $targetLanguage );
 
        try {
            return [ $this->getQuery( $text, $from, $to ) ];
        } catch ( TranslationWebServiceException $e ) {
            $this->reportTranslationServiceFailure( $e->getMessage() );
            return [];
        } catch ( TranslationWebServiceInvalidInputException $e ) {
            // Not much we can do about this, just ignore.
            return [];
        }
    }
 
    public function getResultData( TranslationQueryResponse $response ) {
        if ( $response->getStatusCode() !== 200 ) {
            $this->reportTranslationServiceFailure(
                'STATUS: ' . $response->getStatusMessage() . "\n" .
                'BODY: ' . $response->getBody()
            );
            return null;
        }
 
        try {
            return $this->parseResponse( $response );
        } catch ( TranslationWebServiceException $e ) {
            $this->reportTranslationServiceFailure( $e->getMessage() );
            return null;
        }
    }
 
    abstract public function getType(): string;
 
    /* Service api */
 
    abstract protected function mapCode( string $code ): string;
 
    abstract protected function doPairs(): array;
 
    abstract protected function getQuery(
        string $text, string $sourceLanguage, string $targetLanguage
    ): TranslationQuery;
 
    abstract protected function parseResponse( TranslationQueryResponse $response );
 
    /* Default implementation */
 
    protected $service;
    protected $config;
    protected $logger;
 
    public function __construct( string $service, array $config ) {
        $this->service = $service;
        $this->config = $config;
    }
 
    public function isSupportedLanguagePair( string $sourceLanguage, string $targetLanguage ): bool {
        $pairs = $this->getSupportedLanguagePairs();
        $from = $this->mapCode( $sourceLanguage );
        $to = $this->mapCode( $targetLanguage );
 
        return isset( $pairs[$from][$to] );
    }
 
    protected function getSupportedLanguagePairs(): array {
        $cache = ObjectCache::getInstance( CACHE_ANYTHING );
 
        return $cache->getWithSetCallback(
            $cache->makeKey( 'translate-tmsug-pairs-' . $this->service ),
            $cache::TTL_DAY,
            function ( &$ttl ) use ( $cache ) {
                try {
                    $pairs = $this->doPairs();
                } catch ( Exception $e ) {
                    $pairs = [];
                    $this->reportTranslationServiceFailure( $e->getMessage() );
                    $ttl = $cache::TTL_UNCACHEABLE;
                }
 
                return $pairs;
            }
        );
    }
 
    protected function wrapUntranslatable( string $text ): string {
        $text = str_replace( "\n", '!N!', $text );
        $pattern = '~%[^% ]+%|\$\d|{VAR:[^}]+}|{?{(PLURAL|GRAMMAR|GENDER):[^|]+\||%(\d\$)?[sd]~';
        $wrap = '<span class="notranslate" translate="no">\0</span>';
        return preg_replace( $pattern, $wrap, $text );
    }
 
    protected function unwrapUntranslatable( string $text ): string {
        $text = str_replace( '!N!', "\n", $text );
        $pattern = '~<span class="notranslate" translate="no">(.*?)</span>~';
        return preg_replace( $pattern, '\1', $text );
    }
 
    /* Failure handling and suspending */
 
    public function setLogger( LoggerInterface $logger ): void {
        $this->logger = $logger;
    }
 
    protected $serviceFailureCount = 5;
    protected $serviceFailurePeriod = 900;
 
    public function checkTranslationServiceFailure(): bool {
        $service = $this->service;
        $cache = ObjectCache::getInstance( CACHE_ANYTHING );
 
        $key = $cache->makeKey( "translate-service-$service" );
        $value = $cache->get( $key );
        if ( !is_string( $value ) ) {
            return false;
        }
 
        [ $count, $failed ] = explode( '|', $value, 2 );
        $count = (int)$count;
        $failed = (int)$failed;
        $now = (int)wfTimestamp();
 
        if ( $failed + ( 2 * $this->serviceFailurePeriod ) < $now ) {
            if ( $count >= $this->serviceFailureCount ) {
                $this->logger->warning( "Translation service $service (was) restored" );
            }
            $cache->delete( $key );
 
            return false;
        } elseif ( $failed + $this->serviceFailurePeriod < $now ) {
            /* We are in suspicious mode and one failure is enough to update
             * failed timestamp. If the service works however, let's use it.
             * Previous failures are forgotten after another failure period
             * has passed */
            return false;
        }
 
        // Check the failure count against the limit
        return $count >= $this->serviceFailureCount;
    }
 
    protected function reportTranslationServiceFailure( string $msg ): void {
        $service = $this->service;
        $this->logger->warning( "Translation service $service problem: $msg" );
 
        $cache = ObjectCache::getInstance( CACHE_ANYTHING );
        $key = $cache->makeKey( "translate-service-$service" );
 
        $value = $cache->get( $key );
        if ( !is_string( $value ) ) {
            $count = 0;
        } else {
            [ $count, ] = explode( '|', $value, 2 );
        }
 
        $count++;
        $failed = wfTimestamp();
        $cache->set(
            $key,
            "$count|$failed",
            $this->serviceFailurePeriod * 5
        );
 
        if ( $count === $this->serviceFailureCount ) {
            $this->logger->error( "Translation service $service suspended" );
        } elseif ( $count > $this->serviceFailureCount ) {
            $this->logger->warning( "Translation service $service still suspended" );
        }
    }
}