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