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.view;
018    
019    import java.util.Collections;
020    import java.util.HashSet;
021    import java.util.Map;
022    import java.util.Set;
023    
024    import org.apache.activemq.broker.BrokerRegistry;
025    import org.apache.activemq.broker.BrokerService;
026    import org.apache.activemq.broker.region.Destination;
027    import org.apache.activemq.command.ActiveMQDestination;
028    import org.apache.activemq.command.ActiveMQQueue;
029    import org.apache.activemq.command.ActiveMQTempQueue;
030    import org.apache.activemq.command.ActiveMQTempTopic;
031    import org.apache.activemq.command.ActiveMQTopic;
032    import org.apache.activemq.util.LRUCache;
033    
034    /**
035     * A view into the running Broker
036     */
037    public class MessageBrokerView  {
038        private final BrokerService brokerService;
039        private Map<ActiveMQDestination,BrokerDestinationView> destinationViewMap = new LRUCache<ActiveMQDestination, BrokerDestinationView>();
040    
041    
042        /**
043         * Create a view of a running Broker
044         * @param brokerService
045         */
046        public MessageBrokerView(BrokerService brokerService){
047            this.brokerService = brokerService;
048            if (brokerService == null){
049                throw new NullPointerException("BrokerService is null");
050            }
051            if (!brokerService.isStarted()){
052                throw new IllegalStateException("BrokerService " + brokerService.getBrokerName() + " is not started");
053            }
054        }
055    
056        /**
057         * Create a view of a running Broker
058         * @param brokerName
059         */
060        public MessageBrokerView(String brokerName){
061            this.brokerService = BrokerRegistry.getInstance().lookup(brokerName);
062            if (brokerService == null){
063                throw new NullPointerException("BrokerService is null");
064            }
065            if (!brokerService.isStarted()){
066                throw new IllegalStateException("BrokerService " + brokerService.getBrokerName() + " is not started");
067            }
068        }
069    
070    
071    
072        /**
073         * @return the brokerName
074         */
075        public String getBrokerName(){
076            return brokerService.getBrokerName();
077        }
078    
079        /**
080         * @return the unique id of the Broker
081         */
082        public String getBrokerId(){
083            try {
084                return brokerService.getBroker().getBrokerId().toString();
085            } catch (Exception e) {
086                return "";
087            }
088        }
089    
090    
091        /**
092         * @return the memory used by the Broker as a percentage
093         */
094        public int getMemoryPercentUsage() {
095            return brokerService.getSystemUsage().getMemoryUsage().getPercentUsage();
096        }
097    
098    
099        /**
100         * @return  the space used by the Message Store as a percentage
101         */
102    
103        public int getStorePercentUsage() {
104            return brokerService.getSystemUsage().getStoreUsage().getPercentUsage();
105        }
106    
107        /**
108         * @return the space used by the store for temporary messages as a percentage
109         */
110        public int getTempPercentUsage() {
111            return brokerService.getSystemUsage().getTempUsage().getPercentUsage();
112        }
113    
114        /**
115         * @return the space used by the store of scheduled messages
116         */
117        public int getJobSchedulerStorePercentUsage() {
118            return brokerService.getSystemUsage().getJobSchedulerUsage().getPercentUsage();
119        }
120    
121        /**
122         * @return true if the Broker isn't using an in-memory store only for messages
123         */
124        public boolean isPersistent() {
125            return brokerService.isPersistent();
126        }
127    
128        public BrokerService getBrokerService(){
129            return brokerService;
130        }
131    
132        /**
133         * Retrieve a set of all Destinations be used by the Broker
134         * @return  all Destinations
135         */
136        public Set<ActiveMQDestination> getDestinations(){
137            Set<ActiveMQDestination> result;
138    
139            try {
140                ActiveMQDestination[] destinations =  brokerService.getBroker().getDestinations();
141                result = new HashSet<ActiveMQDestination>();
142                Collections.addAll(result, destinations);
143            }catch (Exception e){
144               result = Collections.emptySet();
145            }
146            return result;
147        }
148    
149        /**
150         * Retrieve a set of all Topics be used by the Broker
151         * @return  all Topics
152         */
153    
154        public Set<ActiveMQTopic> getTopics(){
155            Set<ActiveMQTopic> result = new HashSet<ActiveMQTopic>();
156            for (ActiveMQDestination destination:getDestinations()){
157                if (destination.isTopic() && !destination.isTemporary()){
158                    result.add((ActiveMQTopic) destination);
159                }
160            }
161            return result;
162        }
163    
164        /**
165         * Retrieve a set of all Queues be used by the Broker
166         * @return  all Queues
167         */
168    
169        public Set<ActiveMQQueue> getQueues(){
170            Set<ActiveMQQueue> result = new HashSet<ActiveMQQueue>();
171            for (ActiveMQDestination destination:getDestinations()){
172                if (destination.isQueue() && !destination.isTemporary()){
173                    result.add((ActiveMQQueue) destination);
174                }
175            }
176            return result;
177        }
178    
179        /**
180         * Retrieve a set of all TemporaryTopics be used by the Broker
181         * @return  all TemporaryTopics
182         */
183        public Set<ActiveMQTempTopic> getTempTopics(){
184            Set<ActiveMQTempTopic> result = new HashSet<ActiveMQTempTopic>();
185            for (ActiveMQDestination destination:getDestinations()){
186                if (destination.isTopic() && destination.isTemporary()){
187                    result.add((ActiveMQTempTopic) destination);
188                }
189            }
190            return result;
191        }
192    
193    
194        /**
195         * Retrieve a set of all TemporaryQueues be used by the Broker
196         * @return  all TemporaryQueues
197         */
198        public Set<ActiveMQTempQueue> getTempQueues(){
199            Set<ActiveMQTempQueue> result = new HashSet<ActiveMQTempQueue>();
200            for (ActiveMQDestination destination:getDestinations()){
201                if (destination.isTopic() && destination.isTemporary()){
202                    result.add((ActiveMQTempQueue) destination);
203                }
204            }
205            return result;
206        }
207    
208    
209        /**
210         * It will be assumed the destinationName is prepended with topic:// or queue:// - but
211         * will default to a Queue
212         * @param destinationName
213         * @return the BrokerDestinationView associated with the destinationName
214         * @throws Exception
215         */
216    
217        public BrokerDestinationView getDestinationView(String destinationName)   throws Exception{
218            return getDestinationView(destinationName,ActiveMQDestination.QUEUE_TYPE);
219        }
220    
221        /**
222         * Get the BrokerDestinationView associated with the topic
223         * @param destinationName
224         * @return  BrokerDestinationView
225         * @throws Exception
226         */
227    
228        public BrokerDestinationView getTopicDestinationView(String destinationName)   throws Exception{
229            return getDestinationView(destinationName,ActiveMQDestination.TOPIC_TYPE);
230        }
231    
232        /**
233         * Get the BrokerDestinationView associated with the queue
234         * @param destinationName
235         * @return  BrokerDestinationView
236         * @throws Exception
237         */
238    
239        public BrokerDestinationView getQueueDestinationView(String destinationName) throws Exception{
240            return getDestinationView(destinationName,ActiveMQDestination.QUEUE_TYPE);
241        }
242    
243    
244        /**
245         * Get the BrokerDestinationView associated with destination
246         * @param destinationName
247         * @param type  expects either ActiveMQDestination.QUEUE_TYPE, ActiveMQDestination.TOPIC_TYPE etc
248         * @return  BrokerDestinationView
249         * @throws Exception
250         */
251        public BrokerDestinationView getDestinationView (String destinationName, byte type)  throws Exception {
252            ActiveMQDestination activeMQDestination = ActiveMQDestination.createDestination(destinationName,type);
253            return getDestinationView(activeMQDestination);
254        }
255    
256        /**
257         *  Get the BrokerDestinationView associated with destination
258         * @param activeMQDestination
259         * @return   BrokerDestinationView
260         * @throws Exception
261         */
262        public BrokerDestinationView getDestinationView (ActiveMQDestination activeMQDestination) throws Exception {
263            BrokerDestinationView view = null;
264            synchronized(destinationViewMap){
265                view = destinationViewMap.get(activeMQDestination);
266                if (view==null){
267    
268                        /**
269                         * If auto destinatons are allowed (on by default) - this will create a Broker Destination
270                         * if it doesn't exist. We could query the regionBroker first to check - but this affords more
271                         * flexibility - e.g. you might want to set up a query on destination statistics before any
272                         * messaging clients have started (and hence created the destination themselves
273                         */
274                        Destination destination = brokerService.getDestination(activeMQDestination);
275                        view = new BrokerDestinationView(destination);
276                        destinationViewMap.put(activeMQDestination,view);
277    
278                }
279            }
280            return view;
281        }
282    
283    
284    
285    
286    }