/** * Create, register, and return an MBean for this * <code>ContextEnvironment</code> object. * * @param environment The ContextEnvironment to be managed * * @exception Exception if an MBean cannot be created or registered */ public static DynamicMBean createMBean(ContextEnvironment environment) throws Exception { String mname = createManagedName(environment); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(environment); ObjectName oname = createObjectName(domain, environment); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this * <code>ContextResource</code> object. * * @param resource The ContextResource to be managed * * @exception Exception if an MBean cannot be created or registered */ public static DynamicMBean createMBean(ContextResource resource) throws Exception { String mname = createManagedName(resource); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(resource); ObjectName oname = createObjectName(domain, resource); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this * <code>ContextResourceLink</code> object. * * @param resourceLink The ContextResourceLink to be managed * * @exception Exception if an MBean cannot be created or registered */ public static DynamicMBean createMBean(ContextResourceLink resourceLink) throws Exception { String mname = createManagedName(resourceLink); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(resourceLink); ObjectName oname = createObjectName(domain, resourceLink); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this * <code>Group</code> object. * * @param group The Group to be managed * * @exception Exception if an MBean cannot be created or registered */ static DynamicMBean createMBean(Group group) throws Exception { String mname = createManagedName(group); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(group); ObjectName oname = createObjectName(domain, group); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this <code>Role</code> object. * * @param role * The Role to be managed * * @exception Exception * if an MBean cannot be created or registered */ static DynamicMBean createMBean(Role role) throws Exception { String mname = createManagedName(role); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with " + mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(role); ObjectName oname = createObjectName(domain, role); if (mserver.isRegistered(oname)) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
public Object invoke(ObjectName name, String operationName, Object params[], String signature[]) throws InstanceNotFoundException, MBeanException, ReflectionException { name = nonDefaultDomain(name); DynamicMBean instance = getMBean(name); checkMBeanPermission(instance, operationName, name, "invoke"); try { return instance.invoke(operationName, params, signature); } catch (Throwable t) { rethrowMaybeMBeanException(t); throw new AssertionError(); } }
/** * Create, register, and return an MBean for this * <code>NamingResources</code> object. * * @param resource The NamingResources to be managed * * @exception Exception if an MBean cannot be created or registered * * @deprecated Unused. Will be removed in Tomcat 8.0.x */ @Deprecated static DynamicMBean createMBean(NamingResources resource) throws Exception { String mname = createManagedName(resource); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(resource); ObjectName oname = createObjectName(domain, resource); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this * <code>Role</code> object. * * @param role The Role to be managed * * @exception Exception if an MBean cannot be created or registered */ static DynamicMBean createMBean(Role role) throws Exception { String mname = createManagedName(role); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(role); ObjectName oname = createObjectName(domain, role); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this * <code>User</code> object. * * @param user The User to be managed * * @exception Exception if an MBean cannot be created or registered */ static DynamicMBean createMBean(User user) throws Exception { String mname = createManagedName(user); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(user); ObjectName oname = createObjectName(domain, user); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this * <code>UserDatabase</code> object. * * @param userDatabase The UserDatabase to be managed * * @exception Exception if an MBean cannot be created or registered */ static DynamicMBean createMBean(UserDatabase userDatabase) throws Exception { String mname = createManagedName(userDatabase); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(userDatabase); ObjectName oname = createObjectName(domain, userDatabase); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Build an adapted MBean for the given bean instance, if possible. * <p>The default implementation builds a JMX 1.2 StandardMBean * for the target's MBean/MXBean interface in case of an AOP proxy, * delegating the interface's management operations to the proxy. * @param bean the original bean instance * @return the adapted MBean, or {@code null} if not possible */ @SuppressWarnings("unchecked") protected DynamicMBean adaptMBeanIfPossible(Object bean) throws JMException { Class<?> targetClass = AopUtils.getTargetClass(bean); if (targetClass != bean.getClass()) { Class<?> ifc = JmxUtils.getMXBeanInterface(targetClass); if (ifc != null) { if (!ifc.isInstance(bean)) { throw new NotCompliantMBeanException("Managed bean [" + bean + "] has a target class with an MXBean interface but does not expose it in the proxy"); } return new StandardMBean(bean, ((Class<Object>) ifc), true); } else { ifc = JmxUtils.getMBeanInterface(targetClass); if (ifc != null) { if (!ifc.isInstance(bean)) { throw new NotCompliantMBeanException("Managed bean [" + bean + "] has a target class with an MBean interface but does not expose it in the proxy"); } return new StandardMBean(bean, ((Class<Object>) ifc)); } } } return null; }
/** * Create, register, and return an MBean for this * <code>Connector</code> object. * * @param connector The Connector to be managed * * @exception Exception if an MBean cannot be created or registered */ static DynamicMBean createMBean(Connector connector) throws Exception { String mname = createManagedName(connector); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(connector); ObjectName oname = createObjectName(domain, connector); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this * <code>ContextResourceLink</code> object. * * @param resourceLink The ContextResourceLink to be managed * * @exception Exception if an MBean cannot be created or registered */ static DynamicMBean createMBean(ContextResourceLink resourceLink) throws Exception { String mname = createManagedName(resourceLink); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(resourceLink); ObjectName oname = createObjectName(domain, resourceLink); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this * <code>Engine</code> object. * * @param engine The Engine to be managed * * @exception Exception if an MBean cannot be created or registered */ static DynamicMBean createMBean(Engine engine) throws Exception { String mname = createManagedName(engine); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(engine); ObjectName oname = createObjectName(domain, engine); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
private static String getNewMBeanClassName(Object mbeanToRegister) throws NotCompliantMBeanException { if (mbeanToRegister instanceof DynamicMBean) { DynamicMBean mbean = (DynamicMBean) mbeanToRegister; final String name; try { name = mbean.getMBeanInfo().getClassName(); } catch (Exception e) { // Includes case where getMBeanInfo() returns null NotCompliantMBeanException ncmbe = new NotCompliantMBeanException("Bad getMBeanInfo()"); ncmbe.initCause(e); throw ncmbe; } if (name == null) { final String msg = "MBeanInfo has null class name"; throw new NotCompliantMBeanException(msg); } return name; } else return mbeanToRegister.getClass().getName(); }
/** * Create, register, and return an MBean for this * <code>Loader</code> object. * * @param loader The Loader to be managed * * @exception Exception if an MBean cannot be created or registered */ static DynamicMBean createMBean(Loader loader) throws Exception { String mname = createManagedName(loader); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(loader); ObjectName oname = createObjectName(domain, loader); if( mserver.isRegistered( oname )) { // side effect: stop it mserver.unregisterMBean( oname ); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this * <code>MBeanFactory</code> object. * * @param factory The MBeanFactory to be managed * * @exception Exception if an MBean cannot be created or registered */ static DynamicMBean createMBean(MBeanFactory factory) throws Exception { String mname = createManagedName(factory); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(factory); ObjectName oname = createObjectName(domain, factory); if( mserver.isRegistered(oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
private static void postRegister( ObjectName logicalName, DynamicMBean mbean, boolean registrationDone, boolean registerFailed) { if (registerFailed && mbean instanceof DynamicMBean2) ((DynamicMBean2) mbean).registerFailed(); try { if (mbean instanceof MBeanRegistration) ((MBeanRegistration) mbean).postRegister(registrationDone); } catch (RuntimeException e) { MBEANSERVER_LOGGER.log(Level.DEBUG, "While registering MBean ["+logicalName+ "]: " + "Exception thrown by postRegister: " + "rethrowing <"+e+">, but keeping the MBean registered"); throw new RuntimeMBeanException(e, "RuntimeException thrown in postRegister method: "+ "rethrowing <"+e+">, but keeping the MBean registered"); } catch (Error er) { MBEANSERVER_LOGGER.log(Level.DEBUG, "While registering MBean ["+logicalName+ "]: " + "Error thrown by postRegister: " + "rethrowing <"+er+">, but keeping the MBean registered"); throw new RuntimeErrorException(er, "Error thrown in postRegister method: "+ "rethrowing <"+er+">, but keeping the MBean registered"); } }
/** * Create, register, and return an MBean for this * <code>Realm</code> object. * * @param realm The Realm to be managed * * @exception Exception if an MBean cannot be created or registered */ static DynamicMBean createMBean(Realm realm) throws Exception { String mname = createManagedName(realm); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(realm); ObjectName oname = createObjectName(domain, realm); if( mserver.isRegistered( oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this <code>UserDatabase</code> * object. * * @param userDatabase * The UserDatabase to be managed * * @exception Exception * if an MBean cannot be created or registered */ static DynamicMBean createMBean(UserDatabase userDatabase) throws Exception { String mname = createManagedName(userDatabase); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with " + mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(userDatabase); ObjectName oname = createObjectName(domain, userDatabase); if (mserver.isRegistered(oname)) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
private static ObjectName preRegister( DynamicMBean mbean, MBeanServer mbs, ObjectName name) throws InstanceAlreadyExistsException, MBeanRegistrationException { ObjectName newName = null; try { if (mbean instanceof MBeanRegistration) newName = ((MBeanRegistration) mbean).preRegister(mbs, name); } catch (Throwable t) { throwMBeanRegistrationException(t, "in preRegister method"); } if (newName != null) return newName; else return name; }
private static void postRegister( ObjectName logicalName, DynamicMBean mbean, boolean registrationDone, boolean registerFailed) { if (registerFailed && mbean instanceof DynamicMBean2) ((DynamicMBean2) mbean).registerFailed(); try { if (mbean instanceof MBeanRegistration) ((MBeanRegistration) mbean).postRegister(registrationDone); } catch (RuntimeException e) { MBEANSERVER_LOGGER.fine("While registering MBean ["+logicalName+ "]: " + "Exception thrown by postRegister: " + "rethrowing <"+e+">, but keeping the MBean registered"); throw new RuntimeMBeanException(e, "RuntimeException thrown in postRegister method: "+ "rethrowing <"+e+">, but keeping the MBean registered"); } catch (Error er) { MBEANSERVER_LOGGER.fine("While registering MBean ["+logicalName+ "]: " + "Error thrown by postRegister: " + "rethrowing <"+er+">, but keeping the MBean registered"); throw new RuntimeErrorException(er, "Error thrown in postRegister method: "+ "rethrowing <"+er+">, but keeping the MBean registered"); } }
@Test public void testReadAttributes() throws Exception { DynamicMBean proxy = JMX.newMBeanProxy(platformMBeanServer, threadPoolDynamicWrapperON, DynamicMBean.class); assertEquals(threadCount, proxy.getAttribute(THREAD_COUNT)); assertEquals(threadPoolConfigBean.isTriggerNewInstanceCreation(), proxy.getAttribute(TRIGGER_NEW_INSTANCE_CREATION)); AttributeList attributes = proxy.getAttributes(new String[] { THREAD_COUNT, TRIGGER_NEW_INSTANCE_CREATION }); assertEquals(2, attributes.size()); Attribute threadCountAttr = (Attribute) attributes.get(0); assertEquals(THREAD_COUNT, threadCountAttr.getName()); assertEquals(threadCount, threadCountAttr.getValue()); Attribute boolTestAttr = (Attribute) attributes.get(1); assertEquals(TRIGGER_NEW_INSTANCE_CREATION, boolTestAttr.getName()); assertEquals(threadPoolConfigBean.isTriggerNewInstanceCreation(), boolTestAttr.getValue()); MBeanInfo beanInfo = proxy.getMBeanInfo(); assertEquals(2, beanInfo.getAttributes().length); }
private NotificationListener getListener(ObjectName listener) throws ListenerNotFoundException { // ---------------- // Get listener object // ---------------- DynamicMBean instance; try { instance = getMBean(listener); } catch (InstanceNotFoundException e) { throw EnvHelp.initCause( new ListenerNotFoundException(e.getMessage()), e); } Object resource = getResource(instance); if (!(resource instanceof NotificationListener)) { final RuntimeException exc = new IllegalArgumentException(listener.getCanonicalName()); final String msg = "MBean " + listener.getCanonicalName() + " does not " + "implement " + NotificationListener.class.getName(); throw new RuntimeOperationsException(exc, msg); } return (NotificationListener) resource; }
/** * Create, register, and return an MBean for this <code>Group</code> object. * * @param group * The Group to be managed * * @exception Exception * if an MBean cannot be created or registered */ static DynamicMBean createMBean(Group group) throws Exception { String mname = createManagedName(group); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with " + mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(group); ObjectName oname = createObjectName(domain, group); if (mserver.isRegistered(oname)) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
private NotificationListener getListenerWrapper(NotificationListener l, ObjectName name, DynamicMBean mbean, boolean create) { Object resource = getResource(mbean); ListenerWrapper wrapper = new ListenerWrapper(l, name, resource); synchronized (listenerWrappers) { WeakReference<ListenerWrapper> ref = listenerWrappers.get(wrapper); if (ref != null) { NotificationListener existing = ref.get(); if (existing != null) return existing; } if (create) { ref = new WeakReference<ListenerWrapper>(wrapper); listenerWrappers.put(wrapper, ref); return wrapper; } else return null; } }
/** * <p>Return the named {@link java.lang.ClassLoader}. * @param loaderName The ObjectName of the ClassLoader. * @return The named ClassLoader. * @exception InstanceNotFoundException if the named ClassLoader * is not found. */ public ClassLoader getClassLoader(ObjectName loaderName) throws InstanceNotFoundException { if (loaderName == null) { checkMBeanPermission((String) null, null, null, "getClassLoader"); return server.getClass().getClassLoader(); } DynamicMBean instance = getMBean(loaderName); checkMBeanPermission(instance, null, loaderName, "getClassLoader"); Object resource = getResource(instance); /* Check if the given MBean is a ClassLoader */ if (!(resource instanceof ClassLoader)) throw new InstanceNotFoundException(loaderName.toString() + " is not a classloader"); return (ClassLoader) resource; }
/** * Create, register, and return an MBean for this * <code>MBeanFactory</code> object. * * @param factory The MBeanFactory to be managed * * @exception Exception if an MBean cannot be created or registered * * @deprecated Unused. Will be removed in Tomcat 8.0.x */ @Deprecated static DynamicMBean createMBean(MBeanFactory factory) throws Exception { String mname = createManagedName(factory); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with "+mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(factory); ObjectName oname = createObjectName(domain, factory); if( mserver.isRegistered(oname )) { mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
/** * Create, register, and return an MBean for this <code>Loader</code> * object. * * @param loader * The Loader to be managed * * @exception Exception * if an MBean cannot be created or registered * * @deprecated Unused. Will be removed in Tomcat 8.0.x */ @Deprecated static DynamicMBean createMBean(Loader loader) throws Exception { String mname = createManagedName(loader); ManagedBean managed = registry.findManagedBean(mname); if (managed == null) { Exception e = new Exception("ManagedBean is not found with " + mname); throw new MBeanException(e); } String domain = managed.getDomain(); if (domain == null) domain = mserver.getDefaultDomain(); DynamicMBean mbean = managed.createMBean(loader); ObjectName oname = createObjectName(domain, loader); if (mserver.isRegistered(oname)) { // side effect: stop it mserver.unregisterMBean(oname); } mserver.registerMBean(mbean, oname); return (mbean); }
