ProcessMessageTimeout Method.
511620
public void processMessageTimeout(String strTrxID)
    {
        MessageLog recMessageLog = (MessageLog)this.getMainRecord();
        BaseMessage message = (BaseMessage)recMessageLog.createMessage(strTrxID);
        String strMessageError = "Message timeout";
        BaseMessage messageReply = (BaseMessage)BaseMessageProcessor.processErrorMessage(this, message, strMessageError);
        if (messageReply != null)    // No reply if null.
        {
            BaseMessageTransport transport = this.getMessageTransport(message);
            transport.setupReplyMessage(messageReply, message, MessageInfoType.REPLY, MessageType.MESSAGE_IN);
            transport.processIncomingMessage(messageReply, message);
        }
    }
823524
function handleIncomingMessage(data) {
		var message;
		reader.parse(data, initPending);
		initPending = false;
		while (!reader.isEmpty()) {
			message = reader.pop();
			// console.log("IN MESSAGE: " + inspect(message));
			// Check if there are listeners attached to the event
			// otherwise falls back to the default handler
			if (that.listeners(message.verb).length) {
				handlers[message.verb](message);
			} else {
				defHandlers[message.verb].call(that, message);
			}
		}
	}
1269708
def on_message_received(self, msg):
        
        if self.is_stopped:
            raise RuntimeError("reader has already been stopped")
        else:
            self.buffer.put(msg)
351063
private void processMessageReceipt(String msgId, String conversationId, int convType, long timestamp) {
    Object messageCache =
            MessageReceiptCache.get(session.getSelfPeerId(), msgId);
    if (messageCache == null) {
      return;
    }
    Message m = (Message) messageCache;
    AVIMMessage msg =
            new AVIMMessage(conversationId, session.getSelfPeerId(), m.timestamp, timestamp);
    msg.setMessageId(m.id);
    msg.setContent(m.msg);
    msg.setMessageStatus(AVIMMessage.AVIMMessageStatus.AVIMMessageStatusReceipt);
    AVConversationHolder conversation = session.getConversationHolder(conversationId, convType);
    conversation.onMessageReceipt(msg);
  }
241941
private void fireMessageExceptionedEvent(String apiMsgId,
                                             SIMPMessage message,
                                             int exceptionReason)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc,
                        "fireMessageExceptionedEvent",
                        new Object[] { apiMsgId,
                                      message,
                                      Integer.valueOf(exceptionReason) });

        JsMessagingEngine me = _messageProcessor.getMessagingEngine();
        RuntimeEventListener listener = _messageProcessor.getRuntimeEventListener();

        String systemMessageId = message.getMessage().getSystemMessageId();

        // Check that we have a RuntimeEventListener
        if (listener != null)
        {
            // Build the message for the Notification

            String nlsMessage =
                            nls_mt.getFormattedMessage(
                                                       "MESSAGE_EXCEPTION_DESTINATIONED_CWSJU0012",
                                                       new Object[] {
                                                                     apiMsgId,
                                                                     systemMessageId,
                                                                     _exceptionDestinationName,
                                                                     Integer.valueOf(exceptionReason),
                                                                     message.getMessage().getExceptionMessage() },
                                                       null);

            // Build the properties for the Notification
            Properties props = new Properties();

            // Set values for the intended destination
            String intendedDestinationName = "";
            String intendedDestinationUuid = SIBUuid12.toZeroString();

            if (_originalDestination != null)
            {
                intendedDestinationName = _originalDestination.getName();
                intendedDestinationUuid = _originalDestination.getUuid().toString();
            }
            props.put(SibNotificationConstants.KEY_INTENDED_DESTINATION_NAME,
                      intendedDestinationName);
            props.put(SibNotificationConstants.KEY_INTENDED_DESTINATION_UUID,
                      intendedDestinationUuid);

            // Set values for the exception destination
            props.put(SibNotificationConstants.KEY_EXCEPTION_DESTINATION_NAME,
                      _exceptionDestination.getName());
            props.put(SibNotificationConstants.KEY_EXCEPTION_DESTINATION_UUID,
                      _exceptionDestination.getUuid().toString());

            props.put(SibNotificationConstants.KEY_SYSTEM_MESSAGE_IDENTIFIER,
                      (systemMessageId == null) ? "" : systemMessageId);

            props.put(SibNotificationConstants.KEY_MESSAGE_EXCEPTION_REASON,
                      String.valueOf(exceptionReason));

            // Fire the event
            listener.runtimeEventOccurred(me,
                                          SibNotificationConstants.TYPE_SIB_MESSAGE_EXCEPTIONED,
                                          nlsMessage,
                                          props);
        }
        else
        {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                SibTr.debug(tc, "Null RuntimeEventListener, cannot fire event");
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "fireMessageExceptionedEvent");
    }
256961
private void processBody() {
    // There is no reliable way to get the uncompressed size per message when it's compressed,
    // because the uncompressed bytes are provided through an InputStream whose total size is
    // unknown until all bytes are read, and we don't know when it happens.
    statsTraceCtx.inboundMessageRead(currentMessageSeqNo, inboundBodyWireSize, -1);
    inboundBodyWireSize = 0;
    InputStream stream = compressedFlag ? getCompressedBody() : getUncompressedBody();
    nextFrame = null;
    listener.messagesAvailable(new SingleMessageProducer(stream));

    // Done with this frame, begin processing the next header.
    state = State.HEADER;
    requiredLength = HEADER_LENGTH;
  }
743740
public static void processMessageToMatchSession(HttpMessage message, HttpSession session) {
		processMessageToMatchSession(message, message.getRequestHeader().getHttpCookies(), session);
	}
911979
public BaseMessage processMessage(BaseMessage message)
    {
        RunRemoteProcessMessageData runRemoteProcessMessageData = (RunRemoteProcessMessageData)message.getMessageDataDesc(null);
        if (runRemoteProcessMessageData == null)
            message.addMessageDataDesc(runRemoteProcessMessageData = new RunRemoteProcessMessageData(null, null));
        CreateSiteMessageData siteMessageData = (CreateSiteMessageData)runRemoteProcessMessageData.getMessageDataDesc(CreateSiteMessageData.CREATE_SITE);
        if (siteMessageData == null)
            runRemoteProcessMessageData.addMessageDataDesc(siteMessageData = new CreateSiteMessageData(runRemoteProcessMessageData, null));
        StandardMessageResponseData reply = this.setupUserInfo(siteMessageData);
        if (reply == null)
            return null;
        return reply.getMessage();
    }
908153
private void handleIncomingMessage(SerialMessage incomingMessage) {
		
		logger.debug("Incoming message to process");
		logger.debug(incomingMessage.toString());
		
		switch (incomingMessage.getMessageType()) {
			case Request:
				handleIncomingRequestMessage(incomingMessage);
				break;
			case Response:
				handleIncomingResponseMessage(incomingMessage);
				break;
			default:
				logger.warn("Unsupported incomingMessageType: 0x%02X", incomingMessage.getMessageType());
		}
	}
829108
def ProcessMessage(self, message):
    """"""
    # Only accept authenticated messages
    if (message.auth_state !=
        rdf_flows.GrrMessage.AuthorizationState.AUTHENTICATED):
      return

    now = time.time()

    # Maintain a cache of the foreman
    with self.lock:
      if (self.foreman_cache is None or
          now > self.foreman_cache.age + self.cache_refresh_time):
        self.foreman_cache = aff4.FACTORY.Open(
            "aff4:/foreman", mode="rw", token=self.token)
        self.foreman_cache.age = now

    if message.source:
      self.foreman_cache.AssignTasksToClient(message.source.Basename())
334082
public void processEvent(EventObject event) // for asynchronous
  // (nonblocking) response
  // handling
  {
    synchronized (this) {
    } // wail til message sending has finished (transaction attribute set)

    if (event instanceof ResponseEvent) {
      processResponse((ResponseEvent) event);
    } else if (event instanceof TimeoutEvent) {
      processTimeout((TimeoutEvent) event);
    }

    // note, requests don't come through here, they are handled via the
    // listen/waitFor methods.
  }
501484
public void processMessage (Message msg)
    {
        if (_client.getRunQueue().isRunning()) {
            // append it to our queue
            _actions.append(msg);
            // and queue ourselves up to be run
            _client.getRunQueue().postRunnable(this);
        } else {
            log.info("Dropping message as RunQueue is shutdown", "msg", msg);
        }
    }
1035380
public void processTimeout(TimeoutEvent arg0) {
    synchronized (listeners) {
      Iterator<SipListener> iter = listeners.iterator();
      while (iter.hasNext() == true) {
        SipListener listener = (SipListener) iter.next();
        listener.processTimeout(arg0);
      }
    }
  }
500245
private void receiveMessage() {
		MessagingSystemInfo messagingSystemInfo = oneAgentSdk.createMessagingSystemInfo("DynatraceSample", "theQueue", MessageDestinationType.QUEUE, ChannelType.IN_PROCESS, null);
		IncomingMessageReceiveTracer incomingMessageReceiveTracer = oneAgentSdk.traceIncomingMessageReceive(messagingSystemInfo);
		incomingMessageReceiveTracer.start();
		try {
			Message msg = queueManager.receive("theQeue");
			if (msg == null) {
				return; // no message received
			}
			IncomingMessageProcessTracer incomingMessageProcessTracer = oneAgentSdk.traceIncomingMessageProcess(messagingSystemInfo);
			// store incoming tag to tracer:
			incomingMessageProcessTracer.setDynatraceStringTag(msg.getProperty(OneAgentSDK.DYNATRACE_MESSAGE_PROPERTYNAME));
			incomingMessageProcessTracer.setVendorMessageId(msg.getVendorMessageId());
						incomingMessageProcessTracer.start();
			try {
				// do something with the message ...
				System.out.println("Message received: " + msg.toString());
			} catch (Exception e) {
				incomingMessageProcessTracer.error(e);
			} finally {
				incomingMessageProcessTracer.end();
			}
			
			
		} catch (Exception e) {
			incomingMessageReceiveTracer.error(e);
		} finally {
			incomingMessageReceiveTracer.end();
		}
	}
1220592
@Override
    public void processMessage(AbsSender absSender, Message message, String[] arguments) {
        execute(absSender, message.getFrom(), message.getChat(), message.getMessageId(), arguments);
    }
1313228
public void handleIncomingMessage(byte[] data, int offset, int len) {
		synchronized(messageQueue) {
			messageQueue.add(new IncomingMessage(data, offset, len));
		}
		synchronized(lock) {
			lock.notifyAll();
		}
	}
327413
public void processTimeout(TimeoutEvent timeoutEvent) {
        Transaction transaction = null;
        if(timeoutEvent.isServerTransaction()) {
            transaction = timeoutEvent.getServerTransaction();
            if(logger.isDebugEnabled()) {
                logger.debug("timeout => " + transaction.getRequest().toString());
            }
        } else {
            transaction = timeoutEvent.getClientTransaction();
            if(logger.isDebugEnabled()) {
                logger.debug("timeout => " + transaction.getRequest().toString());
            }
        }
        String callId = ((CallIdHeader)transaction.getRequest().getHeader(CallIdHeader.NAME)).getCallId();
        register.unStickSessionFromNode(callId);
    }