/*

 * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package com.sun.jmx.namespace;

import com.sun.jmx.defaults.JmxProperties;

import com.sun.jmx.interceptor.MBeanServerInterceptor;

import com.sun.jmx.mbeanserver.Util;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.util.Set;

import java.util.logging.Level;

import java.util.logging.Logger;

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.NotCompliantMBeanException;

import javax.management.NotificationFilter;

import javax.management.NotificationListener;

import javax.management.ObjectInstance;

import javax.management.ObjectName;

import javax.management.OperationsException;

import javax.management.QueryExp;

import javax.management.ReflectionException;

import javax.management.RuntimeOperationsException;

import javax.management.loading.ClassLoaderRepository;

import javax.management.namespace.JMXNamespace;

/**

 * This interceptor wraps a JMXNamespace, and performs

 * {@code ObjectName} rewriting. {@code HandlerInterceptor} are

 * usually created and managed by a {@link NamespaceDispatcher} or

 * {@link DomainDispatcher}.

 * <p><b>

 * This API is a Sun internal API and is subject to changes without notice.

 * </b></p>

 * @since 1.7

 */

public abstract class HandlerInterceptor<T extends JMXNamespace>

        extends RoutingMBeanServerConnection<MBeanServer>

        implements MBeanServerInterceptor {

    /**

     * A logger for this class.

     **/

    private static final Logger LOG = JmxProperties.NAMESPACE_LOGGER;

    // The wrapped JMXNamespace

    private final T handler;

    /**

     * Creates a new instance of HandlerInterceptor

     */

    public HandlerInterceptor(T handler) {

        if (handler == null) throw new IllegalArgumentException("null");

        this.handler = handler;

    }

    @Override

    protected MBeanServer source() {

         return handler.getSourceServer();

    }

    // The MBeanServer on which getClassLoader / getClassLoaderFor

    // will be called.

    // The NamespaceInterceptor overrides this method - so that it

    // getClassLoader / getClassLoaderFor don't trigger the loop

    // detection mechanism.

    //

    MBeanServer getServerForLoading() {

         return source();

    }

    T getNamespace() {

        return handler;

    }

    // If the underlying JMXNamespace throws an IO, the IO will be

    // wrapped in a RuntimeOperationsException.

    RuntimeException handleIOException(IOException x,String fromMethodName,

            Object... params) {

            // Must do something here?

        if (LOG.isLoggable(Level.FINEST)) {

            LOG.finest("IO Exception in "+fromMethodName+": "+x+

                    " - "+" rethrowing as RuntimeOperationsException.");

        }

        throw new RuntimeOperationsException(

                    Util.newRuntimeIOException(x));

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public AttributeList getAttributes(ObjectName name, String[] attributes)

        throws InstanceNotFoundException, ReflectionException {

        try {

            return super.getAttributes(name, attributes);

        } catch (IOException ex) {

            throw handleIOException(ex,"getAttributes",name,attributes);

        }

    }

    // From MBeanServer

    public ClassLoader getClassLoaderFor(ObjectName mbeanName)

        throws InstanceNotFoundException {

        final ObjectName sourceName = toSourceOrRuntime(mbeanName);

        try {

            check(mbeanName,null,"getClassLoaderFor");

            return getServerForLoading().getClassLoaderFor(sourceName);

        } catch (RuntimeException ex) {

            throw makeCompliantRuntimeException(ex);

        }

    }

    // From MBeanServer

    public ClassLoader getClassLoader(ObjectName loaderName)

        throws InstanceNotFoundException {

        final ObjectName sourceName = toSourceOrRuntime(loaderName);

        try {

            check(loaderName,null,"getClassLoader");

            return getServerForLoading().getClassLoader(sourceName);

        } catch (RuntimeException ex) {

            throw makeCompliantRuntimeException(ex);

        }

    }

    // From MBeanServer

    public ObjectInstance registerMBean(Object object, ObjectName name)

        throws InstanceAlreadyExistsException, MBeanRegistrationException,

            NotCompliantMBeanException {

        final ObjectName sourceName = newSourceMBeanName(name);

        try {

            checkCreate(name,object.getClass().getName(),"registerMBean");

            return processOutputInstance(

                    source().registerMBean(object,sourceName));

        } catch (RuntimeException ex) {

            throw makeCompliantRuntimeException(ex);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public void removeNotificationListener(ObjectName name, ObjectName listener)

        throws InstanceNotFoundException, ListenerNotFoundException {

        try {

            super.removeNotificationListener(name, listener);

        } catch (IOException ex) {

            throw handleIOException(ex,"removeNotificationListener",name,listener);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public String getDefaultDomain() {

        try {

            return super.getDefaultDomain();

        } catch (IOException ex) {

            throw handleIOException(ex,"getDefaultDomain");

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public String[] getDomains() {

        try {

            return super.getDomains();

        } catch (IOException ex) {

            throw handleIOException(ex,"getDomains");

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public Integer getMBeanCount() {

        try {

            return super.getMBeanCount();

        } catch (IOException ex) {

            throw handleIOException(ex,"getMBeanCount");

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public void setAttribute(ObjectName name, Attribute attribute)

        throws InstanceNotFoundException, AttributeNotFoundException,

            InvalidAttributeValueException, MBeanException,

            ReflectionException {

        try {

            super.setAttribute(name, attribute);

        } catch (IOException ex) {

            throw handleIOException(ex,"setAttribute",name, attribute);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public Set<ObjectName> queryNames(ObjectName name, QueryExp query) {

        try {

            return super.queryNames(name, query);

        } catch (IOException ex) {

            throw handleIOException(ex,"queryNames",name, query);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public Set<ObjectInstance> queryMBeans(ObjectName name, QueryExp query) {

        try {

            return super.queryMBeans(name, query);

        } catch (IOException ex) {

            throw handleIOException(ex,"queryMBeans",name, query);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public boolean isInstanceOf(ObjectName name, String className)

        throws InstanceNotFoundException {

        try {

            return super.isInstanceOf(name, className);

        } catch (IOException ex) {

            throw handleIOException(ex,"isInstanceOf",name, className);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public ObjectInstance createMBean(String className, ObjectName name)

        throws ReflectionException, InstanceAlreadyExistsException,

            MBeanRegistrationException, MBeanException,

            NotCompliantMBeanException {

        try {

            return super.createMBean(className, name);

        } catch (IOException ex) {

            throw handleIOException(ex,"createMBean",className, name);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public ObjectInstance createMBean(String className, ObjectName name,

                        ObjectName loaderName)

        throws ReflectionException, InstanceAlreadyExistsException,

                MBeanRegistrationException, MBeanException,

                NotCompliantMBeanException, InstanceNotFoundException {

        try {

            return super.createMBean(className, name, loaderName);

        } catch (IOException ex) {

            throw handleIOException(ex,"createMBean",className, name, loaderName);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public Object getAttribute(ObjectName name, String attribute)

        throws MBeanException, AttributeNotFoundException,

            InstanceNotFoundException, ReflectionException {

        try {

            return super.getAttribute(name, attribute);

        } catch (IOException ex) {

            throw handleIOException(ex,"getAttribute",name, attribute);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public void removeNotificationListener(ObjectName name, ObjectName listener,

                            NotificationFilter filter, Object handback)

        throws InstanceNotFoundException, ListenerNotFoundException {

        try {

            super.removeNotificationListener(name, listener, filter, handback);

        } catch (IOException ex) {

            throw handleIOException(ex,"removeNotificationListener",name,

                    listener, filter, handback);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public void removeNotificationListener(ObjectName name,

                      NotificationListener listener, NotificationFilter filter,

                      Object handback)

        throws InstanceNotFoundException, ListenerNotFoundException {

        try {

            super.removeNotificationListener(name, listener, filter, handback);

        } catch (IOException ex) {

            throw handleIOException(ex,"removeNotificationListener",name,

                    listener, filter, handback);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public void removeNotificationListener(ObjectName name,

                NotificationListener listener)

        throws InstanceNotFoundException, ListenerNotFoundException {

        try {

            super.removeNotificationListener(name, listener);

        } catch (IOException ex) {

            throw handleIOException(ex,"removeNotificationListener",name,

                    listener);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public void addNotificationListener(ObjectName name,

                    NotificationListener listener, NotificationFilter filter,

                    Object handback) throws InstanceNotFoundException {

        try {

            super.addNotificationListener(name, listener, filter, handback);

        } catch (IOException ex) {

            throw handleIOException(ex,"addNotificationListener",name,

                    listener, filter, handback);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public void addNotificationListener(ObjectName name, ObjectName listener,

                NotificationFilter filter, Object handback)

        throws InstanceNotFoundException {

        try {

            super.addNotificationListener(name, listener, filter, handback);

        } catch (IOException ex) {

            throw handleIOException(ex,"addNotificationListener",name,

                    listener, filter, handback);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public boolean isRegistered(ObjectName name) {

        try {

            return super.isRegistered(name);

        } catch (IOException ex) {

            throw handleIOException(ex,"isRegistered",name);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public void unregisterMBean(ObjectName name)

        throws InstanceNotFoundException, MBeanRegistrationException {

        try {

            super.unregisterMBean(name);

        } catch (IOException ex) {

            throw handleIOException(ex,"unregisterMBean",name);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public MBeanInfo getMBeanInfo(ObjectName name)

        throws InstanceNotFoundException, IntrospectionException,

            ReflectionException {

        try {

            return super.getMBeanInfo(name);

        } catch (IOException ex) {

            throw handleIOException(ex,"getMBeanInfo",name);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public ObjectInstance getObjectInstance(ObjectName name)

        throws InstanceNotFoundException {

        try {

            return super.getObjectInstance(name);

        } catch (IOException ex) {

            throw handleIOException(ex,"getObjectInstance",name);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public ObjectInstance createMBean(String className, ObjectName name,

                Object[] params, String[] signature)

        throws ReflectionException, InstanceAlreadyExistsException,

            MBeanRegistrationException, MBeanException,

            NotCompliantMBeanException {

        try {

            return super.createMBean(className, name, params, signature);

        } catch (IOException ex) {

            throw handleIOException(ex,"createMBean",className, name,

                    params, signature);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public ObjectInstance createMBean(String className, ObjectName name,

                ObjectName loaderName, Object[] params, String[] signature)

        throws ReflectionException, InstanceAlreadyExistsException,

            MBeanRegistrationException, MBeanException,

            NotCompliantMBeanException, InstanceNotFoundException {

        try {

            return super.createMBean(className, name, loaderName, params,

                    signature);

        } catch (IOException ex) {

            throw handleIOException(ex,"createMBean",className, name,loaderName,

                    params, signature);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public AttributeList setAttributes(ObjectName name,AttributeList attributes)

    throws InstanceNotFoundException, ReflectionException {

        try {

            return super.setAttributes(name, attributes);

        } catch (IOException ex) {

            throw handleIOException(ex,"setAttributes",name, attributes);

        }

    }

    // From MBeanServer: catch & handles IOException

    @Override

    public Object invoke(ObjectName name, String operationName, Object[] params,

                String[] signature)

        throws InstanceNotFoundException, MBeanException, ReflectionException {

        try {

            return super.invoke(name, operationName, params, signature);

        } catch (IOException ex) {

            throw handleIOException(ex,"invoke",name, operationName,

                    params, signature);

        }

    }

    //

    //  These methods are inherited from MBeanServer....

    //

    /**

     * This method should never be called.

     * Throws UnsupportedOperationException.

     */

    public Object instantiate(String className)

            throws ReflectionException, MBeanException {

        if (LOG.isLoggable(Level.FINE))

            LOG.fine("call to unsupported instantiate method: " +

                    "trowing UnsupportedOperationException");

        throw new UnsupportedOperationException("Not applicable.");

    }

    /**

     * This method should never be called.

     * Throws UnsupportedOperationException.

     */

    public Object instantiate(String className, ObjectName loaderName)

            throws ReflectionException, MBeanException,

            InstanceNotFoundException {

        if (LOG.isLoggable(Level.FINE))

            LOG.fine("call to unsupported method: instantiate(...) -" +

                    "throwing UnsupportedOperationException");

        throw new UnsupportedOperationException("Not applicable.");

    }

    /**

     * This method should never be called.

     * Throws UnsupportedOperationException.

     */

    public Object instantiate(String className, Object[] params,

            String[] signature) throws ReflectionException, MBeanException {

        if (LOG.isLoggable(Level.FINE))

            LOG.fine("call to unsupported method: instantiate(...) -" +

                    "throwing UnsupportedOperationException");

        throw new UnsupportedOperationException("Not applicable.");

    }

    /**

     * This method should never be called.

     * Throws UnsupportedOperationException.

     */

    public Object instantiate(String className, ObjectName loaderName,

            Object[] params, String[] signature)

            throws ReflectionException, MBeanException,

            InstanceNotFoundException {

        if (LOG.isLoggable(Level.FINE))

            LOG.fine("call to unsupported method: instantiate(...) -" +

                    "throwing UnsupportedOperationException");

        throw new UnsupportedOperationException("Not applicable.");

    }

    /**

     * This method should never be called.

     * Throws UnsupportedOperationException.

     */

    @Deprecated

    public ObjectInputStream deserialize(ObjectName name, byte[] data)

            throws InstanceNotFoundException, OperationsException {

        if (LOG.isLoggable(Level.FINE))

            LOG.fine("call to unsupported method: deserialize(...) -" +

                    "throwing UnsupportedOperationException");

        throw new UnsupportedOperationException("Not applicable.");