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.activemq.broker.region.policy;
018    
019    import org.apache.activemq.ActiveMQPrefetchPolicy;
020    import org.apache.activemq.broker.Broker;
021    import org.apache.activemq.broker.region.BaseDestination;
022    import org.apache.activemq.broker.region.Destination;
023    import org.apache.activemq.broker.region.DurableTopicSubscription;
024    import org.apache.activemq.broker.region.Queue;
025    import org.apache.activemq.broker.region.QueueBrowserSubscription;
026    import org.apache.activemq.broker.region.QueueSubscription;
027    import org.apache.activemq.broker.region.Topic;
028    import org.apache.activemq.broker.region.TopicSubscription;
029    import org.apache.activemq.broker.region.cursors.PendingMessageCursor;
030    import org.apache.activemq.broker.region.group.MessageGroupHashBucketFactory;
031    import org.apache.activemq.broker.region.group.MessageGroupMapFactory;
032    import org.apache.activemq.filter.DestinationMapEntry;
033    import org.apache.activemq.usage.SystemUsage;
034    import org.slf4j.Logger;
035    import org.slf4j.LoggerFactory;
036    
037    /**
038     * Represents an entry in a {@link PolicyMap} for assigning policies to a
039     * specific destination or a hierarchical wildcard area of destinations.
040     * 
041     * @org.apache.xbean.XBean
042     * 
043     */
044    public class PolicyEntry extends DestinationMapEntry {
045    
046        private static final Logger LOG = LoggerFactory.getLogger(PolicyEntry.class);
047        private DispatchPolicy dispatchPolicy;
048        private SubscriptionRecoveryPolicy subscriptionRecoveryPolicy;
049        private boolean sendAdvisoryIfNoConsumers;
050        private DeadLetterStrategy deadLetterStrategy = Destination.DEFAULT_DEAD_LETTER_STRATEGY;
051        private PendingMessageLimitStrategy pendingMessageLimitStrategy;
052        private MessageEvictionStrategy messageEvictionStrategy;
053        private long memoryLimit;
054        private MessageGroupMapFactory messageGroupMapFactory;
055        private PendingQueueMessageStoragePolicy pendingQueuePolicy;
056        private PendingDurableSubscriberMessageStoragePolicy pendingDurableSubscriberPolicy;
057        private PendingSubscriberMessageStoragePolicy pendingSubscriberPolicy;
058        private int maxProducersToAudit=BaseDestination.MAX_PRODUCERS_TO_AUDIT;
059        private int maxAuditDepth=BaseDestination.MAX_AUDIT_DEPTH;
060        private int maxQueueAuditDepth=BaseDestination.MAX_AUDIT_DEPTH;
061        private boolean enableAudit=true;
062        private boolean producerFlowControl = true;
063        private long blockedProducerWarningInterval = Destination.DEFAULT_BLOCKED_PRODUCER_WARNING_INTERVAL;
064        private boolean optimizedDispatch=false;
065        private int maxPageSize=BaseDestination.MAX_PAGE_SIZE;
066        private int maxBrowsePageSize=BaseDestination.MAX_BROWSE_PAGE_SIZE;
067        private boolean useCache=true;
068        private long minimumMessageSize=1024;
069        private boolean useConsumerPriority=true;
070        private boolean strictOrderDispatch=false;
071        private boolean lazyDispatch=false;
072        private int timeBeforeDispatchStarts = 0;
073        private int consumersBeforeDispatchStarts = 0;
074        private boolean advisoryForSlowConsumers;
075        private boolean advisdoryForFastProducers;
076        private boolean advisoryForDiscardingMessages;
077        private boolean advisoryWhenFull;
078        private boolean advisoryForDelivery;
079        private boolean advisoryForConsumed;
080        private long expireMessagesPeriod = BaseDestination.EXPIRE_MESSAGE_PERIOD;
081        private int maxExpirePageSize = BaseDestination.MAX_BROWSE_PAGE_SIZE;
082        private int queuePrefetch=ActiveMQPrefetchPolicy.DEFAULT_QUEUE_PREFETCH;
083        private int queueBrowserPrefetch=ActiveMQPrefetchPolicy.DEFAULT_QUEUE_BROWSER_PREFETCH;
084        private int topicPrefetch=ActiveMQPrefetchPolicy.DEFAULT_TOPIC_PREFETCH;
085        private int durableTopicPrefetch=ActiveMQPrefetchPolicy.DEFAULT_DURABLE_TOPIC_PREFETCH;
086        private boolean usePrefetchExtension = true;
087        private int cursorMemoryHighWaterMark = 70;
088        private int storeUsageHighWaterMark = 100;
089        private SlowConsumerStrategy slowConsumerStrategy;
090        private boolean prioritizedMessages;
091        private boolean allConsumersExclusiveByDefault;
092        private boolean gcInactiveDestinations;
093        private long inactiveTimoutBeforeGC = BaseDestination.DEFAULT_INACTIVE_TIMEOUT_BEFORE_GC;
094        private boolean reduceMemoryFootprint;
095        
096       
097        public void configure(Broker broker,Queue queue) {
098            baseConfiguration(broker,queue);
099            if (dispatchPolicy != null) {
100                queue.setDispatchPolicy(dispatchPolicy);
101            }
102            queue.setDeadLetterStrategy(getDeadLetterStrategy());
103            queue.setMessageGroupMapFactory(getMessageGroupMapFactory());
104            if (memoryLimit > 0) {
105                queue.getMemoryUsage().setLimit(memoryLimit);
106            }
107            if (pendingQueuePolicy != null) {
108                PendingMessageCursor messages = pendingQueuePolicy.getQueuePendingMessageCursor(broker,queue);
109                queue.setMessages(messages);
110            }
111            
112            queue.setUseConsumerPriority(isUseConsumerPriority());
113            queue.setStrictOrderDispatch(isStrictOrderDispatch());
114            queue.setOptimizedDispatch(isOptimizedDispatch());
115            queue.setLazyDispatch(isLazyDispatch());
116            queue.setTimeBeforeDispatchStarts(getTimeBeforeDispatchStarts());
117            queue.setConsumersBeforeDispatchStarts(getConsumersBeforeDispatchStarts());
118            queue.setAllConsumersExclusiveByDefault(isAllConsumersExclusiveByDefault());
119        }
120    
121        public void configure(Broker broker,Topic topic) {
122            baseConfiguration(broker,topic);
123            if (dispatchPolicy != null) {
124                topic.setDispatchPolicy(dispatchPolicy);
125            }
126            topic.setDeadLetterStrategy(getDeadLetterStrategy());
127            if (subscriptionRecoveryPolicy != null) {
128                SubscriptionRecoveryPolicy srp = subscriptionRecoveryPolicy.copy();
129                srp.setBroker(broker);
130                topic.setSubscriptionRecoveryPolicy(srp);
131            }
132            if (memoryLimit > 0) {
133                topic.getMemoryUsage().setLimit(memoryLimit);
134            }
135            topic.setLazyDispatch(isLazyDispatch());
136        }
137        
138        public void baseConfiguration(Broker broker,BaseDestination destination) {
139            destination.setProducerFlowControl(isProducerFlowControl());
140            destination.setBlockedProducerWarningInterval(getBlockedProducerWarningInterval());
141            destination.setEnableAudit(isEnableAudit());
142            destination.setMaxAuditDepth(getMaxQueueAuditDepth());
143            destination.setMaxProducersToAudit(getMaxProducersToAudit());
144            destination.setMaxPageSize(getMaxPageSize());
145            destination.setMaxBrowsePageSize(getMaxBrowsePageSize());
146            destination.setUseCache(isUseCache());
147            destination.setMinimumMessageSize((int) getMinimumMessageSize());
148            destination.setAdvisoryForConsumed(isAdvisoryForConsumed());
149            destination.setAdvisoryForDelivery(isAdvisoryForDelivery());
150            destination.setAdvisoryForDiscardingMessages(isAdvisoryForDiscardingMessages());
151            destination.setAdvisoryForSlowConsumers(isAdvisoryForSlowConsumers());
152            destination.setAdvisdoryForFastProducers(isAdvisdoryForFastProducers());
153            destination.setAdvisoryWhenFull(isAdvisoryWhenFull());
154            destination.setSendAdvisoryIfNoConsumers(sendAdvisoryIfNoConsumers);
155            destination.setExpireMessagesPeriod(getExpireMessagesPeriod());
156            destination.setMaxExpirePageSize(getMaxExpirePageSize());
157            destination.setCursorMemoryHighWaterMark(getCursorMemoryHighWaterMark());
158            destination.setStoreUsageHighWaterMark(getStoreUsageHighWaterMark());
159            SlowConsumerStrategy scs = getSlowConsumerStrategy();
160            if (scs != null) {
161                scs.setBrokerService(broker);
162            }
163            destination.setSlowConsumerStrategy(scs);
164            destination.setPrioritizedMessages(isPrioritizedMessages());
165            destination.setGcIfInactive(isGcInactiveDestinations());
166            destination.setInactiveTimoutBeforeGC(getInactiveTimoutBeforeGC());
167            destination.setReduceMemoryFootprint(isReduceMemoryFootprint());
168        }
169    
170        public void configure(Broker broker, SystemUsage memoryManager, TopicSubscription subscription) {
171            //override prefetch size if not set by the Consumer
172            int prefetch=subscription.getConsumerInfo().getPrefetchSize();
173            if (prefetch == ActiveMQPrefetchPolicy.DEFAULT_TOPIC_PREFETCH){
174                subscription.getConsumerInfo().setPrefetchSize(getTopicPrefetch());
175            }
176            if (pendingMessageLimitStrategy != null) {
177                int value = pendingMessageLimitStrategy.getMaximumPendingMessageLimit(subscription);
178                int consumerLimit = subscription.getInfo().getMaximumPendingMessageLimit();
179                if (consumerLimit > 0) {
180                    if (value < 0 || consumerLimit < value) {
181                        value = consumerLimit;
182                    }
183                }
184                if (value >= 0) {
185                    if (LOG.isDebugEnabled()) {
186                        LOG.debug("Setting the maximumPendingMessages size to: " + value + " for consumer: " + subscription.getInfo().getConsumerId());
187                    }
188                    subscription.setMaximumPendingMessages(value);
189                }
190            }
191            if (messageEvictionStrategy != null) {
192                subscription.setMessageEvictionStrategy(messageEvictionStrategy);
193            }
194            if (pendingSubscriberPolicy != null) {
195                String name = subscription.getContext().getClientId() + "_" + subscription.getConsumerInfo().getConsumerId();
196                int maxBatchSize = subscription.getConsumerInfo().getPrefetchSize();
197                subscription.setMatched(pendingSubscriberPolicy.getSubscriberPendingMessageCursor(broker,name, maxBatchSize,subscription));
198            }
199            if (enableAudit) {
200                subscription.setEnableAudit(enableAudit);
201                subscription.setMaxProducersToAudit(maxProducersToAudit);
202                subscription.setMaxAuditDepth(maxAuditDepth);
203            }
204        }
205    
206        public void configure(Broker broker, SystemUsage memoryManager, DurableTopicSubscription sub) {
207            String clientId = sub.getSubscriptionKey().getClientId();
208            String subName = sub.getSubscriptionKey().getSubscriptionName();
209            int prefetch = sub.getPrefetchSize();
210            sub.setCursorMemoryHighWaterMark(getCursorMemoryHighWaterMark());
211            //override prefetch size if not set by the Consumer
212            if (prefetch == ActiveMQPrefetchPolicy.DEFAULT_DURABLE_TOPIC_PREFETCH || prefetch == ActiveMQPrefetchPolicy.DEFAULT_OPTIMIZE_DURABLE_TOPIC_PREFETCH){
213                sub.setPrefetchSize(getDurableTopicPrefetch());
214            }
215            if (pendingDurableSubscriberPolicy != null) {
216                PendingMessageCursor cursor = pendingDurableSubscriberPolicy.getSubscriberPendingMessageCursor(broker,clientId, subName,sub.getPrefetchSize(),sub);
217                cursor.setSystemUsage(memoryManager);
218                sub.setPending(cursor);
219            }
220            int auditDepth = getMaxAuditDepth();
221            if (auditDepth == BaseDestination.MAX_AUDIT_DEPTH && this.isPrioritizedMessages()) {
222                sub.setMaxAuditDepth(auditDepth * 10);
223            } else {
224                sub.setMaxAuditDepth(auditDepth);
225            }
226            sub.setMaxProducersToAudit(getMaxProducersToAudit());
227            sub.setUsePrefetchExtension(isUsePrefetchExtension());        
228        }
229        
230        public void configure(Broker broker, SystemUsage memoryManager, QueueBrowserSubscription sub) {
231           
232            int prefetch = sub.getPrefetchSize();
233            //override prefetch size if not set by the Consumer
234            
235            if (prefetch == ActiveMQPrefetchPolicy.DEFAULT_QUEUE_BROWSER_PREFETCH){
236                sub.setPrefetchSize(getQueueBrowserPrefetch());
237            }
238            sub.setCursorMemoryHighWaterMark(getCursorMemoryHighWaterMark());
239            sub.setUsePrefetchExtension(isUsePrefetchExtension());
240        }
241        
242        public void configure(Broker broker, SystemUsage memoryManager, QueueSubscription sub) {
243            
244            int prefetch = sub.getPrefetchSize();
245            //override prefetch size if not set by the Consumer
246            
247            if (prefetch == ActiveMQPrefetchPolicy.DEFAULT_QUEUE_PREFETCH){
248                sub.setPrefetchSize(getQueuePrefetch());
249            }
250            sub.setCursorMemoryHighWaterMark(getCursorMemoryHighWaterMark());
251            sub.setUsePrefetchExtension(isUsePrefetchExtension());
252        }
253    
254        // Properties
255        // -------------------------------------------------------------------------
256        public DispatchPolicy getDispatchPolicy() {
257            return dispatchPolicy;
258        }
259    
260        public void setDispatchPolicy(DispatchPolicy policy) {
261            this.dispatchPolicy = policy;
262        }
263    
264        public SubscriptionRecoveryPolicy getSubscriptionRecoveryPolicy() {
265            return subscriptionRecoveryPolicy;
266        }
267    
268        public void setSubscriptionRecoveryPolicy(SubscriptionRecoveryPolicy subscriptionRecoveryPolicy) {
269            this.subscriptionRecoveryPolicy = subscriptionRecoveryPolicy;
270        }
271    
272        public boolean isSendAdvisoryIfNoConsumers() {
273            return sendAdvisoryIfNoConsumers;
274        }
275    
276        /**
277         * Sends an advisory message if a non-persistent message is sent and there
278         * are no active consumers
279         */
280        public void setSendAdvisoryIfNoConsumers(boolean sendAdvisoryIfNoConsumers) {
281            this.sendAdvisoryIfNoConsumers = sendAdvisoryIfNoConsumers;
282        }
283    
284        public DeadLetterStrategy getDeadLetterStrategy() {
285            return deadLetterStrategy;
286        }
287    
288        /**
289         * Sets the policy used to determine which dead letter queue destination
290         * should be used
291         */
292        public void setDeadLetterStrategy(DeadLetterStrategy deadLetterStrategy) {
293            this.deadLetterStrategy = deadLetterStrategy;
294        }
295    
296        public PendingMessageLimitStrategy getPendingMessageLimitStrategy() {
297            return pendingMessageLimitStrategy;
298        }
299    
300        /**
301         * Sets the strategy to calculate the maximum number of messages that are
302         * allowed to be pending on consumers (in addition to their prefetch sizes).
303         * Once the limit is reached, non-durable topics can then start discarding
304         * old messages. This allows us to keep dispatching messages to slow
305         * consumers while not blocking fast consumers and discarding the messages
306         * oldest first.
307         */
308        public void setPendingMessageLimitStrategy(PendingMessageLimitStrategy pendingMessageLimitStrategy) {
309            this.pendingMessageLimitStrategy = pendingMessageLimitStrategy;
310        }
311    
312        public MessageEvictionStrategy getMessageEvictionStrategy() {
313            return messageEvictionStrategy;
314        }
315    
316        /**
317         * Sets the eviction strategy used to decide which message to evict when the
318         * slow consumer needs to discard messages
319         */
320        public void setMessageEvictionStrategy(MessageEvictionStrategy messageEvictionStrategy) {
321            this.messageEvictionStrategy = messageEvictionStrategy;
322        }
323    
324        public long getMemoryLimit() {
325            return memoryLimit;
326        }
327    
328        /**
329         * When set using Xbean, values of the form "20 Mb", "1024kb", and "1g" can be used
330         * @org.apache.xbean.Property propertyEditor="org.apache.activemq.util.MemoryPropertyEditor"
331         */
332        public void setMemoryLimit(long memoryLimit) {
333            this.memoryLimit = memoryLimit;
334        }
335    
336        public MessageGroupMapFactory getMessageGroupMapFactory() {
337            if (messageGroupMapFactory == null) {
338                messageGroupMapFactory = new MessageGroupHashBucketFactory();
339            }
340            return messageGroupMapFactory;
341        }
342    
343        /**
344         * Sets the factory used to create new instances of {MessageGroupMap} used
345         * to implement the <a
346         * href="http://activemq.apache.org/message-groups.html">Message Groups</a>
347         * functionality.
348         */
349        public void setMessageGroupMapFactory(MessageGroupMapFactory messageGroupMapFactory) {
350            this.messageGroupMapFactory = messageGroupMapFactory;
351        }
352    
353        /**
354         * @return the pendingDurableSubscriberPolicy
355         */
356        public PendingDurableSubscriberMessageStoragePolicy getPendingDurableSubscriberPolicy() {
357            return this.pendingDurableSubscriberPolicy;
358        }
359    
360        /**
361         * @param pendingDurableSubscriberPolicy the pendingDurableSubscriberPolicy
362         *                to set
363         */
364        public void setPendingDurableSubscriberPolicy(PendingDurableSubscriberMessageStoragePolicy pendingDurableSubscriberPolicy) {
365            this.pendingDurableSubscriberPolicy = pendingDurableSubscriberPolicy;
366        }
367    
368        /**
369         * @return the pendingQueuePolicy
370         */
371        public PendingQueueMessageStoragePolicy getPendingQueuePolicy() {
372            return this.pendingQueuePolicy;
373        }
374    
375        /**
376         * @param pendingQueuePolicy the pendingQueuePolicy to set
377         */
378        public void setPendingQueuePolicy(PendingQueueMessageStoragePolicy pendingQueuePolicy) {
379            this.pendingQueuePolicy = pendingQueuePolicy;
380        }
381    
382        /**
383         * @return the pendingSubscriberPolicy
384         */
385        public PendingSubscriberMessageStoragePolicy getPendingSubscriberPolicy() {
386            return this.pendingSubscriberPolicy;
387        }
388    
389        /**
390         * @param pendingSubscriberPolicy the pendingSubscriberPolicy to set
391         */
392        public void setPendingSubscriberPolicy(PendingSubscriberMessageStoragePolicy pendingSubscriberPolicy) {
393            this.pendingSubscriberPolicy = pendingSubscriberPolicy;
394        }
395    
396        /**
397         * @return true if producer flow control enabled
398         */
399        public boolean isProducerFlowControl() {
400            return producerFlowControl;
401        }
402    
403        /**
404         * @param producerFlowControl
405         */
406        public void setProducerFlowControl(boolean producerFlowControl) {
407            this.producerFlowControl = producerFlowControl;
408        }
409    
410        /**
411         * Set's the interval at which warnings about producers being blocked by
412         * resource usage will be triggered. Values of 0 or less will disable
413         * warnings
414         * 
415         * @param blockedProducerWarningInterval the interval at which warning about
416         *            blocked producers will be triggered.
417         */
418        public void setBlockedProducerWarningInterval(long blockedProducerWarningInterval) {
419            this.blockedProducerWarningInterval = blockedProducerWarningInterval;
420        }
421    
422        /**
423         * 
424         * @return the interval at which warning about blocked producers will be
425         *         triggered.
426         */
427        public long getBlockedProducerWarningInterval() {
428            return blockedProducerWarningInterval;
429        }
430        
431        /**
432         * @return the maxProducersToAudit
433         */
434        public int getMaxProducersToAudit() {
435            return maxProducersToAudit;
436        }
437    
438        /**
439         * @param maxProducersToAudit the maxProducersToAudit to set
440         */
441        public void setMaxProducersToAudit(int maxProducersToAudit) {
442            this.maxProducersToAudit = maxProducersToAudit;
443        }
444    
445        /**
446         * @return the maxAuditDepth
447         */
448        public int getMaxAuditDepth() {
449            return maxAuditDepth;
450        }
451    
452        /**
453         * @param maxAuditDepth the maxAuditDepth to set
454         */
455        public void setMaxAuditDepth(int maxAuditDepth) {
456            this.maxAuditDepth = maxAuditDepth;
457        }
458    
459        /**
460         * @return the enableAudit
461         */
462        public boolean isEnableAudit() {
463            return enableAudit;
464        }
465    
466        /**
467         * @param enableAudit the enableAudit to set
468         */
469        public void setEnableAudit(boolean enableAudit) {
470            this.enableAudit = enableAudit;
471        }
472    
473        public int getMaxQueueAuditDepth() {
474            return maxQueueAuditDepth;
475        }
476    
477        public void setMaxQueueAuditDepth(int maxQueueAuditDepth) {
478            this.maxQueueAuditDepth = maxQueueAuditDepth;
479        }
480    
481        public boolean isOptimizedDispatch() {
482            return optimizedDispatch;
483        }
484    
485        public void setOptimizedDispatch(boolean optimizedDispatch) {
486            this.optimizedDispatch = optimizedDispatch;
487        }
488        
489        public int getMaxPageSize() {
490            return maxPageSize;
491        }
492    
493        public void setMaxPageSize(int maxPageSize) {
494            this.maxPageSize = maxPageSize;
495        } 
496        
497        public int getMaxBrowsePageSize() {
498            return maxBrowsePageSize;
499        }
500    
501        public void setMaxBrowsePageSize(int maxPageSize) {
502            this.maxBrowsePageSize = maxPageSize;
503        } 
504        
505        public boolean isUseCache() {
506            return useCache;
507        }
508    
509        public void setUseCache(boolean useCache) {
510            this.useCache = useCache;
511        }
512    
513        public long getMinimumMessageSize() {
514            return minimumMessageSize;
515        }
516    
517        public void setMinimumMessageSize(long minimumMessageSize) {
518            this.minimumMessageSize = minimumMessageSize;
519        }   
520        
521        public boolean isUseConsumerPriority() {
522            return useConsumerPriority;
523        }
524    
525        public void setUseConsumerPriority(boolean useConsumerPriority) {
526            this.useConsumerPriority = useConsumerPriority;
527        }
528    
529        public boolean isStrictOrderDispatch() {
530            return strictOrderDispatch;
531        }
532    
533        public void setStrictOrderDispatch(boolean strictOrderDispatch) {
534            this.strictOrderDispatch = strictOrderDispatch;
535        }
536    
537        public boolean isLazyDispatch() {
538            return lazyDispatch;
539        }
540    
541        public void setLazyDispatch(boolean lazyDispatch) {
542            this.lazyDispatch = lazyDispatch;
543        }
544    
545        public int getTimeBeforeDispatchStarts() {
546            return timeBeforeDispatchStarts;
547        }
548    
549        public void setTimeBeforeDispatchStarts(int timeBeforeDispatchStarts) {
550            this.timeBeforeDispatchStarts = timeBeforeDispatchStarts;
551        }
552    
553        public int getConsumersBeforeDispatchStarts() {
554            return consumersBeforeDispatchStarts;
555        }
556    
557        public void setConsumersBeforeDispatchStarts(int consumersBeforeDispatchStarts) {
558            this.consumersBeforeDispatchStarts = consumersBeforeDispatchStarts;
559        }
560    
561        /**
562         * @return the advisoryForSlowConsumers
563         */
564        public boolean isAdvisoryForSlowConsumers() {
565            return advisoryForSlowConsumers;
566        }
567    
568        /**
569         * @param advisoryForSlowConsumers the advisoryForSlowConsumers to set
570         */
571        public void setAdvisoryForSlowConsumers(boolean advisoryForSlowConsumers) {
572            this.advisoryForSlowConsumers = advisoryForSlowConsumers;
573        }
574    
575        /**
576         * @return the advisoryForDiscardingMessages
577         */
578        public boolean isAdvisoryForDiscardingMessages() {
579            return advisoryForDiscardingMessages;
580        }
581    
582        /**
583         * @param advisoryForDiscardingMessages the advisoryForDiscardingMessages to set
584         */
585        public void setAdvisoryForDiscardingMessages(
586                boolean advisoryForDiscardingMessages) {
587            this.advisoryForDiscardingMessages = advisoryForDiscardingMessages;
588        }
589    
590        /**
591         * @return the advisoryWhenFull
592         */
593        public boolean isAdvisoryWhenFull() {
594            return advisoryWhenFull;
595        }
596    
597        /**
598         * @param advisoryWhenFull the advisoryWhenFull to set
599         */
600        public void setAdvisoryWhenFull(boolean advisoryWhenFull) {
601            this.advisoryWhenFull = advisoryWhenFull;
602        }
603    
604        /**
605         * @return the advisoryForDelivery
606         */
607        public boolean isAdvisoryForDelivery() {
608            return advisoryForDelivery;
609        }
610    
611        /**
612         * @param advisoryForDelivery the advisoryForDelivery to set
613         */
614        public void setAdvisoryForDelivery(boolean advisoryForDelivery) {
615            this.advisoryForDelivery = advisoryForDelivery;
616        }
617    
618        /**
619         * @return the advisoryForConsumed
620         */
621        public boolean isAdvisoryForConsumed() {
622            return advisoryForConsumed;
623        }
624    
625        /**
626         * @param advisoryForConsumed the advisoryForConsumed to set
627         */
628        public void setAdvisoryForConsumed(boolean advisoryForConsumed) {
629            this.advisoryForConsumed = advisoryForConsumed;
630        }
631        
632        /**
633         * @return the advisdoryForFastProducers
634         */
635        public boolean isAdvisdoryForFastProducers() {
636            return advisdoryForFastProducers;
637        }
638    
639        /**
640         * @param advisdoryForFastProducers the advisdoryForFastProducers to set
641         */
642        public void setAdvisdoryForFastProducers(boolean advisdoryForFastProducers) {
643            this.advisdoryForFastProducers = advisdoryForFastProducers;
644        }
645    
646        public void setMaxExpirePageSize(int maxExpirePageSize) {
647            this.maxExpirePageSize = maxExpirePageSize;
648        }
649        
650        public int getMaxExpirePageSize() {
651            return maxExpirePageSize;
652        }
653        
654        public void setExpireMessagesPeriod(long expireMessagesPeriod) {
655            this.expireMessagesPeriod = expireMessagesPeriod;
656        }
657        
658        public long getExpireMessagesPeriod() {
659            return expireMessagesPeriod;
660        }
661    
662        /**
663         * Get the queuePrefetch
664         * @return the queuePrefetch
665         */
666        public int getQueuePrefetch() {
667            return this.queuePrefetch;
668        }
669    
670        /**
671         * Set the queuePrefetch
672         * @param queuePrefetch the queuePrefetch to set
673         */
674        public void setQueuePrefetch(int queuePrefetch) {
675            this.queuePrefetch = queuePrefetch;
676        }
677    
678        /**
679         * Get the queueBrowserPrefetch
680         * @return the queueBrowserPrefetch
681         */
682        public int getQueueBrowserPrefetch() {
683            return this.queueBrowserPrefetch;
684        }
685    
686        /**
687         * Set the queueBrowserPrefetch
688         * @param queueBrowserPrefetch the queueBrowserPrefetch to set
689         */
690        public void setQueueBrowserPrefetch(int queueBrowserPrefetch) {
691            this.queueBrowserPrefetch = queueBrowserPrefetch;
692        }
693    
694        /**
695         * Get the topicPrefetch
696         * @return the topicPrefetch
697         */
698        public int getTopicPrefetch() {
699            return this.topicPrefetch;
700        }
701    
702        /**
703         * Set the topicPrefetch
704         * @param topicPrefetch the topicPrefetch to set
705         */
706        public void setTopicPrefetch(int topicPrefetch) {
707            this.topicPrefetch = topicPrefetch;
708        }
709    
710        /**
711         * Get the durableTopicPrefetch
712         * @return the durableTopicPrefetch
713         */
714        public int getDurableTopicPrefetch() {
715            return this.durableTopicPrefetch;
716        }
717    
718        /**
719         * Set the durableTopicPrefetch
720         * @param durableTopicPrefetch the durableTopicPrefetch to set
721         */
722        public void setDurableTopicPrefetch(int durableTopicPrefetch) {
723            this.durableTopicPrefetch = durableTopicPrefetch;
724        }
725        
726        public boolean isUsePrefetchExtension() {
727            return this.usePrefetchExtension;
728        }
729    
730        public void setUsePrefetchExtension(boolean usePrefetchExtension) {
731            this.usePrefetchExtension = usePrefetchExtension;
732        }
733        
734        public int getCursorMemoryHighWaterMark() {
735            return this.cursorMemoryHighWaterMark;
736        }
737    
738        public void setCursorMemoryHighWaterMark(int cursorMemoryHighWaterMark) {
739            this.cursorMemoryHighWaterMark = cursorMemoryHighWaterMark;
740            }
741    
742        public void setStoreUsageHighWaterMark(int storeUsageHighWaterMark) {
743            this.storeUsageHighWaterMark = storeUsageHighWaterMark;   
744        }
745    
746        public int getStoreUsageHighWaterMark() {
747            return storeUsageHighWaterMark;
748        }
749    
750        public void setSlowConsumerStrategy(SlowConsumerStrategy slowConsumerStrategy) {
751            this.slowConsumerStrategy = slowConsumerStrategy;
752        }
753        
754        public SlowConsumerStrategy getSlowConsumerStrategy() {
755            return this.slowConsumerStrategy;
756        }
757        
758        
759        public boolean isPrioritizedMessages() {
760            return this.prioritizedMessages;
761        }
762    
763        public void setPrioritizedMessages(boolean prioritizedMessages) {
764            this.prioritizedMessages = prioritizedMessages;
765        }
766    
767        public void setAllConsumersExclusiveByDefault(boolean allConsumersExclusiveByDefault) {
768            this.allConsumersExclusiveByDefault = allConsumersExclusiveByDefault;
769        }
770    
771        public boolean isAllConsumersExclusiveByDefault() {
772            return allConsumersExclusiveByDefault;
773        }
774    
775        public boolean isGcInactiveDestinations() {
776            return this.gcInactiveDestinations;
777        }
778    
779        public void setGcInactiveDestinations(boolean gcInactiveDestinations) {
780            this.gcInactiveDestinations = gcInactiveDestinations;
781        }
782    
783        public long getInactiveTimoutBeforeGC() {
784            return this.inactiveTimoutBeforeGC;
785        }
786    
787        public void setInactiveTimoutBeforeGC(long inactiveTimoutBeforeGC) {
788            this.inactiveTimoutBeforeGC = inactiveTimoutBeforeGC;
789        }
790        
791        public boolean isReduceMemoryFootprint() {
792            return reduceMemoryFootprint;
793        }
794    
795        public void setReduceMemoryFootprint(boolean reduceMemoryFootprint) {
796            this.reduceMemoryFootprint = reduceMemoryFootprint;
797        }
798    }