[jboss-cvs] JBossAS SVN: r85235 - in trunk: profileservice and 4 other directories.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Wed Mar 4 11:06:47 EST 2009
Author: emuckenhuber
Date: 2009-03-04 11:06:46 -0500 (Wed, 04 Mar 2009)
New Revision: 85235
Added:
trunk/profileservice/src/main/org/jboss/profileservice/management/PlatformMBeanIDC.java
trunk/profileservice/src/main/org/jboss/profileservice/management/PlatformMBeanKernelRegistryPlugin.java
trunk/testsuite/src/main/org/jboss/test/profileservice/test/PlatformMBeanUnitTestCase.java
Modified:
trunk/component-matrix/pom.xml
trunk/profileservice/build.xml
trunk/profileservice/src/main/org/jboss/profileservice/management/ManagementViewImpl.java
trunk/profileservice/src/resources/profileservice-jboss-beans.xml
trunk/server/src/etc/conf/default/bootstrap/deployers.xml
trunk/testsuite/src/main/org/jboss/test/profileservice/test/ProfileServiceUnitTestCase.java
Log:
port r84865, JBAS-6285, add support for exposing platform mbeans as managed components
Modified: trunk/component-matrix/pom.xml
===================================================================
--- trunk/component-matrix/pom.xml 2009-03-04 16:04:36 UTC (rev 85234)
+++ trunk/component-matrix/pom.xml 2009-03-04 16:06:46 UTC (rev 85235)
@@ -73,7 +73,7 @@
<version.org.jboss.jpa>1.0.0-CR1</version.org.jboss.jpa>
<version.org.jboss.logbridge>1.0.0.CR1</version.org.jboss.logbridge>
<version.org.jboss.logmanager>1.0.0.CR1</version.org.jboss.logmanager>
- <version.org.jboss.man>2.1.0.CR1</version.org.jboss.man>
+ <version.org.jboss.man>2.1.0.CR2</version.org.jboss.man>
<version.org.jboss.mdr>2.0.1.GA</version.org.jboss.mdr>
<version.org.jboss.metadata>1.0.0.CR16</version.org.jboss.metadata>
<version.org.jboss.microcontainer>2.0.4.GA</version.org.jboss.microcontainer>
Modified: trunk/profileservice/build.xml
===================================================================
--- trunk/profileservice/build.xml 2009-03-04 16:04:36 UTC (rev 85234)
+++ trunk/profileservice/build.xml 2009-03-04 16:06:46 UTC (rev 85235)
@@ -86,6 +86,8 @@
<path refid="sun.jaxb.classpath"/>
<path refid="stax.api.classpath"/>
<path refid="org.jboss.aspects.classpath"/>
+ <path refid="jboss.systemjmx.classpath"/>
+ <path refid="jboss.j2se.classpath"/>
</path>
<!-- The combined dependant module classpath -->
Modified: trunk/profileservice/src/main/org/jboss/profileservice/management/ManagementViewImpl.java
===================================================================
--- trunk/profileservice/src/main/org/jboss/profileservice/management/ManagementViewImpl.java 2009-03-04 16:04:36 UTC (rev 85234)
+++ trunk/profileservice/src/main/org/jboss/profileservice/management/ManagementViewImpl.java 2009-03-04 16:06:46 UTC (rev 85235)
@@ -67,8 +67,11 @@
import org.jboss.managed.api.annotation.ManagementObjectRef;
import org.jboss.managed.api.annotation.ManagementProperty;
import org.jboss.managed.api.annotation.ViewUse;
+import org.jboss.managed.api.factory.ManagedObjectFactory;
import org.jboss.managed.plugins.ManagedComponentImpl;
+import org.jboss.managed.plugins.ManagedDeploymentImpl;
import org.jboss.managed.plugins.factory.AbstractManagedObjectFactory;
+import org.jboss.managed.plugins.jmx.ManagementFactoryUtils;
import org.jboss.metatype.api.types.ArrayMetaType;
import org.jboss.metatype.api.types.CollectionMetaType;
import org.jboss.metatype.api.types.MetaType;
@@ -140,7 +143,7 @@
private Map<String, ManagedDeployment> managedDeployments = new HashMap<String, ManagedDeployment>();
/** The root deployments to resolve the deployment name. */
private List<String> rootDeployments = new ArrayList<String>();
-
+
@Deprecated
private Map<String, ProfileKey> deploymentsToProfile = new HashMap<String, ProfileKey>();
@@ -150,8 +153,11 @@
/** The dispatcher handles ManagedOperation dispatches */
private RuntimeComponentDispatcher dispatcher;
private InvokerLocator locator;
+ /** . */
private MetaValueFactory metaValueFactory = MetaValueFactory.getInstance();
-
+ /** ManagedObjectFactory used for platform mbean ManagedObjects */
+ ManagedObjectFactory managedObjFactory = ManagedObjectFactory.getInstance();
+
public ManagementViewImpl() throws IOException
{
@@ -203,6 +209,42 @@
}
if(this.runtimeMOs.size() > 0)
log.warn("Failed to merged the following runtime ManagedObjects: "+runtimeMOs);
+
+ // Now create a ManagedDeployment for the platform beans
+ Map<String, ManagedObject> platformMBeanMOs = ManagementFactoryUtils.getPlatformMBeanMOs(managedObjFactory);
+ ManagedDeploymentImpl platformMBeans = new ManagedDeploymentImpl("JDK PlatformMBeans", "PlatformMBeans", null,
+ null, platformMBeanMOs);
+ List<ManagedObject> gcMbeans = ManagementFactoryUtils.getGarbageCollectorMXBeans(managedObjFactory);
+ Map<String, ManagedObject> gcMOs = new HashMap<String, ManagedObject>();
+ for (ManagedObject mo : gcMbeans)
+ gcMOs.put(mo.getName(), mo);
+ List<ManagedObject> mmMbeans = ManagementFactoryUtils.getMemoryManagerMXBeans(managedObjFactory);
+ Map<String, ManagedObject> mmMOs = new HashMap<String, ManagedObject>();
+ for (ManagedObject mo : mmMbeans)
+ mmMOs.put(mo.getName(), mo);
+ List<ManagedObject> mpoolMBeans = ManagementFactoryUtils.getMemoryPoolMXBeans(managedObjFactory);
+ Map<String, ManagedObject> mpoolMOs = new HashMap<String, ManagedObject>();
+ for (ManagedObject mo : mpoolMBeans)
+ mpoolMOs.put(mo.getName(), mo);
+ ManagedDeploymentImpl gcMD = new ManagedDeploymentImpl("GarbageCollectorMXBeans", "GarbageCollectorMXBeans",
+ null, null, gcMOs);
+ platformMBeans.getChildren().add(gcMD);
+ ManagedDeploymentImpl mmMD = new ManagedDeploymentImpl("MemoryManagerMXBeans", "MemoryManagerMXBeans", null,
+ null, mmMOs);
+ platformMBeans.getChildren().add(mmMD);
+ ManagedDeploymentImpl mpoolMD = new ManagedDeploymentImpl("MemoryPoolMXBeans", "MemoryPoolMXBeans", null, null,
+ mpoolMOs);
+ platformMBeans.getChildren().add(mpoolMD);
+
+ try
+ {
+ // Create the ManagedComponents
+ processManagedDeployment(platformMBeans, null, 0, trace);
+ }
+ catch(Exception e)
+ {
+ log.warn("Failed to process ManagedDeployments for the platform beans");
+ }
}
public void reload()
@@ -344,6 +386,7 @@
ManagementObject managementObject = (ManagementObject) moAnns.get(ManagementObject.class.getName());
if (managementObject.isRuntime())
{
+ boolean merged = false;
// Merge this with the ManagedObject
ManagedObject parentMO = moRegistry.get(key);
if (parentMO == null)
@@ -355,6 +398,7 @@
else
{
mergeRuntimeMO(parentMO, mo);
+ merged = true;
runtimeMOs.remove(key);
}
// Update the runtime state of any ManagedComponent associated with this runtime mo
@@ -364,8 +408,18 @@
RunState state = updateRunState(mo, comp);
log.debug("Updated component: "+comp+" run state to: "+state);
}
- // There is no further processing of runtime ManagedObjects
- return;
+ // There is no further processing of runtime ManagedObjects, unless its marked as a component
+ ManagementComponent mc = managementObject.componentType();
+ if (mc.type().length() == 0 && mc.subtype().length() == 0)
+ return;
+ //
+ else if (merged == false)
+ {
+ Set<ManagedOperation> runtimeOps = mo.getOperations();
+ runtimeOps = createOperationProxies(mo, runtimeOps);
+ MutableManagedObject moi = (MutableManagedObject) mo;
+ moi.setOperations(runtimeOps);
+ }
}
else
{
@@ -645,6 +699,15 @@
this.metaValueFactory = metaValueFactory;
}
+ public ManagedObjectFactory getManagedObjFactory()
+ {
+ return managedObjFactory;
+ }
+ public void setManagedObjFactory(ManagedObjectFactory managedObjFactory)
+ {
+ this.managedObjFactory = managedObjFactory;
+ }
+
public void setDispatcher(RuntimeComponentDispatcher dispatcher)
{
this.dispatcher = dispatcher;
@@ -1347,6 +1410,11 @@
{
return delegate.getParameters();
}
+
+ public String[] getReflectionSignature()
+ {
+ return delegate.getReflectionSignature();
+ }
}
private ManagedDeployment getManagedDeployment(ProfileDeployment ctx) throws DeploymentException
Added: trunk/profileservice/src/main/org/jboss/profileservice/management/PlatformMBeanIDC.java
===================================================================
--- trunk/profileservice/src/main/org/jboss/profileservice/management/PlatformMBeanIDC.java (rev 0)
+++ trunk/profileservice/src/main/org/jboss/profileservice/management/PlatformMBeanIDC.java 2009-03-04 16:06:46 UTC (rev 85235)
@@ -0,0 +1,82 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2009, Red Hat Middleware LLC, and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.profileservice.management;
+
+import javax.management.Attribute;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+
+import org.jboss.dependency.spi.ControllerState;
+import org.jboss.dependency.spi.dispatch.InvokeDispatchContext;
+import org.jboss.kernel.plugins.registry.AbstractKernelRegistryEntry;
+
+/**
+ * An extension of AbstractKernelRegistryEntry that implements InvokeDispatchContext
+ * to handle access to the platform mbeans.
+ *
+ * @author Scott.Stark at jboss.org
+ * @version $Revision:$
+ */
+public class PlatformMBeanIDC extends AbstractKernelRegistryEntry
+ implements InvokeDispatchContext
+{
+ private MBeanServer server;
+ private ObjectName objectName;
+
+
+ public PlatformMBeanIDC(MBeanServer server, ObjectName objectName,
+ Object mbean)
+ {
+ super(objectName.getCanonicalName(), mbean);
+ this.server = server;
+ this.objectName = objectName;
+ }
+
+ public ClassLoader getClassLoader() throws Throwable
+ {
+ return server.getClassLoaderFor(objectName);
+ }
+
+ public Object invoke(String operationName, Object[] parameters, String[] signature)
+ throws Throwable
+ {
+ return server.invoke(objectName, operationName, parameters, signature);
+ }
+
+ public Object get(String name) throws Throwable
+ {
+ return server.getAttribute(objectName, name);
+ }
+
+ public void set(String name, Object value) throws Throwable
+ {
+ Attribute attribute = new Attribute(name, value);
+ server.setAttribute(objectName, attribute);
+ }
+
+ @Override
+ public ControllerState getState()
+ {
+ return ControllerState.INSTALLED;
+ }
+
+}
Added: trunk/profileservice/src/main/org/jboss/profileservice/management/PlatformMBeanKernelRegistryPlugin.java
===================================================================
--- trunk/profileservice/src/main/org/jboss/profileservice/management/PlatformMBeanKernelRegistryPlugin.java (rev 0)
+++ trunk/profileservice/src/main/org/jboss/profileservice/management/PlatformMBeanKernelRegistryPlugin.java 2009-03-04 16:06:46 UTC (rev 85235)
@@ -0,0 +1,152 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2009, Red Hat Middleware LLC, and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.profileservice.management;
+
+import java.lang.management.ClassLoadingMXBean;
+import java.lang.management.CompilationMXBean;
+import java.lang.management.GarbageCollectorMXBean;
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryMXBean;
+import java.lang.management.MemoryManagerMXBean;
+import java.lang.management.MemoryPoolMXBean;
+import java.lang.management.OperatingSystemMXBean;
+import java.lang.management.RuntimeMXBean;
+import java.lang.management.ThreadMXBean;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+
+import org.jboss.kernel.spi.registry.KernelRegistryEntry;
+import org.jboss.kernel.spi.registry.KernelRegistryPlugin;
+import org.jboss.system.ServiceController;
+
+/**
+ * A KernelRegistryPlugin that make the j2se platform mbeans visible.
+ *
+ * @author Scott.Stark at jboss.org
+ * @version $Revision$
+ */
+public class PlatformMBeanKernelRegistryPlugin implements KernelRegistryPlugin
+{
+ private Map<String, KernelRegistryEntry> mbeans = new HashMap<String, KernelRegistryEntry>();
+ /** The service controller */
+ private ServiceController serviceController;
+
+ public ServiceController getServiceController()
+ {
+ return serviceController;
+ }
+ public void setServiceController(ServiceController serviceController)
+ {
+ this.serviceController = serviceController;
+ }
+
+ public KernelRegistryEntry getEntry(Object name)
+ {
+ String key;
+ if(name instanceof ObjectName)
+ key = ((ObjectName)name).getCanonicalName();
+ else
+ key = name.toString();
+ KernelRegistryEntry entry = mbeans.get(key);
+ return entry;
+ }
+
+ public void start()
+ throws Throwable
+ {
+ MBeanServer server = ManagementFactory.getPlatformMBeanServer();
+
+ // ClassLoadingMXBean
+ ClassLoadingMXBean clmbean = ManagementFactory.getClassLoadingMXBean();
+ ObjectName clname = new ObjectName(ManagementFactory.CLASS_LOADING_MXBEAN_NAME);
+ PlatformMBeanIDC clidc = new PlatformMBeanIDC(server, clname, clmbean);
+ mbeans.put(clname.getCanonicalName(), clidc);
+
+ // CompilationMXBean
+ CompilationMXBean cmbean = ManagementFactory.getCompilationMXBean();
+ ObjectName cmname = new ObjectName(ManagementFactory.COMPILATION_MXBEAN_NAME);
+ PlatformMBeanIDC cmidc = new PlatformMBeanIDC(server, cmname, cmbean);
+ mbeans.put(cmname.getCanonicalName(), cmidc);
+
+ // GarbageCollectorMXBeans
+ List<GarbageCollectorMXBean> gcbeans = ManagementFactory.getGarbageCollectorMXBeans();
+ for(GarbageCollectorMXBean mbean : gcbeans)
+ {
+ String name = mbean.getName();
+ ObjectName oname = new ObjectName(ManagementFactory.GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE+name);
+ String cname = oname.getCanonicalName();
+ PlatformMBeanIDC gcidc = new PlatformMBeanIDC(server, oname, mbean);
+ mbeans.put(cname, gcidc);
+ }
+ // getMemoryManagerMXBeans
+ List<MemoryManagerMXBean> mmbeans = ManagementFactory.getMemoryManagerMXBeans();
+ for(MemoryManagerMXBean mbean : mmbeans)
+ {
+ String name = mbean.getName();
+ ObjectName oname = new ObjectName(ManagementFactory.MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE+name);
+ String cname = oname.getCanonicalName();
+ PlatformMBeanIDC mmidc = new PlatformMBeanIDC(server, oname, mbean);
+ mbeans.put(cname, mmidc);
+ }
+ // MemoryMXBean
+ MemoryMXBean mxbean = ManagementFactory.getMemoryMXBean();
+ ObjectName mxname = new ObjectName(ManagementFactory.MEMORY_MXBEAN_NAME);
+ PlatformMBeanIDC mxidc = new PlatformMBeanIDC(server, mxname, mxbean);
+ mbeans.put(mxname.getCanonicalName(), mxidc);
+
+ // MemoryPoolMXBeans
+ List<MemoryPoolMXBean> mpbeans = ManagementFactory.getMemoryPoolMXBeans();
+ for(MemoryPoolMXBean mbean : mpbeans)
+ {
+ String name = mbean.getName();
+ ObjectName oname = new ObjectName(ManagementFactory.MEMORY_POOL_MXBEAN_DOMAIN_TYPE+name);
+ String cname = oname.getCanonicalName();
+ PlatformMBeanIDC mpidc = new PlatformMBeanIDC(server, oname, mbean);
+ mbeans.put(cname, mpidc);
+ }
+ // OperatingSystemMXBean
+ OperatingSystemMXBean osbean = ManagementFactory.getOperatingSystemMXBean();
+ ObjectName osname = new ObjectName(ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME);
+ PlatformMBeanIDC osidc = new PlatformMBeanIDC(server, osname, osbean);
+ mbeans.put(osname.getCanonicalName(), osidc);
+
+ // RuntimeMXBean
+ RuntimeMXBean rtbean = ManagementFactory.getRuntimeMXBean();
+ ObjectName rtname = new ObjectName(ManagementFactory.RUNTIME_MXBEAN_NAME);
+ PlatformMBeanIDC rtidc = new PlatformMBeanIDC(server, rtname, rtbean);
+ mbeans.put(rtname.getCanonicalName(), rtidc);
+
+ // ThreadMXBean
+ ThreadMXBean tbean = ManagementFactory.getThreadMXBean();
+ ObjectName tname = new ObjectName(ManagementFactory.THREAD_MXBEAN_NAME);
+ PlatformMBeanIDC tidc = new PlatformMBeanIDC(server, tname, tbean);
+ mbeans.put(tname.getCanonicalName(), tidc);
+ }
+ public void stop()
+ {
+
+ }
+}
Modified: trunk/profileservice/src/resources/profileservice-jboss-beans.xml
===================================================================
--- trunk/profileservice/src/resources/profileservice-jboss-beans.xml 2009-03-04 16:04:36 UTC (rev 85234)
+++ trunk/profileservice/src/resources/profileservice-jboss-beans.xml 2009-03-04 16:06:46 UTC (rev 85235)
@@ -166,5 +166,28 @@
<property name="deploymentManager"><inject bean="DeploymentManager"/></property>
<depends>ConnectorMBean</depends>
</bean>
-
+ <bean name="PlatformMBeanKernelRegistryPlugin" class="org.jboss.profileservice.management.PlatformMBeanKernelRegistryPlugin">
+ <property name="serviceController"><inject bean="JMXKernel" property="serviceController"/></property>
+ </bean>
+ <!-- Handle OpenType composite conversion to MetaType -->
+ <bean name="CompositeDataMetaValueBuilder"
+ class="org.jboss.managed.plugins.jmx.CompositeDataMetaValueBuilder">
+ <install bean="MetaValueFactory" method="setBuilder">
+ <parameter>
+ <value>javax.management.openmbean.CompositeDataSupport</value>
+ </parameter>
+ <parameter>
+ <this/>
+ </parameter>
+ </install>
+ <uninstall bean="MetaValueFactory" method="setBuilder">
+ <parameter>
+ <value>javax.management.openmbean.CompositeDataSupport</value>
+ </parameter>
+ <parameter>
+ <null/>
+ </parameter>
+ </uninstall>
+ <property name="metaValueFactory"><inject bean="MetaValueFactory"/></property>
+ </bean>
</deployment>
Modified: trunk/server/src/etc/conf/default/bootstrap/deployers.xml
===================================================================
--- trunk/server/src/etc/conf/default/bootstrap/deployers.xml 2009-03-04 16:04:36 UTC (rev 85234)
+++ trunk/server/src/etc/conf/default/bootstrap/deployers.xml 2009-03-04 16:06:46 UTC (rev 85235)
@@ -29,6 +29,10 @@
<constructor factoryClass="org.jboss.system.deployers.LegacyDeploymentContextComparator" factoryMethod="getInstance"/>
</bean>
+ <!-- MetaValueFactory -->
+ <bean name="MetaValueFactory" >
+ <constructor factoryClass="org.jboss.metatype.api.values.MetaValueFactory" factoryMethod="getInstance"/>
+ </bean>
<!-- The ManagedObjectFactory -->
<bean name="ManagedObjectFactory">
<constructor factoryClass="org.jboss.managed.api.factory.ManagedObjectFactory" factoryMethod="getInstance"/>
@@ -38,6 +42,7 @@
<!-- Accept any ManagedObjectDefinition -->
<incallback method="addManagedObjectDefinition"/>
<uncallback method="removeManagedObjectDefinition"/>
+ <property name="metaValueFactory"><inject bean="MetaValueFactory"/></property>
</bean>
<!-- The ManagedObjectCreator implementation -->
<bean name="ManagedObjectCreator" class="org.jboss.deployers.spi.deployer.helpers.DefaultManagedObjectCreator">
Added: trunk/testsuite/src/main/org/jboss/test/profileservice/test/PlatformMBeanUnitTestCase.java
===================================================================
--- trunk/testsuite/src/main/org/jboss/test/profileservice/test/PlatformMBeanUnitTestCase.java (rev 0)
+++ trunk/testsuite/src/main/org/jboss/test/profileservice/test/PlatformMBeanUnitTestCase.java 2009-03-04 16:06:46 UTC (rev 85235)
@@ -0,0 +1,400 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.test.profileservice.test;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryUsage;
+import java.lang.management.RuntimeMXBean;
+import java.lang.management.ThreadInfo;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.jboss.deployers.spi.management.ManagementView;
+import org.jboss.managed.api.ComponentType;
+import org.jboss.managed.api.ManagedComponent;
+import org.jboss.managed.api.ManagedDeployment;
+import org.jboss.managed.api.ManagedOperation;
+import org.jboss.managed.api.ManagedProperty;
+import org.jboss.managed.plugins.ManagedOperationMatcher;
+import org.jboss.managed.plugins.jmx.ManagementFactoryUtils;
+import org.jboss.metatype.api.types.SimpleMetaType;
+import org.jboss.metatype.api.values.ArrayValue;
+import org.jboss.metatype.api.values.CompositeValue;
+import org.jboss.metatype.api.values.MetaValue;
+import org.jboss.metatype.api.values.MetaValueFactory;
+import org.jboss.metatype.api.values.SimpleValue;
+import org.jboss.metatype.api.values.SimpleValueSupport;
+
+/**
+ * Tests of the ManagedObjects corresponding to the server platform mbeans.
+ *
+ * @author Scott.Stark at jboss.org
+ * @version $Revision:$
+ */
+public class PlatformMBeanUnitTestCase extends AbstractProfileServiceTest
+{
+ public PlatformMBeanUnitTestCase(String name)
+ {
+ super(name);
+ }
+
+ @Override
+ protected String getProfileName()
+ {
+ return "profileservice";
+ }
+
+ /**
+ * Get the ManagedDeployment named "JDK PlatformMBeans" and validate its
+ * components and subdeployments.
+ *
+ * @throws Exception
+ */
+ public void testPlatformMBeanDeployment()
+ throws Exception
+ {
+ ManagementView mgtView = getManagementView();
+ //mgtView.reloadProfile();
+ ManagedDeployment mbeans = mgtView.getDeployment("JDK PlatformMBeans");
+ assertNotNull(mbeans);
+
+ log.debug("Root component names: "+mbeans.getComponents().keySet());
+ //
+ ManagedComponent clMC = mbeans.getComponent(ManagementFactory.CLASS_LOADING_MXBEAN_NAME);
+ assertNotNull(clMC);
+ ManagedComponent memoryMC = mbeans.getComponent(ManagementFactory.MEMORY_MXBEAN_NAME);
+ assertNotNull(memoryMC);
+ ManagedComponent osMC = mbeans.getComponent(ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME);
+ assertNotNull(osMC);
+ ManagedComponent runtimeMC = mbeans.getComponent(ManagementFactory.RUNTIME_MXBEAN_NAME);
+ assertNotNull(runtimeMC);
+ ManagedComponent threadMC = mbeans.getComponent(ManagementFactory.THREAD_MXBEAN_NAME);
+ assertNotNull(threadMC);
+
+ List<ManagedDeployment> submbeans = mbeans.getChildren();
+ assertNotNull(submbeans);
+ assertEquals("3", 3, submbeans.size());
+ HashMap<String, ManagedDeployment> map = new HashMap<String, ManagedDeployment>();
+ for(ManagedDeployment md : submbeans)
+ map.put(md.getName(), md);
+ // the garbage collector beans deployment
+ ManagedDeployment gcMD = map.get("GarbageCollectorMXBeans");
+ assertNotNull(gcMD);
+ Map<String, ManagedComponent> gcMCs = gcMD.getComponents();
+ assertNotNull(gcMCs);
+ assertTrue(gcMCs.size() > 0);
+ // the memory manager beans deployment
+ ManagedDeployment mmMD = map.get("MemoryManagerMXBeans");
+ assertNotNull(mmMD);
+ Map<String, ManagedComponent> mmMCs = mmMD.getComponents();
+ assertNotNull(mmMCs);
+ assertTrue(mmMCs.size() > 0);
+ // the memory pool beans deployment
+ ManagedDeployment mpoolMD = map.get("MemoryPoolMXBeans");
+ assertNotNull(mpoolMD);
+ Map<String, ManagedComponent> mpoolMCs = mpoolMD.getComponents();
+ assertNotNull(mpoolMCs);
+ assertTrue(mpoolMCs.size() > 0);
+ }
+
+ /**
+ * Test the ManagedObject for the ManagementFactory.CLASS_LOADING_MXBEAN_NAME
+ */
+ public void testClassLoadingMXBean()
+ throws Exception
+ {
+ ManagementView mgtView = getManagementView();
+ ComponentType type = new ComponentType("MBean", "Platform");
+ ManagedComponent clMC = mgtView.getComponent(ManagementFactory.CLASS_LOADING_MXBEAN_NAME, type);
+ assertEquals(ManagementFactory.CLASS_LOADING_MXBEAN_NAME, clMC.getName());
+
+ Map<String, ManagedProperty> props = clMC.getProperties();
+ assertNotNull(props);
+ // totalLoadedClassCount
+ ManagedProperty totalLoadedClassCount = props.get("totalLoadedClassCount");
+ assertNotNull(totalLoadedClassCount);
+ assertEquals(SimpleMetaType.LONG_PRIMITIVE, totalLoadedClassCount.getMetaType());
+ assertEquals("the total number of classes loaded.", totalLoadedClassCount.getDescription());
+ SimpleValue totalLoadedClassCountSV = SimpleValue.class.cast(totalLoadedClassCount.getValue());
+ assertNotNull(totalLoadedClassCountSV);
+ getLog().debug("totalLoadedClassCountSV"+totalLoadedClassCountSV);
+ SimpleValue sv1 = SimpleValueSupport.wrap(new Long(100));
+ assertTrue("> 100 classes loaded", sv1.compareTo(totalLoadedClassCountSV) < 0);
+ // loadedClassCount
+ ManagedProperty loadedClassCount = props.get("loadedClassCount");
+ assertNotNull(loadedClassCount);
+ assertEquals(SimpleMetaType.INTEGER_PRIMITIVE, loadedClassCount.getMetaType());
+ assertEquals("the number of currently loaded classes.", loadedClassCount.getDescription());
+ SimpleValue loadedClassCountSV = SimpleValue.class.cast(loadedClassCount.getValue());
+ assertNotNull(loadedClassCountSV);
+ getLog().debug("loadedClassCountSV"+loadedClassCountSV);
+ assertTrue("> 100 classes loaded", sv1.compareTo(loadedClassCountSV) < 0);
+ // unloadedClassCount
+ ManagedProperty unloadedClassCount = props.get("unloadedClassCount");
+ assertNotNull(unloadedClassCount);
+ assertEquals(SimpleMetaType.LONG_PRIMITIVE, unloadedClassCount.getMetaType());
+ assertEquals("the total number of unloaded classes.", unloadedClassCount.getDescription());
+ SimpleValue unloadedClassCountSV = SimpleValue.class.cast(unloadedClassCount.getValue());
+ assertNotNull(unloadedClassCountSV);
+ getLog().debug("unloadedClassCountSV"+unloadedClassCountSV);
+ // verbose
+ ManagedProperty verbose = props.get("verbose");
+ assertNotNull(verbose);
+ assertEquals(SimpleMetaType.BOOLEAN_PRIMITIVE, verbose.getMetaType());
+ assertEquals("the verbose output flag for the class loading system.", verbose.getDescription());
+ SimpleValue verboseSV = SimpleValue.class.cast(verbose.getValue());
+ assertNotNull(verboseSV);
+ getLog().debug("verboseSV"+verboseSV);
+
+ }
+
+ public void testMemoryMXBean()
+ throws Exception
+ {
+ ManagementView mgtView = getManagementView();
+ ComponentType type = new ComponentType("MBean", "Platform");
+ ManagedComponent mo = mgtView.getComponent(ManagementFactory.MEMORY_MXBEAN_NAME, type);
+ assertNotNull(mo);
+ assertEquals(ManagementFactory.MEMORY_MXBEAN_NAME, mo.getName());
+
+ Map<String, ManagedProperty> props = mo.getProperties();
+ assertNotNull(props);
+
+ // heapMemoryUsage
+ ManagedProperty heapMemoryUsage = props.get("heapMemoryUsage");
+ assertNotNull(heapMemoryUsage);
+ assertEquals("object representing the heap memory usage.", heapMemoryUsage.getDescription());
+ CompositeValue heapMemoryUsageMV = CompositeValue.class.cast(heapMemoryUsage.getValue());
+ assertNotNull(heapMemoryUsageMV);
+ getLog().debug("heapMemoryUsageMV; "+heapMemoryUsageMV);
+ MemoryUsage heapMemoryUsageMU = ManagementFactoryUtils.unwrapMemoryUsage(heapMemoryUsageMV);
+ assertTrue(heapMemoryUsageMU.getInit() >= 0);
+ assertTrue(heapMemoryUsageMU.getUsed() >= 1000);
+ assertTrue(heapMemoryUsageMU.getMax() >= heapMemoryUsageMU.getCommitted());
+ assertTrue(heapMemoryUsageMU.getCommitted() >= heapMemoryUsageMU.getUsed());
+
+ // nonHeapMemoryUsage
+ ManagedProperty nonHeapMemoryUsage = props.get("nonHeapMemoryUsage");
+ assertNotNull(nonHeapMemoryUsage);
+ assertEquals("object representing the non-heap memory usage.", nonHeapMemoryUsage.getDescription());
+ CompositeValue nonHeapMemoryUsageMV = CompositeValue.class.cast(nonHeapMemoryUsage.getValue());
+ assertNotNull(nonHeapMemoryUsageMV);
+ getLog().debug("nonHeapMemoryUsageMV; "+nonHeapMemoryUsageMV);
+ MemoryUsage nonHeapMemoryUsageMU = ManagementFactoryUtils.unwrapMemoryUsage(nonHeapMemoryUsageMV);
+ assertTrue(nonHeapMemoryUsageMU.getInit() >= 0);
+ assertTrue(nonHeapMemoryUsageMU.getUsed() >= 1000);
+ assertTrue(nonHeapMemoryUsageMU.getMax() >= nonHeapMemoryUsageMU.getCommitted());
+ assertTrue(nonHeapMemoryUsageMU.getCommitted() >= nonHeapMemoryUsageMU.getUsed());
+ // objectPendingFinalizationCount
+ ManagedProperty objectPendingFinalizationCount = props.get("objectPendingFinalizationCount");
+ assertNotNull(objectPendingFinalizationCount);
+ assertEquals("the approximate number objects for which finalization is pending.", objectPendingFinalizationCount.getDescription());
+ MetaValue objectPendingFinalizationCountMV = objectPendingFinalizationCount.getValue();
+ assertNotNull(objectPendingFinalizationCountMV);
+ getLog().debug("objectPendingFinalizationCountMV; "+objectPendingFinalizationCountMV);
+
+ // verbose
+ ManagedProperty verbose = props.get("verbose");
+ assertNotNull(verbose);
+ assertEquals(SimpleMetaType.BOOLEAN_PRIMITIVE, verbose.getMetaType());
+ assertEquals("the verbose output flag for the memory system.", verbose.getDescription());
+ SimpleValue verboseSV = SimpleValue.class.cast(verbose.getValue());
+ assertNotNull(verboseSV);
+ getLog().debug("verboseSV; "+verboseSV);
+
+ // The gc op
+ Set<ManagedOperation> ops = mo.getOperations();
+ assertNotNull(ops);
+ assertEquals("There is 1 op", 1, ops.size());
+ ManagedOperation gc = ops.iterator().next();
+ assertEquals("gc", gc.getName());
+ assertEquals("Runs the garbage collector", gc.getDescription());
+ gc.invoke();
+ }
+
+ public void testThreadMXBean()
+ throws Exception
+ {
+ ManagementView mgtView = getManagementView();
+ //mgtView.reloadProfile();
+
+ ComponentType type = new ComponentType("MBean", "Platform");
+ ManagedComponent mo = mgtView.getComponent(ManagementFactory.THREAD_MXBEAN_NAME, type);
+ assertNotNull(mo);
+ assertEquals(ManagementFactory.THREAD_MXBEAN_NAME, mo.getName());
+
+ // Test ThreadInfo MetaValue wrap/unwrap
+ MetaValueFactory metaValueFactory = MetaValueFactory.getInstance();
+
+ // Properties
+ ManagedProperty allThreadIds = mo.getProperty("allThreadIds");
+ assertNotNull(allThreadIds);
+ MetaValue allThreadIdsMV = allThreadIds.getValue();
+ assertTrue("allThreadIds is Array", allThreadIdsMV instanceof ArrayValue);
+ ArrayValue idsArray = ArrayValue.class.cast(allThreadIdsMV);
+ assertTrue(idsArray.getLength() > 10);
+ SimpleValue tid0SV = SimpleValue.class.cast(idsArray.getValue(0));
+ ManagedProperty currentThreadCpuTime = mo.getProperty("currentThreadCpuTime");
+ assertNotNull(currentThreadCpuTime);
+ long x = (Long) metaValueFactory.unwrap(currentThreadCpuTime.getValue());
+ assertTrue(x > 1000);
+ ManagedProperty currentThreadUserTime = mo.getProperty("currentThreadUserTime");
+ assertNotNull(currentThreadUserTime);
+ ManagedProperty daemonThreadCount = mo.getProperty("daemonThreadCount");
+ assertNotNull(daemonThreadCount);
+ x = (Integer) metaValueFactory.unwrap(daemonThreadCount.getValue());
+ assertTrue(x > 1);
+ ManagedProperty peakThreadCount = mo.getProperty("peakThreadCount");
+ assertNotNull(peakThreadCount);
+ x = (Integer) metaValueFactory.unwrap(peakThreadCount.getValue());
+ assertTrue(x > 10);
+ ManagedProperty threadCount = mo.getProperty("threadCount");
+ assertNotNull(threadCount);
+ x = (Integer) metaValueFactory.unwrap(threadCount.getValue());
+ assertTrue(x > 10);
+ ManagedProperty totalStartedThreadCount = mo.getProperty("totalStartedThreadCount");
+ assertNotNull(totalStartedThreadCount);
+ x = (Long) metaValueFactory.unwrap(totalStartedThreadCount.getValue());
+ assertTrue(x > 10);
+ ManagedProperty currentThreadCpuTimeSupported = mo.getProperty("currentThreadCpuTimeSupported");
+ assertNotNull(currentThreadCpuTimeSupported);
+ Boolean flag = (Boolean) metaValueFactory.unwrap(currentThreadCpuTimeSupported.getValue());
+ assertNotNull(flag);
+ ManagedProperty threadContentionMonitoringEnabled = mo.getProperty("threadContentionMonitoringEnabled");
+ assertNotNull(threadContentionMonitoringEnabled);
+ flag = (Boolean) metaValueFactory.unwrap(threadContentionMonitoringEnabled.getValue());
+ assertNotNull(flag);
+ ManagedProperty threadContentionMonitoringSupported = mo.getProperty("threadContentionMonitoringSupported");
+ assertNotNull(threadContentionMonitoringSupported);
+ flag = (Boolean) metaValueFactory.unwrap(threadContentionMonitoringSupported.getValue());
+ assertNotNull(flag);
+ ManagedProperty threadCpuTimeEnabled = mo.getProperty("threadCpuTimeEnabled");
+ assertNotNull(threadCpuTimeEnabled);
+ flag = (Boolean) metaValueFactory.unwrap(threadCpuTimeEnabled.getValue());
+ assertNotNull(flag);
+ ManagedProperty threadCpuTimeSupported = mo.getProperty("threadCpuTimeSupported");
+ assertNotNull(threadCpuTimeSupported);
+ flag = (Boolean) metaValueFactory.unwrap(threadCpuTimeSupported.getValue());
+ assertNotNull(flag);
+
+ // Ops
+ Set<ManagedOperation> ops = mo.getOperations();
+ log.debug(ops);
+
+ assertEquals("Ops count is 8", 8, ops.size());
+ ManagedOperation getThreadInfo = ManagedOperationMatcher.findOperation(ops,
+ "getThreadInfo", SimpleMetaType.LONG_PRIMITIVE, SimpleMetaType.INTEGER_PRIMITIVE);
+ assertNotNull("getThreadInfo", getThreadInfo);
+ log.debug(getThreadInfo);
+
+ MetaValue tid0InfoMV = getThreadInfo.invoke(tid0SV);
+ assertNotNull(tid0InfoMV);
+ assertTrue(tid0InfoMV instanceof CompositeValue);
+ log.debug(tid0InfoMV);
+ CompositeValue tid0InfoCV = (CompositeValue) tid0InfoMV;
+ ThreadInfo tid0Info = ManagementFactoryUtils.unwrapThreadInfo(tid0InfoCV);
+ log.debug(tid0Info);
+ }
+
+ public void testRuntimeMXBean()
+ throws Exception
+ {
+ ManagementView mgtView = getManagementView();
+ ComponentType type = new ComponentType("MBean", "Platform");
+ ManagedComponent mo = mgtView.getComponent(ManagementFactory.RUNTIME_MXBEAN_NAME, type);
+ assertNotNull(mo);
+ assertEquals(ManagementFactory.RUNTIME_MXBEAN_NAME, mo.getName());
+
+ RuntimeMXBean mbean = ManagementFactory.getRuntimeMXBean();
+ MetaValueFactory metaValueFactory = MetaValueFactory.getInstance();
+
+ ManagedProperty bootClassPath = mo.getProperty("bootClassPath");
+ String x = (String) metaValueFactory.unwrap(bootClassPath.getValue());
+ assertTrue(x.length() > 0);
+ ManagedProperty classPath = mo.getProperty("classPath");
+ x = (String) metaValueFactory.unwrap(classPath.getValue());
+ assertTrue(x.length() > 0);
+ ManagedProperty libraryPath = mo.getProperty("libraryPath");
+ x = (String) metaValueFactory.unwrap(libraryPath.getValue());
+ assertTrue(x.length() > 0);
+ ManagedProperty managementSpecVersion = mo.getProperty("managementSpecVersion");
+ x = (String) metaValueFactory.unwrap(managementSpecVersion.getValue());
+ assertEquals(mbean.getManagementSpecVersion(), x);
+ ManagedProperty specName = mo.getProperty("specName");
+ x = (String) metaValueFactory.unwrap(specName.getValue());
+ assertEquals(mbean.getSpecName(), x);
+ ManagedProperty specVendor = mo.getProperty("specVendor");
+ x = (String) metaValueFactory.unwrap(specVendor.getValue());
+ assertEquals(mbean.getSpecVendor(), x);
+ ManagedProperty specVersion = mo.getProperty("specVersion");
+ x = (String) metaValueFactory.unwrap(specVersion.getValue());
+ assertEquals(mbean.getSpecVersion(), x);
+ ManagedProperty vmName = mo.getProperty("vmName");
+ x = (String) metaValueFactory.unwrap(vmName.getValue());
+ assertEquals(mbean.getVmName(), x);
+ ManagedProperty vmVendor = mo.getProperty("vmVendor");
+ x = (String) metaValueFactory.unwrap(vmVendor.getValue());
+ assertEquals(mbean.getVmVendor(), x);
+ ManagedProperty vmVersion = mo.getProperty("vmVersion");
+ x = (String) metaValueFactory.unwrap(vmVersion.getValue());
+ assertEquals(mbean.getVmVersion(), x);
+ ManagedProperty startTime = mo.getProperty("startTime");
+ long time = (Long) metaValueFactory.unwrap(startTime.getValue());
+ assertTrue(time > 10000000);
+ ManagedProperty uptime = mo.getProperty("uptime");
+ time = (Long) metaValueFactory.unwrap(uptime.getValue());
+ ManagedProperty inputArguments = mo.getProperty("inputArguments");
+ List<String> ls = (List<String>) metaValueFactory.unwrap(inputArguments.getValue());
+ assertTrue(ls.size() > 0);
+ ManagedProperty systemProperties = mo.getProperty("systemProperties");
+ MetaValue sysPropsMV = systemProperties.getValue();
+ Map<String, String> sysProps = (Map<String, String>) metaValueFactory.unwrap(sysPropsMV);
+ log.debug(sysProps);
+ assertNotNull(sysProps.get("jboss.home.dir"));
+ assertTrue(sysProps.get("jboss.home.dir") instanceof String);
+ assertNotNull(sysProps.get("jboss.server.home.dir"));
+ assertNotNull(sysProps.get("jboss.common.lib.url"));
+ assertNotNull(sysProps.get("jboss.server.base.url"));
+ }
+ public void testOperatingSystemMXBean()
+ throws Exception
+ {
+ ManagementView mgtView = getManagementView();
+ ComponentType type = new ComponentType("MBean", "Platform");
+ ManagedComponent mo = mgtView.getComponent(ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME, type);
+ assertNotNull(mo);
+ assertEquals(ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME, mo.getName());
+
+ ManagedProperty arch = mo.getProperty("arch");
+ assertNotNull(arch);
+ ManagedProperty availableProcessors = mo.getProperty("availableProcessors");
+ assertNotNull(availableProcessors);
+ SimpleValue procsSV = (SimpleValue) availableProcessors.getValue();
+ Integer procs = (Integer) procsSV.getValue();
+ assertTrue(procs.intValue() >= 1);
+ ManagedProperty version = mo.getProperty("version");
+ assertNotNull(version);
+ log.debug(version.getValue());
+ }
+}
Modified: trunk/testsuite/src/main/org/jboss/test/profileservice/test/ProfileServiceUnitTestCase.java
===================================================================
--- trunk/testsuite/src/main/org/jboss/test/profileservice/test/ProfileServiceUnitTestCase.java 2009-03-04 16:04:36 UTC (rev 85234)
+++ trunk/testsuite/src/main/org/jboss/test/profileservice/test/ProfileServiceUnitTestCase.java 2009-03-04 16:06:46 UTC (rev 85235)
@@ -55,6 +55,7 @@
import org.jboss.metatype.api.types.MapCompositeMetaType;
import org.jboss.metatype.api.types.MetaType;
import org.jboss.metatype.api.types.SimpleMetaType;
+import org.jboss.metatype.api.values.CompositeValue;
import org.jboss.metatype.api.values.CompositeValueSupport;
import org.jboss.metatype.api.values.GenericValue;
import org.jboss.metatype.api.values.MapCompositeValueSupport;
@@ -551,6 +552,16 @@
Map<String,ManagedProperty> props = hsqldb.getProperties();
validatePropertyMetaValues(props);
+ // Validate the config-property
+ ManagedProperty configProperty = hsqldb.getProperty("config-property");
+ assertNotNull(configProperty);
+ MetaValue value = configProperty.getValue();
+ assertTrue("MapCompositeMetaType", value.getMetaType() instanceof MapCompositeMetaType);
+ log.debug("config-property: "+configProperty);
+ assertTrue(value instanceof CompositeValue);
+ log.debug("config-property.value: "+value);
+
+
// Validate more details on specific properties
ManagedProperty securityDomain = props.get("security-domain");
assertNotNull("security-domain", securityDomain);
@@ -822,6 +833,7 @@
removeDeployment("testNoTxCf-ds.xml");
}
+
// Private and protected
private void addNonXaDsProperties(Map<String, MetaValue> propValues,
More information about the jboss-cvs-commits
mailing list