1 /*

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

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

     4  *

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

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

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

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

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

    21  * have any questions.

    22  */

    23 /*

    24  *

    25  * @test QueryNamesTest.java 1.4

    26  * @summary Test how queryNames works with Namespaces.

    27  * @author Daniel Fuchs

    28  * @bug 5072476 6768935

    29  * @run clean QueryNamesTest Wombat WombatMBean

    30  * @run build QueryNamesTest Wombat WombatMBean

    31  * @run main QueryNamesTest

    32  */

    33 

    34 

    35 import java.io.IOException;

    36 import java.lang.management.ManagementFactory;

    37 import java.util.ArrayList;

    38 import java.util.Arrays;

    39 import java.util.Collections;

    40 import java.util.HashMap;

    41 import java.util.HashSet;

    42 import java.util.LinkedHashMap;

    43 import java.util.LinkedHashSet;

    44 import java.util.LinkedList;

    45 import java.util.List;

    46 import java.util.Map;

    47 import java.util.Random;

    48 import java.util.Set;

    49 import java.util.logging.Logger;

    50 import javax.management.InstanceNotFoundException;

    51 import javax.management.JMException;

    52 import javax.management.MBeanServer;

    53 import javax.management.MBeanServerConnection;

    54 import javax.management.MBeanServerFactory;

    55 import javax.management.MalformedObjectNameException;

    56 import javax.management.ObjectInstance;

    57 import javax.management.ObjectName;

    58 import javax.management.RuntimeOperationsException;

    59 import javax.management.namespace.JMXNamespace;

    60 import javax.management.namespace.JMXNamespaces;

    61 

    62 /**

    63  * Class QueryNamesTest

    64  * @author Sun Microsystems, 2005 - All rights reserved.

    65  */

    66 public class QueryNamesTest {

    67 

    68     /**

    69      * A logger for this class.

    70      **/

    71     private static final Logger LOG =

    72             Logger.getLogger(QueryNamesTest.class.getName());

    73 

    74     public static class LocalNamespace

    75             extends JMXNamespace {

    76 

    77         private static MBeanServer check(MBeanServer server) {

    78             if (server == null)

    79                 throw new IllegalArgumentException("MBeanServer can't be null");

    80             return server;

    81         }

    82 

    83         public LocalNamespace() {

    84             this(MBeanServerFactory.createMBeanServer());

    85         }

    86 

    87         public LocalNamespace(MBeanServer server) {

    88             super(check(server));

    89         }

    90 

    91 

    92         public static String add(MBeanServerConnection server,

    93                 String nspath)

    94                 throws IOException, JMException {

    95             server.createMBean(LocalNamespace.class.getName(),

    96                     JMXNamespaces.getNamespaceObjectName(nspath));

    97             return nspath;

    98         }

    99     }

   100 

   101     /** Creates a new instance of QueryNamesTest */

   102     public QueryNamesTest() {

   103     }

   104 

   105     private static String[] namespaces = {

   106         "greg", "greg//chichille", "greg//chichille//petard",

   107         "greg//alambic", "greg//alambic//canette",

   108         "greg//chichille/virgule", "greg//chichille/funeste",

   109         "greg//chichille/virgule//bidouble",

   110         "greg//chichille/virgule//bi/double",

   111         "fran", "fran//gast", "fran//gast//gaf",

   112         "fran//longtar", "fran//longtar//parcmetre"

   113     };

   114 

   115     private static void createNamespaces(MBeanServer server) throws Exception {

   116         final LinkedList<String> all = new LinkedList<String>();

   117         try {

   118             for (String ns : namespaces)

   119                 all.addFirst(LocalNamespace.add(server,ns));

   120         } catch (Exception e) {

   121             removeNamespaces(server,all.toArray(new String[all.size()]));

   122             throw e;

   123         }

   124     }

   125 

   126     // Dummy test that checks that all JMXNamespaces are registered,

   127     // but are not returned by queryNames("*:*");

   128     //

   129     private static void checkRegistration(MBeanServer server)

   130         throws Exception {

   131         final Set<ObjectName> handlerNames = new HashSet<ObjectName>(namespaces.length);

   132         for (String ns : namespaces)

   133             handlerNames.add(JMXNamespaces.getNamespaceObjectName(ns));

   134         for (ObjectName nh : handlerNames) // check handler registration

   135             if (!server.isRegistered(nh))

   136                 throw new InstanceNotFoundException("handler "+nh+

   137                         " is not registered");

   138 

   139         // global: queryNames("*:*") from top level

   140         final Set<ObjectName> all1 = server.queryNames(null,null);

   141         final Set<ObjectName> all2 = server.queryNames(ObjectName.WILDCARD,null);

   142         if (!all1.equals(all2))

   143             throw new Exception("queryNames(*:*) != queryNames(null)");

   144         final Set<ObjectName> common = new HashSet<ObjectName>(all1);

   145         common.retainAll(handlerNames);

   146 

   147         final Set<ObjectName> ref = new HashSet<ObjectName>();

   148         for (String ns : namespaces) {

   149             if (!ns.contains(JMXNamespaces.NAMESPACE_SEPARATOR))

   150                 ref.add(JMXNamespaces.getNamespaceObjectName(ns));

   151         }

   152         if (!common.equals(ref)) {

   153             throw new Exception("some handler names were not returned by " +

   154                     "wildcard query - only returned: "+common+

   155                     ", expected: "+ref);

   156         }

   157 

   158         // for each namespace: queryNames("<namespace>//*:*");

   159         for (String ns : namespaces) {

   160             final ObjectName pattern = new ObjectName(ns+

   161                     JMXNamespaces.NAMESPACE_SEPARATOR+"*:*");

   162             final Set<ObjectName> all4 =

   163                     server.queryNames(pattern,null);

   164             final Set<ObjectName> common4 = new HashSet<ObjectName>(all4);

   165             common4.retainAll(handlerNames);

   166 

   167             final Set<ObjectName> ref4 = new HashSet<ObjectName>();

   168             for (String ns2 : namespaces) {

   169                 if (! ns2.startsWith(ns+JMXNamespaces.NAMESPACE_SEPARATOR))

   170                     continue;

   171                 if (!ns2.substring(ns.length()+

   172                         JMXNamespaces.NAMESPACE_SEPARATOR.length()).

   173                         contains(JMXNamespaces.NAMESPACE_SEPARATOR))

   174                     ref4.add(JMXNamespaces.getNamespaceObjectName(ns2));

   175             }

   176             if (!common4.equals(ref4)) {

   177                 throw new Exception("some handler names were not returned by " +

   178                     "wildcard query on "+pattern+" - only returned: "+common4+

   179                     ", expected: "+ref4);

   180             }

   181         }

   182     }

   183 

   184     // Make a Map<parent, direct children>

   185     private static Map<String,Set<String>> makeNsTree(String[] nslist) {

   186         final Map<String,Set<String>> nsTree =

   187                 new LinkedHashMap<String,Set<String>>(nslist.length);

   188         for (String ns : nslist) {

   189             if (nsTree.get(ns) == null)

   190                 nsTree.put(ns,new LinkedHashSet<String>());

   191             final String[] elts = ns.split(JMXNamespaces.NAMESPACE_SEPARATOR);

   192             int last = ns.lastIndexOf(JMXNamespaces.NAMESPACE_SEPARATOR);

   193             if (last<0) continue;

   194             while (last > 0 && ns.charAt(last-1) == '/') last--;

   195             final String parent = ns.substring(0,last);

   196             if (nsTree.get(parent) == null)

   197                 nsTree.put(parent,new LinkedHashSet<String>());

   198             nsTree.get(parent).add(ns);

   199         }

   200         return nsTree;

   201     }

   202 

   203     private static class Rigolo {

   204         final static String[] ones = { "a", "e", "i", "o", "u", "y", "ai", "oo",

   205         "ae", "ey", "ay", "oy", "au", "ou", "eu", "oi", "ei", "ea"};

   206         final static String[] twos = { "b", "bz", "c", "cz", "ch",

   207         "ct", "ck", "cs", "d", "ds", "f",  "g", "gh", "h", "j", "k", "l", "m",

   208         "n", "p", "ps", "q", "r", "s", "sh", "t", "v", "w", "x",

   209         "z"};

   210         final static String[] threes = {"rr","tt","pp","ss","dd","ff","ll", "mm", "nn",

   211         "zz", "cc", "bb"};

   212         final static String[] fours = {"x", "s", "ght", "cks", "rt", "rts", "ghts", "bs",

   213           "ts", "gg" };

   214         final static String[] fives = { "br", "bl", "cr", "cn", "cth", "dr",

   215         "fr", "fl", "cl", "chr",  "gr", "gl", "kr", "kh", "pr", "pl", "ph",

   216         "rh", "sr", "tr", "vr"};

   217 

   218         private Random rg = new Random();

   219 

   220         private String next(String[] table) {

   221             return table[rg.nextInt(table.length)];

   222         }

   223 

   224         public String nextName(int max) {

   225             final Random rg = new Random();

   226             final int nl = 3 + rg.nextInt(max);

   227             boolean begin = rg.nextBoolean();

   228             StringBuilder sb = new StringBuilder();

   229             for (int j = 0; j < nl ; j++) {

   230                 if (begin) {

   231                     sb.append(next(ones));

   232                 } else if (j > 0 && j < nl-1 && rg.nextInt(4)==0) {

   233                     sb.append(next(threes));

   234                 } else if (j < nl-1 && rg.nextInt(3)==0) {

   235                     sb.append(next(fives));

   236                 } else {

   237                     sb.append(next(twos));

   238                 }

   239                 begin = !begin;

   240             }

   241             if (!begin && rg.nextInt(2)==0)

   242                 sb.append(next(fours));

   243             return sb.toString();

   244         }

   245 

   246         private ObjectName getWombatName(String ns, String domain, String name)

   247             throws MalformedObjectNameException {

   248             String d = domain;

   249             if (ns != null && !ns.equals(""))

   250                 d = ns + JMXNamespaces.NAMESPACE_SEPARATOR + domain;

   251             return new ObjectName(d+":type=Wombat,name="+name);

   252         }

   253 

   254         public Set<ObjectName> nextWombats(String ns)

   255             throws MalformedObjectNameException  {

   256             final int dcount = 1 + rg.nextInt(5);

   257             final Set<ObjectName> wombats = new HashSet<ObjectName>();

   258             for (int i = 0; i < dcount ; i++) {

   259                 final String d = nextName(7);

   260                 final int ncount = 5 + rg.nextInt(20);

   261                 for (int j = 0 ; j<ncount; j++) {

   262                     final String n = nextName(5);

   263                     wombats.add(getWombatName(ns,d,n));

   264                 }

   265             }

   266             return wombats;

   267         }

   268     }

   269 

   270     public static void checkNsQuery(MBeanServer server)

   271         throws Exception {

   272         final Map<String,Set<String>> nsTree = makeNsTree(namespaces);

   273         final Random rg = new Random();

   274         final Rigolo rigolo = new Rigolo();

   275         for (String ns : namespaces) {

   276             final ObjectName name = JMXNamespaces.getNamespaceObjectName(ns);

   277             final String[] doms =

   278                     (String[])server.getAttribute(name,"Domains");

   279             final Set<String> subs = new HashSet<String>();

   280             for (String d : doms) {

   281                 if (d.endsWith(JMXNamespaces.NAMESPACE_SEPARATOR)) {

   282                     subs.add(ns+JMXNamespaces.NAMESPACE_SEPARATOR+d.substring(0,

   283                             d.length()-JMXNamespaces.NAMESPACE_SEPARATOR.length()));

   284                 }

   285             }

   286 

   287             final Set<String> expectNs = new HashSet<String>(nsTree.get(ns));

   288 

   289             if (! subs.containsAll(expectNs))

   290                 throw new Exception("getDomains didn't return all namespaces: "+

   291                         "returned="+subs+", expected="+expectNs);

   292             if (! expectNs.containsAll(subs))

   293                 throw new Exception("getDomains returned additional namespaces: "+

   294                         "returned="+subs+", expected="+expectNs);

   295 

   296             final Set<ObjectName> nsNames = server.queryNames(

   297                     new ObjectName(ns+

   298                     JMXNamespaces.NAMESPACE_SEPARATOR+"*"+

   299                     JMXNamespaces.NAMESPACE_SEPARATOR+":*"),null);

   300 

   301             final Set<ObjectName> expect =

   302                     new HashSet<ObjectName>(expectNs.size());

   303             for (String sub : expectNs) {

   304                 expect.add(JMXNamespaces.getNamespaceObjectName(sub));

   305             }

   306 

   307             if (! nsNames.containsAll(expect))

   308                 throw new Exception("queryNames didn't return all namespaces: "+

   309                         "returned="+nsNames+", expected="+expect);

   310             if (! expect.containsAll(nsNames))

   311                 throw new Exception("getDomains returned additional namespaces: "+

   312                         "returned="+nsNames+", expected="+expect);

   313 

   314         }

   315     }

   316 

   317     private static void addWombats(MBeanServer server, Set<ObjectName> names)

   318         throws Exception {

   319         for (ObjectName on : names) {

   320             if (! server.isRegistered(on)) {

   321                 server.createMBean(Wombat.class.getName(),on);

   322                 System.out.println("A new wombat is born: "+on);

   323             }

   324         }

   325     }

   326 

   327     private static void addWombats(MBeanServer server,

   328              Map<String,Set<ObjectName>> wombats)

   329         throws Exception {

   330         for (String ns : wombats.keySet()) {

   331             addWombats(server,wombats.get(ns));

   332         }

   333     }

   334 

   335     private static Map<String,Set<ObjectName>> nameWombats()

   336         throws Exception {

   337         final Rigolo rigolo = new Rigolo();

   338         final Map<String,Set<ObjectName>> wombats =

   339                 new HashMap<String,Set<ObjectName>>(namespaces.length);

   340 

   341         for (String ns : namespaces) {

   342             wombats.put(ns,rigolo.nextWombats(ns));

   343         }

   344         wombats.put("",rigolo.nextWombats(""));

   345         return wombats;

   346     }

   347 

   348     private static boolean removeWombats(MBeanServer server,

   349             Map<String,Set<ObjectName>> wombats) {

   350         boolean res = true;

   351         for (String ns : wombats.keySet()) {

   352             res = res && removeWombats(server,wombats.get(ns));

   353         }

   354         return res;

   355     }

   356 

   357     private static boolean removeWombats(MBeanServer server,

   358             Set<ObjectName> wombats) {

   359         boolean res = true;

   360         for (ObjectName on : wombats) {

   361             try {

   362                 if (server.isRegistered(on))

   363                     server.unregisterMBean(on);

   364             } catch (Exception x) {

   365                 res = false;

   366                 System.out.println("Failed to remove "+on+": "+x);

   367             }

   368         }

   369         return res;

   370     }

   371 

   372     private static void checkNsPattern(MBeanServer server) throws Exception {

   373         final List<String> list = new ArrayList<String>();

   374         for (String s : namespaces) {

   375             final String[] cmpnt = s.split("//");

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

   377                 final String[] clone = cmpnt.clone();

   378                 if (clone[i].length() < 3) {

   379                     clone[i] = "*";

   380                 } else {

   381                     clone[i] = "?"+cmpnt[i].substring(1, cmpnt[i].length()-2)+"*";

   382                 }

   383                 final StringBuilder sb = new StringBuilder();

   384                 for (int j=0;j<cmpnt.length;j++) {

   385                     sb.append(clone[j]).append("//");

   386                 }

   387                 list.add(sb.toString()+"*:*");

   388             }

   389         }

   390         for (String s : list) {

   391             final Set<ObjectName> res = new HashSet<ObjectName>();

   392 

   393             try {

   394                 res.addAll(server.queryNames(ObjectName.valueOf(s),null));

   395             } catch (RuntimeOperationsException x) {

   396                 if (x.getCause() instanceof IllegalArgumentException) {

   397                     System.out.println("queryNames("+s+"): OK - received "+x.getCause());

   398                     continue;

   399                 }

   400                 System.err.println("queryNames("+s+"): Bad cause: "+x.getCause());

   401                 throw x;

   402             } catch (Exception x) {

   403                 System.err.println("queryNames("+s+"): Bad exception: "+x);

   404                 throw x;

   405             }

   406             System.err.println("queryNames("+s+"): Bad result: "+res);

   407             System.err.println("queryNames("+s+"): Excpected exception not thrown.");

   408             throw new Exception("queryNames("+s+"): Excpected exception not thrown.");

   409         }

   410         for (String s : list) {

   411             final Set<ObjectInstance> res = new HashSet<ObjectInstance>();

   412 

   413             try {

   414                 res.addAll(server.queryMBeans(ObjectName.valueOf(s),null));

   415             } catch (RuntimeOperationsException x) {

   416                 if (x.getCause() instanceof IllegalArgumentException) {

   417                     System.out.println("queryMBeans("+s+"): OK - received "+x.getCause());

   418                     continue;

   419                 }

   420                 System.err.println("queryMBeans("+s+"): Bad cause: "+x.getCause());

   421                 throw x;

   422             } catch (Exception x) {

   423                 System.err.println("queryMBeans("+s+"): Bad exception: "+x);

   424                 throw x;

   425             }

   426             System.err.println("queryMBeans("+s+"): Bad result: "+res);

   427             System.err.println("queryMBeans("+s+"): Excpected exception not thrown.");

   428             throw new Exception("queryMBeans("+s+"): Excpected exception not thrown.");

   429         }

   430     }

   431 

   432     public static void main(String[] args)

   433         throws Exception {

   434         final MBeanServer server = ManagementFactory.getPlatformMBeanServer();

   435         Map<String,Set<ObjectName>>  wombats = nameWombats();

   436         createNamespaces(server);

   437         try {

   438             addWombats(server,wombats);

   439             System.out.println("MBeans: " +server.getMBeanCount());

   440             System.out.println("Visible: " +server.queryNames(null,null).size());

   441             System.out.println("Domains: " +Arrays.asList(server.getDomains()));

   442             checkRegistration(server);

   443             checkNsQuery(server);

   444             checkNsPattern(server);

   445         } finally {

   446             boolean res = true;

   447             res = res && removeWombats(server, wombats);

   448             if (!res)

   449                 throw new RuntimeException("failed to cleanup some namespaces");

   450         }

   451 

   452     }

   453 

   454     private static boolean removeNamespaces(MBeanServer server) {

   455         final List<String> l = Arrays.asList(namespaces);

   456         Collections.reverse(l);

   457         return removeNamespaces(server, l.toArray(new String[namespaces.length]));

   458     }

   459 

   460     private static boolean removeNamespaces(MBeanServer server, String[] t) {

   461         boolean success = true;

   462         for (String ns : t) {

   463             try {

   464                 server.unregisterMBean(JMXNamespaces.getNamespaceObjectName(ns));

   465             } catch (Exception x) {

   466                 System.out.println("failed to remove namespace: "+ ns);

   467                 success = false;

   468             }

   469         }

   470         return success;

   471     }

   472 

   473 }