org/objectweb/proactive/jmx/ProActiveConnection.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library 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 any later version.
 *  
 * This library 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 library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.jmx;

import java.io.IOException;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Set;

import javax.management.Attribute;
import javax.management.AttributeList;
import javax.management.AttributeNotFoundException;
import javax.management.InstanceAlreadyExistsException;
import javax.management.InstanceNotFoundException;
import javax.management.IntrospectionException;
import javax.management.InvalidAttributeValueException;
import javax.management.ListenerNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanRegistrationException;
import javax.management.MBeanServer;
import javax.management.MBeanServerConnection;
import javax.management.NotCompliantMBeanException;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectInstance;
import javax.management.ObjectName;
import javax.management.QueryExp;
import javax.management.ReflectionException;

import org.objectweb.proactive.core.util.wrapper.GenericTypeWrapper;
import org.objectweb.proactive.jmx.listeners.ListenerAdapter;


public class ProActiveConnection implements Serializable, MBeanServerConnection {

    protected static final long serialVersionUID = 1245L;
    private transient MBeanServer mbs;
    private HashMap<NotificationListener, ListenerAdapter> listenerMap = new HashMap<NotificationListener, ListenerAdapter>();

    public ProActiveConnection() {
    }

    public ProActiveConnection(MBeanServer server) {
        this.mbs = server;
    }

    /* *
     * @see javax.management.MBeanServerConnection#createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName)
     */
    public ObjectInstance createMBean(String arg0, ObjectName arg1,
        ObjectName arg2)
        throws InstanceAlreadyExistsException, MBeanRegistrationException,
            NotCompliantMBeanException, InstanceNotFoundException,
            ReflectionException, MBeanException {
        return this.mbs.createMBean(arg0, arg1, arg2);
    }

    /* *
     * @see javax.management.MBeanServerConnection#createMBean(java.lang.String, javax.management.ObjectName, java.lang.Object[], java.lang.String[])
     */
    public ObjectInstance createMBean(String className, ObjectName name,
        Object[] params, String[] signature)
        throws InstanceAlreadyExistsException, MBeanRegistrationException,
            NotCompliantMBeanException, ReflectionException, MBeanException {
        return this.mbs.createMBean(className, name, params, signature);
    }

    public ObjectInstance createMBean(String className, ObjectName name,
        ObjectName loaderName, Object[] params, String[] signature)
        throws InstanceAlreadyExistsException, MBeanRegistrationException,
            NotCompliantMBeanException, InstanceNotFoundException,
            ReflectionException, MBeanException {
        return this.mbs.createMBean(className, name, loaderName, params,
            signature);
    }

    /* *
     * @see javax.management.MBeanServerConnection#unregisterMBean(javax.management.ObjectName)
     */
    public void unregisterMBean(ObjectName name)
        throws InstanceNotFoundException, MBeanRegistrationException {
        this.mbs.unregisterMBean(name);
    }

    @SuppressWarnings("unused")
    public ObjectInstance getObjectInstance(ObjectName name)
        throws InstanceNotFoundException, IOException {
        return this.mbs.getObjectInstance(name);
    }

    @SuppressWarnings("unused")
    public Set <ObjectInstance> queryMBeans(ObjectName name, QueryExp query)
        throws IOException {
        return this.mbs.queryMBeans(name, query);
    }

    @SuppressWarnings("unused")
    public Set queryNames(ObjectName name, QueryExp query)
        throws IOException {
        return this.mbs.queryNames(name, query);
    }

    @SuppressWarnings("unused")
    public boolean isRegistered(ObjectName name) throws IOException {
        return this.mbs.isRegistered(name);
    }

    @SuppressWarnings("unused")
    public Integer getMBeanCount() throws IOException {
        return this.mbs.getMBeanCount();
    }

    @SuppressWarnings("unused")
    public Object getAttribute(ObjectName name, String attribute)
        throws MBeanException, AttributeNotFoundException,
            InstanceNotFoundException, ReflectionException, IOException {
        return this.mbs.getAttribute(name, attribute);
    }

    @SuppressWarnings("unused")
    public AttributeList getAttributes(ObjectName name, String[] attributes)
        throws InstanceNotFoundException, ReflectionException, IOException {
        return mbs.getAttributes(name, attributes);
    }

    @SuppressWarnings("unused")
    public void setAttribute(ObjectName name, Attribute attribute)
        throws InstanceNotFoundException, AttributeNotFoundException,
            InvalidAttributeValueException, MBeanException, ReflectionException,
            IOException {
        this.mbs.setAttribute(name, attribute);
    }

    @SuppressWarnings("unused")
    public AttributeList setAttributes(ObjectName name, AttributeList attributes)
        throws InstanceNotFoundException, ReflectionException, IOException {
        return this.mbs.setAttributes(name, attributes);
    }

    @SuppressWarnings("unused")
    public Object invoke(ObjectName name, String operationName,
        Object[] params, String[] signature)
        throws InstanceNotFoundException, MBeanException, ReflectionException,
            IOException {
        return this.mbs.invoke(name, operationName, params, signature);
    }

    @SuppressWarnings("unused")
    public String getDefaultDomain() throws IOException {
        return this.mbs.getDefaultDomain();
    }

    @SuppressWarnings("unused")
    public String[] getDomains() throws IOException {
        return this.mbs.getDomains();
    }

    @SuppressWarnings("unused")
    public void addNotificationListener(ObjectName name, ObjectName listener,
        NotificationFilter filter, Object handback)
        throws InstanceNotFoundException, IOException {
        this.mbs.addNotificationListener(name, listener, filter, handback);
    }

    @SuppressWarnings("unused")
    public void addNotificationListener(ObjectName name,
        NotificationListener listener, NotificationFilter filter,
        Object handback) throws InstanceNotFoundException, IOException {
        System.out.println("ProActiveConnection.addNotificationListener()");
        try {
            ListenerAdapter tl = new ListenerAdapter(listener);
            
            this.listenerMap.put(listener, tl);
            this.mbs.addNotificationListener(name, tl, filter, handback);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @SuppressWarnings("unused")
    public void removeNotificationListener(ObjectName name, ObjectName listener)
        throws InstanceNotFoundException, ListenerNotFoundException, IOException {
        ListenerAdapter tl = this.listenerMap.get(listener);
        this.mbs.removeNotificationListener(name, tl);
    }

    @SuppressWarnings("unused")
    public void removeNotificationListener(ObjectName name,
        ObjectName listener, NotificationFilter filter, Object handback)
        throws InstanceNotFoundException, ListenerNotFoundException, IOException {
        ListenerAdapter tl = this.listenerMap.get(listener);
        this.mbs.removeNotificationListener(name, tl, filter, handback);
    }

    @SuppressWarnings("unused")
    public void removeNotificationListener(ObjectName name,
        NotificationListener listener)
        throws InstanceNotFoundException, ListenerNotFoundException, IOException {
        ListenerAdapter tl = this.listenerMap.get(listener);
        this.mbs.removeNotificationListener(name, tl);
    }

    @SuppressWarnings("unused")
    public void removeNotificationListener(ObjectName name,
        NotificationListener listener, NotificationFilter filter,
        Object handback)
        throws InstanceNotFoundException, ListenerNotFoundException, IOException {
        ListenerAdapter tl = this.listenerMap.get(listener);
        this.mbs.removeNotificationListener(name, tl, filter, handback);
    }

    @SuppressWarnings("unused")
    public MBeanInfo getMBeanInfo(ObjectName name)
        throws InstanceNotFoundException, IntrospectionException,
            ReflectionException, IOException {
        return this.mbs.getMBeanInfo(name);
    }

    @SuppressWarnings("unused")
    public boolean isInstanceOf(ObjectName name, String className)
        throws InstanceNotFoundException, IOException {
        return this.mbs.isInstanceOf(name, className);
    }

    @SuppressWarnings("unused")
    public ObjectInstance createMBean(String className, ObjectName name)
        throws ReflectionException, InstanceAlreadyExistsException,
            MBeanRegistrationException, MBeanException,
            NotCompliantMBeanException, IOException {
        return this.mbs.createMBean(className, name);
    }

    public GenericTypeWrapper createMBeanAsynchronous(String className,
        ObjectName name) {
        try {
            return new GenericTypeWrapper<ObjectInstance>(this.createMBean(
                    className, name));
        } catch (Exception e) {
            return new GenericTypeWrapper<Exception>(e);
        }
    }

    public GenericTypeWrapper createMBeanAsynchronous(String className,
        ObjectName name, ObjectName loaderName) {
        try {
            return new GenericTypeWrapper<ObjectInstance>(this.createMBean(
                    className, name, loaderName));
        } catch (Exception e) {
            return new GenericTypeWrapper<Exception>(e);
        }
    }

    /* *
     * This method is the same as createMBean but returns a reifiable type in order to perform ProActive asynchronous call
     * @see javax.management.MBeanServerConnection#createMBean(java.lang.String, javax.management.ObjectName, java.lang.Object[], java.lang.String[])
     */
    public GenericTypeWrapper createMBeanAsynchronous(String className,
        ObjectName name, Object[] params, String[] signature) {
        try {
            return new GenericTypeWrapper<ObjectInstance>(this.createMBean(
                    className, name, params, signature));
        } catch (Exception e) {
            return new GenericTypeWrapper<Exception>(e);
        }
    }

    public GenericTypeWrapper createMBeanAsynchronous(String className,
        ObjectName name, ObjectName loaderName, Object[] params,
        String[] signature) {
        try {
            return new GenericTypeWrapper<ObjectInstance>(this.createMBean(
                    className, name, loaderName, params, signature));
        } catch (Exception e) {
            return new GenericTypeWrapper<Exception>(e);
        }
    }

    public GenericTypeWrapper getObjectInstanceAsynchronous(ObjectName name) {
        try {
            return new GenericTypeWrapper<ObjectInstance>(this.getObjectInstance(
                    name));
        } catch (Exception e) {
            return new GenericTypeWrapper<Exception>(e);
        }
    }

    public GenericTypeWrapper queryMBeansAsynchronous(ObjectName name, QueryExp query) {
        try {
            return new GenericTypeWrapper<Set>(this.queryMBeans(name, query));
        } catch (IOException e) {
            return new GenericTypeWrapper<Exception>(e);
        }
    }

    public GenericTypeWrapper queryNamesAsynchronous(ObjectName name, QueryExp query) {
        try {
            return new GenericTypeWrapper<Set>(this.queryNames(name, query));
        } catch (IOException e) {
            return new GenericTypeWrapper<Exception> (e);
        }
    }

    public GenericTypeWrapper getMBeanCountAsynchronous() {
        try {
            return new GenericTypeWrapper<Integer>(this.getMBeanCount());
        } catch (IOException e) {
            return new GenericTypeWrapper<Exception> (e);
        }
    }

    public GenericTypeWrapper getAttributeAsynchronous(ObjectName name,
        String attribute) {
        try {
            return new GenericTypeWrapper <Object>(this.getAttribute(name, attribute));
        } catch (Exception e) {
                return new GenericTypeWrapper<Exception> (e);
        }
    }

    public GenericTypeWrapper getAttributesAsynchronous(ObjectName name,
        String[] attributes) {
        try {
            return new GenericTypeWrapper<AttributeList>(this.getAttributes(name, attributes));
        } catch (Exception e) {
           return new GenericTypeWrapper<Exception> (e);
        } 
    }

    public GenericTypeWrapper setAttributesAsynchronous(ObjectName name,
        AttributeList attributes) {
        try {
            return new GenericTypeWrapper<AttributeList>(this.setAttributes(name, attributes));
        } catch (Exception e) {
          return new GenericTypeWrapper<Exception>(e);
        } 
    }

    public GenericTypeWrapper invokeAsynchronous(ObjectName name,
        String operationName, Object[] params, String[] signature) {
        try {
            return new GenericTypeWrapper <Object>(this.invoke(name, operationName, params,
                    signature));
        } catch (Exception e) {
           return new  GenericTypeWrapper<Exception> (e);
        } 
    }

    public GenericTypeWrapper getDefaultDomainAsynchronous() {
        try {
            return new GenericTypeWrapper<String>(this.getDefaultDomain());
        } catch (IOException e) {
            return new GenericTypeWrapper<Exception> (e);
        }
    }

    public GenericTypeWrapper getDomainsAsynchronous() {
        try {
            return new GenericTypeWrapper <String [] >(this.getDomains());
        } catch (IOException e) {
          return new GenericTypeWrapper<Exception > (e);
        }
    }

    public GenericTypeWrapper  getMBeanInfoAsynchronous(ObjectName name) {
        try {
            return new GenericTypeWrapper<MBeanInfo>(this.getMBeanInfo(name));
        } catch (Exception e) {
      return new GenericTypeWrapper <Exception > (e);
        } 
    }
}

---