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 }