All Classes and Interfaces
Class
Description
A base class for common code shared by processors that fetch RDBMS data.
Provides common functionality used for processors interacting and manipulating JSON data via JsonPath.
Base class for Syslog processors.
X.509 Client Certificate FlowFile Attribute Names
Provider abstraction for reading X.509 Client Certificates from an HTTP Servlet Request and returning FlowFile attributes
Client Authentication Exception for authentication failures during Client configuration
Client Configuration Exception for specific failures during Client configuration
Client Connect Exception for connection failures during Client configuration
HTTP Content-Encoding configuration strategy
This processor reads files in as text according to the specified character set and it outputs another text file according to the given character set.
Interface for RDBMS/JDBC-specific code.
Implementations must be thread-safe.
Document Provider implementation that allows local Document Type Declarations
Output stream that is used to wrap another output stream in a way that the underlying output stream can be swapped out for a different one when needed
This processor executes an external command on the contents of a flow file, and creates a new flow file with the results of the command.
Offers serialization and deserialization for flow file attribute maps.
FTP Client Provider for abstracting initial connection configuration of FTP Client instances
The standard interface for FTP server implementations.
A generic database adapter that generates ANSI SQL.
Certificate Attributes Provider for HandleHttpRequest reads the first X.509 Certificate presented
Enumeration capturing information about the cryptographic hash algorithms
This class provides a generic service for cryptographic hashing.
HTTP Header reusable enumerated values
HTTP Method reusable enumerated values
HTTP protocol configuration strategy
Attempts to detect the MIME Type of a FlowFile by examining its contents.
A processor to retrieve a list of tables (and their metadata) from a database connection
Holder class to pass around a flow file and the writer that is writing records to it.
PerformanceTracker is responsible for providing a mechanism by which any disk operation can be timed and the timing information
can both be used to issue warnings as well as be aggregated for some amount of time, in order to understand how long certain disk operations
take and which files may be responsible for causing longer-than-usual operations to be performed.
Tracks metrics using a rolling window of time, in which older metrics are 'aged off' by calling
ListFile.RollingMetricPerformanceTracker.purgeTimingInfo(long).Provides a mechanism for timing how long a particular operation takes to complete, logging if it takes longer than the configured threshold.
A PerformanceTracker that is capable of tracking which disk access operation is active and which directory is actively being listed,
as well as timing specific operations, but does not track metrics over any amount of time.
A database adapter that generates MS SQL Compatible SQL for version 2008.
A database adapter that generates MS SQL Compatible SQL.
A generic database adapter that generates MySQL compatible SQL.
A DatabaseAdapter that generates Oracle-compliant SQL.
We have this ValueWrapper class here because we want to use it as part of the key to a Map and we
want two values that may or may not be arrays.
A Apache Phoenix database adapter that generates ANSI SQL.
Proxy Socket Factory implementation creates Sockets using the configured Proxy
A holder class for a SQL prepared statement and a BitSet indicating which columns are being updated (to determine which values from the record to set on the statement)
A value of null for getIncludedColumns indicates that all columns/fields should be included.
Simple string serializer, used for serializing the cache key
A simple, immutable data structure to hold a List of FlowFiles and an indicator as to whether
or not those FlowFiles represent a "fragmented transaction" - that is, a collection of FlowFiles
that all must be executed as a single transaction (we refer to it as a fragment transaction
because the information for that transaction, including SQL and the parameters, is fragmented
across multiple FlowFiles).
A simple, immutable data structure to hold a Prepared Statement and a List of FlowFiles
for which that statement should be evaluated.
A FlowFileFilter that is responsible for ensuring that the FlowFiles returned either belong
to the same "fragmented transaction" (i.e., 1 transaction whose information is fragmented
across multiple FlowFiles) or that none of the FlowFiles belongs to a fragmented transaction
This processor routes a FlowFile based on its flow file attributes by using the Attribute Expression Language.
Implementation of SSHJ's LocalSourceFile so we can call 'put' using a FlowFile's InputStream.
Socket Factory Provider abstracts implementation selection based on Proxy Configuration
The SqlWriter interface provides a standard way for processors such as ExecuteSQL, ExecuteSQLRecord, QueryDatabaseTable, and QueryDatabaseTableRecord
to write SQL result sets out to a flow file in whichever manner is appropriate.
SSH Client Provider for abstracting initial connection configuration of SSH Client instances
Configuration Provider for SSHJ
Standard implementation of FTP Client Provider
Standard implementation of Socket Factory Provider support authenticated or unauthenticated SOCKS or HTTP proxies
Standard implementation of SSH Client Provider
Standard implementation of SSH Configuration Provider
This is a marker class to distinguish a table not being found from other SQL exceptions
A simple Java class to hold information about our state so that we can
maintain this state across multiple invocations of the Processor
Enumeration of supported Database column name Translation Strategies
Transmission Strategy enumeration of allowable values for component Property Descriptors
An InputStream that throws an IOException if any byte is read that is not a valid Base32 character.
An InputStream that throws an IOException if any byte is read that is not a valid Base64 character.
The interface for virtual file system implementations.
This class provide a protocol for Wait and Notify processors to work together.