/** * This method adds the current parameter to the specified REST API request. * * @param \GuzzleHttp\Psr7\Request $request * @return Request */ public function apply(Request $request) { $queryString = $request->getUri()->getQuery(); $queryParts = \GuzzleHttp\Psr7\parse_query($queryString); $queryParts[$this->name] = $this->value; $queryString = \GuzzleHttp\Psr7\build_query($queryParts); return $request->withUri($request->getUri()->withQuery($queryString)); }
/** * @param Client $client */ protected function copyClientDefaults(Client $client) { $this->request->withUri(new Uri($client->getConfig('base_uri') . $this->request->getUri())); foreach ($client->getConfig('headers') as $header => $value) { $this->request->withAddedHeader($header, $value); } }
/** * @inheritDoc */ public function execute() { $client = new Client(['headers' => $this->request->getHeaders()]); try { $response = $client->request($this->request->getMethod(), $this->request->getUri(), ['body' => $this->request->getBody()->getContents()]); } catch (ClientException $e) { $this->error = ['status' => $e->getResponse()->getStatusCode(), 'content' => $e->getResponse()->getBody()->getContents()]; return false; } $this->output = $response->getBody()->getContents(); return true; }
public function __construct(Request $request, $proxy, $toggleCrypto = false) { if (!($port = $request->getUri()->getPort())) { $port = $request->getUri()->getScheme() === 'http' ? 80 : 443; } $headers = array("CONNECT {$request->getUri()->getHost()}:{$port} HTTP/1.0"); if (isset($proxy['user'])) { $headers[] = "Proxy-Authorization: Basic " . base64_encode("{$proxy['user']}:{$proxy['pass']}"); } $this->data = implode("\r\n", $headers) . "\r\n\r\n\r\n"; $this->request = new HttpRequest($request); $this->toggleCrypto = $toggleCrypto; }
/** * {@InheritDoc} */ public function send(Request $request) { $guzzleRequest = $this->client->createRequest($request->getMethod(), $request->getUri(), $request->getHeaders(), $request->getBody()); $guzzleResponse = $guzzleRequest->send(); $response = new Response($guzzleResponse->getStatusCode(), $guzzleResponse->getHeaders()->toArray(), $guzzleResponse->getBody(true)); return $response; }
/** * Assert that the value of a query string parameter of a request is equal * to $queryParameterValue * * @param string $queryParameterKey * Name of a query string parameter in the request * @param string $queryParameterValue * Expected value of that query string parameter * @param Request $request * Request object to check * @return void */ public function assertRequestQueryParameterSame($queryParameterKey, $queryParameterValue, Request $request) { // Parse the request's query string into an array $query = []; parse_str($request->getUri()->getQuery(), $query); // Assert that the query parameter's value matches $this->assertSame($queryParameterValue, $query[$queryParameterKey]); }
/** * {@InheritDoc} */ public function send(Request $request) { $guzzleRequest = $this->client->createRequest($request->getMethod(), $request->getUri(), ['headers' => $request->getHeaders()]); $guzzleRequest->setBody(Stream::factory($request->getBody())); $guzzleResponse = $this->getClient()->send($guzzleRequest); $response = new Response($guzzleResponse->getStatusCode(), $guzzleResponse->getHeaders(), $guzzleResponse->getBody(true)); return $response; }
public function testQueryParser() { $endpoint = $this->getEndpoint(); $handler = $this->getHandler($endpoint); $request = new Request('GET', new Uri($endpoint->url())); $uri = $request->getUri()->withQuery('abc=123&def=456&ghi=789'); $query_array = $handler->queryAsArray($request->withUri($uri)); $this->assertEquals(3, count($query_array)); $this->assertArrayHasKey('abc', $query_array); $this->assertArrayHasKey('def', $query_array); $this->assertArrayHasKey('ghi', $query_array); $uri = $request->getUri()->withQuery('abc=123&&ghi=789'); $query_array = $handler->queryAsArray($request->withUri($uri)); $this->assertEquals(2, count($query_array)); $this->assertArrayHasKey('abc', $query_array); $this->assertArrayHasKey('ghi', $query_array); }
/** * Creates a request. * * @param string $verb * @param string $path * @param array $parameters * * @return Request */ protected function createRequest($verb, $path, $parameters = []) { if (isset($parameters['file'])) { $this->queueResourceAs('file', \GuzzleHttp\Psr7\stream_for($parameters['file'])); unset($parameters['file']); } $request = new Request($verb, $this->getUrlFromPath($path), $this->getHeaders()); return $request->withUri($request->getUri()->withQuery(http_build_query($parameters))); }
/** * Insert a log */ private function _addLog() { $log = new Log(); $log->method = $this->_request->getMethod(); $log->uri = (string) $this->_request->getUri(); $config = App::getInstance()->getClient()->getConfig(); $log->options = array_merge_recursive(['headers' => $config['headers']], $this->_options); self::$_log[] = $log; //Keep only the last three requests in the log self::$_log = array_slice(self::$_log, -3); }
/** * @param GuzzleClient $client * @param Request $request * * @return mixed */ public function send(GuzzleClient $client, Request $request) { $uri = $request->getUri(); $path = $this->endpoint . $uri->getPath(); $uri = $uri->withPath($path); $request = $request->withUri($uri); try { $response = $client->send($request); return $response->getBody(); } catch (GuzzleClientException $e) { throw new Exception('Auth service request error', $e); } }
/** * Get all of the received requests. * * @throws \RuntimeException * @return ResponseInterface[] * */ public static function received() { if (!self::$started) { return []; } $response = self::getClient()->request('GET', 'guzzle-server/requests'); $data = json_decode($response->getBody(), true); return array_map(function ($message) { $uri = $message['uri']; if (isset($message['query_string'])) { $uri .= '?' . $message['query_string']; } $response = new Psr7\Request($message['http_method'], $uri, $message['headers'], $message['body'], $message['version']); return $response->withUri($response->getUri()->withScheme('http')->withHost($response->getHeaderLine('host'))); }, $data); }
public function addSignatureToGuzzle6Request(\GuzzleHttp\Psr7\Request $request, $api_token, $secret) { $method = $request->getMethod(); // build URL without parameters $uri = $request->getUri(); $url = $this->buildURLPrefix($uri->getScheme(), $uri->getHost(), $uri->getPort()) . $uri->getPath(); // get parameters if ($method == 'GET') { parse_str($uri->getQuery(), $parameters); } else { // assume json $json_string = $request->getBody(); $parameters = strlen($json_string) ? json_decode($json_string) : []; } // get signature $signature_info = $this->createSignatureParameters($method, $url, $parameters, $api_token, $secret); // add http headers $request = $request->withHeader('X-' . $this->auth_header_namespace . '-AUTH-API-TOKEN', $api_token); $request = $request->withHeader('X-' . $this->auth_header_namespace . '-AUTH-NONCE', $signature_info['nonce']); $request = $request->withHeader('X-' . $this->auth_header_namespace . '-AUTH-SIGNATURE', $signature_info['signature']); return $request; }
/** * Generates the cache key for the given request and request options. The * namespace should be set on the cache provider. * * @param Request $request The request to generate a key for. * @param array $options Configuration options. * * @return string The cache key */ protected function getKey(Request $request, array $options) { return join(":", [$request->getMethod(), $request->getUri(), md5(json_encode($options))]); }
/** * Adds authentication header to the request headers. * * @param \GuzzleHttp\Psr7\Request $request HTTP request object. * * @return \GuzzleHttp\Psr7\Request */ public function handleRequest($request) { $requestHeaders = HttpFormatter::formatHeaders($request->getHeaders()); $signedKey = $this->_authenticationScheme->getAuthorizationHeader($requestHeaders, $request->getUri(), \GuzzleHttp\Psr7\parse_query($request->getUri()->getQuery()), $request->getMethod()); return $request->withHeader(Resources::AUTHENTICATION, $signedKey); }
/** * Keep track of the successes and failures while scraping. * * @param Request $request * @param $status * @param $message */ protected function log(Request $request, $status, $message) { $url = $request->getUri()->getPath(); $this->log[$status][$url][] = $message; }
/** * Prints last response body. * * @Then print response */ public function printResponse() { $request = $this->request; $response = $this->response; echo sprintf("%s %s => %d:\n%s", $this->request->getMethod(), $this->request->getUri(), $response->getStatusCode(), $response->getBody()); }
protected function doRequest($request) { /** @var $request BrowserKitRequest **/ $guzzleRequest = new Psr7Request($request->getMethod(), $request->getUri(), $this->extractHeaders($request), $request->getContent()); $options = $this->requestOptions; $options['cookies'] = $this->extractCookies($guzzleRequest->getUri()->getHost()); $multipartData = $this->extractMultipartFormData($request); if (!empty($multipartData)) { $options['multipart'] = $multipartData; } $formData = $this->extractFormData($request); if (empty($multipartData) and $formData) { $options['form_params'] = $formData; } try { $response = $this->client->send($guzzleRequest, $options); } catch (ConnectException $e) { $url = (string) $this->client->getConfig('base_uri'); throw new ConnectionException("Couldn't connect to {$url}. Please check that web server is running"); } catch (RequestException $e) { if (!$e->hasResponse()) { throw $e; } $response = $e->getResponse(); } return $this->createResponse($response); }
public function testSameInstanceWhenSameUri() { $r1 = new Request('GET', 'http://foo.com'); $r2 = $r1->withUri($r1->getUri()); $this->assertSame($r1, $r2); }
/** * 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 GuzzleRequest|null $request Optional. The Guzzle request object. * @param ResponseInterface|null $response Optional. The Guzzle response object. * * @return void * @throws 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->getUri() . "\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 Request $request * @param array $opts * @return Observable\AnonymousObservable */ public function requestRaw(Request $request, array $opts = []) { // To retry properly this observable will be retried return Observable::create(function (ObserverInterface $observer) use($request, $opts) { $scheme = $request->getUri()->getScheme(); if (!($port = $request->getUri()->getPort())) { $port = $request->getUri()->getScheme() === 'http' ? 80 : 443; } $streamed = Arrays::get($opts, 'stream', false); $req = new HttpRequest($request, $streamed); $this->dns->resolve($request->getUri()->getHost())->flatMap(function ($ip) use($scheme, $opts, $port) { return $this->getConnector($scheme, $opts)->connect($ip, $port)->map(function (Event $e) { if ($e instanceof ConnectorEvent) { $stream = $e->data; $bufferedStream = new BufferedStream($stream->getSocket(), $stream->getLoop()); return new ConnectorEvent($e->name, $bufferedStream, $e->labels, $e->getPriority()); } return $e; }); })->subscribe($req); $req->subscribe($observer); }); }
/** * @return string */ public function getQuery() { return $this->request->getUri()->getQuery(); }
/** * Sends a request via the given client. This centralizes options * that all clients need such as disabling exceptions on errors * and catching redirects. * * @param \GuzzleHttp\Client $client * @param \GuzzleHttp\Psr7\Request $request * * @return \GuzzleHttp\Psr7\Response $response */ public static function send(Client $client, Request $request) { $actualUri = (string) $request->getUri(); try { $response = $client->send($request, ['curl' => ['body_as_string' => true], 'allow_redirects' => ['on_redirect' => function (RequestInterface $request, ResponseInterface $response, $uri) use(&$actualUri) { $actualUri = (string) $uri; }]]); $response->effectiveUri = $actualUri; return $response; } catch (\GuzzleHttp\Exception\BadResponseException $e) { $response = null; $reason = 'Bas response.'; if ($e->hasResponse()) { $response = $e->getResponse(); $reason = $response->getReasonPhrase(); } throw new \Gedcomx\Rs\Client\Exception\GedcomxApplicationException($reason, $response); } }
private function meRequest($accessToken, array $fields) { $request = new Request('GET', FacebookApi::GRAPH_API_ME_URL); $query = $request->getUri(); $query = Uri::withQueryValue($query, 'access_token', $accessToken); if (!empty($fields)) { $query = Uri::withQueryValue($query, 'fields', implode(',', $fields)); } return $request->withUri($query); }
/** * Ensure the API key is appended to a request URL automatically * @depends testRequestHandled * @param Request $request */ public function testApiKeyQueryParameter(Request $request) { $expectedUri = sprintf('https://api.thisdata.com/v%s/%s', self::DUMMY_VERSION, self::DUMMY_ENDPOINT); $this->assertEquals($expectedUri, (string) $request->getUri()); }
/** * This is the main method of this wrapper. It will * sign a given query and return its result. * * @param string $method HTTP method of request (GET,POST,PUT,DELETE) * @param string $path relative url of API request * @param \stdClass|array|null $content body of the request * @param bool $is_authenticated if the request use authentication * * @return array * @throws \GuzzleHttp\Exception\ClientException if http request is an error */ private function rawCall($method, $path, $content = null, $is_authenticated = true) { $url = $this->endpoint . $path; $request = new Request($method, $url); if (isset($content) && $method == 'GET') { $queryString = $request->getUri()->getQuery(); $query = false !== strpos($queryString, '&') ? explode('&', $queryString) : []; $query = array_merge($query, (array) $content); $query = \GuzzleHttp\Psr7\build_query($query); $request = $request->withUri($request->getUri()->withQuery($query)); $body = ""; } elseif (isset($content)) { $body = json_encode($content); $request->getBody()->write($body); } else { $body = ""; } $headers = ['Content-Type' => 'application/json; charset=utf-8', 'X-Ovh-Application' => $this->application_key]; if ($is_authenticated) { if (!isset($this->time_delta)) { $this->calculateTimeDelta(); } $now = time() + $this->time_delta; $headers['X-Ovh-Timestamp'] = $now; if (isset($this->consumer_key)) { $toSign = $this->application_secret . '+' . $this->consumer_key . '+' . $method . '+' . $url . '+' . $body . '+' . $now; $signature = '$1$' . sha1($toSign); $headers['X-Ovh-Consumer'] = $this->consumer_key; $headers['X-Ovh-Signature'] = $signature; } } /** @var Response $response */ $response = $this->http_client->send($request, ['headers' => $headers]); return json_decode($response->getBody(), true); }
/** * generic request executor * * @param string $method GET, POST, PUT, DELETE * @param string $endpointUrl * @param array $queryString * @param array|string $body * @param string $auth http-signatures to enable http-signature signing * @param string $contentMD5Mode body or url * @param float $timeout timeout in seconds * @return Request */ public function buildRequest($method, $endpointUrl, $queryString = null, $body = null, $auth = null, $contentMD5Mode = null, $timeout = null) { if (is_null($contentMD5Mode)) { $contentMD5Mode = !is_null($body) ? 'body' : 'url'; } $request = new Request($method, $endpointUrl); $uri = $request->getUri(); if ($queryString) { foreach ($queryString as $k => $v) { $uri = Uri::withQueryValue($uri, $k, $v); } } if (!self::hasQueryValue($uri, 'api_key')) { $uri = Uri::withQueryValue($uri, 'api_key', $this->apiKey); } // normalize the query string the same way the server expects it /** @var Request $request */ $request = $request->withUri($uri->withQuery(\Symfony\Component\HttpFoundation\Request::normalizeQueryString($uri->getQuery()))); if (!$request->hasHeader('Date')) { $request = $request->withHeader('Date', $this->getRFC1123DateString()); } if (!is_null($body)) { if (!$request->hasHeader('Content-Type')) { $request = $request->withHeader('Content-Type', 'application/json'); } if (!is_string($body)) { $body = json_encode($body); } $request = $request->withBody(\GuzzleHttp\Psr7\stream_for($body)); } // for GET/DELETE requests, MD5 the request URI (excludes domain, includes query strings) if ($contentMD5Mode == 'body') { $request = $request->withHeader('Content-MD5', md5((string) $body)); } else { $request = $request->withHeader('Content-MD5', md5($request->getRequestTarget())); } return $request; }
protected function doRequest($request) { /** @var $request BrowserKitRequest **/ $guzzleRequest = new Psr7Request($request->getMethod(), $request->getUri(), $this->extractHeaders($request), $request->getContent()); $options = $this->requestOptions; $options['cookies'] = $this->extractCookies($guzzleRequest->getUri()->getHost()); $multipartData = $this->extractMultipartFormData($request); if (!empty($multipartData)) { $options['multipart'] = $multipartData; } $formData = $this->extractFormData($request); if (empty($multipartData) and $formData) { $options['form_params'] = $formData; } try { $response = $this->client->send($guzzleRequest, $options); } catch (RequestException $e) { if (!$e->hasResponse()) { throw $e; } $response = $e->getResponse(); } return $this->createResponse($response); }
/** * Parse the response of a success request * * @param mixed $data * @param Request $request * @param Response $response * @param array $options * @return type */ protected function parseResponseSuccesss($data, $request, $response, $options) { if (!isset($data)) { $message = "Corrupt JSON response: " . json_last_error_msg(); throw new InvalidContentException($message, $request, $response); } if (!empty($options['expected_type']) && gettype($data) !== $options['expected_type']) { $message = "Was expecting a {$options['expected_type']} for `" . $request->getMethod() . " " . $request->getUri() . "`, but got a " . gettype($data); throw new UnexpectedContentException($message, $request, $response); } return $data; }