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 */ 017package org.apache.camel.management; 018 019import javax.management.ObjectName; 020 021import org.apache.camel.CamelContext; 022import org.apache.camel.Endpoint; 023import org.apache.camel.management.mbean.ManagedBacklogDebugger; 024import org.apache.camel.management.mbean.ManagedBacklogTracer; 025import org.apache.camel.management.mbean.ManagedCamelContext; 026import org.apache.camel.management.mbean.ManagedComponent; 027import org.apache.camel.management.mbean.ManagedConsumer; 028import org.apache.camel.management.mbean.ManagedEndpoint; 029import org.apache.camel.management.mbean.ManagedErrorHandler; 030import org.apache.camel.management.mbean.ManagedEventNotifier; 031import org.apache.camel.management.mbean.ManagedProcessor; 032import org.apache.camel.management.mbean.ManagedProducer; 033import org.apache.camel.management.mbean.ManagedRoute; 034import org.apache.camel.management.mbean.ManagedService; 035import org.apache.camel.management.mbean.ManagedThreadPool; 036import org.apache.camel.management.mbean.ManagedTracer; 037import org.apache.camel.model.ProcessorDefinition; 038import org.apache.camel.spi.ManagementAgent; 039import org.slf4j.Logger; 040import 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 */ 052public 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}