Back to index...

	/*
	* Copyright (c) 1999, 2011, 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 com.sun.jndi.toolkit.ctx;

	import javax.naming.*;

	/**
	* Clients: deal only with names for its own naming service
	* and deals with single contexts that can be built up into
	* hierarchical naming systems.
	* Direct subclasses of AtomicContext must provide implementations for
	* the abstract a_ Context methods, and c_parseComponent().
	*
	* If the subclass implements the notion of implicit nns,
	* it must override the a_*_nns Context methods as well.
	*
	* @author Rosanna Lee
	*
	*/

	public abstract class AtomicContext extends ComponentContext {
	private static int debug = 0;

	protected AtomicContext () {
	_contextType = _ATOMIC;
	}

	// ------ Abstract methods whose implementation are provided by subclasses


	/* Equivalent to Context methods */
	protected abstract Object a_lookup(String name, Continuation cont)
	throws NamingException;
	protected abstract Object a_lookupLink(String name, Continuation cont)
	throws NamingException;

	protected abstract NamingEnumeration<NameClassPair> a_list(
	Continuation cont) throws NamingException;
	protected abstract NamingEnumeration<Binding> a_listBindings(
	Continuation cont) throws NamingException;
	protected abstract void a_bind(String name, Object obj, Continuation cont)
	throws NamingException;
	protected abstract void a_rebind(String name, Object obj, Continuation cont)
	throws NamingException;
	protected abstract void a_unbind(String name, Continuation cont)
	throws NamingException;
	protected abstract void a_destroySubcontext(String name, Continuation cont)
	throws NamingException;
	protected abstract Context a_createSubcontext(String name,
	Continuation cont) throws NamingException;
	protected abstract void a_rename(String oldname, Name newname,
	Continuation cont) throws NamingException;
	protected abstract NameParser a_getNameParser(Continuation cont)
	throws NamingException;

	/* Parsing */
	/**
	* Parse 'inputName' into two parts:
	* head: the first component in this name
	* tail: the rest of the unused name.
	*
	* Subclasses should provide an implementation for this method
	* which parses inputName using its own name syntax.
	*/
	protected abstract StringHeadTail c_parseComponent(String inputName,
	Continuation cont) throws NamingException;


	// ------ Methods that need to be overridden by subclass

	/* Resolution method for supporting federation */
	/**
	* Resolves the nns for 'name' when the named context is acting
	* as an intermediate context.
	*
	* For a system that supports junctions, this would be equilvalent to
	* a_lookup(name, cont);
	* because for junctions, an intermediate slash simply signifies
	* a syntactic separator.
	*
	* For a system that supports implicit nns, this would be equivalent to
	* a_lookup_nns(name, cont);
	* because for implicit nns, a slash always signifies the implicit nns,
	* regardless of whether it is intermediate or trailing.
	*
	* By default this method supports junctions, and also allows for an
	* implicit nns to be dynamically determined through the use of the
	* "nns" reference (see a_processJunction_nns()).
	* Contexts that implement implicit nns directly should provide an
	* appropriate override.
	*/
	protected Object a_resolveIntermediate_nns(String name, Continuation cont)
	throws NamingException {
	try {
	final Object obj = a_lookup(name, cont);

	// Do not append "" to Continuation 'cont' even if set
	// because the intention is to ignore the nns

	//
	if (obj != null && getClass().isInstance(obj)) {
	// If "obj" is in the same type as this object, it must
	// not be a junction. Continue the lookup with "/".

	cont.setContinueNNS(obj, name, this);
	return null;

	} else if (obj != null && !(obj instanceof Context)) {
	// obj is not even a context, so try to find its nns
	// dynamically by constructing a Reference containing obj.
	RefAddr addr = new RefAddr("nns") {
	public Object getContent() {
	return obj;
	}
	private static final long serialVersionUID =
	-3399518522645918499L;
	};
	Reference ref = new Reference("java.lang.Object", addr);

	// Resolved name has trailing slash to indicate nns
	CompositeName resName = new CompositeName();
	resName.add(name);
	resName.add(""); // add trailing slash

	// Set continuation leave it to
	// PartialCompositeContext.getPCContext() to throw CPE.
	// Do not use setContinueNNS() because we've already
	// consumed "/" (i.e., moved it to resName).

	cont.setContinue(ref, resName, this);
	return null;

	} else {
	return obj;
	}

	} catch (NamingException e) {
	e.appendRemainingComponent(""); // add nns back
	throw e;
	}
	}

	/* Equivalent of Context Methods for supporting nns */

	// The following methods are called when the DirContext methods
	// are invoked with a name that has a trailing slash.
	// For naming systems that support implicit nns,
	// the trailing slash signifies the implicit nns.
	// For such naming systems, override these a_*_nns methods.
	//
	// For naming systems that support junctions (explicit nns),
	// the trailing slash is meaningless because a junction does not
	// have an implicit nns. The default implementation here
	// throws a NameNotFoundException for such names.
	// If a context wants to accept a trailing slash as having
	// the same meaning as the same name without a trailing slash,
	// then it should override these a_*_nns methods.


	protected Object a_lookup_nns(String name, Continuation cont)
	throws NamingException {
	a_processJunction_nns(name, cont);
	return null;
	}

	protected Object a_lookupLink_nns(String name, Continuation cont)
	throws NamingException {
	a_processJunction_nns(name, cont);
	return null;
	}

	protected NamingEnumeration<NameClassPair> a_list_nns(Continuation cont)
	throws NamingException {
	a_processJunction_nns(cont);
	return null;
	}
	protected NamingEnumeration<Binding> a_listBindings_nns(Continuation cont)
	throws NamingException {
	a_processJunction_nns(cont);
	return null;
	}

	protected void a_bind_nns(String name, Object obj, Continuation cont)
	throws NamingException {
	a_processJunction_nns(name, cont);
	}

	protected void a_rebind_nns(String name, Object obj, Continuation cont)
	throws NamingException {
	a_processJunction_nns(name, cont);
	}

	protected void a_unbind_nns(String name, Continuation cont)
	throws NamingException {
	a_processJunction_nns(name, cont);
	}

	protected Context a_createSubcontext_nns(String name, Continuation cont)
	throws NamingException {
	a_processJunction_nns(name, cont);
	return null;
	}

	protected void a_destroySubcontext_nns(String name, Continuation cont)
	throws NamingException {
	a_processJunction_nns(name, cont);
	}

	protected void a_rename_nns(String oldname, Name newname, Continuation cont)
	throws NamingException {
	a_processJunction_nns(oldname, cont);
	}

	protected NameParser a_getNameParser_nns(Continuation cont)
	throws NamingException {
	a_processJunction_nns(cont);
	return null;
	}



	protected boolean isEmpty(String name) {
	return name == null \|\| name.equals("");
	}

	// ------ implementations of c_ and c_*_nns methods using
	// ------ the corresponding a_ and a_*_nns methods

	/* Equivalent to methods in Context interface */

	protected Object c_lookup(Name name, Continuation cont)
	throws NamingException {
	Object ret = null;
	if (resolve_to_penultimate_context(name, cont)) {
	ret = a_lookup(name.toString(), cont);
	if (ret != null && ret instanceof LinkRef) {
	cont.setContinue(ret, name, this);
	ret = null;
	}
	}
	return ret;
	}

	protected Object c_lookupLink(Name name, Continuation cont)
	throws NamingException {
	if (resolve_to_penultimate_context(name, cont)) {
	return a_lookupLink(name.toString(), cont);
	}
	return null;
	}

	protected NamingEnumeration<NameClassPair> c_list(Name name,
	Continuation cont) throws NamingException {
	if (resolve_to_context(name, cont)) {
	return a_list(cont);
	}
	return null;
	}

	protected NamingEnumeration<Binding> c_listBindings(Name name,
	Continuation cont) throws NamingException {
	if (resolve_to_context(name, cont)) {
	return a_listBindings(cont);
	}
	return null;
	}

	protected void c_bind(Name name, Object obj, Continuation cont)
	throws NamingException {
	if (resolve_to_penultimate_context(name, cont))
	a_bind(name.toString(), obj, cont);
	}

	protected void c_rebind(Name name, Object obj, Continuation cont)
	throws NamingException {
	if (resolve_to_penultimate_context(name, cont))
	a_rebind(name.toString(), obj, cont);
	}

	protected void c_unbind(Name name, Continuation cont)
	throws NamingException {
	if (resolve_to_penultimate_context(name, cont))
	a_unbind(name.toString(), cont);
	}

	protected void c_destroySubcontext(Name name, Continuation cont)
	throws NamingException {
	if (resolve_to_penultimate_context(name, cont))
	a_destroySubcontext(name.toString(), cont);
	}

	protected Context c_createSubcontext(Name name,
	Continuation cont) throws NamingException {
	if (resolve_to_penultimate_context(name, cont))
	return a_createSubcontext(name.toString(), cont);
	else
	return null;
	}

	protected void c_rename(Name oldname, Name newname,
	Continuation cont) throws NamingException {
	if (resolve_to_penultimate_context(oldname, cont))
	a_rename(oldname.toString(), newname, cont);
	}

	protected NameParser c_getNameParser(Name name,
	Continuation cont) throws NamingException {
	if (resolve_to_context(name, cont))
	return a_getNameParser(cont);
	return null;
	}

	/* The following are overridden only for AtomicContexts.
	* AtomicContext is used by PartialCompositeDirContext and ComponentDirContext
	* in the inheritance tree to make use of methods in
	* PartialCompositeContext and ComponentContext. We only want to use the
	* atomic forms when we're actually an atomic context.
	*/

	/* From ComponentContext */

	protected Object c_resolveIntermediate_nns(Name name, Continuation cont)
	throws NamingException {
	if (_contextType == _ATOMIC) {
	Object ret = null;
	if (resolve_to_penultimate_context_nns(name, cont)) {
	ret = a_resolveIntermediate_nns(name.toString(), cont);
	if (ret != null && ret instanceof LinkRef) {
	cont.setContinue(ret, name, this);
	ret = null;
	}
	}
	return ret;
	} else {
	// use ComponentContext
	return super.c_resolveIntermediate_nns(name, cont);
	}
	}

	/* Equivalent to methods in Context interface for nns */

	protected Object c_lookup_nns(Name name, Continuation cont)
	throws NamingException {
	if (_contextType == _ATOMIC) {
	Object ret = null;
	if (resolve_to_penultimate_context_nns(name, cont)) {
	ret = a_lookup_nns(name.toString(), cont);
	if (ret != null && ret instanceof LinkRef) {
	cont.setContinue(ret, name, this);
	ret = null;
	}
	}
	return ret;
	} else {
	return super.c_lookup_nns(name, cont);
	}
	}

	protected Object c_lookupLink_nns(Name name, Continuation cont)
	throws NamingException {
	if (_contextType == _ATOMIC) {
	// %%% check logic
	resolve_to_nns_and_continue(name, cont);
	return null;
	} else {
	// use ComponentContext
	return super.c_lookupLink_nns(name, cont);
	}
	}

	protected NamingEnumeration<NameClassPair> c_list_nns(Name name,
	Continuation cont) throws NamingException {
	if (_contextType == _ATOMIC) {
	resolve_to_nns_and_continue(name, cont);
	return null;
	} else {
	// use ComponentContext
	return super.c_list_nns(name, cont);
	}
	}

	protected NamingEnumeration<Binding> c_listBindings_nns(Name name,
	Continuation cont) throws NamingException {
	if (_contextType == _ATOMIC) {
	resolve_to_nns_and_continue(name, cont);
	return null;
	} else {
	// use ComponentContext
	return super.c_listBindings_nns(name, cont);
	}
	}

	protected void c_bind_nns(Name name, Object obj, Continuation cont)
	throws NamingException {
	if (_contextType == _ATOMIC) {
	if (resolve_to_penultimate_context_nns(name, cont))
	a_bind_nns(name.toString(), obj, cont);
	} else {
	// use ComponentContext
	super.c_bind_nns(name, obj, cont);
	}
	}

	protected void c_rebind_nns(Name name, Object obj, Continuation cont)
	throws NamingException {
	if (_contextType == _ATOMIC) {
	if (resolve_to_penultimate_context_nns(name, cont))
	a_rebind_nns(name.toString(), obj, cont);
	} else {
	// use ComponentContext
	super.c_rebind_nns(name, obj, cont);
	}
	}

	protected void c_unbind_nns(Name name, Continuation cont)
	throws NamingException {
	if (_contextType == _ATOMIC) {
	if (resolve_to_penultimate_context_nns(name, cont))
	a_unbind_nns(name.toString(), cont);
	} else {
	// use ComponentContext
	super.c_unbind_nns(name, cont);
	}
	}

	protected Context c_createSubcontext_nns(Name name,
	Continuation cont) throws NamingException {
	if (_contextType == _ATOMIC) {
	if (resolve_to_penultimate_context_nns(name, cont))
	return a_createSubcontext_nns(name.toString(), cont);
	else
	return null;
	} else {
	// use ComponentContext
	return super.c_createSubcontext_nns(name, cont);
	}
	}

	protected void c_destroySubcontext_nns(Name name, Continuation cont)
	throws NamingException {
	if (_contextType == _ATOMIC) {
	if (resolve_to_penultimate_context_nns(name, cont))
	a_destroySubcontext_nns(name.toString(), cont);
	} else {
	// use ComponentContext
	super.c_destroySubcontext_nns(name, cont);
	}
	}

	protected void c_rename_nns(Name oldname, Name newname, Continuation cont)
	throws NamingException {
	if (_contextType == _ATOMIC) {
	if (resolve_to_penultimate_context_nns(oldname, cont))
	a_rename_nns(oldname.toString(), newname, cont);
	} else {
	// use ComponentContext
	super.c_rename_nns(oldname, newname, cont);
	}
	}

	protected NameParser c_getNameParser_nns(Name name, Continuation cont)
	throws NamingException {
	if (_contextType == _ATOMIC) {
	resolve_to_nns_and_continue(name, cont);
	return null;
	} else {
	// use COmponentContext
	return super.c_getNameParser_nns(name, cont);
	}
	}

	// -------------- internal methods used by this class

	/* Handles nns for junctions */
	/**
	* This function is used when implementing a naming system that
	* supports junctions. For example, when the a_bind_nns(name, newobj)
	* method is invoked, that means the caller is attempting to bind the
	* object 'newobj' to the nns of 'name'. For context that supports
	* junctions, 'name' names a junction and is pointing to the root
	* of another naming system, which in turn might have an nns.
	* This means that a_bind_nns() should first resolve 'name' and attempt to
	* continue the operation in the context named by 'name'. (i.e. bind
	* to the nns of the context named by 'name').
	* If name is already empty, then throw NameNotFoundException because
	* this context by default does not have any nns.
	*/
	protected void a_processJunction_nns(String name, Continuation cont)
	throws NamingException {
	if (name.equals("")) {
	NameNotFoundException e = new NameNotFoundException();
	cont.setErrorNNS(this, name);
	throw cont.fillInException(e);
	}
	try {
	// lookup name to continue operation in nns
	Object target = a_lookup(name, cont);
	if (cont.isContinue())
	cont.appendRemainingComponent(""); // add nns back
	else {
	cont.setContinueNNS(target, name, this);
	}
	} catch (NamingException e) {
	e.appendRemainingComponent(""); // add nns back
	throw e;
	}
	}

	/**
	* This function is used when implementing a naming system that
	* supports junctions. For example, when the a_list_nns(newobj)
	* method is invoked, that means the caller is attempting to list the
	* the nns context of of this context. For a context that supports
	* junctions, it by default does not have any nns. Consequently,
	* a NameNotFoundException is thrown.
	*/
	protected void a_processJunction_nns(Continuation cont) throws NamingException {

	// Construct a new Reference that contains this context.
	RefAddr addr = new RefAddr("nns") {
	public Object getContent() {
	return AtomicContext.this;
	}
	private static final long serialVersionUID = 3449785852664978312L;
	};
	Reference ref = new Reference("java.lang.Object", addr);

	// Set continuation leave it to PartialCompositeContext.getPCContext()
	// to throw the exception.
	// Do not use setContinueNNS() because we've are
	// setting relativeResolvedName to "/".
	cont.setContinue(ref, _NNS_NAME, this);
	}

	/* ********* core resolution routines ***************** */

	/** Resolve to context named by 'name'.
	* Returns true if at named context (i.e. 'name' is empty name).
	* Returns false otherwise, and sets Continuation on parts of 'name'
	* not yet resolved.
	*/
	protected boolean resolve_to_context(Name name, Continuation cont)
	throws NamingException {
	String target = name.toString();


	StringHeadTail ht = c_parseComponent(target, cont);
	String tail = ht.getTail();
	String head = ht.getHead();

	if (debug > 0)
	System.out.println("RESOLVE TO CONTEXT(" + target + ") = {" +
	head + ", " + tail + "}");

	if (head == null) {
	// something is wrong; no name at all
	InvalidNameException e = new InvalidNameException();
	throw cont.fillInException(e);
	}
	if (!isEmpty(head)) {
	// if there is head is a non-empty name
	// this means more resolution to be done
	try {
	Object headCtx = a_lookup(head, cont);
	// System.out.println("answer " + headCtx);
	if (headCtx != null)
	cont.setContinue(headCtx, head, this, (tail == null ? "" : tail));
	else if (cont.isContinue())
	cont.appendRemainingComponent(tail);
	} catch (NamingException e) {
	e.appendRemainingComponent(tail);
	throw e;
	}
	} else {
	cont.setSuccess(); // clear
	return true;
	}
	return false;
	}

	/**
	* Resolves to penultimate context named by 'name'.
	* Returns true if penultimate context has been reached (i.e. name
	* only has one atomic component left).
	* Returns false otherwise, and sets Continuation to parts of name
	* not yet resolved.
	*/
	protected boolean resolve_to_penultimate_context(Name name, Continuation cont)
	throws NamingException {
	String target = name.toString();

	if (debug > 0)
	System.out.println("RESOLVE TO PENULTIMATE" + target);

	StringHeadTail ht = c_parseComponent(target, cont);
	String tail = ht.getTail();
	String head = ht.getHead();
	if (head == null) {
	// something is wrong; no name at all
	InvalidNameException e = new InvalidNameException();
	throw cont.fillInException(e);
	}

	if (!isEmpty(tail)) {
	// more components; hence not at penultimate context yet
	try {
	Object headCtx = a_lookup(head, cont);
	if (headCtx != null)
	cont.setContinue(headCtx, head, this, tail);
	else if (cont.isContinue())
	cont.appendRemainingComponent(tail);
	} catch (NamingException e) {
	e.appendRemainingComponent(tail);
	throw e;
	}
	} else {
	// already at penultimate context
	cont.setSuccess(); // clear
	return true;
	}
	return false;
	}

	/**
	* This function is similar to resolve_to_penultimate_context()
	* except it should only be called by the nns() functions.
	* This function fixes any exception or continuations so that
	* it will have the proper nns name.
	*/
	protected boolean resolve_to_penultimate_context_nns(Name name,
	Continuation cont)
	throws NamingException {
	try {
	if (debug > 0)
	System.out.println("RESOLVE TO PENULTIMATE NNS" + name.toString());
	boolean answer = resolve_to_penultimate_context(name, cont);

	// resolve_to_penultimate_context() only calls a_lookup().
	// Any continuation it sets is lacking the nns, so
	// we need to add it back
	if (cont.isContinue())
	cont.appendRemainingComponent("");

	return answer;
	} catch (NamingException e) {
	// resolve_to_penultimate_context() only calls a_lookup().
	// Any exceptions it throws is lacking the nns, so
	// we need to add it back.
	e.appendRemainingComponent("");
	throw e;
	}
	}

	/**
	* Resolves to nns associated with 'name' and set Continuation
	* to the result.
	*/
	protected void resolve_to_nns_and_continue(Name name, Continuation cont)
	throws NamingException {
	if (debug > 0)
	System.out.println("RESOLVE TO NNS AND CONTINUE" + name.toString());

	if (resolve_to_penultimate_context_nns(name, cont)) {
	Object nns = a_lookup_nns(name.toString(), cont);
	if (nns != null)
	cont.setContinue(nns, name, this);
	}
	}
	}

Back to index...