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