Graze\TelnetClient\TelnetClient

Complexity

Total Complexity

32

Size/Duplication

Total Lines	289
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

94.19%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	connect()	0	22	5
A	setPrompt()	0	4	1
A	setPromptError()	0	4	1
A	setLineEnding()	0	4	1
A	setSocket()	0	4	1
A	getSocket()	0	4	1
A	setReadTimeout()	0	11	2
A	execute()	0	9	2
A	write()	0	8	2
A	setMaxBytesRead()	0	4	1
C	getResponse()	0	51	11
A	factory()	0	8	1
A	__destruct()	0	8	2

<?php

/**
 * This file is part of graze/telnet-client.
 *
 * Copyright (c) 2016 Nature Delivered Ltd. <https://www.graze.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @license https://github.com/graze/telnet-client/blob/master/LICENSE
 * @link https://github.com/graze/telnet-client
 */

namespace Graze\TelnetClient;

use Exception;
use Graze\TelnetClient\Exception\TelnetException;
use Graze\TelnetClient\Exception\TelnetExceptionInterface;
use Socket\Raw\Factory as SocketFactory;
use Socket\Raw\Socket;

class TelnetClient implements TelnetClientInterface
{
    /**
     * @var SocketFactory
     */
    protected $socketFactory;

    /**
     * @var PromptMatcherInterface
     */
    protected $promptMatcher;

    /**
     * @var InterpretAsCommand
     */
    protected $interpretAsCommand;

    /**
     * @var string
     */
    protected $prompt = '\$';

    /**
     * @var string
     */
    protected $promptError = 'ERROR';

    /**
     * @var string
     */
    protected $lineEnding = "\n";

    /**
     * @var int
     */
    protected $maxBytesRead = 0;

    /**
     * @var Socket
     */
    protected $socket;

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

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

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

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

    /**
     * @param SocketFactory $socketFactory
     * @param PromptMatcherInterface $promptMatcher
     * @param InterpretAsCommand $interpretAsCommand
     */
    public function __construct(
        SocketFactory $socketFactory,
        PromptMatcherInterface $promptMatcher,
        InterpretAsCommand $interpretAsCommand
    ) {
        $this->socketFactory = $socketFactory;
        $this->promptMatcher = $promptMatcher;
        $this->interpretAsCommand = $interpretAsCommand;

        $this->NULL = chr(0);
        $this->DC1 = chr(17);
    }

    /**
     * @param string $dsn
     * @param string $prompt
     * @param string $promptError
     * @param string $lineEnding
     * @param float|null $timeout
     *
     * @throws TelnetExceptionInterface
     */
    public function connect($dsn, $prompt = null, $promptError = null, $lineEnding = null, $timeout = null)
    {
        if ($prompt !== null) {
            $this->setPrompt($prompt);
        }

        if ($promptError !== null) {
            $this->setPromptError($promptError);
        }

        if ($lineEnding !== null) {
            $this->setLineEnding($lineEnding);
        }

        try {
            $socket = $this->socketFactory->createClient($dsn, $timeout);
        } catch (Exception $e) {
            throw new TelnetException(sprintf('unable to create socket connection to [%s]', $dsn), 0, $e);
        }

        $this->setSocket($socket);
    }

    /**
     * @param string $prompt
     */
    public function setPrompt($prompt)
    {
        $this->prompt = $prompt;
    }

    /**
     * @param string $promptError
     */
    public function setPromptError($promptError)
    {
        $this->promptError = $promptError;
    }

    /**
     * @param string $lineEnding
     */
    public function setLineEnding($lineEnding)
    {
        $this->lineEnding = $lineEnding;
    }

    /**
     * Set the maximum number of bytes that can be read per request
     *
     * @param int $maxBytesRead
     */
    public function setMaxBytesRead($maxBytesRead)
    {
        $this->maxBytesRead = $maxBytesRead;
    }

    /**
     * @param Socket $socket
     */
    public function setSocket(Socket $socket)
    {
        $this->socket = $socket;
    }

    /**
     * @return Socket
     */
    public function getSocket()
    {
        return $this->socket;
    }

    /**
     * @param float $timeout
     */
    public function setReadTimeout($timeout)
    {
        if (!$this->socket) {
            throw new TelnetException('cannot set read timeout, socket does not exist (call connect() first)');
        }

        $sec = floor($timeout);
        $usec = round(fmod($timeout, 1) * 1000000);

        $this->socket->setOption(SOL_SOCKET, SO_RCVTIMEO, ['sec' => $sec, 'usec' => $usec]);
    }

    /**
     * @param string $command
     * @param string $prompt
     * @param string $promptError
     *
     * @return TelnetResponseInterface
     */
    public function execute($command, $prompt = null, $promptError = null)
    {
        if (!$this->socket) {
            throw new TelnetException('attempt to execute without a connection - call connect first');
        }

        $this->write($command);
        return $this->getResponse($prompt, $promptError);
    }

    /**
     * @param string $command
     *
     * @return void
     * @throws TelnetExceptionInterface
     */
    protected function write($command)
    {
        try {
            $this->socket->write($command . $this->lineEnding);
        } catch (Exception $e) {
            throw new TelnetException(sprintf('failed writing to socket [%s]', $command), 0, $e);
        }
    }

    /**
     * @param string $prompt
     * @param string $promptError
     *
     * @return TelnetResponseInterface
     * @throws TelnetExceptionInterface
     */
    protected function getResponse($prompt = null, $promptError = null)
    {
        $isError = false;
        $buffer = '';
        $bytesRead = 0;
        do {
            // process one byte at a time
            try {
                $byte = $this->socket->read(1);
                $bytesRead++;
            } catch (Exception $e) {
                throw new TelnetException('failed reading from socket', 0, $e);
            }

            if (in_array($byte, [$this->NULL, $this->DC1])) {
                break;
            }

            if ($this->interpretAsCommand->interpret($byte, $this->socket)) {
                continue;
            }

            $buffer .= $byte;

            // check for prompt
            if ($this->promptMatcher->isMatch($prompt ?: $this->prompt, $buffer, $this->lineEnding)) {
                break;
            }

            // check for error prompt
            if ($this->promptMatcher->isMatch($promptError ?: $this->promptError, $buffer, $this->lineEnding)) {
                $isError = true;
                break;
            }

            // throw an exception if the number of bytes read is greater than the limit
            if ($this->maxBytesRead > 0 && $bytesRead >= $this->maxBytesRead) {
                throw new TelnetException(sprintf(
                    'Maximum number of bytes read (%d), the last bytes were %s',
                    $this->maxBytesRead,
                    substr($buffer, -10)
                ));
            }
        } while (true);

        return new TelnetResponse(
            $isError,
            $this->promptMatcher->getResponseText(),
            $this->promptMatcher->getMatches()
        );
    }

    /**
     * @return TelnetClientInterface
     */
    public static function factory()
    {
        return new static(
            new SocketFactory(),
            new PromptMatcher(),
            new InterpretAsCommand()
        );
    }

    public function __destruct()
    {
        if (!$this->socket) {
            return;
        }

        $this->socket->close();
    }
}