NamingManagerImplpublic final class NamingManagerImpl extends Object implements NamingManager| This is the manager that handles all naming operations including
publishObject as well as binding environment props, resource and
ejb references in the namespace. |
| Fields Summary |
|---|
| static Logger | _logger | | public static final String | IIOPOBJECT_FACTORY | | public static final String | JAVA_COMP_STRING | | private static final String | CONTEXT_SEPARATOR | | private static final String | ID_SEPARATOR | | private static final int | UNKNOWN_COMPONENT | | private static final int | EJB_COMPONENT | | private static final int | WEB_COMPONENT | | private static final int | APP_CLIENT_COMPONENT | | private static LocalStringManagerImpl | localStrings | | private InitialContext | initialContext | | private InitialContext | cosContext | | private InvocationManager | im | | private Switch | theSwitch | | private NameParser | nameParser | | private Hashtable | namespaces | | public static final String | EIS_STRING | | private static final String | CORBANAME | | private static final String | IIOPURL |
| Constructors Summary |
|---|
public NamingManagerImpl()
this( new InitialContext() );
| public NamingManagerImpl(InitialContext ic)Create the naming manager. Creates a new initial context.
initialContext = ic;
namespaces = new Hashtable();
theSwitch = Switch.getSwitch();
im = theSwitch.getInvocationManager();
|
| Methods Summary |
|---|
| private void | bindIntermediateContexts(java.util.HashMap namespace, java.lang.String name)
// for each component of name, put an entry into namespace
name = name.substring("java:comp/".length());
StringTokenizer toks = new StringTokenizer(name, "/", false);
String partialName="java:comp";
while ( toks.hasMoreTokens() ) {
String tok = toks.nextToken();
partialName = partialName + "/" + tok;
if ( namespace.get(partialName) == null ) {
namespace.put(partialName, new javaURLContext(partialName, null));
}
}
| | public synchronized java.lang.String | bindObjects(JndiNameEnvironment env)This method enumerates the env properties, ejb and resource
references etc for a J2EE component and binds them in the component's
java:comp namespace.
This method is synchronized to avoid any possibility of concurrent
deployment-time calls.
String componentId = getMangledIdName(env);
// Note: HashMap is not synchronized. The namespace is populated
// at deployment time by a single thread, and then on there are
// no structural modifications (i.e. no keys added/removed).
// So the namespace doesnt need to be synchronized.
HashMap namespace = new HashMap();
namespaces.put(componentId, namespace);
// put entries for java:, java:comp and java:comp/env
namespace.put("java:", new javaURLContext("java:", null));
namespace.put("java:comp", new javaURLContext("java:comp", null));
namespace.put("java:comp/env", new javaURLContext("java:comp/env", null));
for (Iterator itr = env.getEnvironmentProperties().iterator();
itr.hasNext();) {
EnvironmentProperty next = (EnvironmentProperty) itr.next();
String logicalJndiName = descriptorToLogicalJndiName(next);
// Skip any env-entries that have not been assigned a value.
if( !next.hasAValue() ) {
continue;
}
Object valueObject = next.getValueObject();
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,localStrings.getLocalString("naming.bind",
"Binding name:{0}" , new Object[] {logicalJndiName}));
}
if (namespace.put(logicalJndiName, valueObject) != null) {
_logger.log(Level.WARNING,
localStrings.getLocalString("naming.alreadyexists",
"Reference name [{0}] already exists in {1}",
new Object[] {next.getName(), getApplicationName(env)}));
}
bindIntermediateContexts(namespace, logicalJndiName);
}
//JmsDestinationReferenceDescriptor actually represents all Admin objects.
for (Iterator itr = env.getJmsDestinationReferenceDescriptors().iterator();
itr.hasNext();) {
JmsDestinationReferenceDescriptor next =
(JmsDestinationReferenceDescriptor) itr.next();
String logicalJndiName = descriptorToLogicalJndiName(next);
String destinationName = next.getJndiName();
Object destinationObject = null;
if (next.isEJBContext()) {
// Need to delay ejb context lookup until runtime
destinationObject =
new J2EEEnvWrapper(next, J2EEEnvWrapper.EJB_CONTEXT);
} else {
try {
destinationObject = initialContext.lookup(destinationName);
}
catch(NamingException ne) {
_logger.log(Level.SEVERE,
"enterprise_naming.notfound_jmsdestination", destinationName);
_logger.log(Level.SEVERE, ne.getClass().getName(), ne);
// For embedded resource adapters, admin object can be
// created after deployment. Doesnt throw exception,
// because deployment/should succeed.
destinationObject = null;
}
if (destinationObject == null) {
destinationObject = new J2EEEnvWrapper (destinationName,
J2EEEnvWrapper.MUTABLE_RESOURCE_REF);
}
}
if( destinationObject instanceof javax.jms.Queue ) {
if( !next.getRefType().equals("javax.jms.Queue") &&
!next.getRefType().equals("javax.jms.Destination")) {
throw new InvalidNameException(localStrings.getLocalString("naming.destinationRefTypeMismatch", "", new Object[] {next.getName(), next.getRefType()}));
}
} else if( destinationObject instanceof javax.jms.Topic ) {
if( !next.getRefType().equals("javax.jms.Topic") &&
!next.getRefType().equals("javax.jms.Destination")) {
throw new InvalidNameException(localStrings.getLocalString("naming.destinationRefTypeMismatch", "", new Object[] {next.getName(), next.getRefType()}));
}
}
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,localStrings.getLocalString("naming.bind",
"Binding name:{0}" , new Object[] {logicalJndiName}));
}
if ( namespace.put(logicalJndiName, destinationObject) != null) {
_logger.log(Level.WARNING,
localStrings.getLocalString("naming.alreadyexists",
"Reference name [{0}] already exists in {1}",
new Object[] {next.getName(), getApplicationName(env)}));
}
bindIntermediateContexts(namespace, logicalJndiName);
}
for (Iterator itr = env.getEjbReferenceDescriptors().iterator();
itr.hasNext();) {
EjbReferenceDescriptor next = (EjbReferenceDescriptor) itr.next();
String logicalJndiName = descriptorToLogicalJndiName(next);
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,localStrings.getLocalString
("naming.bind", "Binding name:{0}",
new Object[] {logicalJndiName}));
}
Object home = null;
if ( next.isLocal() ) { // an ejb-local-ref
// Create EJB_LOCAL_REF wrapper. Actual ejb local ref
// lookup resolution is done lazily.
home = new J2EEEnvWrapper(next,J2EEEnvWrapper.EJBLOCAL_REF);
}
else { // an ejb-ref
home = new J2EEEnvWrapper(next, J2EEEnvWrapper.EJB_REF);
// We dont do a COSNaming lookup here because COSNaming lookup
// internally calls "is_a" on the EJB which causes problems
// if the EJB requires authentication.
}
if (namespace.put(logicalJndiName, home) != null) {
_logger.log(Level.WARNING,
localStrings.getLocalString("naming.alreadyexists",
"Reference name [{0}] already exists in {1}",
new Object[] {next.getName(), getApplicationName(env)}));
}
bindIntermediateContexts(namespace, logicalJndiName);
}
for (Iterator itr = env.getMessageDestinationReferenceDescriptors().
iterator(); itr.hasNext();) {
MessageDestinationReferenceDescriptor next =
(MessageDestinationReferenceDescriptor) itr.next();
String logicalJndiName = descriptorToLogicalJndiName(next);
String destinationName = null;
// when this message ref is linked to a logical destination
if( next.isLinkedToMessageDestination() ) {
destinationName =
next.getMessageDestination().getJndiName();
// when this message ref is to a physical destination
} else {
destinationName = next.getJndiName();
}
// if this message reference has been resolved
if (destinationName != null) {
_logger.fine("NamingManagerImpl : destinationName = "+ destinationName );
try {
Object adminObject =
initialContext.lookup(destinationName);
_logger.fine("NamingManagerImpl : binding " + logicalJndiName + " to " +adminObject);
_logger.log(Level.INFO, localStrings.getLocalString(
"naming.bind", "Binding name:`{0}`",
new Object[] {logicalJndiName}));
namespace.put(logicalJndiName, adminObject);
bindIntermediateContexts(namespace, logicalJndiName);
} catch(Exception e) {
String msg = localStrings.getLocalString
("naming.invalidDestination",
"Invalid Destination:`{0} for {1}`",
new Object[] {destinationName, logicalJndiName});
_logger.log(Level.SEVERE, "naming.invalidDestination",
new Object[] {destinationName, logicalJndiName});
NamingException ne = new NamingException();
ne.initCause(e);
throw ne;
}
} else {
String msg =
localStrings.getLocalString("naming.unresolvedmsgdestref",
"Message Destination Reference {0} has not been" +
" resolved",
new Object[] { logicalJndiName });
_logger.log(Level.SEVERE, "naming.unresolvedmsgdestref",
new Object[] {logicalJndiName});
throw new NamingException(msg);
}
}
for (Iterator itr = env.getResourceReferenceDescriptors().iterator();
itr.hasNext();) {
ResourceReferenceDescriptor next =
(ResourceReferenceDescriptor) itr.next();
next.checkType();
String logicalResRef = next.getName(); // "MyAccountBean"
String logicalJndiName = descriptorToLogicalJndiName(next);
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,localStrings.
getLocalString("naming.bind", "Binding name:{0}",
new Object[] {logicalJndiName}));
}
String resJndi = next.getJndiName();
if(resJndi == null || resJndi.equals("")) {
throw new InvalidNameException
("Real JNDI name cannot be " +
"empty for " + logicalResRef);
}
Object obj = null;
if (next.isMailResource()) {
obj = new J2EEEnvWrapper(resJndi, J2EEEnvWrapper.MAIL_REF);
}
else if (next.isURLResource()) {
String url = next.getJndiName();
try {
obj = new java.net.URL(url);
}
catch(MalformedURLException e) {
throw new InvalidNameException
(localStrings.getLocalString("naming.malformedURL",
"Malformed URL:'{0}'",
new Object[] {url}));
}
obj = new J2EEEnvWrapper(obj, J2EEEnvWrapper.MUTABLE);
}
//IMPORTANT!!! this needs to be before the test for JDBC as
//a connector could have a type of javax.sql.DataSource
//else if (next.isResourceConnectionFactory()) {
else if (isConnector(logicalJndiName)) {
obj = new J2EEEnvWrapper(resJndi,
J2EEEnvWrapper.RESOURCE_ADAPTER_REF);
}
// adding check for jdbc resource
// IMPORTANT!!! this needs to be after the test for connectors as
// a connector could have a type of javax.sql.DataSource
else if (next.isJDBCResource()) {
try {
Object res = initialContext.lookup(resJndi);
obj = new J2EEEnvWrapper(res, J2EEEnvWrapper.JDBC_REF);
} catch( NamingException ne ) {
String msg = localStrings.getLocalString
("naming.unresolved.warning", "",
new Object[] {logicalJndiName, resJndi});
_logger.log(Level.FINE,msg);
}
if ( obj == null ) { // perhaps the resource is not yet deployed
obj = new J2EEEnvWrapper(resJndi,
J2EEEnvWrapper.MUTABLE_RESOURCE_REF);
}
}
else if (next.isJMSConnectionFactory()) {
try {
Object res = initialContext.lookup(resJndi);
obj = new J2EEEnvWrapper(res, J2EEEnvWrapper.RESOURCE_ADAPTER);
} catch (NamingException ne) {
String msg = localStrings.getLocalString
("naming.unresolved.warning", "",
new Object[] {logicalJndiName, resJndi});
_logger.log(Level.FINE,msg);
}
if ( obj == null ) { // perhaps the resource is not yet deployed
obj = new J2EEEnvWrapper(resJndi,
J2EEEnvWrapper.MUTABLE_RESOURCE_REF);
}
}
else if (next.isORB()) {
_logger.fine(" we have an ORB resource " + next);
// Need to delay ejb context lookup until runtime
obj = new J2EEEnvWrapper(next, J2EEEnvWrapper.ORB_RESOURCE);
}
else if(next.isWebServiceContext()) {
Object wsc = new com.sun.enterprise.webservice.WebServiceContextImpl();
obj = new J2EEEnvWrapper(wsc, J2EEEnvWrapper.WEBSERVICE_CONTEXT);
}
else {
try {
// Find the actual object to which this reference is mapped
Object res = initialContext.lookup(resJndi);
obj = new J2EEEnvWrapper(res, J2EEEnvWrapper.MUTABLE);
}
catch( NamingException ne ) {
String msg = localStrings.getLocalString
("naming.unresolved.warning", "",
new Object[] {logicalJndiName, resJndi});
_logger.log(Level.FINE,msg);
// TN - allow unresolved reference at deployment time
}
if ( obj == null ) { // perhaps the resource is not yet deployed
obj = new J2EEEnvWrapper(resJndi,
J2EEEnvWrapper.MUTABLE_RESOURCE_REF);
}
}
// Add the resource to the component's local java:comp namespace
if ( namespace.put(logicalJndiName, obj) != null) {
_logger.log(Level.WARNING,
localStrings.getLocalString("naming.alreadyexists",
"Reference name [{0}] already exists in {1}",
new Object[] {next.getName(), getApplicationName(env)}));
}
bindIntermediateContexts(namespace, logicalJndiName);
}
for (Iterator itr = env.getServiceReferenceDescriptors().iterator();
itr.hasNext();) {
ServiceReferenceDescriptor next =
(ServiceReferenceDescriptor) itr.next();
if(next.getMappedName() != null) {
next.setName(next.getMappedName());
}
String logicalJndiName = descriptorToLogicalJndiName(next);
// Set WSDL File URL here if it null (happens during server restart)
if((next.getWsdlFileUrl() == null) &&
(next.getWsdlFileUri() != null)) {
try {
if(next.getWsdlFileUri().startsWith("http")) {
// HTTP URLs set as is
next.setWsdlFileUrl(new URL(next.getWsdlFileUri()));
} else if((new File(next.getWsdlFileUri())).isAbsolute()) {
// Absolute WSDL file paths set as is
next.setWsdlFileUrl((new File(next.getWsdlFileUri())).toURL());
} else {
// Relative WSDL file paths prefixed with module dir
BaseManager mgr=null;
if(next.getBundleDescriptor().getApplication().isVirtual()) {
ModuleType mType = next.getBundleDescriptor().getModuleType();
if(mType.equals(ModuleType.WAR)) {
mgr = DeploymentServiceUtils.getInstanceManager(DeployableObjectType.WEB);
} else if(mType.equals(ModuleType.EAR)) {
mgr = DeploymentServiceUtils.getInstanceManager(DeployableObjectType.APP);
} else if(mType.equals(ModuleType.EJB)) {
mgr = DeploymentServiceUtils.getInstanceManager(DeployableObjectType.EJB);
} else if(mType.equals(ModuleType.CAR)) {
mgr = DeploymentServiceUtils.getInstanceManager(DeployableObjectType.CAR);
}
String deployedDir =
mgr.getLocation(next.getBundleDescriptor().getApplication().getRegistrationName());
if(deployedDir != null) {
File fileURL;
if(next.getBundleDescriptor().getApplication().isVirtual()) {
fileURL = new File(deployedDir+File.separator+next.getWsdlFileUri());
} else {
fileURL = new File(deployedDir+File.separator+
next.getBundleDescriptor().getModuleDescriptor().getArchiveUri().replaceAll("\\.", "_") +
File.separator +next.getWsdlFileUri());
}
next.setWsdlFileUrl(fileURL.toURL());
}
}
}
} catch (Throwable mex) {
throw new NamingException(mex.getLocalizedMessage());
}
}
// Delay creation of service ref until access time
// to avoid classloading difficulties. (E.g. Setting
// up service-ref for web component requires classes
// that could be in .war or in .war's library jar.
// Better to let context classloader handle it later...)
Object serviceRefObject =
new J2EEEnvWrapper(next, J2EEEnvWrapper.SERVICE_REF);
_logger.log(Level.INFO, "naming.bind",
new Object[] {logicalJndiName});
namespace.put(logicalJndiName, serviceRefObject);
bindIntermediateContexts(namespace, logicalJndiName);
}
for (EntityManagerFactoryReferenceDescriptor next :
env.getEntityManagerFactoryReferenceDescriptors()) {
String logicalJndiName = descriptorToLogicalJndiName(next);
// Delay creation of actual object until lookup time.
Object factoryRefObject =
new J2EEEnvWrapper(next,
J2EEEnvWrapper.ENTITY_MANAGER_FACTORY_REF);
_logger.log(Level.INFO, "naming.bind",
new Object[] {logicalJndiName});
namespace.put(logicalJndiName, factoryRefObject);
bindIntermediateContexts(namespace, logicalJndiName);
}
for (EntityManagerReferenceDescriptor next :
env.getEntityManagerReferenceDescriptors()) {
String logicalJndiName = descriptorToLogicalJndiName(next);
// Delay creation of actual object until lookup time.
Object entityManagerRefObject =
new J2EEEnvWrapper(next, J2EEEnvWrapper.ENTITY_MANAGER_REF);
_logger.log(Level.INFO, "naming.bind",
new Object[] {logicalJndiName});
namespace.put(logicalJndiName, entityManagerRefObject);
bindIntermediateContexts(namespace, logicalJndiName);
}
return componentId;
| | private void | createSubContexts(javax.naming.Name name, javax.naming.Context rootCtx)Create any sub-contexts in name that don't already exist.
int numSubContexts = name.size() - 1;
Context currentCtx = rootCtx;
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,"Creating sub contexts for " + name);
}
for(int subCtxIndex = 0; subCtxIndex < numSubContexts; subCtxIndex++) {
String subCtxName = name.get(subCtxIndex);
try {
Object obj = currentCtx.lookup(subCtxName);
if( obj == null ) {
// @@@ thought it should throw NameNotFound when
// context doesn't exist...
if( _logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,"name == null");
}
// Doesn't exist so create it.
Context newCtx = currentCtx.createSubcontext(subCtxName);
currentCtx = newCtx;
}
else if( obj instanceof Context ) {
// OK -- no need to create it.
currentCtx = (Context) obj;
}
else {
// Context name clashes with existing object.
throw new NameAlreadyBoundException(subCtxName);
}
}
catch(NameNotFoundException e) {
_logger.log(Level.FINE,"name not found", e);
// Doesn't exist so create it.
Context newCtx = currentCtx.createSubcontext(subCtxName);
currentCtx = newCtx;
}
} // End for -- each sub-context
return;
| | private java.lang.String | descriptorToLogicalJndiName(Descriptor descriptor)Generate the name of an environment property in the java:comp/env
namespace. This is the lookup string used by a component to access
its environment.
return JAVA_COMP_STRING + descriptor.getName();
| | private java.lang.String | getApplicationName(JndiNameEnvironment env)
String appName = "";
int componentType = getComponentType(env);
String moduleName = "";
switch(componentType) {
case EJB_COMPONENT :
// EJB component
EjbDescriptor ejbEnv = (EjbDescriptor) env;
EjbBundleDescriptor ejbBundle = ejbEnv.getEjbBundleDescriptor();
appName = "ejb ["+
ejbEnv.getApplication().getRegistrationName();
moduleName = ejbEnv.getName();
if (moduleName == null || moduleName.equals("")) {
appName = appName+"]";
}
else {
appName = appName+":"+ejbEnv.getName()+"]";
}
break;
case WEB_COMPONENT :
WebBundleDescriptor webEnv = (WebBundleDescriptor) env;
appName = "web module ["+
webEnv.getApplication().getRegistrationName();
moduleName = webEnv.getContextRoot();
if (moduleName == null || moduleName.equals("")) {
appName = appName+"]";
}
else {
appName = appName+":"+webEnv.getContextRoot()+"]";
}
break;
case APP_CLIENT_COMPONENT :
ApplicationClientDescriptor appEnv =
(ApplicationClientDescriptor) env;
appName = "client ["+appEnv.getName() +
":" + appEnv.getMainClassName()+"]";
break;
}
return appName;
| | private java.lang.Object | getClientServiceObject(ServiceReferenceDescriptor desc)
Class serviceInterfaceClass = null;
Object returnObj = null;
WsUtil wsUtil = new WsUtil();
try {
WSContainerResolver.set(desc);
ClassLoader cl = Thread.currentThread().getContextClassLoader();
serviceInterfaceClass = cl.loadClass(desc.getServiceInterface());
resolvePortComponentLinks(desc);
Service serviceDelegate = null;
javax.xml.ws.Service jaxwsDelegate = null;
Object injValue = null;
if( desc.hasGeneratedServiceInterface() || desc.hasWsdlFile() ) {
String serviceImplName = desc.getServiceImplClassName();
if(serviceImplName != null) {
Class serviceImplClass = cl.loadClass(serviceImplName);
serviceDelegate = (Service) serviceImplClass.newInstance();
} else {
// The target is probably a post JAXRPC-1.1- based service;
// If Service Interface class is set, check if it is indeed a subclass of Service
// initiateInstance should not be called if the user has given javax.xml.ws.Service itself
// as the interface through DD
if(javax.xml.ws.Service.class.isAssignableFrom(serviceInterfaceClass) &&
!javax.xml.ws.Service.class.equals(serviceInterfaceClass)) {
// OK - the interface class is indeed the generated service class; get an instance
injValue = initiateInstance(serviceInterfaceClass, desc);
} else {
// First try failed; Try to get the Service class type from injected field name
// and from there try to get an instance of the service class
// I assume the at all inejction target are expecting the SAME service
// interface, therefore I take the first one.
if (desc.isInjectable()) {
InjectionTarget target = desc.getInjectionTargets().iterator().next();
Class serviceType = null;
if (target.isFieldInjectable()) {
java.lang.reflect.Field f = target.getField();
if(f == null) {
String fName = target.getFieldName();
Class targetClass = cl.loadClass(target.getClassName());
try {
f = targetClass.getDeclaredField(target.getFieldName());
} catch(java.lang.NoSuchFieldException nsfe) {}// ignoring exception
}
serviceType = f.getType();
}
if (target.isMethodInjectable()) {
Method m = target.getMethod();
if(m == null) {
String mName = target.getMethodName();
Class targetClass = cl.loadClass(target.getClassName());
try {
m = targetClass.getDeclaredMethod(target.getMethodName());
} catch(java.lang.NoSuchMethodException nsfe) {}// ignoring exception
}
if (m.getParameterTypes().length==1) {
serviceType = m.getParameterTypes()[0];
}
}
if (serviceType!=null){
Class loadedSvcClass = cl.loadClass(serviceType.getCanonicalName());
injValue = initiateInstance(loadedSvcClass, desc);
}
}
}
// Unable to get hold of generated service class -> try the Service.create avenue to get a Service
if(injValue == null) {
// Here create the service with WSDL (overridden wsdl if wsdl-override is present)
// so that JAXWS runtime uses this wsdl @ runtime
javax.xml.ws.Service svc =
javax.xml.ws.Service.create((new WsUtil()).privilegedGetServiceRefWsdl(desc),
desc.getServiceName());
jaxwsDelegate = new JAXWSServiceDelegate(desc, svc, cl);
}
}
if( desc.hasHandlers() ) {
// We need the service's ports to configure the
// handler chain (since service-ref handler chain can
// optionally specify handler-port association)
// so create a configured service and call getPorts
Service configuredService =
wsUtil.createConfiguredService(desc);
Iterator ports = configuredService.getPorts();
wsUtil.configureHandlerChain
(desc, serviceDelegate, ports, cl);
}
// check if this is a post 1.1 web service
if(javax.xml.ws.Service.class.isAssignableFrom(serviceInterfaceClass)) {
// This is a JAXWS based webservice client;
// process handlers and mtom setting
// moved test for handlers into wsUtil, in case
// we have to add system handler
javax.xml.ws.Service service =
(injValue != null ?
(javax.xml.ws.Service) injValue : jaxwsDelegate);
if (service != null) {
// Now configure client side handlers
wsUtil.configureJAXWSClientHandlers(service, desc);
}
// the requested resource is not the service but one of its port.
if (injValue!=null && desc.getInjectionTargetType()!=null) {
Class requestedPortType = service.getClass().getClassLoader().loadClass(desc.getInjectionTargetType());
injValue = service.getPort(requestedPortType);
}
}
} else {
// Generic service interface / no WSDL
QName serviceName = desc.getServiceName();
if( serviceName == null ) {
// ServiceFactory API requires a service-name.
// However, 109 does not allow getServiceName() to be
// called, so it's ok to use a dummy value.
serviceName = new QName("urn:noservice", "servicename");
}
ServiceFactory serviceFac = ServiceFactory.newInstance();
serviceDelegate = serviceFac.createService(serviceName);
}
// Create a proxy for the service object.
// Get a proxy only in jaxrpc case because in jaxws the service class is not
// an interface any more
InvocationHandler handler = null;
if(serviceDelegate != null) {
handler = new ServiceInvocationHandler(desc, serviceDelegate, cl);
returnObj = Proxy.newProxyInstance
(cl, new Class[] { serviceInterfaceClass }, handler);
} else if(jaxwsDelegate != null) {
returnObj = jaxwsDelegate;
} else if(injValue != null) {
returnObj = injValue;
}
} catch(PrivilegedActionException pae) {
_logger.log(Level.WARNING, "", pae);
NamingException ne = new NamingException();
ne.initCause(pae.getCause());
throw ne;
} catch(Exception e) {
_logger.log(Level.WARNING, "", e);
NamingException ne = new NamingException();
ne.initCause(e);
throw ne;
} finally {
WSContainerResolver.unset();
}
return returnObj;
| | private java.lang.String | getComponentId()Get the component id from the Invocation Manager.
String id = null;
ComponentInvocation ci = im.getCurrentInvocation();
if (ci == null) {
throw new NamingException("invocation exception ");
}
try {
Object containerContext = ci.getContainerContext();
if(containerContext == null) {
throw new NamingException("No container context");
}
if ( containerContext instanceof Container )
return ((Container)containerContext).getComponentId();
JndiNameEnvironment desc = (JndiNameEnvironment)
theSwitch.getDescriptorFor(containerContext);
id = getMangledIdName(desc);
} catch(InvocationException e) {
NamingException ine = new NamingException("invocation exception");
ine.initCause(e);
throw ine;
}
return id;
| | private int | getComponentType(JndiNameEnvironment env)
int componentType = UNKNOWN_COMPONENT;
if(env instanceof EjbDescriptor) {
componentType = EJB_COMPONENT;
} else if (env instanceof WebBundleDescriptor) {
componentType = WEB_COMPONENT;
} else if (env instanceof ApplicationClientDescriptor) {
componentType = APP_CLIENT_COMPONENT;
} else {
throw new IllegalArgumentException("Unknown component type" +
env);
}
return componentType;
| | private javax.naming.InitialContext | getCosContext()Get cosContext which is the root of the COSNaming namespace.
Setting java.naming.corba.orb is necessary to prevent the
COSNaming context from creating its own ORB instance.
if (cosContext == null) {
Hashtable cosNamingEnv = new Hashtable ();
cosNamingEnv.put("java.naming.factory.initial",
"com.sun.jndi.cosnaming.CNCtxFactory");
ORB orb = ORBManager.getORB();
cosNamingEnv.put("java.naming.corba.orb", orb);
cosContext = new InitialContext(cosNamingEnv);
}
return cosContext;
| | public javax.naming.Context | getInitialContext()Get the initial naming context.
return initialContext;
| | private java.lang.String | getMangledIdName(JndiNameEnvironment env)Generate a unique id name for each J2EE component.
String id = null;
int componentType = getComponentType(env);
switch(componentType) {
case EJB_COMPONENT :
// EJB component
EjbDescriptor ejbEnv = (EjbDescriptor) env;
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,
"Application:" + ejbEnv.getApplication());
}
// Make jndi name flat so it won't result in the creation of
// a bunch of sub-contexts.
String flattedJndiName = ejbEnv.getJndiName().replace('/", '.");
EjbBundleDescriptor ejbBundle = ejbEnv.getEjbBundleDescriptor();
id = ejbEnv.getApplication().getName() + ID_SEPARATOR +
ejbBundle.getModuleDescriptor().getArchiveUri()
+ ID_SEPARATOR +
ejbEnv.getName() + ID_SEPARATOR + flattedJndiName +
ejbEnv.getUniqueId();
break;
case WEB_COMPONENT :
WebBundleDescriptor webEnv = (WebBundleDescriptor) env;
id = webEnv.getApplication().getName() + ID_SEPARATOR +
webEnv.getContextRoot();
break;
case APP_CLIENT_COMPONENT :
ApplicationClientDescriptor appEnv =
(ApplicationClientDescriptor) env;
id = "client" + ID_SEPARATOR + appEnv.getName() +
ID_SEPARATOR + appEnv.getMainClassName();
break;
}
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "Component Id: " + id);
}
return id;
| | public javax.naming.NameParser | getNameParser()
return nameParser;
| | private java.lang.Object | initiateInstance(java.lang.Class svcClass, ServiceReferenceDescriptor desc)
java.lang.reflect.Constructor cons = svcClass.getConstructor(new Class[]{java.net.URL.class,
javax.xml.namespace.QName.class});
com.sun.enterprise.webservice.ServiceRefDescUtil descUtil =
new com.sun.enterprise.webservice.ServiceRefDescUtil();
descUtil.preServiceCreate(desc);
WsUtil wsu = new WsUtil();
URL wsdlFile = wsu.privilegedGetServiceRefWsdl(desc);
// Check if there is a catalog for this web service client
// If so resolve the catalog entry
String genXmlDir;
if(desc.getBundleDescriptor().getApplication() != null) {
genXmlDir = desc.getBundleDescriptor().getApplication().getGeneratedXMLDirectory();
if(!desc.getBundleDescriptor().getApplication().isVirtual()) {
String subDirName = desc.getBundleDescriptor().getModuleDescriptor().getArchiveUri();
genXmlDir += (File.separator+subDirName.replaceAll("\\.", "_"));
}
} else {
// this is the case of an appclient being run as class file from command line
genXmlDir = desc.getBundleDescriptor().getModuleDescriptor().getArchiveUri();
}
File catalogFile = new File(genXmlDir,
desc.getBundleDescriptor().getDeploymentDescriptorDir() +
File.separator + "jax-ws-catalog.xml");
if(catalogFile.exists()) {
wsdlFile = wsu.resolveCatalog(catalogFile, desc.getWsdlFileUri(), null);
}
Object obj =
cons.newInstance(wsdlFile, desc.getServiceName());
descUtil.postServiceCreate();
return obj;
| | private boolean | isCOSNamingObj(java.lang.Object obj)
return ((obj instanceof java.rmi.Remote) ||
(obj instanceof org.omg.CORBA.Object));
| | private boolean | isConnector(java.lang.String logicalJndiName)
return (logicalJndiName.indexOf(EIS_STRING)!=-1);
| | public javax.naming.NamingEnumeration | list(java.lang.String name)
ArrayList list = listNames(name);
return new NamePairsEnum(this, list.iterator());
| | public javax.naming.NamingEnumeration | listBindings(java.lang.String name)
ArrayList list = listNames(name);
return new BindingsEnum(this, list.iterator());
| | private java.util.ArrayList | listNames(java.lang.String name)
// Get the component id and namespace to lookup
String componentId = getComponentId();
HashMap namespace = (HashMap)namespaces.get(componentId);
Object obj = namespace.get(name);
if ( obj == null )
throw new NameNotFoundException("No object bound to name " + name);
if ( !(obj instanceof javaURLContext) )
throw new NotContextException(name + " cannot be listed");
// This iterates over all names in entire component namespace,
// so its a little inefficient. The alternative is to store
// a list of bindings in each javaURLContext instance.
ArrayList list = new ArrayList();
Iterator itr = namespace.keySet().iterator();
if ( !name.endsWith("/") )
name = name + "/";
while ( itr.hasNext() ) {
String key = (String)itr.next();
// Check if key begins with name and has only 1 component extra
// (i.e. no more slashes)
if ( key.startsWith(name)
&& key.indexOf('/", name.length()) == -1 )
list.add(key);
}
return list;
| | public java.lang.Object | lookup(java.lang.String name)
return lookup(name, null);
| | public java.lang.Object | lookup(java.lang.String name, SerialContext serialContext)This method is called from SerialContext class.
The serialContext instance that was created by the appclient's
Main class is passed so that stickiness is preserved.
Called from javaURLContext.lookup, for java:comp names.
_logger.fine("serialcontext in NamingManagerImpl.." + serialContext);
Context ic = null;
if (serialContext != null) {
ic = serialContext;
} else {
ic = initialContext;
}
//initialContext is used as ic in case of PE while
//serialContext is used as ic in case of EE/SE
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"NamingManagerImpl : looking up name : " + name);
// Get the component id and namespace to lookup
String componentId = getComponentId();
HashMap namespace = (HashMap)namespaces.get(componentId);
Object obj = namespace.get(name);
if ( obj == null )
throw new NameNotFoundException("No object bound to name " + name);
if ( obj instanceof J2EEEnvWrapper ) {
J2EEEnvWrapper wr = (J2EEEnvWrapper)obj;
switch ( wr.type ) {
case J2EEEnvWrapper.MUTABLE:
// XXX is this copy necessary ?
obj= NamingUtils.makeCopyOfObject(wr.object);
break;
case J2EEEnvWrapper.JDBC_REF:
obj = wr.object;
break;
case J2EEEnvWrapper.MAIL_REF:
// MailConfiguration config = (MailConfiguration)wr.object;
String resJndi = (String)wr.object;
MailConfiguration config =
(MailConfiguration)ic.lookup(resJndi);
// Note: javax.mail.Session is not serializable,
// but we need to get a new instance on every lookup.
javax.mail.Session s = javax.mail.Session.getInstance(
config.getMailProperties(), null);
s.setDebugOut(new PrintStream(new MailLogOutputStream()));
s.setDebug(true);
obj = s;
break;
case J2EEEnvWrapper.ORB_RESOURCE:
ResourceReferenceDescriptor resRef =
(ResourceReferenceDescriptor) wr.object;
if (resRef.getSharingScope().equals(
ResourceReferenceDescriptor.RESOURCE_SHAREABLE)) {
//jndi name is java:comp/ORB
_logger.fine("ORB resource is shareable" + resRef.getJndiName());
obj = ic.lookup(resRef.getJndiName());
} else {
//init a new ORB with empty args and an empty Properties obj
obj = ORB.init(new String[]{}, new Properties());
_logger.fine("ORB resource is unshareable" + obj);
}
break;
case J2EEEnvWrapper.EJB_REF:
// Lookup the target bean's EJBHome ref using JNDI name.
// If the string is a "corbaname:...." URL
// the lookup happens thru the corbanameURL context,
// else it happens thru the COSNaming context.
// if ic is equal to initialContext then we are in
//PE environment
// else we should use sticky serialContext's private
//field cosContext which is an IC pointing to that
//specific orb's CosNaming Service.
/* MEJB lookup involved one more level of indirection
* hence, the following check.
* if name starts with corbaname: then use the
* initialcontext pointing to CosNaming Service
* (sticky or local)
* else use sticky SerialContext or InitialContext
* that is set in NamingManagerImpl()
*/
EjbReferenceDescriptor remoteEjbRef =
(EjbReferenceDescriptor) wr.object;
// Get actual jndi-name from ejb module.
String remoteJndiName =
EJBUtils.getRemoteEjbJndiName(remoteEjbRef);
if( _logger.isLoggable(Level.FINE) ) {
_logger.fine("EJB_REF..." + remoteEjbRef);
}
if (remoteJndiName.startsWith(CORBANAME)) {
ORB orb = ORBManager.getORB();
obj = (Object) orb.string_to_object(remoteJndiName);
} else {
if (remoteJndiName.startsWith(IIOPURL)) {
Properties env = new Properties();
env.put("java.naming.corba.orb",ORBManager.getORB());
Context ctx = new InitialContext(env);
obj = ctx.lookup(remoteJndiName);
} else {
obj = ic.lookup(remoteJndiName);
}
}
obj = EJBUtils.resolveEjbRefObject(remoteEjbRef, obj);
//if serialContext is null, no loadbalancing is
//happening. So cache the ref obj. else dont,
//inorder to do load balancing
if (serialContext == null) {
if( EJBUtils.isEjbRefCacheable(remoteEjbRef) ) {
namespace.put(name, obj);
}
}
break;
case J2EEEnvWrapper.EJBLOCAL_REF:
EjbReferenceDescriptor localEjbRef =
(EjbReferenceDescriptor) wr.object;
// @@@ revisit api
obj = EJBUtils.resolveEjbRefObject(localEjbRef, null);
// No need to check load-balancing when determining whether
// to cache ejb-local-ref object b/c ejb local-refs are
// only available to components running within the server.
// However, still need to check with ejb module to determine
// whether the ref itself is cacheable.
if( EJBUtils.isEjbRefCacheable(localEjbRef) ) {
namespace.put(name, obj);
}
break;
case J2EEEnvWrapper.EJB_CONTEXT:
JmsDestinationReferenceDescriptor jmsRef =
(JmsDestinationReferenceDescriptor) wr.object;
// Get current ejb context. This should never be cached
// within the namespace.
obj = Switch.getSwitch().getContainerFactory().
getEJBContextObject(jmsRef.getRefType());
break;
case J2EEEnvWrapper.MUTABLE_RESOURCE_REF:
// lookup resource using JNDI name
obj = ic.lookup((String)wr.object);
// replace wr with a MUTABLE wrapper for future lookups.
// Note: this is not a structural modification,
// so no synchronization needed.
wr = new J2EEEnvWrapper(obj, J2EEEnvWrapper.MUTABLE);
//if serialContext is null, no loadbalancing is
//happening. So cache the ref obj. else dont,
//in order to do load balancing
if (serialContext == null) {
namespace.put(name, wr);
}
break;
case J2EEEnvWrapper.RESOURCE_ADAPTER:
obj=wr.object;
break;
case J2EEEnvWrapper.RESOURCE_ADAPTER_REF:
// lookup resource using JNDI name
obj = ic.lookup((String)wr.object);
break;
case J2EEEnvWrapper.SERVICE_REF :
ServiceReferenceDescriptor desc =
(ServiceReferenceDescriptor) wr.object;
obj = getClientServiceObject(desc);
// Replace wrapper with actual service ref object
namespace.put(name, obj);
break;
case J2EEEnvWrapper.ENTITY_MANAGER_FACTORY_REF :
EntityManagerFactoryReferenceDescriptor emfRefDesc =
(EntityManagerFactoryReferenceDescriptor) wr.object;
obj = new EntityManagerFactoryWrapper(emfRefDesc);
// Do not cache resulting object so that each lookup
// will create a new wrapper object.
break;
case J2EEEnvWrapper.ENTITY_MANAGER_REF :
EntityManagerReferenceDescriptor emRefDesc =
(EntityManagerReferenceDescriptor) wr.object;
obj = new EntityManagerWrapper(emRefDesc);
// Do not cache resulting object so that each lookup
// will create a new wrapper object.
break;
case J2EEEnvWrapper.WEBSERVICE_CONTEXT :
// lookup resource using JNDI name; if not present
obj = wr.object;
break;
}
}
if (obj instanceof com.sun.enterprise.naming.java.javaURLContext) {
if (serialContext != null) {
//in EE mode
return ((com.sun.enterprise.naming.java.javaURLContext)obj).addStickyContext(serialContext);
}
}
return obj;
| | public void | publishObject(java.lang.String name, java.lang.Object obj, boolean rebind)Publish a name in the naming service.
Name nameobj = new CompositeName(name);
publishObject(nameobj, obj, rebind);
| | public void | publishObject(javax.naming.Name name, java.lang.Object obj, boolean rebind)Publish a name in the naming service.
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,"Publish object " + obj + " using name " + name);
}
Object serialObj = obj;
if ( isCOSNamingObj( obj ) ) {
// Create any COS naming sub-contexts in name
// that don't already exist.
createSubContexts( name, getCosContext() );
if( rebind ) {
getCosContext().rebind(name, obj);
}
else {
getCosContext().bind(name, obj);
}
// Bind a reference to it in the SerialContext using
// the same name. This is needed to allow standalone clients
// to lookup the object using the same JNDI name.
// It is also used from bindObjects while populating ejb-refs in
// the java:comp namespace.
serialObj = new Reference("reference",
new StringRefAddr("url", name.toString()),
IIOPOBJECT_FACTORY, null);
} // End if -- CORBA object
if( rebind ) {
initialContext.rebind(name, serialObj);
}
else {
initialContext.bind(name, serialObj);
}
| | private void | resolvePortComponentLinks(ServiceReferenceDescriptor desc)
// Resolve port component links to target endpoint address.
// We can't assume web service client is running in same VM
// as endpoint in the intra-app case because of app clients.
//
// Also set port-qname based on linked port's qname if not
// already set.
for(Iterator iter = desc.getPortsInfo().iterator(); iter.hasNext();) {
ServiceRefPortInfo portInfo = (ServiceRefPortInfo) iter.next();
if( portInfo.isLinkedToPortComponent() ) {
WebServiceEndpoint linkedPortComponent =
portInfo.getPortComponentLink();
// XXX-JD we could at this point try to figure out the
// endpoint-address from the ejb wsdl file but it is a
// little complicated so I will leave it for post Beta2
if( !(portInfo.hasWsdlPort()) ) {
portInfo.setWsdlPort(linkedPortComponent.getWsdlPort());
}
}
}
| | public javax.naming.Context | restoreJavaCompEnvContext(java.lang.String contextName)Recreate a context for java:comp/env or one of its sub-contexts given
the context name.
if( !contextName.startsWith("java:" ) ) {
throw new NamingException("Invalid context name [" + contextName
+ "]. Name must start with java:");
}
return new javaURLContext(contextName, null);
| | public void | unbindObjects(JndiNameEnvironment env)This method enumerates the env properties, ejb and resource
references and unbinds them from the java:comp namespace.
String componentId = getMangledIdName(env);
namespaces.remove(componentId); // remove local namespace cache
| | public void | unpublishObject(java.lang.String name)Remove an object from the naming service.
Object obj = initialContext.lookup(name);
if ( isCOSNamingObj( obj ) ) {
getCosContext().unbind(name);
}
initialContext.unbind(name);
// XXX Clean up sub-contexts???
| | public void | unpublishObject(javax.naming.Name name)Remove an object from the naming service.
this.unpublishObject(name.toString());
|
|
