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 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; }
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 Optional<CeTask> submit(CeTaskSubmit submission, EnumSet<SubmitOption> submitOptions) { try (DbSession dbSession = dbClient.openSession(false)) { if (submitOptions.contains(UNIQUE_QUEUE_PER_MAIN_COMPONENT) && submission.getComponent() .map(component -> dbClient.ceQueueDao().countByStatusAndMainComponentUuid(dbSession, PENDING, component.getMainComponentUuid()) > 0) .orElse(false)) { return Optional.empty(); } CeQueueDto taskDto = addToQueueInDb(dbSession, submission); dbSession.commit(); Map<String, ComponentDto> componentsByUuid = loadComponentDtos(dbSession, taskDto); if (componentsByUuid.isEmpty()) { return of(convertToTask(dbSession, taskDto, submission.getCharacteristics(), null, null)); } return of(convertToTask(dbSession, taskDto, submission.getCharacteristics(), ofNullable(taskDto.getComponentUuid()).map(componentsByUuid::get).orElse(null), ofNullable(taskDto.getMainComponentUuid()).map(componentsByUuid::get).orElse(null))); } }
@Override public Optional<CeTask> peek(String workerUuid) { requireNonNull(workerUuid, "workerUuid can't be null"); if (computeEngineStatus.getStatus() != ComputeEngineStatus.Status.STARTED || getWorkersPauseStatus() != WorkersPauseStatus.RESUMED) { return Optional.empty(); } try (DbSession dbSession = dbClient.openSession(false)) { CeQueueDao ceQueueDao = dbClient.ceQueueDao(); int i = ceQueueDao.resetToPendingForWorker(dbSession, workerUuid); if (i > 0) { dbSession.commit(); LOG.debug("{} in progress tasks reset for worker uuid {}", i, workerUuid); } Optional<CeQueueDto> opt = ceQueueDao.peek(dbSession, workerUuid); if (opt.isPresent()) { CeQueueDto taskDto = opt.get(); Map<String, ComponentDto> componentsByUuid = loadComponentDtos(dbSession, taskDto); Map<String, String> characteristics = dbClient.ceTaskCharacteristicsDao().selectByTaskUuids(dbSession, singletonList(taskDto.getUuid())).stream() .collect(uniqueIndex(CeTaskCharacteristicDto::getKey, CeTaskCharacteristicDto::getValue)); CeTask task = convertToTask(dbSession, taskDto, characteristics, ofNullable(taskDto.getComponentUuid()).map(componentsByUuid::get).orElse(null), ofNullable(taskDto.getMainComponentUuid()).map(componentsByUuid::get).orElse(null)); queueStatus.addInProgress(); return Optional.of(task); } return Optional.empty(); } }
@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 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(); }
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(); }