public void registerTimer(final TimerInstance timer, String processId, Map<String, Object> params) { try { kruntime.startOperation(); timer.setId(++timerId); timer.setProcessInstanceId(-1l); timer.setSessionId(((StatefulKnowledgeSession) kruntime).getIdentifier()); timer.setActivated(new Date()); Trigger trigger = null; if (timer.getCronExpression() != null) { Date startTime = new Date(timerService.getCurrentTime() + 1000); trigger = new CronTrigger(timerService.getCurrentTime(), startTime, null, -1, timer.getCronExpression(), null, null); // cron timers are by nature repeatable timer.setPeriod(1); } else { trigger = new IntervalTrigger(timerService.getCurrentTime(), null, null, timer.getRepeatLimit(), timer.getDelay(), timer.getPeriod(), null, null); } StartProcessJobContext ctx = new StartProcessJobContext(timer, trigger, processId, params, this.kruntime); JobHandle jobHandle = this.timerService.scheduleJob(startProcessJob, ctx, trigger); timer.setJobHandle(jobHandle); timers.put(timer.getId(), timer); } finally { kruntime.endOperation(); } }
public static TimerInstance readTimer(MarshallerReaderContext context, JBPMMessages.ProcessTimer.TimerInstance _timer) { TimerInstance timer = new TimerInstance(); timer.setId( _timer.getId()); timer.setTimerId( _timer.getTimerId() ); timer.setDelay( _timer.getDelay() ); timer.setPeriod( _timer.getPeriod() ); timer.setProcessInstanceId( _timer.getProcessInstanceId() ); if (_timer.hasDEPRECATEDSessionId()) { timer.setSessionId( _timer.getDEPRECATEDSessionId() ); } else { timer.setSessionId( _timer.getSessionId() ); } timer.setActivated( new Date( _timer.getActivatedTime() ) ); if ( _timer.hasLastTriggered() ) { timer.setLastTriggered( new Date( _timer.getLastTriggered() ) ); } timer.setRepeatLimit(_timer.getRepeatLimit()); return timer; }
public static JBPMMessages.ProcessTimer.TimerInstance writeTimer(MarshallerWriteContext context, TimerInstance timer) { Builder _timer = JBPMMessages.ProcessTimer.TimerInstance.newBuilder() .setId( timer.getId() ) .setTimerId( timer.getTimerId() ) .setSessionId( timer.getSessionId() ) .setDelay( timer.getDelay() ) .setPeriod( timer.getPeriod() ) .setProcessInstanceId( timer.getProcessInstanceId() ) .setActivatedTime( timer.getActivated().getTime() ) .setRepeatLimit(timer.getRepeatLimit()); Date lastTriggered = timer.getLastTriggered(); if ( lastTriggered != null ) { _timer.setLastTriggered( lastTriggered.getTime() ); } return _timer.build(); }
protected TimerInstance rescheduleTimer(TimerInstance timer, TimerManager tm) { logger.debug("Found timer {} that is going to be canceled", timer); tm.cancelTimer(timer.getTimerId()); logger.debug("Timer {} canceled successfully", timer); TimerInstance newTimer = new TimerInstance(); if (delay != 0) { newTimer.setDelay(calculateDelay(delay, timer)); } newTimer.setPeriod(period); newTimer.setRepeatLimit(repeatLimit); newTimer.setTimerId(timer.getTimerId()); return newTimer; } }
public void internalAddTimer(final TimerInstance timer) { long delay; Date lastTriggered = timer.getLastTriggered(); if (lastTriggered == null) { Date activated = timer.getActivated(); Date now = new Date(); long timespan = now.getTime() - activated.getTime(); delay = timer.getDelay() - timespan; if (delay < 0) { delay = 0; } } else { Date now = new Date(); long timespan = now.getTime() - lastTriggered.getTime(); delay = timespan - timer.getPeriod(); if (delay < 0) { delay = 0; } } Trigger trigger = new IntervalTrigger(timerService.getCurrentTime(), null, null, -1, delay, timer.getPeriod(), null, null); ProcessJobContext ctx = new ProcessJobContext(timer, trigger, timer.getProcessInstanceId(), this.kruntime); JobHandle jobHandle = this.timerService.scheduleJob(processJob, ctx, trigger); timer.setJobHandle(jobHandle); timers.put(timer.getId(), timer); }
public void signalEvent(String type, Object event) { if ("timerTriggered".equals(type)) { TimerInstance timer = (TimerInstance) event; logger.info("Timer {} triggered", timer.getId()); counter++; } } };
ctx.getTimer().setLastTriggered( new Date(ctx.getKnowledgeRuntime().<SessionClock> getSessionClock().getCurrentTime())); ctx.getTimer().setPeriod(0); if (ctx.getTimer().getPeriod() == 0) { tm.getTimerMap().remove(ctx.getTimer().getId()); tm.getTimerService().removeJob(ctx.getJobHandle());
protected void updateBasedOnTrigger(TimerInstance timerInstance) { Trigger trigger = ((DefaultJobHandle)timerInstance.getJobHandle()).getTimerJobInstance().getTrigger(); if (trigger instanceof IntervalTrigger && timerInstance.getPeriod() > 0) { IntervalTrigger intervalTrigger = (IntervalTrigger) trigger; if (timerInstance.getRepeatLimit() > 0) { timerInstance.setRepeatLimit(intervalTrigger.getRepeatLimit() - intervalTrigger.getRepeatCount() + 1); // +1 because repeatCount contains also one last scheduled, but cancelled trigger } long delay; if (intervalTrigger.getLastFireTime() != null) { // it is already fired calculate the new delay using the period instead of the delay delay = timerInstance.getPeriod() - (System.currentTimeMillis() - intervalTrigger.getLastFireTime().getTime()); } else { delay = timerInstance.getDelay() - (System.currentTimeMillis() - intervalTrigger.getCreatedTime().getTime()); } timerInstance.setDelay(delay); } }
TimerInstance timer = new TimerInstance(); timerManager.registerTimer(timer, processInstance); try { timer = new TimerInstance(); timer.setDelay(500); timerManager.registerTimer(timer, processInstance); assertEquals(0, counter); timer = new TimerInstance(); timer.setDelay(500); timer.setPeriod(300); timerManager.registerTimer(timer, processInstance); assertEquals(0, counter); timerManager.cancelTimer(timer.getId()); int lastCount = counter; try {
protected TimerInstance createTimerInstance(Timer timer, InternalKnowledgeRuntime kruntime) { TimerInstance timerInstance = new TimerInstance(); if (kruntime != null && kruntime.getEnvironment().get("jbpm.business.calendar") != null){ BusinessCalendar businessCalendar = (BusinessCalendar) kruntime.getEnvironment().get("jbpm.business.calendar"); String delay = timer.getDelay(); timerInstance.setDelay(businessCalendar.calculateBusinessTimeAsDuration(delay)); if (timer.getPeriod() == null) { timerInstance.setPeriod(0); } else { String period = timer.getPeriod(); timerInstance.setPeriod(businessCalendar.calculateBusinessTimeAsDuration(period)); } } else { configureTimerInstance(timer, timerInstance); } timerInstance.setTimerId(timer.getId()); return timerInstance; }
public void configureSLA() { String slaDueDateExpression = (String) getProcess().getMetaData().get("customSLADueDate"); if (slaDueDateExpression != null) { TimerInstance timer = configureSLATimer(slaDueDateExpression); if (timer != null) { this.slaTimerId = timer.getId(); this.slaDueDate = new Date(System.currentTimeMillis() + timer.getDelay()); this.slaCompliance = SLA_PENDING; logger.debug("SLA for process instance {} is PENDING with due date {}", this.getId(), this.slaDueDate); } } }
TimerInstance timerInstance = entry.getValue().get(0); long delay = timerInstance.getDelay() - (System.currentTimeMillis() - timerInstance.getActivated().getTime()); timerInstance.setDelay(delay); ((TimerNodeInstance) active).internalSetTimerId(timerInstance.getId()); } else if (active instanceof StateBasedNodeInstance) { List<Long> timers = new ArrayList<>(); for (TimerInstance timerInstance : timerInstances) { long delay = timerInstance.getDelay() - (System.currentTimeMillis() - timerInstance.getActivated().getTime()); timerInstance.setDelay(delay); timers.add(timerInstance.getId());
protected TimerInstance createTimerInstance(Timer timer) { TimerInstance timerInstance = new TimerInstance(); KieRuntime kruntime = getProcessInstance().getKnowledgeRuntime(); if (kruntime != null && kruntime.getEnvironment().get("jbpm.business.calendar") != null){ timerInstance.setCronExpression(timer.getDelay()); } else { int repeatLimit = Integer.parseInt(tempRepeatLimit); if (repeatLimit > -1) { timerInstance.setRepeatLimit(repeatLimit+1); timerInstance.setDelay(businessCalendar.calculateBusinessTimeAsDuration(tempDelay)); timerInstance.setPeriod(0); } else { timerInstance.setPeriod(businessCalendar.calculateBusinessTimeAsDuration(tempPeriod)); delay = resolveVariable(timer.getDelay()); timerInstance.setDelay(businessCalendar.calculateBusinessTimeAsDuration(delay)); timerInstance.setPeriod(0); break; case Timer.TIME_DATE: configureTimerInstance(timer, timerInstance); timerInstance.setTimerId(timer.getId()); return timerInstance;
public TimerInstance configureSLATimer(String slaDueDateExpression) { // setup SLA if provided slaDueDateExpression = resolveVariable(slaDueDateExpression); if (slaDueDateExpression == null || slaDueDateExpression.trim().isEmpty()) { logger.debug("Sla due date expression resolved to no value '{}'", slaDueDateExpression); return null; } logger.debug("SLA due date is set to {}", slaDueDateExpression); InternalKnowledgeRuntime kruntime = getKnowledgeRuntime(); long duration = -1; if (kruntime != null && kruntime.getEnvironment().get("jbpm.business.calendar") != null){ BusinessCalendar businessCalendar = (BusinessCalendar) kruntime.getEnvironment().get("jbpm.business.calendar"); duration = businessCalendar.calculateBusinessTimeAsDuration(slaDueDateExpression); } else { duration = DateTimeUtils.parseDuration(slaDueDateExpression); } TimerInstance timerInstance = new TimerInstance(); timerInstance.setId(-1); timerInstance.setDelay(duration); timerInstance.setPeriod(0); if (useTimerSLATracking()) { ((InternalProcessRuntime)kruntime.getProcessRuntime()).getTimerManager().registerTimer(timerInstance, this); } return timerInstance; }
case Timer.TIME_CYCLE: if (timer.getPeriod() != null) { timerInstance.setDelay(resolveValue(timer.getDelay())); if (timer.getPeriod() == null) { timerInstance.setPeriod(0); } else { timerInstance.setPeriod(resolveValue(timer.getPeriod())); timerInstance.setCronExpression(resolvedDelay); } else { int parsedReapedCount = (int)repeatValues[0]; if (parsedReapedCount > -1) { timerInstance.setRepeatLimit(parsedReapedCount+1); timerInstance.setDelay(repeatValues[1]); timerInstance.setPeriod(repeatValues[2]); }else if (repeatValues.length == 2) { timerInstance.setDelay(repeatValues[0]); timerInstance.setPeriod(repeatValues[1]); } else { timerInstance.setDelay(repeatValues[0]); timerInstance.setPeriod(0); timerInstance.setDelay(duration); timerInstance.setPeriod(0); break; case Timer.TIME_DATE:
int parsedReapedCount = (int)repeatValues[0]; if (parsedReapedCount > -1) { timerInstance.setRepeatLimit(parsedReapedCount+1); timerInstance.setDelay(repeatValues[1]); timerInstance.setPeriod(repeatValues[2]); } else { timerInstance.setDelay(repeatValues[0]); try { long period = DateTimeUtils.parseTimeString(timer.getPeriod()); timerInstance.setPeriod(period); } catch (RuntimeException e) { timerInstance.setPeriod(repeatValues[0]); timerInstance.setDelay(duration); timerInstance.setPeriod(0); break; case Timer.TIME_DATE: duration = DateTimeUtils.parseDateAsDuration(timer.getDate()); timerInstance.setDelay(duration); timerInstance.setPeriod(0); break;
public void deserialize(MarshallerReaderContext inCtx, Timer timer) throws ClassNotFoundException { JBPMMessages.ProcessTimer ptimer = timer.getExtension(JBPMMessages.procTimer); TimerService ts = inCtx.wm.getTimerService(); long processInstanceId = ptimer.getTimer().getProcessInstanceId(); Trigger trigger = ProtobufInputMarshaller.readTrigger(inCtx, ptimer.getTrigger()); TimerInstance timerInstance = ProtobufProcessMarshaller.readTimer(inCtx, ptimer.getTimer()); TimerManager tm = ((InternalProcessRuntime) inCtx.wm.getProcessRuntime()).getTimerManager(); // check if the timer instance is not already registered to avoid duplicated timers if (!tm.getTimerMap().containsKey(timerInstance.getId())) { ProcessJobContext pctx = new ProcessJobContext(timerInstance, trigger, processInstanceId, inCtx.wm.getKnowledgeRuntime(), false); Date date = trigger.hasNextFireTime(); if (date != null) { long then = date.getTime(); long now = pctx.getKnowledgeRuntime().getSessionClock().getCurrentTime(); // overdue timer if (then < now) { trigger = new OverdueTrigger(trigger, pctx.getKnowledgeRuntime()); } } JobHandle jobHandle = ts.scheduleJob(processJob, pctx, trigger); timerInstance.setJobHandle(jobHandle); pctx.setJobHandle(jobHandle); tm.getTimerMap().put(timerInstance.getId(), timerInstance); } } }
private void initTimer(InternalKnowledgeRuntime kruntime) { for (StartNode startNode : startNodes) { if (startNode != null && startNode.getTimer() != null) { TimerInstance timerInstance = null; if (startNode.getTimer().getDelay() != null && CronExpression.isValidExpression(startNode.getTimer().getDelay())) { timerInstance = new TimerInstance(); timerInstance.setCronExpression(startNode.getTimer().getDelay()); } else { timerInstance = createTimerInstance(startNode.getTimer(), kruntime); } timerManager.registerTimer(timerInstance, processId, null); } } }
public void dispose() { // for ( TimerInstance timer : timers.values() ) { // timerService.removeJob( timer.getJobHandle() ); // } if (timerService instanceof RegisteredTimerServiceDelegate) { timers.clear(); return; } for (Iterator<TimerInstance> it = timers.values().iterator(); it.hasNext();) { TimerInstance timer = it.next(); timerService.removeJob(timer.getJobHandle()); it.remove(); } timerService.shutdown(); }