ServiceContainer.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Services;
 
use InvalidArgumentException;
use RuntimeException;
use Wikimedia\Assert\Assert;
 
class ServiceContainer implements DestructibleService {
 
    private $services = [];
 
    private $serviceInstantiators = [];
 
    private $disabled = [];
 
    private $extraInstantiationParams;
 
    private $destroyed = false;
 
    public function __construct( array $extraInstantiationParams = [] ) {
        $this->extraInstantiationParams = $extraInstantiationParams;
    }
 
    public function destroy() {
        foreach ( $this->getServiceNames() as $name ) {
            $service = $this->peekService( $name );
            if ( $service !== null && $service instanceof DestructibleService ) {
                $service->destroy();
            }
        }
 
        $this->destroyed = true;
    }
 
    public function loadWiringFiles( array $wiringFiles ) {
        foreach ( $wiringFiles as $file ) {
            // the wiring file is required to return an array of instantiators.
            $wiring = require $file;
 
            Assert::postcondition(
                is_array( $wiring ),
                "Wiring file $file is expected to return an array!"
            );
 
            $this->applyWiring( $wiring );
        }
    }
 
    public function applyWiring( array $serviceInstantiators ) {
        Assert::parameterElementType( 'callable', $serviceInstantiators, '$serviceInstantiators' );
 
        foreach ( $serviceInstantiators as $name => $instantiator ) {
            $this->defineService( $name, $instantiator );
        }
    }
 
    public function importWiring( ServiceContainer $container, $skip = [] ) {
        $newInstantiators = array_diff_key(
            $container->serviceInstantiators,
            array_flip( $skip )
        );
 
        $this->serviceInstantiators = array_merge(
            $this->serviceInstantiators,
            $newInstantiators
        );
    }
 
    public function hasService( $name ) {
        return isset( $this->serviceInstantiators[$name] );
    }
 
    public function peekService( $name ) {
        if ( !$this->hasService( $name ) ) {
            throw new NoSuchServiceException( $name );
        }
 
        return isset( $this->services[$name] ) ? $this->services[$name] : null;
    }
 
    public function getServiceNames() {
        return array_keys( $this->serviceInstantiators );
    }
 
    public function defineService( $name, callable $instantiator ) {
        Assert::parameterType( 'string', $name, '$name' );
 
        if ( $this->hasService( $name ) ) {
            throw new ServiceAlreadyDefinedException( $name );
        }
 
        $this->serviceInstantiators[$name] = $instantiator;
    }
 
    public function redefineService( $name, callable $instantiator ) {
        Assert::parameterType( 'string', $name, '$name' );
 
        if ( !$this->hasService( $name ) ) {
            throw new NoSuchServiceException( $name );
        }
 
        if ( isset( $this->services[$name] ) ) {
            throw new CannotReplaceActiveServiceException( $name );
        }
 
        $this->serviceInstantiators[$name] = $instantiator;
        unset( $this->disabled[$name] );
    }
 
    public function disableService( $name ) {
        $this->resetService( $name );
 
        $this->disabled[$name] = true;
    }
 
    final protected function resetService( $name, $destroy = true ) {
        Assert::parameterType( 'string', $name, '$name' );
 
        $instance = $this->peekService( $name );
 
        if ( $destroy && $instance instanceof DestructibleService )  {
            $instance->destroy();
        }
 
        unset( $this->services[$name] );
        unset( $this->disabled[$name] );
    }
 
    public function getService( $name ) {
        if ( $this->destroyed ) {
            throw new ContainerDisabledException();
        }
 
        if ( isset( $this->disabled[$name] ) ) {
            throw new ServiceDisabledException( $name );
        }
 
        if ( !isset( $this->services[$name] ) ) {
            $this->services[$name] = $this->createService( $name );
        }
 
        return $this->services[$name];
    }
 
    private function createService( $name ) {
        if ( isset( $this->serviceInstantiators[$name] ) ) {
            $service = call_user_func_array(
                $this->serviceInstantiators[$name],
                array_merge( [ $this ], $this->extraInstantiationParams )
            );
            // NOTE: when adding more wiring logic here, make sure copyWiring() is kept in sync!
        } else {
            throw new NoSuchServiceException( $name );
        }
 
        return $service;
    }
 
    public function isServiceDisabled( $name ) {
        return isset( $this->disabled[$name] );
    }
}