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