/**
* @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;
}
/**
* {@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;
}
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(), ['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;
}
/**
* 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);
}
/**
* Reads a page of results, usually of type \Gedcomx\Atom\Feed.
*
* @param string $rel The rel
* @param \Gedcomx\Rs\Client\Options\StateTransitionOption $option,... zero or more StateTransitionOption objects
*
* @return \Gedcomx\Rs\Client\GedcomxApplicationState The requested page.
*/
protected function readPage($rel, StateTransitionOption $option = null)
{
$link = $this->getLink($rel);
if ($link === null || $link->getHref() === null) {
return null;
}
$headers = ['Accept' => count($this->request->getHeader("Accept")) > 0 ? $this->request->getHeader("Accept")[0] : null, 'Content-Type' => count($this->request->getHeader("Content-Type")) > 0 ? $this->request->getHeader("Content-Type")[0] : null];
$request = $this->createAuthenticatedRequest($this->request->getMethod(), $link->getHref(), $headers);
$class = get_class($this);
return new $class($this->client, $request, $this->passOptionsTo('invoke', array($request), func_get_args()), $this->accessToken, $this->stateFactory);
}
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 testCapitalizesMethod()
{
$r = new Request('get', '/');
$this->assertEquals('GET', $r->getMethod());
}
/**
* @param Request $request
* @param Connection $connection
*
* @return Psr7\Request
*/
protected function _createPsr7Request(Request $request, Connection $connection)
{
$req = new Psr7\Request($request->getMethod(), $this->_getActionPath($request), $connection->hasConfig('headers') && is_array($connection->getConfig('headers')) ? $connection->getConfig('headers') : []);
$data = $request->getData();
if (!empty($data) || '0' === $data) {
if ($req->getMethod() == Request::GET) {
$req = $req->withMethod(Request::POST);
}
if ($this->hasParam('postWithRequestBody') && $this->getParam('postWithRequestBody') == true) {
$request->setMethod(Request::POST);
$req = $req->withMethod(Request::POST);
}
$req = $req->withBody(Psr7\stream_for(is_array($data) ? JSON::stringify($data, 'JSON_ELASTICSEARCH') : $data));
}
return $req;
}
/**
* 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);
}
/**
* 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());
}
public function testBadRequest()
{
$url = new Uri('/test');
$expReq = new Request('GET', $url);
$expRespData = ['test' => true];
$expResp = new Response(400, ['Content-Type' => 'application/json'], json_encode($expRespData));
$httpClient = $this->getMockHttpClient();
$httpClient->expects($this->once())->method('request')->with($this->equalTo('GET'), $this->equalTo($url->getPath()))->will($this->throwException(new RequestException('Invalid request', $expReq, $expResp)));
$client = new Client();
$client->setHttpClient($httpClient);
try {
$data = $client->exec($url->getPath(), $expReq->getMethod());
} catch (RequestException $e) {
$this->assertEquals($expResp, $e->getResponse());
$this->assertEquals($expResp, $client->getResponse());
return;
} catch (\Exception $e) {
$this->fail(sprintf('Expected exception of type GuzzleHttp\\Exception\\RequestException, got %s', get_class($e)));
}
$this->fail('Expected exception was not thrown');
}
/**
* Assert that the HTTP request method of a request is the same as $method
*
* @param string $method
* Expected HTTP request method i.e. GET, POST
* @param Request $request
* Request object to check
* @return void
*/
public function assertRequestMethodSame($method, Request $request)
{
$this->assertSame($method, $request->getMethod());
}
/**
* 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;
}
/**
* {@inheritDoc}
*/
public function getMethod()
{
return $this->request->getMethod();
}
/**
* 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;
}
