Package org.apache.nifi.flow.synchronization

Class StandardVersionedComponentSynchronizer

java.lang.Object

org.apache.nifi.flow.synchronization.StandardVersionedComponentSynchronizer

All Implemented Interfaces:

VersionedComponentSynchronizer

public class StandardVersionedComponentSynchronizer
extends Object
implements VersionedComponentSynchronizer

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static final record	StandardVersionedComponentSynchronizer.CreatedOrModifiedExtension
private static final record	StandardVersionedComponentSynchronizer.ParameterValueAndReferences

Field Summary

Fields

Modifier and Type	Field	Description
private final ConnectableAdditionTracker	connectableAdditionTracker
private final VersionedFlowSynchronizationContext	context
private final List<StandardVersionedComponentSynchronizer.CreatedOrModifiedExtension>	createdAndModifiedExtensions
static final String	ENC_PREFIX
static final String	ENC_SUFFIX
private static final org.slf4j.Logger	LOG
private FlowSynchronizationOptions	syncOptions
private static final String	TEMP_FUNNEL_ID_SUFFIX
private final Set<String>	updatedVersionedComponentIds

Constructor Summary

Constructors

Constructor	Description
StandardVersionedComponentSynchronizer(VersionedFlowSynchronizationContext context)

Method Summary

Modifier and Type	Method	Description
private Connection	addConnection(ProcessGroup destinationGroup, org.apache.nifi.flow.VersionedConnection proposed, ComponentIdGenerator componentIdGenerator)
private ControllerServiceNode	addControllerService(ProcessGroup destination, org.apache.nifi.flow.VersionedControllerService proposed, ComponentIdGenerator componentIdGenerator, ProcessGroup topLevelGroup)
private FlowAnalysisRuleNode	addFlowAnalysisRule(org.apache.nifi.flow.VersionedFlowAnalysisRule flowAnalysisRule)
private Funnel	addFunnel(ProcessGroup destination, org.apache.nifi.flow.VersionedFunnel proposed, ComponentIdGenerator componentIdGenerator)
private Port	addInputPort(ProcessGroup destination, org.apache.nifi.flow.VersionedPort proposed, ComponentIdGenerator componentIdGenerator, String temporaryName)
private Label	addLabel(ProcessGroup destination, org.apache.nifi.flow.VersionedLabel proposed, ComponentIdGenerator componentIdGenerator)
private void	addMissingConfiguration(org.apache.nifi.flow.VersionedParameterContext versionedParameterContext, ParameterContext currentParameterContext, Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts, Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences, ComponentIdGenerator componentIdGenerator)
private Port	addOutputPort(ProcessGroup destination, org.apache.nifi.flow.VersionedPort proposed, ComponentIdGenerator componentIdGenerator, String temporaryName)
private ProcessGroup	addProcessGroup(ProcessGroup destination, org.apache.nifi.flow.VersionedProcessGroup proposed, ComponentIdGenerator componentIdGenerator, Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts, Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences, ProcessGroup topLevelGroup)
private ProcessorNode	addProcessor(ProcessGroup destination, org.apache.nifi.flow.VersionedProcessor proposed, ComponentIdGenerator componentIdGenerator, ProcessGroup topLevelGroup)
private RemoteProcessGroup	addRemoteProcessGroup(ProcessGroup destination, org.apache.nifi.flow.VersionedRemoteProcessGroup proposed, ComponentIdGenerator componentIdGenerator)
private ReportingTaskNode	addReportingTask(org.apache.nifi.flow.VersionedReportingTask reportingTask)
ComponentAdditions	addVersionedComponentsToProcessGroup(ProcessGroup group, VersionedComponentAdditions additions, FlowSynchronizationOptions options)	Adds versioned components to the specified Process Group.
private void	bleedOut(ProcessGroup processGroup, long timeout, FlowSynchronizationOptions synchronizationOptions)
private void	collectValueAndReferences(ParameterContext parameterContext, Map<String,StandardVersionedComponentSynchronizer.ParameterValueAndReferences> valueAndRef)
private <T extends Connectable> Map<String,T>	componentsById(ProcessGroup group, Function<ProcessGroup,Collection<T>> retrieveComponents)
private <T> Map<String,T>	componentsById(ProcessGroup group, Function<ProcessGroup,Collection<T>> retrieveComponents, Function<T,String> retrieveId, Function<T,Optional<String>> retrieveVersionedComponentId)
private boolean	connectionsEmpty(Collection<Connection> connections)
private void	createMissingParameterProvider(org.apache.nifi.flow.VersionedParameterContext versionedParameterContext, String parameterProviderId, Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences, ComponentIdGenerator componentIdGenerator)
private Parameter	createParameter(String contextId, org.apache.nifi.flow.VersionedParameter versionedParameter)
private ParameterContext	createParameterContext(org.apache.nifi.flow.VersionedParameterContext versionedParameterContext, String parameterContextId, Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts, Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences, ComponentIdGenerator componentIdGenerator)
private ParameterContext	createParameterContextWithoutReferences(org.apache.nifi.flow.VersionedParameterContext versionedParameterContext)
private Map<String,Parameter>	createParameterMap(Collection<org.apache.nifi.flow.VersionedParameter> versionedParameters)
private String	createParameterReferenceId(String parameterContextName, Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts, Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences, ComponentIdGenerator componentIdGenerator)
private RemoteProcessGroupPortDescriptor	createPortDescriptor(org.apache.nifi.flow.VersionedRemoteGroupPort proposed, ComponentIdGenerator componentIdGenerator, String rpgId)
private static String	decrypt(String value, PropertyDecryptor decryptor)
private String	determineRegistryId(org.apache.nifi.flow.VersionedFlowCoordinates coordinates)
private void	findAllConnections(Set<org.apache.nifi.flow.VersionedConnection> connections, Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups, Map<String,org.apache.nifi.flow.VersionedConnection> map)
private void	findAllControllerServices(Set<org.apache.nifi.flow.VersionedControllerService> controllerServices, Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups, Map<String,org.apache.nifi.flow.VersionedControllerService> map)
private void	findAllProcessors(Set<org.apache.nifi.flow.VersionedProcessor> processors, Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups, Map<String,org.apache.nifi.flow.VersionedProcessor> map)
private void	findUpstreamComponents(Connection connection, Set<Connectable> components)
private void	findUpstreamComponents(org.apache.nifi.flow.VersionedConnection connection, Set<Connectable> components)
private String	generateTemporaryPortName(org.apache.nifi.flow.VersionedPort proposedPort)
private Connectable	getConnectable(ProcessGroup group, org.apache.nifi.flow.ConnectableComponent connectableComponent)
private Connectable	getConnectable(ProcessGroup group, org.apache.nifi.flow.ConnectableComponent connectableComponent, Function<org.apache.nifi.flow.ConnectableComponent,String> idFunction)
private Map<String,String>	getDecryptedProperties(Map<String,String> properties)
private ParameterContext	getParameterContextByName(String contextName)
private ParameterProviderConfiguration	getParameterProviderConfiguration(org.apache.nifi.flow.VersionedParameterContext context)
private Map<String,String>	getPropertyValues(ComponentNode componentNode)
private String	getPublicPortFinalName(PublicPort publicPort, String proposedFinalName)
private RemoteGroupPort	getRpgInputPort(org.apache.nifi.flow.VersionedRemoteGroupPort port, RemoteProcessGroup rpg, ComponentIdGenerator componentIdGenerator)
private RemoteGroupPort	getRpgOutputPort(org.apache.nifi.flow.VersionedRemoteGroupPort port, RemoteProcessGroup rpg, ComponentIdGenerator componentIdGenerator)
private RemoteGroupPort	getRpgPort(org.apache.nifi.flow.VersionedRemoteGroupPort port, RemoteProcessGroup rpg, ComponentIdGenerator componentIdGenerator, Function<String,RemoteGroupPort> portLookup, Set<RemoteGroupPort> ports)
private Set<String>	getSensitiveDynamicPropertyNames(ComponentNode componentNode, Map<String,String> proposedProperties, Collection<org.apache.nifi.flow.VersionedPropertyDescriptor> proposedDescriptors)
private String	getServiceInstanceId(String serviceVersionedComponentId, ProcessGroup group)
private Funnel	getTemporaryFunnel(ProcessGroup group)
private Set<RemoteGroupPort>	getTransmittingPorts(RemoteProcessGroup rpg)
protected Set<String>	getUpdatedParameterNames(ParameterContext parameterContext, org.apache.nifi.flow.VersionedParameterContext proposed)
private Set<Connectable>	getUpstreamComponents(Connection connection)
private Set<Connectable>	getUpstreamComponents(org.apache.nifi.flow.VersionedConnection connection)
private StandardVersionedComponentSynchronizer.ParameterValueAndReferences	getValueAndReferences(org.apache.nifi.flow.VersionedParameter parameter)
private StandardVersionedComponentSynchronizer.ParameterValueAndReferences	getValueAndReferences(Parameter parameter)
private ControllerServiceNode	getVersionedControllerService(ProcessGroup group, String versionedComponentId)
private String	getVersionedId(String instanceId, String versionedId)	Determines the Versioned Component ID to use for a component by first using the Versioned ID if it is already available.
private String	getVersionedId(ProcessGroup processGroup)
private boolean	isConnectionDestinationReachable(Connectable source, Connectable destination)	Checks if a Connection can be made from the given source component to the given destination component
private boolean	isDoneProcessing(ProcessGroup group)
private boolean	isEqual(BundleCoordinate coordinate, org.apache.nifi.flow.Bundle bundle)
private boolean	isSourceProcessor(ProcessorNode processor)
private boolean	isTempDestinationNecessary(Connection existingConnection, org.apache.nifi.flow.VersionedConnection proposedConnection, Connectable newDestination)
private boolean	isTransmitting(org.apache.nifi.flow.VersionedRemoteProcessGroup versionedRpg)
private boolean	isUpdateable(Connection connection)
private static boolean	isValueEncrypted(String value)
private Map<String,org.apache.nifi.flow.VersionedRemoteGroupPort>	mapRemoteGroupPortsByTargetId(Set<org.apache.nifi.flow.VersionedRemoteGroupPort> remoteGroupPorts)
private boolean	matchesGroupId(ProcessGroup group, String groupId)
private <T extends VersionedComponent & Connectable> boolean	matchesId(T component, String id)
private void	notifyScheduledStateChange(Collection<ControllerServiceNode> servicesToRestart, FlowSynchronizationOptions synchronizationOptions, org.apache.nifi.flow.ScheduledState intendedState)
private void	notifyScheduledStateChange(Connectable component, FlowSynchronizationOptions synchronizationOptions, org.apache.nifi.flow.ScheduledState intendedState)
private void	notifyScheduledStateChange(Port inputPort, FlowSynchronizationOptions synchronizationOptions, org.apache.nifi.flow.ScheduledState intendedState)
private void	notifyScheduledStateChange(ComponentNode component, FlowSynchronizationOptions synchronizationOptions, org.apache.nifi.flow.ScheduledState intendedState)
private Map<String,String>	populatePropertiesMap(ComponentNode componentNode, Map<String,String> proposedProperties, Map<String,org.apache.nifi.flow.VersionedPropertyDescriptor> proposedPropertyDescriptors, ProcessGroup group, ProcessGroup topLevelGroup)
private void	purgeChildGroupOfEmptyChildren(ProcessGroup group)
private void	removeMissingChildGroups(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,ProcessGroup> groupsByVersionedId)
private <C, V extends org.apache.nifi.flow.VersionedComponent> void	removeMissingComponents(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,C> componentsById, Function<org.apache.nifi.flow.VersionedProcessGroup,Collection<V>> getVersionedComponents, BiConsumer<ProcessGroup,C> removeComponent)
private void	removeMissingConnections(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,Connection> connectionsByVersionedId)
private void	removeMissingControllerServices(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,ControllerServiceNode> servicesByVersionedId)
private void	removeMissingFunnels(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,Funnel> funnelsByVersionedId)
private void	removeMissingInputPorts(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,Port> portsByVersionedId)
private void	removeMissingLabels(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,Label> labelsByVersionedId)
private void	removeMissingOutputPorts(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,Port> portsByVersionedId)
private void	removeMissingProcessors(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,ProcessorNode> processorsByVersionedId)
private void	removeMissingRpg(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,RemoteProcessGroup> rpgsByVersionedId)
private void	removeTemporaryFunnel(ProcessGroup group)
private void	restoreConnectionDestinations(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,Connection> connectionsByVersionedId, Set<String> connectionsWithTempDestination)
private ParameterContext	selectParameterContext(org.apache.nifi.flow.VersionedParameterContext versionedParameterContext, Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts, Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences, ComponentIdGenerator componentIdGenerator)
void	setSynchronizationOptions(FlowSynchronizationOptions syncOptions)
private void	startComponents(Collection<Connectable> stoppedComponents, FlowSynchronizationOptions synchronizationOptions)
private void	stopControllerService(ControllerServiceNode controllerService, org.apache.nifi.flow.VersionedControllerService proposed, long timeout, FlowSynchronizationOptions.ComponentStopTimeoutAction timeoutAction, Set<ComponentNode> referencesStopped, Set<ControllerServiceNode> servicesDisabled, FlowSynchronizationOptions synchronizationOptions)
private Set<Connectable>	stopDownstreamComponents(Connectable component, long timeout, FlowSynchronizationOptions synchronizationOptions)
private <T extends Connectable> Set<T>	stopOrTerminate(Set<T> components, long timeout, FlowSynchronizationOptions synchronizationOptions)
private boolean	stopOrTerminate(Connectable component, long timeout, FlowSynchronizationOptions synchronizationOptions)
private boolean	stopOrTerminate(ProcessorNode processor, long timeout, FlowSynchronizationOptions synchronizationOptions)
private boolean	stopProcessor(ProcessorNode processor, long timeout)
void	synchronize(Connection connection, org.apache.nifi.flow.VersionedConnection proposedConnection, ProcessGroup group, FlowSynchronizationOptions synchronizationOptions)	Synchronizes the given Connection to match the proposed one, or deletes the Connection if the proposed is null.
void	synchronize(Funnel funnel, org.apache.nifi.flow.VersionedFunnel proposed, ProcessGroup group, FlowSynchronizationOptions synchronizationOptions)	Synchronizes the given Funnel to match the proposed one, or deletes the Funnel if the proposed is null.
void	synchronize(Port port, org.apache.nifi.flow.VersionedPort proposed, ProcessGroup group, FlowSynchronizationOptions synchronizationOptions)	Synchronizes the given Port to match the proposed one, or deletes the Port if the proposed is null.
void	synchronize(FlowAnalysisRuleNode flowAnalysisRule, org.apache.nifi.flow.VersionedFlowAnalysisRule proposed, FlowSynchronizationOptions synchronizationOptions)	Synchronizes the given Flow Analysis Rule to match the proposed one, or deletes the Flow Analysis Rule if the proposed is null.
void	synchronize(Label label, org.apache.nifi.flow.VersionedLabel proposed, ProcessGroup group, FlowSynchronizationOptions synchronizationOptions)	Synchronizes the given Label to match the proposed one, or deletes the Label if the proposed is null.
void	synchronize(ProcessorNode processor, org.apache.nifi.flow.VersionedProcessor proposedProcessor, ProcessGroup group, FlowSynchronizationOptions synchronizationOptions)	Synchronizes the given Processor to match the proposed snapshot, or deletes the Processor if the proposed snapshot is null.
void	synchronize(ReportingTaskNode reportingTask, org.apache.nifi.flow.VersionedReportingTask proposed, FlowSynchronizationOptions synchronizationOptions)	Synchronizes the given Reporting Task to match the proposed one, or deletes the Reporting Task if the proposed is null.
void	synchronize(ControllerServiceNode controllerService, org.apache.nifi.flow.VersionedControllerService proposed, ProcessGroup group, FlowSynchronizationOptions synchronizationOptions)	Synchronizes the given Controller Service to match the proposed version, or deletes the Controller Service if the proposed snapshot is null.
void	synchronize(ProcessGroup group, org.apache.nifi.flow.VersionedExternalFlow versionedExternalFlow, FlowSynchronizationOptions options)	Synchronize the given Process Group to match the proposed flow
private void	synchronize(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts, Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences, ProcessGroup topLevelGroup, boolean updateGroupSettings)
void	synchronize(RemoteProcessGroup rpg, org.apache.nifi.flow.VersionedRemoteProcessGroup proposed, ProcessGroup group, FlowSynchronizationOptions synchronizationOptions)	Synchronizes the given Remote Process Group to match the proposed one, or deletes the rpg if the proposed is null.
void	synchronize(ParameterContext parameterContext, org.apache.nifi.flow.VersionedParameterContext proposed, FlowSynchronizationOptions synchronizationOptions)
private void	synchronizeChildGroups(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts, Map<String,ProcessGroup> childGroupsByVersionedId, Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences, ProcessGroup topLevelGroup)
private void	synchronizeConnections(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,Connection> connectionsByVersionedId)
private void	synchronizeControllerServices(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,ControllerServiceNode> servicesByVersionedId, ProcessGroup topLevelGroup)
private void	synchronizeFunnels(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,Funnel> funnelsByVersionedId)
private void	synchronizeInputPorts(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<Port,String> proposedPortFinalNames, Map<String,Port> inputPortsByVersionedId)
private void	synchronizeLabels(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,Label> labelsByVersionedId)
private void	synchronizeOutputPorts(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<Port,String> proposedPortFinalNames, Map<String,Port> outputPortsByVersionedId)
void	synchronizeProcessGroupSettings(ProcessGroup processGroup, org.apache.nifi.flow.VersionedProcessGroup proposed, ProcessGroup parentGroup, FlowSynchronizationOptions synchronizationOptions)
private void	synchronizeProcessors(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,ProcessorNode> processorsByVersionedId, ProcessGroup topLevelGroup)
private void	synchronizeRemoteGroupPorts(Set<RemoteGroupPort> remoteGroupPorts, Set<org.apache.nifi.flow.VersionedRemoteGroupPort> proposedPorts)
private void	synchronizeRemoteGroups(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,RemoteProcessGroup> rpgsByVersionedId)
private void	synchronizeTransmissionState(org.apache.nifi.flow.VersionedRemoteGroupPort versionedPort, RemoteGroupPort remoteGroupPort)
private void	terminateComponents(Set<Connectable> components, FlowSynchronizationOptions synchronizationOptions)
private BundleCoordinate	toCoordinate(org.apache.nifi.flow.Bundle bundle)
private void	updateConnection(Connection connection, org.apache.nifi.flow.VersionedConnection proposed)
private Set<String>	updateConnectionDestinations(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,Connection> connectionsByVersionedId)
private void	updateControllerService(ControllerServiceNode service, org.apache.nifi.flow.VersionedControllerService proposed, ProcessGroup topLevelGroup)
private void	updateFlowAnalysisRule(FlowAnalysisRuleNode flowAnalysisRule, org.apache.nifi.flow.VersionedFlowAnalysisRule proposed)
private void	updateFunnel(Funnel funnel, org.apache.nifi.flow.VersionedFunnel proposed)
private void	updateLabel(Label label, org.apache.nifi.flow.VersionedLabel proposed)
private void	updateParameterContext(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup proposed, Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts, Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences, ComponentIdGenerator componentIdGenerator)
private void	updatePort(Port port, org.apache.nifi.flow.VersionedPort proposed, String temporaryName)
private void	updatePortsToFinalNames(Map<Port,String> proposedPortFinalNames)
private void	updatePortToSetFinalName(Port port, String name)
private void	updateProcessor(ProcessorNode processor, org.apache.nifi.flow.VersionedProcessor proposed, ProcessGroup topLevelGroup)
private void	updateRemoteProcessGroup(RemoteProcessGroup rpg, org.apache.nifi.flow.VersionedRemoteProcessGroup proposed, ComponentIdGenerator componentIdGenerator)
private void	updateReportingTask(ReportingTaskNode reportingTask, org.apache.nifi.flow.VersionedReportingTask proposed)
void	verifyCanAddVersionedComponents(ProcessGroup group, VersionedComponentAdditions additions)	Verifies that the given additions can be applied to the specified process group.
private void	verifyCanDelete(Connectable connectable, long timeout)
private void	verifyCanDeleteConnections(Connectable connectable, long timeout)
private void	verifyCanDeleteWhenQueueEmpty(Connection connection)
private void	verifyCanInstantiateConnections(ProcessGroup group, Set<org.apache.nifi.flow.VersionedConnection> connections, Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups)
private void	verifyCanInstantiateControllerServices(ProcessGroup group, Set<org.apache.nifi.flow.VersionedControllerService> controllerServices, Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups)
private void	verifyCanInstantiateProcessors(ProcessGroup group, Set<org.apache.nifi.flow.VersionedProcessor> processors, Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups)
private void	verifyCanRemoveMissingComponents(ProcessGroup processGroup, org.apache.nifi.flow.VersionedProcessGroup proposedGroup, boolean verifyConnectionRemoval)	Match components of the given process group to the proposed versioned process group and verify missing components are in a state that they can be safely removed.
private void	verifyCanSynchronize(Connection connection, org.apache.nifi.flow.VersionedConnection proposedConnection)
private void	verifyCanSynchronize(Port port, org.apache.nifi.flow.VersionedPort proposed, long timeout)
private void	verifyCanSynchronize(ProcessorNode processor, org.apache.nifi.flow.VersionedProcessor proposedProcessor, long timeout)
private void	verifyCanSynchronize(ControllerServiceNode controllerService, org.apache.nifi.flow.VersionedControllerService proposed)
void	verifyCanSynchronize(ProcessGroup group, org.apache.nifi.flow.VersionedProcessGroup flowContents, boolean verifyConnectionRemoval)	Verifies that the given Process Group can be updated to match the proposed flow
private void	verifyCanSynchronize(ParameterContext parameterContext, org.apache.nifi.flow.VersionedParameterContext proposed)
private void	verifyNoIncomingConnections(Connectable connectable)
private void	verifyNotInherited(String parameterContextId)
private void	waitFor(long timeout, BooleanSupplier condition)
private void	waitForQueueEmpty(Connection connection, Duration duration)
private void	waitForStopCompletion(Future<?> future, Object component, long timeout, FlowSynchronizationOptions.ComponentStopTimeoutAction timeoutAction)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

LOG

private static final org.slf4j.Logger LOG

TEMP_FUNNEL_ID_SUFFIX

private static final String TEMP_FUNNEL_ID_SUFFIX

See Also:

• Constant Field Values

ENC_PREFIX

public static final String ENC_PREFIX

See Also:

• Constant Field Values

ENC_SUFFIX

public static final String ENC_SUFFIX

See Also:

• Constant Field Values

context

private final VersionedFlowSynchronizationContext context

updatedVersionedComponentIds

private final Set<String> updatedVersionedComponentIds

createdAndModifiedExtensions

private final List<StandardVersionedComponentSynchronizer.CreatedOrModifiedExtension> createdAndModifiedExtensions

syncOptions

private FlowSynchronizationOptions syncOptions

connectableAdditionTracker

private final ConnectableAdditionTracker connectableAdditionTracker

Constructor Details

StandardVersionedComponentSynchronizer

public StandardVersionedComponentSynchronizer(VersionedFlowSynchronizationContext context)

Method Details

setSynchronizationOptions

public void setSynchronizationOptions(FlowSynchronizationOptions syncOptions)

addVersionedComponentsToProcessGroup

public ComponentAdditions addVersionedComponentsToProcessGroup(ProcessGroup group,
 VersionedComponentAdditions additions,
 FlowSynchronizationOptions options)

Description copied from interface: VersionedComponentSynchronizer

Adds versioned components to the specified Process Group.

Specified by:

addVersionedComponentsToProcessGroup in interface VersionedComponentSynchronizer

Parameters:

group - the Process Group to append to

additions - the component additions to add to the Process Group

options - sync options

Returns:

the component additions

synchronize

public void synchronize(ProcessGroup group,
 org.apache.nifi.flow.VersionedExternalFlow versionedExternalFlow,
 FlowSynchronizationOptions options)

Description copied from interface: VersionedComponentSynchronizer

Synchronize the given Process Group to match the proposed flow

Specified by:

synchronize in interface VersionedComponentSynchronizer

Parameters:

group - the Process Group to update

versionedExternalFlow - the proposed/desired state for the process group

options - options for how to synchronize the group

synchronize

private void synchronize(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts,
 Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences,
 ProcessGroup topLevelGroup,
 boolean updateGroupSettings)
                  throws ProcessorInstantiationException

Throws:

ProcessorInstantiationException

determineRegistryId

private String determineRegistryId(org.apache.nifi.flow.VersionedFlowCoordinates coordinates)

synchronizeChildGroups

private void synchronizeChildGroups(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts,
 Map<String,ProcessGroup> childGroupsByVersionedId,
 Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences,
 ProcessGroup topLevelGroup)
                             throws ProcessorInstantiationException

Throws:

ProcessorInstantiationException

synchronizeControllerServices

private void synchronizeControllerServices(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,ControllerServiceNode> servicesByVersionedId,
 ProcessGroup topLevelGroup)

removeMissingConnections

private void removeMissingConnections(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,Connection> connectionsByVersionedId)

synchronizeConnections

private void synchronizeConnections(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,Connection> connectionsByVersionedId)

updateConnectionDestinations

private Set<String> updateConnectionDestinations(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,Connection> connectionsByVersionedId)

isConnectionDestinationReachable

private boolean isConnectionDestinationReachable(Connectable source,
 Connectable destination)

Checks if a Connection can be made from the given source component to the given destination component

Parameters:

source - the source component

destination - the destination component

Returns:

true if the connection is allowable, false if the connection cannot be made due to the Process Group hierarchies

isTempDestinationNecessary

private boolean isTempDestinationNecessary(Connection existingConnection,
 org.apache.nifi.flow.VersionedConnection proposedConnection,
 Connectable newDestination)

getVersionedId

private String getVersionedId(ProcessGroup processGroup)

getVersionedId

private String getVersionedId(String instanceId,
 String versionedId)

Determines the Versioned Component ID to use for a component by first using the Versioned ID if it is already available. Otherwise, use the Component ID Lookup to determine the Versioned ID based on the Instance ID. This allows us to ensure that when we sync the dataflow, we use the same approach to mapping as we will use when we write out the dataflow.

Returns:

the Versioned Component ID to use for the component

getTemporaryFunnel

private Funnel getTemporaryFunnel(ProcessGroup group)

restoreConnectionDestinations

private void restoreConnectionDestinations(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,Connection> connectionsByVersionedId,
 Set<String> connectionsWithTempDestination)

removeTemporaryFunnel

private void removeTemporaryFunnel(ProcessGroup group)

componentsById

private <T extends Connectable> Map<String,T> componentsById(ProcessGroup group,
 Function<ProcessGroup,Collection<T>> retrieveComponents)

componentsById

private <T> Map<String,T> componentsById(ProcessGroup group,
 Function<ProcessGroup,Collection<T>> retrieveComponents,
 Function<T,String> retrieveId,
 Function<T,Optional<String>> retrieveVersionedComponentId)

synchronizeFunnels

private void synchronizeFunnels(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,Funnel> funnelsByVersionedId)

synchronizeInputPorts

private void synchronizeInputPorts(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<Port,String> proposedPortFinalNames,
 Map<String,Port> inputPortsByVersionedId)

synchronizeOutputPorts

private void synchronizeOutputPorts(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<Port,String> proposedPortFinalNames,
 Map<String,Port> outputPortsByVersionedId)

updatePortsToFinalNames

private void updatePortsToFinalNames(Map<Port,String> proposedPortFinalNames)

synchronizeLabels

private void synchronizeLabels(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,Label> labelsByVersionedId)

removeMissingProcessors

private void removeMissingProcessors(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,ProcessorNode> processorsByVersionedId)

removeMissingInputPorts

private void removeMissingInputPorts(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,Port> portsByVersionedId)

removeMissingOutputPorts

private void removeMissingOutputPorts(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,Port> portsByVersionedId)

removeMissingLabels

private void removeMissingLabels(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,Label> labelsByVersionedId)

removeMissingFunnels

private void removeMissingFunnels(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,Funnel> funnelsByVersionedId)

removeMissingRpg

private void removeMissingRpg(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,RemoteProcessGroup> rpgsByVersionedId)

removeMissingControllerServices

private void removeMissingControllerServices(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,ControllerServiceNode> servicesByVersionedId)

removeMissingChildGroups

private void removeMissingChildGroups(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,ProcessGroup> groupsByVersionedId)

purgeChildGroupOfEmptyChildren

private void purgeChildGroupOfEmptyChildren(ProcessGroup group)

removeMissingComponents

private <C,
V extends org.apache.nifi.flow.VersionedComponent>
void removeMissingComponents(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,C> componentsById,
 Function<org.apache.nifi.flow.VersionedProcessGroup,Collection<V>> getVersionedComponents,
 BiConsumer<ProcessGroup,C> removeComponent)

synchronizeProcessors

private void synchronizeProcessors(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,ProcessorNode> processorsByVersionedId,
 ProcessGroup topLevelGroup)
                            throws ProcessorInstantiationException

Throws:

ProcessorInstantiationException

synchronizeRemoteGroups

private void synchronizeRemoteGroups(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,RemoteProcessGroup> rpgsByVersionedId)

verifyCanAddVersionedComponents

public void verifyCanAddVersionedComponents(ProcessGroup group,
 VersionedComponentAdditions additions)

Description copied from interface: VersionedComponentSynchronizer

Verifies that the given additions can be applied to the specified process group.

Specified by:

verifyCanAddVersionedComponents in interface VersionedComponentSynchronizer

Parameters:

group - the Process Group that will be appended to

additions - the component additions that will be added to the Process Group

verifyCanSynchronize

public void verifyCanSynchronize(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup flowContents,
 boolean verifyConnectionRemoval)

Description copied from interface: VersionedComponentSynchronizer

Verifies that the given Process Group can be updated to match the proposed flow

Specified by:

verifyCanSynchronize in interface VersionedComponentSynchronizer

Parameters:

group - the group to update

flowContents - the proposed updated version

verifyConnectionRemoval - if true and synchronizing the Process Group would result in any Connection being removed, an IllegalStateException will be thrown if that Connection has data in it. If false, the presence of data in removed queues will be ignored.

verifyCanInstantiateProcessors

private void verifyCanInstantiateProcessors(ProcessGroup group,
 Set<org.apache.nifi.flow.VersionedProcessor> processors,
 Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups)

verifyCanInstantiateControllerServices

private void verifyCanInstantiateControllerServices(ProcessGroup group,
 Set<org.apache.nifi.flow.VersionedControllerService> controllerServices,
 Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups)

verifyCanInstantiateConnections

private void verifyCanInstantiateConnections(ProcessGroup group,
 Set<org.apache.nifi.flow.VersionedConnection> connections,
 Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups)

addProcessGroup

private ProcessGroup addProcessGroup(ProcessGroup destination,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 ComponentIdGenerator componentIdGenerator,
 Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts,
 Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences,
 ProcessGroup topLevelGroup)
                              throws ProcessorInstantiationException

Throws:

ProcessorInstantiationException

addControllerService

private ControllerServiceNode addControllerService(ProcessGroup destination,
 org.apache.nifi.flow.VersionedControllerService proposed,
 ComponentIdGenerator componentIdGenerator,
 ProcessGroup topLevelGroup)

verifyCanSynchronize

private void verifyCanSynchronize(ControllerServiceNode controllerService,
 org.apache.nifi.flow.VersionedControllerService proposed)

synchronize

public void synchronize(ControllerServiceNode controllerService,
 org.apache.nifi.flow.VersionedControllerService proposed,
 ProcessGroup group,
 FlowSynchronizationOptions synchronizationOptions)
                 throws FlowSynchronizationException,
TimeoutException,
InterruptedException

Description copied from interface: VersionedComponentSynchronizer

Synchronizes the given Controller Service to match the proposed version, or deletes the Controller Service if the proposed snapshot is null. If the given Controller Service is null, adds the Controller Service to the given Process Group

Specified by:

synchronize in interface VersionedComponentSynchronizer

Parameters:

controllerService - the Controller Service to synchronize

proposed - the proposed/desired state for the controller service

group - the ProcessGroup to which the Controller Service should belong

synchronizationOptions - options for how to synchronize the flow

Throws:

FlowSynchronizationException - if unable to synchronize the Controller Service with the proposed version

TimeoutException - if the Controller Service must be disabled in order to synchronize it with the proposed version and disabling takes longer than the timeout allowed by the synchronization options.

InterruptedException - if interrupted while waiting for Controller Service to disable

waitForStopCompletion

private void waitForStopCompletion(Future<?> future,
 Object component,
 long timeout,
 FlowSynchronizationOptions.ComponentStopTimeoutAction timeoutAction)
                            throws InterruptedException,
FlowSynchronizationException,
TimeoutException

Throws:

InterruptedException

FlowSynchronizationException

TimeoutException

updateControllerService

private void updateControllerService(ControllerServiceNode service,
 org.apache.nifi.flow.VersionedControllerService proposed,
 ProcessGroup topLevelGroup)

getSensitiveDynamicPropertyNames

private Set<String> getSensitiveDynamicPropertyNames(ComponentNode componentNode,
 Map<String,String> proposedProperties,
 Collection<org.apache.nifi.flow.VersionedPropertyDescriptor> proposedDescriptors)

populatePropertiesMap

private Map<String,String> populatePropertiesMap(ComponentNode componentNode,
 Map<String,String> proposedProperties,
 Map<String,org.apache.nifi.flow.VersionedPropertyDescriptor> proposedPropertyDescriptors,
 ProcessGroup group,
 ProcessGroup topLevelGroup)

getDecryptedProperties

private Map<String,String> getDecryptedProperties(Map<String,String> properties)

decrypt

private static String decrypt(String value,
 PropertyDecryptor decryptor)

isValueEncrypted

private static boolean isValueEncrypted(String value)

verifyCanSynchronize

private void verifyCanSynchronize(ParameterContext parameterContext,
 org.apache.nifi.flow.VersionedParameterContext proposed)
                           throws FlowSynchronizationException

Throws:

FlowSynchronizationException

synchronize

public void synchronize(ParameterContext parameterContext,
 org.apache.nifi.flow.VersionedParameterContext proposed,
 FlowSynchronizationOptions synchronizationOptions)
                 throws FlowSynchronizationException,
TimeoutException,
InterruptedException

Specified by:

synchronize in interface VersionedComponentSynchronizer

Throws:

FlowSynchronizationException

TimeoutException

InterruptedException

collectValueAndReferences

private void collectValueAndReferences(ParameterContext parameterContext,
 Map<String,StandardVersionedComponentSynchronizer.ParameterValueAndReferences> valueAndRef)

getUpdatedParameterNames

protected Set<String> getUpdatedParameterNames(ParameterContext parameterContext,
 org.apache.nifi.flow.VersionedParameterContext proposed)

getValueAndReferences

private StandardVersionedComponentSynchronizer.ParameterValueAndReferences getValueAndReferences(Parameter parameter)

getValueAndReferences

private StandardVersionedComponentSynchronizer.ParameterValueAndReferences getValueAndReferences(org.apache.nifi.flow.VersionedParameter parameter)

synchronizeProcessGroupSettings

public void synchronizeProcessGroupSettings(ProcessGroup processGroup,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 ProcessGroup parentGroup,
 FlowSynchronizationOptions synchronizationOptions)
                                     throws FlowSynchronizationException,
TimeoutException,
InterruptedException

Specified by:

synchronizeProcessGroupSettings in interface VersionedComponentSynchronizer

Throws:

FlowSynchronizationException

TimeoutException

InterruptedException

isDoneProcessing

private boolean isDoneProcessing(ProcessGroup group)

bleedOut

private void bleedOut(ProcessGroup processGroup,
 long timeout,
 FlowSynchronizationOptions synchronizationOptions)
               throws FlowSynchronizationException,
TimeoutException,
InterruptedException

Throws:

FlowSynchronizationException

TimeoutException

InterruptedException

waitFor

private void waitFor(long timeout,
 BooleanSupplier condition)
              throws InterruptedException

Throws:

InterruptedException

connectionsEmpty

private boolean connectionsEmpty(Collection<Connection> connections)

isSourceProcessor

private boolean isSourceProcessor(ProcessorNode processor)

verifyNotInherited

private void verifyNotInherited(String parameterContextId)

updateParameterContext

private void updateParameterContext(ProcessGroup group,
 org.apache.nifi.flow.VersionedProcessGroup proposed,
 Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts,
 Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences,
 ComponentIdGenerator componentIdGenerator)

createMissingParameterProvider

private void createMissingParameterProvider(org.apache.nifi.flow.VersionedParameterContext versionedParameterContext,
 String parameterProviderId,
 Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences,
 ComponentIdGenerator componentIdGenerator)

getPublicPortFinalName

private String getPublicPortFinalName(PublicPort publicPort,
 String proposedFinalName)

getParameterContextByName

private ParameterContext getParameterContextByName(String contextName)

createParameterContextWithoutReferences

private ParameterContext createParameterContextWithoutReferences(org.apache.nifi.flow.VersionedParameterContext versionedParameterContext)

getParameterProviderConfiguration

private ParameterProviderConfiguration getParameterProviderConfiguration(org.apache.nifi.flow.VersionedParameterContext context)

createParameterContext

private ParameterContext createParameterContext(org.apache.nifi.flow.VersionedParameterContext versionedParameterContext,
 String parameterContextId,
 Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts,
 Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences,
 ComponentIdGenerator componentIdGenerator)

createParameterMap

private Map<String,Parameter> createParameterMap(Collection<org.apache.nifi.flow.VersionedParameter> versionedParameters)

createParameterReferenceId

private String createParameterReferenceId(String parameterContextName,
 Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts,
 Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences,
 ComponentIdGenerator componentIdGenerator)

selectParameterContext

private ParameterContext selectParameterContext(org.apache.nifi.flow.VersionedParameterContext versionedParameterContext,
 Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts,
 Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences,
 ComponentIdGenerator componentIdGenerator)

addMissingConfiguration

private void addMissingConfiguration(org.apache.nifi.flow.VersionedParameterContext versionedParameterContext,
 ParameterContext currentParameterContext,
 Map<String,org.apache.nifi.flow.VersionedParameterContext> versionedParameterContexts,
 Map<String,org.apache.nifi.flow.ParameterProviderReference> parameterProviderReferences,
 ComponentIdGenerator componentIdGenerator)

createParameter

private Parameter createParameter(String contextId,
 org.apache.nifi.flow.VersionedParameter versionedParameter)

isEqual

private boolean isEqual(BundleCoordinate coordinate,
 org.apache.nifi.flow.Bundle bundle)

toCoordinate

private BundleCoordinate toCoordinate(org.apache.nifi.flow.Bundle bundle)

synchronize

public void synchronize(Funnel funnel,
 org.apache.nifi.flow.VersionedFunnel proposed,
 ProcessGroup group,
 FlowSynchronizationOptions synchronizationOptions)
                 throws FlowSynchronizationException,
TimeoutException,
InterruptedException

Description copied from interface: VersionedComponentSynchronizer

Synchronizes the given Funnel to match the proposed one, or deletes the Funnel if the proposed is null. If the given Funnel is null, creates it and adds it to the given ProcessGroup

Specified by:

synchronize in interface VersionedComponentSynchronizer

Parameters:

funnel - the funnel to synchronize

proposed - the proposed/desired state for the funnel

group - the ProcessGroup to which the funnel should belong

synchronizationOptions - options for how to synchronize the flow

Throws:

FlowSynchronizationException - if unable to synchronize the funnel with the proposed version

TimeoutException - if the funnel is being removed and downstream components take longer to stop than the timeout allowed by the synchronization options.

InterruptedException

synchronize

public void synchronize(Label label,
 org.apache.nifi.flow.VersionedLabel proposed,
 ProcessGroup group,
 FlowSynchronizationOptions synchronizationOptions)

Description copied from interface: VersionedComponentSynchronizer

Synchronizes the given Label to match the proposed one, or deletes the Label if the proposed is null. If the given Label is null, creates it and adds it to the given ProcessGroup

Specified by:

synchronize in interface VersionedComponentSynchronizer

Parameters:

label - the label to synchronize

proposed - the proposed/desired state for the label

group - the ProcessGroup to which the label should belong

synchronizationOptions - options for how to synchronize the flow

updateFunnel

private void updateFunnel(Funnel funnel,
 org.apache.nifi.flow.VersionedFunnel proposed)

addFunnel

private Funnel addFunnel(ProcessGroup destination,
 org.apache.nifi.flow.VersionedFunnel proposed,
 ComponentIdGenerator componentIdGenerator)

isUpdateable

private boolean isUpdateable(Connection connection)

generateTemporaryPortName

private String generateTemporaryPortName(org.apache.nifi.flow.VersionedPort proposedPort)

updatePortToSetFinalName

private void updatePortToSetFinalName(Port port,
 String name)

verifyCanSynchronize

private void verifyCanSynchronize(Port port,
 org.apache.nifi.flow.VersionedPort proposed,
 long timeout)
                           throws InterruptedException,
TimeoutException,
FlowSynchronizationException

Throws:

InterruptedException

TimeoutException

FlowSynchronizationException

synchronize

public void synchronize(Port port,
 org.apache.nifi.flow.VersionedPort proposed,
 ProcessGroup group,
 FlowSynchronizationOptions synchronizationOptions)
                 throws FlowSynchronizationException,
TimeoutException,
InterruptedException

Description copied from interface: VersionedComponentSynchronizer

Synchronizes the given Port to match the proposed one, or deletes the Port if the proposed is null. If the given Port is null, creates it and adds it to the given ProcessGroup

Specified by:

synchronize in interface VersionedComponentSynchronizer

Parameters:

port - the port to synchronize

proposed - the proposed/desired state for the port

group - the ProcessGroup to which the port should belong

synchronizationOptions - options for how to synchronize the flow

Throws:

FlowSynchronizationException - if unable to synchronize the port with the proposed version

TimeoutException - if the port is running and takes longer to stop than the timeout allowed by the synchronization options.

InterruptedException

startComponents

private void startComponents(Collection<Connectable> stoppedComponents,
 FlowSynchronizationOptions synchronizationOptions)

updatePort

private void updatePort(Port port,
 org.apache.nifi.flow.VersionedPort proposed,
 String temporaryName)

addInputPort

private Port addInputPort(ProcessGroup destination,
 org.apache.nifi.flow.VersionedPort proposed,
 ComponentIdGenerator componentIdGenerator,
 String temporaryName)

addOutputPort

private Port addOutputPort(ProcessGroup destination,
 org.apache.nifi.flow.VersionedPort proposed,
 ComponentIdGenerator componentIdGenerator,
 String temporaryName)

addLabel

private Label addLabel(ProcessGroup destination,
 org.apache.nifi.flow.VersionedLabel proposed,
 ComponentIdGenerator componentIdGenerator)

updateLabel

private void updateLabel(Label label,
 org.apache.nifi.flow.VersionedLabel proposed)

addProcessor

private ProcessorNode addProcessor(ProcessGroup destination,
 org.apache.nifi.flow.VersionedProcessor proposed,
 ComponentIdGenerator componentIdGenerator,
 ProcessGroup topLevelGroup)
                            throws ProcessorInstantiationException

Throws:

ProcessorInstantiationException

verifyCanSynchronize

private void verifyCanSynchronize(ProcessorNode processor,
 org.apache.nifi.flow.VersionedProcessor proposedProcessor,
 long timeout)
                           throws InterruptedException,
TimeoutException,
FlowSynchronizationException

Throws:

InterruptedException

TimeoutException

FlowSynchronizationException

verifyCanDelete

private void verifyCanDelete(Connectable connectable,
 long timeout)
                      throws InterruptedException,
TimeoutException,
FlowSynchronizationException

Throws:

InterruptedException

TimeoutException

FlowSynchronizationException

verifyCanDeleteConnections

private void verifyCanDeleteConnections(Connectable connectable,
 long timeout)
                                 throws InterruptedException,
TimeoutException,
FlowSynchronizationException

Throws:

InterruptedException

TimeoutException

FlowSynchronizationException

verifyNoIncomingConnections

private void verifyNoIncomingConnections(Connectable connectable)
                                  throws FlowSynchronizationException

Throws:

FlowSynchronizationException

synchronize

public void synchronize(ProcessorNode processor,
 org.apache.nifi.flow.VersionedProcessor proposedProcessor,
 ProcessGroup group,
 FlowSynchronizationOptions synchronizationOptions)
                 throws FlowSynchronizationException,
TimeoutException,
InterruptedException

Description copied from interface: VersionedComponentSynchronizer

Synchronizes the given Processor to match the proposed snapshot, or deletes the Processor if the proposed snapshot is null. If the given processor is null, adds the processor to the given ProcessGroup

Specified by:

synchronize in interface VersionedComponentSynchronizer

Parameters:

processor - the processor to synchronize

proposedProcessor - the proposed/desired state for the processor

group - the ProcessGroup to which the ProcessorNode should belong.

synchronizationOptions - options for how to synchronize the flow

Throws:

FlowSynchronizationException - if unable to synchronize the processor with the proposed version

TimeoutException - if the processor must be stopped in order to synchronize it with the proposed version and stopping takes longer than the timeout allowed by the synchronization options.

InterruptedException - if interrupted while waiting for processor to stop or outbound connections to empty if processor is being removed

stopDownstreamComponents

private Set<Connectable> stopDownstreamComponents(Connectable component,
 long timeout,
 FlowSynchronizationOptions synchronizationOptions)
                                           throws FlowSynchronizationException,
TimeoutException

Throws:

FlowSynchronizationException

TimeoutException

stopOrTerminate

private <T extends Connectable> Set<T> stopOrTerminate(Set<T> components,
 long timeout,
 FlowSynchronizationOptions synchronizationOptions)
                                                throws TimeoutException,
FlowSynchronizationException

Throws:

TimeoutException

FlowSynchronizationException

notifyScheduledStateChange

private void notifyScheduledStateChange(Connectable component,
 FlowSynchronizationOptions synchronizationOptions,
 org.apache.nifi.flow.ScheduledState intendedState)

notifyScheduledStateChange

private void notifyScheduledStateChange(ComponentNode component,
 FlowSynchronizationOptions synchronizationOptions,
 org.apache.nifi.flow.ScheduledState intendedState)

notifyScheduledStateChange

private void notifyScheduledStateChange(Collection<ControllerServiceNode> servicesToRestart,
 FlowSynchronizationOptions synchronizationOptions,
 org.apache.nifi.flow.ScheduledState intendedState)

notifyScheduledStateChange

private void notifyScheduledStateChange(Port inputPort,
 FlowSynchronizationOptions synchronizationOptions,
 org.apache.nifi.flow.ScheduledState intendedState)

stopOrTerminate

private boolean stopOrTerminate(Connectable component,
 long timeout,
 FlowSynchronizationOptions synchronizationOptions)
                         throws TimeoutException,
FlowSynchronizationException

Throws:

TimeoutException

FlowSynchronizationException

stopOrTerminate

private boolean stopOrTerminate(ProcessorNode processor,
 long timeout,
 FlowSynchronizationOptions synchronizationOptions)
                         throws TimeoutException,
FlowSynchronizationException

Throws:

TimeoutException

FlowSynchronizationException

stopProcessor

private boolean stopProcessor(ProcessorNode processor,
 long timeout)
                       throws FlowSynchronizationException,
TimeoutException

Throws:

FlowSynchronizationException

TimeoutException

stopControllerService

private void stopControllerService(ControllerServiceNode controllerService,
 org.apache.nifi.flow.VersionedControllerService proposed,
 long timeout,
 FlowSynchronizationOptions.ComponentStopTimeoutAction timeoutAction,
 Set<ComponentNode> referencesStopped,
 Set<ControllerServiceNode> servicesDisabled,
 FlowSynchronizationOptions synchronizationOptions)
                            throws FlowSynchronizationException,
TimeoutException,
InterruptedException

Throws:

FlowSynchronizationException

TimeoutException

InterruptedException

updateProcessor

private void updateProcessor(ProcessorNode processor,
 org.apache.nifi.flow.VersionedProcessor proposed,
 ProcessGroup topLevelGroup)
                      throws ProcessorInstantiationException

Throws:

ProcessorInstantiationException

getServiceInstanceId

private String getServiceInstanceId(String serviceVersionedComponentId,
 ProcessGroup group)

synchronize

public void synchronize(RemoteProcessGroup rpg,
 org.apache.nifi.flow.VersionedRemoteProcessGroup proposed,
 ProcessGroup group,
 FlowSynchronizationOptions synchronizationOptions)
                 throws FlowSynchronizationException,
TimeoutException,
InterruptedException

Description copied from interface: VersionedComponentSynchronizer

Synchronizes the given Remote Process Group to match the proposed one, or deletes the rpg if the proposed is null. If the given rpg is null, creates it and adds it to the given ProcessGroup

Specified by:

synchronize in interface VersionedComponentSynchronizer

Parameters:

rpg - the rpg to synchronize

proposed - the proposed/desired state for the rpg

group - the ProcessGroup to which the rpg should belong

synchronizationOptions - options for how to synchronize the flow

Throws:

FlowSynchronizationException - if unable to synchronize the rpg with the proposed version

TimeoutException - if the rpg is being removed and takes longer to stop than the timeout allowed by the synchronization options.

InterruptedException

isTransmitting

private boolean isTransmitting(org.apache.nifi.flow.VersionedRemoteProcessGroup versionedRpg)

getTransmittingPorts

private Set<RemoteGroupPort> getTransmittingPorts(RemoteProcessGroup rpg)

addRemoteProcessGroup

private RemoteProcessGroup addRemoteProcessGroup(ProcessGroup destination,
 org.apache.nifi.flow.VersionedRemoteProcessGroup proposed,
 ComponentIdGenerator componentIdGenerator)

updateRemoteProcessGroup

private void updateRemoteProcessGroup(RemoteProcessGroup rpg,
 org.apache.nifi.flow.VersionedRemoteProcessGroup proposed,
 ComponentIdGenerator componentIdGenerator)

synchronizeRemoteGroupPorts

private void synchronizeRemoteGroupPorts(Set<RemoteGroupPort> remoteGroupPorts,
 Set<org.apache.nifi.flow.VersionedRemoteGroupPort> proposedPorts)

mapRemoteGroupPortsByTargetId

private Map<String,org.apache.nifi.flow.VersionedRemoteGroupPort> mapRemoteGroupPortsByTargetId(Set<org.apache.nifi.flow.VersionedRemoteGroupPort> remoteGroupPorts)

getRpgInputPort

private RemoteGroupPort getRpgInputPort(org.apache.nifi.flow.VersionedRemoteGroupPort port,
 RemoteProcessGroup rpg,
 ComponentIdGenerator componentIdGenerator)

getRpgOutputPort

private RemoteGroupPort getRpgOutputPort(org.apache.nifi.flow.VersionedRemoteGroupPort port,
 RemoteProcessGroup rpg,
 ComponentIdGenerator componentIdGenerator)

getRpgPort

private RemoteGroupPort getRpgPort(org.apache.nifi.flow.VersionedRemoteGroupPort port,
 RemoteProcessGroup rpg,
 ComponentIdGenerator componentIdGenerator,
 Function<String,RemoteGroupPort> portLookup,
 Set<RemoteGroupPort> ports)

synchronizeTransmissionState

private void synchronizeTransmissionState(org.apache.nifi.flow.VersionedRemoteGroupPort versionedPort,
 RemoteGroupPort remoteGroupPort)

createPortDescriptor

private RemoteProcessGroupPortDescriptor createPortDescriptor(org.apache.nifi.flow.VersionedRemoteGroupPort proposed,
 ComponentIdGenerator componentIdGenerator,
 String rpgId)

verifyCanSynchronize

private void verifyCanSynchronize(Connection connection,
 org.apache.nifi.flow.VersionedConnection proposedConnection)
                           throws FlowSynchronizationException

Throws:

FlowSynchronizationException

verifyCanDeleteWhenQueueEmpty

private void verifyCanDeleteWhenQueueEmpty(Connection connection)
                                    throws FlowSynchronizationException

Throws:

FlowSynchronizationException

getUpstreamComponents

private Set<Connectable> getUpstreamComponents(Connection connection)

findUpstreamComponents

private void findUpstreamComponents(Connection connection,
 Set<Connectable> components)

getUpstreamComponents

private Set<Connectable> getUpstreamComponents(org.apache.nifi.flow.VersionedConnection connection)

findUpstreamComponents

private void findUpstreamComponents(org.apache.nifi.flow.VersionedConnection connection,
 Set<Connectable> components)

synchronize

public void synchronize(Connection connection,
 org.apache.nifi.flow.VersionedConnection proposedConnection,
 ProcessGroup group,
 FlowSynchronizationOptions synchronizationOptions)
                 throws FlowSynchronizationException,
TimeoutException

Description copied from interface: VersionedComponentSynchronizer

Synchronizes the given Connection to match the proposed one, or deletes the Connection if the proposed is null. If the given connection is null, adds the connection to the given ProcessGroup

Specified by:

synchronize in interface VersionedComponentSynchronizer

Parameters:

connection - the connection to synchronize

proposedConnection - the proposed/desired state for the connection

group - the ProcessGroup to which the connection should belong

synchronizationOptions - options for how to synchronize the flow

Throws:

FlowSynchronizationException - if unable to synchronize the connection with the proposed version

TimeoutException - if the source or destination of the connection must be stopped in order to perform the synchronization and stopping it takes longer than the timeout allowed by the synchronization options.

waitForQueueEmpty

private void waitForQueueEmpty(Connection connection,
 Duration duration)
                        throws TimeoutException,
InterruptedException

Throws:

TimeoutException

InterruptedException

terminateComponents

private void terminateComponents(Set<Connectable> components,
 FlowSynchronizationOptions synchronizationOptions)

updateConnection

private void updateConnection(Connection connection,
 org.apache.nifi.flow.VersionedConnection proposed)

addConnection

private Connection addConnection(ProcessGroup destinationGroup,
 org.apache.nifi.flow.VersionedConnection proposed,
 ComponentIdGenerator componentIdGenerator)

getConnectable

private Connectable getConnectable(ProcessGroup group,
 org.apache.nifi.flow.ConnectableComponent connectableComponent)

getConnectable

private Connectable getConnectable(ProcessGroup group,
 org.apache.nifi.flow.ConnectableComponent connectableComponent,
 Function<org.apache.nifi.flow.ConnectableComponent,String> idFunction)

synchronize

public void synchronize(ReportingTaskNode reportingTask,
 org.apache.nifi.flow.VersionedReportingTask proposed,
 FlowSynchronizationOptions synchronizationOptions)
                 throws FlowSynchronizationException,
TimeoutException,
InterruptedException,
ReportingTaskInstantiationException

Description copied from interface: VersionedComponentSynchronizer

Synchronizes the given Reporting Task to match the proposed one, or deletes the Reporting Task if the proposed is null. If the given Reporting Task is null, creates it

Specified by:

synchronize in interface VersionedComponentSynchronizer

Parameters:

reportingTask - the reporting task to synchronize

proposed - the proposed/desired state

synchronizationOptions - options for how to synchronize the flow

Throws:

FlowSynchronizationException - if unable to synchronize the reporting task with the proposed version

TimeoutException - if the reporting task is being removed and takes longer to stop than the timeout allowed by the synchronization options.

InterruptedException

ReportingTaskInstantiationException

addReportingTask

private ReportingTaskNode addReportingTask(org.apache.nifi.flow.VersionedReportingTask reportingTask)
                                    throws ReportingTaskInstantiationException

Throws:

ReportingTaskInstantiationException

updateReportingTask

private void updateReportingTask(ReportingTaskNode reportingTask,
 org.apache.nifi.flow.VersionedReportingTask proposed)
                          throws ReportingTaskInstantiationException

Throws:

ReportingTaskInstantiationException

synchronize

public void synchronize(FlowAnalysisRuleNode flowAnalysisRule,
 org.apache.nifi.flow.VersionedFlowAnalysisRule proposed,
 FlowSynchronizationOptions synchronizationOptions)
                 throws FlowSynchronizationException,
TimeoutException,
InterruptedException,
FlowAnalysisRuleInstantiationException

Description copied from interface: VersionedComponentSynchronizer

Synchronizes the given Flow Analysis Rule to match the proposed one, or deletes the Flow Analysis Rule if the proposed is null. If the given Flow Analysis Rule is null, creates it.

Specified by:

synchronize in interface VersionedComponentSynchronizer

Parameters:

flowAnalysisRule - the flow analysis rule to synchronize

proposed - the proposed/desired state

synchronizationOptions - options for how to synchronize the flow

Throws:

FlowSynchronizationException - if unable to synchronize the flow analysis rule with the proposed version

TimeoutException - if the flow analysis rule is being removed and takes longer to stop than the timeout allowed by the synchronization options.

InterruptedException

FlowAnalysisRuleInstantiationException

addFlowAnalysisRule

private FlowAnalysisRuleNode addFlowAnalysisRule(org.apache.nifi.flow.VersionedFlowAnalysisRule flowAnalysisRule)
                                          throws FlowAnalysisRuleInstantiationException

Throws:

FlowAnalysisRuleInstantiationException

updateFlowAnalysisRule

private void updateFlowAnalysisRule(FlowAnalysisRuleNode flowAnalysisRule,
 org.apache.nifi.flow.VersionedFlowAnalysisRule proposed)
                             throws FlowAnalysisRuleInstantiationException

Throws:

FlowAnalysisRuleInstantiationException

matchesId

private <T extends VersionedComponent & Connectable>
boolean matchesId(T component,
 String id)

matchesGroupId

private boolean matchesGroupId(ProcessGroup group,
 String groupId)

findAllProcessors

private void findAllProcessors(Set<org.apache.nifi.flow.VersionedProcessor> processors,
 Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups,
 Map<String,org.apache.nifi.flow.VersionedProcessor> map)

findAllControllerServices

private void findAllControllerServices(Set<org.apache.nifi.flow.VersionedControllerService> controllerServices,
 Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups,
 Map<String,org.apache.nifi.flow.VersionedControllerService> map)

findAllConnections

private void findAllConnections(Set<org.apache.nifi.flow.VersionedConnection> connections,
 Set<org.apache.nifi.flow.VersionedProcessGroup> childGroups,
 Map<String,org.apache.nifi.flow.VersionedConnection> map)

verifyCanRemoveMissingComponents

private void verifyCanRemoveMissingComponents(ProcessGroup processGroup,
 org.apache.nifi.flow.VersionedProcessGroup proposedGroup,
 boolean verifyConnectionRemoval)

Match components of the given process group to the proposed versioned process group and verify missing components are in a state that they can be safely removed. Specifically, check for removed child process groups and descendants. Optionally also check for removed connections with data in their queue, either because the connections were removed from a matched process group or their group itself was removed.

Parameters:

processGroup - the current process group to examine

proposedGroup - the proposed versioned process group to match with

verifyConnectionRemoval - whether or not to verify that connections that are not present in the proposed flow can be removed

getVersionedControllerService

private ControllerServiceNode getVersionedControllerService(ProcessGroup group,
 String versionedComponentId)

getPropertyValues

private Map<String,String> getPropertyValues(ComponentNode componentNode)