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] );
    }
}