StandardProcessorNode (nifi-framework-components 1.13.0 API)

java.lang.Object
- org.apache.nifi.controller.AbstractComponentNode
- - org.apache.nifi.controller.ProcessorNode
  - - org.apache.nifi.controller.StandardProcessorNode

All Implemented Interfaces:

Authorizable, ComponentAuthorizable, VersionedComponent, Connectable, Positionable, ComponentNode, Triggerable
```
public class StandardProcessorNode
extends ProcessorNode
implements Connectable
```
ProcessorNode provides thread-safe access to a FlowFileProcessor as it exists within a controlled flow. This node keeps track of the processor, its scheduling information and its relationships to other processors and whatever scheduled futures exist for it. Must be thread safe.

Field Summary

Fields
Modifier and Type	Field and Description
`private Map<Thread,ActiveTask>`	`activeThreads`
`static String`	`BULLETIN_OBSERVER_ID`
`private LogLevel`	`bulletinLevel`
`private AtomicReference<String>`	`comments`
`private AtomicInteger`	`concurrentTaskCount`
`private Map<Relationship,Set<Connection>>`	`connections`
`static String`	`DEFAULT_PENALIZATION_PERIOD`
`static TimeUnit`	`DEFAULT_TIME_UNIT`
`static String`	`DEFAULT_YIELD_PERIOD`
`private ScheduledState`	`desiredState`
`private Map<Connection,Connectable>`	`destinations`
`private ExecutionNode`	`executionNode`
`private boolean`	`hasActiveThreads`
`private int`	`hashCode`
`private AtomicReference<String>`	`identifier`
`private AtomicReference<List<Connection>>`	`incomingConnections`
`private static org.slf4j.Logger`	`LOG`
`private AtomicBoolean`	`lossTolerant`
`private AtomicReference<String>`	`penalizationPeriod`
`private AtomicReference<Position>`	`position`
`private AtomicReference<ProcessGroup>`	`processGroup`
`private AtomicReference<ProcessorDetails>`	`processorRef`
`private ProcessScheduler`	`processScheduler`
`private long`	`runNanos`
`private AtomicLong`	`schedulingNanos`
`private AtomicReference<String>`	`schedulingPeriod`
`private SchedulingStrategy`	`schedulingStrategy`
`private AtomicReference<Map<String,String>>`	`style`
`private AtomicReference<Set<Relationship>>`	`undefinedRelationshipsToTerminate`
`private AtomicReference<String>`	`versionedComponentId`
`private AtomicLong`	`yieldExpiration`
`private long`	`yieldNanos`
`private AtomicReference<String>`	`yieldPeriod`

Fields inherited from class org.apache.nifi.controller.ProcessorNode
scheduledState

Fields inherited from interface org.apache.nifi.controller.Triggerable
MINIMUM_SCHEDULING_NANOS

Constructor Summary

Constructors
Constructor and Description
`StandardProcessorNode(LoggableComponent<Processor> processor, String uuid, ValidationContextFactory validationContextFactory, ProcessScheduler scheduler, ControllerServiceProvider controllerServiceProvider, ComponentVariableRegistry variableRegistry, ReloadComponent reloadComponent, ExtensionManager extensionManager, ValidationTrigger validationTrigger)`
`StandardProcessorNode(LoggableComponent<Processor> processor, String uuid, ValidationContextFactory validationContextFactory, ProcessScheduler scheduler, ControllerServiceProvider controllerServiceProvider, String componentType, String componentCanonicalClass, ComponentVariableRegistry variableRegistry, ReloadComponent reloadComponent, ExtensionManager extensionManager, ValidationTrigger validationTrigger, boolean isExtensionMissing)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`activateThread()`
`void`	`addConnection(Connection connection)`
`protected Collection<ValidationResult>`	`computeValidationErrors(ValidationContext validationContext)`
`private void`	`deactivateThread()`
`void`	`disable()`
`void`	`enable()`
`boolean`	`equals(Object other)` Establishes node equality (based on the processor's identifier)
`int`	`getActiveThreadCount()`
`List<ActiveThreadInfo>`	`getActiveThreads(ThreadDetails threadDetails)`
`Set<Relationship>`	`getAutoTerminatedRelationships()`
`LogLevel`	`getBulletinLevel()`
`BundleCoordinate`	`getBundleCoordinate()`
`String`	`getComments()`
`ConfigurableComponent`	`getComponent()`
`Class<?>`	`getComponentClass()`
`ConnectableType`	`getConnectableType()`
`Set<Connection>`	`getConnections()`
`Set<Connection>`	`getConnections(Relationship relationship)`
`ScheduledState`	`getDesiredState()`
`Set<Connectable>`	`getDestinations()`
`Set<Connectable>`	`getDestinations(Relationship relationship)`
`ExecutionNode`	`getExecutionNode()`
`String`	`getIdentifier()`
`List<Connection>`	`getIncomingConnections()`
`(package private) List<Connection>`	`getIncomingNonLoopConnections()`
`InputRequirement.Requirement`	`getInputRequirement()`
`TerminationAwareLogger`	`getLogger()`
`int`	`getMaxConcurrentTasks()`
`protected ParameterContext`	`getParameterContext()`
`ParameterLookup`	`getParameterLookup()`
`Authorizable`	`getParentAuthorizable()`
`String`	`getPenalizationPeriod()`
`long`	`getPenalizationPeriod(TimeUnit timeUnit)`
`Position`	`getPosition()`
`ProcessGroup`	`getProcessGroup()`
`String`	`getProcessGroupIdentifier()`
`Processor`	`getProcessor()`
`String`	`getProcessorDescription()`
`Relationship`	`getRelationship(String relationshipName)`
`Collection<Relationship>`	`getRelationships()`
`Resource`	`getResource()`
`long`	`getRunDuration(TimeUnit timeUnit)`
`Object`	`getRunnableComponent()`
`String`	`getSchedulingPeriod()`
`long`	`getSchedulingPeriod(TimeUnit timeUnit)`
`SchedulingStrategy`	`getSchedulingStrategy()`
`Map<String,String>`	`getStyle()`
`int`	`getTerminatedThreadCount()`
`Set<Relationship>`	`getUndefinedRelationships()`
`Collection<ValidationResult>`	`getValidationErrors()`
`Optional<String>`	`getVersionedComponentId()`
`long`	`getYieldExpiration()`
`String`	`getYieldPeriod()`
`long`	`getYieldPeriod(TimeUnit timeUnit)`
`int`	`hashCode()`
`boolean`	`hasIncomingConnection()`
`private void`	`initiateStart(ScheduledExecutorService taskScheduler, long administrativeYieldMillis, long timeoutMilis, Supplier<ProcessContext> processContextFactory, SchedulingAgentCallback schedulingAgentCallback)`
`boolean`	`isAutoTerminated(Relationship relationship)`
`boolean`	`isDeprecated()`
`boolean`	`isEventDrivenSupported()`
`boolean`	`isExecutionNodeRestricted()` Indicates whether the processor's executionNode configuration is restricted to run only in primary node
`boolean`	`isIsolated()`
`boolean`	`isLossTolerant()`
`(package private) boolean`	`isRelated(ProcessorNode node)` Determines if the given node is a destination for this node
`boolean`	`isRestricted()`
`boolean`	`isRunning()`
`boolean`	`isSessionBatchingSupported()`
`boolean`	`isSideEffectFree()`
`boolean`	`isTerminated(Thread thread)`
`boolean`	`isTriggeredSerially()`
`boolean`	`isTriggerWhenAnyDestinationAvailable()`
`boolean`	`isTriggerWhenEmpty()`
`boolean`	`isValidationNecessary()`
`private void`	`monitorAsyncTask(Future<?> taskFuture, Future<?> monitoringFuture, long completionTimestamp)`
`void`	`onTrigger(ProcessContext context, ProcessSessionFactory sessionFactory)`
`void`	`reload(Set<URL> additionalUrls)`
`void`	`removeConnection(Connection connection)`
`void`	`setAnnotationData(String data)`
`void`	`setAutoTerminatedRelationships(Set<Relationship> terminate)`
`void`	`setBulletinLevel(LogLevel level)`
`void`	`setComments(String comments)` Provides and opportunity to retain information about this particular processor instance
`void`	`setExecutionNode(ExecutionNode executionNode)`
`private void`	`setIncomingConnections(List<Connection> incoming)`
`void`	`setLossTolerant(boolean lossTolerant)` Indicates whether flow file content made by this processor must be persisted
`void`	`setMaxConcurrentTasks(int taskCount)` Determines the number of concurrent tasks that may be running for this processor.
`void`	`setName(String name)`
`void`	`setPenalizationPeriod(String penalizationPeriod)`
`void`	`setPosition(Position position)`
`void`	`setProcessGroup(ProcessGroup group)`
`void`	`setProcessor(LoggableComponent<Processor> processor)`
`void`	`setRunDuration(long duration, TimeUnit timeUnit)`
`void`	`setScheduldingPeriod(String schedulingPeriod)`
`void`	`setSchedulingStrategy(SchedulingStrategy schedulingStrategy)` Updates the Scheduling Strategy used for this Processor
`void`	`setStyle(Map<String,String> style)`
`void`	`setVersionedComponentId(String versionedComponentId)`
`void`	`setYieldPeriod(String yieldPeriod)`
`void`	`start(ScheduledExecutorService taskScheduler, long administrativeYieldMillis, long timeoutMillis, Supplier<ProcessContext> processContextFactory, SchedulingAgentCallback schedulingAgentCallback, boolean failIfStopping)` Will idempotently start the processor using the following sequence: Validate Processor's state (e.g., PropertyDescriptors, ControllerServices etc.) Transition (atomically) Processor's scheduled state form STOPPED to STARTING.
`CompletableFuture<Void>`	`stop(ProcessScheduler processScheduler, ScheduledExecutorService executor, ProcessContext processContext, SchedulingAgent schedulingAgent, LifecycleState scheduleState)` Will idempotently stop the processor using the following sequence: Transition (atomically) Processor's scheduled state from RUNNING to STOPPING.
`int`	`terminate()`
`String`	`toString()`
`void`	`updateConnection(Connection connection)`
`void`	`verifyCanClearState()`
`void`	`verifyCanDelete()`
`void`	`verifyCanDelete(boolean ignoreConnections)`
`void`	`verifyCanDisable()`
`void`	`verifyCanEnable()`
`void`	`verifyCanStart()`
`void`	`verifyCanStart(Set<ControllerServiceNode> ignoredReferences)`
`void`	`verifyCanStop()`
`void`	`verifyCanTerminate()`
`void`	`verifyCanUpdate()`
`void`	`verifyModifiable()`
`private void`	`verifyNoActiveThreads()`
`void`	`yield()` Causes the processor not to be scheduled for some period of time.
`void`	`yield(long period, TimeUnit timeUnit)`

Methods inherited from class org.apache.nifi.controller.ProcessorNode
getPhysicalScheduledState, getScheduledState

Methods inherited from class org.apache.nifi.controller.AbstractComponentNode
getAdditionalClasspathResources, getAnnotationData, getCanonicalClassName, getComponentType, getControllerServiceProvider, getEffectivePropertyValue, getEffectivePropertyValues, getExtensionManager, getName, getProperties, getProperty, getPropertyDescriptor, getPropertyDescriptors, getRawPropertyValue, getRawPropertyValues, getReferencedParameterNames, getReloadComponent, getValidationContext, getValidationContextFactory, getValidationErrors, getValidationState, getValidationStatus, getValidationStatus, getVariableRegistry, isExtensionMissing, isReferencingParameter, onParametersModified, onPropertyModified, pauseValidationTrigger, performValidation, performValidation, performValidation, refreshProperties, reloadAdditionalResourcesIfNecessary, resetValidationState, resumeValidationTrigger, setAdditionalResourcesFingerprint, setExtensionMissing, setProperties, validateReferencedControllerServices, verifyCanUpdateBundle, verifyCanUpdateProperties

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.nifi.connectable.Connectable
getComponentType, getName

Methods inherited from interface org.apache.nifi.controller.Triggerable
getScheduledState

Methods inherited from interface org.apache.nifi.authorization.resource.Authorizable
authorize, authorize, checkAuthorization, checkAuthorization, getRequestedResource, isAuthorized

Methods inherited from interface org.apache.nifi.controller.ComponentNode
authorize, checkAuthorization, setProperties

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - BULLETIN_OBSERVER_ID
```
public static final String BULLETIN_OBSERVER_ID
```
    See Also:
    
    Constant Field Values
  - DEFAULT_TIME_UNIT
```
public static final TimeUnit DEFAULT_TIME_UNIT
```
  - DEFAULT_YIELD_PERIOD
```
public static final String DEFAULT_YIELD_PERIOD
```
    See Also:
    
    Constant Field Values
  - DEFAULT_PENALIZATION_PERIOD
```
public static final String DEFAULT_PENALIZATION_PERIOD
```
    See Also:
    
    Constant Field Values
  - processGroup
```
private final AtomicReference<ProcessGroup> processGroup
```
  - processorRef
```
private final AtomicReference<ProcessorDetails> processorRef
```
  - identifier
```
private final AtomicReference<String> identifier
```
  - destinations
```
private final Map<Connection,Connectable> destinations
```
  - connections
```
private final Map<Relationship,Set<Connection>> connections
```
  - undefinedRelationshipsToTerminate
```
private final AtomicReference<Set<Relationship>> undefinedRelationshipsToTerminate
```
  - incomingConnections
```
private final AtomicReference<List<Connection>> incomingConnections
```
  - lossTolerant
```
private final AtomicBoolean lossTolerant
```
  - comments
```
private final AtomicReference<String> comments
```
  - position
```
private final AtomicReference<Position> position
```
  - schedulingPeriod
```
private final AtomicReference<String> schedulingPeriod
```
  - yieldPeriod
```
private final AtomicReference<String> yieldPeriod
```
  - penalizationPeriod
```
private final AtomicReference<String> penalizationPeriod
```
  - style
```
private final AtomicReference<Map<String,String>> style
```
  - concurrentTaskCount
```
private final AtomicInteger concurrentTaskCount
```
  - yieldExpiration
```
private final AtomicLong yieldExpiration
```
  - schedulingNanos
```
private final AtomicLong schedulingNanos
```
  - versionedComponentId
```
private final AtomicReference<String> versionedComponentId
```
  - processScheduler
```
private final ProcessScheduler processScheduler
```
  - runNanos
```
private long runNanos
```
  - yieldNanos
```
private volatile long yieldNanos
```
  - desiredState
```
private volatile ScheduledState desiredState
```
  - bulletinLevel
```
private volatile LogLevel bulletinLevel
```
  - schedulingStrategy
```
private SchedulingStrategy schedulingStrategy
```
  - executionNode
```
private ExecutionNode executionNode
```
  - activeThreads
```
private final Map<Thread,ActiveTask> activeThreads
```
  - hashCode
```
private final int hashCode
```
  - hasActiveThreads
```
private volatile boolean hasActiveThreads
```
- Constructor Detail
  - StandardProcessorNode
```
public StandardProcessorNode(LoggableComponent<Processor> processor,
                             String uuid,
                             ValidationContextFactory validationContextFactory,
                             ProcessScheduler scheduler,
                             ControllerServiceProvider controllerServiceProvider,
                             ComponentVariableRegistry variableRegistry,
                             ReloadComponent reloadComponent,
                             ExtensionManager extensionManager,
                             ValidationTrigger validationTrigger)
```
  - StandardProcessorNode
```
public StandardProcessorNode(LoggableComponent<Processor> processor,
                             String uuid,
                             ValidationContextFactory validationContextFactory,
                             ProcessScheduler scheduler,
                             ControllerServiceProvider controllerServiceProvider,
                             String componentType,
                             String componentCanonicalClass,
                             ComponentVariableRegistry variableRegistry,
                             ReloadComponent reloadComponent,
                             ExtensionManager extensionManager,
                             ValidationTrigger validationTrigger,
                             boolean isExtensionMissing)
```
- Method Detail
  - getComponent
```
public ConfigurableComponent getComponent()
```
    Specified by:
    
    getComponent in interface ComponentNode
  - getLogger
```
public TerminationAwareLogger getLogger()
```
    Specified by:
    
    getLogger in interface ComponentNode
  - getRunnableComponent
```
public Object getRunnableComponent()
```
    Specified by:
    
    getRunnableComponent in interface Connectable
  - getBundleCoordinate
```
public BundleCoordinate getBundleCoordinate()
```
    Specified by:
    
    getBundleCoordinate in interface ComponentNode
  - getComments
```
public String getComments()
```
    Specified by:
    
    getComments in interface Connectable
    
    Returns:
    
    comments about this specific processor instance
  - getParentAuthorizable
```
public Authorizable getParentAuthorizable()
```
    Specified by:
    
    getParentAuthorizable in interface Authorizable
  - getResource
```
public Resource getResource()
```
    Specified by:
    
    getResource in interface Authorizable
  - isRestricted
```
public boolean isRestricted()
```
    Specified by:
    
    isRestricted in interface ComponentNode
  - getComponentClass
```
public Class<?> getComponentClass()
```
    Specified by:
    
    getComponentClass in interface ComponentNode
  - isDeprecated
```
public boolean isDeprecated()
```
    Specified by:
    
    isDeprecated in interface ComponentNode
  - setComments
```
public void setComments(String comments)
```
    Provides and opportunity to retain information about this particular processor instance
    
    Specified by:
    
    setComments in interface Connectable
    
    Parameters:
    
    comments - new comments
  - getPosition
```
public Position getPosition()
```
    Specified by:
    
    getPosition in interface Positionable
  - setPosition
```
public void setPosition(Position position)
```
    Specified by:
    
    setPosition in interface Positionable
  - getStyle
```
public Map<String,String> getStyle()
```
    Specified by:
    
    getStyle in class ProcessorNode
  - setStyle
```
public void setStyle(Map<String,String> style)
```
    Specified by:
    
    setStyle in class ProcessorNode
  - getIdentifier
```
public String getIdentifier()
```
    Specified by:
    
    getIdentifier in interface ComponentAuthorizable
    
    Specified by:
    
    getIdentifier in interface Connectable
    
    Specified by:
    
    getIdentifier in interface ComponentNode
    
    Overrides:
    
    getIdentifier in class AbstractComponentNode
  - isLossTolerant
```
public boolean isLossTolerant()
```
    Specified by:
    
    isLossTolerant in interface Connectable
    
    Returns:
    
    if true flow file content generated by this processor is considered loss tolerant
  - isIsolated
```
public boolean isIsolated()
```
    Specified by:
    
    isIsolated in interface Connectable
    
    Specified by:
    
    isIsolated in class ProcessorNode
  - isTriggerWhenEmpty
```
public boolean isTriggerWhenEmpty()
```
    Specified by:
    
    isTriggerWhenEmpty in interface Connectable
    
    Returns:
    
    true if the processor has the TriggerWhenEmpty annotation, false otherwise.
  - isSideEffectFree
```
public boolean isSideEffectFree()
```
    Specified by:
    
    isSideEffectFree in interface Connectable
    
    Specified by:
    
    isSideEffectFree in class ProcessorNode
    
    Returns:
    
    true if the processor has the SideEffectFree annotation, false otherwise.
  - isSessionBatchingSupported
```
public boolean isSessionBatchingSupported()
```
    Specified by:
    
    isSessionBatchingSupported in interface Connectable
  - isTriggerWhenAnyDestinationAvailable
```
public boolean isTriggerWhenAnyDestinationAvailable()
```
    Specified by:
    
    isTriggerWhenAnyDestinationAvailable in interface Connectable
    
    Specified by:
    
    isTriggerWhenAnyDestinationAvailable in class ProcessorNode
    
    Returns:
    
    true if the processor has the TriggerWhenAnyDestinationAvailable annotation, false otherwise.
  - isExecutionNodeRestricted
```
public boolean isExecutionNodeRestricted()
```
    Indicates whether the processor's executionNode configuration is restricted to run only in primary node
    
    Specified by:
    
    isExecutionNodeRestricted in class ProcessorNode
  - setLossTolerant
```
public void setLossTolerant(boolean lossTolerant)
```
    Indicates whether flow file content made by this processor must be persisted
    
    Specified by:
    
    setLossTolerant in interface Connectable
    
    Parameters:
    
    lossTolerant - tolerant
  - isAutoTerminated
```
public boolean isAutoTerminated(Relationship relationship)
```
    Specified by:
    
    isAutoTerminated in interface Connectable
  - setAutoTerminatedRelationships
```
public void setAutoTerminatedRelationships(Set<Relationship> terminate)
```
    Specified by:
    
    setAutoTerminatedRelationships in class ProcessorNode
  - getAutoTerminatedRelationships
```
public Set<Relationship> getAutoTerminatedRelationships()
```
    Specified by:
    
    getAutoTerminatedRelationships in class ProcessorNode
    
    Returns:
    
    an unmodifiable Set that contains all of the ProcessorRelationship objects that are configured to be auto-terminated
  - getProcessorDescription
```
public String getProcessorDescription()
```
    Returns:
    
    the value of the processor's CapabilityDescription annotation, if one exists, else null.
  - setName
```
public void setName(String name)
```
    Specified by:
    
    setName in interface Connectable
    
    Specified by:
    
    setName in interface ComponentNode
    
    Overrides:
    
    setName in class AbstractComponentNode
  - getSchedulingPeriod
```
public long getSchedulingPeriod(TimeUnit timeUnit)
```
    Specified by:
    
    getSchedulingPeriod in interface Triggerable
    
    Parameters:
    
    timeUnit - determines the unit of time to represent the scheduling period.
    
    Returns:
    
    the schedule period that should elapse before subsequent cycles of this processor's tasks
  - isEventDrivenSupported
```
public boolean isEventDrivenSupported()
```
    Specified by:
    
    isEventDrivenSupported in class ProcessorNode
  - setSchedulingStrategy
```
public void setSchedulingStrategy(SchedulingStrategy schedulingStrategy)
```
    Updates the Scheduling Strategy used for this Processor
    
    Specified by:
    
    setSchedulingStrategy in class ProcessorNode
    
    Parameters:
    
    schedulingStrategy - strategy
    
    Throws:
    
    IllegalArgumentException - if the SchedulingStrategy is not not applicable for this Processor
  - getSchedulingStrategy
```
public SchedulingStrategy getSchedulingStrategy()
```
    Specified by:
    
    getSchedulingStrategy in interface Connectable
    
    Specified by:
    
    getSchedulingStrategy in class ProcessorNode
    
    Returns:
    
    the currently configured scheduling strategy
  - getSchedulingPeriod
```
public String getSchedulingPeriod()
```
    Specified by:
    
    getSchedulingPeriod in interface Triggerable
  - setScheduldingPeriod
```
public void setScheduldingPeriod(String schedulingPeriod)
```
    Specified by:
    
    setScheduldingPeriod in interface Triggerable
  - setExecutionNode
```
public void setExecutionNode(ExecutionNode executionNode)
```
    Specified by:
    
    setExecutionNode in class ProcessorNode
  - getExecutionNode
```
public ExecutionNode getExecutionNode()
```
    Specified by:
    
    getExecutionNode in class ProcessorNode
  - getRunDuration
```
public long getRunDuration(TimeUnit timeUnit)
```
    Specified by:
    
    getRunDuration in interface Connectable
    
    Specified by:
    
    getRunDuration in class ProcessorNode
  - setRunDuration
```
public void setRunDuration(long duration,
                           TimeUnit timeUnit)
```
    Specified by:
    
    setRunDuration in class ProcessorNode
  - getYieldPeriod
```
public long getYieldPeriod(TimeUnit timeUnit)
```
    Specified by:
    
    getYieldPeriod in interface Connectable
  - getYieldPeriod
```
public String getYieldPeriod()
```
    Specified by:
    
    getYieldPeriod in interface Connectable
  - setYieldPeriod
```
public void setYieldPeriod(String yieldPeriod)
```
    Specified by:
    
    setYieldPeriod in interface Connectable
  - yield
```
public void yield()
```
    Causes the processor not to be scheduled for some period of time. This duration can be obtained and set via the getYieldPeriod(TimeUnit) and setYieldPeriod(String).
    
    Specified by:
    
    yield in interface Connectable
  - yield
```
public void yield(long period,
                  TimeUnit timeUnit)
```
    Specified by:
    
    yield in interface Connectable
    
    Specified by:
    
    yield in class ProcessorNode
  - getYieldExpiration
```
public long getYieldExpiration()
```
    Specified by:
    
    getYieldExpiration in interface Connectable
    
    Returns:
    
    the number of milliseconds since Epoch at which time this processor is to once again be scheduled.
  - getPenalizationPeriod
```
public long getPenalizationPeriod(TimeUnit timeUnit)
```
    Specified by:
    
    getPenalizationPeriod in interface Connectable
  - getPenalizationPeriod
```
public String getPenalizationPeriod()
```
    Specified by:
    
    getPenalizationPeriod in interface Connectable
  - setPenalizationPeriod
```
public void setPenalizationPeriod(String penalizationPeriod)
```
    Specified by:
    
    setPenalizationPeriod in interface Connectable
  - setMaxConcurrentTasks
```
public void setMaxConcurrentTasks(int taskCount)
```
    Determines the number of concurrent tasks that may be running for this processor.
    
    Specified by:
    
    setMaxConcurrentTasks in interface Triggerable
    
    Parameters:
    
    taskCount - a number of concurrent tasks this processor may have running
    
    Throws:
    
    IllegalArgumentException - if the given value is less than 1
  - isTriggeredSerially
```
public boolean isTriggeredSerially()
```
    Specified by:
    
    isTriggeredSerially in class ProcessorNode
  - getMaxConcurrentTasks
```
public int getMaxConcurrentTasks()
```
    Specified by:
    
    getMaxConcurrentTasks in interface Triggerable
    
    Returns:
    
    the number of tasks that may execute concurrently for this processor
  - getBulletinLevel
```
public LogLevel getBulletinLevel()
```
    Specified by:
    
    getBulletinLevel in class ProcessorNode
  - setBulletinLevel
```
public void setBulletinLevel(LogLevel level)
```
    Specified by:
    
    setBulletinLevel in class ProcessorNode
  - getConnections
```
public Set<Connection> getConnections()
```
    Specified by:
    
    getConnections in interface Connectable
  - getIncomingConnections
```
public List<Connection> getIncomingConnections()
```
    Specified by:
    
    getIncomingConnections in interface Connectable
  - getConnections
```
public Set<Connection> getConnections(Relationship relationship)
```
    Specified by:
    
    getConnections in interface Connectable
  - addConnection
```
public void addConnection(Connection connection)
```
    Specified by:
    
    addConnection in interface Connectable
  - hasIncomingConnection
```
public boolean hasIncomingConnection()
```
    Specified by:
    
    hasIncomingConnection in interface Connectable
  - updateConnection
```
public void updateConnection(Connection connection)
                      throws IllegalStateException
```
    Specified by:
    
    updateConnection in interface Connectable
    
    Throws:
    
    IllegalStateException
  - removeConnection
```
public void removeConnection(Connection connection)
```
    Specified by:
    
    removeConnection in interface Connectable
  - setIncomingConnections
```
private void setIncomingConnections(List<Connection> incoming)
```
  - getRelationship
```
public Relationship getRelationship(String relationshipName)
```
    Specified by:
    
    getRelationship in interface Connectable
    
    Parameters:
    
    relationshipName - name
    
    Returns:
    
    the relationship for this nodes processor for the given name or creates a new relationship for the given name
  - getProcessor
```
public Processor getProcessor()
```
    Specified by:
    
    getProcessor in class ProcessorNode
  - setProcessor
```
public void setProcessor(LoggableComponent<Processor> processor)
```
    Specified by:
    
    setProcessor in class ProcessorNode
  - reload
```
public void reload(Set<URL> additionalUrls)
            throws ProcessorInstantiationException
```
    Specified by:
    
    reload in interface ComponentNode
    
    Throws:
    
    ProcessorInstantiationException
  - getDestinations
```
public Set<Connectable> getDestinations()
```
    Returns:
    
    the Set of destination processors for all relationships excluding any destinations that are this processor itself (self-loops)
  - getDestinations
```
public Set<Connectable> getDestinations(Relationship relationship)
```
  - getUndefinedRelationships
```
public Set<Relationship> getUndefinedRelationships()
```
  - isRelated
```
boolean isRelated(ProcessorNode node)
```
    Determines if the given node is a destination for this node
    
    Parameters:
    
    node - node
    
    Returns:
    
    true if is a direct destination node; false otherwise
  - isRunning
```
public boolean isRunning()
```
    Specified by:
    
    isRunning in interface Triggerable
  - isValidationNecessary
```
public boolean isValidationNecessary()
```
    Specified by:
    
    isValidationNecessary in interface ComponentNode
  - getActiveThreadCount
```
public int getActiveThreadCount()
```
    Specified by:
    
    getActiveThreadCount in class ProcessorNode
  - getIncomingNonLoopConnections
```
List<Connection> getIncomingNonLoopConnections()
```
  - getValidationErrors
```
public Collection<ValidationResult> getValidationErrors()
```
    Specified by:
    
    getValidationErrors in interface Connectable
    
    Specified by:
    
    getValidationErrors in interface ComponentNode
    
    Overrides:
    
    getValidationErrors in class AbstractComponentNode
  - computeValidationErrors
```
protected Collection<ValidationResult> computeValidationErrors(ValidationContext validationContext)
```
    Overrides:
    
    computeValidationErrors in class AbstractComponentNode
  - getInputRequirement
```
public InputRequirement.Requirement getInputRequirement()
```
    Specified by:
    
    getInputRequirement in class ProcessorNode
  - equals
```
public boolean equals(Object other)
```
    Establishes node equality (based on the processor's identifier)
    
    Overrides:
    
    equals in class AbstractComponentNode
    
    Parameters:
    
    other - node
    
    Returns:
    
    true if equal
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class AbstractComponentNode
  - getRelationships
```
public Collection<Relationship> getRelationships()
```
    Specified by:
    
    getRelationships in interface Connectable
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class AbstractComponentNode
  - getProcessGroup
```
public ProcessGroup getProcessGroup()
```
    Specified by:
    
    getProcessGroup in interface Connectable
  - getParameterContext
```
protected ParameterContext getParameterContext()
```
    Specified by:
    
    getParameterContext in class AbstractComponentNode
  - getParameterLookup
```
public ParameterLookup getParameterLookup()
```
    Specified by:
    
    getParameterLookup in interface ComponentNode
  - setProcessGroup
```
public void setProcessGroup(ProcessGroup group)
```
    Specified by:
    
    setProcessGroup in interface Connectable
  - onTrigger
```
public void onTrigger(ProcessContext context,
                      ProcessSessionFactory sessionFactory)
```
    Specified by:
    
    onTrigger in interface Triggerable
  - getConnectableType
```
public ConnectableType getConnectableType()
```
    Specified by:
    
    getConnectableType in interface Connectable
  - setAnnotationData
```
public void setAnnotationData(String data)
```
    Specified by:
    
    setAnnotationData in interface ComponentNode
    
    Overrides:
    
    setAnnotationData in class AbstractComponentNode
  - verifyCanDelete
```
public void verifyCanDelete()
                     throws IllegalStateException
```
    Specified by:
    
    verifyCanDelete in interface Connectable
    
    Throws:
    
    IllegalStateException
  - verifyCanDelete
```
public void verifyCanDelete(boolean ignoreConnections)
```
    Specified by:
    
    verifyCanDelete in interface Connectable
  - verifyCanStart
```
public void verifyCanStart()
```
    Specified by:
    
    verifyCanStart in interface Connectable
  - verifyCanStart
```
public void verifyCanStart(Set<ControllerServiceNode> ignoredReferences)
```
    Specified by:
    
    verifyCanStart in class ProcessorNode
  - verifyCanStop
```
public void verifyCanStop()
```
    Specified by:
    
    verifyCanStop in interface Connectable
  - verifyCanUpdate
```
public void verifyCanUpdate()
```
    Specified by:
    
    verifyCanUpdate in interface Connectable
  - verifyCanEnable
```
public void verifyCanEnable()
```
    Specified by:
    
    verifyCanEnable in interface Connectable
  - verifyCanDisable
```
public void verifyCanDisable()
```
    Specified by:
    
    verifyCanDisable in interface Connectable
  - verifyCanClearState
```
public void verifyCanClearState()
                         throws IllegalStateException
```
    Specified by:
    
    verifyCanClearState in interface Connectable
    
    Throws:
    
    IllegalStateException
  - verifyNoActiveThreads
```
private void verifyNoActiveThreads()
                            throws IllegalStateException
```
    Throws:
    
    IllegalStateException
  - verifyModifiable
```
public void verifyModifiable()
                      throws IllegalStateException
```
    Specified by:
    
    verifyModifiable in class AbstractComponentNode
    
    Throws:
    
    IllegalStateException
  - enable
```
public void enable()
```
    Specified by:
    
    enable in class ProcessorNode
  - disable
```
public void disable()
```
    Specified by:
    
    disable in class ProcessorNode
  - start
```
public void start(ScheduledExecutorService taskScheduler,
                  long administrativeYieldMillis,
                  long timeoutMillis,
                  Supplier<ProcessContext> processContextFactory,
                  SchedulingAgentCallback schedulingAgentCallback,
                  boolean failIfStopping)
```
    Will idempotently start the processor using the following sequence:
    
    Validate Processor's state (e.g., PropertyDescriptors, ControllerServices etc.)
    
    Transition (atomically) Processor's scheduled state form STOPPED to STARTING. If the above state transition succeeds, then execute the start task (asynchronously) which will be re-tried until @OnScheduled is executed successfully and "schedulingAgentCallback' is invoked, or until STOP operation is initiated on this processor. If state transition fails it means processor is already being started and WARN message will be logged explaining it.
    
    Any exception thrown while invoking operations annotated with @OnSchedule will be caught and logged after which @OnUnscheduled operation will be invoked (quietly) and the start sequence will be repeated (re-try) after delay provided by 'administrativeYieldMillis'.
    
    Upon successful completion of start sequence (@OnScheduled -> 'schedulingAgentCallback') the attempt will be made to transition processor's scheduling state to RUNNING at which point processor is considered to be fully started and functioning. If upon successful invocation of @OnScheduled operation the processor can not be transitioned to RUNNING state (e.g., STOP operation was invoked on the processor while it's @OnScheduled operation was executing), the processor's @OnUnscheduled operation will be invoked and its scheduling state will be set to STOPPED at which point the processor is considered to be fully stopped.
    Specified by:
    
    start in class ProcessorNode
  - activateThread
```
private void activateThread()
```
  - deactivateThread
```
private void deactivateThread()
```
  - getActiveThreads
```
public List<ActiveThreadInfo> getActiveThreads(ThreadDetails threadDetails)
```
    Specified by:
    
    getActiveThreads in class ProcessorNode
  - getTerminatedThreadCount
```
public int getTerminatedThreadCount()
```
    Specified by:
    
    getTerminatedThreadCount in class ProcessorNode
  - terminate
```
public int terminate()
```
    Specified by:
    
    terminate in class ProcessorNode
  - isTerminated
```
public boolean isTerminated(Thread thread)
```
    Specified by:
    
    isTerminated in class ProcessorNode
  - verifyCanTerminate
```
public void verifyCanTerminate()
```
    Specified by:
    
    verifyCanTerminate in class ProcessorNode
  - initiateStart
```
private void initiateStart(ScheduledExecutorService taskScheduler,
                           long administrativeYieldMillis,
                           long timeoutMilis,
                           Supplier<ProcessContext> processContextFactory,
                           SchedulingAgentCallback schedulingAgentCallback)
```
  - stop
```
public CompletableFuture<Void> stop(ProcessScheduler processScheduler,
                                    ScheduledExecutorService executor,
                                    ProcessContext processContext,
                                    SchedulingAgent schedulingAgent,
                                    LifecycleState scheduleState)
```
    Will idempotently stop the processor using the following sequence:
    
    Transition (atomically) Processor's scheduled state from RUNNING to STOPPING. If the above state transition succeeds, then invoke any method on the Processor with the OnUnscheduled annotation. Once those methods have been called and returned (either normally or exceptionally), start checking to see if all of the Processor's active threads have finished. If not, check again every 100 milliseconds until they have. Once all after threads have completed, the processor's @OnStopped operation will be invoked and its scheduled state is set to STOPPED which completes processor stop sequence.
    
    If for some reason processor's scheduled state can not be transitioned to STOPPING (e.g., the processor didn't finish @OnScheduled operation when stop was called), the attempt will be made to transition processor's scheduled state from STARTING to STOPPING which will allow start(ScheduledExecutorService, long, long, Supplier, SchedulingAgentCallback, boolean) method to initiate processor's shutdown upon exiting @OnScheduled operation, otherwise the processor's scheduled state will remain unchanged ensuring that multiple calls to this method are idempotent.
    Specified by:
    
    stop in class ProcessorNode
  - getDesiredState
```
public ScheduledState getDesiredState()
```
    Specified by:
    
    getDesiredState in class ProcessorNode
  - monitorAsyncTask
```
private void monitorAsyncTask(Future<?> taskFuture,
                              Future<?> monitoringFuture,
                              long completionTimestamp)
```
  - getProcessGroupIdentifier
```
public String getProcessGroupIdentifier()
```
    Specified by:
    
    getProcessGroupIdentifier in interface ComponentAuthorizable
  - getVersionedComponentId
```
public Optional<String> getVersionedComponentId()
```
    Specified by:
    
    getVersionedComponentId in interface VersionedComponent
  - setVersionedComponentId
```
public void setVersionedComponentId(String versionedComponentId)
```
    Specified by:
    
    setVersionedComponentId in interface VersionedComponent

Class StandardProcessorNode

Field Summary

Fields inherited from class org.apache.nifi.controller.ProcessorNode

Fields inherited from interface org.apache.nifi.controller.Triggerable

Constructor Summary

Method Summary

Methods inherited from class org.apache.nifi.controller.ProcessorNode

Methods inherited from class org.apache.nifi.controller.AbstractComponentNode

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.nifi.connectable.Connectable

Methods inherited from interface org.apache.nifi.controller.Triggerable

Methods inherited from interface org.apache.nifi.authorization.resource.Authorizable

Methods inherited from interface org.apache.nifi.controller.ComponentNode

Field Detail

LOG

BULLETIN_OBSERVER_ID

DEFAULT_TIME_UNIT

DEFAULT_YIELD_PERIOD

DEFAULT_PENALIZATION_PERIOD

processGroup

processorRef

identifier

destinations

connections

undefinedRelationshipsToTerminate

incomingConnections

lossTolerant

comments

position

schedulingPeriod

yieldPeriod

penalizationPeriod

style

concurrentTaskCount

yieldExpiration

schedulingNanos

versionedComponentId

processScheduler

runNanos

yieldNanos

desiredState

bulletinLevel

schedulingStrategy

executionNode

activeThreads

hashCode

hasActiveThreads

Constructor Detail

StandardProcessorNode

StandardProcessorNode

Method Detail

getComponent

getLogger

getRunnableComponent

getBundleCoordinate

getComments

getParentAuthorizable

getResource

isRestricted

getComponentClass

isDeprecated

setComments

getPosition

setPosition

getStyle

setStyle

getIdentifier

isLossTolerant

isIsolated

isTriggerWhenEmpty

isSideEffectFree

isSessionBatchingSupported

isTriggerWhenAnyDestinationAvailable

isExecutionNodeRestricted

setLossTolerant

isAutoTerminated

setAutoTerminatedRelationships

getAutoTerminatedRelationships

getProcessorDescription

setName