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