public CeActivityDto(CeQueueDto queueDto) { this.uuid = queueDto.getUuid(); this.taskType = queueDto.getTaskType(); this.componentUuid = queueDto.getComponentUuid(); this.mainComponentUuid = queueDto.getMainComponentUuid(); this.isLastKey = format("%s%s", taskType, Strings.nullToEmpty(componentUuid)); this.mainIsLastKey = format("%s%s", taskType, Strings.nullToEmpty(mainComponentUuid)); this.submitterUuid = queueDto.getSubmitterUuid(); this.workerUuid = queueDto.getWorkerUuid(); this.submittedAt = queueDto.getCreatedAt(); this.startedAt = queueDto.getStartedAt(); }
private CeQueueDto createQueueDto(String uuid) { CeQueueDto queueDto = new CeQueueDto(); queueDto.setTaskType(CeTaskTypes.REPORT); queueDto.setUuid(uuid); queueDto.setComponentUuid(privateProject.uuid()); return queueDto; }
public static CeQueueDto newCeQueueDto(String uuid) { return new CeQueueDto() .setUuid(uuid) .setComponentUuid(randomAlphanumeric(40)) .setMainComponentUuid(randomAlphanumeric(39)) .setStatus(CeQueueDto.Status.PENDING) .setTaskType(CeTaskTypes.REPORT) .setSubmitterUuid(randomAlphanumeric(255)) .setCreatedAt(nextLong()) .setUpdatedAt(nextLong()); }
public CeQueueDto insert(DbSession session, CeQueueDto dto) { if (dto.getCreatedAt() == 0L || dto.getUpdatedAt() == 0L) { long now = system2.now(); dto.setCreatedAt(now); dto.setUpdatedAt(now); } mapper(session).insert(dto); return dto; }
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 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(); }
private CeTaskCharacteristicDto insertCharacteristic(CeQueueDto queueDto, String key, String value) { return insertCharacteristic(queueDto.getUuid(), key, value); }
CeTask convertToTask(DbSession dbSession, CeQueueDto taskDto, Map<String, String> characteristics, @Nullable ComponentDto component, @Nullable ComponentDto mainComponent) { CeTask.Builder builder = new CeTask.Builder() .setUuid(taskDto.getUuid()) .setType(taskDto.getTaskType()) .setCharacteristics(characteristics) .setSubmitter(resolveSubmitter(dbSession, taskDto.getSubmitterUuid())); String componentUuid = taskDto.getComponentUuid(); if (component != null) { builder.setComponent(new CeTask.Component(component.uuid(), component.getDbKey(), component.name())); builder.setOrganizationUuid(component.getOrganizationUuid()); } else if (componentUuid != null) { builder.setComponent(new CeTask.Component(componentUuid, null, null)); } String mainComponentUuid = taskDto.getMainComponentUuid(); if (mainComponent != null) { builder.setMainComponent(new CeTask.Component(mainComponent.uuid(), mainComponent.getDbKey(), mainComponent.name())); } else if (mainComponentUuid != null) { builder.setMainComponent(new CeTask.Component(mainComponentUuid, null, null)); } // FIXME this should be set from the CeQueueDto if (!builder.hasOrganizationUuid()) { builder.setOrganizationUuid(defaultOrganizationProvider.get().getUuid()); } return builder.build(); }
private void verifyCeQueueDtoForTaskSubmit(CeTaskSubmit taskSubmit) { Optional<CeQueueDto> queueDto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), taskSubmit.getUuid()); assertThat(queueDto.isPresent()).isTrue(); CeQueueDto dto = queueDto.get(); assertThat(dto.getTaskType()).isEqualTo(taskSubmit.getType()); Optional<CeTaskSubmit.Component> component = taskSubmit.getComponent(); if (component.isPresent()) { assertThat(dto.getMainComponentUuid()).isEqualTo(component.get().getMainComponentUuid()); assertThat(dto.getComponentUuid()).isEqualTo(component.get().getUuid()); } else { assertThat(dto.getMainComponentUuid()).isNull(); assertThat(dto.getComponentUuid()).isNull(); } assertThat(dto.getSubmitterUuid()).isEqualTo(taskSubmit.getSubmitterUuid()); assertThat(dto.getCreatedAt()).isEqualTo(dto.getUpdatedAt()).isNotNull(); }
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()); }
public CeActivityDto(CeQueueDto queueDto) { this.uuid = queueDto.getUuid(); this.taskType = queueDto.getTaskType(); this.componentUuid = queueDto.getComponentUuid(); this.isLastKey = format("%s%s", taskType, Strings.nullToEmpty(componentUuid)); this.submitterLogin = queueDto.getSubmitterLogin(); this.submittedAt = queueDto.getCreatedAt(); this.startedAt = queueDto.getStartedAt(); }
private List<CeTask> loadTasks(DbSession dbSession, List<CeQueueDto> dtos) { // load components, if defined Set<String> componentUuids = dtos.stream() .flatMap(dto -> Stream.of(dto.getComponentUuid(), dto.getMainComponentUuid())) .filter(Objects::nonNull) .collect(Collectors.toSet()); Map<String, ComponentDto> componentsByUuid = dbClient.componentDao() .selectByUuids(dbSession, componentUuids).stream() .collect(uniqueIndex(ComponentDto::uuid)); // load characteristics // TODO could be avoided, characteristics are already present in submissions Set<String> taskUuids = dtos.stream().map(CeQueueDto::getUuid).collect(MoreCollectors.toSet(dtos.size())); Multimap<String, CeTaskCharacteristicDto> characteristicsByTaskUuid = dbClient.ceTaskCharacteristicsDao() .selectByTaskUuids(dbSession, taskUuids).stream() .collect(MoreCollectors.index(CeTaskCharacteristicDto::getTaskUuid)); List<CeTask> result = new ArrayList<>(); for (CeQueueDto dto : dtos) { ComponentDto component = ofNullable(dto.getComponentUuid()) .map(componentsByUuid::get) .orElse(null); ComponentDto mainComponent = ofNullable(dto.getMainComponentUuid()) .map(componentsByUuid::get) .orElse(null); Map<String, String> characteristics = characteristicsByTaskUuid.get(dto.getUuid()).stream() .collect(uniqueIndex(CeTaskCharacteristicDto::getKey, CeTaskCharacteristicDto::getValue)); result.add(convertToTask(dbSession, dto, characteristics, component, mainComponent)); } return result; }
private CeActivityDto insertWithCreationDate(String uuid, long date) { CeQueueDto queueDto = new CeQueueDto(); queueDto.setUuid(uuid); queueDto.setTaskType("fake"); CeActivityDto dto = new CeActivityDto(queueDto); dto.setStatus(SUCCESS); dto.setAnalysisUuid(uuid + "_AA"); system2.setNow(date); underTest.insert(db.getSession(), dto); return dto; }
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); }); } }
Map<String, ComponentDto> loadComponentDtos(DbSession dbSession, CeQueueDto taskDto) { Set<String> componentUuids = Stream.of(taskDto.getComponentUuid(), taskDto.getMainComponentUuid()) .filter(Objects::nonNull) .collect(MoreCollectors.toSet(2)); if (componentUuids.isEmpty()) { return emptyMap(); } return dbClient.componentDao().selectByUuids(dbSession, componentUuids) .stream() .collect(uniqueIndex(ComponentDto::uuid, 2)); }
private void checkPermission(DbSession dbSession, CeQueueDto ceQueueDto) { if (userSession.isSystemAdministrator()) { return; } String componentUuid = ceQueueDto.getComponentUuid(); if (componentUuid == null) { throw insufficientPrivilegesException(); } Optional<ComponentDto> component = dbClient.componentDao().selectByUuid(dbSession, componentUuid); if (!component.isPresent()) { throw insufficientPrivilegesException(); } userSession.checkComponentPermission(UserRole.ADMIN, component.get()); } }
@Test public void setTaskType_accepts_empty_and_string_15_chars_or_less() { underTest.setTaskType(""); underTest.setTaskType("bar"); underTest.setTaskType(STR_15_CHARS); }
@Test public void setComponentUuid_accepts_null_empty_and_string_40_chars_or_less() { underTest.setComponentUuid(null); underTest.setComponentUuid(""); underTest.setComponentUuid("bar"); underTest.setComponentUuid(STR_40_CHARS); }
/** * now - startedAt */ @CheckForNull private Long computeExecutionTimeMs(CeQueueDto dto) { Long startedAt = dto.getStartedAt(); if (startedAt == null) { return null; } return system2.now() - startedAt; }