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 advisdoryForFastProducers;
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.setAdvisdoryForFastProducers(isAdvisdoryForFastProducers());
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 isAdvisdoryForFastProducers() {
665 return advisdoryForFastProducers;
666 }
667
668 /**
669 * @param advisdoryForFastProducers the advisdoryForFastProducers to set
670 */
671 public void setAdvisdoryForFastProducers(boolean advisdoryForFastProducers) {
672 this.advisdoryForFastProducers = advisdoryForFastProducers;
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 }