JTimerService.java

package org.objectweb.jonas_ejb.container;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;

import javax.ejb.EJBException;
import javax.ejb.Timer;
import javax.ejb.TimerService;
import javax.ejb.TransactionRolledbackLocalException;
import javax.transaction.TransactionManager;

import org.objectweb.jonas.jtm.TransactionService;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.service.ServiceManager;
import org.objectweb.jonas_timer.TraceTimer;
import org.objectweb.util.monolog.api.BasicLevel;

public class JTimerService implements TimerService {

    private ArrayList mytimers = new ArrayList();

    private JFactory bf = null;

    private JEntitySwitch es = null;

        private TransactionManager tm;

    public JTimerService(JFactory bf) {
        this.bf = bf;
        // Get the transaction service
        try {
            TransactionService ts = (TransactionService) ServiceManager.getInstance().getTransactionService();
            tm = ts.getTransactionManager();
        } catch (Exception e) {
            throw new EJBException("Error when starting the Timer service ", e);
        }

    }

    public JTimerService(JEntitySwitch es) {
        this.es = es;
        // Get the transaction service
        try {
            TransactionService ts = (TransactionService) ServiceManager.getInstance().getTransactionService();
            tm = ts.getTransactionManager();
        } catch (Exception e) {
            throw new EJBException("Error when starting the Timer service ", e);
        }

    }

    public TransactionManager getTransactionManager() {
        return tm;
    }
    
    public void notify(Timer timer) {
        if (es != null) {
            // Entity Bean
            es.notifyTimeout(timer);
        } else {
            if (bf instanceof JMdbFactory) {
                ((JMdbFactory) bf).notifyTimeout(timer);
            } else if (bf instanceof JMdbEndpointFactory) {
                ((JMdbEndpointFactory) bf).notifyTimeout(timer);
            } else if (bf instanceof JStatelessFactory) {
                ((JStatelessFactory) bf).notifyTimeout(timer);
            } else {
                TraceEjb.logger.log(BasicLevel.ERROR, "Cannot notify this type of bean");
            }
        }
    }

    public void remove(Timer timer) {
        synchronized (this) {
            int index = mytimers.lastIndexOf(timer);
            if (index == -1) {
                TraceTimer.logger.log(BasicLevel.WARN, "try to remove unexisting timer");
            } else {
                mytimers.remove(index);
            }
        }
    }

    public void cancelAllTimers() {
        synchronized (this) {
            es = null;
            for (Iterator i = mytimers.iterator(); i.hasNext(); ) {
                JTimer timer = (JTimer) i.next();
                timer.stopTimer();
            }
            mytimers.clear();
        }
    }

    public Timer getTimer(long initialDuration, long intervalDuration, Serializable info) {
        Timer dummy = new JTimer(this, initialDuration, intervalDuration, info);
        synchronized (this) {
            for (Iterator i = mytimers.iterator(); i.hasNext(); ) {
                JTimer timer = (JTimer) i.next();
                if (timer.equals(dummy)) {
                    return timer;
                }
            }
        }
        return null;
    }

    // ------------------------------------------------------------------------------------
    // TimerService implemetation
    // ------------------------------------------------------------------------------------

    public Timer createTimer(Date initialExpiration, long intervalDuration, Serializable info)
            throws IllegalArgumentException, IllegalStateException, EJBException {
        if (initialExpiration == null) {
            throw new IllegalArgumentException("expiration date is null");
        }
        // avoids negative argument here (add a few milliseconds)
        long initialDuration = initialExpiration.getTime() - System.currentTimeMillis() + 20;
        return createTimer(initialDuration, intervalDuration, info);
    }

    public Timer createTimer(Date expiration, Serializable info) throws IllegalArgumentException,
            IllegalStateException, EJBException {
        return createTimer(expiration, 0, info);
    }

    public Timer createTimer(long initialDuration, long intervalDuration, Serializable info)
        throws IllegalArgumentException, IllegalStateException, EJBException {

        // Check that we are not called from entity ejbCreate
        if (es != null) {
            es.getPrimaryKey(); // can throw IllegalStateException
        }

        // Check duration positive
        if (initialDuration < 0 || intervalDuration < 0) {
            throw new IllegalArgumentException("duration is negative");
        }

        JTimer timer = new JTimer(this, initialDuration, intervalDuration, info);
        synchronized (this) {
            if (mytimers.add(timer)) {
                timer.startTimer();
            } else {
                TraceTimer.logger.log(BasicLevel.WARN, "create a timer already known");
            }
        }
        return timer;
    }


    public Timer createTimer(long duration, Serializable info) throws IllegalArgumentException, IllegalStateException,
            EJBException {
        return createTimer(duration, 0, info);
    }

    public Collection getTimers() throws IllegalStateException, EJBException {
        // Check that we are not called from entity ejbCreate
        if (es != null) {
            es.getPrimaryKey(); // can throw IllegalStateException
        }
        return (ArrayList) mytimers.clone();
    }

    public String getEjbName() {
        if (bf != null) {
            return bf.getEJBName();
        }
        if (es != null) {
            return es.getBeanFactory().getEJBName();
        }
        return null;
    }

    public Serializable getPK() {
        if (es != null) {
            JEntityFactory ef = (JEntityFactory) es.getBeanFactory();
            Serializable pks = (Serializable) es.getPrimaryKey();
            Serializable pk = (Serializable) ef.encodePK(pks);
            TraceEjb.interp.log(BasicLevel.DEBUG, "pk = " + pks);
            TraceEjb.interp.log(BasicLevel.DEBUG, "encoded pk = " + pk);
            return pk;
        } else {
            return null;
        }
    }

    public String getContainer() {
        JFactory f = bf;
        if (es != null) {
            f = es.getBeanFactory();
        }
        JContainer cont = f.getContainer();
        return cont.getExternalFileName();
    }
}

---