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