@Override public AddressQuery addressQuery(final SimpleString address) throws ActiveMQException { checkClosed(); return sessionContext.addressQuery(address); }
@Override public void expire(final ClientConsumer consumer, final Message message) throws ActiveMQException { checkClosed(); // We don't send expiries for pre-ack since message will already have been acked on server if (!preAcknowledge) { sessionContext.expireMessage(consumer, message); } }
@Override public void createAddress(final SimpleString address, EnumSet<RoutingType> routingTypes, boolean autoCreated) throws ActiveMQException { checkClosed(); startCall(); try { sessionContext.createAddress(address, routingTypes, autoCreated); } finally { endCall(); } }
public void stop(final boolean waitForOnMessage) throws ActiveMQException { checkClosed(); if (started) { for (ClientConsumerInternal clientConsumerInternal : cloneConsumers()) { clientConsumerInternal.stop(waitForOnMessage); } sessionContext.sessionStop(); started = false; } }
@Override public void deleteQueue(final SimpleString queueName) throws ActiveMQException { checkClosed(); startCall(); try { sessionContext.deleteQueue(queueName); } finally { endCall(); } }
@Override public QueueQuery queueQuery(final SimpleString queueName) throws ActiveMQException { checkClosed(); startCall(); try { return sessionContext.queueQuery(queueName); } finally { endCall(); } }
@Override public ClientSessionImpl start() throws ActiveMQException { checkClosed(); if (!started) { for (ClientConsumerInternal clientConsumerInternal : cloneConsumers()) { clientConsumerInternal.start(); } sessionContext.sessionStart(); started = true; } return this; }
@Override public void individualAcknowledge(final ClientConsumer consumer, final Message message) throws ActiveMQException { // if we're pre-acknowledging then we don't need to do anything if (preAcknowledge) { return; } checkClosed(); startCall(); try { sessionContext.sendACK(true, blockOnAcknowledge, consumer, message); } finally { endCall(); } }
/** * @param queueName * @param filterString * @param windowSize * @param browseOnly * @return * @throws ActiveMQException */ private ClientConsumer internalCreateConsumer(final SimpleString queueName, final SimpleString filterString, final int windowSize, final int maxRate, final boolean browseOnly) throws ActiveMQException { checkClosed(); ClientConsumerInternal consumer = sessionContext.createConsumer(queueName, filterString, windowSize, maxRate, ackBatchSize, browseOnly, executor, flowControlExecutor); addConsumer(consumer); // Now we send window size credits to start the consumption // We even send it if windowSize == -1, since we need to start the // consumer // TODO: this could semantically change on other servers. I know for instance on stomp this is just an ignore if (windowSize != 0) { sessionContext.sendConsumerCredits(consumer, windowSize); } return consumer; }
/** * Creates Shared queue. A queue that will exist as long as there are consumers or is durable. * * @param address the queue will be bound to this address * @param routingType the delivery mode for this queue, MULTICAST or ANYCAST * @param queueName the name of the queue * @param filter whether the queue is durable or not * @param durable if the queue is durable * @param maxConsumers how many concurrent consumers will be allowed on this queue * @param purgeOnNoConsumers whether to delete the contents of the queue when the last consumer disconnects * @param exclusive if the queue is exclusive queue * @param lastValue if the queue is last value queue * @throws ActiveMQException in an exception occurs while creating the queue */ @Override public void createSharedQueue(SimpleString address, RoutingType routingType, SimpleString queueName, SimpleString filter, boolean durable, Integer maxConsumers, Boolean purgeOnNoConsumers, Boolean exclusive, Boolean lastValue) throws ActiveMQException { checkClosed(); startCall(); try { sessionContext.createSharedQueue(address, queueName, routingType, filter, durable, maxConsumers, purgeOnNoConsumers, exclusive, lastValue); } finally { endCall(); } }
/** * Acknowledges all messages received by the consumer so far. */ @Override public void acknowledge(final ClientConsumer consumer, final Message message) throws ActiveMQException { // if we're pre-acknowledging then we don't need to do anything if (preAcknowledge) { return; } checkClosed(); if (logger.isDebugEnabled()) { logger.debug("client ack messageID = " + message.getMessageID()); } startCall(); try { sessionContext.sendACK(false, blockOnAcknowledge, consumer, message); } finally { endCall(); } }
public void rollback(final boolean isLastMessageAsDelivered, final boolean waitConsumers) throws ActiveMQException { if (logger.isTraceEnabled()) { logger.trace("calling rollback(isLastMessageAsDelivered=" + isLastMessageAsDelivered + ")"); } checkClosed(); // We do a "JMS style" rollback where the session is stopped, and the buffer is cancelled back // first before rolling back // This ensures messages are received in the same order after rollback w.r.t. to messages in the buffer // For core we could just do a straight rollback, it really depends if we want JMS style semantics or not... boolean wasStarted = started; if (wasStarted) { stop(); } // We need to make sure we don't get any inflight messages for (ClientConsumerInternal consumer : cloneConsumers()) { consumer.clear(waitConsumers); } // Acks must be flushed here *after connection is stopped and all onmessages finished executing flushAcks(); sessionContext.simpleRollback(isLastMessageAsDelivered); if (wasStarted) { start(); } rollbackOnly = false; }
private ClientProducer internalCreateProducer(final SimpleString address, final int maxRate) throws ActiveMQException { checkClosed(); ClientProducerInternal producer = new ClientProducerImpl(this, address, maxRate == -1 ? null : new TokenBucketLimiterImpl(maxRate, false), autoCommitSends && blockOnNonDurableSend, autoCommitSends && blockOnDurableSend, autoGroup, groupID == null ? null : new SimpleString(groupID), minLargeMessageSize, sessionContext); addProducer(producer); return producer; }
final Boolean exclusive, final Boolean lastValue) throws ActiveMQException { checkClosed();
@Override public void commit(boolean block) throws ActiveMQException { checkClosed();
@Override public void expire(final ClientConsumer consumer, final Message message) throws ActiveMQException { checkClosed(); // We don't send expiries for pre-ack since message will already have been acked on server if (!preAcknowledge) { sessionContext.expireMessage(consumer, message); } }
@Override public QueueQuery queueQuery(final SimpleString queueName) throws ActiveMQException { checkClosed(); startCall(); try { return sessionContext.queueQuery(queueName); } finally { endCall(); } }
@Override public ClientSessionImpl start() throws ActiveMQException { checkClosed(); if (!started) { for (ClientConsumerInternal clientConsumerInternal : cloneConsumers()) { clientConsumerInternal.start(); } sessionContext.sessionStart(); started = true; } return this; }
@Override public QueueQuery queueQuery(final SimpleString queueName) throws ActiveMQException { checkClosed(); startCall(); try { return sessionContext.queueQuery(queueName); } finally { endCall(); } }
@Override public QueueQuery queueQuery(final SimpleString queueName) throws ActiveMQException { checkClosed(); startCall(); try { return sessionContext.queueQuery(queueName); } finally { endCall(); } }