@Override public void cancel(DbSession dbSession, CeQueueDto ceQueueDto) { checkState(PENDING.equals(ceQueueDto.getStatus()), "Task is in progress and can't be canceled [uuid=%s]", ceQueueDto.getUuid()); cancelImpl(dbSession, ceQueueDto); }
@Override public void fail(DbSession dbSession, CeQueueDto task, @Nullable String errorType, @Nullable String errorMessage) { checkState(IN_PROGRESS.equals(task.getStatus()), "Task is not in-progress and can't be marked as failed [uuid=%s]", task.getUuid()); CeActivityDto activityDto = new CeActivityDto(task); activityDto.setStatus(CeActivityDto.Status.FAILED); activityDto.setErrorType(errorType); activityDto.setErrorMessage(errorMessage); updateExecutionFields(activityDto); remove(dbSession, task, activityDto); }
int cancelAll(boolean includeInProgress) { int count = 0; try (DbSession dbSession = dbClient.openSession(false)) { for (CeQueueDto queueDto : dbClient.ceQueueDao().selectAllInAscOrder(dbSession)) { if (includeInProgress || !queueDto.getStatus().equals(IN_PROGRESS)) { cancelImpl(dbSession, queueDto); count++; } } return count; } }
private void verifyUnmodifiedTask(CeQueueDto originalDto) { CeQueueDto dto = db.getDbClient().ceQueueDao().selectByUuid(session, originalDto.getUuid()).get(); assertThat(dto.getStatus()).isEqualTo(originalDto.getStatus()); assertThat(dto.getCreatedAt()).isEqualTo(originalDto.getCreatedAt()); assertThat(dto.getUpdatedAt()).isEqualTo(originalDto.getUpdatedAt()); }
private void verifyUnmodified(CeQueueDto original) { CeQueueDto dto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), original.getUuid()).get(); assertThat(dto.getStatus()).isEqualTo(original.getStatus()); assertThat(dto.getCreatedAt()).isEqualTo(original.getCreatedAt()); assertThat(dto.getUpdatedAt()).isEqualTo(original.getUpdatedAt()); }
private void verifyInProgressUnchangedByResetToPendingForWorker(CeQueueDto original, String workerUuid, long startedAt) { CeQueueDto dto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), original.getUuid()).get(); assertThat(dto.getStatus()).isEqualTo(IN_PROGRESS); assertThat(dto.getStartedAt()).isEqualTo(startedAt); assertThat(dto.getCreatedAt()).isEqualTo(original.getCreatedAt()); assertThat(dto.getUpdatedAt()).isEqualTo(startedAt); assertThat(dto.getWorkerUuid()).isEqualTo(workerUuid); }
private void verifyUnchangedByResetToPendingForWorker(CeQueueDto original) { CeQueueDto dto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), original.getUuid()).get(); assertThat(dto.getStatus()).isEqualTo(original.getStatus()); assertThat(dto.getStartedAt()).isEqualTo(original.getStartedAt()); assertThat(dto.getCreatedAt()).isEqualTo(original.getCreatedAt()); assertThat(dto.getUpdatedAt()).isEqualTo(original.getUpdatedAt()); assertThat(dto.getWorkerUuid()).isEqualTo(original.getWorkerUuid()); }
public static void reset(DbSession dbSession, long now, CeQueueDto... ceQueueDtos) { Stream.of(ceQueueDtos).forEach(ceQueueDto -> { checkArgument(ceQueueDto.getStatus() == IN_PROGRESS); checkArgument(ceQueueDto.getWorkerUuid() != null); CeQueueMapper mapper = dbSession.getMapper(CeQueueMapper.class); int touchedRows = mapper.updateIf(ceQueueDto.getUuid(), new UpdateIf.NewProperties(PENDING, ceQueueDto.getUuid(), now, now), new UpdateIf.OldProperties(IN_PROGRESS)); assertThat(touchedRows).isEqualTo(1); }); } }
private void verifyResetToPendingForWorker(CeQueueDto original, String workerUuid, long startedAt) { CeQueueDto dto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), original.getUuid()).get(); assertThat(dto.getStatus()).isEqualTo(PENDING); assertThat(dto.getStartedAt()).isEqualTo(startedAt); assertThat(dto.getCreatedAt()).isEqualTo(original.getCreatedAt()); assertThat(dto.getUpdatedAt()).isGreaterThan(startedAt); assertThat(dto.getWorkerUuid()).isEqualTo(workerUuid); }
@Test public void test_selectByUuid() { CeQueueDto ceQueueDto = insertPending(TASK_UUID_1, MAIN_COMPONENT_UUID_1); assertThat(underTest.selectByUuid(db.getSession(), "TASK_UNKNOWN").isPresent()).isFalse(); CeQueueDto saved = underTest.selectByUuid(db.getSession(), TASK_UUID_1).get(); assertThat(saved.getUuid()).isEqualTo(TASK_UUID_1); assertThat(saved.getTaskType()).isEqualTo(CeTaskTypes.REPORT); assertThat(saved.getMainComponentUuid()).isEqualTo(MAIN_COMPONENT_UUID_1); assertThat(saved.getComponentUuid()).isEqualTo(ceQueueDto.getComponentUuid()); assertThat(saved.getStatus()).isEqualTo(PENDING); assertThat(saved.getSubmitterUuid()).isEqualTo("henri"); assertThat(saved.getWorkerUuid()).isNull(); assertThat(saved.getCreatedAt()).isEqualTo(INIT_TIME); assertThat(saved.getUpdatedAt()).isEqualTo(INIT_TIME); assertThat(saved.getStartedAt()).isNull(); }
private void verifyResetByResetTasks(CeQueueDto original, long startedAt) { CeQueueDto dto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), original.getUuid()).get(); assertThat(dto.getStatus()).isEqualTo(PENDING); assertThat(dto.getStartedAt()).isEqualTo(startedAt); assertThat(dto.getCreatedAt()).isEqualTo(original.getCreatedAt()); assertThat(dto.getUpdatedAt()).isGreaterThan(startedAt); assertThat(dto.getWorkerUuid()).isNull(); }
private void verifyReset(CeQueueDto original) { CeQueueDto dto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), original.getUuid()).get(); // We do not touch CreatedAt assertThat(dto.getCreatedAt()).isEqualTo(original.getCreatedAt()); // Status must have changed to PENDING and must not be equal to previous status assertThat(dto.getStatus()).isEqualTo(CeQueueDto.Status.PENDING).isNotEqualTo(original.getStatus()); // UpdatedAt must have been updated assertThat(dto.getUpdatedAt()).isNotEqualTo(original.getUpdatedAt()); assertThat(dto.getStartedAt()).isEqualTo(original.getStartedAt()); // WorkerUuid must be null assertThat(dto.getWorkerUuid()).isNull(); }
private void verifyResetTask(CeQueueDto originalDto) { CeQueueDto dto = db.getDbClient().ceQueueDao().selectByUuid(session, originalDto.getUuid()).get(); assertThat(dto.getStatus()).isEqualTo(CeQueueDto.Status.PENDING); assertThat(dto.getCreatedAt()).isEqualTo(originalDto.getCreatedAt()); assertThat(dto.getUpdatedAt()).isGreaterThan(originalDto.getUpdatedAt()); }
private Ce.Task formatQueue(CeQueueDto dto, DtoCache cache) { Ce.Task.Builder builder = Ce.Task.newBuilder(); String organizationKey = cache.getOrganizationKey(dto.getComponentUuid()); ofNullable(organizationKey).ifPresent(builder::setOrganization); if (dto.getComponentUuid() != null) { builder.setComponentId(dto.getComponentUuid()); setComponent(builder, dto.getComponentUuid(), cache); } builder.setId(dto.getUuid()); builder.setStatus(Ce.TaskStatus.valueOf(dto.getStatus().name())); builder.setType(dto.getTaskType()); builder.setLogs(false); cache.getUser(dto.getSubmitterUuid()).ifPresent(user -> builder.setSubmitterLogin(user.getLogin())); builder.setSubmittedAt(formatDateTime(new Date(dto.getCreatedAt()))); ofNullable(dto.getStartedAt()).map(DateUtils::formatDateTime).ifPresent(builder::setStartedAt); ofNullable(computeExecutionTimeMs(dto)).ifPresent(builder::setExecutionTimeMs); setBranchOrPullRequest(builder, dto.getUuid(), cache); return builder.build(); }
protected void remove(DbSession dbSession, CeQueueDto queueDto, CeActivityDto activityDto) { String taskUuid = queueDto.getUuid(); CeQueueDto.Status expectedQueueDtoStatus = queueDto.getStatus(); dbClient.ceActivityDao().insert(dbSession, activityDto); dbClient.ceTaskInputDao().deleteByUuids(dbSession, singleton(taskUuid)); int deletedTasks = dbClient.ceQueueDao().deleteByUuid(dbSession, taskUuid, new DeleteIf(expectedQueueDtoStatus)); if (deletedTasks == 1) { dbSession.commit(); } else { Loggers.get(CeQueueImpl.class).debug( "Remove rolled back because task in queue with uuid {} and status {} could not be deleted", taskUuid, expectedQueueDtoStatus); dbSession.rollback(); } }
@Override public void cancel(DbSession dbSession, CeQueueDto ceQueueDto) { checkState(PENDING.equals(ceQueueDto.getStatus()), "Task is in progress and can't be canceled [uuid=%s]", ceQueueDto.getUuid()); cancelImpl(dbSession, ceQueueDto); }
protected int cancelAll(boolean includeInProgress) { int count = 0; try (DbSession dbSession = dbClient.openSession(false)) { for (CeQueueDto queueDto : dbClient.ceQueueDao().selectAllInAscOrder(dbSession)) { if (includeInProgress || !queueDto.getStatus().equals(CeQueueDto.Status.IN_PROGRESS)) { cancelImpl(dbSession, queueDto); count++; } } return count; } }
private Ce.Task formatQueue(CeQueueDto dto, DtoCache cache) { Ce.Task.Builder builder = Ce.Task.newBuilder(); String organizationKey = cache.getOrganizationKey(dto.getComponentUuid()); setNullable(organizationKey, builder::setOrganization); if (dto.getComponentUuid() != null) { builder.setComponentId(dto.getComponentUuid()); setComponent(builder, dto.getComponentUuid(), cache); } builder.setId(dto.getUuid()); builder.setStatus(Ce.TaskStatus.valueOf(dto.getStatus().name())); builder.setType(dto.getTaskType()); builder.setLogs(false); cache.getUser(dto.getSubmitterUuid()).ifPresent(user -> builder.setSubmitterLogin(user.getLogin())); builder.setSubmittedAt(formatDateTime(new Date(dto.getCreatedAt()))); setNullable(dto.getStartedAt(), builder::setStartedAt, DateUtils::formatDateTime); setNullable(computeExecutionTimeMs(dto), builder::setExecutionTimeMs); setBranchOrPullRequest(builder, dto.getUuid(), cache); return builder.build(); }