001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.camel.component.jms;
018
019 import java.util.concurrent.ScheduledExecutorService;
020 import javax.jms.ConnectionFactory;
021 import javax.jms.Destination;
022 import javax.jms.ExceptionListener;
023 import javax.jms.JMSException;
024 import javax.jms.Message;
025 import javax.jms.Queue;
026 import javax.jms.TemporaryQueue;
027 import javax.jms.TemporaryTopic;
028 import javax.jms.Topic;
029
030 import org.apache.camel.Exchange;
031 import org.apache.camel.ExchangePattern;
032 import org.apache.camel.MultipleConsumersSupport;
033 import org.apache.camel.PollingConsumer;
034 import org.apache.camel.Processor;
035 import org.apache.camel.component.jms.requestor.Requestor;
036 import org.apache.camel.impl.DefaultEndpoint;
037 import org.apache.camel.impl.DefaultExchange;
038 import org.apache.camel.spi.HeaderFilterStrategy;
039 import org.apache.camel.spi.HeaderFilterStrategyAware;
040 import org.apache.camel.spi.ManagementAware;
041 import org.springframework.core.task.TaskExecutor;
042 import org.springframework.jms.core.JmsOperations;
043 import org.springframework.jms.listener.AbstractMessageListenerContainer;
044 import org.springframework.jms.support.converter.MessageConverter;
045 import org.springframework.jms.support.destination.DestinationResolver;
046 import org.springframework.jmx.export.annotation.ManagedAttribute;
047 import org.springframework.jmx.export.annotation.ManagedResource;
048 import org.springframework.transaction.PlatformTransactionManager;
049
050 /**
051 * A <a href="http://activemq.apache.org/jms.html">JMS Endpoint</a>
052 *
053 * @version $Revision:520964 $
054 */
055 @ManagedResource(description = "Managed JMS Endpoint")
056 public class JmsEndpoint extends DefaultEndpoint implements HeaderFilterStrategyAware, ManagementAware<JmsEndpoint>, MultipleConsumersSupport {
057 private static final int DEFAULT_THREADPOOL_SIZE = 100;
058
059 private ScheduledExecutorService scheduledExecutorService;
060 private HeaderFilterStrategy headerFilterStrategy;
061 private boolean pubSubDomain;
062 private JmsBinding binding;
063 private String destinationName;
064 private Destination destination;
065 private String selector;
066 private JmsConfiguration configuration;
067 private Requestor requestor;
068
069 public JmsEndpoint() {
070 this(null, null);
071 }
072
073 public JmsEndpoint(Topic destination) throws JMSException {
074 this("jms:topic:" + destination.getTopicName(), null);
075 this.destination = destination;
076 }
077
078 public JmsEndpoint(String uri, JmsComponent component, String destinationName, boolean pubSubDomain, JmsConfiguration configuration) {
079 super(uri, component);
080 this.configuration = configuration;
081 this.destinationName = destinationName;
082 this.pubSubDomain = pubSubDomain;
083 }
084
085 public JmsEndpoint(String endpointUri, JmsBinding binding, JmsConfiguration configuration, String destinationName, boolean pubSubDomain) {
086 super(endpointUri);
087 this.binding = binding;
088 this.configuration = configuration;
089 this.destinationName = destinationName;
090 this.pubSubDomain = pubSubDomain;
091 }
092
093 public JmsEndpoint(String endpointUri, String destinationName, boolean pubSubDomain) {
094 this(endpointUri, null, new JmsConfiguration(), destinationName, pubSubDomain);
095 this.binding = new JmsBinding(this);
096 }
097
098 /**
099 * Creates a pub-sub endpoint with the given destination
100 */
101 public JmsEndpoint(String endpointUri, String destinationName) {
102 this(endpointUri, destinationName, true);
103 }
104
105
106 /**
107 * Returns a new JMS endpoint for the given JMS destination using the configuration from the given JMS component
108 */
109 public static JmsEndpoint newInstance(Destination destination, JmsComponent component) throws JMSException {
110 JmsEndpoint answer = newInstance(destination);
111 JmsConfiguration newConfiguration = component.getConfiguration().copy();
112 answer.setConfiguration(newConfiguration);
113 answer.setCamelContext(component.getCamelContext());
114 return answer;
115 }
116
117 /**
118 * Returns a new JMS endpoint for the given JMS destination
119 */
120 public static JmsEndpoint newInstance(Destination destination) throws JMSException {
121 if (destination instanceof TemporaryQueue) {
122 return new JmsTemporaryQueueEndpoint((TemporaryQueue) destination);
123 } else if (destination instanceof TemporaryTopic) {
124 return new JmsTemporaryTopicEndpoint((TemporaryTopic) destination);
125 } else if (destination instanceof Queue) {
126 return new JmsQueueEndpoint((Queue) destination);
127 } else {
128 return new JmsEndpoint((Topic) destination);
129 }
130 }
131
132 public JmsProducer createProducer() throws Exception {
133 return new JmsProducer(this);
134 }
135
136 public JmsConsumer createConsumer(Processor processor) throws Exception {
137 AbstractMessageListenerContainer listenerContainer = configuration.createMessageListenerContainer(this);
138 return createConsumer(processor, listenerContainer);
139 }
140
141 public AbstractMessageListenerContainer createMessageListenerContainer() {
142 return configuration.createMessageListenerContainer(this);
143 }
144
145 public void configureListenerContainer(AbstractMessageListenerContainer listenerContainer) {
146 if (destinationName != null) {
147 listenerContainer.setDestinationName(destinationName);
148 } else if (destination != null) {
149 listenerContainer.setDestination(destination);
150 } else {
151 DestinationResolver resolver = getDestinationResolver();
152 if (resolver != null) {
153 listenerContainer.setDestinationResolver(resolver);
154 } else {
155 throw new IllegalArgumentException("Neither destination, destinationName or destinationResolver are specified on this endpoint!");
156 }
157 }
158 listenerContainer.setPubSubDomain(pubSubDomain);
159 }
160
161 /**
162 * Creates a consumer using the given processor and listener container
163 *
164 * @param processor the processor to use to process the messages
165 * @param listenerContainer the listener container
166 * @return a newly created consumer
167 * @throws Exception if the consumer cannot be created
168 */
169 public JmsConsumer createConsumer(Processor processor, AbstractMessageListenerContainer listenerContainer) throws Exception {
170 configureListenerContainer(listenerContainer);
171 return new JmsConsumer(this, processor, listenerContainer);
172 }
173
174 @Override
175 public PollingConsumer createPollingConsumer() throws Exception {
176 JmsOperations template = createInOnlyTemplate();
177 return new JmsPollingConsumer(this, template);
178 }
179
180 @Override
181 public Exchange createExchange(ExchangePattern pattern) {
182 Exchange exchange = new DefaultExchange(this, pattern);
183 exchange.setProperty(Exchange.BINDING, getBinding());
184 return exchange;
185 }
186
187 public Exchange createExchange(Message message) {
188 Exchange exchange = createExchange(getExchangePattern());
189 exchange.setIn(new JmsMessage(message, getBinding()));
190 return exchange;
191 }
192
193 /**
194 * Factory method for creating a new template for InOnly message exchanges
195 */
196 public JmsOperations createInOnlyTemplate() {
197 return configuration.createInOnlyTemplate(this, pubSubDomain, destinationName);
198 }
199
200 /**
201 * Factory method for creating a new template for InOut message exchanges
202 */
203 public JmsOperations createInOutTemplate() {
204 return configuration.createInOutTemplate(this, pubSubDomain, destinationName, configuration.getRequestTimeout());
205 }
206
207 public Object getManagedObject(JmsEndpoint endpoint) {
208 return this;
209 }
210
211 public boolean isMultipleConsumersSupported() {
212 // only allow multiple consumers for pub sub domain (e.g. topics)
213 return isPubSubDomain();
214 }
215
216 // Properties
217 // -------------------------------------------------------------------------
218 public HeaderFilterStrategy getHeaderFilterStrategy() {
219 if (headerFilterStrategy == null) {
220 headerFilterStrategy = new JmsHeaderFilterStrategy();
221 }
222 return headerFilterStrategy;
223 }
224
225 public void setHeaderFilterStrategy(HeaderFilterStrategy strategy) {
226 this.headerFilterStrategy = strategy;
227 }
228
229 public JmsBinding getBinding() {
230 if (binding == null) {
231 binding = new JmsBinding(this);
232 }
233 return binding;
234 }
235
236 /**
237 * Sets the binding used to convert from a Camel message to and from a JMS
238 * message
239 *
240 * @param binding the binding to use
241 */
242 public void setBinding(JmsBinding binding) {
243 this.binding = binding;
244 }
245
246 public String getDestinationName() {
247 return destinationName;
248 }
249
250 public void setDestinationName(String destinationName) {
251 this.destinationName = destinationName;
252 }
253
254 public Destination getDestination() {
255 return destination;
256 }
257
258 /**
259 * Allows a specific JMS Destination object to be used as the destination
260 */
261 public void setDestination(Destination destination) {
262 this.destination = destination;
263 }
264
265 public JmsConfiguration getConfiguration() {
266 return configuration;
267 }
268
269 public void setConfiguration(JmsConfiguration configuration) {
270 this.configuration = configuration;
271 }
272
273 public String getSelector() {
274 return selector;
275 }
276
277 /**
278 * Sets the JMS selector to use
279 */
280 public void setSelector(String selector) {
281 this.selector = selector;
282 }
283
284 @ManagedAttribute
285 public boolean isSingleton() {
286 return true;
287 }
288
289 public synchronized Requestor getRequestor() throws Exception {
290 if (requestor == null) {
291 requestor = new Requestor(getConfiguration(), getScheduledExecutorService());
292 requestor.start();
293 }
294 return requestor;
295 }
296
297 public void setRequestor(Requestor requestor) {
298 this.requestor = requestor;
299 }
300
301 public synchronized ScheduledExecutorService getScheduledExecutorService() {
302 if (scheduledExecutorService == null) {
303 scheduledExecutorService = getCamelContext().getExecutorServiceStrategy()
304 .newScheduledThreadPool(this, getEndpointUri(), DEFAULT_THREADPOOL_SIZE);
305 }
306 return scheduledExecutorService;
307 }
308
309 public void setScheduledExecutorService(ScheduledExecutorService scheduledExecutorService) {
310 this.scheduledExecutorService = scheduledExecutorService;
311 }
312
313 public boolean isPubSubDomain() {
314 return pubSubDomain;
315 }
316
317 /**
318 * Lazily loads the temporary queue type if one has not been explicitly configured
319 * via calling the {@link JmsProviderMetadata#setTemporaryQueueType(Class)}
320 * on the {@link #getConfiguration()} instance
321 */
322 public Class<? extends TemporaryQueue> getTemporaryQueueType() {
323 JmsProviderMetadata metadata = getProviderMetadata();
324 JmsOperations template = getMetadataJmsOperations();
325 return metadata.getTemporaryQueueType(template);
326 }
327
328 /**
329 * Lazily loads the temporary topic type if one has not been explicitly configured
330 * via calling the {@link JmsProviderMetadata#setTemporaryTopicType(Class)}
331 * on the {@link #getConfiguration()} instance
332 */
333 public Class<? extends TemporaryTopic> getTemporaryTopicType() {
334 JmsOperations template = getMetadataJmsOperations();
335 JmsProviderMetadata metadata = getProviderMetadata();
336 return metadata.getTemporaryTopicType(template);
337 }
338
339 /**
340 * Returns the provider metadata
341 */
342 protected JmsProviderMetadata getProviderMetadata() {
343 JmsConfiguration conf = getConfiguration();
344 JmsProviderMetadata metadata = conf.getProviderMetadata();
345 return metadata;
346 }
347
348
349 /**
350 * Returns the {@link JmsOperations} used for metadata operations such as creating temporary destinations
351 */
352 protected JmsOperations getMetadataJmsOperations() {
353 JmsOperations template = getConfiguration().getMetadataJmsOperations(this);
354 if (template == null) {
355 throw new IllegalArgumentException("No Metadata JmsTemplate supplied!");
356 }
357 return template;
358 }
359
360 // Delegated properties from the configuration
361 //-------------------------------------------------------------------------
362 @ManagedAttribute
363 public int getAcknowledgementMode() {
364 return getConfiguration().getAcknowledgementMode();
365 }
366
367 @ManagedAttribute
368 public String getAcknowledgementModeName() {
369 return getConfiguration().getAcknowledgementModeName();
370 }
371
372 @ManagedAttribute
373 public int getCacheLevel() {
374 return getConfiguration().getCacheLevel();
375 }
376
377 @ManagedAttribute
378 public String getCacheLevelName() {
379 return getConfiguration().getCacheLevelName();
380 }
381
382 @ManagedAttribute
383 public String getClientId() {
384 return getConfiguration().getClientId();
385 }
386
387 @ManagedAttribute
388 public int getConcurrentConsumers() {
389 return getConfiguration().getConcurrentConsumers();
390 }
391
392 public ConnectionFactory getConnectionFactory() {
393 return getConfiguration().getConnectionFactory();
394 }
395
396 public ConsumerType getConsumerType() {
397 return getConfiguration().getConsumerType();
398 }
399
400 public DestinationResolver getDestinationResolver() {
401 return getConfiguration().getDestinationResolver();
402 }
403
404 @ManagedAttribute
405 public String getDurableSubscriptionName() {
406 return getConfiguration().getDurableSubscriptionName();
407 }
408
409 public ExceptionListener getExceptionListener() {
410 return getConfiguration().getExceptionListener();
411 }
412
413 @ManagedAttribute
414 public int getIdleTaskExecutionLimit() {
415 return getConfiguration().getIdleTaskExecutionLimit();
416 }
417
418 public JmsOperations getJmsOperations() {
419 return getConfiguration().getJmsOperations();
420 }
421
422 public ConnectionFactory getListenerConnectionFactory() {
423 return getConfiguration().getListenerConnectionFactory();
424 }
425
426 @ManagedAttribute
427 public int getMaxConcurrentConsumers() {
428 return getConfiguration().getMaxConcurrentConsumers();
429 }
430
431 @ManagedAttribute
432 public int getMaxMessagesPerTask() {
433 return getConfiguration().getMaxMessagesPerTask();
434 }
435
436 public MessageConverter getMessageConverter() {
437 return getConfiguration().getMessageConverter();
438 }
439
440 public JmsOperations getMetadataJmsOperations(JmsEndpoint endpoint) {
441 return getConfiguration().getMetadataJmsOperations(endpoint);
442 }
443
444 @ManagedAttribute
445 public int getPriority() {
446 return getConfiguration().getPriority();
447 }
448
449 @ManagedAttribute
450 public long getReceiveTimeout() {
451 return getConfiguration().getReceiveTimeout();
452 }
453
454 @ManagedAttribute
455 public long getRecoveryInterval() {
456 return getConfiguration().getRecoveryInterval();
457 }
458
459 @ManagedAttribute
460 public String getReplyTo() {
461 return getConfiguration().getReplyTo();
462 }
463
464 @ManagedAttribute
465 public String getReplyToDestinationSelectorName() {
466 return getConfiguration().getReplyToDestinationSelectorName();
467 }
468
469 public String getReplyToTempDestinationAffinity() {
470 return getConfiguration().getReplyToTempDestinationAffinity();
471 }
472
473 public long getRequestMapPurgePollTimeMillis() {
474 return getConfiguration().getRequestMapPurgePollTimeMillis();
475 }
476
477 @ManagedAttribute
478 public long getRequestTimeout() {
479 return getConfiguration().getRequestTimeout();
480 }
481
482 public TaskExecutor getTaskExecutor() {
483 return getConfiguration().getTaskExecutor();
484 }
485
486 public ConnectionFactory getTemplateConnectionFactory() {
487 return getConfiguration().getTemplateConnectionFactory();
488 }
489
490 @ManagedAttribute
491 public long getTimeToLive() {
492 return getConfiguration().getTimeToLive();
493 }
494
495 public PlatformTransactionManager getTransactionManager() {
496 return getConfiguration().getTransactionManager();
497 }
498
499 @ManagedAttribute
500 public String getTransactionName() {
501 return getConfiguration().getTransactionName();
502 }
503
504 @ManagedAttribute
505 public int getTransactionTimeout() {
506 return getConfiguration().getTransactionTimeout();
507 }
508
509 @ManagedAttribute
510 public boolean isAcceptMessagesWhileStopping() {
511 return getConfiguration().isAcceptMessagesWhileStopping();
512 }
513
514 @ManagedAttribute
515 public boolean isAlwaysCopyMessage() {
516 return getConfiguration().isAlwaysCopyMessage();
517 }
518
519 @ManagedAttribute
520 public boolean isAutoStartup() {
521 return getConfiguration().isAutoStartup();
522 }
523
524 @ManagedAttribute
525 public boolean isDeliveryPersistent() {
526 return getConfiguration().isDeliveryPersistent();
527 }
528
529 @ManagedAttribute
530 public boolean isDisableReplyTo() {
531 return getConfiguration().isDisableReplyTo();
532 }
533
534 @ManagedAttribute
535 public boolean isEagerLoadingOfProperties() {
536 return getConfiguration().isEagerLoadingOfProperties();
537 }
538
539 @ManagedAttribute
540 public boolean isExplicitQosEnabled() {
541 return getConfiguration().isExplicitQosEnabled();
542 }
543
544 @ManagedAttribute
545 public boolean isExposeListenerSession() {
546 return getConfiguration().isExposeListenerSession();
547 }
548
549 @ManagedAttribute
550 public boolean isMessageIdEnabled() {
551 return getConfiguration().isMessageIdEnabled();
552 }
553
554 @ManagedAttribute
555 public boolean isMessageTimestampEnabled() {
556 return getConfiguration().isMessageTimestampEnabled();
557 }
558
559 @ManagedAttribute
560 public boolean isPreserveMessageQos() {
561 return getConfiguration().isPreserveMessageQos();
562 }
563
564 @ManagedAttribute
565 public boolean isPubSubNoLocal() {
566 return getConfiguration().isPubSubNoLocal();
567 }
568
569 @ManagedAttribute
570 public boolean isReplyToDeliveryPersistent() {
571 return getConfiguration().isReplyToDeliveryPersistent();
572 }
573
574 @ManagedAttribute
575 public boolean isSubscriptionDurable() {
576 return getConfiguration().isSubscriptionDurable();
577 }
578
579 @ManagedAttribute
580 public boolean isTransacted() {
581 return getConfiguration().isTransacted();
582 }
583
584 @ManagedAttribute
585 public boolean isTransactedInOut() {
586 return getConfiguration().isTransactedInOut();
587 }
588
589 @ManagedAttribute
590 public boolean isUseMessageIDAsCorrelationID() {
591 return getConfiguration().isUseMessageIDAsCorrelationID();
592 }
593
594 /**
595 * @deprecated will be removed in Camel 2.2
596 */
597 @Deprecated
598 public boolean isUseVersion102() {
599 return getConfiguration().isUseVersion102();
600 }
601
602 @ManagedAttribute
603 public void setAcceptMessagesWhileStopping(boolean acceptMessagesWhileStopping) {
604 getConfiguration().setAcceptMessagesWhileStopping(acceptMessagesWhileStopping);
605 }
606
607 @ManagedAttribute
608 public void setAcknowledgementMode(int consumerAcknowledgementMode) {
609 getConfiguration().setAcknowledgementMode(consumerAcknowledgementMode);
610 }
611
612 @ManagedAttribute
613 public void setAcknowledgementModeName(String consumerAcknowledgementMode) {
614 getConfiguration().setAcknowledgementModeName(consumerAcknowledgementMode);
615 }
616
617 @ManagedAttribute
618 public void setAlwaysCopyMessage(boolean alwaysCopyMessage) {
619 getConfiguration().setAlwaysCopyMessage(alwaysCopyMessage);
620 }
621
622 @ManagedAttribute
623 public void setAutoStartup(boolean autoStartup) {
624 getConfiguration().setAutoStartup(autoStartup);
625 }
626
627 @ManagedAttribute
628 public void setCacheLevel(int cacheLevel) {
629 getConfiguration().setCacheLevel(cacheLevel);
630 }
631
632 @ManagedAttribute
633 public void setCacheLevelName(String cacheName) {
634 getConfiguration().setCacheLevelName(cacheName);
635 }
636
637 @ManagedAttribute
638 public void setClientId(String consumerClientId) {
639 getConfiguration().setClientId(consumerClientId);
640 }
641
642 @ManagedAttribute
643 public void setConcurrentConsumers(int concurrentConsumers) {
644 getConfiguration().setConcurrentConsumers(concurrentConsumers);
645 }
646
647 public void setConnectionFactory(ConnectionFactory connectionFactory) {
648 getConfiguration().setConnectionFactory(connectionFactory);
649 }
650
651 public void setConsumerType(ConsumerType consumerType) {
652 getConfiguration().setConsumerType(consumerType);
653 }
654
655 @ManagedAttribute
656 public void setDeliveryPersistent(boolean deliveryPersistent) {
657 getConfiguration().setDeliveryPersistent(deliveryPersistent);
658 }
659
660 public void setDestinationResolver(DestinationResolver destinationResolver) {
661 getConfiguration().setDestinationResolver(destinationResolver);
662 }
663
664 @ManagedAttribute
665 public void setDisableReplyTo(boolean disableReplyTo) {
666 getConfiguration().setDisableReplyTo(disableReplyTo);
667 }
668
669 @ManagedAttribute
670 public void setDurableSubscriptionName(String durableSubscriptionName) {
671 getConfiguration().setDurableSubscriptionName(durableSubscriptionName);
672 }
673
674 @ManagedAttribute
675 public void setEagerLoadingOfProperties(boolean eagerLoadingOfProperties) {
676 getConfiguration().setEagerLoadingOfProperties(eagerLoadingOfProperties);
677 }
678
679 public void setExceptionListener(ExceptionListener exceptionListener) {
680 getConfiguration().setExceptionListener(exceptionListener);
681 }
682
683 @ManagedAttribute
684 public void setExplicitQosEnabled(boolean explicitQosEnabled) {
685 getConfiguration().setExplicitQosEnabled(explicitQosEnabled);
686 }
687
688 @ManagedAttribute
689 public void setExposeListenerSession(boolean exposeListenerSession) {
690 getConfiguration().setExposeListenerSession(exposeListenerSession);
691 }
692
693 @ManagedAttribute
694 public void setIdleTaskExecutionLimit(int idleTaskExecutionLimit) {
695 getConfiguration().setIdleTaskExecutionLimit(idleTaskExecutionLimit);
696 }
697
698 public void setJmsOperations(JmsOperations jmsOperations) {
699 getConfiguration().setJmsOperations(jmsOperations);
700 }
701
702 public void setListenerConnectionFactory(ConnectionFactory listenerConnectionFactory) {
703 getConfiguration().setListenerConnectionFactory(listenerConnectionFactory);
704 }
705
706 @ManagedAttribute
707 public void setMaxConcurrentConsumers(int maxConcurrentConsumers) {
708 getConfiguration().setMaxConcurrentConsumers(maxConcurrentConsumers);
709 }
710
711 @ManagedAttribute
712 public void setMaxMessagesPerTask(int maxMessagesPerTask) {
713 getConfiguration().setMaxMessagesPerTask(maxMessagesPerTask);
714 }
715
716 public void setMessageConverter(MessageConverter messageConverter) {
717 getConfiguration().setMessageConverter(messageConverter);
718 }
719
720 @ManagedAttribute
721 public void setMessageIdEnabled(boolean messageIdEnabled) {
722 getConfiguration().setMessageIdEnabled(messageIdEnabled);
723 }
724
725 @ManagedAttribute
726 public void setMessageTimestampEnabled(boolean messageTimestampEnabled) {
727 getConfiguration().setMessageTimestampEnabled(messageTimestampEnabled);
728 }
729
730 public void setMetadataJmsOperations(JmsOperations metadataJmsOperations) {
731 getConfiguration().setMetadataJmsOperations(metadataJmsOperations);
732 }
733
734 @ManagedAttribute
735 public void setPreserveMessageQos(boolean preserveMessageQos) {
736 getConfiguration().setPreserveMessageQos(preserveMessageQos);
737 }
738
739 @ManagedAttribute
740 public void setPriority(int priority) {
741 getConfiguration().setPriority(priority);
742 }
743
744 public void setProviderMetadata(JmsProviderMetadata providerMetadata) {
745 getConfiguration().setProviderMetadata(providerMetadata);
746 }
747
748 @ManagedAttribute
749 public void setPubSubNoLocal(boolean pubSubNoLocal) {
750 getConfiguration().setPubSubNoLocal(pubSubNoLocal);
751 }
752
753 @ManagedAttribute
754 public void setReceiveTimeout(long receiveTimeout) {
755 getConfiguration().setReceiveTimeout(receiveTimeout);
756 }
757
758 @ManagedAttribute
759 public void setRecoveryInterval(long recoveryInterval) {
760 getConfiguration().setRecoveryInterval(recoveryInterval);
761 }
762
763 @ManagedAttribute
764 public void setReplyTo(String replyToDestination) {
765 getConfiguration().setReplyTo(replyToDestination);
766 }
767
768 @ManagedAttribute
769 public void setReplyToDeliveryPersistent(boolean replyToDeliveryPersistent) {
770 getConfiguration().setReplyToDeliveryPersistent(replyToDeliveryPersistent);
771 }
772
773 @ManagedAttribute
774 public void setReplyToDestinationSelectorName(String replyToDestinationSelectorName) {
775 getConfiguration().setReplyToDestinationSelectorName(replyToDestinationSelectorName);
776 }
777
778 public void setReplyToTempDestinationAffinity(String replyToTempDestinationAffinity) {
779 getConfiguration().setReplyToTempDestinationAffinity(replyToTempDestinationAffinity);
780 }
781
782 public void setRequestMapPurgePollTimeMillis(long requestMapPurgePollTimeMillis) {
783 getConfiguration().setRequestMapPurgePollTimeMillis(requestMapPurgePollTimeMillis);
784 }
785
786 @ManagedAttribute
787 public void setRequestTimeout(long requestTimeout) {
788 getConfiguration().setRequestTimeout(requestTimeout);
789 }
790
791 @ManagedAttribute
792 public void setSubscriptionDurable(boolean subscriptionDurable) {
793 getConfiguration().setSubscriptionDurable(subscriptionDurable);
794 }
795
796 public void setTaskExecutor(TaskExecutor taskExecutor) {
797 getConfiguration().setTaskExecutor(taskExecutor);
798 }
799
800 public void setTemplateConnectionFactory(ConnectionFactory templateConnectionFactory) {
801 getConfiguration().setTemplateConnectionFactory(templateConnectionFactory);
802 }
803
804 @ManagedAttribute
805 public void setTimeToLive(long timeToLive) {
806 getConfiguration().setTimeToLive(timeToLive);
807 }
808
809 @ManagedAttribute
810 public void setTransacted(boolean consumerTransacted) {
811 getConfiguration().setTransacted(consumerTransacted);
812 }
813
814 @ManagedAttribute
815 public void setTransactedInOut(boolean transactedInOut) {
816 getConfiguration().setTransactedInOut(transactedInOut);
817 }
818
819 public void setTransactionManager(PlatformTransactionManager transactionManager) {
820 getConfiguration().setTransactionManager(transactionManager);
821 }
822
823 @ManagedAttribute
824 public void setTransactionName(String transactionName) {
825 getConfiguration().setTransactionName(transactionName);
826 }
827
828 @ManagedAttribute
829 public void setTransactionTimeout(int transactionTimeout) {
830 getConfiguration().setTransactionTimeout(transactionTimeout);
831 }
832
833 @ManagedAttribute
834 public void setUseMessageIDAsCorrelationID(boolean useMessageIDAsCorrelationID) {
835 getConfiguration().setUseMessageIDAsCorrelationID(useMessageIDAsCorrelationID);
836 }
837
838 /**
839 * @deprecated will be removed in Camel 2.2
840 */
841 @Deprecated
842 public void setUseVersion102(boolean useVersion102) {
843 getConfiguration().setUseVersion102(useVersion102);
844 }
845
846 public JmsMessageType getJmsMessageType() {
847 return getConfiguration().getJmsMessageType();
848 }
849
850 public void setJmsMessageType(JmsMessageType jmsMessageType) {
851 getConfiguration().setJmsMessageType(jmsMessageType);
852 }
853
854 public JmsKeyFormatStrategy getJmsKeyFormatStrategy() {
855 return getConfiguration().getJmsKeyFormatStrategy();
856 }
857
858 public void setJmsKeyFormatStrategy(JmsKeyFormatStrategy jmsHeaderStrategy) {
859 getConfiguration().setJmsKeyFormatStrategy(jmsHeaderStrategy);
860 }
861
862 @ManagedAttribute
863 public boolean isTransferExchange() {
864 return getConfiguration().isTransferExchange();
865 }
866
867 @ManagedAttribute
868 public void setTransferExchange(boolean transferExchange) {
869 getConfiguration().setTransferExchange(transferExchange);
870 }
871
872 @ManagedAttribute
873 public boolean isTransferException() {
874 return getConfiguration().isTransferException();
875 }
876
877 @ManagedAttribute
878 public void setTransferException(boolean transferException) {
879 getConfiguration().setTransferException(transferException);
880 }
881
882 @ManagedAttribute
883 public boolean isTestConnectionOnStartup() {
884 return configuration.isTestConnectionOnStartup();
885 }
886
887 @ManagedAttribute
888 public void setTestConnectionOnStartup(boolean testConnectionOnStartup) {
889 configuration.setTestConnectionOnStartup(testConnectionOnStartup);
890 }
891
892 @ManagedAttribute(description = "Camel id")
893 public String getCamelId() {
894 return getCamelContext().getName();
895 }
896
897 @ManagedAttribute(description = "Endpoint Uri")
898 @Override
899 public String getEndpointUri() {
900 return super.getEndpointUri();
901 }
902
903 // Implementation methods
904 //-------------------------------------------------------------------------
905
906 @Override
907 protected String createEndpointUri() {
908 String scheme = "jms";
909 if (destination != null) {
910 return scheme + ":" + destination;
911 } else if (destinationName != null) {
912 return scheme + ":" + destinationName;
913 }
914 DestinationResolver resolver = getDestinationResolver();
915 if (resolver != null) {
916 return scheme + ":" + resolver;
917 }
918 return super.createEndpointUri();
919 }
920
921 }