PHP RequestException::getRequest方法代码示例

 /**
  * Converts a Guzzle exception into an Httplug exception.
  *
  * @param RequestException $exception
  *
  * @return Exception
  */
 private function createException(RequestException $exception)
 {
     if ($exception->hasResponse()) {
         return new HttpException($exception->getMessage(), $exception->getRequest(), $exception->getResponse(), $exception);
     }
     return new NetworkException($exception->getMessage(), $exception->getRequest(), $exception);
 }

 /**
  * Handles a Request Exception.
  *
  * @param RequestException $e The request exception.
  *
  * @return void
  */
 protected function onRequestException(RequestException $e)
 {
     $request = $e->getRequest();
     $response = $e->getResponse();
     $statusCode = $response->getStatusCode();
     $isClientError = $response->isClientError();
     $isServerError = $response->isServerError();
     if ($isClientError || $isServerError) {
         $content = $response->getContent();
         $error = $response->getError();
         $description = $response->getErrorDescription();
         if (400 === $statusCode) {
             throw new BadRequestException($description, $error, $statusCode, $response, $request);
         }
         if (401 === $statusCode) {
             $otp = (string) $response->getHeader('X-Bitreserve-OTP');
             if ('required' === $otp) {
                 $description = 'Two factor authentication is enabled on this account';
                 throw new TwoFactorAuthenticationRequiredException($description, $error, $statusCode, $response, $request);
             }
             throw new AuthenticationRequiredException($description, $error, $statusCode, $response, $request);
         }
         if (404 === $statusCode) {
             $description = sprintf('Object or route not found: %s', $request->getPath());
             throw new NotFoundException($description, 'not_found', $statusCode, $response, $request);
         }
         if (429 === $statusCode) {
             $rateLimit = $response->getApiRateLimit();
             $description = sprintf('You have reached Bitreserve API limit. API limit is: %s. Your remaining requests will be reset at %s.', $rateLimit['limit'], date('Y-m-d H:i:s', $rateLimit['reset']));
             throw new ApiLimitExceedException($description, $error, $statusCode, $response, $request);
         }
         throw new RuntimeException($description, $error, $statusCode, $response, $request);
     }
 }

 private function manejar_excepcion_request(RequestException $e)
 {
     $msg = $e->getRequest() . "\n";
     if ($e->hasResponse()) {
         $msg .= $e->getResponse() . "\n";
     }
     throw new toba_error($msg);
 }

 public function testHasRequestAndResponse()
 {
     $req = new Request('GET', '/');
     $res = new Response(200);
     $e = new RequestException('foo', $req, $res);
     $this->assertSame($req, $e->getRequest());
     $this->assertSame($res, $e->getResponse());
     $this->assertTrue($e->hasResponse());
     $this->assertEquals('foo', $e->getMessage());
 }

 /**
  * Wraps an API exception in the appropriate domain exception.
  *
  * @param RequestException $e The API exception
  *
  * @return HttpException
  */
 public static function wrap(RequestException $e)
 {
     $response = $e->getResponse();
     if ($errors = self::errors($response)) {
         $class = self::exceptionClass($response, $errors[0]);
         $message = implode(', ', array_map('strval', $errors));
     } else {
         $class = self::exceptionClass($response);
         $message = $e->getMessage();
     }
     return new $class($message, $errors, $e->getRequest(), $response, $e);
 }

 public function __construct(RequestException $e)
 {
     $message = $e->getMessage();
     if ($e instanceof ClientException) {
         $response = $e->getResponse();
         $responseBody = $response->getBody()->getContents();
         $this->errorDetails = $responseBody;
         $message .= ' [details] ' . $this->errorDetails;
     } elseif ($e instanceof ServerException) {
         $message .= ' [details] Zendesk may be experiencing internal issues or undergoing scheduled maintenance.';
     } elseif (!$e->hasResponse()) {
         $request = $e->getRequest();
         // Unsuccessful response, log what we can
         $message .= ' [url] ' . $request->getUri();
         $message .= ' [http method] ' . $request->getMethod();
     }
     parent::__construct($message, $e->getCode());
 }

 public function __construct(RequestException $e)
 {
     $this->request = $e->getRequest();
     $this->response = $e->getResponse();
     $simpleMessage = $e->getMessage();
     $code = 0;
     if ($this->response) {
         try {
             $decodedJson = Utils::jsonDecode((string) $this->response->getBody(), true);
             if ($decodedJson && isset($decodedJson['errorType'])) {
                 $simpleMessage = $decodedJson['errorType'] . ' ' . $decodedJson['message'];
             }
         } catch (\InvalidArgumentException $e) {
             // Not Json
         }
         $code = $this->response->getStatusCode();
     }
     $responseDescription = $this->response ? (string) $this->response : 'none';
     $requestDescription = $this->request ? (string) $this->request : 'none';
     $message = sprintf("%s\n\nRequest: %s\n\nResponse: %s\n\n", $simpleMessage, $requestDescription, $responseDescription);
     parent::__construct($message, $code, $e);
 }

 /**
  * @param RequestException $e
  *
  * @return ClientError|ServerError
  */
 private function createRequestException(RequestException $e)
 {
     $response = $e->getResponse();
     $responseBody = $response->getBody()->getContents();
     try {
         $status = $this->serializer->deserialize($responseBody, Status::class, 'json');
     } catch (\RuntimeException $serializerException) {
         $status = new Status(Status::FAILURE, $responseBody);
     }
     $exceptionClass = $e instanceof ClientException ? ClientError::class : ServerError::class;
     return new $exceptionClass($status, $e->getRequest());
 }

 /**
  * @param RequestException $exception
  *
  * @return string
  */
 private function create401ErrorMessage(RequestException $exception)
 {
     $request = $exception->getRequest();
     $response = $exception->getResponse();
     return $this->getExceptionMessage($request, $response);
 }

 /**
  * @author WN
  * @param Exception\RequestException $e
  * @return array
  */
 private function formatRequestException(Exception\RequestException $e)
 {
     return ['message' => $e->getMessage(), 'request' => ['headers' => $e->getRequest()->getHeaders(), 'body' => $e->getRequest()->getBody()->getContents(), 'method' => $e->getRequest()->getMethod(), 'uri' => $e->getRequest()->getUri()]];
 }

 public function __construct(\GuzzleHttp\Exception\RequestException $exception)
 {
     parent::__construct($exception->getMessage(), $exception->getRequest(), $exception->getResponse(), $exception->getPrevious(), $exception->getHandlerContext());
 }

 private function handleException(RequestException $exception)
 {
     if ($exception->getCode() === self::STREAM_DOES_NOT_EXIST) {
         throw new StreamDoesNotExist($exception->getMessage());
     }
     if ($exception->getCode() === self::REQUEST_BODY_INVALID && empty(json_decode($exception->getRequest()->getBody()))) {
         throw new CannotWriteStreamWithoutEvents($exception->getMessage());
     }
     throw new EventStoreConnectionFailed($exception->getMessage());
 }

 /**
  * Manage exception in http call.
  *
  * @param RequestException $exception
  *
  * @throw RuntimeException.
  */
 protected function manageException(RequestException $exception)
 {
     $errorMessage = $exception->getMessage() . ' Request: ' . $exception->getRequest();
     if ($exception->hasResponse()) {
         $errorMessage .= ' ErrorCode: ' . $exception->getResponse()->getStatusCode() . ' Response: ' . $exception->getResponse()->getBody();
     }
     throw new RuntimeException($errorMessage);
 }

 /**
  * Method will elaborate on RequestException.
  *
  * @param RequestException $e
  *
  * @throws SalesforceException
  * @throws TokenExpiredException
  */
 private function assignExceptions(RequestException $e)
 {
     if ($e->hasResponse() && $e->getResponse()->getStatusCode() == '401') {
         throw new TokenExpiredException(sprintf('Salesforce token has expired'));
     } elseif ($e->hasResponse()) {
         throw new SalesforceException(sprintf('Salesforce response error: %s', $e->getResponse()));
     } else {
         throw new SalesforceException(sprintf('Invalid request: %s', $e->getRequest()));
     }
 }