public function __invoke(RequestInterface $request, array $options) { $fn = $this->nextHandler; $throttleId = isset($options['throttle_id']) ? $options['throttle_id'] : null; $limit = isset($options['throttle_limit']) ? $options['throttle_limit'] : null; if (!$throttleId || !$limit) { // Request is not throttled; just ignore it. return $fn($request, $options); } if (!isset($this->running[$throttleId])) { $this->running[$throttleId] = 0; $this->queue[$throttleId] = []; } $promise = new Promise([\GuzzleHttp\Promise\queue(), 'run']); if ($this->running[$throttleId] + 1 <= $limit) { // Queue has enough space; run this request and watch for queue size. ++$this->running[$throttleId]; return $fn($request, $options)->then($this->getQueuePopper($throttleId, true), $this->getQueuePopper($throttleId, false)); } // The queue is full; delay the request, and don't forget to also pop the queue. $this->queue[$throttleId][] = function () use($request, $options, $fn, $throttleId, $promise) { $promise->resolve($fn($request, $options)->then($this->getQueuePopper($throttleId, true), $this->getQueuePopper($throttleId, false))); }; return $promise; }
public function testAsynchronouslyInvokesOnFulfilled() { $p = new FulfilledPromise('a'); $r = null; $f = function ($d) use(&$r) { $r = $d; }; $p2 = $p->then($f); $this->assertNotSame($p, $p2); $this->assertNull($r); \GuzzleHttp\Promise\queue()->run(); $this->assertEquals('a', $r); }
public function listen($port, $host = '127.0.0.1') { self::$loop = Factory::create(); $socket = new SocketServer(self::$loop); $http = new HttpServer($socket); $queue = \GuzzleHttp\Promise\queue(); $queue->run(); self::$loop->addPeriodicTimer(0, [$queue, 'run']); //Add Intervals $intervals = Interval::getIntervals(); if ($intervals instanceof \ArrayIterator) { foreach ($intervals as $interval) { self::$loop->addPeriodicTimer($interval->getTime(), $interval->getCallback()); } } $http->on('request', $this->app); echo "Server running on {$host}:{$port}\n"; $socket->listen($port, $host); self::$loop->run(); }
/** * @test */ public function it_rejects_deferred_with_runtime_exception_asynchronous_when_json_response_is_invalid() { $producerInAsyncMode = new HttpMessageProducer($this->guzzleClient, new NoOpMessageConverter(), null, true); $fetchDataQuery = new FetchSomething(['filter' => 'foo']); $psrResponse = $this->prophesize(ResponseInterface::class); $queryDeferred = new Deferred(); $producerInAsyncMode($fetchDataQuery, $queryDeferred); //Return invalid json $psrResponse->getBody()->willReturn('[{"data" => "bar"'); $this->responsePromise->resolve($psrResponse->reveal()); //Perform next tick, required to resolve the promise when we are in async mode $queue = \GuzzleHttp\Promise\queue(); $queue->run(); $rejectionReason = null; $queryDeferred->promise()->otherwise(function ($reason) use(&$rejectionReason) { $rejectionReason = $reason; }); $this->assertInstanceOf(RuntimeException::class, $rejectionReason); }
public function testCreatesPromiseWhenFulfilledBeforeThen() { $p = new Promise(); $p->resolve('foo'); $carry = null; $p2 = $p->then(function ($v) use(&$carry) { $carry = $v; }); $this->assertNotSame($p, $p2); $this->assertNull($carry); \GuzzleHttp\Promise\queue()->run(); $this->assertEquals('foo', $carry); }
public function testCanResolveThenWithSuccess() { $actual = null; $p = new RejectedPromise('foo'); $p->otherwise(function ($v) { return $v . ' bar'; })->then(function ($v) use(&$actual) { $actual = $v; }); \GuzzleHttp\Promise\queue()->run(); $this->assertEquals('foo bar', $actual); }
protected function invokeQueue() { $this->loop->addTimer(static::QUEUE_TIMER_INTERVAL, function () { \GuzzleHttp\Promise\queue()->run(); }); }
private function processProcessMessages() { $clean = true; reset($this->processHandles); $now = time(); $checkTimeout = $this->processTimeoutChecker !== $now; $this->processTimeoutChecker = $now; while ($entry = current($this->processHandles)) { next($this->processHandles); /** @var LoopHandle $easy */ $easy = $entry['easy']; if ($checkTimeout) { try { $easy->handle->checkTimeout(); } catch (ProcessFailedException $timeoutException) { } } if ($easy->handle->isRunning()) { continue; } /** @var Promise $deferred */ $deferred = $entry['promise']; unset($this->processHandles[$entry['id']]); if ($easy->handle->isSuccessful()) { $deferred->resolve(isset($timeoutException) ? new RejectedPromise($timeoutException) : $easy->handle); } else { $deferred->reject(new ProcessFailedException($easy->handle)); } $clean = false; } if (!$clean) { \GuzzleHttp\Promise\queue()->run(); return true; } return false; }