Examples with StandardVersionControlInformation org.apache.nifi.registry.flow.StandardVersionControlInformation used on opensource projects

Example 1 with StandardVersionControlInformation

use of org.apache.nifi.registry.flow.StandardVersionControlInformation in project nifi by apache.

the class StandardProcessGroupDAO method updateVersionControlInformation.

@Override
public ProcessGroup updateVersionControlInformation(final VersionControlInformationDTO versionControlInformation, final Map<String, String> versionedComponentMapping) {
    final String groupId = versionControlInformation.getGroupId();
    final ProcessGroup group = locateProcessGroup(flowController, groupId);
    final String registryId = versionControlInformation.getRegistryId();
    final FlowRegistry flowRegistry = flowController.getFlowRegistryClient().getFlowRegistry(registryId);
    final String registryName = flowRegistry == null ? registryId : flowRegistry.getName();
    final NiFiRegistryFlowMapper mapper = new NiFiRegistryFlowMapper();
    final VersionedProcessGroup flowSnapshot = mapper.mapProcessGroup(group, flowController, flowController.getFlowRegistryClient(), false);
    final StandardVersionControlInformation vci = StandardVersionControlInformation.Builder.fromDto(versionControlInformation).registryName(registryName).flowSnapshot(flowSnapshot).build();
    group.setVersionControlInformation(vci, versionedComponentMapping);
    group.onComponentModified();
    return group;
}

Example 2 with StandardVersionControlInformation

use of org.apache.nifi.registry.flow.StandardVersionControlInformation in project nifi by apache.

the class StandardProcessGroupDAO method updateProcessGroupFlow.

@Override
public ProcessGroup updateProcessGroupFlow(final String groupId, final NiFiUser user, final VersionedFlowSnapshot proposedSnapshot, final VersionControlInformationDTO versionControlInformation, final String componentIdSeed, final boolean verifyNotModified, final boolean updateSettings, final boolean updateDescendantVersionedFlows) {
    final ProcessGroup group = locateProcessGroup(flowController, groupId);
    group.updateFlow(proposedSnapshot, componentIdSeed, verifyNotModified, updateSettings, updateDescendantVersionedFlows);
    group.findAllRemoteProcessGroups().stream().forEach(RemoteProcessGroup::initialize);
    final StandardVersionControlInformation svci = StandardVersionControlInformation.Builder.fromDto(versionControlInformation).flowSnapshot(proposedSnapshot.getFlowContents()).build();
    group.setVersionControlInformation(svci, Collections.emptyMap());
    group.onComponentModified();
    return group;
}

Example 3 with StandardVersionControlInformation

use of org.apache.nifi.registry.flow.StandardVersionControlInformation in project nifi by apache.

the class StandardProcessGroup method setVersionControlInformation.

@Override
public void setVersionControlInformation(final VersionControlInformation versionControlInformation, final Map<String, String> versionedComponentIds) {
    final StandardVersionControlInformation svci = new StandardVersionControlInformation(versionControlInformation.getRegistryIdentifier(), versionControlInformation.getRegistryName(), versionControlInformation.getBucketIdentifier(), versionControlInformation.getFlowIdentifier(), versionControlInformation.getVersion(), stripContentsFromRemoteDescendantGroups(versionControlInformation.getFlowSnapshot(), true), versionControlInformation.getStatus()) {

        @Override
        public String getRegistryName() {
            final String registryId = versionControlInformation.getRegistryIdentifier();
            final FlowRegistry registry = flowController.getFlowRegistryClient().getFlowRegistry(registryId);
            return registry == null ? registryId : registry.getName();
        }

        private boolean isModified() {
            Set<FlowDifference> differences = versionControlFields.getFlowDifferences();
            if (differences == null) {
                differences = getModifications();
                if (differences == null) {
                    return false;
                }
                versionControlFields.setFlowDifferences(differences);
            }
            return !differences.isEmpty();
        }

        @Override
        public VersionedFlowStatus getStatus() {
            // If current state is a sync failure, then
            final String syncFailureExplanation = versionControlFields.getSyncFailureExplanation();
            if (syncFailureExplanation != null) {
                return new StandardVersionedFlowStatus(VersionedFlowState.SYNC_FAILURE, syncFailureExplanation);
            }
            final boolean modified = isModified();
            if (!modified) {
                final VersionControlInformation vci = StandardProcessGroup.this.versionControlInfo.get();
                if (vci.getFlowSnapshot() == null) {
                    return new StandardVersionedFlowStatus(VersionedFlowState.SYNC_FAILURE, "Process Group has not yet been synchronized with Flow Registry");
                }
            }
            final boolean stale = versionControlFields.isStale();
            final VersionedFlowState flowState;
            if (modified && stale) {
                flowState = VersionedFlowState.LOCALLY_MODIFIED_AND_STALE;
            } else if (modified) {
                flowState = VersionedFlowState.LOCALLY_MODIFIED;
            } else if (stale) {
                flowState = VersionedFlowState.STALE;
            } else {
                flowState = VersionedFlowState.UP_TO_DATE;
            }
            return new StandardVersionedFlowStatus(flowState, flowState.getDescription());
        }
    };
    svci.setBucketName(versionControlInformation.getBucketName());
    svci.setFlowName(versionControlInformation.getFlowName());
    svci.setFlowDescription(versionControlInformation.getFlowDescription());
    final VersionedFlowState flowState = versionControlInformation.getStatus().getState();
    versionControlFields.setStale(flowState == VersionedFlowState.STALE || flowState == VersionedFlowState.LOCALLY_MODIFIED_AND_STALE);
    versionControlFields.setLocallyModified(flowState == VersionedFlowState.LOCALLY_MODIFIED || flowState == VersionedFlowState.LOCALLY_MODIFIED_AND_STALE);
    versionControlFields.setSyncFailureExplanation(null);
    writeLock.lock();
    try {
        updateVersionedComponentIds(this, versionedComponentIds);
        this.versionControlInfo.set(svci);
        versionControlFields.setFlowDifferences(null);
        final ProcessGroup parent = getParent();
        if (parent != null) {
            parent.onComponentModified();
        }
        scheduler.submitFrameworkTask(() -> synchronizeWithFlowRegistry(flowController.getFlowRegistryClient()));
    } finally {
        writeLock.unlock();
    }
}

Example 4 with StandardVersionControlInformation

use of org.apache.nifi.registry.flow.StandardVersionControlInformation in project nifi by apache.

the class StandardProcessGroup method synchronizeWithFlowRegistry.

@Override
public void synchronizeWithFlowRegistry(final FlowRegistryClient flowRegistryClient) {
    final StandardVersionControlInformation vci = versionControlInfo.get();
    if (vci == null) {
        return;
    }
    final String registryId = vci.getRegistryIdentifier();
    final FlowRegistry flowRegistry = flowRegistryClient.getFlowRegistry(registryId);
    if (flowRegistry == null) {
        final String message = String.format("Unable to synchronize Process Group with Flow Registry because Process Group was placed under Version Control using Flow Registry " + "with identifier %s but cannot find any Flow Registry with this identifier", registryId);
        versionControlFields.setSyncFailureExplanation(message);
        LOG.error("Unable to synchronize {} with Flow Registry because Process Group was placed under Version Control using Flow Registry " + "with identifier {} but cannot find any Flow Registry with this identifier", this, registryId);
        return;
    }
    final VersionedProcessGroup snapshot = vci.getFlowSnapshot();
    if (snapshot == null) {
        // This allows us to know whether or not the flow has been modified since it was last synced with the Flow Registry.
        try {
            final VersionedFlowSnapshot registrySnapshot = flowRegistry.getFlowContents(vci.getBucketIdentifier(), vci.getFlowIdentifier(), vci.getVersion(), false);
            final VersionedProcessGroup registryFlow = registrySnapshot.getFlowContents();
            vci.setFlowSnapshot(registryFlow);
        } catch (final IOException | NiFiRegistryException e) {
            final String message = String.format("Failed to synchronize Process Group with Flow Registry because could not retrieve version %s of flow with identifier %s in bucket %s", vci.getVersion(), vci.getFlowIdentifier(), vci.getBucketIdentifier());
            versionControlFields.setSyncFailureExplanation(message);
            LOG.error("Failed to synchronize {} with Flow Registry because could not retrieve version {} of flow with identifier {} in bucket {}", this, vci.getVersion(), vci.getFlowIdentifier(), vci.getBucketIdentifier(), e);
            return;
        }
    }
    try {
        final VersionedFlow versionedFlow = flowRegistry.getVersionedFlow(vci.getBucketIdentifier(), vci.getFlowIdentifier());
        final int latestVersion = (int) versionedFlow.getVersionCount();
        vci.setBucketName(versionedFlow.getBucketName());
        vci.setFlowName(versionedFlow.getName());
        vci.setFlowDescription(versionedFlow.getDescription());
        vci.setRegistryName(flowRegistry.getName());
        if (latestVersion == vci.getVersion()) {
            LOG.debug("{} is currently at the most recent version ({}) of the flow that is under Version Control", this, latestVersion);
            versionControlFields.setStale(false);
        } else {
            LOG.info("{} is not the most recent version of the flow that is under Version Control; current version is {}; most recent version is {}", new Object[] { this, vci.getVersion(), latestVersion });
            versionControlFields.setStale(true);
        }
        versionControlFields.setSyncFailureExplanation(null);
    } catch (final IOException | NiFiRegistryException e) {
        final String message = String.format("Failed to synchronize Process Group with Flow Registry : " + e.getMessage());
        versionControlFields.setSyncFailureExplanation(message);
        LOG.error("Failed to synchronize {} with Flow Registry because could not determine the most recent version of the Flow in the Flow Registry", this, e);
    }
}

Example 5 with StandardVersionControlInformation

use of org.apache.nifi.registry.flow.StandardVersionControlInformation in project nifi by apache.

the class StandardProcessGroup method updateFlow.

@Override
public void updateFlow(final VersionedFlowSnapshot proposedSnapshot, final String componentIdSeed, final boolean verifyNotDirty, final boolean updateSettings, final boolean updateDescendantVersionedFlows) {
    writeLock.lock();
    try {
        verifyCanUpdate(proposedSnapshot, true, verifyNotDirty);
        final NiFiRegistryFlowMapper mapper = new NiFiRegistryFlowMapper();
        final VersionedProcessGroup versionedGroup = mapper.mapProcessGroup(this, controllerServiceProvider, flowController.getFlowRegistryClient(), true);
        final ComparableDataFlow localFlow = new StandardComparableDataFlow("Local Flow", versionedGroup);
        final ComparableDataFlow remoteFlow = new StandardComparableDataFlow("Remote Flow", proposedSnapshot.getFlowContents());
        final FlowComparator flowComparator = new StandardFlowComparator(remoteFlow, localFlow, getAncestorGroupServiceIds(), new StaticDifferenceDescriptor());
        final FlowComparison flowComparison = flowComparator.compare();
        final Set<String> updatedVersionedComponentIds = new HashSet<>();
        for (final FlowDifference diff : flowComparison.getDifferences()) {
            // Ignore these as local differences for now because we can't do anything with it
            if (diff.getDifferenceType() == DifferenceType.BUNDLE_CHANGED) {
                continue;
            }
            // and if so compare our VersionedControllerService to the existing service.
            if (diff.getDifferenceType() == DifferenceType.COMPONENT_ADDED) {
                final VersionedComponent component = diff.getComponentA() == null ? diff.getComponentB() : diff.getComponentA();
                if (ComponentType.CONTROLLER_SERVICE == component.getComponentType()) {
                    final ControllerServiceNode serviceNode = getVersionedControllerService(this, component.getIdentifier());
                    if (serviceNode != null) {
                        final VersionedControllerService versionedService = mapper.mapControllerService(serviceNode, controllerServiceProvider);
                        final Set<FlowDifference> differences = flowComparator.compareControllerServices(versionedService, (VersionedControllerService) component);
                        if (!differences.isEmpty()) {
                            updatedVersionedComponentIds.add(component.getIdentifier());
                        }
                        continue;
                    }
                }
            }
            final VersionedComponent component = diff.getComponentA() == null ? diff.getComponentB() : diff.getComponentA();
            updatedVersionedComponentIds.add(component.getIdentifier());
            if (component.getComponentType() == ComponentType.REMOTE_INPUT_PORT || component.getComponentType() == ComponentType.REMOTE_OUTPUT_PORT) {
                final String remoteGroupId = ((VersionedRemoteGroupPort) component).getRemoteGroupId();
                updatedVersionedComponentIds.add(remoteGroupId);
            }
        }
        if (LOG.isInfoEnabled()) {
            final String differencesByLine = flowComparison.getDifferences().stream().map(FlowDifference::toString).collect(Collectors.joining("\n"));
            LOG.info("Updating {} to {}; there are {} differences to take into account:\n{}", this, proposedSnapshot, flowComparison.getDifferences().size(), differencesByLine);
        }
        final Set<String> knownVariables = getKnownVariableNames();
        final StandardVersionControlInformation originalVci = this.versionControlInfo.get();
        try {
            updateProcessGroup(this, proposedSnapshot.getFlowContents(), componentIdSeed, updatedVersionedComponentIds, false, updateSettings, updateDescendantVersionedFlows, knownVariables);
        } catch (final Throwable t) {
            // As a result, it is safe to use the get() and then the set() methods of the AtomicReference without introducing the 'check-then-modify' problem.
            if (this.versionControlInfo.get() == null) {
                this.versionControlInfo.set(originalVci);
            }
            throw t;
        }
    } catch (final ProcessorInstantiationException pie) {
        throw new IllegalStateException("Failed to update flow", pie);
    } finally {
        writeLock.unlock();
    }
}