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 java.net.UnknownHostException;
020import java.util.concurrent.ThreadPoolExecutor;
021import javax.management.MalformedObjectNameException;
022import javax.management.ObjectName;
023
024import org.apache.camel.CamelContext;
025import org.apache.camel.CamelContextAware;
026import org.apache.camel.Component;
027import org.apache.camel.Consumer;
028import org.apache.camel.Endpoint;
029import org.apache.camel.ErrorHandlerFactory;
030import org.apache.camel.NamedNode;
031import org.apache.camel.Processor;
032import org.apache.camel.Producer;
033import org.apache.camel.Route;
034import org.apache.camel.Service;
035import org.apache.camel.StaticService;
036import org.apache.camel.builder.ErrorHandlerBuilderRef;
037import org.apache.camel.cluster.CamelClusterService;
038import org.apache.camel.management.mbean.ManagedBacklogDebugger;
039import org.apache.camel.management.mbean.ManagedBacklogTracer;
040import org.apache.camel.management.mbean.ManagedCamelContext;
041import org.apache.camel.management.mbean.ManagedCamelHealth;
042import org.apache.camel.management.mbean.ManagedClusterService;
043import org.apache.camel.management.mbean.ManagedComponent;
044import org.apache.camel.management.mbean.ManagedConsumer;
045import org.apache.camel.management.mbean.ManagedDataFormat;
046import org.apache.camel.management.mbean.ManagedEndpoint;
047import org.apache.camel.management.mbean.ManagedErrorHandler;
048import org.apache.camel.management.mbean.ManagedEventNotifier;
049import org.apache.camel.management.mbean.ManagedProcessor;
050import org.apache.camel.management.mbean.ManagedProducer;
051import org.apache.camel.management.mbean.ManagedRoute;
052import org.apache.camel.management.mbean.ManagedRouteController;
053import org.apache.camel.management.mbean.ManagedService;
054import org.apache.camel.management.mbean.ManagedStep;
055import org.apache.camel.management.mbean.ManagedThreadPool;
056import org.apache.camel.spi.DataFormat;
057import org.apache.camel.spi.EventNotifier;
058import org.apache.camel.spi.ManagementObjectNameStrategy;
059import org.apache.camel.spi.RouteContext;
060import org.apache.camel.util.InetAddressUtil;
061import org.apache.camel.util.ObjectHelper;
062import org.apache.camel.util.URISupport;
063
064/**
065 * Naming strategy used when registering MBeans.
066 */
067public class DefaultManagementObjectNameStrategy implements ManagementObjectNameStrategy, CamelContextAware {
068    public static final String VALUE_UNKNOWN = "unknown";
069    public static final String KEY_NAME = "name";
070    public static final String KEY_TYPE = "type";
071    public static final String KEY_CONTEXT = "context";
072    public static final String TYPE_CONTEXT = "context";
073    public static final String TYPE_ROUTE_CONTROLLER = "routecontrollers";
074    public static final String TYPE_HEALTH = "health";
075    public static final String TYPE_ENDPOINT = "endpoints";
076    public static final String TYPE_DATAFORMAT = "dataformats";
077    public static final String TYPE_PROCESSOR = "processors";
078    public static final String TYPE_CONSUMER = "consumers";
079    public static final String TYPE_PRODUCER = "producers";
080    public static final String TYPE_ROUTE = "routes";
081    public static final String TYPE_COMPONENT = "components";
082    public static final String TYPE_STEP = "steps";
083    public static final String TYPE_TRACER = "tracer";
084    public static final String TYPE_EVENT_NOTIFIER = "eventnotifiers";
085    public static final String TYPE_ERRORHANDLER = "errorhandlers";
086    public static final String TYPE_THREAD_POOL = "threadpools";
087    public static final String TYPE_SERVICE = "services";
088    public static final String TYPE_HA = "clusterservices";
089
090    protected String domainName;
091    protected String hostName = "localhost";
092    protected CamelContext camelContext;
093
094    public DefaultManagementObjectNameStrategy() {
095        this(null);
096        // default constructor needed for <bean> style configuration
097    }
098
099    public DefaultManagementObjectNameStrategy(String domainName) {
100        this.domainName = domainName != null ? domainName : "org.apache.camel";
101        try {
102            hostName = InetAddressUtil.getLocalHostName();
103        } catch (UnknownHostException ex) {
104            // ignore, use the default "localhost"
105        }
106    }
107
108    public CamelContext getCamelContext() {
109        return camelContext;
110    }
111
112    public void setCamelContext(CamelContext camelContext) {
113        this.camelContext = camelContext;
114    }
115
116    public ObjectName getObjectName(Object managedObject) throws MalformedObjectNameException {
117        if (managedObject == null) {
118            return null;
119        }
120        ObjectName objectName = null;
121        if (managedObject instanceof ManagedCamelContext) {
122            ManagedCamelContext mcc = (ManagedCamelContext) managedObject;
123            objectName = getObjectNameForCamelContext(mcc.getContext());
124        } else if (managedObject instanceof ManagedCamelHealth) {
125            ManagedCamelHealth mch = (ManagedCamelHealth) managedObject;
126            objectName = getObjectNameForCamelHealth(mch.getContext());
127        } else if (managedObject instanceof ManagedRouteController) {
128            ManagedRouteController mrc = (ManagedRouteController) managedObject;
129            objectName = getObjectNameForRouteController(mrc.getContext());
130        } else if (managedObject instanceof ManagedComponent) {
131            ManagedComponent mc = (ManagedComponent) managedObject;
132            objectName = getObjectNameForComponent(mc.getComponent(), mc.getComponentName());
133        } else if (managedObject instanceof ManagedDataFormat) {
134            ManagedDataFormat md = (ManagedDataFormat) managedObject;
135            objectName = getObjectNameForDataFormat(md.getContext(), md.getDataFormat());
136        } else if (managedObject instanceof ManagedEndpoint) {
137            ManagedEndpoint me = (ManagedEndpoint) managedObject;
138            objectName = getObjectNameForEndpoint(me.getEndpoint());
139        } else if (managedObject instanceof Endpoint) {
140            objectName = getObjectNameForEndpoint((Endpoint) managedObject);
141        } else if (managedObject instanceof ManagedRoute) {
142            ManagedRoute mr = (ManagedRoute) managedObject;
143            objectName = getObjectNameForRoute(mr.getRoute());
144        } else if (managedObject instanceof ManagedErrorHandler) {
145            ManagedErrorHandler meh = (ManagedErrorHandler) managedObject;
146            objectName = getObjectNameForErrorHandler(meh.getRouteContext(), meh.getErrorHandler(), meh.getErrorHandlerBuilder());
147        } else if (managedObject instanceof ManagedStep) {
148            ManagedStep mp = (ManagedStep) managedObject;
149            objectName = getObjectNameForStep(mp.getContext(), mp.getProcessor(), mp.getDefinition());
150        } else if (managedObject instanceof ManagedProcessor) {
151            ManagedProcessor mp = (ManagedProcessor) managedObject;
152            objectName = getObjectNameForProcessor(mp.getContext(), mp.getProcessor(), mp.getDefinition());
153        } else if (managedObject instanceof ManagedConsumer) {
154            ManagedConsumer ms = (ManagedConsumer) managedObject;
155            objectName = getObjectNameForConsumer(ms.getContext(), ms.getConsumer());
156        } else if (managedObject instanceof ManagedProducer) {
157            ManagedProducer ms = (ManagedProducer) managedObject;
158            objectName = getObjectNameForProducer(ms.getContext(), ms.getProducer());
159        } else if (managedObject instanceof ManagedBacklogTracer) {
160            ManagedBacklogTracer mt = (ManagedBacklogTracer) managedObject;
161            objectName = getObjectNameForTracer(mt.getContext(), mt.getBacklogTracer());
162        } else if (managedObject instanceof ManagedBacklogDebugger) {
163            ManagedBacklogDebugger md = (ManagedBacklogDebugger) managedObject;
164            objectName = getObjectNameForTracer(md.getContext(), md.getBacklogDebugger());
165        } else if (managedObject instanceof ManagedEventNotifier) {
166            ManagedEventNotifier men = (ManagedEventNotifier) managedObject;
167            objectName = getObjectNameForEventNotifier(men.getContext(), men.getEventNotifier());
168        } else if (managedObject instanceof ManagedThreadPool) {
169            ManagedThreadPool mes = (ManagedThreadPool) managedObject;
170            objectName = getObjectNameForThreadPool(mes.getContext(), mes.getThreadPool(), mes.getId(), mes.getSourceId());
171        } else if (managedObject instanceof ManagedClusterService) {
172            ManagedClusterService mcs = (ManagedClusterService) managedObject;
173            objectName = getObjectNameForClusterService(mcs.getContext(), mcs.getService());
174        } else if (managedObject instanceof ManagedService) {
175            // check for managed service should be last
176            ManagedService ms = (ManagedService) managedObject;
177            // skip endpoints as they are already managed
178            if (ms.getService() instanceof Endpoint) {
179                return null;
180            }
181            objectName = getObjectNameForService(ms.getContext(), ms.getService());
182        }
183
184        return objectName;
185    }
186
187    public ObjectName getObjectNameForCamelContext(String managementName, String name) throws MalformedObjectNameException {
188        StringBuilder buffer = new StringBuilder();
189        buffer.append(domainName).append(":");
190        buffer.append(KEY_CONTEXT + "=").append(getContextId(managementName)).append(",");
191        buffer.append(KEY_TYPE + "=" + TYPE_CONTEXT + ",");
192        buffer.append(KEY_NAME + "=").append(ObjectName.quote(name));
193        return createObjectName(buffer);
194    }
195
196    public ObjectName getObjectNameForCamelContext(CamelContext context) throws MalformedObjectNameException {
197        // prefer to use the given management name if previously assigned
198        String managementName = context.getManagementName();
199        if (managementName == null) {
200            managementName = context.getManagementNameStrategy().getName();
201        }
202        String name = context.getName();
203        return getObjectNameForCamelContext(managementName, name);
204    }
205
206    @Override
207    public ObjectName getObjectNameForCamelHealth(CamelContext context) throws MalformedObjectNameException {
208        // prefer to use the given management name if previously assigned
209        String managementName = context.getManagementName();
210        if (managementName == null) {
211            managementName = context.getManagementNameStrategy().getName();
212        }
213
214        StringBuilder buffer = new StringBuilder();
215        buffer.append(domainName).append(":");
216        buffer.append(KEY_CONTEXT + "=").append(getContextId(managementName)).append(",");
217        buffer.append(KEY_TYPE + "=" + TYPE_HEALTH + ",");
218        buffer.append(KEY_NAME + "=").append(ObjectName.quote(context.getName()));
219
220        return createObjectName(buffer);
221    }
222
223    @Override
224    public ObjectName getObjectNameForRouteController(CamelContext context) throws MalformedObjectNameException {
225        // prefer to use the given management name if previously assigned
226        String managementName = context.getManagementName();
227        if (managementName == null) {
228            managementName = context.getManagementNameStrategy().getName();
229        }
230
231        StringBuilder buffer = new StringBuilder();
232        buffer.append(domainName).append(":");
233        buffer.append(KEY_CONTEXT + "=").append(getContextId(managementName)).append(",");
234        buffer.append(KEY_TYPE + "=" + TYPE_ROUTE_CONTROLLER + ",");
235        buffer.append(KEY_NAME + "=").append(ObjectName.quote(context.getName()));
236
237        return createObjectName(buffer);
238    }
239
240    public ObjectName getObjectNameForEndpoint(Endpoint endpoint) throws MalformedObjectNameException {
241        StringBuilder buffer = new StringBuilder();
242        buffer.append(domainName).append(":");
243        buffer.append(KEY_CONTEXT + "=").append(getContextId(endpoint.getCamelContext())).append(",");
244        buffer.append(KEY_TYPE + "=" + TYPE_ENDPOINT + ",");
245        buffer.append(KEY_NAME + "=").append(ObjectName.quote(getEndpointId(endpoint)));
246        return createObjectName(buffer);
247    }
248
249    public ObjectName getObjectNameForDataFormat(CamelContext context, DataFormat dataFormat) throws MalformedObjectNameException {
250        StringBuilder buffer = new StringBuilder();
251        buffer.append(domainName).append(":");
252        buffer.append(KEY_CONTEXT + "=").append(getContextId(context)).append(",");
253        buffer.append(KEY_TYPE + "=" + TYPE_DATAFORMAT + ",");
254        buffer.append(KEY_NAME + "=").append(dataFormat.getClass().getSimpleName());
255        if (!(dataFormat instanceof StaticService)) {
256            buffer.append("(").append(ObjectHelper.getIdentityHashCode(dataFormat)).append(")");
257        }
258        return createObjectName(buffer);
259    }
260
261    public ObjectName getObjectNameForComponent(Component component, String name) throws MalformedObjectNameException {
262        StringBuilder buffer = new StringBuilder();
263        buffer.append(domainName).append(":");
264        buffer.append(KEY_CONTEXT + "=").append(getContextId(component.getCamelContext())).append(",");
265        buffer.append(KEY_TYPE + "=" + TYPE_COMPONENT + ",");
266        buffer.append(KEY_NAME + "=").append(ObjectName.quote(name));
267        return createObjectName(buffer);
268    }
269
270    public ObjectName getObjectNameForProcessor(CamelContext context, Processor processor, NamedNode definition) throws MalformedObjectNameException {
271        StringBuilder buffer = new StringBuilder();
272        buffer.append(domainName).append(":");
273        buffer.append(KEY_CONTEXT + "=").append(getContextId(context)).append(",");
274        buffer.append(KEY_TYPE + "=").append(TYPE_PROCESSOR).append(",");
275        buffer.append(KEY_NAME + "=").append(ObjectName.quote(definition.getId()));
276        return createObjectName(buffer);
277    }
278
279    public ObjectName getObjectNameForStep(CamelContext context, Processor processor, NamedNode definition) throws MalformedObjectNameException {
280        StringBuilder buffer = new StringBuilder();
281        buffer.append(domainName).append(":");
282        buffer.append(KEY_CONTEXT + "=").append(getContextId(context)).append(",");
283        buffer.append(KEY_TYPE + "=").append(TYPE_STEP).append(",");
284        buffer.append(KEY_NAME + "=").append(ObjectName.quote(definition.getId()));
285        return createObjectName(buffer);
286    }
287
288    public ObjectName getObjectNameForErrorHandler(RouteContext routeContext, Processor errorHandler, ErrorHandlerFactory builder) throws MalformedObjectNameException {
289        StringBuilder buffer = new StringBuilder();
290        buffer.append(domainName).append(":");
291        buffer.append(KEY_CONTEXT + "=").append(getContextId(routeContext.getCamelContext())).append(",");
292        buffer.append(KEY_TYPE + "=").append(TYPE_ERRORHANDLER + ",");
293
294        // we want to only register one instance of the various error handler types and thus do some lookup
295        // if its a ErrorHandlerBuildRef. We need a bit of work to do that as there are potential indirection.
296        String ref = null;
297        if (builder instanceof ErrorHandlerBuilderRef) {
298            ErrorHandlerBuilderRef builderRef = (ErrorHandlerBuilderRef) builder;
299
300            // it has not then its an indirection and we should do some work to lookup the real builder
301            ref = builderRef.getRef();
302            ErrorHandlerFactory refBuilder = ErrorHandlerBuilderRef.lookupErrorHandlerBuilder(routeContext, builderRef.getRef(), false);
303            if (refBuilder != null) {
304                builder = refBuilder;
305            }
306
307            // must do a 2nd lookup in case this is also a reference
308            // (this happens with spring DSL using errorHandlerRef on <route> as it gets a bit
309            // complex with indirections for error handler references
310            if (builder instanceof ErrorHandlerBuilderRef) {
311                builderRef = (ErrorHandlerBuilderRef) builder;
312                // does it refer to a non default error handler then do a 2nd lookup
313                if (!builderRef.getRef().equals(ErrorHandlerBuilderRef.DEFAULT_ERROR_HANDLER_BUILDER)) {
314                    refBuilder = ErrorHandlerBuilderRef.lookupErrorHandlerBuilder(routeContext, builderRef.getRef(), false);
315                    if (refBuilder != null) {
316                        ref = builderRef.getRef();
317                        builder = refBuilder;
318                    }
319                }
320            }
321        }
322
323        if (ref != null) {
324            String name = builder.getClass().getSimpleName() + "(ref:" + ref + ")";
325            buffer.append(KEY_NAME + "=").append(ObjectName.quote(name));
326        } else {
327            // create a name based on its instance
328            buffer.append(KEY_NAME + "=")
329                .append(builder.getClass().getSimpleName())
330                .append("(").append(ObjectHelper.getIdentityHashCode(builder)).append(")");
331        }
332
333        return createObjectName(buffer);
334    }
335
336    public ObjectName getObjectNameForConsumer(CamelContext context, Consumer consumer) throws MalformedObjectNameException {
337        StringBuilder buffer = new StringBuilder();
338        buffer.append(domainName).append(":");
339        buffer.append(KEY_CONTEXT + "=").append(getContextId(context)).append(",");
340        buffer.append(KEY_TYPE + "=").append(TYPE_CONSUMER).append(",");
341
342        String name = consumer.getClass().getSimpleName();
343        if (ObjectHelper.isEmpty(name)) {
344            name = "Consumer";
345        }
346        buffer.append(KEY_NAME + "=")
347            .append(name)
348            .append("(").append(ObjectHelper.getIdentityHashCode(consumer)).append(")");
349        return createObjectName(buffer);
350    }
351
352    public ObjectName getObjectNameForProducer(CamelContext context, Producer producer) throws MalformedObjectNameException {
353        StringBuilder buffer = new StringBuilder();
354        buffer.append(domainName).append(":");
355        buffer.append(KEY_CONTEXT + "=").append(getContextId(context)).append(",");
356        buffer.append(KEY_TYPE + "=").append(TYPE_PRODUCER).append(",");
357
358        String name = producer.getClass().getSimpleName();
359        if (ObjectHelper.isEmpty(name)) {
360            name = "Producer";
361        }
362        buffer.append(KEY_NAME + "=")
363            .append(name)
364            .append("(").append(ObjectHelper.getIdentityHashCode(producer)).append(")");
365        return createObjectName(buffer);
366    }
367
368    public ObjectName getObjectNameForTracer(CamelContext context, Service tracer) throws MalformedObjectNameException {
369        // use the simple name of the class as the mbean name (eg Tracer, BacklogTracer, BacklogDebugger)
370        String name = tracer.getClass().getSimpleName();
371
372        StringBuilder buffer = new StringBuilder();
373        buffer.append(domainName).append(":");
374        buffer.append(KEY_CONTEXT + "=").append(getContextId(context)).append(",");
375        buffer.append(KEY_TYPE + "=" + TYPE_TRACER + ",");
376        buffer.append(KEY_NAME + "=").append(name);
377        return createObjectName(buffer);
378    }
379
380    public ObjectName getObjectNameForEventNotifier(CamelContext context, EventNotifier eventNotifier) throws MalformedObjectNameException {
381        StringBuilder buffer = new StringBuilder();
382        buffer.append(domainName).append(":");
383        buffer.append(KEY_CONTEXT + "=").append(getContextId(context)).append(",");
384        buffer.append(KEY_TYPE + "=" + TYPE_EVENT_NOTIFIER + ",");
385
386        if (eventNotifier instanceof JmxNotificationEventNotifier) {
387            // JMX notifier shall have an easy to use name
388            buffer.append(KEY_NAME + "=").append("JmxEventNotifier");
389        } else {
390            // others can be per instance
391            buffer.append(KEY_NAME + "=")
392                .append("EventNotifier")
393                .append("(").append(ObjectHelper.getIdentityHashCode(eventNotifier)).append(")");
394        }
395        return createObjectName(buffer);
396    }
397
398    public ObjectName getObjectNameForRoute(Route route) throws MalformedObjectNameException {
399        Endpoint ep = route.getEndpoint();
400        String id = route.getId();
401
402        StringBuilder buffer = new StringBuilder();
403        buffer.append(domainName).append(":");
404        buffer.append(KEY_CONTEXT + "=").append(getContextId(ep.getCamelContext())).append(",");
405        buffer.append(KEY_TYPE + "=" + TYPE_ROUTE + ",");
406        buffer.append(KEY_NAME + "=").append(ObjectName.quote(id));
407        return createObjectName(buffer);
408    }
409
410    public ObjectName getObjectNameForService(CamelContext context, Service service) throws MalformedObjectNameException {
411        StringBuilder buffer = new StringBuilder();
412        buffer.append(domainName).append(":");
413        buffer.append(KEY_CONTEXT + "=").append(getContextId(context)).append(",");
414        buffer.append(KEY_TYPE + "=" + TYPE_SERVICE + ",");
415        buffer.append(KEY_NAME + "=").append(service.getClass().getSimpleName());
416        if (!(service instanceof StaticService)) {
417            buffer.append("(").append(ObjectHelper.getIdentityHashCode(service)).append(")");
418        }
419        return createObjectName(buffer);
420    }
421
422    public ObjectName getObjectNameForClusterService(CamelContext context, CamelClusterService service) throws MalformedObjectNameException {
423        StringBuilder buffer = new StringBuilder();
424        buffer.append(domainName).append(":");
425        buffer.append(KEY_CONTEXT + "=").append(getContextId(context)).append(",");
426        buffer.append(KEY_TYPE + "=" + TYPE_HA + ",");
427        buffer.append(KEY_NAME + "=").append(service.getClass().getSimpleName());
428        if (!(service instanceof StaticService)) {
429            buffer.append("(").append(ObjectHelper.getIdentityHashCode(service)).append(")");
430        }
431        return createObjectName(buffer);
432    }
433
434    public ObjectName getObjectNameForThreadPool(CamelContext context, ThreadPoolExecutor threadPool, String id, String sourceId) throws MalformedObjectNameException {
435        StringBuilder buffer = new StringBuilder();
436        buffer.append(domainName).append(":");
437        buffer.append(KEY_CONTEXT + "=").append(getContextId(context)).append(",");
438        buffer.append(KEY_TYPE + "=" + TYPE_THREAD_POOL + ",");
439
440        String name = id;
441        if (sourceId != null) {
442            // provide source id if we know it, this helps end user to know where the pool is used
443            name = name + "(" + sourceId + ")";
444        }
445        buffer.append(KEY_NAME + "=").append(ObjectName.quote(name));
446        return createObjectName(buffer);
447    }
448
449    public String getDomainName() {
450        return domainName;
451    }
452
453    public void setDomainName(String domainName) {
454        this.domainName = domainName;
455    }
456
457    public String getHostName() {
458        return hostName;
459    }
460
461    public void setHostName(String hostName) {
462        this.hostName = hostName;
463    }
464
465    protected String getContextId(CamelContext context) {
466        if (context == null) {
467            return getContextId(VALUE_UNKNOWN);
468        } else {
469            String name = context.getManagementName() != null ? context.getManagementName() : context.getName();
470            return getContextId(name);
471        }
472    }
473
474    protected String getContextId(String name) {
475        Boolean includeHostName = camelContext != null && camelContext.getManagementStrategy().getManagementAgent().getIncludeHostName();
476        if (includeHostName != null && includeHostName) {
477            return hostName + "/" + (name != null ? name : VALUE_UNKNOWN);
478        } else {
479            return name != null ? name : VALUE_UNKNOWN;
480        }
481    }
482
483    protected String getEndpointId(Endpoint ep) {
484        String answer = doGetEndpointId(ep);
485        Boolean sanitize = camelContext != null && camelContext.getManagementStrategy().getManagementAgent().getMask();
486        if (sanitize != null && sanitize) {
487            // use xxxxxx as replacements as * has to be quoted for MBean names
488            answer = URISupport.sanitizeUri(answer);
489        }
490        return answer;
491    }
492
493    private String doGetEndpointId(Endpoint ep) {
494        if (ep.isSingleton()) {
495            return ep.getEndpointKey();
496        } else {
497            // non singleton then add hashcoded id
498            String uri = ep.getEndpointKey();
499            int pos = uri.indexOf('?');
500            String id = (pos == -1) ? uri : uri.substring(0, pos);
501            id += "?id=" + ObjectHelper.getIdentityHashCode(ep);
502            return id;
503        }
504    }
505
506    /**
507     * Factory method to create an ObjectName escaping any required characters
508     */
509    protected ObjectName createObjectName(StringBuilder buffer) throws MalformedObjectNameException {
510        String text = buffer.toString();
511        try {
512            return new ObjectName(text);
513        } catch (MalformedObjectNameException e) {
514            throw new MalformedObjectNameException("Could not create ObjectName from: " + text + ". Reason: " + e);
515        }
516    }
517}