Glassfish example source code file (AMXProxyTests.java)

This example Glassfish source code file (AMXProxyTests.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Glassfish tags/keywords

amxproxy, amxproxy, childgetter, childgetter, list, managedattribute, management, map, method, property, property, reflection, set, string, test, test, util

The Glassfish AMXProxyTests.java source code

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package amxtest;

import org.testng.annotations.*;
import org.testng.Assert;

import javax.management.ObjectName;

import java.lang.reflect.Method;
import java.util.Set;
import java.util.HashSet;
import java.util.Map;
import java.util.List;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Collection;

import org.glassfish.admin.amx.intf.config.*;
import org.glassfish.admin.amx.core.*;
import org.glassfish.admin.amx.base.*;
import org.glassfish.admin.amx.config.*;
//import org.glassfish.admin.amx.j2ee.*;
import org.glassfish.admin.amx.monitoring.*;
import org.glassfish.admin.amx.util.CollectionUtil;
import org.glassfish.admin.amx.util.ExceptionUtil;
import org.glassfish.admin.amx.util.jmx.JMXUtil;
import org.glassfish.admin.amx.logging.Logging;
import org.glassfish.admin.amx.annotation.*;


/** 
    These tests are designed to exercise the AMXProxyHandler code.
 */
//@Test(groups={"amx"}, description="AMXProxy tests", sequential=false, threadPoolSize=5)
@Test(
    sequential=false, threadPoolSize=10,
    groups =
    {
        "amx"
    },
    description = "test the functionality of AMX dymamic proxy eg AMXProxy"
)
public final class AMXProxyTests extends AMXTestBase
{
    public AMXProxyTests()
    {
    }
    
    private String attrName( final Method m )
    {
        if ( ! JMXUtil.isIsOrGetter(m) ) return null;
        
        return JMXUtil.getAttributeName(m);
    }
    
    
    private <T extends AMXProxy> void testProxyInterface(final AMXProxy amx, Class clazz)
    {
        final List<String> problems = _testProxyInterface(amx, clazz);
        assert problems.size() == 0 : CollectionUtil.toString( problems, "\n" );
    }
    
    
    private <T extends AMXProxy> List _testProxyInterface(final AMXProxy amxIn, Class clazz)
    {
        assert amxIn != null : "_testProxyInterface(): null proxy for class " + clazz.getName();
        
        final List<String> problems = new ArrayList();
        
        final T amx = amxIn.as(clazz);
        
        final String nameProp = amx.nameProp();
        assert Util.getNameProp(amx.objectName()) == nameProp;
        
        assert amx.parentPath() != null;
        assert amx.type() != null;
        assert amx.valid();
        assert amx.childrenSet() != null;
        assert amx.childrenMaps() != null;
        assert amx.attributesMap() != null;
        final Set<String> attrNames = amx.attributeNames();
        assert attrNames != null;
        final ObjectName objectName = amx.objectName();
        assert objectName != null;
        assert amx.extra() != null;
        
        final Extra extra = amx.extra();
        //assert extra.mbeanServerConnection() == getMBeanServerConnection();
        assert extra.proxyFactory() == getProxyFactory();
        assert extra.java().length() >= 100;
        
        assert extra.mbeanInfo() != null;
        assert extra.interfaceName() != null;
        assert extra.genericInterface() != null;
        assert extra.group() != null;
        assert extra.descriptor() != null;
        extra.isInvariantMBeanInfo();   // just call it
        extra.subTypes();   // just call it
        extra.supportsAdoption();   // just call it
        if ( extra.globalSingleton() )
        {
            assert extra.singleton();
        }
            
        
        final Method[] methods = clazz.getMethods();
        final Set<String> attrNamesFromMethods = new HashSet();
        for( final Method m : methods )
        {
            if ( JMXUtil.isIsOrGetter(m) )
            {
                final String attrName = attrName(m);
                final ChildGetter childGetter = m.getAnnotation(ChildGetter.class);
                if ( attrNames.contains(attrName) && childGetter != null )
                {
                    println( "Warning: Attribute " + attrName +
                        " exists in " + objectName + ", but has superfluous @ChildGetter annotation" );
                }
                
                try
                {
                    final Object result = m.invoke( amx, (Object[])null);
                    
                    attrNamesFromMethods.add( attrName(m) );
                }
                catch( final Exception e )
                {
                    e.printStackTrace();
                    problems.add( "Error invoking " + m.getName() + "() on " + objectName + " = " + e );
                }
            }
        }
        if ( clazz != AMXProxy.class && clazz != AMXConfigProxy.class )
        {
            // see whether the interface is missing any getters
            final Set<String> missing = new HashSet(attrNames);
            missing.removeAll(attrNamesFromMethods);
            if ( missing.size() != 0 )
            {
                //println( clazz.getName() + " missing getters attributes: " + missing );
            }
        }
        return problems;
    }

    @Test
    public void testDomainRoot()
    {
        final DomainRoot dr = getDomainRootProxy();
        testProxyInterface( dr, DomainRoot.class );
        
        // sanity check:  see that the various attributes are reachable through its proxy
        assert dr.getAMXReady();
        assert dr.getDebugPort() != null;
        assert dr.getApplicationServerFullVersion() != null;
        assert dr.getInstanceRoot() != null;
        assert dr.getDomainDir() != null;
        assert dr.getConfigDir() != null;
        assert dr.getInstallDir() != null;
        assert dr.getUptimeMillis() != null;

    }

    @Test
    public void testExt()
    {
        testProxyInterface( getExt(), Ext.class );
    }

    @Test
    public void testQuery()
    {
        testProxyInterface( getQueryMgr(), Query.class );
    }

    @Test
    public void testBulkAccess()
    {
        testProxyInterface( getDomainRootProxy().getBulkAccess(), BulkAccess.class );
    }

    @Test
    public void testTools()
    {
        testProxyInterface( getDomainRootProxy().getTools(), Tools.class );
    }

    @Test
    public void testMonitoringRoot()
    {
        testProxyInterface( getDomainRootProxy().getMonitoringRoot(), MonitoringRoot.class );
    }

    @Test
    public void testRuntimeRoot()
    {
        testProxyInterface( getDomainRootProxy().getRuntime(), RuntimeRoot.class );
    }

    @Test
    public void testServerRuntime()
    {
        final RuntimeRoot runtime = getDomainRootProxy().getRuntime();
        final Map<String,ServerRuntime>  serverRuntimes = runtime.getServerRuntime();
        assert serverRuntimes.keySet().size() != 0;
        for( final ServerRuntime sr : serverRuntimes.values() )
        {
            testProxyInterface( sr, ServerRuntime.class );
        }
    }

    @Test
    public void testSystemInfo()
    {
        testProxyInterface( getDomainRootProxy().getSystemInfo(), SystemInfo.class );
    }

    @Test
    public void testLogging()
    {
        testProxyInterface( getDomainRootProxy().getLogging(), Logging.class );
    }

    @Test
    public void testPathnames()
    {
        testProxyInterface( getDomainRootProxy().getPathnames(), Pathnames.class );
    }

    @Test
    public void testDomainConfig()
    {
        final Domain dc = getDomainConfig();
        testProxyInterface( dc, Domain.class );
        
        assert dc.getApplicationRoot() != null;
        dc.getLocale(); // can be null
        assert dc.getLogRoot() != null;
    }

    @Test
    public void testApplications()
    {
        testProxyInterface( getDomainConfig().getApplications(), Applications.class );
    }

    @Test
    public void testResources()
    {
        final Resources resources = getDomainConfig().getResources();
        testProxyInterface( resources, Resources.class );
    }

    @Test
    public void testConfigs()
    {
        testProxyInterface( getDomainConfig().getConfigs(), Configs.class );
    }

    @Test
    public void testSystemApplications()
    {
        testProxyInterface( getDomainConfig().getSystemApplications(), SystemApplications.class );
    }

    @Test
    public void testServers()
    {
        testProxyInterface( getDomainConfig().getServers(), Servers.class );
    }
        
    /** test all MBeans that contain Property */
    @Test
    public void testPropertyParent()
    {
        final Set<AMXProxy> parentsWithProperty = findAllContainingType( Util.deduceType(Property.class) );
        
        for( final AMXProxy amx : parentsWithProperty )
        {
            final PropertiesAccess pa = amx.as(PropertiesAccess.class);
            final Map<String, Property> children = pa.getProperty();
            for( final Property prop : children.values() ) { prop.getValue(); }
        }
    }
    
    /** test all MBeans that contain SystemProperty */
    @Test
    public void testSystemPropertyParent()
    {
        final Set<AMXProxy> parentsWithProperty = findAllContainingType( Util.deduceType(SystemProperty.class) );
        
        for( final AMXProxy amx : parentsWithProperty )
        {
            final SystemPropertiesAccess pa = amx.as(SystemPropertiesAccess.class);
            final Map<String, SystemProperty> children = pa.getSystemProperty();
            for( final SystemProperty prop : children.values() ) { prop.getValue(); }
        }
    }
    
    /** test all MBeans generically */
    @Test
    public void testForBogusAnnotations()
    {
        final List<Class interfaces = getInterfaces().all();
        
        for( final Class<? extends AMXProxy>  intf : interfaces )
        {
            final Method[] methods = intf.getMethods();
            for( final Method m : methods )
            {
                final ChildGetter cg = m.getAnnotation(ChildGetter.class);
                final ManagedAttribute ma = m.getAnnotation(ManagedAttribute.class);
                final ManagedOperation mo = m.getAnnotation(ManagedOperation.class);
                final String desc = intf.getName() + "." + m.getName() + "()";
                final int numArgs = m.getParameterTypes().length;
                
                assert ma == null || mo == null :
                    "Can't have both @ManagedAttribute and @ManagedOperation: " + desc;

                if ( cg != null )
                {
                    assert numArgs == 0 :
                        "@ChildGetter cannot be applied to method with arguments: " + desc;
                        
                    assert ma == null && mo == null :
                        "@ManagedAttribute/@ManagedOperation not applicable with @ChildGetter: " + desc;
                }
                
                if ( mo != null )
                {
                    // operations that mimic getters are bad. We can't prevent all such things
                    // but we can object to such oddball usage in an AMX interface
                    if ( numArgs == 0 && m.getName().startsWith("get") )
                    {
                        assert false : "testForBogusAnnotations: @ManagedOperation should be @ManagedAttribute: " + desc;
                    }
                }
            }
        }
    }
    

    @Test
    public void testSystemStatus()
    {
        final SystemStatus ss = getDomainRootProxy().getExt().getSystemStatus();

        final List<UnprocessedConfigChange> changes = SystemStatus.Helper.toUnprocessedConfigChange( ss.getRestartRequiredChanges() );

        final Set<AMXProxy> pools = getQueryMgr().queryType( Util.deduceType(JdbcConnectionPool.class) );

        for (final AMXProxy pool : pools)
        {
            final Map<String, Object> result = ss.pingJdbcConnectionPool(pool.getName());
            assert result != null;
        }
    }
    
    @Test
    public void testAutoConvert()
    {
        // make sure there is a required change so the change list will be non-empty
        final JavaConfig jc = getDomainConfig().getConfigs().getConfig().get("server-config").getJavaConfig();
        final String[] jvmOptions = jc.getJvmOptions();
        assert jvmOptions != null;
        for( int i = 0; i < jvmOptions.length; ++i )
        {
            final String option = jvmOptions[i];
            if ( option.startsWith( "-Xmx" ) )
            {
                //System.out.println( "CHANGING OPTION " + option );
                jvmOptions[i] = "-Xmx999m";
                jc.setJvmOptions( jvmOptions );
                
                jvmOptions[i] = option;
                jc.setJvmOptions( jvmOptions ); // set back to old value
                // we should now have two changes in the list
                break;
            }
        }
        
        final SystemStatus systemStatus = getDomainRootProxy().getExt().getSystemStatus();
        
        final List<UnprocessedConfigChange>  changes = SystemStatus.Helper.toUnprocessedConfigChange( systemStatus.getRestartRequiredChanges() );
        assert changes != null && changes.size() >= 2;
        System.out.println( "CHANGE COUNT: " + changes.size() );
        for( final UnprocessedConfigChange change : changes )
        {
            change.toString();  // force it to exist and function properly
           // System.out.println( "" + change );
        }
    }
    
    
    /** test all MBeans generically */
    @Test
    public void testAllGenerically()
    {
        final Interfaces interfaces = getInterfaces();
        final List<String> problems = new ArrayList();

        for( final AMXProxy amx : getQueryMgr().queryAll() )
        {
            assert amx != null : "testAllGenerically(): null proxy in query list";
            try
            {
                final List<String> p = _testProxyInterface( amx, interfaces.get(amx.type()) );
                problems.addAll(p);
            }
            catch( final Throwable t )
            {
                final Throwable rootCause = ExceptionUtil.getRootCause(t);
                problems.add( rootCause.getMessage() );
            }
        }

        if ( problems.size() != 0 )
        {
            System.out.println( "\nPROBLEMS:\n" + CollectionUtil.toString(problems, "\n\n") );
            assert false : "" + problems;
        }
    }
    
    
    @Test
    public void testSingletonOrNot()
    {
        final Domain domain = getDomainConfig();
        final Configs configs = getDomainConfig().getConfigs();
        
        try
        {
            domain.child(Configs.class);
        }
        catch( final Exception e )
        {
            assert false : e;
        }
        
        try
        {
            configs.child(Config.class);
            assert false : "expecting failure";
        }
        catch( final Exception e )
        {
            // good
        }
    }
    
    

    /**
      Used to test the AMXProxyHandler processing of Set/List/Map/[] on any AMX MBean that
      has children of type Property ("property").
      */
    interface ChildGetterProxy extends AMXProxy
    {
        @ChildGetter    // type should be derived from method name
        Map<String, Property> getProperty();
        
        @ChildGetter(type="property")
        ObjectName[]  propertiesAsObjectNames();
        
        @ChildGetter(type="property")
        Property[]  propertiesAsArray();
        
        @ChildGetter(type="property")
        Set<Property>  propertiesAsSet();
        
        @ChildGetter(type="property")
        List<Property> propertiesAsList();
        
        @ChildGetter(type="property")
        Map<String,Property>  propertiesAsMap();
    }
    
    
    void _testChildGetter( final AMXProxy amx)
    {
        // we assume there are always properties on Domain
        ChildGetterProxy getter = amx.as(ChildGetterProxy.class);
        
        final Map<String,Property>  property = getter.getProperty();
        assert property.keySet().size() != 0 : " no properties found for " + amx.objectName();
        for( final Property prop : property.values() ) { prop.getValue(); }
        final int numProps = property.keySet().size();
        
        //System.out.println( "Testing properties on: " + amx.objectName() + " = " + numProps);
            
        final Set<Property>   asSet = getter.propertiesAsSet();
        assert asSet.size() == numProps : " no properties found for " + amx.objectName();
        for( final Property prop : asSet ) { prop.getValue(); }
        
        final List<Property>  asList = getter.propertiesAsList();
        assert asList.size() == numProps : " no properties found for " + amx.objectName();
        for( final Property prop : asList ) { prop.getValue(); }
        
        final Map<String,Property>  asMap = getter.propertiesAsMap();
        assert asMap.keySet().size() == numProps : " no properties found for " + amx.objectName();
        for( final Property prop : asMap.values() ) { prop.getValue(); }
        
        final ObjectName[]    asObjectNameArray = getter.propertiesAsObjectNames();
        assert asObjectNameArray.length == numProps : " no properties found for " + amx.objectName();
        
        final Property[]      asArray = getter.propertiesAsArray();
        assert asArray.length == numProps : " no properties found for " + amx.objectName();
        for( final Property prop : asList ) { prop.getValue(); }
    }
        
    @Test
    public void testChildGetterVariants()
    {
        final Set<AMXProxy> parentsWithProperty = findAllContainingType( Util.deduceType(Property.class) );
        
        for( final AMXProxy amx : parentsWithProperty )
        {
            _testChildGetter( amx );
        }
    }
    
    @Test
    public void testJ2EEDomain() throws ClassNotFoundException
    {
        if ( haveJSR77() )
        {
            testProxyInterface( getDomainRootProxy().getJ2EEDomain(), getJ2EEDomainClass() );
        }
    }
    
}