/**
* 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;
}
