AbstractSocket::select() - Code Metrics - Inspection of "more overhauling" - hfw/socket - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( a91d54...875978 )

by y
created 2020-03-09 13:11 UTC
AbstractSocket::select() A

↳ Parent: AbstractSocket
Complexity

Conditions	2
Paths	2
Size

Total Lines	18
Code Lines	14
Duplication

Lines	0
Ratio	0 %
Importance

Changes	3
Bugs	0	Features	0
Metric	Value
cc	2
eloc	14
c	3
b	0
f	0
nc	2
nop	4
dl	0
loc	18
rs	9.7998
<?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 SocketError
     */
    public static function create ($domain = AF_INET, ...$extra) {
        if (!$resource = @socket_create($domain, static::getType(), 0)) { // auto-protocol
            throw new SocketError; // reliable errno
        }
        return new static(...array_merge([$resource], $extra));
        return new static(/** @scrutinizer ignore-type */ ...array_merge([$resource], $extra));
    }

    /**
     * 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 SocketError (`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 = SocketError::getLast($resource)) {
            $error = new SocketError(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 () {
        if ($this->isOpen()) {
            $this->close();
        }
    }

    /**
     * Blocks until the socket becomes available on a given channel.
     *
     * Throws if the underlying resource has a pending error (non-blocking sockets only).
     *
     * @see isReady()
     *
     * @param int $channel `SocketInterface` channel constant.
     * @return $this
     * @throws SocketError
     */
    public function await ($channel) {
        $rwe = [$channel => [$this->resource]];
        if (!@socket_select($rwe[0], $rwe[1], $rwe[2], null)) {
            throw new SocketError($this->resource);
        }
        return $this;
    }

    /**
     * @see await()
     *
     * @return $this
     */
    final public function awaitOutOfBand () {
        return $this->await(self::CH_EXCEPT);
    }

    /**
     * @see await()
     *
     * @return $this
     */
    final public function awaitReadable () {
        return $this->await(self::CH_READ);
    }

    /**
     * @see await()
     *
     * @return $this
     */
    final public function awaitWritable () {
        return $this->await(self::CH_WRITE);
    }

    /**
     * Closes the socket if it's open.
     *
     * @link https://php.net/socket_close
     *
     * @return $this
     */
    public function close () {
        socket_close($this->resource); // never errors
        return $this;
    }

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

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

    /**
     * Retrieves a socket-level option.
     *
     * @link https://php.net/socket_get_option
     *
     * @param int $option `SO_*` option constant.
     * @throws SocketError
     * @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 SocketError($this->resource, SOCKET_EINVAL);
        }
        return $value;
    }

    /**
     * @return int
     */
    final public function getProtocol (): int {
        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 SocketError
     * @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 SocketError($this->resource, SOCKET_EOPNOTSUPP);
        }
        return [$addr, $port];
    }

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

    /**
     * Polls for whether the socket can perform a non-blocking out-of-band read.
     *
     * @see isReady()
     *
     * @return bool
     * @throws SocketError
     */
    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 SocketError
     */
    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 SocketError
     */
    public function isReady ($channel, $timeout = 0.0): bool {
        $rwe = [$channel => [$this->resource]];
        // core casts non-null timeout to int.
        // usec is ignored if timeout is null.
        $usec = (int)(fmod($timeout, 1) * 1000000);
        if (false === $count = @socket_select($rwe[0], $rwe[1], $rwe[2], $timeout, $usec)) {
        if (false === $count = @socket_select($rwe[0], $rwe[1], $rwe[2], /** @scrutinizer ignore-type */ $timeout, $usec)) {
            throw new SocketError($this->resource);
        }
        return (bool)$count;
    }

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

    /**
     * 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 SocketError
     * @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 SocketError($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 SocketError
     * @return $this
     */
    public function setOption ($option, $value) {
        if (!@socket_set_option($this->resource, SOL_SOCKET, $option, $value)) {
            throw new SocketError($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 SocketError
     */
    public function setTimeout ($timeout) {
        $tv = [
            'sec' => (int)$timeout,
            'usec' => (int)(fmod($timeout, 1) * 1000000)
        ];
        $this->setOption(SO_RCVTIMEO, $tv);
        $this->setOption(SO_SNDTIMEO, $tv);
        return $this;
    }

    /**
     * Shuts down I/O.
     *
     * Shutting down is a formal handshake two peers can do before actually closing.
     * It's not required, but it can help assert I/O access logic.
     *
     * 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 $channels `CH_READ | CH_WRITE`
     * @throws SocketError
     * @return $this
     */
    public function shutdown (int $channels = self::CH_READ | self::CH_WRITE) {
        if (!@socket_shutdown($this->resource, $channels)) {
            throw new SocketError($this->resource); // reliable errno
        }
        return $this;
    }

}
hfw / socket

Push — master ( a91d54...875978 )

AbstractSocket::select() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
