JTimer.java

package org.objectweb.jonas_ejb.container;

import java.io.Serializable;
import java.util.Date;

import javax.ejb.EJBException;
import javax.ejb.NoSuchObjectLocalException;
import javax.ejb.Timer;
import javax.ejb.TimerHandle;
import javax.transaction.RollbackException;
import javax.transaction.Status;
import javax.transaction.Synchronization;
import javax.transaction.SystemException;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;

import org.objectweb.jonas_timer.TimerEvent;
import org.objectweb.jonas_timer.TimerEventListener;
import org.objectweb.jonas_timer.TimerManager;
import org.objectweb.jonas_timer.TraceTimer;
import org.objectweb.util.monolog.api.BasicLevel;

public class JTimer implements Timer, TimerEventListener, Synchronization {

    private boolean oneshot;

    private long period;

    private long initial;

    private JTimerService timerservice;

    private Serializable info;

    private TimerManager tim = TimerManager.getInstance();

    private TimerEvent te1 = null;

    private TimerEvent te2 = null;

    private long starttime;

    private long endtime;

    private boolean createdInTx = false;

    private boolean cancelledInTx = false;
    
    private boolean cancelled = false;

    private TimerHandle myHandle = null;

    public JTimer(JTimerService timerservice, long initial, long period, Serializable info) {
        TraceTimer.logger.log(BasicLevel.DEBUG, "New JTimer initial = " + initial + ", period = " + period);
        this.timerservice = timerservice;
        this.info = info;
        this.period = period;
        this.initial = initial;
        oneshot = (period == 0);
        
    }

    public long getStartTime() {
        return starttime;
    }

    public long getInitial() {
        return initial;
    }

    public long getPeriod() {
        return period;
    }

    public JTimerService getTimerService() {
        return timerservice;
    }

    public void startTimer() {
        
        // If this is created inside a transaction, register this object as a synchronization.
        TransactionManager tm = timerservice.getTransactionManager();
        try {
                        Transaction tx = tm.getTransaction();
                        if (tx != null) {
                                tx.registerSynchronization(this);
                                createdInTx = true;
                        }
                } catch (SystemException e) {
            TraceTimer.logger.log(BasicLevel.ERROR, "Cannot get Transaction");
                } catch (IllegalStateException e) {
            TraceTimer.logger.log(BasicLevel.ERROR, "Cannot register synchronization:" + e);
                } catch (RollbackException e) {
            TraceTimer.logger.log(BasicLevel.ERROR, "transaction already rolled back");
                }
                
                // init time
        starttime = System.currentTimeMillis();
        endtime = starttime + initial;
        
        // Create the jonas timer
        te1 = tim.addTimerMs(this, initial, null, false);
    }

    public void stopTimer() {
        TraceTimer.logger.log(BasicLevel.DEBUG, "Stop JTimer");
        cancelled = true;
        if (te1 != null) {
            te1.unset();
            te1 = null;
        }
        if (te2 != null) {
            te2.unset();
            te2 = null;
        }
    }

    // ------------------------------------------------------------------------------------
    // The container must implement suitable equals() and hashCode() methods
    // ------------------------------------------------------------------------------------

    public boolean equals(Object obj) {
        if (obj instanceof JTimer) {
            JTimer timer2 = (JTimer) obj;
            if (timer2.getInitial() != getInitial()) {
                TraceTimer.logger.log(BasicLevel.DEBUG, "different initial duration");
                return false;
            }
            if (timer2.getPeriod() != getPeriod()) {
                TraceTimer.logger.log(BasicLevel.DEBUG, "different period");
                return false;
            }
            if (timer2.getTimerService() != getTimerService()) {
                TraceTimer.logger.log(BasicLevel.DEBUG, "different timerservice");
                return false;
            }
            TraceTimer.logger.log(BasicLevel.DEBUG, "timers are equal");
            return true;
        } else {
            TraceTimer.logger.log(BasicLevel.DEBUG, "not a Timer");
            return false;
        }
    }

    public int hashCode() {
        return (int) (getPeriod() / 1000);
    }

    // ------------------------------------------------------------------------------------
    // TimerEventListener implemetation
    // ------------------------------------------------------------------------------------

    public void timeoutExpired(Object arg) {
        TraceTimer.logger.log(BasicLevel.DEBUG, "JTimer expires");
        // propagate the timeout
        timerservice.notify(this);
        if (cancelled) {
            TraceTimer.logger.log(BasicLevel.DEBUG, "JTimer cancelled during timeout");
            return;
        }
        if (te2 == null) {
            te1 = null;
            if (oneshot) {
                timerservice.remove(this);
                cancelled = true;
            } else {
                // start a new jonas timer (periodic)
                TraceTimer.logger.log(BasicLevel.DEBUG, "Start periodic jonas timer");
                endtime = System.currentTimeMillis() + period;
                te2 = tim.addTimerMs(this, period, null, true);
            }
        } else {
            // recompute time of next expiration
            endtime = System.currentTimeMillis() + period;
        }
    }

    // ------------------------------------------------------------------------------------
    // Timer implemetation
    // ------------------------------------------------------------------------------------

    public void cancel() throws IllegalStateException, NoSuchObjectLocalException, EJBException {
        if (cancelled || cancelledInTx) {
            TraceTimer.logger.log(BasicLevel.ERROR, "Timer cancelled");
            throw new NoSuchObjectLocalException("Timer already cancelled");
        }
        TraceTimer.logger.log(BasicLevel.DEBUG, "");

        // If this is called inside a transaction, register this object as a synchronization.
        TransactionManager tm = timerservice.getTransactionManager();
        try {
                        Transaction tx = tm.getTransaction();
                        if (tx != null) {
                            // will be cancelled at commit.
                                tx.registerSynchronization(this);
                                cancelledInTx = true;
                        } else {
                            doCancel();
                        }
                } catch (SystemException e) {
            TraceTimer.logger.log(BasicLevel.ERROR, "Cannot get Transaction");
                } catch (IllegalStateException e) {
            TraceTimer.logger.log(BasicLevel.ERROR, "Cannot register synchronization:" + e);
                } catch (RollbackException e) {
            TraceTimer.logger.log(BasicLevel.ERROR, "transaction already rolled back");
                }
    }
    
    private void doCancel() {
        stopTimer();
        timerservice.remove(this);
    }

    public long getTimeRemaining() throws IllegalStateException, NoSuchObjectLocalException, EJBException {
        if (cancelled || cancelledInTx) {
            TraceTimer.logger.log(BasicLevel.ERROR, "Timer cancelled");
            throw new NoSuchObjectLocalException("Timer cancelled or expired");
        }
        TraceTimer.logger.log(BasicLevel.DEBUG, "");
        return endtime - System.currentTimeMillis();
    }

    public Date getNextTimeout() throws IllegalStateException, NoSuchObjectLocalException, EJBException {
        if (cancelled || cancelledInTx) {
            TraceTimer.logger.log(BasicLevel.ERROR, "Timer cancelled");
            throw new NoSuchObjectLocalException("Timer cancelled or expired");
        }
        TraceTimer.logger.log(BasicLevel.DEBUG, "");
        return new Date(endtime);
    }

    public Serializable getInfo() throws IllegalStateException, NoSuchObjectLocalException, EJBException {
        if (cancelled || cancelledInTx) {
            TraceTimer.logger.log(BasicLevel.ERROR, "Timer cancelled");
            throw new NoSuchObjectLocalException("Timer cancelled or expired");
        }
        TraceTimer.logger.log(BasicLevel.DEBUG, "");
        return info;
    }

    public TimerHandle getHandle() throws IllegalStateException, NoSuchObjectLocalException, EJBException {
        if (cancelled || cancelledInTx) {
            TraceTimer.logger.log(BasicLevel.ERROR, "Timer cancelled");
            throw new NoSuchObjectLocalException("Timer cancelled or expired");
        }
        TraceTimer.logger.log(BasicLevel.DEBUG, "");
        if (myHandle == null) {
            myHandle = new JTimerHandle(initial, period, info, timerservice.getEjbName(), 
                                        timerservice.getContainer(), timerservice.getPK());
        }
        return myHandle;
    }

    // ------------------------------------------------------------------------------------
    // Synchronization implemetation
    // ------------------------------------------------------------------------------------

    public void afterCompletion(int status) {
        TraceEjb.tx.log(BasicLevel.DEBUG, "");

        // Timers created in a transaction that is rolled back must be removed.
        if (createdInTx) {
            if (status != Status.STATUS_COMMITTED && !cancelled) {
                doCancel();
            }
            createdInTx = false;
        }
        
        // Cancel timers only if transaction is committed
        if (cancelledInTx) {
            if (status == Status.STATUS_COMMITTED && !cancelled) {
                doCancel();
            }
            cancelledInTx = false;
        }
    }

        /* 
         * @see javax.transaction.Synchronization#beforeCompletion()
         */
        public void beforeCompletion() {
                // nothing to do 
        }

}

---