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