GuzzleHttpRequest.php

Go to the documentation of this file.

<?php
use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Request;

class GuzzleHttpRequest extends MWHttpRequest {
    const SUPPORTS_FILE_POSTS = true;

    protected $handler = null;
    protected $sink = null;
    protected $guzzleOptions = [ 'http_errors' => false ];

    public function __construct(
        $url, array $options = [], $caller = __METHOD__, Profiler $profiler = null
    ) {
        parent::__construct( $url, $options, $caller, $profiler );

        if ( isset( $options['handler'] ) ) {
            $this->handler = $options['handler'];
        }
        if ( isset( $options['sink'] ) ) {
            $this->sink = $options['sink'];
        }
    }

    public function setCallback( $callback ) {
        $this->sink = null;
        $this->doSetCallback( $callback );
    }

    protected function doSetCallback( $callback ) {
        if ( !$this->sink ) {
            parent::doSetCallback( $callback );
            $this->sink = new MWCallbackStream( $this->callback );
        }
    }

    public function execute() {
        $this->prepare();

        if ( !$this->status->isOK() ) {
            return Status::wrap( $this->status ); // TODO B/C; move this to callers
        }

        if ( $this->proxy ) {
            $this->guzzleOptions['proxy'] = $this->proxy;
        }

        $this->guzzleOptions['timeout'] = $this->timeout;
        $this->guzzleOptions['connect_timeout'] = $this->connectTimeout;
        $this->guzzleOptions['version'] = '1.1';

        if ( !$this->followRedirects ) {
            $this->guzzleOptions['allow_redirects'] = false;
        } else {
            $this->guzzleOptions['allow_redirects'] = [
                'max' => $this->maxRedirects
            ];
        }

        if ( $this->method == 'POST' ) {
            $postData = $this->postData;
            if ( is_array( $postData ) ) {
                $this->guzzleOptions['form_params'] = $postData;
            } else {
                $this->guzzleOptions['body'] = $postData;
            }

            // Suppress 'Expect: 100-continue' header, as some servers
            // will reject it with a 417 and Curl won't auto retry
            // with HTTP 1.0 fallback
            $this->guzzleOptions['expect'] = false;
        }

        $this->guzzleOptions['headers'] = $this->reqHeaders;

        if ( $this->handler ) {
            $this->guzzleOptions['handler'] = $this->handler;
        }

        if ( $this->sink ) {
            $this->guzzleOptions['sink'] = $this->sink;
        }

        if ( $this->caInfo ) {
            $this->guzzleOptions['verify'] = $this->caInfo;
        } elseif ( !$this->sslVerifyHost && !$this->sslVerifyCert ) {
            $this->guzzleOptions['verify'] = false;
        }

        try {
            $client = new Client( $this->guzzleOptions );
            $request = new Request( $this->method, $this->url );
            $response = $client->send( $request );
            $this->headerList = $response->getHeaders();

            $this->respVersion = $response->getProtocolVersion();
            $this->respStatus = $response->getStatusCode() . ' ' . $response->getReasonPhrase();
        } catch ( GuzzleHttp\Exception\ConnectException $e ) {
            // ConnectException is thrown for several reasons besides generic "timeout":
            //   Connection refused
            //   couldn't connect to host
            //   connection attempt failed
            //   Could not resolve IPv4 address for host
            //   Could not resolve IPv6 address for host
            if ( $this->usingCurl() ) {
                $handlerContext = $e->getHandlerContext();
                if ( $handlerContext['errno'] == CURLE_OPERATION_TIMEOUTED ) {
                    $this->status->fatal( 'http-timed-out', $this->url );
                } else {
                    $this->status->fatal( 'http-curl-error', $handlerContext['error'] );
                }
            } else {
                $this->status->fatal( 'http-request-error' );
            }
        } catch ( GuzzleHttp\Exception\RequestException $e ) {
            if ( $this->usingCurl() ) {
                $handlerContext = $e->getHandlerContext();
                $this->status->fatal( 'http-curl-error', $handlerContext['error'] );
            } else {
                // Non-ideal, but the only way to identify connection timeout vs other conditions
                $needle = 'Connection timed out';
                if ( strpos( $e->getMessage(), $needle ) !== false ) {
                    $this->status->fatal( 'http-timed-out', $this->url );
                } else {
                    $this->status->fatal( 'http-request-error' );
                }
            }
        } catch ( GuzzleHttp\Exception\GuzzleException $e ) {
            $this->status->fatal( 'http-internal-error' );
        }

        if ( $this->profiler ) {
            $profileSection = $this->profiler->scopedProfileIn(
                __METHOD__ . '-' . $this->profileName
            );
        }

        if ( $this->profiler ) {
            $this->profiler->scopedProfileOut( $profileSection );
        }

        $this->parseHeader();
        $this->setStatus();

        return Status::wrap( $this->status ); // TODO B/C; move this to callers
    }

    protected function prepare() {
        $this->doSetCallback( $this->callback );
        parent::prepare();
    }

    protected function usingCurl() {
        return ( $this->handler && is_a( $this->handler, 'GuzzleHttp\Handler\CurlHandler' ) ) ||
            ( !$this->handler && extension_loaded( 'curl' ) );
    }

    protected function parseHeader() {
        // Failure without (valid) headers gets a response status of zero
        if ( !$this->status->isOK() ) {
            $this->respStatus = '0 Error';
        }

        foreach ( $this->headerList as $name => $values ) {
            $this->respHeaders[strtolower( $name )] = $values;
        }

        $this->parseCookies();
    }
}