/*

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

 *

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

 */

/*

 *

 * @test JMXNamespaceViewTest.java

 * @summary Test the JMXNamespaceView class.

 * @author Daniel Fuchs

 * @run clean JMXNamespaceViewTest Wombat WombatMBean

 * @run build JMXNamespaceViewTest Wombat WombatMBean

 * @run main JMXNamespaceViewTest

 */

import java.lang.management.ManagementFactory;

import java.net.ServerSocket;

import java.rmi.registry.LocateRegistry;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.management.JMException;

import javax.management.MBeanRegistration;

import javax.management.MBeanServer;

import javax.management.MBeanServerFactory;

import javax.management.ObjectInstance;

import javax.management.ObjectName;

import javax.management.namespace.JMXNamespace;

import javax.management.namespace.JMXNamespaceView;

import javax.management.namespace.JMXNamespaces;

import javax.management.namespace.JMXRemoteNamespace;

import javax.management.remote.JMXConnectorServer;

import javax.management.remote.JMXConnectorServerFactory;

import javax.management.remote.JMXServiceURL;

/**

 * A simple test to test the JMXNamespaceViewTest...

 * @author dfuchs

 */

public class JMXNamespaceViewTest {

    // TODO: Remove this when contexts are added.

    public static class ClientContext {

        public final static String NAMESPACE = "jmx.context";

    }

    /**

     * Describe the configuration of a namespace

     */

    public static class NamespaceConfig {

        /** name of the namespace - no // allowed **/

        public String name;

        /**

         * JMXServiceURL through which the namespace is exported, if it

         * is a remote namespace. {@code null} if the namespace is local.

         * This is an inpur URL - eg: new JMXServiceURL("rmi",null,0).toString()

         * is acceptable here.

         */

        public String jmxurl;

        /**

         * Values of the name= key for each WombatMBean contained in the

         * namespace.

         */

        public String[] wombats;

        /** list of child namespace **/

        public NamespaceConfig[] children;

    }

    /**

     * Creates a NamespaceConfig record for a local namespace.

     * @param name     name  of the namespace

     * @param wombats  names of WombatMBean it should contain.

     * @return a NamespaceConfig.

     */

    public static NamespaceConfig config(String name, String[] wombats) {

        return config(name,null,wombats);

    }

    /**

     * Creates a NamespaceConfig record for a remote namespace.

     * @param name    name  of the namespace

     * @param jmxurl  input JMXServiceURL for creating the JMXConnectorServer

     * @param wombats names of WombatMBean it should contain.

     * @return a NamespaceConfig.

     */

    public static NamespaceConfig config(String name, String jmxurl,

            String[] wombats) {

        return config(name,jmxurl,wombats,(NamespaceConfig[])null);

    }

    /**

     * Creates a NamespaceConfig record for a local namespace.

     * @param name     name  of the namespace

     * @param wombats  names of WombatMBean it should contain.

     * @param children list  of sub namespaces.

     * @return a NamespaceConfig.

     */

    public static NamespaceConfig config(String name, String[] wombats,

            NamespaceConfig... children) {

        return config(name,null,wombats,children);

    }

    /**

     * Creates a NamespaceConfig record for a remote namespace.

     * @param name    name  of the namespace

     * @param jmxurl  input JMXServiceURL for creating the JMXConnectorServer

     * @param wombats names of WombatMBean it should contain.

     * @param children list  of sub namespaces.

     * @return a NamespaceConfig.

     */

    static NamespaceConfig config(String name, String jmxurl, String[] wombats,

            NamespaceConfig... children) {

         final NamespaceConfig cfg = new NamespaceConfig();

         cfg.name=name; cfg.jmxurl=jmxurl; cfg.wombats=wombats;

         cfg.children=children;

         return cfg;

    }

    /**

     * Returns the given names. This is a utility method to ease code

     * reading.

     * @param names names of Wombat MBeans.

     * @return the given names.

     */

    static String[] wombats(String... names) {

        return names;

    }

    /**

     * Creates a JMXServiceURL string for the given protocol.

     * This is also a utility method to ease code reading.

     * @param protocol The protocol name (e.g. "rmi")

     * @return A JMXServiceURL string.

     * @throws Exception if creation of the JMXServiceURL fails.

     */

    static String url(String protocol) throws Exception {

        return new JMXServiceURL(protocol,null,0).toString();

    }

    /**

     * Creates a config for a hierarchy of namespaces, mixing local namespaces

     * and remote namespaces using the given protocol.

     * @param protocol The protocol that should be used for remote namespaces.

     * @return A namespace config hierarchy.

     * @throws java.lang.Exception

     */

    public static NamespaceConfig[] makeConfig(String protocol)

        throws Exception {

        final NamespaceConfig[] config = {

        // Top level namespace "top1" (local)

        config("top1",wombats("wchief","w1","w2","w3"),

                // top1//local1

                config("local1",wombats("wchief","ww1","ww2")),

                // top1//local2

                config("local2",wombats("wchief","ww4","ww5","ww6"),

                    // top1//local2//local3

                    config("local3",wombats("wchief","www1","www2")),

                    // top1//local2//rmi1

                    config("rmi1",url(protocol),wombats("wchief","www3","www4","www5"))),

                // top1//rmi2

                config("rmi2",url(protocol),wombats("wchief","ww7","ww8","ww9"),

                    // top1//rmi2//local4

                    config("local4",wombats("wchief","www6","www7")),

                    // top1//rmi2//rmi3

                    config("rmi3",url(protocol),wombats("wchief","www3","www4","www5"),

                        // top1//rmi2//rmi3//local5

                        config("local5",wombats("wchief","wwww1"))))),

        // Top level namespace "top2" (local)

        config("top2",wombats("wchief","w21","w22","w23"),

                // top2//local21

                config("local21",wombats("wchief","ww21","ww22")),

                // top2//rmi22

                config("rmi22",url(protocol),wombats("wchief","ww27","ww28","ww29"),

                    // top2//rmi22//local24

                    config("local24",wombats("wchief","www26","www27")),

                    // top2//rmi22//rmi23

                    config("rmi23",url(protocol),wombats("wchief","www23","www24","www25"),

                        // top2//rmi22//rmi23//local25

                        config("local25",wombats("wchief","wwww21"))))),

        // Top level namespace "top3" (remote)

        config("top3",url(protocol),wombats("wchief","w31","w32","w33"),

                // top3//local31

                config("local31",wombats("wchief","ww31","ww32")),

                // top3//rmi32

                config("rmi32",url(protocol),wombats("wchief","ww37","ww38","ww39"),

                    // top3//rmi32//local34

                    config("local34",wombats("wchief","www36","www37")),

                    // top3//rmi32//rmi33

                    config("rmi33",url(protocol),wombats("wchief","www33","www34","www35"),

                        // top3//rmi32//local35

                        config("local35",wombats("wchief","wwww31"))))),

        };

        return config;

    }

    /**

     * Close all connector servers in the list.

     * @param cslist List of connector servers to close.

     */

    public static void closeAll(List<JMXConnectorServer> cslist) {

            for (JMXConnectorServer cs : cslist) {

                try {

                    cs.stop();

                } catch (Exception xx) {

                    System.err.println("Failed to stop connector: " + xx);

                }

            }

    }

    public static class MBeanServerConfigCreator {

        public MBeanServer createMBeanServerFor(NamespaceConfig config) {

            return MBeanServerFactory.newMBeanServer();

        }

    }

    /**

     * Load the given namespace configuration inside the given MBeanServer.

     * Return a list of connector servers created in the process.

     * @param server      The MBeanServer in which the namespaces must

     *                    be created.

     * @param namespaces  The list of namespaces to create.

     * @return a list of started connector servers.

     * @throws java.lang.Exception failed to create the specified namespaces.

     */

    public static List<JMXConnectorServer> load(MBeanServer server,

           MBeanServerConfigCreator factory,

           NamespaceConfig... namespaces) throws Exception {

        final List<JMXConnectorServer> cslist =

                new ArrayList<JMXConnectorServer>();

        try {

            final ObjectName creator =

                    new ObjectName("jmx.creator:type=JMXNamespaceCreator");

            if (System.getProperty("jmx.wait")!=null

                    && !server.isRegistered(creator)) {

                server.registerMBean(new JMXNamespaceCreator(),creator);

            }

            for (NamespaceConfig cfg : namespaces) {

                final MBeanServer srv = factory.createMBeanServerFor(cfg);

                if (System.getProperty("jmx.wait")!=null

                    && !srv.isRegistered(creator)) {

                    srv.registerMBean(new JMXNamespaceCreator(),creator);

                }

                if (cfg.wombats != null) {

                    for (String w : cfg.wombats) {

                        final ObjectName n =

                                new ObjectName("wombat:type=Wombat,name=" + w);

                        final WombatMBean ww = new Wombat();

                        srv.registerMBean(ww, n);

                    }

                }

                if (cfg.children != null) {

                    cslist.addAll(load(srv, factory, cfg.children));

                }

                JMXNamespace nm;

                if (cfg.jmxurl == null) {

                    nm = new JMXNamespace(srv);

                } else {

                    JMXConnectorServer cs = JMXConnectorServerFactory.newJMXConnectorServer(new JMXServiceURL(cfg.jmxurl),

                            null, srv);

                    srv.registerMBean(cs,

                            new ObjectName("jmx.remote:type=JMXConnectorServer"));

                    cs.start();

                    cslist.add(cs);

                    nm = JMXRemoteNamespace.

                            newJMXRemoteNamespace(cs.getAddress(),

                            null);

                }

                server.registerMBean(nm,

                        JMXNamespaces.getNamespaceObjectName(cfg.name));

                if (nm instanceof JMXRemoteNamespace) {

                    server.invoke(

                            JMXNamespaces.getNamespaceObjectName(cfg.name),

                            "connect", null, null);

                }

            }

        } catch (Exception x) {

            closeAll(cslist);

            throw x;

        }

        return cslist;

    }

    /**

     * Add an entry {@code <path,NamespaceConfig>} in the map for the given

     * namespace and its subnamespaces.

     * @param map    A {@code Map<path,NamespaceConfig>}.

     * @param parent The path of the parent workspace.

     * @param cfg    The NamespaceConfig hierarchy to index in the map.

     */

    public static void fillMap(Map<String,NamespaceConfig> map, String parent,

            NamespaceConfig cfg) {

        final String where;

        if (parent == null || parent.equals(""))

            where=cfg.name;

        else

            where=parent+JMXNamespaces.NAMESPACE_SEPARATOR+cfg.name;

        map.put(where,cfg);

        if (cfg.children==null) return;

        for(NamespaceConfig child:cfg.children) {

            fillMap(map,where,child);

        }

    }

    /**

     * Compare a list of namespace names obtained from JMXNamespaceView.list()

     * with the expected clildren list of the corresponding NamespaceConfig.

     * @param list      A list of namespace names

     * @param children  A list of NamespaceConfig correspondng to expected

     *                  namespace.

     * @param fail      If true and the comparison yields false, throws an

     *                  exception instead of simply returning false.

     * @return true if OK, false if NOK.

     */

    private static boolean compare(String[] list, NamespaceConfig[] children,

            boolean fail) {

        final List<String> found = new ArrayList<String>(Arrays.asList(list));

        if (found.contains(ClientContext.NAMESPACE))

            found.remove(ClientContext.NAMESPACE);

        if (children == null && found.size()==0) return  true;

        if (children == null && fail == false) return false;

        if (children == null) throw new RuntimeException(

                "No child expected. Found "+Arrays.toString(list));

        final Set<String> names = new HashSet<String>();

        for (NamespaceConfig cfg : children) {

            names.add(cfg.name);

            if (found.contains(cfg.name)) continue;

            if (!fail) return false;

            throw new RuntimeException(cfg.name+" not found in "+

                    found);

        }

        found.removeAll(names);

        if (found.size()==0) return true;

        if (fail==false) return false;

        throw new RuntimeException("found additional namespaces: "+

                found);

    }

    /**

     * Compares the result of queryNames(null,null) with a set of expected

     * wombats.

     * @param where    The path of the namespace that was queried.

     * @param list     The set of ObjectNames found.

     * @param wombats  The expected list of wombats.

     * @param fail      If true and the comparison yields false, throws an

     *                  exception instead of simply returning false.

     * @return true if OK, false if NOK.

     * @throws java.lang.Exception something went wrong.

     */

    private static boolean compare(String where,

            Set<ObjectName>list, String[] wombats,

            boolean fail) throws Exception {

        final Set<ObjectName> found = new HashSet<ObjectName>();

        final Set<ObjectName> expected = new HashSet<ObjectName>();

        for (ObjectName n : list) {

            if ("Wombat".equals(n.getKeyProperty("type")))

               found.add(n);

        }

        for(String w : wombats) {

            final ObjectName n =

                    new ObjectName("wombat:type=Wombat,name=" + w);

            expected.add(n);

            if (found.contains(n)) continue;

            if (fail == false) return false;

            throw new RuntimeException(where+

                    ": Wombat "+w+" not found in "+found);

        }

        found.removeAll(expected);

        if (found.size()==0) {

            System.out.println(where+": found all expected: "+expected);

            return true;

        }

        if (fail==false) return false;

        throw new RuntimeException(where+": found additional MBeans: "+

                found);

    }

    /**

     * A generic test to test JMXNamespaceView over a namespace configuration.

     * @param server      The MBeanServer in which to load the namespace

     *                    config.

     * @param namespaces  The namespace config to run the test over...

     * @throws java.lang.Exception

     */

    public static void doTest(MBeanServer server, NamespaceConfig... namespaces)

            throws Exception {

        List<JMXConnectorServer> cslist = load(server,

                new MBeanServerConfigCreator(), namespaces);

        Map<String,NamespaceConfig> inputMap =

                new HashMap<String,NamespaceConfig>();

        for (NamespaceConfig cfg : namespaces) {

            fillMap(inputMap,"",cfg);

        }

        try {

            final JMXNamespaceView root = new JMXNamespaceView(server);

            List<JMXNamespaceView> vlist = new ArrayList<JMXNamespaceView>();

            vlist.add(root);

            while (!vlist.isEmpty()) {

                JMXNamespaceView v = vlist.remove(0);

                final String where = v.isRoot()?"root":v.where();

                System.out.println(where+": "+

                   v.getMBeanServerConnection().queryNames(null,null));

                for (String ns : v.list()) {

                    final JMXNamespaceView down = v.down(ns);

                    vlist.add(down);

                    if (!down.where().equals(v.isRoot()?ns:where+

                            JMXNamespaces.NAMESPACE_SEPARATOR+ns)) {

                        throw new RuntimeException("path of "+down.where()+

                            " should be "+(v.isRoot()?ns:where+

                            JMXNamespaces.NAMESPACE_SEPARATOR+ns));

                    }

                    if (down.up().equals(v)) continue;

                    throw new RuntimeException("parent of "+down.where()+

                            " should be "+where);

                }

                final NamespaceConfig[] children;

                final NamespaceConfig   cfg;

                if (v.isRoot()) {

                    children=namespaces;

                    cfg = null;

                } else {

                    cfg = inputMap.get(where);

                    children = cfg==null?null:cfg.children;

                }

                compare(v.list(),children,true);

                if (!v.isRoot()) {

                    if (where.endsWith(ClientContext.NAMESPACE)) {

                        System.out.println(where+": skipping queryNames analysis");

                        continue;

                    }

                    //System.out.println(where+": cfg is: "+cfg);

                    compare(where,v.getMBeanServerConnection().

                        queryNames(null, null),cfg.wombats,true);

                }

            }

            exportAndWaitIfNeeded(server);

        } finally {

            closeAll(cslist);

        }

    }

    public static interface JMXNamespaceCreatorMBean {

        public ObjectInstance createLocalNamespace(String namespace)

                throws JMException ;

        public void removeLocalNamespace(String namespace)

                throws JMException;

    }

    public static class JMXNamespaceCreator

            implements MBeanRegistration,

                      JMXNamespaceCreatorMBean {

        private volatile MBeanServer mbeanServer;

        public ObjectInstance createLocalNamespace(String namespace)

            throws JMException {

            return mbeanServer.registerMBean(

                    new JMXNamespace(MBeanServerFactory.newMBeanServer()),

                    JMXNamespaces.getNamespaceObjectName(namespace));

        }

        public void removeLocalNamespace(String namespace)

            throws JMException {

            mbeanServer.unregisterMBean(

                    JMXNamespaces.getNamespaceObjectName(namespace));

        }

        public ObjectName preRegister(MBeanServer server, ObjectName name)

                throws Exception {

            mbeanServer = server;

            return name;

        }

        public void postRegister(Boolean registrationDone) {

        }

        public void preDeregister() throws Exception {

         }

        public void postDeregister() {

        }

    }

    public static void exportAndWaitIfNeeded(MBeanServer server)

        throws Exception {

                if (System.getProperty("jmx.wait")!=null) {

                final int port = getPortFor("rmi");

                LocateRegistry.createRegistry(port);

                final JMXServiceURL url =

                        new JMXServiceURL("rmi",null,port,

                        "/jndi/rmi://localhost:"+port+"/jmxrmi");

                final JMXConnectorServer cs =

                        JMXConnectorServerFactory.

                        newJMXConnectorServer(url, null, server);

                cs.start();

                try {

                    System.out.println("RMI Server waiting at: "+cs.getAddress());

                    System.in.read();

                } finally {

                    cs.stop();