JSessionRemote.java

package org.objectweb.jonas_ejb.container;

import java.rmi.Remote;
import java.rmi.RemoteException;

import javax.ejb.EJBHome;
import javax.ejb.EJBObject;
import javax.ejb.Handle;
import javax.ejb.RemoveException;
import javax.rmi.PortableRemoteObject;

import org.objectweb.carol.rmi.exception.RmiUtility;
import org.objectweb.carol.util.configuration.CarolCurrentConfiguration;

import org.objectweb.jonas_ejb.lib.EJBInvocation;
import org.objectweb.jonas_ejb.svc.JHandleIIOP;

import org.objectweb.util.monolog.api.BasicLevel;

public abstract class JSessionRemote extends JRemote implements Remote {


    protected JSessionSwitch bs;

    public JSessionRemote(JSessionFactory bf) throws RemoteException {
        super((JFactory) bf);
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
    }

    // --------------------------------------------------------------------------
    // EJBObject implementation
    // remove() is implemented in the generated part.
    // --------------------------------------------------------------------------

    public abstract void remove() throws RemoteException, RemoveException;

    public EJBHome getEJBHome() {
        /*
         * try/catch block is commented because the encapsulated code don't
         * throw a RemoteException
         * If the code changes and throws a such exception, let's think
         * to uncomment it
         *
         * try {
         */

        return bf.getHome();

        /*
         * } catch (RemoteException e) {
         * // check if rmi exception mapping is needed - if yes the method  rethrows it
         * RmiUtility.rethrowRmiException(e);
         * // if not, throws the exception just as it is
         * throw e;
         * }
         */

    }

    public Object getPrimaryKey() throws RemoteException {

        try {
            throw new RemoteException("Session bean has no primary key");
        } catch (RemoteException e) {
            // check if rmi exception mapping is needed - if yes the method rethrows it
            RmiUtility.rethrowRmiException(e);
            // if not, throws the exception just as it is
            throw e;
            }
    }

    public boolean isIdentical(EJBObject obj) throws RemoteException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        try {
        boolean ret = false;
            JSessionFactory sf = (JSessionFactory) bf;
            if (sf.isStateful()) {
                // For stateful sessions, just compare both objects.
                if (obj != null) {
                    ret = ((obj.equals(PortableRemoteObject.toStub(this))) || (obj.equals(this)));
                }
            } else {
                // In case of Stateless session bean, we must compare the 2 Home
                // We cannot cast the remote EJBObject cbecause it's a stub.
                String myhome = getEJBHome().getEJBMetaData().getHomeInterfaceClass().getName();
                if (obj != null) {
                    ret = obj.getEJBHome().getEJBMetaData().getHomeInterfaceClass().getName().equals(myhome);
                }
            }
            return ret;
        } catch (RemoteException e) {
            // check if rmi exception mapping is needed - if yes the method
            // rethrows it
            RmiUtility.rethrowRmiException(e);
            // if not, throws the exception just as it is
            throw e;
        }
    }

    public Handle getHandle() throws RemoteException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");

        /*
         * try/catch block is commented because the encapsulated code don't
         * throw a RemoteException
         * If the code changes and throws a such exception, let's think
         * to uncomment it
         *
         * try {
         */
        // for iiop, a specific interoperable Handle is created with the use of
        // HandleDelegate
        String protocol = CarolCurrentConfiguration.getCurrent().getCurrentRMIName();
        TraceEjb.interp.log(BasicLevel.DEBUG, "Current protocol=" + protocol);

        if (protocol.equals("iiop")) {
            return new JHandleIIOP(this);
        } else {
            return new JSessionHandle(this);
        }

        /*
         * } catch (RemoteException e) {
         * // check if rmi exception mapping is needed - if yes the method  rethrows it
         * RmiUtility.rethrowRmiException(e);
         * // if not, throws the exception just as it is
         * throw e;
         * }
         */

    }

    // ---------------------------------------------------------------
    // other public methods, for internal use.
    // ---------------------------------------------------------------

    public void setSessionSwitch(JSessionSwitch bs) {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        this.bs = bs;
    }

    public JSessionSwitch getSessionSwitch() {
        return bs;
    }

    public RequestCtx preInvoke(int txa) throws RemoteException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        RequestCtx rctx = bf.preInvokeRemote(txa);
        bs.setMustCommit(rctx.mustCommit); // for remove stateful session
        bs.enlistConnections(rctx.currTx); // Enlist connection list to tx
        return rctx;
    }

    public void checkSecurity(EJBInvocation ejbInv) {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        bf.checkSecurity(ejbInv);
    }

    public void postInvoke(RequestCtx rctx) throws RemoteException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        bs.delistConnections(rctx.currTx);
        // save current tx (for Bean Managed only)
        bs.saveBeanTx();
        try {
            bf.postInvokeRemote(rctx);
        } finally {
            if (rctx.sysExc != null) {
                bs.discardICtx(rctx.currTx);
            } else {
                bs.releaseICtx(rctx.currTx);
            }
        }
    }

}

---