You are here

Home » API reference » Auth0 Single Sign On 8.2 » RequestException.php

class RequestException in Auth0 Single Sign On 8.2

HTTP Request exception

Hierarchy

  • class \GuzzleHttp\Exception\TransferException extends \GuzzleHttp\Exception\RuntimeException implements \GuzzleHttp\Exception\GuzzleException

Expanded class hierarchy of RequestException

7 files declare their use of RequestException
Auth0.php in vendor/auth0/auth0-php/src/Auth0.php
CurlFactory.php in vendor/guzzlehttp/guzzle/src/Handler/CurlFactory.php
JWKFetcher.php in vendor/auth0/auth0-php/src/Helpers/JWKFetcher.php
Middleware.php in vendor/guzzlehttp/guzzle/src/Middleware.php
MockHandler.php in vendor/guzzlehttp/guzzle/src/Handler/MockHandler.php

... See full list

File

vendor/guzzlehttp/guzzle/src/Exception/RequestException.php, line 12

Namespace

GuzzleHttp\Exception
View source 
class RequestException extends TransferException {

  /** @var RequestInterface */
  private $request;

  /** @var ResponseInterface|null */
  private $response;

  /** @var array */
  private $handlerContext;
  public function __construct($message, RequestInterface $request, ResponseInterface $response = null, \Exception $previous = null, array $handlerContext = []) {

    // Set the code of the exception if the response is set and not future.
    $code = $response && !$response instanceof PromiseInterface ? $response
      ->getStatusCode() : 0;
    parent::__construct($message, $code, $previous);
    $this->request = $request;
    $this->response = $response;
    $this->handlerContext = $handlerContext;
  }

  /**
   * Wrap non-RequestExceptions with a RequestException
   *
   * @param RequestInterface $request
   * @param \Exception       $e
   *
   * @return RequestException
   */
  public static function wrapException(RequestInterface $request, \Exception $e) {
    return $e instanceof RequestException ? $e : new RequestException($e
      ->getMessage(), $request, null, $e);
  }

  /**
   * Factory method to create a new exception with a normalized error message
   *
   * @param RequestInterface  $request  Request
   * @param ResponseInterface $response Response received
   * @param \Exception        $previous Previous exception
   * @param array             $ctx      Optional handler context.
   *
   * @return self
   */
  public static function create(RequestInterface $request, ResponseInterface $response = null, \Exception $previous = null, array $ctx = []) {
    if (!$response) {
      return new self('Error completing request', $request, null, $previous, $ctx);
    }
    $level = (int) floor($response
      ->getStatusCode() / 100);
    if ($level === 4) {
      $label = 'Client error';
      $className = ClientException::class;
    }
    elseif ($level === 5) {
      $label = 'Server error';
      $className = ServerException::class;
    }
    else {
      $label = 'Unsuccessful request';
      $className = __CLASS__;
    }
    $uri = $request
      ->getUri();
    $uri = static::obfuscateUri($uri);

    // Client Error: `GET /` resulted in a `404 Not Found` response:
    // <html> ... (truncated)
    $message = sprintf('%s: `%s %s` resulted in a `%s %s` response', $label, $request
      ->getMethod(), $uri, $response
      ->getStatusCode(), $response
      ->getReasonPhrase());
    $summary = static::getResponseBodySummary($response);
    if ($summary !== null) {
      $message .= ":\n{$summary}\n";
    }
    return new $className($message, $request, $response, $previous, $ctx);
  }

  /**
   * Get a short summary of the response
   *
   * Will return `null` if the response is not printable.
   *
   * @param ResponseInterface $response
   *
   * @return string|null
   */
  public static function getResponseBodySummary(ResponseInterface $response) {
    return \GuzzleHttp\Psr7\get_message_body_summary($response);
  }

  /**
   * Obfuscates URI if there is a username and a password present
   *
   * @param UriInterface $uri
   *
   * @return UriInterface
   */
  private static function obfuscateUri(UriInterface $uri) {
    $userInfo = $uri
      ->getUserInfo();
    if (false !== ($pos = strpos($userInfo, ':'))) {
      return $uri
        ->withUserInfo(substr($userInfo, 0, $pos), '***');
    }
    return $uri;
  }

  /**
   * Get the request that caused the exception
   *
   * @return RequestInterface
   */
  public function getRequest() {
    return $this->request;
  }

  /**
   * Get the associated response
   *
   * @return ResponseInterface|null
   */
  public function getResponse() {
    return $this->response;
  }

  /**
   * Check if a response was received
   *
   * @return bool
   */
  public function hasResponse() {
    return $this->response !== null;
  }

  /**
   * Get contextual information about the error from the underlying handler.
   *
   * The contents of this array will vary depending on which handler you are
   * using. It may also be just an empty array. Relying on this data will
   * couple you to a specific handler, but can give more debug information
   * when needed.
   *
   * @return array
   */
  public function getHandlerContext() {
    return $this->handlerContext;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
RequestException::$handlerContext private property @var array
RequestException::$request private property @var RequestInterface
RequestException::$response private property @var ResponseInterface|null
RequestException::create public static function Factory method to create a new exception with a normalized error message
RequestException::getHandlerContext public function Get contextual information about the error from the underlying handler.
RequestException::getRequest public function Get the request that caused the exception
RequestException::getResponse public function Get the associated response 1
RequestException::getResponseBodySummary public static function Get a short summary of the response
RequestException::hasResponse public function Check if a response was received 1
RequestException::obfuscateUri private static function Obfuscates URI if there is a username and a password present
RequestException::wrapException public static function Wrap non-RequestExceptions with a RequestException
RequestException::__construct public function 2