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}