/**
* {@inheritdoc}
*/
public function getLatestResponseHeaders()
{
if (null === $this->response) {
return;
}
return array('reset' => (int) (string) $this->response->getHeader('RateLimit-Reset'), 'remaining' => (int) (string) $this->response->getHeader('RateLimit-Remaining'), 'limit' => (int) (string) $this->response->getHeader('RateLimit-Limit'));
}
public function decode(ResponseInterface $raw, $totalTime = 0)
{
$executionTime = $callTime = 0;
if ($raw->hasHeader('X-Execution-Time')) {
$executionTime = $raw->getHeader('X-Execution-Time');
}
if ($raw->hasHeader('X-Call-Time')) {
$callTime = $raw->getHeader('X-Call-Time');
}
$body = '';
try {
$body = (string) $raw->getBody();
$result = $this->_getDecoder()->decode($body, self::FORMAT, $this->_getDecodeContext());
} catch (\Exception $e) {
if (!empty($body)) {
$body = ' (' . $body . ')';
}
error_log("Invalid API Response: " . $body);
throw new InvalidApiResponseException("Unable to decode raw api response.", 500, $e);
}
if (!property_exists($result, 'type') || !property_exists($result, 'status') || !property_exists($result, 'result') || !property_exists($result->status, 'message') || !property_exists($result->status, 'code')) {
error_log("Invalid API Result: " . json_encode($result));
throw new InvalidApiResponseException("Invalid api result", 500);
}
if ($executionTime === 0) {
$executionTime = $totalTime;
}
if ($callTime === 0) {
$callTime = $executionTime;
}
return ResponseBuilder::create(ApiCallData::create($result->type, $result->result, $result->status->code, $result->status->message, (double) str_replace([',', 'ms'], '', $totalTime), (double) str_replace([',', 'ms'], '', $executionTime), (double) str_replace([',', 'ms'], '', $callTime)));
}
/**
* Gets the age of a response in seconds.
*
* @param ResponseInterface $response
*
* @return int
*/
public static function getResponseAge(ResponseInterface $response)
{
if ($response->hasHeader('Age')) {
return (int) $response->getHeader('Age');
}
$date = strtotime($response->getHeader('Date') ?: 'now');
return time() - $date;
}
/**
* @param ResponseInterface $response raw json response
* @param bool $throw Should throw API errors as exceptions
*
* @throws \Exception
*/
public function __construct(ResponseInterface $response = null, $throw = true)
{
if ($response !== null) {
$this->_executionTime = $response->getHeader('X-Execution-Time');
$this->_callTime = $response->getHeader('X-Call-Time');
$this->readJson((string) $response->getBody(), $throw);
}
}
protected function getResponse(GuzzleResponse $response)
{
if (strpos($response->getHeader('Content-Type'), 'json')) {
$returnResponse = new JsonResponse($response->getBody());
} elseif (strpos($response->getHeader('Content-Type'), 'xml')) {
$returnResponse = new XmlResponse($response->xml());
} else {
throw new \Exception('Unknow return type');
}
return $returnResponse;
}
/**
* Gets the Location header.
*
* @throws \RuntimeException If the Location header is missing
*
* @return string
*/
public function getLocation()
{
if (!$this->response->hasHeader('Location')) {
throw new \RuntimeException('Response is missing a Location header');
}
return $this->response->getHeader('Location');
}
/**
* @param ResponseInterface $response
*
* @return ApiResult
*/
protected function _getResult($response)
{
if (!$response instanceof ResponseInterface) {
throw new \InvalidArgumentException("{$response} should be an instance of ResponseInterface");
}
$result = new ApiResult();
$result->setStatusCode($response->getStatusCode());
$callId = $response->getHeader('X-Call-Id');
if (!empty($callId)) {
$result->setCallId($callId);
}
$decoded = json_decode((string) $response->getBody());
if (isset($decoded->meta) && isset($decoded->data) && isset($decoded->meta->code) && $decoded->meta->code == $response->getStatusCode()) {
$meta = $decoded->meta;
$data = $decoded->data;
if (isset($meta->message)) {
$result->setStatusMessage($meta->message);
}
$result->setContent(json_encode($data));
} else {
$result->setContent((string) $response->getBody());
}
$result->setHeaders($response->getHeaders());
return $result;
}
function it_should_make_post_request(ResponseInterface $responce)
{
$responce->getHeader("Content-Type")->willReturn('blablaxmlblabla');
$responce->getBody()->willReturn('<xml></xml>');
$this->client->post(Argument::any(), Argument::any())->willReturn($responce);
$responce->xml()->willReturn(new \SimpleXMLElement('<xml></xml>'));
$this->post(Argument::type('string'))->shouldBeAnInstanceOf('Bxav\\Component\\ResellerClub\\Model\\XmlResponse');
}
public function visit(GuzzleCommandInterface $command, ResponseInterface $response, Parameter $param, &$result, array $context = array())
{
// Retrieving a single header by name
$name = $param->getName();
if ($header = $response->getHeader($param->getWireName())) {
$result[$name] = $param->filter($header);
}
}
private function parseHeaders(ResponseInterface $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})";
}
}
/**
* @Then the response is oauth2 format
*/
public function theResponseHasTheOAuth2Format()
{
$expectedHeaders = ['cache-control' => 'no-store', 'pragma' => 'no-cache'];
foreach ($expectedHeaders as $name => $value) {
if ($this->response->getHeader($name) != $value) {
throw new \Exception(sprintf("Header %s is should be %s, %s given", $name, $value, $this->response->getHeader($name)));
}
}
}
/**
* Populates the current resource from a response object.
*
* @param ResponseInterface $response
*
* @return $this|ResourceInterface
*/
public function populateFromResponse(ResponseInterface $response)
{
if (strpos($response->getHeader('Content-Type'), 'application/json') === 0) {
$json = $response->json();
if (!empty($json)) {
$this->populateFromArray($this->flatten($json));
}
}
return $this;
}
public function parse(ResponseInterface $response)
{
$collection = new Collection();
if (!$response->getBody()) {
return $collection;
}
// help bad responses be more multipart compliant
$body = "\r\n" . $response->getBody()->__toString() . "\r\n";
// multipart
preg_match('/boundary\\=\\"(.*?)\\"/', $response->getHeader('Content-Type'), $matches);
if (isset($matches[1])) {
$boundary = $matches[1];
} else {
preg_match('/boundary\\=(.*?)(\\s|$|\\;)/', $response->getHeader('Content-Type'), $matches);
$boundary = $matches[1];
}
// strip quotes off of the boundary
$boundary = preg_replace('/^\\"(.*?)\\"$/', '\\1', $boundary);
// clean up the body to remove a reamble and epilogue
$body = preg_replace('/^(.*?)\\r\\n--' . $boundary . '\\r\\n/', "\r\n--{$boundary}\r\n", $body);
// make the last one look like the rest for easier parsing
$body = preg_replace('/\\r\\n--' . $boundary . '--/', "\r\n--{$boundary}\r\n", $body);
// cut up the message
$multi_parts = explode("\r\n--{$boundary}\r\n", $body);
// take off anything that happens before the first boundary (the preamble)
array_shift($multi_parts);
// take off anything after the last boundary (the epilogue)
array_pop($multi_parts);
$message_parser = new MessageParser();
$parser = new Single();
// go through each part of the multipart message
foreach ($multi_parts as $part) {
// get Guzzle to parse this multipart section as if it's a whole HTTP message
$parts = $message_parser->parseResponse("HTTP/1.1 200 OK\r\n" . $part);
// now throw this single faked message through the Single GetObject response parser
$single = new Response($parts['code'], $parts['headers'], Stream::factory($parts['body']));
$obj = $parser->parse($single);
// add information about this multipart to the returned collection
$collection->push($obj);
}
return $collection;
}
/**
* Asserts response match with the response schema.
*
* @param ResponseInterface $response
* @param SchemaManager $schemaManager
* @param string $path percent-encoded path used on the request.
* @param string $httpMethod
* @param string $message
*/
public function assertResponseMatch(ResponseInterface $response, SchemaManager $schemaManager, $path, $httpMethod, $message = '')
{
$this->assertResponseMediaTypeMatch($response->getHeader('Content-Type'), $schemaManager, $path, $httpMethod, $message);
$httpCode = $response->getStatusCode();
$headers = $response->getHeaders();
foreach ($headers as &$value) {
$value = implode(', ', $value);
}
$this->assertResponseHeadersMatch($headers, $schemaManager, $path, $httpMethod, $httpCode, $message);
$this->assertResponseBodyMatch($response->json(['object' => true]), $schemaManager, $path, $httpMethod, $httpCode, $message);
}
public function parseMetadata(ResponseInterface $response)
{
$metadata = [];
foreach ($response->getHeaders() as $header => $value) {
$position = strpos($header, static::METADATA_PREFIX);
if ($position === 0) {
$metadata[ltrim($header, static::METADATA_PREFIX)] = $response->getHeader($header);
}
}
return $metadata;
}
/**
* @Then The following headers should be set
* @param \Behat\Gherkin\Node\TableNode $table
* @throws \Exception
*/
public function theFollowingHeadersShouldBeSet(\Behat\Gherkin\Node\TableNode $table)
{
foreach ($table->getTable() as $header) {
$headerName = $header[0];
$expectedHeaderValue = $header[1];
$returnedHeader = $this->response->getHeader($headerName);
if ($returnedHeader !== $expectedHeaderValue) {
throw new \Exception(sprintf("Expected value '%s' for header '%s', got '%s'", $expectedHeaderValue, $headerName, $returnedHeader));
}
}
}
/**
* @param \GuzzleHttp\Message\ResponseInterface $response
* @param \GuzzleHttp\Message\MessageParser $parser
* @param \GuzzleHttp\Message\MessageFactoryInterface $messageFactory
*/
public function __construct(ResponseInterface $response, MessageParser $parser = null, MessageFactoryInterface $messageFactory = null)
{
$matches = null;
$body = $response->getBody();
$header = $response->getHeader('Content-Type');
if (!preg_match('/boundary=(.*)$/', $header, $matches) || !isset($matches[1])) {
throw new InvalidArgumentException("Unable to parse boundary from content type : '{$header}'");
}
$this->response = $response;
$this->parser = $parser ?: new MessageParser();
$this->factory = $messageFactory ?: new MessageFactory();
$this->iterator = new MultipartStreamIterator($body, $matches[1]);
}
/**
* @param RequestInterface|ResponseInterface $message
* @return string
*/
protected function formatBody($message)
{
$header = $message->getHeader('Content-Type');
if (JsonStringFormatter::isJsonHeader($header)) {
$formatter = new JsonStringFormatter();
return $formatter->format($message->getBody());
} elseif (XmlStringFormatter::isXmlHeader($header)) {
$formatter = new XmlStringFormatter();
return $formatter->format($message->getBody());
}
$factory = new StringFactoryFormatter();
return $factory->format($message->getBody());
}
public function parseResponse(ResponseInterface $response, $classes = array())
{
$contentType = $response->getHeader('content-type');
$contentType = explode(';', $contentType);
$boundary = false;
foreach ($contentType as $part) {
$part = explode('=', $part, 2);
if (isset($part[0]) && 'boundary' == trim($part[0])) {
$boundary = $part[1];
}
}
$body = (string) $response->getBody();
if (!empty($body)) {
$body = str_replace("--{$boundary}--", "--{$boundary}", $body);
$parts = explode("--{$boundary}", $body);
$responses = array();
foreach ($parts as $i => $part) {
$part = trim($part);
if (!empty($part)) {
list($rawHeaders, $part) = explode("\r\n\r\n", $part, 2);
$headers = $this->parseRawHeaders($rawHeaders);
$status = substr($part, 0, strpos($part, "\n"));
$status = explode(" ", $status);
$status = $status[1];
list($partHeaders, $partBody) = $this->parseHttpResponse($part, false);
$response = new Response($status, $partHeaders, Stream::factory($partBody));
// Need content id.
$key = $headers['content-id'];
$class = '';
if (!empty($this->expected_classes[$key])) {
$class = $this->expected_classes[$key];
}
try {
$response = Google_Http_REST::decodeHttpResponse($response);
if (isset($classes[$key])) {
$response = new $classes[$key]($response);
}
} catch (Google_Service_Exception $e) {
// Store the exception as the response, so successful responses
// can be processed.
$response = $e;
}
$responses[$key] = $response;
}
}
return $responses;
}
return null;
}
/**
* Get the right I/O Class and rewrite the content.
*
* @return $this
*/
protected function parseResponse()
{
$strContentType = $this->request->getHeader('Content-Type');
$strContentType = preg_replace("/;.*\$/", "", $strContentType);
// Search a engine
$objIOEngine = \CtoCommunication\InputOutput\Factory::getEngingeForContentType($strContentType);
// Check if we have found one
if ($objIOEngine == false) {
throw new \RuntimeException("No I/O class found for " . $strContentType);
}
// Parse response
$this->response = $objIOEngine->InputResponse($this->response, $this->objCodifyengine);
// Write Debug msg
$strDebug = "";
$strDebug .= "Success: ";
$strDebug .= $this->response->isSuccess() ? "true" : "false";
$strDebug .= "\n";
if ($this->response->isSplitcontent() == true) {
$strDebug .= "Split: " . $this->response->isSplitcontent();
$strDebug .= "\n";
$strDebug .= "Splitinfo: " . "Count - " . $this->response->getSplitcount() . " Name - " . $this->response->getSplitname();
$strDebug .= "\n";
}
if ($this->response->getError() != null && is_object($this->response->getError())) {
$strDebug .= "Error: " . $this->response->getError()->getMessage();
$strDebug .= "\n";
$strDebug .= "Error RPC: " . $this->response->getError()->getRPC();
$strDebug .= "\n";
$strDebug .= "Error Class: " . $this->response->getError()->getClass();
$strDebug .= "\n";
$strDebug .= "Error Func.: " . $this->response->getError()->getFunction();
$strDebug .= "\n";
}
$strDebug .= "Response: " . substr(json_encode($this->response->getResponse()), 0, 2048);
$this->objDebug->addDebug("Response Object", $strDebug);
return $this;
}
/**
* Set the appropriate URL on the request based on the location header
*
* @param RequestInterface $request
* @param ResponseInterface $response
* @param array $protocols
*/
private function setRedirectUrl(RequestInterface $request, ResponseInterface $response, array $protocols)
{
$location = $response->getHeader('Location');
$location = Url::fromString($location);
// Combine location with the original URL if it is not absolute.
if (!$location->isAbsolute()) {
$originalUrl = Url::fromString($request->getUrl());
// Remove query string parameters and just take what is present on
// the redirect Location header
$originalUrl->getQuery()->clear();
$location = $originalUrl->combine($location);
}
// Ensure that the redirect URL is allowed based on the protocols.
if (!in_array($location->getScheme(), $protocols)) {
throw new BadResponseException(sprintf('Redirect URL, %s, does not use one of the allowed redirect protocols: %s', $location, implode(', ', $protocols)), $request, $response);
}
$request->setUrl($location);
}
/**
*
* @param HttpResponse $response
* @return \webignition\InternetMediaType\InternetMediaType
*/
private function getContentTypeFromResponse(HttpResponse $response)
{
$mediaTypeParser = new InternetMediaTypeParser();
$mediaTypeParser->setAttemptToRecoverFromInvalidInternalCharacter(true);
$mediaTypeParser->setIgnoreInvalidAttributes(true);
return $mediaTypeParser->parse($response->getHeader('content-type'));
}
/**
* @param string $header
* @return string
*/
public function header($header)
{
return $this->response->getHeader($header);
}
function it_throws_exception_when_invalid_response_format_is_received($client, ResponseInterface $response)
{
$response->getHeader('Content-Type')->willReturn('application/xhtml+xml');
$response->getBody()->willReturn('body');
$response->getStatusCode()->willReturn(400);
$client->get('uri/1')->willReturn($response)->shouldBeCalled();
$this->shouldThrow(new InvalidResponseFormatException('body', 400))->during('get', [1]);
}
public function extractCookies(RequestInterface $request, ResponseInterface $response)
{
if ($cookieHeader = $response->getHeader('Set-Cookie', true)) {
foreach ($cookieHeader as $cookie) {
$sc = SetCookie::fromString($cookie);
if (!$sc->getDomain()) {
$sc->setDomain($request->getHost());
}
$this->setCookie($sc);
}
}
}
/**
* Set the appropriate URL on the request based on the location header
*
* @param RequestInterface $request
* @param ResponseInterface $response
*/
private function setRedirectUrl(RequestInterface $request, ResponseInterface $response)
{
$location = $response->getHeader('Location');
$location = Url::fromString($location);
// Combine location with the original URL if it is not absolute.
if (!$location->isAbsolute()) {
$originalUrl = Url::fromString($request->getUrl());
// Remove query string parameters and just take what is present on
// the redirect Location header
$originalUrl->getQuery()->clear();
$location = $originalUrl->combine($location);
}
$request->setUrl($location);
}
private function getManifestEntries($key, $currentTime, ResponseInterface $response, $persistedRequest)
{
$entries = [];
$manifest = $this->cache->fetch($key);
if (!$manifest) {
return $entries;
}
// Determine which cache entries should still be in the cache
$vary = $response->getHeader('Vary');
foreach (unserialize($manifest) as $entry) {
// Check if the entry is expired
if ($entry[4] < $currentTime) {
continue;
}
$varyCmp = isset($entry[1]['vary']) ? $entries[1]['vary'] : '';
if ($vary != $varyCmp || !$this->requestsMatch($vary, $entry[0], $persistedRequest)) {
$entries[] = $entry;
}
}
return $entries;
}
private function genericHandler(ResponseInterface $response)
{
$code = (string) $response->getStatusCode();
return ['request_id' => (string) $response->getHeader('x-amzn-requestid'), 'code' => null, 'message' => null, 'type' => $code[0] == '4' ? 'client' : 'server', 'parsed' => $response->json()];
}
private function handle304Response(RequestInterface $request, ResponseInterface $response, ResponseInterface $validated, CompleteEvent $event)
{
// Make sure that this response has the same ETag
if ($validated->getHeader('ETag') !== $response->getHeader('ETag')) {
// Revalidation failed, so remove from cache and retry.
$this->storage->delete($request);
$event->intercept($event->getClient()->send($request));
return;
}
// Replace cached headers with any of these headers from the
// origin server that might be more up to date
$modified = false;
foreach (self::$replaceHeaders as $name) {
if ($validated->hasHeader($name) && $validated->getHeader($name) != $response->getHeader($name)) {
$modified = true;
$response->setHeader($name, $validated->getHeader($name));
}
}
// Store the updated response in cache
if ($modified) {
$this->storage->cache($request, $response);
}
}
private function responseToArray(ResponseInterface $response)
{
$responseType = $response->getHeader('Content-Type');
if (false === strpos($responseType, 'application/json') && false === strpos($responseType, 'application/xml')) {
throw new InvalidResponseFormatException((string) $response->getBody(), $response->getStatusCode());
}
return strpos($responseType, 'application/json') !== false ? $response->json() : $response->xml();
}
