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}