private CeActivityDto createActivityDto(String uuid) { CeQueueDto queueDto = createQueueDto(uuid); CeActivityDto activityDto = new CeActivityDto(queueDto); activityDto.setStatus(CeActivityDto.Status.FAILED); activityDto.setExecutionTimeMs(500L); activityDto.setAnalysisUuid(uuid + "u1"); return activityDto; }
private static Ce.Task formatActivity(CeActivityDto dto, DtoCache cache, @Nullable String scannerContext, List<String> warnings) { Ce.Task.Builder builder = Ce.Task.newBuilder(); String organizationKey = cache.getOrganizationKey(dto.getComponentUuid()); ofNullable(organizationKey).ifPresent(builder::setOrganization); builder.setId(dto.getUuid()); builder.setStatus(Ce.TaskStatus.valueOf(dto.getStatus().name())); builder.setType(dto.getTaskType()); builder.setLogs(false); ofNullable(dto.getComponentUuid()).ifPresent(uuid -> setComponent(builder, uuid, cache).setComponentId(uuid)); String analysisUuid = dto.getAnalysisUuid(); ofNullable(analysisUuid).ifPresent(builder::setAnalysisId); setBranchOrPullRequest(builder, dto.getUuid(), cache); ofNullable(analysisUuid).ifPresent(builder::setAnalysisId); cache.getUser(dto.getSubmitterUuid()).ifPresent(user -> builder.setSubmitterLogin(user.getLogin())); builder.setSubmittedAt(formatDateTime(new Date(dto.getSubmittedAt()))); ofNullable(dto.getStartedAt()).map(DateUtils::formatDateTime).ifPresent(builder::setStartedAt); ofNullable(dto.getExecutedAt()).map(DateUtils::formatDateTime).ifPresent(builder::setExecutedAt); ofNullable(dto.getExecutionTimeMs()).ifPresent(builder::setExecutionTimeMs); ofNullable(dto.getErrorMessage()).ifPresent(builder::setErrorMessage); ofNullable(dto.getErrorStacktrace()).ifPresent(builder::setErrorStacktrace); ofNullable(dto.getErrorType()).ifPresent(builder::setErrorType); ofNullable(scannerContext).ifPresent(builder::setScannerContext); builder.setHasScannerContext(dto.isHasScannerContext()); builder.setWarningCount(dto.getWarningCount()); warnings.forEach(builder::addWarnings); return builder.build(); }
@Test public void formatActivity_with_both_error_message_and_stacktrace() { CeActivityDto dto = newActivity("UUID", "COMPONENT_UUID", CeActivityDto.Status.FAILED, null) .setErrorMessage("error msg") .setErrorStacktrace("error stacktrace") .setErrorType("anErrorType"); Ce.Task task = underTest.formatActivity(db.getSession(), Collections.singletonList(dto)).iterator().next(); assertThat(task.getErrorMessage()).isEqualTo(dto.getErrorMessage()); assertThat(task.getErrorStacktrace()).isEqualTo(dto.getErrorStacktrace()); assertThat(task.getErrorType()).isEqualTo(dto.getErrorType()); }
private void cancelImpl(DbSession dbSession, CeQueueDto q) { CeActivityDto activityDto = new CeActivityDto(q); activityDto.setStatus(CeActivityDto.Status.CANCELED); remove(dbSession, q, activityDto); }
public void insert(DbSession dbSession, CeActivityDto dto) { dto.setCreatedAt(system2.now()); dto.setUpdatedAt(system2.now()); boolean isLast = dto.getStatus() != CeActivityDto.Status.CANCELED; dto.setIsLast(isLast); CeActivityMapper ceActivityMapper = mapper(dbSession); if (isLast) { ceActivityMapper.clearIsLast(dto.getIsLastKey(), dto.getUpdatedAt()); ceActivityMapper.clearMainIsLast(dto.getMainIsLastKey(), dto.getUpdatedAt()); } ceActivityMapper.insert(dto); }
private static void updateError(CeActivityDto activityDto, @Nullable Throwable error) { if (error == null) { return; } if (error instanceof VisitException && error.getCause() != null) { activityDto.setErrorMessage(format("%s (%s)", error.getCause().getMessage(), error.getMessage())); } else { activityDto.setErrorMessage(error.getMessage()); } String stacktrace = getStackTraceForPersistence(error); if (stacktrace != null) { activityDto.setErrorStacktrace(stacktrace); } if (error instanceof TypedException) { activityDto.setErrorType(((TypedException) error).getType()); } }
@CheckForNull private String extractScannerContext(DbSession dbSession, CeActivityDto activityDto, Set<AdditionalField> additionalFields) { if (additionalFields.contains(AdditionalField.SCANNER_CONTEXT)) { return dbClient.ceScannerContextDao().selectScannerContext(dbSession, activityDto.getUuid()) .orElse(null); } return null; }
@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); }
@Test public void fail_in_progress_task() { CeTask task = submit(CeTaskTypes.REPORT, newComponent(randomAlphabetic(12))); CeQueueDto queueDto = db.getDbClient().ceQueueDao().peek(db.getSession(), WORKER_UUID).get(); underTest.fail(db.getSession(), queueDto, "TIMEOUT", "Failed on timeout"); Optional<CeActivityDto> activity = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid()); assertThat(activity.isPresent()).isTrue(); assertThat(activity.get().getStatus()).isEqualTo(CeActivityDto.Status.FAILED); assertThat(activity.get().getErrorType()).isEqualTo("TIMEOUT"); assertThat(activity.get().getErrorMessage()).isEqualTo("Failed on timeout"); assertThat(activity.get().getExecutedAt()).isEqualTo(NOW); assertThat(activity.get().getWorkerUuid()).isEqualTo(WORKER_UUID); }
@Test public void test_insert_error_message_and_stacktrace() { CeActivityDto dto = createActivityDto("TASK_1", REPORT, COMPONENT_1, MAINCOMPONENT_1, FAILED) .setErrorStacktrace("error stack"); underTest.insert(db.getSession(), dto); Optional<CeActivityDto> saved = underTest.selectByUuid(db.getSession(), "TASK_1"); CeActivityDto read = saved.get(); assertThat(read.getErrorMessage()).isEqualTo(dto.getErrorMessage()); assertThat(read.getErrorStacktrace()).isEqualTo(dto.getErrorStacktrace()); assertThat(read.getErrorType()).isNotNull().isEqualTo(dto.getErrorType()); }
@Test @UseDataProvider("stringsWithChar0") public void setErrorMessage_filters_out_char_zero(String withChar0, String expected) { underTest.setErrorMessage(withChar0); assertThat(underTest.getErrorMessage()).isEqualTo(expected); }
@Test public void return_stacktrace_of_failed_activity_with_stacktrace_when_additionalField_is_set() { logInAsRoot(); CeActivityDto activityDto = createActivityDto(SOME_TASK_UUID) .setErrorMessage("error msg") .setErrorStacktrace("error stack"); persist(activityDto); Ce.TaskResponse taskResponse = ws.newRequest() .setParam("id", SOME_TASK_UUID) .setParam("additionalFields", "stacktrace") .executeProtobuf(Ce.TaskResponse.class); Ce.Task task = taskResponse.getTask(); assertThat(task.getId()).isEqualTo(SOME_TASK_UUID); assertThat(task.getErrorMessage()).isEqualTo(activityDto.getErrorMessage()); assertThat(task.hasErrorStacktrace()).isTrue(); assertThat(task.getErrorStacktrace()).isEqualTo(activityDto.getErrorStacktrace()); }
@Test public void remove_saves_error_message_and_stacktrace_when_exception_is_provided() { Throwable error = new NullPointerException("Fake NPE to test persistence to DB"); CeTask task = submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1")); Optional<CeTask> peek = underTest.peek(WORKER_UUID_1); underTest.remove(peek.get(), CeActivityDto.Status.FAILED, null, error); Optional<CeActivityDto> activityDto = db.getDbClient().ceActivityDao().selectByUuid(session, task.getUuid()); assertThat(activityDto).isPresent(); assertThat(activityDto.get().getErrorMessage()).isEqualTo(error.getMessage()); assertThat(activityDto.get().getErrorStacktrace()).isEqualToIgnoringWhitespace(stacktraceToString(error)); assertThat(activityDto.get().getErrorType()).isNull(); }
private void insertWithDates(String uuid, long submittedAt, long executedAt) { CeQueueDto queueDto = new CeQueueDto(); queueDto.setUuid(uuid); queueDto.setTaskType("fake"); CeActivityDto dto = new CeActivityDto(queueDto); dto.setStatus(SUCCESS); dto.setSubmittedAt(submittedAt); dto.setExecutedAt(executedAt); underTest.insert(db.getSession(), dto); }
private ReportAnalysisFailureNotification buildNotification(CeActivityDto ceActivityDto, ComponentDto projectDto, @Nullable Throwable error) { Long executedAt = ceActivityDto.getExecutedAt(); return new ReportAnalysisFailureNotification( new ReportAnalysisFailureNotification.Project( projectDto.uuid(), projectDto.getKey(), projectDto.name(), projectDto.getBranch()), new ReportAnalysisFailureNotification.Task( ceActivityDto.getUuid(), ceActivityDto.getSubmittedAt(), executedAt == null ? system2.now() : executedAt), error == null ? null : error.getMessage()); } }
private void insertWithDate(String uuid, LocalDateTime dateTime) { long date = dateTime.toInstant(UTC).toEpochMilli(); CeQueueDto queueDto = new CeQueueDto(); queueDto.setUuid(uuid); queueDto.setTaskType(CeTaskTypes.REPORT); CeActivityDto dto = new CeActivityDto(queueDto); dto.setStatus(CeActivityDto.Status.SUCCESS); when(system2.now()).thenReturn(date); CeTaskCharacteristicDto ceTaskCharacteristicDto = new CeTaskCharacteristicDto() .setUuid(UuidFactoryFast.getInstance().create()) .setValue(randomAlphanumeric(10)) .setKey(randomAlphanumeric(10)) .setTaskUuid(dto.getUuid()); dbTester.getDbClient().ceTaskInputDao().insert(dbTester.getSession(), dto.getUuid(), IOUtils.toInputStream(randomAlphanumeric(10), Charset.forName("UTF-8"))); dbTester.getDbClient().ceActivityDao().insert(dbTester.getSession(), dto); dbTester.getDbClient().ceTaskCharacteristicsDao().insert(dbTester.getSession(), Collections.singletonList(ceTaskCharacteristicDto)); dbTester.getSession().commit(); insertScannerContext(uuid, date); }
private void insertActivityDto(String taskUuid, int createdAt, @Nullable Long executedAt, ComponentDto project) { dbClient.ceActivityDao().insert(dbTester.getSession(), new CeActivityDto(new CeQueueDto() .setUuid(taskUuid) .setTaskType(CeTaskTypes.REPORT) .setComponentUuid(project.uuid()) .setCreatedAt(createdAt)) .setExecutedAt(executedAt) .setStatus(CeActivityDto.Status.FAILED)); dbTester.getSession().commit(); }
public void insert(DbSession dbSession, CeActivityDto dto) { dto.setCreatedAt(system2.now()); dto.setUpdatedAt(system2.now()); dto.setIsLast(dto.getStatus() != CeActivityDto.Status.CANCELED); CeActivityMapper ceActivityMapper = mapper(dbSession); if (dto.getIsLast()) { ceActivityMapper.updateIsLastToFalseForLastKey(dto.getIsLastKey(), dto.getUpdatedAt()); } ceActivityMapper.insert(dto); }
@Test public void cancel_pending() { CeTask task = submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1")); CeQueueDto queueDto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), task.getUuid()).get(); underTest.cancel(db.getSession(), queueDto); Optional<CeActivityDto> activity = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid()); assertThat(activity.isPresent()).isTrue(); assertThat(activity.get().getStatus()).isEqualTo(CeActivityDto.Status.CANCELED); }
@Test public void do_not_return_stacktrace_of_failed_activity_with_stacktrace_when_additionalField_is_not_set() { logInAsRoot(); CeActivityDto activityDto = createActivityDto(SOME_TASK_UUID) .setErrorMessage("error msg") .setErrorStacktrace("error stack"); persist(activityDto); Ce.TaskResponse taskResponse = ws.newRequest() .setParam("id", SOME_TASK_UUID) .executeProtobuf(Ce.TaskResponse.class); Ce.Task task = taskResponse.getTask(); assertThat(task.getId()).isEqualTo(SOME_TASK_UUID); assertThat(task.getErrorMessage()).isEqualTo(activityDto.getErrorMessage()); assertThat(task.hasErrorStacktrace()).isFalse(); }