/** * 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); } }
private function sendRequestAsyncInternal(BaseRequest &$request, BaseResponse &$response, AsyncCallback $callback = NULL) { $this->addRequiredHeaders($request); $parameters = array('exceptions' => false, 'http_errors' => false); $queryString = $request->getQueryString(); $body = $request->getBody(); if ($queryString != NULL) { $parameters['query'] = $queryString; } if ($body != NULL) { $parameters['body'] = $body; } $request = new Request(strtoupper($request->getMethod()), $request->getResourcePath(), $request->getHeaders()); try { if ($callback != NULL) { return $this->client->sendAsync($request, $parameters)->then(function ($res) use(&$response, $callback) { try { $response->parseResponse($res->getStatusCode(), $res->getBody()); $callback->onSucceed($response); } catch (MnsException $e) { $callback->onFailed($e); } }); } else { return $this->client->sendAsync($request, $parameters); } } catch (TransferException $e) { $message = $e->getMessage(); if ($e->hasResponse()) { $message = $e->getResponse()->getBody(); } throw new MnsException($e->getCode(), $message, $e); } }
/** * {@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; }
/** * HttpRequest constructor. * @param Request $request * @param bool $streamed */ public function __construct(Request $request, $streamed = false) { $this->isStreamed = $streamed; $body = $request->getBody()->getContents(); if ($length = strlen($body)) { $request = $request->withHeader('Content-Length', $length); } // Build HTTP request $req[] = "{$request->getMethod()} {$request->getRequestTarget()} HTTP/{$request->getProtocolVersion()}"; $headers = $request->getHeaders(); foreach ($headers as $key => $v) { if (is_array($v)) { $v = Arrays::first($v); } $req[] = "{$key}: {$v}"; } $req[] = ''; if ($body) { $req[] = $body; } else { $req[] = ''; } $this->data = implode("\r\n", $req); $this->parserCallable = [$this, 'parseHead']; }
public function testOnlyResponse() { $request = new Request('GET', 'http://petstore.swagger.io/v2/pet/findByStatus'); $request->withHeader('Accept', 'application/json'); $response = $this->guzzleHttpClient->send($request); $this->assertResponseMatch($response, self::$schemaManager, '/v2/pet/findByStatus', 'get'); }
/** * This method adds the current header parameters to the REST API request. * * @param Request $request * @return Request $request */ public function apply(Request $request) { if ($this->replace) { return $request->withHeader($this->name, $this->value); } else { return $request->withAddedHeader($this->name, $this->value); } }
private function authenticateRequest(HttpRequest $request) { $body = JsonRpc\json_decode((string) $request->getBody()->getContents(), true); $body['auth'] = $this->auth_token; $json_body = JsonRpc\json_encode($body); $request = $request->withBody(Psr7\stream_for($json_body)); return $request; }
/** * {@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; }
private function guzzleClientShouldSetupToken() { $this->guzzleClient->shouldReceive('post')->with(WhenIWorkApi::WHEN_I_WORK_ENDPOINT . '/login', array('headers' => array('W-Key' => self::DEVELOPER_KEY), 'json' => array('username' => self::USERNAME, 'password' => self::PASSWORD)))->once()->andReturn($this->request); $mockStream = \Mockery::mock('GuzzleHttp\\Psr7\\Stream'); $mockStream->shouldReceive('close')->once(); $mockStream->shouldReceive('getContents')->once()->andReturn('{"login":{"token":"someHiddenToken"}}'); $this->request->shouldReceive('getBody')->once()->andReturn($mockStream); $this->request->shouldReceive('\\GuzzleHttp\\json_decode')->andReturn(array('login' => array('token' => self::TOKEN))); }
/** * 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))); }
/** * Adds static header(s) to the HTTP request headers * * @param \GuzzleHttp\Psr7\Request $request HTTP request object. * * @return \GuzzleHttp\Psr7\Request */ public function handleRequest($request) { $result = $request; foreach ($this->_headers as $key => $value) { $headers = $request->getHeaders(); if (!array_key_exists($key, $headers)) { $result = $result->withHeader($key, $value); } } return $result; }
/** * Applies the ETag or last modified cache control headers to the specified REST API request. The cache control * headers are applied conditionally. The ETag and last modified values will only be applied if they are not * null. Furthermore, the application of each are independent of the other. This could, therefore, only apply a * last modified cache control header and not an ETag cache control header if the ETag property of this instance * were null and last modified was not. * * @param Request $request * @param Request $request */ public function apply(Request $request) { $newRequest = $request; if ($this->etag !== null) { $newRequest = $request->withHeader(HeaderParameter::IF_MATCH, $this->etag); } if ($this->lastModified !== null) { $newRequest = $request->withHeader(HeaderParameter::IF_UNMODIFIED_SINCE, $this->lastModified); } return $newRequest; }
/** * @covers MicrosoftAzure\Storage\Common\Internal\Filters\HeadersFilter::handleRequest * @covers MicrosoftAzure\Storage\Common\Internal\Filters\HeadersFilter::__construct */ public function testHandleRequestEmptyHeaders() { // Setup $uri = new Uri('http://microsoft.com'); $request = new Request('Get', $uri, array(), NULL); $filter = new HeadersFilter(array()); $expected = $request->getHeaders(); // Test $request = $filter->handleRequest($request); // Assert $this->assertEquals($expected, $request->getHeaders()); }
/** * @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; }
/** * @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 verifySubProtocol(Request $request, Response $response) { $subProtocolRequest = $request->getHeader('Sec-WebSocket-Protocol'); if (empty($subProtocolRequest)) { return true; } $subProtocolResponse = $response->getHeader('Sec-WebSocket-Protocol'); if (count($subProtocolResponse) !== 1) { // there should be exactly one subprotocol sent back if we requested return false; } if (in_array($subProtocolResponse[0], $subProtocolRequest)) { // the response is one of the requested subprotocols return true; } return false; }
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); }
/** * 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 array $serverParams Server parameters, typically from $_SERVER * @param array $uploadedFiles Upload file information, a tree of UploadedFiles * @param string $uri URI for the request, if any. * @param string $method HTTP method for the request, if any. * @param string|resource|StreamInterface $body Message body, if any. * @param array $headers Headers for the message, if any. * @param array $cookies Cookies for the message, if any. * @param array $queryParams Query params for the message, if any. * @param array|object $parsedBody The deserialized body parameters, if any. * @param string $protocol HTTP protocol version. * * @throws InvalidArgumentException for any invalid value. */ public function __construct(array $serverParams = [], array $uploadedFiles = [], $uri = null, string $method = null, $body = null, array $headers = [], array $cookies = [], array $queryParams = [], $parsedBody = null, string $protocolVersion = '1.1') { $this->validateUploadedFiles($uploadedFiles); $this->attributes = []; $this->serverParams = $serverParams; $this->uploadedFiles = $uploadedFiles; $this->cookieParams = $cookies; $this->queryParams = $queryParams; $this->parsedBody = $parsedBody; parent::__construct($method, $uri, $headers, $body, $protocolVersion); }
/** * Send request upstream * * @param Request $request * * @return Response * @throws HttpException */ public static function makeRequest(Request $request) { try { $url = Url::createFromUrl($request->fullUrl()); $host = static::getHostFromUrl($url); $client = new Client(['base_uri' => $url->getScheme() . '://' . $host]); $proxyRequest = new GuzzleRequest($request->method(), $request->path()); $headers = $request->header(); array_walk($headers, function ($value, $key) use($proxyRequest) { $proxyRequest->withHeader($key, $value); }); $stream = \GuzzleHttp\Psr7\stream_for(json_encode($request->json()->all())); $response = $client->send($proxyRequest, ['timeout' => 2, 'body' => $stream, 'query' => $request->query(), 'form_params' => $request->input()]); return static::createLocalResponse($response); } catch (Exception $e) { if (get_class($e) == GuzzleException\ClientException::class) { return static::createLocalResponse($e->getResponse()); } abort(404); } }
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; }
public function __construct($method, $uri, array $headers = array(), $body = NULL, $protocolVersion = '1.1') { parent::__construct($method, $uri, $headers, $body, $protocolVersion); if (!in_array($this->getMethod(), array('HEAD', 'GET', 'POST'))) { throw new \InvalidArgumentException('Invalid or unsupported method ' . $this->getMethod()); } if (!in_array($this->getUri()->getScheme(), array('http', 'https'))) { throw new \InvalidArgumentException('Invalid or unsupported scheme ' . $this->getUri()->getScheme()); } if (!filter_var((string) $this->getUri(), FILTER_VALIDATE_URL)) { throw new \InvalidArgumentException('Invalid or unsupported URI ' . (string) $this->getUri()); } }
public function addRequiredHeaders() { foreach ($this->defaultHeaders as $k => $v) { // remove any header that is there now $this->request = $this->request->withoutHeader($k); $this->request = $this->request->withHeader($k, $v); } if (!empty($this->subProtocols)) { $this->request = $this->request->withoutHeader('Sec-WebSocket-Protocol'); $this->request = $this->request->withHeader('Sec-WebSocket-Protocol', $this->subProtocols); } $this->request = $this->request->withoutHeader("Sec-WebSocket-Key"); $this->request = $this->request->withHeader("Sec-WebSocket-Key", $this->websocketKey); }
/** * Parses a request message string into a request object. * * @param string $message Request message string. * * @return Request */ function parse_request($message) { $data = _parse_message($message); $matches = []; if (!preg_match('/^[\\S]+\\s+([a-zA-Z]+:\\/\\/|\\/).*/', $data['start-line'], $matches)) { throw new \InvalidArgumentException('Invalid request string'); } $parts = explode(' ', $data['start-line'], 3); $version = isset($parts[2]) ? explode('/', $parts[2])[1] : '1.1'; $request = new Request($parts[0], $matches[1] === '/' ? _parse_request_uri($parts[1], $data['headers']) : $parts[1], $data['headers'], $data['body'], $version); return $matches[1] === '/' ? $request : $request->withRequestTarget($parts[1]); }
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); }
/** * {@inheritDoc} */ public function getResource() { return $this->request->getRequestTarget(); }
/** * 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); }