Get this Message Queue (or create one if this name doesn't exist).
429323
public BaseMessageQueue getMessageQueue(String strQueueName, String strQueueType)
    {
        // Look up the message Queue!
        BaseMessageQueue messageQueue = (BaseMessageQueue)super.getMessageQueue(strQueueName, strQueueType);
        if (messageQueue != null)
            return messageQueue;
        Object server = null;
        boolean bCreateIfNotFound = false;
        if (((this.getApplication().getProperty(DBParams.REMOTE_HOST) != null) && (this.getApplication().getProperty(DBParams.REMOTE_HOST).length() > 0))
            || (this.getApplication().getProperty(DBParams.REMOTE_APP_NAME) != null))
                bCreateIfNotFound = true;   // If you explicitly specify a remote server, create the server if new.
        if (((BaseApplication)this.getApplication()).getEnvironment().getDefaultApplication() != null)
            if (!MessageConstants.LOCAL_QUEUE.equalsIgnoreCase(strQueueType))
                if ((!DBConstants.TRUE.equalsIgnoreCase(this.getApplication().getProperty(DBParams.MESSAGE_SERVER)))  // Don't try to get a remote message server if I am the remote message server
                    && (!DBParams.LOCAL.equalsIgnoreCase(this.getApplication().getProperty(DBParams.MESSAGE_SERVER))))
                        server = ((BaseApplication)this.getApplication()).getEnvironment().getDefaultApplication().getRemoteTask(null, null, bCreateIfNotFound);    // (remote)
        // This assumes that I only have a server for client processes (Should be correct).
        if (server != null)
            return new org.jbundle.base.message.core.dual.DualMessageQueue(this, strQueueName, strQueueType); // Handle remote and local
        else
            return new LocalMessageQueue(this, strQueueName);
    }
529660
public static BaseMessageHeader createMessageHeader(String strMessageHeaderClassName, String strQueueName, String strQueueType, Object source, Map<String,Object> properties)
    {
        BaseMessageHeader messageHeader = (BaseMessageHeader)ClassServiceUtility.getClassService().makeObjectFromClassName(strMessageHeaderClassName);
        if (messageHeader != null)
        	messageHeader.init(strQueueName, strQueueType, source, properties);
        return messageHeader;
    }
196162
public RemoteSendQueue createRemoteSendQueue(String strQueueName, String strQueueType) throws RemoteException
    {
        MessageManager messageManager = this.getEnvironment().getMessageManager(this.getApplication(), true);
        BaseMessageSender sender = (BaseMessageSender)messageManager.getMessageQueue(strQueueName, strQueueType).getMessageSender();
        SendQueueSession remoteQueue = new SendQueueSession(this, sender);
        return remoteQueue;
    }
1365451
public function createQueue()
    {
        $attributes = [
            'VisibilityTimeout'             => $this->options['message_timeout'],
            'MessageRetentionPeriod'        => $this->options['message_expiration'],
            'ReceiveMessageWaitTimeSeconds' => $this->options['receive_wait_time']
        ];

        if ($this->isQueueFIFO()) {
            $attributes['FifoQueue'] = 'true';
            $attributes['ContentBasedDeduplication'] = $this->options['content_based_deduplication'] === true
                ? 'true'
                : 'false';
        }

        $result = $this->sqs->createQueue(['QueueName' => $this->getNameWithPrefix(), 'Attributes' => $attributes]);

        $this->queueUrl = $result->get('QueueUrl');

        $key = $this->getNameWithPrefix() . '_url';
        $this->cache->save($key, $this->queueUrl);

        $this->log(200, "Created SQS Queue", ['QueueUrl' => $this->queueUrl]);

        if ($this->options['push_notifications']) {

            $policy = $this->createSqsPolicy();

            $this->sqs->setQueueAttributes([
                'QueueUrl'      => $this->queueUrl,
                'Attributes'    => [
                    'Policy'    => $policy,
                ]
            ]);

            $this->log(200, "Created Updated SQS Policy");
        }
    }
521772
public SIMPMessage getMessageLocked() throws MessageStoreException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getMessageLocked");
    
    SIMPMessage msg = null;
    
    if(classifyingMessages)
    {
      // Take the classifications read lock
      consumerSet.takeClassificationReadLock();

      // Classifications may change dynamically, so check the pendingReset
      // flag under this lock. If classifications have changed then we'll
      // set up the filters again
      if(pendingFlowReset)
      {
        pendingFlowReset = false;
        resetFlowProperties();
      }
        
      // Determine which cursor to use. chooseGetCursorIndex() will 
      // randomly choose an index if XD has specified weightings.
      // The method can be called more than once. This supports the situation
      // where we've looked for but not found any messages of a particular 
      // classification. 
      // 
      // If chooseGetCursorIndex() returns 0, then either no classifications were 
      // specified or we've already tried all the classifications. An index
      // of 0 leads to the use of the default (unclassified) cursor.
      int classIndex = -1;
      while(classIndex != 0)
      {
        classIndex = chooseGetCursorIndex(classIndex);
     
        // Always use the cursor straight from the key
        msg = getMessageLocked(classIndex);

        if(msg != null)
          classIndex = 0;
      }

      // Free the classifications read lock
      consumerSet.freeClassificationReadLock();
    }
    else // Not classifying
    {
      // Use the zeroth index
      msg = getMessageLocked(0);
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getMessageLocked", msg);

    return msg;
  }
418599
@Bean
    public Queue dmfReceiverQueue() {
        return new Queue(amqpProperties.getReceiverQueue(), true, false, false,
                amqpDeadletterProperties.getDeadLetterExchangeArgs(amqpProperties.getDeadLetterExchange()));
    }
1157484
def get_message(self):
        
        if not self._message:
            return None
        self._populate_message_attributes(self._message)
        return self._message
1005668
function createQueue(name, options) {
  options = options || {};
  var attributes = [];
  function attr(name, value) { attributes.push({name: name, value: value}); }
  if (options.delay != null)
    attr('DelaySeconds', seconds(options.delay, 'delay', 0, 900));
  if (options.messageRetentionPeriod != null)
    attr('MessageRetentionPeriod', seconds(options.messageRetention, 'messageRetention', 60, 1209600));
  if (options.pollDuration != null)
    attr('ReceiveMessageWaitTimeSeconds', seconds(options.pollDuration, 'pollDuration', 0, 20));
  else
    attr('ReceiveMessageWaitTimeSeconds', 20);
  if (options.visibilityTimeout != null)
    attr('VisibilityTimeout', seconds(options.visibilityTimeout, 'visibilityTimeout', 0, 43200));
  if (options.maxMessageSize != null)
    attr('MaximumMessageSize', bytes(options.maxMessageSize, 'MaximumMessageSize', 1024, 65536));

  var query = {};
  query.QueueName = name;
  for (var i = 0; i < attributes.length; i++) {
    query['Attribute.' + (i+1) + '.Name'] = attributes[i].name;
    query['Attribute.' + (i+1) + '.Value'] = attributes[i].value;
  }
  var queueURL = call(this, 'CreateQueue', query)
    .then(function (res) {
      return res.CreateQueueResult.QueueUrl;
    });
  queueURL.toString = function () { return name; };
  return Queue(queueURL, this._keys.accessKey, this._keys.secretKey, this._keys.region);
}
347117
public function getMessageQueue()
	{
		// For empty queue, if messages exists in the session, enqueue them.
		if (!count($this->_messageQueue))
		{
			$session = JFactory::getSession();
			$sessionQueue = $session->get('application.queue');

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

		return $this->_messageQueue;
	}
395749
def get_rr_queue(self):
        """"""
        return Queue(self.inbox_rr.name + '.rr', self.inbox_rr,
                     auto_delete=True)
20076
private AbstractMessage fetchNext() throws JMSException
	{
		if (nextMessage != null)
			return nextMessage; // Already fetched
		nextMessage = localQueue.browse(cursor, parsedSelector); // Lookup next candidate
		if (nextMessage == null)
			close(); // Auto-close enumeration at end of queue
		return nextMessage;
	}
356046
@Override
    public Message createMessage(Session session) throws JMSException {
        Message message = session.createTextMessage(requestMessage);
        if (correlationId != null)
            message.setJMSCorrelationID(correlationId);
        if (replyQueue != null) {
            message.setJMSReplyTo(replyQueue);
        }
        if (delaySeconds >0) {
            ApplicationContext.getJmsProvider().setMessageDelay(null, message, delaySeconds);
        }
        return message;
    }
752649
def queue(self):
        """"""
        entry = self._proto.commandQueueEntry
        if entry.HasField('queueName'):
            return entry.queueName
        return None
771382
def queue(self, queue, message, params={}, uids=[]):
        

        d = {
            'id': uuid.uuid1().get_hex(),
            'version': 1,
            'message': message,
            'params': params
        }

        ser = json.dumps(d)
        
        if uids:
            for uid in uids:
                path = '/dq/%s/%s' % (uid, queue)
                yield self._put_queue(path, ser)

        else:
            path = '/q/%s' % queue
            yield self._put_queue(path, ser)

        defer.returnValue(d['id'])
448870
def gotMessage(self, message_id, message):
        
        d = defer.maybeDeferred(self._handle_message, message)
        d.addCallback(self.generate_response)
        d.addCallback(lambda resp: self.reply(message_id, resp))
        return d
1270430
private Queue<MethodWrapper> formConversationQueue(Queue<MethodWrapper> queue, String methodName) {
        MethodWrapper methodWrapper = methodNameMap.get(methodName);
        queue.add(methodWrapper);
        if (StringUtils.isEmpty(methodName)) {
            return queue;
        } else {
            return formConversationQueue(queue, methodWrapper.getNext());
        }
    }
585098
def get(*args)
      if args.size == 1 && args[0].is_a?(Hash)
        queue_name = (args[0][:name] || args[0]['name']).to_s
        queue_name.empty? ? super : queues_get(queue_name)
      else
        super
      end
    end