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 javax.management.ObjectName;
020
021 import org.apache.camel.CamelContext;
022 import org.apache.camel.Endpoint;
023 import org.apache.camel.management.mbean.ManagedBacklogDebugger;
024 import org.apache.camel.management.mbean.ManagedBacklogTracer;
025 import org.apache.camel.management.mbean.ManagedCamelContext;
026 import org.apache.camel.management.mbean.ManagedComponent;
027 import org.apache.camel.management.mbean.ManagedConsumer;
028 import org.apache.camel.management.mbean.ManagedEndpoint;
029 import org.apache.camel.management.mbean.ManagedErrorHandler;
030 import org.apache.camel.management.mbean.ManagedEventNotifier;
031 import org.apache.camel.management.mbean.ManagedProcessor;
032 import org.apache.camel.management.mbean.ManagedProducer;
033 import org.apache.camel.management.mbean.ManagedRoute;
034 import org.apache.camel.management.mbean.ManagedService;
035 import org.apache.camel.management.mbean.ManagedThreadPool;
036 import org.apache.camel.management.mbean.ManagedTracer;
037 import org.apache.camel.model.ProcessorDefinition;
038 import org.apache.camel.spi.ManagementAgent;
039 import org.slf4j.Logger;
040 import org.slf4j.LoggerFactory;
041
042 /**
043 * A JMX capable {@link org.apache.camel.spi.ManagementStrategy} that Camel by default uses if possible.
044 * <p/>
045 * Camel detects whether its possible to use this JMX capable strategy and if <b>not</b> then Camel
046 * will fallback to the {@link org.apache.camel.management.DefaultManagementStrategy} instead.
047 *
048 * @see org.apache.camel.spi.ManagementStrategy
049 * @see org.apache.camel.management.DefaultManagementStrategy
050 * @version
051 */
052 public class ManagedManagementStrategy extends DefaultManagementStrategy {
053
054 private static final Logger LOG = LoggerFactory.getLogger(ManagedManagementStrategy.class);
055
056 public ManagedManagementStrategy() {
057 }
058
059 @Deprecated
060 public ManagedManagementStrategy(ManagementAgent managementAgent) {
061 setManagementAgent(managementAgent);
062 }
063
064 public ManagedManagementStrategy(CamelContext camelContext, ManagementAgent managementAgent) {
065 setCamelContext(camelContext);
066 setManagementAgent(managementAgent);
067 }
068
069 public void manageObject(Object managedObject) throws Exception {
070 manageNamedObject(managedObject, null);
071 }
072
073 public void manageNamedObject(Object managedObject, Object preferredName) throws Exception {
074 ObjectName objectName = getObjectName(managedObject, preferredName);
075
076 if (objectName != null) {
077 getManagementAgent().register(managedObject, objectName);
078 }
079 }
080
081 public <T> T getManagedObjectName(Object managedObject, String customName, Class<T> nameType) throws Exception {
082 if (managedObject == null) {
083 return null;
084 }
085
086 ObjectName objectName = null;
087
088 if (managedObject instanceof ManagedCamelContext) {
089 ManagedCamelContext mcc = (ManagedCamelContext) managedObject;
090 objectName = getManagementNamingStrategy().getObjectNameForCamelContext(mcc.getContext());
091 } else if (managedObject instanceof ManagedComponent) {
092 ManagedComponent mc = (ManagedComponent) managedObject;
093 objectName = getManagementNamingStrategy().getObjectNameForComponent(mc.getComponent(), mc.getComponentName());
094 } else if (managedObject instanceof ManagedEndpoint) {
095 ManagedEndpoint me = (ManagedEndpoint) managedObject;
096 objectName = getManagementNamingStrategy().getObjectNameForEndpoint(me.getEndpoint());
097 } else if (managedObject instanceof Endpoint) {
098 objectName = getManagementNamingStrategy().getObjectNameForEndpoint((Endpoint) managedObject);
099 } else if (managedObject instanceof ManagedRoute) {
100 ManagedRoute mr = (ManagedRoute) managedObject;
101 objectName = getManagementNamingStrategy().getObjectNameForRoute(mr.getRoute());
102 } else if (managedObject instanceof ManagedErrorHandler) {
103 ManagedErrorHandler meh = (ManagedErrorHandler) managedObject;
104 objectName = getManagementNamingStrategy().getObjectNameForErrorHandler(meh.getRouteContext(), meh.getErrorHandler(), meh.getErrorHandlerBuilder());
105 } else if (managedObject instanceof ManagedProcessor) {
106 ManagedProcessor mp = (ManagedProcessor) managedObject;
107 objectName = getManagementNamingStrategy().getObjectNameForProcessor(mp.getContext(), mp.getProcessor(), mp.getDefinition());
108 } else if (managedObject instanceof ManagedConsumer) {
109 ManagedConsumer ms = (ManagedConsumer) managedObject;
110 objectName = getManagementNamingStrategy().getObjectNameForConsumer(ms.getContext(), ms.getConsumer());
111 } else if (managedObject instanceof ManagedProducer) {
112 ManagedProducer ms = (ManagedProducer) managedObject;
113 objectName = getManagementNamingStrategy().getObjectNameForProducer(ms.getContext(), ms.getProducer());
114 } else if (managedObject instanceof ManagedTracer) {
115 ManagedTracer mt = (ManagedTracer) managedObject;
116 objectName = getManagementNamingStrategy().getObjectNameForTracer(mt.getContext(), mt.getTracer());
117 } else if (managedObject instanceof ManagedBacklogTracer) {
118 ManagedBacklogTracer mt = (ManagedBacklogTracer) managedObject;
119 objectName = getManagementNamingStrategy().getObjectNameForTracer(mt.getContext(), mt.getBacklogTracer());
120 } else if (managedObject instanceof ManagedBacklogDebugger) {
121 ManagedBacklogDebugger md = (ManagedBacklogDebugger) managedObject;
122 objectName = getManagementNamingStrategy().getObjectNameForTracer(md.getContext(), md.getBacklogDebugger());
123 } else if (managedObject instanceof ManagedEventNotifier) {
124 ManagedEventNotifier men = (ManagedEventNotifier) managedObject;
125 objectName = getManagementNamingStrategy().getObjectNameForEventNotifier(men.getContext(), men.getEventNotifier());
126 } else if (managedObject instanceof ManagedThreadPool) {
127 ManagedThreadPool mes = (ManagedThreadPool) managedObject;
128 objectName = getManagementNamingStrategy().getObjectNameForThreadPool(mes.getContext(), mes.getThreadPool(), mes.getId(), mes.getSourceId());
129 } else if (managedObject instanceof ManagedService) {
130 // check for managed service should be last
131 ManagedService ms = (ManagedService) managedObject;
132 // skip endpoints as they are already managed
133 if (ms.getService() instanceof Endpoint) {
134 return null;
135 }
136 objectName = getManagementNamingStrategy().getObjectNameForService(ms.getContext(), ms.getService());
137 }
138
139 return nameType.cast(objectName);
140 }
141
142 public void unmanageObject(Object managedObject) throws Exception {
143 ObjectName objectName = getManagedObjectName(managedObject, null, ObjectName.class);
144 unmanageNamedObject(objectName);
145 }
146
147 public void unmanageNamedObject(Object name) throws Exception {
148 ObjectName objectName = getObjectName(null, name);
149 if (objectName != null) {
150 getManagementAgent().unregister(objectName);
151 }
152 }
153
154 public boolean isManaged(Object managedObject, Object name) {
155 try {
156 ObjectName objectName = getObjectName(managedObject, name);
157 if (objectName != null) {
158 return getManagementAgent().isRegistered(objectName);
159 }
160 } catch (Exception e) {
161 LOG.warn("Cannot check whether the managed object is registered. This exception will be ignored.", e);
162 }
163 return false;
164 }
165
166 @Override
167 public boolean manageProcessor(ProcessorDefinition<?> definition) {
168 return true;
169 }
170
171 private ObjectName getObjectName(Object managedObject, Object preferedName) throws Exception {
172 ObjectName objectName;
173
174 if (preferedName != null && preferedName instanceof String) {
175 String customName = (String) preferedName;
176 objectName = getManagedObjectName(managedObject, customName, ObjectName.class);
177 } else if (preferedName != null && preferedName instanceof ObjectName) {
178 objectName = (ObjectName) preferedName;
179 } else {
180 objectName = getManagedObjectName(managedObject, null, ObjectName.class);
181 }
182 return objectName;
183 }
184
185 @Override
186 protected void doStart() throws Exception {
187 LOG.info("JMX is enabled");
188 doStartManagementStrategy();
189 }
190
191 }