JMX, SNMP, Java, etc...

You can run the proxy on the client side, so there's no need to modify the server application. The proxy will simply take any JMX RMI/JRMP requests it receives from the north side and translate them into corresponding JMX RMI/IIOP requests to the south side.

A connector server is usually associated with an MBean Server obtained using the methods ManagementFactory.getPlatformMBeanServer() or MBeanServerFactory.createMBeanServer(). But in fact it can be associated with any object that implements the MBeanServer interface. Here, we create such an object (an instance of MBeanServerProxyHandler in the code below) where every method in the MBeanServer interface is forwarded to the remote MBeanServer using the RMI/IIOP connector. There are a few MBeanServer methods that are not available remotely, but that will still be called by the JMX Connector Server when deserialiazing attribute values and parameters sent by the client, so we need to fake those methods with code that does something reasonable.

/*
 * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Sun Microsystems nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package com.sun.jmx.example.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.rmi.registry.LocateRegistry;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;
import javax.management.MBeanServer;
import javax.management.MBeanServerConnection;
import javax.management.ObjectName;
import javax.management.loading.ClassLoaderRepository;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXConnectorServer;
import javax.management.remote.JMXConnectorServerFactory;
import javax.management.remote.JMXServiceURL;

/**
 * Class RMIIIOPProxy - Creates a JMX RMI/JRMP proxy for a JMX RMI/IIOP server
 * @author Daniel Fuchs, 2007.
 */
public class RMIIIOPProxy {

    /**
     * A logger for this class.
     **/
    private static final Logger LOG =
            Logger.getLogger(RMIIIOPProxy.class.getName());

    // Just a quick access Map to convert MBeanServer methods to their
    // corresponding MBeanServerConnection equivalent....
    //
    private static class ProxyMethodMap {
        static final Map<Method,Method> methodMap;
        static {
            try {
                final Method[] mm =
                        MBeanServerConnection.class.getMethods();
                methodMap = new HashMap<Method,Method>(mm.length);
                for (Method m : mm) {
                    try {
                        final Method ms =
                                MBeanServer.class.getMethod(m.getName(),
                                m.getParameterTypes());
                        methodMap.put(ms,m);
                    } catch (Exception x) {
                        // OK - no such method...
                    }
                }
            } catch (Exception x) {
                throw new ExceptionInInitializerError(x);
            }
        }
    }

    // This class makes it possible to create a Proxy implementing
    // the MBeanServer interface by wrapping an MBeanServerConnection
    //
    private static class MBeanServerProxyHandler
            implements InvocationHandler {
        final MBeanServerConnection conn;
        final ClassLoaderRepository classLoaderRepository;

        // Creates an MBeanServerProxyHandler.
        public MBeanServerProxyHandler(MBeanServerConnection conn) {
            this.conn=conn;
            classLoaderRepository = new ClassLoaderRepository() {
                public Class loadClass(String className)
                    throws ClassNotFoundException {
                    // trivial impl: we're
                    // loading everything through the System Class Loader.
                    return Class.forName(className,false,
                            ClassLoader.getSystemClassLoader());
                }
                public Class loadClassBefore(ClassLoader stop, String className)
                    throws ClassNotFoundException {
                    // trivial impl: ignore 'stop' and 'exclude' - since we're
                    // loading everything through the System Class Loader.
                    return loadClass(className);
                }
                public Class loadClassWithout(ClassLoader exclude,
                        String className) throws ClassNotFoundException {
                    // trivial impl: ignore 'stop' and 'exclude' - since we're
                    // loading everything through the System Class Loader.
                    return loadClass(className);
                }
            };
        }

        // Takes a method from MBeanServer.class and forwards it to
        // a wrapped MBeanServerConnection...
        //
        public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {

            // Methods also defined in MBeanServerConnection
            final Method toInvoke = ProxyMethodMap.methodMap.get(method);
            if (toInvoke != null) {
                try {
                    return toInvoke.invoke(conn,args);
                } catch (InvocationTargetException x) {
                    throw x.getCause();
                }
            }

            final String name = method.getName();
            final Class[] sig = method.getParameterTypes();

            // equals & hashcode
            if ("equals".equals(name) && sig.length == 1
                    && Object.class.equals(sig[0])) {
                return super.equals(args[0]);
            }
            if ("hashCode".equals(name) && sig.length == 0) {
                return super.hashCode();
            }
            if ("toString".equals(name) && sig.length == 0) {
                return super.toString();
            }

            // There might be better ways - but we will impose that
            // all necessary classes are given in the classpath.
            //
            if ("getClassLoaderFor".equals(name) && sig.length == 1
                    && ObjectName.class.equals(sig[0])) {
                return ClassLoader.getSystemClassLoader();
            }
            if ("getClassLoader".equals(name) && sig.length == 1
                    && ObjectName.class.equals(sig[0])) {
                return ClassLoader.getSystemClassLoader();
            }
            if ("getClassLoaderRepository".equals(name) && sig.length == 0) {
                return classLoaderRepository;
            }

            // The connector server shouldn't need to call any other methods....
            //
            throw new UnsupportedOperationException(name+Arrays.asList(sig));
        }

    }


    /**
     * Starts a JMX RMI/JRMP proxy for a JMX RMI/IIOP Server.
     * Run this using JDK 1.5.
     * @param args the command line arguments:
     * {@code <rmiport> <rmi-server-name> <iiophost> <iiopport> <iiop-server-name>}
     */
    public static void main(String[] args) throws Exception {

        // check args
        if (args.length < 5) {
            System.err.println("syntax: java "+RMIIIOPProxy.class.getName()+
                    " <rmiport> <rmi-server-name> <iiophost> <iiopport> <iiop-server-name>");
            System.exit(1);
        }

        final int rmiport  = Integer.parseInt(args[0]);
        final String rmiServerName = args[1];
        final String iiophost = args[2];
        final int iiopport = Integer.parseInt(args[3]);
        final String iiopServerName = args[4];

        if (rmiport < 1) throw new IllegalArgumentException(args[0]);
        if (iiopport < 1) throw new IllegalArgumentException(args[3]);

        // creates north side URL & conf (tweak this if you want to add
        // authentication, authorization, etc....)
        //
        final JMXServiceURL rmi =
                new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:"
                +rmiport+"/"+rmiServerName);
        final Map<String,Object> northEnv = Collections.emptyMap();

        // creates south side URL & conf (tweak this if south side requires
        // authentication, authorization, etc....)
        //
        final JMXServiceURL iiop =
                new JMXServiceURL("service:jmx:iiop:///jndi/iiop://"+iiophost+":"
                +iiopport+"/"+iiopServerName);
        final Map<String,Object> southEnv = Collections.emptyMap();

        // Connect to south side...
        final JMXConnector south = JMXConnectorFactory.connect(iiop,southEnv);
        try {

            // Make an MBeanServer from south side MBeanServerConnection
            final MBeanServerProxyHandler proxyHandler =
                    new MBeanServerProxyHandler(south.getMBeanServerConnection());
            final MBeanServer remote = (MBeanServer) Proxy.newProxyInstance(
                    ClassLoader.getSystemClassLoader(),
                    new Class[] {MBeanServer.class}, proxyHandler);
            System.out.println("Connection established with south server at: "+
                    iiop);

            // Start a JMX RMI/JRMP connector server for north side...
            //
            // You may need to tweak these lines if you want to add SSL etc...
            LocateRegistry.createRegistry(rmiport);
            final JMXConnectorServer cs =
                    JMXConnectorServerFactory.newJMXConnectorServer(rmi,
                    northEnv,remote);
            cs.start();

            System.out.println("Proxy server listening at: "+rmi);
            System.out.println("Strike <Enter> to exit");
            System.in.read();
            cs.stop();

        } finally {
            south.close();
        }
    }

}