All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| AbortMigration |
|
| AbstractAsyncFuture<T> |
Created by acurtis on 5/1/18.
|
| AbstractAvroChunkingAdapter<T> |
Read compute and write compute chunking adapter
|
| AbstractAvroComputeRequestBuilder<K> |
This abstract class contains all the common field and APIs for compute request builder;
for each new compute request version, there will be a new builder class that extends
this class and the new builder will include customized fields and APIs.
|
| AbstractAvroRecordReader<INPUT_KEY,INPUT_VALUE> |
An abstraction for a record reader that reads records from input into Avro-serialized keys and values.
|
| AbstractAvroStoreClient<K,V> |
|
| AbstractClientRoutingStrategy |
|
| AbstractCoalescingBufferQueue10294 |
Forked from Netty's AbstractCoalescingBufferQueue (4.1.42)
Includes fix to guard readableBytes from re-entry.
|
| AbstractDataWriterSparkJob |
|
| AbstractDataWriterTask |
|
| AbstractHttp2StreamFrameCodec |
A copy of the netty Http2StreamFrameToHttpObjectCodec except with the
methods which actually return the converted objects have been made abstract.
|
| AbstractInputRecordProcessor<INPUT_KEY,INPUT_VALUE> |
An abstraction of the task that processes each record from the input, and returns serialized, and potentially
compressed, Avro key/value pairs.
|
| AbstractKafkaConsumerService |
|
| AbstractPartitionStateModel |
An abstraction of Helix State model behavior registry that defines how participants
(Storage node) fetch data from Kafka.
|
| AbstractPartitionWriter |
An abstraction of the task that processes all key/value pairs, checks for duplicates and emits the final key/value
pairs to Venice's PubSub.
|
| AbstractPartitionWriter.DuplicateKeyPrinter |
Using Avro Json encoder to print duplicate keys
in case there are tons of duplicate keys, only print first AbstractPartitionWriter.DuplicateKeyPrinter.MAX_NUM_OF_LOG
of them so that it won't pollute Reducer's log.
|
| AbstractPartitionWriter.VeniceWriterMessage |
|
| AbstractPollStrategy |
A base class which encapsulates the common plumbing needed by all PollStrategy implementations. |
| AbstractPushMonitor |
|
| AbstractQOS |
Created by acurtis on 7/27/17.
|
| AbstractQOSBasedQueue<T extends QOSBasedRequestRunnable> |
Abstract base class for QOS priority queues.
|
| AbstractQuantileEstimation<SAMPLE extends AbstractQuantileEstimation.AbstractSample<SAMPLE>> |
A memory efficient abstract implementation for calculating quantile summaries.
|
| AbstractQuantileEstimation.AbstractSample<SAMPLE extends AbstractQuantileEstimation.AbstractSample<SAMPLE>> |
|
| AbstractQuantileEstimation.Quantile |
|
| AbstractQuantileEstimation.Quantiles |
|
| AbstractReadResponse |
This class is used to store common fields shared by various read responses.
|
| AbstractReadResponseStats |
This abstract class is the container for response stats.
|
| AbstractRecordStreamDecoder<ENVELOPE,K,V> |
Streaming callback for batch-get/compute.
|
| AbstractRoute |
|
| AbstractSchemaEntrySerializer<T extends GeneratedSchemaEntry> |
|
| AbstractShutdownableResource<R> |
|
| AbstractStateModelFactory |
ModelFactory manages Helix state model creation.
|
| AbstractStorageEngine<Partition extends AbstractStoragePartition> |
A base storage abstract class which is actually responsible for data persistence.
|
| AbstractStorageEngine.StoragePartitionAdjustmentTrigger |
|
| AbstractStorageIterator |
|
| AbstractStoragePartition |
An abstract implementation of a storage partition.
|
| AbstractStore |
This is an abstraction of metadata maintained per Store.
|
| AbstractStore.StoreVersionSupplier |
|
| AbstractStoreAclHandler<REQUEST_TYPE> |
Store-level access control handler, which is being used by both Router and Server.
|
| AbstractStoreBufferService |
Abstract class capturing the responsibilities of drainers threads doing store ingestion.
|
| AbstractStoreMetadata |
|
| AbstractVeniceAggStats<T extends AbstractVeniceStats> |
|
| AbstractVeniceAggStoreStats<T extends AbstractVeniceStats> |
This class is an aggregate place that keeps stats objects for multiple stores.
|
| AbstractVeniceAggVersionedStats<STATS,STATS_REPORTER extends AbstractVeniceStatsReporter<STATS>> |
|
| AbstractVeniceFilter<INPUT_VALUE> |
An abstraction to filter given data type.
|
| AbstractVeniceHttpStats |
|
| AbstractVeniceMapper<INPUT_KEY,INPUT_VALUE> |
An abstraction of the mapper that would return serialized, and potentially
compressed, Avro key/value pairs.
|
| AbstractVeniceProducer<K,V> |
|
| AbstractVeniceRecordReader<INPUT_KEY,INPUT_VALUE> |
An abstraction for a record reader that reads records from the configured input into Avro-serialized keys and values.
|
| AbstractVeniceService |
Blueprint for all Services initiated from Venice Server
|
| AbstractVeniceService.ServiceState |
|
| AbstractVeniceStats |
|
| AbstractVeniceStatsReporter<STATS> |
|
| AbstractVeniceWriter<K,V,U> |
A base class which users of VeniceWriter can leverage in order to
make unit tests easier. |
| AbstractVsonSchemaAdapter<T> |
Deprecated. |
| AccessController |
An AccessController allows a request to be checked against an Access Control List (ACL).
|
| AccessResult |
|
| AceEntry |
Represents an Access Control Entry.
|
| AclBinding |
Represents an Access Control Binding.
|
| AclCreationDeletionListener |
Update access controller resource list when a store is created/deleted
|
| AclException |
|
| AclResponse |
|
| ActiveActiveProducerCallback |
|
| ActiveActiveStoreIngestionTask |
This class contains logic that SNs must perform if a store-version is running in Active/Active mode.
|
| ActiveStreamsCountHandler |
Counts the number of the active HTTP/2 Streams
|
| AddVersion |
|
| AdHash |
This class AdHash is used to keep track of the checksum of the data incrementally.
|
| Adler32CheckSum |
Running checksum implementations based on Adler32.
|
| Admin |
|
| Admin.OfflinePushStatusInfo |
|
| AdminCommandExecution |
The execution object is a kind of context for a admin command including essential information used to track the
status of this command.
|
| AdminCommandExecutionResponse |
|
| AdminCommandExecutionRoutes |
|
| AdminCommandExecutionStatus |
|
| AdminCommandExecutionTracker |
This class is used to track the execution of the async admin command.
|
| AdminConsumerService |
One consumer service for one cluster.
|
| AdminConsumptionStats |
|
| AdminConsumptionTask |
This class is used to create a task, which will consume the admin messages from the special admin topics.
|
| AdminExecutionTask |
This class is used to create Callable that execute AdminOperations for a given store. |
| AdminMessageType |
|
| AdminOperation |
|
| AdminOperationSerializer |
|
| AdminOperationsHandler |
|
| AdminOperationsStats |
|
| AdminOperationWrapper |
|
| AdminRequest |
AdminRequest encapsulates an admin request from server admin tools.
|
| AdminResponse |
This class stores all the information required for answering a server admin request.
|
| AdminResponseRecord |
Response record for admin request, version 1
|
| AdminSparkServer |
Controller admin API leveraging sparkjava: http://sparkjava.com/documentation.html
|
| AdminTool |
|
| AdminTool.PrintFunction |
|
| AdminTopicMetadataAccessor |
|
| AdminTopicMetadataResponse |
|
| AdminTopicMetadataRoutes |
|
| AdminTopicUtils |
|
| AggHostHealthStats |
|
| AggHostLevelIngestionStats |
|
| AggKafkaConsumerService |
|
| AggKafkaConsumerServiceStats |
This class is an aggregate place that keeps stats objects for multiple stores and total stats for each region for
AggKafkaConsumerService.
|
| AggPartitionHealthStats |
Monitor the change of Helix's external view and warn in case that any partition is unhealthy.
|
| AggPushHealthStats |
|
| AggPushStatusCleanUpStats |
|
| AggregatedHealthStatusRequest |
|
| AggRocksDBStats |
Right now, Venice SN only reports aggregated metrics for RocksDB.
|
| AggRouterHttpRequestStats |
|
| AggServerHttpRequestStats |
AggServerHttpRequestStats is the aggregate statistics for ServerHttpRequestStats corresponding to
the type of requests defined in RequestType. |
| AggServerQuotaUsageStats |
AggServerQuotaUsageStats is the aggregate statistics for ServerQuotaUsageStats which
measures requests and quota rejections of each store.
|
| AggStoreStats |
|
| AggVersionedDIVStats |
|
| AggVersionedIngestionStats |
The store level stats or the total stats will be unpopulated because there is no easy and reliable way to aggregate
gauge stats such as rt topic offset lag.
|
| AggVersionedStorageEngineStats |
|
| AllowlistAccessor |
Interface defines the ways to access to the allowlist of Helix NodeId.
|
| AndPredicate |
|
| ApacheHttpAsyncStorageNodeClient |
|
| ApacheKafkaAdminAdapter |
|
| ApacheKafkaAdminAdapterFactory |
|
| ApacheKafkaAdminConfig |
|
| ApacheKafkaConsumerAdapter |
This class is not thread safe because of the internal KafkaConsumer is not thread safe.
|
| ApacheKafkaConsumerAdapterFactory |
|
| ApacheKafkaConsumerConfig |
Configuration for Apache Kafka consumer.
|
| ApacheKafkaOffsetPosition |
Offset position for Apache Kafka topics
|
| ApacheKafkaProducerAdapter |
|
| ApacheKafkaProducerAdapterFactory |
|
| ApacheKafkaProducerCallback |
|
| ApacheKafkaProducerConfig |
This class holds all properties used to construct ApacheKafkaProducerAdapter
(This class could be refactored to hold consumer properties as well). |
| ApacheKafkaProduceResult |
|
| ApacheKafkaUtils |
|
| AppTimeOutTrackingCompletableFuture<T> |
CompletableFuture implementation, which is able to track the timeout behavior when happening.
|
| ArbitraryOrderingPollStrategy |
A PollStrategy implementation which delivers messages in the order specified
at construction time. |
| Arg |
|
| ArrayBackedNullSkippingIterator<E> |
This iterator traverses the entire backing array, while skipping over null entries.
|
| ArrayCollection<E> |
Expose an array of ArrayCollection as an immutable Collection
Changes to the array are reflected in the collection. |
| ArrayMap<K,V> |
Simple ArrayList backed Map implementation which uses simple linear scans of the
list for searching for matching keys.
|
| ArraySortedSet<E> |
A thread-safe SortedSet implementation which uses an array as a backing store.
|
| ArrayUtils |
|
| AsciiStringURLCodec |
|
| AsyncFullHttpRequestHandler |
|
| AsyncFullHttpRequestHandler.RequestHandler |
|
| AsyncFuture<T> |
A Future which has very netty-style semantics where AsyncFutureListener can
be added to the future to be executed upon condition of Success or Failure has been satisfied. |
| AsyncFuture.Status |
|
| AsyncFutureListener<T> |
An interface (lambda) which is fired upon completion of an AsyncFuture. |
| AsyncPartitionFinder<K> |
Created by acurtis on 1/26/18.
|
| AsyncPool<T> |
|
| AsyncPool.LifeCycle<T> |
|
| AsyncPoolImpl<T> |
|
| AsyncPoolImpl.ShutdownException |
|
| AsyncPoolImpl.TooManyWaitersException |
|
| AsyncPromise<T> |
|
| AsyncQOSPool<T> |
|
| AsyncQOSPoolImpl<T> |
|
| AsyncRetryingServiceDiscoveryAnnouncer |
This class is responsible for announcing and de-announcing a ServiceDiscoveryAnnouncer to a Service Discovery system
and taking care of failed registrations by retrying them asynchronously. |
| AuditInfo |
|
| AuthorizerService |
|
| AutoCloseableLock |
Concrete implementations are expected to lock their inner lock(s) in their own constructor.
|
| AutoCloseableMultiLock |
|
| AutoCloseableSingleLock |
|
| AvroBlackHoleResponseStoreClientImpl<K,V> |
This class should be used for experiments only.
|
| AvroCollectionElementComparator |
This comparator is used to compare GenericRecord collection field elements which must have schemas.
|
| AvroCompatibilityUtils |
|
| AvroComputeRequestBuilderV3<K> |
|
| AvroComputeRequestBuilderV4<K> |
|
| AvroGenericDaVinciClient<K,V> |
|
| AvroGenericDeserializer<V> |
|
| AvroGenericDeserializer.IterableImpl |
Deprecated. |
| AvroGenericReadComputeStoreClient<K,V> |
Venice avro generic client to provide read compute operations.
|
| AvroGenericStoreClient<K,V> |
Venice avro generic client to communicate with Venice backend for key-value lookup.
|
| AvroGenericStoreClientImpl<K,V> |
|
| AvroProtocolDefinition |
This enum lays out the basic specs of the various stateful protocols used in Venice.
|
| AvroRecordUtils |
|
| AvroSchemaParseUtils |
|
| AvroSchemaUtils |
|
| AvroSerializer<K> |
AvroSerializer provides the functionality to serialize objects by using Avro.
|
| AvroSpecificDaVinciClient<K,V extends org.apache.avro.specific.SpecificRecord> |
|
| AvroSpecificDeserializer<T extends org.apache.avro.specific.SpecificRecord> |
|
| AvroSpecificStoreClient<K,V extends org.apache.avro.specific.SpecificRecord> |
AvroSpecificStoreClient for type safety purpose.
|
| AvroSpecificStoreClientImpl<K,V extends org.apache.avro.specific.SpecificRecord> |
|
| AvroSpecificStoreDeserializerCache<V extends org.apache.avro.specific.SpecificRecord> |
|
| AvroStoreDeserializerCache<T> |
Container for the deserializers of a single store.
|
| AvroSupersetSchemaUtils |
|
| BackgroundChannelHandler |
Created by acurtis on 5/4/17.
|
| BackupStrategy |
Enums of the strategies used to backup older store versions in Venice.
|
| BackupVersionOptimizationService |
This class is used to periodically scan inactive store versions and perform optimization if the inactive period
of some store version meets the pre-configured threshold, this class will trigger the database reopen action to
unload unnecessary RAM usage, which was built up when there were active reads coming.
|
| BackupVersionOptimizationServiceStats |
BackupVersionOptimizationServiceStats record the statistics for the database optimization done by the
BackupVersionOptimizationService including both successes and failures. |
| BadHttpRequest |
Created by acurtis on 9/28/17.
|
| BasicClientStats |
This class offers very basic metrics for client, and right now, it is directly used by DaVinci.
|
| BasicConsumerStats |
|
| BasicDnsResolver |
A simple asynchronous resolver which uses the default JVM blocking resolver.
|
| BasicFullHttpMultiPart |
Created by acurtis on 3/22/17.
|
| BasicFullHttpMultiPartRequest |
Created by acurtis on 3/27/17.
|
| BasicFullHttpRequest |
|
| BasicFullHttpResponse |
Created by acurtis on 4/19/17.
|
| BasicHeaders |
|
| BasicHttpClientCodec |
|
| BasicHttpContentEncoder |
A replacement for the Netty HttpContentEncoder which can handle use in client and server pipelines.
|
| BasicHttpMultiPart |
Created by acurtis on 3/22/17.
|
| BasicHttpNonMultiPartAggregator |
Created by acurtis on 3/24/17.
|
| BasicHttpObjectAggregator |
|
| BasicHttpObjectDecoder |
|
| BasicHttpObjectDecoder.State |
|
| BasicHttpRequest |
|
| BasicHttpRequestDecoder |
|
| BasicHttpResponse |
Created by acurtis on 3/23/17.
|
| BasicHttpResponseDecoder |
Decodes ByteBufs into HttpResponses and
HttpContents.
|
| BasicHttpServerCodec |
|
| BasicHttpServerCodec.ResponseOutOfSequence |
|
| BasicRequest |
|
| BasicServerChannelInitializer<C extends io.netty.channel.Channel,FACTORY extends BasicServerChannelInitializer<C,FACTORY>> |
|
| BatchConflictResolutionPolicy |
|
| BatchDeserializer<E,K,V> |
This API controls the behavior of the user payload deserialization phase of the
batch get response handling.
|
| BatchDeserializerType |
This enum controls the behavior of the user payload deserialization phase of the batch get response handling.
|
| BatchGetChunkingAdapter |
Batch get chunking adapter
|
| BatchGetRequestContext<K,V> |
Keep track of the progress of a batch get request .
|
| BatchJobHeartbeatConfigs |
|
| BatchJobHeartbeatKey |
Key part of the heartbeat sent by a push job.
|
| BatchJobHeartbeatValue |
Value part of the heartbeat sent by a push job
|
| BiIntFunction<R> |
|
| BiIntKeyCache<E> |
Read-through cache for items retrievable by two positive integer IDs.
|
| BinaryResponse |
|
| BlackHoleDeserializer<E,K,V> |
|
| BlackHoleStorageEngine |
|
| BlackHoleStorageEngineFactory |
|
| BlackHoleStorageEnginePartition |
|
| BlobFinder |
|
| BlobPeersDiscoveryResponse |
|
| BlobSnapshotManager |
This class will manage the snapshot creation, for batch store and hybrid store.
|
| BlobTransferManager<T> |
A BlobTransferManager is responsible for transferring blobs between two entities, either that Peer to Peer or node to
a blob store and vice versa.
|
| BlobTransferNettyChannelInitializer |
|
| BlobTransferPartitionMetadata |
This class is the metadata of a partition in the blob transfer client
|
| BlobTransferPayload |
POJO to hold the payload for blob transfer related informartion
|
| BlobTransferUtil |
|
| BlobTransferUtils |
|
| BlobTransferUtils.BlobTransferType |
|
| BlockingDaVinciRecordTransformer<K,V,O> |
|
| BlockingDeserializer<E,K,V> |
|
| BlockingLatch |
Created by acurtis on 10/16/17.
|
| BlockingObserverPollStrategy |
This PollStrategy delegates polling to another implementation, and also executes
an arbitrary function during each poll. |
| BlockingQueueType |
|
| BootstrappingVeniceChangelogConsumer<K,V> |
This interface is meant for users where local state must be built off of the entirety of a venice data set
(i.e.
|
| BoundedHashMap<K,V> |
A map implementation with a bounded size.
|
| BroadcastScatterGatherRequest<H,K> |
This type of specialized ScatterGatherRequest does not use keys for routing, and carry some extra state. |
| BufferReplayPolicy |
Enums of the policies used to decide how buffer replay start timestamps are calculated.
|
| ByteArray |
|
| ByteArrayKey |
A low overhead immutable container of byte[] suitable for use as a map key.
|
| ByteBufAsciiString |
A string implementation, similar to AsciiString, which is backed by a ByteBuf
instead of a byte[] array.
|
| ByteBufferOptimizedBinaryDecoder |
This class is a wrapper of BinaryDecoder with the following optimization:
When deserializing byte array field, instead of copying the bytes into a new ByteBuffer,
this class will create a ByteBuffer, which is wrapping the original array.
|
| ByteBufferToHexFormatJsonEncoder |
This class overrides JsonEncoder.writeBytes(byte[], int, int), in order to convert
all bytes schema data to hexadecimal strings in the output stream, since hexadecimal strings
are more readable.
|
| ByteBufferValueRecord<T> |
This class encapsulates a value from venice storage accompanied by the schema
id that was used to serialize the value.
|
| BytesStreamingCallback |
|
| ByteUtils |
Utility functions for munging on bytes
N.B.: Most functions taken from Voldemort's ByteUtils class.
|
| CachedDnsResolver |
CachedDnsResolver caches the dns entries for hosts, which matches the specified host pattern. |
| CachedReadOnlyStoreRepository |
|
| CachedResourceZkStateListener |
Listener used to monitor zk connection state change and refresh venice resource once zk connection is reconnected.
|
| CachingDaVinciClientFactory |
|
| CachingDaVinciClientFactory.DaVinciClientConstructor |
|
| CachingVeniceStoreClientFactory |
|
| CaffeineVeniceStoreCache |
|
| CallCompletion |
|
| CallTracker |
|
| CallTracker.CallStats |
|
| CallTrackerImpl |
Tracker for "load average" of a call.
|
| CallTrackerImpl.Mode |
|
| CancelledAsyncFuture<T> |
|
| ChainedCompletableFuture<I,O> |
A utility class to chain two completable futures together.
|
| ChangeCaptureView |
|
| ChangeCaptureViewWriter |
|
| ChangeEvent<T> |
|
| ChangelogClientConfig<T extends org.apache.avro.specific.SpecificRecord> |
|
| ChannelInitializer<C extends io.netty.channel.Channel> |
A special ChannelInboundHandler which offers an easy way to initialize a Channel once it was
registered to its EventLoop.
|
| ChannelPoolFactory |
|
| ChannelPoolManager |
The interface which describes the public methods of a channel pool manager.
|
| ChannelPoolManagerImpl |
|
| ChannelPoolResolver |
A simple interface for an asynchronous InetSocketAddress resolver.
|
| ChannelPoolWithStats |
A simple interface which extends ChannelPool to expose various stats.
|
| ChannelTaskSerializer |
|
| CheckPointProperties |
|
| CheckSum |
Parent class for various running checksum implementations.
|
| CheckSumType |
Types of checksum algorithms supported by Venice's Data Ingest Validation.
|
| ChildAwareResponse |
|
| ChunkAssembler |
|
| ChunkAssembler |
This class accumulates all mapper values and assemble them to provide assembled complete large values or regular
message.
|
| ChunkAssembler.ValueBytesAndSchemaId |
|
| ChunkAwareCallback |
|
| ChunkedHttpResponse |
|
| ChunkedKeySuffix |
This record is appended to the end of keys in a store-version where chunking is enabled.
|
| ChunkedKeySuffixSerializer |
|
| ChunkedPayloadAndManifest |
This class contains both chunked results and manifest for a specific payload.
|
| ChunkedResponseHandler |
|
| ChunkedValueInputStream |
This InputStream implementation allows us to pass a value made up of many chunks into the Avro decoder
without stitching it up into a single big byte array.
|
| ChunkedValueManifest |
This record maintains chunking information in order to re-assemble a value that was split in many chunks.
|
| ChunkedValueManifestContainer |
|
| ChunkedValueManifestSerializer |
|
| ChunkId |
This record contains chunking information to uniquely identify each chunk.
|
| ChunkingAdapter<CHUNKS_CONTAINER,VALUE> |
This interface allows each code path which needs to interact with chunked values
to optimize the way the re-assembly is handled so that the final form in which
the is consumed is generated as efficiently as possible, via the
use of a temporary ChunkingAdapter. |
| ChunkingTestUtils |
|
| ChunkingUtils |
This class and the rest of this package encapsulate the complexity of assembling chunked values
from the storage engine.
|
| ChunkKeyValueTransformer |
This interface provides methods to split a key into raw key/value byte array and ChunkedKeySuffix. |
| ChunkKeyValueTransformer.KeyType |
|
| ChunkKeyValueTransformerImpl |
|
| ClassSizeEstimator |
|
| ClassUtil |
Utilities for Classes / reflection.
|
| CLIArgument |
Annotation for a command line option with an argument, like "--file ".
|
| CLIArgumentParser<T> |
Utility class to handle typical command line argument parsing and log initialization.
|
| ClientComputeRecordStreamDecoder<K,V> |
|
| ClientComputeRecordStreamDecoder.Callback<K,V> |
|
| ClientConfig<T extends org.apache.avro.specific.SpecificRecord> |
|
| ClientConfig<K,V,T extends org.apache.avro.specific.SpecificRecord> |
|
| ClientConfig.ClientConfigBuilder<K,V,T extends org.apache.avro.specific.SpecificRecord> |
|
| ClientFactory |
|
| ClientFactory |
|
| ClientFactoryTestUtils |
|
| ClientRoutingStrategy |
|
| ClientRoutingStrategyType |
Different routing strategy types for client side routing:
1.
|
| ClientStats |
|
| ClientTestUtils |
|
| ClientTestUtils.FastClientHTTPVariant |
|
| CLIFlag |
Annotation for a boolean command line option without an argument, like "--exit-on-error".
|
| CLIFooter |
Annotation for text to display as the footer of the "--help" output.
|
| CLIHeader |
Annotation for text to display as the header of the "--help" output.
|
| CLIParser<T> |
|
| CLIUnknown |
Annotation for a String[] property which will receive all the command line elements which were not processed
by the command line parser.
|
| CloseableThreadLocal<T extends java.lang.AutoCloseable> |
A wrapper of ThreadLocal for AutoCloseable objects.
|
| ClusterDiscovery |
|
| ClusterInfoProvider |
|
| ClusterLeaderInitializationManager |
Takes care of executing each routine once per cluster.
|
| ClusterLeaderInitializationRoutine |
This class encapsulates business logic which needs to be executed once per cluster the
first time a controller becomes leader of that cluster.
|
| ClusterLockManager |
A centralized place to control the locking behavior, such as lock order and lock granularity.
|
| ClusterRoutes |
|
| ClusterRouteStats |
|
| ClusterRouteStats.RouteStats |
Per-route request metrics.
|
| ClusterStaleDataAuditResponse |
|
| ClusterStats |
This class includes the metrics in the cluster-level.
|
| CollectionFieldOperationHandler |
This class handles all operations on a collection field with replication metadata.
|
| CollectionRmdTimestamp<DELETED_ELEMENT_TYPE> |
This class centralizes the logic of creating a collection replication metadata schema and providing a POJO representation
upon a collection replication metadata generic record.
|
| CollectionTimestampMergeRecordHelper |
This class handles merges with replication metadata with collection metadata timestamp CollectionRmdTimestamp
for collection field. |
| CollectionUtil |
|
| CollectionUtil.ListBuilder<T> |
|
| CollectionUtil.MapBuilder<K,V> |
|
| CollectionUtil.SetBuilder<T> |
|
| CollectionUtils |
|
| Command |
|
| Command |
|
| Command.Params |
|
| Command.Result |
|
| CommonConfigKeys |
Common config keys shared by venice-backend and venice-thin-client.
|
| CompactHeaderHandler |
Handler for compacting Espresso headers to a single header entry.
|
| ComplementSet<T> |
A set that uses complement representation, which is useful when universal set cardinality is unknown.
|
| CompletableFutureCallback |
Compose a CompletableFuture and Callback together to be a CompletableFutureCallback type.
|
| CompletableFutureTask<V> |
Created by acurtis on 4/4/17.
|
| ComplexAccumulator<T,A,R> |
One or more variables that together maintain an accumulation.
|
| CompositePollStrategy |
A PollStrategy implementation which takes a queue of many poll strategies. |
| CompressionStrategy |
Enums of the strategies used to compress/decompress Record's value
|
| CompressionUtils |
|
| CompressorFactory |
|
| CompressOutputStream |
BackupOutputStream encapsulates an GZip compressor and provides methods
to allow other threads to wait upon the completion of the file.
|
| ComputeGenericRecord |
A simple wrapper to throw exception when retrieving failed computation.
|
| ComputeJob |
An interface to abstract executing and monitoring a compute job running on any batch compute engine
|
| ComputeJob.Status |
|
| ComputeOperation |
|
| ComputeOperationType |
|
| ComputeRecordStreamDecoder<K,V> |
|
| ComputeRequest |
This record only contains the operations and result schema, and keys will be appended after during serialization
|
| ComputeRequestBuilder<K> |
|
| ComputeRequestContext<K,V> |
Keep track of the progress of a compute request .
|
| ComputeRequestV1 |
This record only contains the operations and result schema, and keys will be appended after during serialization
|
| ComputeRequestV2 |
This record only contains the operations and result schema, and keys will be appended after during serialization
|
| ComputeRequestV3 |
This record only contains the operations and result schema, and keys will be appended after during serialization
|
| ComputeRequestV4 |
This record only contains the operations and result schema, and keys will be appended after during serialization
|
| ComputeRequestWrapper |
This class is used by the client to encapsulate the information it needs about a compute request.
|
| ComputeResponseRecordV1 |
This record used to store the response per key
|
| ComputeResponseRecordV1ChunkedDeserializer |
|
| ComputeResponseStats |
|
| ComputeResponseStatsWithSizeProfiling |
|
| ComputeResponseWrapper |
|
| ComputeRouterRequestKeyV1 |
This field will store all the related info for one key
|
| ComputeRouterRequestWrapper |
ComputeRouterRequestWrapper encapsulates a POST request for read-compute from routers.
|
| ComputeUtils |
This class provides utilities for float-vector operations, and it also handles PrimitiveFloatList
transparently to the user of this class.
|
| ConcurrencyUtils |
|
| ConcurrentAccumulator<T,A,R> |
One or more variables that together maintain an accumulation.
|
| ConcurrentAccumulator.Mode |
|
| ConcurrentBatchPushException |
|
| ConcurrentLinkedBlockingQueue<E> |
A BlockingQueue implementation which uses a collection of concurrent Queues per thread
in order to reduce the hotspot of a highly contended mutex or atomic reference.
|
| ConcurrentRef<T> |
|
| ConfigBuilder<C> |
Used for creation and verification of configs
Forked from com.linkedin.databus.core.util @ r293057
|
| ConfigConstants |
|
| ConfigKeys |
|
| ConfigurationException |
Thrown when a config property is invalid or missing
|
| ConfigureActiveActiveReplicationForCluster |
|
| ConfigureIncrementalPushForCluster |
A command to migrate all incremental push stores in a cluster to a specific incremental push policy.
|
| ConfigureNativeReplicationForCluster |
|
| ConnectionControlHandler |
A ChannelHandler which regulates the number of open connections by disabling
the parent socket auto-read config when the number of active connections
exceeds the limit value.
|
| ConnectionLimitHandler |
|
| ConstantVenicePartitioner |
|
| ConsumedDataReceiver<MESSAGE> |
An abstraction of a receiver of data consumed from a message queue.
|
| ConsumerAction |
|
| ConsumerActionType |
|
| ConsumerPoolType |
|
| ConsumerSubscriptionCleaner |
Encapsulates the logic for deciding if a given topic-partition should be unsubscribed and, in that case, executing
the unsubscription.
|
| ConsumptionStateSnapshot |
Type describes all the version attributes
|
| ContentDecompressor |
|
| ContentDecompressResult |
A POJO to store the response content and additional compression related metadata.
|
| ControllerApiConstants |
|
| ControllerClient |
|
| ControllerClientBackedSystemSchemaInitializer |
|
| ControllerClientFactory |
|
| ControllerResponse |
Extend this class to create response objects for the controller
Any fields that must be in all responses can go here.
|
| ControllerRoute |
|
| ControllerRoutes |
|
| ControllerTransport |
|
| ControlMessage |
ControlMessage payloads contain metadata about the stream of data, for validation and debuggability purposes.
|
| ControlMessageDumper |
|
| ControlMessageType |
A simple enum to map the values of
ControlMessage.controlMessageType
N.B.: We maintain this enum manually because Avro's auto-generated enums do
not support evolution (i.e.: adding values) properly. |
| CorruptDataException |
This exception is thrown when we detect corrupt data in the Kafka stream.
|
| CosineSimilarity |
|
| CosineSimilarityOperator |
|
| Count |
|
| CounterBackedMapReduceDataWriterTaskTracker |
An interface to retrieve metrics related to data writer tasks after a MapReduce job has completed.
|
| CounterQueue<T extends RetryCounter> |
A queue implemented with a circular buffer of AtomicReferences
Example of using:
1.
|
| CountOperator |
|
| Crc32 |
CRC32 algorithm as used by Deflate.
|
| Crc32C |
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.
|
| CRC32CheckSum |
Running checksum implementations based on CRC32.
|
| CreateStoragePersona |
|
| CreateStore |
|
| CreateVersion |
This class will add a new version to the given store.
|
| CurrentStoreStates |
This type of store metadata describes the current states of the store in a given fabric and Venice cluster.
|
| CurrentVersionRequest |
|
| CurrentVersionResponse |
|
| CurrentVersionStates |
This type of store metadata describes the current version states of the store in a given fabric and Venice cluster.
|
| D2ClientFactory |
|
| D2ClientUtils |
|
| D2ControllerClient |
|
| D2ControllerClientFactory |
|
| D2HealthChecker |
Runs a daemon thread that consistently sends HTTP GET request to
admin healthcheck endpoint.
|
| D2Server |
|
| D2ServerManager |
This class provides a server manager with start/shutdown methods to be invoked to manage the lifecycle of the server
announcer.
|
| D2ServiceDiscovery |
This class is used to find the proper d2 service name for the given store through default D2 service
d2://VeniceRouter.
|
| D2ServiceDiscoveryResponse |
|
| D2ServiceDiscoveryResponseV2 |
Deprecated. |
| D2TransportClient |
D2Client based TransportClient implementation.
|
| DaemonThreadFactory |
A thread factory that sets the threads to run as daemons.
|
| DataModelBackedStructure<T extends org.apache.avro.specific.SpecificRecord> |
|
| DataProviderUtils |
This class gathers all common data provider patterns in test cases.
|
| DataRecoveryClient |
DataRecoveryClient is the central class to manage data recovery feature.
|
| DataRecoveryClient.DataRecoveryParams |
|
| DataRecoveryConfig |
|
| DataRecoveryEstimator |
DataRecoveryExecutor is the engine to run tasks in data recovery.
|
| DataRecoveryExecutor |
DataRecoveryExecutor is the engine to run tasks in data recovery.
|
| DataRecoveryManager |
This class contains all the logics to:
1.
|
| DataRecoveryMonitor |
|
| DataRecoveryRoutes |
|
| DataRecoveryTask |
A Task is wrapper class that designed to execute multiple commands in sequence.
|
| DataRecoveryTask.TaskParams |
|
| DataRecoveryTask.TaskResult |
|
| DataRecoveryVersionConfig |
This interface defines all the public APIs, and if you need to add accessors to
some new fields, this interface needs to be changed accordingly.
|
| DataRecoveryVersionConfigImpl |
|
| DataRecoveryWorker |
|
| DataReplicationPolicy |
The data replication policy determines which fabric to use for sending real-time writes from clients and
where to direct servers for real-time data consumption.
|
| DataValidationException |
This class encompasses all error conditions which are related to the quality of
the data consumed from Kafka.
|
| DataWriterAccumulators |
All the AccumulatorV2 objects that are used in the Spark DataWriter jobs.
|
| DataWriterComputeJob |
An abstraction for executing and monitoring a data writer compute job running on any batch compute engine
|
| DataWriterMRJob |
|
| DataWriterSparkJob |
|
| DataWriterTaskTracker |
An interface to report and retrieve metrics related to data writer tasks.
|
| DateUtils |
|
| DaVinciBackend |
|
| DaVinciBlobFinder |
DvcBlobFinder discovers live DaVinci peer nodes to facilitate blob transfers necessary for bootstrapping the database
|
| DaVinciClient<K,V> |
Da Vinci Client to provide key-value lookups in embedded mode
|
| DaVinciClientFactory |
|
| DaVinciConfig |
|
| DaVinciPushStatusUpdateTask |
This is a scheduler for sending batching push status in DaVinci.
|
| DaVinciRecordTransformer<K,V,O> |
This abstract class can be extended in order to transform records stored in the Da Vinci Client,
or write to a custom storage of your choice.
|
| DaVinciRecordTransformerConfig |
|
| DaVinciRecordTransformerFunctionalInterface |
|
| DaVinciRecordTransformerResult<O> |
|
| DaVinciRecordTransformerResult.Result |
|
| DaVinciRecordTransformerUtility<K,O> |
|
| DeepCopyOffsetManager |
This class is used to systematically copy OffsetRecord instances rather than
passing them as is. |
| DeepCopyStorageMetadataService |
This class is used to systematically copy OffsetRecord instances rather than
passing them as is. |
| DefaultAsyncFuture<T> |
An implementation of AsyncFuture where much of the implementation is based upon
netty's org.jboss.netty.channel.DefaultChannelFuture. |
| DefaultAsyncFutureTask<T> |
|
| DefaultCollectingAsyncFuture<V> |
A specialised instance of @{link AsyncFuture} for collecting the results of one or more
futures of lists into a single list.
|
| DefaultFileChannelHttpResponse |
|
| DefaultHadoopJobClientProvider |
|
| DefaultIdentityParser |
|
| DefaultIngestionBackend |
The default ingestion backend implementation.
|
| DefaultInputDataInfoProvider |
|
| DefaultJobClientWrapper |
|
| DefaultLingeringStoreVersionChecker |
|
| DefaultPushJobHeartbeatSenderFactory |
|
| DefaultSerializer |
Default Kafka VeniceKafkaSerializer
|
| DefaultSSLFactory |
Cloned from com.linkedin.security.ssl.access.control.SSLEngineComponentFactoryImpl;
Changes:
1.
|
| DefaultSupersetSchemaGenerator |
|
| DefaultVenicePartitioner |
|
| DelegatingAvroGenericDaVinciClient<K,V> |
|
| DelegatingAvroStoreClient<K,V> |
Inside Fast-Client, we choose to use n-tier architecture style to build a pipeline to separate different
types of logic in different layer.
|
| DelegatingClusterLeaderInitializationRoutine |
|
| DelegatingStoreClient<K,V> |
|
| DelegatingTrackingCallback<K,V> |
|
| Delete |
Delete payloads contain fields related to replication metadata of the record.
|
| DeleteAllVersions |
|
| DeleteMetadata |
This is a simple container class to hold replication metadata related fields together to be passed on to the Delete api in VeniceWriter
VeniceWriter#delete(Object, Callback, LeaderMetadataWrapper, long, Optional).
|
| DeleteOldVersion |
|
| DeleteStoragePersona |
|
| DeleteStore |
|
| DeleteUnusedValueSchemas |
|
| DerivedMutableByteBuf |
Mutable ByteBuf.
|
| DerivedReadOnlyByteBuf |
Immutable ByteBuf.
|
| DerivedSchemaCreation |
|
| DerivedSchemaEntry |
Derived schemas are designed for write compute operations.
|
| DerivedSchemaEntrySerializer |
This class is registered in ZKClient to handle derive schema serialization.
|
| DeterministicGuidGenerator |
|
| DeterministicMapOrderDatumWriter |
This interface provides method to write map entries in a deterministic order.
|
| DeterministicMapOrderGenericDatumWriter<T> |
An Avro generic datum writer that sorts the map entries by keys before
serializing the map.
|
| DeterministicMapOrderSpecificDatumWriter<T> |
An Avro specific datum writer that sorts the map entries by keys before
serializing the map.
|
| DictionaryFetchRequest |
DictionaryFetchRequest encapsulates a GET request to storage/storename/version on the storage node to
fetch the compression dictionary for that version.
|
| DictionaryRetrievalService |
DictionaryRetrievalService runs in a producer-consumer pattern.
|
| DictionaryUtils |
|
| DiffValidationUtils |
|
| DirectionalSchemaCompatibilityType |
|
| DisabledPartitionEnablerService |
|
| DisabledPartitionStats |
|
| DisableReplicaCallback |
The callback method to disable leader replicas whenever they are in ERROR state so that helix
can elect a new leader.
|
| DisableStoreRead |
|
| DiskHealthCheckService |
DiskHealthCheckService will wake up every 10 seconds by default and run a health check
in the disk by writing 64KB random data, read them back and verify the content; if there
is any error within the process, an in-memory state variable "diskHealthy" will be updated
to false; otherwise, "diskHealthy" will be kept as true.
|
| DiskHealthStats |
DiskHealthStats measures the disk health conditions based on the periodic tests ran by the DiskHealthCheckService. |
| DiskLimitExhaustedException |
|
| DiskUsage |
We define a threshold where we consider the disk to be full.
|
| DispatchingAvroGenericStoreClient<K,V> |
This class is in charge of routing and serialization/de-serialization.
|
| DispatchingAvroSpecificStoreClient<K,V extends org.apache.avro.specific.SpecificRecord> |
|
| DispatchingVsonStoreClient<K,V> |
Deprecated. |
| DIVStats |
This class contains stats for DIV.
|
| DIVStatsReporter |
This class is the reporting class for stats class DIVStats. |
| DIVStatsReporter.DIVStatsGauge |
|
| DnsLookupStats |
|
| DotProduct |
|
| DotProductOperator |
|
| DoubleAndBooleanConsumer |
|
| DoubleQuantileEstimation |
|
| DoubleQuantileEstimation.Sample |
|
| DoublyLinkedList<E extends DoublyLinkedList.Entry<E>> |
Linked list implementation of the List interface.
|
| DoublyLinkedList.Entry<E extends DoublyLinkedList.Entry<E>> |
In order to maintain a doubly-linked list, each element needs to establish links to its adjacent elements.
|
| DualReadAvroGenericStoreClient<K,V> |
The following class has capability to send dual read requests via Fast-client and Thin-client.
|
| DualReadAvroSpecificStoreClient<K,V extends org.apache.avro.specific.SpecificRecord> |
|
| DumpAdminMessages |
The design consideration to consume in admin tool directly instead of letting controller to
consume the required admin message and return them back to admin tool:
1.
|
| DumpAdminMessages.AdminOperationInfo |
|
| DuplicateDataException |
|
| DuplicateTopicException |
The source and destination topic for topic switching are the same topic
|
| DuplicatingPollStrategy |
A PollStrategy implementation which can introduce duplicates. |
| DurableWrite |
This class is used as the return type of the CompletableFuture that is returned
by the Venice producer.
|
| DynamicAccessController |
A DynamicAccessController is an AccessController with a mutable resource list.
|
| ElementTimestampAndIdx |
A POJO containing an index and a timestamp for a collection element.
|
| ElideDuplicateHeadersHandler |
A simple cache to reduce the number of duplicate CharSequences held by the HttpHeaders
instances.
|
| EmptyPubSubMessageHeaders |
|
| EnableStoreRead |
|
| EncodingUtils |
|
| EndOfIncrementalPush |
This ControlMessage is sent per partition by each offline incremental push job, once per partition, at the end of a incremental push
|
| EndOfPush |
This ControlMessage is sent once per partition, at the end of a bulk load, after all of the data producers come online.
|
| EndOfSegment |
This ControlMessage is sent at least once per partition per producer.
|
| EngineTaskConfigProvider |
An interface to get information about a running job and task on any batch computing engine.
|
| EnumUtils |
|
| EqualsRelationalOperator |
|
| ErrorCatchingHandler |
Expects a GetRequestObject which has store name, key, and partition
Queries the local store for the associated value
writes the value (as a byte[]) back down the stack
|
| ErrorPartitionResetTask |
A task that iterates over store version resources and reset error partitions if they meet the following criteria:
The store version resource is the current version.
The error partition only has exactly one error replica.
For L/F model, using EV to check error replicas misses internal error replica states.
|
| ErrorPartitionStats |
|
| ErrorType |
ExceptionType enum did not have a default deserialization annotation and this makes it non-evolvable till all
clients upgrade to newer versions. |
| EspressoFixedChannelPool |
Forked from Netty's FixedChannelPool
{ChannelPool} implementation that takes another {ChannelPool} implementation and enforce a maximum
number of concurrent connections.
|
| EspressoHttp2FrameCodec |
An extension of the Http2FrameCodec which provides a facility to
be able to block stream creation from clients without incurring any cost
of stream creation on the server side.
|
| EspressoHttp2FrameCodecBuilder |
|
| EspressoHttp2FrameCodecUtil |
Utility class to expose package private members.
|
| EspressoHttp2MultiplexHandler |
Forked from Netty's Http2MultiplexHandler (4.1.42)
(https://github.com/netty/netty/blob/4.1/codec-http2/src/main/java/io/netty/handler/codec/http2/Http2MultiplexHandler.java)
In HTTP/1.1, the requests from the client are distributed across 48 workers threads of router.
|
| EspressoHttp2StreamChannelBootstrap |
|
| EspressoHttpObjectAggregator |
Forked from Netty 4.1.42.Final.
|
| EspressoHttpObjectEncoder<H extends io.netty.handler.codec.http.HttpMessage> |
Forked from Netty 4.1.42.Final.
|
| EspressoMessageAggregator<I,S,C extends io.netty.buffer.ByteBufHolder,O extends io.netty.buffer.ByteBufHolder> |
Forked from Netty 4.1.42.Final.
|
| EspressoMessageToMessageDecoder<I> |
Forked from Netty 4.1.42.Final.
|
| EspressoMessageToMessageEncoder<I> |
Forked from Netty 4.1.42.Final.
|
| EspressoSimpleChannelPool |
Forked from Netty's SimpleChannelPool
Simple ChannelPool implementation which will create new Channels if someone tries to acquire
a Channel but none is in the pool atm.
|
| EstimateDataRecoveryTimeCommand |
|
| EstimateDataRecoveryTimeCommand.Params |
|
| EstimateDataRecoveryTimeCommand.Params.Builder |
|
| EstimateDataRecoveryTimeCommand.Result |
|
| ETLStoreConfig |
This interface defines all the public APIs, and if you need to add accessors to
some new fields, this interface needs to be changed accordingly.
|
| ETLStoreConfig |
|
| ETLStoreConfigImpl |
A container of ETL Enabled Store related configurations.
|
| ETLStoreConfigRecord |
|
| ETLUtils |
|
| ETLValueSchemaTransformation |
In ETL jobs, when a "delete" record is seen, "value" is set to "null" and "DELETED_TS" is set to the offset where
this delete record was seen.
|
| EventGroupLoopSupplier |
Created by acurtis on 12/22/17.
|
| EventThrottler |
A class to throttle Events to a certain rate
This class takes a maximum rate in events/sec and a minimum interval over
which to check the rate.
|
| EventThrottlingStrategy |
This interface is used to abstract the strategy to handle the quota exceeding case.
|
| ExceptionCaptorNotifier |
|
| ExceptionClassAndCauseClassMatcher |
|
| ExceptionClassMatcher |
|
| ExceptionType |
Deprecated.
|
| ExceptionUtil |
|
| ExceptionUtil.ExceptionThrower |
|
| ExceptionUtils |
Static utility functions to deal with exceptions.
|
| ExceptionWithResponseStatus |
|
| ExceptionWithStatus |
|
| ExecutionIdAccessor |
Accessor user to get/update the last execution id and the generated id from a storage.
|
| ExecutionStatus |
Status of executing off-line push.
|
| ExecutionStatusWithDetails |
|
| Executors |
|
| ExecutorService |
An analog to ExecutorService except that the futures
returned are AsyncFutures. |
| Experimental |
|
| ExtendedResourcePathParser<P extends ResourcePath<K>,K,HTTP_REQUEST extends BasicRequest> |
Created by acurtis on 6/12/17.
|
| ExternalCommand |
This class encapsulates a java Process to handle properly
output and error and preventing potential deadlocks.
|
| FailedAsyncFuture<T> |
|
| FakeCompressingSchema |
This record is only used to training a ZSTD dictionary on a small amount of generated avro data
|
| FastAvroGenericDeserializer<V> |
* This class is leveraging linkedin-avro-fastserde-impl to speed up deserialization.
|
| FastAvroSerializer<K> |
This class is leveraging linkedin-avro-fastserde-impl to speed up serialization,
and so far it doesn't work for Avro-1.4, and it will fail back to regular Avro.
|
| FastAvroSpecificDeserializer<T extends org.apache.avro.specific.SpecificRecord> |
This class is leveraging linkedin-avro-fastserde-impl to speed up deserialization.
|
| FastClientStats |
|
| FastDeserializerGeneratorAccessor |
Only for the sake of accessing a package-private method...
|
| FastFixedChannelPool |
Forked from Netty's FixedChannelPool
{ChannelPool} implementation that takes another {ChannelPool} implementation and enforce a maximum
number of concurrent connections.
|
| FastLog |
|
| FastLogContext |
|
| FastLogContextFactory |
An alternate Log4j2 LoggerContextFactory implementation which returns loggers which can
short-circuit debug and trace messages so that they may be disabled without incurring cost from
filters installed within Log4j.
|
| FastLogger |
|
| FastLogMBean |
|
| FastSerializerDeserializerFactory |
|
| FastSimpleChannelPool |
Forked from Netty's SimpleChannelPool
Simple ChannelPool implementation which will create new Channels if someone tries to acquire
a Channel but none is in the pool atm.
|
| FatalDataValidationException |
This class encompasses all error conditions which:
1.
|
| FilterChain<INPUT_VALUE> |
The FilterChain class takes a list of AbstractVeniceFilter to assemble a filter chain to manage the life cycles'
of filters and perform filtering based on the order of filters. |
| FilteringPollStrategy |
A PollStrategy implementation which can pluck out records from the stream. |
| FixedChannelPoolFactory |
|
| FixedChannelPoolImpl |
Created by acurtis on 5/8/18.
|
| FixedFastChannelPoolImpl |
Created by acurtis on 5/8/18.
|
| FnvHashFunction |
Forked from com.linkedin.databus.core.util @ r293057
|
| ForceCloseOnWriteTimeoutHandler |
If a remote peer is unresponsive due to CPU throttling, GC or otherwise, ForceCloseOnWriteTimeoutHandler closes
the connection on write timeout, the time out by default is 30 sec.
|
| ForkedJavaProcess |
Adapted from https://stackoverflow.com/a/723914/791758
|
| ForkedJavaProcess.LogInfo |
|
| FullHttpMultiPart |
Created by acurtis on 3/22/17.
|
| FullHttpMultiPartRequest |
Created by acurtis on 3/27/17.
|
| FusedSslHandler |
An implementation of SslHandler which limits the number of objects held within the
pendingUnencryptedWrites queue.
|
| FusedSslHandler.OverflowException |
|
| Futures |
Created by acurtis on 2/1/17.
|
| GeneratedSchemaEntry |
This is an abstract class which represents a generic class associating a generated schema id with it's
corresponding value schema id
|
| GeneratedSchemaID |
In Venice, some schemas are generated, by deriving them from value schemas.
|
| GenericChunkingAdapter<V extends org.apache.avro.generic.GenericRecord> |
Read compute and write compute chunking adapter
|
| GenericQuantileEstimation<T> |
|
| GenericQuantileEstimation.Sample<T> |
|
| GenericRecordChunkingAdapter |
Just for the sake of casting the generic type to GenericRecord...
|
| GetRequestContext |
|
| GetRouterRequest |
GetRouterRequest encapsulates a GET request to storage/resourcename/partition/key on the storage node for a single-get operation.
|
| GrpcClientConfig |
|
| GrpcClientConfig.Builder |
|
| GrpcOutboundResponseHandler |
|
| GrpcOutboundStatsHandler |
|
| GrpcReadQuotaEnforcementHandler |
|
| GrpcRequestContext |
We need to keep track of each request as it goes through the pipeline so that we can record the necessary metrics
and separate different parts of the logic for the response.
|
| GrpcRouterRequestHandler |
|
| GrpcStatsHandler |
|
| GrpcStorageReadRequestHandler |
|
| GrpcTransportClient |
|
| GrpcUtils |
|
| GuavaRateLimiter |
A wrapper around Guava's RateLimiter to provide a common interface for rate limiting.
|
| GUID |
|
| GuidUtils |
Utility class for generating GUIDs.
|
| GzipCompressor |
|
| HadamardProduct |
|
| HadamardProductOperator |
|
| HadoopJobClientProvider |
|
| HadoopUtils |
Hadoop-specific utils.
|
| HashCodeComparator<T> |
|
| HashFunction |
Forked from com.linkedin.databus.core.util @ r293057
|
| HdfsAvroUtils |
|
| HDFSSchemaSource |
HDFSSchemaSource caches the Value schemes and RMD schemas for a given store on the HDFS and serve them during the Mapper
stage.
|
| HeaderNames |
|
| HeaderNames.HeaderNamesProvider |
|
| HeaderNames.XClusterName |
|
| HeaderNames.XErrorCauseClass |
|
| HeaderNames.XErrorCauseMessage |
|
| HeaderNames.XErrorClass |
|
| HeaderNames.XErrorInResponse |
|
| HeaderNames.XErrorMessage |
|
| HeaderNames.XMetrics |
|
| HeaderNames.XMultipartContentStatus |
|
| HeaderNames.XPartition |
|
| HeaderNames.XRequestId |
|
| HeaderNames.XResponseBoundary |
|
| HeaderNames.XReturnMetrics |
|
| HeaderNames.XServedBy |
|
| Headers |
|
| HeaderStamp |
|
| HeaderStringCache |
|
| HeaderStringCache.Cache |
|
| HeaderUtils |
|
| HeaderUtils.ContentType |
|
| HealthCheckHandler |
|
| HealthCheckRequest |
HealthCheckRequest encapsulates information of a health-check request from routers.
|
| HealthCheckStats |
|
| HeartbeatBasedCheckerStats |
|
| HeartbeatBasedLingeringStoreVersionChecker |
|
| HeartbeatGuidV3Generator |
A Guid generator which uses the UUID.nameUUIDFromBytes(byte[]).
|
| HeartbeatMonitoringService |
This service monitors heartbeats.
|
| HeartbeatRequest |
|
| HeartbeatStat |
|
| HeartbeatStatReporter |
|
| HeartbeatTimeStampEntry |
|
| HeartbeatVersionedStats |
|
| HelixAdapterSerializer |
Serializer to adapt venice serializer to PathBasedZkSerializer.
|
| HelixAdminClient |
Interface and wrapper for Helix related admin operations needed by Venice when running Helix as a service.
|
| HelixBaseRoutingRepository |
Get routing data from Helix and convert it to our Venice partition and replica objects.
|
| HelixClusterMaintenanceModeException |
|
| HelixCustomizedViewOfflinePushRepository |
|
| HelixCVBasedPushMonitor |
An implementation of AbstractPushMonitor that listens to Helix
Customized View to determine the push status |
| HelixExternalViewRepository |
Extend HelixBaseRoutingRepository to leverage external view data.
|
| HelixGroupInfo |
|
| HelixGroupLeastLoadedStrategy |
This strategy is tried to distribute more load to Helix Groups with more capacity.
|
| HelixGroupRoundRobinStrategy |
This simple strategy will try to distribute the load evenly to every Helix Group.
|
| HelixGroupSelectionStrategy |
|
| HelixGroupSelectionStrategyEnum |
|
| HelixGroupSelector |
|
| HelixGroupStats |
|
| HelixHybridStoreQuotaRepository |
Extend RoutingTableChangeListener to leverage customized view data for hybrid store quota.
|
| HelixInstanceConfigRepository |
This repository is used to store the instance config per instance.
|
| HelixInstanceConverter |
Convert between ZNRecord in Helix instanceConfig and Venice instance.
|
| HelixLiveInstanceMonitor |
This class is used to monitor the current live instances(Helix participators).
|
| HelixMessageChannelStats |
|
| HelixParticipationService |
Venice Participation Service wrapping Helix Participant.
|
| HelixPartitionState |
|
| HelixPartitionStateAccessor |
A parent class to access Helix customized partition state, which is different from the states
defined in the state model.
|
| HelixPartitionStatusAccessor |
A class for accessing partition offline push and hybrid quota status in Helix customized state (per Helix
instance) on Zookeeper
|
| HelixReadOnlyLiveClusterConfigRepository |
This class is used to cache live cluster configs.
|
| HelixReadOnlySchemaRepository |
This class is used to cache store schema and provide various query operations.
|
| HelixReadOnlySchemaRepositoryAdapter |
This repository provides the read-only access to both system stores and regular stores.
|
| HelixReadOnlyStoreConfigRepository |
This class is used to fetch all store configs from ZK and cached locally, then provide the way to read those
configs.
|
| HelixReadOnlyStoreRepository |
|
| HelixReadOnlyStoreRepositoryAdapter |
This repository provides an read only interface to access both system store and regular venice store.
|
| HelixReadOnlyZKSharedSchemaRepository |
This repository is used to retrieve all the zk shared system store schemas from the system store cluster.
|
| HelixReadOnlyZKSharedSystemStoreRepository |
This repository provides an interface to access zk shared system stores only.
|
| HelixReadWriteLiveClusterConfigRepository |
This class is used to modify live cluster configs.
|
| HelixReadWriteSchemaRepository |
This class is used to add schema entries for stores.
|
| HelixReadWriteSchemaRepositoryAdapter |
This repository supports the following operations:
1.
|
| HelixReadWriteStoreRepository |
Read write store repository which uses Helix as storage.
|
| HelixReadWriteStoreRepositoryAdapter |
This repository provides an read-write interface to access both system store and regular venice store.
|
| HelixScatterGatherRoutingStrategy |
This strategy will assign an ordering of helix groups via round-robin for even distribution.
|
| HelixSchemaAccessor |
|
| HelixState |
States of Venice node in Helix.
|
| HelixStatusMessageChannel |
The control message changed built on Helix message service.
|
| HelixStoreGraveyard |
|
| HelixUtils |
Helper functions for Helix.
|
| HelixVeniceClusterResources |
Aggregate all essentials resources required by controller to manage a Venice cluster.
|
| HelixViewPropertyType |
|
| HostFinder<H,R> |
Provides methods to locate the storage node or nodes for database partitions.
|
| HostHealthMonitor<H> |
This is an interface for monitoring the healthiness of storage nodes.
|
| HostHealthStats |
This class is used to monitor the various reasons for unhealthy hosts.
|
| HostLevelIngestionStats |
This class contains stats for stats on the storage node host level.
|
| Http1FullRequest |
|
| Http1FullResponse |
|
| Http1Headers |
|
| Http1Request |
|
| Http1Response |
|
| Http2AwareChannelPool |
A ChannelPool Wrapper that would return either a ChannelPool if the request is an HTTP 1.1 request or
A Stream if HTTP2
|
| Http2ExceptionHandler |
This class is ExceptionHandler for all HTTP/2.
|
| Http2PingCallListener |
|
| Http2PingHelper |
|
| Http2PingResponseHandler |
|
| Http2PingSendHandler |
|
| Http2PipelineInitializer |
Initializes HTTP/2 Pipeline.
|
| Http2PipelineInitializer.Builder<T extends Http2PipelineInitializer.Builder<T>> |
|
| Http2PipelineInitializer.BuilderSupplier |
|
| Http2SettingsFrameLogger |
Logs the HTTP/2 Settings Frames.
|
| Http2StreamFrameClientCodec |
|
| Http2StreamFrameServerCodec |
|
| Http2TooManyStreamsException |
Client-facing exception for HTTP/2 too many active streams exception with a clearer message for the clients.
|
| Http2Utils |
HTTP/2 utility methods.
|
| HttpByteBufContentChunker |
Created by acurtis on 3/23/17.
|
| HttpChannelInitializer |
|
| HttpClient5BasedR2Client |
This utility class could construct a HttpClient5 based R2 Client.
|
| HttpClient5StorageNodeClient |
|
| HttpClient5Utils |
This class is used to provide a facility to initialize httpclient5 lib based Http/2 Client.
|
| HttpClient5Utils.HttpClient5Builder |
|
| HttpClientTransport |
|
| HttpClientUtils |
|
| HttpClientUtils.ClosableHttpAsyncClientWithConnManager |
|
| HttpConnectionPoolStats |
|
| HttpConstants |
|
| HttpContentMultiPartAggregator |
|
| HttpContentMultiPartDecode |
|
| HttpContentUnwrap |
Unwraps the content of messages which have multipart bodies as bare ByteBuf messages
which can then be further processed by HttpContentMultiPartDecode. |
| HttpMethod |
|
| HttpMultiPart |
Created by acurtis on 3/22/17.
|
| HttpMultiPartContentAggregator |
This _only_ knows how to aggregate HttpMultiPart messages and "bad things"(tm) will occur when it encounters other
types of messages.
|
| HttpMultiPartContentCodec |
Created by acurtis on 3/22/17.
|
| HttpMultiPartContentDecoder |
Decodes MIME multipart encoded content bodies by separating them into separate HttpMessage objects.
|
| HttpMultiPartContentEncoder |
Encodes a stream of HttpMultiPart objects into a MIME encoded document. |
| HttpObjectToBasicHttpObjectAdapter |
Created by acurtis on 4/26/18.
|
| HttpResponseStatusCodeCategory |
Maps the provided HTTP response status HttpResponseStatus to one of
1xx, 2xx, 3xx, 4xx, 5xx categories.
|
| HttpServerConcurrencyObserver |
Created by acurtis on 12/6/17.
|
| HttpServerStatisticsHandler |
An abstract handler which may be used to examine latencies in the Netty4 HTTP request processing.
|
| HttpServerStatisticsHandler.Stats |
|
| HttpShortcutResponse |
Created by mwise on 3/11/16.
|
| HttpsTransportClient |
|
| HttpToStringUtils |
Created by acurtis on 3/23/17.
|
| HttpTransportClient |
CloseableHttpAsyncClient based TransportClient implementation.
|
| HttpUtils |
This will be used to stash reoccurring common bits of code.
|
| HttpVersionFilter |
Created by acurtis on 9/28/17.
|
| HybridStoreConfig |
This interface defines all the public APIs, and if you need to add accessors to
some new fields, this interface needs to be changed accordingly.
|
| HybridStoreConfig |
|
| HybridStoreConfigImpl |
A container of Hybrid Store related configurations.
|
| HybridStoreConfigRecord |
|
| HybridStoreQuotaStatus |
|
| HybridStoreQuotaStatusResponse |
Hybrid store quota status response for a resource; this is a response
that will be returned by Router.
|
| ICProvider |
An interface for implementation of IC( invocation-context) provider class for calls between various deployable services.
|
| IdentityParser |
An interface that provides a method to parse identity information from a certificate.
|
| IdentityRecordDeserializer |
This class is used as an identity function to return the same bytes that were passed in the input to the output.
|
| IdentityVeniceRecordReader |
A record reader that returns the input key and value as is.
|
| ImmutableChangeCapturePubSubMessage<K,V> |
|
| ImmutableMapEntry<K,V> |
A Pair which may be used as a Map.Entry. |
| ImmutablePubSubMessage<K,V> |
|
| ImproperlyStartedSegmentException |
|
| InboundContentDebugHandler |
In order to dump the HTTP headers when there is a decode failure, surround the HTTP decode handler with these
handles...example:
|
| InboundContentDebugHandler.HttpDecodeResult |
|
| IncomingDataAfterSegmentEndedException |
This exception is thrown when the server reads data from same segment after the segment is ended.
|
| IncrementalPush |
|
| IncrementalPushVersionsResponse |
|
| IndexedHashMap<K,V> |
This is a fork of the standard HashMap which implements
IndexedMap. |
| IndexedMap<K,V> |
The IndexedMap interface implements Map and several functions for dealing with its
content via the index corresponding to their insertion order.
|
| IndexedMap<K,V> |
The IndexedMap interface implements Map and several functions for dealing with its
content via the index corresponding to their insertion order.
|
| IngestionAction |
|
| IngestionBackend |
|
| IngestionBatchProcessor |
This class is used to process the AA/WC messages in parallel to address the long-tail partition lagging issues.
|
| IngestionCommandType |
IngestionCommandType is an Enum class for specifying different commands for ingestion isolation.
|
| IngestionComponentType |
IngestionComponentType is an Enum class for specifying different components for graceful shutdown in forked ingestion process.
|
| IngestionMetadataRetriever |
|
| IngestionMetadataRetrieverDelegator |
|
| IngestionMetadataUpdateType |
|
| IngestionMetricsReport |
|
| IngestionMode |
IngestionMode is an Enum class that contains all modes for ingestion.
|
| IngestionReportType |
IngestionReportType is an Enum class for specifying different ingestion reports for ingestion isolation.
|
| IngestionStats |
This class contains stats for store ingestion.
|
| IngestionStatsReporter |
|
| IngestionStatsReporter.IngestionStatsGauge |
|
| IngestionStorageMetadata |
|
| IngestionTaskCommand |
|
| IngestionTaskReport |
|
| IngestionThrottler |
This throttler has the following functionality:
1.
|
| InMemoryAdminTopicMetadataAccessor |
|
| InMemoryExecutionIdAccessor |
|
| InMemoryKafkaBroker |
Used in unit tests in order to avoid spinning a full Kafka broker with network stack
and disk IO.
|
| InMemoryKafkaMessage |
A single Kafka message, strongly typed for the types that Venice uses.
|
| InMemoryLogAppender |
|
| InMemoryLogAppender.Builder |
|
| InMemoryOffsetManager |
In memory implementation of OffsetManager, should really only be used for tests
|
| InMemoryStorageEngine |
A simple non-persistent, in-memory store.
|
| InMemoryStorageEngineFactory |
|
| InMemoryStorageMetadataService |
In memory implementation of StorageMetadataService, should really only be used for tests
|
| InMemoryStoragePartition |
An in-memory hashmap implementation of a storage partition
Assumptions:
1.No need to worry about synchronizing write/deletes as the model is based on a single writer.
|
| InputDataInfoProvider |
This interface lets users get input data information
|
| InputDataInfoProvider.InputDataInfo |
A POJO that contains input data information (schema information and input data file size)
|
| InputStorageQuotaTracker |
This class is used to keep track of store storage quota and storage overhead ratio and check whether the total
input data size exceeds the quota
|
| Instance |
Class defines the Instance in Venice.
|
| InstanceHealthMonitor |
The class is used to measure the healthiness about the cluster the store belongs to.
|
| InstanceRemovableStatuses |
|
| InstanceRemovableStatuses.NonStoppableReason |
|
| InstanceSizeEstimator |
This utility class provides functions to measure the heap size of objects for a limited number of classes.
|
| InstanceStatus |
Status of the instance in Venice cluster.
|
| InstanceStatusDecider |
This class is not Thread-safe.
|
| InstrumentedBootstrap |
Because various netty methods and classes have been declared as final,
we construct this pile of foo in order to be able to instrument the InstrumentedBootstrap.connect()
method invocation. |
| InstrumentibleEventExecutor |
|
| InternalAvroSpecificSerializer<SPECIFIC_RECORD extends org.apache.avro.specific.SpecificRecord> |
Serializer for translating a versioned protocol of Avro records.
|
| InternalAvroStoreClient<K,V> |
This class includes some necessary functions to deal with certain metric-handling activities that only
the client implementation can be aware of.
|
| InternalAvroStoreClient<K,V> |
All the internal implementations of different tiers should extend this class.
|
| InternalTransportClient |
Abstract class for Fast-Client transport layer implementation, and this layer is mostly decided which methods
need to be implemented at different stages.
|
| InvalidConfigException |
Forked from com.linkedin.databus.core.util @ r293057
|
| InvalidDatabaseNameException |
|
| InvalidKeySchemaPartitioner |
|
| InvalidVeniceSchemaException |
|
| IOUtils |
|
| IsolatedIngestionBackend |
This class is the implementation of ingestion backend designed for ingestion isolation.
|
| IsolatedIngestionNotifier |
|
| IsolatedIngestionProcessHeartbeatStats |
|
| IsolatedIngestionProcessStats |
IsolatedIngestionProcessStats is a metrics collecting class that aims to collect metrics from isolated ingestion process.
|
| IsolatedIngestionRequestClient |
This class sends requests to monitor service in main process and retrieves responses.
|
| IsolatedIngestionServer |
This class is the server service of the isolated ingestion.
|
| IsolatedIngestionServerAclHandler |
|
| IsolatedIngestionServerChannelInitializer |
|
| IsolatedIngestionServerHandler |
|
| IsolatedIngestionUtils |
This class contains methods used for communication between ingestion client and server.
|
| IteratorUtil |
Utility methods for Iterators.
|
| IteratorUtils |
|
| JavaUtilGuidV4Generator |
A Guid generator which internally uses UUID.randomUUID().
|
| JDBCUtils |
Utility methods for JDBC.
|
| JenkinsHashFunction |
Hash algorithm by Bob Jenkins, 1996.
|
| JobClientWrapper |
|
| JobRoutes |
|
| JobStatusQueryResponse |
Response for querying job status.
|
| JobUtils |
|
| Joiner |
A replacement to the use of the Google collections class of the same name,
|
| KafkaClusterBasedRecordThrottler |
This class is used to throttle records consumed per Kafka cluster
|
| KafkaConsumerException |
Custom Exception for Venice Kafka Consumer Related Issues.
|
| KafkaConsumerService |
KafkaConsumerService is used to manage a pool of consumption-related resources connected to a specific Kafka
cluster. |
| KafkaConsumerService.ConsumerAssignmentStrategy |
This consumer assignment strategy specify how consumers from consumer pool are allocated.
|
| KafkaConsumerServiceDelegator |
This delegator impl is used to distribute different partition requests into different consumer service.
|
| KafkaConsumerServiceDelegator.ConsumerPoolStrategyType |
|
| KafkaConsumerServiceStats |
This class provides the stats for Kafka consumer service per region or per store.
|
| KafkaDataIntegrityValidator |
This class is a library that can validate the Kafka message during consumption, which can be used in
Venice-Server/Da-Vinci and ETL.
|
| KafkaInputDataInfoProvider |
|
| KafkaInputDictTrainer |
Zstd dict trainer for Kafka Repush.
|
| KafkaInputDictTrainer.Param |
|
| KafkaInputDictTrainer.ParamBuilder |
|
| KafkaInputFormat |
We borrowed some idea from the open-sourced attic-crunch lib:
https://github.com/apache/attic-crunch/blob/master/crunch-kafka/src/main/java/org/apache/crunch/kafka/record/KafkaInputFormat.java
This InputFormat implementation is used to read data off a Kafka topic.
|
| KafkaInputFormatCombiner |
This class is a Combiner, which is a functionality of the MR framework where we can plug a Reducer
implementation to be executed within the Mapper task, on its output.
|
| KafkaInputKeyComparator |
This class is used to support secondary sorting for KafkaInput Repush.
|
| KafkaInputMapperKey |
The protocol between Mapper and Reducer with KafkaInputFormat for key field
|
| KafkaInputMapperValue |
The data protocol between Mapper and Reducer for KafkaInputFormat
|
| KafkaInputMRPartitioner |
This class is used for KafkaInput Repush, and it only considers the key part of the composed key (ignoring the offset).
|
| KafkaInputRecordReader |
We borrowed some idea from the open-sourced attic-crunch lib:
https://github.com/apache/attic-crunch/blob/master/crunch-kafka/src/main/java/org/apache/crunch/kafka/record/KafkaRecordReader.java
This class is used to read data off a Kafka topic partition.
|
| KafkaInputSplit |
We borrowed some idea from the open-sourced attic-crunch lib:
https://github.com/apache/attic-crunch/blob/master/crunch-kafka/src/main/java/org/apache/crunch/kafka/record/KafkaInputSplit.java
InputSplit that represent retrieving data from a single TopicPartition between the specified start
and end offsets.
|
| KafkaInputUtils |
|
| KafkaInputValueGroupingComparator |
|
| KafkaKey |
Class which stores the components of a Kafka Key, and is the format specified in the
KafkaKeySerializer. |
| KafkaKeySerializer |
|
| KafkaMessageEnvelope |
|
| KafkaSSLUtils |
|
| KafkaStoreIngestionService |
Assumes: One to One mapping between a Venice Store and Kafka Topic.
|
| KafkaTopicDumper |
This class contains logic to dump Venice Kafka topics.
|
| KafkaValueSerializer |
|
| KeyAndValueSchemas |
|
| KeyLevelLocksManager |
A helper class to return the same lock for the same raw key bytes.
|
| KeyWithChunkingSuffixSerializer |
|
| KillOfflinePushJob |
|
| KillOfflinePushMessage |
|
| KillPushJob |
|
| LagType |
|
| LambdaStat |
Deprecated.
|
| LandFillObjectPool<O> |
A dummy implementation which simply allocates a new object on every ObjectPool.get() and lets the garbage collector
dispose of it rather than reusing. |
| LastSucceedExecutionIdResponse |
|
| LatencyUtils |
|
| Lazy<T> |
Created by acurtis on 3/29/17.
|
| Lazy<T> |
This utility provides lazy initialization for a wrapped object.
|
| LazyImpl<T> |
Fork of the LazyInitializer with some additional APIs.
|
| LazyResettable<C> |
This, like Lazy, implements the same API as Optional and provides
late initialization for its content. |
| LazyResettableImpl<C> |
|
| LazyResettableWithTearDown<C> |
|
| LeaderCompleteState |
Completion state of the leader partition.
|
| LeaderControllerResponse |
|
| LeaderFollowerIngestionProgressNotifier |
|
| LeaderFollowerPartitionStateModel |
Venice partition's state model to manage Leader/Follower(Standby) state transitions.
|
| LeaderFollowerPartitionStateModel.LeaderSessionIdChecker |
A leader session id checker will be created for each consumer action;
server checks whether the session id is still valid before processing
the consumer action.
|
| LeaderFollowerPartitionStateModelDualPoolFactory |
|
| LeaderFollowerPartitionStateModelFactory |
State Transition Handler factory for handling Leader/Follower resources in the storage node.
|
| LeaderFollowerPartitionStateModelFactory.LeaderFollowerThreadPoolStrategy |
The leader follower state thread pool strategy specifies how thread pools are allocated for Helix state transition.
|
| LeaderFollowerStateType |
|
| LeaderFollowerStoreIngestionTask |
This class contains the state transition work between leader and follower; both leader and follower
will keep track of information like which topic leader is consuming from and the corresponding offset
as well as the latest successfully consumed or produced offset in the version topic (VT).
|
| LeaderMetadata |
|
| LeaderMetadataWrapper |
This is a simple container class to hold Leader metadata related fields together to be passed on to the Put and Delete api in VeniceWriter
Caller should construct an instance of this object by properly filling up all the fields of this object.
|
| LeaderProducedRecordContext |
This class holds all the necessary context information which is passed from
kafka consumer thread -> kafka producer callback thread -> drainer thread.
|
| LeaderProducerCallback |
|
| LeakDetect |
General purpose object reference leak detector with recovery.
|
| LeakedPushStatusCleanUpService |
LeakedPushStatusCleanUpService will wake up regularly (interval is determined by controller config
ConfigKeys.LEAKED_PUSH_STATUS_CLEAN_UP_SERVICE_SLEEP_INTERVAL_MS), get all existing push
status ZNodes on Zookeeper that belong to the specified cluster, without scanning through the replica statuses, find
all leaked push status and delete them on Zookeeper. |
| LeakedResourceCleaner |
LeakedResourceCleaner is a background thread which wakes up regularly
to release leaked resources from local disk.
|
| LeakedResourceCleanerStats |
LeakedResourceCleanerStats records the occurrences of store resources get removed by LeakedResourceCleaner. |
| LeastLoadedClientRoutingStrategy |
This strategy is trying to route the request to the least-loaded instances.
|
| Level |
This is the subset of org.apache.log4j.Level and org.apache.log4j.Priority with version 1.2.17
Copied here because slf4j does not have a Level concept
|
| LifeCycleFilter<T> |
|
| LifeCycleStatsCollector<T> |
|
| LingeringStoreVersionChecker |
|
| ListenerManager<T> |
This class provides the unified way to manager venice listener.
|
| ListenerService |
Service that listens on configured port to accept incoming GET requests
|
| LiveClusterConfig |
|
| LiveInstanceChangedListener |
|
| LiveInstanceMonitor |
|
| LoadedStoreUserPartitionMapping |
|
| LocalBootstrappingVeniceChangelogConsumer<K,V> |
This is a wrapper class on top of InternalBootstrappingVeniceChangelogConsumerImpl.
|
| LocalThreadEventLoopGroup<E extends io.netty.channel.MultithreadEventLoopGroup> |
A specialised EventLoopGroup which the MultithreadEventLoopGroup.next() method prefers to return
an EventLoop for the current thread, if the current thread is a thread of the wrapped
MultithreadEventLoopGroup.
|
| LocalVeniceChangelogConsumerProvider<K,V> |
|
| LockAssistedCompletableFuture<T> |
|
| Log4J2FrameLogger |
Created by acurtis on 4/19/18.
|
| Log4J2LoggingHandler |
Created by acurtis on 4/20/18.
|
| LogConfigurator |
|
| LogMessages |
|
| LogNotifier |
Logs the Notification received.
|
| LogSslCipherSuiteHandler |
|
| LongAdderRateGauge |
This metric class is to optimize for high write throughput, low read throughput measurement use case instead of real-time
measurement.
|
| LongEqualOrGreaterThanMatcher |
|
| LongQuantileArrayEstimation |
|
| LongQuantileEstimation |
|
| LongQuantileEstimation.Sample |
|
| LongStats |
|
| LongStatsAggregator |
Extend the LongQuantileEstimation class and add computation for the mean and standard deviation of
the supplied values. |
| LongStatsAggregatorLowQuantile |
|
| LongStatsArrayAggregator |
Extend the LongQuantileEstimation class and add computation for the mean and standard deviation of
the supplied values. |
| LongStatsLowQuantile |
|
| LongStatsLowQuantileImpl |
|
| LongTailRetryStatsProvider |
This class is a stats generator for dds router framework to record scattering/gathering
related metrics.
|
| LongTailRetrySupplier<P extends ResourcePath<K>,K> |
|
| LowerCaseAsciiCharSequence |
|
| MainIngestionMonitorService |
This class is the listener service in main process which handles various kinds of reports sent from
isolated ingestion service.
|
| MainIngestionReportChannelInitializer |
|
| MainIngestionReportHandler |
|
| MainIngestionRequestClient |
This class sends requests to isolated ingestion process and retrieves responses.
|
| MainIngestionStorageMetadataService |
|
| MainPartitionIngestionStatus |
|
| MainTopicIngestionStatus |
This class manages the ingestion status for each partition for a given topic when isolated ingestion is enabled.
|
| ManagedChannelPool |
|
| MapOrderPreservingDatumReader<T> |
MapOrderPreservingDatumReader converts map type serialized items into instances with
a consistent ordering of entries.
|
| MapOrderPreservingDeserializer |
|
| MapOrderPreservingFastDeserializer |
|
| MapOrderPreservingFastSerDeFactory |
Factory to create fast serializer/deserializer of supporting map ordering.
|
| MapOrderPreservingFastSerializer<K> |
|
| MapOrderPreservingGenericDatumWriter<T> |
MapOrderPreservingGenericDatumWriter converts map type instances to in-memory serialized format
* with a consistent ordering of map entries.
|
| MapOrderPreservingSerDeFactory |
|
| MapOrderPreservingSerializer<K> |
|
| MapOrderPreservingSpecificDatumWriter<T> |
MapOrderPreservingSpecificDatumWriter converts map type instances to in-memory serialized format
with a consistent ordering of map entries.
|
| MapperValueType |
|
| MapReduceEngineTaskConfigProvider |
|
| MaterializedView |
|
| MD5CheckSum |
Running checksum implementation based on BouncyCastle's implementation of MD5.
|
| Measurable |
|
| MeasurableLinkedHashMap<K,V extends Measurable> |
A subclass of LinkedHashMap which does a best-effort attempt at guessing its size on heap + the size of its
values.
|
| MemoryBoundBlockingQueue<T extends Measurable> |
This class is a generic implementation of a memory bound blocking queue.
|
| MemoryLimitExhaustedException |
|
| Merge<T> |
API for merging existing data with incoming writes.
|
| MergeByteBuffer |
This class handles byte-level merge.
|
| MergeConflictResolver |
The workflow is
Query old replication metadata.
|
| MergeConflictResolverFactory |
|
| MergeConflictResult |
An object to encapsulate the results of conflict resolution to denote how the operation and value that should be
applied or if the current update should be ignored.
|
| MergeConflictResultWrapper |
This wrapper is used to keep the context after handling Active/Active messages.
|
| MergeGenericRecord |
|
| MergeRecordHelper |
The purpose of this interface is to extract common merge logic.
|
| MergeResultValueSchemaResolverImpl |
|
| MergeUtils |
|
| MessageType |
A simple enum to map the values of
KafkaMessageEnvelope.messageType
N.B.: We maintain this enum manually because Avro's auto-generated enums do
not support evolution (i.e.: adding values) properly. |
| MessageType.Constants |
|
| MetadataAggregator |
MetadataAggregator is a custom HttpObjectAggregator that
only aggregated HttpResponse messages for metadata.
|
| MetadataFetchRequest |
MetadataFetchRequest encapsulates a GET request to /metadata/storename on the storage node to fetch metadata
for that node.
|
| MetaDataHandler |
This MetaDataHandle is used to handle the following meta data requests:
1.
|
| MetadataRepoBasedTopicExistingCheckerImpl |
|
| MetadataResponse |
This class stores all the information required for answering a server metadata fetch request.
|
| MetadataResponseRecord |
This record will store version properties, key & value schemas, and routing information
|
| MetadataSchemaCreation |
|
| MetadataUpdateStats |
|
| MetaStoreDataType |
All the data types supported in meta system store.
|
| MetaStoreReader |
|
| MetaStoreShadowReader |
This class serves as the shadow read handler of the meta system store.
|
| MetaStoreWriter |
This class is to write metadata: store properties/key schema/value schemas/replica statuses to meta system store.
|
| MetaSystemStoreAutoCreationValidation |
|
| MeteredOutputStream |
|
| Method |
Collection of all available methods that a Principal can perform. |
| MetricEntity |
Metric entity class to define a metric with all its properties
|
| MetricEntityState |
Operational state of a metric.
|
| MetricEntityState.TehutiSensorRegistrationFunction |
create the metrics/Sensors
|
| MetricNames |
|
| Metrics |
|
| MetricsAware |
|
| MetricsDecoder |
|
| MetricsDecorator |
|
| MetricsProvider |
|
| MetricsRepositoryUtils |
Utility functions to help create common metrics repository.
|
| MetricsUtils |
Utility functions to help test metrics
|
| MetricType |
Metric type enum to define the type of metrics Venice supports via OpenTelemetry
|
| MetricUnit |
Metric Unit enum to define list of Units supported for metrics
|
| MigrateStore |
|
| MigrationPushStrategy |
|
| MigrationPushStrategyJSONSerializer |
|
| MigrationPushStrategyResponse |
|
| MigrationPushStrategyZKAccessor |
|
| MigrationRoutes |
|
| MissingDataException |
This exception is thrown when we detect missing data in the Kafka stream.
|
| MissingKeyInStoreMetadataException |
|
| MockCircularTime |
A mock time that takes a list of synthetic timestamps in MS and return them one by one in a circular manner.
|
| MockInMemoryAdminAdapter |
|
| MockInMemoryConsumer |
|
| MockInMemoryProducerAdapter |
|
| MockTehutiReporter |
|
| MockTestStateModelFactory |
|
| MockTestStateModelFactory.OnlineOfflineStateModel |
|
| MockVeniceAuthorizer |
|
| MonitorCommand |
|
| MonitorCommand.Params |
|
| MonitorCommand.Params.Builder |
|
| MonitorCommand.Result |
|
| MRJobCounterHelper |
All MapReducer job counters (identified by a group name + a counter name) are defined here and this util class
provides method to increment counters and read counters
|
| MRJobCounterHelper.GroupAndCounterNames |
Bundle counter group name and counter name in this POJO
|
| Msg |
Message holder object for use with lazy logging.
|
| MultiGetRecordStreamDecoder<K,V> |
|
| MultiGetResponseRecordV1 |
This field will store all the related info for one record
|
| MultiGetResponseRecordV1ChunkedDeserializer |
|
| MultiGetResponseStatsWithSizeProfiling |
|
| MultiGetResponseWrapper |
|
| MultiGetRouterRequestKeyV1 |
This field will store all the related info for one key
|
| MultiGetRouterRequestWrapper |
MultiGetRouterRequestWrapper encapsulates a POST request to storage/resourcename on the storage node for a multi-get operation.
|
| MultiKeyRequestContext<K,V> |
Keep track of the progress of a multi-key requests - batch get and compute.
|
| MultiKeyRequestContext.KeyInfo<K> |
represents a key requested on a route and tracks info related to it but specific to the route
|
| MultiKeyResponseStats |
|
| MultiKeyResponseWrapper<K> |
|
| MultiKeyRouterRequestWrapper<K> |
MultiKeyRouterRequestWrapper is a base class for a multi-key operation.
|
| MultiNodeResponse |
|
| MultiNodesStatusResponse |
|
| MultipartContent |
|
| MultipartHttpResponse |
|
| MultiReplicaResponse |
|
| MultiSchemaIdResponse |
|
| MultiSchemaResponse |
|
| MultiSchemaResponse.Schema |
|
| MultiStoragePersonaResponse |
|
| MultiStoreInfoResponse |
|
| MultiStoreResponse |
|
| MultiStoreStatusResponse |
|
| MultiStoreTopicsResponse |
|
| MultiVersionResponse |
Created by mwise on 5/3/16.
|
| MultiVersionStatusResponse |
|
| NamedThreadFactory |
ThreadFactory which creates named threads for use in an ExecutorService.
|
| NamedThreadFactory |
A thread factory that sets the threads to create threads with a specific prefix name.
|
| NativeMetadataRepository |
Venice in-house implementation of a read only metadata repository where callers can retrieve various metadata such as
Store objects and their corresponding schemas.
|
| NativeMetadataRepositoryStats |
|
| Netty |
|
| Netty4RouterException |
|
| Netty4ThrowException |
Simple wrapper using Netty4 PlatformDependent implementation
|
| NettyChunkedWriteHandler |
This class was copied from ChunkedWriteHandler, and the only change we made here is to
using ConcurrentLinkedQueue for NettyChunkedWriteHandler.queue since NettyChunkedWriteHandler.resumeTransfer() or NettyChunkedWriteHandler.discard(Throwable)
could happen in any sequence with any parallelism because of scatter/gather logic in Venice Router. |
| NettyFileTransferClient |
|
| NettyP2PBlobTransferManager |
Netty based P2P blob transfer manager implementation.
|
| NettyUtils |
Created by acurtis on 3/30/17.
|
| NettyUtils |
|
| NettyUtils.Mode |
|
| NettyUtils.ReadMode |
|
| NettyVersion |
|
| NewClusterBuildOutRoutes |
|
| NewStoreResponse |
|
| NodeRemovableResult |
|
| NodeRemovableResult.BlockingRemoveReason |
|
| NodeReplicasReadinessResponse |
|
| NodeReplicasReadinessState |
|
| NodesAndReplicas |
|
| NodeStatusResponse |
Response to represent the status of a node
|
| NonEmptyStringMatcher |
|
| NonLocalAccessException |
|
| NoopCompressor |
Locking is not necessary for NoopCompressor, so this class overrides all the public APIs to avoid locking. |
| NoOpPushJobHeartbeatSender |
|
| NoOpPushJobHeartbeatSenderFactory |
|
| NoOpReadResponseStats |
|
| NoOpSentPushJobDetailsTracker |
|
| NoOpValidator |
No Op validator.
|
| NotImplemented |
|
| NotThreadsafe |
Warns that a class is not threadsafe.
|
| NullCallTracker |
Created by acurtis on 3/30/17.
|
| NullOutputStream |
A simple @{link OutputStream} implementation which is equivalent to
/dev/null by acting as a sink for bytes.
|
| NullSkippingIteratorWrapper<E> |
This iterator traverses the entire backing iterator, while skipping over null entries.
|
| NullStats |
|
| ObjectCacheBackend |
This class is in charge of managing access and maintenance of a VeniceStoreCache.
|
| ObjectCacheConfig |
|
| ObjectMapperFactory |
|
| ObjectPool<O> |
An interface to get and give back objects that are intended to be long-lived and recycled, but where the
location in the code for beginning to use the object is far from the location where we stop using it, e.g.
|
| OfflinePushAccessor |
Accessor to execute the CURD operations for offline push and its replicas statuses.
|
| OfflinePushStatus |
Class stores all the statuses and history of one offline push.
|
| OfflinePushStatusJSONSerializer |
|
| OfflinePushStatusJSONSerializer.OfflinePushStatusSerializerMixin |
|
| OfflinePushStatusJSONSerializer.StatusSnapshotSerializerMixin |
|
| OfflinePushStrategy |
Enum of strategies used to decide the when the data is ready to serve in off-line push.
|
| OffsetManager |
This class records the offset for every pair(topic,partition) this node is responsible for.
|
| OffsetRecord |
If OffsetRecord is initialized with a serializer that contains SchemaReader, old version of server codes
will be able to deserialize OffsetRecord that is serialized with a newer protocol version, which can happen
after rolling back a server release with new protocol version to an old server release with old protocol version.
|
| OnlineInstanceFinder |
Look up online instances related to a topic's partition.
|
| OnlineProducerFactory |
|
| OnlineVeniceProducer<K,V> |
An implementation of a VeniceProducer suitable for online applications.
|
| OperationNotAllowedException |
|
| OptimizedBinaryDecoder |
This class is used to optimize bytes field decoding.
|
| OptimizedBinaryDecoderFactory |
|
| OptimizedKafkaValueSerializer |
This class is to reuse the original array for put payload of each message
to reduce the unnecessary byte array allocation.
|
| OutboundByteBufAggregator |
SSL uses 16kb application message packets.
|
| OutboundHttpWrapperHandler |
wraps raw bytes into an HTTP response object that HttpServerCodec expects
|
| OwnerResponse |
|
| P2PBlobTransferManager<T> |
Peer-to-Peer (P2P) Blob Transfer Manager.
|
| P2PBlobTransferService |
|
| P2PFileTransferClientHandler |
The client-side Netty handler to process responses for P2P file transfer.
|
| P2PFileTransferServerHandler |
The server-side Netty handler to process requests for P2P file transfer.
|
| P2PMetadataTransferHandler |
The client-side Netty handler to process responses for P2P metadata transfer.
|
| Pair<F,S> |
A simple container for a pair of (2) values.
|
| Pair<F,S> |
Deprecated.
|
| ParallelMultiKeyResponseWrapper<T extends MultiKeyResponseWrapper> |
|
| ParentControllerConfigUpdateUtils |
This class is a utility class for Parent Controller store update logics.
|
| ParentControllerRegionState |
Enum representing the state of the region where the parent controller resides.
|
| ParentHelixOfflinePushAccessor |
|
| ParticipantMessageKey |
|
| ParticipantMessageType |
|
| ParticipantMessageValue |
|
| ParticipantStateTransitionStats |
This class is used to track the thread pool stats for the state transitions of the participant.
|
| ParticipantStoreClientsManager |
A helper class that wraps the readers and writers for the participant stores.
|
| ParticipantStoreConsumptionStats |
|
| ParticipantStoreConsumptionTask |
|
| Partition |
Class defines the partition in Venice.
|
| PartitionAssignment |
This class represent the assignments of one resource including all of assigned partitions and expected number of
partitions.
|
| PartitionConsumptionState |
This class is used to maintain internal state for consumption of each partition.
|
| PartitionConsumptionState.TransientRecord |
This immutable class holds a association between a key and value and the source offset of the consumed message.
|
| PartitionDetail |
|
| PartitionDispatchHandler<H,P extends ResourcePath<K>,K,HTTP_REQUEST extends BasicRequest,HTTP_RESPONSE,HTTP_RESPONSE_STATUS> |
|
| PartitionDispatchHandler4<H,P extends ResourcePath<K>,K> |
|
| PartitionerConfig |
This interface defines all the public APIs, and if you need to add accessors to
some new fields, this interface needs to be changed accordingly.
|
| PartitionerConfig |
|
| PartitionerConfigImpl |
|
| PartitionerConfigRecord |
|
| PartitionerSchemaMismatchException |
|
| PartitionFinder<K> |
Provides methods to find the partition name for a piece of data.
|
| PartitionHealthStats |
Resource level partition health stats.
|
| PartitionReplicaIngestionContext |
This class is for wrapping the information about the role of the partition replica on that host to
AggKafkaConsumerService to achieve finer granularity of consumer assignment. |
| PartitionReplicaIngestionContext.VersionRole |
|
| PartitionReplicaIngestionContext.WorkloadType |
|
| PartitionResponse |
|
| PartitionSorter |
Sort the rows based on the key and value in ascending order using unsigned byte comparison.
|
| PartitionState |
This record holds the state necessary for a consumer to checkpoint its progress when consuming a Venice partition.
|
| PartitionStatus |
Class stores the status of one partition including all the replicas statuses in this partition.
|
| PartitionStatusBasedPushMonitor |
|
| PartitionStatusJSONSerializer |
|
| PartitionStatusJSONSerializer.PartitionStatusSerializerMixin |
|
| PartitionStatusJSONSerializer.ReplicaStatusSerializerMixin |
|
| PartitionStatusListener |
Listener used to listen the data change of partition status.
|
| PartitionTracker |
This class maintains state about all the upstream producers for a given partition.
|
| PartitionTracker.DIVErrorMetricCallback |
|
| PartitionTracker.TopicType |
|
| PartitionUtils |
|
| PartitionWiseKafkaConsumerService |
|
| PathResourceRegistry<T> |
|
| PauseStore |
|
| PendingConnectFuturePromise |
The implementation of this method is mostly similar to DefaultChannelFuture except that
we store the Channel inside a CompletableFuture because it is not yet known at the time
of construction.
|
| PendingConnectPromise |
The implementation of this method is mostly similar to DefaultChannelFuture except that
we store the Channel inside a CompletableFuture because it is not yet known at the time
of construction.
|
| PendingRequestThrottler |
This class maintains a simple counter for capacity management.
|
| PerClusterInternalRTStoreInitializationRoutine |
|
| Permission |
|
| PersistenceFailureException |
Thrown by the StorageEngine or Storage Partitions if storage fails
|
| PersistenceType |
Enums of persistence types in Venice.
|
| Persona |
A class to represent a Persona, a relationship between stores and a quota system that is enforced.
|
| PigzDeflateCompressor |
|
| PigzOutputStream |
|
| PigzOutputStream.Compressor |
|
| PollStrategy |
This interface is used inside of the MockInMemoryConsumer
in order to mess around with the way messages are delivered to the consuming code. |
| PoolStats |
|
| PoolStats.LifeCycleStats |
|
| PortableHttpResponse |
This interface exposes the commonalities between the Apache httpasyncclient and Netty and R2 client.
|
| Preconditions |
Utility methods for precondition checks.
|
| Predicate |
Functor interface for performing a predicate test on GenericRecord
|
| PredicateBuilder |
|
| Principal |
Represents an actor entry.
|
| ProcessShutdownCommand |
|
| ProcessUtil |
Utility methods for Processes.
|
| ProducerMetadata |
|
| ProducerPartitionState |
A record containing the state pertaining to the data sent by one upstream producer into one partition.
|
| ProducerTool |
|
| PromiseDelegate<V> |
A simple delegate class which wraps an existing Promise and permits
overriding of some of its methods.
|
| PropertyBuilder |
PropertyBuilder is the suggested Way to construct VeniceProperties.
|
| PubSubAdminAdapter |
An adapter for PubSubAdmin to create/delete/list/update topics.
|
| PubSubAdminAdapterFactory<ADAPTER extends PubSubAdminAdapter> |
Generic admin factory interface.
|
| PubSubClientException |
|
| PubSubClientRetriableException |
|
| PubSubClientsFactory |
A wrapper around pub-sub producer, consumer, and admin adapter factories
This will be passed as one of the arguments to the component which depends on the pub-sub APIs.
|
| PubSubConstants |
Constants used by pub-sub components.
|
| PubSubConstantsOverrider |
The purpose of this class is only to make the package private test-only functions of PubSubConstants
available to all packages within tests. |
| PubSubConsumerAdapter |
An adapter for consuming messages from a Pub-Sub topic.
|
| PubSubConsumerAdapterFactory<ADAPTER extends PubSubConsumerAdapter> |
Generic consumer factory interface.
|
| PubSubHelper |
|
| PubSubHelper.MutablePubSubMessage |
|
| PubSubMessage<K,V,OFFSET> |
|
| PubSubMessageCoder<K,V> |
|
| PubSubMessageDeserializer |
The class for deserializing messages from the pubsub specific message format to PubSubMessage |
| PubSubMessageHeader |
A key-value pair that is associated with a message
|
| PubSubMessageHeaders |
Set of key-value pairs to tagged with messages produced to a topic.
|
| PubSubMessageProcessedResult |
|
| PubSubMessageProcessedResultWrapper<K,V,OFFSET> |
|
| PubSubOpTimeoutException |
Used when an operation against PubSub failed to complete in time.
|
| PubSubPosition |
Represents a position of a message in a partition of a topic.
|
| PubSubPositionFactory |
Factory class for creating PubSubPosition objects from wire format
|
| PubSubPositionType |
Constants for the different types of positions
Do not change the values of these constants.
|
| PubSubPositionWireFormat |
|
| PubSubProducerAdapter |
The pub-sub producer interface with which venice writer's interact to send messages to pub-sub topic.
|
| PubSubProducerAdapterConcurrentDelegator |
This class will spin up multiple producer instances to speed up the producing.
|
| PubSubProducerAdapterConcurrentDelegator.ProducerQueueDrainer |
|
| PubSubProducerAdapterConcurrentDelegator.ProducerQueueNode |
|
| PubSubProducerAdapterDelegator |
|
| PubSubProducerAdapterFactory<ADAPTER extends PubSubProducerAdapter> |
Generic producer factory interface.
|
| PubSubProducerCallback |
A callback interface that users of PubSubProducerAdapter should implement if they want
to execute some code once PubSubProducerAdapter#sendMessage request is completed.
|
| PubSubProducerCallbackSimpleImpl |
A simple implementation of PubSubProducerCallback interface for testing purposes.
|
| PubSubProduceResult |
An interface implemented by specific PubSubProducerAdapters to return the result of a produce action.
|
| PubSubSecurityProtocol |
This enum is equivalent to Kafka's SecurityProtocol enum.
|
| PubSubTopic |
|
| PubSubTopicAuthorizationException |
Class for all Venice exceptions that are triggered by Kafka topic authorization related issues.
|
| PubSubTopicConfigResponse |
|
| PubSubTopicConfiguration |
|
| PubSubTopicDoesNotExistException |
The source or destination topic for the replication request does not exit
|
| PubSubTopicExistsException |
|
| PubSubTopicImpl |
|
| PubSubTopicPartition |
|
| PubSubTopicPartitionImpl |
|
| PubSubTopicPartitionInfo |
|
| PubSubTopicPartitionOffset |
|
| PubSubTopicRepository |
|
| PubSubTopicType |
|
| PubSubUnsubscribedTopicPartitionException |
|
| PushHealthStats |
|
| PushInputSchemaBuilder |
This class is a simple schema builder to generate Venice Push Job input file schema.
|
| PushJobCheckpoints |
Different successful checkpoints and known error scenarios of the VPJ flow.
|
| PushJobDetails |
|
| PushJobDetailsStatus |
|
| PushJobDetailsStatusTuple |
0 => STARTED, 1 => COMPLETED, 2 => ERROR, 3 => NOT_CREATED, 4 => UNKNOWN, 5 => TOPIC_CREATED, 6 => WRITE_TO_KAFKA_COMPLETED, 7 => KILLED, 8 => END_OF_PUSH_RECEIVED, 9 => START_OF_INCREMENTAL_PUSH_RECEIVED, 10 => END_OF_INCREMENTAL_PUSH_RECEIVED
|
| PushJobHeartbeatSender |
This interface provides methods to send push job heartbeats
|
| PushJobHeartbeatSenderFactory |
This interface provides methods to let users create a heartbeat provider
|
| PushJobSetting |
This class carries the state for the duration of the VenicePushJob.
|
| PushJobStatus |
|
| PushJobStatusRecordKey |
|
| PushJobStatusStats |
|
| PushJobStatusUploadResponse |
Response for uploading a job status record.
|
| PushJobZstdConfig |
|
| PushMonitor |
In Venice, Push is a task that asynchronously writes data to Venice.
|
| PushMonitorDelegator |
This class maintains the mapping of Kafka topic to each PushMonitor instance and delegates calls to the
correct instance. |
| PushMonitorType |
This enum controls the behavior of how PushMonitorDelegator chooses
proper PushMonitor for resources. |
| PushMonitorUtils |
This class contains some common util methods for push monitoring purpose.
|
| PushStatusCleanUpServiceState |
|
| PushStatusCleanUpStats |
|
| PushStatusCollector |
This class serves as a collector of offline push status for both Venice Server and Da Vinci clients.
|
| PushStatusDecider |
Decide the offline push status by checking all replicas statuses under different offline push strategies.
|
| PushStatusKey |
|
| PushStatusNotifier |
Notifies both OfflinePushStatus and Helix Customized View
|
| PushStatusResponse |
Push job status response for a resource; this is a response
that will be returned by Router.
|
| PushStatusStoreReader |
This class is a helper class for Venice controller to read PushStatus / Heartbeat messages.
|
| PushStatusStoreReader.InstanceStatus |
|
| PushStatusStoreUtils |
Helper class for PushStatusStore related logic.
|
| PushStatusStoreUtils.PushStatusKeyType |
|
| PushStatusStoreVeniceWriterCache |
Wrapper class for acquiring VeniceWriter for push status stores.
|
| PushStatusStoreWriter |
PushStatusStoreWriter is a helper class for Da Vinci to write PushStatus and heartbeat message into PushStatus store
real-time topic.
|
| PushStatusSystemStoreAutoCreationValidation |
|
| PushStatusValue |
|
| Put |
Put payloads contain a record value, and information on how to deserialize it.
|
| PutMetadata |
This is a simple container class to hold replication metadata related fields together to be passed on to the Put api in VeniceWriter
VeniceWriter#put(Object, Object, int, Callback, LeaderMetadataWrapper, long, PutMetadata).
|
| QOS |
Sets the quality of service (QOS) for the request.
|
| QOSBasedMultiQueue<T extends QOSBasedRequestRunnable> |
A fair multi-queue based upon a ring topology.
|
| QOSBasedQueue<T extends QOSBasedRequestRunnable> |
|
| QOSBasedRequestRunnable |
Wrapper class for "runnables" i.e.
|
| QOSFCFSQueue<T extends QOSBasedRequestRunnable> |
Simple wrapper over a ConcurrentLinkedQueue to expose FCFS Queue operations.
|
| QOSPolicy |
Enumerates all the QOS Policies supported.
|
| QOSPolicy.Config |
|
| QOSPolicy.StaticConfig |
|
| QueryAction |
|
| QueryParams |
A simple container with builder functions to sugar-coat the code a bit.
|
| QueryStringDecoder |
Imported this implementation from netty 3.2.4 because the implementation within 3.5.11 will corrupt
uri paths, converting ';' semicolons into '&' ampersands.
|
| QueryTool |
A tool use thin client to query the value from a store by the specified key.
|
| QuotaExceededException |
|
| R2TransportClient |
R2 based Transport Client Interface.
|
| R2TransportClient.R2TransportClientCallback |
|
| RandomAccessDaemonThreadFactory |
|
| RandomEventExecutorChooserFactory |
Created by acurtis on 12/12/16.
|
| RandomGenUtils |
|
| RandomPollStrategy |
A simple PollStrategy which delivers messages from any partition, while respecting the
ordering guarantee of individual partitions. |
| RateLimitConnectHandler |
Created by acurtis on 3/19/18.
|
| RateLimitedCreateLifeCycle<T> |
|
| RawBytesChunkingAdapter |
A ChunkingAdapter to be used when we want to read the value from storage engine as raw bytes.
|
| RawBytesStoreDeserializerCache |
|
| RawKeyBytesAndChunkedKeySuffix |
|
| ReadAvroProtocolDefinition |
TDOO: Consider merging with AvroProtocolDefinition
|
| ReadComputeOperator |
|
| ReadEnvelopeChunkedDeserializer<V> |
This class provides support to deserialize customized records even the input doesn't contain
the full record.
|
| ReadEnvelopeChunkedDeserializer.NotEnoughBytesException |
Exception when the deserialization hits partial record.
|
| ReadEnvelopeChunkedDeserializer.ValueContainer<V> |
This class contains two fields:
1.
|
| ReadMetadataRetriever |
|
| ReadOnlyLiveClusterConfigRepository |
|
| ReadOnlyPartitionStatus |
|
| ReadOnlySchemaRepository |
|
| ReadOnlyStore |
A read-only wrapper of Store, and all the modification to delegated instance
will throw UnsupportedOperationException. |
| ReadOnlyStore.ReadOnlyVersion |
|
| ReadOnlyStoreConfigRepository |
Interface defined the way to retrieve the store config from a repository.
|
| ReadOnlyStoreRepository |
Interface defined readonly operations to access stores.
|
| ReadOnlyViewConfig |
|
| ReadPersona |
A type of Persona that enforces a read (bandwidth) limit across multiple stores. |
| ReadQuotaEnforcementHandler |
|
| ReadQuotaEnforcementHandler.QuotaEnforcementResult |
|
| ReadRequestThrottler |
This class define the throttler on reads request.
|
| ReadResponse |
This is used to store common fields shared by various read responses.
|
| ReadResponseStats |
This class is used to accumulate stats associated with a read response.
|
| ReadResponseStatsRecorder |
This class is used to record stats associated with a read response.
|
| ReadStrategy |
Enums of the strategies used to read data from multiple replications in Venice.
|
| ReadWriteLiveClusterConfigRepository |
|
| ReadWriteSchemaRepository |
|
| ReadWriteStoreRepository |
Interface defined read and write operations to access stores.
|
| ReadyForDataRecoveryResponse |
|
| RealTimeTopicSwitcher |
Class which implements the process of switching from a batch topic (e.g.
|
| RecordChangeEvent |
Schema which describes a record change event in a Venice store.
|
| RecordChangeEventReadOnlySchemaRepository |
TODO: This class is a bit of a hack.
|
| RecordDeserializer<T> |
|
| RecordSerializer<T> |
|
| RecordStreamDecoder |
|
| RecordTooLargeException |
|
| RecoverStoreMetadata |
|
| RedundantExceptionFilter |
|
| ReferenceCounted<T> |
|
| ReflectUtils |
Utilities for reflection
TODO This class may not be needed if we decide to proceed with Guice library
for reflections and need to be discarded then
|
| RegionNameUtil |
|
| RegionPushDetails |
|
| RegionPushDetailsResponse |
|
| RegionUtils |
|
| RelayNotifier |
RelayNotifier is a VeniceNotifier which takes in a target VeniceNotifier and forward all actions to the target notifier.
|
| RemoteIngestionRepairService |
Singleton class meant to keep track of subscription failures for ingestion tasks where the ingestion
task needs to keep running despite cluster failures.
|
| Replica |
Replica is the basic unit to distribute data, replica is belong to a partition and running in a instance.
|
| ReplicaDetail |
|
| ReplicaHeartbeatInfo |
|
| ReplicaIngestionResponse |
|
| ReplicaState |
|
| ReplicaStatus |
Class stores replica status and history.
|
| ReplicationMetadataRocksDBStoragePartition |
|
| ReplicationMetadataSchemaEntrySerializer |
This class is registered in ZKClient to handle Replication metadata schema serialization.
|
| ReplicationMetadataSchemaRepository |
|
| Reporter |
|
| ReporterBackedMapReduceDataWriterTaskTracker |
An interface to report and retrieve metrics related to data writer tasks during the execution of a MapReduce job.
|
| RepushInfo |
|
| RepushInfoResponse |
|
| RepushViabilityInfo |
|
| RepushViabilityInfo.Result |
|
| RequestBasedMetadata |
Store metadata class that uses the server's endpoint to fetch metadata and keep the local cache up to date.
|
| RequestConstants |
Created by mwise on 3/16/16.
|
| RequestContext |
This class is used to include all the intermediate fields required for the communication between the different tiers.
|
| RequestHeadersProvider |
Provide the appropriate headers based on the request type for all remote Venice clients.
|
| RequestHelper |
|
| RequestRetriableChecker<P,R,HRS> |
|
| RequestRetryAbortReason |
|
| RequestRetryType |
|
| RequestType |
|
| RequestValidationOutcome |
|
| ResolveAllBootstrap |
The existing Netty Bootstrap has a limitation regarding connecting to remote hosts
where the hostname resolves to more than one IP address.
|
| Resource |
Represents a resource identified by "name".
|
| ResourceAssignment |
Assignments for all of resources.
|
| ResourceAssignment.ResourceAssignmentChanges |
|
| ResourceAutoClosableLockManager<T> |
This class maintains a map from resource of a certain type to its lock.
|
| ResourcePath<K> |
|
| ResourcePathParser<P extends ResourcePath<K>,K> |
|
| ResourceReadUsageTracker |
This interface defines the API to track the read usage per resource.
|
| ResourceRegistry |
|
| ResourceRegistry.Factory<R extends ShutdownableResource> |
Factories must implement this interface.
|
| ResourceRegistry.ShutdownFirst |
|
| ResourceRegistry.ShutdownLast |
|
| ResourceRegistry.Sync |
Resources which implement ResourceRegistry.Sync will be shut down after preceding resources have finished shutting down
and further resources will shut down after it has completed shutting down. |
| ResourceRegistryTestBase |
|
| ResourceStateResponse |
|
| ResourceStillExistsException |
|
| ResponseAggregatorFactory<BASIC_HTTP_REQUEST extends BasicRequest,HTTP_RESPONSE> |
Created by acurtis on 6/19/17.
|
| ResponseStatsUtil |
|
| ResumeStore |
|
| RetriableAvroGenericStoreClient<K,V> |
This class is mostly used to trigger retry in the following scenarios:
1.
|
| RetriableAvroSpecificStoreClient<K,V extends org.apache.avro.specific.SpecificRecord> |
|
| RetriableStoreClient<K,V> |
TODO: make retry work for compute request.
|
| RetryCounter |
A non-thread safe counter that should be used and increased in a single thread env when the increment is called
|
| RetryCountSlidingWindow |
A Sliding Window implementation that is implemented as followed:
1.
|
| RetryManager |
|
| RetryManagerStats |
|
| RetryUtils |
|
| RetryUtils.IntermediateFailureHandler |
|
| ReusableGzipOutputStream |
This class implements a stream filter for writing compressed data in the GZIP file format.
|
| ReverseHandler |
Reverse the polarity of the streams!
Created by acurtis on 6/26/17.
|
| RmdConstants |
This is an util class that contains constants related to replication metadata.
|
| RmdDeserializerCache<T> |
Container for the deserializers of a single store.
|
| RmdSchemaEntry |
This holds the schema to perform conflict resolution on records when samza produces data in
active active replication mode.
|
| RmdSchemaGenerator |
This is simply a wrapper class to delegate the actual schema generation to version specific adapter.
|
| RmdSchemaGeneratorV1 |
This class helps in generating a active-active metadata schema to hold update timestamps and offsets from a value schema of a store .
|
| RmdSerDe |
This class is responsible for serialization and deserialization related tasks.
|
| RmdTimestampType |
Type of the replication metadata timestamp.
|
| RmdUtils |
Ths class is responsible for deserializing RMDs and extract some information from it.
|
| RmdVersionId |
|
| RmdWithValueSchemaId |
A POJO class that contains 3 things/fields:
1.
|
| RocksDBBlockCacheImplementations |
|
| RocksDBMemoryStats |
Class that exposes RocksDB memory consumption stats based on all properties
that are made available in https://github.com/facebook/rocksdb/blob/master/include/rocksdb/db.h#L870
Properties exist on a per RockDB database basis (equivalent to a Venice partition).
|
| RocksDBServerConfig |
|
| RocksDBSstFileWriter |
|
| RocksDBStats |
Check TickerType to find more details about RocksDB metrics.
|
| RocksDBStorageEngine |
|
| RocksDBStorageEngineFactory |
|
| RocksDBStorageIterator |
|
| RocksDBStoragePartition |
|
| RocksDBThrottler |
This class is used to throttle RocksDB operations.
|
| RocksDBThrottler.RocksDBSupplier |
|
| RocksDBUtils |
|
| RoleFinder<Role> |
|
| RollbackCurrentVersion |
|
| RollForwardCurrentVersion |
|
| RouteHttpRequestStats |
This class stores the stats for combined all type(SINGLE/MULTI/COMPUTE etc) of Router requests to the HttpAsync client compared
to RouteHttpStats which stores only per type stats. |
| RouteHttpStats |
|
| Router |
|
| Router.Builder |
|
| Router.PipelineFactory<CHANNEL_HANDLER> |
|
| Router4<C extends io.netty.channel.Channel> |
|
| Router4Impl<C extends io.netty.channel.Channel> |
|
| Router4PipelineFactory<C extends io.netty.channel.Channel> |
|
| RouterBackedSchemaReader |
|
| RouterBasedHybridStoreQuotaMonitor |
This push monitor is able to query hybrid store quota status from routers
|
| RouterBasedHybridStoreQuotaMonitor.HybridQuotaMonitorTask |
|
| RouterBasedHybridStoreQuotaMonitor.TransportClientReinitProvider |
|
| RouterBasedPushMonitor |
This push monitor is able to query push job status from routers; it only works for
stores running in Leader/Follower mode and it will be built for STREAM_REPROCESSING job.
|
| RouterBasedStoreSchemaFetcher |
|
| RouterClusterConfigJSONSerializer |
Serializer used to convert data between RouterClusterConfig Object and JSON string
|
| RouterCurrentVersionStats |
|
| RouterException |
Exception class for checked exceptions within the Espresso Router.
|
| RouterExceptionAndTrackingUtils |
Right now, there is no simple way to capture all the exception cases with DDS Router.
|
| RouterExceptionAndTrackingUtils.FailureType |
|
| RouterHeartbeat |
RouterHeartbeat is a service that monitors and reports the health of current live instances in the Venice cluster.
|
| RouterHttpRequestStats |
|
| RouterKey |
RouterKey encapsulates the required information for a key in a router request.
|
| RouterMetricEntity |
List all Metric entities for router
|
| RouterPipelineFactory<CHANNEL_HANDLER> |
|
| RouterRequest |
RouterRequest is an abstract base class for single-get and multi-get operations.
|
| RouterRequestHttpHandler |
Monitors the stream, when it gets enough bytes that form a genuine object,
it deserializes the object and passes it along the stack.
|
| RouterResourceType |
|
| RoutersClusterConfig |
Cluster level metadata for all routers.
|
| RoutersClusterConfigResponse |
|
| RoutersClusterConfigRoutes |
|
| RoutersClusterManager |
This interface define the operations used to manage all routers in a cluster.
|
| RoutersClusterManager.RouterCountChangedListener |
|
| RouterServer |
|
| RouterSslVerificationHandler |
|
| RouterStats<STAT_TYPE> |
|
| RouterStoreAclHandler |
Store-level access control handler, which is being used by both Router and Server.
|
| RouterThrottleHandler |
|
| RouterThrottler |
|
| RouterThrottleStats |
|
| RouterTimeoutProcessor |
|
| RouterTimeoutProcessor.TimeoutFuture |
|
| RoutingDataRepository |
Repository to access routing data like Partition and replica.
|
| RoutingDataRepository.RoutingDataChangedListener |
|
| RoutingStrategy |
Enums of strategies used to route the key to partition in Venice.
|
| RowToAvroConverter |
A utility class to convert Spark SQL Row to an Avro GenericRecord with the specified schema.
|
| RunnableScheduledFuture<V> |
|
| RunOnce |
A simple filter Runnable which will only invoke the contained runnable no more than once.
|
| SafeAllocator |
An instance of SafeAllocator may be used to wrap an existing ByteBufAllocator
to provide insurance against slow memory leaks from exceptional conditions by providing a means
for the leaked ByteBuf objects to be reclaimed. |
| SafeAllocatorMetric |
|
| SafeHelixDataAccessor |
A wrapper around HelixDataAccessor which disables the unsafe functionality.
|
| SafeHelixManager |
A wrapper around HelixManager which disables the unsafe functionality.
|
| SamzaExitMode |
Various methods for stopping/exiting a Samza task.
|
| Scatter<H,P extends ResourcePath<K>,K> |
Collection of ScatterGatherRequests for a request to the router.
|
| ScatterGatherHelper<H,P extends ResourcePath<K>,K,R,BASIC_HTTP_REQUEST extends BasicRequest,HTTP_RESPONSE,HTTP_RESPONSE_STATUS> |
|
| ScatterGatherHelper.Builder<H,P extends ResourcePath<K>,K,R,HTTP_REQUEST extends BasicRequest,HTTP_RESPONSE,HTTP_RESPONSE_STATUS> |
|
| ScatterGatherMode |
Created by acurtis on 6/20/17.
|
| ScatterGatherRequest<H,K> |
Routing information for part of a request which the router has mapped to a single storage node.
|
| ScatterGatherRequestHandler<H,P extends ResourcePath<K>,K,R> |
|
| ScatterGatherRequestHandler4<H,P extends ResourcePath<K>,K,R> |
|
| ScatterGatherRequestHandlerImpl<H,P extends ResourcePath<K>,K,R,CHC,BHS extends BasicRequest,HR,HRS extends io.netty.handler.codec.http.HttpResponseStatus,SCATTER_GATHER_HELPER extends ScatterGatherHelper<H,P,K,R,BHS,HR,HRS>> |
|
| ScatterGatherStats |
|
| ScatterGatherStatsMBean |
|
| ScheduledExecutorService |
|
| ScheduledFuture<V> |
|
| SchemaAdapter |
Try to adapt the {@param datum} to the {@param expectedSchema}.
|
| SchemaAndToString |
Used to cache the toString of a given schema, since it is expensive to compute.
|
| SchemaCompatibility |
Evaluate the compatibility between a reader schema and a writer schema.
|
| SchemaCompatibility.SchemaCompatibilityType |
Identifies the type of a schema compatibility result.
|
| SchemaCompatibility.SchemaPairCompatibility |
Provides information about the compatibility of a single reader and writer schema pair.
|
| SchemaData |
This class is used to store all the schemas related to a given store:
1.
|
| SchemaDuplicateException |
|
| SchemaEntry |
SchemaEntry is composed of a schema and its corresponding id. |
| SchemaEntrySerializer |
This class to use to serialize/deserialize Zookeeper node
|
| SchemaIncompatibilityException |
Throw this exception when the schema is not fully compatible with the previous ones.
|
| SchemaMeta |
|
| SchemaPresenceChecker |
This class helps checks presence of a schema version in ZK.
|
| SchemaReader |
This interface is considered as an internal interface to Venice codebase.
|
| SchemaRepoBackedSchemaReader |
|
| SchemaResponse |
|
| SchemaRoutes |
|
| SchemaSource |
A high-level interface as a source specifically for RmdSchema.
|
| SchemaType |
|
| SchemaUsageResponse |
|
| SchemaUtils |
|
| SecureClientHandler |
This is a port of the com.linkedin.security.netty.ssl.access.control.SecureClientHandler class as
a netty 4 implementation.
|
| SecurityStats |
|
| Segment |
A segment is a sequence of messages sent by a single producer into a single partition.
|
| SegmentStatus |
|
| SentPushJobDetailsTracker |
Interface of class that is used to keep track of push job details sent to the Venice controller.
|
| SeparatedStoreBufferService |
This store buffer services maintains two separate drainer queues for store ingestions.
|
| SerializableSystemStore |
|
| SerializerDeserializerFactory |
For one given store, the client only needs the followings:
1.
|
| SerializerDeserializerFactory.SchemaPairAndClassContainer |
|
| ServerAclHandler |
|
| ServerAdminAction |
|
| ServerBlobFinder |
|
| ServerConfigSnapshot |
|
| ServerConnectionStats |
|
| ServerConnectionStatsHandler |
|
| ServerCurrentVersionResponse |
|
| ServerHandlerUtils |
|
| ServerHttpRequestStats |
ServerHttpRequestStats contains a list of counters in order to mainly measure the performance of
handling requests from Routers.
|
| ServerMetadataServiceStats |
|
| ServerReadMetadataRepository |
A wrapper that holds reference for various repositories responsible for constructing metadata responses upon request.
|
| ServerReadQuotaUsageStats |
For measuring quota requests and rejections for a given store.
|
| ServerStatsContext |
We need to be able to record server side statistics for gRPC requests.
|
| ServerStoreAclHandler |
Together with ServerAclHandler, Server will allow two kinds of access pattern:
1. |
| ServiceDiscoveryAnnouncer |
This interface is used to announce the service to a Service Discovery system on startup and de-announce the service
on graceful shutdown.
|
| ServiceDiscoveryAnnouncerRetryTask |
|
| ServiceDiscoveryException |
|
| SetStoreCurrentVersion |
|
| SetStoreOwner |
|
| SetStorePartitionCount |
|
| SharedHelixReadOnlyZKSharedSchemaRepository |
This class is intended to only be used in Controller, which is sharing one instance across
all the clusters.
|
| SharedHelixReadOnlyZKSharedSystemStoreRepository |
This class is intended to only be used in Controller, which is sharing one instance across
all the clusters.
|
| SharedInternalRTStoreInitializationRoutine |
|
| SharedKafkaProducerConfig |
A class containing shared kafka producer related configurations.
|
| SharedObjectFactory<T> |
A factory class to create shared objects that need to release resources cleanly.
|
| Shutdownable |
|
| ShutdownableChannelGroup |
|
| ShutdownableEventLoopGroup<E extends io.netty.channel.EventLoopGroup> |
Created by acurtis on 3/30/17.
|
| ShutdownableExecutors |
|
| ShutdownableExecutorService |
|
| ShutdownableExecutorServiceImpl<E extends ExecutorService> |
|
| ShutdownableHashedWheelTimer |
|
| ShutdownableNioEventLoopGroup |
|
| ShutdownableResource |
|
| ShutdownableScheduledExecutorService |
|
| ShutdownableScheduledExecutorServiceImpl<E extends ScheduledExecutorService> |
|
| SimpleChannelInitializer<C extends io.netty.channel.Channel> |
Created by acurtis on 4/27/18.
|
| SimpleChannelPoolManagerImpl |
|
| SimpleJsonMapper |
A VERY simple JSON mapper.
|
| SimplePartitioner |
This VenicePartitioner implementation takes the first byte of the key,
and computes the partition as such:
firstByte % numPartitions
It is meant to be used in tests where we want to control the partition that a
key belongs to, but without needing to work out a proper input that yields the
desired partition when hashed by the
DefaultVenicePartitioner. |
| SimplePubSubProduceResultImpl |
A simple implementation of PubSubProduceResult interface for testing purposes.
|
| SimpleQueue<T> |
Simplified Queue Interface that supports basic operations like add(), poll() etc akin to the operations on
Queue.
|
| SimpleStringSerializer |
|
| SingleGetChunkingAdapter |
Single get chunking adapter
|
| SingleGetResponseStats |
|
| SingleGetResponseWrapper |
|
| SingleThreadEventLoopGroup |
Created by acurtis on 3/30/17.
|
| SingleThreadEventLoopGroupSupplier |
Created by acurtis on 3/30/17.
|
| SkipAdminRoute |
|
| SlowFieldAccessor<T,V> |
Field accessor using Reflection.
|
| SlowFieldAccessorHelper |
|
| SnappyDecoder |
|
| SnappyEncoder |
|
| SoftThreadLocal<T> |
This class provides thread-local variables with SoftReference semantics.
|
| SortBasedCollectionFieldOpHandler |
|
| SparkConstants |
|
| SparkDataWriterTaskTracker |
|
| SparkEngineTaskConfigProvider |
|
| SparkInputRecordProcessor |
An implementation of AbstractInputRecordProcessor for Spark that processes input records from the dataframe
and emits an Iterator of Row with DEFAULT_SCHEMA as the schema. |
| SparkInputRecordProcessorFactory |
|
| SparkPartitionUtils |
Spark partitioning functionality in Dataframe and Dataset APIs is not very flexible.
|
| SparkPartitionWriter |
|
| SparkPartitionWriterFactory |
|
| SparkScalaUtils |
Utility methods for restricting Scala-ism in Spark code in a single class.
|
| SparkServerStats |
|
| SparseConcurrentList<E> |
A List implementation with some usability improvements around resizing.
|
| SparseConcurrentListWithOffset<E> |
|
| SpecificRecordChunkingAdapter<V extends org.apache.avro.specific.SpecificRecord> |
|
| SpecificRetriableStoreClient<K,V extends org.apache.avro.specific.SpecificRecord> |
|
| SpecificStatTrackingStoreClient<K,V extends org.apache.avro.specific.SpecificRecord> |
|
| SslClientInitializer |
Created by acurtis on 9/7/17.
|
| SSLConfig |
|
| SSLConfig |
|
| SSLConfig.ConfigHelper |
|
| SSLConfig.ConfigHelper.MissingConfigParameterException |
|
| SSLConfigurator |
|
| SSLContextBuilder |
Builds a new instance of SSLContext object from given key store and trust store parameters.
|
| SSLContextBuilder |
Created by acurtis on 4/19/18.
|
| SSLEngineFactory |
Factory interface to create SSLEngine and get SSLSessionContext objects for Netty4 pipelines
|
| SSLEngineFactoryImpl |
|
| SSLEngineFactoryImpl.Config |
|
| SslFactory |
SSL Factory interface to get common SSL objects.
|
| SSLFactory |
Venice SSL Factory interface.
|
| SslInitializer |
Created by acurtis on 9/7/17.
|
| SslUtils |
|
| SslUtils.VeniceTlsConfiguration |
This class is used to configure TLS for Venice components in integration tests.
|
| SslUtils.VeniceTlsConfiguration.Builder |
|
| StaleConnectionHandler |
This handler closes the connection when a ReadTimeoutException occurs.
|
| StaleVersionReason |
This enum is used to denote why a particular store version was found to be stale
|
| StaleVersionStats |
|
| StartOfBufferReplay |
This ControlMessage is sent by the Controller, once per partition, after the EndOfPush ControlMessage, in Hybrid Stores that ingest from both offline and nearline sources.
|
| StartOfIncrementalPush |
This ControlMessage is sent per partition by each offline incremental push job, once per partition, at the beginning of a incremental push.
|
| StartOfPush |
This ControlMessage is sent once per partition, at the beginning of a bulk load, before any of the data producers come online.
|
| StartOfSegment |
This ControlMessage is sent at least once per partition per producer.
|
| StateModelIngestionProgressNotifier |
This class notifies the Helix State Models (SM) about corresponding ingestion progress.
|
| StaticAccessController |
A StaticAccessController is an AccessController with an immutable resource list.
|
| StaticClusterInfoProvider |
|
| StatsAvroGenericDaVinciClient<K,V> |
Currently, we only expose metrics for single-get and batch-get requests, and if there
is a need to have metrics for other request types, we can add them later.
|
| StatsAvroGenericStoreClient<K,V> |
This class is in charge of all the metric emissions per request.
|
| StatsAvroSpecificDaVinciClient<K,V extends org.apache.avro.specific.SpecificRecord> |
|
| StatsAvroSpecificStoreClient<K,V extends org.apache.avro.specific.SpecificRecord> |
|
| StatsErrorCode |
This enum tracks the error codes that we use to report anomalies in metrics.
|
| StatsHandler |
|
| StatsSupplier<T extends AbstractVeniceStats> |
|
| StatsUtils |
|
| StatTrackingStoreClient<K,V> |
This class is used to handle all the metric related logic.
|
| StatusMessage |
Venice control message which is used to transfer command and status between storage node and controller, so that
controller could control the whole cluster and make the global decision.
|
| StatusMessageChannel |
Channel used to send and receive control message.
|
| StatusMessageHandler<T extends StatusMessage> |
|
| StatusSnapshot |
The snapshot of status change.
|
| StickyEventExecutorChooserFactory |
Created by acurtis on 12/12/16.
|
| StoppableNodeStatusResponse |
|
| StorageClass |
|
| StorageEngineBackedCompressorFactory |
|
| StorageEngineFactory |
An abstraction that represents the shared resources of a persistence engine.
|
| StorageEngineInitializationException |
This exception indicates that the server was unable to initialize on or more
storage services or stores within a service.
|
| StorageEngineMetadataService |
StorageEngineMetadataService is wrapper service on top of storageEngineRepository to serve read/write to storage metadata.
|
| StorageEngineOverheadRatioResponse |
|
| StorageEngineRepository |
A wrapper class that holds all the server's storage engines.
|
| StorageInitializationException |
thrown by StorageEngineFactory and AbstractStorageEngine when storage creation fails
|
| StorageMetadataService |
This is a superset of the OffsetManager APIs, which also provide functions for storing store-version level state.
|
| StorageNodeClient |
|
| StorageNodeClientType |
|
| StorageNodeStatus |
Class used to represent the status of storage node.
|
| StoragePartitionConfig |
Storage partition level config, which could be used to specify partition specific config when
initializing/opening the corresponding AbstractStoragePartition. |
| StoragePartitionDiskUsage |
This class maintains in-memory partition usage.
|
| StoragePartitionInitializationException |
This exception indicates that the server was unable to initialize on or more
storage services or stores within a service.
|
| StoragePersona |
A type of Persona that enforces a storage (size) limit across multiple stores. |
| StoragePersonaAccessor |
Zookeeper accessor for StoragePersona objects, allowing for read/write to persona paths. |
| StoragePersonaJSONSerializer |
Serializer used to convert the data between Persona and json. |
| StoragePersonaJSONSerializer.StoragePersonaSerializerMixin |
This class annotates the constructor for StoragePersona and serves as a property-based creator. |
| StoragePersonaRepository |
Cached wrapper for the StoragePersonaAccessor class, which keeps a map of store names to personas that
contain them, as well as caches Zookeeper personas. |
| StoragePersonaRepository.StoragePersonaStoreDataListener |
Helper class which listens to changes from a ReadOnlyStoreRepository and updates the caches and ZK of the
StoragePersonaRepository accordingly. |
| StoragePersonaResponse |
|
| StoragePersonaRoutes |
|
| StorageReadRequestHandler |
StorageReadRequestHandler will take the incoming read requests from router RouterRequest, and delegate
the lookup request to a thread pool StorageReadRequestHandler.executor, which is being shared by all the requests. |
| StorageService |
Storage interface to Venice Server, Da Vinci and Isolated Ingestion Service.
|
| StorageUtilizationManager |
This class has the following responsibilities:
1.
|
| Store |
This interface defines all the public APIs, and if you need to add accessors to
some new fields, this interface needs to be changed accordingly.
|
| StoreAttributes |
This type of metadata contains various store properties/configs and describes the clusters that store is materialized in.
|
| StoreAwarePartitionWiseKafkaConsumerService |
|
| StoreBackend |
|
| StoreBackendConfig |
|
| StoreBackendStats |
|
| StoreBackupVersionCleanupService |
This service is in charge of cleaning up backup versions based on retention policy defined on store basis.
|
| StoreBackupVersionCleanupServiceStats |
|
| StoreBufferService |
This class is serving as a PubSubMessage buffer with an accompanying pool of drainer threads. |
| StoreBufferServiceStats |
|
| StoreCacheStats |
|
| StoreCleaner |
|
| StoreClientTestUtils |
|
| StoreClusterConfig |
This type describes the various Venice cluster information for a store
|
| StoreComparisonInfo |
|
| StoreComparisonResponse |
|
| StoreConfig |
Configurations of a store which are non-cluster specified.
|
| StoreConfigJsonSerializer |
|
| StoreConfigJsonSerializer.StoreConfigSerializerMixin |
|
| StoreCreation |
|
| StoreDataAudit |
This is a class used to manage multiple replicas of the same store.
|
| StoreDataChangedListener |
Interface used to register into metadata repository to listen the change of store data.
|
| StoreDeserializerCache<T> |
|
| StoreDisabledException |
|
| StoreETLConfig |
|
| StoreGraveyard |
The graveyard used to keep all deleted stores.
|
| StoreGraveyardCleanupService |
This service is in charge of removing stores under /venice//StoreGraveyard zk path.
|
| StoreHealthAuditResponse |
|
| StoreHybridConfig |
|
| StoreInfo |
Json-serializable class for sending store information to the controller client
|
| StoreIngestionService |
An interface for Store Ingestion Service for Venice.
|
| StoreIngestionTask |
A runnable Kafka Consumer consuming messages from all the partition assigned to current node for a Kafka Topic.
|
| StoreIngestionTask.DelegateConsumerRecordResult |
|
| StoreIngestionTaskFactory |
|
| StoreIngestionTaskFactory.Builder |
Builder class for StoreIngestionTaskFactory; once the build() function is invoked,
no modification is allowed on any parameters. |
| StoreJSONSerializer |
Serializer used to convert the data between Store and json.
|
| StoreJSONSerializer.ETLStoreConfigSerializerMixin |
|
| StoreJSONSerializer.HybridStoreConfigSerializerMixin |
Mixin used to add the annotation to figure out the constructor used by Jackson lib when deserialize the version
|
| StoreJSONSerializer.PartitionerConfigSerializerMixin |
|
| StoreJSONSerializer.StoreSerializerMixin |
Mixin used to add the annotation to figure out the constructor used by Jackson lib when deserialize the store.
|
| StoreJSONSerializer.VersionSerializerMixin |
Mixin used to add the annotation to figure out the constructor used by Jackson lib when deserialize the version
|
| StoreJSONSerializer.ViewConfigSerializerMixin |
|
| StoreKeySchemaExistException |
Throw this exception when try to add key schema to a store, whose key schema already exists.
|
| StoreKeySchemas |
This type of store metadata describes the key schemas of the store
|
| StoreKeySchemas |
This type describes the key schemas of the store
|
| StoreLifecycleEventOutcome |
|
| StoreLifecycleHooks |
This interface defines a set of lifecycle events for stores and their store-versions.
Pre-hooks and post-hooks
Most events have a pre- and post- variant, all pre-hooks provide an option to control the outcome of the event
(e.g.
|
| StoreListChangedListener |
Interface used to register into metadata repository to listen the change of store list.
|
| StoreMetadata |
|
| StoreMetadataFetchMode |
Modes that control how fast client will fetch store metadata
|
| StoreMetadataKey |
A composite key that divides the key space to retrieve different types of metadata for a Venice store.
|
| StoreMetadataType |
|
| StoreMetadataValue |
|
| StoreMetaKey |
A composite key that divides the key space to retrieve different types of metadata for a Venice store.
|
| StoreMetaValue |
|
| StoreMigrationResponse |
|
| StorePartitionDataReceiver |
|
| StorePartitionerConfig |
|
| StoreProperties |
|
| StoreProperties |
This type contains all the store configs and the corresponding versions
|
| StoreReplicaStatus |
This structure will contain all kinds of info related to one replica
|
| StoreRepushCommand |
StoreRepushCommand contains the details of executing/processing repush command.
|
| StoreRepushCommand.Params |
|
| StoreRepushCommand.Params.Builder |
|
| StoreRepushCommand.Result |
|
| StoreResponse |
|
| StoreSchemaFetcher |
This class is the public interface for Venice store user to fetch store schemas.
|
| StoresRoutes |
|
| StoreStateReader |
This class retrieves the corresponding Store object from a router endpoint which contains the latest store state.
|
| StoreStats |
|
| StoreStatus |
|
| StoreStatusDecider |
|
| StoreStatusMessage |
Control description used to notify controller that the status of Offline push in Storage node.
|
| StoreUtils |
|
| StoreValueSchema |
This type describes a single version of the value schema of the store.
|
| StoreValueSchemas |
This type of store metadata describes the value schemas of the store.
|
| StoreValueSchemas |
This type describes the value schemas of the store.
|
| StoreValueSchemasCacheService |
This class implements the fast value schema/latest value schema lookup with acceptable delay.
|
| StoreVersion |
Type describes all the version attributes
|
| StoreVersionLifecycleEventOutcome |
A hook which returns this enum has the option of proceeding, aborting, waiting or rolling back.
|
| StoreVersionNotFoundException |
|
| StoreVersionState |
This record maintains store-version level state, such as the StartOfBufferReplay Control Message, in the case of Hybrid Stores.
|
| StoreVersionState |
|
| StoreViewConfig |
A configuration for a particular view.
|
| StoreViewConfigRecord |
A configuration for a particular view.
|
| StoreViewUtils |
|
| StoreWriteComputeProcessor |
This class handles Write Compute operations related to a specific store.
|
| StreamingCallback<K,V> |
|
| StreamingCallback<T> |
|
| StreamingConstants |
|
| StreamingFooterRecordV1 |
This record will store all the additional info after sending out streaming response
|
| StreamingResponseTracker |
This class provides percentile tracking and stats emission for streaming response
|
| StreamingUtils |
|
| StringAnnotatedStoreSchemaCache |
This class serves as the annotated schema cache for merge conflict resolution purpose in Active/Active replication.
|
| StringSerializer |
|
| StringToLongMapJSONSerializer |
|
| StripedAccumulator<A> |
|
| StuckConsumerRepairStats |
|
| SubprocessBuilder |
A proxy class for java.lang.ProcessBuilder which may be overridden
for purposes of test.
|
| SubscriptionBasedReadOnlyStoreRepository |
Interface defined subscription based readonly operations to access stores.
|
| SubscriptionBasedStoreRepository |
|
| SuccessAsyncFuture<T> |
A simple implementation of AsyncFuture which behaves as if the Future has already
completed successfully. |
| SuccessfulStreamingResponse |
Full response to indicate that all the sub responses are with good status: HttpResponseStatus.OK
for streaming request.
|
| SupersetSchemaCreation |
|
| SupersetSchemaGenerator |
|
| SupersetSchemaGeneratorWithCustomProp |
This class would copy the specified SupersetSchemaGeneratorWithCustomProp.customProp from the latest value schema to the generated
superset schema and in the meantime, the compare method in this impl will consider this extra property as well.
|
| SyncResourceRegistry |
|
| SyncShutdownable |
|
| SyncShutdownableAdapter |
|
| SystemSchemaInitializationRoutine |
|
| SystemStore |
This SystemStore class is a wrapper of the corresponding zk shared system store and the regular venice store to provide
the exact same interface as the regular Venice Store for System Stores.
|
| SystemStoreAclSynchronizationTask |
Currently, acl creation is still managed by Nuage but Nuage is not aware about the system stores.
|
| SystemStoreAttributes |
|
| SystemStoreAttributesImpl |
|
| SystemStoreHealthCheckStats |
|
| SystemStoreHeartbeatResponse |
|
| SystemStoreInitializationHelper |
This class contains the logic to set up system stores.
|
| SystemStoreJSONSerializer |
|
| SystemStoreJSONSerializer.SystemStoreSerializerMixin |
|
| SystemStoreProperties |
This type describes all the distinct properties
|
| SystemStoreRepairService |
This class is the system store repair service in Venice parent controller.
|
| SystemStoreRepairTask |
This class tries to scan all cluster which current parent controller is the leader controller.
|
| SystemTime |
Time implementation that just reads from the system clock |
| TargetVersionStates |
This type of store metadata contains the target version states announced by the parent controller leader for a given store that each fabric should be bootstrapping towards.
|
| TaskTracker |
An interface to report task health and track task progress for different execution engines
|
| TehutiMetricNameEnum |
Interface for creating metric names enum for tehuti metrics
|
| TehutiUtils |
Utils for venice metrics
|
| TehutiUtils.RatioStat |
Generate a ratio stat that is based on two arbitrary Rate.
|
| TehutiUtils.SimpleRatioStat |
Generate a ratio stat that is based on two arbitrary MeasurableStat.
|
| TempFileSSLConfigurator |
|
| TerminalStateTopicCheckerForParentController |
A task that periodically polls the job state for existing version topics in the parent fabric.
|
| TestKeyRecord |
|
| TestMockTime |
A Time implementation which abstracts logical time away from real
time, so that it can be deterministically controlled. |
| TestStoragePersonaUtils |
|
| TestUtil |
|
| TestUtils |
General-purpose utility functions for tests.
|
| TestUtils.NonDeterministicAssertion |
|
| TestValueRecord |
|
| TestValueRecordWithMoreFields |
|
| TestWriteUtils |
|
| TestWriteUtils.TestRecordType |
|
| TestWriteUtils.TestTargetedField |
|
| ThinClientMetaStoreBasedRepository |
|
| ThreadedAccumulator<T,A,R> |
|
| ThreadPoolExecutor |
An ExecutorService that executes each submitted task using
one of possibly several pooled threads, normally configured
using Executors factory methods. |
| ThreadPoolFactory |
|
| ThreadPoolStats |
Stats used to collect the usage of a thread pool including: 1.
|
| Threadsafe |
Claims that a class is threadsafe or admonishes implementors of an interface
to ensure that their implementation is threadsafe.
|
| ThreadUtils |
|
| ThreadUtils.DarwinCLib |
|
| ThreadUtils.LinuxCLib |
|
| ThreadUtils.OsPlatform |
|
| ThreadUtils.WindowsCLib |
|
| Time |
Utility methods for time travelling and freezing time.
|
| Time |
The interface to time itself.
|
| Time.Awaitable |
|
| TimeFormat |
This utility class provides methods to format and parse a timespan in a human readable form.
|
| TimeoutProcessor |
More efficient handling of cancellable schedulable events.
|
| TimeoutProcessor.TimeoutFuture |
|
| Timer |
|
| TimerTimeoutProcessor |
|
| TimeScheduledThreadPoolExecutor |
A ThreadPoolExecutor that can additionally schedule
commands to run after a given delay, or to execute
periodically. |
| TimeValue |
A class to encapsulate time values along with their measurement units
Works for both timestamps as well as time durations.
|
| TokenBucket |
|
| TopicCleanupService |
The topic cleanup in Venice adopts the following strategy:
1.
|
| TopicCleanupServiceForParentController |
|
| TopicCleanupServiceStats |
|
| TopicExistenceChecker |
|
| TopicManager |
Topic manager is responsible for creating, deleting, and updating topics.
|
| TopicManagerContext |
A context object that contains all the dependencies needed by TopicManager. |
| TopicManagerContext.Builder |
|
| TopicManagerContext.PubSubPropertiesSupplier |
|
| TopicManagerRepository |
A repository of TopicManager instances, each associated with a specific PubSub region and cluster. |
| TopicMessageFinder |
This class is used to find messages for a given key from a specified topic.
|
| TopicPartitionConsumerFunction |
|
| TopicPartitionForIngestion |
This class is a wrapper of pair of .
|
| TopicPartitionIngestionContextRequest |
|
| TopicPartitionIngestionInfo |
|
| TopicPartitionsOffsetsTracker |
This class tracks consumed topic partitions' offsets
|
| TopicSwitch |
This ControlMessage is sent by the Controller, once per partition; it will only be used in leader/follower state transition model; this control message will indicate the leader to switch to a new source topic and start consuming from offset with a specific timestamp.
|
| TopicSwitchWrapper |
This class precomputes the conversion from Avro's CharSequence to String, and also hangs on to the
correct instance of PubSubTopic, so that the lookup need not be performed in many locations. |
| TopicWiseKafkaConsumerService |
|
| TouchTimer |
Handy utility class to track the timing while processing a request.
|
| TouchTimer.Visitor |
Message Visitor interface
|
| TrackableControllerResponse |
Extend this class to create response objects for async command.
|
| TrackingStreamingCallback<K,V> |
|
| TransformingProducerAdapter |
This PubSubProducerAdapter implementation allows tests to perform
arbitrary transformations on the messages that are about to be written to
Kafka. |
| TransformingProducerAdapter.SendMessageParameters |
|
| TransformingProducerAdapter.SendMessageParametersTransformer |
|
| TransportClient |
|
| TransportClientCallback |
|
| TransportClientResponse |
|
| TransportClientResponseForRoute |
|
| TransportClientStreamingCallback |
|
| TrieBasedPathResourceRegistry<T> |
This class implements a generic trie-based lookup tree.
|
| TriFunction<T,U,S,R> |
|
| TTLResolutionPolicy |
The policy controls the TTL behavior regarding how batch writes are treated.
|
| TypedFieldAccessor<T,V> |
Interface for a generic typed field accessor.
|
| TypedFieldAccessorHelper |
Helper class to determine at run time which implementation to use.
|
| UncompletedPartition |
|
| UncompletedReplica |
|
| UndefinedPropertyException |
Thrown when a required property is not present
|
| UnresolvedUnionUtil |
This class makes use of UnresolvedUnionException, which is not present in all versions of Avro.
|
| UnsupportedMessageTypeException |
This is thrown when some code encounters a message type it does not know about.
|
| UnusedValueSchemaCleanupService |
This service runs in the parent controller to delete historical unused value schemas.
|
| Update |
Partial update operation, which merges the update value with the existing value.
|
| UpdateBuilder |
This class applies the builder pattern to build a partial update record.
|
| UpdateBuilderImpl |
|
| UpdateClusterConfigQueryParams |
|
| UpdateResultStatus |
This enum represents status of something (a record or a field) after being updated.
|
| UpdateStoragePersona |
|
| UpdateStoragePersonaQueryParams |
|
| UpdateStore |
|
| UpdateStoreQueryParams |
|
| URLCodec |
Copies of the implementation of URLEncoder.encode(String, String) and
URLDecoder.decode(String, String) except with the following changes:
Accept a Charset argument for the character set instead of a string
which would cause Charset.forName(String) to be called.
Internally use StringBuilder instead of StringBuffer.
These methods no longer throw a checked exception because it
no longer calls Charset.forName(String).
These methods are annotated with Nonnull annotations.
|
| UserCredentialsFactory |
|
| UserSystemStoreLifeCycleHelper |
This class is responsible for automatically create and delete per user store system store resources when the
corresponding user store is created or deleted.
|
| Utils |
Helper functions
|
| Utils.ConfigEntity<T> |
This class encapsulates config entity information such as config name, default value, config document
|
| V1Delete |
|
| V1Get |
Controller API version 1 HTTP GET routes
|
| V1Post |
|
| V1Put |
|
| V1Route |
|
| ValidateSchemaAndBuildDictMapper |
Mapper only MR to Validate Schema, Build compression dictionary if needed and persist
some data (total file size and compression dictionary) in HDFS to be used by the VPJ Driver
Note: processing all the files in this split are done sequentially and if it
results in significant increase in the mapper time or resulting in timeouts,
this needs to be revisited to be done via a thread pool.
|
| ValidateSchemaAndBuildDictMapperOutput |
The data protocol between ValidateSchemaAndBuildDictMapper and VenicePushJob
|
| ValidateSchemaAndBuildDictMapperOutputReader |
|
| ValidateSchemaAndBuildDictOutputFormat |
This class provides a way to:
1.
|
| Validator |
Interface for targeted region push validation.
|
| ValueAndDerivedSchemaData |
|
| ValueAndRmd<T> |
This class holds a value of type {@param T} and its corresponding replication metadata.
|
| ValueBytes |
Optional field which describes the previous state of a given row.
|
| ValueHolder<T> |
|
| ValueRecord |
This class provides the following functionalities:
1.
|
| ValueSchemaCreation |
|
| ValueSize |
|
| VeniceAbstractPartitionReader |
|
| VeniceAclException |
A runtime exception which may be thrown by implementation of AuthorizerService interface.
|
| VeniceAdminStats |
|
| VeniceAfterImageConsumerImpl<K,V> |
|
| VeniceAvroFileIterator |
|
| VeniceAvroKafkaSerializer |
|
| VeniceAvroMapper |
|
| VeniceAvroRecordReader |
A record reader that reads records from Avro file input into Avro-serialized keys and values.
|
| VeniceBlobTransferFileNotFoundException |
Classes for P2P use case that are triggered by blob transfer file not found in target host
|
| VeniceChangeCoordinate |
|
| VeniceChangelogConsumer<K,V> |
Venice change capture consumer to provide value change callback.
|
| VeniceChangelogConsumerClientFactory |
|
| VeniceChangelogConsumerClientFactory.ViewClassGetter |
|
| VeniceChangelogConsumerImpl<K,V> |
|
| VeniceChangelogConsumerIO |
Beam Connector for Venice Change data capture IO.
|
| VeniceChangelogConsumerIO.Read<K,V> |
|
| VeniceChangelogConsumerIO.Read.SeekWhence |
|
| VeniceChangelogConsumerProvider<K,V> |
|
| VeniceCheckedRunnable |
A Runnable that throws checked exceptions.
|
| VeniceCheckedSupplier<T> |
A Supplier that throws checked exceptions.
|
| VeniceCheckpointMark |
|
| VeniceCheckpointMark.Coder |
|
| VeniceChecksumException |
|
| VeniceChunkedPayloadTTLFilter |
|
| VeniceChunkedResponse |
|
| VeniceChunkedWriteHandler |
This class is the wrapper of ChunkedWriteHandler, and essentially it will introduce the following logic:
1.
|
| VeniceChunkedWriteHandler.WriteMessageCallback |
|
| VeniceClientException |
Thrown by the venice thin client if something goes wrong with the request
Parent class to VeniceClientHttpException
|
| VeniceClientHttpException |
|
| VeniceClientRateExceededException |
|
| VeniceClientRequest |
Protobuf type com.linkedin.venice.protocols.VeniceClientRequest
|
| VeniceClientRequest.Builder |
Protobuf type com.linkedin.venice.protocols.VeniceClientRequest
|
| VeniceClientRequestOrBuilder |
|
| VeniceClientTlsStrategy |
This class copies most of the logic from DefaultClientTlsStrategy and AbstractClientTlsStrategy to
get rid of the cipher check to be backward compatible.
|
| VeniceClientTlsStrategyBuilder |
This class copies most of the logic from ClientTlsStrategyBuilder to get rid of the cipher check while using
http/2 in TlsCiphers to be backward compatible.
|
| VeniceClusterConfig |
class that maintains config very specific to a Venice cluster
|
| VeniceComponent |
|
| VeniceCompressor |
|
| VeniceComputePath |
|
| VeniceConcurrentHashMap<K,V> |
|
| VeniceConfigLoader |
VeniceConfigService loads the static configuration that does not change
once the Server is started.
|
| VeniceConstants |
|
| VeniceController |
Venice Controller to manage the cluster.
|
| VeniceControllerClusterConfig |
Configuration which is specific to a Venice controller.
|
| VeniceControllerContext |
|
| VeniceControllerContext.Builder |
|
| VeniceControllerMultiClusterConfig |
|
| VeniceControllerService |
A service venice controller.
|
| VeniceControllerStateModel |
State model used to handle the change of leader-standby relationship for controllers.
|
| VeniceCoordinateOutOfRangeException |
|
| VeniceDelegateMode |
|
| VeniceDispatcher |
|
| VeniceDistClusterControllerStateModelFactory |
Factory to create VeniceDistClusterControllerStateModel and provide some utility methods to get state model by given
cluster.
|
| VeniceEnumValue |
N.B.: Although there is no way to force this via Java interfaces, the convention is that all enums implementing this
interface should have static "valueOf" function to return the correct enum value from a given numeric value, i.e.:
Note that VeniceEnumValueTest makes it easy to test the above, and we should have a subclass of that test for all
implementations of this interface.
|
| VeniceEnumValueTest<T extends VeniceEnumValue> |
Abstract class which makes it as easy as possible to generically test all the assumptions for enums which implement
the VeniceEnumValue interface. |
| VeniceException |
Base exception that all other Venice exceptions extend
|
| VeniceFileInputFormat |
|
| VeniceFullHttpResponse |
A specialized DefaultFullHttpResponse object to record the decompression time of the records in the response.
|
| VeniceGrpcServer |
|
| VeniceGrpcServerConfig |
|
| VeniceGrpcServerConfig.Builder |
|
| VeniceHdfsInputPartition |
|
| VeniceHdfsInputPartitionReader |
|
| VeniceHdfsInputPartitionReaderFactory |
|
| VeniceHdfsInputScan |
|
| VeniceHdfsInputScanBuilder |
|
| VeniceHdfsInputTable |
A table format that is used by Spark to read Avro files from HDFS for use in VenicePushJob.
|
| VeniceHdfsSource |
This is the entrypoint of the Avro input source.
|
| VeniceHelixAdmin |
Helix Admin based on 0.8.4.215 APIs.
|
| VeniceHelixAdmin.StoreMetadataOperation |
|
| VeniceHostFinder |
{code VeniceHostFinder} finds a set of hosts that can serve the given Venice resource partition.
|
| VeniceHostHealth |
|
| VeniceHttp2PipelineInitializerBuilder |
This utility is used to manage all the HTTP/2 related configs and offer a way to spin up a pipeline to support
both HTTP/1.1 and HTTP/2.
|
| VeniceHttpException |
|
| VeniceInconsistentSchemaException |
Customized exception for inconsistent Avro schema error of input directory
in VenicePushJob |
| VeniceInconsistentStoreMetadataException |
This exception is thrown when we detect inconsistent or possibly corrupted store metadata on storage nodes.
|
| VeniceIngestionTaskKilledException |
|
| VeniceJsonSerializer<T> |
|
| VeniceJVMStats |
Simple class that spins JVM platform stats into Venice stats.
|
| VeniceKafkaDecodedRecord |
|
| VeniceKafkaInputMapper |
This class is designed specifically for KafkaInputFormat, and right now, it is doing simple pass-through. |
| VeniceKafkaInputReducer |
This class is designed specifically for KafkaInputFormat, and right now, it will pick up the latest
entry according to the associated offset, and produce it to Kafka. |
| VeniceKafkaInputTTLFilter |
This class is responsible to filter records based on the RMD information and the ttl config by taking KIF input KafkaInputMapperValue. |
| VeniceKafkaSerializer<T> |
Map objects to byte arrays and back again
|
| VeniceKeyCountLimitException |
|
| VeniceLock |
Venice wrapper around a Lock object to record metrics and emit logs when lock acquisition is taking too long.
|
| VeniceLockStats |
|
| VeniceMessageCoder<K,V> |
|
| VeniceMessageException |
Custom Exception for Venice messages.
|
| VeniceMetadataRepositoryBuilder |
VeniceMetadataRepositoryBuilder is a centralized builder class for constructing a variety of metadata components
including store repository, schema repository, ZK-shared schema repository, ZK client and cluster info provider
for Da Vinci, Venice Service and Isolated Ingestion Service.
|
| VeniceMetaDataRequest |
|
| VeniceMetricsConfig |
Configuration for metrics emitted by Venice: Holds OpenTelemetry as well as Tehuti configs
Configs starting with "otel.venice." are venice specific configs for OpenTelemetry metrics
other configs starting with "otel.exporter." are generic OpenTelemetry exporter configs but
are parsed in this class and used setters to configure otel exporter.
|
| VeniceMetricsConfig.Builder |
|
| VeniceMetricsDimensions |
|
| VeniceMetricsProvider |
This is used to initialize a Metrics for each request. |
| VeniceMetricsRepository |
Repository to hold both tehuti and OpenTelemetry metrics.
|
| VeniceMRPartitioner |
|
| VeniceMultiGetPath |
|
| VeniceMultiKeyPath<K> |
|
| VeniceMultiKeyRoutingStrategy |
This enum is used to define various routing strategies for multi-key requests.
|
| VeniceNoClusterException |
|
| VeniceNoHelixResourceException |
|
| VeniceNoStoreException |
Thrown when an operation should return information about a store, but the store does not exist
|
| VeniceNotifier |
Interface for listening to Notifications for Store consumption.
|
| VeniceObjectWithTimestamp |
This class defines a wrapper object to wrap up the actual object and the corresponding update timestamp.
|
| VeniceOfflinePushMonitorAccessor |
|
| VeniceOpenTelemetryMetricNamingFormat |
|
| VeniceOpenTelemetryMetricsRepository |
|
| VeniceParentControllerRegionStateHandler |
Handler for checking the state of the region of the parent controller to handle requests in its region.
|
| VeniceParentHelixAdmin |
This class is a wrapper of VeniceHelixAdmin, which will be used in parent controller. |
| VenicePartitioner |
Determines partitioning, which is used for producing messages into the right
Kafka partitions and routing reads to the correct Venice storage nodes.
|
| VenicePartitionFinder |
VenicePartitionFinder provides methods to find the partition name or number for the given data.
|
| VenicePath |
|
| VenicePathParser<HTTP_REQUEST extends BasicHttpRequest> |
Inbound single get request to the router will look like:
GET /storage/storeName/key?f=fmt
'storage' is a literal, meaning we will request the value for a single key
storeName will be the name of the requested store
key is the key being looked up
fmt is an optional format parameter, one of 'string' or 'b64'.
|
| VenicePathParserHelper |
Created by mwise on 4/25/16.
|
| VenicePeersConnectionException |
Classes for P2P use case that are triggered by founded peers cannot connect
|
| VenicePeersNotFoundException |
Classes for P2P usecase that are triggered by peers not found
|
| VeniceProducer<K,V> |
The API for online applications to write to Venice.
|
| VeniceProducerMetrics |
|
| VeniceProperties |
|
| VenicePulsarSink |
A Pulsar Sink that sends messages to Venice.
|
| VenicePulsarSinkConfig |
Configuration class for the Sink Connector.
|
| VenicePushJob |
This class sets up the Hadoop job used to push data to Venice.
|
| VenicePushJobConstants |
|
| VeniceRateLimiter |
|
| VeniceRateLimiter.RateLimiterType |
|
| VeniceReadResponseStatus |
Enumeration of response status codes for Venice read requests.
|
| VeniceReadServiceGrpc |
|
| VeniceReadServiceGrpc.VeniceReadServiceBlockingStub |
|
| VeniceReadServiceGrpc.VeniceReadServiceFutureStub |
|
| VeniceReadServiceGrpc.VeniceReadServiceImplBase |
|
| VeniceReadServiceGrpc.VeniceReadServiceStub |
|
| VeniceReadServiceImpl |
|
| VeniceReadServiceOuterClass |
|
| VeniceRecordIterator |
|
| VeniceReducer |
VeniceReducer will be in charge of producing the messages to Kafka broker. |
| VeniceReentrantReadWriteLock |
This class simply exposes publicly the protected methods of its parent, for debugging purposes.
|
| VeniceRequestEarlyTerminationException |
|
| VeniceResource |
Venice resource that could be refreshed to retrieve the newest data or clear the current data in memory.
|
| VeniceResourceAccessException |
Class for all Venice exceptions that are triggered by Kafka topic authorization related issues.
|
| VeniceResourceCloseResult |
|
| VeniceResponseAggregator |
VeniceResponseAggregator aggregates the sub-responses returned by storage node for a multi-get request.
|
| VeniceResponseCompletableFuture<T> |
CompletableFuture implementation to handle partial response.
|
| VeniceResponseDecompressor |
|
| VeniceResponseMap<K,V> |
Venice customized map, which could contains either a full response or a partial response.
|
| VeniceResponseMapImpl<K,V> |
|
| VeniceResponseStatusCategory |
How Venice categorizes the response status of a request:
We are emitting both HttpResponseStatusCodeCategory and this enum to capture the http standard as
well as the Venice specific categorization. |
| VeniceRetriableException |
Interface for all Venice exceptions that are retriable.
|
| VeniceRmdTTLFilter<INPUT_VALUE> |
This class is responsible to filter records based on the RMD information and the ttl config.
|
| VeniceRole |
|
| VeniceRoleFinder |
|
| VeniceRouteHandler<T extends ControllerResponse> |
Common route handler implement the common part of error handling and writing response to json.
|
| VeniceRouterConfig |
Configuration for Venice Router.
|
| VeniceRouterException |
|
| VeniceRouterUtils |
|
| VeniceSchemaFieldNotFoundException |
Customized exception for non-existing key/value field error in Avro schema
in VenicePushJob |
| VeniceSerializationException |
|
| VeniceSerializer<T> |
Interface defines how to serialize and deserialize the venice object.
|
| VeniceServer |
Class that represents the Venice server.
|
| VeniceServerConfig |
VeniceServerConfig maintains configs specific to Venice Server, Da Vinci client and Isolated Ingestion Service.
|
| VeniceServerConfig.IncrementalPushStatusWriteMode |
|
| VeniceServerContext |
VeniceServerContext contains dependencies required by VeniceServer
|
| VeniceServerContext.Builder |
|
| VeniceServerGrpcHandler |
|
| VeniceServerGrpcRequestProcessor |
|
| VeniceServerResponse |
Protobuf type com.linkedin.venice.protocols.VeniceServerResponse
|
| VeniceServerResponse.Builder |
Protobuf type com.linkedin.venice.protocols.VeniceServerResponse
|
| VeniceServerResponseOrBuilder |
|
| VeniceSingleGetPath |
|
| VeniceSocketConnectorFactory |
Creates socket connectors.
|
| VeniceSparkEmbeddedJettyServer |
Spark server implementation
|
| VeniceSparkPartitioner |
|
| VeniceSparkServerFactory |
Creates instances of embedded jetty containers.
|
| VeniceSpecificDatumReader<T> |
|
| VeniceStandalone |
|
| VeniceStoreAlreadyExistsException |
Thrown when an operation should create a store, but the store already exists
|
| VeniceStoreCache |
Interface for a cache on a venice store.
|
| VeniceStoreCacheStorageEngine |
|
| VeniceStoreCacheStoragePartition |
|
| VeniceStoreClientFactory |
|
| VeniceStoreClientFactory.ClientConfigUpdater |
|
| VeniceStoreClientGlobalConfig |
|
| VeniceStoreCreationException |
|
| VeniceStoreIsMigratedException |
Thrown when an operation should return information about a store, but the store is migrated to another cluster
|
| VeniceStoreVersionConfig |
class that maintains all properties that are not specific to a venice server and cluster.
|
| VeniceSuiteListener |
|
| VeniceSystemFactory |
Samza jobs talk to either parent or child controller depending on the aggregate mode config.
|
| VeniceSystemProducer |
VeniceSystemProducer defines the interfaces for Samza jobs to send data to Venice stores.
|
| VeniceSystemStoreType |
Enum used to differentiate the different types of Venice system stores when access their metadata.
|
| VeniceSystemStoreUtils |
|
| VeniceTestListener |
|
| VeniceTimeoutException |
Used when timeout happens in Venice.
|
| VeniceUnsupportedOperationException |
|
| VeniceUserStoreType |
Enums that lists most Venice user store types.
|
| VeniceValidationException |
Customized exception for validation error for targeted colo push
in VenicePushJob |
| VeniceVersionedStats<STATS,STATS_REPORTER extends AbstractVeniceStatsReporter<STATS>> |
|
| VeniceVersionedStatsReporter<STATS,STATS_REPORTER extends AbstractVeniceStatsReporter<STATS>> |
|
| VeniceVersionFinder |
VeniceVersionFinder provides methods to find the version for a given store.
|
| VeniceView |
This is the abstract implementation of the 'management' component for a venice view.
|
| VeniceViewWriter |
This class is kept separate from the VeniceView class to not leak certain concepts that
currently exclusively reside in the server to other components.
|
| VeniceViewWriterFactory |
|
| VeniceVsonFileIterator |
|
| VeniceVsonMapper |
Mapper that reads Vson input and deserializes it as Avro object and then Avro binary
|
| VeniceVsonRecordReader |
A record reader that reads records from VSON SequenceFile file input into Avro-serialized keys and values.
|
| VeniceWriter<K,V,U> |
Class which acts as the primary writer API.
|
| VeniceWriter.DefaultLeaderMetadata |
|
| VeniceWriter.KeyProvider |
An interface which enables the key to contain parts of the {@param producerMetadata} within it, which is
useful for control messages and chunked values.
|
| VeniceWriterFactory |
|
| VeniceWriterOptions |
VeniceWriterOptions is used to pass arguments to VeniceWriter constructor.
|
| VeniceWriterOptions.Builder |
|
| VeniceWriterStats |
A host level metric to track number of active venice writers.
|
| VeniceZkPaths |
This class contains constants that represent Venice-managed ZooKeeper paths.
|
| VerifySslHandler |
Currently this VerifySslHandler is only used in servers or the isolated ingestion process.
|
| Version |
This interface defines all the public APIs, and if you need to add accessors to
some new fields, this interface needs to be changed accordingly.
|
| Version.PushType |
Producer type for writing data to Venice
|
| VersionBackend |
|
| VersionCreationResponse |
|
| VersionImpl |
Class defines the version of Venice store.
|
| VersionProperties |
|
| VersionResponse |
|
| VersionRoute |
|
| VersionStatus |
Enums of status of verion.
|
| VersionSwap |
This controlMessage is written to the real-time topic by the controller or to the store-version topic by the current version's leader server.
|
| ViewConfig |
|
| ViewConfigImpl |
|
| ViewParameterKeys |
|
| ViewUtils |
|
| ViewWriterUtils |
|
| VIPRequestHandler |
|
| VIPRequestHandler.State |
|
| VPJSSLUtils |
This class contains some utils methods for VPJ jobs to obtain SSL-related configs.
|
| VsonAvroDatumReader<D> |
Deprecated. |
| VsonAvroDatumReader.DeepEqualsArrayList |
This class supports the special byte[] check.
|
| VsonAvroDatumReader.DeepEqualsHashMap |
This class supports the special byte[] check.
|
| VsonAvroDatumWriter<K> |
Deprecated. |
| VsonAvroGenericDeserializer<K> |
|
| VsonAvroGenericSerializer<K> |
|
| VsonAvroSchemaAdapter |
Deprecated. |
| VsonAvroSerializer |
Deprecated. |
| VsonGenericStoreClientImpl<K,V> |
Deprecated. |
| VsonReader |
Deprecated. |
| VsonSchema |
Deprecated. |
| VsonSchemaAdapter |
Deprecated. |
| VsonSequenceFileInputFormat |
This class was originally from Voldemort.
|
| VsonSerializationException |
|
| VsonTypes |
Deprecated. |
| WaitAllPushStatusDecider |
Wait all strategy stands for Venice do not allow one replica to be failed.
|
| WaitNMinusOnePushStatusDecider |
Wait N-1 strategy stands for Venice could tolerate one of replica to be failed for each partition.
|
| Welfords |
Welford's algorithm for calculating variance.
|
| Welfords.DoubleWelford |
|
| Welfords.LongWelford |
|
| Welfords.Result |
|
| WriteComputeConstants |
This utility class contains all String literal constants used in write compute.
|
| WriteComputeHandler |
This interface provides methods to execute write-compute operation a value
|
| WriteComputeHandlerV1 |
Write compute V1 handles value records that do not have replication metadata.
|
| WriteComputeHandlerV2 |
Write compute V2 handles value records with replication metadata.
|
| WriteComputeOperation |
This enum describe the possible write compute operations Venice supports.
|
| WriteComputeProcessor |
This class is able to read write-computed value and apply it to original value.
|
| WriteComputeResultWrapper |
This result wrapper is for non-Active-Active stores.
|
| WriteComputeSchemaConverter |
This class converts a Avro Schema.Type.RECORD schema to its write compute schema.
|
| WriteComputeSchemaValidator |
validate if a write-compute schema can be pair with value schema
|
| WriteComputeSchemaValidator.InvalidWriteComputeException |
|
| WritePathLatencySensor |
This class serves as a latency sensor for write path that contains two types of stats: Avg and Max.
|
| WriterChunkingHelper |
This class is a helper class that contains writer side chunking logics.
|
| ZeroCopyByteArrayOutputStream |
|
| ZeroInputStream |
A simple @{link InputStream} implementation which is equivalent to
/dev/zero by acting as a source for a stream of NUL bytes.
|
| ZkAdminTopicMetadataAccessor |
|
| ZkAllowlistAccessor |
Class used to access to the allowlist stored in ZK.
|
| ZkClientFactory |
|
| ZkClientStatusStats |
The stats keep track of ZK Client status changes.
|
| ZkCopier |
This class contains methods to 1)migrate Venice-specific metadata from a source ZooKeeper (ZK) to a destination ZK
and 2)extract Venice-specific paths from an input text file containing ZK paths to an output text file.
|
| ZkDataAccessException |
|
| ZkExecutionIdAccessor |
|
| ZkHelixAdminClient |
The purpose of this class is to abstract Helix operations out of the VeniceHelixAdmin and eventually rename
it to VeniceAdmin. |
| ZkRoutersClusterManager |
Manage live routers through Zookeeper.
|
| ZKStore |
Class defines the store of Venice.
|
| ZkStoreConfigAccessor |
The class is used to access the store configs in Zookeeper.
|
| ZstdWithDictCompressor |
|