Gemz\Port\Port

Complexity

Total Complexity

34

Size/Duplication

Total Lines	248
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	for()	0	4	1
A	__construct()	0	4	1
A	sanitizeDomain()	0	8	2
A	getDomain()	0	4	1
A	getDefaultPorts()	0	4	1
A	getProtocols()	0	4	1
A	addResult()	0	8	1
A	check()	0	18	2
A	getUri()	0	4	1
A	checkPort()	0	16	3
A	checkNonUdpPort()	0	13	2
A	checkUdpPort()	0	37	4
A	useTcp()	0	6	1
A	useTls()	0	6	1
A	useUdp()	0	6	1
A	useSsl()	0	6	1
A	setTimeout()	0	6	1
A	setProtocol()	0	4	1
A	addPortWithProtocol()	0	4	1
B	resolvePorts()	0	25	7

<?php

namespace Gemz\Port;

use React\Promise\Deferred;
use React\Promise\PromiseInterface;
use React\Socket\Connector;
use React\EventLoop\Factory;
use React\EventLoop\LoopInterface;
use React\Socket\ConnectionInterface;
use Gemz\Port\Exceptions\InvalidArgument;

class Port
{
    const PROTOCOL_TCP = 'tcp';
    const PROTOCOL_UDP = 'udp';
    const PROTOCOL_SSL = 'ssl';
    const PROTOCOL_TLS = 'tls';

    /** @var string */
    protected $domain;

    /** @var string */
    protected $protocol = self::PROTOCOL_TCP;

    /** @var float */
    protected $timeout = 0.5;

    /** @var array */
    protected $protocols = ['tcp', 'tls', 'udp', 'ssl'];

    /**
     * @var array
     */
    protected $defaultPorts = [
        22 => 'tcp',
        80 => 'tcp',
        443 => 'tls',
        8080 => 'tcp',
        3306 => 'tcp',
    ];

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

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

    public static function for(string $domain): self
    {
        return new self($domain);
    }

    public function __construct(string $domain)
    {
        $this->domain = $this->sanitizeDomain($domain);
    }

    protected function sanitizeDomain(string $domain): string
    {
        if (empty($domain)) {
            throw InvalidArgument::domainIsNotValid($domain);
        }

        return str_replace(['http://', 'https://'], '', $domain);
    }

    public function getDomain(): string
    {
        return $this->domain;
    }

    public function getDefaultPorts(): array
    {
        return $this->defaultPorts;
    }

    public function getProtocols(): array
    {
        return $this->protocols;
    }

    protected function addResult(int $port, string $protocol, bool $isOpen): void
    {
        array_push($this->result, [
           'port' => $port,
           'protocol' => $protocol,
           'open' => $isOpen
        ]);
    }

    /**
     * @param array|int ...$ports
     *
     * @return array
     */
    public function check(...$ports): array
    {
        $this->resolvePorts($ports);

        foreach ($this->portsWithProtocol as $port => $protocol) {
            $this->checkPort($port, $protocol)
                ->then(
                    function () use ($port, $protocol) {
                        $this->addResult($port, $protocol, true);
                    },
                    function () use ($port, $protocol) {
                        $this->addResult($port, $protocol, false);
                    }
                );
        }

        return $this->result;
    }

    protected function getUri(string $protocol): string
    {
        return "{$protocol}://{$this->domain}";
    }

    protected function checkPort(int $port, string $protocol): PromiseInterface
    {
        $deferred = new Deferred();

        $portIsOpen = ($protocol == self::PROTOCOL_UDP)
            ? $this->checkUdpPort($port)
            : $portIsOpen = $this->checkNonUdpPort($port, $protocol);

        if ($portIsOpen) {
            $deferred->resolve();
        } else {
            $deferred->reject();
        }

        return $deferred->promise();
    }

    protected function checkNonUdpPort(int $port, string $protocol): bool
    {
        $handler = @fsockopen(
            $this->getUri($protocol), $port, $errno, $errstr, $this->timeout
        );

        if (is_resource($handler)) {
            fclose($handler);
            return true;
        }

        return false;
    }

    protected function checkUdpPort($port): bool
    {
        $handler = @fsockopen(
            $this->getUri(self::PROTOCOL_UDP), $port, $errno, $errstr, $this->timeout
        );

        if (! $handler) {
            return false;
        }

        socket_set_timeout($handler, $this->timeout);

        $write = fwrite($handler, "x00");

        if (! $write) {
            return false;
        }

        $startTime = time();

        $header = fread($handler, 1);

$header is not used, you could remove the assignment.

        $endTime = time();

        $timeDiff = $endTime - $startTime;


        if ($timeDiff >= $this->timeout) {
            fclose($handler);

            return true;
        }

        fclose($handler);

        return false;
    }

    public function useTcp(): self
    {
        $this->setProtocol(self::PROTOCOL_TCP);

        return $this;
    }

    public function useTls(): self
    {
        $this->setProtocol(self::PROTOCOL_TLS);

        return $this;
    }

    public function useUdp(): self
    {
        $this->setProtocol(self::PROTOCOL_UDP);

        return $this;
    }

    public function useSsl(): self
    {
        $this->setProtocol(self::PROTOCOL_SSL);

        return $this;
    }

    public function setTimeout(float $seconds): self
    {
        $this->timeout = $seconds;

        return $this;
    }

    protected function setProtocol(string $protocol): void
    {
        $this->protocol = $protocol;
    }

    protected function addPortWithProtocol(int $port, string $protocol): void
    {
        $this->portsWithProtocol[$port] = $protocol;
    }

    protected function resolvePorts(array $ports = []): void
    {
        if (empty($ports)) {
            $ports = $this->defaultPorts;
        }

        $ports = is_array($ports[0] ?? null)
            ? $ports[0]
            : $ports;

        foreach ($ports as $port => $protocol) {

            if (in_array($protocol, $this->protocols) && is_int($port)) {
                $this->addPortWithProtocol($port, $protocol);
                continue;
            }

            if (is_int($protocol)) {
                $this->addPortWithProtocol($protocol, $this->protocol);
                continue;
            }

            throw InvalidArgument::portOrProtocolIsNotValid($port, $protocol);
        }
    }
}