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