javax.ejb.TimerConfig Java Examples

void createTimerWithPeriod(TimerService timerService, TimerType timerType,
        long timerOffset, Period period) {
    if (isTimerCreated(timerType, timerService)) {
        return;
    }
    TimerConfig config = new TimerConfig();
    config.setInfo(timerType);
    Date startDate = getDateForNextTimerExpiration(period, timerOffset);
    ScheduleExpression schedleExpression = getExpressionForPeriod(period,
            startDate);
    Timer timer = timerService.createCalendarTimer(schedleExpression,
            config);
    Date nextStart = timer.getNextTimeout();
    SimpleDateFormat sdf = new SimpleDateFormat();
    logger.logInfo(Log4jLogger.SYSTEM_LOG,
            LogMessageIdentifier.INFO_TIMER_CREATED,
            String.valueOf(timerType), sdf.format(nextStart));
}
 

@Override
public Timer createTimer(final Object primaryKey,
                         final Method timeoutMethod,
                         final long duration,
                         final TimerConfig timerConfig) throws IllegalArgumentException, IllegalStateException, EJBException {
    if (duration < 0) {
        throw new IllegalArgumentException("duration is negative: " + duration);
    }
    checkState();

    final Date expiration = new Date(System.currentTimeMillis() + duration);
    try {
        final TimerData timerData = timerStore.createSingleActionTimer(this, (String) deployment.getDeploymentID(), primaryKey, timeoutMethod, expiration, timerConfig);
        initializeNewTimer(timerData);
        return timerData.getTimer();
    } catch (final TimerStoreException e) {
        throw new EJBException(e);
    }
}
 

@Override
public Timer createTimer(final Object primaryKey,
                         final Method timeoutMethod,
                         final Date expiration,
                         final TimerConfig timerConfig) throws IllegalArgumentException, IllegalStateException, EJBException {
    if (expiration == null) {
        throw new IllegalArgumentException("expiration is null");
    }
    if (expiration.getTime() < 0) {
        throw new IllegalArgumentException("expiration is negative: " + expiration.getTime());
    }
    checkState();

    try {
        final TimerData timerData = timerStore.createSingleActionTimer(this, (String) deployment.getDeploymentID(), primaryKey, timeoutMethod, expiration, timerConfig);
        initializeNewTimer(timerData);
        return timerData.getTimer();
    } catch (final TimerStoreException e) {
        throw new EJBException(e);
    }
}
 

@Override
public Timer createTimer(final Object primaryKey, final Method timeoutMethod, final ScheduleExpression scheduleExpression, final TimerConfig timerConfig) {
    if (scheduleExpression == null) {
        throw new IllegalArgumentException("scheduleExpression is null");
    }
    //TODO add more schedule expression validation logic ?
    checkState();
    try {
        final TimerData timerData = timerStore.createCalendarTimer(this,
            (String) deployment.getDeploymentID(),
            primaryKey,
            timeoutMethod,
            scheduleExpression,
            timerConfig,
            false);
        initializeNewTimer(timerData);
        return timerData.getTimer();
    } catch (final TimerStoreException e) {
        throw new EJBException(e);
    }
}
 

@Test
public void initTimers_interval() throws Exception {
    // given
    TimerServiceStub timeServiceStub = mock(TimerServiceStub.class);
    when(ctx.getTimerService()).thenReturn(timeServiceStub);
    TimerConfig timerConfig = new TimerConfig();
    timerConfig.setInfo(TimerType.BILLING_INVOCATION);
    doReturn(new TimerStub(null, timerConfig)).when(timeServiceStub)
            .createCalendarTimer(any(ScheduleExpression.class),
                    any(TimerConfig.class));

    // when
    tm.initTimers();

    // then
    verify(timeServiceStub, times(4)).createTimer(any(Date.class),
            eq(10000L), any(TimerType.class));
}
 

@Override
public TimerData createCalendarTimer(final EjbTimerServiceImpl timerService, final String deploymentId, final Object primaryKey, final Method timeoutMethod, final ScheduleExpression scheduleExpression, final TimerConfig timerConfig, final boolean auto)
    throws TimerStoreException {
    final long id = counter.incrementAndGet();
    final TimerData timerData = new CalendarTimerData(id, timerService, deploymentId, primaryKey, timeoutMethod, timerConfig, scheduleExpression, auto);
    getTasks().addTimerData(timerData);
    return timerData;
}
 

@Override
public Timer createIntervalTimer(long arg0, long arg1, TimerConfig arg2)
        throws IllegalArgumentException, IllegalStateException,
        EJBException {

    return null;
}
 

@Override
public Timer createIntervalTimer(Date arg0, long arg1, TimerConfig arg2)
        throws IllegalArgumentException, IllegalStateException,
        EJBException {

    return null;
}
 

@Override
public Timer createCalendarTimer(ScheduleExpression arg0, TimerConfig arg1)
        throws IllegalArgumentException, IllegalStateException,
        EJBException {
    TimerStub timer = new TimerStub(arg0, arg1);
    timers.add(timer);
    return timer;
}
 

@Override
public Timer createSingleActionTimer(Date arg0, TimerConfig arg1)
        throws IllegalArgumentException, IllegalStateException,
        EJBException {

    return null;
}
 

public Timer setTimerNow() {
    final ScheduleExpression schedule = new ScheduleExpression().second("*/3").minute("*").hour("*");

    final TimerConfig timerConfig = new TimerConfig();
    timerConfig.setPersistent(false);

    return timerService.createCalendarTimer(schedule, timerConfig);
}
 

public void newTimer() {
    final TimerConfig tc = new TimerConfig("my-timer", true);
    final ScheduleExpression se = new ScheduleExpression();
    final Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.SECOND, 2);
    se.second(calendar.get(Calendar.SECOND) + "/3");
    se.minute("*");
    se.hour("*");
    se.dayOfMonth("*");
    se.dayOfWeek("*");
    se.month("*");
    timer = timerService.createCalendarTimer(se, tc);
}
 

private void createTimer() {
    try {
        this.timer = this.timerService.createSingleActionTimer(100, new TimerConfig(TIMER_NAME, false));
    } catch (final Exception e) {
        throw new RuntimeException("SingleActionTimer: Failed to create timer", e);
    }
}
 

public Timer start() {
    String startMessage = new StringBuilder("==========================\n")
            .append("Bot started at ").append(new Date().toString()).append("\n")
            .toString();
    event.fire(startMessage);
    return timerService.createIntervalTimer(0, DURATION, new TimerConfig(null, false));
}
 

public Timer start() {
    String startMessage = new StringBuilder("==========================\n")
            .append("Bot started at ").append(new Date().toString()).append("\n")
            .toString();
    event.fire(startMessage);
    return timerService.createIntervalTimer(0, DURATION, new TimerConfig(null, false));
}
 

public Timer start() {
    String startMessage = new StringBuilder("==========================\n")
            .append("Bot started at ").append(new Date().toString()).append("\n")
            .toString();
    event.fire(startMessage);
    return timerService.createIntervalTimer(0, DURATION, new TimerConfig(null, false));
}
 

@Override
public Timer createSingleActionTimer(long arg0, TimerConfig arg1)
        throws IllegalArgumentException, IllegalStateException,
        EJBException {

    return null;
}
 

public TimerStub(ScheduleExpression scheduleExpression, TimerConfig config) {
    this.scheduleExpression = scheduleExpression;
    Calendar cal = Calendar.getInstance();
    cal.add(Calendar.DAY_OF_YEAR, 1);
    this.execDate = cal.getTime();
    this.info = config.getInfo();
}
 

public void newTimer() {
    final TimerConfig tc = new TimerConfig("my-timer", true);
    final ScheduleExpression se = new ScheduleExpression();
    final Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.SECOND, 2);
    se.second(calendar.get(Calendar.SECOND) + "/3");
    se.minute("*");
    se.hour("*");
    se.dayOfMonth("*");
    se.dayOfWeek("*");
    se.month("*");
    timer = timerService.createCalendarTimer(se, tc);
}
 

@PostConstruct
private void construct() {
    final TimerConfig plantTheCorn = new TimerConfig("plantTheCorn", false);
    timerService.createCalendarTimer(new ScheduleExpression().month(5).dayOfMonth("20-Last").minute(0).hour(8), plantTheCorn);
    timerService.createCalendarTimer(new ScheduleExpression().month(6).dayOfMonth("1-10").minute(0).hour(8), plantTheCorn);

    final TimerConfig harvestTheCorn = new TimerConfig("harvestTheCorn", false);
    timerService.createCalendarTimer(new ScheduleExpression().month(9).dayOfMonth("20-Last").minute(0).hour(8), harvestTheCorn);
    timerService.createCalendarTimer(new ScheduleExpression().month(10).dayOfMonth("1-10").minute(0).hour(8), harvestTheCorn);

    final TimerConfig checkOnTheDaughters = new TimerConfig("checkOnTheDaughters", false);
    timerService.createCalendarTimer(new ScheduleExpression().second("*").minute("*").hour("*"), checkOnTheDaughters);
}
 

private void addSchedulesToMethod(final MethodContext methodContext, final MethodScheduleInfo info) {

        if (methodContext == null) {
            return;
        }

        for (final ScheduleInfo scheduleInfo : info.schedules) {

            final ScheduleExpression expr = new ScheduleExpression();
            expr.second(scheduleInfo.second == null ? "0" : scheduleInfo.second);
            expr.minute(scheduleInfo.minute == null ? "0" : scheduleInfo.minute);
            expr.hour(scheduleInfo.hour == null ? "0" : scheduleInfo.hour);
            expr.dayOfWeek(scheduleInfo.dayOfWeek == null ? "*" : scheduleInfo.dayOfWeek);
            expr.dayOfMonth(scheduleInfo.dayOfMonth == null ? "*" : scheduleInfo.dayOfMonth);
            expr.month(scheduleInfo.month == null ? "*" : scheduleInfo.month);
            expr.year(scheduleInfo.year == null ? "*" : scheduleInfo.year);
            expr.timezone(scheduleInfo.timezone);
            expr.start(scheduleInfo.start);
            expr.end(scheduleInfo.end);

            final TimerConfig config = new TimerConfig();
            config.setInfo(scheduleInfo.info);
            config.setPersistent(scheduleInfo.persistent);

            methodContext.getSchedules().add(new ScheduleData(config, expr));
        }

    }
 

@Override
public Timer createTimer(final Object primaryKey,
                         final Method timeoutMethod,
                         final long initialDuration,
                         final long intervalDuration,
                         final TimerConfig timerConfig) throws IllegalArgumentException, IllegalStateException, EJBException {
    if (initialDuration < 0) {
        throw new IllegalArgumentException("initialDuration is negative: " + initialDuration);
    }
    if (intervalDuration < 0) {
        throw new IllegalArgumentException("intervalDuration is negative: " + intervalDuration);
    }
    checkState();

    final Date initialExpiration = new Date(System.currentTimeMillis() + initialDuration);
    try {
        final TimerData timerData = timerStore.createIntervalTimer(this,
            (String) deployment.getDeploymentID(),
            primaryKey,
            timeoutMethod,
            initialExpiration,
            intervalDuration,
            timerConfig);
        initializeNewTimer(timerData);
        return timerData.getTimer();
    } catch (final TimerStoreException e) {
        throw new EJBException(e);
    }
}
 

public TimerData(final long id,
                 final EjbTimerServiceImpl timerService,
                 final String deploymentId,
                 final Object primaryKey,
                 final Method timeoutMethod,
                 final TimerConfig timerConfig) {
    this.id = id;
    this.timerService = timerService;
    this.deploymentId = deploymentId;
    this.primaryKey = primaryKey;
    this.info = timerConfig == null ? null : timerConfig.getInfo();
    this.persistent = timerConfig == null || timerConfig.isPersistent();
    this.timer = new TimerImpl(this);
    this.timeoutMethod = timeoutMethod;
}
 

@Override
public TimerData createSingleActionTimer(final EjbTimerServiceImpl timerService, final String deploymentId, final Object primaryKey, final Method timeoutMethod, final Date expiration, final TimerConfig timerConfig) throws TimerStoreException {
    final long id = counter.incrementAndGet();
    final TimerData timerData = new SingleActionTimerData(id, timerService, deploymentId, primaryKey, timeoutMethod, timerConfig, expiration);
    getTasks().addTimerData(timerData);
    return timerData;
}
 

@Override
public TimerData createIntervalTimer(final EjbTimerServiceImpl timerService, final String deploymentId, final Object primaryKey, final Method timeoutMethod, final Date initialExpiration, final long intervalDuration, final TimerConfig timerConfig)
    throws TimerStoreException {
    final long id = counter.incrementAndGet();
    final TimerData timerData = new IntervalTimerData(id, timerService, deploymentId, primaryKey, timeoutMethod, timerConfig, initialExpiration, intervalDuration);
    getTasks().addTimerData(timerData);
    return timerData;
}
 

@Override
public Timer createTimer(final Object primaryKey,
                         final Method timeoutMethod,
                         final Date initialExpiration,
                         final long intervalDuration,
                         final TimerConfig timerConfig) throws IllegalArgumentException, IllegalStateException, EJBException {
    if (initialExpiration == null) {
        throw new IllegalArgumentException("initialExpiration is null");
    }
    if (initialExpiration.getTime() < 0) {
        throw new IllegalArgumentException("initialExpiration is negative: " + initialExpiration.getTime());
    }
    if (intervalDuration < 0) {
        throw new IllegalArgumentException("intervalDuration is negative: " + intervalDuration);
    }
    checkState();

    try {
        final TimerData timerData = timerStore.createIntervalTimer(this,
            (String) deployment.getDeploymentID(),
            primaryKey,
            timeoutMethod,
            initialExpiration,
            intervalDuration,
            timerConfig);
        initializeNewTimer(timerData);
        return timerData.getTimer();
    } catch (final TimerStoreException e) {
        throw new EJBException(e);
    }
}
 

public Timer createTimer(final Date expiration, final Serializable info) throws IllegalArgumentException, IllegalStateException, EJBException {
    return ejbTimerService.createTimer(primaryKey, ejbTimeout, expiration, new TimerConfig(info, true));
}
 

public Timer createTimer(final long duration, final Serializable info) throws IllegalArgumentException, IllegalStateException, EJBException {
    return ejbTimerService.createTimer(primaryKey, ejbTimeout, duration, new TimerConfig(info, true));
}
 

public Timer createTimer(final Date initialExpiration, final long intervalDuration, final Serializable info) throws IllegalArgumentException, IllegalStateException, EJBException {
    return ejbTimerService.createTimer(primaryKey, ejbTimeout, initialExpiration, intervalDuration, new TimerConfig(info, true));
}
 

public IntervalTimerData(final long id, final EjbTimerServiceImpl timerService, final String deploymentId, final Object primaryKey, final Method timeoutMethod, final TimerConfig timerConfig, final Date initialExpiration, final long intervalDuration) {
    super(id, timerService, deploymentId, primaryKey, timeoutMethod, timerConfig);
    this.initialExpiration = initialExpiration;
    this.intervalDuration = intervalDuration;
}