AbstractSocket::setBlocking() - Code Metrics - Inspection of "refactored some things, init websockets" - hfw/socket - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( b4e552...a91d54 )

by y
created 2020-03-02 13:52 UTC
AbstractSocket::setBlocking() A

↳ Parent: AbstractSocket
Complexity

Conditions	3
Paths	4
Size

Total Lines	11
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes	3
Bugs	0	Features	0
Metric	Value
cc	3
eloc	7
c	3
b	0
f	0
nc	4
nop	1
dl	0
loc	11
rs	10
<?php

namespace Helix\Socket;

use InvalidArgumentException;

/**
 * Abstract parent to all sockets.
 */
abstract class AbstractSocket implements SocketInterface {

    /**
     * The socket's address family.
     *
     * @var int `AF_*`
     */
    protected $domain;

    /**
     * The socket's protocol.
     *
     * @var int
     */
    protected $protocol;

    /**
     * The underlying PHP resource.
     *
     * @var resource
     */
    protected $resource;

    /**
     * **Variadic.**
     * Creates an instance of the called class.
     *
     * @link https://php.net/socket_create
     *
     * @param int $domain `AF_*`
     * @param array $extra Variadic constructor arguments.
     * @return static
     * @throws Error
     */
    public static function create ($domain = AF_INET, ...$extra) {
        if (!$resource = @socket_create($domain, static::getType(), 0)) { // auto-protocol
            throw new Error; // reliable errno
        }
        return new static(...array_merge([$resource], $extra));
        return new static(/** @scrutinizer ignore-type */ ...array_merge([$resource], $extra));
    }

    /**
     * Selects instances.
     *
     * @link https://php.net/socket_select
     *
     * @param SocketInterface[] $read
     * @param SocketInterface[] $write
     * @param SocketInterface[] $except
     * @param float|null $timeout Maximum seconds to block. `NULL` blocks forever.
     * @return int
     * @throws Error
     */
    public static function select (array &$read, array &$write, array &$except, $timeout = null) {
        $getResource = function(SocketInterface $socket) {
            return $socket->getResource();
        };
        // PHP 7.1 broke by-reference array_walk_recursive, use array_map instead.
        $r = array_map($getResource, $read);
        $w = array_map($getResource, $write);
        $e = array_map($getResource, $except);
        $usec = (int)(fmod($timeout, 1) * 1000000); // ignored if timeout is null
        $count = @socket_select($r, $w, $e, $timeout, $usec);
        $count = @socket_select($r, $w, $e, /** @scrutinizer ignore-type */ $timeout, $usec);
        if ($count === false) {
            $read = $write = $except = [];
            throw new Error;
        }
        $read = array_intersect_key($read, $r);
        $write = array_intersect_key($write, $w);
        $except = array_intersect_key($except, $e);
        return $count;
    }

    /**
     * Validates and sets the underlying socket resource.
     *
     * The resource must be open, of the correct type, and have no pending errors.
     *
     * @param resource $resource PHP socket resource.
     * @throws InvalidArgumentException Not a socket resource, or the socket is of the wrong type.
     * @throws Error (`SOCKET_EBADFD`) There was a pending error on the socket.
     * The preexisting error code is set as the exception's extra data.
     */
    public function __construct ($resource) {
        if (!is_resource($resource) or get_resource_type($resource) !== 'Socket') {
            throw new InvalidArgumentException('Expected an open socket resource.', SOCKET_EBADF);
        }
        elseif (socket_get_option($resource, SOL_SOCKET, SO_TYPE) !== static::getType()) {
            throw new InvalidArgumentException('The given socket resource is of the wrong type for ' . get_class(), SOCKET_ESOCKTNOSUPPORT);
        }
        elseif ($errno = Error::getLast($resource)) {
            $error = new Error(SOCKET_EBADFD);
            $error->setExtra($errno);
            throw $error;
        }
        $this->resource = $resource;
        $this->domain = $this->getOption(self::SO_DOMAIN);
        $this->protocol = $this->getOption(self::SO_PROTOCOL);
    }

    /**
     * Closes the socket if it's open.
     */
    public function __destruct () {
        $this->close();
    }

    /**
     * Blocks until the socket becomes available on a given channel.
     *
     * Throws if the underlying resource has a pending error (non-blocking).
     *
     * @see isReady()
     *
     * @param int $channel `SocketInterface` channel constant.
     * @return $this
     * @throws Error
     */
    public function await ($channel) {
        $select = [$channel => [$this->resource]];
        $count = @socket_select($select[self::CH_READ], $select[self::CH_WRITE], $select[self::CH_EXCEPT], null);
        if (!$count) {
            throw new Error($this->resource);
        }
        return $this;
    }

    /**
     * Closes the socket if it's open.
     * I/O channels should be shut down before calling this.
     *
     * @link https://php.net/socket_close
     *
     * @see onClose()
     *
     * @return $this
     */
    public function close () {
        // socket_close() never errors, but we guard anyway to prevent
        // a redundant call to onClose(), and an incorrect call to it if
        // the constructor failed and the destructor is calling this.
        if ($this->isOpen()) {
            $this->onClose();
            socket_close($this->resource);
        }
        return $this;
    }

    /**
     * @return int
     */
    final public function getDomain () {
        return $this->domain;
    }

    /**
     * @return int
     */
    final public function getId () {
        return (int)$this->resource;
    }

    /**
     * Retrieves a socket-level option.
     *
     * @link https://php.net/socket_get_option
     *
     * @param int $option `SO_*` option constant.
     * @throws Error
     * @return mixed The option's value. This is never `false`.
     */
    public function getOption ($option) {
        $value = @socket_get_option($this->resource, SOL_SOCKET, $option);
        if ($value === false) {
            throw new Error($this->resource, SOCKET_EINVAL);
        }
        return $value;
    }

    /**
     * @return int
     */
    final public function getProtocol () {
        return $this->protocol;
    }

    /**
     * @return resource
     */
    final public function getResource () {
        return $this->resource;
    }

    /**
     * Returns the local address and port, or Unix file path and port `0`.
     *
     * @link https://php.net/socket_getsockname
     *
     * @throws Error
     * @return array String address/file and integer port at indices `0` and `1`.
     */
    public function getSockName () {
        if (!@socket_getsockname($this->resource, $addr, $port)) {
            throw new Error($this->resource, SOCKET_EOPNOTSUPP);
        }
        return [$addr, $port];
    }

    /**
     * Whether the underlying resource is open.
     *
     * @return bool
     */
    public function isOpen () {
        return is_resource($this->resource);
    }

    /**
     * Polls for whether the socket can perform a non-blocking out-of-band read.
     *
     * @see isReady()
     *
     * @return bool
     * @throws Error
     */
    public function isOutOfBand () {
        return $this->isReady(self::CH_EXCEPT);
    }

    /**
     * Polls for whether the socket can perform a non-blocking read.
     *
     * @see isReady()
     *
     * @return bool
     * @throws Error
     */
    final public function isReadable () {
        return $this->isReady(self::CH_READ);
    }

    /**
     * Selects for channel availability.
     *
     * @see await()
     *
     * @param int $channel `SocketInterface` channel constant.
     * @param float|null $timeout Maximum seconds to block. `NULL` blocks forever. Defaults to a poll.
     * @return bool
     * @throws Error
     */
    public function isReady ($channel, $timeout = 0.0) {
        $usec = (int)(fmod($timeout, 1) * 1000000); // ignored if timeout is null
        $select = [$channel => [$this->resource]];
        $count = $count = @socket_select(

            $select[self::CH_READ],
            $select[self::CH_WRITE],
            $select[self::CH_EXCEPT],
            $timeout, // allow null to pass through. core converts numeric to int.
            /** @scrutinizer ignore-type */ $timeout, // allow null to pass through. core converts numeric to int.
            $usec
        );
        if ($count === false) {
            throw new Error($this->resource);
        }
        return (bool)$count;
    }

    /**
     * Polls for whether the socket can perform a non-blocking write.
     *
     * @see isReady()
     *
     * @return bool
     * @throws Error
     */
    final public function isWritable () {
        return $this->isReady(self::CH_WRITE);
    }

    /**
     * Stub. Called before the underlying resource is closed.
     *
     * @return void
     */
    protected function onClose () {
    }

    /**
     * Stub. Called before an I/O channel is shut down.
     *
     * @param int $channel `SocketInterface` channel constant.
     * @return void
     */
    protected function onShutdown ($channel) {
    protected function onShutdown (/** @scrutinizer ignore-unused */ $channel) {
    }

    /**
     * Stub. Called when an I/O timeout has occurred, before it's thrown.
     *
     * @return void
     */
    protected function onTimeout () {
    }

    /**
     * Enables or disables blocking.
     *
     * **Note: PHP provides no way to retrieve a socket's blocking mode.**
     *
     * Sockets are always created in blocking mode.
     *
     * Non-blocking errors are thrown when performing ordinary operations, even if unrelated to those operations.
     * This is known as error slippage.
     * To test for and clear an existing non-blocking error, use `->getOption(SO_ERROR)`.
     *
     * @link https://php.net/socket_set_block
     * @link https://php.net/socket_set_nonblock
     *
     * @param bool $blocking Whether the socket should block.
     * @throws Error
     * @return $this
     */
    public function setBlocking ($blocking) {
        if ($blocking) {
            $success = @socket_set_block($this->resource);
        }
        else {
            $success = @socket_set_nonblock($this->resource);
        }
        if (!$success) {
            throw new Error($this->resource); // reliable errno
        }
        return $this;
    }

    /**
     * Sets an option on the underlying resource.
     *
     * @link https://php.net/socket_set_option
     *
     * @param int $option `SO_*` constant.
     * @param mixed $value
     * @throws Error
     * @return $this
     */
    public function setOption ($option, $value) {
        if (!@socket_set_option($this->resource, SOL_SOCKET, $option, $value)) {
            throw new Error($this->resource, SOCKET_EINVAL);
        }
        return $this;
    }

    /**
     * Sets the I/O timeout length in seconds.
     *
     * @param float $timeout Zero means "no timeout" (block forever).
     * @return $this
     * @throws Error
     */
    public function setTimeout ($timeout) {
        $timeval = ['sec' => (int)$timeout, 'usec' => (int)(fmod($timeout, 1) * 1000000)];
        $this->setOption(SO_RCVTIMEO, $timeval);
        $this->setOption(SO_SNDTIMEO, $timeval);
        return $this;
    }

    /**
     * Shuts down I/O for a single channel.
     *
     * If writing is shut down, trying to send will throw `SOCKET_EPIPE`,
     * and the remote peer will read an empty string after receiving all pending data.
     *
     * If reading is shut down, trying to receive will return an empty string,
     * and the remote peer will get an `EPIPE` error if they try to send.
     *
     * Writing should be shut down first between two connected sockets.
     *
     * Selection always returns positive for a shut down channel,
     * and the remote peer will similarly have positive selection for the opposite channel.
     *
     * @link https://php.net/socket_shutdown
     *
     * @param int $channel `SocketInterface::CH_READ` or `SocketInterface::CH_WRITE`
     * @throws Error
     * @return $this
     */
    public function shutdown ($channel) {
        $this->onShutdown($channel);
        if (!@socket_shutdown($this->resource, $channel)) {
            throw new Error($this->resource); // reliable errno
        }
        return $this;
    }

}
hfw / socket

Push — master ( b4e552...a91d54 )

AbstractSocket::setBlocking() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
