Spiral\Http\LegacyRrDispatcher

Complexity

Total Complexity

9

Size/Duplication

Total Lines	94
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	handleException()	0	28	3
A	canServe()	0	3	2
A	serve()	0	15	3
A	__construct()	0	10	1

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Http;

use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Spiral\Boot\DispatcherInterface;
use Spiral\Boot\EnvironmentInterface;
use Spiral\Boot\FinalizerInterface;
use Spiral\Core\FactoryInterface;
use Spiral\Debug\StateInterface;
use Spiral\Exceptions\HtmlHandler;
use Spiral\RoadRunner\PSR7Client;
use Spiral\Snapshots\SnapshotInterface;
use Spiral\Snapshots\SnapshotterInterface;

final class LegacyRrDispatcher implements DispatcherInterface
{
    /** @var EnvironmentInterface */
    private $env;

    /** @var FinalizerInterface */
    private $finalizer;

    /** @var ContainerInterface */
    private $container;

    /** @var FactoryInterface */
    private $factory;

    /**
     * @param EnvironmentInterface $env
     * @param FinalizerInterface   $finalizer
     * @param ContainerInterface   $container
     * @param FactoryInterface     $factory
     */
    public function __construct(
        EnvironmentInterface $env,
        FinalizerInterface $finalizer,
        ContainerInterface $container,
        FactoryInterface $factory
    ) {
        $this->env = $env;
        $this->finalizer = $finalizer;
        $this->container = $container;
        $this->factory = $factory;
    }

    /**
     * @inheritdoc
     */
    public function canServe(): bool
    {
        return (\PHP_SAPI === 'cli' && $this->env->get('RR_HTTP') !== null);
    }

    /**
     * @inheritdoc
     */
    public function serve(PSR7Client $client = null): void
    {
        // On demand to save some memory.

        $client = $client ?? $this->factory->make(PSR7Client::class);

        /** @var Http $http */
        $http = $this->container->get(Http::class);
        while ($request = $client->acceptRequest()) {

The method acceptRequest() does not exist on null.

            try {
                $client->respond($http->handle($request));
            } catch (\Throwable $e) {
                $this->handleException($client, $e);

It seems like $client can also be of type null; however, parameter $client of Spiral\Http\LegacyRrDispatcher::handleException() does only seem to accept Spiral\RoadRunner\PSR7Client, maybe add an additional type check?

            } finally {
                $this->finalizer->finalize(false);
            }
        }
    }

    /**
     * @param PSR7Client $client
     * @param \Throwable $e
     */
    protected function handleException(PSR7Client $client, \Throwable $e): void
    {
        $handler = new HtmlHandler();

        try {
            /** @var SnapshotInterface $snapshot */
            $snapshot = $this->container->get(SnapshotterInterface::class)->register($e);
            error_log($snapshot->getMessage());

            // on demand
            $state = $this->container->get(StateInterface::class);
            if ($state !== null) {
                $handler = $handler->withState($state);
            }
        } catch (\Throwable | ContainerExceptionInterface $se) {
            error_log((string)$e);
        }

        /** @var ResponseFactoryInterface $responseFactory */
        $responseFactory = $this->container->get(ResponseFactoryInterface::class);
        $response = $responseFactory->createResponse(500);

        // Reporting system (non handled) exception directly to the client
        $response->getBody()->write(
            $handler->renderException($e, HtmlHandler::VERBOSITY_VERBOSE)
        );

        $client->respond($response);
    }
}