View Javadoc

    1   package org.mortbay.jetty.plus.naming;
    2
    3
    4
    5
    6   import java.util.ArrayList;
    7   import java.util.Collections;
    8   import java.util.List;
    9
    10  import javax.naming.Binding;
    11  import javax.naming.Context;
    12  import javax.naming.InitialContext;
    13  import javax.naming.Name;
    14  import javax.naming.NameNotFoundException;
    15  import javax.naming.NameParser;
    16  import javax.naming.NamingEnumeration;
    17  import javax.naming.NamingException;
    18
    19  import org.mortbay.log.Log;
    20
    21
    22  public class NamingEntryUtil
    23  {
    24
    25
    26      /**
    27       * Link a name in a webapp's java:/comp/evn namespace to a pre-existing
    28       * resource. The pre-existing resource can be either in the webapp's
    29       * naming environment, or in the container's naming environment. Webapp's
    30       * environment takes precedence over the server's namespace.
    31       *
    32       * @param asName the name to bind as
    33       * @param mappedName the name from the environment to link to asName
    34       * @param namingEntryType
    35       * @throws NamingException
    36       */
    37      public static boolean bindToENC (Object scope, String asName, String mappedName)
    38      throws NamingException
    39      {
    40          if (asName==null||asName.trim().equals(""))
    41              throw new NamingException ("No name for NamingEntry");
    42
    43          if (mappedName==null || "".equals(mappedName))
    44              mappedName=asName;
    45
    46          NamingEntry entry = lookupNamingEntry (scope, mappedName);
    47          if (entry == null)
    48              return false;
    49
    50          entry.bindToENC(asName);
    51          return true;
    52       }
    53
    54
    55
    56
    57
    58      /**
    59       * Find a NamingEntry instance.
    60       *
    61       * First the webapp's naming space is searched, and then
    62       * the container's.
    63       *
    64       * @param jndiName name to lookup
    65       * @return
    66       * @throws NamingException
    67       */
    68      public static NamingEntry lookupNamingEntry (Object scope, String jndiName)
    69      throws NamingException
    70      {
    71          NamingEntry entry = null;
    72          try
    73          {
    74              Name scopeName = getNameForScope(scope);
    75              InitialContext ic = new InitialContext();
    76              NameParser parser = ic.getNameParser("");
    77              Name namingEntryName = makeNamingEntryName(parser, jndiName);
    78              scopeName.addAll(namingEntryName);
    79              entry =  (NamingEntry)ic.lookup(scopeName);
    80          }
    81          catch (NameNotFoundException ee)
    82          {
    83          }
    84
    85          return entry;
    86      }
    87
    88
    89      /**
    90       * Get all NameEntries of a certain type in the given naming
    91       * environment scope (server-wide names or context-specific names)
    92       *
    93       * @param scope
    94       * @param clazz the type of the entry
    95       * @return
    96       * @throws NamingException
    97       */
    98      public static List lookupNamingEntries (Object scope, Class clazz)
    99      throws NamingException
    100     {
    101         try
    102         {
    103             Context scopeContext = getContextForScope(scope);
    104             Context namingEntriesContext = (Context)scopeContext.lookup(NamingEntry.__contextName);
    105             ArrayList list = new ArrayList();
    106             lookupNamingEntries(list, namingEntriesContext, clazz);
    107             return list;
    108         }
    109         catch (NameNotFoundException e)
    110         {
    111             return Collections.EMPTY_LIST;
    112         }
    113     }
    114
    115
    116     public static Name makeNamingEntryName (NameParser parser, NamingEntry namingEntry)
    117     throws NamingException
    118     {
    119         return makeNamingEntryName(parser, (namingEntry==null?null:namingEntry.getJndiName()));
    120     }
    121
    122     public static Name makeNamingEntryName (NameParser parser, String jndiName)
    123     throws NamingException
    124     {
    125         if (jndiName==null)
    126             return null;
    127
    128         if (parser==null)
    129         {
    130             InitialContext ic = new InitialContext();
    131             parser = ic.getNameParser("");
    132         }
    133
    134         Name name = parser.parse("");
    135         name.add(NamingEntry.__contextName);
    136         name.addAll(parser.parse(jndiName));
    137         return name;
    138     }
    139
    140
    141     public static Name getNameForScope (Object scope)
    142     {
    143         try
    144         {
    145             InitialContext ic = new InitialContext();
    146             NameParser parser = ic.getNameParser("");
    147             Name name = parser.parse("");
    148             if (scope != null)
    149             {
    150                 name.add(canonicalizeScope(scope));
    151             }
    152             return name;
    153         }
    154         catch (NamingException e)
    155         {
    156             Log.warn(e);
    157             return null;
    158         }
    159     }
    160
    161     public static Context getContextForScope(Object scope)
    162     throws NamingException
    163     {
    164
    165         InitialContext ic = new InitialContext();
    166         NameParser parser = ic.getNameParser("");
    167         Name name = parser.parse("");
    168         if (scope != null)
    169         {
    170             name.add(canonicalizeScope(scope));
    171         }
    172         return (Context)ic.lookup(name);
    173     }
    174
    175     public static Context getContextForNamingEntries (Object scope)
    176     throws NamingException
    177     {
    178         Context scopeContext = getContextForScope(scope);
    179         return (Context)scopeContext.lookup(NamingEntry.__contextName);
    180     }
    181
    182     /**
    183      * Build up a list of NamingEntry objects that are of a specific type.
    184      *
    185      * @param list
    186      * @param context
    187      * @param clazz
    188      * @return
    189      * @throws NamingException
    190      */
    191     private static List lookupNamingEntries (List list, Context context, Class clazz)
    192     throws NamingException
    193     {
    194         try
    195         {
    196             NamingEnumeration nenum = context.listBindings("");
    197             while (nenum.hasMoreElements())
    198             {
    199                 Binding binding = (Binding)nenum.next();
    200                 if (binding.getObject() instanceof Context)
    201                     lookupNamingEntries (list, (Context)binding.getObject(), clazz);
    202                 else if (clazz.isInstance(binding.getObject()))
    203                   list.add(binding.getObject());
    204             }
    205         }
    206         catch (NameNotFoundException e)
    207         {
    208             Log.debug("No entries of type "+clazz.getName()+" in context="+context);
    209         }
    210
    211         return list;
    212     }
    213
    214     private static String canonicalizeScope(Object scope)
    215     {
    216         if (scope==null)
    217             return "";
    218
    219         String str = scope.toString();
    220         str=str.replace('/', '_').replace(' ', '_');
    221         return str;
    222     }
    223 }