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 */ 017package org.apache.activemq.broker.region; 018 019import java.io.IOException; 020import java.util.List; 021import org.apache.activemq.Service; 022import org.apache.activemq.broker.ConnectionContext; 023import org.apache.activemq.broker.ProducerBrokerExchange; 024import org.apache.activemq.broker.region.policy.DeadLetterStrategy; 025import org.apache.activemq.broker.region.policy.SharedDeadLetterStrategy; 026import org.apache.activemq.broker.region.policy.SlowConsumerStrategy; 027import org.apache.activemq.command.ActiveMQDestination; 028import org.apache.activemq.command.Message; 029import org.apache.activemq.command.MessageAck; 030import org.apache.activemq.command.MessageDispatchNotification; 031import org.apache.activemq.command.ProducerInfo; 032import org.apache.activemq.store.MessageStore; 033import org.apache.activemq.thread.Task; 034import org.apache.activemq.usage.MemoryUsage; 035import org.apache.activemq.usage.Usage; 036 037/** 038 * 039 */ 040public interface Destination extends Service, Task { 041 042 public static final DeadLetterStrategy DEFAULT_DEAD_LETTER_STRATEGY = new SharedDeadLetterStrategy(); 043 public static final long DEFAULT_BLOCKED_PRODUCER_WARNING_INTERVAL = 30000; 044 045 void addSubscription(ConnectionContext context, Subscription sub) throws Exception; 046 047 void removeSubscription(ConnectionContext context, Subscription sub, long lastDeliveredSequenceId) throws Exception; 048 049 void addProducer(ConnectionContext context, ProducerInfo info) throws Exception; 050 051 void removeProducer(ConnectionContext context, ProducerInfo info) throws Exception; 052 053 void send(ProducerBrokerExchange producerExchange, Message messageSend) throws Exception; 054 055 void acknowledge(ConnectionContext context, Subscription sub, final MessageAck ack, final MessageReference node) throws IOException; 056 057 void gc(); 058 059 ActiveMQDestination getActiveMQDestination(); 060 061 MemoryUsage getMemoryUsage(); 062 063 void dispose(ConnectionContext context) throws IOException; 064 065 DestinationStatistics getDestinationStatistics(); 066 067 DeadLetterStrategy getDeadLetterStrategy(); 068 069 Message[] browse(); 070 071 String getName(); 072 073 MessageStore getMessageStore(); 074 075 boolean isProducerFlowControl(); 076 077 void setProducerFlowControl(boolean value); 078 079 /** 080 * Set's the interval at which warnings about producers being blocked by 081 * resource usage will be triggered. Values of 0 or less will disable 082 * warnings 083 * 084 * @param blockedProducerWarningInterval the interval at which warning about 085 * blocked producers will be triggered. 086 */ 087 public void setBlockedProducerWarningInterval(long blockedProducerWarningInterval); 088 089 /** 090 * 091 * @return the interval at which warning about blocked producers will be 092 * triggered. 093 */ 094 public long getBlockedProducerWarningInterval(); 095 096 int getMaxProducersToAudit(); 097 098 void setMaxProducersToAudit(int maxProducersToAudit); 099 100 int getMaxAuditDepth(); 101 102 void setMaxAuditDepth(int maxAuditDepth); 103 104 boolean isEnableAudit(); 105 106 void setEnableAudit(boolean enableAudit); 107 108 boolean isActive(); 109 110 int getMaxPageSize(); 111 112 public void setMaxPageSize(int maxPageSize); 113 114 public int getMaxBrowsePageSize(); 115 116 public void setMaxBrowsePageSize(int maxPageSize); 117 118 public boolean isUseCache(); 119 120 public void setUseCache(boolean useCache); 121 122 public int getMinimumMessageSize(); 123 124 public void setMinimumMessageSize(int minimumMessageSize); 125 126 public int getCursorMemoryHighWaterMark(); 127 128 public void setCursorMemoryHighWaterMark(int cursorMemoryHighWaterMark); 129 130 /** 131 * optionally called by a Subscriber - to inform the Destination its ready 132 * for more messages 133 */ 134 public void wakeup(); 135 136 /** 137 * @return true if lazyDispatch is enabled 138 */ 139 public boolean isLazyDispatch(); 140 141 /** 142 * set the lazy dispatch - default is false 143 * 144 * @param value 145 */ 146 public void setLazyDispatch(boolean value); 147 148 /** 149 * Inform the Destination a message has expired 150 * 151 * @param context 152 * @param subs 153 * @param node 154 */ 155 void messageExpired(ConnectionContext context, Subscription subs, MessageReference node); 156 157 /** 158 * called when message is consumed 159 * 160 * @param context 161 * @param messageReference 162 */ 163 void messageConsumed(ConnectionContext context, MessageReference messageReference); 164 165 /** 166 * Called when message is delivered to the broker 167 * 168 * @param context 169 * @param messageReference 170 */ 171 void messageDelivered(ConnectionContext context, MessageReference messageReference); 172 173 /** 174 * Called when a message is discarded - e.g. running low on memory This will 175 * happen only if the policy is enabled - e.g. non durable topics 176 * 177 * @param context 178 * @param messageReference 179 * @param sub 180 */ 181 void messageDiscarded(ConnectionContext context, Subscription sub, MessageReference messageReference); 182 183 /** 184 * Called when there is a slow consumer 185 * 186 * @param context 187 * @param subs 188 */ 189 void slowConsumer(ConnectionContext context, Subscription subs); 190 191 /** 192 * Called to notify a producer is too fast 193 * 194 * @param context 195 * @param producerInfo 196 */ 197 void fastProducer(ConnectionContext context, ProducerInfo producerInfo); 198 199 /** 200 * Called when a Usage reaches a limit 201 * 202 * @param context 203 * @param usage 204 */ 205 void isFull(ConnectionContext context, Usage usage); 206 207 List<Subscription> getConsumers(); 208 209 /** 210 * called on Queues in slave mode to allow dispatch to follow subscription 211 * choice of master 212 * 213 * @param messageDispatchNotification 214 * @throws Exception 215 */ 216 void processDispatchNotification(MessageDispatchNotification messageDispatchNotification) throws Exception; 217 218 boolean isPrioritizedMessages(); 219 220 SlowConsumerStrategy getSlowConsumerStrategy(); 221}