| Methods Summary |
|---|
| public void | bind(java.lang.String name, java.lang.Object obj, javax.naming.directory.Attributes attrs)Binds a name to an object, along with associated attributes. If attrs
is null, the resulting binding will have the attributes associated
with obj if obj is a DirContext, and no attributes otherwise. If attrs
is non-null, the resulting binding will have attrs as its attributes;
any attributes associated with obj are ignored.
throw new OperationNotSupportedException();
|
| public javax.naming.directory.DirContext | createSubcontext(java.lang.String name, javax.naming.directory.Attributes attrs)Creates and binds a new context, along with associated attributes.
This method creates a new subcontext with the given name, binds it in
the target context (that named by all but terminal atomic component of
the name), and associates the supplied attributes with the newly
created object. All intermediate and target contexts must already
exist. If attrs is null, this method is equivalent to
Context.createSubcontext().
throw new OperationNotSupportedException();
|
| public void | destroySubcontext(java.lang.String name)Destroys the named context and removes it from the namespace. Any
attributes associated with the name are also removed. Intermediate
contexts are not destroyed.
This method is idempotent. It succeeds even if the terminal atomic
name is not bound in the target context, but throws
NameNotFoundException if any of the intermediate contexts do not exist.
In a federated naming system, a context from one naming system may be
bound to a name in another. One can subsequently look up and perform
operations on the foreign context using a composite name. However, an
attempt destroy the context using this composite name will fail with
NotContextException, because the foreign context is not a "subcontext"
of the context in which it is bound. Instead, use unbind() to remove
the binding of the foreign context. Destroying the foreign context
requires that the destroySubcontext() be performed on a context from
the foreign context's "native" naming system.
throw new OperationNotSupportedException();
|
| public javax.naming.directory.Attributes | getAttributes(java.lang.String name, java.lang.String[] attrIds)Retrieves selected attributes associated with a named object.
See the class description regarding attribute models, attribute type
names, and operational attributes.
return getAttributes(new CompositeName(name), attrIds);
|
| public javax.naming.directory.Attributes | getAttributes(javax.naming.Name name, java.lang.String[] attrIds)Retrieves all of the attributes associated with a named object.
Entry entry = null;
if (name.isEmpty())
entry = entries;
else
entry = treeLookup(name);
if (entry == null)
throw new NamingException
(sm.getString("resources.notFound", name));
ZipEntry zipEntry = entry.getEntry();
ResourceAttributes attrs = new ResourceAttributes();
attrs.setCreationDate(new Date(zipEntry.getTime()));
attrs.setName(entry.getName());
if (!zipEntry.isDirectory())
attrs.setResourceType("");
attrs.setContentLength(zipEntry.getSize());
attrs.setLastModified(new Date(zipEntry.getTime()));
return attrs;
|
| public java.lang.String | getNameInNamespace()Retrieves the full name of this context within its own namespace.
Many naming services have a notion of a "full name" for objects in
their respective namespaces. For example, an LDAP entry has a
distinguished name, and a DNS record has a fully qualified name. This
method allows the client application to retrieve this name. The string
returned by this method is not a JNDI composite name and should not be
passed directly to context methods. In naming systems for which the
notion of full name does not make sense,
OperationNotSupportedException is thrown.
return docBase;
|
| public javax.naming.directory.DirContext | getSchema(java.lang.String name)Retrieves the schema associated with the named object. The schema
describes rules regarding the structure of the namespace and the
attributes stored within it. The schema specifies what types of
objects can be added to the directory and where they can be added;
what mandatory and optional attributes an object can have. The range
of support for schemas is directory-specific.
throw new OperationNotSupportedException();
|
| public javax.naming.directory.DirContext | getSchemaClassDefinition(java.lang.String name)Retrieves a context containing the schema objects of the named
object's class definitions.
throw new OperationNotSupportedException();
|
| public javax.naming.NamingEnumeration | list(java.lang.String name)Enumerates the names bound in the named context, along with the class
names of objects bound to them. The contents of any subcontexts are
not included.
If a binding is added to or removed from this context, its effect on
an enumeration previously returned is undefined.
return list(new CompositeName(name));
|
| public javax.naming.NamingEnumeration | list(javax.naming.Name name)Enumerates the names bound in the named context, along with the class
names of objects bound to them. The contents of any subcontexts are
not included.
If a binding is added to or removed from this context, its effect on
an enumeration previously returned is undefined.
if (name.isEmpty())
return new NamingContextEnumeration(list(entries));
Entry entry = treeLookup(name);
if (entry == null)
throw new NamingException
(sm.getString("resources.notFound", name));
return new NamingContextEnumeration(list(entry));
|
| protected java.util.Vector | list(org.apache.naming.resources.WARDirContext$Entry entry)List children as objects.
Vector entries = new Vector();
Entry[] children = entry.getChildren();
Arrays.sort(children);
NamingEntry namingEntry = null;
for (int i = 0; i < children.length; i++) {
ZipEntry current = children[i].getEntry();
Object object = null;
if (current.isDirectory()) {
object = new WARDirContext(base, children[i]);
} else {
object = new WARResource(current);
}
namingEntry = new NamingEntry
(children[i].getName(), object, NamingEntry.ENTRY);
entries.addElement(namingEntry);
}
return entries;
|
| public javax.naming.NamingEnumeration | listBindings(java.lang.String name)Enumerates the names bound in the named context, along with the
objects bound to them. The contents of any subcontexts are not
included.
If a binding is added to or removed from this context, its effect on
an enumeration previously returned is undefined.
return listBindings(new CompositeName(name));
|
| public javax.naming.NamingEnumeration | listBindings(javax.naming.Name name)Enumerates the names bound in the named context, along with the
objects bound to them. The contents of any subcontexts are not
included.
If a binding is added to or removed from this context, its effect on
an enumeration previously returned is undefined.
if (name.isEmpty())
return new NamingContextBindingsEnumeration(list(entries));
Entry entry = treeLookup(name);
if (entry == null)
throw new NamingException
(sm.getString("resources.notFound", name));
return new NamingContextBindingsEnumeration(list(entry));
|
| protected void | loadEntries()Constructs a tree of the entries contained in a WAR file.
try {
Enumeration entryList = base.entries();
entries = new Entry("/", new ZipEntry("/"));
while (entryList.hasMoreElements()) {
ZipEntry entry = (ZipEntry) entryList.nextElement();
String name = normalize(entry);
int pos = name.lastIndexOf('/");
// Check that parent entries exist and, if not, create them.
// This fixes a bug for war files that don't record separate
// zip entries for the directories.
int currentPos = -1;
int lastPos = 0;
while ((currentPos = name.indexOf('/", lastPos)) != -1) {
Name parentName = new CompositeName(name.substring(0, lastPos));
Name childName = new CompositeName(name.substring(0, currentPos));
String entryName = name.substring(lastPos, currentPos);
// Parent should have been created in last cycle through
// this loop
Entry parent = treeLookup(parentName);
Entry child = treeLookup(childName);
if (child == null) {
// Create a new entry for missing entry and strip off
// the leading '/' character and appended on by the
// normalize method and add '/' character to end to
// signify that it is a directory entry
String zipName = name.substring(1, currentPos) + "/";
child = new Entry(entryName, new ZipEntry(zipName));
if (parent != null)
parent.addChild(child);
}
// Increment lastPos
lastPos = currentPos + 1;
}
String entryName = name.substring(pos + 1, name.length());
Name compositeName = new CompositeName(name.substring(0, pos));
Entry parent = treeLookup(compositeName);
Entry child = new Entry(entryName, entry);
if (parent != null)
parent.addChild(child);
}
} catch (Exception e) {
}
|
| public java.lang.Object | lookup(java.lang.String name)Retrieves the named object.
return lookup(new CompositeName(name));
|
| public java.lang.Object | lookup(javax.naming.Name name)Retrieves the named object. If name is empty, returns a new instance
of this context (which represents the same naming context as this
context, but its environment may be modified independently and it may
be accessed concurrently).
if (name.isEmpty())
return this;
Entry entry = treeLookup(name);
if (entry == null)
throw new NamingException
(sm.getString("resources.notFound", name));
ZipEntry zipEntry = entry.getEntry();
if (zipEntry.isDirectory())
return new WARDirContext(base, entry);
else
return new WARResource(entry.getEntry());
|
| public java.lang.Object | lookupLink(java.lang.String name)Retrieves the named object, following links except for the terminal
atomic component of the name. If the object bound to name is not a
link, returns the object itself.
// Note : Links are not supported
return lookup(name);
|
| public void | modifyAttributes(java.lang.String name, int mod_op, javax.naming.directory.Attributes attrs)Modifies the attributes associated with a named object. The order of
the modifications is not specified. Where possible, the modifications
are performed atomically.
throw new OperationNotSupportedException();
|
| public void | modifyAttributes(java.lang.String name, javax.naming.directory.ModificationItem[] mods)Modifies the attributes associated with a named object using an an
ordered list of modifications. The modifications are performed in the
order specified. Each modification specifies a modification operation
code and an attribute on which to operate. Where possible, the
modifications are performed atomically.
throw new OperationNotSupportedException();
|
| protected java.lang.String | normalize(java.util.zip.ZipEntry entry)Normalize the name of an entry read from the Zip.
String result = "/" + entry.getName();
if (entry.isDirectory()) {
result = result.substring(0, result.length() - 1);
}
return result;
|
| public void | rebind(java.lang.String name, java.lang.Object obj, javax.naming.directory.Attributes attrs)Binds a name to an object, along with associated attributes,
overwriting any existing binding. If attrs is null and obj is a
DirContext, the attributes from obj are used. If attrs is null and obj
is not a DirContext, any existing attributes associated with the object
already bound in the directory remain unchanged. If attrs is non-null,
any existing attributes associated with the object already bound in
the directory are removed and attrs is associated with the named
object. If obj is a DirContext and attrs is non-null, the attributes
of obj are ignored.
throw new OperationNotSupportedException();
|
| public void | release()Release any resources allocated for this directory context.
entries = null;
if (base != null) {
try {
base.close();
} catch (IOException e) {
log.warn("Exception closing WAR File " + base.getName(), e);
}
}
base = null;
super.release();
|
| public void | rename(java.lang.String oldName, java.lang.String newName)Binds a new name to the object bound to an old name, and unbinds the
old name. Both names are relative to this context. Any attributes
associated with the old name become associated with the new name.
Intermediate contexts of the old name are not changed.
throw new OperationNotSupportedException();
|
| public javax.naming.NamingEnumeration | search(java.lang.String name, javax.naming.directory.Attributes matchingAttributes, java.lang.String[] attributesToReturn)Searches in a single context for objects that contain a specified set
of attributes, and retrieves selected attributes. The search is
performed using the default SearchControls settings.
throw new OperationNotSupportedException();
|
| public javax.naming.NamingEnumeration | search(java.lang.String name, javax.naming.directory.Attributes matchingAttributes)Searches in a single context for objects that contain a specified set
of attributes. This method returns all the attributes of such objects.
It is equivalent to supplying null as the atributesToReturn parameter
to the method search(Name, Attributes, String[]).
throw new OperationNotSupportedException();
|
| public javax.naming.NamingEnumeration | search(java.lang.String name, java.lang.String filter, javax.naming.directory.SearchControls cons)Searches in the named context or object for entries that satisfy the
given search filter. Performs the search as specified by the search
controls.
throw new OperationNotSupportedException();
|
| public javax.naming.NamingEnumeration | search(java.lang.String name, java.lang.String filterExpr, java.lang.Object[] filterArgs, javax.naming.directory.SearchControls cons)Searches in the named context or object for entries that satisfy the
given search filter. Performs the search as specified by the search
controls.
throw new OperationNotSupportedException();
|
| public void | setDocBase(java.lang.String docBase)Set the document root.
// ------------------------------------------------------------- Properties
// Validate the format of the proposed document root
if (docBase == null)
throw new IllegalArgumentException
(sm.getString("resources.null"));
if (!(docBase.endsWith(".war")))
throw new IllegalArgumentException
(sm.getString("warResources.notWar"));
// Calculate a File object referencing this document base directory
File base = new File(docBase);
// Validate that the document base is an existing directory
if (!base.exists() || !base.canRead() || base.isDirectory())
throw new IllegalArgumentException
(sm.getString("warResources.notWar"));
try {
this.base = new ZipFile(base);
} catch (Exception e) {
throw new IllegalArgumentException
(sm.getString("warResources.invalidWar", e.getMessage()));
}
super.setDocBase(docBase);
loadEntries();
|
| protected org.apache.naming.resources.WARDirContext$Entry | treeLookup(javax.naming.Name name)Entry tree lookup.
if (name.isEmpty())
return entries;
Entry currentEntry = entries;
for (int i = 0; i < name.size(); i++) {
if (name.get(i).length() == 0)
continue;
currentEntry = currentEntry.getChild(name.get(i));
if (currentEntry == null)
return null;
}
return currentEntry;
|
| public void | unbind(java.lang.String name)Unbinds the named object. Removes the terminal atomic name in name
from the target context--that named by all but the terminal atomic
part of name.
This method is idempotent. It succeeds even if the terminal atomic
name is not bound in the target context, but throws
NameNotFoundException if any of the intermediate contexts do not exist.
throw new OperationNotSupportedException();
|
