JContext.java

package org.objectweb.jonas_ejb.container;

import java.security.Identity;
import java.security.Principal;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;

import javax.ejb.EJBContext;
import javax.ejb.EJBHome;
import javax.ejb.EJBLocalHome;
import javax.ejb.EnterpriseBean;
import javax.ejb.TimerService;
import javax.transaction.Status;
import javax.transaction.SystemException;
import javax.transaction.UserTransaction;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.objectweb.jonas_lib.deployment.api.SecurityRoleRefDesc;
import org.objectweb.jonas_lib.naming.ContainerNaming;
import org.objectweb.jonas.naming.NamingManager;
import org.objectweb.transaction.jta.TransactionManager;
import org.objectweb.util.monolog.api.BasicLevel;

public abstract class JContext implements EJBContext {

    protected EnterpriseBean instance = null;
    protected JFactory bf = null;
    protected JHome home = null;
    protected JLocalHome localhome = null;
    protected JContainer cont = null;
    protected TransactionManager tm = null;

    private PermissionManager permissionManager = null;

    
    int instanceState = 0;

    // ------------------------------------------------------------------
    // constructors
    // ------------------------------------------------------------------

    public JContext(JFactory bf, EnterpriseBean i) {
        this.bf = bf;
        this.instance = i;
        if (i == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "null EnterpriseBean!");
        }
        this.cont = bf.getContainer();
        this.tm = bf.getTransactionManager();
        this.permissionManager = cont.getPermissionManager();

    }

    public void setState(int newState) {
        instanceState = newState;
        TraceEjb.context.log(BasicLevel.DEBUG, "" + instanceState);
    }
    
    public int getState() {
        TraceEjb.context.log(BasicLevel.DEBUG, "" + instanceState);
        return instanceState;
    }
    
    // ------------------------------------------------------------------
    // EJBContext implementation
    // ------------------------------------------------------------------

    public Identity getCallerIdentity() {
        throw new RuntimeException ("getCallerIdentity() method deprecated. use instead getCallerPrincipal()");
    }


    public Principal getCallerPrincipal() throws IllegalStateException {

        if (getState() == 0) {
            throw new IllegalStateException("the instance is not allowed to call this method");
        }
        boolean inRunAs = false;
        if (bf.dd.getRunAsRole() != null) {
            inRunAs = true;
        }

        Principal principal = cont.getPrincipalFactory().getCallerPrincipal(inRunAs);
        if (principal == null) {
            throw new IllegalStateException("no security context exists");
        }
        return principal;

    }

    public EJBHome getEJBHome() throws IllegalStateException {
        return home;
    }

    public EJBLocalHome getEJBLocalHome() throws IllegalStateException {
        if (!bf.dd.hasDefinedLocalInterface()) {
            TraceEjb.logger.log(BasicLevel.ERROR, "No Local Interface declared for this bean");
            throw new IllegalStateException("No Local Interface declared for this bean");
        }
        return localhome;
    }

    public Properties getEnvironment() {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        return bf.getEjb10Environment();
    }

    public boolean getRollbackOnly() throws IllegalStateException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");

        if (getState() == 0) {
            throw new IllegalStateException("the instance is not allowed to call this method");
        }

        try {
            switch (tm.getStatus()) {
            case Status.STATUS_MARKED_ROLLBACK:
            case Status.STATUS_ROLLING_BACK:
                return true;
            case Status.STATUS_ACTIVE:
            case Status.STATUS_COMMITTING:
            case Status.STATUS_PREPARED:
            case Status.STATUS_PREPARING:
                return false;
            case Status.STATUS_ROLLEDBACK:
                throw new IllegalStateException("Transaction already rolled back");
            case Status.STATUS_COMMITTED:
                throw new IllegalStateException("Transaction already committed");
            case Status.STATUS_NO_TRANSACTION:
            case Status.STATUS_UNKNOWN:
                throw new IllegalStateException("Cannot getRollbackOnly outside transaction");
            }
        } catch (SystemException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "cannot get transaction status:", e);
            throw new IllegalStateException("Cannot get transaction status");
        }
        return true;
    }

    public abstract TimerService getTimerService() throws IllegalStateException;

    public UserTransaction getUserTransaction() throws IllegalStateException {

        TraceEjb.interp.log(BasicLevel.DEBUG, "");

        if (!bf.isTxBeanManaged()) {
            throw new IllegalStateException("This bean is not allowed to use UserTransaction interface");
        }
        if (getState() == 0) {
            throw new IllegalStateException("the instance is not allowed to call this method");
        }
        return (UserTransaction) tm;
    }

    public boolean isCallerInRole(Identity role) {
        throw new RuntimeException ("isCallerInRole(Identity) method deprecated. use instead isCallerInRole(String)");
    }

    public boolean isCallerInRole(String roleName) throws IllegalStateException {
        TraceEjb.security.log(BasicLevel.DEBUG, "");

       if (getState() == 0) {
            throw new IllegalStateException("the instance is not allowed to call this method");
        }

        // See EJB 2.1 specification
        // Chapter 21 : 21.2.5.2

        // Check that the roleName is in security-role-ref
        List list = bf.dd.getSecurityRoleRefDescList();

        if (list == null) {
            TraceEjb.logger.log(BasicLevel.WARN, "EJB 2.1 spec, Chapter 21 : 21.2.5.2 : No security-role-ref list. Invalid usage of isCallerInRole without security-role-ref elements.");
            return false;
        }
        boolean foundItem = false;
        Iterator it = bf.dd.getSecurityRoleRefDescList().iterator();
        String tmpRoleName = null;
        SecurityRoleRefDesc sRoleRefDesc = null;
        while (!foundItem && it.hasNext()) {
            sRoleRefDesc = (SecurityRoleRefDesc) it.next();
            tmpRoleName = sRoleRefDesc.getRoleName();
            if (tmpRoleName.equals(roleName)) {
                foundItem = true;
            }
        }

        if (!foundItem) {
            TraceEjb.security.log(BasicLevel.DEBUG, "No security-role-ref with role name '" + roleName
                                + "' was found in the deployment descriptor of bean '"
                                + bf.getEJBName() + ".");
            return false;
        }

        boolean inRunAs = false;
        if (bf.dd.getRunAsRole() != null) {
            inRunAs = true;
        }
        // Check with JACC manager
        boolean inRole = permissionManager.isCallerInRole(bf.getEJBName(), roleName, inRunAs);

        TraceEjb.security.log(BasicLevel.DEBUG, "isCallerInRole: " + inRole);
        return inRole;

    }

    public void setRollbackOnly() throws IllegalStateException {

        TraceEjb.interp.log(BasicLevel.DEBUG, "");

        // Check transaction state. 
        // Should throw IllegalStateException if not in a correct state.
        // This may be not handled correctly by the TM.
        boolean ir = getRollbackOnly();

        try {
            tm.setRollbackOnly();
        } catch (IllegalStateException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "current thread not associated with transaction");
            throw e;
        } catch (SystemException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "setRollbackOnly unexpected exception:", e);
        }
    }

}

---