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.camel.management;
018    
019    import java.util.concurrent.ThreadPoolExecutor;
020    
021    import org.apache.camel.CamelContext;
022    import org.apache.camel.Component;
023    import org.apache.camel.Consumer;
024    import org.apache.camel.DelegateProcessor;
025    import org.apache.camel.Endpoint;
026    import org.apache.camel.ErrorHandlerFactory;
027    import org.apache.camel.Processor;
028    import org.apache.camel.Producer;
029    import org.apache.camel.Route;
030    import org.apache.camel.Service;
031    import org.apache.camel.component.bean.BeanProcessor;
032    import org.apache.camel.impl.ScheduledPollConsumer;
033    import org.apache.camel.management.mbean.ManagedBeanProcessor;
034    import org.apache.camel.management.mbean.ManagedBrowsableEndpoint;
035    import org.apache.camel.management.mbean.ManagedCamelContext;
036    import org.apache.camel.management.mbean.ManagedComponent;
037    import org.apache.camel.management.mbean.ManagedConsumer;
038    import org.apache.camel.management.mbean.ManagedDelayer;
039    import org.apache.camel.management.mbean.ManagedEndpoint;
040    import org.apache.camel.management.mbean.ManagedErrorHandler;
041    import org.apache.camel.management.mbean.ManagedEventNotifier;
042    import org.apache.camel.management.mbean.ManagedIdempotentConsumer;
043    import org.apache.camel.management.mbean.ManagedProcessor;
044    import org.apache.camel.management.mbean.ManagedProducer;
045    import org.apache.camel.management.mbean.ManagedRoute;
046    import org.apache.camel.management.mbean.ManagedScheduledPollConsumer;
047    import org.apache.camel.management.mbean.ManagedSendProcessor;
048    import org.apache.camel.management.mbean.ManagedService;
049    import org.apache.camel.management.mbean.ManagedSuspendableRoute;
050    import org.apache.camel.management.mbean.ManagedThreadPool;
051    import org.apache.camel.management.mbean.ManagedThrottler;
052    import org.apache.camel.model.ModelCamelContext;
053    import org.apache.camel.model.ProcessorDefinition;
054    import org.apache.camel.processor.Delayer;
055    import org.apache.camel.processor.ErrorHandler;
056    import org.apache.camel.processor.SendProcessor;
057    import org.apache.camel.processor.Throttler;
058    import org.apache.camel.processor.idempotent.IdempotentConsumer;
059    import org.apache.camel.spi.BrowsableEndpoint;
060    import org.apache.camel.spi.EventNotifier;
061    import org.apache.camel.spi.ManagementObjectStrategy;
062    import org.apache.camel.spi.RouteContext;
063    
064    /**
065     *
066     */
067    public class DefaultManagementObjectStrategy implements ManagementObjectStrategy {
068    
069        public Object getManagedObjectForCamelContext(CamelContext context) {
070            ManagedCamelContext mc = new ManagedCamelContext((ModelCamelContext)context);
071            mc.init(context.getManagementStrategy());
072            return mc;
073        }
074    
075        @SuppressWarnings({"deprecation", "unchecked"})
076        public Object getManagedObjectForComponent(CamelContext context, Component component, String name) {
077            if (component instanceof org.apache.camel.spi.ManagementAware) {
078                return ((org.apache.camel.spi.ManagementAware<Component>) component).getManagedObject(component);
079            } else {
080                ManagedComponent mc = new ManagedComponent(name, component);
081                mc.init(context.getManagementStrategy());
082                return mc;
083            }
084        }
085    
086        @SuppressWarnings({"deprecation", "unchecked"})
087        public Object getManagedObjectForEndpoint(CamelContext context, Endpoint endpoint) {
088            // we only want to manage singleton endpoints
089            if (!endpoint.isSingleton()) {
090                return null;
091            }
092    
093            if (endpoint instanceof org.apache.camel.spi.ManagementAware) {
094                return ((org.apache.camel.spi.ManagementAware<Endpoint>) endpoint).getManagedObject(endpoint);
095            } else if (endpoint instanceof BrowsableEndpoint) {
096                ManagedBrowsableEndpoint me = new ManagedBrowsableEndpoint((BrowsableEndpoint) endpoint);
097                me.init(context.getManagementStrategy());
098                return me;
099            } else {
100                ManagedEndpoint me = new ManagedEndpoint(endpoint);
101                me.init(context.getManagementStrategy());
102                return me;
103            }
104        }
105    
106        public Object getManagedObjectForErrorHandler(CamelContext context, RouteContext routeContext,
107                                                      Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder) {
108            ManagedErrorHandler me = new ManagedErrorHandler(routeContext, errorHandler, errorHandlerBuilder);
109            me.init(context.getManagementStrategy());
110            return me;
111        }
112    
113        public Object getManagedObjectForRoute(CamelContext context, Route route) {
114            ManagedRoute mr;
115            if (route.supportsSuspension()) {
116                mr = new ManagedSuspendableRoute((ModelCamelContext)context, route);
117            } else {
118                mr = new ManagedRoute((ModelCamelContext)context, route);
119            }
120            mr.init(context.getManagementStrategy());
121            return mr;
122        }
123    
124        public Object getManagedObjectForThreadPool(CamelContext context, ThreadPoolExecutor threadPool,
125                                                    String id, String sourceId, String routeId, String threadPoolProfileId) {
126            ManagedThreadPool mtp = new ManagedThreadPool(context, threadPool, id, sourceId, routeId, threadPoolProfileId);
127            mtp.init(context.getManagementStrategy());
128            return mtp;
129        }
130    
131        public Object getManagedObjectForEventNotifier(CamelContext context, EventNotifier eventNotifier) {
132            ManagedEventNotifier men = new ManagedEventNotifier(context, eventNotifier);
133            men.init(context.getManagementStrategy());
134            return men;
135        }
136    
137        public Object getManagedObjectForConsumer(CamelContext context, Consumer consumer) {
138            ManagedConsumer mc;
139            if (consumer instanceof ScheduledPollConsumer) {
140                mc = new ManagedScheduledPollConsumer(context, (ScheduledPollConsumer) consumer);
141            } else {
142                mc = new ManagedConsumer(context, consumer);
143            }
144            mc.init(context.getManagementStrategy());
145            return mc;
146        }
147    
148        public Object getManagedObjectForProducer(CamelContext context, Producer producer) {
149            ManagedProducer mp = new ManagedProducer(context, producer);
150            mp.init(context.getManagementStrategy());
151            return mp;
152        }
153    
154        public Object getManagedObjectForService(CamelContext context, Service service) {
155            ManagedService mc = new ManagedService(context, service);
156            mc.init(context.getManagementStrategy());
157            return mc;
158        }
159    
160        @SuppressWarnings({"deprecation", "unchecked"})
161        public Object getManagedObjectForProcessor(CamelContext context, Processor processor,
162                                                   ProcessorDefinition<?> definition, Route route) {
163            ManagedProcessor answer = null;
164    
165            // unwrap delegates as we want the real target processor
166            Processor target = processor;
167            while (target != null) {
168    
169                // skip error handlers
170                if (target instanceof ErrorHandler) {
171                    return false;
172                }
173    
174                // look for specialized processor which we should prefer to use
175                if (target instanceof Delayer) {
176                    answer = new ManagedDelayer(context, (Delayer) target, definition);
177                } else if (target instanceof Throttler) {
178                    answer = new ManagedThrottler(context, (Throttler) target, definition);
179                } else if (target instanceof SendProcessor) {
180                    answer = new ManagedSendProcessor(context, (SendProcessor) target, definition);
181                } else if (target instanceof BeanProcessor) {
182                    answer = new ManagedBeanProcessor(context, (BeanProcessor) target, definition);
183                } else if (target instanceof IdempotentConsumer) {
184                    answer = new ManagedIdempotentConsumer(context, (IdempotentConsumer) target, definition);
185                } else if (target instanceof org.apache.camel.spi.ManagementAware) {
186                    return ((org.apache.camel.spi.ManagementAware<Processor>) target).getManagedObject(processor);
187                }
188    
189                if (answer != null) {
190                    // break out as we found an answer
191                    break;
192                }
193    
194                // no answer yet, so unwrap any delegates and try again
195                if (target instanceof DelegateProcessor) {
196                    target = ((DelegateProcessor) target).getProcessor();
197                } else {
198                    // no delegate so we dont have any target to try next
199                    break;
200                }
201            }
202    
203            if (answer == null) {
204                // fallback to a generic processor
205                answer = new ManagedProcessor(context, target, definition);
206            }
207    
208            answer.setRoute(route);
209            answer.init(context.getManagementStrategy());
210            return answer;
211        }
212    
213    }