[jboss-cvs] JBossAS SVN: r72233 - trunk/testsuite/src/main/org/jboss/test/util.

[jboss-cvs-commits at lists.jboss.org]

Author: scott.stark at jboss.org
Date: 2008-04-15 10:32:32 -0400 (Tue, 15 Apr 2008)
New Revision: 72233

Modified:
   trunk/testsuite/src/main/org/jboss/test/util/Debug.java
Log:
Add a util method to recursively dump a jndi context

Modified: trunk/testsuite/src/main/org/jboss/test/util/Debug.java
===================================================================
--- trunk/testsuite/src/main/org/jboss/test/util/Debug.java	2008-04-15 14:30:35 UTC (rev 72232)
+++ trunk/testsuite/src/main/org/jboss/test/util/Debug.java	2008-04-15 14:32:32 UTC (rev 72233)
@@ -21,11 +21,20 @@
   */
 package org.jboss.test.util;
 
+import java.io.PrintWriter;
+import java.io.StringWriter;
 import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
 import java.net.URL;
 import java.security.CodeSource;
 import java.security.ProtectionDomain;
 
+import javax.naming.Context;
+import javax.naming.LinkRef;
+import javax.naming.NameClassPair;
+import javax.naming.NamingEnumeration;
+import javax.naming.NamingException;
+
 /** Various debugging utility methods available for use in unit tests
  * @author Scott.Stark at jboss.org
  */
@@ -100,5 +109,156 @@
       }
       return urls;
    }
-   
+
+   /**
+    * Recursively display the naming context information into the buffer.
+    * 
+    * @param ctx
+    * @param indent
+    * @param buffer
+    * @param verbose
+    */
+   public static void list(Context ctx, String indent, StringBuffer buffer, boolean verbose)
+   {
+      ClassLoader loader = Thread.currentThread().getContextClassLoader();
+      try
+      {
+         NamingEnumeration ne = ctx.list("");
+         while (ne.hasMore())
+         {
+            NameClassPair pair = (NameClassPair) ne.next();
+
+            String name = pair.getName();
+            String className = pair.getClassName();
+            boolean recursive = false;
+            boolean isLinkRef = false;
+            boolean isProxy = false;
+            Class c = null;
+            try
+            {
+               c = loader.loadClass(className);
+
+               if (Context.class.isAssignableFrom(c))
+                  recursive = true;
+               if (LinkRef.class.isAssignableFrom(c))
+                  isLinkRef = true;
+
+               isProxy = Proxy.isProxyClass(c);
+            }
+            catch (ClassNotFoundException cnfe)
+            {
+               // If this is a $Proxy* class its a proxy
+               if (className.startsWith("$Proxy"))
+               {
+                  isProxy = true;
+                  // We have to get the class from the binding
+                  try
+                  {
+                     Object p = ctx.lookup(name);
+                     c = p.getClass();
+                  }
+                  catch (NamingException e)
+                  {
+                     Throwable t = e.getRootCause();
+                     if (t instanceof ClassNotFoundException)
+                     {
+                        // Get the class name from the exception msg
+                        String msg = t.getMessage();
+                        if (msg != null)
+                        {
+                           // Reset the class name to the CNFE class
+                           className = msg;
+                        }
+                     }
+                  }
+               }
+            }
+
+            buffer.append(indent + " +- " + name);
+
+            // Display reference targets
+            if (isLinkRef)
+            {
+               // Get the 
+               try
+               {
+                  Object obj = ctx.lookupLink(name);
+
+                  LinkRef link = (LinkRef) obj;
+                  buffer.append("[link -> ");
+                  buffer.append(link.getLinkName());
+                  buffer.append(']');
+               }
+               catch (Throwable t)
+               {
+                  buffer.append("invalid]");
+               }
+            }
+
+            // Display proxy interfaces
+            if (isProxy)
+            {
+               buffer.append(" (proxy: " + pair.getClassName());
+               if (c != null)
+               {
+                  Class[] ifaces = c.getInterfaces();
+                  buffer.append(" implements ");
+                  for (int i = 0; i < ifaces.length; i++)
+                  {
+                     buffer.append(ifaces[i]);
+                     buffer.append(',');
+                  }
+                  buffer.setCharAt(buffer.length() - 1, ')');
+               }
+               else
+               {
+                  buffer.append(" implements " + className + ")");
+               }
+            }
+            else if (verbose)
+            {
+               buffer.append(" (class: " + pair.getClassName() + ")");
+            }
+
+            buffer.append('\n');
+            if (recursive)
+            {
+               try
+               {
+                  Object value = ctx.lookup(name);
+                  if (value instanceof Context)
+                  {
+                     Context subctx = (Context) value;
+                     list(subctx, indent + " |  ", buffer, verbose);
+                  }
+                  else
+                  {
+                     buffer.append(indent + " |   NonContext: " + value);
+                     buffer.append('\n');
+                  }
+               }
+               catch (Throwable t)
+               {
+                  buffer.append("Failed to lookup: " + name + ", errmsg=" + t.getMessage());
+                  buffer.append('\n');
+               }
+            }
+         }
+         ne.close();
+      }
+      catch (NamingException ne)
+      {
+         buffer.append("error while listing context " + ctx.toString() + ": " + ne.toString(true));
+         formatException(buffer, ne);
+      }
+   }
+   public static void formatException(StringBuffer buffer, Throwable t)
+   {
+      StringWriter sw = new StringWriter();
+      PrintWriter pw = new PrintWriter(sw);
+      buffer.append("<pre>\n");
+      t.printStackTrace(pw);
+      buffer.append(sw.toString());
+      buffer.append("</pre>\n");
+   }
 }