Examples with Wait com.netflix.conductor.core.execution.tasks.Wait used on opensource projects

Example 1 with Wait

use of com.netflix.conductor.core.execution.tasks.Wait in project conductor by Netflix.

the class QueueManager method startMonitor.

private void startMonitor(Status status, ObservableQueue queue) {
    queue.observe().subscribe((Message msg) -> {
        try {
            logger.debug("Got message {}", msg.getPayload());
            String payload = msg.getPayload();
            JsonNode payloadJSON = objectMapper.readTree(payload);
            String externalId = getValue("externalId", payloadJSON);
            if (externalId == null || "".equals(externalId)) {
                logger.error("No external Id found in the payload {}", payload);
                queue.ack(Collections.singletonList(msg));
                return;
            }
            JsonNode json = objectMapper.readTree(externalId);
            String workflowId = getValue("workflowId", json);
            String taskRefName = getValue("taskRefName", json);
            String taskId = getValue("taskId", json);
            if (workflowId == null || "".equals(workflowId)) {
                // This is a bad message, we cannot process it
                logger.error("No workflow id found in the message. {}", payload);
                queue.ack(Collections.singletonList(msg));
                return;
            }
            Workflow workflow = executionService.getExecutionStatus(workflowId, true);
            Optional<Task> taskOptional;
            if (StringUtils.isNotEmpty(taskId)) {
                taskOptional = workflow.getTasks().stream().filter(task -> !task.getStatus().isTerminal() && task.getTaskId().equals(taskId)).findFirst();
            } else if (StringUtils.isEmpty(taskRefName)) {
                logger.error("No taskRefName found in the message. If there is only one WAIT task, will mark it as completed. {}", payload);
                taskOptional = workflow.getTasks().stream().filter(task -> !task.getStatus().isTerminal() && task.getTaskType().equals(Wait.NAME)).findFirst();
            } else {
                taskOptional = workflow.getTasks().stream().filter(task -> !task.getStatus().isTerminal() && task.getReferenceTaskName().equals(taskRefName)).findFirst();
            }
            if (!taskOptional.isPresent()) {
                logger.error("No matching tasks found to be marked as completed for workflow {}, taskRefName {}, taskId {}", workflowId, taskRefName, taskId);
                queue.ack(Collections.singletonList(msg));
                return;
            }
            Task task = taskOptional.get();
            task.setStatus(status);
            task.getOutputData().putAll(objectMapper.convertValue(payloadJSON, _mapType));
            executionService.updateTask(task);
            List<String> failures = queue.ack(Collections.singletonList(msg));
            if (!failures.isEmpty()) {
                logger.error("Not able to ack the messages {}", failures.toString());
            }
        } catch (JsonParseException e) {
            logger.error("Bad message? : {} ", msg, e);
            queue.ack(Collections.singletonList(msg));
        } catch (ApplicationException e) {
            if (e.getCode().equals(Code.NOT_FOUND)) {
                logger.error("Workflow ID specified is not valid for this environment");
                queue.ack(Collections.singletonList(msg));
            }
            logger.error("Error processing message: {}", msg, e);
        } catch (Exception e) {
            logger.error("Error processing message: {}", msg, e);
        }
    }, (Throwable t) -> {
        logger.error(t.getMessage(), t);
    });
    logger.info("QueueListener::STARTED...listening for " + queue.getName());
}

Example 2 with Wait

use of com.netflix.conductor.core.execution.tasks.Wait in project conductor by Netflix.

the class TestWorkflowExecutor method testScheduleTask.

@Test
public void testScheduleTask() {
    AtomicBoolean httpTaskExecuted = new AtomicBoolean(false);
    AtomicBoolean http2TaskExecuted = new AtomicBoolean(false);
    new Wait();
    new WorkflowSystemTask("HTTP") {

        @Override
        public boolean isAsync() {
            return true;
        }

        @Override
        public void start(Workflow workflow, Task task, WorkflowExecutor executor) {
            httpTaskExecuted.set(true);
            task.setStatus(Status.COMPLETED);
            super.start(workflow, task, executor);
        }
    };
    new WorkflowSystemTask("HTTP2") {

        @Override
        public void start(Workflow workflow, Task task, WorkflowExecutor executor) {
            http2TaskExecuted.set(true);
            task.setStatus(Status.COMPLETED);
            super.start(workflow, task, executor);
        }
    };
    Workflow workflow = new Workflow();
    workflow.setWorkflowId("1");
    List<Task> tasks = new LinkedList<>();
    WorkflowTask taskToSchedule = new WorkflowTask();
    taskToSchedule.setWorkflowTaskType(TaskType.USER_DEFINED);
    taskToSchedule.setType("HTTP");
    WorkflowTask taskToSchedule2 = new WorkflowTask();
    taskToSchedule2.setWorkflowTaskType(TaskType.USER_DEFINED);
    taskToSchedule2.setType("HTTP2");
    WorkflowTask wait = new WorkflowTask();
    wait.setWorkflowTaskType(TaskType.WAIT);
    wait.setType("WAIT");
    wait.setTaskReferenceName("wait");
    Task task1 = new Task();
    task1.setTaskType(taskToSchedule.getType());
    task1.setTaskDefName(taskToSchedule.getName());
    task1.setReferenceTaskName(taskToSchedule.getTaskReferenceName());
    task1.setWorkflowInstanceId(workflow.getWorkflowId());
    task1.setCorrelationId(workflow.getCorrelationId());
    task1.setScheduledTime(System.currentTimeMillis());
    task1.setTaskId(IDGenerator.generate());
    task1.setInputData(new HashMap<>());
    task1.setStatus(Status.SCHEDULED);
    task1.setRetryCount(0);
    task1.setCallbackAfterSeconds(taskToSchedule.getStartDelay());
    task1.setWorkflowTask(taskToSchedule);
    Task task2 = new Task();
    task2.setTaskType(Wait.NAME);
    task2.setTaskDefName(taskToSchedule.getName());
    task2.setReferenceTaskName(taskToSchedule.getTaskReferenceName());
    task2.setWorkflowInstanceId(workflow.getWorkflowId());
    task2.setCorrelationId(workflow.getCorrelationId());
    task2.setScheduledTime(System.currentTimeMillis());
    task2.setInputData(new HashMap<>());
    task2.setTaskId(IDGenerator.generate());
    task2.setStatus(Status.IN_PROGRESS);
    task2.setWorkflowTask(taskToSchedule);
    Task task3 = new Task();
    task3.setTaskType(taskToSchedule2.getType());
    task3.setTaskDefName(taskToSchedule.getName());
    task3.setReferenceTaskName(taskToSchedule.getTaskReferenceName());
    task3.setWorkflowInstanceId(workflow.getWorkflowId());
    task3.setCorrelationId(workflow.getCorrelationId());
    task3.setScheduledTime(System.currentTimeMillis());
    task3.setTaskId(IDGenerator.generate());
    task3.setInputData(new HashMap<>());
    task3.setStatus(Status.SCHEDULED);
    task3.setRetryCount(0);
    task3.setCallbackAfterSeconds(taskToSchedule.getStartDelay());
    task3.setWorkflowTask(taskToSchedule);
    tasks.add(task1);
    tasks.add(task2);
    tasks.add(task3);
    when(executionDAOFacade.createTasks(tasks)).thenReturn(tasks);
    AtomicInteger startedTaskCount = new AtomicInteger(0);
    doAnswer(invocation -> {
        startedTaskCount.incrementAndGet();
        return null;
    }).when(executionDAOFacade).updateTask(any());
    AtomicInteger queuedTaskCount = new AtomicInteger(0);
    final Answer answer = invocation -> {
        String queueName = invocation.getArgument(0, String.class);
        System.out.println(queueName);
        queuedTaskCount.incrementAndGet();
        return null;
    };
    doAnswer(answer).when(queueDAO).push(any(), any(), anyLong());
    doAnswer(answer).when(queueDAO).push(any(), any(), anyInt(), anyLong());
    boolean stateChanged = workflowExecutor.scheduleTask(workflow, tasks);
    assertEquals(2, startedTaskCount.get());
    assertEquals(1, queuedTaskCount.get());
    assertTrue(stateChanged);
    assertFalse(httpTaskExecuted.get());
    assertTrue(http2TaskExecuted.get());
}

Example 3 with Wait

use of com.netflix.conductor.core.execution.tasks.Wait in project conductor by Netflix.

the class TestWorkflowExecutor method testExecuteSystemTask.

@Test
public void testExecuteSystemTask() {
    String workflowId = "workflow-id";
    Wait wait = new Wait();
    String task1Id = IDGenerator.generate();
    Task task1 = new Task();
    task1.setTaskType(TaskType.WAIT.name());
    task1.setReferenceTaskName("waitTask");
    task1.setWorkflowInstanceId(workflowId);
    task1.setScheduledTime(System.currentTimeMillis());
    task1.setTaskId(task1Id);
    task1.setStatus(Status.SCHEDULED);
    Workflow workflow = new Workflow();
    workflow.setWorkflowId(workflowId);
    workflow.setStatus(Workflow.WorkflowStatus.RUNNING);
    when(executionDAOFacade.getTaskById(anyString())).thenReturn(task1);
    when(executionDAOFacade.getWorkflowById(anyString(), anyBoolean())).thenReturn(workflow);
    workflowExecutor.executeSystemTask(wait, task1Id, 30);
    assertEquals(Status.IN_PROGRESS, task1.getStatus());
}