@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); }
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()); }
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 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(); }
@Test public void massSubmit_with_UNIQUE_QUEUE_PER_MAIN_COMPONENT_creates_task_without_component_when_there_is_a_pending_task_without_component() { CeTaskSubmit taskSubmit = createTaskSubmit("no_component"); CeQueueDto dto = insertPendingInQueue(null); List<CeTask> tasks = underTest.massSubmit(of(taskSubmit), UNIQUE_QUEUE_PER_MAIN_COMPONENT); assertThat(tasks).hasSize(1); assertThat(db.getDbClient().ceQueueDao().selectAllInAscOrder(db.getSession())) .extracting(CeQueueDto::getUuid) .containsOnly(dto.getUuid(), tasks.iterator().next().getUuid()); }
@Test public void cancel_pending_task_having_no_component() { logInAsSystemAdministrator(); CeQueueDto queue = createTaskSubmit(null); tester.newRequest() .setParam("id", queue.getUuid()) .execute(); assertThat(db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), queue.getUuid()).get().getStatus()).isEqualTo(CeActivityDto.Status.CANCELED); }
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(); }
@Test public void cancel_pending_task_on_project() { logInAsSystemAdministrator(); ComponentDto project = db.components().insertPrivateProject(); CeQueueDto queue = createTaskSubmit(project); tester.newRequest() .setParam("id", queue.getUuid()) .execute(); assertThat(db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), queue.getUuid()).get().getStatus()).isEqualTo(CeActivityDto.Status.CANCELED); }
@Test public void massSubmit_without_UNIQUE_QUEUE_PER_MAIN_COMPONENT_creates_task_when_there_is_one_pending_task_for_other_main_component() { String mainComponentUuid = randomAlphabetic(5); CeTaskSubmit taskSubmit = createTaskSubmit("with_component", newComponent(mainComponentUuid), null); CeQueueDto dto = insertPendingInQueue(newComponent(mainComponentUuid)); List<CeTask> tasks = underTest.massSubmit(of(taskSubmit)); assertThat(tasks).hasSize(1); assertThat(db.getDbClient().ceQueueDao().selectAllInAscOrder(db.getSession())) .extracting(CeQueueDto::getUuid) .containsOnly(dto.getUuid(), tasks.iterator().next().getUuid()); }
@Test public void massSubmit_with_UNIQUE_QUEUE_PER_MAIN_COMPONENT_creates_task_when_there_is_a_pending_task_for_another_main_component() { String mainComponentUuid = randomAlphabetic(5); String otherMainComponentUuid = randomAlphabetic(6); CeTaskSubmit taskSubmit = createTaskSubmit("with_component", newComponent(mainComponentUuid), null); CeQueueDto dto = insertPendingInQueue(newComponent(otherMainComponentUuid)); List<CeTask> tasks = underTest.massSubmit(of(taskSubmit), UNIQUE_QUEUE_PER_MAIN_COMPONENT); assertThat(tasks).hasSize(1); assertThat(db.getDbClient().ceQueueDao().selectAllInAscOrder(db.getSession())) .extracting(CeQueueDto::getUuid) .containsOnly(dto.getUuid(), tasks.iterator().next().getUuid()); }
@Test public void submit_with_UNIQUE_QUEUE_PER_MAIN_COMPONENT_creates_task_without_component_when_there_is_a_pending_task_without_component() { CeTaskSubmit taskSubmit = createTaskSubmit("no_component"); CeQueueDto dto = insertPendingInQueue(null); Optional<CeTask> task = underTest.submit(taskSubmit, UNIQUE_QUEUE_PER_MAIN_COMPONENT); assertThat(task).isNotEmpty(); assertThat(db.getDbClient().ceQueueDao().selectAllInAscOrder(db.getSession())) .extracting(CeQueueDto::getUuid) .containsOnly(dto.getUuid(), task.get().getUuid()); }
@Test public void getting_global_queue_task_requires_to_be_system_administrator() { UserDto user = db.users().insertUser(); userSession.logIn(user).setSystemAdministrator(); CeQueueDto task = createAndPersistQueueTask(null, user); call(task.getUuid()); }
@Test public void submit_with_UNIQUE_QUEUE_PER_MAIN_COMPONENT_creates_task_when_there_is_a_pending_task_for_another_main_component() { String mainComponentUuid = randomAlphabetic(5); String otherMainComponentUuid = randomAlphabetic(6); CeTaskSubmit taskSubmit = createTaskSubmit("with_component", newComponent(mainComponentUuid), null); CeQueueDto dto = insertPendingInQueue(newComponent(otherMainComponentUuid)); Optional<CeTask> task = underTest.submit(taskSubmit, UNIQUE_QUEUE_PER_MAIN_COMPONENT); assertThat(task).isNotEmpty(); assertThat(db.getDbClient().ceQueueDao().selectAllInAscOrder(db.getSession())) .extracting(CeQueueDto::getUuid) .containsOnly(dto.getUuid(), task.get().getUuid()); }
@Test public void getting_project_queue_task_throws_ForbiddenException_if_no_admin_nor_scan_permissions() { UserDto user = db.users().insertUser(); userSession.logIn(user); CeQueueDto task = createAndPersistQueueTask(privateProject, user); expectedException.expect(ForbiddenException.class); call(task.getUuid()); }
@Test public void getting_project_queue_task_of_public_project_fails_with_ForbiddenException() { UserDto user = db.users().insertUser(); userSession.logIn().registerComponents(publicProject); CeQueueDto task = createAndPersistQueueTask(publicProject, user); expectedException.expect(ForbiddenException.class); call(task.getUuid()); }
@Test public void get_project_queue_task_with_scan_permission_on_organization_but_not_on_project() { UserDto user = db.users().insertUser(); userSession.logIn(user).addPermission(SCAN, privateProject.getOrganizationUuid()); CeQueueDto task = createAndPersistQueueTask(privateProject, user); call(task.getUuid()); }
@Test public void submit_without_UNIQUE_QUEUE_PER_MAIN_COMPONENT_creates_task_when_there_is_one_pending_task_for_same_main_component() { String mainComponentUuid = randomAlphabetic(5); CeTaskSubmit taskSubmit = createTaskSubmit("with_component", newComponent(mainComponentUuid), null); CeQueueDto dto = insertPendingInQueue(newComponent(mainComponentUuid)); CeTask task = underTest.submit(taskSubmit); assertThat(db.getDbClient().ceQueueDao().selectAllInAscOrder(db.getSession())) .extracting(CeQueueDto::getUuid) .containsOnly(dto.getUuid(), task.getUuid()); }
@Test public void selectWornout_returns_task_pending_with_a_non_null_startedAt() { insertPending("p1"); makeInProgress("w1", alwaysIncreasingSystem2.now(), insertPending("i1")); CeQueueDto resetDto = makeInProgress("w1", alwaysIncreasingSystem2.now(), insertPending("i2")); makeInProgress("w1", alwaysIncreasingSystem2.now(), insertPending("i3")); reset(db.getSession(), alwaysIncreasingSystem2.now(), resetDto); List<CeQueueDto> ceQueueDtos = underTest.selectWornout(db.getSession()); assertThat(ceQueueDtos) .extracting(CeQueueDto::getStatus, CeQueueDto::getUuid) .containsOnly(tuple(PENDING, resetDto.getUuid())); }