org.eclipse.jetty.jndi.NamingContext Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of testatoo-container-jetty-full Show documentation
Show all versions of testatoo-container-jetty-full Show documentation
Testatoo Jetty Container with JSP support
// ========================================================================
// Copyright (c) 1999-2009 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
package org.eclipse.jetty.jndi;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.NoSuchElementException;
import javax.naming.Binding;
import javax.naming.CompoundName;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.LinkRef;
import javax.naming.Name;
import javax.naming.NameAlreadyBoundException;
import javax.naming.NameClassPair;
import javax.naming.NameNotFoundException;
import javax.naming.NameParser;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.NotContextException;
import javax.naming.OperationNotSupportedException;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.naming.spi.NamingManager;
import org.eclipse.jetty.util.log.Log;
/*------------------------------------------------*/
/** NamingContext
* Implementation of Context interface.
*
*
Notes
* All Names are expected to be Compound, not Composite.
*
*
Usage
*
*/
/*
*
*
* @see
*
*
* @version 1.0
*/
public class NamingContext implements Context, Cloneable
{
public static final String LOCK_PROPERTY = "org.eclipse.jndi.lock";
public static final String UNLOCK_PROPERTY = "org.eclipse.jndi.unlock";
public static final Enumeration EMPTY_ENUM = new Enumeration ()
{
public boolean hasMoreElements()
{
return false;
}
public Object nextElement ()
{
throw new NoSuchElementException();
}
};
protected Context _parent = null;
protected String _name = null;
protected Hashtable _env = null;
protected Hashtable _bindings = new Hashtable();
protected NameParser _parser = null;
/*------------------------------------------------*/
/** NameEnumeration
* Implementation of NamingEnumeration interface.
*
*
Notes
* Used for returning results of Context.list();
*
*
Usage
*
*/
/*
*
*
* @see
*
*/
public class NameEnumeration implements NamingEnumeration
{
Enumeration _delegate;
public NameEnumeration (Enumeration e)
{
_delegate = e;
}
public void close()
throws NamingException
{
}
public boolean hasMore ()
throws NamingException
{
return _delegate.hasMoreElements();
}
public Object next()
throws NamingException
{
Binding b = (Binding)_delegate.nextElement();
return new NameClassPair (b.getName(), b.getClassName(), true);
}
public boolean hasMoreElements()
{
return _delegate.hasMoreElements();
}
public Object nextElement()
{
Binding b = (Binding)_delegate.nextElement();
return new NameClassPair (b.getName(), b.getClassName(), true);
}
}
/*------------------------------------------------*/
/** BindingEnumeration
* Implementation of NamingEnumeration
*
*
Notes
* Used to return results of Context.listBindings();
*
*
Usage
*
*/
/*
*
*
* @see
*
*/
public class BindingEnumeration implements NamingEnumeration
{
Enumeration _delegate;
public BindingEnumeration (Enumeration e)
{
_delegate = e;
}
public void close()
throws NamingException
{
}
public boolean hasMore ()
throws NamingException
{
return _delegate.hasMoreElements();
}
public Object next()
throws NamingException
{
Binding b = (Binding)_delegate.nextElement();
return new Binding (b.getName(), b.getClassName(), b.getObject(), true);
}
public boolean hasMoreElements()
{
return _delegate.hasMoreElements();
}
public Object nextElement()
{
Binding b = (Binding)_delegate.nextElement();
return new Binding (b.getName(), b.getClassName(), b.getObject(),true);
}
}
/*------------------------------------------------*/
/**
* Constructor
*
* @param env environment properties
* @param name relative name of this context
* @param parent immediate ancestor Context (can be null)
* @param parser NameParser for this Context
*/
public NamingContext(Hashtable env,
String name,
Context parent,
NameParser parser)
{
if (env == null)
_env = new Hashtable();
else
_env = new Hashtable(env);
_name = name;
_parent = parent;
_parser = parser;
}
/*------------------------------------------------*/
/**
* Creates a new NamingContext instance.
*
* @param env a Hashtable value
*/
public NamingContext (Hashtable env)
{
if (env == null)
_env = new Hashtable();
else
_env = new Hashtable(env);
}
/*------------------------------------------------*/
/**
* Constructor
*
*/
public NamingContext ()
{
_env = new Hashtable();
}
/*------------------------------------------------*/
/**
* Clone this NamingContext
*
* @return copy of this NamingContext
* @exception CloneNotSupportedException if an error occurs
*/
public Object clone ()
throws CloneNotSupportedException
{
NamingContext ctx = (NamingContext)super.clone();
ctx._env = (Hashtable)_env.clone();
ctx._bindings = (Hashtable)_bindings.clone();
return ctx;
}
/*------------------------------------------------*/
/**
* Getter for _name
*
* @return name of this Context (relative, not absolute)
*/
public String getName ()
{
return _name;
}
/*------------------------------------------------*/
/**
* Getter for _parent
*
* @return parent Context
*/
public Context getParent()
{
return _parent;
}
/*------------------------------------------------*/
/**
* Setter for _parser
*
*
*/
public void setNameParser (NameParser parser)
{
_parser = parser;
}
/*------------------------------------------------*/
/**
* Bind a name to an object
*
* @param name Name of the object
* @param obj object to bind
* @exception NamingException if an error occurs
*/
public void bind(Name name, Object obj)
throws NamingException
{
if (isLocked())
throw new NamingException ("This context is immutable");
Name cname = toCanonicalName(name);
if (cname == null)
throw new NamingException ("Name is null");
if (cname.size() == 0)
throw new NamingException ("Name is empty");
//if no subcontexts, just bind it
if (cname.size() == 1)
{
//get the object to be bound
Object objToBind = NamingManager.getStateToBind(obj, name,this, null);
// Check for Referenceable
if (objToBind instanceof Referenceable)
{
objToBind = ((Referenceable)objToBind).getReference();
}
//anything else we should be able to bind directly
Binding binding = getBinding (cname);
if (binding == null)
addBinding (cname, objToBind);
else
throw new NameAlreadyBoundException (cname.toString());
}
else
{
if(Log.isDebugEnabled())Log.debug("Checking for existing binding for name="+cname+" for first element of name="+cname.get(0));
//walk down the subcontext hierarchy
//need to ignore trailing empty "" name components
String firstComponent = cname.get(0);
Object ctx = null;
if (firstComponent.equals(""))
ctx = this;
else
{
Binding binding = getBinding (firstComponent);
if (binding == null)
throw new NameNotFoundException (firstComponent+ " is not bound");
ctx = binding.getObject();
if (ctx instanceof Reference)
{
//deference the object
try
{
ctx = NamingManager.getObjectInstance(ctx, getNameParser("").parse(firstComponent), this, _env);
}
catch (NamingException e)
{
throw e;
}
catch (Exception e)
{
Log.warn("",e);
throw new NamingException (e.getMessage());
}
}
}
if (ctx instanceof Context)
{
((Context)ctx).bind (cname.getSuffix(1), obj);
}
else
throw new NotContextException ("Object bound at "+firstComponent +" is not a Context");
}
}
/*------------------------------------------------*/
/**
* Bind a name (as a String) to an object
*
* @param name a String value
* @param obj an Object value
* @exception NamingException if an error occurs
*/
public void bind(String name, Object obj)
throws NamingException
{
bind (_parser.parse(name), obj);
}
/*------------------------------------------------*/
/**
* Create a context as a child of this one
*
* @param name a Name value
* @return a Context value
* @exception NamingException if an error occurs
*/
public Context createSubcontext (Name name)
throws NamingException
{
if (isLocked())
{
NamingException ne = new NamingException ("This context is immutable");
ne.setRemainingName(name);
throw ne;
}
Name cname = toCanonicalName (name);
if (cname == null)
throw new NamingException ("Name is null");
if (cname.size() == 0)
throw new NamingException ("Name is empty");
if (cname.size() == 1)
{
//not permitted to bind if something already bound at that name
Binding binding = getBinding (cname);
if (binding != null)
throw new NameAlreadyBoundException (cname.toString());
Context ctx = new NamingContext ((Hashtable)_env.clone(), cname.get(0), this, _parser);
addBinding (cname, ctx);
return ctx;
}
//If the name has multiple subcontexts, walk the hierarchy by
//fetching the first one. All intermediate subcontexts in the
//name must already exist.
String firstComponent = cname.get(0);
Object ctx = null;
if (firstComponent.equals(""))
ctx = this;
else
{
Binding binding = getBinding (firstComponent);
if (binding == null)
throw new NameNotFoundException (firstComponent + " is not bound");
ctx = binding.getObject();
if (ctx instanceof Reference)
{
//deference the object
if(Log.isDebugEnabled())Log.debug("Object bound at "+firstComponent +" is a Reference");
try
{
ctx = NamingManager.getObjectInstance(ctx, getNameParser("").parse(firstComponent), this, _env);
}
catch (NamingException e)
{
throw e;
}
catch (Exception e)
{
Log.warn("",e);
throw new NamingException (e.getMessage());
}
}
}
if (ctx instanceof Context)
{
return ((Context)ctx).createSubcontext (cname.getSuffix(1));
}
else
throw new NotContextException (firstComponent +" is not a Context");
}
/*------------------------------------------------*/
/**
* Create a Context as a child of this one
*
* @param name a String value
* @return a Context value
* @exception NamingException if an error occurs
*/
public Context createSubcontext (String name)
throws NamingException
{
return createSubcontext(_parser.parse(name));
}
/*------------------------------------------------*/
/**
* Not supported
*
* @param name name of subcontext to remove
* @exception NamingException if an error occurs
*/
public void destroySubcontext (String name)
throws NamingException
{
removeBinding(_parser.parse(name));
}
/*------------------------------------------------*/
/**
* Not supported
*
* @param name name of subcontext to remove
* @exception NamingException if an error occurs
*/
public void destroySubcontext (Name name)
throws NamingException
{
removeBinding(name);
}
/*------------------------------------------------*/
/**
* Lookup a binding by name
*
* @param name name of bound object
* @exception NamingException if an error occurs
*/
public Object lookup(Name name)
throws NamingException
{
if(Log.isDebugEnabled())Log.debug("Looking up name=\""+name+"\"");
Name cname = toCanonicalName(name);
if ((cname == null) || (cname.size() == 0))
{
Log.debug("Null or empty name, returning copy of this context");
NamingContext ctx = new NamingContext (_env, _name, _parent, _parser);
ctx._bindings = _bindings;
return ctx;
}
if (cname.size() == 1)
{
Binding binding = getBinding (cname);
if (binding == null)
{
NameNotFoundException nnfe = new NameNotFoundException();
nnfe.setRemainingName(cname);
throw nnfe;
}
Object o = binding.getObject();
//handle links by looking up the link
if (o instanceof LinkRef)
{
//if link name starts with ./ it is relative to current context
String linkName = ((LinkRef)o).getLinkName();
if (linkName.startsWith("./"))
return this.lookup (linkName.substring(2));
else
{
//link name is absolute
InitialContext ictx = new InitialContext();
return ictx.lookup (linkName);
}
}
else if (o instanceof Reference)
{
//deference the object
try
{
return NamingManager.getObjectInstance(o, cname, this, _env);
}
catch (NamingException e)
{
throw e;
}
catch (Exception e)
{
Log.warn("",e);
throw new NamingException (e.getMessage());
}
}
else
return o;
}
//it is a multipart name, recurse to the first subcontext
String firstComponent = cname.get(0);
Object ctx = null;
if (firstComponent.equals(""))
ctx = this;
else
{
Binding binding = getBinding (firstComponent);
if (binding == null)
{
NameNotFoundException nnfe = new NameNotFoundException();
nnfe.setRemainingName(cname);
throw nnfe;
}
//as we have bound a reference to an object factory
//for the component specific contexts
//at "comp" we need to resolve the reference
ctx = binding.getObject();
if (ctx instanceof Reference)
{
//deference the object
try
{
ctx = NamingManager.getObjectInstance(ctx, getNameParser("").parse(firstComponent), this, _env);
}
catch (NamingException e)
{
throw e;
}
catch (Exception e)
{
Log.warn("",e);
throw new NamingException (e.getMessage());
}
}
}
if (!(ctx instanceof Context))
throw new NotContextException();
return ((Context)ctx).lookup (cname.getSuffix(1));
}
/*------------------------------------------------*/
/**
* Lookup binding of an object by name
*
* @param name name of bound object
* @return object bound to name
* @exception NamingException if an error occurs
*/
public Object lookup (String name)
throws NamingException
{
return lookup (_parser.parse(name));
}
/*------------------------------------------------*/
/**
* Lookup link bound to name
*
* @param name name of link binding
* @return LinkRef or plain object bound at name
* @exception NamingException if an error occurs
*/
public Object lookupLink (Name name)
throws NamingException
{
Name cname = toCanonicalName(name);
if (cname == null)
{
NamingContext ctx = new NamingContext (_env, _name, _parent, _parser);
ctx._bindings = _bindings;
return ctx;
}
if (cname.size() == 0)
throw new NamingException ("Name is empty");
if (cname.size() == 1)
{
Binding binding = getBinding (cname);
if (binding == null)
throw new NameNotFoundException();
Object o = binding.getObject();
//handle links by looking up the link
if (o instanceof Reference)
{
//deference the object
try
{
return NamingManager.getObjectInstance(o, cname.getPrefix(1), this, _env);
}
catch (NamingException e)
{
throw e;
}
catch (Exception e)
{
Log.warn("",e);
throw new NamingException (e.getMessage());
}
}
else
{
//object is either a LinkRef which we don't dereference
//or a plain object in which case spec says we return it
return o;
}
}
//it is a multipart name, recurse to the first subcontext
String firstComponent = cname.get(0);
Object ctx = null;
if (firstComponent.equals(""))
ctx = this;
else
{
Binding binding = getBinding (firstComponent);
if (binding == null)
throw new NameNotFoundException ();
ctx = binding.getObject();
if (ctx instanceof Reference)
{
//deference the object
try
{
ctx = NamingManager.getObjectInstance(ctx, getNameParser("").parse(firstComponent), this, _env);
}
catch (NamingException e)
{
throw e;
}
catch (Exception e)
{
Log.warn("",e);
throw new NamingException (e.getMessage());
}
}
}
if (!(ctx instanceof Context))
throw new NotContextException();
return ((Context)ctx).lookup (cname.getSuffix(1));
}
/*------------------------------------------------*/
/**
* Lookup link bound to name
*
* @param name name of link binding
* @return LinkRef or plain object bound at name
* @exception NamingException if an error occurs
*/
public Object lookupLink (String name)
throws NamingException
{
return lookupLink (_parser.parse(name));
}
/*------------------------------------------------*/
/**
* List all names bound at Context named by Name
*
* @param name a Name value
* @return a NamingEnumeration value
* @exception NamingException if an error occurs
*/
public NamingEnumeration list(Name name)
throws NamingException
{
if(Log.isDebugEnabled())Log.debug("list() on Context="+getName()+" for name="+name);
Name cname = toCanonicalName(name);
if (cname == null)
{
return new NameEnumeration(EMPTY_ENUM);
}
if (cname.size() == 0)
{
return new NameEnumeration (_bindings.elements());
}
//multipart name
String firstComponent = cname.get(0);
Object ctx = null;
if (firstComponent.equals(""))
ctx = this;
else
{
Binding binding = getBinding (firstComponent);
if (binding == null)
throw new NameNotFoundException ();
ctx = binding.getObject();
if (ctx instanceof Reference)
{
//deference the object
if(Log.isDebugEnabled())Log.debug("Dereferencing Reference for "+name.get(0));
try
{
ctx = NamingManager.getObjectInstance(ctx, getNameParser("").parse(firstComponent), this, _env);
}
catch (NamingException e)
{
throw e;
}
catch (Exception e)
{
Log.warn("",e);
throw new NamingException (e.getMessage());
}
}
}
if (!(ctx instanceof Context))
throw new NotContextException();
return ((Context)ctx).list (cname.getSuffix(1));
}
/*------------------------------------------------*/
/**
* List all names bound at Context named by Name
*
* @param name a Name value
* @return a NamingEnumeration value
* @exception NamingException if an error occurs
*/
public NamingEnumeration list(String name)
throws NamingException
{
return list(_parser.parse(name));
}
/*------------------------------------------------*/
/**
* List all Bindings present at Context named by Name
*
* @param name a Name value
* @return a NamingEnumeration value
* @exception NamingException if an error occurs
*/
public NamingEnumeration listBindings(Name name)
throws NamingException
{
Name cname = toCanonicalName (name);
if (cname == null)
{
return new BindingEnumeration(EMPTY_ENUM);
}
if (cname.size() == 0)
{
return new BindingEnumeration (_bindings.elements());
}
//multipart name
String firstComponent = cname.get(0);
Object ctx = null;
//if a name has a leading "/" it is parsed as "" so ignore it by staying
//at this level in the tree
if (firstComponent.equals(""))
ctx = this;
else
{
//it is a non-empty name component
Binding binding = getBinding (firstComponent);
if (binding == null)
throw new NameNotFoundException ();
ctx = binding.getObject();
if (ctx instanceof Reference)
{
//deference the object
try
{
ctx = NamingManager.getObjectInstance(ctx, getNameParser("").parse(firstComponent), this, _env);
}
catch (NamingException e)
{
throw e;
}
catch (Exception e)
{
Log.warn("",e);
throw new NamingException (e.getMessage());
}
}
}
if (!(ctx instanceof Context))
throw new NotContextException();
return ((Context)ctx).listBindings (cname.getSuffix(1));
}
/*------------------------------------------------*/
/**
* List all Bindings at Name
*
* @param name a String value
* @return a NamingEnumeration value
* @exception NamingException if an error occurs
*/
public NamingEnumeration listBindings(String name)
throws NamingException
{
return listBindings (_parser.parse(name));
}
/*------------------------------------------------*/
/**
* Overwrite or create a binding
*
* @param name a Name value
* @param obj an Object value
* @exception NamingException if an error occurs
*/
public void rebind(Name name,
Object obj)
throws NamingException
{
if (isLocked())
throw new NamingException ("This context is immutable");
Name cname = toCanonicalName(name);
if (cname == null)
throw new NamingException ("Name is null");
if (cname.size() == 0)
throw new NamingException ("Name is empty");
//if no subcontexts, just bind it
if (cname.size() == 1)
{
//check if it is a Referenceable
Object objToBind = NamingManager.getStateToBind(obj, name, this, null);
if (objToBind instanceof Referenceable)
{
objToBind = ((Referenceable)objToBind).getReference();
}
addBinding (cname, objToBind);
}
else
{
//walk down the subcontext hierarchy
if(Log.isDebugEnabled())Log.debug("Checking for existing binding for name="+cname+" for first element of name="+cname.get(0));
String firstComponent = cname.get(0);
Object ctx = null;
if (firstComponent.equals(""))
ctx = this;
else
{
Binding binding = getBinding (name.get(0));
if (binding == null)
throw new NameNotFoundException (name.get(0)+ " is not bound");
ctx = binding.getObject();
if (ctx instanceof Reference)
{
//deference the object
try
{
ctx = NamingManager.getObjectInstance(ctx, getNameParser("").parse(firstComponent), this, _env);
}
catch (NamingException e)
{
throw e;
}
catch (Exception e)
{
Log.warn("",e);
throw new NamingException (e.getMessage());
}
}
}
if (ctx instanceof Context)
{
((Context)ctx).rebind (cname.getSuffix(1), obj);
}
else
throw new NotContextException ("Object bound at "+firstComponent +" is not a Context");
}
}
/*------------------------------------------------*/
/**
* Overwrite or create a binding from Name to Object
*
* @param name a String value
* @param obj an Object value
* @exception NamingException if an error occurs
*/
public void rebind (String name,
Object obj)
throws NamingException
{
rebind (_parser.parse(name), obj);
}
/*------------------------------------------------*/
/**
* Not supported.
*
* @param name a String value
* @exception NamingException if an error occurs
*/
public void unbind (String name)
throws NamingException
{
unbind(_parser.parse(name));
}
/*------------------------------------------------*/
/**
* Not supported.
*
* @param name a String value
* @exception NamingException if an error occurs
*/
public void unbind (Name name)
throws NamingException
{
if (name.size() == 0)
return;
if (isLocked())
throw new NamingException ("This context is immutable");
Name cname = toCanonicalName(name);
if (cname == null)
throw new NamingException ("Name is null");
if (cname.size() == 0)
throw new NamingException ("Name is empty");
//if no subcontexts, just unbind it
if (cname.size() == 1)
{
removeBinding (cname);
}
else
{
//walk down the subcontext hierarchy
if(Log.isDebugEnabled())Log.debug("Checking for existing binding for name="+cname+" for first element of name="+cname.get(0));
String firstComponent = cname.get(0);
Object ctx = null;
if (firstComponent.equals(""))
ctx = this;
else
{
Binding binding = getBinding (name.get(0));
if (binding == null)
throw new NameNotFoundException (name.get(0)+ " is not bound");
ctx = binding.getObject();
if (ctx instanceof Reference)
{
//deference the object
try
{
ctx = NamingManager.getObjectInstance(ctx, getNameParser("").parse(firstComponent), this, _env);
}
catch (NamingException e)
{
throw e;
}
catch (Exception e)
{
Log.warn("",e);
throw new NamingException (e.getMessage());
}
}
}
if (ctx instanceof Context)
{
((Context)ctx).unbind (cname.getSuffix(1));
}
else
throw new NotContextException ("Object bound at "+firstComponent +" is not a Context");
}
}
/*------------------------------------------------*/
/**
* Not supported
*
* @param oldName a Name value
* @param newName a Name value
* @exception NamingException if an error occurs
*/
public void rename(Name oldName,
Name newName)
throws NamingException
{
throw new OperationNotSupportedException();
}
/*------------------------------------------------*/
/**
* Not supported
*
* @param oldName a Name value
* @param newName a Name value
* @exception NamingException if an error occurs
*/ public void rename(String oldName,
String newName)
throws NamingException
{
throw new OperationNotSupportedException();
}
/*------------------------------------------------*/
/** Join two names together. These are treated as
* CompoundNames.
*
* @param name a Name value
* @param prefix a Name value
* @return a Name value
* @exception NamingException if an error occurs
*/
public Name composeName(Name name,
Name prefix)
throws NamingException
{
if (name == null)
throw new NamingException ("Name cannot be null");
if (prefix == null)
throw new NamingException ("Prefix cannot be null");
Name compoundName = (CompoundName)prefix.clone();
compoundName.addAll (name);
return compoundName;
}
/*------------------------------------------------*/
/** Join two names together. These are treated as
* CompoundNames.
*
* @param name a Name value
* @param prefix a Name value
* @return a Name value
* @exception NamingException if an error occurs
*/
public String composeName (String name,
String prefix)
throws NamingException
{
if (name == null)
throw new NamingException ("Name cannot be null");
if (prefix == null)
throw new NamingException ("Prefix cannot be null");
Name compoundName = _parser.parse(prefix);
compoundName.add (name);
return compoundName.toString();
}
/*------------------------------------------------*/
/**
* Do nothing
*
* @exception NamingException if an error occurs
*/
public void close ()
throws NamingException
{
}
/*------------------------------------------------*/
/**
* Return a NameParser for this Context.
*
* @param name a Name value
* @return a NameParser value
*/
public NameParser getNameParser (Name name)
{
return _parser;
}
/*------------------------------------------------*/
/**
* Return a NameParser for this Context.
*
* @param name a Name value
* @return a NameParser value
*/
public NameParser getNameParser (String name)
{
return _parser;
}
/*------------------------------------------------*/
/**
* Get the full name of this Context node
* by visiting it's ancestors back to root.
*
* NOTE: if this Context has a URL namespace then
* the URL prefix will be missing
*
* @return the full name of this Context
* @exception NamingException if an error occurs
*/
public String getNameInNamespace ()
throws NamingException
{
Name name = _parser.parse("");
NamingContext c = this;
while (c != null)
{
String str = c.getName();
if (str != null)
name.add(0, str);
c = (NamingContext)c.getParent();
}
return name.toString();
}
/*------------------------------------------------*/
/**
* Add an environment setting to this Context
*
* @param propName name of the property to add
* @param propVal value of the property to add
* @return propVal or previous value of the property
* @exception NamingException if an error occurs
*/
public Object addToEnvironment(String propName,
Object propVal)
throws NamingException
{
if (isLocked() && !(propName.equals(UNLOCK_PROPERTY)))
throw new NamingException ("This context is immutable");
return _env.put (propName, propVal);
}
/*------------------------------------------------*/
/**
* Remove a property from this Context's environment.
*
* @param propName name of property to remove
* @return value of property or null if it didn't exist
* @exception NamingException if an error occurs
*/
public Object removeFromEnvironment(String propName)
throws NamingException
{
if (isLocked())
throw new NamingException ("This context is immutable");
return _env.remove (propName);
}
/*------------------------------------------------*/
/**
* Get the environment of this Context.
*
* @return a copy of the environment of this Context.
*/
public Hashtable getEnvironment ()
{
return (Hashtable)_env.clone();
}
/*------------------------------------------------*/
/**
* Add a name to object binding to this Context.
*
* @param name a Name value
* @param obj an Object value
*/
protected void addBinding (Name name, Object obj)
{
String key = name.toString();
if(Log.isDebugEnabled())Log.debug("Adding binding with key="+key+" obj="+obj+" for context="+_name);
_bindings.put (key, new Binding (key, obj));
}
/*------------------------------------------------*/
/**
* Get a name to object binding from this Context
*
* @param name a Name value
* @return a Binding value
*/
protected Binding getBinding (Name name)
{
if(Log.isDebugEnabled())Log.debug("Looking up binding for "+name.toString()+" for context="+_name);
return (Binding) _bindings.get(name.toString());
}
/*------------------------------------------------*/
/**
* Get a name to object binding from this Context
*
* @param name as a String
* @return null or the Binding
*/
protected Binding getBinding (String name)
{
if(Log.isDebugEnabled())Log.debug("Looking up binding for "+name+" for context="+_name);
return (Binding) _bindings.get(name);
}
protected void removeBinding (Name name)
{
String key = name.toString();
if (Log.isDebugEnabled()) Log.debug("Removing binding with key="+key);
_bindings.remove(key);
}
/*------------------------------------------------*/
/**
* Remove leading or trailing empty components from
* name. Eg "/comp/env/" -> "comp/env"
*
* @param name the name to normalize
* @return normalized name
*/
public Name toCanonicalName (Name name)
{
Name canonicalName = name;
if (name != null)
{
if (canonicalName.size() > 1)
{
if (canonicalName.get(0).equals(""))
canonicalName = canonicalName.getSuffix(1);
if (canonicalName.get(canonicalName.size()-1).equals(""))
canonicalName = canonicalName.getPrefix(canonicalName.size()-1);
}
}
return canonicalName;
}
private boolean isLocked()
{
if ((_env.get(LOCK_PROPERTY) == null) && (_env.get(UNLOCK_PROPERTY) == null))
return false;
Object lockKey = _env.get(LOCK_PROPERTY);
Object unlockKey = _env.get(UNLOCK_PROPERTY);
if ((lockKey != null) && (unlockKey != null) && (lockKey.equals(unlockKey)))
return false;
return true;
}
}