HttpRequestFactory.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Http;
 
use CurlHttpRequest;
use GuzzleHttp\Client;
use GuzzleHttpRequest;
use Http;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Logger\LoggerFactory;
use MultiHttpClient;
use MWHttpRequest;
use PhpHttpRequest;
use Profiler;
use Psr\Log\LoggerInterface;
use RuntimeException;
use Status;
 
class HttpRequestFactory {
    private $options;
    private $logger;
 
    public const CONSTRUCTOR_OPTIONS = [
        'HTTPTimeout',
        'HTTPConnectTimeout',
        'HTTPMaxTimeout',
        'HTTPMaxConnectTimeout',
    ];
 
    public function __construct( ServiceOptions $options, LoggerInterface $logger ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->options = $options;
        $this->logger = $logger;
    }
 
    public function create( $url, array $options = [], $caller = __METHOD__ ) {
        if ( !Http::$httpEngine ) {
            Http::$httpEngine = 'guzzle';
        }
 
        if ( !isset( $options['logger'] ) ) {
            $options['logger'] = $this->logger;
        }
        $options['timeout'] = $this->normalizeTimeout(
            $options['timeout'] ?? null,
            $options['maxTimeout'] ?? null,
            $this->options->get( 'HTTPTimeout' ),
            $this->options->get( 'HTTPMaxTimeout' )
        );
        $options['connectTimeout'] = $this->normalizeTimeout(
            $options['connectTimeout'] ?? null,
            $options['maxConnectTimeout'] ?? null,
            $this->options->get( 'HTTPConnectTimeout' ),
            $this->options->get( 'HTTPMaxConnectTimeout' )
        );
 
        switch ( Http::$httpEngine ) {
            case 'guzzle':
                return new GuzzleHttpRequest( $url, $options, $caller, Profiler::instance() );
            case 'curl':
                return new CurlHttpRequest( $url, $options, $caller, Profiler::instance() );
            case 'php':
                return new PhpHttpRequest( $url, $options, $caller, Profiler::instance() );
            default:
                throw new RuntimeException( __METHOD__ . ': The requested engine is not valid.' );
        }
    }
 
    private function normalizeTimeout( $parameter, $maxParameter, $default, $maxConfigured ) {
        if ( $parameter === 'default' || $parameter === null ) {
            if ( !is_numeric( $default ) ) {
                throw new \InvalidArgumentException(
                    '$wgHTTPTimeout and $wgHTTPConnectTimeout must be set to a number' );
            }
            $value = $default;
        } else {
            $value = $parameter;
        }
        if ( $maxParameter !== null ) {
            $max = $maxParameter;
        } else {
            $max = $maxConfigured;
        }
        if ( $max && $value > $max ) {
            return $max;
        } else {
            return $value;
        }
    }
 
    public function canMakeRequests() {
        return function_exists( 'curl_init' ) || wfIniGetBool( 'allow_url_fopen' );
    }
 
    public function request( $method, $url, array $options = [], $caller = __METHOD__ ) {
        $logger = LoggerFactory::getInstance( 'http' );
        $logger->debug( "$method: $url" );
 
        $options['method'] = strtoupper( $method );
 
        $req = $this->create( $url, $options, $caller );
        $status = $req->execute();
 
        if ( $status->isOK() ) {
            return $req->getContent();
        } else {
            $errors = $status->getErrorsByType( 'error' );
            $logger->warning( Status::wrap( $status )->getWikiText( false, false, 'en' ),
                [ 'error' => $errors, 'caller' => $caller, 'content' => $req->getContent() ] );
            return null;
        }
    }
 
    public function get( $url, array $options = [], $caller = __METHOD__ ) {
        return $this->request( 'GET', $url, $options, $caller );
    }
 
    public function post( $url, array $options = [], $caller = __METHOD__ ) {
        return $this->request( 'POST', $url, $options, $caller );
    }
 
    public function getUserAgent() {
        return 'MediaWiki/' . MW_VERSION;
    }
 
    public function createMultiClient( $options = [] ) {
        $options['reqTimeout'] = $this->normalizeTimeout(
            $options['reqTimeout'] ?? $options['timeout'] ?? null,
            $options['maxReqTimeout'] ?? $options['maxTimeout'] ?? null,
            $this->options->get( 'HTTPTimeout' ),
            $this->options->get( 'HTTPMaxTimeout' )
        );
        $options['connTimeout'] = $this->normalizeTimeout(
            $options['connTimeout'] ?? $options['connectTimeout'] ?? null,
            $options['maxConnTimeout'] ?? $options['maxConnectTimeout'] ?? null,
            $this->options->get( 'HTTPConnectTimeout' ),
            $this->options->get( 'HTTPMaxConnectTimeout' )
        );
        $options += [
            'maxReqTimeout' => $this->options->get( 'HTTPMaxTimeout' ),
            'maxConnTimeout' => $this->options->get( 'HTTPMaxConnectTimeout' ),
            'userAgent' => $this->getUserAgent(),
            'logger' => $this->logger
        ];
        return new MultiHttpClient( $options );
    }
 
    public function createGuzzleClient( array $config = [] ): Client {
        $config['timeout'] = $this->normalizeTimeout(
            $config['timeout'] ?? null,
            $config['maxTimeout'] ?? null,
            $this->options->get( 'HTTPTimeout' ),
            $this->options->get( 'HTTPMaxTimeout' )
        );
 
        $config['connect_timeout'] = $this->normalizeTimeout(
            $config['connect_timeout'] ?? null,
            $config['maxConnectTimeout'] ?? null,
            $this->options->get( 'HTTPConnectTimeout' ),
            $this->options->get( 'HTTPMaxConnectTimeout' )
        );
 
        if ( !isset( $config['headers']['User-Agent'] ) ) {
            $config['headers']['User-Agent'] = $this->getUserAgent();
        }
 
        return new Client( $config );
    }
}