/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2011 Oracle and/or its affiliates. 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_1_1.html
* or packager/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 packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [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 org.glassfish.enterprise.iiop.impl;
import com.sun.corba.ee.spi.ior.IOR;
import com.sun.corba.ee.spi.ior.ObjectKey;
import com.sun.corba.ee.spi.ior.TaggedProfile;
import com.sun.corba.ee.spi.oa.rfm.ReferenceFactory;
import java.rmi.Remote;
import java.rmi.RemoteException;
import org.glassfish.enterprise.iiop.api.ProtocolManager;
import org.glassfish.enterprise.iiop.api.RemoteReferenceFactory;
import org.glassfish.enterprise.iiop.spi.EjbContainerFacade;
import org.glassfish.enterprise.iiop.spi.EjbService;
import com.sun.enterprise.deployment.EjbDescriptor;
import com.sun.enterprise.util.Utility;
import javax.ejb.NoSuchObjectLocalException;
import javax.ejb.TransactionRolledbackLocalException;
import javax.ejb.TransactionRequiredLocalException;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.Servant;
import org.omg.CosNaming.NamingContext;
import org.omg.CosNaming.NamingContextHelper;
import org.omg.CosNaming.NameComponent;
import com.sun.corba.ee.spi.oa.rfm.ReferenceFactoryManager ;
import com.sun.corba.ee.spi.orb.ORB;
import com.sun.corba.ee.spi.presentation.rmi.PresentationManager;
import com.sun.corba.ee.spi.presentation.rmi.StubAdapter;
import com.sun.corba.ee.spi.orbutil.ORBConstants;
import com.sun.logging.LogDomains;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.rmi.CORBA.Tie;
import org.jvnet.hk2.annotations.Service;
import org.jvnet.hk2.component.Habitat;
import org.jvnet.hk2.annotations.Inject;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.INVALID_TRANSACTION;
import org.omg.CORBA.LocalObject;
import org.omg.CORBA.MARSHAL;
import org.omg.CORBA.NO_PERMISSION;
import org.omg.CORBA.OBJECT_NOT_EXIST;
import org.omg.CORBA.Policy;
import org.omg.CORBA.TRANSACTION_REQUIRED;
import org.omg.CORBA.TRANSACTION_ROLLEDBACK;
import org.omg.PortableServer.ForwardRequest;
import org.omg.PortableServer.ServantLocator;
import org.omg.PortableServer.ServantLocatorPackage.CookieHolder;
/**
* This class implements the ProtocolManager interface for the
* RMI/IIOP ORB with POA (Portable Object Adapter).
* Note that the POA is now accessed only through the
* ReferenceFactoryManager for EJB.
*
* @author Vivek Nagar
*/
@Service
public final class POAProtocolMgr extends org.omg.CORBA.LocalObject
implements ProtocolManager
{
private static final Logger _logger =
LogDomains.getLogger(POAProtocolMgr.class, LogDomains.CORBA_LOGGER);
private static final int MAPEXCEPTION_CODE = 9998;
private ORB orb;
private ReferenceFactoryManager rfm = null ;
private PresentationManager presentationMgr;
@Inject
private Habitat habitat;
public POAProtocolMgr() {}
@Override
public void initialize(org.omg.CORBA.ORB o) {
this.orb = (ORB)o;
this.presentationMgr = ORB.getPresentationManager();
}
// Called in all VMs, must be called only after InitialNaming is available
@Override
public void initializePOAs() throws Exception {
// NOTE: The RootPOA manager used to be activated here.
getRFM() ;
_logger.log(Level.FINE,
"POAProtocolMgr.initializePOAs: RFM resolved and activated");
}
private static class RemoteNamingServantLocator extends LocalObject
implements ServantLocator {
private final ORB orb ;
private final Servant servant ;
public RemoteNamingServantLocator( ORB orb, Remote impl ) {
this.orb = orb ;
Tie tie = ORB.getPresentationManager().getTie() ;
tie.setTarget( impl ) ;
servant = Servant.class.cast( tie ) ;
}
@Override
public synchronized Servant preinvoke( byte[] oid, POA adapter,
String operation, CookieHolder the_cookie ) throws ForwardRequest {
return servant ;
}
@Override
public void postinvoke( byte[] oid, POA adapter,
String operation, Object the_cookie, Servant the_servant ) {
}
}
private synchronized ReferenceFactoryManager getRFM() {
if (rfm == null) {
try {
rfm = ReferenceFactoryManager.class.cast(
orb.resolve_initial_references( "ReferenceFactoryManager" )) ;
rfm.activate() ;
} catch (Exception exc) {
// do nothing
}
}
return rfm ;
}
private org.omg.CORBA.Object getRemoteNamingReference( Remote remoteNamingProvider ) {
final ServantLocator locator = new RemoteNamingServantLocator( orb,
remoteNamingProvider ) ;
final PresentationManager pm = ORB.getPresentationManager() ;
String repositoryId ;
try {
repositoryId = pm.getRepositoryId( remoteNamingProvider ) ;
} catch (Exception exc) {
throw new RuntimeException( exc ) ;
}
final List<Policy> policies = new ArrayList<Policy>() ;
final ReferenceFactory rf = getRFM().create( "RemoteSerialContextProvider",
repositoryId, policies, locator ) ;
// arbitrary
final byte[] oid = { 0, 3, 5, 7, 2, 37, 42 } ;
final org.omg.CORBA.Object ref = rf.createReference( oid ) ;
return ref ;
}
@Override
public void initializeRemoteNaming(Remote remoteNamingProvider)
throws Exception {
try {
org.omg.CORBA.Object provider = getRemoteNamingReference( remoteNamingProvider ) ;
// put object in NameService
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
NamingContext ncRef = NamingContextHelper.narrow(objRef);
// XXX use constant for SerialContextProvider name
NameComponent nc = new NameComponent("SerialContextProvider", "");
NameComponent path[] = {nc};
ncRef.rebind(path, provider);
} catch (Exception ex) {
_logger.log(Level.SEVERE,
"enterprise_naming.excep_in_insertserialcontextprovider",ex);
RemoteException re = new RemoteException("initSerialCtxProvider error", ex);
throw re;
}
}
// Called only in J2EE Server VM
@Override
public void initializeNaming() throws Exception {
// NOTE: The TransientNameService reference is NOT HA.
// new TransientNameService((com.sun.corba.ee.spi.orb.ORB)orb);
// _logger.log(Level.FINE, "POAProtocolMgr.initializeNaming: complete");
}
/**
* Return a factory that can be used to create/destroy remote
* references for a particular EJB type.
* @param container The container to use
* @param remoteHomeView The remote home view
* @param id The object id
* @return the ref factory
*/
@Override
public RemoteReferenceFactory getRemoteReferenceFactory(
EjbContainerFacade container, boolean remoteHomeView, String id) {
RemoteReferenceFactory factory = new POARemoteReferenceFactory
(container, this, orb, remoteHomeView, id);
return factory;
}
/**
* Connect the RMI object to the protocol.
*/
@Override
public void connectObject(Remote remoteObj) throws RemoteException
{
StubAdapter.connect(remoteObj, orb);
}
@Override
public boolean isStub(Object obj) {
return StubAdapter.isStub(obj);
}
@Override
public boolean isLocal(Object obj) {
return StubAdapter.isLocal(obj);
}
@Override
public byte[] getObjectID(org.omg.CORBA.Object obj) {
IOR ior = ((com.sun.corba.ee.spi.orb.ORB)orb).getIOR(obj, false);
java.util.Iterator iter = ior.iterator();
byte[] oid = null;
if (iter.hasNext()) {
TaggedProfile profile = (TaggedProfile) iter.next();
ObjectKey objKey = profile.getObjectKey();
oid = objKey.getId().getId();
}
return oid;
}
/**
* Return true if the two object references refer to the same
* remote object.
*/
@Override
public boolean isIdentical(Remote obj1, Remote obj2) {
org.omg.CORBA.Object corbaObj1 = (org.omg.CORBA.Object)obj1;
org.omg.CORBA.Object corbaObj2 = (org.omg.CORBA.Object)obj2;
return corbaObj1._is_equivalent(corbaObj2);
}
@Override
public void validateTargetObjectInterfaces(Remote targetObj) {
if( targetObj != null ) {
// All Remote interfaces implemented by targetObj will be
// validated as a side-effect of calling setTarget().
// A runtime exception will be propagated if validation fails.
Tie tie = presentationMgr.getTie();
tie.setTarget(targetObj);
} else {
throw new IllegalArgumentException
("null passed to validateTargetObjectInterfaces");
}
}
/**
* Map the EJB/RMI exception to a protocol-specific (e.g. CORBA) exception
*/
@Override
public Throwable mapException(Throwable exception) {
boolean initCause = true;
Throwable mappedException = exception;
if ( exception instanceof java.rmi.NoSuchObjectException
|| exception instanceof NoSuchObjectLocalException )
{
mappedException = new OBJECT_NOT_EXIST(MAPEXCEPTION_CODE,
CompletionStatus.COMPLETED_MAYBE);
} else if ( exception instanceof java.rmi.AccessException
|| exception instanceof javax.ejb.AccessLocalException )
{
mappedException = new NO_PERMISSION(MAPEXCEPTION_CODE,
CompletionStatus.COMPLETED_MAYBE);
} else if ( exception instanceof java.rmi.MarshalException ) {
mappedException = new MARSHAL(MAPEXCEPTION_CODE,
CompletionStatus.COMPLETED_MAYBE);
} else if ( exception instanceof javax.transaction.TransactionRolledbackException
|| exception instanceof TransactionRolledbackLocalException )
{
mappedException = new TRANSACTION_ROLLEDBACK(MAPEXCEPTION_CODE,
CompletionStatus.COMPLETED_MAYBE);
} else if ( exception instanceof javax.transaction.TransactionRequiredException
|| exception instanceof TransactionRequiredLocalException )
{
mappedException = new TRANSACTION_REQUIRED(MAPEXCEPTION_CODE,
CompletionStatus.COMPLETED_MAYBE);
} else if ( exception instanceof javax.transaction.InvalidTransactionException ) {
mappedException = new INVALID_TRANSACTION(MAPEXCEPTION_CODE,
CompletionStatus.COMPLETED_MAYBE);
} else {
initCause = false;
}
if( initCause ) {
mappedException.initCause(exception);
}
return mappedException;
}
/**
* Called from SecurityMechanismSelector for each objref creation
*/
@Override
public EjbDescriptor getEjbDescriptor(byte[] ejbKey) {
EjbDescriptor result = null;
try {
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,
"POAProtocolMgr.getEjbDescriptor->: {0}", ejbKey);
}
if ( ejbKey.length < POARemoteReferenceFactory.EJBID_OFFSET + 8 ) {
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,
"POAProtocolMgr.getEjbDescriptor: {0}: {1} < {2}{3}",
new Object[]{ejbKey, ejbKey.length,
POARemoteReferenceFactory.EJBID_OFFSET, 8});
}
return null;
}
long ejbId = Utility.bytesToLong(ejbKey,
POARemoteReferenceFactory.EJBID_OFFSET);
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,
"POAProtocolMgr.getEjbDescriptor: {0}: ejbId: {1}",
new Object[]{ejbKey, ejbId});
}
EjbService ejbService = habitat.getByContract(EjbService.class);
result = ejbService.ejbIdToDescriptor(ejbId);
} finally {
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,
"POAProtocolMgr.getEjbDescriptor<-: {0}: {1}",
new Object[]{ejbKey, result});
}
}
return result;
}
}