All Classes and Interfaces (Apache Hadoop Common 3.5.0 API)
Description: class index

# All Classes and Interfaces

Class
Description
Abortable
Abort data being written to a stream, so that close() does not write the data.
Abortable.AbortableResult
Interface for the result of aborts; allows subclasses to extend (IOStatistics etc) or for future enhancements if ever needed.
AbstractDelegationTokenIdentifier
AbstractDelegationTokenSecretManager<TokenIdent extends AbstractDelegationTokenIdentifier>
AbstractDelegationTokenSecretManager.DelegationTokenInformation
Class to encapsulate a token's renew date and password.
AbstractDelegationTokenSelector<TokenIdent extends AbstractDelegationTokenIdentifier>
Look through tokens to find the first delegation token that matches the service and return it.
AbstractDNSToSwitchMapping
This is a base class for DNS to Switch mappings.
AbstractFileSystem
This class provides an interface for implementors of a Hadoop file system (analogous to the VFS of Unix).
AbstractFSBuilderImpl<S,B extends FSBuilder<S,B>>
Builder for filesystem/filecontext operations of various kinds, with option support.
AbstractGangliaSink
This the base class for Ganglia sink classes using metrics2.
AbstractGangliaSink.GangliaConfType
define enum for various type of conf
AbstractGangliaSink.GangliaSlope
ganglia slope values which equal the ordinal
AbstractIOStatisticsImpl
Base implementation in case common methods/fields need to be added in future.
AbstractJavaKeyStoreProvider
Abstract class for implementing credential providers that are based on Java Keystores as the underlying credential store.
AbstractLaunchableService
Subclass of `AbstractService` that provides basic implementations of the `LaunchableService` methods.
AbstractMapWritable
Abstract base class for MapWritable and SortedMapWritable Unlike org.apache.nutch.crawl.MapWritable, this class allows creation of MapWritable<Writable, MapWritable> so the CLASS_TO_ID and ID_TO_CLASS maps travel with the class instead of being static.
AbstractMetric
The immutable metric
AbstractMultipartUploader
Standard base class for Multipart Uploaders.
AbstractPatternFilter
Base class for pattern based filters
AbstractService
This is the base implementation class for services.
AccessControlException
An exception class for access control related issues.
AccessControlList
Class representing a configured access control list.
AclEntry
Defines a single entry in an ACL.
AclEntry.Builder
Builder for creating new AclEntry instances.
AclEntryScope
Specifies the scope or intended usage of an ACL entry.
AclEntryType
Specifies the type of an ACL entry.
AclStatus
An AclStatus contains the ACL information of a specific file.
AclStatus.Builder
Builder for creating new Acl instances.
AclUtil
AclUtil contains utility methods for manipulating ACLs.
ActiveStandbyElector
This class implements a simple library to perform leader election on top of Apache Zookeeper.
ActiveStandbyElector.ActiveNotFoundException
Exception thrown when there is no active leader
ActiveStandbyElector.ActiveStandbyElectorCallback
Callback interface to interact with the ActiveStandbyElector object.
ActiveThreadSpanSource<T extends AuditSpan>
Interface to get the active thread span.
AdminAuthorizedServlet
General servlet which is admin-authorized.
AlignmentContext
This interface intends to align the state between client and server via RPC communication.
AlreadyClosedException
An exception class for when a closed compressor/decopressor is being used `Compressor` `Decompressor`
AnnotatedSecurityInfo
Constructs SecurityInfo from Annotations provided in protocol interface.
ApplicationClassLoader
A `URLClassLoader` for application isolation.
ArrayFile
A dense file-based mapping from integers to values.
ArrayFile.Reader
Provide access to an existing array file.
ArrayFile.Writer
Write a new array file.
ArrayPrimitiveWritable
This is a wrapper class.
ArrayWritable
A Writable for arrays containing instances of a class.
AsyncCallHandler
Handle async calls.
AsyncCallLimitExceededException
Signals that an AsyncCallLimitExceededException has occurred.
AsyncDiskService
AsyncGet<R,E extends Throwable>
This interface defines an asynchronous `AsyncGet.get(long, TimeUnit)` method.
AsyncGet.Util
Utility
AsyncGetFuture<T,E extends Throwable>
A `Future` implemented using an `AsyncGet` object.
AtMostOnce
Used to mark certain methods of an interface with at-most-once semantics.
AuditConstants
Constants related to auditing.
AuditEntryPoint
A marker attribute simply to highlight which of the methods in a FileSystem why are audit entry points.
AuditingFunctions
Static methods to assist in working with Audit Spans.
AuditSpan
This is a span created by an `AuditSpanSource`.
AuditSpanSource<T extends AuditSpan>
A source of audit spans.
AuditStatisticNames
Statistic Names for Auditing.
AuthenticationFilterInitializer
Initializes hadoop-auth AuthenticationFilter which provides support for Kerberos HTTP SPNEGO authentication.
AuthorizationContext
Utility for managing a thread-local authorization header for RPC calls.
AuthorizationException
An exception class for authorization-related issues.
AutoCloseableLock
This is a wrap class of a ReentrantLock.
AvroFSInput
Adapts an `FSDataInputStream` to Avro's SeekableInput interface.
AvroReflectSerializable
Tag interface for Avro 'reflect' serializable classes.
AvroReflectSerialization
Serialization for Avro Reflect classes.
AvroSerialization<T>
Base class for providing serialization to Avro types.
AvroSpecificSerialization
Serialization for Avro Specific classes.
BackReference
Holds reference to an object to be attached to a stream or store to avoid the reference being lost to GC.
BadFencingConfigurationException
Indicates that the operator has specified an invalid configuration for fencing methods.
BaseExpression
Abstract expression for use in the `Find` command.
BasicDiskValidator
BasicDiskValidator is a wrapper around `DiskChecker`.
BatchedRemoteIterator<K,E>
A RemoteIterator that fetches elements in batches.
BatchedRemoteIterator.BatchedEntries<E>
BatchedRemoteIterator.BatchedListEntries<E>
BatchListingOperations
Interface filesystems MAY implement to offer a batched list.
BBPartHandle
Byte array backed part handle.
BBUploadHandle
Byte array backed upload handle.
BiFunctionRaisingIOE<T,U,R>
Function of arity 2 which may raise an IOException.
BinaryComparable
Interface supported by `WritableComparable` types supporting ordering/permutation by a representative set of bytes.
BindingUtils
Utility methods to assist binding to Hadoop APIs through reflection.
BlockCache
Provides functionality necessary for caching blocks of data read from FileSystem.
BlockCompressorStream
A `CompressorStream` which works with 'block-based' based compression algorithms, as opposed to 'stream-based' compression algorithms.
BlockData
Holds information about blocks of data in a file.
BlockDecompressorStream
A `DecompressorStream` which works with 'block-based' based compression algorithms, as opposed to 'stream-based' compression algorithms.
BlockGrouper
As part of a codec, to handle how to form a block group for encoding and provide instructions on how to recover erased blocks from a block group
BlockingThreadPoolExecutorService
This ExecutorService blocks the submission of new tasks when its queue is already full by using a semaphore.
BlockLocation
Represents the network location of a block, information about the hosts that contain block replicas, and other block metadata (E.g. the file offset associated with the block, length, whether it is corrupt, etc).
BlockManager
Provides read access to the underlying file one block at a time.
BlockManagerParameters
This class is used to provide parameters to `BlockManager`.
BlockOperations
Block level operations performed on a file.
BlockOperations.End
BlockOperations.Kind
Operation kind.
BlockOperations.Operation
BlockStoragePolicySpi
A storage policy specifies the placement of block replicas on specific storage types.
BlockUploadStatistics
BloomFilter
Implements a Bloom filter, as defined by Bloom in 1970.
BloomMapFile
This class extends `MapFile` and provides very much the same functionality.
BloomMapFile.Reader
BloomMapFile.Writer
BooleanWritable
A WritableComparable for booleans.
BooleanWritable.Comparator
A Comparator optimized for BooleanWritable.
BouncyCastleFipsKeyStoreProvider
CredentialProvider based on Bouncy Castle FIPS KeyStore file format.
BouncyCastleFipsKeyStoreProvider.Factory
The factory to create JksProviders, which is used by the ServiceLoader.
BoundedByteArrayOutputStream
A byte array backed output stream with a limit.
BoundedRangeFileInputStream
BoundedRangeFIleInputStream abstracts a contiguous region of a Hadoop FSDataInputStream as a regular input stream.
BoundedResourcePool<T>
Manages a fixed pool of resources.
BufferData
Holds the state of a ByteBuffer that is in use by `CachingBlockManager`.
BufferData.State
BufferedFSInputStream
A class that optimizes reading from FSInputStream by buffering.
BufferedIOStatisticsInputStream
An extension of `BufferedInputStream` which implements `IOStatisticsSource` and forwards requests for the `IOStatistics` to the wrapped stream.
BufferedIOStatisticsOutputStream
An extension of `BufferedOutputStream` which implements `IOStatisticsSource` and forwards requests for the `IOStatistics` to the wrapped stream.
BufferPool
Manages a fixed pool of `ByteBuffer` instances.
BuiltInGzipCompressor
A `Compressor` based on the popular gzip compressed file format.
BuiltInGzipDecompressor
A `Decompressor` based on the popular gzip compressed file format.
BuiltInGzipDecompressor.GzipStateLabel
The current state of the gzip decoder, external to the Inflater context.
BuiltInZlibDeflater
A wrapper around java.util.zip.Deflater to make it conform to org.apache.hadoop.io.compress.Compressor interface.
BuiltInZlibInflater
A wrapper around java.util.zip.Inflater to make it conform to org.apache.hadoop.io.compress.Decompressor interface.
BulkDelete
API for bulk deletion of objects/files, but not directories.
BulkDeleteSource
Interface for bulk deletion.
BulkDeleteUtils
Utility class for bulk delete operations.
ByteArray
Adaptor class to wrap byte-array backed objects (including java byte array) as RawComparable objects.
ByteBufferInputStream
Provide an input stream from a byte buffer; supporting `ByteBufferInputStream.mark(int)`.
ByteBufferPool
ByteBufferPositionedReadable
Implementers of this interface provide a positioned read API that writes to a `ByteBuffer` rather than a `byte[]`.
ByteBufferReadable
Implementers of this interface provide a read API that writes to a ByteBuffer, not a byte[].
ByteBufferUtil
BytesWritable
A byte sequence that is usable as a key or value.
BytesWritable.Comparator
A Comparator optimized for BytesWritable.
ByteWritable
A WritableComparable for a single byte.
ByteWritable.Comparator
A Comparator optimized for ByteWritable.
BZip2Codec
This class provides output and input streams for bzip2 compression and decompression.
Bzip2Compressor
A `Compressor` based on the popular bzip2 compression algorithm.
BZip2Constants
Base class for both the compress and decompress classes.
Bzip2Decompressor
A `Decompressor` based on the popular bzip2 compression algorithm.
BZip2DummyCompressor
This is a dummy compressor for BZip2.
BZip2DummyDecompressor
This is a dummy decompressor for BZip2.
Bzip2Factory
A collection of factories to create the right bzip2 compressor/decompressor instances.
CacheableIPList
CacheableIPList loads a list of subnets from a file.
CachedDNSToSwitchMapping
A cached implementation of DNSToSwitchMapping that takes an raw DNSToSwitchMapping and stores the resolved network location in a cache.
CachingBlockManager
Provides read access to the underlying file one block at a time.
CachingGetSpaceUsed
Interface for class that can tell estimate much space is used in a directory.
CachingKeyProvider
A `KeyProviderExtension` implementation providing a short lived cache for `KeyVersions` and `Metadata`to avoid burst of requests to hit the underlying `KeyProvider`.
CallableRaisingIOE<R>
This is a callable which only raises an IOException.
CallerContext
A class defining the caller context for auditing coarse granularity operations.
CallerContext.Builder
The caller context builder.
CallQueueManager<E extends Schedulable>
Abstracts queue operations for different blocking queues.
CanSetDropBehind
CanSetReadahead
CanUnbuffer
FSDataInputStreams implement this interface to indicate that they can clear their buffers on request.
CBZip2InputStream
An input stream that decompresses from the BZip2 format (without the file header chars) to be read as any other stream.
CBZip2InputStream.STATE
A state machine to keep track of current state of the de-coder
CBZip2OutputStream
An output stream that compresses into the BZip2 format (without the file header chars) into another stream.
ChecksumException
Thrown for checksum errors.
ChecksumFileSystem
Abstract Checksumed FileSystem.
ChecksumFs
Abstract Checksumed Fs.
ChmodParser
Parse a permission mode passed in from a chmod command and apply that mode against an existing file.
ChunkedArrayList<T>
Simplified List implementation which stores elements as a list of chunks, each chunk having a maximum size.
CipherOption
Used between client and server to negotiate the cipher suite, key and iv.
CipherSuite
Defines properties of a CipherSuite.
Classpath
Command-line utility for getting the full classpath needed to launch a Hadoop client application.
ClassUtil
CleanerUtil
sun.misc.Cleaner has moved in OpenJDK 9 and sun.misc.Unsafe#invokeCleaner(ByteBuffer) is the replacement.
CleanerUtil.BufferCleaner
Pass in an implementation of this interface to cleanup ByteBuffers.
Client
A client for an IPC service.
Client.ConnectionId
This class holds the address and the user ticket.
Client.IpcStreams
Manages the input and output streams for an IPC connection.
ClientCache
ClientId
A class defining a set of static helper methods to provide conversion between bytes and string for UUID-based client Id.
Closeable
Deprecated.
use java.io.Closeable
CloseableReferenceCount
A closeable object that maintains a reference count.
CloseableTaskPoolSubmitter
A task submitter which is closeable, and whose close() call shuts down the pool.
ClosedIOException
Exception to denote if the underlying stream, cache or other closable resource is closed.
ClusterStorageCapacityExceededException
Exception raised by HDFS indicating that storage capacity in the cluster filesystem is exceeded.
CodecConstants
Codec related constants.
CodecPool
A global compressor/decompressor pool used to save and reuse (possibly native) compression/decompression codecs.
CodecRegistry
This class registers all coder implementations.
CodecUtil
A codec & coder utility to help create coders conveniently.
CoderUtil
Helpful utilities for implementing some raw erasure coders.
CombinedFileRange
A file range that represents a set of underlying file ranges.
CombinedIPList
Util class to stores ips/hosts/subnets.
CombinedIPWhiteList
Command
An abstract class for the execution of a file system command
CommandFactory
class to search for and register commands
CommandFormat
Parse the args of a command and check the format of args.
CommandFormat.DuplicatedOptionException
Used when a duplicated option is supplied to a command.
CommandFormat.IllegalNumberOfArgumentsException
Used when the arguments exceed their bounds
CommandFormat.NotEnoughArgumentsException
Used when too few arguments are supplied to a command
CommandFormat.TooManyArgumentsException
Used when too many arguments are supplied to a command
CommandFormat.UnknownOptionException
Used when an unsupported option is supplied to a command
CommandShell
This program is a CLI utility base class utilizing hadoop Tool class.
CommonAuditContext
The common audit context is a map of common context information which can be used with any audit span.
CommonCallableSupplier<T>
A bridge from Callable to Supplier; catching exceptions raised by the callable and wrapping them as appropriate.
CommonConfigurationKeys
This class contains constants for configuration keys used in the common code.
CommonConfigurationKeysPublic
This class contains constants for configuration keys used in the common code.
CommonPathCapabilities
Common path capabilities.
ComparableVersion
Generic implementation of version comparison.
CompositeCrcFileChecksum
Composite CRC.
CompositeGroupsMapping
An implementation of `GroupMappingServiceProvider` which composites other group mapping providers for determining group membership.
CompositeService
Composition of services.
CompositeService.CompositeServiceShutdownHook
JVM Shutdown hook for CompositeService which will stop the give CompositeService gracefully in case of JVM shutdown.
CompressedWritable
A base-class for Writables which store themselves compressed and lazily inflate on field access.
Compression
Compression related stuff.
Compression.Algorithm
Compression algorithms.
CompressionCodec
This class encapsulates a streaming compression/decompression pair.
CompressionCodec.Util
CompressionCodecFactory
A factory that will find the correct codec for a given filename.
CompressionInputStream
A compression input stream.
CompressionOutputStream
A compression output stream.
Compressor
Specification of a stream-based 'compressor' which can be plugged into a `CompressionOutputStream` to compress data.
CompressorStream
Concat
Concat the given files.
ConfigRedactor
Tool for redacting sensitive information when displaying config parameters.
Configurable
Something that may be configured with a `Configuration`.
Configuration
Provides access to configuration parameters.
Configuration.DeprecationDelta
A pending addition to the global set of deprecated keys.
Configuration.IntegerRanges
A class that represents a set of positive integer ranges.
ConfigurationHelper
Configuration Helper class to provide advanced configuration parsing.
ConfigurationWithLogging
Logs access to `Configuration`.
Configured
Base class for things that may be configured with a `Configuration`.
ConfigUtil
Utilities for config variables of the viewFs See `ViewFs`
ConfServlet
A servlet to print out the running configuration data.
ConfServlet.BadFormatException
ConfTest
This class validates configuration XML files in ${HADOOP_CONF_DIR} or specified ones.
ConnectTimeoutException
Thrown by `NetUtils.connect(java.net.Socket, java.net.SocketAddress, int)` if it times out while connecting to the remote host.
Constants
Config variable prefixes for ViewFs - see `ViewFs` for examples.
ConsumerRaisingIOE<T>
Version of java.util.function.Consumer which raises exceptions.
ContentSummary
Store the summary of a content (a directory or a file).
ContentSummary.Builder
We don't use generics.
Contracts
Additional helpers (besides guava Preconditions) for programming by contract
CopyCommandWithMultiThread
Abstract command to enable sub copy commands run with multi-thread.
CostProvider
Used by `DecayRpcScheduler` to get the cost of users' operations.
Count
Count the number of directories, files, bytes, quota, and remaining quota.
CountingBloomFilter
Implements a counting Bloom filter, as defined by Fan et al. in a ToN 2000 paper.
CpuTimeTracker
Utility for sampling and computing CPU usage.
CrcComposer
Encapsulates logic for composing multiple CRCs into one or more combined CRCs corresponding to concatenated underlying data ranges.
CrcUtil
This class provides utilities for working with CRCs.
CreateFlag
CreateFlag specifies the file create semantic.
CredentialProvider
A provider of credentials or password for Hadoop applications.
CredentialProvider.CredentialEntry
The combination of both the alias and the actual credential value.
CredentialProviderFactory
A factory to create a list of CredentialProvider based on the path given in a Configuration.
Credentials
Base class for all credentials.
Credentials
A class that provides the facilities of reading and writing secret keys and Tokens.
Credentials.SerializedFormat
CredentialsGSS
Credential used by RPCSEC_GSS
CredentialShell
This program is the CLI utility for the CredentialProvider facilities in Hadoop.
CredentialShell.PasswordReader
To facilitate testing since Console is a final class.
CredentialsNone
Credential used by AUTH_NONE
CredentialsSys
Credential used by AUTH_SYS
CrossOriginFilter
CryptoCodec
Crypto codec class, encapsulates encryptor/decryptor pair.
CryptoFSDataInputStream
CryptoFSDataOutputStream
CryptoInputStream
CryptoInputStream decrypts data.
CryptoOutputStream
CryptoOutputStream encrypts data.
CryptoProtocolVersion
Versions of the client/server protocol used for HDFS encryption.
CryptoStreamUtils
CryptoUtils
Utility methods for the crypto related features.
CustomizedCallbackHandler
For handling customized `Callback`.
CustomizedCallbackHandler.Cache
CustomizedCallbackHandler.DefaultHandler
Daemon
A thread that has called `Thread.setDaemon(boolean)` with true.
Daemon.DaemonFactory
Provide a factory for named daemon threads, for use in ExecutorServices constructors
DataBlocks
A class to provide disk, byteBuffer and byteArray option for Filesystem OutputStreams.
DataBlocks.BlockFactory
Base class for block factories.
DataBlocks.BlockUploadData
The output information for an upload.
DataBlocks.DataBlock
This represents a block being uploaded.
DataBlocks.DataBlock.DestState
DataChecksum
This class provides interface and utilities for processing checksums for DFS data transfers.
DataChecksum.Type
The checksum types
DataInputBuffer
A reusable `DataInput` implementation that reads from an in-memory buffer.
DataInputByteBuffer
DataOutputBuffer
A reusable `DataOutput` implementation that writes to an in-memory buffer.
DataOutputOutputStream
OutputStream implementation that wraps a DataOutput.
DecayRpcScheduler
The decay RPC scheduler tracks the cost of incoming requests in a map, then decays the costs at a fixed time interval.
DecayRpcScheduler.DecayTask
This TimerTask will call decayCurrentCosts until the scheduler has been garbage collected.
DecayRpcScheduler.MetricsProxy
MetricsProxy is a singleton because we may init multiple schedulers and we want to clean up resources when a new scheduler replaces the old one.
DecayRpcSchedulerDetailedMetrics
This class is for maintaining queue (priority) level related statistics when FairCallQueue is used and publishing them through the metrics interface.
DecayRpcSchedulerMXBean
Provides metrics for Decay scheduler.
DecodingValidator
A utility class to validate decoding.
Decompressor
Specification of a stream-based 'de-compressor' which can be plugged into a `CompressionInputStream` to compress data.
DecompressorStream
Decryptor
DefaultBulkDeleteOperation
Default implementation of the `BulkDelete` interface.
DefaultCodec
DefaultCostProvider
Ignores process details and returns a constant value for each call.
DefaultFailoverProxyProvider<T>
An implementation of `FailoverProxyProvider` which does nothing in the event of failover, and always returns the same proxy object.
DefaultImpersonationProvider
DefaultMetricsFactory
Experimental interface to extend metrics dynamically
DefaultMetricsSystem
The default metrics system singleton.
DefaultRpcScheduler
No op default RPC scheduler.
DefaultStringifier<T>
DefaultStringifier is the default implementation of the `Stringifier` interface which stringifies the objects using base64 encoding of the serialized version of the objects.
DeflateCodec
Alias class for DefaultCodec to enable codec discovery by 'deflate' name.
DelegateToFileSystem
Implementation of AbstractFileSystem based on the existing implementation of `FileSystem`.
DelegatingSSLSocketFactory
A `SSLSocketFactory` that can delegate to various SSL implementations.
DelegatingSSLSocketFactory.SSLChannelMode
Default indicates Ordered, preferred OpenSSL, if failed to load then fall back to Default_JSSE.
DelegationKey
Key used for generating and verifying delegation tokens
DelegationTokenAuthenticatedURL
The `DelegationTokenAuthenticatedURL` is a `AuthenticatedURL` sub-class with built-in Hadoop Delegation Token functionality.
DelegationTokenAuthenticatedURL.Token
Client side authentication token that handles Delegation Tokens.
DelegationTokenAuthenticationFilter
The `DelegationTokenAuthenticationFilter` filter is a `AuthenticationFilter` with Hadoop Delegation Token support.
DelegationTokenAuthenticationHandler
An `AuthenticationHandler` that implements Kerberos SPNEGO mechanism for HTTP and supports Delegation Token functionality.
DelegationTokenAuthenticator
`Authenticator` wrapper that enhances an `Authenticator` with Delegation Token support.
DelegationTokenAuthenticator.DelegationTokenOperation
DelegationToken operations.
DelegationTokenIdentifier
Concrete delegation token identifier used by `DelegationTokenManager`, `KerberosDelegationTokenAuthenticationHandler` and `DelegationTokenAuthenticationFilter`.
DelegationTokenIssuer
Class for issuing delegation tokens.
DelegationTokenLoadingCache<K,V>
Cache for delegation tokens that can handle high volume of tokens.
DelegationTokenManager
Delegation Token Manager used by the `KerberosDelegationTokenAuthenticationHandler`.
DelegationTokenRenewer
A daemon thread that waits for the next file system to renew.
DelegationTokenRenewer.Renewable
The renewable interface used by the renewer.
DelegationTokenRenewer.RenewAction<T extends FileSystem & DelegationTokenRenewer.Renewable>
An action that will renew and replace the file system's delegation tokens automatically.
Deserializer<T>
Provides a facility for deserializing objects of type <T> from an `InputStream`.
DeserializerComparator<T>
A `RawComparator` that uses a `Deserializer` to deserialize the objects to be compared so that the standard `Comparator` can be used to compare them.
DF
Filesystem disk space usage statistics.
DFCachingGetSpaceUsed
Fast but inaccurate class to tell how much space HDFS is using.
DirectBufferPool
A simple class for pooling direct ByteBuffers.
DirectDecompressionCodec
This class encapsulates a codec which can decompress direct bytebuffers.
DirectDecompressor
Specification of a direct ByteBuffer 'de-compressor'.
DirectoryListingStartAfterNotFoundException
Thrown when the startAfter can't be found when listing a directory.
DiskChecker
Class that provides utility functions for checking disk problem
DiskChecker.DiskErrorException
DiskChecker.DiskOutOfSpaceException
DiskValidator
A interface for disk validators.
DiskValidatorFactory
The factory class to create instance of `DiskValidator`.
DNS
A class that provides direct and reverse lookup functionalities, allowing the querying of specific network interfaces or nameservers.
DNSDomainNameResolver
DNSDomainNameResolver wraps up the default DNS service for forward/reverse DNS lookup.
DNSToSwitchMapping
An interface that must be implemented to allow pluggable DNS-name/IP-address to RackID resolvers.
DNSToSwitchMappingWithDependency
An interface that must be implemented to allow pluggable DNS-name/IP-address to RackID resolvers.
DomainNameResolver
This interface provides methods for the failover proxy to get IP addresses of the associated servers (NameNodes, RBF routers etc).
DomainNameResolverFactory
This class creates the DomainNameResolver instance based on the config.
DomainSocket
The implementation of UNIX domain sockets in Java.
DomainSocketWatcher
The DomainSocketWatcher watches a set of domain sockets to see when they become readable, or closed.
DomainSocketWatcher.Handler
DoNotPool
This is a marker annotation that marks a compressor or decompressor type as not to be pooled.
DoubleWritable
Writable for Double values.
DoubleWritable.Comparator
A Comparator optimized for DoubleWritable.
DtFetcher
DtFetcher is an interface which permits the abstraction and separation of delegation token fetch implementaions across different packages and compilation units.
DtFileOperations
DtFileOperations is a collection of delegation token file operations.
DtUtilShell
DtUtilShell is a set of command line token file management operations.
DU
Filesystem disk space usage statistics.
DUHelper
DummyErasureCodec
Dummy erasure coder does not real coding computing.
DummyErasureDecoder
Dummy erasure decoder does no real computation.
DummyErasureEncoder
Dummy erasure encoder does no real computation.
DummyRawDecoder
A dummy raw decoder that does no real computation.
DummyRawEncoder
A dummy raw encoder that does no real computation.
DummyRawErasureCoderFactory
A raw erasure coder factory for dummy raw coders.
DumpUtil
A dump utility class for debugging data erasure coding/decoding issues.
DurationInfo
A duration with logging of final state at info or debug in the `close()` call.
DurationStatisticSummary
Summary of duration tracking statistics as extracted from an IOStatistics instance.
DurationTracker
Interface to be implemented by objects which can track duration.
DurationTrackerFactory
Interface for a source of duration tracking.
DynamicBloomFilter
Implements a dynamic Bloom filter, as defined in the INFOCOM 2006 paper.
DynamicIOStatisticsBuilder
Builder of `DynamicIOStatistics`.
DynamicWrappedIO
The wrapped IO methods in `org.apache.hadoop.io.wrappedio.WrappedIO`, dynamically loaded.
DynamicWrappedStatistics
The wrapped IOStatistics methods in `WrappedStatistics`, dynamically loaded.
DynConstructors
Dynamic constructors.
DynConstructors.Builder
DynConstructors.Ctor<C>
DynMethods
Dynamic method invocation.
DynMethods.BoundMethod
DynMethods.Builder
DynMethods.StaticMethod
DynMethods.UnboundMethod
Convenience wrapper class around `Method`.
ECBlock
A wrapper of block level data source/output that `ECChunk`s can be extracted from.
ECBlockGroup
A group of blocks or `ECBlock` incurred in an erasure coding task.
ECChunk
A wrapper for ByteBuffer or bytes array for an erasure code chunk.
ECSchema
Erasure coding schema to housekeeper relevant information.
ElasticByteBufferPool
This is a simple ByteBufferPool which just creates ByteBuffers as needed.
ElasticByteBufferPool.Key
EmptyPrefetchingStatistics
Empty implementation of the prefetching statistics interface.
Encryptor
EnumSetWritable<E extends Enum<E>>
A Writable wrapper for EnumSet.
ErasureCodec
Abstract Erasure Codec is defines the interface of each actual erasure codec classes.
ErasureCodeConstants
Constants related to the erasure code feature.
ErasureCodecOptions
Erasure codec options.
ErasureCodeNative
Erasure code native libraries (for now, Intel ISA-L) related utilities.
ErasureCoder
An erasure coder to perform encoding or decoding given a group.
ErasureCoderOptions
Erasure coder configuration that maintains schema info and coder options.
ErasureCodingStep
Erasure coding step that's involved in encoding/decoding of a block group.
ErasureDecoder
An abstract erasure decoder that's to be inherited by new decoders.
ErasureDecodingStep
Erasure decoding step, a wrapper of all the necessary information to perform a decoding step involved in the whole process of decoding a block group.
ErasureEncoder
An abstract erasure encoder that's to be inherited by new encoders.
ErasureEncodingStep
Erasure encoding step, a wrapper of all the necessary information to perform an encoding step involved in the whole process of encoding a block group.
Errno
Enum representing POSIX errno values.
EtagChecksum
An etag as a checksum.
EtagSource
An optional interface for `FileStatus` subclasses to implement to provide access to etags.
ExecutorHelper
Helper functions for Executors.
ExecutorServiceFuturePool
A FuturePool implementation backed by a java.util.concurrent.ExecutorService.
ExitCodeProvider
Get the exit code of an exception.
ExitUtil
Facilitates hooking process termination for tests, debugging and embedding.
ExitUtil.ExitException
An exception raised when a call to `ExitUtil.terminate(int)` was called and system exits were blocked.
ExitUtil.HaltException
An exception raised when a call to `ExitUtil.terminate(int)` was called and system halts were blocked.
Expression
Interface describing an expression to be used in the `Find` command.
ExternalCall<T>
FailoverController
The FailOverController is responsible for electing an active service on startup or when the current active is changing (eg due to failure), monitoring the health of a service, and performing a fail-over when a new active service is either manually selected by a user or elected.
FailoverFailedException
Exception thrown to indicate service failover has failed.
FailoverProxyProvider<T>
An implementer of this interface is capable of providing proxy objects for use in IPC communication, and potentially modifying these objects or creating entirely new ones in the event of certain types of failures.
FailoverProxyProvider.ProxyInfo<T>
FairCallQueue<E extends Schedulable>
A queue with multiple levels for each priority.
FairCallQueueMXBean
FastNumberFormat
Fast thread-safe version of NumberFormat
FastSaslClientFactory
Class for dealing with caching SASL client factories.
FastSaslServerFactory
Class for dealing with caching SASL server factories.
FenceMethod
A fencing method is a method by which one node can forcibly prevent another node from making continued progress.
FileAlreadyExistsException
Used when target file already exists for any operation and is not configured to be overwritten.
FileBasedIPList
FileBasedIPList loads a list of subnets in CIDR format and ip addresses from a file.
FileBasedKeyStoresFactory
`KeyStoresFactory` implementation that reads the certificates from keystore files.
FileChecksum
An abstract class representing file checksums for files.
FileContext
The FileContext class provides an interface for users of the Hadoop file system.
FileEncryptionInfo
FileEncryptionInfo encapsulates all the encryption-related information for an encrypted file.
FileMonitoringTimerTask
Implements basic logic to track when a file changes on disk and call the action passed to the constructor when it does.
FilePosition
Provides functionality related to tracking the position within a file.
FileRange
A byte range of a file.
FileRangeImpl
A range of bytes from a file with an optional buffer to read those bytes for zero copy.
FileSink
A metrics sink that writes to a file
FileStatus
Interface that represents the client side information for a file.
FileStatus.AttrFlags
Flags for entity attributes.
FileSystem
An abstract base class for a fairly generic filesystem.
FileSystem.DirectoryEntries
Represents a batch of directory entries when iteratively listing a directory.
FileSystem.Statistics
Tracks statistics about how many reads, writes, and so forth have been done in a FileSystem.
FileSystem.Statistics.StatisticsData
Statistics data.
FileSystemLinkResolver<T>
FileSystem-specific class used to operate on and resolve symlinks in a path.
FileSystemMultipartUploader
A MultipartUploader that uses the basic FileSystem commands.
FileSystemMultipartUploaderBuilder
Builder for `FileSystemMultipartUploader`.
FileSystemStatisticNames
Common statistic names for Filesystem-level statistics, including internals.
FileSystemStorageStatistics
A basic StorageStatistics instance which simply returns data from FileSystem#Statistics.
FileUtil
A collection of file-processing util methods
FileUtil.HardLink
Deprecated.
Use `HardLink`
Filter
Defines the general behavior of a filter.
FilterContainer
A container class for javax.servlet.Filter.
FilterExpression
Provides an abstract composition filter for the `Expression` interface.
FilterFileSystem
A `FilterFileSystem` contains some other file system, which it uses as its basic file system, possibly transforming the data along the way or providing additional functionality.
FilterFs
A `FilterFs` contains some other file system, which it uses as its basic file system, possibly transforming the data along the way or providing additional functionality.
FilterInitializer
Initialize a javax.servlet.Filter.
Find
FindClass
This entry point exists for diagnosing classloader problems: is a class or resource present -and if so, where?
FindOptions
Options to be used by the `Find` command and its `Expression`s.
FlagSet<E extends Enum<E>>
A set of flags, constructed from a configuration option or from a string, with the semantics of `ConfigurationHelper.parseEnumSet(String, String, Class, boolean)` and implementing `StreamCapabilities`.
FloatWritable
A WritableComparable for floats.
FloatWritable.Comparator
A Comparator optimized for FloatWritable.
ForwardingIOStatisticsStore
This may seem odd having an IOStatisticsStore which does nothing but forward to a wrapped store, but it's designed to assist in subclassing of selective methods, such as those to increment counters, get durations etc.
FsAction
File system actions, e.g. read, write, etc.
FSBuilder<S,B extends FSBuilder<S,B>>
The base interface which various FileSystem FileContext Builder interfaces can extend, and which underlying implementations will then implement.
FSBuilderSupport
Class to help with use of FSBuilder.
FsCommand
Base class for all "hadoop fs" commands.
FsConstants
FileSystem related constants.
FsCreateModes
A class that stores both masked and unmasked create modes and is a drop-in replacement for masked permission.
FSDataInputStream
Utility that wraps a `FSInputStream` in a `DataInputStream` and buffers input through a `BufferedInputStream`.
FSDataOutputStream
Utility that wraps a `OutputStream` in a `DataOutputStream`.
FSDataOutputStreamBuilder<S extends FSDataOutputStream,B extends FSDataOutputStreamBuilder<S,B>>
Builder for `FSDataOutputStream` and its subclasses.
FSError
Thrown for unexpected filesystem errors, presumed to reflect disk errors in the native filesystem.
FSExceptionMessages
Standard strings to use in exception messages in filesystems HDFS is used as the reference source of the strings
FsGetter
File system instance getter.
FSInputChecker
This is a generic input stream for verifying checksums for data before it is read by a user.
FSInputStream
FSInputStream is a generic old InputStream with a little bit of RAF-style seek ability.
FsLinkResolution<T>
Class to allow Lambda expressions to be used in `FileContext` link resolution.
FsLinkResolution.FsLinkResolutionFunction<T>
The signature of the function to invoke.
FSLinkResolver<T>
Used primarily by `FileContext` to operate on and resolve symlinks in a path.
FSOutputSummer
This is a generic output stream for generating checksums for data before it is written to the underlying stream
FsPermission
A class for file/directory permissions.
FsServerDefaults
Provides server default configuration values to clients.
FsShell
Provide command line access to a FileSystem.
FsShellPermissions
This class is the home for file permissions related commands.
FsShellPermissions.Chgrp
Used to change group of files
FsShellPermissions.Chmod
The pattern is almost as flexible as mode allowed by chmod shell command.
FsShellPermissions.Chown
Used to change owner and/or group of files
FsStatus
This class is used to represent the capacity, free and used space on a `FileSystem`.
FsTracer
Holds the HTrace Tracer used for FileSystem operations.
FsUrlStreamHandlerFactory
Factory for URL stream handlers.
FtpConfigKeys
This class contains constants for configuration keys used in the ftp file system.
FTPException
A class to wrap a `Throwable` into a Runtime Exception.
FTPFileSystem
A `FileSystem` backed by an FTP client provided by Apache Commons Net.
FtpFs
The FtpFs implementation of AbstractFileSystem.
FTPInputStream
Function4RaisingIOE<I1,I2,I3,I4,R>
Function of arity 4 which may raise an IOException.
FunctionalIO
Functional utilities for IO operations.
FunctionRaisingIOE<T,R>
Function of arity 1 which may raise an IOException.
FunctionsRaisingIOE
Deprecated.
use `org.apache.hadoop.util.functional`
FunctionsRaisingIOE.BiFunctionRaisingIOE<T,U,R>
Deprecated.
use `BiFunctionRaisingIOE`
FunctionsRaisingIOE.CallableRaisingIOE<R>
Deprecated.
use `CallableRaisingIOE`
FunctionsRaisingIOE.FunctionRaisingIOE<T,R>
Deprecated.
use `FunctionRaisingIOE`
FutureDataInputStreamBuilder
Builder for input streams and subclasses whose return value is actually a completable future: this allows for better asynchronous operation.
FutureDataInputStreamBuilderImpl
Builder for input streams and subclasses whose return value is actually a completable future: this allows for better asynchronous operation.
FutureIO
Future IO Helper methods.
FutureIOSupport
Deprecated.
GaloisField
Implementation of Galois field arithmetic with 2^p elements.
GangliaSink30
This code supports Ganglia 3.0
GangliaSink31
This code supports Ganglia 3.1
GcTimeMonitor
This class monitors the percentage of time the JVM is paused in GC within the specified observation window, say 1 minute.
GcTimeMonitor.Builder
GcTimeMonitor.GcData
Encapsulates data about GC pauses measured at the specific timestamp.
GcTimeMonitor.GcTimeAlertHandler
The user can provide an instance of a class implementing this interface when initializing a GcTimeMonitor to receive alerts when GC time percentage exceeds the specified threshold.
GenericOptionsParser
`GenericOptionsParser` is a utility to parse command line arguments generic to the Hadoop framework.
GenericRefreshProtocol
Protocol which is used to refresh arbitrary things at runtime.
GenericRefreshProtocolClientSideTranslatorPB
GenericRefreshProtocolPB
GenericRefreshProtocolServerSideTranslatorPB
GenericsUtil
Contains utility methods for dealing with Java Generics.
GenericWritable
A wrapper for Writable instances.
GetGroupsBase
Base class for the HDFS and MR implementations of tools which fetch and display the groups that users belong to.
GetSpaceUsed
GetSpaceUsed.Builder
The builder class
GetUserMappingsProtocol
Protocol implemented by the Name Node and Job Tracker which maps users to groups.
GetUserMappingsProtocolClientSideTranslatorPB
GetUserMappingsProtocolPB
GetUserMappingsProtocolServerSideTranslatorPB
GF256
A GaloisField utility class only caring of 256 fields for efficiency.
GlobalStorageStatistics
Stores global storage statistics objects.
GlobalStorageStatistics.StorageStatisticsProvider
A callback API for creating new StorageStatistics instances.
Globber
Implementation of `FileSystem.globStatus(Path, PathFilter)`.
Globber.GlobBuilder
Builder for Globber instances.
GlobExpander
GlobFilter
A filter for POSIX glob pattern with brace expansions.
GlobFilter
A glob pattern filter for metrics.
GlobPattern
A class for POSIX glob pattern with brace expansions.
GraphiteSink
A metrics sink that writes to a Graphite server.
GraphiteSink.Graphite
GroupMappingServiceProvider
An interface for the implementation of a user-to-groups mapping service used by `Groups`.
Groups
A user-to-groups mapping service.
GSet<K,E extends K>
A `GSet` is set, which supports the `GSet.get(Object)` operation.
GSetByHashMap<K,E extends K>
A `GSet` implementation by `HashMap`.
GzipCodec
This class creates gzip compressors/decompressors.
HAAdmin
A command-line tool for making calls in the HAServiceProtocol.
HAAdmin.UsageInfo
UsageInfo class holds args and help details.
HadoopExecutors
Factory methods for ExecutorService, ScheduledExecutorService instances.
HadoopIllegalArgumentException
Indicates that a method has been passed illegal or invalid argument.
HadoopKerberosName
This class implements parsing and handling of Kerberos principal names.
HadoopScheduledThreadPoolExecutor
An extension of ScheduledThreadPoolExecutor that provides additional functionality.
HadoopThreadPoolExecutor
An extension of ThreadPoolExecutor that provides additional functionality.
HadoopUncaughtExceptionHandler
This class is intended to be installed by calling `Thread.setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler)` in the main entry point.
HardLink
Class for creating hardlinks.
HardLink.LinkStats
HardLink statistics counters and methods.
HarFileSystem
This is an implementation of the Hadoop Archive Filesystem.
HarFs
HasEnhancedByteBufferAccess
FSDataInputStreams implement this interface to provide enhanced byte buffer access.
HAServiceProtocol
Protocol interface that provides High Availability related primitives to monitor and fail-over the service.
HAServiceProtocol.HAServiceState
An HA service may be in active or standby state.
HAServiceProtocol.RequestSource
HAServiceProtocol.StateChangeRequestInfo
Information describing the source for a request to change state.
HAServiceProtocolClientSideTranslatorPB
This class is the client side translator to translate the requests made on `HAServiceProtocol` interfaces to the RPC server implementing `HAServiceProtocolPB`.
HAServiceProtocolHelper
Helper for making `HAServiceProtocol` RPC calls.
HAServiceProtocolPB
HAServiceProtocolServerSideTranslatorPB
This class is used on the server side.
HAServiceStatus
HAServiceTarget
Represents a target of the client side HA administration commands.
HasFileDescriptor
Having a FileDescriptor
Hash
This class represents a common API for hashing functions.
HashFunction
Implements a hash object that returns a certain number of hashed values.
HCFSMountTableConfigLoader
An implementation for Apache Hadoop compatible file system based mount-table file loading.
HealthCheckFailedException
Exception thrown to indicate that health check of a service failed.
HealthMonitor
This class is a daemon which runs in a loop, periodically heartbeating with an HA service.
HealthMonitor.State
HeapSort
An implementation of the core algorithm of HeapSort.
HHErasureCodingStep
Abstract class for Hitchhiker common facilities shared by `HHXORErasureEncodingStep`and `HHXORErasureDecodingStep`.
HHUtil
Some utilities for Hitchhiker coding.
HHXORErasureCodec
A Hitchhiker-XOR erasure codec.
HHXORErasureDecoder
Hitchhiker is a new erasure coding algorithm developed as a research project at UC Berkeley by Rashmi Vinayak.
HHXORErasureDecodingStep
Hitchhiker-XOR Erasure decoding step, a wrapper of all the necessary information to perform a decoding step involved in the whole process of decoding a block group.
HHXORErasureEncoder
Hitchhiker is a new erasure coding algorithm developed as a research project at UC Berkeley by Rashmi Vinayak.
HHXORErasureEncodingStep
Hitchhiker-XOR Erasure encoding step, a wrapper of all the necessary information to perform an encoding step involved in the whole process of encoding a block group.
HostsFileReader
HostsFileReader.HostDetails
An atomic view of the included and excluded hosts
HtmlQuoting
This class is responsible for quoting HTML characters.
HttpConfig
Singleton to get access to Http related configuration.
HttpConfig.Policy
HttpCrossOriginFilterInitializer
HttpExceptionUtils
HTTP utility class to help propagate server side exception to the client over HTTP as a JSON payload.
HttpFileSystem
A Filesystem that reads from HTTP endpoint.
HttpReferrerAuditHeader
Contains all the logic for generating an HTTP "Referer" entry; includes escaping query params.
HttpReferrerAuditHeader.Builder
Builder.
HttpRequestLog
RequestLog object for use with Http
HttpServer2
Create a Jetty embedded server to answer http requests.
HttpServer2.Builder
Class to construct instances of HTTP server with specific options.
HttpServer2.QuotingInputFilter
A Servlet input filter that quotes all HTML active characters in the parameter names and values.
HttpServer2.QuotingInputFilter.RequestQuoter
HttpServer2.StackServlet
A very simple servlet to serve up a text representation of the current stack traces.
HttpServer2.XFrameOption
The X-FRAME-OPTIONS header in HTTP response to mitigate clickjacking attack.
HttpServer2Metrics
This class collects all the metrics of Jetty's StatisticsHandler and expose them as Hadoop Metrics.
HttpsFileSystem
A Filesystem that reads from HTTPS endpoint.
HttpUserGroupInformation
Util class that returns the remote `UserGroupInformation` in scope for the HTTP request.
Idempotent
Used to mark certain methods of an interface as being idempotent, and therefore warrant being retried on failover.
IdentityHashStore<K,V>
The IdentityHashStore stores (key, value) mappings in an array.
IdentityHashStore.Visitor<K,V>
IdentityProvider
The IdentityProvider creates identities for each schedulable by extracting fields and returning an identity string.
IdGenerator
Generic ID generator used for generating various types of number sequences.
IdMappingConstant
Some constants for IdMapping
IdMappingServiceProvider
An interface for the implementation of <userId, userName> mapping and <groupId, groupName> mapping.
ImpersonationProvider
IndexedSortable
Interface for collections capable of being sorted by `IndexedSorter` algorithms.
IndexedSorter
Interface for sort algorithms accepting `IndexedSortable` items.
IngressPortBasedResolver
An implementation of SaslPropertiesResolver.
InnerNode
InnerNode.Factory<N extends InnerNode>
InnerNodeImpl
InnerNode represents a switch/router of a data center or rack.
InnerNodeImpl.Factory
InodeTree<T>
InodeTree implements a mount-table as a tree of inodes.
InodeTree.INodeLink<T>
An internal class to represent a mount link.
InodeTree.MountPoint<T>
InodeTree.ResolveResult<T>
Resolve returns ResolveResult.
InputBuffer
A reusable `InputStream` implementation that reads from an in-memory buffer.
InstrumentedLock
This is a debugging class that can be used by callers to track whether a specific lock is being held for too long and periodically log a warning and stack trace, if so.
InstrumentedLock.SuppressedSnapshot
Immutable class to capture a snapshot of suppressed log message stats.
InstrumentedReadLock
This is a wrap class of a `ReadLock`.
InstrumentedReadWriteLock
This is a wrap class of a `ReentrantReadWriteLock`.
InstrumentedWriteLock
This is a wrap class of a `WriteLock`.
InternalOperations
This method allows access to Package-scoped operations from classes in org.apache.hadoop.fs.impl and other file system implementations in the hadoop modules.
Interns
Helpers to create interned metrics info.
InterruptEscalator
Handles interrupts by shutting down a service, escalating if the service does not shut down in time, or when other interrupts are received.
InterruptEscalator.ServiceForcedShutdown
Forced shutdown runnable.
IntrusiveCollection<E extends IntrusiveCollection.Element>
Implements an intrusive doubly-linked list.
IntrusiveCollection.Element
An element contained in this list.
IntWritable
A WritableComparable for ints.
IntWritable.Comparator
A Comparator optimized for IntWritable.
InvalidChecksumSizeException
Thrown when bytesPerChecksun field in the meta file is less than or equal to 0 or type is invalid.
InvalidDecodingException
Thrown for invalid decoding.
InvalidPathException
Path string is invalid either because it has invalid characters or due to other file system specific reasons.
InvalidPathHandleException
Thrown when the constraints enoded in a `PathHandle` do not hold.
InvalidRequestException
Thrown when the user makes a malformed request, for example missing required parameters or parameters that are not valid.
InvocationRaisingIOE
This is a lambda-expression which may raises an IOException.
IOStatistics
IO Statistics.
IOStatisticsAggregator
Interface exported by classes which support aggregation of `IOStatistics`.
IOStatisticsBinding
Support for implementing IOStatistics interfaces.
IOStatisticsContext
An interface defined to capture thread-level IOStatistics by using per thread context.
IOStatisticsContextImpl
Implementing the IOStatisticsContext.
IOStatisticsContextIntegration
A Utility class for IOStatisticsContext, which helps in creating and getting the current active context.
IOStatisticsLogging
Utility operations convert IO Statistics sources/instances to strings, especially for robustly logging.
IOStatisticsSetters
Setter for IOStatistics entries.
IOStatisticsSnapshot
Snapshot of statistics from a different source.
IOStatisticsSource
A source of IO statistics.
IOStatisticsStore
Interface of an IOStatistics store intended for use in classes which track statistics for reporting.
IOStatisticsStoreBuilder
Builder of the `IOStatisticsStore` implementation.
IOStatisticsSupport
Support for working with IOStatistics.
IOUtils
An utility class for I/O related functionality.
IOUtils.NullOutputStream
The /dev/null of OutputStreams.
IpcException
IPC exception is thrown by IPC layer when the IPC connection cannot be established.
IPList
IrqHandler
Handler of interrupts that relays them to a registered implementation of `IrqHandler.Interrupted`.
IrqHandler.InterruptData
Interrupt data to pass on.
IrqHandler.Interrupted
Callback issues on an interrupt.
IsActiveServlet
Used by Load Balancers to detect the active NameNode/ResourceManager/Router.
JavaKeyStoreProvider
KeyProvider based on Java's KeyStore file format.
JavaKeyStoreProvider
CredentialProvider based on Java's KeyStore file format.
JavaKeyStoreProvider.Factory
The factory to create JksProviders, which is used by the ServiceLoader.
JavaKeyStoreProvider.Factory
The factory to create JksProviders, which is used by the ServiceLoader.
JavaKeyStoreProvider.KeyMetadata
An adapter between a KeyStore Key and our Metadata.
JavaSerialization
An experimental `Serialization` for Java `Serializable` classes.
JavaSerializationComparator<T extends Serializable & Comparable<T>>
A `RawComparator` that uses a `JavaSerialization` `Deserializer` to deserialize objects that are then compared via their `Comparable` interfaces.
JceAesCtrCryptoCodec
Implement the AES-CTR crypto codec using JCE provider.
JceCtrCryptoCodec
JceCtrCryptoCodec.JceCtrCipher
JceSm4CtrCryptoCodec
Implement the SM4-CTR crypto codec using JCE provider.
JenkinsHash
Produces 32-bit hash for hash table lookup.
JettyUtils
Contains utility methods and constants relating to Jetty.
JMXJsonServlet
Provides Read only web access to JMX.
JMXJsonServletNaNFiltered
For example in case of MutableGauge we are using numbers, but not implementing Number interface, so we skip class check here because we can not be sure NaN values are wrapped with classes which implements the Number interface
JniBasedUnixGroupsMapping
A JNI-based implementation of `GroupMappingServiceProvider` that invokes libC calls to get the group memberships of a given user.
JniBasedUnixGroupsMappingWithFallback
JniBasedUnixGroupsNetgroupMapping
A JNI-based implementation of `GroupMappingServiceProvider` that invokes libC calls to get the group memberships of a given user.
JniBasedUnixGroupsNetgroupMappingWithFallback
JsonSerialization<T>
Support for marshalling objects to and from JSON.
JvmMetrics
JVM and logging related metrics.
JvmMetricsInfo
JVM and logging related metrics info instances
JvmPauseMonitor
Class which sets up a simple thread which runs in a loop sleeping for a short interval of time.
KDiag
Kerberos diagnostics This operation expands some of the diagnostic output of the security code, but not all.
KDiag.KerberosDiagsFailure
Diagnostics failures return the exit code 41, "unauthorized".
KerberosAuthException
Thrown when `UserGroupInformation` failed with an unrecoverable error, such as failure in kerberos login/logout, invalid subject etc.
KerberosDelegationTokenAuthenticationHandler
An `AuthenticationHandler` that implements Kerberos SPNEGO mechanism for HTTP and supports Delegation Token functionality.
KerberosDelegationTokenAuthenticator
The `KerberosDelegationTokenAuthenticator` provides support for Kerberos SPNEGO authentication mechanism and support for Hadoop Delegation Token operations.
KerberosInfo
Indicates Kerberos related information to be used
Key
The general behavior of a key that must be stored in a filter.
KeyProvider
A provider of secret key material for Hadoop applications.
KeyProvider.KeyVersion
The combination of both the key version name and the key material.
KeyProvider.Metadata
Key metadata that is associated with the key.
KeyProvider.Options
Options when creating key objects.
KeyProviderCryptoExtension
A KeyProvider with Cryptographic Extensions specifically for generating and decrypting encrypted encryption keys.
KeyProviderCryptoExtension.CryptoExtension
CryptoExtension is a type of Extension that exposes methods to generate EncryptedKeys and to decrypt the same.
KeyProviderCryptoExtension.EncryptedKeyVersion
An encrypted encryption key (EEK) and related information.
KeyProviderDelegationTokenExtension
A KeyProvider extension with the ability to add a renewer's Delegation Tokens to the provided Credentials.
KeyProviderDelegationTokenExtension.DelegationTokenExtension
DelegationTokenExtension is a type of Extension that exposes methods needed to work with Delegation Tokens.
KeyProviderExtension<E extends KeyProviderExtension.Extension>
This is a utility class used to extend the functionality of KeyProvider, that takes a KeyProvider and an Extension.
KeyProviderExtension.Extension
A marker interface for the KeyProviderExtension subclass implement.
KeyProviderFactory
A factory to create a list of KeyProvider based on the path given in a Configuration.
KeyProviderTokenIssuer
File systems that support Encryption Zones have to implement this interface.
KeyShell
This program is the CLI utility for the KeyProvider facilities in Hadoop.
KeyStoreProvider
CredentialProvider based on Java Key Store API.
KeyStoresFactory
Interface that gives access to `KeyManager` and `TrustManager` implementations.
KMSClientProvider
KMS client `KeyProvider` implementation.
KMSClientProvider.Factory
The factory to create KMSClientProvider, which is used by the ServiceLoader.
KMSClientProvider.KMSEncryptedKeyVersion
KMSClientProvider.KMSKeyVersion
KMSClientProvider.KMSMetadata
KMSClientProvider.KMSTokenRenewer
The KMS implementation of `TokenRenewer`.
KMSDelegationToken
Holder class for KMS delegation tokens.
KMSDelegationToken.KMSDelegationTokenIdentifier
DelegationTokenIdentifier used for the KMS.
KMSRESTConstants
KMS REST and JSON constants and utility methods for the KMSServer.
KMSUtil
Utils for KMS.
LambdaUtils
Lambda-expression utilities be they generic or specific to Hadoop datatypes.
LaunchableService
An interface which services can implement to have their execution managed by the ServiceLauncher.
LauncherArguments
Standard launcher arguments.
LauncherExitCodes
Common Exit codes.
LazyAtomicReference<T>
A lazily constructed reference, whose reference constructor is a `CallableRaisingIOE` so may raise IOExceptions.
LazyAutoCloseableReference<T extends AutoCloseable>
A subclass of `LazyAtomicReference` which holds an `AutoCloseable` reference and calls `close()` when it itself is closed.
LdapGroupsMapping
An implementation of `GroupMappingServiceProvider` which connects directly to an LDAP server for determining group membership.
LdapGroupsMapping.LdapSslSocketFactory
An private internal socket factory used to create SSL sockets with custom configuration.
LeakReporter
A class to report leaks of streams.
LeaseRecoverable
Whether the given Path of the FileSystem has the capability to perform lease recovery.
LifecycleEvent
A serializable lifecycle event: the time a state transition occurred, and what state was entered.
LightWeightCache<K,E extends K>
A low memory footprint Cache which extends `LightWeightGSet`.
LightWeightCache.Entry
Entries of `LightWeightCache`.
LightWeightGSet<K,E extends K>
A low memory footprint `GSet` implementation, which uses an array for storing the elements and linked lists for collision resolution.
LightWeightGSet.LinkedElement
Elements of `LightWeightGSet`.
LightWeightResizableGSet<K,E extends K>
A low memory footprint `GSet` implementation, which uses an array for storing the elements and linked lists for collision resolution.
LimitInputStream
Copied from guava source code v15 (LimitedInputStream) Guava deprecated LimitInputStream in v14 and removed it in v15.
LineReader
A class that provides a line reader from an input stream.
Lists
Static utility methods pertaining to `List` instances.
LoadBalancingKMSClientProvider
A simple LoadBalancing KMSClientProvider that round-robins requests across a provided array of KMSClientProviders.
LocalBouncyCastleFipsKeyStoreProvider
CredentialProvider based on bouncy castle FIPS KeyStore file format.
LocalBouncyCastleFipsKeyStoreProvider.Factory
The factory to create KeyStore Providers, which is used by the ServiceLoader.
LocalConfigKeys
This class contains constants for configuration keys used in the local file system, raw local fs and checksum fs.
LocalDirAllocator
An implementation of a round-robin scheme for disk allocation for creating files.
LocalFileSystem
Implement the FileSystem API for the checksumed local filesystem.
LocalFileSystemConfigKeys
This class contains constants for configuration keys used in the local file system, raw local fs and checksum fs.
LocalFileSystemPathHandle
Opaque handle to an entity in a FileSystem.
LocalFs
The LocalFs implementation of ChecksumFs.
LocalJavaKeyStoreProvider
CredentialProvider based on Java's KeyStore file format.
LocalJavaKeyStoreProvider.Factory
The factory to create JksProviders, which is used by the ServiceLoader.
LocalKeyStoreProvider
CredentialProvider based on Java's KeyStore file format.
LocatedFileStatus
This class defines a FileStatus that includes a file's block locations.
LogExactlyOnce
Log exactly once, even across threads.
LoggingStateChangeListener
This is a state change listener that logs events at INFO level
LogLevel
Change log level in runtime.
LogLevel.Servlet
A servlet implementation
LogThrottlingHelper
This is a class to help easily throttle log statements, so that they will not be emitted more frequently than a certain rate.
LogThrottlingHelper.LogAction
An indication of what action the caller should take.
LongWritable
A WritableComparable for longs.
LongWritable.Comparator
A Comparator optimized for LongWritable.
LongWritable.DecreasingComparator
A decreasing Comparator optimized for LongWritable.
LossyRetryInvocationHandler<T>
A dummy invocation handler extending RetryInvocationHandler.
Lz4Codec
This class creates lz4 compressors/decompressors.
Lz4Compressor
A `Compressor` based on the lz4 compression algorithm.
Lz4Decompressor
A `Decompressor` based on the lz4 compression algorithm.
MachineList
Container class which holds a list of ip/host addresses and answers membership queries.
MachineList.InetAddressFactory
InetAddressFactory is used to obtain InetAddress from host.
MapFile
A file-based map from keys to values.
MapFile.Merger
Class to merge multiple MapFiles of same Key and Value types to one MapFile
MapFile.Reader
Provide access to an existing map.
MapFile.Reader.Option
MapFile.Writer
Writes a new map.
MapFile.Writer.Option
MapWritable
A Writable Map.
MBeans
This util class provides a method to register an MBean using our standard naming convention as described in the doc for {link `MBeans.register(String, String, Object)`.
MD5Hash
A Writable for MD5 hash values.
MD5Hash.Comparator
A WritableComparator optimized for MD5Hash keys.
MD5MD5CRC32CastagnoliFileChecksum
For CRC32 with the Castagnoli polynomial
MD5MD5CRC32FileChecksum
MD5 of MD5 of CRC32.
MD5MD5CRC32GzipFileChecksum
For CRC32 with the Gzip polynomial
MeanStatistic
A mean statistic represented as the sum and the sample count; the mean is calculated on demand.
MergeSort
An implementation of the core algorithm of MergeSort.
MetaBlockAlreadyExists
Exception - Meta Block with the same name already exists.
MetaBlockDoesNotExist
Exception - No such Meta Block with the given name.
Metric
Annotation interface for a single metric used to annotate a field or a method in the class.
Metric.Type
Metrics
Annotation interface for a group of metrics
Metrics2Util
Utility class to simplify creation of hadoop metrics2 source/sink.
Metrics2Util.NameValuePair
A pair of a name and its corresponding value.
Metrics2Util.TopN
A fixed-size priority queue, used to retrieve top-n of offered entries.
MetricsAnnotations
Metrics annotation helpers.
MetricsCache
A metrics cache for sinks that don't support sparse updates.
MetricsCache.Record
Cached record
MetricsCollector
The metrics collector interface
MetricsCollectorImpl
MetricsException
A general metrics exception wrapper
MetricsFilter
The metrics filter interface.
MetricsInfo
Interface to provide immutable metainfo for metrics.
MetricsJsonBuilder
Build a JSON dump of the metrics.
MetricsPlugin
The plugin interface for the metrics framework
MetricsRecord
An immutable snapshot of metrics with a timestamp
MetricsRecordBuilder
The metrics record builder interface
MetricsRecordImpl
MetricsRegistry
An optional metrics registry class for creating and maintaining a collection of MetricsMutables, making writing metrics source easier.
MetricsSink
The metrics sink interface.
MetricsSource
The source of metrics information.
MetricsSourceBuilder
Helper class to build `MetricsSource` object from annotations.
MetricsSystem
The metrics system interface.
MetricsSystem.AbstractCallback
Convenient abstract class for implementing callback interface
MetricsSystem.Callback
The metrics system callback interface (needed for proxies.)
MetricsSystemImpl
A base class for metrics system singletons
MetricsSystemMXBean
The JMX interface to the metrics system
MetricsTag
Immutable tag for metrics (for grouping on host/queue/username etc.)
MetricStringBuilder
Build a string dump of the metrics.
MetricsVisitor
A visitor interface for metrics
MetricType
MountTableConfigLoader
An interface for loading mount-table configuration.
MsInfo
Metrics system related metrics info instances
MultiException
Holder class that clients can use to return multiple exceptions.
MultipartUploader
MultipartUploader is an interface for copying files multipart and across multiple nodes.
MultipartUploaderBuilder<S extends MultipartUploader,B extends MultipartUploaderBuilder<S,B>>
Builder interface for Multipart readers.
MultipartUploaderBuilderImpl<S extends MultipartUploader,B extends MultipartUploaderBuilder<S,B>>
Builder for `MultipartUploader` implementations.
MultipleIOException
Encapsulate a list of `IOException` into an `IOException`
MultipleIOException.Builder
Build an `IOException` using `MultipleIOException` if there are more than one.
MultiSchemeDelegationTokenAuthenticationHandler
A `CompositeAuthenticationHandler` that supports multiple HTTP authentication schemes along with Delegation Token functionality. e.g.
MurmurHash
This is a very fast, non-cryptographic hash suitable for general hash-based lookup.
MutableCounter
The mutable counter (monotonically increasing) metric interface
MutableCounterInt
A mutable int counter for implementing metrics sources
MutableCounterLong
A mutable long counter
MutableGauge
The mutable gauge metric interface
MutableGaugeFloat
A mutable float gauge.
MutableGaugeInt
A mutable int gauge
MutableGaugeLong
A mutable long gauge
MutableInverseQuantiles
Watches a stream of long values, maintaining online estimates of specific quantiles with provably low error bounds.
MutableMetric
The mutable metric interface
MutableMetricsFactory
MutableQuantiles
Watches a stream of long values, maintaining online estimates of specific quantiles with provably low error bounds.
MutableRate
A convenient mutable metric for throughput measurement
MutableRates
Helper class to manage a group of mutable rate metrics This class synchronizes all accesses to the metrics it contains, so it should not be used in situations where there is high contention on the metrics.
MutableRatesWithAggregation
Helper class to manage a group of mutable rate metrics.
MutableRollingAverages
This class maintains a group of rolling average metrics.
MutableStat
A mutable metric with stats.
NativeCodeLoader
A helper to load the native hadoop code i.e. libhadoop.so.
NativeIO
JNI wrappers for various native IO-related calls not available in Java.
NativeIO.POSIX
NativeIO.POSIX.CacheManipulator
Used to manipulate the operating system cache.
NativeIO.POSIX.NoMlockCacheManipulator
A CacheManipulator used for testing which does not actually call mlock.
NativeIO.POSIX.Pmem
JNI wrapper of persist memory operations.
NativeIO.POSIX.PmemMappedRegion
Denote memory region for a file mapped.
NativeIO.POSIX.Stat
Result type of the fstat call
NativeIO.POSIX.SupportState
Keeps the support state of PMDK.
NativeIO.Windows
NativeIO.Windows.AccessRight
Supported list of Windows access right flags
NativeIOException
An exception generated by a call to the native IO code.
NativeLibraryChecker
NativeRSRawDecoder
A Reed-Solomon raw decoder using Intel ISA-L library.
NativeRSRawEncoder
A Reed-Solomon raw encoder using Intel ISA-L library.
NativeRSRawErasureCoderFactory
A raw coder factory for raw Reed-Solomon coder in native using Intel ISA-L.
NativeXORRawDecoder
A XOR raw decoder using Intel ISA-L library.
NativeXORRawEncoder
A XOR raw encoder using Intel ISA-L library.
NativeXORRawErasureCoderFactory
A raw coder factory for xor coder in native using Intel ISA-L library.
NetgroupCache
Class that caches the netgroups and inverts group-to-user map to user-to-group map, primarily intended for use with netgroups (as returned by getent netgrgoup) which only returns group to user mapping.
NetUtils
NetworkTopology
The class represents a cluster of computer with a tree hierarchical network topology.
NetworkTopology.InvalidTopologyException
NetworkTopologyWithNodeGroup
The class extends NetworkTopology to represents a cluster of computer with a 4-layers hierarchical network topology.
NoCacheFilter
Node
The interface defines a node in a network topology.
NodeBase
A base class that implements interface Node
NodeFencer
This class parses the configured list of fencing methods, and is responsible for trying each one in turn while logging informative output.
NotInMountpointException
NotInMountpointException extends the UnsupportedOperationException.
NullGroupsMapping
This class provides groups mapping for `UserGroupInformation` when the user group information will not be used.
NullWritable
Singleton Writable with no data.
NullWritable.Comparator
A Comparator "optimized" for NullWritable.
ObjectWritable
A polymorphic Writable that writes an instance with it's class name.
ObserverRetryOnActiveException
Thrown by a remote ObserverNode indicating the operation has failed and the client should retry active namenode directly (instead of retry other ObserverNodes).
OpenFileParameters
All the parameters from the openFile builder for the `openFileWithOptions` commands.
OpensslAesCtrCryptoCodec
Implement the AES-CTR crypto codec using JNI into OpenSSL.
OpensslCipher
OpenSSL cipher using JNI.
OpensslCtrCryptoCodec
OpensslCtrCryptoCodec.OpensslCtrCipher
OpensslSecureRandom
OpenSSL secure random using JNI.
OpensslSm4CtrCryptoCodec
Implement the SM4-CTR crypto codec using JNI into OpenSSL.
OperationDuration
Little duration counter.
Options
This class contains options related to file system operations.
Options
This class allows generic access to variable length type-safe parameter lists.
Options.BooleanOption
Options.ChecksumCombineMode
Enum for indicating what mode to use when combining chunk and block checksums to define an aggregate FileChecksum.
Options.ChecksumOpt
This is used in FileSystem and FileContext to specify checksum options.
Options.ClassOption
Options.CreateFileOptionKeys
The standard `createFile()` options.
Options.CreateOpts
Class to support the varargs for create() options.
Options.CreateOpts.BlockSize
Options.CreateOpts.BufferSize
Options.CreateOpts.BytesPerChecksum
This is not needed if ChecksumParam is specified.
Options.CreateOpts.ChecksumParam
Options.CreateOpts.CreateParent
Options.CreateOpts.Perms
Options.CreateOpts.Progress
Options.CreateOpts.ReplicationFactor
Options.FSDataInputStreamOption
Options.FSDataOutputStreamOption
Options.HandleOpt
Options for creating `PathHandle` references.
Options.HandleOpt.Data
Option storing standard constraints on data.
Options.HandleOpt.Location
Option storing standard constraints on location.
Options.IntegerOption
Options.LongOption
Options.OpenFileOptions
The standard `openFile()` options.
Options.PathOption
Options.ProgressableOption
Options.Rename
Enum to support the varargs for rename() options
Options.StringOption
OsSecureRandom
A Random implementation that uses random bytes sourced from the operating system.
OutputBuffer
A reusable `OutputStream` implementation that writes to an in-memory buffer.
ParentNotDirectoryException
Indicates that the parent of specified Path is not a directory as expected.
PartHandle
Opaque, serializable reference to a part id for multipart uploads.
PartialListing<T extends FileStatus>
A partial listing of the children of a parent directory.
PassthroughCodec
This is a special codec which does not transform the output.
PassthroughCodec.PassthroughDecompressorStream
The decompressor.
PassthroughCodec.StubDecompressor
The decompressor is a no-op.
Path
Names a file or directory in a `FileSystem`.
PathAccessDeniedException
EACCES
PathCapabilities
The Path counterpoint to `StreamCapabilities`; a query to see if, a FileSystem/FileContext instance has a specific capability under the given path.
PathCapabilitiesSupport
PathData
Encapsulates a Path (path), its FileStatus (stat), and its FileSystem (fs).
PathData.FileTypeRequirement
PathData.PathType
PathExistsException
Exception corresponding to File Exists - EEXISTS
PathFilter
PathHandle
Opaque, serializable reference to an entity in the FileSystem.
PathIOException
Exceptions based on standard posix/linux style exceptions for path related errors.
PathIsDirectoryException
EISDIR
PathIsNotDirectoryException
ENOTDIR
PathIsNotEmptyDirectoryException
Generated by rm commands
PathNotFoundException
Exception corresponding to path not found: ENOENT/ENOFILE
PathOperationException
ENOTSUP
PathPermissionException
Exception corresponding to Operation Not Permitted - EPERM
PBHelper
Utility methods aiding conversion of fs data structures.
PerformanceAdvisory
PermissionStatus
Store permission related information.
PolicyProvider
`PolicyProvider` provides the `Service` definitions to the security `Policy` in effect for Hadoop.
PortmapMapping
Represents a mapping entry for in the Portmap service for binding RPC protocols.
PortmapRequest
Helper utility for building portmap request
PortmapResponse
Helper utility for sending portmap response.
PositionedReadable
Stream that permits positional reading.
PowerShellFencer
Fencer method that uses PowerShell to remotely connect to a machine and kill the required process.
Preconditions
This class replaces `guava.Preconditions` which provides helpers to validate the following conditions: An invalid `null` obj causes a `NullPointerException`. An invalid argument causes an `IllegalArgumentException`. An invalid state causes an `IllegalStateException`. An invalid index causes an `IndexOutOfBoundsException`.
PrefetchConstants
Constants used by prefetch implementations.
PrefetchingStatistics
PrintJarMainClass
A micro-application that prints the main class name out of a jar file.
PriorityQueue<T>
A PriorityQueue maintains a partial ordering of its elements such that the least element can always be found in constant time.
ProcessingDetails
Stores the times that a call takes to be processed through each step and its response status.
ProcessingDetails.Timing
The different stages to track the time of.
ProcessUtils
Process related utilities.
ProfileOutputServlet
Servlet to serve files generated by `ProfileServlet`.
ProfilerDisabledServlet
Servlet for disabled async-profiler.
ProfileServlet
Servlet that runs async-profiler as web-endpoint.
ProgramDriver
A driver that is used to run programs added to it
Progress
Utility to assist with generation of progress reports.
Progressable
A facility for reporting progress.
PrometheusMetricsSink
Metrics sink for prometheus exporter.
PrometheusServlet
Servlet to publish hadoop metrics in prometheus format.
ProtobufHelper
Deprecated.
hadoop code MUST use `ShadedProtobufHelper`.
ProtobufRpcEngine
Deprecated.
ProtobufRpcEngine.Invoker
ProtobufRpcEngine.Server
Server implementation is always ProtobufRpcEngine2 based implementation, supports backward compatibility for protobuf 2.5 based implementations, which uses non-shaded protobuf classes.
ProtobufRpcEngine2
RPC Engine for for protobuf based RPCs.
ProtobufRpcEngine2.Invoker
ProtobufRpcEngine2.Server
ProtobufRpcEngineCallback
Deprecated.
ProtobufRpcEngineCallback2
ProtobufWrapperLegacy
A RpcWritable wrapper for unshaded protobuf messages.
ProtocolInfo
The protocol name that is used when a client and server connect.
ProtocolMetaInfoPB
Protocol to get versions and signatures for supported protocols from the server.
ProtocolMetaInfoServerSideTranslatorPB
This class serves the requests for protocol versions and signatures by looking them up in the server registry.
ProtocolMetaInterface
This interface is implemented by the client side translators and can be used to obtain information about underlying protocol e.g. to check if a method is supported on the server side.
ProtocolProxy<T>
a class wraps around a server's proxy, containing a list of its supported methods.
ProtocolSignature
ProtocolTranslator
An interface implemented by client-side protocol translators to get the underlying proxy object the translator is operating on.
ProtoUtil
ProviderUtils
Utility methods for both key and credential provider APIs.
ProxyCombiner
A utility class used to combine two protocol proxies.
ProxyServers
ProxyUserAuthenticationFilter
AuthenticationFilter which adds support to perform operations using end user instead of proxy user.
ProxyUserAuthenticationFilterInitializer
Filter initializer to initialize `ProxyUserAuthenticationFilter` which adds support to perform operations using end user instead of proxy user.
ProxyUsers
PseudoDelegationTokenAuthenticationHandler
An `AuthenticationHandler` that implements Kerberos SPNEGO mechanism for HTTP and supports Delegation Token functionality.
PseudoDelegationTokenAuthenticator
The `PseudoDelegationTokenAuthenticator` provides support for Hadoop's pseudo authentication mechanism that accepts the user name specified as a query string parameter and support for Hadoop Delegation Token operations.
PureJavaCrc32
A pure-java implementation of the CRC32 checksum that uses the same polynomial as the built-in native CRC32.
PureJavaCrc32C
A pure-java implementation of the CRC32 checksum that uses the CRC32-C polynomial, the same polynomial used by iSCSI and implemented on many Intel chipsets supporting SSE4.2.
Quantile
Specifies a quantile (with error bounds) to be watched by a `SampleQuantiles` object.
QuantileEstimator
QuickSort
An implementation of the core algorithm of QuickSort.
QuotaUsage
Store the quota usage of a directory.
QuotaUsage.Builder
Builder class for QuotaUsage.
RateLimiting
Minimal subset of google rate limiter class.
RateLimitingFactory
Factory for Rate Limiting.
RawComparable
Interface for objects that can be compared through `RawComparator`.
RawComparator<T>
A `Comparator` that operates directly on byte representations of objects.
RawErasureCoderFactory
Raw erasure coder factory that can be used to create raw encoder and decoder.
RawErasureDecoder
An abstract raw erasure decoder that's to be inherited by new decoders.
RawErasureEncoder
An abstract raw erasure encoder that's to be inherited by new encoders.
RawLocalFileSystem
Implement the FileSystem API for the raw local filesystem.
RawLocalFs
The RawLocalFs implementation of AbstractFileSystem.
RawPathHandle
Generic format of FileStatus objects.
ReadaheadPool
Manages a pool of threads which can issue readahead requests on file descriptors.
ReadaheadPool.ReadaheadRequest
An outstanding readahead request that has been submitted to the pool.
ReadOption
Options that can be used when reading from a FileSystem.
ReadWriteDiskValidator
ReadWriteDiskValidator is the class to check a directory by to create a file, write some bytes into it, read back, and verify if they are identical.
ReadWriteDiskValidatorMetrics
The metrics for a directory generated by `ReadWriteDiskValidator`.
Reconfigurable
Something whose `Configuration` can be changed at run time.
ReconfigurableBase
Utility base class for implementing the Reconfigurable interface.
ReconfigurationException
Exception indicating that configuration property cannot be changed at run time.
ReconfigurationServlet
A servlet for changing a node's configuration.
ReconfigurationTaskStatus
ReconfigurationUtil
ReconfigurationUtil.PropertyChange
ReflectionUtils
General reflection utils
RefreshAuthorizationPolicyProtocol
Protocol which is used to refresh the authorization policy in use currently.
RefreshAuthorizationPolicyProtocolClientSideTranslatorPB
RefreshAuthorizationPolicyProtocolPB
RefreshAuthorizationPolicyProtocolServerSideTranslatorPB
RefreshCallQueueProtocol
Protocol which is used to refresh the call queue in use currently.
RefreshCallQueueProtocolClientSideTranslatorPB
RefreshCallQueueProtocolPB
RefreshCallQueueProtocolServerSideTranslatorPB
RefreshHandler
Used to registry custom methods to refresh at runtime.
RefreshRegistry
Used to registry custom methods to refresh at runtime.
RefreshResponse
Return a response in the handler method for the user to see.
RefreshUserMappingsProtocol
Protocol use
RefreshUserMappingsProtocolClientSideTranslatorPB
RefreshUserMappingsProtocolPB
RefreshUserMappingsProtocolServerSideTranslatorPB
RegexFilter
A regex pattern filter for metrics
RegexMountPointInterceptorType
RegexMountPointInterceptorType.
RegistrationClient
A simple client that registers an RPC program with portmap.
ReloadingX509KeystoreManager
An implementation of `X509KeyManager` that exposes a method, `ReloadingX509KeystoreManager.loadFrom(Path)` to reload its configuration.
ReloadingX509TrustManager
A `TrustManager` implementation that exposes a method, `ReloadingX509TrustManager.loadFrom(Path)` to reload its configuration for example when the truststore file on disk changes.
RemoteException
RemoteIterator<E>
An iterator over a collection whose elements need to be fetched remotely
RemoteIterators
A set of remote iterators supporting transformation and filtering, with IOStatisticsSource passthrough, and of conversions of the iterators to lists/arrays and of performing actions on the values.
RemoteIterators.WrappingRemoteIterator<S,T>
Wrapper of another remote iterator; IOStatistics and Closeable methods are passed down if implemented.
RemoveScheme
Defines the different remove scheme for retouched Bloom filters.
ResourcePool<T>
Manages a fixed pool of resources.
ResponseBuffer
RestCsrfPreventionFilter
This filter provides protection against cross site request forgery (CSRF) attacks for REST APIs.
RestCsrfPreventionFilter.HttpInteraction
Defines the minimal API requirements for the filter to execute its filtering logic.
Result
RetouchedBloomFilter
Implements a retouched Bloom filter, as defined in the CoNEXT 2006 paper.
RetriableException
Exception thrown by a server typically to indicate that server is in a state where request cannot be processed temporarily (such as still starting up).
RetryCache
Maintains a cache of non-idempotent requests that have been successfully processed by the RPC server implementation, to handle the retries.
RetryCache.CacheEntry
CacheEntry is tracked using unique client ID and callId of the RPC request.
RetryCache.CacheEntryWithPayload
CacheEntry with payload that tracks the previous response or parts of previous response to be used for generating response for retried requests.
RetryCacheMetrics
This class is for maintaining the various RetryCache-related statistics and publishing them through the metrics interfaces.
Retryer
Provides retry related functionality.
RetryInvocationHandler<T>
A `RpcInvocationHandler` which supports client side retry .
RetryPolicies
A collection of useful implementations of `RetryPolicy`.
RetryPolicies.MultipleLinearRandomRetry
Given pairs of number of retries and sleep time (n0, t0), (n1, t1), ..., the first n0 retries sleep t0 milliseconds on average, the following n1 retries sleep t1 milliseconds on average, and so on.
RetryPolicies.MultipleLinearRandomRetry.Pair
Pairs of numRetries and sleepSeconds
RetryPolicy
Specifies a policy for retrying method failures.
RetryPolicy.RetryAction
Returned by `RetryPolicy.shouldRetry(Exception, int, int, boolean)`.
RetryPolicy.RetryAction.RetryDecision
RetryProxy
A factory for creating retry proxies.
RetryUtils
RollingFileSystemSink
This class is a metrics sink that uses `FileSystem` to write the metrics logs.
RPC
A simple RPC mechanism.
RPC.Builder
Class to construct instances of RPC server with specific options.
RPC.RpcKind
RPC.Server
An RPC Server.
RPC.VersionMismatch
A version mismatch for the RPC protocol.
RpcAcceptedReply
Represents RPC message MSG_ACCEPTED reply body.
RpcAcceptedReply.AcceptState
RpcAuthInfo
Authentication Info.
RpcAuthInfo.AuthFlavor
Different types of authentication as defined in RFC 1831
RpcCall
Represents an RPC message of type RPC call as defined in RFC 1831
RpcCallCache
This class is used for handling the duplicate non-idempotenty Rpc calls.
RpcCallCache.CacheEntry
RpcCallCache.ClientRequest
Call that is used to track a client in the `RpcCallCache`
RpcClientException
Indicates an exception in the RPC client
RpcClientUtil
This class maintains a cache of protocol versions and corresponding protocol signatures, keyed by server address, protocol and rpc kind.
RpcConstants
RpcDeniedReply
Represents RPC message MSG_DENIED reply body.
RpcDeniedReply.RejectState
RpcDetailedMetrics
This class is for maintaining RPC method related statistics and publishing them through the metrics interfaces.
RpcEngine
An RPC implementation.
RpcException
Indicates an exception during the execution of remote procedure call.
RpcInfo
RpcInfo records all contextual information of an RPC message.
RpcInvocationHandler
This interface must be implemented by all InvocationHandler implementations.
RpcMessage
Represent an RPC message as defined in RFC 1831.
RpcMessage.Type
Message type
RpcMetrics
This class is for maintaining the various RPC statistics and publishing them through the metrics interfaces.
RpcMultiplexer
Implement this interface to make a pluggable multiplexer in the FairCallQueue.
RpcNoSuchMethodException
No such Method for an Rpc Call
RpcNoSuchProtocolException
No such protocol (i.e. interface) for and Rpc Call
RpcProgram
Class for writing RPC server programs based on RFC 1050.
RpcReply
Represents an RPC message of type RPC reply as defined in RFC 1831
RpcReply.ReplyState
RPC reply_stat as defined in RFC 1831
RpcResponse
RpcResponse encapsulates a response to a RPC request.
RpcScheduler
Implement this interface to be used for RPC scheduling and backoff.
RpcServerException
Indicates an exception on the RPC server
RpcUtil
RpcWritable
RpcWritable.Buffer
adapter to allow decoding of writables and protobufs from a byte buffer.
RSErasureCodec
A Reed-Solomon erasure codec.
RSErasureDecoder
Reed-Solomon erasure decoder that decodes a block group.
RSErasureEncoder
Reed-Solomon erasure encoder that encodes a block group.
RSLegacyRawDecoder
A raw erasure decoder in RS code scheme in pure Java in case native one isn't available in some environment.
RSLegacyRawEncoder
A raw erasure encoder in RS code scheme in pure Java in case native one isn't available in some environment.
RSLegacyRawErasureCoderFactory
A raw coder factory for the legacy raw Reed-Solomon coder in Java.
RSRawDecoder
A raw erasure decoder in RS code scheme in pure Java in case native one isn't available in some environment.
RSRawEncoder
A raw erasure encoder in RS code scheme in pure Java in case native one isn't available in some environment.
RSRawErasureCoderFactory
A raw coder factory for the new raw Reed-Solomon coder in Java.
RSUtil
Utilities for implementing Reed-Solomon code, used by RS coder.
RuleBasedLdapGroupsMapping
This class uses `LdapGroupsMapping` for group lookup and applies the rule configured on the group names.
RunJar
Run a Hadoop job jar.
RunnableRaisingIOE
Runnable interface whose `RunnableRaisingIOE.apply()` method may raise an IOE.
SafeMode
Whether the given filesystem is in any status of safe mode.
SafeModeAction
An identical copy from org.apache.hadoop.hdfs.protocol.HdfsConstants.SafeModeAction, that helps the other file system implementation to define `SafeMode`.
SampleQuantiles
Implementation of the Cormode, Korn, Muthukrishnan, and Srivastava algorithm for streaming calculation of targeted high-percentile epsilon-approximate quantiles.
SampleStat
Helper to compute running sample stats
SampleStat.MinMax
Helper to keep running min/max
SaslInputStream
A SaslInputStream is composed of an InputStream and a SaslServer (or SaslClient) so that read() methods return data that are read in from the underlying InputStream but have been additionally processed by the SaslServer (or SaslClient) object.
SaslMechanismFactory
SASL related constants.
SaslOutputStream
A SaslOutputStream is composed of an OutputStream and a SaslServer (or SaslClient) so that write() methods first process the data before writing them out to the underlying OutputStream.
SaslPlainServer
SaslPlainServer.SaslPlainServerFactory
SaslPlainServer.SecurityProvider
SaslPropertiesResolver
Provides SaslProperties to be used for a connection.
SaslRpcClient
A utility class that encapsulates SASL logic for RPC client
SaslRpcServer
A utility class for dealing with SASL on RPC server
SaslRpcServer.AuthMethod
Authentication method
SaslRpcServer.QualityOfProtection
SaslRpcServer.SaslDigestCallbackHandler
CallbackHandler for SASL mechanism.
SaslRpcServer.SaslGssCallbackHandler
CallbackHandler for SASL GSSAPI Kerberos mechanism
Schedulable
Interface which allows extracting information necessary to create schedulable identity strings.
ScopedAclEntries
Groups a list of ACL entries into separate lists for access entries vs.
ScriptBasedMapping
This class implements the `DNSToSwitchMapping` interface using a script configured via the `CommonConfigurationKeysPublic.NET_TOPOLOGY_SCRIPT_FILE_NAME_KEY` option.
ScriptBasedMapping.RawScriptBasedMapping
This is the uncached script mapping that is fed into the cache managed by the superclass `CachedDNSToSwitchMapping`
ScriptBasedMappingWithDependency
This class extends ScriptBasedMapping class and implements the `DNSToSwitchMappingWithDependency` interface using a script configured via the `CommonConfigurationKeysPublic.NET_DEPENDENCY_SCRIPT_FILE_NAME_KEY` option.
SecretManager<T extends TokenIdentifier>
The server-side secret manager for each token type.
SecretManager.InvalidToken
The token was invalid and the message explains why.
SecureIOUtils
This class provides secure APIs for opening and creating files on the local disk.
SecureIOUtils.AlreadyExistsException
Signals that an attempt to create a file at a given pathname has failed because another file already existed at that path.
SecurityHandler
SecurityInfo
SecurityUtil
Security Utils.
SecurityUtil.QualifiedHostResolver
This an alternate resolver with important properties that the standard java resolver lacks: 1) The hostname is fully qualified.
SecurityUtil.TruststoreKeystore
Helper class to contain the Truststore/Keystore paths for the ZK client connection over SSL/TLS.
Seekable
Stream that permits seeking.
SemaphoredDelegatingExecutor
This ExecutorService blocks the submission of new tasks when its queue is already full by using a semaphore.
SequenceFile
`SequenceFile`s are flat files consisting of binary key/value pairs.
SequenceFile.CompressionType
The compression type used to compress key/value pairs in the `SequenceFile`.
SequenceFile.Metadata
The class encapsulating with the metadata of a file.
SequenceFile.Reader
Reads key/value pairs from a sequence-format file.
SequenceFile.Reader.Option
A tag interface for all of the Reader options
SequenceFile.Sorter
Sorts key/value pairs in a sequence-format file.
SequenceFile.Sorter.RawKeyValueIterator
The interface to iterate over raw keys/values of SequenceFiles.
SequenceFile.ValueBytes
The interface to 'raw' values of SequenceFiles.
SequenceFile.Writer
Write key/value pairs to a sequence-format file.
SequenceFile.Writer.Option
SequentialNumber
Sequential number generator.
Serialization<T>
Encapsulates a `Serializer`/`Deserializer` pair.
SerializationFactory
A factory for `Serialization`s.
Serializer<T>
Provides a facility for serializing objects of type <T> to an `OutputStream`.
Server
An abstract IPC service.
Server.AuthProtocol
Server.Call
A generic call queued for handling.
Servers
Helpers to handle server addresses
Service
An abstract definition of service as related to Service Level Authorization for Hadoop.
Service
Service LifeCycle.
Service.STATE
Service states
ServiceAuthorizationManager
An authorization manager which handles service-level authorization for incoming service requests.
ServiceFailedException
Exception thrown to indicate that an operation performed to modify the state of a service or application failed.
ServiceLauncher<S extends Service>
A class to launch any YARN service by name.
ServiceLauncher.MinimalGenericOptionsParser
A generic options parser which does not parse any of the traditional Hadoop options.
ServiceLaunchException
A service launch exception that includes an exit code.
ServiceOperations
This class contains a set of methods to work with services, especially to walk them through their lifecycle.
ServiceOperations.ServiceListeners
Class to manage a list of `ServiceStateChangeListener` instances, including a notification loop that is robust against changes to the list during the notification process.
ServicePlugin
Service plug-in interface.
ServiceShutdownHook
JVM Shutdown hook for Service which will stop the Service gracefully in case of JVM shutdown.
ServiceStateChangeListener
Interface to notify state changes of a service.
ServiceStateException
Exception that can be raised on state change operations, whose exit code can be explicitly set, determined from that of any nested cause, or a default value of `LauncherExitCodes.EXIT_SERVICE_LIFECYCLE_EXCEPTION`.
ServiceStateModel
Implements the service state model.
ServletUtil
SetFile
A file-based set of keys.
SetFile.Reader
Provide access to an existing set file.
SetFile.Writer
Write a new set file.
Sets
Static utility methods pertaining to `Set` instances.
SFTPFileSystem
SFTP FileSystem.
ShadedProtobufHelper
Helper methods for protobuf related RPC implementation using the hadoop `org.apache.hadoop.thirdparty.protobuf` shaded version.
ShadedProtobufHelper.IpcCall<T>
SharedFileDescriptorFactory
A factory for creating shared file descriptors inside a given directory.
Shell
A base class for running a Shell command.
Shell.CommandExecutor
Shell.ExitCodeException
This is an IOException with exit code added.
Shell.OSType
Shell.ShellCommandExecutor
A simple shell command executor.
ShellBasedIdMapping
A simple shell-based implementation of `IdMappingServiceProvider` Map id to user name or group name.
ShellBasedUnixGroupsMapping
A simple shell-based implementation of `GroupMappingServiceProvider` that exec's the `groups` shell command to fetch the group memberships of a given user.
ShellBasedUnixGroupsNetgroupMapping
A simple shell-based implementation of `GroupMappingServiceProvider` that exec's the `groups` shell command to fetch the group memberships of a given user.
ShellCommandFencer
Fencing method that runs a shell command.
ShortWritable
A WritableComparable for shorts.
ShortWritable.Comparator
A Comparator optimized for ShortWritable.
ShutdownHookManager
The `ShutdownHookManager` enables running shutdownHook in a deterministic order, higher priority first.
ShutdownThreadsHelper
Helper class to shutdown `Thread`s and `ExecutorService`s.
SignalLogger
This class logs a message whenever we're about to exit on a UNIX signal.
SignalUtil
SignalUtil.Handler
SignalUtil.Signal
SimpleBufferedOutputStream
A simplified BufferedOutputStream with borrowed buffer, and allow users to see how much data have been buffered.
SimpleTcpClient
A simple TCP based RPC client which just sends a request to a server.
SimpleTcpClientHandler
A simple TCP based RPC client handler used by `SimpleTcpServer`.
SimpleTcpServer
Simple UDP server implemented using netty.
SimpleUdpClient
A simple UDP based RPC client which just sends one request to a server.
SimpleUdpServer
Simple UDP server implemented based on netty.
SingleFilePerBlockCache
Provides functionality necessary for caching blocks of data read from FileSystem.
Sizes
Sizes of binary values and other some common sizes.
SnappyCodec
This class creates snappy compressors/decompressors.
SnappyCompressor
A `Compressor` based on the snappy compression algorithm.
SnappyDecompressor
A `Decompressor` based on the snappy compression algorithm.
SnappyDecompressor.SnappyDirectDecompressor
SocketInputStream
This implements an input stream that can have a timeout while reading.
SocketInputWrapper
A wrapper stream around a socket which allows setting of its timeout.
SocketOutputStream
This implements an output stream that can have a timeout while writing.
SocksSocketFactory
Specialized SocketFactory to create sockets with a SOCKS proxy
SortedMapWritable<K extends WritableComparable<? super K>>
A Writable SortedMap.
SourceWrappedStatistics
Wrap a statistics instance with an `IOStatisticsSource` instance which will then serve up the statistics when asked.
SplitCompressionInputStream
An InputStream covering a range of compressed data.
SplittableCompressionCodec
This interface is meant to be implemented by those compression codecs which are capable to compress / de-compress a stream starting at any arbitrary position.
SplittableCompressionCodec.READ_MODE
During decompression, data can be read off from the decompressor in two modes, namely continuous and blocked.
SQLDelegationTokenSecretManager<TokenIdent extends AbstractDelegationTokenIdentifier>
An implementation of `AbstractDelegationTokenSecretManager` that persists TokenIdentifiers and DelegationKeys in an existing SQL database.
SshFenceByTcpPort
This fencing implementation sshes to the target node and uses `fuser` to kill the process listening on the service's TCP port.
SSLFactory
Factory that creates SSLEngine and SSLSocketFactory instances using Hadoop configuration information.
SSLFactory.Mode
SSLHostnameVerifier
Copied from the not-yet-commons-ssl project at http://juliusdavies.ca/commons-ssl/ This project is not yet in Apache, but it is Apache 2.0 licensed.
SSLHostnameVerifier.AbstractVerifier
SSLHostnameVerifier.Certificates
StandardSocketFactory
Specialized SocketFactory to create sockets with a SOCKS proxy
StandbyException
Thrown by a remote server when it is up, but is not the active server in a set of servers in which only a subset may be active.
Stat
Wrapper for the Unix stat(1) command.
StaticUserWebFilter
Provides a servlet filter that pretends to authenticate a fake user (Dr.Who) so that the web UI is usable for a secure cluster without authentication.
StaticUserWebFilter.StaticUserFilter
StatisticDurationTracker
Track the duration of an object.
StatsDSink
A metrics sink that writes metrics to a StatsD daemon.
StatsDSink.StatsD
Class that sends UDP packets to StatsD daemon.
StopWatch
A simplified StopWatch implementation which can measure times in nanoseconds.
StorageSize
A class that contains the numeric value and the unit of measure.
StorageStatistics
StorageStatistics contains statistics data for a FileSystem or FileContext instance.
StorageStatistics.CommonStatisticNames
These are common statistic names.
StorageStatistics.LongStatistic
A 64-bit storage statistic.
StorageStatisticsFromIOStatistics
Returns all the counters of an IOStatistics instance as StorageStatistics.
StorageType
Defines the types of supported storage media.
StorageUnit
Class that maintains different forms of Storage Units.
StoreImplementationUtils
Utility classes to help implementing filesystems and streams.
StoreStatisticNames
Common statistic names for object store operations..
StreamCapabilities
Interface to query streams for supported capabilities.
StreamCapabilities.StreamCapability
Deprecated.
StreamCapabilitiesPolicy
Static methods to implement policies for `StreamCapabilities`.
StreamStatisticNames
These are common statistic names.
Stringifier<T>
Stringifier interface offers two methods to convert an object to a string representation and restore the object given its string representation.
StringInterner
Provides string interning utility methods.
StringUtils
General string utils
StringUtils.TraditionalBinaryPrefix
The traditional binary prefixes, kilo, mega, ..., exa, which can be represented by a 64-bit integer.
StubDurationTracker
A simple stub duration tracker which can be issued in interfaces and other places where full duration tracking is not implemented.
StubDurationTrackerFactory
This is a stub factory which always returns no-op duration trackers.
SubjectInheritingThread
Helper class to restore Subject propagation behavior of threads after the JEP411/JEP486 changes.
Syncable
This is the interface for flush/sync operations.
SysInfo
Plugin to calculate resource information on the system.
SysInfoLinux
Plugin to calculate resource information on Linux systems.
SysInfoWindows
Plugin to calculate resource information on Windows systems.
SysSecurityHandler
TableListing
This class implements a "table listing" with column headers.
TableListing.Builder
TableListing.Justification
TableMapping
Simple `DNSToSwitchMapping` implementation that reads a 2 column text file.
TaskPool
Utility class for parallel execution, takes closures for the various actions.
TaskPool.Builder<I>
Builder for task execution.
TaskPool.FailureTask<I,E extends Exception>
Callback invoked on a failure.
TaskPool.Submitter
Interface to whatever lets us submit tasks.
TaskPool.Task<I,E extends Exception>
Callback invoked to process an item.
Text
This class stores text using standard UTF8 encoding.
Text.Comparator
A WritableComparator optimized for Text keys.
TFile
A TFile is a container of key-value pairs.
TFile.Reader
TFile Reader.
TFile.Reader.Scanner
The TFile Scanner.
TFile.Writer
TFile Writer.
ThreadUtil
Time
Utility methods for getting the time and computing intervals.
Timer
Utility methods for getting the time and computing intervals.
Token<T extends TokenIdentifier>
The client-side form of the token.
Token.TrivialRenewer
A trivial renewer for token kinds that aren't managed.
TokenIdentifier
An identifier that identifies a token, may contain public information about a token, including its kind (or type).
TokenInfo
Indicates Token related information to be used
TokenRenewer
This is the interface for plugins that handle tokens.
TokenSelector<T extends TokenIdentifier>
Select token of type T from tokens for use with named service
Tool
A tool interface that supports handling of generic command-line options.
ToolRunner
A utility to help run `Tool`s.
TouchCommands
Unix touch like commands
TouchCommands.Touch
A UNIX like touch command.
TouchCommands.Touchz
(Re)create zero-length file at the specified path.
TrackingByteBufferPool
A wrapper `ByteBufferPool` implementation that tracks whether all allocated buffers are released.
TrackingByteBufferPool.ByteBufferAllocationStacktraceException
Strack trace of allocation as saved in the tracking map.
TrackingByteBufferPool.LeakDetectorHeapByteBufferPoolException
TrackingByteBufferPool.LeakedByteBufferException
Exception raised in `TrackingByteBufferPool.close()` if there was an unreleased buffer.
TrackingByteBufferPool.ReleasingUnallocatedByteBufferException
Exception raised in `TrackingByteBufferPool.putBuffer(ByteBuffer)` if the buffer to release was not in the hash map.
Trash
Provides a trash facility which supports pluggable Trash policies.
TrashPolicy
This interface is used for implementing different Trash policies.
TrashPolicyDefault
Provides a trash feature.
Truncate
Truncates a file to a new size
Tuples
Tuple support.
TwoDArrayWritable
A Writable for 2D arrays containing a matrix of instances of a class.
UnexpectedServerException
Indicates that the RPC server encountered an undeclared exception from the service
UnionStorageStatistics
A StorageStatistics instance which combines the outputs of several other StorageStatistics instances.
UniqueNames
Generates predictable and user-friendly unique names
UnresolvedLinkException
Thrown when a symbolic link is encountered in a path.
UnsupportedCodecException
Thrown to indicate that the specific codec is not supported.
UnsupportedFileSystemException
File system for a given file system name/scheme is not supported
UnsupportedMultipartUploaderException
MultipartUploader for a given file system name/scheme is not supported.
UploadHandle
Opaque, serializable reference to an uploadId for multipart uploads.
UserGroupInformation
User and group information for Hadoop.
UserGroupInformation.AuthenticationMethod
existing types of authentications' methods
UserGroupInformation.HadoopLoginModule
A login module that looks at the Kerberos, Unix, or Windows principal and adds the corresponding UserName.
UserIdentityProvider
The UserIdentityProvider creates uses the username as the identity.
UserProvider
A KeyProvider factory for UGIs.
UserProvider
A CredentialProvider for UGIs.
UserProvider.Factory
UserProvider.Factory
UTF8
Deprecated.
replaced by Text
UTF8.Comparator
A WritableComparator optimized for UTF8 keys.
UTF8ByteArrayUtils
Utils
Supporting Utility classes used by TFile, and shared by users of TFile.
Utils.Version
A generic Version class.
Validate
A superset of Validate class in Apache commons lang3.
ValueQueue<E>
A Utility class that maintains a Queue of entries for a given key.
ValueQueue.QueueRefiller<E>
QueueRefiller interface a client must implement to use this class
ValueQueue.SyncGenerationPolicy
Policy to decide how many values to return to client when client asks for "n" values and Queue is empty.
VectoredReadUtils
Utility class which implements helper methods used in vectored IO implementation.
VectorIOBufferPool
A ByteBufferPool implementation that uses a pair of functions to allocate and release ByteBuffers; intended for use implementing the VectorIO API as it makes the pair of functions easier to pass around and use in existing code.
Verifier
Base class for verifier.
VerifierGSS
Verifier mapped to RPCSEC_GSS.
VerifierNone
Verifier used by AUTH_NONE.
VersionedProtocol
Superclass of all protocols that use Hadoop RPC.
VersionedWritable
A base class for Writables that provides version checking.
VersionInfo
This class returns build information about Hadoop components.
VersionMismatchException
Thrown by `VersionedWritable.readFields(DataInput)` when the version of an object being read does not match the current implementation version as returned by `VersionedWritable.getVersion()`.
VersionUtil
A wrapper class to maven's ComparableVersion class, to comply with maven's version name string convention
ViewFileSystem
ViewFileSystem (extends the FileSystem interface) implements a client-side mount table.
ViewFileSystem.MountPoint
MountPoint representation built from the configuration.
ViewFileSystemOverloadScheme
This class is extended from the ViewFileSystem for the overloaded scheme file system.
ViewFileSystemOverloadScheme.MountPathInfo<T>
A class to maintain the target file system and a path to pass to the target file system.
ViewFileSystemUtil
Utility APIs for ViewFileSystem.
ViewFs
ViewFs (extends the AbstractFileSystem interface) implements a client-side mount table.
ViewFs.MountPoint
VIntWritable
A WritableComparable for integer values stored in variable-length format.
VLongWritable
A WritableComparable for longs in a variable-length format.
Waitable<T>
Represents an object that you can wait for.
WeakReferencedElasticByteBufferPool
Buffer pool implementation which uses weak references to store buffers in the pool, such that they are garbage collected when there are no references to the buffer during a gc run.
WeakReferenceMap<K,V>
A map of keys type K to objects of type V which uses weak references, so does lot leak memory through long-lived references at the expense of losing references when GC takes place..
WeakReferenceThreadMap<V>
A WeakReferenceMap for threads.
WeakRefMetricsSource
A weak referenced metrics source which avoids hanging on to large objects if somehow they don't get fully closed/cleaned up.
WebServlet
Hadoop DefaultServlet for serving static web content.
WeightedRoundRobinMultiplexer
Determines which queue to start reading from, occasionally drawing from low-priority queues in order to prevent starvation.
WeightedTimeCostProvider
A `CostProvider` that calculates the cost for an operation as a weighted sum of its processing time values (see `ProcessingDetails`).
WhitelistBasedResolver
An implementation of the SaslPropertiesResolver.
WindowsGetSpaceUsed
Class to tell the size of a path on windows.
WithErasureCoding
Filesystems that support EC can implement this interface.
WrappedIO
Reflection-friendly access to APIs which are not available in some of the older Hadoop versions which libraries still compile against.
WrappedIOException
Deprecated.
use the `UncheckedIOException` directly.]
WrappedIOStatistics
Wrap IOStatistics source with another (dynamic) wrapper.
WrappedStatistics
Reflection-friendly access to IOStatistics APIs.
Writable
A serializable object which implements a simple, efficient, serialization protocol, based on `DataInput` and `DataOutput`.
WritableComparable<T>
A `Writable` which is also `Comparable`.
WritableComparator
A Comparator for `WritableComparable`s.
WritableFactories
Factories for non-public writables.
WritableFactory
A factory for a class of Writable.
WritableName
Utility to permit renaming of Writable implementation classes without invalidiating files that contain their class name.
WritableRpcEngine
Deprecated.
WritableRpcEngine.Server
Deprecated.
WritableSerialization
A `Serialization` for `Writable`s that delegates to `Writable.write(java.io.DataOutput)` and `Writable.readFields(java.io.DataInput)`.
WritableUtils
XAttrCodec
The value of `XAttr` is byte[], this class is to covert byte[] to some kind of string representation or convert back.
XAttrSetFlag
XDR
Utility class for building XDR messages based on RFC 4506.
XDR.State
XFrameOptionsFilter
This filter protects webapps from clickjacking attacks that are possible through use of Frames to embed the resources in another application and intercept clicks to accomplish nefarious things.
XMLUtils
General xml utilities.
XORErasureCodec
A XOR erasure codec.
XORErasureDecoder
Xor erasure decoder that decodes a block group.
XORErasureEncoder
Xor erasure encoder that encodes a block group.
XORRawDecoder
A raw decoder in XOR code scheme in pure Java, adapted from HDFS-RAID.
XORRawEncoder
A raw encoder in XOR code scheme in pure Java, adapted from HDFS-RAID.
XORRawErasureCoderFactory
A raw coder factory for raw XOR coder.
ZeroCopyUnavailableException
ZKCuratorManager
Helper class that provides utility methods specific to ZK operations.
ZKCuratorManager.HadoopZookeeperFactory
ZKDelegationTokenSecretManager<TokenIdent extends AbstractDelegationTokenIdentifier>
An implementation of `AbstractDelegationTokenSecretManager` that persists TokenIdentifiers and DelegationKeys in Zookeeper.
ZKFailoverController
ZKFCProtocol
Protocol exposed by the ZKFailoverController, allowing for graceful failover.
ZKFCProtocolClientSideTranslatorPB
ZKFCProtocolPB
ZKFCProtocolServerSideTranslatorPB
ZKFCRpcServer
ZKUtil
Utilities for working with ZooKeeper.
ZKUtil.BadAclFormatException
ZKUtil.BadAuthFormatException
ZKUtil.ZKAuthInfo
An authentication token passed to ZooKeeper.addAuthInfo
ZlibCompressor
A `Compressor` based on the popular zlib compression algorithm.
ZlibCompressor.CompressionHeader
The type of header for compressed data.
ZlibCompressor.CompressionLevel
The compression level for zlib library.
ZlibCompressor.CompressionStrategy
The compression level for zlib library.
ZlibDecompressor
A `Decompressor` based on the popular zlib compression algorithm.
ZlibDecompressor.CompressionHeader
The headers to detect from compressed data.
ZlibDecompressor.ZlibDirectDecompressor
ZlibFactory
A collection of factories to create the right zlib/gzip compressor/decompressor instances.
ZStandardCodec
This class creates zstd compressors/decompressors.
ZStandardCompressor
A `Compressor` based on the zStandard compression algorithm.
ZStandardDecompressor
A `Decompressor` based on the zStandard compression algorithm.
ZStandardDecompressor.ZStandardDirectDecompressor
A `DirectDecompressor` for ZStandard https://github.com/facebook/zstd.