/**
* Creates a Ring request from a request object.
*
* This function does not hook up the "then" and "progress" events that
* would be required for actually sending a Guzzle request through a
* RingPHP handler.
*
* @param RequestInterface $request Request to convert.
*
* @return array Converted Guzzle Ring request.
*/
public static function createRingRequest(RequestInterface $request)
{
$options = $request->getConfig()->toArray();
$url = $request->getUrl();
// No need to calculate the query string twice (in URL and query).
$qs = ($pos = strpos($url, '?')) ? substr($url, $pos + 1) : null;
return ['scheme' => $request->getScheme(), 'http_method' => $request->getMethod(), 'url' => $url, 'uri' => $request->getPath(), 'headers' => $request->getHeaders(), 'body' => $request->getBody(), 'version' => $request->getProtocolVersion(), 'client' => $options, 'query_string' => $qs, 'future' => isset($options['future']) ? $options['future'] : false];
}
/**
* Executes a GuzzleHttp\Message\Request and (if applicable) automatically retries
* when errors occur.
*
* @param Google_Client $client
* @param GuzzleHttp\Message\Request $req
* @return array decoded result
* @throws Google_Service_Exception on server side error (ie: not authenticated,
* invalid or malformed post body, invalid url)
*/
public static function execute(ClientInterface $client, RequestInterface $request, $config = array(), $retryMap = null)
{
$runner = new Google_Task_Runner($config, sprintf('%s %s', $request->getMethod(), $request->getUrl()), array(get_class(), 'doExecute'), array($client, $request));
if (!is_null($retryMap)) {
$runner->setRetryMap($retryMap);
}
return $runner->run();
}
/**
* @param RequestInterface $request
* @return array ['query' => ..., 'request' => ...]
*/
protected function getRequestAndQuery(RequestInterface $request)
{
$query = [];
foreach ($request->getQuery() as $param => $val) {
$query[$param] = $val;
}
$requestInfo = ['url' => $request->getUrl(), 'path' => $request->getPath(), 'queryString' => (string) $request->getQuery(), 'method' => $request->getMethod(), 'hostname' => $request->getHost(), 'port' => $request->getPort(), 'resource' => $request->getResource()];
return ['query' => $query, 'request' => $requestInfo];
}
/**
* @param RequestInterface $request
* @param ResponseInterface $response
* @return string
*/
protected function buildMessage($request, $response)
{
$resource = $this->getResponseBody();
if (is_null($resource)) {
$resource = '';
}
$message = sprintf('[url] %s [http method] %s [status code] %s [reason phrase] %s: %s', $request->getUrl(), $request->getMethod(), $response->getStatusCode(), $response->getReasonPhrase(), $resource);
return $message;
}
/**
* @param RequestInterface $actual
* @param RequestInterface $expected
* @throws FailedRequestExpectationException
*/
public static function checkRequest(RequestInterface $actual, RequestInterface $expected)
{
self::checkIsEqual($actual->getHost(), $expected->getHost(), 'host');
self::checkIsEqual($actual->getPath(), $expected->getPath(), 'url path');
self::checkIsEqual($actual->getMethod(), $expected->getMethod(), 'http method');
self::checkRequestQuery($actual, $expected);
self::checkContentType($actual, $expected);
self::checkRequestBody($actual, $expected);
}
private function createCanonicalizedString(RequestInterface $request, $expires = null)
{
$buffer = $request->getMethod() . "\n";
// Add the interesting headers
foreach ($this->signableHeaders as $header) {
$buffer .= $request->getHeader($header) . "\n";
}
$date = $expires ?: $request->getHeader('date');
$buffer .= "{$date}\n" . $this->createCanonicalizedAmzHeaders($request) . $this->createCanonicalizedResource($request);
return $buffer;
}
private function shouldValidate(RequestInterface $request, ResponseInterface $response)
{
if ($request->getMethod() != 'GET' || $request->getConfig()->get('cache.disable')) {
return false;
}
$validate = Utils::getDirective($request, 'Pragma') === 'no-cache' || Utils::getDirective($response, 'Pragma') === 'no-cache' || Utils::getDirective($request, 'must-revalidate') || Utils::getDirective($response, 'must-revalidate') || Utils::getDirective($request, 'no-cache') || Utils::getDirective($response, 'no-cache') || Utils::getDirective($response, 'max-age') === '0' || Utils::getDirective($response, 's-maxage') === '0';
// Use the strong ETag validator if available and the response contains
// no Cache-Control directive
if (!$validate && !$response->hasHeader('Cache-Control') && $response->hasHeader('ETag')) {
$validate = true;
}
return $validate;
}
private function applyMethod(RequestInterface $request, array &$options)
{
$method = $request->getMethod();
if ($method == 'HEAD') {
$options[CURLOPT_NOBODY] = true;
unset($options[CURLOPT_WRITEFUNCTION], $options[CURLOPT_READFUNCTION]);
} else {
$options[CURLOPT_CUSTOMREQUEST] = $method;
if (!$request->getBody()) {
unset($options[CURLOPT_READFUNCTION]);
} else {
$this->applyBody($request, $options);
}
}
}
public function signRequest(RequestInterface $request, CredentialsInterface $credentials)
{
/** @var PostBodyInterface $body */
$body = $request->getBody();
$body->setField('Timestamp', gmdate('c'));
$body->setField('SignatureVersion', '2');
$body->setField('SignatureMethod', 'HmacSHA256');
$body->setField('AWSAccessKeyId', $credentials->getAccessKeyId());
if ($token = $credentials->getSecurityToken()) {
$body->setField('SecurityToken', $token);
}
// build string to sign
$sign = $request->getMethod() . "\n" . $request->getHost() . "\n" . '/' . "\n" . $this->getCanonicalizedParameterString($body);
$request->getConfig()->set('aws.signature', $sign);
$body->setField('Signature', base64_encode(hash_hmac('sha256', $sign, $credentials->getSecretKey(), true)));
}
public function send(RequestInterface $request)
{
$this->logger->info(sprintf('%s "%s"', $request->getMethod(), $request->getUrl()));
$this->logger->debug(sprintf("Request:\n%s", (string) $request));
try {
$response = $this->client->send($request);
} catch (TransferException $e) {
$message = sprintf('Something went wrong when calling vault (%s).', $e->getMessage());
$this->logger->error($message);
throw new ServerException($message);
}
$this->logger->debug(sprintf("Response:\n%s", $response));
if (400 <= $response->getStatusCode()) {
$message = sprintf('Something went wrong when calling vault (%s - %s).', $response->getStatusCode(), $response->getReasonPhrase());
$this->logger->error($message);
$message .= "\n{$response}";
if (500 <= $response->getStatusCode()) {
throw new ServerException($message, $response->getStatusCode(), $response);
}
throw new ClientException($message, $response->getStatusCode(), $response);
}
return $response;
}
/**
* Hash a request URL into a string that returns cache metadata.
*
* @param RequestInterface $request The Request to generate the cache key
* for.
* @param array $vary (optional) An array of headers to vary
* the cache key by.
*
* @return string
*/
private function getCacheKey(RequestInterface $request, array $vary = [])
{
$key = $request->getMethod() . ' ' . $request->getUrl();
// If Vary headers have been passed in, fetch each header and add it to
// the cache key.
foreach ($vary as $header) {
$key .= " {$header}: " . $request->getHeader($header);
}
return $this->keyPrefix . md5($key);
}
/**
* @param RequestInterface $request
*/
protected function extractBodyArgument(RequestInterface $request)
{
if ($request->getBody() && ($contents = (string) $request->getBody())) {
$this->addOption('d', escapeshellarg($contents));
}
//if get request has data Add G otherwise curl will make a post request
if (!empty($this->options['d']) && 'GET' === $request->getMethod()) {
$this->addOption('G');
}
}
/**
* Returns a formatted message
*
* @param RequestInterface $request Request that was sent
* @param ResponseInterface $response Response that was received
* @param \Exception $error Exception that was received
* @param array $customData Associative array of custom template data
*
* @return string
*/
public function format(RequestInterface $request, ResponseInterface $response = null, \Exception $error = null, array $customData = array())
{
$cache = $customData;
$that = $this;
return preg_replace_callback('/{\\s*([A-Za-z_\\-\\.0-9]+)\\s*}/', function (array $matches) use($request, $response, $error, &$cache, $that) {
if (isset($cache[$matches[1]])) {
return $cache[$matches[1]];
}
$result = '';
switch ($matches[1]) {
case 'request':
$result = $request;
break;
case 'response':
$result = $response;
break;
case 'req_headers':
$result = trim($request->getMethod() . ' ' . $request->getResource()) . ' HTTP/' . $request->getProtocolVersion() . "\r\n" . $that->headers($request);
break;
case 'res_headers':
$result = $response ? sprintf('HTTP/%s %d %s', $response->getProtocolVersion(), $response->getStatusCode(), $response->getReasonPhrase()) . "\r\n" . $that->headers($response) : 'NULL';
break;
case 'req_body':
$result = $request->getBody();
break;
case 'res_body':
$result = $response ? $response->getBody() : 'NULL';
break;
case 'ts':
$result = gmdate('c');
break;
case 'method':
$result = $request->getMethod();
break;
case 'url':
$result = $request->getUrl();
break;
case 'resource':
$result = $request->getResource();
break;
case 'req_version':
$result = $request->getProtocolVersion();
break;
case 'res_version':
$result = $response ? $response->getProtocolVersion() : 'NULL';
break;
case 'host':
$result = $request->getHost();
break;
case 'hostname':
$result = gethostname();
break;
case 'code':
$result = $response ? $response->getStatusCode() : 'NULL';
break;
case 'phrase':
$result = $response ? $response->getReasonPhrase() : 'NULL';
break;
case 'error':
$result = $error ? $error->getMessage() : 'NULL';
break;
default:
// handle prefixed dynamic headers
if (strpos($matches[1], 'req_header_') === 0) {
$result = $request->getHeader(substr($matches[1], 11));
} elseif (strpos($matches[1], 'res_header_') === 0) {
$result = $response ? $response->getHeader(substr($matches[1], 11)) : 'NULL';
}
}
$cache[$matches[1]] = $result;
return $result;
}, $this->template);
}
private function getDefaultOptions(RequestInterface $request)
{
$headers = '';
foreach ($request->getHeaders() as $name => $values) {
$headers .= $name . ': ' . implode(', ', $values) . "\r\n";
}
return ['http' => ['method' => $request->getMethod(), 'header' => trim($headers), 'protocol_version' => $request->getProtocolVersion(), 'ignore_errors' => true, 'follow_location' => 0, 'content' => (string) $request->getBody()]];
}
/**
* Handle an error. We handle errors by throwing an exception.
*
* @param string $error An error code representing the error
* (use_underscore_separators).
* @param string|null $message The error message.
* @param \GuzzleHttp\Message\RequestInterface|null $request Optional. The
* Guzzle request object.
* @param \GuzzleHttp\Message\ResponseInterface|null $response Optional. The
* Guzzle response object.
*
* @return void
* @throws \Box\View\BoxViewException
*/
protected static function error($error, $message = null, $request = null, $response = null)
{
if (!empty($request)) {
$message .= "\n";
$message .= 'Method: ' . $request->getMethod() . "\n";
$message .= 'URL: ' . $request->getUrl() . "\n";
$message .= 'Query: ' . json_encode($request->getQuery()->toArray()) . "\n";
$message .= 'Headers: ' . json_encode($request->getHeaders()) . "\n";
$message .= 'Request Body: ' . $request->getBody() . "\n";
}
if (!empty($response)) {
$message .= "\n";
$message .= 'Response Body: ' . $response->getBody() . "\n";
}
$exception = new BoxViewException($message);
$exception->errorCode = $error;
throw $exception;
}
/**
* @param \GuzzleHttp\Message\RequestInterface $request
* @return \SlevomatZboziApi\Request\ZboziApiRequest
*/
private function getZboziApiRequest(\GuzzleHttp\Message\RequestInterface $request)
{
return new ZboziApiRequest($request->getMethod(), $request->getUrl(), $request->getHeaders(), $request->getBody() === null ? null : json_decode((string) $request->getBody()));
}
private function getRequestHeaderAsString(RequestInterface $request)
{
$message = vsprintf('%s %s HTTP/%s', [strtoupper($request->getMethod()), $request->getUrl(), $request->getProtocolVersion()]) . "\r\n";
foreach ($request->getHeaders() as $name => $values) {
$message .= $name . ': ' . implode(', ', $values) . "\r\n";
}
$message .= "\r\n";
return $message;
}
/**
* Creates the Signature Base String.
*
* The Signature Base String is a consistent reproducible concatenation of
* the request elements into a single string. The string is used as an
* input in hashing or signing algorithms.
*
* @param RequestInterface $request Request being signed
* @param array $params Associative array of OAuth parameters
*
* @return string Returns the base string
* @link http://oauth.net/core/1.0/#sig_base_example
*/
protected function createBaseString(RequestInterface $request, array $params)
{
// Remove query params from URL. Ref: Spec: 9.1.2.
$url = Url::fromString($request->getUrl());
$url->setQuery('');
$query = http_build_query($params, '', '&', PHP_QUERY_RFC3986);
return strtoupper($request->getMethod()) . '&' . rawurlencode($url) . '&' . rawurlencode($query);
}
/**
* @internal Create the canonical representation of a request
* @param RequestInterface $request Request to canonicalize
* @param string $payload Hash of the request payload
* @return array Returns an array of context information
*/
private function createContext(RequestInterface $request, $payload)
{
static $signable = ['host' => true, 'date' => true, 'content-md5' => true];
// Normalize the path as required by SigV4 and ensure it's absolute
$canon = $request->getMethod() . "\n" . '/' . ltrim($request->getPath(), '/') . "\n" . $this->getCanonicalizedQuery($request) . "\n";
$canonHeaders = [];
// Always include the "host", "date", and "x-amz-" headers.
foreach ($request->getHeaders() as $key => $values) {
$key = strtolower($key);
if (isset($signable[$key]) || substr($key, 0, 6) === 'x-amz-') {
if (count($values) == 1) {
$values = $values[0];
} else {
sort($values);
$values = implode(',', $values);
}
$canonHeaders[$key] = $key . ':' . preg_replace('/\\s+/', ' ', $values);
}
}
ksort($canonHeaders);
$signedHeadersString = implode(';', array_keys($canonHeaders));
$canon .= implode("\n", $canonHeaders) . "\n\n" . $signedHeadersString . "\n" . $payload;
return ['creq' => $canon, 'headers' => $signedHeadersString];
}
/**
* Asserts response match with the response schema.
*
* @param ResponseInterface $response
* @param RequestInterface $request
* @param SchemaManager $schemaManager
* @param string $message
*/
public function assertResponseAndRequestMatch(ResponseInterface $response, RequestInterface $request, SchemaManager $schemaManager, $message = '')
{
$this->assertResponseMatch($response, $schemaManager, $request->getPath(), $request->getMethod(), $message);
}
/**
* get cache key for a request
*
*/
protected function getCacheKey(RequestInterface $request)
{
return $this->keyPrefix . '_' . str_replace([':', '/', '?', '&&'], '_', $request->getUrl()) . '_' . md5($request->getMethod() . ' ' . $request->getUrl());
}
/**
* Build a string for displaying in the time-line containing useful info on the request.
*
* @param RequestInterface $request
* @param ResponseInterface $response
*
* @return string
*/
private function createTimelineMessage(RequestInterface $request, ResponseInterface $response = null)
{
$code = $response ? $response->getStatusCode() : 'NULL';
return sprintf('%s %s (%s)', $request->getMethod(), $request->getUrl(), $code);
}
/**
* @param RequestInterface $request
* @param ResponseInterface $response
* @return string
*/
protected function buildMessage($request, $response)
{
$message = sprintf('[url] %s [http method] %s [status code] %s [reason phrase] %s.', $request->getUrl(), $request->getMethod(), $response->getStatusCode(), $response->getReasonPhrase());
return $message;
}
private function assertThatRequestIsEqual(RequestInterface $expectedRequest, RequestInterface $request)
{
$this->assertEquals($expectedRequest->getMethod(), $request->getMethod());
$this->assertEquals($expectedRequest->getUrl(), $request->getUrl());
}
/**
* Hash a request URL into a string that returns cache metadata
*
* @param RequestInterface $request
*
* @return string
*/
private function getCacheKey(RequestInterface $request)
{
return $this->keyPrefix . md5($request->getMethod() . ' ' . $request->getUrl());
}
protected function canCacheRequest(RequestInterface $request)
{
return !$request->getConfig()->get('cache.disable') && in_array($request->getMethod(), array('GET', 'HEAD', 'OPTIONS'));
}
/**
* Default function used to determine if a request can be cached.
*
* @param RequestInterface $request Request to check
*
* @return bool
*/
public static function canCacheRequest(RequestInterface $request)
{
$method = $request->getMethod();
// Only GET and HEAD requests can be cached
if ($method !== 'GET' && $method !== 'HEAD') {
return false;
}
// Don't fool with Range requests for now
if ($request->hasHeader('Range')) {
return false;
}
return self::getDirective($request, 'no-store') === null;
}
/**
* Internal method which prevents infinite recursion. For certain requests, like the initial
* auth call itself, we do NOT want to send a token.
*
* @param RequestInterface $request
*
* @return bool
*/
private function shouldIgnore(RequestInterface $request)
{
return strpos((string) $request->getUrl(), 'tokens') !== false && $request->getMethod() == 'POST';
}
/**
* Creates the Signature Base String.
*
* The Signature Base String is a consistent reproducible concatenation of
* the request elements into a single string. The string is used as an
* input in hashing or signing algorithms.
*
* @param RequestInterface $request Request being signed
* @param array $params HTTP Request parameters
*
* @return string Returns the base string
*/
protected function createBaseString(RequestInterface $request, $params = [])
{
// Remove query params from URL.
$url = preg_replace('/https:\\/\\/|\\?.*/', '', $request->getUrl());
if (is_array($params)) {
$query = http_build_query($params, '', '&', PHP_QUERY_RFC1738);
} else {
$query = $params;
}
return strtoupper($request->getMethod()) . ' ' . $url . '?' . $query;
}
/**
* Collect & sanitize data about a Guzzle request.
*
* @param RequestInterface $request Guzzle request.
* @return array
*/
private function collectRequest(RequestInterface $request)
{
$query = $request->getQuery();
return ['headers' => $request->getHeaders(), 'method' => $request->getMethod(), 'scheme' => $request->getScheme(), 'host' => $request->getHost(), 'path' => $request->getPath(), 'query' => (string) $query, 'queryParams' => $query->toArray(), 'body' => (string) $request->getBody()];
}
