| /* |
| * Copyright (c) 1999, 2004, Oracle and/or its affiliates. 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. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package javax.naming.spi; |
| |
| import java.util.Hashtable; |
| |
| import javax.naming.Context; |
| import javax.naming.Name; |
| import javax.naming.Reference; |
| import javax.naming.Referenceable; |
| import javax.naming.NamingException; |
| import javax.naming.CannotProceedException; |
| import javax.naming.directory.DirContext; |
| import javax.naming.directory.Attributes; |
| |
| import com.sun.naming.internal.ResourceManager; |
| import com.sun.naming.internal.FactoryEnumeration; |
| |
| |
| /** |
| * This class contains methods for supporting <tt>DirContext</tt> |
| * implementations. |
| *<p> |
| * This class is an extension of <tt>NamingManager</tt>. It contains methods |
| * for use by service providers for accessing object factories and |
| * state factories, and for getting continuation contexts for |
| * supporting federation. |
| *<p> |
| * <tt>DirectoryManager</tt> is safe for concurrent access by multiple threads. |
| *<p> |
| * Except as otherwise noted, |
| * a <tt>Name</tt>, <tt>Attributes</tt>, or environment parameter |
| * passed to any method is owned by the caller. |
| * The implementation will not modify the object or keep a reference |
| * to it, although it may keep a reference to a clone or copy. |
| * |
| * @author Rosanna Lee |
| * @author Scott Seligman |
| * |
| * @see DirObjectFactory |
| * @see DirStateFactory |
| * @since 1.3 |
| */ |
| |
| public class DirectoryManager extends NamingManager { |
| |
| /* |
| * Disallow anyone from creating one of these. |
| */ |
| DirectoryManager() {} |
| |
| /** |
| * Creates a context in which to continue a <tt>DirContext</tt> operation. |
| * Operates just like <tt>NamingManager.getContinuationContext()</tt>, |
| * only the continuation context returned is a <tt>DirContext</tt>. |
| * |
| * @param cpe |
| * The non-null exception that triggered this continuation. |
| * @return A non-null <tt>DirContext</tt> object for continuing the operation. |
| * @exception NamingException If a naming exception occurred. |
| * |
| * @see NamingManager#getContinuationContext(CannotProceedException) |
| */ |
| public static DirContext getContinuationDirContext( |
| CannotProceedException cpe) throws NamingException { |
| |
| Hashtable env = cpe.getEnvironment(); |
| if (env == null) { |
| env = new Hashtable(7); |
| } else { |
| // Make a (shallow) copy of the environment. |
| env = (Hashtable) env.clone(); |
| } |
| env.put(CPE, cpe); |
| |
| return (new ContinuationDirContext(cpe, env)); |
| } |
| |
| /** |
| * Creates an instance of an object for the specified object, |
| * attributes, and environment. |
| * <p> |
| * This method is the same as <tt>NamingManager.getObjectInstance</tt> |
| * except for the following differences: |
| *<ul> |
| *<li> |
| * It accepts an <tt>Attributes</tt> parameter that contains attributes |
| * associated with the object. The <tt>DirObjectFactory</tt> might use these |
| * attributes to save having to look them up from the directory. |
| *<li> |
| * The object factories tried must implement either |
| * <tt>ObjectFactory</tt> or <tt>DirObjectFactory</tt>. |
| * If it implements <tt>DirObjectFactory</tt>, |
| * <tt>DirObjectFactory.getObjectInstance()</tt> is used, otherwise, |
| * <tt>ObjectFactory.getObjectInstance()</tt> is used. |
| *</ul> |
| * Service providers that implement the <tt>DirContext</tt> interface |
| * should use this method, not <tt>NamingManager.getObjectInstance()</tt>. |
| *<p> |
| * |
| * @param refInfo The possibly null object for which to create an object. |
| * @param name The name of this object relative to <code>nameCtx</code>. |
| * Specifying a name is optional; if it is |
| * omitted, <code>name</code> should be null. |
| * @param nameCtx The context relative to which the <code>name</code> |
| * parameter is specified. If null, <code>name</code> is |
| * relative to the default initial context. |
| * @param environment The possibly null environment to |
| * be used in the creation of the object factory and the object. |
| * @param attrs The possibly null attributes associated with refInfo. |
| * This might not be the complete set of attributes for refInfo; |
| * you might be able to read more attributes from the directory. |
| * @return An object created using <code>refInfo</code> and <tt>attrs</tt>; or |
| * <code>refInfo</code> if an object cannot be created by |
| * a factory. |
| * @exception NamingException If a naming exception was encountered |
| * while attempting to get a URL context, or if one of the |
| * factories accessed throws a NamingException. |
| * @exception Exception If one of the factories accessed throws an |
| * exception, or if an error was encountered while loading |
| * and instantiating the factory and object classes. |
| * A factory should only throw an exception if it does not want |
| * other factories to be used in an attempt to create an object. |
| * See <tt>DirObjectFactory.getObjectInstance()</tt>. |
| * @see NamingManager#getURLContext |
| * @see DirObjectFactory |
| * @see DirObjectFactory#getObjectInstance |
| * @since 1.3 |
| */ |
| public static Object |
| getObjectInstance(Object refInfo, Name name, Context nameCtx, |
| Hashtable<?,?> environment, Attributes attrs) |
| throws Exception { |
| |
| ObjectFactory factory; |
| |
| ObjectFactoryBuilder builder = getObjectFactoryBuilder(); |
| if (builder != null) { |
| // builder must return non-null factory |
| factory = builder.createObjectFactory(refInfo, environment); |
| if (factory instanceof DirObjectFactory) { |
| return ((DirObjectFactory)factory).getObjectInstance( |
| refInfo, name, nameCtx, environment, attrs); |
| } else { |
| return factory.getObjectInstance(refInfo, name, nameCtx, |
| environment); |
| } |
| } |
| |
| // use reference if possible |
| Reference ref = null; |
| if (refInfo instanceof Reference) { |
| ref = (Reference) refInfo; |
| } else if (refInfo instanceof Referenceable) { |
| ref = ((Referenceable)(refInfo)).getReference(); |
| } |
| |
| Object answer; |
| |
| if (ref != null) { |
| String f = ref.getFactoryClassName(); |
| if (f != null) { |
| // if reference identifies a factory, use exclusively |
| |
| factory = getObjectFactoryFromReference(ref, f); |
| if (factory instanceof DirObjectFactory) { |
| return ((DirObjectFactory)factory).getObjectInstance( |
| ref, name, nameCtx, environment, attrs); |
| } else if (factory != null) { |
| return factory.getObjectInstance(ref, name, nameCtx, |
| environment); |
| } |
| // No factory found, so return original refInfo. |
| // Will reach this point if factory class is not in |
| // class path and reference does not contain a URL for it |
| return refInfo; |
| |
| } else { |
| // if reference has no factory, check for addresses |
| // containing URLs |
| // ignore name & attrs params; not used in URL factory |
| |
| answer = processURLAddrs(ref, name, nameCtx, environment); |
| if (answer != null) { |
| return answer; |
| } |
| } |
| } |
| |
| // try using any specified factories |
| answer = createObjectFromFactories(refInfo, name, nameCtx, |
| environment, attrs); |
| return (answer != null) ? answer : refInfo; |
| } |
| |
| private static Object createObjectFromFactories(Object obj, Name name, |
| Context nameCtx, Hashtable environment, Attributes attrs) |
| throws Exception { |
| |
| FactoryEnumeration factories = ResourceManager.getFactories( |
| Context.OBJECT_FACTORIES, environment, nameCtx); |
| |
| if (factories == null) |
| return null; |
| |
| ObjectFactory factory; |
| Object answer = null; |
| // Try each factory until one succeeds |
| while (answer == null && factories.hasMore()) { |
| factory = (ObjectFactory)factories.next(); |
| if (factory instanceof DirObjectFactory) { |
| answer = ((DirObjectFactory)factory). |
| getObjectInstance(obj, name, nameCtx, environment, attrs); |
| } else { |
| answer = |
| factory.getObjectInstance(obj, name, nameCtx, environment); |
| } |
| } |
| return answer; |
| } |
| |
| /** |
| * Retrieves the state of an object for binding when given the original |
| * object and its attributes. |
| * <p> |
| * This method is like <tt>NamingManager.getStateToBind</tt> except |
| * for the following differences: |
| *<ul> |
| *<li>It accepts an <tt>Attributes</tt> parameter containing attributes |
| * that were passed to the <tt>DirContext.bind()</tt> method. |
| *<li>It returns a non-null <tt>DirStateFactory.Result</tt> instance |
| * containing the object to be bound, and the attributes to |
| * accompany the binding. Either the object or the attributes may be null. |
| *<li> |
| * The state factories tried must each implement either |
| * <tt>StateFactory</tt> or <tt>DirStateFactory</tt>. |
| * If it implements <tt>DirStateFactory</tt>, then |
| * <tt>DirStateFactory.getStateToBind()</tt> is called; otherwise, |
| * <tt>StateFactory.getStateToBind()</tt> is called. |
| *</ul> |
| * |
| * Service providers that implement the <tt>DirContext</tt> interface |
| * should use this method, not <tt>NamingManager.getStateToBind()</tt>. |
| *<p> |
| * See NamingManager.getStateToBind() for a description of how |
| * the list of state factories to be tried is determined. |
| *<p> |
| * The object returned by this method is owned by the caller. |
| * The implementation will not subsequently modify it. |
| * It will contain either a new <tt>Attributes</tt> object that is |
| * likewise owned by the caller, or a reference to the original |
| * <tt>attrs</tt> parameter. |
| * |
| * @param obj The non-null object for which to get state to bind. |
| * @param name The name of this object relative to <code>nameCtx</code>, |
| * or null if no name is specified. |
| * @param nameCtx The context relative to which the <code>name</code> |
| * parameter is specified, or null if <code>name</code> is |
| * relative to the default initial context. |
| * @param environment The possibly null environment to |
| * be used in the creation of the state factory and |
| * the object's state. |
| * @param attrs The possibly null Attributes that is to be bound with the |
| * object. |
| * @return A non-null DirStateFactory.Result containing |
| * the object and attributes to be bound. |
| * If no state factory returns a non-null answer, the result will contain |
| * the object (<tt>obj</tt>) itself with the original attributes. |
| * @exception NamingException If a naming exception was encountered |
| * while using the factories. |
| * A factory should only throw an exception if it does not want |
| * other factories to be used in an attempt to create an object. |
| * See <tt>DirStateFactory.getStateToBind()</tt>. |
| * @see DirStateFactory |
| * @see DirStateFactory#getStateToBind |
| * @see NamingManager#getStateToBind |
| * @since 1.3 |
| */ |
| public static DirStateFactory.Result |
| getStateToBind(Object obj, Name name, Context nameCtx, |
| Hashtable<?,?> environment, Attributes attrs) |
| throws NamingException { |
| |
| // Get list of state factories |
| FactoryEnumeration factories = ResourceManager.getFactories( |
| Context.STATE_FACTORIES, environment, nameCtx); |
| |
| if (factories == null) { |
| // no factories to try; just return originals |
| return new DirStateFactory.Result(obj, attrs); |
| } |
| |
| // Try each factory until one succeeds |
| StateFactory factory; |
| Object objanswer; |
| DirStateFactory.Result answer = null; |
| while (answer == null && factories.hasMore()) { |
| factory = (StateFactory)factories.next(); |
| if (factory instanceof DirStateFactory) { |
| answer = ((DirStateFactory)factory). |
| getStateToBind(obj, name, nameCtx, environment, attrs); |
| } else { |
| objanswer = |
| factory.getStateToBind(obj, name, nameCtx, environment); |
| if (objanswer != null) { |
| answer = new DirStateFactory.Result(objanswer, attrs); |
| } |
| } |
| } |
| |
| return (answer != null) ? answer : |
| new DirStateFactory.Result(obj, attrs); // nothing new |
| } |
| } |
