nosu
/
taskana
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

TSK-567 Create scheduler task job

This commit is contained in:
Martin Rojas Miguel Angel 2018-06-20 10:32:26 +02:00 committed by Holger Hagen
parent 4c6c3f30ad
commit 8b060b2a39
3 changed files with 186 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
lib/taskana-core/src/main/java/pro/taskana/impl/JobTaskRunner.java Normal file
View File

@ -0,0 +1,58 @@
package pro.taskana.impl;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.BulkOperationResults;
import pro.taskana.TaskService;
import pro.taskana.TaskSummary;
import pro.taskana.TaskanaEngine;
import pro.taskana.TimeInterval;
import pro.taskana.exceptions.TaskanaException;
/**
* This is the runner for Tasks jobs.
*
* @author mmr
*/
public class JobTaskRunner {
private static final Logger LOGGER = LoggerFactory.getLogger(TaskServiceImpl.class);
private TaskanaEngineImpl taskanaEngine;
private TaskServiceImpl taskService;
public JobTaskRunner(TaskanaEngine taskanaEngine, TaskService taskService) {
this.taskanaEngine = (TaskanaEngineImpl) taskanaEngine;
this.taskService = (TaskServiceImpl) taskService;
}
public BulkOperationResults<String, TaskanaException> runCleanCompletedTasks(Instant untilDate) {
return cleanCompletedTasks(untilDate);
}
private BulkOperationResults<String, TaskanaException> cleanCompletedTasks(Instant untilDate) {
LOGGER.info("entry to RunCompletedTasks({})", untilDate.toString());
BulkOperationResults<String, TaskanaException> bulkLog = new BulkOperationResults<>();
try {
List<String> tasksIds = new ArrayList<>();
List<TaskSummary> tasksCompleted = taskService.createTaskQuery()
.completedWithin(new TimeInterval(null, untilDate))
.list();
tasksCompleted.stream().forEach(task -> {
tasksIds.add(task.getTaskId());
LOGGER.info("task id deleted: {}", task.getTaskId());
});
bulkLog = taskService.deleteTasks(tasksIds);
} catch (Exception e) {
taskanaEngine.returnConnection();
LOGGER.info("exit from RunCompletedTasks(). Returning result {} ", bulkLog);
}
LOGGER.info("exit from RunCompletedTasks({})", untilDate.toString());
return bulkLog;
}
}

104
lib/taskana-core/src/test/java/acceptance/task/JobTaskRunnerAccTest.java Normal file
View File

@ -0,0 +1,104 @@
package acceptance.task;
import static junit.framework.TestCase.assertTrue;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import acceptance.AbstractAccTest;
import pro.taskana.BulkOperationResults;
import pro.taskana.Task;
import pro.taskana.TaskService;
import pro.taskana.TaskSummary;
import pro.taskana.TimeInterval;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.InvalidOwnerException;
import pro.taskana.exceptions.InvalidStateException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.TaskAlreadyExistException;
import pro.taskana.exceptions.TaskNotFoundException;
import pro.taskana.exceptions.TaskanaException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.JobTaskRunner;
import pro.taskana.security.JAASRunner;
import pro.taskana.security.WithAccessId;
/**
* Acceptance test for all "jobs tasks runner" scenarios.
*/
@RunWith(JAASRunner.class)
public class JobTaskRunnerAccTest extends AbstractAccTest {
TaskService taskService;
@Before
public void before() {
taskService = taskanaEngine.getTaskService();
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"group_1", "group_2"})
@Test
public void shouldCleanCompletedTasksUntilDate() {
JobTaskRunner runner = new JobTaskRunner(taskanaEngine, taskService);
Instant completeUntilDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIN)
.atZone(ZoneId.systemDefault())
.minusDays(14)
.toInstant();
List<TaskSummary> tasksCompletedUntilDateBefore = getTaskCompletedUntilDate(completeUntilDate);
BulkOperationResults<String, TaskanaException> results = runner.runCleanCompletedTasks(completeUntilDate);
List<TaskSummary> tasksCompletedUntilDateAfter = getTaskCompletedUntilDate(completeUntilDate);
assertFalse(results.containsErrors());
assertTrue(tasksCompletedUntilDateBefore.size() > 0);
assertTrue(tasksCompletedUntilDateAfter.size() == 0);
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"group_1", "group_2"})
@Test
public void shouldNotCleanCompleteTasksAfterDefinedDay()
throws TaskNotFoundException, NotAuthorizedException, InvalidStateException, InvalidOwnerException,
TaskAlreadyExistException, InvalidArgumentException, WorkbasketNotFoundException,
ClassificationNotFoundException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Task createdTask = taskService.createTask(newTask);
taskService.claim(createdTask.getId());
taskService.completeTask(createdTask.getId());
JobTaskRunner runner = new JobTaskRunner(taskanaEngine, taskService);
Instant completeUntilDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIN)
.atZone(ZoneId.systemDefault())
.minusDays(14)
.toInstant();
runner.runCleanCompletedTasks(completeUntilDate);
Task completedCreatedTask = taskService.getTask(createdTask.getId());
assertNotNull(completedCreatedTask);
}
private List<TaskSummary> getTaskCompletedUntilDate(Instant date) {
return taskService.createTaskQuery()
.completedWithin(new TimeInterval(null, date))
.list();
}
}

24
rest/taskana-rest-spring-example/src/main/java/pro/taskana/rest/JobScheduler.java
View File

@ -1,5 +1,10 @@
package pro.taskana.rest;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
@ -12,7 +17,9 @@ import org.springframework.stereotype.Component;
import pro.taskana.BulkOperationResults;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaTransactionProvider;
import pro.taskana.exceptions.TaskanaException;
import pro.taskana.impl.JobRunner;
import pro.taskana.impl.JobTaskRunner;
import pro.taskana.impl.util.LoggerUtils;
/**
@ -23,6 +30,7 @@ import pro.taskana.impl.util.LoggerUtils;
@Component
public class JobScheduler {
private final long untilDays = 14;
private static final Logger LOGGER = LoggerFactory.getLogger(JobScheduler.class);
private static AtomicBoolean jobRunning = new AtomicBoolean(false);
@ -50,4 +58,20 @@ public class JobScheduler {
LOGGER.info("Don't run Jobs because already another JobRunner is running");
}
}
// Run everyDay at mid night
@Scheduled(cron = "0 0 0 * * *")
public void triggerTaskCompletedCleanUpJob() {
LOGGER.info("triggerTaskCompletedCleanUpJob");
JobTaskRunner runner = new JobTaskRunner(taskanaEngine, taskanaEngine.getTaskService());
Instant completeUntilDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIN)
.atZone(ZoneId.systemDefault())
.minusDays(untilDays)
.toInstant();
BulkOperationResults<String, TaskanaException> result = runner.runCleanCompletedTasks(completeUntilDate);
Map<String, TaskanaException> errors = result.getErrorMap();
LOGGER.info("triggerTaskCompletedCleanUpJob Completed Result = {} ", LoggerUtils.mapToString(errors));
}
}