Create a chanel named queue_name. Must be connected before calling this method.
        :param queue_name: str: name of the queue to create
        :return: pika.channel.Channel: channel we can send/receive messages to/from
767354
def create_channel(self, queue_name):
        
        channel = self.connection.channel()
        channel.queue_declare(queue=queue_name, durable=True)
        return channel
265556
def pop(self, queue_name):
        
        queue = self._get_queue(queue_name)
        message = queue.read()

        if message:
            data = message.get_body()
            return data
637415
def open_channel(self):
        
        _logger.info('Creating a new channel')
        self._connection.channel(on_open_callback=self.on_channel_open)
16022
def create(request):
    
    name = request.POST.get("name")
    if name:
        room, created = ChatRoom.objects.get_or_create(name=name)
        return redirect(room)
    return redirect(rooms)
54377
def _queue_job(redis, queue_name, delegate, *args):
        
        log.info('Queuing job...')
        with Connection(redis):
            q = Queue(queue_name)
            job = q.enqueue(delegate, *args)
            return job.id
712665
@Override
    public java.util.concurrent.Future<CreateQueueResult> createQueueAsync(String queueName) {

        return createQueueAsync(new CreateQueueRequest().withQueueName(queueName));
    }
341324
def flush(self, queue_name):
        
        for name in (queue_name, dq_name(queue_name), xq_name(queue_name)):
            self.channel.queue_purge(name)
1258083
async def create_category(self, name, *, overwrites=None, reason=None):
        
        data = await self._create_channel(name, overwrites, ChannelType.category, reason=reason)
        channel = CategoryChannel(state=self._state, guild=self, data=data)

        # temporarily add to the cache
        self._channels[channel.id] = channel
        return channel
985304
def create_queue_service(self):
        '''
        
        '''
        try:
            from azure.storage.queue.queueservice import QueueService
            return QueueService(self.account_name, self.account_key,
                                sas_token=self.sas_token,
                                is_emulated=self.is_emulated)
        except ImportError:
            raise Exception('The package azure-storage-queue is required. '
                            + 'Please install it using "pip install azure-storage-queue"')
59692
protected void setupQueue() throws IOException {
		if (queueName != null) {
			channel.queueDeclare(queueName, false, false, false, null);
		}
	}
389260
def create_queue(self):
        """"""
        q = asyncio.Queue()
        q.Empty = asyncio.QueueEmpty
        return q
962532
def queue_exists(self, name):
        
        try:
            queue = self._manager.head(name)
            return True
        except exc.NotFound:
            return False
472656
public AmqpTemplate getAmqpTemplate(String queueName) throws RabbitmqCommunicateException
    {
        if (queueName == null)
        {
            String message = "QueueName is not defined.";
            throw new RabbitmqCommunicateException(message);
        }

        AmqpTemplate template = this.amqpTemplateMap.get(queueName);

        if (template == null)
        {
            template = createAmqpTemplate(queueName);
            this.amqpTemplateMap.put(queueName, template);
        }
        return template;
    }
603905
function(queueName, target, method) {
    var queues = this._queues, queue;
    if (!queues) { queues = this._queues = {}; }
    queue = queues[queueName];
    if (!queue) { queue = queues[queueName] = []; }

    var args = arguments.length > 3 ? slice.call(arguments, 3) : null;
    queue.push({ target: target, method: method, args: args });
    return this;
  }
47994
def new_consumer(self, config, consumer_name):
        
        return Consumer(0,
                        dict(),
                        config.get('qty', self.DEFAULT_CONSUMER_QTY),
                        config.get('queue', consumer_name))
210039
def pool_create(self, name, description, category):
        
        params = {
            'pool[name]': name,
            'pool[description]': description,
            'pool[category]': category
            }
        return self._get('pools.json', params, method='POST', auth=True)
921296
public <T> QueuePublisher<T> createQueuePublisher(final String name, final PublisherCallback<T> messageCallback)
    {
        Preconditions.checkState(connectionFactory != null, "connection factory was never injected!");
        return new QueuePublisher<T>(connectionFactory, amqpConfig, name, messageCallback);
    }