/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can obtain
* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
* or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
* Sun designates this particular file as subject to the "Classpath" exception
* as provided by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the License
* Header, with the fields enclosed by brackets [] replaced by your own
* identifying information: "Portions Copyrighted [year]
* [name of copyright owner]"
*
* Contributor(s):
*
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.enterprise.naming;
import java.util.*;
import java.io.*;
import javax.naming.*;
import org.omg.CORBA.ORB;
import com.sun.enterprise.util.ORBManager;
import com.sun.enterprise.Switch;
import com.sun.enterprise.naming.java.javaURLContext;
import javax.rmi.PortableRemoteObject;
import java.rmi.RemoteException;
import org.omg.CosNaming.NamingContext;
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContextHelper;
import com.sun.enterprise.server.ondemand.entry.*;
import java.util.logging.*;
import com.sun.logging.*;
/**
* This is a JNDI Context implementation for storing serializable objects.
* This is the default Context for the J2EE RI. Lookups of unqualified
* names (i.e. names not starting with "java:", "corbaname:" etc)
* are serviced by SerialContext. The namespace is implemented in
* the J2EE server in the SerialContextProviderImpl object, which is
* accessed over RMI-IIOP from clients.
* <p><b>NOT THREAD SAFE: mutable instance variables</b>
*/
public class SerialContext implements Context {
private static final Logger _logger=LogDomains.getLogger(LogDomains.JNDI_LOGGER);
private static final NameParser myParser = new SerialNameParser();
private Hashtable myEnv=null; // THREAD UNSAFE
private SerialContextProvider provider; // THREAD UNSAFE
private static Hashtable providerCache = new Hashtable();
private final String myName;
private final javaURLContext javaUrlContext;
private static final String JAVA_URL = "java:";
// private InitialContext cosContext;
private static final Boolean threadlock = new Boolean(true);
private static final ThreadLocal stickyContext = new ThreadLocal();
private final boolean isEE;
/**
* set and get methods for preserving stickiness.
* This is a temporary solution
* to store the sticky IC as a thread local variable.
* This sticky IC will be used by all classes that require a context
* object to do lookup (if LB is enabled)
* SerialContext.lookup() sets a value for the thread local variable
* (stickyContext) before performing th lookup in case LB is enabled.
* If not, the thread local variable is null.
* At the end of the SerialContext.lookup() method, the thread local
* variable gets set to null.
* So actually speaking, more than being a global variable for the
* entire thread, its global only during the execution of the
* SerialContext.lookup() method. bug 5050591
* This will be cleaned for the next release.
*
*/
public static void setSticky(ThreadLocalIC var) {
stickyContext.set(var);
}
public static ThreadLocalIC getSticky() {
return (ThreadLocalIC) stickyContext.get();
}
/**
* This method is called from SerialInitContextFactory & S1ASCtxFactory
* to check if sticky context is set.
*/
public static Context getStickyContext() {
return getSticky().getStickyContext();
}
/**
* method to narrow down the provider.
* common code that is called from getProvider()
*/
private SerialContextProvider narrowProvider(org.omg.CORBA.Object ref)
throws Exception {
NamingContext nctx = NamingContextHelper.narrow(ref);
NameComponent[] path =
{ new NameComponent("SerialContextProvider", "") };
synchronized (threadlock) {
provider = (SerialContextProvider)
PortableRemoteObject.narrow(nctx.resolve(path),
SerialContextProvider.class);
}
return provider;
}
private SerialContextProvider getProvider()
throws NamingException {
try {
if (provider == null) {
if (Switch.getSwitch().getContainerType() ==
Switch.EJBWEB_CONTAINER) {
if (_logger.isLoggable(Level.FINE)) {
_logger.fine("lookup call inside the server VM...");
}
provider = Switch.getSwitch().getProviderManager().getLocalProvider();
} else {
if (_logger.isLoggable(Level.FINE)) {
_logger.fine("lookup call outside the server VM...");
}
// get SerialContextProvider from naming service
// Get orb to use for connecting to NameService
ORB orb = (ORB) myEnv.get(ORBManager.JNDI_CORBA_ORB_PROPERTY);
if ( orb == null ) {
orb = ORBManager.getORB();
}
if (_logger.isLoggable(Level.FINE))
print(orb);
org.omg.CORBA.Object ref = null;
//if the following is not null, then we are in EE world
//else PE
//if (myEnv.get("com.sun.appserv.ee.iiop.endpointslist") != null) {
if (isEE == true) {
ref = orb.string_to_object((String)(myEnv.get(
"com.sun.appserv.ee.iiop.endpointslist")));
provider = narrowProvider(ref);
} else {
provider = (SerialContextProvider) providerCache.get(orb);
// thread-safety: race condition
if (provider == null) {
ref = orb.resolve_initial_references("NameService");
provider = narrowProvider(ref);
providerCache.put(orb, provider);
}
}
}
}
} catch (Exception ex) {
setSticky(null);
CommunicationException ce = new CommunicationException
("Can't find SerialContextProvider");
ce.initCause(ex);
throw ce;
}
return provider;
}
//internal API for logging
public void print(ORB orb) {
_logger.fine("SerialContext ==> SerialContext instance created : " + this);
if (orb != null) {
_logger.fine("SerialContext ==> ORB instance : " + orb);
String host = ((com.sun.corba.ee.impl.orb.ORBImpl)orb).
getORBData().getORBInitialHost();
int port = ((com.sun.corba.ee.impl.orb.ORBImpl)orb).
getORBData().getORBInitialPort();
_logger.fine("SerialContext ==> ORB HOST : " + host +
", ORB PORT : " + port);
} else _logger.fine("orb is null");
}
/**
* Constructor for the context. Initializes the object reference
* to the remote provider object.
*/
public SerialContext(String name, Hashtable environment) throws NamingException {
myEnv = (environment != null)
? (Hashtable)(environment.clone())
: null;
// Dont initialize provider now, this throws an exception
// if J2EEServer is not yet started. Get it lazily when needed.
//provider = SerialContext.getProvider(myEnv);
this.myName = name;
if (_logger.isLoggable(Level.FINE))
_logger.fine("SerialContext ==> SerialContext instance created : " + this);
// using these two temp variables allows instance variables
// to be 'final'.
javaURLContext urlContextTemp = null;
boolean isEETemp = false;
if (myEnv.get("com.sun.appserv.ee.iiop.endpointslist") != null) {
isEETemp = true;
urlContextTemp = new javaURLContext(myEnv, this);
}
else {
urlContextTemp = new javaURLContext(myEnv, null);
}
javaUrlContext = urlContextTemp;
isEE = isEETemp;
}
/**
* This constructor takes the component id as an argument. All
* name arguments to operations are prepended by the component id.
*/
public SerialContext(Hashtable env) throws NamingException {
this("", env);
}
/**
* The getNameInNamespace API is not supported in this context.
* @exception NamingException if there is a naming exception.
*/
public String getNameInNamespace() throws NamingException {
return myName;
}
/**
* method to check if the name to look up starts with "java:"
*/
private boolean isjavaURL(String name) {
if (name.startsWith(JAVA_URL)) {
return true;
} else return false;
}
/**
* Generates an entry context and give it to ondemand initialization framework.
*/
public void generateEntryContext(Object context) {
ServerEntryHelper.generateJndiEntryContext((String) context);
}
/**
* method for checking the count and decrementing it
* also resets the sticky context to null if count is 0
*/
private void resetSticky() {
if (getSticky() != null) {
getSticky().decrementCount();
if (getSticky().getStickyCount() == 0) {
setSticky(null);
}
}
}
/**
* Lookup the specified name in the context.
* Returns the resolved object.
* @return the resolved object.
* @exception NamingException if there is a naming exception.
*/
public Object lookup(String name) throws NamingException {
//Before enything call ondemand initialization framework.
generateEntryContext(name);
/**
* In case a user is creating an IC with env passed
* in constructor; env specifies endpoints in some form
* in that case, the sticky IC should be stores as a thread local
* variable.
*
*/
if (myEnv.get("com.sun.appserv.ee.iiop.endpointslist") != null) {
if (getSticky() == null) {
ThreadLocalIC threadLocal = new ThreadLocalIC(this,1);
setSticky(threadLocal);
} else getSticky().incrementCount();
}
if (_logger.isLoggable(Level.FINE))
_logger.fine("SerialContext ==> doing lookup with " + this);
if (name.equals("")) {
resetSticky();
// Asking to look up this context itself. Create and return
// a new instance with its own independent environment.
return (new SerialContext(myName, myEnv));
}
name = getRelativeName(name);
if (_logger.isLoggable(Level.FINE))
_logger.fine("SerialContext ==> looking up : " + name);
try {
if (isjavaURL(name)) {
resetSticky();
return javaUrlContext.lookup(name);
} else {
Object obj = getProvider().lookup(name);
if(obj instanceof Context) {
resetSticky();
return new SerialContext(name, myEnv);
}
Object retObj =
javax.naming.spi.NamingManager.getObjectInstance(obj,
new CompositeName(name),
null, myEnv);
resetSticky();
return retObj;
}
} catch (NamingException nnfe) {
setSticky(null);
throw nnfe;
} catch (Exception ex) {
setSticky(null);
_logger.log(Level.SEVERE,
"enterprise_naming.serialctx_communication_exception",
ex);
//temp fix for 6320008
//this should be removed once we change the transient NS implementation to persistent
if (ex instanceof java.rmi.MarshalException &&
ex.getCause() instanceof org.omg.CORBA.COMM_FAILURE) {
provider = null;
_logger.fine("Resetting provider to NULL. Will get new obj ref for provider since previous obj ref was stale...");
return lookup(name);
} else {
CommunicationException ce =
new CommunicationException("serial context communication ex");
ce.initCause(ex);
throw ce;
}
}
}
/**
* Lookup the specifed name in the context.
* Returns the resolved object.
* @return the resolved object.
* @exception NamingException if there is a naming exception.
*/
public Object lookup(Name name) throws NamingException {
// Flat namespace; no federation; just call string version
return lookup(name.toString());
}
/**
* Bind the object to the specified name.
* @param the name that the object is being bound to.
* @param the object that is being bound.
* @exception NamingException if there is a naming exception.
*/
public void bind(String name, Object obj) throws NamingException {
name = getRelativeName(name);
if (isjavaURL(name)) {
javaUrlContext.bind(name, obj);
} else {
try {
getProvider().bind(name, obj);
} catch (RemoteException ex) {
throw new CommunicationException(ex.toString());
}
}
}
/**
* Bind the object to the specified name.
* @param the name that the object is being bound to.
* @param the object that is being bound.
* @exception NamingException if there is a naming exception.
*/
public void bind(Name name, Object obj) throws NamingException {
// Flat namespace; no federation; just call string version
bind(name.toString(), obj);
}
/**
* Rebind the object to the specified name.
* @param the name that the object is being bound to.
* @param the object that is being bound.
* @exception NamingException if there is a naming exception.
*/
public void rebind(String name, Object obj) throws NamingException {
name = getRelativeName(name);
if (isjavaURL(name)) {
javaUrlContext.rebind(name, obj);
} else {
try {
getProvider().rebind(name, obj);
} catch (RemoteException ex) {
throw new CommunicationException(ex.toString());
}
}
}
/**
* Rebind the object to the specified name.
* @param the name that the object is being bound to.
* @param the object that is being bound.
* @exception NamingException if there is a naming exception.
*/
public void rebind(Name name, Object obj) throws NamingException {
// Flat namespace; no federation; just call string version
rebind(name.toString(), obj);
}
/**
* Unbind the object with the specified name.
* @param the name that is being unbound.
* @exception NamingException if there is a naming exception.
*/
public void unbind(String name) throws NamingException {
name = getRelativeName(name);
if (isjavaURL(name)) {
javaUrlContext.unbind(name);
} else {
try {
getProvider().unbind(name);
} catch (RemoteException ex) {
throw new CommunicationException(ex.toString());
}
}
}
/**
* Unbind the object with the specified name.
* @param the name that is being unbound.
* @exception NamingException if there is a naming exception.
*/
public void unbind(Name name) throws NamingException {
// Flat namespace; no federation; just call string version
unbind(name.toString());
}
/**
* Rename the bound object.
* @param the old name that the object is bound as.
* @param the new name that the object will be bound as.
* @exception NamingException if there is a naming exception.
*/
public void rename(String oldname, String newname) throws NamingException {
oldname = getRelativeName(oldname);
newname = getRelativeName(newname);
if (isjavaURL(oldname)) {
javaUrlContext.rename(oldname, newname);
} else {
try {
getProvider().rename(oldname, newname);
} catch (RemoteException ex) {
throw new CommunicationException(ex.toString());
}
}
}
/**
* Rename the bound object.
* @param the old name that the object is bound as.
* @param the new name that the object will be bound as.
* @exception NamingException if there is a naming exception.
*/
public void rename(Name oldname, Name newname)
throws NamingException {
// Flat namespace; no federation; just call string version
rename(oldname.toString(), newname.toString());
}
/**
* List the contents of the specified context.
* @return an enumeration of the contents.
* @param the context name.
* @exception NamingException if there is a naming exception.
*/
public NamingEnumeration list(String name) throws NamingException {
if (name.equals("")) {
// listing this context
try {
Hashtable bindings = getProvider().list(myName);
return new RepNames(bindings);
} catch (RemoteException ex) {
throw new CommunicationException(ex.toString());
}
}
name = getRelativeName(name);
if (isjavaURL(name)) {
return javaUrlContext.list(name);
} else {
// Perhaps 'name' names a context
Object target = lookup(name);
if (target instanceof Context) {
return ((Context)target).list("");
}
throw new NotContextException(name + " cannot be listed");
}
}
/**
* List the contents of the specified context.
* @return an enumeration of the contents.
* @param the context name.
* @exception NamingException if there is a naming exception.
*/
public NamingEnumeration list(Name name)
throws NamingException {
// Flat namespace; no federation; just call string version
return list(name.toString());
}
/**
* List the bindings in the specified context.
* @return an enumeration of the bindings.
* @param the context name.
* @exception NamingException if there is a naming exception.
*/
public NamingEnumeration listBindings(String name)
throws NamingException {
if (name.equals("")) {
// listing this context
try {
Hashtable bindings = getProvider().list(myName);
return new RepBindings(bindings);
} catch (RemoteException ex) {
CommunicationException ce =
new CommunicationException(ex.toString());
ce.initCause(ex);
throw ce;
}
}
name = getRelativeName(name);
if (isjavaURL(name)) {
return javaUrlContext.listBindings(name);
} else {
// Perhaps 'name' names a context
Object target = lookup(name);
if (target instanceof Context) {
return ((Context)target).listBindings("");
}
throw new NotContextException(name + " cannot be listed");
}
}
/**
* List the bindings in the specified context.
* @return an enumeration of the bindings.
* @param the context name.
* @exception NamingException if there is a naming exception.
*/
public NamingEnumeration listBindings(Name name)
throws NamingException {
// Flat namespace; no federation; just call string version
return listBindings(name.toString());
}
/**
* Destroy the specified subcontext.
* @param the name of the subcontext.
* @exception NamingException if there is a naming exception.
*/
public void destroySubcontext(String name) throws NamingException {
name = getRelativeName (name);
if (isjavaURL(name)) {
javaUrlContext.destroySubcontext(name);
} else {
try {
getProvider().destroySubcontext(name);
} catch(RemoteException e) {
CommunicationException ce =
new CommunicationException(e.toString());
ce.initCause(e);
throw ce;
}
}
}
/**
* Destroy the specified subcontext.
* @param the name of the subcontext.
* @exception NamingException if there is a naming exception.
*/
public void destroySubcontext(Name name) throws NamingException {
// Flat namespace; no federation; just call string version
destroySubcontext(name.toString());
}
/**
* Create the specified subcontext.
* @return the created subcontext.
* @param the name of the subcontext.
* @exception NamingException if there is a naming exception.
*/
public Context createSubcontext(String name)
throws NamingException {
Context c = null;
name = getRelativeName (name);
if (isjavaURL(name)) {
return javaUrlContext.createSubcontext(name);
} else {
try {
c = getProvider().createSubcontext(name);
/* this simulates the transient context structure on the
* client side. Have to do this - as reference to
* Transient Context is not resolved properly due to rmi
*/
if (c instanceof Context){
c = new SerialContext (name, myEnv);
}
} catch(RemoteException e) {
CommunicationException ce =
new CommunicationException(e.toString());
ce.initCause(e);
throw ce;
}
return c;
}
}
/**
* Create the specified subcontext.
* @return the created subcontext.
* @param the name of the subcontext.
* @exception NamingException if there is a naming exception.
*/
public Context createSubcontext(Name name) throws NamingException {
// Flat namespace; no federation; just call string version
return createSubcontext(name.toString());
}
/**
* Links are not treated specially.
* @param the name of the link.
* @return the resolved object.
* @exception NamingException if there is a naming exception.
*/
public Object lookupLink(String name) throws NamingException {
name = getRelativeName(name);
if (isjavaURL(name)) {
return javaUrlContext.lookupLink(name);
} else {
// This flat context does not treat links specially
return lookup(name);
}
}
/**
* Links are not treated specially.
* @param the name of the link.
* @return the resolved object.
* @exception NamingException if there is a naming exception.
*/
public Object lookupLink(Name name) throws NamingException {
// Flat namespace; no federation; just call string version
return lookupLink(name.toString());
}
/**
* Allow access to the name parser object.
* @param String JNDI name, is ignored since there is only one Name
* Parser object.
* @exception NamingException
* @return NameParser object
*/
public NameParser getNameParser(String name)
throws NamingException {
return myParser;
}
/**
* Allow access to the name parser object.
* @param String JNDI name, is ignored since there is only one Name
* Parser object.
* @exception NamingException
* @return NameParser object
*/
public NameParser getNameParser(Name name) throws NamingException {
// Flat namespace; no federation; just call string version
return getNameParser(name.toString());
}
public String composeName(String name, String prefix)
throws NamingException {
Name result = composeName(new CompositeName(name),
new CompositeName(prefix));
return result.toString();
}
public Name composeName(Name name, Name prefix)
throws NamingException {
Name result = (Name)(prefix.clone());
result.addAll(name);
return result;
}
/**
* Add to the environment for the current context.
* @exception NamingException if there is a naming exception.
*/
public Object addToEnvironment(String propName, Object propVal)
throws NamingException {
if (myEnv == null) {
myEnv = new Hashtable(5, 0.75f);
}
return myEnv.put(propName, propVal);
}
/**
* Remove from the environment for the current context.
* @exception NamingException if there is a naming exception.
*/
public Object removeFromEnvironment(String propName)
throws NamingException {
if (myEnv == null) {
return null;
}
return myEnv.remove(propName);
}
/**
* Return the environment for the current context.
* @exception NamingException if there is a naming exception.
*/
public Hashtable getEnvironment() throws NamingException {
if (myEnv == null) {
// Must return non-null
myEnv = new Hashtable(3, 0.75f);
}
return myEnv;
}
/**
* Set the environment for the current context to null when close is
* called.
* @exception NamingException if there is a naming exception.
*/
public void close() throws NamingException {
myEnv = null;
}
private String getRelativeName(String name) {
if(!myName.equals("")) {
name = myName + "/" + name;
}
return name;
}
// Class for enumerating name/class pairs
class RepNames implements NamingEnumeration {
Hashtable bindings;
Enumeration names;
RepNames (Hashtable bindings) {
this.bindings = bindings;
this.names = bindings.keys();
}
public boolean hasMoreElements() {
return names.hasMoreElements();
}
public boolean hasMore() throws NamingException {
return hasMoreElements();
}
public Object nextElement() {
if(names.hasMoreElements())
{
String name = (String)names.nextElement();
String className = bindings.get(name).getClass().getName();
return new NameClassPair(name, className);
}
else
return null;
}
public Object next() throws NamingException {
return nextElement();
}
// New API for JNDI 1.2
public void close() throws NamingException {
throw new OperationNotSupportedException("close() not implemented");
}
}
// Class for enumerating bindings
class RepBindings implements NamingEnumeration {
Enumeration names;
Hashtable bindings;
RepBindings (Hashtable bindings) {
this.bindings = bindings;
this.names = bindings.keys();
}
public boolean hasMoreElements() {
return names.hasMoreElements();
}
public boolean hasMore() throws NamingException {
return hasMoreElements();
}
public Object nextElement() {
if(hasMoreElements())
{
String name = (String)names.nextElement();
return new Binding(name, bindings.get(name));
}
else
return null;
}
public Object next() throws NamingException {
return nextElement();
}
// New API for JNDI 1.2
public void close() throws NamingException {
throw new OperationNotSupportedException("close() not implemented");
}
}
/**
* This is a temporary solution to store
* the sticky context as a threadlocal variable. bug 5050591
* context is the sticky context
* count is needed to know how many times the lookup method is being called
* from within the user code's ic.lookup(). e.g. JMS resource lookups (via ConnectorObjectFactory)
*/
class ThreadLocalIC {
Context ctx;
int count = 0;
public ThreadLocalIC(Context ctxIn, int countIn) {
ctx = ctxIn;
count = countIn;
}
public void setStickyContext(Context ctxIn) {
ctx = ctxIn;
}
public Context getStickyContext() {
return ctx;
}
public void setStickyCount(int countIn) {
count = countIn;
}
public int getStickyCount() {
return count;
}
public void incrementCount() {
count++;
}
public void decrementCount() {
count--;
}
}
};
|
