This is a put message that has oringinated from another ME

@param msgItem  The message to be put.
499635
protected void remoteToLocalPut(MessageItem msgItem) throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "remoteToLocalPut",
        new Object[] { msgItem });

    _targetStreamManager.handleMessage(msgItem);

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

  }
720526
@Override
    public void put(Set<Task> tasks) {
        String msgBody = null;
        SendMessageBatchRequestEntry msgEntry = null;
        Set<SendMessageBatchRequestEntry> msgEntries = new HashSet<>();
        for (Task task : tasks) {
            msgBody = unmarshallTask(task);
            msgEntry = new SendMessageBatchRequestEntry()
                .withMessageBody(msgBody)
                .withId(msgEntries.size() + "");  // must set unique ID for each msg in the batch request
            msgEntries.add(msgEntry);

            // Can only send batch of max 10 messages in a SQS queue request
            if (msgEntries.size() == 10) {
                this.sendBatchMessages(msgEntries);
                msgEntries.clear();  // clear the already sent messages
            }
        }

        // After for loop check to see if there are msgs in msgEntries that
        // haven't been sent yet because the size never reached 10.
        if (!msgEntries.isEmpty()) {
            this.sendBatchMessages(msgEntries);
        }
    }
779980
public void sendTextMessage(String message) {
		MessageEnvelope envelope = new MessageEnvelope();
		ReceivedMessage body = new ReceivedMessage();

		body.setText(message);
		envelope.setMessage(body);
		envelope.setSender(new User(facebookMockId));

		System.out.println("Sending message: [" + message + "] as user : ["
				+ facebookMockId + "].");
		forward(envelope);
		System.out.println("Sent!");
	}
194334
protected function sendMessage(Message $message) {
		if(!$this->isIgnored($message)) {
			parent::sendMessage($message);
			$this->sentMessages[] = $message;
		}
	}
1234338
public void sendMessage(Message message)
    {
        if (message == null)
            return;     // Don't allow a null message to be sent.
        m_stack.add(message);
        if (m_bWaiting)
        {
            synchronized (m_thread)
            {
                if (m_bWaiting) // Inside the sync block
                    m_thread.notify();
            }
        }
    }
48160
private synchronized void add(long pTime,String message) {
        debugEntries.addFirst(new Entry(pTime,message));
        trim();
    }
594201
public void sendMessage(String message) {
        EventBuilder eventBuilder = new EventBuilder().withMessage(message)
            .withLevel(Event.Level.INFO);
        sendEvent(eventBuilder);
    }
279971
@Override
	public void processMessage( Message message ) {

		if( message instanceof MsgNotifMachineDown )
			processMsgNotifMachineDown((MsgNotifMachineDown) message );

		else if( message instanceof MsgNotifInstanceChanged )
			processMsgNotifInstanceChanged((MsgNotifInstanceChanged) message );

		else if( message instanceof MsgNotifInstanceRemoved )
			processMsgNotifInstanceRemoved((MsgNotifInstanceRemoved) message );

		else if( message instanceof MsgNotifHeartbeat )
			processMsgNotifHeartbeat((MsgNotifHeartbeat) message );

		else if(message instanceof MsgNotifAutonomic)
			processMsgMonitoringEvent((MsgNotifAutonomic) message );

		else if( message instanceof MsgEcho )
			this.manager.debugMngr().notifyMsgEchoReceived((MsgEcho) message );

		else if( message instanceof MsgNotifLogs )
			processMsgNotifLogs((MsgNotifLogs) message );

		else
			this.logger.warning( "The DM got an undetermined message to process: " + message.getClass().getName());
	}
279915
public void put(DelayableImmutableMessage delayableImmutableMessage) {
        if (messagePersister.persist(messageQueueId, delayableImmutableMessage)) {
            logger.trace("Message {} was persisted for messageQueueId {}",
                         delayableImmutableMessage.getMessage(),
                         messageQueueId);
        } else {
            logger.trace("Message {} was not persisted for messageQueueId {}",
                         delayableImmutableMessage.getMessage(),
                         messageQueueId);
        }
        delayableImmutableMessages.put(delayableImmutableMessage);
    }
222972
protected function appendMessage(string $message): void
    {
        $this->messages[] = $message;

        if (sizeof($this->messages) > $this->config['max_messages']) {
            array_shift($this->messages);
        }
    }
852144
public void error(final String message) {
        messages.add(new LogMessage(message, LogMessage.Type.ERROR));
        log.error(message);
    }
1043015
public void setPayloadProperties(BaseMessage message, Object msg)
   {
       MessageDataDesc messageDataDesc = message.getMessageDataDesc(null);   // Top level only
       if (messageDataDesc != null)
       {
           Map<String,Class<?>> mapPropertyNames = messageDataDesc.getPayloadPropertyNames(null);
           if (mapPropertyNames != null)
           {
               for (String strKey : mapPropertyNames.keySet())
               {
                   Class<?> classKey = mapPropertyNames.get(strKey);
                   this.setPayloadProperty(message, msg, strKey, classKey);
               }
           }
       }
       if (message.get("Version") == null)
           this.setPayloadProperty(DEFAULT_VERSION, msg, "Version", Float.class);
       this.setPayloadProperty(this.getTimeStamp(), msg, "TimeStamp", org.joda.time.DateTime.class); // Current timestamp
   }
478368
@Override
    public void notifyMessageReceived(SQSMessage message) throws JMSException {
        SQSMessageIdentifier messageIdentifier = SQSMessageIdentifier.fromSQSMessage(message);
        if (!unAckMessages.contains(messageIdentifier)) {
            unAckMessages.add(messageIdentifier);
        }
    }
1158353
public boolean put(SIMPMessage msg, boolean isOnItemStream)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "put", new Object[] { msg, Boolean.valueOf(isOnItemStream)});

    boolean returnValue = false;
    // chose small value for ArrayList initial size since typically not many new messages will be produced
    // during the short time this method is being executed
    ArrayList<AORequestedTick> satisfiedTicks = new ArrayList<AORequestedTick>(5);

    // We need to lock down the whole AOStream so that another thread can't jump in between
    // us satisfying the request and actually creating an AOValue and updating the AOStream.
    // Otherwise, the other thread may modify the latestTick value, based on their request,
    // and we'll put a 'future' tick as our 'previous' tick and end up with an inconsistent
    // stream.
    synchronized(parent) // AOStream
    {
      try
      {
        this.lock();
        try
        {
          if (closed)
          {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "put", Boolean.FALSE);
            return false;
          }
          if (!isOnItemStream)
          {
            // this should not really occur. we ought to log this error
            SIErrorException e =
              new SIErrorException(
                nls.getFormattedMessage(
                  "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                  new Object[] {
                    "com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint",
                    "1:713:1.43.2.26" },
                  null));
            FFDCFilter.processException(
              e,
              "com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint.put",
              "1:718:1.43.2.26",
              this);
            SibTr.exception(tc, e);
            SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
              new Object[] {
                "com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint",
                "1:724:1.43.2.26" });
  
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "put", Boolean.valueOf(false));
  
            return false; // we only accept recoverable messages
          }
          if (!isready)
          {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "put", Boolean.valueOf(false));
  
            return false; // no one is interested in a message
          }
  
          // set isready to false since ConsumerKey is no longer ready
          isready = false;
  
          // possibly someone interested in the message
          AORequestedTick rt = (AORequestedTick) listOfRequests.getFirst();
          if (rt == null)
          {
            // no request is waiting, so do nothing
          }
          else
          { // there is atleast one waiting request (which is !expired and !satisfied)
            boolean locked = false;
            try
            {
              locked = msg.lockItemIfAvailable(cks[0].getGetCursor(msg).getLockID());
            }
            catch(MessageStoreException e)
            {
              // FFDC
              FFDCFilter.processException(
                  e,
                  "com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint.put",
                  "1:761:1.43.2.26",
                  this);  
                          
              SibTr.exception(tc, e); 
              
              // TODO : We need a much wider handling of exception here and around this area. If anything
              // goes wrong we probably need to close off the consumerSession otherwise msgs could get "stuck"
              
            }
            // lock this particular message
            if (!locked)
              msg = null;
  
            if (msg != null)
            {
              AORequestedTick satTick = satisfyRequest(rt, msg);
              if (satTick != null)
                satisfiedTicks.add(satTick);
  
              rt = null;
              msg = null;
              returnValue = true; // the message was accepted
            }
            // At this point there are 2 possibilities: (1) msg == null && rt == null, or
            // (2) msg == null && rt != null. Case #2 occurs if the msg was not successfully locked.
  
            // while the ConsumerKey was not ready, many messages may have been made available but they were missed
            // so loop till either there are no more waiting requests, or there are no more available messages
            satisfiedTicks.addAll(processQueuedMsgs(rt));
  
          } // end else
        } // end this.lock()
        finally
        {
          this.unlock();
        }
      }
      catch(SINotPossibleInCurrentConfigurationException e)
      {
        // No FFDC code needed
        notifyException(e);
      }
      
      // inform parent about satisfied ticks - outside lock
      int length = satisfiedTicks.size();
      for (int i = 0; i < length; i++)
      {
        AORequestedTick aotick = (AORequestedTick) satisfiedTicks.get(i);
        parent.satisfiedRequest(aotick.tick, aotick.getMessage());
      }
    } // synchronized(parent)
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "put", Boolean.valueOf(returnValue));

    return returnValue;
  }
261048
public void addMessage(String message) {
    ActionMessages messages = (ActionMessages) next.get(Flash.MESSAGES);
    if (null == messages) {
      messages = new ActionMessages();
      put(Flash.MESSAGES, messages);
    }
    messages.getMessages().add(message);
  }
687871
public void sendMessage(Message message)
    {
        ((DualMessageQueue)this.getMessageQueue()).getMessageStack().sendMessage(message);
        
        ((BaseMessage)message).setProcessedByClient(true);     // Make sure any server doesn't send this back up.

        super.sendMessage(message);
    }
453942
public function addMessage($message)
    {
        collect((array) $message)->each(function ($item) {
            collect($item)->flatten()->each(function ($flattened) {
                $this->messageList->push($flattened);
            });
        });
    }