SwooleTW\Http\Server\Sandbox

Complexity

Total Complexity

45

Size/Duplication

Total Lines	376
Duplicated Lines	0 %

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	3
A	setFramework()	0	5	1
A	setBaseApp()	0	5	1
A	setRequest()	0	5	1
A	setInitialConfig()	0	3	1
A	getSnapshot()	0	3	1
A	terminate()	0	16	3
A	getFramework()	0	3	1
A	setInitialProviders()	0	9	3
A	getKernel()	0	3	1
A	getBaseApp()	0	3	1
A	prepareResponse()	0	9	1
A	initialize()	0	10	2
A	disable()	0	4	1
A	run()	0	13	3
A	getRequest()	0	3	1
A	setInstance()	0	13	2
A	enable()	0	8	2
B	prepareObResponse()	0	33	7
A	handleRequest()	0	7	2
A	getConfig()	0	3	1
A	removeRequest()	0	3	1
A	getApplication()	0	11	2
A	isLaravel()	0	3	1
A	setSnapshot()	0	5	1
A	resetApp()	0	11	1

<?php

namespace SwooleTW\Http\Server;

use Illuminate\Http\Request;
use Illuminate\Container\Container;
use SwooleTW\Http\Coroutine\Context;
use Illuminate\Contracts\Http\Kernel;
use Illuminate\Support\Facades\Facade;
use Illuminate\Support\ServiceProvider;
use SwooleTW\Http\Concerns\ResetApplication;
use SwooleTW\Http\Exceptions\SandboxException;
use Laravel\Lumen\Application as LumenApplication;
use Symfony\Component\HttpFoundation\StreamedResponse;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Illuminate\Contracts\Config\Repository as ConfigContract;
use Symfony\Component\HttpFoundation\Response as SymfonyResponse;

class Sandbox
{
    use ResetApplication;

The trait SwooleTW\Http\Concerns\ResetApplication requires some properties which are not provided by SwooleTW\Http\Server\Sandbox: $routes, $router

    /**
     * @var \Illuminate\Container\Container
     */
    protected $app;

    /**
     * @var string
     */
    protected $framework = 'laravel';

    /**
     * @var \Illuminate\Config\Repository
     */
    protected $config;

    /**
     * @var array
     */
    protected $providers = [];

    public function __construct($app = null, $framework = null)
    {
        if (! $app instanceof Container) {
            return;
        }

        $this->setBaseApp($app);
        $this->setFramework($framework ?: $this->framework);
        $this->initialize();
    }

    /**
     * Set framework type.
     */
    public function setFramework(string $framework)
    {
        $this->framework = $framework;

        return $this;
    }

    /**
     * Get framework type.
     */
    public function getFramework()
    {
        return $this->framework;
    }

    /**
     * Set a base application.
     *
     * @param \Illuminate\Container\Container
     */
    public function setBaseApp(Container $app)
    {
        $this->app = $app;

        return $this;
    }

    /**
     * Set current request.
     *
     * @param \Illuminate\Http\Request
     */
    public function setRequest(Request $request)
    {
        Context::setData('_request', $request);

        return $this;
    }

    /**
     * Set current snapshot.
     *
     * @param \Illuminate\Container\Container
     */
    public function setSnapshot(Container $snapshot)
    {
        Context::setApp($snapshot);

        return $this;
    }

    /**
     * Initialize based on base app.
     */
    public function initialize()
    {
        if (! $this->app instanceof Container) {

$this->app is always a sub-type of Illuminate\Container\Container. If $this->app can have other possible types, add them to src/Server/Sandbox.php:24.

            throw new SandboxException('A base app has not been set.');
        }

        $this->setInitialConfig();
        $this->setInitialProviders();

        return $this;
    }

    /**
     * Set initial config.
     */
    protected function setInitialConfig()
    {
        $this->config = clone $this->getBaseApp()->make('config');
    }

    /**
     * Get config snapshot.
     */
    public function getConfig()
    {
        return $this->config;
    }

    /**
     * Initialize customized service providers.
     */
    protected function setInitialProviders()
    {
        $app = $this->getBaseApp();
        $providers = $this->config->get('swoole_http.providers', []);

        foreach ($providers as $provider) {
            if (class_exists($provider)) {
                $provider = new $provider($app);
                $this->providers[get_class($provider)] = $provider;
            }
        }
    }

    /**
     * Get base application.
     *
     * @return \Illuminate\Container\Container
     */
    public function getBaseApp()
    {
        return $this->app;
    }

    /**
     * Get an application snapshot
     *
     * @return \Illuminate\Container\Container
     */
    public function getApplication()
    {
        $snapshot = $this->getSnapshot();
        if ($snapshot instanceOf Container) {
            return $snapshot;
        }

        $snapshot = clone $this->getBaseApp();
        $this->setSnapshot($snapshot);

        return $snapshot;
    }

    /**
     * Reset Laravel/Lumen Application.
     */
    public function resetApp(Container $app)
    {
        $this->resetConfigInstance($app);
        $this->resetSession($app);
        $this->resetCookie($app);
        $this->clearInstances($app);
        $this->bindRequest($app);
        $this->rebindKernelContainer($app);
        $this->rebindRouterContainer($app);
        $this->rebindViewContainer($app);
        $this->resetProviders($app);
    }

    /**
     * Run framework.
     *
     * @param \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
     */
    public function run(Request $request)
    {
        if (! $this->getSnapshot() instanceof Container) {
            throw new SandboxException('Sandbox is not enabled.');
        }

        $shouldUseOb = $this->config->get('swoole_http.ob_output', true);

        if ($shouldUseOb) {
            return $this->prepareObResponse($request);
        }

        return $this->prepareResponse($request);
    }

    /**
     * Handle request for non-ob case.
     *
     * @param \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
     */
    protected function prepareResponse(Request $request)
    {
        // handle request with laravel or lumen
        $response = $this->handleRequest($request);

        // process terminating logics
        $this->terminate($request, $response);

        return $response;
    }

    /**
     * Handle request for ob output.
     *
     * @param \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
     */
    protected function prepareObResponse(Request $request)
    {
        ob_start();

        // handle request with laravel or lumen
        $response = $this->handleRequest($request);

        // prepare content for ob
        $content = '';
        $isFile = false;
        if ($isStream = $response instanceof StreamedResponse) {
            $response->sendContent();
        } elseif ($response instanceof SymfonyResponse) {

$response is always a sub-type of Symfony\Component\HttpFoundation\Response.

            $content = $response->getContent();
        } elseif (! $isFile = $response instanceof BinaryFileResponse) {
            $content = (string) $response;
        }

        // process terminating logics
        $this->terminate($request, $response);

        // append ob content to response
        if (! $isFile && ob_get_length() > 0) {

The condition $isFile is always false.

            if ($isStream) {
                $response->output = ob_get_contents();

The property output does not seem to exist on Illuminate\Http\Response.

            } else {
                $response->setContent(ob_get_contents() . $content);
            }
        }

        ob_end_clean();

        return $response;
    }

    /**
     * Handle request through Laravel or Lumen.
     *
     * @param \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
     */
    protected function handleRequest(Request $request)
    {
        if ($this->isLaravel()) {
            return $this->getKernel()->handle($request);
        }

        return $this->getApplication()->dispatch($request);
    }

    /**
     * Get Laravel kernel.
     */
    protected function getKernel()
    {
        return $this->getApplication()->make(Kernel::class);
    }

    /**
     * Return if it's Laravel app.
     */
    protected function isLaravel()
    {
        return $this->framework === 'laravel';
    }

    /**
     * @param \Illuminate\Http\Request $request
     * @param \Illuminate\Http\Response $response
     */
    public function terminate(Request $request, $response)
    {
        if ($this->isLaravel()) {
            $this->getKernel()->terminate($request, $response);
        } else {
            $app = $this->getApplication();
            $reflection = new \ReflectionObject($app);

            $middleware = $reflection->getProperty('middleware');
            $middleware->setAccessible(true);

            $callTerminableMiddleware = $reflection->getMethod('callTerminableMiddleware');
            $callTerminableMiddleware->setAccessible(true);

            if (count($middleware->getValue($app)) > 0) {
                $callTerminableMiddleware->invoke($app, $response);
            }
        }
    }

    /**
     * Set laravel snapshot to container and facade.
     */
    public function enable()
    {
        if (! $this->config instanceof ConfigContract) {

$this->config is always a sub-type of Illuminate\Contracts\Config\Repository. If $this->config can have other possible types, add them to src/Server/Sandbox.php:34.

            throw new SandboxException('Please initialize after setting base app.');
        }

        $this->setInstance($app = $this->getApplication());
        $this->resetApp($app);
    }

    /**
     * Set original laravel app to container and facade.
     */
    public function disable()
    {
        Context::clear();
        $this->setInstance($this->getBaseApp());
    }

    /**
     * Replace app's self bindings.
     */
    public function setInstance(Container $app)
    {
        $app->instance('app', $app);
        $app->instance(Container::class, $app);

        if ($this->framework === 'lumen') {
            $app->instance(LumenApplication::class, $app);
        }

        Container::setInstance($app);
        Context::setApp($app);
        Facade::clearResolvedInstances();
        Facade::setFacadeApplication($app);

$app of type Illuminate\Container\Container is incompatible with the type Illuminate\Contracts\Foundation\Application expected by parameter $app of Illuminate\Support\Facades\Facade::setFacadeApplication().

    }

    /**
     * Get current snapshot.
     */
    public function getSnapshot()
    {
        return Context::getApp();
    }

    /**
     * Remove current request.
     */
    protected function removeRequest()
    {
        return Context::removeData('_request');

Are you sure the usage of SwooleTW\Http\Coroutine\Context::removeData('_request') targeting SwooleTW\Http\Coroutine\Context::removeData() seems to always return null.

    }

    /**
     * Get current request.
     */
    public function getRequest()
    {
        return Context::getData('_request');
    }
}