Creates a client for working with Queues.
421816
def connect_to_queues(region=None, public=True):
    """"""
    return _create_client(ep_name="queues", region=region, public=public)
472338
protected void initQueue(T queue, QueueSpec spec) throws Exception {
        queue.setObserver(defaultObserver);
        queue.init();
    }
704104
public RabbitmqClient createRabbitmqClient() throws RabbitmqCommunicateException
    {
        List<RabbitmqClusterContext> contextList = this.reader.readConfiguration();
        return createRabbitmqClient(contextList);
    }
59692
protected void setupQueue() throws IOException {
		if (queueName != null) {
			channel.queueDeclare(queueName, false, false, false, null);
		}
	}
502163
def create(self):
        
        self.queue = self.scheduler.queue.addSubQueue(self.priority, LockEvent.createMatcher(self.context, self.key),
                                         maxdefault = self.size, defaultQueueClass = CBQueue.AutoClassQueue.initHelper('locker', subqueuelimit = 1))
611515
def create(self, **kwargs):
        """"""
        resp = self.client.create(url=self.base_url,
                                  json=kwargs)
        return resp
93705
def setup_queue(name, ids = nil)
      queue = {:name => name, :options => {:durable => true, :no_declare => @options[:secure]}}
      filter = [:from, :tags, :tries, :persistent]
      options = {:ack => true, Push => filter, Request => filter, Result => [:from], :brokers => ids}
      @client.subscribe(queue, nil, options) { |_, packet, header| handle_packet(name, packet, header) }
    end
611868
def _populate(self, client):
        
        self.client = client
        for fn in self._buffered_calls:
            self._log.debug("Executing buffered call {}".format(fn))
            fn()
222
public Client build() {
    validate();
    Client client = new Client(database, credentials, host, scheme);
    return client;
  }
833284
def create_queue(self, *args, **kwargs):
        """"""
        q = queue.Queue(*args, **kwargs)
        q.Empty = queue.Empty
        return q
964678
@Override
    public Queue createQueue(String queueName) throws JMSException {
        checkClosed();
        return new SQSQueueDestination(queueName, amazonSQSClient.getQueueUrl(queueName).getQueueUrl());
    }
1268683
function assetQueue(addr, queue, options) {
  return createChannel(addr).then(data => {
    let ch = data[1];

    return ch.assertQueue(queue, options).then(q => [ch, q]);
  });
}
222164
def _ensure_queue(self):
        """"""
        if self._queue_path not in self._client.kv:
            self._client.kv[self._queue_path] = None
772017
public static Client using(final Configuration configuration, final ClientConsumerType type, final int poolSize) throws Exception {
    return new Client(configuration, type, poolSize);
  }
575994
def queue(self):
        """"""
        with self.connection_pool.acquire(block=True) as conn:
            return Q(
                self.routing_key,
                exchange=self.exchange,
                routing_key=self.routing_key
            )(conn)
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)
1274996
def make_client(api_version, session=None,
                endpoint=None, service_type='monitoring'):
    """"""

    client_cls = utils.get_client_class('monitoring', api_version, VERSION_MAP)
    c = client_cls(
        session=session,
        service_type=service_type,
        endpoint=endpoint,
        app_name='monascaclient',
        app_version=version.version_string,
    )

    return c