Carno\Web\Handlers\IngressWrapper

Complexity

Total Complexity

5

Size/Duplication

Total Lines	80
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	inbound()	0	10	1
A	__construct()	0	4	1
A	exception()	0	11	2
A	outbound()	0	5	1

<?php
/**
 * Controller invoker
 * User: moyo
 * Date: 2018/5/29
 * Time: 12:15 PM
 */

namespace Carno\Web\Handlers;

use Carno\Chain\Layered;
use function Carno\Coroutine\async;
use Carno\Coroutine\Context;
use function Carno\Coroutine\race;
use function Carno\Coroutine\timeout;
use Carno\HTTP\Server\Connection;
use Carno\HTTP\Standard\Response;
use Carno\HTTP\Standard\ServerRequest;
use Carno\Promise\Promised;
use Carno\Web\Chips\Server\BodyParser;
use Carno\Web\Dispatcher;
use Carno\Web\Exception\HTTPException;
use Carno\Web\Options;
use Throwable;

class IngressWrapper implements Layered
{
    use BodyParser;

    /**
     * operated connection
     */
    public const CONNECTION = 'http-session';

    /**
     * request/response for connection
     */
    public const REQUESTING = 'http-request';
    public const RESPONDING = 'http-response';

    /**
     * @var Dispatcher
     */
    private $dispatcher = null;

    /**
     * @var Options
     */
    private $options = null;

    /**
     * IngressWrapper constructor.
     * @param Dispatcher $dispatcher
     * @param Options $options
     */
    public function __construct(Dispatcher $dispatcher, Options $options = null)
    {
        $this->dispatcher = $dispatcher;
        $this->options = $options ?? new Options;
    }

    /**
     * @param Connection $ingress
     * @param Context $ctx
     * @return Promised
     */
    public function inbound($ingress, Context $ctx) : Promised
    {
        $ctx->set(self::CONNECTION, $ingress);
        $ctx->set(self::REQUESTING, $request = $ingress->request());

        $this->parsedBody($request);

        return race(async(function (ServerRequest $sr) {
            return $this->dispatcher->invoke($sr);
        }, $ctx, $request), timeout($this->options->ttExec));
    }

    /**
     * @param Response $response
     * @param Context $ctx
     * @return Response
     */
    public function outbound($response, Context $ctx) : Response
    {
        $ctx->set(self::RESPONDING, $response);

        return $response;
    }

    /**
     * @param Throwable $e
     * @param Context $ctx
     */
    public function exception(Throwable $e, Context $ctx) : void
    {
        if ($e instanceof HTTPException) {
            $response = new Response($e->getCode(), [], $e->getMessage());
        } else {
            $response = new Response(500, [], get_class($e));
        }

        $this->outbound($response, $ctx);

        throw $e;
    }
}