Borobudur\Kernel\AbstractKernel

Complexity

Total Complexity

35

Size/Duplication

Total Lines	342
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	24

Importance

Changes	1
Bugs	0	Features	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	getEnvironmentManager()	0	4	1
A	getBundleManager()	0	4	1
A	getContainer()	0	4	1
A	setContainer()	0	5	1
A	getServiceLocator()	0	8	2
A	getMiddleware()	0	4	1
A	getRequest()	0	4	1
A	listen()	0	8	1
B	boot()	0	25	4
A	shutdown()	0	22	3
A	getKernelParameters()	0	17	2
A	setErrorHandler()	0	6	2
A	handleFatalError()	0	13	2
A	initialize()	0	6	2
A	registerProcessors()	0	4	1
A	importEnvironmentFile()	0	14	3
A	getKernelProcessors()	0	14	1
A	bootBundle()	0	7	2
A	sendException()	0	16	3

<?php
/*
 * This file is part of the Borobudur-Kernel package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Kernel;

use Borobudur\Config\FileLoader;
use Borobudur\DependencyInjection\ContainerBuilder;
use Borobudur\DependencyInjection\Definition;
use Borobudur\DependencyInjection\ParameterBag;
use Borobudur\EventDispatcher\Subscriber\SubscriberTrait;
use Borobudur\Http\Request;
use Borobudur\Http\Response;
use Borobudur\Kernel\Bundling\BundleManager;
use Borobudur\Kernel\Event\KernelEvent;
use Borobudur\Kernel\Event\ResponseExceptionEvent;
use Borobudur\Kernel\Exception\ErrorException;
use Borobudur\Kernel\Exception\FatalErrorException;
use Borobudur\Kernel\Exception\RuntimeException;
use Borobudur\Kernel\Middleware\MiddlewareContainer;
use Borobudur\Kernel\Processor\BundleProcessor;
use Borobudur\Kernel\Processor\ConfigurationProcessor;
use Borobudur\Kernel\Processor\ContainerProcessor;
use Borobudur\Kernel\Processor\EnvironmentProcessor;
use Borobudur\Kernel\Processor\ExtensionProcessor;
use Borobudur\Kernel\Processor\MiddlewareProcessor;
use Borobudur\Kernel\Processor\ProcessorInterface;
use Exception;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/7/15
 */
abstract class AbstractKernel implements KernelInterface
{
    use IdentifierTrait, SubscriberTrait;

    /**
     * @var ContainerBuilder
     */
    protected $container;

    /**
     * @var Request|null
     */
    protected $request;

    /**
     * @var KernelServiceLocator
     */
    protected $serviceLocator;

    /**
     * @var MiddlewareContainer
     */
    protected $middleware;

    /**
     * @var EnvironmentManager
     */
    protected $envManager;

    /**
     * @var BundleManager
     */
    protected $bundleManager;

    /**
     * @var bool
     */
    protected $booted = false;

    /**
     * @var string
     */
    protected $envFile = '.env';

    /**
     * @var array
     */
    private $envs = array();

    /**
     * Constructor.
     *
     * @param string|null $env Active environment.
     */
    final public function __construct($env = null)
    {
        $this->importEnvironmentFile();
        $this->envManager = new EnvironmentManager(env('APP_ENV', $env));
        $this->bundleManager = new BundleManager();
        $this->middleware = new MiddlewareContainer();
        error_reporting(0);

        set_error_handler(array($this, 'setErrorHandler'));
        register_shutdown_function(array($this, 'handleFatalError'));
    }

    /**
     * {@inheritdoc}
     */
    public function getEnvironmentManager()
    {
        return $this->envManager;
    }

    /**
     * {@inheritdoc}
     */
    public function getBundleManager()
    {
        return $this->bundleManager;
    }

    /**
     * {@inheritdoc}
     */
    public function getContainer()
    {
        return $this->container;
    }

    /**
     * {@inheritdoc}
     */
    public function setContainer(ContainerBuilder $container)
    {
        $this->container = $container;
        $this->serviceLocator = new KernelServiceLocator($container);
    }

    /**
     * {@inheritdoc}
     */
    public function getServiceLocator()
    {
        if (null === $this->serviceLocator) {
            throw new RuntimeException('Undefined service locator.');
        }

        return $this->serviceLocator;
    }

    /**
     * {@inheritdoc}
     */
    public function getMiddleware()
    {
        return $this->middleware;
    }

    /**
     * {@inheritdoc}
     */
    public function getRequest()
    {
        return $this->request;
    }

    /**
     * Listen request.
     *
     * @param Request $request
     *
     * @return $this
     */
    public function listen(Request $request)
    {
        $this->request = $request;

        $this->addListenerOnce(KernelEvents::BOOTED, array(new HttpKernelListener(), 'onBooted'));

        return $this;
    }

    /**
     * Boot kernel.
     */
    public function boot()
    {
        if (true === $this->booted) {
            return;
        }

        $this->booted = true;

        try {
            $this->initialize();

            // boot environment
            $this->getEnvironmentManager()->getEnvInstance()->boot();

            // boot bundle
            $this->bootBundle();
            $this->fireEvent(KernelEvents::BOOTED, new KernelEvent($this, $this->request));
        } catch (\Exception $e) {
            if (!$this->hasListener(KernelEvents::EXCEPTION)) {
                throw $e;
            }

            $this->sendException($e);
        }
    }

    /**
     * Shutdown current kernel.
     */
    public function shutdown()
    {
        if (false === $this->booted) {
            return;
        }

        $this->booted = false;

        // shutdown environment
        $this->getEnvironmentManager()->getEnvInstance()->shutdown();

        // shutdown bundle
        foreach ($this->getBundleManager()->all() as $bundle) {
            $bundle->shutdown();
            $bundle->setContainer(null);
        }

        $this->envs = array();
        $this->container = null;
        $this->request = null;
        $this->envManager = null;
    }

    /**
     * {@inheritdoc}
     */
    public function getKernelParameters()
    {
        $bundles = array();
        $env = $this->envManager->getEnvInstance();
        foreach ($this->getBundleManager()->all() as $name => $bundle) {
            $bundles[$name] = $bundle->getFullName();
        }

        return array_merge(
            array(
                'kernel.root_dir'    => $this->getPath(),
                'kernel.environment' => $this->envManager->getEnv(),
                'kernel.bundles'     => $bundles,
            ),
            $env->getEnvParameters()
        );
    }

    /**
     * Error handler.
     *
     * @param int    $severity
     * @param string $errMessage
     * @param string $file
     * @param int    $line
     */
    public function setErrorHandler($severity, $errMessage, $file, $line)
    {
        if (E_WARNING !== $severity) {
            $this->sendException(new ErrorException($errMessage, 0, $severity, $file, $line));
        }
    }

    /**
     * Handle fatal error.
     */
    public function handleFatalError()
    {
        $error = error_get_last();

        if( $error !== NULL) {
            $severity = $error["type"];
            $file = $error["file"];
            $line = $error["line"];
            $errMessage = $error["message"];

            $this->sendException(new FatalErrorException($errMessage, 0, $severity, $file, $line));
        }
    }

    /**
     * Initialize kernel.
     */
    protected function initialize()
    {
        foreach ($this->getKernelProcessors() as $processor) {
            $processor->initialize($this);
        }
    }

    /**
     * Register processors.
     *
     * @return array
     */
    protected function registerProcessors()
    {
        return array();
    }

    /**
     * Import environment file.
     */
    private function importEnvironmentFile()
    {
        $envFile = $this->getPath() . '/' . $this->envFile;
        if (file_exists($envFile)) {
            $loader = new FileLoader();
            $vars = $loader->import(new FileLoader\FileLocator($envFile));

            foreach ($vars as $name => $value) {
                $name = strtolower($name);
                $this->envs[$name] = $value;
                setenv($name, $value);
            }
        }
    }

    /**
     * Get kernel processors.
     *
     * @return ProcessorInterface[]
     */
    private function getKernelProcessors()
    {
        return array_merge(
            array(
                new EnvironmentProcessor(),
                new BundleProcessor(),
                new ContainerProcessor(),
                new ConfigurationProcessor($this->envs),
                new ExtensionProcessor(),
                new MiddlewareProcessor(),
            ),
            (array) $this->registerProcessors()
        );
    }

    /**
     * Boot bundle.
     */
    private function bootBundle()
    {
        foreach ($this->getBundleManager()->all() as $bundle) {
            $bundle->setContainer($this->container);
            $bundle->boot();
        }
    }

    /**
     * Send exception.
     *
     * @param Exception $e
     */
    private function sendException(Exception $e)
    {
        $evt = new ResponseExceptionEvent($this, $this->request);
        $evt->setException($e);
        $this->fireEvent(KernelEvents::EXCEPTION, $evt);

        if (false !== $this->booted) {
            if (!$evt->hasResponse()) {
                throw new RuntimeException(sprintf(
                    'There are no response found. Did you forgot add a return statement?'
                ));
            }

            $evt->getResponse()->send();
        }
    }
}