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 }