private function sync()
{
if ($this->synchronized) {
return;
}
/** @var ResponseInterface $clientResponse */
$clientResponse = $this->promise->wait();
if (200 !== $clientResponse->getStatusCode()) {
throw new RemoteCallFailedException();
}
$data = (string) $clientResponse->getBody();
// Null (empty response) is expected if only notifications were sent
$rawResponses = [];
if ('' !== $data) {
$rawResponses = json_decode($data, false);
if (json_last_error() !== JSON_ERROR_NONE) {
throw ResponseParseException::notAJsonResponse();
}
}
if (!is_array($rawResponses) && $rawResponses instanceof \stdClass) {
$rawResponses = [$rawResponses];
}
$this->responses = [];
foreach ($rawResponses as $rawResponse) {
try {
$response = new SyncResponse($rawResponse);
} catch (ResponseParseException $exception) {
//todo: logging??? (@scaytrase)
continue;
}
$this->responses[$response->getId()] = $response;
}
$this->synchronized = true;
}
/**
* {@inheritdoc}
*/
public function wait($unwrap = true)
{
$this->promise->wait(false);
if ($unwrap) {
if ($this->getState() == self::REJECTED) {
throw $this->exception;
}
return $this->response;
}
}
/**
* Gets the relevant data from the Guzzle clients.
*
* @param RequestInterface $request
* @param ResponseInterface|PromiseInterface $response
*/
public function __construct(RequestInterface $request, $response)
{
if ($response instanceof ResponseInterface) {
$this->httpStatusCode = $response->getStatusCode();
} elseif ($response instanceof PromiseInterface) {
$this->httpStatusCode = null;
} else {
throw new \InvalidArgumentException('Second constructor argument "response" must be instance of ResponseInterface or PromiseInterface');
}
$this->requestUrl = (string) $request->getUri();
}
/**
* Gets the relevant data from the Http client.
*
* @param TelegramRequest $request
* @param ResponseInterface|PromiseInterface $response
*/
public function __construct(TelegramRequest $request, $response)
{
if ($response instanceof ResponseInterface) {
$this->httpStatusCode = $response->getStatusCode();
$this->body = $response->getBody();
$this->headers = $response->getHeaders();
$this->decodeBody();
} elseif ($response instanceof PromiseInterface) {
$this->httpStatusCode = null;
} else {
throw new \InvalidArgumentException('Second constructor argument "response" must be instance of ResponseInterface or PromiseInterface');
}
$this->request = $request;
$this->endPoint = (string) $request->getEndpoint();
}
/**
* Request asynchronously using the current HTTP client, preparing the
* success and exception callbacks to transfer results in.
*
* @param string $method HTTP method
* @param callable $uriCallable Must return array of uri parts
* @param callable $optionsCallable Must return array of request options
* @param callable $onFulfilled Option callback to chain on fulfillment
* @param callable $onRejected Option callback to chain on rejection
*
* @return PromiseInterface
*/
protected function requestAsync($method, callable $uriCallable = null, callable $optionsCallable = null, callable $onFulfilled = null, callable $onRejected = null)
{
// clear previous responses and settle any async operation
$this->clearResponse();
// define request options
$uri = null;
$options = [];
try {
// uri
if ($uriCallable) {
$uri = (array) $uriCallable($this);
// sanitize uri parts, RFC 3986
$uri = implode('/', array_map('rawurlencode', $uri));
}
// options
if ($optionsCallable) {
$options = (array) $optionsCallable($this);
// safely build query string
if (isset($options['query']) && is_array($options['query'])) {
$options['query'] = http_build_query($options['query'], null, '&', PHP_QUERY_RFC3986);
}
}
} catch (MissingPropertyException $e) {
$this->setException($e);
return new RejectedPromiseException($this->getReasonPhrase(), $this);
}
// enforce http exceptions
$options['http_errors'] = true;
// request
$promise = $this->getHttpClient()->requestAsync($method, $uri, $options);
$self = $this;
$this->_promise = $promise->then(static function (ResponseInterface $response) use($self) {
// clear out
$self->_promise = null;
// set response
$self->transferResponseData($response);
// return the item itself
return $self;
}, static function (RequestException $e) use($self) {
// clear out
$self->_promise = null;
// set exception
$self->setException($e);
// set response, if there is one
if ($e->hasResponse()) {
$self->transferResponseData($e->getResponse());
// honor the Orchestrate error messages
if (!empty($self->_bodyArray['message'])) {
$self->_reasonPhrase = $self->_bodyArray['message'];
}
}
// return exception, with possibility to get the item back
return new RejectedPromise(new RejectedPromiseException($self->getReasonPhrase(), $self));
});
// chain
if ($onFulfilled || $onRejected) {
$this->_promise = $this->_promise->then($onFulfilled, $onRejected);
}
return $this->_promise;
}
private function withTracking(PromiseInterface $promise, $uri)
{
return $promise->then(function (ResponseInterface $response) use($uri) {
// Note that we are pushing to the front of the list as this
// would be an earlier response than what is currently present
// in the history header.
$header = $response->getHeader(self::HISTORY_HEADER);
array_unshift($header, $uri);
return $response->withHeader(self::HISTORY_HEADER, $header);
});
}
/**
* Waits for the operation to complete, when dealing with an asynchronous and incomplete operation.
*
* @throws \LogicException For unexpected exception not related to the SDK itself.
*/
public function wait()
{
/* The operation already completed, nothing to do. */
if ($this->isOperationComplete()) {
return;
}
/* Wait for the response and unwrap it. */
try {
$this->result = $this->wrapResult($this->promise->wait(true));
} catch (AwsException $e) {
/* Set the response and exception. */
$this->result = null;
$this->setupClientException($e);
}
}
/**
* {@inheritdoc}
*/
public function wait()
{
$this->promise->wait(false);
}
/**
* This method registers an onFulfilled and an onRejected handler to proxy the result to the deferred
*
* Note: The Guzzle\Promise will only be resolved when the global task queue `run` is invoked:
* This task queue MUST be run in an event loop in order for promises to be
* settled asynchronously.
*
* <code>
* while ($eventLoop->isRunning()) {
* GuzzleHttp\Promise\queue()->run();
* }
* </code>
*
* @param Deferred $deferred
* @param PromiseInterface $promise
*/
private function resolveOrRejectDeferredAsync(Deferred $deferred, PromiseInterface $promise)
{
$promise->then(function (ResponseInterface $response) use($deferred) {
try {
$payload = $this->getPayloadFromResponse($response);
$deferred->resolve($payload);
} catch (\Exception $e) {
$deferred->reject($e);
}
}, function ($reason) use($deferred) {
$deferred->reject($reason);
});
}
public function cancel()
{
$this->currentPromise->cancel();
$this->result->cancel();
}
