Get the queue information from Iron.io.

@return object
776731
protected function getQueue()
    {
        if (isset($this->meta)) return $this->meta;

        return $this->meta = $this->container['queue']->getIron()->getQueue($this->argument('queue'));
    }
1360124
public function actionIndex()
    {
        $queue = $this->buildImporterQueue();

        foreach ($queue as $pos => $object) {
            $this->verbosePrint("Run importer object '{$object->className()}' on position '{$pos}'.", __METHOD__);
            $this->verbosePrint('Module context id: ' . $object->module->id);
            $object->run();
        }

        if (Yii::$app->hasModule('admin')) {
            Config::set(Config::CONFIG_LAST_IMPORT_TIMESTAMP, time());
            Config::set(Config::CONFIG_INSTALLER_VENDOR_TIMESTAMP, Yii::$app->packageInstaller->timestamp);
            Yii::$app->db->createCommand()->update('admin_user', ['force_reload' => 1])->execute();
        }
        
        $this->output('LUYA import command (based on LUYA ' . Boot::VERSION . ')');
        
        foreach ($this->getLog() as $section => $value) {
            $this->outputInfo(PHP_EOL . $section . ":");
            $this->logValueToTable($value);
        }
        
        return $this->outputSuccess("Importer run successful.");
    }
81681
private function getRaw()
    {
        if ($this->pool === null) {
            $this->pool = new ConnectionPool($this->keyspace, $this->servers);
        }
        return $this->pool->get();
    }
877941
public function getNextBuild()
    {
        //if (count($this->_queue)<1) {
        //    $this->getNextBuildTime();
        //}
        usort($this->queue, array($this, 'sortQueue'));
        if (isset($this->queue[0])) {
            if ($this->queue[0]->getNextBuildTime() <= time()) {
                $build = array_shift($this->queue);
                $build->dequeue();

                return $build;
            }
        }

        return;
    }
650196
public function runQueue()
    {
        $count = 0;
        $statistics = array();
        $queue = $this->getServiceManager()->get(Queue::CONFIG_ID);
        $report = new Report(Report::TYPE_SUCCESS);
        $limit = $this->getLimit();
        foreach ($queue as $task) {
            $subReport = $queue->runTask($task);
            $statistics[$subReport->getType()] = isset($statistics[$subReport->getType()])
            ? $statistics[$subReport->getType()] + 1
            : 1;
            $report->add($subReport);
            $count++;
            if ($limit !== 0 && $count === $limit) {
                break;
            }
        }
        
        if (empty($statistics)) {
            $report = new Report(Report::TYPE_INFO, __('No tasks to run'));
        } else {
            if (isset($statistics[Report::TYPE_ERROR]) || isset($statistics[Report::TYPE_WARNING])) {
                $report->setType(Report::TYPE_WARNING);
            }
            $report->setMessage(__('Ran %s task(s):', array_sum($statistics)));
        }
        return $report;
    }
1041659
public function getEventQueue()
    {
        if (null === $this->eventQueue) {
            $this->eventQueue = new Event\EventQueue(
                $this->getConfigurationRegistry(),
                $this->getEventDispatcher()
            );
        }

        return $this->eventQueue;
    }
4341
public function toMessage()
    {
        $m = new Message();
        foreach ($this->queueStatus as $action) {
            $m->push($action['action']);
            $m->push($action['queue']);
            $m->push($action['busy']);
            $m->push($action['available']);
        }

        return $m;
    }
728338
public function getMessageQueue() {

        $session      = $this->getSession();
        $sessionQueue = $session->get('application.queue');

        if (isset($sessionQueue) && count($sessionQueue)) {
            $this->_messageQueue = array_merge($sessionQueue, $this->_messageQueue);
            $session->set('application.queue', null);
        }

        return $this->_messageQueue;
    }
249224
public function getMailQueue(): ?MailQueue
    {
        if (!$this->hasMailQueue()) {
            $this->setMailQueue($this->getDefaultMailQueue());
        }
        return $this->mailQueue;
    }
1146548
private function createQueueEventObject()
    {
        $obj = clone $this->queueEventDocument;
        $obj->setEvent($this->generateRoutingKey());
        $obj->setDocumenturl($this->request->get('selfLink'));
        $obj->setStatusurl($this->getStatusUrl($obj));
        $obj->setCoreUserId($this->getSecurityUsername());

        return $obj;
    }
1293611
public function getQueueLength()
	{
		$queueLength = 0;

		foreach ($this->gatewayPool as $gateway)
		{
			$queueLength += $gateway->getQueueLength();
		}

		return $queueLength;
	}
293291
function () {
                var refreshMgrInfo = this._refreshMgrInfo;
                if (!refreshMgrInfo) {
                    refreshMgrInfo = {
                        refreshArgs : null,
                        queue : []
                        // queue is used in the repeater
                    };
                    this._refreshMgrInfo = refreshMgrInfo;
                    aria.templates.RefreshManager.queue({
                        fn : this._refreshManagerCallback,
                        scope : this
                    }, this);
                }
                return refreshMgrInfo;
            }
401226
protected function loadQueue()
	{
		$loadQueue = self::$loadQueue;

		foreach ($loadQueue as $type => $queries)
		{
			foreach ($queries as $query)
			{
				$ids = [];
				foreach ($query['ids'] as $id)
				{
					if( Trunk::has([$id, $query['relations']], $type) )
					{
						$object = Trunk::get([$id, $query['relations']], $type);
						$this->addIncludes($object);
						continue;
					}

					$ids[] = $id;
				}

				if( empty($ids) )
				{
					continue;
				}

				$locale = null;

				if( ! empty($this->meta['locale']) )
				{
					$locale = $this->meta['locale'];
				}

				$result = Resolver::resolve($query['type'], $query['ids'], $query['relations'], $locale);

				Trunk::put($result);
				
				$this->addIncludes($result);
			}
		}
	}
67974
protected function next()
    {
        $promiseOrValue = array_shift($this->queue);
        $promise = resolve($promiseOrValue);
        $this->cancellationQueue->enqueue($promise);
        return $promise;
    }
470561
public function get()
	{
		$key = $this->getKey();
		$queued = $this->jar->getQueuedCookies();

		if (isset($queued[$key]))
		{
			return $queued[$key];
		}

		if ($this->strategy === 'request')
		{
			return $this->request->cookie($key);
		}
		else
		{
			return $this->jar->get($key);
		}
	}
940567
public function dequeue() {
        if (null === $this->queue) return null;
        if ($this->tail > $this->head) return null;
        $item = $this->queue[$this->tail];
        $this->tail++;
        return $item;
    }
1231707
public function require(): IQueueObject
	{
		$queueObject = $this->remoteLoader->load($this->name, $this->canCreateNew());
		
		if (!$queueObject)
		{
			throw new QueueNotExistsException($this->name);
		}
		
		return $queueObject;
	}