You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
339 lines
13 KiB
339 lines
13 KiB
/*
|
|
* Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
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)
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public static DirContext getContinuationDirContext(
|
|
CannotProceedException cpe) throws NamingException {
|
|
|
|
Hashtable<Object,Object> env = (Hashtable<Object,Object>)cpe.getEnvironment();
|
|
if (env == null) {
|
|
env = new Hashtable<>(7);
|
|
} else {
|
|
// Make a (shallow) copy of the environment.
|
|
env = (Hashtable<Object,Object>) 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
|
|
}
|
|
}
|