@Override public void removeConsumer(ConnectionContext context, ConsumerInfo info) throws Exception { if (!AdvisorySupport.isAdvisoryTopic(info.getDestination()) && !info.getDestination().isTemporary()) { if (singleSelectorPerDestination) { String destinationName = info.getDestination().getQualifiedName(); Set<String> selectors = subSelectorCache.get(destinationName); if (info.getSelector() == null && selectors.size() > 1) { boolean removed = selectors.remove(MATCH_EVERYTHING); LOG.debug("A non-selector consumer has dropped. Removing the catchall matching pattern 'TRUE'. Successful? " + removed); } } } super.removeConsumer(context, info); }
private void undoMapRegistration(DemandSubscription sub) { subscriptionMapByLocalId.remove(sub.getLocalInfo().getConsumerId()); subscriptionMapByRemoteId.remove(sub.getRemoteInfo().getConsumerId()); }
final protected DemandSubscription createDemandSubscription(ActiveMQDestination destination, final String subscriptionName) { ConsumerInfo info = new ConsumerInfo(); info.setNetworkSubscription(true); info.setDestination(destination); if (subscriptionName != null) { info.setSubscriptionName(subscriptionName); } // Indicate that this subscription is being made on behalf of the remote broker. info.setBrokerPath(new BrokerId[]{remoteBrokerId}); // the remote info held by the DemandSubscription holds the original // consumerId, the local info get's overwritten info.setConsumerId(new ConsumerId(localSessionInfo.getSessionId(), consumerIdGenerator.getNextSequenceId())); DemandSubscription result = null; try { result = createDemandSubscription(info); } catch (IOException e) { LOG.error("Failed to create DemandSubscription ", e); } return result; }
public ConsumerInfo copy() { ConsumerInfo info = new ConsumerInfo(); copy(info); return info; }
/** * @return true if this is a durable topic subscriber */ public boolean isDurableSubscriber() { return info.getSubscriptionName() != null && info.getDestination().isTopic(); }
public AdvisoryConsumer(ActiveMQConnection connection, ConsumerId consumerId) throws JMSException { this.connection = connection; info = new ConsumerInfo(consumerId); info.setDestination(AdvisorySupport.TEMP_DESTINATION_COMPOSITE_ADVISORY_TOPIC); info.setPrefetchSize(1000); info.setNoLocal(true); info.setDispatchAsync(true); this.connection.addDispatcher(info.getConsumerId(), this); this.connection.syncSendPacket(this.info); }
if (!AdvisorySupport.isAdvisoryTopic(info.getDestination())) { ActiveMQTopic topic = AdvisorySupport.getConsumerAdvisoryTopic(info.getDestination()); consumersLock.writeLock().lock(); try { consumers.put(info.getConsumerId(), info); if (getBrokerService().isUseVirtualDestSubs()) { for (VirtualDestination virtualDestination : virtualDestinations) { if (virtualDestinationMatcher.matches(virtualDestination, info.getDestination())) { fireVirtualDestinationAddAdvisory(context, info, info.getDestination(), virtualDestination); fireConsumerAdvisory(context, info.getDestination(), topic, info); } else { if (AdvisorySupport.isConnectionAdvisoryTopic(info.getDestination())) { for (Iterator<ConnectionInfo> iter = connections.values().iterator(); iter.hasNext(); ) { ConnectionInfo value = iter.next(); ActiveMQTopic topic = AdvisorySupport.getConnectionAdvisoryTopic(); fireAdvisory(context, topic, value, info.getConsumerId()); if (AdvisorySupport.isTempDestinationAdvisoryTopic(info.getDestination())) { for (DestinationInfo destination : destinations.values()) { if (destination.getDestination().isTemporary()) { ActiveMQTopic topic = AdvisorySupport.getDestinationAdvisoryTopic(destination.getDestination()); fireAdvisory(context, topic, destination, info.getConsumerId()); } else if (AdvisorySupport.isDestinationAdvisoryTopic(info.getDestination())) {
@Override public Subscription addConsumer(ConnectionContext context, ConsumerInfo info) throws Exception { if (info.isDurable()) { if (broker.getBrokerService().isRejectDurableConsumers()) { throw new JMSException("Durable Consumers are not allowed"); ActiveMQDestination destination = info.getDestination(); if (!destination.isPattern()) { String clientId = context.getClientId(); String subscriptionName = info.getSubscriptionName(); SubscriptionKey key = new SubscriptionKey(clientId, subscriptionName); DurableTopicSubscription sub = durableSubscriptions.get(key); if (sub != null) { if (sub.getConsumerInfo().getConsumerId() != null) { subscriptions.remove(sub.getConsumerInfo().getConsumerId()); sub.info = info; sub.context = context; sub.deactivate(keepDurableSubsActive, info.getLastDeliveredSequenceId()); if (info.isNoLocal()) { sub.setSelector(sub.getSelector()); subscriptions.put(info.getConsumerId(), sub); throw new JMSException("Cannot use the same consumerId: " + info.getConsumerId() + " for two different durable subscriptions clientID: " + key.getClientId() + " subscriberName: " + key.getSubscriptionName());
if (brokerConsumerDests.get(pair) == null) { ConnectionId connectionId = new ConnectionId(connectionIdGenerator.generateId()); SessionId sessionId = new SessionId(connectionId, sessionIdGenerator.getNextSequenceId()); ConsumerId consumerId = new ConsumerId(sessionId, consumerIdGenerator.getNextSequenceId()); info = new ConsumerInfo(consumerId); if(brokerConsumerDests.putIfAbsent(pair, info) == null) { LOG.debug("Virtual consumer pair added: {} for consumer: {} ", pair, info); setConsumerInfoVirtualDest(info, virtualDestination, activeMQDest); ActiveMQTopic topic = AdvisorySupport.getVirtualDestinationConsumerAdvisoryTopic(info.getDestination()); if (virtualDestinationConsumers.putIfAbsent(info, virtualDestination) == null) { LOG.debug("Virtual consumer added: {}, for virtual destination: {}", info, virtualDestination); fireConsumerAdvisory(context, info.getDestination(), topic, info); info = info.copy(); setConsumerInfoVirtualDest(info, virtualDestination, activeMQDest); ActiveMQTopic topic = AdvisorySupport.getVirtualDestinationConsumerAdvisoryTopic(info.getDestination()); if (virtualDestinationConsumers.putIfAbsent(info, virtualDestination) == null) { LOG.debug("Virtual consumer added: {}, for virtual destination: {}", info, virtualDestination); fireConsumerAdvisory(context, info.getDestination(), topic, info);
info.setConsumerId((org.apache.activemq.command.ConsumerId)looseUnmarsalCachedObject(wireFormat, dataIn)); info.setBrowser(dataIn.readBoolean()); info .setDestination((org.apache.activemq.command.ActiveMQDestination)looseUnmarsalCachedObject( wireFormat, dataIn)); info.setPrefetchSize(dataIn.readInt()); info.setMaximumPendingMessageLimit(dataIn.readInt()); info.setDispatchAsync(dataIn.readBoolean()); info.setSelector(looseUnmarshalString(dataIn)); info.setSubscriptionName(looseUnmarshalString(dataIn)); info.setNoLocal(dataIn.readBoolean()); info.setExclusive(dataIn.readBoolean()); info.setRetroactive(dataIn.readBoolean()); info.setPriority(dataIn.readByte()); info.setBrokerPath(value); } else { info.setBrokerPath(null); .setAdditionalPredicate((org.apache.activemq.filter.BooleanExpression)looseUnmarsalNestedObject( wireFormat, dataIn)); info.setNetworkSubscription(dataIn.readBoolean()); info.setOptimizedAcknowledge(dataIn.readBoolean()); info.setNoRangeAcks(dataIn.readBoolean());
DurableTopicSubscription sub = durableSubscriptions.get(key); ConsumerInfo consumerInfo = createInactiveConsumerInfo(info); if (sub == null) { ConnectionContext c = new ConnectionContext(); c.setBroker(context.getBroker()); c.setClientId(key.getClientId()); c.setConnectionId(consumerInfo.getConsumerId().getParentId().getParentId()); sub = (DurableTopicSubscription)createSubscription(c, consumerInfo); sub.setOfflineTimestamp(System.currentTimeMillis()); durableSubscriptions.values(); for (DurableTopicSubscription sub : durableSubscriptions.values()) {
@Override public Response processAddConsumer(ConsumerInfo info) { if (info != null) { SessionId sessionId = info.getConsumerId().getParentId(); if (sessionId != null) { ConnectionId connectionId = sessionId.getParentId(); if (connectionId != null) { ConnectionState cs = connectionStates.get(connectionId); if (cs != null) { SessionState ss = cs.getSessionState(sessionId); if (ss != null) { ss.addConsumer(info); if (info.isResponseRequired()) { return new Tracked(new ExceptionResponseCheckAction(info)); } } } } } } return TRACKED_RESPONSE_MARKER; }
@Override public void removeConsumer(ConnectionContext context, ConsumerInfo info) throws Exception { if (info.isDurable()) { SubscriptionKey key = new SubscriptionKey(context.getClientId(), info.getSubscriptionName()); DurableTopicSubscription sub = durableSubscriptions.get(key); if (sub != null) { // deactivate only if given context is same // as what is in the sub. otherwise, during linksteal // sub will get new context, but will be removed here if (sub.getContext() == context) { sub.deactivate(keepDurableSubsActive, info.getLastDeliveredSequenceId()); } } } else { super.removeConsumer(context, info); } }
private void fireVirtualDestinationRemoveAdvisory(ConnectionContext context, ConsumerInfo info) throws Exception { VirtualDestination virtualDestination = virtualDestinationConsumers.remove(info); if (virtualDestination != null) { LOG.debug("Virtual consumer removed: {}, for virtual destination: {}", info, virtualDestination); ActiveMQTopic topic = AdvisorySupport.getVirtualDestinationConsumerAdvisoryTopic(virtualDestination.getVirtualDestination()); ActiveMQDestination dest = info.getDestination(); if (!dest.isTemporary() || destinations.containsKey(dest)) { fireConsumerAdvisory(context, dest, topic, info.createRemoveCommand()); } } }
protected boolean removeDemandSubscriptionByLocalId(ConsumerId consumerId) { boolean removeDone = false; DemandSubscription sub = subscriptionMapByLocalId.get(consumerId); if (sub != null) { try { removeDemandSubscription(sub.getRemoteInfo().getConsumerId()); removeDone = true; } catch (IOException e) { LOG.debug("removeDemandSubscriptionByLocalId failed for localId: {}", consumerId, e); } } return removeDone; }
protected void configureDemandSubscription(ConsumerInfo info, DemandSubscription sub) throws IOException { if (AdvisorySupport.isConsumerAdvisoryTopic(info.getDestination()) || AdvisorySupport.isVirtualDestinationConsumerAdvisoryTopic(info.getDestination())) { sub.getLocalInfo().setDispatchAsync(true); } else { sub.getLocalInfo().setDispatchAsync(configuration.isDispatchAsync()); } configureConsumerPrefetch(sub.getLocalInfo()); subscriptionMapByLocalId.put(sub.getLocalInfo().getConsumerId(), sub); subscriptionMapByRemoteId.put(sub.getRemoteInfo().getConsumerId(), sub); sub.setNetworkBridgeFilter(createNetworkBridgeFilter(info)); if (!info.isDurable()) { // This works for now since we use a VM connection to the local broker. // may need to change if we ever subscribe to a remote broker. sub.getLocalInfo().setAdditionalPredicate(sub.getNetworkBridgeFilter()); } else { sub.setLocalDurableSubscriber(new SubscriptionInfo(info.getClientId(), info.getSubscriptionName())); } }
@Override public void removeConsumer(ConnectionContext context, ConsumerInfo info) throws Exception { super.removeConsumer(context, info); // Don't advise advisory topics. ActiveMQDestination dest = info.getDestination(); if (!AdvisorySupport.isAdvisoryTopic(dest)) { ActiveMQTopic topic = AdvisorySupport.getConsumerAdvisoryTopic(dest); consumersLock.writeLock().lock(); try { consumers.remove(info.getConsumerId()); //remove the demand for this consumer if it matches a virtual destination if(getBrokerService().isUseVirtualDestSubs()) { fireVirtualDestinationRemoveAdvisory(context, info); } } finally { consumersLock.writeLock().unlock(); } if (!dest.isTemporary() || destinations.containsKey(dest)) { fireConsumerAdvisory(context, dest, topic, info.createRemoveCommand()); } } }
consumersLock.readLock().lock(); try { if (getBrokerService().isUseVirtualDestSubsOnCreation()) { for (ActiveMQDestination destination : destinations.keySet()) { if(destination.isQueue()) { if (virtualDestinationMatcher.matches(virtualDestination, destination)) { fireVirtualDestinationAddAdvisory(context, null, destination, virtualDestination); if (virtualDestinationMatcher.matches(virtualDestination, info.getDestination())) { fireVirtualDestinationAddAdvisory(context, info, info.getDestination(), virtualDestination); consumersLock.readLock().unlock();
if (info.isNetworkSubscription() && info.getDestination().isQueue() && !configuration.isConduitNetworkQueueSubscriptions()) { return false; for (DemandSubscription ds : subscriptionMapByLocalId.values()) { DestinationFilter filter = DestinationFilter.parseFilter(ds.getLocalInfo().getDestination()); if (canConduit(ds) && filter.matches(info.getDestination())) { LOG.debug("{} {} with ids {} matched (add interest) {}", new Object[]{ configuration.getBrokerName(), info, info.getNetworkConsumerIds(), ds }); if (!info.isDurable()) { ds.add(info.getConsumerId()); if (isForcedDurable) { forcedDurableRemoteId.add(info.getConsumerId()); ds.addForcedDurableConsumer(info.getConsumerId()); info.getSubscriptionName() != null && info.getSubscriptionName().startsWith(DURABLE_SUB_PREFIX)) { final BrokerId[] path = info.getBrokerPath(); addProxyNetworkSubscriptionBrokerPath(ds, path, info.getSubscriptionName()); } else if (isProxyNSConsumerClientId(info.getClientId()) && isProxyBridgeSubscription(info.getClientId(), info.getSubscriptionName())) { addProxyNetworkSubscriptionClientId(ds, info.getClientId(), info.getSubscriptionName()); } else { ds.getDurableRemoteSubs().add(new SubscriptionInfo(info.getClientId(), info.getSubscriptionName()));
protected boolean doesConsumerExist(ActiveMQDestination dest) { DestinationFilter filter = DestinationFilter.parseFilter(dest); for (DemandSubscription ds : subscriptionMapByLocalId.values()) { if (filter.matches(ds.getLocalInfo().getDestination())) { return true; } } return false; } }