@Override public Destination intercept(Destination destination) { return selectorAware ? new SelectorAwareVirtualTopicInterceptor(destination, this) : new VirtualTopicInterceptor(destination, this); }
@Override public Destination intercept(Destination destination) { return new CompositeDestinationFilter(destination, getForwardTo(), isForwardOnly(), isConcurrentSend()); }
public VirtualTopicInterceptor(Destination next, VirtualTopic virtualTopic) { super(next); this.prefix = virtualTopic.getPrefix(); this.postfix = virtualTopic.getPostfix(); this.local = virtualTopic.isLocal(); this.concurrentSend = virtualTopic.isConcurrentSend(); this.transactedSend = virtualTopic.isTransactedSend(); this.dropMessageOnResourceLimit = virtualTopic.isDropOnResourceLimit(); this.setOriginalDestination = virtualTopic.isSetOriginalDestination(); }
/** * Create the default destination interceptor */ protected DestinationInterceptor[] createDefaultDestinationInterceptor() { List<DestinationInterceptor> answer = new ArrayList<>(); if (isUseVirtualTopics()) { VirtualDestinationInterceptor interceptor = new VirtualDestinationInterceptor(); VirtualTopic virtualTopic = new VirtualTopic(); virtualTopic.setName("VirtualTopic.>"); VirtualDestination[] virtualDestinations = { virtualTopic }; interceptor.setVirtualDestinations(virtualDestinations); answer.add(interceptor); } if (isUseMirroredQueues()) { MirroredQueue interceptor = new MirroredQueue(); answer.add(interceptor); } DestinationInterceptor[] array = new DestinationInterceptor[answer.size()]; answer.toArray(array); return array; }
@Override public Destination interceptMappedDestination(Destination destination) { if (!isForwardOnly() && destination.getActiveMQDestination().isQueue()) { // recover retroactive messages in mapped Queue return new MappedQueueFilter(getVirtualDestination(), destination); } return destination; }
@Override public void send(ProducerBrokerExchange context, Message message) throws Exception { if (!message.isAdvisory() && !(local && message.getBrokerPath() != null)) { ActiveMQDestination queueConsumers = getQueueConsumersWildcard(message.getDestination()); send(context, message, queueConsumers); } super.send(context, message); }
public void setVirtualDestinations(VirtualDestination[] virtualDestinations) { destinationMap = new DestinationMap(); mappedDestinationMap = new DestinationMap(); this.virtualDestinations = virtualDestinations; for (int i = 0; i < virtualDestinations.length; i++) { VirtualDestination virtualDestination = virtualDestinations[i]; destinationMap.put(virtualDestination.getVirtualDestination(), virtualDestination); mappedDestinationMap.put(virtualDestination.getMappedDestinations(), virtualDestination); } }
@Override public boolean matches(VirtualDestination virtualDestination, ActiveMQDestination activeMQDest) { if (virtualDestination instanceof CompositeDestination) { DestinationFilter filter = DestinationFilter.parseFilter(virtualDestination.getMappedDestinations()); if (filter.matches(activeMQDest)) { return true; } } else if (virtualDestination instanceof VirtualTopic) { DestinationFilter filter = DestinationFilter.parseFilter(new ActiveMQQueue(((VirtualTopic) virtualDestination).getPrefix() + DestinationFilter.ANY_DESCENDENT)); if (filter.matches(activeMQDest)) { return true; } } return false; }
@Override public Destination interceptMappedDestination(Destination destination) { // do a reverse map from destination to get actual virtual destination final String physicalName = destination.getActiveMQDestination().getPhysicalName(); final Pattern pattern = Pattern.compile(getRegex(prefix) + "(.*)" + getRegex(postfix)); final Matcher matcher = pattern.matcher(physicalName); if (matcher.matches()) { final String virtualName = matcher.group(1); return new MappedQueueFilter(new ActiveMQTopic(virtualName), destination); } return destination; }
@Override public String toString() { return "CompositeTopic [" + getName() + "]"; } }
@Override public String toString() { return "CompositeQueue [" + getName() + "]"; } }
/** * Sets the destination property to the given queue name */ public void setQueue(String queue) { setDestination(ActiveMQDestination.createDestination(queue, ActiveMQDestination.QUEUE_TYPE)); }
@Override public void create(Broker broker, ConnectionContext context, ActiveMQDestination destination) throws Exception { for (VirtualDestination virt : virtualDestinations) { virt.create(broker, context, destination); } }
public boolean matches(MessageEvaluationContext context) throws JMSException { BooleanExpression booleanExpression = getFilter(); if (booleanExpression == null) { return false; } return booleanExpression.matches(context); }
/** * Sets the JMS selector used to filter messages before forwarding them to this destination */ public void setSelector(String selector) throws InvalidSelectorException { this.selector = selector; setFilter(SelectorParser.parse(selector)); }
@Override public ActiveMQDestination getVirtualDestination() { return new ActiveMQTopic(getName()); }
private BooleanExpression getExpression(String selector) throws Exception{ BooleanExpression result; synchronized(expressionCache){ result = expressionCache.get(selector); if (result == null){ result = compileSelector(selector); expressionCache.put(selector,result); } } return result; }
@Override public ActiveMQDestination getVirtualDestination() { return new ActiveMQTopic(getName()); }
@Override public ActiveMQDestination getVirtualDestination() { return new ActiveMQQueue(getName()); }
/** * Sets the destination property to the given topic name */ public void setTopic(String topic) { setDestination(ActiveMQDestination.createDestination(topic, ActiveMQDestination.TOPIC_TYPE)); }