Java AdvisorySupport.isAdvisoryTopic方法代码示例

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
/**
 * Add a destination
 *
 * @param context
 * @param destination
 * @throws Exception
 */
@Override
public synchronized void add(ConnectionContext context, Destination destination) throws Exception {
    if (destination != null && !AdvisorySupport.isAdvisoryTopic(destination.getActiveMQDestination())) {
        TopicStorePrefetch tsp = new TopicStorePrefetch(this.subscription,(Topic)destination, clientId, subscriberName);
        tsp.setMaxBatchSize(destination.getMaxPageSize());
        tsp.setSystemUsage(systemUsage);
        tsp.setMessageAudit(getMessageAudit());
        tsp.setEnableAudit(isEnableAudit());
        tsp.setMemoryUsageHighWaterMark(getMemoryUsageHighWaterMark());
        tsp.setUseCache(isUseCache());
        tsp.setCacheEnabled(isUseCache() && tsp.isEmpty());
        topics.put(destination, tsp);
        storePrefetches.add(tsp);
        if (isStarted()) {
            tsp.start();
        }
    }
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
protected FrameTranslator findTranslator(String header, ActiveMQDestination destination) {
    FrameTranslator translator = frameTranslator;
    try {
        if (header != null) {
            translator = (FrameTranslator) FRAME_TRANSLATOR_FINDER
                    .newInstance(header);
        } else {
            if (destination != null && AdvisorySupport.isAdvisoryTopic(destination)) {
                translator = new JmsFrameTranslator();
            }
        }
    } catch (Exception ignore) {
        // if anything goes wrong use the default translator
    }

    if (translator instanceof BrokerContextAware) {
        ((BrokerContextAware)translator).setBrokerContext(brokerContext);
    }

    return translator;
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
@Override
public void tempQueueDeleted(SimpleString bindingName) {
   ActiveMQDestination dest = new ActiveMQTempQueue(bindingName.toString());
   state.removeTempDestination(dest);

   if (!AdvisorySupport.isAdvisoryTopic(dest)) {
      AMQConnectionContext context = getContext();
      DestinationInfo advInfo = new DestinationInfo(context.getConnectionId(), DestinationInfo.REMOVE_OPERATION_TYPE, dest);

      ActiveMQTopic topic = AdvisorySupport.getDestinationAdvisoryTopic(dest);
      try {
         protocolManager.fireAdvisory(context, topic, advInfo);
      } catch (Exception e) {
         logger.warn("Failed to fire advisory on " + topic, e);
      }
   }
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
protected Set<GroupPrincipal> getACLs(ActiveMQDestination destination, String roleBase, String roleAttribute) {
    try {
        context = open();
    } catch (NamingException e) {
        LOG.error(e.toString());
        return new HashSet<GroupPrincipal>();
    }



    String destinationBase = "";
    SearchControls constraints = new SearchControls();
    if (AdvisorySupport.isAdvisoryTopic(destination) && useAdvisorySearchBase) {
        destinationBase = advisorySearchBase;
    } else {
        if ((destination.getDestinationType() & ActiveMQDestination.QUEUE_TYPE) == ActiveMQDestination.QUEUE_TYPE) {
            destinationBase = queueSearchMatchingFormat.format(new String[]{destination.getPhysicalName()});
            if (queueSearchSubtreeBool) {
                constraints.setSearchScope(SearchControls.SUBTREE_SCOPE);
            } else {
                constraints.setSearchScope(SearchControls.ONELEVEL_SCOPE);
            }
        }
        if ((destination.getDestinationType() & ActiveMQDestination.TOPIC_TYPE) == ActiveMQDestination.TOPIC_TYPE) {
            destinationBase = topicSearchMatchingFormat.format(new String[]{destination.getPhysicalName()});
            if (topicSearchSubtreeBool) {
                constraints.setSearchScope(SearchControls.SUBTREE_SCOPE);
            } else {
                constraints.setSearchScope(SearchControls.ONELEVEL_SCOPE);
            }
        }
    }

    constraints.setReturningAttributes(new String[] {roleAttribute});

    return getACLs(destinationBase, constraints, roleBase, roleAttribute);
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
@Override
public Response processAddProducer(ProducerInfo info) throws Exception {
    SessionId sessionId = info.getProducerId().getParentId();
    ConnectionId connectionId = sessionId.getParentId();
    TransportConnectionState cs = lookupConnectionState(connectionId);
    if (cs == null) {
        throw new IllegalStateException("Cannot add a producer to a connection that had not been registered: "
                + connectionId);
    }
    SessionState ss = cs.getSessionState(sessionId);
    if (ss == null) {
        throw new IllegalStateException("Cannot add a producer to a session that had not been registered: "
                + sessionId);
    }
    // Avoid replaying dup commands
    if (!ss.getProducerIds().contains(info.getProducerId())) {
        ActiveMQDestination destination = info.getDestination();
        if (destination != null && !AdvisorySupport.isAdvisoryTopic(destination)) {
            if (getProducerCount(connectionId) >= connector.getMaximumProducersAllowedPerConnection()){
                throw new IllegalStateException("Can't add producer on connection " + connectionId + ": at maximum limit: " + connector.getMaximumProducersAllowedPerConnection());
            }
        }
        broker.addProducer(cs.getContext(), info);
        try {
            ss.addProducer(info);
        } catch (IllegalStateException e) {
            broker.removeProducer(cs.getContext(), info);
        }

    }
    return null;
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
@Override
public Response processAddConsumer(ConsumerInfo info) throws Exception {
    SessionId sessionId = info.getConsumerId().getParentId();
    ConnectionId connectionId = sessionId.getParentId();
    TransportConnectionState cs = lookupConnectionState(connectionId);
    if (cs == null) {
        throw new IllegalStateException("Cannot add a consumer to a connection that had not been registered: "
                + connectionId);
    }
    SessionState ss = cs.getSessionState(sessionId);
    if (ss == null) {
        throw new IllegalStateException(broker.getBrokerName()
                + " Cannot add a consumer to a session that had not been registered: " + sessionId);
    }
    // Avoid replaying dup commands
    if (!ss.getConsumerIds().contains(info.getConsumerId())) {
        ActiveMQDestination destination = info.getDestination();
        if (destination != null && !AdvisorySupport.isAdvisoryTopic(destination)) {
            if (getConsumerCount(connectionId) >= connector.getMaximumConsumersAllowedPerConnection()){
                throw new IllegalStateException("Can't add consumer on connection " + connectionId + ": at maximum limit: " + connector.getMaximumConsumersAllowedPerConnection());
            }
        }

        broker.addConsumer(cs.getContext(), info);
        try {
            ss.addConsumer(info);
            addConsumerBrokerExchange(info.getConsumerId());
        } catch (IllegalStateException e) {
            broker.removeConsumer(cs.getContext(), info);
        }

    }
    return null;
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
@Override
public void removeDestination(Destination dest) {
    ActiveMQDestination destination = dest.getActiveMQDestination();
    if (!destination.isTemporary()) {
        if (destination.isQueue()) {
            persistenceAdapter.removeQueueMessageStore((ActiveMQQueue) destination);
        }
        else if (!AdvisorySupport.isAdvisoryTopic(destination)) {
            persistenceAdapter.removeTopicMessageStore((ActiveMQTopic) destination);
        }
    }
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
public void addDestination(DestinationInfo info) throws Exception {
   boolean created = false;
   ActiveMQDestination dest = info.getDestination();
   if (!protocolManager.isSupportAdvisory() && AdvisorySupport.isAdvisoryTopic(dest)) {
      return;
   }

   SimpleString qName = SimpleString.toSimpleString(dest.getPhysicalName());
   if (server.locateQueue(qName) == null) {
      AddressSettings addressSettings = server.getAddressSettingsRepository().getMatch(dest.getPhysicalName());
      AddressInfo addressInfo = new AddressInfo(qName, dest.isTopic() ? RoutingType.MULTICAST : RoutingType.ANYCAST);
      if (AdvisorySupport.isAdvisoryTopic(dest) && protocolManager.isSuppressInternalManagementObjects()) {
         addressInfo.setInternal(true);
      }
      if (dest.isQueue() && (addressSettings.isAutoCreateQueues() || dest.isTemporary())) {
         internalSession.createQueue(addressInfo, qName, null, dest.isTemporary(), !dest.isTemporary(), !dest.isTemporary());
         created = true;
      } else if (dest.isTopic() && (addressSettings.isAutoCreateAddresses() || dest.isTemporary())) {
         internalSession.createAddress(addressInfo, !dest.isTemporary());
         created = true;
      }
   }

   if (dest.isTemporary()) {
      //Openwire needs to store the DestinationInfo in order to send
      //Advisory messages to clients
      this.state.addTempDestination(info);
   }

   if (created && !AdvisorySupport.isAdvisoryTopic(dest)) {
      AMQConnectionContext context = getContext();
      DestinationInfo advInfo = new DestinationInfo(context.getConnectionId(), DestinationInfo.ADD_OPERATION_TYPE, dest);

      ActiveMQTopic topic = AdvisorySupport.getDestinationAdvisoryTopic(dest);
      protocolManager.fireAdvisory(context, topic, advInfo);
   }
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
public void removeDestination(ActiveMQDestination dest) throws Exception {
   if (dest.isQueue()) {
      try {
         server.destroyQueue(new SimpleString(dest.getPhysicalName()));
      } catch (ActiveMQNonExistentQueueException neq) {
         //this is ok, ActiveMQ 5 allows this and will actually do it quite often
         ActiveMQServerLogger.LOGGER.debug("queue never existed");
      }


   } else {
      Bindings bindings = server.getPostOffice().getBindingsForAddress(new SimpleString(dest.getPhysicalName()));

      for (Binding binding : bindings.getBindings()) {
         Queue b = (Queue) binding.getBindable();
         if (b.getConsumerCount() > 0) {
            throw new Exception("Destination still has an active subscription: " + dest.getPhysicalName());
         }
         if (b.isDurable()) {
            throw new Exception("Destination still has durable subscription: " + dest.getPhysicalName());
         }
         b.deleteQueue();
      }
   }

   if (!AdvisorySupport.isAdvisoryTopic(dest)) {
      AMQConnectionContext context = getContext();
      DestinationInfo advInfo = new DestinationInfo(context.getConnectionId(), DestinationInfo.REMOVE_OPERATION_TYPE, dest);

      ActiveMQTopic topic = AdvisorySupport.getDestinationAdvisoryTopic(dest);
      protocolManager.fireAdvisory(context, topic, advInfo);
   }
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
@Override
public Response processAddProducer(ProducerInfo info) throws Exception {
   SessionId sessionId = info.getProducerId().getParentId();
   ConnectionState cs = getState();

   if (cs == null) {
      throw new IllegalStateException("Cannot add a producer to a connection that had not been registered: " + sessionId.getParentId());
   }

   SessionState ss = cs.getSessionState(sessionId);
   if (ss == null) {
      throw new IllegalStateException("Cannot add a producer to a session that had not been registered: " + sessionId);
   }

   // Avoid replaying dup commands
   if (!ss.getProducerIds().contains(info.getProducerId())) {
      ActiveMQDestination destination = info.getDestination();

      if (destination != null && !AdvisorySupport.isAdvisoryTopic(destination)) {
         if (destination.isQueue()) {
            OpenWireConnection.this.validateDestination(destination);
         }
         DestinationInfo destInfo = new DestinationInfo(getContext().getConnectionId(), DestinationInfo.ADD_OPERATION_TYPE, destination);
         OpenWireConnection.this.addDestination(destInfo);
      }

      ss.addProducer(info);

   }
   return null;
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
public List<AMQConsumer> createConsumer(ConsumerInfo info,
                                        SlowConsumerDetectionListener slowConsumerDetectionListener) throws Exception {
   //check destination
   ActiveMQDestination dest = info.getDestination();
   ActiveMQDestination[] dests = null;
   if (dest.isComposite()) {
      dests = dest.getCompositeDestinations();
   } else {
      dests = new ActiveMQDestination[]{dest};
   }

   List<AMQConsumer> consumersList = new java.util.LinkedList<>();

   for (ActiveMQDestination openWireDest : dests) {
      boolean isInternalAddress = false;
      if (AdvisorySupport.isAdvisoryTopic(dest)) {
         if (!connection.isSuppportAdvisory()) {
            continue;
         }
         isInternalAddress = connection.isSuppressInternalManagementObjects();
      }
      if (openWireDest.isQueue()) {
         SimpleString queueName = new SimpleString(convertWildcard(openWireDest.getPhysicalName()));

         if (!checkAutoCreateQueue(queueName, openWireDest.isTemporary())) {
            throw new InvalidDestinationException("Destination doesn't exist: " + queueName);
         }
      }
      AMQConsumer consumer = new AMQConsumer(this, openWireDest, info, scheduledPool, isInternalAddress);

      long nativeID = consumerIDGenerator.generateID();
      consumer.init(slowConsumerDetectionListener, nativeID);
      consumersList.add(consumer);
   }

   return consumersList;
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
@Override
public Destination addDestination(ConnectionContext context, ActiveMQDestination destination, boolean createIfTemporary) throws Exception {
	if (!AdvisorySupport.isAdvisoryTopic(destination) && zoner.getManager().getZoneId(destination) == null) {
		String pn = zoner.getManager().zoneDestination(context, destination);
		LOG.debug("Zoning destination '{}' to '{}'", destination.getPhysicalName(), pn);
		destination.setPhysicalName(pn);
	}
	return super.addDestination(context, destination, createIfTemporary);
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
/**
 * Provides a hook to allow messages with no consumer to be processed in
 * some way - such as to send to a dead letter queue or something..
 */
protected void onMessageWithNoConsumers(ConnectionContext context, Message msg) throws Exception {
    if (!msg.isPersistent()) {
        if (isSendAdvisoryIfNoConsumers()) {
            // allow messages with no consumers to be dispatched to a dead
            // letter queue
            if (destination.isQueue() || !AdvisorySupport.isAdvisoryTopic(destination)) {

                Message message = msg.copy();
                // The original destination and transaction id do not get
                // filled when the message is first sent,
                // it is only populated if the message is routed to another
                // destination like the DLQ
                if (message.getOriginalDestination() != null) {
                    message.setOriginalDestination(message.getDestination());
                }
                if (message.getOriginalTransactionId() != null) {
                    message.setOriginalTransactionId(message.getTransactionId());
                }

                ActiveMQTopic advisoryTopic;
                if (destination.isQueue()) {
                    advisoryTopic = AdvisorySupport.getNoQueueConsumersAdvisoryTopic(destination);
                } else {
                    advisoryTopic = AdvisorySupport.getNoTopicConsumersAdvisoryTopic(destination);
                }
                message.setDestination(advisoryTopic);
                message.setTransactionId(null);

                // Disable flow control for this since since we don't want
                // to block.
                boolean originalFlowControl = context.isProducerFlowControl();
                try {
                    context.setProducerFlowControl(false);
                    ProducerBrokerExchange producerExchange = new ProducerBrokerExchange();
                    producerExchange.setMutable(false);
                    producerExchange.setConnectionContext(context);
                    producerExchange.setProducerState(new ProducerState(new ProducerInfo()));
                    context.getBroker().send(producerExchange, message);
                } finally {
                    context.setProducerFlowControl(originalFlowControl);
                }

            }
        }
    }
}
 

import org.apache.activemq.advisory.AdvisorySupport; //导入方法依赖的package包/类
public void addConsumer(ConsumerInfo info) throws Exception {
   // Todo: add a destination interceptors holder here (amq supports this)
   SessionId sessionId = info.getConsumerId().getParentId();
   ConnectionId connectionId = sessionId.getParentId();
   ConnectionState cs = getState();
   if (cs == null) {
      throw new IllegalStateException("Cannot add a consumer to a connection that had not been registered: " + connectionId);
   }
   SessionState ss = cs.getSessionState(sessionId);
   if (ss == null) {
      throw new IllegalStateException(server + " Cannot add a consumer to a session that had not been registered: " + sessionId);
   }
   // Avoid replaying dup commands
   if (!ss.getConsumerIds().contains(info.getConsumerId())) {

      AMQSession amqSession = sessions.get(sessionId);
      if (amqSession == null) {
         throw new IllegalStateException("Session not exist! : " + sessionId);
      }

      List<AMQConsumer> consumersList = amqSession.createConsumer(info, new SlowConsumerDetection());
      if (consumersList.size() == 0) {
         return;
      }

      this.addConsumerBrokerExchange(info.getConsumerId(), amqSession, consumersList);
      ss.addConsumer(info);
      amqSession.start();

      if (AdvisorySupport.isAdvisoryTopic(info.getDestination())) {
         //advisory for temp destinations
         if (AdvisorySupport.isTempDestinationAdvisoryTopic(info.getDestination())) {
            // Replay the temporary destinations.
            List<DestinationInfo> tmpDests = this.protocolManager.getTemporaryDestinations();
            for (DestinationInfo di : tmpDests) {
               ActiveMQTopic topic = AdvisorySupport.getDestinationAdvisoryTopic(di.getDestination());
               String originalConnectionId = di.getConnectionId().getValue();
               protocolManager.fireAdvisory(context, topic, di, info.getConsumerId(), originalConnectionId);
            }
         }
      }
   }
}