@Override public VersionControlInformationEntity deleteVersionControl(final Revision revision, final String processGroupId) { final ProcessGroup group = processGroupDAO.getProcessGroup(processGroupId); final RevisionUpdate<VersionControlInformationDTO> snapshot = updateComponent(revision, group, () -> processGroupDAO.disconnectVersionControl(processGroupId), processGroup -> dtoFactory.createVersionControlInformationDto(group)); return entityFactory.createVersionControlInformationEntity(snapshot.getComponent(), dtoFactory.createRevisionDTO(snapshot.getLastModification())); }
@Override public Set<ProcessGroupEntity> getProcessGroups(final String parentGroupId) { final Set<ProcessGroup> groups = processGroupDAO.getProcessGroups(parentGroupId); return groups.stream() .map(group -> createProcessGroupEntity(group)) .collect(Collectors.toSet()); }
@Override public void verifyUpdateProcessGroup(ProcessGroupDTO processGroupDTO) { if (processGroupDAO.hasProcessGroup(processGroupDTO.getId())) { processGroupDAO.verifyUpdate(processGroupDTO); } }
@Override public VersionControlInformationEntity setVersionControlInformation(final Revision revision, final String processGroupId, final VersionControlInformationDTO versionControlInfo, final Map<String, String> versionedComponentMapping) { final ProcessGroup group = processGroupDAO.getProcessGroup(processGroupId); final RevisionUpdate<VersionControlInformationDTO> snapshot = updateComponent(revision, group, () -> processGroupDAO.updateVersionControlInformation(versionControlInfo, versionedComponentMapping), processGroup -> dtoFactory.createVersionControlInformationDto(processGroup)); return entityFactory.createVersionControlInformationEntity(snapshot.getComponent(), dtoFactory.createRevisionDTO(snapshot.getLastModification())); }
@Override public Set<Revision> getRevisionsFromGroup(final String groupId, final Function<ProcessGroup, Set<String>> getComponents) { final ProcessGroup group = processGroupDAO.getProcessGroup(groupId); final Set<String> componentIds = getComponents.apply(group); return componentIds.stream().map(id -> revisionManager.getRevision(id)).collect(Collectors.toSet()); }
@Override public VariableRegistryEntity updateVariableRegistry(Revision revision, VariableRegistryDTO variableRegistryDto) { final ProcessGroup processGroupNode = processGroupDAO.getProcessGroup(variableRegistryDto.getProcessGroupId()); final RevisionUpdate<VariableRegistryDTO> snapshot = updateComponent(revision, processGroupNode, () -> processGroupDAO.updateVariableRegistry(variableRegistryDto), processGroup -> dtoFactory.createVariableRegistryDto(processGroup, revisionManager)); final PermissionsDTO permissions = dtoFactory.createPermissionsDto(processGroupNode); final RevisionDTO updatedRevision = dtoFactory.createRevisionDTO(snapshot.getLastModification()); return entityFactory.createVariableRegistryEntity(snapshot.getComponent(), updatedRevision, permissions); }
@Override public ProcessGroupEntity deleteProcessGroup(final Revision revision, final String groupId) { final ProcessGroup processGroup = processGroupDAO.getProcessGroup(groupId); final PermissionsDTO permissions = dtoFactory.createPermissionsDto(processGroup); // grab the resources in the snippet so we can delete the policies afterwards final Set<Resource> groupResources = new HashSet<>(); processGroup.findAllProcessors().forEach(processor -> groupResources.add(processor.getResource())); processGroup.findAllInputPorts().forEach(inputPort -> groupResources.add(inputPort.getResource())); processGroup.findAllOutputPorts().forEach(outputPort -> groupResources.add(outputPort.getResource())); processGroup.findAllFunnels().forEach(funnel -> groupResources.add(funnel.getResource())); processGroup.findAllLabels().forEach(label -> groupResources.add(label.getResource())); processGroup.findAllProcessGroups().forEach(childGroup -> groupResources.add(childGroup.getResource())); processGroup.findAllRemoteProcessGroups().forEach(remoteProcessGroup -> groupResources.add(remoteProcessGroup.getResource())); processGroup.findAllTemplates().forEach(template -> groupResources.add(template.getResource())); processGroup.findAllControllerServices().forEach(controllerService -> groupResources.add(controllerService.getResource())); final ProcessGroupDTO snapshot = deleteComponent( revision, processGroup.getResource(), () -> processGroupDAO.deleteProcessGroup(groupId), true, dtoFactory.createProcessGroupDto(processGroup)); // delete all applicable component policies groupResources.forEach(groupResource -> cleanUpPolicies(groupResource)); return entityFactory.createProcessGroupEntity(snapshot, null, permissions, null, null); }
@Override public ProcessGroupEntity createProcessGroup(final Revision revision, final String parentGroupId, final ProcessGroupDTO processGroupDTO) { final RevisionUpdate<ProcessGroupDTO> snapshot = createComponent( revision, processGroupDTO, () -> processGroupDAO.createProcessGroup(parentGroupId, processGroupDTO), processGroup -> dtoFactory.createProcessGroupDto(processGroup)); final ProcessGroup processGroup = processGroupDAO.getProcessGroup(processGroupDTO.getId()); final PermissionsDTO permissions = dtoFactory.createPermissionsDto(processGroup); final ProcessGroupStatusDTO status = dtoFactory.createConciseProcessGroupStatusDto(controllerFacade.getProcessGroupStatus(processGroup.getIdentifier())); final List<BulletinDTO> bulletins = dtoFactory.createBulletinDtos(bulletinRepository.findBulletinsForSource(processGroup.getIdentifier())); final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList()); return entityFactory.createProcessGroupEntity(snapshot.getComponent(), dtoFactory.createRevisionDTO(snapshot.getLastModification()), permissions, status, bulletinEntities); }
@Override public ProcessGroupEntity updateProcessGroup(final Revision revision, final ProcessGroupDTO processGroupDTO) { final ProcessGroup processGroupNode = processGroupDAO.getProcessGroup(processGroupDTO.getId()); final RevisionUpdate<ProcessGroupDTO> snapshot = updateComponent(revision, processGroupNode, () -> processGroupDAO.updateProcessGroup(processGroupDTO), processGroup -> dtoFactory.createProcessGroupDto(processGroup)); final PermissionsDTO permissions = dtoFactory.createPermissionsDto(processGroupNode); final RevisionDTO updatedRevision = dtoFactory.createRevisionDTO(snapshot.getLastModification()); final ProcessGroupStatusDTO status = dtoFactory.createConciseProcessGroupStatusDto(controllerFacade.getProcessGroupStatus(processGroupNode.getIdentifier())); final List<BulletinDTO> bulletins = dtoFactory.createBulletinDtos(bulletinRepository.findBulletinsForSource(processGroupNode.getIdentifier())); final List<BulletinEntity> bulletinEntities = bulletins.stream().map(bulletin -> entityFactory.createBulletinEntity(bulletin, permissions.getCanRead())).collect(Collectors.toList()); return entityFactory.createProcessGroupEntity(snapshot.getComponent(), updatedRevision, permissions, status, bulletinEntities); }
@Override public RevisionUpdate<ScheduleComponentsEntity> update() { // schedule the components processGroupDAO.enableComponents(processGroupId, state, componentRevisions.keySet()); // update the revisions final Map<String, Revision> updatedRevisions = new HashMap<>(); for (final Revision revision : componentRevisions.values()) { final Revision currentRevision = revisionManager.getRevision(revision.getComponentId()); updatedRevisions.put(revision.getComponentId(), currentRevision.incrementRevision(revision.getClientId())); } // save controllerFacade.save(); // gather details for response final ScheduleComponentsEntity entity = new ScheduleComponentsEntity(); entity.setId(processGroupId); entity.setState(state.name()); return new StandardRevisionUpdate<>(entity, null, new HashSet<>(updatedRevisions.values())); } });
@Override public RevisionUpdate<ScheduleComponentsEntity> update() { // schedule the components processGroupDAO.scheduleComponents(processGroupId, state, componentRevisions.keySet()); // update the revisions final Map<String, Revision> updatedRevisions = new HashMap<>(); for (final Revision revision : componentRevisions.values()) { final Revision currentRevision = revisionManager.getRevision(revision.getComponentId()); updatedRevisions.put(revision.getComponentId(), currentRevision.incrementRevision(revision.getClientId())); } // save controllerFacade.save(); // gather details for response final ScheduleComponentsEntity entity = new ScheduleComponentsEntity(); entity.setId(processGroupId); entity.setState(state.name()); return new StandardRevisionUpdate<>(entity, null, new HashSet<>(updatedRevisions.values())); } });
@Override public RevisionUpdate<ActivateControllerServicesEntity> update() { // schedule the components processGroupDAO.activateControllerServices(processGroupId, state, serviceRevisions.keySet()); // update the revisions final Map<String, Revision> updatedRevisions = new HashMap<>(); for (final Revision revision : serviceRevisions.values()) { final Revision currentRevision = revisionManager.getRevision(revision.getComponentId()); updatedRevisions.put(revision.getComponentId(), currentRevision.incrementRevision(revision.getClientId())); } // save controllerFacade.save(); // gather details for response final ActivateControllerServicesEntity entity = new ActivateControllerServicesEntity(); entity.setId(processGroupId); entity.setState(state.name()); return new StandardRevisionUpdate<>(entity, null, new HashSet<>(updatedRevisions.values())); } });
@Override public void verifyImportProcessGroup(final VersionControlInformationDTO versionControlInfo, final VersionedProcessGroup contents, final String groupId) { final ProcessGroup group = processGroupDAO.getProcessGroup(groupId); verifyImportProcessGroup(versionControlInfo, contents, group); }
@Override public ProcessGroupEntity getProcessGroup(final String groupId) { final ProcessGroup processGroup = processGroupDAO.getProcessGroup(groupId); return createProcessGroupEntity(processGroup); }
@Override public void verifyCanUpdate(final String groupId, final VersionedFlowSnapshot proposedFlow, final boolean verifyConnectionRemoval, final boolean verifyNotDirty) { final ProcessGroup group = processGroupDAO.getProcessGroup(groupId); group.verifyCanUpdate(proposedFlow, verifyConnectionRemoval, verifyNotDirty); }
@Override public void verifyCanSaveToFlowRegistry(final String groupId, final String registryId, final String bucketId, final String flowId) { final ProcessGroup group = processGroupDAO.getProcessGroup(groupId); group.verifyCanSaveToFlowRegistry(registryId, bucketId, flowId); }
@Override public void verifyCanRevertLocalModifications(final String groupId, final VersionedFlowSnapshot versionedFlowSnapshot) { final ProcessGroup group = processGroupDAO.getProcessGroup(groupId); group.verifyCanRevertLocalModifications(); // verify that the process group can be updated to the given snapshot. We do not verify that connections can // be removed, because the flow may still be running, and it only matters that the connections can be removed once the components // have been stopped. group.verifyCanUpdate(versionedFlowSnapshot, false, false); }
@Override public ProcessGroupAuthorizable getProcessGroup(final String id) { final ProcessGroup processGroup = processGroupDAO.getProcessGroup(id); return new StandardProcessGroupAuthorizable(processGroup, controllerFacade.getExtensionManager()); }
@Override public VariableRegistryEntity getVariableRegistry(final String groupId, final boolean includeAncestorGroups) { final ProcessGroup processGroup = processGroupDAO.getProcessGroup(groupId); if (processGroup == null) { throw new ResourceNotFoundException("Could not find group with ID " + groupId); } return createVariableRegistryEntity(processGroup, includeAncestorGroups); }
/** * Audits the removal of a process group via deleteProcessGroup(). * * @param proceedingJoinPoint join point * @param groupId group id * @throws Throwable ex */ @Around("within(org.apache.nifi.web.dao.ProcessGroupDAO+) && " + "execution(void deleteProcessGroup(String)) && " + "args(groupId)") public void removeProcessGroupAdvice(ProceedingJoinPoint proceedingJoinPoint, String groupId) throws Throwable { // get the process group before removing it ProcessGroupDAO processGroupDAO = getProcessGroupDAO(); ProcessGroup processGroup = processGroupDAO.getProcessGroup(groupId); // remove the process group proceedingJoinPoint.proceed(); // if no exceptions were thrown, add removal actions... // audit the process group removal final Action action = generateAuditRecord(processGroup, Operation.Remove); // save the actions if (action != null) { saveAction(action, logger); } }