/** * Returns object with properties int:status object:body * @param string $method * @param string $path * @param array $query * @param bool $doAuth * @throws \InvalidArgumentException * @throws \Exception * @return \stdClass */ public function request($method, $path, $query = array(), $doAuth = false) { $this->userAgent = 'Rocker REST Client v' . Server::VERSION; $method = strtolower($method); $request = $this->initiateRequest($method, $path, $query); if ($doAuth) { $this->addAuthHeader($request); } try { $this->lastResponse = $request->send(); } catch (\Guzzle\Http\Exception\ClientErrorResponseException $e) { $this->lastResponse = $e->getResponse(); if ($this->lastResponse->getStatusCode() == 401 && !$doAuth && !empty($this->user)) { trigger_error('Doing unauthenticated requests to an URI that requires authentication (' . $path . ')', E_WARNING); return $this->request($method, $path, $query, true); } } if ($this->lastResponse->getStatusCode() == 400) { throw new ClientException($this->lastResponse, 400); } if ($this->lastResponse->getStatusCode() == 204) { return (object) array('status' => 204, 'body' => array()); } if (strpos($this->lastResponse->getContentType(), 'json') === false) { throw new ClientException($this->lastResponse, ClientException::ERR_UNEXPECTED_CONTENT_TYPE, 'Server responded with unexpected content type (' . $this->lastResponse->getContentType() . ')'); } $str = (string) $this->lastResponse->getBody(); $body = json_decode($str); return (object) array('status' => $this->lastResponse->getStatusCode(), 'headers' => $this->headerCollectionToArray($this->lastResponse->getHeaders()), 'body' => $body); }
/** * @param Response $response * * @return string */ protected static function createMessage(Response $response) { if ($response->getStatusCode() != 400) { return '[' . $response->getStatusCode() . '] A HTTP error has occurred: ' . $response->getBody(true); } $message = 'Some errors occurred:'; foreach ($response->xml()->error as $error) { $message .= PHP_EOL . '[' . (string) $error->code . '] ' . (string) $error->message; } return $message; }
/** * Simple exception factory for creating Intercom standardised exceptions * * @param RequestInterface $request The Request * @param Response $response The response * @return BadResponseException */ public static function factory(RequestInterface $request, Response $response) { $response_json = $response->json(); $intercom_unavailable_error = NULL; if (!static::isValidIntercomError($response_json)) { if ($response->isServerError()) { $label = 'Server error response'; $class = __NAMESPACE__ . '\\ServerErrorResponseException'; $intercom_unavailable_error = 'Service Unavailable: Back-end server is at capacity'; } else { $label = 'Unsuccessful response'; $class = __CLASS__; } } elseif ($response->isClientError()) { $label = 'Client error response'; $class = __NAMESPACE__ . '\\ClientErrorResponseException'; } elseif ($response->isServerError()) { $label = 'Server error response'; $class = __NAMESPACE__ . '\\ServerErrorResponseException'; } else { $label = 'Unsuccessful response'; $class = __CLASS__; } $message = $label . PHP_EOL . implode(PHP_EOL, array('[status code] ' . $response->getStatusCode(), '[reason phrase] ' . $response->getReasonPhrase(), '[url] ' . $request->getUrl())); $e = new $class($message); $e->setResponse($response); $e->setRequest($request); // Sets the errors if the error response is the standard Intercom error type if (static::isValidIntercomError($response_json)) { $e->setErrors($response_json['errors']); } elseif ($intercom_unavailable_error != NULL) { $e->setErrors(array('code' => 'service_unavailable', "message" => $intercom_unavailable_error)); } return $e; }
/** * @throws HttpException */ protected function handleError() { $body = (string) $this->response->getBody(true); $code = (int) $this->response->getStatusCode(); $content = json_decode($body); throw new HttpException(isset($content->message) ? $content->message : 'Request not processed.', $code); }
/** * Simple exception factory for creating Intercom standardised exceptions * * @param RequestInterface $request The Request * @param Response $response The response * @return BadResponseException */ public static function factory(RequestInterface $request, Response $response) { if (!static::isValidIntercomError($response->json())) { $label = 'Unsuccessful response'; $class = __CLASS__; } elseif ($response->isClientError()) { $label = 'Client error response'; $class = __NAMESPACE__ . '\\ClientErrorResponseException'; } elseif ($response->isServerError()) { $label = 'Server error response'; $class = __NAMESPACE__ . '\\ServerErrorResponseException'; } else { $label = 'Unsuccessful response'; $class = __CLASS__; } $message = $label . PHP_EOL . implode(PHP_EOL, array('[status code] ' . $response->getStatusCode(), '[reason phrase] ' . $response->getReasonPhrase(), '[url] ' . $request->getUrl())); $e = new $class($message); $e->setResponse($response); $e->setRequest($request); // Sets the errors if the error response is the standard Intercom error type if (static::isValidIntercomError($response->json())) { $e->setErrors($response->json()['errors']); } return $e; }
/** * Determine an exception code from the given response, exception data and * JSON body. * * @param Response $response * @param array $data * @param array $json * * @return string|null */ private function determineCode(Response $response, array $data, array $json) { if (409 === $response->getStatusCode()) { return 'DocumentAlreadyExists'; } return $this->determineCodeFromErrors($data['errors']); }
/** * Validate the HTTP response and throw exceptions on errors * * @throws ServerException */ private function validateResponse() { if ($this->httpResponse->getStatusCode() !== 200) { $statusCode = $this->httpResponse->getStatusCode(); throw new ServerException('Server responded with HTTP status ' . $statusCode, $statusCode); } else { if (strpos($this->httpResponse->getHeader('Content-Type'), 'application/json') === false) { throw new ServerException('Server did not respond with the expected content-type (application/json)'); } } try { $this->httpResponse->json(); } catch (RuntimeException $e) { throw new ServerException($e->getMessage()); } }
/** * request error * @param \Guzzle\Common\Event $event */ public function onRequestError(Event $event) { $this->request = $event->offsetGet('request'); $this->response = $event->offsetGet('response'); $body = $this->response->getBody(true); switch ($this->response->getStatusCode()) { case 400: $this->error400($body); break; case 520: $this->error520($body); break; default: $this->commonError($body); break; } }
/** * Factory method to create a new Oauth exception. * * @param RequestInterface $request * @param Response $response * * @return OauthException */ public static function factory(RequestInterface $request, Response $response) { $message = 'Client error response' . PHP_EOL . implode(PHP_EOL, array('[status code] ' . $response->getStatusCode(), '[reason phrase] ' . $response->getReasonPhrase(), '[url] ' . $request->getUrl())); $e = new static($message); $e->setResponse($response); $e->setRequest($request); return $e; }
/** * Should return if sending the data was successful * * @return bool */ public function isSuccess() { $statuscode = $this->response->getStatusCode(); if (!in_array($statuscode, ['200', '204'])) { throw new \Exception('HTTP Code ' . $statuscode . ' ' . $this->response->getBody()); } return true; }
/** * {@inheritDoc} */ public static function fromCommand(CommandInterface $command, Response $response) { $errors = json_decode($response->getBody(true), true); $type = array_get($errors, 'error.type', null); $code = array_get($errors, 'error.code', null); $message = array_get($errors, 'error.message', null); $class = '\\Apache\\Usergrid\\Api\\Exception\\' . studly_case($type) . 'Exception'; if (class_exists($class)) { $exception = new $class($message, $response->getStatusCode()); } else { $exception = new static($message, $response->getStatusCode()); } $exception->setErrorType($type); $exception->setResponse($response); $exception->setRequest($command->getRequest()); return $exception; }
/** * Parses additional exception information from the response headers * * @param RequestInterface $request Request that was issued * @param Response $response The response from the request * @param array $data The current set of exception data */ protected function parseHeaders(RequestInterface $request, Response $response, array &$data) { $data['message'] = $response->getStatusCode() . ' ' . $response->getReasonPhrase(); if ($requestId = $response->getHeader('x-amz-request-id')) { $data['request_id'] = $requestId; $data['message'] .= " (Request-ID: {$requestId})"; } }
/** * {@inheritDoc} */ public static function fromCommand(CommandInterface $command, Response $response) { $errors = json_decode($response->getBody(true), true); $type = $errors['error']['type']; $message = isset($errors['error']['message']) ? $errors['error']['message'] : 'Unknown error'; $code = isset($errors['error']['code']) ? $errors['error']['code'] : null; // We can trigger very specific exception based on the type and code if ($type === 'card_error') { $exception = new CardErrorException($message, $response->getStatusCode()); } elseif ($type === 'invalid_request_error' && $code === 'rate_limit') { $exception = new ApiRateLimitException($message, $response->getStatusCode()); } else { $exception = new static($message, $response->getStatusCode()); } $exception->setRequest($command->getRequest()); $exception->setResponse($response); return $exception; }
protected function prepareResponse(Response $data) { if ($data->getStatusCode() != 200) { throw new \InvalidArgumentException($data->getReasonPhrase()); } $response = json_decode($data->getBody(), true); $this->validateResponse($response); return $response; }
/** * @param $statusCode * @param $url * @param RequestInterface $request * @param Response $response */ public function validate($statusCode, $url, RequestInterface $request, Response $response) { if ($response->getStatusCode() === $statusCode) { return; } $message = $url . ' gives a non-200 status code response.'; $this->logger->warning($message, array('request' => (string) $request, 'response' => (string) $response)); throw new RuntimeException($message . ' See logs.' . $response->serialize()); }
public function visit( CommandInterface $command, Response $response, Parameter $param, &$value, $context = null ) { $value[$param->getName()] = $response->getStatusCode(); }
/** * Check the response for an error. * * @param Response $response The response received. * * @param RequestInterface $request The request sent. * * @return void * * @throws \RuntimeException On any error. */ protected function checkError(Response $response, RequestInterface $request) { if ($response->getStatusCode() == 200 || $response->getStatusCode() == 201) { return; } switch ($response->getHeader('Content-Type')) { case 'text/plain': throw new \RuntimeException('Error: ' . $response->getBody(true) . ' URI: ' . $request->getUrl()); case 'application/json': $error = json_decode($response->getBody(true)); if (isset($error->message)) { throw new \RuntimeException($error->message . ' URI: ' . $request->getUrl()); } break; default: throw new \RuntimeException('Unknown Error: No error message was returned from the server - Code: ' . $response->getStatusCode() . ' URI: ' . $response->getRequest()->getUrl()); } }
protected function createResponse(\Guzzle\Http\Message\Response $gResponse, Request $request) { $response = new Response($gResponse->getBody(), $gResponse->getStatusCode()); foreach ($gResponse->getHeaderLines() as $header) { list($name, $value) = explode(':', $header, 2); $response->headers->set($name, $value); } return $this->prepareResponse($response, $request); }
protected function getDelay($retries, RequestInterface $request, Response $response = null, HttpException $e = null) { if ($response) { if ($response->isSuccessful()) { return false; } else { return isset($this->errorCodes[$response->getStatusCode()]) ? true : null; } } }
/** * Create an prepare an exception object * * @param RequestInterface $request Request * @param Response $response Response received * @param array $parts Parsed exception data * * @return \Exception */ protected function createException(RequestInterface $request, Response $response, array $parts) { $message = 'Status Code: ' . $response->getStatusCode() . PHP_EOL . 'Kinvey Request ID: ' . $parts['request_id'] . PHP_EOL . 'Kinvey Exception Type: ' . $parts['type'] . PHP_EOL . 'Kinvey Error Message: ' . $parts['description'] . PHP_EOL . 'Kinvey Debug: ' . $parts['debug']; $class = new KinveyResponseException($message); $class->setExceptionType($parts['type']); $class->setResponse($response); $class->setRequest($request); $class->setRequestId($parts['request_id']); $class->setDebug($parts['debug']); return $class; }
public static function factory(RequestInterface $request, Response $response) { $label = 'Bearer error response'; $bearerReason = self::headerToReason($response->getHeader("WWW-Authenticate")); $message = $label . PHP_EOL . implode(PHP_EOL, array('[status code] ' . $response->getStatusCode(), '[reason phrase] ' . $response->getReasonPhrase(), '[bearer reason] ' . $bearerReason, '[url] ' . $request->getUrl())); $e = new static($message); $e->setResponse($response); $e->setRequest($request); $e->setBearerReason($bearerReason); return $e; }
/** * Prepares an EmbeddedResponse from the original response and data * * @param Guzzle\Http\Message\Response $originalResponse * @param array $data * * @return Desk\Relationship\Resource\EmbeddedResponse */ public function createResponse(Response $originalResponse, array $data) { $statusCode = $originalResponse->getStatusCode(); $reasonPhrase = $originalResponse->getReasonPhrase(); $headers = $originalResponse->getHeaders(); $body = json_encode($data); // set reason phrase -- needs to be done vie $response = $this->newResponse($statusCode, $headers, $body); $response->setReasonPhrase($reasonPhrase); return $response; }
/** * Executing service description defined operations returns the result * @group unit */ public function testMagicOperationsReturnResult() { $responseData = array("this" => "that"); Phockito::when($this->mockResponse->getStatusCode())->return(200); Phockito::when($this->mockResponse->json())->return($this->testDescription); Phockito::when($this->mockRequest->send())->return($this->mockResponse); Phockito::when($this->client)->get(anything())->return($this->mockRequest); Phockito::when($this->client)->callParent(anything(), anything())->return($responseData); $result = $this->client->SomeOperation(array()); $this->assertEquals($result, $responseData); }
public function __construct(Response $response, $code = 0, $prevException = NULL) { $this->response = $response; $this->httpCode = $response->getStatusCode(); $message = $this->response->getBody(true); if ($j = json_decode($message)) { $message = $j->message; } # ([ string $message = "" [, int $code = 0 [, Exception $previous = NULL ]]] ) parent::__construct($message, 0, $prevException); }
/** * @param array $responseCollection * @return \CanalTP\AbstractGuzzle\Guzzle */ public function getMock(array $responseCollection) { $plugin = new MockPlugin(); foreach ($responseCollection as $response) { if ($response instanceof Psr7Response) { $response = new Response($response->getStatusCode(), $response->getHeaders(), $response->getBody()); } $plugin->addResponse($response); } $client = GuzzleFactory::createClient(''); $client->addSubscriber($plugin); return $client; }
/** * Reads response meta tags to guess content-type charset. */ protected function createResponse(GuzzleResponse $response) { $body = $response->getBody(true); $statusCode = $response->getStatusCode(); $headers = $response->getHeaders()->getAll(); $contentType = $response->getContentType(); if (!$contentType || false === strpos($contentType, 'charset=')) { if (preg_match('/\\<meta[^\\>]+charset *= *["\']?([a-zA-Z\\-0-9]+)/i', $body, $matches)) { $contentType .= ';charset=' . $matches[1]; } } $headers['Content-Type'] = $contentType; return new Response($body, $statusCode, $headers); }
/** * @param Event $event * * @throws \RuntimeException|ExceptionInterface */ protected function handleResponse(Event $event) { $this->response = $event['response']; if ($this->response->isSuccessful()) { return; } $body = $this->response->getBody(true); $code = $this->response->getStatusCode(); if ($this->exception) { throw $this->exception->create($body, $code); } $content = json_decode($body); throw new \RuntimeException(sprintf('[%d] %s (%s)', $code, $content->message, $content->id), $code); }
/** * Get the amount of time to delay in seconds before retrying a request * * @param int $retries Number of retries of the request * @param RequestInterface $request Request that was sent * @param Response $response Response that was received. Note that there may not be a response * @param HttpException $e Exception that was encountered if any * * @return bool|int Returns false to not retry or the number of seconds to delay between retries */ public function getBackoffPeriod($retries, RequestInterface $request, Response $response = null, HttpException $e = null) { if (!$response) { return false; } if ($response->getStatusCode() != 429) { return false; } $reset = (string) $response->getHeader('X-Rate-Limit-Reset'); if (!preg_match('/^[0-9]+$/', $reset)) { return false; } return ((int) $reset + 0.1) * $this->getMultiplier(); }
/** * {@inheritdoc} */ protected function getDelay($retries, RequestInterface $request, Response $response = null, HttpException $e = null) { if ($response && $response->getStatusCode() == 400 && strpos($response->getBody(), self::ERR)) { // Check if the request is sending a local file, and if so, clear the stat cache and recalculate the size. if ($request instanceof EntityEnclosingRequestInterface) { if ($request->getBody()->getWrapper() == 'plainfile') { $filename = $request->getBody()->getUri(); // Clear the cache so that we send accurate file sizes clearstatcache(true, $filename); $length = filesize($filename); $request->getBody()->setSize($length); $request->setHeader('Content-Length', $length); } } return true; } }
/** * @param \Guzzle\Http\Message\Response $guzzleResponse * @param ActionsInterface $action * @return Response */ public static function parseGuzzleResponse(\Guzzle\Http\Message\Response $guzzleResponse, ActionsInterface $action) { $response = new self(); if ($guzzleResponse->getStatusCode() != 200) { $response->setStatus(false); $response->setError($response::ERROR_REQUEST_ERROR); return $response; } $responseArray = json_decode($guzzleResponse->getBody(true), true); $response->setStatus($responseArray['ok']); if ($response->getStatus() === false) { $response->setError($responseArray['error']); return $response; } $response->setData($action->parseResponse($responseArray)); return $response; }