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