/*

 * 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.mbeanserver.Util;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Queue;

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

import javax.management.ListenerNotFoundException;

import javax.management.MBeanPermission;

import javax.management.MBeanServerDelegate;

import javax.management.MBeanServerNotification;

import javax.management.MalformedObjectNameException;

import javax.management.Notification;

import javax.management.NotificationFilter;

import javax.management.NotificationListener;

import javax.management.ObjectInstance;

import javax.management.ObjectName;

import javax.management.QueryExp;

import javax.management.namespace.JMXDomain;

/**

 * A DomainInterceptor wraps a JMXDomain.

 * <p><b>

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

 * </b></p>

 * @since 1.7

 */

public class DomainInterceptor extends HandlerInterceptor<JMXDomain> {

    // TODO: Ideally DomainInterceptor should be replaced by

    //       something at Repository level.

    //       The problem there will be that we may need to

    //       reinstantiate the 'queryPerformedByRepos' boolean

    //       [or we will need to wrap the repository in

    //        a 'RepositoryInterceptor'?]

    //       Also there's no real need for a DomainInterceptor to

    //       extend RewritingMBeanServerConnection.

    /**

     * A logger for this class.

     **/

    private static final Logger LOG = JmxProperties.NAMESPACE_LOGGER;

    private final String           domainName;

    private volatile ObjectName    ALL;

    private final String           serverName;

    private volatile NotificationListener mbsListener;

    private static class PatternNotificationFilter

            implements NotificationFilter {

        final ObjectName pattern;

        public PatternNotificationFilter(ObjectName pattern) {

            this.pattern = pattern;

        }

        public boolean isNotificationEnabled(Notification notification) {

            if (!(notification instanceof MBeanServerNotification))

                return false;

            final MBeanServerNotification mbsn =

                    (MBeanServerNotification) notification;

            if (pattern == null || pattern.apply(mbsn.getMBeanName()))

                return true;

            return false;

        }

        static final long serialVersionUID = 7409950927025262111L;

    }

    /**

     * Creates a new instance of NamespaceInterceptor

     */

    public DomainInterceptor(String serverName,

                             JMXDomain handler,

                             String domainName) {

        super(handler);

        this.domainName = domainName;

        this.serverName = serverName;

    }

    @Override

    public String toString() {

        return this.getClass().getName()+"(parent="+serverName+

                ", domain="+this.domainName+")";

    }

    public void connectDelegate(final MBeanServerDelegate delegate)

            throws InstanceNotFoundException {

        final NotificationFilter filter =

                new PatternNotificationFilter(getPatternFor(null));

        synchronized (this) {

            if (mbsListener == null)

                mbsListener = new NotificationListener() {

               public void handleNotification(Notification notification,

                    Object handback) {

                    if (filter.isNotificationEnabled(notification))

                        delegate.sendNotification(notification);

                }

            };

        }

        getNamespace().

                addMBeanServerNotificationListener(mbsListener, filter);

    }

    public void disconnectDelegate()

            throws InstanceNotFoundException, ListenerNotFoundException {

        final NotificationListener l;

        synchronized (this) {

            l = mbsListener;

            if (l == null) return;

            mbsListener = null;

        }

        getNamespace().removeMBeanServerNotificationListener(l);

    }

    public void addPostRegisterTask(Queue<Runnable> queue,

            final MBeanServerDelegate delegate) {

        if (queue == null)

            throw new IllegalArgumentException("task queue must not be null");

        final Runnable task1 = new Runnable() {

            public void run() {

                try {

                    connectDelegate(delegate);

                } catch (Exception x) {

                    throw new UnsupportedOperationException("notification forwarding",x);

                }

            }

        };

        queue.add(task1);

    }

    public void addPostDeregisterTask(Queue<Runnable> queue,

            final MBeanServerDelegate delegate) {

        if (queue == null)

            throw new IllegalArgumentException("task queue must not be null");

        final Runnable task1 = new Runnable() {

            public void run() {

                try {

                    disconnectDelegate();

                } catch (Exception x) {

                    throw new UnsupportedOperationException("notification forwarding",x);

                }

            }

        };

        queue.add(task1);

    }

    /**

     * Throws IllegalArgumentException if targetName.getDomain() is not

     * in the domain handled.

     **/

    @Override

    protected ObjectName toSource(ObjectName targetName) {

        if (targetName == null) return null;

        if (targetName.isDomainPattern()) return targetName;

        final String targetDomain = targetName.getDomain();

        // TODO: revisit this. RuntimeOperationsException may be better?

        //

        if (!targetDomain.equals(domainName))

            throw new IllegalArgumentException(targetName.toString());

        return targetName;

    }

    @Override

    protected ObjectName toTarget(ObjectName sourceName) {

        return sourceName;

    }

    /**

     * No rewriting: always return sources - stripping instances for which

     * the caller doesn't have permissions.

     **/

    @Override

    Set<ObjectInstance> processOutputInstances(Set<ObjectInstance> sources) {

        if (sources == null || sources.isEmpty() || !checkOn())

            return sources;

        final Set<ObjectInstance> res = Util.equivalentEmptySet(sources);

        for (ObjectInstance o : sources) {

            if (checkQuery(o.getObjectName(), "queryMBeans"))

                res.add(o);

        }

        return res;

    }

    /**

     * No rewriting: always return sourceNames - stripping names for which

     * the caller doesn't have permissions.

     **/

    @Override

    Set<ObjectName> processOutputNames(Set<ObjectName> sourceNames) {

        if (sourceNames == null || sourceNames.isEmpty() || !checkOn())

            return sourceNames;

        final Set<ObjectName> res = Util.equivalentEmptySet(sourceNames);

        for (ObjectName o : sourceNames) {

            if (checkQuery(o, "queryNames"))

                res.add(o);

        }

        return res;

    }

    /** No rewriting: always return source **/

    @Override

    ObjectInstance processOutputInstance(ObjectInstance source) {

        return source;

    }

    @Override

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

        try {

            // We don't trust the wrapped JMXDomain...

            final ObjectName pattern = getPatternFor(name);

            final Set<ObjectName> res = super.queryNames(pattern,query);

            return Util.filterMatchingNames(pattern,res);

        } catch (Exception x) {

            if (LOG.isLoggable(Level.FINE))

                LOG.fine("Unexpected exception raised in queryNames: "+x);

            LOG.log(Level.FINEST,"Unexpected exception raised in queryNames",x);

        }

        // We reach here only when an exception was raised.

        //

        final Set<ObjectName> empty = Collections.emptySet();

        return empty;

    }

    private ObjectName getPatternFor(final ObjectName name) {

        try {

            if (ALL == null) ALL = ObjectName.getInstance(domainName + ":*");

            if (name == null) return ALL;

            if (name.getDomain().equals(domainName)) return name;

            return name.withDomain(domainName);

        } catch (MalformedObjectNameException x) {

            throw new IllegalArgumentException(String.valueOf(name),x);

        }

   }

    @Override

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

        try {

            // We don't trust the wrapped JMXDomain...

            final ObjectName pattern = getPatternFor(name);

            final Set<ObjectInstance> res = super.queryMBeans(pattern,query);

            return Util.filterMatchingInstances(pattern,res);

        } catch (Exception x) {

            if (LOG.isLoggable(Level.FINE))

                LOG.fine("Unexpected exception raised in queryNames: "+x);

            LOG.log(Level.FINEST,"Unexpected exception raised in queryNames",x);

        }

        // We reach here only when an exception was raised.

        //

        final Set<ObjectInstance> empty = Collections.emptySet();

        return empty;

    }

    @Override

    public String getDefaultDomain() {

        return domainName;

    }

    @Override

    public String[] getDomains() {

        return new String[] {domainName};

    }

    // We call getMBeanCount() on the namespace rather than on the

    // source server in order to avoid counting MBeans which are not

    // in the domain.

    @Override

    public Integer getMBeanCount() {

        return getNamespace().getMBeanCount();

    }

    private boolean checkOn() {

        final SecurityManager sm = System.getSecurityManager();

        return (sm != null);

    }

    //

    // Implements permission checks.

    //

    @Override

    void check(ObjectName routingName, String member, String action) {

        if (!checkOn()) return;

        final String act = (action==null)?"-":action.intern();

        if(act == "queryMBeans" || act == "queryNames") { // ES: OK

            // This is tricky. check with 3 parameters is called

            // by queryNames/queryMBeans before performing the query.

            // At this point we must check with no class name.

            // Therefore we pass a className of "-".

            // The filtering will be done later - processOutputNames and

            // processOutputInstance will call checkQuery.

            //

            check(routingName, "-", "-", act);

        } else {

            // This is also tricky:

            // passing null here will cause check to retrieve the classname,

            // if needed.

            check(routingName, null, member, act);

        }

    }

    //

    // Implements permission checks.

    //

    @Override

    void checkCreate(ObjectName routingName, String className, String action) {

        if (!checkOn()) return;

        check(routingName,className,"-",action);

    }

    //

    // Implements permission checks.

    //

    void check(ObjectName routingName, String className, String member,

            String action) {

        if (!checkOn()) return;

        final MBeanPermission perm;

        // action is most probably already an intern string.

        // string literals are intern strings.

        // we create a new intern string for 'action' - just to be on

        // the safe side...

        // We intern it in order to be able to use == rather than equals

        // below, because if we don't, and if action is not one of the

        // 4 literals below, we would have to do a full string comparison.

        //

        final String act = (action==null)?"-":action.intern();

        if (act == "getDomains") { // ES: OK

            perm = new  MBeanPermission(serverName,"-",member,

                    routingName,act);

        } else {

            final String clazz =

                    (className==null)?getClassName(routingName):className;

            perm = new  MBeanPermission(serverName,clazz,member,

                    routingName,act);

        }

        final SecurityManager sm = System.getSecurityManager();

        if (sm != null)

            sm.checkPermission(perm);

    }

    String getClassName(ObjectName routingName) {

        if (routingName == null || routingName.isPattern()) return "-";

        try {

            return getNamespace().getSourceServer().

                    getObjectInstance(routingName).getClassName();

        } catch (InstanceNotFoundException ex) {

            LOG.finest("Can't get class name for "+routingName+

                    ", using \"-\". Cause is: "+ex);

            return "-";

        }

    }

    //

    // Implements permission filters for attributes...

    //

    @Override

    AttributeList checkAttributes(ObjectName routingName,

            AttributeList attributes, String action) {

        if (!checkOn()) return attributes;

        final String className = getClassName(routingName);

        check(routingName,className,"-",action);

        if (attributes == null || attributes.isEmpty()) return attributes;

        final AttributeList res = new AttributeList();

        for (Attribute at : attributes.asList()) {

            try {

                check(routingName,className,at.getName(),action);

                res.add(at);

            } catch (SecurityException x) { // DLS: OK

                continue;

            }

        }

        return res;

    }

    //

    // Implements permission filters for attributes...

    //

    @Override

    String[] checkAttributes(ObjectName routingName, String[] attributes,

            String action) {

        if (!checkOn()) return attributes;

        final String className = getClassName(routingName);

        check(routingName,className,"-",action);

        if (attributes == null || attributes.length==0) return attributes;

        final List<String> res = new ArrayList<String>(attributes.length);

        for (String at : attributes) {

            try {

                check(routingName,className,at,action);

                res.add(at);

            } catch (SecurityException x) { // DLS: OK

                continue;

            }

        }

        return res.toArray(new String[res.size()]);

    }

    //

    // Implements permission filters for domains...

    //

    @Override

    String[] checkDomains(String[] domains, String action) {

         if (domains == null || domains.length==0 || !checkOn())

             return domains;

         int count=0;

         for (int i=0;i<domains.length;i++) {

             try {

                 check(Util.newObjectName(domains[i]+":x=x"),"-",

                         "-","getDomains");

             } catch (SecurityException x) { // DLS: OK

                 count++;

                 domains[i]=null;

             }

         }

         if (count == 0) return domains;

         final String[] res = new String[domains.length-count];

         count = 0;

         for (int i=0;i<domains.length;i++)

             if (domains[i]!=null) res[count++]=domains[i];

         return res;

    }

    //

    // Implements permission filters for queries...

    //

    @Override

    boolean checkQuery(ObjectName routingName, String action) {

        try {

            final String className = getClassName(routingName);

            check(routingName,className,"-",action);

            return true;

        } catch (SecurityException x) { // DLS: OK

            return false;

        }

    }

}