JMessageDrivenBean.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.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ServerSession;
import javax.jms.Session;
import javax.jms.XASession;
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.transaction.jta.TransactionManager;
import org.objectweb.util.monolog.api.BasicLevel;

public class JMessageDrivenBean implements MessageListener, ServerSession, Runnable, MessageDrivenContext {

    protected Session sess = null;

    protected JMdbFactory bf = null;

    protected MessageDrivenBean mdb = null;

    protected int txattr;

    protected int timerTxAttr;

    protected TransactionManager tm = null;

    protected ThreadPool thpool = null;

    public JMessageDrivenBean(JMdbFactory bf, Session sess, MessageDrivenBean mdb, ThreadPool thpool) {
        this.bf = bf;
        this.sess = sess;
        this.mdb = mdb;
        this.thpool = thpool;
        // keep these locally for efficiency.
        txattr = bf.getTransactionAttribute();
        timerTxAttr = bf.getTimerTxAttribute();
        tm = bf.getTransactionManager();
    }

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

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

    // ----------------------------------------------------------------------
    // javax.jms.MessageListener implementation
    // ----------------------------------------------------------------------

    public synchronized void onMessage(Message message) {
        TraceEjb.mdb.log(BasicLevel.DEBUG, "");

        RequestCtx rctx = null;
        try {

            if (tm.getTransaction() != null) {
                // This should not occur (DEBUG)
                TraceEjb.logger.log(BasicLevel.ERROR, "Transaction already OPENED");
                TraceEjb.logger.log(BasicLevel.ERROR, "Transaction = " + tm.getTransaction());
                Thread.dumpStack();
                return;
            }

            rctx = bf.preInvoke(txattr);
            bf.checkSecurity(null);
            if (rctx.mustCommit) {
                TraceEjb.tx.log(BasicLevel.DEBUG, "enlistResource");
                rctx.currTx.enlistResource(((XASession) sess).getXAResource());
            }
        } catch (Exception e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "preInvoke failed: ", e);
            return;
        }
        try {
            TraceEjb.mdb.log(BasicLevel.DEBUG, "Call MDB");
            ((MessageListener) mdb).onMessage(message);
            TraceEjb.mdb.log(BasicLevel.DEBUG, "Return from MDB");
        } 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 {
                if (rctx.mustCommit) {
                    TraceEjb.tx.log(BasicLevel.DEBUG, "delistResource");
                    rctx.currTx.delistResource(((XASession) sess).getXAResource(), XAResource.TMSUCCESS);
                }
                bf.postInvoke(rctx);
            } catch (Exception e) {
                TraceEjb.logger.log(BasicLevel.ERROR, "exception on postInvoke: ", e);
            }
        }
    }

    // ----------------------------------------------------------------------
    // javax.jms.ServerSession implementation
    // ----------------------------------------------------------------------

    public Session getSession() throws JMSException {
        TraceEjb.mdb.log(BasicLevel.DEBUG, "");
        return sess;
    }

    public void start() throws JMSException {
        TraceEjb.mdb.log(BasicLevel.DEBUG, "");
        thpool.addRunnable(this);
    }

    // ----------------------------------------------------------------------
    // Runnable implementation
    // ----------------------------------------------------------------------

    public void run() {
        TraceEjb.mdb.log(BasicLevel.DEBUG, "");

        // this thread must have the classloader of this container to
        // be able to retrieve beans called from a MDB.
        Thread.currentThread().setContextClassLoader(bf.myClassLoader());

        sess.run();
        bf.releaseServerSession(this);
    }

    // ----------------------------------------------------------------------
    // 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() {
        TraceEjb.logger.log(BasicLevel.ERROR, DISALLOWED_MSG);
        throw new IllegalStateException("getCallerPrincipal()" + DISALLOWED_MSG);
    }

    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, "");
        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, "");

        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, "");

        RequestCtx rctx = null;
        try {
            rctx = bf.preInvoke(timerTxAttr);
        } 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");
            }
        } 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);
            }
        }
    }
}

---