HttpTransport::getConnectTimeout() - Code Metrics - Inspection of "Update readme with infor the ignore-error-transpor..." - bzikarsky/gelf-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( ee7ada...86e322 )

by Benjamin
created 2018-10-25 06:39 UTC
HttpTransport::getConnectTimeout() A

↳ Parent: HttpTransport
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0
<?php

/*
 * This file is part of the php-gelf package.
 *
 * (c) Benjamin Zikarsky <http://benjamin-zikarsky.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Gelf\Transport;

use Gelf\MessageInterface;
use Gelf\Encoder\CompressedJsonEncoder;
use Gelf\Encoder\JsonEncoder as DefaultEncoder;
use RuntimeException;

/**
 * HttpTransport allows the transfer of GELF-messages to an compatible
 * GELF-HTTP-backend as described in
 * http://www.graylog2.org/resources/documentation/sending/gelfhttp
 *
 * It can also act as a direct publisher
 *
 * @author Benjamin Zikarsky <[email protected]>
 */
class HttpTransport extends AbstractTransport
{
    const DEFAULT_HOST = "127.0.0.1";
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
    const DEFAULT_PORT = 12202;
    const DEFAULT_PATH = "/gelf";
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
    
    const AUTO_SSL_PORT = 443;
    
    /**
     * @var string
     */
    protected $host;

    /**
     * @var int
     */
    protected $port;

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

    /**
     * @var StreamSocketClient
     */
    protected $socketClient;

    /**
     * @var SslOptions|null
     */
    protected $sslOptions = null;

    /**
     * @var string|null
     */
    protected $authentication = null;

    /**
     * Class constructor
     *
     * @param string|null     $host       when NULL or empty default-host is used
     * @param int|null        $port       when NULL or empty default-port is used
     * @param string|null     $path       when NULL or empty default-path is used
     * @param SslOptions|null $sslOptions when null not SSL is used
     */
    public function __construct(
        $host = self::DEFAULT_HOST,
        $port = self::DEFAULT_PORT,
        $path = self::DEFAULT_PATH,
        SslOptions $sslOptions = null
    ) {
        $this->host = $host;
        $this->port = $port;
        $this->path = $path;

        if ($port == self::AUTO_SSL_PORT && $sslOptions == null) {
            $sslOptions = new SslOptions();
        }

        $this->sslOptions = $sslOptions;

        $this->messageEncoder = new DefaultEncoder();
        $this->socketClient = new StreamSocketClient(
$a = "a";
$ab = "ab";
$abc = "abc";
            $this->getScheme(),
            $this->host,
            $this->port,
            $this->getContext()
        );
    }

    /**
     * Creates a HttpTransport from a URI
     *
     * Supports http and https schemes, port-, path- and auth-definitions
     * If the port is ommitted 80 and 443 are used respectively.
     * If a username but no password is given, and empty password is used.
     * If a https URI is given, the provided SslOptions (with a fallback to
     * the default SslOptions) are used.
     *
     * @param  string          $url
     * @param  SslOptions|null $sslOptions
     *
     * @return HttpTransport
     */
    public static function fromUrl($url, SslOptions $sslOptions = null)
    {
        $parsed = parse_url($url);
        
        // check it's a valid URL
        if (false === $parsed || !isset($parsed['host']) || !isset($parsed['scheme'])) {
            throw new \InvalidArgumentException("$url is not a valid URL");
// Instead of
$x = "foo $bar $baz";

// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
        }
        
        // check it's http or https
        $scheme = strtolower($parsed['scheme']);
        if (!in_array($scheme, array('http', 'https'))) {
            throw new \InvalidArgumentException("$url is not a valid http/https URL");
// Instead of
$x = "foo $bar $baz";

// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
        }

        // setup defaults
        $defaults = array('port' => 80, 'path' => '', 'user' => null, 'pass' => '');

        // change some defaults for https
        if ($scheme == 'https') {
            $sslOptions = $sslOptions ?: new SslOptions();
$a = "a";
$ab = "ab";
$abc = "abc";
            $defaults['port'] = 443;
        }
         
        // merge defaults and real data and build transport
        $parsed = array_merge($defaults, $parsed);
$a = "a";
$ab = "ab";
$abc = "abc";
        $transport = new static($parsed['host'], $parsed['port'], $parsed['path'], $sslOptions);

        // add optional authentication
        if ($parsed['user']) {
            $transport->setAuthentication($parsed['user'], $parsed['pass']);
        }

        return $transport;
    }

    /**
     * Sets HTTP basic authentication
     *
     * @param string $username
     * @param string $password
     */
    public function setAuthentication($username, $password)
    {
        $this->authentication = $username . ":" . $password;
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
    }

    /**
     * Sends a Message over this transport
     *
     * @param MessageInterface $message
     *
     * @return int the number of bytes sent
     */
    public function send(MessageInterface $message)
    {
        $messageEncoder = $this->getMessageEncoder();
        $rawMessage = $messageEncoder->encode($message);
$a = "a";
$ab = "ab";
$abc = "abc";

        $request = array(
            sprintf("POST %s HTTP/1.1", $this->path),
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            sprintf("Host: %s:%d", $this->host, $this->port),
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            sprintf("Content-Length: %d", strlen($rawMessage)),
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            "Content-Type: application/json",
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            "Connection: Keep-Alive",
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            "Accept: */*"
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        );

        if (null !== $this->authentication) {
            $request[] = "Authorization: Basic " . base64_encode($this->authentication);
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        }

        if ($messageEncoder instanceof CompressedJsonEncoder) {
            $request[] = "Content-Encoding: gzip";
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        }

        $request[] = ""; // blank line to separate headers from body
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        $request[] = $rawMessage;

        $request = implode($request, "\r\n");
        $request = /** @scrutinizer ignore-call */ implode($request, "\r\n");

        $byteCount = $this->socketClient->write($request);
        $headers = $this->readResponseHeaders();
$a = "a";
$ab = "ab";
$abc = "abc";

        // if we don't have a HTTP/1.1 connection, or the server decided to close the connection
        // we should do so as well. next read/write-attempt will open a new socket in this case.
        if (strpos($headers, "HTTP/1.1") !== 0 || preg_match("!Connection:\s*Close!i", $headers)) {
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            $this->socketClient->close();
        }

        if (!preg_match("!^HTTP/1.\d 202 Accepted!i", $headers)) {
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            throw new RuntimeException(
                sprintf(
                    "Graylog-Server didn't answer properly, expected 'HTTP/1.x 202 Accepted', response is '%s'",

                    trim($headers)
                )
            );
        }

        return $byteCount;
    }

    /**
     * @return string
     */
    private function readResponseHeaders()
    {
        $chunkSize = 1024; // number of bytes to read at once
        $delimiter = "\r\n\r\n"; // delimiter between headers and rsponse
        $response = "";
$a = "a";
$ab = "ab";
$abc = "abc";

        do {
            $chunk = $this->socketClient->read($chunkSize);
$a = "a";
$ab = "ab";
$abc = "abc";
            $response .= $chunk;
        } while (false === strpos($chunk, $delimiter) && strlen($chunk) > 0);

        $elements = explode($delimiter, $response, 2);

        return $elements[0];
    }

    /**
     * @return string
     */
    private function getScheme()
    {
        return null === $this->sslOptions ? 'tcp' : 'ssl';
    }

    /**
     * @return array
     */
    private function getContext()
    {
        if (null === $this->sslOptions) {
            return array();
        }

        return $this->sslOptions->toStreamContext($this->host);
    }

    /**
     * Sets the connect-timeout
     *
     * @param int $timeout
     */
    public function setConnectTimeout($timeout)
    {
        $this->socketClient->setConnectTimeout($timeout);
    }

    /**
     * Returns the connect-timeout
     *
     * @return int
     */
    public function getConnectTimeout()
    {
        return $this->socketClient->getConnectTimeout();
    }
}


bzikarsky / gelf-php

Push — master ( ee7ada...86e322 )

HttpTransport::getConnectTimeout() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
