PHP ClientInterface::sendAsync方法代码示例

 /** @test */
 public function it_fails_when_try_to_send_requests_in_bath_with_wrong_method()
 {
     $this->expectException(\RuntimeException::class);
     $expectedRequest1 = new Request('GET', 'http://some-absolute/uri1', ['Accept' => ['application/vnd.eventstore.atom+json']]);
     $this->guzzle->sendAsync($expectedRequest1, [])->willReturn(new Response(200, [], '{"some": "data1"}'));
     $this->client->requestsBatch('PUT', ['http://some-absolute/uri1']);
 }

 /**
  * @param Psr7Request $request
  * @param Array       $options Http options for the client.
  *
  * @return GuzzleHttp\Promise\PromiseInterface Promise that will be resolved with a
  *                                             Psr\Http\Message\ResponseInterface
  *                                             response object.
  */
 public function __invoke(RequestInterface $request, array $options)
 {
     // Remove options that are not supported.
     foreach (array_keys($options) as $key) {
         if (!isset(self::$validOptions[$key])) {
             unset($options[$key]);
         }
     }
     return $this->client->sendAsync($request, $options);
 }

 /**
  * @param Psr7Request $request
  * @param array       $options
  *
  * @return Promise\Promise
  */
 public function __invoke(Psr7Request $request, array $options = [])
 {
     $request = $request->withHeader('User-Agent', $request->getHeaderLine('User-Agent') . ' ' . \GuzzleHttp\default_user_agent());
     return $this->client->sendAsync($request, $this->parseOptions($options))->otherwise(static function (\Exception $e) {
         $error = ['exception' => $e, 'connection_error' => $e instanceof ConnectException, 'response' => null];
         if ($e instanceof RequestException && $e->getResponse()) {
             $error['response'] = $e->getResponse();
         }
         return new Promise\RejectedPromise($error);
     });
 }

 /**
  * @param ClientInterface $client   Client used to send the requests.
  * @param array|\Iterator $requests Requests or functions that return
  *                                  requests to send concurrently.
  * @param array           $config   Associative array of options
  *     - concurrency: (int) Maximum number of requests to send concurrently
  *     - options: Array of request options to apply to each request.
  *     - fulfilled: (callable) Function to invoke when a request completes.
  *     - rejected: (callable) Function to invoke when a request is rejected.
  */
 public function __construct(ClientInterface $client, $requests, array $config = [])
 {
     // Backwards compatibility.
     if (isset($config['pool_size'])) {
         $config['concurrency'] = $config['pool_size'];
     } elseif (!isset($config['concurrency'])) {
         $config['concurrency'] = 25;
     }
     if (isset($config['options'])) {
         $opts = $config['options'];
         unset($config['options']);
     } else {
         $opts = [];
     }
     $iterable = \GuzzleHttp\Promise\iter_for($requests);
     $requests = function () use($iterable, $client, $opts) {
         foreach ($iterable as $key => $rfn) {
             if ($rfn instanceof RequestInterface) {
                 (yield $key => $client->sendAsync($rfn, $opts));
             } elseif (is_callable($rfn)) {
                 (yield $key => $rfn($opts));
             } else {
                 throw new \InvalidArgumentException('Each value yielded by ' . 'the iterator must be a Psr7\\Http\\Message\\RequestInterface ' . 'or a callable that returns a promise that fulfills ' . 'with a Psr7\\Message\\Http\\ResponseInterface object.');
             }
         }
     };
     $this->each = new EachPromise($requests(), $config);
 }

 /**
  * {@inheritdoc}
  *
  * @return PromiseInterface
  */
 public function run(CommandInterface $command, $result = null)
 {
     $key = $command->getRequestMethod() === 'GET' ? 'query' : 'body';
     $options = [$key => []];
     if (!empty($params = $command->getParams())) {
         $options[$key] = array_merge($options[$key], $params);
     }
     if ($config = $this->getConfig()) {
         if (!empty($config->getSteamKey())) {
             $options[$key]['key'] = $config->getSteamKey();
         }
         $this->urlBuilder->setBaseUrl($config->getBaseSteamApiUrl());
     }
     $request = new Request($command->getRequestMethod(), $this->urlBuilder->build($command));
     return $this->client->sendAsync($request, $options);
 }

 /**
  * {@inheritdoc}
  */
 public function invoke($calls)
 {
     try {
         if (!is_array($calls) && $calls instanceof RpcRequestInterface) {
             $transformedCall = $this->transformCall($calls);
             return new JsonRpcResponseCollection($this->client->sendAsync($this->createHttpRequest($transformedCall)), [new RequestTransformation($calls, $transformedCall)]);
         }
         $requests = [];
         $batchRequest = [];
         foreach ($calls as $key => $call) {
             $transformedCall = $this->transformCall($call);
             $requests[spl_object_hash($call)] = new RequestTransformation($call, $transformedCall);
             $batchRequest[] = $transformedCall;
         }
         return new JsonRpcResponseCollection($this->client->sendAsync($this->createHttpRequest($batchRequest)), $requests);
     } catch (GuzzleException $exception) {
         throw new RemoteCallFailedException($exception->getMessage(), 0, $exception);
     }
 }

 /**
  * Send asynchronous guzzle request
  *
  * @param RequestInterface $request
  * @param \Tebru\Retrofit\Http\Callback $callback
  * @return null
  */
 public function sendAsync(RequestInterface $request, Callback $callback)
 {
     $this->promises[] = $this->client->sendAsync($request)->then(function (ResponseInterface $response) use($callback, $request) {
         if (null !== $this->eventDispatcher) {
             $this->eventDispatcher->dispatch(AfterSendEvent::NAME, new AfterSendEvent($request, $response));
         }
         $callback->onResponse($response);
     }, function (Exception $exception) use($callback, $request) {
         $response = null;
         $context = [];
         if ($exception instanceof \GuzzleHttp\Exception\RequestException) {
             $request = $exception->getRequest();
             $response = $exception->getResponse();
             $context = $exception->getHandlerContext();
         }
         $requestException = new RequestException($exception->getMessage(), $exception->getCode(), $exception->getPrevious(), $request, $response, $context);
         if (null !== $this->eventDispatcher) {
             $this->eventDispatcher->dispatch(ApiExceptionEvent::NAME, new ApiExceptionEvent($requestException, $request));
         }
         $callback->onFailure($requestException);
     });
 }

 private function getRequestWorkerFn()
 {
     while ($request = $this->queue->pop()) {
         try {
             $this->dispatchSending($request);
             $promise = $this->client->sendAsync($request)->then($this->getRequestFulfilledFn($request), $this->getRequestRejectedFn($request));
             (yield $promise);
         } catch (\Exception $e) {
             // Mark the request as complete so we don't get stuck on it.
             $this->queue->complete($request);
             $this->dispatchException($request, $e, null);
             (yield \GuzzleHttp\Promise\rejection_for($e));
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public function sendAsyncRequest(RequestInterface $request)
 {
     $promise = $this->client->sendAsync($request);
     return new Guzzle6Promise($promise, $request);
 }

 /**
  * Send asynchronous guzzle request
  *
  * @param Request $request
  * @param \Tebru\Retrofit\Http\Callback $callback
  * @return null
  */
 public function sendAsync(Request $request, Callback $callback)
 {
     $this->promises[] = $this->client->sendAsync($request)->then($callback->success(), $callback->failure());
 }

 /**
  * @param RequestInterface $request
  * @return PromiseInterface|ResponseInterface
  */
 protected function send(RequestInterface $request)
 {
     return $this->async ? $this->client->sendAsync($request) : $this->client->send($request);
 }

 /**
  * {@inheritdoc}
  */
 public function sendAsync(RequestInterface $request, array $options = []) : Promise
 {
     $promise = $this->client->sendAsync($request, $options);
     return new GuzzlePromise($promise, $request);
 }

 /**
  * {@inheritdoc}
  */
 public function sendAllAsync(array $requests)
 {
     return $this->httpClient->sendAsync($this->createRequest(RequestInterface::BATCH, $this->getBatchRequestOptions($requests)))->then(function (ResponseInterface $response) {
         return $this->getBatchResponses($response);
     });
 }