private function createRequestForApiCall(ApiCallInterface $apiCall)
{
$request = $this->guzzleClient->createRequest($apiCall->getMethod(), $apiCall->getPath(), $apiCall->getHeaders(), $apiCall->getBody());
$query = $request->getQuery();
$query->merge($apiCall->getQuery());
$query->set('api_key', $this->apiKey);
return $request;
}
/**
* @param string $endpoint
* @param string $content
* @param array $headers
* @param array $files
*
* @return Response
*/
public function send($endpoint, $content, array $headers = array(), array $files = array())
{
$request = $this->client->createRequest(RequestInterface::POST, $endpoint, $headers, $content, array('exceptions' => false));
if ($files && $request instanceof EntityEnclosingRequestInterface) {
$request->addPostFiles($files);
}
$response = $request->send();
return new Response($response->getStatusCode(), $response->getBody(true));
}
public function download()
{
$progressFunctions = null;
if ($this->getProgressFunction()) {
$progressFunctions = $this->createProgressFunctions(array_fill(0, count($this->requests), 0));
}
$requests = array();
foreach ($this->requests as $i => $r) {
$requests[] = $request = $this->client->createRequest('GET', $r['url'], array(), null, array('save_to' => $r['file']));
if ($progressFunctions !== null) {
// Guzzle progress is too complex for my needs
$request->getCurlOptions()->add(CURLOPT_NOPROGRESS, false)->add(CURLOPT_PROGRESSFUNCTION, $progressFunctions[$i]);
}
}
$this->client->send($requests);
}
/**
* Sends all requests to each caching proxy server
*
* Requests are sent in parallel to minimise impact on performance.
*
* @param RequestInterface[] $requests Requests
*
* @throws ExceptionCollection
*/
private function sendRequests(array $requests)
{
$allRequests = array();
foreach ($requests as $request) {
$headers = $request->getHeaders()->toArray();
// Force to re-create Host header if empty, as Apache chokes on this. See #128 for discussion.
if (empty($headers['Host'])) {
unset( $headers['Host'] );
}
foreach ($this->servers as $server) {
$proxyRequest = $this->client->createRequest(
$request->getMethod(),
$server . $request->getResource(),
$headers
);
$allRequests[] = $proxyRequest;
}
}
try {
$this->client->send($allRequests);
} catch (GuzzleExceptionCollection $e) {
$this->handleException($e);
}
}
/**
* Creates a request.
*
* @param \Ivory\HttpAdapter\Message\InternalRequestInterface $internalRequest The internal request.
* @param callable|null $success The success callable.
* @param callable|null $error The error callable.
*
* @return \Ivory\HttpAdapter\Message\RequestInterface The request.
*/
private function createRequest(InternalRequestInterface $internalRequest, $success = null, $error = null)
{
$request = $this->client->createRequest($internalRequest->getMethod(), (string) $internalRequest->getUri(), $this->prepareHeaders($internalRequest), $this->prepareContent($internalRequest), array('exceptions' => false, 'allow_redirects' => false, 'timeout' => $this->getConfiguration()->getTimeout(), 'connect_timeout' => $this->getConfiguration()->getTimeout()));
$request->setProtocolVersion($internalRequest->getProtocolVersion());
if (is_callable($success)) {
$messageFactory = $this->getConfiguration()->getMessageFactory();
$request->getEventDispatcher()->addListener('request.success', function (Event $event) use($messageFactory, $success, $internalRequest) {
$response = $messageFactory->createResponse($event['response']->getStatusCode(), $event['response']->getProtocolVersion(), $event['response']->getHeaders()->toArray(), BodyNormalizer::normalize(function () use($event) {
$resource = $event['response']->getBody()->getStream();
$event['response']->getBody()->detachStream();
return $resource;
}, $internalRequest->getMethod()));
$response = $response->withParameter('request', $internalRequest);
call_user_func($success, $response);
});
}
if (is_callable($error)) {
$httpAdapterName = $this->getName();
$request->getEventDispatcher()->addListener('request.exception', function (Event $event) use($error, $internalRequest, $httpAdapterName) {
$exception = HttpAdapterException::cannotFetchUri($event['exception']->getRequest()->getUrl(), $httpAdapterName, $event['exception']->getMessage());
$exception->setRequest($internalRequest);
call_user_func($error, $exception);
});
}
return $request;
}
/**
* @param $method
* @param $fullUrl
* @param array $query
* @param string $body
* @param array $headers
* @param array $options
* @return RequestInterface
*/
public function prepareRequest($method, $fullUrl, array $query = array(), $body = '', array $headers = array(), array $options = array())
{
$query["sign"] = $this->getSignature($body);
$headers["Authorization"] = "TOKEN " . $this->apiToken;
$fullUrl = $this->formatUrl($fullUrl, $query);
$request = $this->client->createRequest($method, $fullUrl, $headers, $body, $options);
return $request;
}
/**
* @param $url
* @return int|null
*/
private function getHttpStatus($url)
{
$request = $this->httpClient->createRequest('GET', $url);
try {
return $request->send()->getStatusCode();
} catch (RequestException $e) {
}
return null;
}
/**
* @param string $httpMethod
* @param string $path
*/
protected function createRequest($httpMethod, $path, $body = null, array $headers = array(), array $options = array())
{
$path = $this->options['api_version'] . '/' . $path;
if ($httpMethod === 'GET' && $body) {
$path .= false === strpos($path, '?') ? '?' : '&';
$path .= utf8_encode(http_build_query($body, '', '&'));
}
return $this->client->createRequest($httpMethod, $path, array_merge($this->headers, $headers), $body, $options);
}
/**
* get all actions
*
* @param ClientCommand $command
*
* @return Response|CommandResponse|DecryptedCommandResponse|StatusResponse
*/
public function send(ClientCommand $command)
{
$request = $this->client->createRequest($command->method(), $this->client->getBaseUrl() . $command->uri($this->cryptographyEngine), $this->headers($command->apiVersion(), $command->format(), $command->headers()), $command->body($this->cryptographyEngine), $this->config->getHttpClientConfig());
try {
$response = $request->send();
} catch (ClientErrorResponseException $exception) {
$response = $exception->getResponse();
} catch (ServerErrorResponseException $exception) {
$response = $exception->getResponse();
}
return $command->response($response, $this->cryptographyEngine);
}
/**
* @param string $method
* @param string $relativeUrl
* @param array $params
* @return array
* @throws Exception\BaseApiErrorResponseException
* @throws Exception\RuntimeException
* @throws Exception\RateLimitExceededException
*/
public function request($method, $relativeUrl, array $params = [])
{
if (!$this->token instanceof AccessToken) {
throw new RuntimeException('Not authorized yet.');
}
$request = $this->httpClient->createRequest($method, $relativeUrl, ['Authorization' => "Bearer {$this->token->accessToken}"], null, $params);
try {
$response = $this->httpClient->send($request);
$body = json_decode($response->getBody(), true) or [];
return $body;
} catch (BadResponseException $e) {
$body = json_decode($e->getResponse()->getBody(), true);
switch ($body['error_description']) {
case self::ACCESS_TOKEN_EXPIRED_MESSAGE:
$this->refresh();
return $this->request($method, $relativeUrl, $params);
case self::RATE_LIMIT_EXCEEDED_MESSAGE:
throw new RateLimitExceededException(self::RATE_LIMIT_EXCEEDED_MESSAGE);
default:
throw new BaseApiErrorResponseException($body, $e->getResponse()->getStatusCode());
}
}
}
/**
* Sends all requests to each caching proxy server.
*
* Requests are sent in parallel to minimise impact on performance.
*
* @param RequestInterface[] $requests Requests
*
* @throws ExceptionCollection
*/
private function sendRequests(array $requests)
{
$allRequests = [];
foreach ($requests as $request) {
/* @var RequestInterface $request */
$proxyRequest = $this->client->createRequest($request->getMethod(), $request->getUrl(), $request->getHeaders());
$allRequests[] = $proxyRequest;
}
try {
$this->client->send($allRequests);
} catch (MultiTransferException $e) {
$this->handleException($e);
}
}
/**
* Create request
*
* @param string $method HTTP method
* @param string $url URL
* @param array $headers HTTP headers
*
* @return RequestInterface
*/
protected function createRequest($method, $url, array $headers = array())
{
return $this->client->createRequest($method, $url, $headers);
}
/**
* Create a request object to send to the server
*
* @param string $httpMethod
* @param string $path
* @param mixed $body
* @param array $options
*
* @return \Guzzle\Http\Message\RequestInterface
*/
protected function createRequest($httpMethod, $path, $body = null, array $options = array())
{
return $this->client->createRequest($httpMethod, $path, $this->headers, $body, $options);
}
