/** * Starts pending tasks end move them from the pendingQueue to the runningQueue */ private function startPendingTasks() { while (count($this->runningTasks) < $this->concurrencyLimit && !$this->pendingTasks->isEmpty()) { /** @var TaskInterface $task */ $task = $this->pendingTasks->dequeue(); $task->start()->progress(function (Event $notification) { $this->deferred->notify($notification); })->always(function () use($task) { $this->finishedTasks[] = $task; $this->deferred->notify(new TaskFinishedEvent($this, $task)); }); $this->deferred->notify(new TaskStartedEvent($this, $task)); $this->runningTasks->enqueue($task); } }
/** * @return LogEvent */ public function getLoggedEvent() : LogEvent { if (!$this->hasLoggedEvents()) { throw new \LogicException('No more events logged!'); } return $this->logs->dequeue(); }
public function onExit($status) { if ($this->pendingRequests->count() > 0) { $nextExpectedTest = $this->pendingRequests->dequeue(); $this->distributor->testCompleted($this, TestResult::errorFromRequest($nextExpectedTest, "Worker{$this->id} died\n{$this->testErr}")); } }
/** @return Error|null */ public static function pop() { if (!self::$errors) { return null; } return self::$errors->count() > 0 ? self::$errors->dequeue() : null; }
/** * Deliver notifications via given instance of Notifier * @param Notifier $notifier */ public function deliver(Notifier $notifier) { foreach ($this->queue as $notification) { $notifier->notify($notification); $this->queue->dequeue(); } }
public function __invoke($id, $service) { if ($this->middlewares->isEmpty()) { return $service; } $method = $this->middlewares->dequeue(); return call_user_func($method, $this->container, new Next($this->container, $this->middlewares), $id, $service); }
public function close() { if (!$this->promises->isEmpty()) { $this->promises->dequeue()->resolve(); } else { $this->current--; } }
public function uncork() { if (!$this->corked) { return; } while (!$this->corked && !$this->writeBuffer->isEmpty()) { $this->doWrite(...$this->writeBuffer->dequeue()); } }
/** * @inheritDoc */ public function getQuery(Driver $driver, $link) { if (!$this->pool->contains($link)) { throw new \OutOfBoundsException(sprintf('Undefined %s in the pooling controller.', $driver->info($link))); } if (!$this->waiting->isEmpty()) { return $this->waiting->dequeue(); } $this->idle->enqueue($link); }
protected function processQueue() { $this->loop->futureTick(function () { if ($this->callQueue->isEmpty()) { return; } $message = $this->callQueue->dequeue(); $data = ['function' => $message->getFunction(), 'args' => $message->getArgs(), 'errorResultCode' => $message->getErrorResultCode()]; $message->getDeferred()->resolve($data); }); }
/** * Once a connection has finished being used... * @param Connection $connection */ public function releaseConnection(Connection $connection) { // If we have any promises waiting for the connection, pass it along. if ($this->waiting->count() > 0) { $cb = $this->waiting->dequeue(); $cb($connection); return; } // Otherwise, move it to the idle queue. $this->available->enqueue($connection); }
/** * @param Message $chapterCommand * @param mixed $data * @param ChapterLogger $chapterLogger */ public function __invoke(Message $chapterCommand, $data, ChapterLogger $chapterLogger) { $done = $this->done; // No middleware remains; done if ($this->queue->isEmpty()) { return $done($chapterCommand, $data, $chapterLogger); } $stage = $this->queue->dequeue(); $executeStage = $this->executeStage; return $executeStage($stage, $chapterCommand, $data, $chapterLogger, $this); }
private function run() { /** @var HttpServer $server */ $server = $this->container->get('http_server'); // Run async dispatcher $server->getLoop()->addPeriodicTimer(Timer::MIN_INTERVAL, function (Timer $timer) { if ($this->queue->isEmpty()) { $timer->cancel(); return; } $event = $this->queue->dequeue(); $this->dispatch($event); }); }
/** * @param Request $request * @param Response $response * @param callable[] ...$callables unshift callables (top priority) * @return Response */ public function __invoke(Request $request, Response $response, ...$callables) { while ($callable = array_pop($callables)) { $this->queue->unshift($callable); } if ($this->queue->isEmpty()) { return $response; } $callable = $this->resolve($this->queue->dequeue()); if (is_callable($callable)) { return call_user_func($callable, $request, $response, $this); } else { throw new \UnexpectedValueException(); } }
/** * Process the given queue of template files and * returns the generated output. * * @param string $file * * @return string * @throws RendererException */ public function render(string $file) : string { if ($this->rendering) { throw new RendererException("Cannot call render() inside templates."); } $this->rendering = true; $this->queue->enqueue($file); $this->sections()->declare('content'); ob_start(); while (!$this->queue->isEmpty()) { $file = $this->engine->path($this->queue->dequeue()); if (!file_exists($file)) { throw new \RuntimeException("Cannot find file: {$file}"); } require $file; $this->sections()->populate('content', ob_get_contents(), 'replace'); ob_clean(); if ($this->extended) { $this->extended = false; } } ob_end_clean(); $this->rendering = false; return $this->sections()->fetch('content'); }
/** * @return string[] names of any dependencies involved in dependency cycle[s] (or that depend * upon those in the cycle) */ public function list_dependency_cycles() { $dep_counts = $this->dependency_counts(); $depends_on = $this->reverse_graph(); $deps_met_queue = new \SplQueue(); foreach ($dep_counts as $dependency => $count) { if ($count === 0) { $deps_met_queue->enqueue($dependency); } } // Iteratively resolve dependencies $num_removed = 0; while (!$deps_met_queue->isEmpty()) { $name = $deps_met_queue->dequeue(); $num_removed++; if (!array_key_exists($name, $depends_on)) { continue; } foreach ($depends_on[$name] as $dependant) { $dep_counts[$dependant]--; if ($dep_counts[$dependant] === 0) { $deps_met_queue->enqueue($dependant); } } } // Find the dependencies that couldn't be resolved $depends_on_cycle = []; foreach ($dep_counts as $dependency => $count) { if ($count > 0) { $depends_on_cycle[] = $dependency; } } return $depends_on_cycle; }
/** * a generator that loops once over the dequeued and return a watcher * * @return WatcherInterface[] */ protected function getDequeuedWatcher() { $c = $this->queue->count(); for ($i = 0; $i < $c; $i++) { (yield $this->queue->dequeue()); } }
/** * @param null $lastPublicationId */ private function processStateQueue($lastPublicationId = null) { if ($lastPublicationId !== null) { // create an array of pub ids // if we can't find the lastPublicationId in the queue // then we are going to assume it was before our time $pubIds = []; /** @var EventMessage $msg */ foreach ($this->pauseQueue as $msg) { $pubIds[] = $msg->getPublicationId(); } if (!in_array($lastPublicationId, $pubIds)) { $lastPublicationId = null; } } while (!$this->pauseQueue->isEmpty()) { $msg = $this->pauseQueue->dequeue(); if ($lastPublicationId === null) { $this->sendEventMessage($msg); } if ($lastPublicationId == $msg->getPublicationId()) { $lastPublicationId = null; } } }
function bfs_path($graph, $start, $end) { $queue = new SplQueue(); # Enqueue the path $queue->enqueue([$start]); $visited = [$start]; while ($queue->count() > 0) { $path = $queue->dequeue(); # Get the last node on the path # so we can check if we're at the end $node = $path[sizeof($path) - 1]; if ($node === $end) { return $path; } foreach ($graph[$node] as $neighbour) { if (!in_array($neighbour, $visited)) { $visited[] = $neighbour; # Build new path appending the neighbour then and enqueue it $new_path = $path; $new_path[] = $neighbour; $queue->enqueue($new_path); } } } return false; }
/** * Process the Queue * * @throws \Exception */ public function processQueue() { if (!$this->getAllowMultipleRegistrations()) { throw new \Exception("queuing only allowed when there are multiple registrations"); } // find the best candidate while ($this->callQueue->count() > 0) { $congestion = true; /* @var $bestRegistration \Thruway\Registration */ $bestRegistration = $this->registrations[0]; /* @var $registration \Thruway\Registration */ foreach ($this->registrations as $registration) { if ($registration->getSession()->getPendingCallCount() == 0) { $bestRegistration = $registration; $congestion = false; break; } if ($registration->getSession()->getPendingCallCount() < $bestRegistration->getSession()->getPendingCallCount()) { $bestRegistration = $registration; } } if ($congestion) { // there is congestion $bestRegistration->getSession()->getRealm()->publishMeta('thruway.metaevent.procedure.congestion', [["name" => $this->getProcedureName()]]); return; } $call = $this->callQueue->dequeue(); $bestRegistration->processCall($call); } }
protected function doTask() { $resource = null; //从空闲队列中取出可用的资源 while (count($this->idlePool) > 0) { $_resource = $this->idlePool->dequeue(); $rid = spl_object_hash($_resource); //资源已经不可用了,连接已关闭 if (!isset($this->resourcePool[$rid])) { continue; } else { //找到可用连接 $resource = $_resource; break; } } //没有可用连接,继续等待 if (!$resource) { if (count($this->resourcePool) == 0) { call_user_func($this->createFunction); $this->resourceNum++; } return; } $callback = $this->taskQueue->dequeue(); call_user_func($callback, $resource); }
/** * Close the writer * * @return void */ public function shutdown() { while (!$this->buffer->isEmpty()) { $this->buffer->dequeue(); } $this->writer->shutdown(); }
public function processQueue() { if ($this->commandQueue->count() == 0) { return; } if ($this->connStatus === $this::CONNECTION_BAD) { $this->failAllCommandsWith(new \Exception("Bad connection: " . $this->lastError)); $this->stream->end(); return; } while ($this->commandQueue->count() > 0 && $this->queryState === static::STATE_READY) { /** @var CommandInterface $c */ $c = $this->commandQueue->dequeue(); $this->debug("Sending " . get_class($c)); if ($c instanceof Query) { $this->debug("Sending simple query: " . $c->getQueryString()); } $this->stream->write($c->encodedMessage()); if ($c instanceof Terminate) { $this->stream->end(); } if ($c->shouldWaitForComplete()) { $this->queryState = $this::STATE_BUSY; if ($c instanceof Query) { $this->queryType = $this::QUERY_SIMPLE; } elseif ($c instanceof Sync) { $this->queryType = $this::QUERY_EXTENDED; } $this->currentCommand = $c; return; } } }
/** * Receive a value from the channel. * * Be careful when you may receive null values: you need to change the EOF param accordingly! * * @param mixed $eof The EOF value, a channel will return this value if it has been closed without an error. * @return mixed The received value. * * @throws \Throwable Fails if the channel has been closed with an error. */ public function receive($eof = null) : Awaitable { if (!$this->buffer) { while ($this->senders && !$this->senders->isEmpty()) { $subscription = $this->senders->dequeue(); if ($subscription->active) { $subscription->resolve($subscription->data); return new Success($subscription->data); } } } elseif (!$this->buffer->isEmpty()) { while ($this->senders && !$this->senders->isEmpty()) { $subscription = $this->senders->dequeue(); if ($subscription->active) { $subscription->resolve($subscription->data); $this->buffer->push($subscription->data); } } return new Success($this->buffer->dequeue()); } if ($this->closed instanceof \Throwable) { return new Failure($this->closed); } elseif ($this->closed) { return new Success($eof); } if (!$this->receivers) { $this->receivers = new \SplQueue(); } $this->receivers->enqueue($subscription = new ChannelSubscription($eof)); return $subscription; }
protected function render(Func $func) { if (null !== $func->cfg) { $this->enqueueBlock($func->cfg); } $renderedOps = new \SplObjectStorage(); $renderedBlocks = new \SplObjectStorage(); while ($this->blockQueue->count() > 0) { $block = $this->blockQueue->dequeue(); $ops = []; if ($block === $func->cfg) { foreach ($func->params as $param) { $renderedOps[$param] = $ops[] = $this->renderOp($param); } } foreach ($block->phi as $phi) { $result = $this->indent($this->renderOperand($phi->result) . " = Phi("); $result .= implode(', ', array_map([$this, 'renderOperand'], $phi->vars)); $result .= ')'; $renderedOps[$phi] = $ops[] = ["op" => $phi, "label" => $result, "childBlocks" => []]; } foreach ($block->children as $child) { $renderedOps[$child] = $ops[] = $this->renderOp($child); } $renderedBlocks[$block] = $ops; } $varIds = $this->varIds; $blockIds = $this->blocks; $this->reset(); return ["blocks" => $renderedBlocks, "ops" => $renderedOps, "varIds" => $varIds, "blockIds" => $blockIds]; }
/** * {@inheritdoc} */ protected function executePipeline(ConnectionInterface $connection, \SplQueue $commands) { while (!$commands->isEmpty()) { $connection->writeRequest($commands->dequeue()); } $connection->disconnect(); return array(); }
/** * {@inheritdoc} */ public function tick() { if (!$this->process->isRunning() && $this->outputBuffer->isEmpty()) { usleep(1000); if ($this->outputBuffer->isEmpty()) { if ($this->process->isSuccessful()) { $this->deferred->resolve(new MessageEvent($this, $this->process->getOutput())); } else { $this->deferred->reject(new MessageEvent($this, $this->process->getOutput())); } return; } } if (!$this->outputBuffer->isEmpty()) { $this->deferred->notify(new MessageEvent($this, $this->outputBuffer->dequeue()[1])); } }
/** * Cancels all pending tasks. */ private function cancelPending() { if (!$this->busyQueue->isEmpty()) { $exception = new WorkerException('Worker was shut down.'); do { $this->busyQueue->dequeue()->cancel($exception); } while (!$this->busyQueue->isEmpty()); } }
/** * * @throws Exception * @return int */ protected function _getNewStreamId() { if ($this->_lastStreamId < 32767) { return ++$this->_lastStreamId; } while ($this->_recycledStreams->isEmpty()) { $this->_getResponse(); } return $this->_recycledStreams->dequeue(); }
public function execute() { /** @var Transaction[] */ $failed = []; while (!$this->transactionsToRetry->isEmpty()) { //Some failed transactions are waiting from the previous execution to be retried $this->transactionQueue->enqueue($this->transactionsToRetry->dequeue()); } if (!$this->transactionQueue->isEmpty()) { $this->player->getServer()->getPluginManager()->callEvent($ev = new InventoryTransactionEvent($this)); } else { return; } while (!$this->transactionQueue->isEmpty()) { $transaction = $this->transactionQueue->dequeue(); if ($ev->isCancelled()) { $this->transactionCount -= 1; $transaction->sendSlotUpdate($this->player); //Send update back to client for cancelled transaction unset($this->inventories[spl_object_hash($transaction)]); continue; } elseif (!$transaction->execute($this->player)) { $transaction->addFailure(); if ($transaction->getFailures() >= self::DEFAULT_ALLOWED_RETRIES) { /* Transaction failed completely after several retries, hold onto it to send a slot update */ $this->transactionCount -= 1; $failed[] = $transaction; } else { /* Add the transaction to the back of the queue to be retried on the next tick */ $this->transactionsToRetry->enqueue($transaction); } continue; } $this->transactionCount -= 1; $transaction->setSuccess(); $transaction->sendSlotUpdate($this->player); unset($this->inventories[spl_object_hash($transaction)]); } foreach ($failed as $f) { $f->sendSlotUpdate($this->player); unset($this->inventories[spl_object_hash($f)]); } }