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    
237        public void clearPendingMessages();
238    }