StreamHandler::createSink() - Code Metrics - Inspection of "Add guzzle via composer" - godbout/alfred-time - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8d12ff...458df2 )

by Guillaume

created 2017-05-02 09:55 UTC

StreamHandler::createSink() A

↳ Parent: StreamHandler

Complexity

Conditions	4
Paths	5

Size

Total Lines	14
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	9
nc	5
nop	2
dl	0
loc	14
rs	9.2
c	0
b	0
f	0

<?php
namespace GuzzleHttp\Handler;

use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Exception\ConnectException;
use GuzzleHttp\Promise\FulfilledPromise;
use GuzzleHttp\Promise\RejectedPromise;
use GuzzleHttp\Promise\PromiseInterface;
use GuzzleHttp\Psr7;
use GuzzleHttp\TransferStats;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamInterface;

/**
 * HTTP handler that uses PHP's HTTP stream wrapper.
 */
class StreamHandler
{
    private $lastHeaders = [];

    /**
     * Sends an HTTP request.
     *
     * @param RequestInterface $request Request to send.
     * @param array            $options Request transfer options.
     *
     * @return PromiseInterface
     */
    public function __invoke(RequestInterface $request, array $options)
    {
        // Sleep if there is a delay specified.
        if (isset($options['delay'])) {
            usleep($options['delay'] * 1000);
        }

        $startTime = isset($options['on_stats']) ? microtime(true) : null;

        try {
            // Does not support the expect header.
            $request = $request->withoutHeader('Expect');

            // Append a content-length header if body size is zero to match
            // cURL's behavior.
            if (0 === $request->getBody()->getSize()) {
                $request = $request->withHeader('Content-Length', 0);
            }

            return $this->createResponse(
                $request,
                $options,
                $this->createStream($request, $options),
                $startTime
            );
        } catch (\InvalidArgumentException $e) {
            throw $e;
        } catch (\Exception $e) {
            // Determine if the error was a networking error.
            $message = $e->getMessage();
            // This list can probably get more comprehensive.
            if (strpos($message, 'getaddrinfo') // DNS lookup failed
                || strpos($message, 'Connection refused')
                || strpos($message, "couldn't connect to host") // error on HHVM
            ) {
                $e = new ConnectException($e->getMessage(), $request, $e);
            }
            $e = RequestException::wrapException($request, $e);
            $this->invokeStats($options, $request, $startTime, null, $e);

            return new RejectedPromise($e);
        }
    }

    private function invokeStats(
        array $options,
        RequestInterface $request,
        $startTime,
        ResponseInterface $response = null,
        $error = null
    ) {
        if (isset($options['on_stats'])) {
            $stats = new TransferStats(
                $request,
                $response,
                microtime(true) - $startTime,
                $error,
                []
            );
            call_user_func($options['on_stats'], $stats);
        }
    }

    private function createResponse(
        RequestInterface $request,
        array $options,
        $stream,
        $startTime
    ) {
        $hdrs = $this->lastHeaders;
        $this->lastHeaders = [];
        $parts = explode(' ', array_shift($hdrs), 3);
        $ver = explode('/', $parts[0])[1];
        $status = $parts[1];
        $reason = isset($parts[2]) ? $parts[2] : null;
        $headers = \GuzzleHttp\headers_from_lines($hdrs);
        list ($stream, $headers) = $this->checkDecode($options, $headers, $stream);
        $stream = Psr7\stream_for($stream);
        $sink = $stream;

        if (strcasecmp('HEAD', $request->getMethod())) {
            $sink = $this->createSink($stream, $options);
        }

        $response = new Psr7\Response($status, $headers, $sink, $ver, $reason);

        if (isset($options['on_headers'])) {
            try {
                $options['on_headers']($response);
            } catch (\Exception $e) {
                $msg = 'An error was encountered during the on_headers event';
                $ex = new RequestException($msg, $request, $response, $e);
                return new RejectedPromise($ex);
            }
        }

        // Do not drain when the request is a HEAD request because they have
        // no body.
        if ($sink !== $stream) {
            $this->drain(
                $stream,
                $sink,
                $response->getHeaderLine('Content-Length')
            );
        }

        $this->invokeStats($options, $request, $startTime, $response, null);

        return new FulfilledPromise($response);
    }

    private function createSink(StreamInterface $stream, array $options)
    {
        if (!empty($options['stream'])) {
            return $stream;
        }

        $sink = isset($options['sink'])
            ? $options['sink']
            : fopen('php://temp', 'r+');

        return is_string($sink)
            ? new Psr7\LazyOpenStream($sink, 'w+')
            : Psr7\stream_for($sink);
    }

    private function checkDecode(array $options, array $headers, $stream)
    {
        // Automatically decode responses when instructed.
        if (!empty($options['decode_content'])) {
            $normalizedKeys = \GuzzleHttp\normalize_header_keys($headers);
            if (isset($normalizedKeys['content-encoding'])) {
                $encoding = $headers[$normalizedKeys['content-encoding']];
                if ($encoding[0] === 'gzip' || $encoding[0] === 'deflate') {
                    $stream = new Psr7\InflateStream(
                        Psr7\stream_for($stream)
                    );
                    $headers['x-encoded-content-encoding']
                        = $headers[$normalizedKeys['content-encoding']];
                    // Remove content-encoding header
                    unset($headers[$normalizedKeys['content-encoding']]);
                    // Fix content-length header
                    if (isset($normalizedKeys['content-length'])) {

                        $headers['x-encoded-content-length']
                            = $headers[$normalizedKeys['content-length']];

                        $length = (int) $stream->getSize();
                        if ($length === 0) {
                            unset($headers[$normalizedKeys['content-length']]);
                        } else {
                            $headers[$normalizedKeys['content-length']] = [$length];
                        }
                    }
                }
            }
        }

        return [$stream, $headers];
    }

    /**
     * Drains the source stream into the "sink" client option.
     *
     * @param StreamInterface $source
     * @param StreamInterface $sink
     * @param string          $contentLength Header specifying the amount of
     *                                       data to read.
     *
     * @return StreamInterface
     * @throws \RuntimeException when the sink option is invalid.
     */
    private function drain(
        StreamInterface $source,
        StreamInterface $sink,
        $contentLength
    ) {
        // If a content-length header is provided, then stop reading once
        // that number of bytes has been read. This can prevent infinitely
        // reading from a stream when dealing with servers that do not honor
        // Connection: Close headers.
        Psr7\copy_to_stream(
            $source,
            $sink,
            (strlen($contentLength) > 0 && (int) $contentLength > 0) ? (int) $contentLength : -1
        );

        $sink->seek(0);
        $source->close();

        return $sink;
    }

    /**
     * Create a resource and check to ensure it was created successfully
     *
     * @param callable $callback Callable that returns stream resource
     *
     * @return resource
     * @throws \RuntimeException on error
     */
    private function createResource(callable $callback)
    {
        $errors = null;
        set_error_handler(function ($_, $msg, $file, $line) use (&$errors) {
            $errors[] = [
                'message' => $msg,
                'file'    => $file,
                'line'    => $line
            ];
            return true;
        });

        $resource = $callback();
        restore_error_handler();

        if (!$resource) {
            $message = 'Error creating resource: ';
            foreach ($errors as $err) {

                foreach ($err as $key => $value) {
                    $message .= "[$key] $value" . PHP_EOL;
                }
            }
            throw new \RuntimeException(trim($message));
        }

        return $resource;
    }

    private function createStream(RequestInterface $request, array $options)
    {
        static $methods;
        if (!$methods) {
            $methods = array_flip(get_class_methods(__CLASS__));
        }

        // HTTP/1.1 streams using the PHP stream wrapper require a
        // Connection: close header
        if ($request->getProtocolVersion() == '1.1'
            && !$request->hasHeader('Connection')
        ) {
            $request = $request->withHeader('Connection', 'close');
        }

        // Ensure SSL is verified by default
        if (!isset($options['verify'])) {
            $options['verify'] = true;
        }

        $params = [];
        $context = $this->getDefaultContext($request, $options);


        if (isset($options['on_headers']) && !is_callable($options['on_headers'])) {
            throw new \InvalidArgumentException('on_headers must be callable');
        }

        if (!empty($options)) {
            foreach ($options as $key => $value) {
                $method = "add_{$key}";
                if (isset($methods[$method])) {
                    $this->{$method}($request, $context, $value, $params);
                }
            }
        }

        if (isset($options['stream_context'])) {
            if (!is_array($options['stream_context'])) {
                throw new \InvalidArgumentException('stream_context must be an array');
            }
            $context = array_replace_recursive(
                $context,
                $options['stream_context']
            );
        }

        $context = $this->createResource(
            function () use ($context, $params) {
                return stream_context_create($context, $params);
            }
        );

        return $this->createResource(
            function () use ($request, &$http_response_header, $context) {
                $resource = fopen((string) $request->getUri()->withFragment(''), 'r', null, $context);
                $this->lastHeaders = $http_response_header;
                return $resource;
            }
        );
    }

    private function getDefaultContext(RequestInterface $request)
    {
        $headers = '';
        foreach ($request->getHeaders() as $name => $value) {
            foreach ($value as $val) {
                $headers .= "$name: $val\r\n";
            }
        }

        $context = [
            'http' => [
                'method'           => $request->getMethod(),
                'header'           => $headers,
                'protocol_version' => $request->getProtocolVersion(),
                'ignore_errors'    => true,
                'follow_location'  => 0,
            ],
        ];

        $body = (string) $request->getBody();

        if (!empty($body)) {
            $context['http']['content'] = $body;
            // Prevent the HTTP handler from adding a Content-Type header.
            if (!$request->hasHeader('Content-Type')) {
                $context['http']['header'] .= "Content-Type:\r\n";
            }
        }

        $context['http']['header'] = rtrim($context['http']['header']);

        return $context;
    }

    private function add_proxy(RequestInterface $request, &$options, $value, &$params)

    {
        if (!is_array($value)) {
            $options['http']['proxy'] = $value;
        } else {
            $scheme = $request->getUri()->getScheme();
            if (isset($value[$scheme])) {
                if (!isset($value['no'])
                    || !\GuzzleHttp\is_host_in_noproxy(
                        $request->getUri()->getHost(),
                        $value['no']
                    )
                ) {
                    $options['http']['proxy'] = $value[$scheme];
                }
            }
        }
    }

    private function add_timeout(RequestInterface $request, &$options, $value, &$params)

    {
        if ($value > 0) {
            $options['http']['timeout'] = $value;
        }
    }

    private function add_verify(RequestInterface $request, &$options, $value, &$params)

    {
        if ($value === true) {
            // PHP 5.6 or greater will find the system cert by default. When
            // < 5.6, use the Guzzle bundled cacert.
            if (PHP_VERSION_ID < 50600) {
                $options['ssl']['cafile'] = \GuzzleHttp\default_ca_bundle();
            }
        } elseif (is_string($value)) {
            $options['ssl']['cafile'] = $value;
            if (!file_exists($value)) {
                throw new \RuntimeException("SSL CA bundle not found: $value");
            }
        } elseif ($value === false) {
            $options['ssl']['verify_peer'] = false;
            $options['ssl']['verify_peer_name'] = false;
            return;
        } else {
            throw new \InvalidArgumentException('Invalid verify request option');
        }

        $options['ssl']['verify_peer'] = true;
        $options['ssl']['verify_peer_name'] = true;
        $options['ssl']['allow_self_signed'] = false;
    }

    private function add_cert(RequestInterface $request, &$options, $value, &$params)

    {
        if (is_array($value)) {
            $options['ssl']['passphrase'] = $value[1];
            $value = $value[0];
        }

        if (!file_exists($value)) {
            throw new \RuntimeException("SSL certificate not found: {$value}");
        }

        $options['ssl']['local_cert'] = $value;
    }

    private function add_progress(RequestInterface $request, &$options, $value, &$params)

    {
        $this->addNotification(
            $params,
            function ($code, $a, $b, $c, $transferred, $total) use ($value) {
                if ($code == STREAM_NOTIFY_PROGRESS) {
                    $value($total, $transferred, null, null);
                }
            }
        );
    }

    private function add_debug(RequestInterface $request, &$options, $value, &$params)

    {
        if ($value === false) {
            return;
        }

        static $map = [
            STREAM_NOTIFY_CONNECT       => 'CONNECT',
            STREAM_NOTIFY_AUTH_REQUIRED => 'AUTH_REQUIRED',
            STREAM_NOTIFY_AUTH_RESULT   => 'AUTH_RESULT',
            STREAM_NOTIFY_MIME_TYPE_IS  => 'MIME_TYPE_IS',
            STREAM_NOTIFY_FILE_SIZE_IS  => 'FILE_SIZE_IS',
            STREAM_NOTIFY_REDIRECTED    => 'REDIRECTED',
            STREAM_NOTIFY_PROGRESS      => 'PROGRESS',
            STREAM_NOTIFY_FAILURE       => 'FAILURE',
            STREAM_NOTIFY_COMPLETED     => 'COMPLETED',
            STREAM_NOTIFY_RESOLVE       => 'RESOLVE',
        ];
        static $args = ['severity', 'message', 'message_code',
            'bytes_transferred', 'bytes_max'];

        $value = \GuzzleHttp\debug_resource($value);
        $ident = $request->getMethod() . ' ' . $request->getUri()->withFragment('');
        $this->addNotification(
            $params,
            function () use ($ident, $value, $map, $args) {
                $passed = func_get_args();
                $code = array_shift($passed);
                fprintf($value, '<%s> [%s] ', $ident, $map[$code]);
                foreach (array_filter($passed) as $i => $v) {
                    fwrite($value, $args[$i] . ': "' . $v . '" ');
                }
                fwrite($value, "\n");
            }
        );
    }

    private function addNotification(array &$params, callable $notify)
    {
        // Wrap the existing function if needed.
        if (!isset($params['notification'])) {
            $params['notification'] = $notify;
        } else {
            $params['notification'] = $this->callArray([
                $params['notification'],
                $notify
            ]);
        }
    }

    private function callArray(array $functions)
    {
        return function () use ($functions) {
            $args = func_get_args();
            foreach ($functions as $fn) {
                call_user_func_array($fn, $args);
            }
        };
    }
}


1		<?php
2		namespace GuzzleHttp\Handler;
3
4		use GuzzleHttp\Exception\RequestException;
5		use GuzzleHttp\Exception\ConnectException;
6		use GuzzleHttp\Promise\FulfilledPromise;
7		use GuzzleHttp\Promise\RejectedPromise;
8		use GuzzleHttp\Promise\PromiseInterface;
9		use GuzzleHttp\Psr7;
10		use GuzzleHttp\TransferStats;
11		use Psr\Http\Message\RequestInterface;
12		use Psr\Http\Message\ResponseInterface;
13		use Psr\Http\Message\StreamInterface;
14
15		/**
16		* HTTP handler that uses PHP's HTTP stream wrapper.
17		*/
18		class StreamHandler
19		{
20		private $lastHeaders = [];
21
22		/**
23		* Sends an HTTP request.
24		*
25		* @param RequestInterface $request Request to send.
26		* @param array $options Request transfer options.
27		*
28		* @return PromiseInterface
29		*/
30		public function __invoke(RequestInterface $request, array $options)
31		{
32		// Sleep if there is a delay specified.
33		if (isset($options['delay'])) {
34		usleep($options['delay'] * 1000);
35		}
36
37		$startTime = isset($options['on_stats']) ? microtime(true) : null;
38
39		try {
40		// Does not support the expect header.
41		$request = $request->withoutHeader('Expect');
42
43		// Append a content-length header if body size is zero to match
44		// cURL's behavior.
45		if (0 === $request->getBody()->getSize()) {
46		$request = $request->withHeader('Content-Length', 0);
47		}
48
49		return $this->createResponse(
50		$request,
51		$options,
52		$this->createStream($request, $options),
53		$startTime
54		);
55		} catch (\InvalidArgumentException $e) {
56		throw $e;
57		} catch (\Exception $e) {
58		// Determine if the error was a networking error.
59		$message = $e->getMessage();
60		// This list can probably get more comprehensive.
61		if (strpos($message, 'getaddrinfo') // DNS lookup failed
62		\|\| strpos($message, 'Connection refused')
63		\|\| strpos($message, "couldn't connect to host") // error on HHVM
64		) {
65		$e = new ConnectException($e->getMessage(), $request, $e);
66		}
67		$e = RequestException::wrapException($request, $e);
68		$this->invokeStats($options, $request, $startTime, null, $e);
69
70		return new RejectedPromise($e);
71		}
72		}
73
74		private function invokeStats(
75		array $options,
76		RequestInterface $request,
77		$startTime,
78		ResponseInterface $response = null,
79		$error = null
80		) {
81		if (isset($options['on_stats'])) {
82		$stats = new TransferStats(
83		$request,
84		$response,
85		microtime(true) - $startTime,
86		$error,
87		[]
88		);
89		call_user_func($options['on_stats'], $stats);
90		}
91		}
92
93		private function createResponse(
94		RequestInterface $request,
95		array $options,
96		$stream,
97		$startTime
98		) {
99		$hdrs = $this->lastHeaders;
100		$this->lastHeaders = [];
101		$parts = explode(' ', array_shift($hdrs), 3);
102		$ver = explode('/', $parts[0])[1];
103		$status = $parts[1];
104		$reason = isset($parts[2]) ? $parts[2] : null;
105		$headers = \GuzzleHttp\headers_from_lines($hdrs);
106		list ($stream, $headers) = $this->checkDecode($options, $headers, $stream);
107		$stream = Psr7\stream_for($stream);
108		$sink = $stream;
109
110		if (strcasecmp('HEAD', $request->getMethod())) {
111		$sink = $this->createSink($stream, $options);
112		}
113
114		$response = new Psr7\Response($status, $headers, $sink, $ver, $reason);
115
116		if (isset($options['on_headers'])) {
117		try {
118		$options['on_headers']($response);
119		} catch (\Exception $e) {
120		$msg = 'An error was encountered during the on_headers event';
121		$ex = new RequestException($msg, $request, $response, $e);
122		return new RejectedPromise($ex);
123		}
124		}
125
126		// Do not drain when the request is a HEAD request because they have
127		// no body.
128		if ($sink !== $stream) {
129		$this->drain(
130		$stream,
131		$sink,
132		$response->getHeaderLine('Content-Length')
133		);
134		}
135
136		$this->invokeStats($options, $request, $startTime, $response, null);
137
138		return new FulfilledPromise($response);
139		}
140
141		private function createSink(StreamInterface $stream, array $options)
142		{
143		if (!empty($options['stream'])) {
144		return $stream;
145		}
146
147		$sink = isset($options['sink'])
148		? $options['sink']
149		: fopen('php://temp', 'r+');
150
151		return is_string($sink)
152		? new Psr7\LazyOpenStream($sink, 'w+')
153		: Psr7\stream_for($sink);
154		}
155
156		private function checkDecode(array $options, array $headers, $stream)
157		{
158		// Automatically decode responses when instructed.
159		if (!empty($options['decode_content'])) {
160		$normalizedKeys = \GuzzleHttp\normalize_header_keys($headers);
161		if (isset($normalizedKeys['content-encoding'])) {
162		$encoding = $headers[$normalizedKeys['content-encoding']];
163		if ($encoding[0] === 'gzip' \|\| $encoding[0] === 'deflate') {
164		$stream = new Psr7\InflateStream(
165		Psr7\stream_for($stream)
166		);
167		$headers['x-encoded-content-encoding']
168		= $headers[$normalizedKeys['content-encoding']];
169		// Remove content-encoding header
170		unset($headers[$normalizedKeys['content-encoding']]);
171		// Fix content-length header
172	View Code Duplication	if (isset($normalizedKeys['content-length'])) {
		0 ignored issues – show Duplication introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
173		$headers['x-encoded-content-length']
174		= $headers[$normalizedKeys['content-length']];
175
176		$length = (int) $stream->getSize();
177		if ($length === 0) {
178		unset($headers[$normalizedKeys['content-length']]);
179		} else {
180		$headers[$normalizedKeys['content-length']] = [$length];
181		}
182		}
183		}
184		}
185		}
186
187		return [$stream, $headers];
188		}
189
190		/**
191		* Drains the source stream into the "sink" client option.
192		*
193		* @param StreamInterface $source
194		* @param StreamInterface $sink
195		* @param string $contentLength Header specifying the amount of
196		* data to read.
197		*
198		* @return StreamInterface
199		* @throws \RuntimeException when the sink option is invalid.
200		*/
201		private function drain(
202		StreamInterface $source,
203		StreamInterface $sink,
204		$contentLength
205		) {
206		// If a content-length header is provided, then stop reading once
207		// that number of bytes has been read. This can prevent infinitely
208		// reading from a stream when dealing with servers that do not honor
209		// Connection: Close headers.
210		Psr7\copy_to_stream(
211		$source,
212		$sink,
213		(strlen($contentLength) > 0 && (int) $contentLength > 0) ? (int) $contentLength : -1
214		);
215
216		$sink->seek(0);
217		$source->close();
218
219		return $sink;
220		}
221
222		/**
223		* Create a resource and check to ensure it was created successfully
224		*
225		* @param callable $callback Callable that returns stream resource
226		*
227		* @return resource
228		* @throws \RuntimeException on error
229		*/
230		private function createResource(callable $callback)
231		{
232		$errors = null;
233		set_error_handler(function ($_, $msg, $file, $line) use (&$errors) {
234		$errors[] = [
235		'message' => $msg,
236		'file' => $file,
237		'line' => $line
238		];
239		return true;
240		});
241
242		$resource = $callback();
243		restore_error_handler();
244
245		if (!$resource) {
246		$message = 'Error creating resource: ';
247		foreach ($errors as $err) {
		0 ignored issues – show Bug introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The expression `$errors` of type `null` is not traversable. Loading history...
248		foreach ($err as $key => $value) {
249		$message .= "[$key] $value" . PHP_EOL;
250		}
251		}
252		throw new \RuntimeException(trim($message));
253		}
254
255		return $resource;
256		}
257
258		private function createStream(RequestInterface $request, array $options)
259		{
260		static $methods;
261		if (!$methods) {
262		$methods = array_flip(get_class_methods(__CLASS__));
263		}
264
265		// HTTP/1.1 streams using the PHP stream wrapper require a
266		// Connection: close header
267		if ($request->getProtocolVersion() == '1.1'
268		&& !$request->hasHeader('Connection')
269		) {
270		$request = $request->withHeader('Connection', 'close');
271		}
272
273		// Ensure SSL is verified by default
274		if (!isset($options['verify'])) {
275		$options['verify'] = true;
276		}
277
278		$params = [];
279		$context = $this->getDefaultContext($request, $options);
		0 ignored issues – show Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The call to `StreamHandler::getDefaultContext()` has too many arguments starting with `$options`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
280
281		if (isset($options['on_headers']) && !is_callable($options['on_headers'])) {
282		throw new \InvalidArgumentException('on_headers must be callable');
283		}
284
285		if (!empty($options)) {
286		foreach ($options as $key => $value) {
287		$method = "add_{$key}";
288		if (isset($methods[$method])) {
289		$this->{$method}($request, $context, $value, $params);
290		}
291		}
292		}
293
294		if (isset($options['stream_context'])) {
295		if (!is_array($options['stream_context'])) {
296		throw new \InvalidArgumentException('stream_context must be an array');
297		}
298		$context = array_replace_recursive(
299		$context,
300		$options['stream_context']
301		);
302		}
303
304		$context = $this->createResource(
305		function () use ($context, $params) {
306		return stream_context_create($context, $params);
307		}
308		);
309
310		return $this->createResource(
311		function () use ($request, &$http_response_header, $context) {
312		$resource = fopen((string) $request->getUri()->withFragment(''), 'r', null, $context);
313		$this->lastHeaders = $http_response_header;
314		return $resource;
315		}
316		);
317		}
318
319		private function getDefaultContext(RequestInterface $request)
320		{
321		$headers = '';
322		foreach ($request->getHeaders() as $name => $value) {
323		foreach ($value as $val) {
324		$headers .= "$name: $val\r\n";
325		}
326		}
327
328		$context = [
329		'http' => [
330		'method' => $request->getMethod(),
331		'header' => $headers,
332		'protocol_version' => $request->getProtocolVersion(),
333		'ignore_errors' => true,
334		'follow_location' => 0,
335		],
336		];
337
338		$body = (string) $request->getBody();
339
340		if (!empty($body)) {
341		$context['http']['content'] = $body;
342		// Prevent the HTTP handler from adding a Content-Type header.
343		if (!$request->hasHeader('Content-Type')) {
344		$context['http']['header'] .= "Content-Type:\r\n";
345		}
346		}
347
348		$context['http']['header'] = rtrim($context['http']['header']);
349
350		return $context;
351		}
352
353		private function add_proxy(RequestInterface $request, &$options, $value, &$params)
		0 ignored issues – show Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The parameter `$params` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
354		{
355		if (!is_array($value)) {
356		$options['http']['proxy'] = $value;
357		} else {
358		$scheme = $request->getUri()->getScheme();
359		if (isset($value[$scheme])) {
360		if (!isset($value['no'])
361		\|\| !\GuzzleHttp\is_host_in_noproxy(
362		$request->getUri()->getHost(),
363		$value['no']
364		)
365		) {
366		$options['http']['proxy'] = $value[$scheme];
367		}
368		}
369		}
370		}
371
372		private function add_timeout(RequestInterface $request, &$options, $value, &$params)
		0 ignored issues – show Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The parameter `$request` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The parameter `$params` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
373		{
374		if ($value > 0) {
375		$options['http']['timeout'] = $value;
376		}
377		}
378
379		private function add_verify(RequestInterface $request, &$options, $value, &$params)
		0 ignored issues – show Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The parameter `$request` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The parameter `$params` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
380		{
381		if ($value === true) {
382		// PHP 5.6 or greater will find the system cert by default. When
383		// < 5.6, use the Guzzle bundled cacert.
384		if (PHP_VERSION_ID < 50600) {
385		$options['ssl']['cafile'] = \GuzzleHttp\default_ca_bundle();
386		}
387		} elseif (is_string($value)) {
388		$options['ssl']['cafile'] = $value;
389		if (!file_exists($value)) {
390		throw new \RuntimeException("SSL CA bundle not found: $value");
391		}
392		} elseif ($value === false) {
393		$options['ssl']['verify_peer'] = false;
394		$options['ssl']['verify_peer_name'] = false;
395		return;
396		} else {
397		throw new \InvalidArgumentException('Invalid verify request option');
398		}
399
400		$options['ssl']['verify_peer'] = true;
401		$options['ssl']['verify_peer_name'] = true;
402		$options['ssl']['allow_self_signed'] = false;
403		}
404
405		private function add_cert(RequestInterface $request, &$options, $value, &$params)
		0 ignored issues – show Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The parameter `$request` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The parameter `$params` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
406		{
407		if (is_array($value)) {
408		$options['ssl']['passphrase'] = $value[1];
409		$value = $value[0];
410		}
411
412		if (!file_exists($value)) {
413		throw new \RuntimeException("SSL certificate not found: {$value}");
414		}
415
416		$options['ssl']['local_cert'] = $value;
417		}
418
419		private function add_progress(RequestInterface $request, &$options, $value, &$params)
		0 ignored issues – show Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The parameter `$request` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The parameter `$options` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
420		{
421		$this->addNotification(
422		$params,
423		function ($code, $a, $b, $c, $transferred, $total) use ($value) {
424		if ($code == STREAM_NOTIFY_PROGRESS) {
425		$value($total, $transferred, null, null);
426		}
427		}
428		);
429		}
430
431		private function add_debug(RequestInterface $request, &$options, $value, &$params)
		0 ignored issues – show Unused Code introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The parameter `$options` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
432		{
433		if ($value === false) {
434		return;
435		}
436
437		static $map = [
438		STREAM_NOTIFY_CONNECT => 'CONNECT',
439		STREAM_NOTIFY_AUTH_REQUIRED => 'AUTH_REQUIRED',
440		STREAM_NOTIFY_AUTH_RESULT => 'AUTH_RESULT',
441		STREAM_NOTIFY_MIME_TYPE_IS => 'MIME_TYPE_IS',
442		STREAM_NOTIFY_FILE_SIZE_IS => 'FILE_SIZE_IS',
443		STREAM_NOTIFY_REDIRECTED => 'REDIRECTED',
444		STREAM_NOTIFY_PROGRESS => 'PROGRESS',
445		STREAM_NOTIFY_FAILURE => 'FAILURE',
446		STREAM_NOTIFY_COMPLETED => 'COMPLETED',
447		STREAM_NOTIFY_RESOLVE => 'RESOLVE',
448		];
449		static $args = ['severity', 'message', 'message_code',
450		'bytes_transferred', 'bytes_max'];
451
452		$value = \GuzzleHttp\debug_resource($value);
453		$ident = $request->getMethod() . ' ' . $request->getUri()->withFragment('');
454		$this->addNotification(
455		$params,
456		function () use ($ident, $value, $map, $args) {
457		$passed = func_get_args();
458		$code = array_shift($passed);
459		fprintf($value, '<%s> [%s] ', $ident, $map[$code]);
460		foreach (array_filter($passed) as $i => $v) {
461		fwrite($value, $args[$i] . ': "' . $v . '" ');
462		}
463		fwrite($value, "\n");
464		}
465		);
466		}
467
468		private function addNotification(array &$params, callable $notify)
469		{
470		// Wrap the existing function if needed.
471		if (!isset($params['notification'])) {
472		$params['notification'] = $notify;
473		} else {
474		$params['notification'] = $this->callArray([
475		$params['notification'],
476		$notify
477		]);
478		}
479		}
480
481		private function callArray(array $functions)
482		{
483		return function () use ($functions) {
484		$args = func_get_args();
485		foreach ($functions as $fn) {
486		call_user_func_array($fn, $args);
487		}
488		};
489		}
490		}
491

godbout / alfred-time

Push — master ( 8d12ff...458df2 )

StreamHandler::createSink() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like