@Override public synchronized ClientConsumerImpl setMessageHandler(final MessageHandler theHandler) throws ActiveMQException { checkClosed(); if (receiverThread != null) { throw ActiveMQClientMessageBundle.BUNDLE.inReceive(); } boolean noPreviousHandler = handler == null; if (handler != theHandler && clientWindowSize == 0) { startSlowConsumer(); } handler = theHandler; // if no previous handler existed queue up messages for delivery if (handler != null && noPreviousHandler) { requeueExecutors(); } else if (handler == null && !noPreviousHandler) { // if unsetting a previous handler may be in onMessage so wait for completion waitForOnMessageToComplete(true); } return this; }
@Override public void clear(boolean waitForOnMessage) throws ActiveMQException { synchronized (this) { // Need to send credits for the messages in the buffer Iterator<ClientMessageInternal> iter = buffer.iterator(); while (iter.hasNext()) { try { ClientMessageInternal message = iter.next(); if (message.isLargeMessage()) { ClientLargeMessageInternal largeMessage = (ClientLargeMessageInternal) message; largeMessage.getLargeMessageController().cancel(); } flowControlBeforeConsumption(message); } catch (Exception e) { ActiveMQClientLogger.LOGGER.errorClearingMessages(e); } } clearBuffer(); try { resetLargeMessageController(); } catch (Throwable e) { // nothing that could be done here ActiveMQClientLogger.LOGGER.errorClearingMessages(e); } } // Need to send credits for the messages in the buffer waitForOnMessageToComplete(waitForOnMessage); }
@Override public void acknowledge(final ClientMessage message) throws ActiveMQException { ClientMessageInternal cmi = (ClientMessageInternal) message; if (ackIndividually) { individualAcknowledge(message); } else { ackBytes += message.getEncodeSize(); if (logger.isTraceEnabled()) { logger.trace(this + "::acknowledge ackBytes=" + ackBytes + " and ackBatchSize=" + ackBatchSize + ", encodeSize=" + message.getEncodeSize()); } if (ackBytes >= ackBatchSize) { if (logger.isTraceEnabled()) { logger.trace(this + ":: acknowledge acking " + cmi); } doAck(cmi); } else { if (logger.isTraceEnabled()) { logger.trace(this + ":: acknowledge setting lastAckedMessage = " + cmi); } lastAckedMessage = cmi; } } }
@Override public void clearAtFailover() { if (logger.isTraceEnabled()) { logger.trace(this + "::ClearAtFailover"); } clearBuffer(); // failover will issue a start later this.stopped = true; resetLargeMessageController(); lastAckedMessage = null; creditsToSend = 0; failedOver = true; ackIndividually = false; }
@Override public synchronized void handleMessage(final ClientMessageInternal message) throws Exception { if (closing) { // This is ok - we just ignore the message return; } if (message.getBooleanProperty(Message.HDR_LARGE_COMPRESSED)) { handleCompressedMessage(message); } else { handleRegularMessage(message); } }
waitForOnMessageToComplete(true); resetLargeMessageController(); flushAcks(); clearBuffer();
checkClosed(); logger.trace(this + "::receive(" + timeout + ", " + forcingDelivery + ") -> start slowConsumer"); startSlowConsumer(); resetIfSlowConsumer(); flowControlBeforeConsumption(m); startSlowConsumer(); logger.trace(this + "::Returning null"); resetIfSlowConsumer(); return null;
@Override public ClientConsumerInternal createConsumer(SimpleString queueName, SimpleString filterString, int windowSize, int maxRate, int ackBatchSize, boolean browseOnly, Executor executor, Executor flowControlExecutor) throws ActiveMQException { long consumerID = idGenerator.generateID(); ActiveMQConsumerContext consumerContext = new ActiveMQConsumerContext(consumerID); SessionCreateConsumerMessage request = new SessionCreateConsumerMessage(consumerID, queueName, filterString, browseOnly, true); SessionQueueQueryResponseMessage queueInfo = (SessionQueueQueryResponseMessage) getSessionChannel().sendBlocking(request, PacketImpl.SESS_QUEUEQUERY_RESP); // The actual windows size that gets used is determined by the user since // could be overridden on the queue settings // The value we send is just a hint return new ClientConsumerImpl(session, consumerContext, queueName, filterString, browseOnly, calcWindowSize(windowSize), ackBatchSize, maxRate > 0 ? new TokenBucketLimiterImpl(maxRate, false) : null, executor, flowControlExecutor, this, queueInfo.toQueueQuery(), lookupTCCL()); }
@Override public synchronized void handleLargeMessageContinuation(final byte[] chunk, final int flowControlSize, final boolean isContinues) throws Exception { if (closing) { return; } if (currentLargeMessageController == null) { if (logger.isTraceEnabled()) { logger.trace(this + "::Sending back credits for largeController = null " + flowControlSize); } flowControl(flowControlSize, false); } else { currentLargeMessageController.addPacket(chunk, flowControlSize, isContinues); } }
@Override public void flushAcks() throws ActiveMQException { if (lastAckedMessage != null) { if (logger.isTraceEnabled()) { logger.trace(this + "::FlushACK acking lastMessage::" + lastAckedMessage); } doAck(lastAckedMessage); } }
@Override public MessageHandler getMessageHandler() throws ActiveMQException { checkClosed(); return handler; }
@Override public void individualAcknowledge(ClientMessage message) throws ActiveMQException { if (lastAckedMessage != null) { flushAcks(); } session.individualAcknowledge(this, message); }
@Override public void close() throws ActiveMQException { doCleanUp(true); }
@Override public synchronized void handleLargeMessage(final ClientLargeMessageInternal clientLargeMessage, long largeMessageSize) throws Exception { if (closing) { // This is ok - we just ignore the message return; } // Flow control for the first packet, we will have others File largeMessageCache = null; if (session.isCacheLargeMessageClient()) { largeMessageCache = File.createTempFile("tmp-large-message-" + clientLargeMessage.getMessageID() + "-", ".tmp"); largeMessageCache.deleteOnExit(); } ClientSessionFactory sf = session.getSessionFactory(); ServerLocator locator = sf.getServerLocator(); long callTimeout = locator.getCallTimeout(); currentLargeMessageController = new LargeMessageControllerImpl(this, largeMessageSize, callTimeout, largeMessageCache); if (clientLargeMessage.isCompressed()) { clientLargeMessage.setLargeMessageController(new CompressedLargeMessageControllerImpl(currentLargeMessageController)); } else { clientLargeMessage.setLargeMessageController(currentLargeMessageController); } handleRegularMessage(clientLargeMessage); }
waitForOnMessageToComplete(true); resetLargeMessageController(); flushAcks(); clearBuffer();
@Override public synchronized void handleMessage(final ClientMessageInternal message) throws Exception { if (closing) { // This is ok - we just ignore the message return; } if (message.getBooleanProperty(Message.HDR_LARGE_COMPRESSED)) { handleCompressedMessage(message); } else { handleRegularMessage(message); } }
@Override public void clearAtFailover() { if (logger.isTraceEnabled()) { logger.trace(this + "::ClearAtFailover"); } clearBuffer(); // failover will issue a start later this.stopped = true; resetLargeMessageController(); lastAckedMessage = null; creditsToSend = 0; failedOver = true; ackIndividually = false; }