protected Object executeTask(ScheduledTask task) { switch (task.getDefinedBy()) { case BEAN: { log.trace("{}: invoking bean", task); Object bean = AppBeans.get(task.getBeanName()); try { List<MethodParameterInfo> methodParams = task.getMethodParameters(); Class[] paramTypes = new Class[methodParams.size()]; Object[] paramValues = new Object[methodParams.size()]; Method method = bean.getClass().getMethod(task.getMethodName(), paramTypes); return method.invoke(bean, paramValues); } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) { Class taskClass = scripting.loadClass(task.getClassName()); Callable callable = (Callable) taskClass.newInstance(); return callable.call(); } catch (InstantiationException | IllegalAccessException e) { throw new RuntimeException(String.format("An error occurred while instantiating class %s.", task.getClassName()), e); } catch (Exception e) { throw new RuntimeException( String.format("An error occurred while running method call() of class %s.", task.getClassName()), e); return scripting.runGroovyScript(task.getScriptName(), Collections.<String, Object>emptyMap()); throw new IllegalStateException( String.format("\"Defined by\" field has illegal value: %s. Task id: [%s].", task.getDefinedBy(), task.getId()));
protected boolean checkAllTasksHaveSameStatus(Set<ScheduledTask> tasks) { if (!tasks.isEmpty()) { boolean firstItemState = BooleanUtils.isTrue(tasks.iterator().next().getActive()); for (ScheduledTask task : tasks) { if (BooleanUtils.isTrue(task.getActive()) != firstItemState) { return false; } } return true; } else { return false; } }
@Override public boolean setRunning(ScheduledTask task, boolean running) { log.trace("{}: mark running={}", task, running); if (running) { task.setCurrentStartTimestamp(timeSource.currentTimeMillis()); Long prev = runningTasks.putIfAbsent(task, task.getCurrentStartTimestamp()); return prev != null; } else { Long startTime = runningTasks.get(task); if (Objects.equals(task.getCurrentStartTimestamp(), startTime)) { runningTasks.remove(task); } return false; } }
@Override public boolean isLastExecutionFinished(ScheduledTask task, long now) { EntityManager em = persistence.getEntityManager(); Query query = em.createQuery( "select e.finishTime from sys$ScheduledExecution e where e.task.id = ?1 and e.startTime = ?2"); query.setParameter(1, task.getId()); query.setParameter(2, task.getLastStartTime()); List list = query.getResultList(); if (list.isEmpty() || list.get(0) == null) { // Execution finish was not registered for some reason, so using timeout value or just return false boolean result = task.getTimeout() != null && (task.getLastStart() + task.getTimeout() * 1000) <= now; if (result) log.trace(task + ": considered finished because of timeout"); else log.trace(task + ": not finished and not timed out"); return result; } Date date = (Date) list.get(0); log.trace("{} : finished at {}", task, date.getTime()); return true; }
/** * Method reads values of methodName and parameters from item, * finds appropriate MethodInfo object in methodInfoField's optionsList * and sets found value to methodInfoField */ protected void setInitialMethodNameValue(ScheduledTask task) { if (availableMethods == null) return; List<MethodParameterInfo> methodParamInfos = task.getMethodParameters(); MethodInfo currentMethodInfo = new MethodInfo(task.getMethodName(), methodParamInfos); for (MethodInfo availableMethod : availableMethods) { if (currentMethodInfo.definitionEquals(availableMethod)) { availableMethod.setParameters(currentMethodInfo.getParameters()); methodNameField.setValue(availableMethod); break; } } }
protected ScheduledExecution registerExecutionStart(ScheduledTask task, long now) { if (!BooleanUtils.isTrue(task.getLogStart()) && !BooleanUtils.isTrue(task.getSingleton()) && task.getSchedulingType() != SchedulingType.FIXED_DELAY) return null; log.trace("{}: registering execution start", task); Transaction tx = persistence.createTransaction(); try { EntityManager em = persistence.getEntityManager(); ScheduledExecution execution = metadata.create(ScheduledExecution.class); execution.setTask(em.getReference(ScheduledTask.class, task.getId())); execution.setStartTime(new Date(now)); execution.setServer(serverInfo.getServerId()); em.persist(execution); tx.commit(); return execution; } finally { tx.end(); } }
@MetaProperty public String getMethodParametersString() { StringBuilder sb = new StringBuilder(); int count = 0; List<MethodParameterInfo> parameters = getMethodParameters(); for (MethodParameterInfo param : parameters) { sb.append(param.getType().getSimpleName()) .append(" ") .append(param.getName()) .append(" = ") .append(param.getValue()); if (++count != parameters.size()) sb.append(", "); } return sb.toString(); } }
@Override public void setActive(Set<ScheduledTask> tasks, boolean active) { try (Transaction tx = persistence.createTransaction()) { EntityManager em = persistence.getEntityManager(); for (ScheduledTask task : tasks) { ScheduledTask t = em.find(ScheduledTask.class, task.getId()); t.setActive(active); } tx.commit(); } }
@Override public void setItem(Entity item) { super.setItem(item); if (StringUtils.isNotEmpty(getItem().getMethodName())) { setInitialMethodNameValue(getItem()); } }
protected long calculateNextCronDate(ScheduledTask task, long date, long currentDate, long frame) { CronSequenceGenerator cronSequenceGenerator = new CronSequenceGenerator(task.getCron(), getCurrentTimeZone()); //if last start = 0 (task never has run) or to far in the past, we use (NOW - FRAME) timestamp for pivot time //this approach should work fine cause cron works with absolute time long pivotPreviousTime = Math.max(date, currentDate - frame); Date currentStart = null; Date nextDate = cronSequenceGenerator.next(new Date(pivotPreviousTime)); while (nextDate.getTime() < currentDate) {//if next date is in past try to find next date nearest to now currentStart = nextDate; nextDate = cronSequenceGenerator.next(nextDate); } if (currentStart == null) { currentStart = nextDate; } log.trace("{}\n now={} frame={} currentStart={} lastStart={} cron={}", task, currentDate, frame, currentStart, task.getCron()); return currentStart.getTime(); }
@Override public long getLastFinished(ScheduledTask task) { EntityManager em = persistence.getEntityManager(); Query query = em.createQuery( "select max(e.finishTime) from sys$ScheduledExecution e where e.task.id = ?1") .setParameter(1, task.getId()); Date date = (Date) query.getFirstResult(); return date == null ? 0 : date.getTime(); }
protected boolean checkAllTasksIsNotActive(Set<ScheduledTask> tasks) { if (!tasks.isEmpty()) { for (ScheduledTask task : tasks) { if (BooleanUtils.isTrue(task.getActive())) { return false; } } return true; } else { return false; } }
@Override public boolean isApplicable() { ScheduledTask task = tasksTable.getSingleSelected(); return task != null && !BooleanUtils.isTrue(task.getActive()); } }
.withHandler(e -> { Set<ScheduledTask> tasks = tasksTable.getSelected(); service.setActive(tasks, !BooleanUtils.isTrue(tasks.iterator().next().getActive())); tasksDs.refresh(); })); Set<ScheduledTask> selected = tasksTable.getSelected(); boolean isSingleSelected = selected.size() == 1; boolean enableEdit = isSingleSelected && !BooleanUtils.isTrue(singleSelected.getActive()); activateBtn.setCaption(getMessage("activate")); } else { activateBtn.setCaption(BooleanUtils.isTrue(singleSelected.getActive()) ? getMessage("deactivate") : getMessage("activate"));