All Classes and Interfaces
Class
Description
Base class for scheduled scanners on a Datanode.
Base class for container scanner metrics.
This class serves as an intermediate format for all possible database
layouts for datanodes.
Implementation of the
DatanodeStore interface that contains
functionality common to all more derived datanode store implementations.Block Iterator for KeyValue Container.
Block localId Iterator for KeyValue Container.
Abstract Interface defining the way to interact with any rocksDB in the datanode.
Abstract class to capture common variables and methods for different types
of replication tasks.
ENUM representing the different status values a replication task can
have.
A class that can be used to schedule an asynchronous check on a given
Checkable.Filter for selecting volumes with enough space for a new container.
Data scanner that full checks a volume.
This class is responsible to perform metadata verification of the
containers.
This class captures the Background Storage Volume Scanner Metrics.
A per-datanode container block deleting service takes in charge
of deleting staled ozone blocks.
Pair of container data and the number of blocks to delete.
Metrics related to Block Deleting Service running on Datanode.
BlockDeletingTask for KeyValueContainer.
Block Iterator for container.
BlockManager is for performing key related operations on the container.
This class is for performing block related operations on the KeyValue
Container.
Utils functions to help block functions.
Volume choosing policy that randomly choose volume with remaining
space to satisfy the size constraints.
Chunk Manager allows read, write, delete and listing of chunks in a container.
Selects ChunkManager implementation to use for each chunk operation.
Implementation of ChunkManager built for running performance tests.
Select an appropriate ChunkManager implementation as per config setting.
Utility methods for chunk operations for KeyValue container.
Asks datanode to close a container.
Handler for close container command received from SCM.
Asks datanode to close a pipeline.
Handler for close pipeline command received from SCM.
Dispatches command to the correct handler.
Helper class to construct command dispatcher.
Command for the datanode with the destination address.
Generic interface for handlers.
This class collects and exposes metrics for CommandHandlerMetrics.
A class that is used to communicate status of datanode commands.
Builder class for CommandStatus.
Publishes CommandStatusReport which will be sent to SCM as part of
heartbeat.
Interface for Container Operations.
container cache is a LRUMap that maintains the DB handles.
Metrics for the usage of ContainerDB.
This class coordinates reading and writing Container checksum information for all containers.
Control plane for container management in datanode.
ContainerCreateInfo is a class that holds information about the state and other information on creation
This class is immutable.
ContainerData is the in-memory representation of container metadata and is
represented on disk by the .container file.
Block byte used, block count and pending deletion count.
Read/write/block statistics of a container.
This class captures the container data scanner metrics on the data-node.
Orders containers:
1. containers not yet scanned first,
2. then least recently scanned first,
3. ties are broken by containerID.
Class for creating and reading .container files.
This interface is used for choosing desired containers for
block deletion.
Abstract class that serves as the template for deletion choosing policy.
This class represents the difference between our replica of a container and a peer's replica of a container.
Represents a block that has been deleted in a peer whose metadata we need to add to our container replica's
merkle tree.
Dispatcher acts as the bridge between the transport layer and
the actual container layer.
Service to download container data from other datanodes.
Imports container from tarball.
A ContainerInspector is tool used to log information about all
containers as they are being processed during datanode startup.
Utility class to manage container inspectors.
Defines layout versions for the Chunks.
Returns physical path locations, where the containers will be created.
Returns physical path locations, where the containers will be created.
Utility class defining methods to write to the datanode container log.
Class to collect metrics related to container merkle tree.
This class constructs a Merkle tree that provides one checksum for all data within a container.
This class captures the container meta-data scanner metrics on the
data-node.
This class is for maintaining the various Storage Container
DataNode statistics and publishing them through the metrics interfaces.
Service to pack/unpack ContainerData container data to/from a single byte
stream.
Class used to read .container files from Volume and build container map.
Contract to prepare provide the container in binary form..
Service to do the real replication task.
Publishes ContainerReport which will be sent to SCM as part of heartbeat.
This class is used to identify any error that may be seen while scanning a container.
Represents the reason a container scan failed and a container should
be marked unhealthy.
Mixin to handle common data and metadata scan operations among background and on-demand scanners.
This class defines configuration parameters for the container scanners.
Class that manages Containers created on the datanode.
A
StateMachine for containers,
which is responsible for handling different types of container requests.Upgrade Action for DataNode for update the table schema data of containerIds Table.
Client-side interface for sending a container to a target datanode.
A mix of helper functions for containers.
Defines compression algorithm for container replication.
Asks datanode to create a pipeline.
Handler for create pipeline command received from SCM.
This class is for maintaining Container State Machine statistics.
Configuration class used for high level datanode configuration parameters.
The class manages DBProfiles for Datanodes.
DBProfile for HDD datanode disks.
DBProfile for SSD datanode disks.
Class for creating datanode.id file in yaml format.
Datanode details bean to be written to the yaml file.
DataNodeStorageConfig is responsible for management of the
StorageDirectories used by the DataNode.
Class contains metrics related to Datanode queues.
This class allows support of the schema version one RocksDB layout for
datanode, where
all data is kept in the same default table.
This class defines the RocksDB structure for datanode following schema
version 3, where the block data, metadata, and transactions which are to be
deleted are put in their own separate column families and with containerID
as key prefix.
This class defines the RocksDB structure for datanodes following schema
version 2, where the block data, metadata, and transactions which are to be
deleted are put in their own separate column families.
Upgrade Action for DataNode for the very first first Upgrade Version.
Upgrade Action for DataNode for SCHEMA V3.
State Interface that allows tasks to maintain states.
State Machine Class.
States that a datanode can be in.
Interface for interacting with datanode databases.
Cache for all per-disk DB handles under schema v3.
Constructs a datanode store in accordance with schema version 1, which
places all data in the default column family.
Constructs a datanode store in accordance with schema version 3, which uses
three column families/tables:
1.
Constructs a datanode store in accordance with schema version 2, which uses
three column families/tables:
1.
Constructs a datanode store in accordance with schema version 2, which uses
three column families/tables:
1.
Wrapper class to represent a table in a datanode RocksDB instance.
UpgradeFinalizer for the DataNode.
This is a utility class which helps to create the version file on datanode
and also validate the content of the version file.
Represents the result of a container data scan.
DB handle abstract class.
Interface for interacting with datanode databases.
DbVolume represents a volume in datanode holding db instances
for multiple HddsVolumes.
Builder class for DbVolume.
A factory class for DbVolume.
Command status to report about block deletion.
Builder for DeleteBlockCommandStatus.
A SCM command asks a datanode to delete a number of blocks.
Handle block deletion commands.
This class represents the result of executing a delete block transaction.
A delete command info.
The SchemaHandler interface provides a contract for handling
KeyValueContainerData and DeletedBlocksTransaction based
on different schema versions.
SCM command which tells the datanode to delete a container.
Handler to process the DeleteContainerCommand from SCM.
A helper class to wrap the info about under deletion container blocks.
Store interface for DeleteTransaction table.
Streaming binaries to single directory.
Streaming files from single directory.
Protocol definition from streaming binary files.
Protocol definition of the streaming.
Utility class that supports checking disk health when provided a directory
where the disk is mounted.
Defines operations that must be implemented by a class injecting
failures into this class.
DispatcherContext class holds transport protocol specific context info
required for execution of container commands over the container dispatcher.
Builder class for building DispatcherContext.
Operation types.
Determines which stage of writeChunk a write chunk request is for.
Enum to define Audit Action types for Datanode.
This class wraps necessary container-level rpc calls for container reconciliation
This is the JMX management interface for DN information.
This is the JMX management class for DN information.
Default replication implementation.
This class wraps necessary container-level rpc calls
during ec offline reconstruction
This class is to keep the required EC reconstruction info.
The Coordinator implements the main flow of reconstructing
missing container replicas.
This is the actual EC reconstruction coordination task.
Metrics class for EC Reconstruction.
Endpoint is used as holder class that keeps state around the RPC endpoint.
States that an Endpoint can be in.
JMX representation of an EndpointStateMachine.
Helper class to use it to replace original Ratis GRPC outgoing calls.
This class is for performing chunk related operations.
This class is for performing chunk related operations.
Asks DataNode to Finalize new upgrade version.
Handler for FinalizeNewLayoutVersion command received from SCM.
Uploads container to target datanode via gRPC.
Observes gRPC response for SendContainer request, notifies callback on
completion/error.
this class wrap the request stream observer and handle error
reported by ratis to response handler.
Client to read container data from gRPC.
gRPC stream observer to CompletableFuture adapter.
Service to make containers available for replication.
Grpc Service for handling Container Commands on datanode.
Dispatcher sends ContainerCommandRequests to Handler.
The RPC server that listens to requests from clients.
Simple http server to provide basic monitoring for hdds datanode.
Datanode service plugin to start the HDDS container services.
Interface which declares a method to stop HddsDatanodeService.
Ozone Container dispatcher takes a call from the netty server and routes it
to the right handler function.
PolicyProvider for Datanode protocols.HddsVolume represents volume in a datanode.
Builder for HddsVolume.
A factory class for HddsVolume.
Layout version which describes information about the layout version
on the datanode volume.
A util class for
HddsVolume.Heartbeat class for SCMs.
Builder class for HeartbeatEndpointTask.
Fixed list of volumes.
IncrementalReportSender is an interface to send ICRs.
Init Datanode State is the task that gets run when we are in Init State.
Class to perform KeyValue Container operations.
Class to run integrity checks on Datanode Containers.
This class represents the KeyValueContainer metadata, which is the
in-memory representation of container metadata and is represented on disk
by the .container file.
Class which provides utility methods for container locations.
Container inspector for key value container metadata.
The mode to run the inspector in.
Class which defines utility methods for KeyValueContainer.
Handler for KeyValue Container type.
This class is used to get the DataChannel for streaming.
A Manager who manages the mapped buffers to under a predefined total count, also support reuse mapped buffers.
ContainerReplicator wrapper with additional metrics.
Represents the result of a container metadata scan.
MetadataVolume represents a volume in datanode for metadata(ratis).
Builder class for MetadataVolume.
A factory class for MetadataVolume.
VolumeSet to manage volumes in a DataNode.
Publishes NodeReport which will be sent to SCM as part of heartbeat.
A naive implementation of the replication source which creates a tar file
on-demand without pre-create the compressed archives.
Class for performing on demand scans of containers.
This class captures the on-demand container data scanner metrics.
Map: containerId -> (localId ->
BlockData).Ozone main class sets up the network servers and initializes the container
layer.
Publishes Pipeline which will be sent to SCM as part of heartbeat.
Pushes the container to the target datanode.
Randomly choosing containers for block deletion.
Holds configuration items for Ratis/Raft server.
Just a wrapper for DatanodeStore.
Asks datanodes to reconcile the specified container with other container replicas.
Handles commands from SCM to reconcile a container replica on this datanode with the replicas on its peers.
Used to execute a container reconciliation task that has been queued from the ReplicationSupervisor.
The protocol spoken between datanodes and Recon.
Protocol used from a datanode to Recon.
SCM command to request reconstruction of EC containers.
To store the datanode details with replica index.
Command handler for reconstructing the lost EC containers.
Class to implement reference counting over instances handed by Container
Cache.
Asks datanode to refresh disk usage info immediately.
Command handler to refresh usage info of all volumes.
Response to Datanode Register call.
A builder class to verify all values are sane.
Register a datanode with SCM.
Builder class for RegisterEndPoint task.
SCM command to request replication of a container.
Command handler to copy containers from sources.
Separated network server for server2server container replication.
Replication-related configuration.
Single point to schedule the downloading tasks based on priorities.
Builder for
ReplicationSupervisor.Metrics source to report number of replication tasks.
The task to download a container from the sources.
ReportManager is responsible for managing all the
ReportPublisher
and also provides ScheduledExecutorService to ReportPublisher
which should be used for scheduling the reports.Builder to construct
ReportManager.Abstract class responsible for scheduling the reports based on the
configured interval.
Factory class to construct
ReportPublisher for a report.Informs a datanode to register itself with SCM again.
Choose volumes in round-robin order.
Class that implements handshake with SCM.
Encapsulates the result of a container scan.
Codec for parsing
ContainerProtos.ChunkInfoList
objects from data
that may have been written using schema version one.For RocksDB instances written using DB schema version 1, all data is
stored in the default column family.
Containers written using schema version 1 wrote unprefixed block ID keys
as longs, and metadata or prefixed block IDs as Strings.
A class that acts as the base class to convert between Java and SCM
commands in protobuf format.
SCMConnectionManager - Acts as a class that manages the membership
information of the SCMs that we are working with.
JMX information about the connected SCM servers.
Action to run upgrade flow for SCM HA exactly once.
A command used to persist the current node operational state on the datanode.
Handle the SetNodeOperationalStateCommand sent from SCM to the datanode
to persist the current operational state.
Simple ContainerDownloaderImplementation to download the missing container
from the first available datanode.
A per-datanode container stale recovering container scrubbing service
takes in charge of deleting stale recovering containers.
Current Context of State Machine.
The protocol spoken between datanodes and SCM.
This class is the client-side translator to translate the requests made on
the
StorageContainerDatanodeProtocol interface to the RPC server
implementing StorageContainerDatanodeProtocolPB.Protocol used from a datanode to StorageContainerManager.
This class is the server-side translator that forwards requests received on
StorageContainerDatanodeProtocolPB to the StorageContainerDatanodeProtocol server implementation.The protocol spoken between datanodes and SCM.
Storage location stats of datanodes that provide back store for containers.
Builder class for building StorageLocationReport.
Contract to define properties available on the JMX interface.
StorageVolume represents a generic Volume in datanode, could be
1.
Builder class for StorageVolume.
VolumeState represents the different states a StorageVolume can be in.
Type for StorageVolume.
A class that encapsulates running disk checks against each volume and
allows retrieving a list of failed volumes.
A callback interface that is supplied the result of running an
async disk check on multiple volumes.
A factory class for StorageVolume.
A util class for
StorageVolume.Client to stream huge binaries from a streamling server.
Interface defines the mapping to the destination.
Runtime exception for any streaming related errors.
Netty based streaming server to replicate files from a directory.
Interface to define which files should be replicated for a given id.
Compress/uncompress KeyValueContainer data to a tar archive.
An implementation of
AsyncChecker that skips checking recently
checked objects.Wraps block and container token managers for datanode.
TopN Ordered choosing policy that choosing containers based on pending
deletion blocks' number.
Util methods for upgrade.
Utility class to retrieve the version of a feature that corresponds to the
metadata layout version specified by the provided
HDDSLayoutVersionManager.Utilities for container Schema V2 layout feature.
Utilities for container Schema V3 layout feature.
Utilities for SCM HA layout feature.
Task that returns version.
This is a class that tracks versions of SCM.
Version response class.
Builder class.
This interface specifies the policy for choosing volumes to store replicas.
A factory to create volume choosing policy instance based on configuration
property
HddsConfigKeys.HDDS_DATANODE_VOLUME_CHOOSING_POLICY.This class is used to track Volume Health metrics for all volumes on a datanode.
This class is used to track Volume Info stats for each HDDS Volume.
This class is used to track Volume IO stats for each HDDS Volume.
Set of volumes.
Stores information about a disk/volume.
Class for defining the schema for master volume in a datanode.
Interface for interacting with database in the master volume of a datanode.
Class for interacting with database in the master volume of a datanode.
this will hold old version tables required during upgrade, and these are initialized based on version only.
Creates a Grpc server endpoint that acts as the communication layer for
Ozone containers.
Creates a ratis server endpoint that acts as the communication layer for
Ozone containers.
A server endpoint that acts as the communication layer for Ozone containers.