TtmServerFactory.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\TtmServer;
 
use InvalidArgumentException;
use TTMServer;
 
class TtmServerFactory {
    private array $configs;
    private ?string $default;
    private const TTMSERVER_CLASSES = [
        ReadableTtmServer::class,
        WritableTtmServer::class,
        SearchableTtmServer::class
    ];
 
    public function __construct( array $configs, ?string $default = null ) {
        $this->configs = $configs;
        $this->default = $default;
    }
 
    public function getNames(): array {
        $ttmServersIds = [];
        foreach ( $this->configs as $serviceId => $config ) {
            $type = $config['type'] ?? '';
            if ( $type === 'ttmserver' || $type === 'remote-ttmserver' ) {
                $ttmServersIds[] = $serviceId;
            }
 
            // Translation memory configuration may not define a type, in such
            // cases we determine whether the service is a TTM server using the
            // interfaces it implements.
            $serviceClass = $config['class'] ?? null;
            if ( $serviceClass !== null ) {
                foreach ( self::TTMSERVER_CLASSES as $ttmClass ) {
                    if ( $serviceClass instanceof $ttmClass ) {
                        $ttmServersIds[] = $serviceId;
                        break;
                    }
                }
            }
        }
        return $ttmServersIds;
    }
 
    public function has( string $name ): bool {
        $ttmServersIds = $this->getNames();
        return in_array( $name, $ttmServersIds );
    }
 
    public function create( string $name ): TTMServer {
        if ( !$this->has( $name ) ) {
            throw new ServiceCreationFailure( "No configuration for name '$name'" );
        }
 
        $config = $this->configs[$name];
        if ( !is_array( $config ) ) {
            throw new ServiceCreationFailure( "Invalid configuration for name '$name'" );
        }
 
        if ( isset( $config['class'] ) ) {
            $class = $config['class'];
 
            // TODO: Add a factory to create TTM server instances
            if ( in_array( $class, [ DatabaseTtmServer::class, 'DatabaseTTMServer', 'DatabaseTtmServer' ] ) ) {
                return new DatabaseTtmServer( $config );
            }
 
            return new $class( $config );
        } elseif ( isset( $config['type'] ) ) {
            $type = $config['type'];
            switch ( $type ) {
                case 'ttmserver':
                    return new DatabaseTtmServer( $config );
                case 'remote-ttmserver':
                    return new RemoteTTMServer( $config );
                default:
                    throw new ServiceCreationFailure( "Unknown type for name '$name': $type" );
            }
        }
 
        throw new ServiceCreationFailure( "Invalid configuration for name '$name': type not specified" );
    }
 
    public function getDefaultForQuerying(): ReadableTtmServer {
        if ( $this->default === null ) {
            return new FakeTtmServer();
        }
 
        if ( $this->configs[ $this->default ][ 'writable' ] ?? false ) {
            throw new InvalidArgumentException(
                "Default TTM service {$this->default} cannot be write only"
            );
        }
 
        $service = $this->create( $this->default );
 
        if ( $service instanceof ReadableTtmServer ) {
            return $service;
        }
 
        throw new InvalidArgumentException(
            "Default TTM service {$this->default} must implement ReadableTtmServer."
        );
    }
 
    public function getWritable(): array {
        $writableServers = $readOnlyServers = [];
        $ttmServerIds = $this->getNames();
 
        foreach ( $ttmServerIds as $serverId ) {
            $isWritable = $this->configs[ $serverId ][ 'writable' ] ?? null;
 
            if ( $isWritable ) {
                if ( $serverId === $this->default ) {
                    throw new InvalidArgumentException(
                        "Default TTM server {$this->default} cannot be write only"
                    );
                }
 
                $server = $this->create( $serverId );
                if ( !$server instanceof WritableTtmServer ) {
                    throw new InvalidArgumentException(
                        "Server '$serverId' marked writable does not implement WritableTtmServer interface"
                    );
                }
                $writableServers[ $serverId ] = $server;
            } elseif ( $isWritable === false ) {
                $readOnlyServers[] = $serverId;
            }
        }
 
        if ( $writableServers ) {
            return $writableServers;
        }
 
        // If there are no writable server, check and use the default server
        if ( $this->default ) {
            $defaultTtmServer = $this->create( $this->default );
 
            if ( $defaultTtmServer instanceof WritableTtmServer ) {
                if ( !in_array( $this->default, $readOnlyServers ) ) {
                    $writableServers[ $this->default ] = $defaultTtmServer;
                }
            }
 
            if ( $writableServers ) {
                return $writableServers;
            }
        }
 
        // Did not find any writable servers.
        return [];
    }
 
    public function getWriteOnly(): array {
        $ttmServerIds = $this->getNames();
        $writableServers = [];
        foreach ( $ttmServerIds as $serverId ) {
            if ( $this->configs[ $serverId ][ 'writable' ] ?? false ) {
                $server = $this->create( $serverId );
                if ( !$server instanceof WritableTtmServer ) {
                    throw new \InvalidArgumentException(
                        "Server '$serverId' marked writable does not implement WritableTtmServer interface"
                    );
                }
                $writableServers[ $serverId ] = $server;
            }
        }
 
        return $writableServers;
    }
}