Updates the list of currently known queues and subqueues
510699
def refresh_queues(self, fatal=False):
        

        try:
            queues = []
            prefixes = [q for q in self.config["queues"] if q.endswith("/")]
            known_subqueues = Queue.all_known(prefixes=prefixes)

            for q in self.config["queues"]:
                queues.append(Queue(q))
                if q.endswith("/"):
                    for subqueue in known_subqueues:
                        if subqueue.startswith(q):
                            queues.append(Queue(subqueue))

            self.queues = queues

        except Exception as e:  # pylint: disable=broad-except
            self.log.error("When refreshing subqueues: %s", e)
            if fatal:
                raise
127543
Collection<AsteriskQueue> getQueues()
    {
        refreshQueuesIfForced();

        Collection<AsteriskQueue> copy;

        synchronized (queuesLRU)
        {
            copy = new ArrayList<AsteriskQueue>(queuesLRU.values());
        }
        return copy;
    }
382661
def updateQueue(self):
        """"""
        for future in self.socket.recvFuture():
            if future._ended():
                # If the answer is coming back, update its entry
                try:
                    thisFuture = scoop._control.futureDict[future.id]
                except KeyError:
                    # Already received?
                    scoop.logger.warn('{0}: Received an unexpected future: '
                                      '{1}'.format(scoop.worker, future.id))
                    continue
                thisFuture.resultValue = future.resultValue
                thisFuture.exceptionValue = future.exceptionValue
                thisFuture.executor = future.executor
                thisFuture.isDone = future.isDone
                # Execute standard callbacks here (on parent)
                thisFuture._execute_callbacks(CallbackType.standard)
                self.append(thisFuture)
                future._delete()
            elif future.id not in scoop._control.futureDict:
                scoop._control.futureDict[future.id] = future
                self.append(scoop._control.futureDict[future.id])
            else:
                self.append(scoop._control.futureDict[future.id])
448888
def dispatch_queue(self):
        
        self.queue_lock.acquire()
        q = list(self.queue)
        self.queue = []
        self.queue_lock.release()
        log.debug("Dispatching requests: {}".format(q))
        for req in q:
            req.response = self.dispatch_request(req)
        for req in q:
            req.signal()
201405
public void flushUpdate()
    {
        for (int i = 0; i < numberOfQueues; i++)
        {
            if (!dbUpdateLists[i].isEmpty())
            {
                this.submitTaskToQueue(this.createUpdateTask(dbUpdateLists[i], fileUpdateLists[i]), i, processedUpdates);
                this.dbUpdateLists[i] = new ArrayList(batchSize);
                this.fileUpdateLists[i] = new ArrayList(batchSize);
                this.updatesQueued++;
            }
        }
    }
1004361
@Override
    public void updateRemoteQueuePointSet(Set newQueuePointLocalisingMEUuids)
                    throws SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(
                        tc,
                        "updateRemoteQueuePointSet",
                        new Object[] {
                                      newQueuePointLocalisingMEUuids,
                                      this });

        _localisationManager.updateRemoteQueuePointSet(newQueuePointLocalisingMEUuids,
                                                       _postMediatedItemStreamsRequiringCleanup);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "updateRemoteQueuePointSet");

    }
1151707
def do_update(pool,request,models):
  ""
  return {k:fkapply(models,pool,process_update,missing_update,k,v) for k,v in request.items()}
996013
private function addNextRequests()
    {
        $limit = max($this->getPoolSize() - count($this->waitQueue), 0);
        while ($limit--) {
            if (!$this->addNextRequest()) {
                break;
            }
        }
    }
481560
def update(self):
        
        con = self.subpars.pars.control
        self(con.eqi2*con.tind)
592254
def flush_queue(self):
        """"""
        records = []

        while not self.queue.empty() and len(records) < self.batch_size:
            records.append(self.queue.get())

        if records:
            self.send_records(records)
            self.last_flush = time.time()
1146073
def get_all_queues(self, prefix=''):
        
        params = {}
        if prefix:
            params['QueueNamePrefix'] = prefix
        return self.get_list('ListQueues', params, [('QueueUrl', Queue)])
243227
def all_existing_queues
      known_queues    = Backburner::Worker.known_queue_classes.map(&:queue)
      existing_tubes  = self.connection.tubes.all.map(&:name).select { |tube| tube =~ /^#{queue_config.tube_namespace}/ }
      existing_tubes + known_queues + [queue_config.primary_queue]
    end
459927
def update(self):
        
        con = self.subpars.pars.control
        self(con.eqd1*con.tind)
958512
def prepare_queues(queues, lock):
    """"""
    for queue in queues:
        queue._pebble_lock = lock
        with queue.mutex:
            queue._pebble_old_method = queue._put
            queue._put = MethodType(new_method, queue)
961906
def queues(self):
        
        if self._queues is None:
            self._queues = QueueList(self._version, account_sid=self._solution['sid'], )
        return self._queues
947187
protected void updateCounts(LoadStatisticsSnapshot current) {
        definedExecutors.update(current.getDefinedExecutors());
        onlineExecutors.update(current.getOnlineExecutors());
        connectingExecutors.update(current.getConnectingExecutors());
        busyExecutors.update(current.getBusyExecutors());
        idleExecutors.update(current.getIdleExecutors());
        availableExecutors.update(current.getAvailableExecutors());
        queueLength.update(current.getQueueLength());
    }
983004
def list_queues(backend='sqlite'):
    '''
    
    '''
    queue_funcs = salt.loader.queues(__opts__)
    cmd = '{0}.list_queues'.format(backend)
    if cmd not in queue_funcs:
        raise SaltInvocationError('Function "{0}" is not available'.format(cmd))
    ret = queue_funcs[cmd]()
    return ret