/*

 * 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.

 *

 * 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.

 *

 */

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.Serializable;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.management.ManagementFactory;

import java.lang.ref.WeakReference;

import java.lang.reflect.AccessibleObject;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.WeakHashMap;

import java.util.concurrent.Callable;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentMap;

import javax.management.Attribute;

import javax.management.AttributeList;

import javax.management.AttributeNotFoundException;

import javax.management.DynamicMBean;

import javax.management.InstanceAlreadyExistsException;

import javax.management.InstanceNotFoundException;

import javax.management.IntrospectionException;

import javax.management.InvalidAttributeValueException;

import javax.management.ListenerNotFoundException;

import javax.management.MBeanAttributeInfo;

import javax.management.MBeanConstructorInfo;

import javax.management.MBeanException;

import javax.management.MBeanInfo;

import javax.management.MBeanNotificationInfo;

import javax.management.MBeanOperationInfo;

import javax.management.MBeanRegistration;

import javax.management.MBeanRegistrationException;

import javax.management.MBeanServer;

import javax.management.MBeanServerBuilder;

import javax.management.MBeanServerConnection;

import javax.management.MBeanServerDelegate;

import javax.management.MBeanServerFactory;

import javax.management.MBeanServerNotification;

import javax.management.MalformedObjectNameException;

import javax.management.NotCompliantMBeanException;

import javax.management.Notification;

import javax.management.NotificationBroadcaster;

import javax.management.NotificationBroadcasterSupport;

import javax.management.NotificationEmitter;

import javax.management.NotificationFilter;

import javax.management.NotificationListener;

import javax.management.ObjectInstance;

import javax.management.ObjectName;

import javax.management.OperationsException;

import javax.management.QueryEval;

import javax.management.QueryExp;

import javax.management.ReflectionException;

import javax.management.RuntimeErrorException;

import javax.management.RuntimeMBeanException;

import javax.management.StandardMBean;

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;

/*

 * @test OldMBeanServerTest.java

 * @bug 5072268

 * @summary Test that nothing assumes a post-1.2 MBeanServer

 * @author Eamonn McManus

 * @run main/othervm -ea OldMBeanServerTest

 */

/*

 * We defined the MBeanServerBuilder class and the associated system

 * property javax.management.builder.initial in version 1.2 of the JMX

 * spec.  That amounts to a guarantee that someone can set the property

 * to an MBeanServer that only knows about JMX 1.2 semantics, and if they

 * only do JMX 1.2 operations, everything should work.  This test is a

 * sanity check that ensures we don't inadvertently make any API changes

 * that stop that from being true.  It includes a complete (if slow)

 * MBeanServer implementation.  That implementation doesn't replicate the

 * mandated exception behaviour everywhere, though, since there's lots of

 * arbitrary cruft in that.  Also, the behaviour of concurrent unregisterMBean

 * calls is incorrect in detail.

 */

public class OldMBeanServerTest {

    private static MBeanServerConnection mbsc;

    private static String failure;

    public static void main(String[] args) throws Exception {

        if (!OldMBeanServerTest.class.desiredAssertionStatus())

            throw new Exception("Test must be run with -ea");

        System.setProperty("javax.management.builder.initial",

                OldMBeanServerBuilder.class.getName());

        assert MBeanServerFactory.newMBeanServer() instanceof OldMBeanServer;

        System.out.println("=== RUNNING TESTS WITH LOCAL MBEANSERVER ===");

        runTests(new Callable<MBeanServerConnection>() {

            public MBeanServerConnection call() {

                return MBeanServerFactory.newMBeanServer();

            }

        }, null);

        System.out.println("=== RUNNING TESTS THROUGH CONNECTOR ===");

        ConnectionBuilder builder = new ConnectionBuilder();

        runTests(builder, builder);

        if (failure == null)

            System.out.println("TEST PASSED");

        else

            throw new Exception("TEST FAILED: " + failure);

    }

    private static class ConnectionBuilder

            implements Callable<MBeanServerConnection>, Runnable {

        private JMXConnector connector;

        public MBeanServerConnection call() {

            MBeanServer mbs = MBeanServerFactory.newMBeanServer();

            try {

                JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://");

                JMXConnectorServer cs =

                    JMXConnectorServerFactory.newJMXConnectorServer(

                        url, null, mbs);

                cs.start();

                JMXServiceURL addr = cs.getAddress();

                connector = JMXConnectorFactory.connect(addr);

                return connector.getMBeanServerConnection();

            } catch (IOException e) {

                throw new RuntimeException(e);

            }

        }

        public void run() {

            if (connector != null) {

                try {

                    connector.close();

                } catch (IOException e) {

                    throw new RuntimeException(e);

                }

            }

        }

    }

    private static void runTests(

            Callable<MBeanServerConnection> maker, Runnable breaker)

    throws Exception {

        for (Method m : OldMBeanServerTest.class.getDeclaredMethods()) {

            if (Modifier.isStatic(m.getModifiers()) &&

                    m.getName().startsWith("test") &&

                    m.getParameterTypes().length == 0) {

                ExpectException expexc = m.getAnnotation(ExpectException.class);

                mbsc = maker.call();

                try {

                    m.invoke(null);

                    if (expexc != null) {

                        failure =

                                m.getName() + " did not got expected exception " +

                                expexc.value().getName();

                        System.out.println(failure);

                    } else

                        System.out.println(m.getName() + " OK");

                } catch (InvocationTargetException ite) {

                    Throwable t = ite.getCause();

                    String prob = null;

                    if (expexc != null) {

                        if (expexc.value().isInstance(t)) {

                            System.out.println(m.getName() + " OK (got expected " +

                                    expexc.value().getName() + ")");

                        } else

                            prob = "got wrong exception";

                    } else

                        prob = "got exception";

                    if (prob != null) {

                        failure = m.getName() + ": " + prob + " " +

                                t.getClass().getName();

                        System.out.println(failure);

                        t.printStackTrace(System.out);

                    }

                } finally {

                    if (breaker != null)

                        breaker.run();

                }

            }

        }

    }

    @Retention(RetentionPolicy.RUNTIME)

    private static @interface ExpectException {

        Class<? extends Exception> value();

    }

    public static interface BoringMBean {

        public String getName();

        public int add(int x, int y);

    }

    // This class is Serializable so we can createMBean a StandardMBean

    // that contains it.  Not recommended practice in general --

    // should we have a StandardMBean constructor that takes a class

    // name and constructor parameters?

    public static class Boring implements BoringMBean, Serializable {

        public String getName() {

            return "Jessica";

        }

        public int add(int x, int y) {

            return x + y;

        }

    }

    public static interface BoringNotifierMBean extends BoringMBean {

        public void send();

    }

    public static class BoringNotifier

            extends Boring implements BoringNotifierMBean, NotificationBroadcaster {

        private final NotificationBroadcasterSupport nbs =

                new NotificationBroadcasterSupport();

        public void addNotificationListener(

                NotificationListener listener, NotificationFilter filter, Object handback)

        throws IllegalArgumentException {

            nbs.addNotificationListener(listener, filter, handback);

        }

        public void removeNotificationListener(NotificationListener listener)

        throws ListenerNotFoundException {

            nbs.removeNotificationListener(listener);

        }

        public MBeanNotificationInfo[] getNotificationInfo() {

            return null;

        }

        public void send() {

            Notification n = new Notification("type.type", this, 0L);

            nbs.sendNotification(n);

        }

    }

    private static class CountListener implements NotificationListener {

        volatile int count;

        public void handleNotification(Notification n, Object h) {

            if (h == null)

                h = 1;

            count += (Integer) h;

        }

        void waitForCount(int expect) throws InterruptedException {

            long deadline = System.currentTimeMillis() + 2000L;

            while (count < expect && System.currentTimeMillis() < deadline)

                Thread.sleep(1);

            assert count == expect;

        }

    }

    private static void testBasic() throws Exception {

        CountListener countListener = new CountListener();

        mbsc.addNotificationListener(

                MBeanServerDelegate.DELEGATE_NAME, countListener, null, null);

        assert countListener.count == 0;

        ObjectName name = new ObjectName("a:b=c");

        if (mbsc instanceof MBeanServer)

            ((MBeanServer) mbsc).registerMBean(new Boring(), name);

        else

            mbsc.createMBean(Boring.class.getName(), name);

        countListener.waitForCount(1);

        assert mbsc.isRegistered(name);

        assert mbsc.queryNames(null, null).contains(name);

        assert mbsc.getAttribute(name, "Name").equals("Jessica");

        assert mbsc.invoke(

                name, "add", new Object[] {2, 3}, new String[] {"int", "int"})

                .equals(5);

        mbsc.unregisterMBean(name);

        countListener.waitForCount(2);

        assert !mbsc.isRegistered(name);

        assert !mbsc.queryNames(null, null).contains(name);

        mbsc.createMBean(BoringNotifier.class.getName(), name);

        countListener.waitForCount(3);

        CountListener boringListener = new CountListener();

        class AlwaysNotificationFilter implements NotificationFilter {

            public boolean isNotificationEnabled(Notification notification) {

                return true;

            }

        }

        mbsc.addNotificationListener(

                name, boringListener, new AlwaysNotificationFilter(), 5);

        mbsc.invoke(name, "send", null, null);

        boringListener.waitForCount(5);

    }

    private static void testPrintAttrs() throws Exception {

        printAttrs(mbsc, null);

    }

    private static void testPlatformMBeanServer() throws Exception {

        MBeanServer pmbs = ManagementFactory.getPlatformMBeanServer();

        assert pmbs instanceof OldMBeanServer;

        // Preceding assertion could be violated if at some stage we wrap

        // the Platform MBeanServer.  In that case we can still check that

        // it is ultimately an OldMBeanServer for example by adding a

        // counter to getAttribute and checking that it is incremented

        // when we call pmbs.getAttribute.

        printAttrs(pmbs, UnsupportedOperationException.class);

        ObjectName memoryMXBeanName =

                new ObjectName(ManagementFactory.MEMORY_MXBEAN_NAME);

        pmbs.invoke(memoryMXBeanName, "gc", null, null);

    }

    private static void printAttrs(

            MBeanServerConnection mbsc1, Class<? extends Exception> expectX)

    throws Exception {

        Set<ObjectName> names = mbsc1.queryNames(null, null);

        for (ObjectName name : names) {

            System.out.println(name + ":");

            MBeanInfo mbi = mbsc1.getMBeanInfo(name);

            MBeanAttributeInfo[] mbais = mbi.getAttributes();

            for (MBeanAttributeInfo mbai : mbais) {

                String attr = mbai.getName();

                Object value;

                try {

                    value = mbsc1.getAttribute(name, attr);

                } catch (Exception e) {

                    if (expectX != null && expectX.isInstance(e))

                        value = "<" + e + ">";

                    else

                        throw e;

                }

                String s = "  " + attr + " = " + value;

                if (s.length() > 80)

                    s = s.substring(0, 77) + "...";

                System.out.println(s);

            }

        }

    }

    private static void testJavaxManagementStandardMBean() throws Exception {

        ObjectName name = new ObjectName("a:b=c");

        Object mbean = new StandardMBean(new Boring(), BoringMBean.class);

        mbsc.createMBean(

                StandardMBean.class.getName(), name,

                new Object[] {new Boring(), BoringMBean.class},

                new String[] {Object.class.getName(), Class.class.getName()});

        assert mbsc.getAttribute(name, "Name").equals("Jessica");

        assert mbsc.invoke(

                name, "add", new Object[] {2, 3}, new String[] {"int", "int"})

                .equals(5);

        mbsc.unregisterMBean(name);

    }

    private static void testConnector() throws Exception {

    }

    public static class OldMBeanServerBuilder extends MBeanServerBuilder {

        public MBeanServer newMBeanServer(

                String defaultDomain, MBeanServer outer, MBeanServerDelegate delegate) {

            return new OldMBeanServer(defaultDomain, delegate);

        }

    }

    public static class OldMBeanServer implements MBeanServer {

        // We pretend there's a ClassLoader MBean representing the Class Loader

        // Repository and intercept references to it where necessary to keep up

        // the pretence.  This allows us to fake the right behaviour for

        // the omitted-ClassLoader versions of createMBean and instantiate

        // (which are not the same as passing a null for the ClassLoader parameter

        // of the versions that have one).

        private static final ObjectName clrName;

        static {

            try {

                clrName =

                        new ObjectName("JMImplementation:type=ClassLoaderRepository");

            } catch (MalformedObjectNameException e) {

                throw new RuntimeException(e);

            }

        }

        private final ConcurrentMap<ObjectName, DynamicMBean> mbeans =

                new ConcurrentHashMap<ObjectName, DynamicMBean>();

        private final ConcurrentMap<ObjectName, ListenerTable> listenerMap =

                new ConcurrentHashMap<ObjectName, ListenerTable>();

        private final String defaultDomain;

        private final MBeanServerDelegate delegate;

        private final ClassLoaderRepositoryImpl clr =

                new ClassLoaderRepositoryImpl();

        OldMBeanServer(String defaultDomain, MBeanServerDelegate delegate) {

            this.defaultDomain = defaultDomain;

            this.delegate = delegate;

            try {

                registerMBean(delegate, MBeanServerDelegate.DELEGATE_NAME);

            } catch (Exception e) {

                throw new RuntimeException(e);

            }

        }

        public ObjectInstance createMBean(String className, ObjectName name)

        throws ReflectionException, InstanceAlreadyExistsException,

                MBeanRegistrationException, MBeanException,

                NotCompliantMBeanException {

            return createMBean(className, name, null, null);

        }

        public ObjectInstance createMBean(

                String className, ObjectName name, ObjectName loaderName)

        throws ReflectionException, InstanceAlreadyExistsException,

                MBeanRegistrationException, MBeanException,

                NotCompliantMBeanException, InstanceNotFoundException {

            return createMBean(className, name, loaderName, null, null);

        }

        public ObjectInstance createMBean(

                String className, ObjectName name, Object[] params, String[] signature)

        throws ReflectionException, InstanceAlreadyExistsException,

                MBeanRegistrationException, MBeanException,

                NotCompliantMBeanException {

            try {

                return createMBean(className, name, clrName, params, signature);

            } catch (InstanceNotFoundException ex) {

                throw new RuntimeException(ex);  // can't happen

            }

        }

        public ObjectInstance createMBean(

                String className, ObjectName name, ObjectName loaderName,

                Object[] params, String[] signature)

        throws ReflectionException, InstanceAlreadyExistsException,

                MBeanRegistrationException, MBeanException,

                NotCompliantMBeanException, InstanceNotFoundException {

            Object mbean = instantiate(className, loaderName, params, signature);

            return registerMBean(mbean, name);

        }

        private void forbidJMImpl(ObjectName name) {

            if (name.getDomain().equals("JMImplementation") &&

                    mbeans.containsKey(MBeanServerDelegate.DELEGATE_NAME))

                throw new IllegalArgumentException("JMImplementation reserved");

        }

        public ObjectInstance registerMBean(Object object, ObjectName name)

        throws InstanceAlreadyExistsException, MBeanRegistrationException,

                NotCompliantMBeanException {

            forbidJMImpl(name);

            if (name.isPattern())

                throw new IllegalArgumentException(name.toString());

            // This is the only place we check for wildcards.  Since you

            // can't register a wildcard name, other operations that supply

            // one will get InstanceNotFoundException when they look it up.

            DynamicMBean mbean;

            if (object instanceof DynamicMBean)

                mbean = (DynamicMBean) object;

            else

                mbean = standardToDynamic(object);

            MBeanRegistration reg = mbeanRegistration(object);

            try {

                name = reg.preRegister(this, name);

            } catch (Exception e) {

                throw new MBeanRegistrationException(e);

            }

            DynamicMBean put = mbeans.putIfAbsent(name, mbean);

            if (put != null) {

                reg.postRegister(false);

                throw new InstanceAlreadyExistsException(name.toString());

            }

            reg.postRegister(true);

            if (object instanceof ClassLoader)

                clr.addLoader((ClassLoader) object);

            Notification n = new MBeanServerNotification(

                    MBeanServerNotification.REGISTRATION_NOTIFICATION,

                    MBeanServerDelegate.DELEGATE_NAME,

                    0,

                    name);

            delegate.sendNotification(n);

            String className = mbean.getMBeanInfo().getClassName();

            return new ObjectInstance(name, className);

        }

        public void unregisterMBean(ObjectName name)

        throws InstanceNotFoundException, MBeanRegistrationException {

            forbidJMImpl(name);

            DynamicMBean mbean = getMBean(name);

            if (mbean == null)

                throw new InstanceNotFoundException(name.toString());

            MBeanRegistration reg = mbeanRegistration(mbean);

            try {

                reg.preDeregister();

            } catch (Exception e) {

                throw new MBeanRegistrationException(e);

            }