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