JMessageEndpoint.java

package org.objectweb.jonas_ejb.container;

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

import javax.ejb.EJBException;
import javax.ejb.EJBHome;
import javax.ejb.EJBLocalHome;
import javax.ejb.MessageDrivenBean;
import javax.ejb.MessageDrivenContext;
import javax.ejb.TimedObject;
import javax.ejb.Timer;
import javax.ejb.TimerService;
import javax.resource.spi.endpoint.MessageEndpoint;
import javax.transaction.Status;
import javax.transaction.SystemException;
import javax.transaction.UserTransaction;
import javax.transaction.xa.XAResource;

import org.objectweb.jonas_ejb.deployment.api.MethodDesc;

import org.objectweb.security.context.SecurityContext;
import org.objectweb.security.context.SecurityCurrent;

import org.objectweb.transaction.jta.TransactionManager;
import org.objectweb.util.monolog.api.BasicLevel;

public class JMessageEndpoint implements MessageDrivenContext {

    protected JMdbEndpointFactory bf = null;

    protected MessageDrivenBean mdb = null;

    protected MessageEndpoint mep = null;

    protected int txattr; // TX_NOT_SUPPORTED, TX_REQUIRED or TX_NOT_SET (= bean
                          // managed)

    protected TransactionManager tm = null;

    protected XAResource xar = null;

    protected boolean released = false;

    private static final int MAX_NB_RETRY = 2;

    public JMessageEndpoint(JMdbEndpointFactory bf, MessageDrivenBean mdb) {
        this.bf = bf;
        this.mdb = mdb;
        // keep these locally for efficiency.
        txattr = bf.getTransactionAttribute();
        tm = bf.getTransactionManager();
    }

    public void setProxy(MessageEndpoint mep) {
        this.mep = mep;
    }

    public XAResource getXAResource() {
        return xar;
    }

    public void setXAResource(XAResource xa) {
        xar = xa;
        // Check state of transaction to determine what to do
    }

    public boolean getReleasedState() {
        return released;
    }

    public void setReleasedState(boolean state) {
        released = state;
    }

    // ------------------------------------------------------------------
    // EJBContext implementation
    // ------------------------------------------------------------------

    public TimerService getTimerService() throws IllegalStateException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        return bf.getTimerService();
    }

    // ----------------------------------------------------------------------
    // javax.ejb.MessageDrivenContext implementation
    // ----------------------------------------------------------------------

    private static final String DISALLOWED_MSG = " is disallowed in a message driven bean";

    public Identity getCallerIdentity() {
        TraceEjb.logger.log(BasicLevel.ERROR, DISALLOWED_MSG);
        throw new IllegalStateException("getCallerIdentity()" + DISALLOWED_MSG);
    }

    public Principal getCallerPrincipal() {
        boolean inRunAs = false;
        if (bf.dd.getRunAsRole() != null) {
            inRunAs = true;
        }
        // Set a security context if there was no one set.
        SecurityCurrent current = SecurityCurrent.getCurrent();
        if (current != null) {
            SecurityContext sctx = current.getSecurityContext();
            if (sctx == null) {
                TraceEjb.security.log(BasicLevel.DEBUG, "runas : Security context is null, create a new one");
                sctx = new SecurityContext();
                current.setSecurityContext(sctx);
            }
        }

        Principal principal =  bf.getContainer().getPrincipalFactory().getCallerPrincipal(inRunAs);
        if (principal == null) {
            throw new IllegalStateException("No principal exists in security context");
        }
        return principal;
    }

    public boolean isCallerInRole(Identity role) {
        TraceEjb.logger.log(BasicLevel.ERROR, DISALLOWED_MSG);
        throw new IllegalStateException("isCallerInRole()" + DISALLOWED_MSG);
    }

    public boolean isCallerInRole(java.lang.String roleLink) {
        TraceEjb.logger.log(BasicLevel.ERROR, DISALLOWED_MSG);
        throw new IllegalStateException("isCallerInRole()" + DISALLOWED_MSG);
    }

  public void setRollbackOnly() {

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

    if(bf.isTxBeanManaged())
      throw new IllegalStateException("Bean-managed transaction, not use this method.");
    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, "unexpected exception:", e);
    }
  }

  public boolean getRollbackOnly() {
    TraceEjb.mdb.log(BasicLevel.DEBUG, "");
    if(bf.isTxBeanManaged())
      throw new IllegalStateException("Bean-managed transaction, not use this method.");
    try {
      if (tm.getTransaction() != null) {
        switch (tm.getStatus()) {
        case Status.STATUS_MARKED_ROLLBACK:
        case Status.STATUS_ROLLEDBACK:
        case Status.STATUS_ROLLING_BACK:
          return true;
        case Status.STATUS_NO_TRANSACTION:
          throw new IllegalStateException("No transaction");
        default:
          return false;
        }
      } else {
        TraceEjb.logger.log(BasicLevel.ERROR, "the bean is not associated in a transaction");
        throw new IllegalStateException("the message driven bean is not associated in a transaction");
      }
    } catch (SystemException e) {
      TraceEjb.logger.log(BasicLevel.ERROR, "cannot get status:", e);
      return false;
    }
  }

    public EJBHome getEJBHome() {
        TraceEjb.logger.log(BasicLevel.ERROR, DISALLOWED_MSG);
        throw new IllegalStateException("getEJBHome()" + DISALLOWED_MSG);
    }

    public EJBLocalHome getEJBLocalHome() {
        TraceEjb.logger.log(BasicLevel.ERROR, DISALLOWED_MSG);
        throw new IllegalStateException("getEJBLocalHome()" + DISALLOWED_MSG);
    }

    public Properties getEnvironment() {
        TraceEjb.logger.log(BasicLevel.ERROR, "deprecated use : Use the JNDI naming context java:comp/env");
        return new java.util.Properties();
    }

    public UserTransaction getUserTransaction() throws IllegalStateException {

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

        if (!bf.isTxBeanManaged()) {
            throw new IllegalStateException("This bean is not allowed to use UserTransaction interface");
        }
        return (UserTransaction) tm;
    }

    // -----------------------------------------------------------------------
    // other public methods
    // -----------------------------------------------------------------------

    public void deliverTimeout(Timer timer) {
        TraceEjb.mdb.log(BasicLevel.DEBUG, "");

        boolean committed = false;
        for (int nbretry = 0; ! committed && nbretry < MAX_NB_RETRY; nbretry++) {
            RequestCtx rctx = null;
            try {
                // For MDB, transaction attribute must be required or NotSupported.
                rctx = bf.preInvoke(MethodDesc.TX_REQUIRED);
            } catch (Exception e) {
                TraceEjb.logger.log(BasicLevel.ERROR, "preInvoke failed: ", e);
                return;
            }
            try {
                bf.checkSecurity(null);
                if (mdb instanceof TimedObject) {
                    ((TimedObject) mdb).ejbTimeout(timer);
                } else {
                    throw new EJBException("The bean does not implement the `TimedObject` interface");
                }
                committed = ! getRollbackOnly();
            } catch (EJBException e) {
                rctx.sysExc = e;
                TraceEjb.logger.log(BasicLevel.ERROR, "EJB exception thrown by an enterprise Bean", e);
            } catch (RuntimeException e) {
                rctx.sysExc = e;
                TraceEjb.logger.log(BasicLevel.ERROR, "runtime exception thrown by an enterprise Bean", e);
            } catch (Error e) {
                rctx.sysExc = e;
                TraceEjb.logger.log(BasicLevel.ERROR, "error thrown by an enterprise Bean", e);
                        } finally {
                try {
                    bf.postInvoke(rctx);
                } catch (Exception e) {
                    TraceEjb.logger.log(BasicLevel.ERROR, "exception on postInvoke: ", e);
                }
            }
        }
    }
}

---