/*

 * Copyright 2007-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 javax.management;

import com.sun.jmx.mbeanserver.NotificationMBeanSupport;

import com.sun.jmx.mbeanserver.Util;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Collections;

import java.util.Set;

/**

 * <p>General-purpose notification filter.  This filter can be used to

 * filter notifications from a possibly-remote MBean.  Most filtering

 * decisions can be coded using this filter, which avoids having to

 * write a custom implementation of the {@link NotificationFilter}

 * class.  Writing a custom implementation requires you to deploy it

 * on both the client and the server in the remote case, so using this class

 * instead is recommended where possible.</p>

 *

 * <p>This class uses the {@linkplain Query Query API} to specify the

 * filtering logic.  For example, to select only notifications where the

 * {@linkplain Notification#getType() type} is {@code "com.example.mytype"},

 * you could use</p>

 *

 * <pre>

 * NotificationFilter filter =

 *     new QueryNotificationFilter("Type = 'com.example.mytype'");

 * </pre>

 *

 * <p>or equivalently</p>

 *

 * <pre>

 * NotificationFilter filter =

 *     new QueryNotificationFilter(

 *             Query.eq(Query.attr("Type"), Query.value("com.example.mytype")));

 * </pre>

 *

 * <p>(This particular example could also use

 * {@link NotificationFilterSupport}.)</p>

 *

 * <p>Here are some other examples of filters you can specify with this class.</p>

 *

 * <dl>

 *

 * <dt>{@code QueryNotificationFilter("Type = 'com.example.type1' or

 * Type = 'com.example.type2'")}

 * <dd>Notifications where the type is either of the given strings.

 *

 * <dt>{@code QueryNotificationFilter("Type in ('com.example.type1',

 * 'com.example.type2')")}

 * <dd>Another way to write the previous example.

 *

 * <dt>{@code QueryNotificationFilter("SequenceNumber > 1000")}

 * <dd>Notifications where the {@linkplain Notification#getSequenceNumber()

 * sequence number} is greater than 1000.

 *

 * <dt>{@code QueryNotificationFilter(AttributeChangeNotification.class, null)}

 * <dd>Notifications where the notification class is

 * {@link AttributeChangeNotification} or a subclass of it.

 *

 * <dt>{@code QueryNotificationFilter(AttributeChangeNotification.class,

 * "AttributeName = 'Size'")}

 * <dd>Notifications where the notification class is

 * {@link AttributeChangeNotification} or a subclass, and where the

 * {@linkplain AttributeChangeNotification#getAttributeName() name of the

 * changed attribute} is {@code Size}.

 *

 * <dt>{@code QueryNotificationFilter(AttributeChangeNotification.class,

 * "AttributeName = 'Size' and NewValue - OldValue > 100")}

 * <dd>As above, but the difference between the

 * {@linkplain AttributeChangeNotification#getNewValue() new value} and the

 * {@linkplain AttributeChangeNotification#getOldValue() old value} must be

 * greater than 100.

 *

 * <dt>{@code QueryNotificationFilter("like 'com.example.mydomain:*'")}

 * <dd>Notifications where the {@linkplain Notification#getSource() source}

 * is an ObjectName that matches the pattern.

 *

 * <dt>{@code QueryNotificationFilter("Source.canonicalName like

 * 'com.example.mydomain:%'")}

 * <dd>Another way to write the previous example.

 *

 * <dt>{@code QueryNotificationFilter(MBeanServerNotification.class,

 * "Type = 'JMX.mbean.registered' and MBeanName.canonicalName like

 * 'com.example.mydomain:%'")}

 * <dd>Notifications of class {@link MBeanServerNotification} representing

 * an object registered in the domain {@code com.example.mydomain}.

 *

 * </dl>

 *

 * <h4>How it works</h4>

 *

 * <p>Although the examples above are clear, looking closely at the

 * Query API reveals a subtlety.  A {@link QueryExp} is evaluated on

 * an {@link ObjectName}, not a {@code Notification}.</p>

 *

 * <p>Every time a {@code Notification} is to be filtered by a

 * {@code QueryNotificationFilter}, a special {@link MBeanServer} is created.

 * This {@code MBeanServer} contains exactly one MBean, which represents the

 * {@code Notification}.  If the {@linkplain Notification#getSource()

 * source} of the notification is an {@code ObjectName}, which is

 * recommended practice, then the name of the MBean representing the

 * {@code Notification} will be this {@code ObjectName}.  Otherwise the

 * name is unspecified.</p>

 *

 * <p>The query specified in the {@code QueryNotificationFilter} constructor

 * is evaluated against this {@code MBeanServer} and {@code ObjectName},

 * and the filter returns true if and only if the query does.  If the

 * query throws an exception, then the filter will return false.</p>

 *

 * <p>The MBean representing the {@code Notification} has one attribute for

 * every property of the {@code Notification}. Specifically, for every public

 * method {@code T getX()} in the {@code NotificationClass}, the MBean will

 * have an attribute called {@code X} of type {@code T}. For example, if the

 * {@code Notification} is an {@code AttributeChangeNotification}, then the

 * MBean will have an attribute called {@code AttributeName} of type

 * {@code "java.lang.String"}, corresponding to the method {@link

 * AttributeChangeNotification#getAttributeName}.</p>

 *

 * <p>Query evaluation usually involves calls to the methods of {@code

 * MBeanServer}.  The methods have the following behavior:</p>

 *

 * <ul>

 * <li>The {@link MBeanServer#getAttribute getAttribute} method returns the

 * value of the corresponding property.

 * <li>The {@link MBeanServer#getObjectInstance getObjectInstance}

 * method returns an {@link ObjectInstance} where the {@link

 * ObjectInstance#getObjectName ObjectName} is the name of the MBean and the

 * {@link ObjectInstance#getClassName ClassName} is the class name of the

 * {@code Notification}.

 * <li>The {@link MBeanServer#isInstanceOf isInstanceOf} method returns true

 * if and only if the {@code Notification}'s {@code ClassLoader} can load the

 * named class, and the {@code Notification} is an {@linkplain Class#isInstance

 * instance} of that class.

 * </ul>

 *

 * <p>These are the only {@code MBeanServer} methods that are needed to

 * evaluate standard queries. The behavior of the other {@code MBeanServer}

 * methods is unspecified.</p>

 *

 * @since 1.7

 */

public class QueryNotificationFilter implements NotificationFilter {

    private static final long serialVersionUID = -8408613922660635231L;

    private static final ObjectName DEFAULT_NAME =

            Util.newObjectName(":type=Notification");

    private static final QueryExp trueQuery;

    static {

        ValueExp zero = Query.value(0);

        trueQuery = Query.eq(zero, zero);

    }

    private final QueryExp query;

    /**

     * Construct a {@code QueryNotificationFilter} that evaluates the given

     * {@code QueryExp} to determine whether to accept a notification.

     *

     * @param query the {@code QueryExp} to evaluate.  Can be null,

     * in which case all notifications are accepted.

     */

    public QueryNotificationFilter(QueryExp query) {

        if (query == null)

            this.query = trueQuery;

        else

            this.query = query;

    }

    /**

     * Construct a {@code QueryNotificationFilter} that evaluates the query

     * in the given string to determine whether to accept a notification.

     * The string is converted into a {@code QueryExp} using

     * {@link Query#fromString Query.fromString}.

     *

     * @param query the string specifying the query to evaluate.  Can be null,

     * in which case all notifications are accepted.

     *

      * @throws IllegalArgumentException if the string is not a valid

      * query string.

     */

    public QueryNotificationFilter(String query) {

        this(Query.fromString(query));

    }

    /**

     * <p>Construct a {@code QueryNotificationFilter} that evaluates the query

     * in the given string to determine whether to accept a notification,

     * and where the notification must also be an instance of the given class.

     * The string is converted into a {@code QueryExp} using

     * {@link Query#fromString Query.fromString}.</p>

     *

     * @param notifClass the class that the notification must be an instance of.

     * Cannot be null.

     *

     * @param query the string specifying the query to evaluate.  Can be null,

     * in which case all notifications are accepted.

     *

     * @throws IllegalArgumentException if the string is not a valid

     * query string, or if {@code notifClass} is null.

     */

    public QueryNotificationFilter(

            Class<? extends Notification> notifClass, String query) {

        this(Query.and(Query.isInstanceOf(Query.value(notNull(notifClass).getName())),

                       Query.fromString(query)));

    }

    private static <T> T notNull(T x) {

        if (x == null)

            throw new IllegalArgumentException("Null argument");

        return x;

    }

    /**

     * Retrieve the query that this notification filter will evaluate for

     * each notification.

     *

     * @return the query.

     */

    public QueryExp getQuery() {

        return query;

    }

    public boolean isNotificationEnabled(Notification notification) {

        ObjectName name;

        Object source = notification.getSource();

        if (source instanceof ObjectName)

            name = (ObjectName) source;

        else

            name = DEFAULT_NAME;

        MBS mbsImpl = new MBS(notification, name);

        MBeanServer mbs = (MBeanServer) Proxy.newProxyInstance(

                MBeanServer.class.getClassLoader(),

                new Class<?>[] {MBeanServer.class},

                new ForwardIH(mbsImpl));

        return evalQuery(query, mbs, name);

    }

    private static boolean evalQuery(

            QueryExp query, MBeanServer mbs, ObjectName name) {

        MBeanServer oldMBS = QueryEval.getMBeanServer();

        try {

            if (mbs != null)

                query.setMBeanServer(mbs);

            return query.apply(name);

        } catch (Exception e) {

            return false;

        } finally {

            query.setMBeanServer(oldMBS);

        }

    }

    private static class ForwardIH implements InvocationHandler {

        private final MBS mbs;

        ForwardIH(MBS mbs) {

            this.mbs = mbs;

        }

        public Object invoke(Object proxy, Method method, Object[] args)

                throws Throwable {

            Method forward;

            try {

                forward = MBS.class.getMethod(

                        method.getName(), method.getParameterTypes());

            } catch (NoSuchMethodException e) {

                throw new UnsupportedOperationException(method.getName());

            }

            try {

                return forward.invoke(mbs, args);

            } catch (InvocationTargetException e) {

                throw e.getCause();

            }

        }

    }

    private static class MBS {

        private final Notification notification;

        private final ObjectName objectName;

        private final ObjectInstance objectInstance;

        private volatile DynamicMBean mbean;

        MBS(Notification n, ObjectName name) {

            this.notification = n;

            this.objectName = name;

            this.objectInstance = new ObjectInstance(name, n.getClass().getName());

        }

        private void checkName(ObjectName name) throws InstanceNotFoundException {

            if (!objectName.equals(name))

                throw new InstanceNotFoundException(String.valueOf(name));

        }

        private DynamicMBean mbean(ObjectName name)

                throws InstanceNotFoundException, ReflectionException {

            if (mbean == null) {

                try {

                    mbean = new NotificationMBeanSupport(notification);

                } catch (NotCompliantMBeanException e) {

                    throw new ReflectionException(e);

                }

            }

            return mbean;

        }

        public ObjectInstance getObjectInstance(ObjectName name)

                throws InstanceNotFoundException {

            checkName(name);

            return objectInstance;

        }

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

            Set<ObjectName> names = queryNames(name, query);

            switch (names.size()) {

            case 0:

                return Collections.emptySet();

            case 1:

                return Collections.singleton(objectInstance);

            default:

                throw new UnsupportedOperationException("Internal error");

            }

        }

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

            if ((name != null && !name.apply(objectName)) ||

                    (query != null && !evalQuery(query, null, name)))

                return Collections.emptySet();

            return Collections.singleton(objectName);

        }

        public boolean isRegistered(ObjectName name) {

            return objectName.equals(name);

        }

        public Integer getMBeanCount() {

            return 1;

        }

        public Object getAttribute(ObjectName name, String attribute)

                throws MBeanException, AttributeNotFoundException,

                       InstanceNotFoundException, ReflectionException {

            return mbean(name).getAttribute(attribute);

        }

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

                throws InstanceNotFoundException, ReflectionException {

            return mbean(name).getAttributes(attributes);

        }

        public String getDefaultDomain() {

            return objectName.getDomain();

        }

        public String[] getDomains() {

            return new String[] {objectName.getDomain()};

        }

        public MBeanInfo getMBeanInfo(ObjectName name)

                throws InstanceNotFoundException, ReflectionException {

            return mbean(name).getMBeanInfo();

        }

        public boolean isInstanceOf(ObjectName name, String className)

                throws InstanceNotFoundException {

            try {

                mbean(name);

                ClassLoader loader = notification.getClass().getClassLoader();

                Class<?> c = Class.forName(className, false, loader);

                return c.isInstance(notification);

            } catch (ReflectionException e) {

                return false;

            } catch (ClassNotFoundException e) {

                return false;

            }

        }

        public ClassLoader getClassLoaderFor(ObjectName mbeanName)

                throws InstanceNotFoundException {

            checkName(mbeanName);

            return notification.getClass().getClassLoader();

        }

    }

}