Class Index

A B C D E F G H I J K L M N O P Q R S T U W Y Z

A

AbstractBaseKnapsackSolver Common implementation of a knapsack solver

Based on the C++ knapsack solver in Google's or-tools package. 
AbstractBaseStage  
AbstractHelixResolver A basic implementation of a resolver in terms of expiring routing tables  
AbstractKnapsackPropagator Common implementation of a knapsack constraint satisfier

Based on the C++ knapsack solver in Google's or-tools package. 
AbstractParticipantService A modeling of a helix participant as a self-contained service. 
AccessOption  
AdministratorId  
AgentStateModel  
AgentStateModelFactory  
AlertHistory Maintains a history of alerts that have been fired, as well as actions taken, if any. 
Alerts Describe alerts and corresponding metrics. 
Alerts.AlertsProperty Supported fields corresponding to a set of alerts  
AlertStatus Get characteristics of alerts, whether they were fired, and their context. 
AnalyticsTaskFactory  
AppConfig  
AppLauncher Main class to launch the job. 
ApplicationSpec  
ApplicationSpecFactory  
AppMasterConfig Convenient method to pass information to containers The methods simply sets up environment variables  
AppMasterConfig.AppEnvironment  
AppMasterLauncher This will
  • start zookeeper automatically
  • create the cluster
  • set up resource(s)
  • start helix controller
 
AppStatusReportGenerator  
AsyncCallback  
AsyncCallbackService  
AsyncCallbackService.AsyncCallbackMessageHandler  
AtomicClusterAccessor An atomic version of the ClusterAccessor. 
AttributeName  
AutoFallbackPropertyStore<T> Property store that does auto fallback to an old location. 
AutoModeISBuilder IdealState builder for SEMI_AUTO mode  
AutoRebalanceModeISBuilder IdealState builder for FULL_AUTO mode  
AutoRebalanceStrategy  
AutoRebalanceStrategy.DefaultPlacementScheme Compute preferred placements based on a default strategy that assigns replicas to nodes as evenly as possible while avoiding placing two replicas of the same partition on any node. 
AutoRebalanceStrategy.ReplicaPlacementScheme Interface for providing a custom approach to computing a replica's affinity to a node. 

B

BaseDataAccessor<T> Generic interface for accessing and manipulating data on a backing store like Zookeeper. 
BaseKnapsackSolver The interface of any multidimensional knapsack solver

Based on the C++ knapsack solver in Google's or-tools package. 
BasicControllerContext A simple context that can be serialized by a DefaultStringSerializer  
BasicZkSerializer Basic path based serializer which ignores the path and delegates serialization into a regular ZkSerializer  
BatchMessageHandler  
BatchMessageWrapper default implementation of handling start/end of batch messages  
BestPossibleStateCalcStage For partition compute best possible (instance,state) pair based on IdealState,StateModel,LiveInstance  
BestPossibleStateOutput  
BootstrapHandler  
BootstrapHandler.BootstrapStateModel  
BootstrapProcess This process does little more than handling the state transition messages. 
BootstrapProcess.CustomMessageHandlerFactory  
ByteArraySerializer  

C

Cache<T>  
ChainedPathZkSerializer  
ChainedPathZkSerializer.Builder  
ChangeLog  
ChangeLogGenerator  
ChangeLogProcessor Processes the change log and invokes rsync for every change on the remote machine  
ChangeLogReader  
ChangeRecord  
CheckpointFile  
CLMLogFileAppender  
Cluster Represent a logical helix cluster  
ClusterAccessor  
ClusterConfig Configuration properties of a cluster  
ClusterConfig.Builder Assembles a cluster configuration  
ClusterConfig.Delta Update context for a ClusterConfig  
ClusterConfiguration Persisted configuration properties for a cluster  
ClusterConstraints All of the constraints on a given cluster and its subcomponents, both physical and logical. 
ClusterConstraints.ConstraintAttribute Attributes on which constraints operate  
ClusterConstraints.ConstraintType What is being constrained  
ClusterConstraints.ConstraintValue Possible special values that constraint attributes can take  
ClusterConstraintsBuilder  
ClusterDataCache Reads the data from the cluster using data accessor. 
ClusterEvent  
ClusterEventBlockingQueue A blocking queue of ClusterEvent objects to be used by the controller pipeline. 
ClusterExternalViewVerifier given zk, cluster, and a list of expected live-instances check whether cluster's external-view reaches best-possible states  
ClusterId Identifies a cluster  
ClusterLiveNodesVerifier  
ClusterMBeanObserver  
ClusterMessagingService Provides the ability to
  • Send message to a specific component in the cluster[ participant, controller, Spectator(probably not needed) ]
  • Broadcast message to all participants
  • Send message to instances that hold a specific resource
  • Asynchronous request response api. 
  • ClusterRepresentationUtil  
    ClusterResource  
    ClusterSetup  
    ClustersResource  
    ClusterStateVerifier  
    ClusterStateVerifier.BestPossAndExtViewZkVerifier verifier that verifies best possible state and external view  
    ClusterStateVerifier.MasterNbInExtViewVerifier  
    ClusterStateVerifier.Verifier  
    ClusterStateVerifier.ZkVerifier  
    ClusterStatusMonitor  
    ClusterStatusMonitorMBean  
    ClusterVerifier  
    CommandAttribute  
    CommandConfig  
    CommandConfig.Builder builder for command-config  
    CompatibilityCheckStage controller checks if participant version is compatible  
    ConfigAccessor Provides access to the persistent configuration of the cluster, the instances that live on it, and the logical resources assigned to it. 
    ConfigResource  
    ConsistentHashingMasterSlaveStrategy  
    ConsistentHashingMasterSlaveStrategy.FnvHash The default string hash function. 
    ConsistentHashingMasterSlaveStrategy.HashFunction Interface to calculate the hash function value of a string  
    ConstraintBasedAssignment Collection of functions that will compute the best possible state based on the participants and the rebalancer configuration of a resource. 
    ConstraintId Identifies a constraint item on the cluster  
    ConstraintItem A single constraint and its associated attributes  
    ConstraintItemBuilder  
    ConstraintResource  
    Consumer  
    ConsumerStateModel  
    ConsumerStateTransitionHandlerFactory  
    ConsumerThread  
    ContainerAdmin  
    ContainerAskResponse  
    ContainerConfig  
    ContainerId  
    ContainerLaunchResponse  
    ContainerProvider  
    ContainerProvisioningStage This stage will manager the container allocation/deallocation needed for a specific resource. 
    ContainerReleaseResponse  
    ContainerSpec  
    ContainerState  
    ContainerStopResponse  
    ContextId Identifies a context  
    Controller A helix controller  
    ControllerChangeListener Interface to implement to respond to controller changes. 
    ControllerContext Controller stages can implement this interface to set and get persistent state  
    ControllerContextHolder Wrap a ControllerContext so that it can be persisted in the backing store  
    ControllerContextProvider An interface for getting and setting ControllerContext objects, which will eventually be persisted and accessible across runs of the controller pipeline. 
    ControllerId Identifies Helix nodes that take on the CONTROLLER role  
    ControllerManagerHelper helper class for controller manager  
    ControllerResource  
    ControllerStatusUpdateResource  
    CountTask  
    Criteria Describes various properties that operations involving Message delivery will follow. 
    Criteria.DataSource  
    CriteriaEvaluator  
    CurrentState Current states of partitions in a resource for an instance. 
    CurrentState.CurrentStateProperty Lookup keys for the current state  
    CurrentStateBuilder Assemble a CurrentState  
    CurrentStateChangeListener Interface to implement to respond to changes in the current state  
    CurrentStateComputationStage For each LiveInstances select currentState and message whose sessionId matches sessionId from LiveInstance Get Partition,State for all the resources computed in previous State [ResourceComputationStage]  
    CurrentStateOutput  
    CurrentStateResource  
    CurrentStatesResource  
    CurrentStateUpdate  
    CustomCodeCallbackHandler Callback interface to running custom code on Helix participant manager The custom code will be triggered on user specified cluster changes  
    CustomCodeInvoker  
    CustomModeISBuilder IdealState builder for CUSTOMIZED mode  
    CustomRebalancer  

    D

    Dag  
    Dag.Node  
    DefaultControllerMessageHandlerFactory  
    DefaultControllerMessageHandlerFactory.DefaultControllerMessageHandler  
    DefaultMessagingService  
    DefaultParticipantErrorMessageHandlerFactory DefaultParticipantErrorMessageHandlerFactory works on controller side. 
    DefaultParticipantErrorMessageHandlerFactory.ActionOnError  
    DefaultParticipantErrorMessageHandlerFactory.DefaultParticipantErrorMessageHandler  
    DefaultSchedulerMessageHandlerFactory  
    DefaultSchedulerMessageHandlerFactory.DefaultSchedulerMessageHandler  
    DefaultSchedulerMessageHandlerFactory.SchedulerAsyncCallback  
    DefaultStringSerializer Default serializer implementation for converting to/from strings. 
    DefaultTwoStateStrategy DefaultIdealStateCalculator tries to optimally allocate two state partitions among storage nodes. 
    DummyParticipant  
    DummyParticipant.DummyMSModelFactory  
    DummyParticipant.DummyMSStateModel  

    E

    Emitter  
    Error Defines an error that occurs in computing a valid ideal state or external view  
    ErrorResource  
    ErrorsResource  
    EspressoRelayStrategy  
    ExampleHelper  
    ExampleProcess  
    ExternalCommand Wrapper for running commands outside of the JVM 
    ExternalCommand  
    ExternalView External view is an aggregation (across all instances) of current states for the partitions in a resource  
    ExternalViewChangeListener Interface to implement to be notified of changes to the external view  
    ExternalViewComputeStage  
    ExternalViewGenerator  
    ExternalViewResource  

    F

    FallbackRebalancer This class is intented for use to wrap usages of Rebalancer
    FileChangeWatcher  
    FileStore  
    FileStoreStateModel  
    FileStoreStateModelFactory  
    FileSystemWatchService  
    FilterTask  
    FixedTargetProvider  
    FixedTargetTaskRebalancer A rebalancer for when a task group must be assigned according to partitions/states on a target resource. 
    FullAutoRebalancer  

    G

    GenericApplicationMaster  
    GenericHelixController Cluster Controllers main goal is to keep the cluster state as close as possible to Ideal State. 
    GenericLeaderStandbyModel  
    GenericLeaderStandbyStateModelFactory  
    GenericTaskRebalancer This class does an assignment based on an automatic rebalancing strategy, rather than requiring assignment to target partitions and states of another resource  
    GenericTaskRebalancer.RetryPolicy  
    GroupCommit Support committing updates to data such that they are ordered for each key  
    GroupMessageHandler  

    H

    HelixAddress  
    HelixAdmin  
    HelixAdminWebApp  
    HelixAgentMain  
    HelixBatchMessageTask  
    HelixConfigScope config-scope that replaces @link ConfigScope  
    HelixConfigScope.ConfigScopeProperty Defines the various scopes of configs, and how they are represented on Zookeeper  
    HelixConfigScopeBuilder config-scope builder that replaces @link ConfigScopeBuilder  
    HelixConnection Helix connection (aka helix manager)  
    HelixConnectionStateListener  
    HelixConstants  
    HelixConstants.ChangeType  
    HelixConstants.ClusterConfigType  
    HelixConstants.StateModelToken  
    HelixController  
    HelixControllerMain  
    HelixCustomCodeRunner This provides the ability for users to run a custom code in exactly one process using a LeaderStandBy state model. 
    HelixDataAccessor Interface used to interact with Helix Data Types like IdealState, Config, LiveInstance, Message, ExternalView etc PropertyKey represent the HelixData type. 
    HelixDefinedState helix defined states ERROR : when errors happen during state transitions, transit to ERROR state participant will also invoke state-model.on-err(), ignore errors in state-model.on-err() when drop resource in ERROR state and not disabled, controller sends ERROR->DROPPED transition if errors happen in ERROR->DROPPED transition, participant will disable resource/partition when disable resource/partition in ERROR state, resource/partition will be marked disabled but controller not send any transitions when reset resource/partition in ERROR state and not disabled controller send ERROR->initial-state transition if errors happen in ERROR->initial-state transition, remain in ERROR state DROPPED : when drop resource in a non-ERROR state and not disabled controller sends all the transitions from current-state to initial-state then sends initial-state->DROPPED transition 
    HelixException Base class for an exception thrown by Helix due to inconsistencies caught by Helix itself. 
    HelixGroupCommit<T>  
    HelixIPCCallback Callback registered per message type to handle messages. 
    HelixIPCMessageManager A wrapper around a base IPC service that manages message retries / timeouts. 
    HelixIPCService Allows message passing among instances in Helix clusters. 
    HelixLock Generic (distributed) lock for Helix-related persisted updates  
    HelixLockable Implemented by any Helix construct that is lockable and is able to return a HelixLock instance  
    HelixManager Class that represents the Helix Agent. 
    HelixManagerFactory Obtain one of a set of Helix cluster managers, organized by the backing system. 
    HelixManagerProperties hold helix-manager properties read from helix-core/src/main/resources/cluster-manager.properties  
    HelixManagerShutdownHook Shutdown hook for helix manager Working for kill -2/-15 NOT working for kill -9  
    HelixMessageScope A definition of the addressing scope of a message. 
    HelixMessageScope.Builder Creator for a HelixMessageScope  
    HelixMultiClusterController Autonomous controller  
    HelixParticipant Helix participant  
    HelixProperty A wrapper class for ZNRecord. 
    HelixProperty.HelixPropertyAttribute  
    HelixPropertyListener  
    HelixPropertyStore<T>  
    HelixRebalancer Allows one to come up with custom implementation of a rebalancer. 
    HelixResolver An interface that resolves a message scope to a direct address. 
    HelixRole helix-role i.e. 
    HelixService Operational methods of a helix role  
    HelixStageLatencyMonitor  
    HelixStageLatencyMonitorMBean  
    HelixStateMachineEngine  
    HelixStateTransitionHandler  
    HelixStateTransitionHandler.HelixStateMismatchException  
    HelixTask  
    HelixTaskExecutor  
    HelixTaskResult  
    HelixTimerTask Interface for defining a generic task to run periodically. 
    HelixUtil  
    HelixVersion Helix version (e.g. 
    HelixYarnUtil  
    HelloWordAppSpecFactory  
    HelloworldAppSpec  
    HelloWorldService  
    HierarchicalDataHolder<T> Generic class that will read the data given the root path. 

    I

    Id Generic identifier for Helix constructs  
    IdealState The ideal states of all partitions in a resource  
    IdealState.IdealStateModeProperty Deprecated. 
    IdealState.IdealStateProperty Properties that are persisted and are queryable for an ideal state  
    IdealState.RebalanceMode The mode used for rebalance. 
    IdealStateBuilder  
    IdealStateBuilderExample  
    IdealStateChangeListener Interface to implement to listen for changes to the ideal state of resources. 
    IdealStateExample Ideal state json format file used in this example for CUSTOMIZED ideal state mode

     {
     "id" : "TestDB",
     "mapFields" : {
       "TestDB_0" : {
         "localhost_12918" : "MASTER",
         "localhost_12919" : "SLAVE",
         "localhost_12920" : "SLAVE"
       },
       "TestDB_1" : {
         "localhost_12918" : "MASTER",
         "localhost_12919" : "SLAVE",
         "localhost_12920" : "SLAVE"
       },
       "TestDB_2" : {
         "localhost_12918" : "MASTER",
         "localhost_12919" : "SLAVE",
         "localhost_12920" : "SLAVE"
       },
       "TestDB_3" : {
         "localhost_12918" : "MASTER",
         "localhost_12919" : "SLAVE",
         "localhost_12920" : "SLAVE"
       }
     },
     "listFields" : {
     },
     "simpleFields" : {
       "IDEAL_STATE_MODE" : "CUSTOMIZED",
       "NUM_PARTITIONS" : "4",
       "REPLICAS" : "3",
       "STATE_MODEL_DEF_REF" : "MasterSlave",
       "STATE_MODEL_FACTORY_NAME" : "DEFAULT"
     }
     }
     
     
    IdealStateResource  
    InstanceConfig Instance configurations  
    InstanceConfig.InstanceConfigProperty Configurable characteristics of an instance  
    InstanceConfigChangeListener Interface to implement to listen for changes to instance configurations. 
    InstanceMonitor Implementation of the instance status bean  
    InstanceMonitorMBean A basic bean describing the status of a single instance  
    InstanceResource  
    InstancesResource  
    InstancesResource.ListInstancesWrapper A wrapper class for quick serialization of the data presented by this call  
    InstanceType CONTROLLER: cluster managing component is a controller PARTICIPANT: participate in the cluster state changes SPECTATOR: interested in the state changes in the cluster CONTROLLER_PARTICIPANT: special participant that competes for the leader of CONTROLLER_CLUSTER used in cluster controller of distributed mode {@HelixControllerMain }  
    IntegrationTest  
    IntegrationTestUtil collection of test utilities for integration tests  

    J

    JacksonPayloadSerializer Serializes and deserializes data of a generic type using Jackson  
    JmxDumper  
    JobBean Bean class used for parsing job definitions from YAML. 
    JobConfig Provides a typed interface to job configurations. 
    JobConfig.Builder A builder for JobConfig
    JobContext Provides a typed interface to the context information stored by TaskRebalancer in the Helix property store. 
    JobDag Provides a convenient way to construct, traverse, and validate a job dependency graph  
    JobQueue A named queue to which jobs can be added  
    JobQueue.Builder Supports creation of a single empty queue  
    JobRunnerMain  
    JoinTask  
    JsonParameters  

    K

    KnapsackAssignment The assignment of a knapsack item to a knapsack

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackCapacityPropagatorImpl A knapsack propagator that constrains assignments based on knapsack capacity for a given dimension

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackGenericSolverImpl A generic knapsack solver that supports multiple dimensions

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackItem Basic structure of an item in a knapsack

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackPropagator Constraint enforcer for a single dimenstion on a knapsack solution search

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackSearchNode Description of a knapsack element during the search process

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackSearchNodeImpl Implementation of KnapsackSearchNode

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackSearchPath Construction of the path between search nodes in a knapsack

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackSearchPathImpl Implementation of KnapsackSearchPath

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackSolver Interface for a factory of multidimensional 0-1 knapsack solvers that support reductions

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackSolver.SolverType Collection of supported algorithms  
    KnapsackSolverImpl Implementation of KnapsackSolver

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackState The current state of the knapsack

    Based on the C++ knapsack solver in Google's or-tools package. 
    KnapsackStateImpl Implementation of KnapsackState

    Based on the C++ knapsack solver in Google's or-tools package. 

    L

    LeaderHistory The history of instances that have served as the leader controller  
    LeaderStandbyStateModelFactory  
    LeaderStandbyStateModelFactory.LeaderStandbyStateModel  
    LiveInstance Instance that connects to zookeeper (stored ephemerally)  
    LiveInstance.LiveInstanceProperty Saved properties of a live instance  
    LiveInstanceChangeListener Interface to implement to listen for live instance changes. 
    LiveInstanceInfoProvider Interface to provide additional information about a live instance at creation time  
    LocalZKServer Provides ability to start zookeeper locally on a particular port  
    Lock  
    Lock  
    LockFactory  
    LockFactory This factory allows a participant to get the appropriate state model callbacks for the lock manager state model. 
    LockManagerDemo  
    LockManagerDemo  
    LockManagerRebalancer  
    LockProcess  
    LockProcess  
    LogicalModelExample Example showing all major interactions with the new Helix logical model  
    LogicalModelExample.LockUnlockFactory State model factory for lock-unlock  
    LogicalModelExample.LockUnlockStateModel Dummy state model that just prints state transitions for the lock-unlock model  

    M

    MasterSlaveStateModelFactory  
    MasterSlaveStateModelFactory.MasterSlaveStateModel  
    Message Messages sent internally among nodes in the system to respond to changes in state. 
    Message.Attributes Properties attached to Messages  
    Message.MessageState The current processed state of the message  
    Message.MessageType The major categories of messages that are sent  
    MessageConstraintItemBuilder Specify a ConstraintItem based on a message (commonly used for transition constraints)  
    MessageGenerationStage Compares the currentState, pendingState with IdealState and generate messages  
    MessageHandler Provides the base class for all message handlers. 
    MessageHandler.ErrorCode  
    MessageHandler.ErrorType  
    MessageHandlerFactory  
    MessageId  
    MessageListener Interface to implement when there is a change to messages  
    MessageOutput  
    MessagePoster  
    MessageQueueMonitor  
    MessageQueueMonitorMBean  
    MessageSelectionStage  
    MessageSelectionStage.Bounds  
    MessageTask  
    MessageTaskInfo  
    MessageThrottleStage  
    MessageTimeoutTask  
    MultiClusterControllerTransitionHandler  
    MultiClusterControllerTransitionHandlerFactory  
    MyService  
    MyTask Callbacks for task execution - THIS INTERFACE IS SUBJECT TO CHANGE  
    MyTaskAppSpec  
    MyTaskAppSpecFactory  
    MyTaskService A simple "service" for task callback registration. 

    N

    NamespacedConfig Generic configuration of Helix components prefixed with a namespace  
    NettyHelixIPCService Provides partition/state-level messaging among nodes in a Helix cluster. 
    NettyHelixIPCService.Config  
    NotificationContext Metadata associated with a notification event and the current state of the cluster  
    NotificationContext.MapKey keys used for object map  
    NotificationContext.Type Valid types of notifications  

    O

    OnlineOfflineStateModelFactory  
    OnlineOfflineStateModelFactory.OnlineOfflineStateModel  

    P

    Participant A cluster participant  
    ParticipantConfig Configuration properties of a Helix participant  
    ParticipantConfig.Builder Assemble a participant  
    ParticipantConfig.Delta Update context for a ParticipantConfig  
    ParticipantId  
    ParticipantLauncher Main class that invokes the Participant Api  
    ParticipantLauncher.ShutdownMessageHandler  
    ParticipantLauncher.ShutdownMessageHandlerFactory  
    ParticipantMonitor  
    Partition A partition of a resource  
    Partition A distinct partition of a resource Deprecated. 
    PartitionConfiguration Persisted configuration properties for a partition  
    PartitionId  
    PathBasedZkSerializer  
    PathUtils Path related utilities  
    PauseSignal Represent a pause in the cluster  
    PayloadSerializer Interface for converting back and forth between raw bytes and generic objects  
    PerInstanceResourceMonitor  
    PerInstanceResourceMonitor.BeanName  
    PerInstanceResourceMonitorMBean A bean that describes the resource on each instance  
    PersistAssignmentStage Persist the ResourceAssignment of each resource that went through rebalancing  
    PersistContextStage Persist all dirty contexts set in the controller pipeline  
    PersistentStats Statistics for an instance  
    PersistentStats.PersistentStatsProperty High-level properties to provide context for these statistics  
    Pipeline  
    PipelineRegistry  
    PreConnectCallback Called to allow definition of tasks prior to connecting to Zookeeper  
    ProcessMonitorThread thread for monitoring a pid  
    ProcId  
    PropertyChangeListener<T> Callback interface on property changes 
    PropertyItem  
    PropertyJsonComparator<T>  
    PropertyJsonSerializer<T>  
    PropertyKey Key allowing for type-safe lookups of and conversions to HelixProperty objects. 
    PropertyKey.Builder PropertyKey builder for a cluster  
    PropertyPathConfig Utility mapping properties to their Zookeeper locations  
    PropertySerializer<T> Serializer interface for property store 
    PropertyStat  
    PropertyStoreException This exception class can be used to indicate any exception during operation on the propertystore  
    PropertyType Types of data stored on Zookeeper by Helix  
    Provisioner  
    ProvisionerConfig  
    ProvisionerConfigHolder Configuration for a resource provisioner. 
    ProvisionerRef Reference to a class that extends Provisioner

    Q

    Quickstart  

    R

    ReadClusterDataStage  
    Rebalancer Allows one to come up with custom implementation of a rebalancer. 
    RebalancerConfig Defines the state available to a rebalancer. 
    RebalancerConfigHolder Configuration for a resource rebalancer. 
    RebalancerConfigHolder.Fields  
    RebalancerRef Reference to a class that extends HelixRebalancer
    RebalanceUtil  
    RedisTaskResultStore  
    Replicator  
    ReportTask  
    ResolverRoutingTable A routing table that can also return all resources, partitions, and states in the cluster  
    Resource Represent a resource entity in helix cluster  
    Resource A resource contains a set of partitions and its replicas are managed by a state model  
    ResourceAssignment Represents the assignments of replicas for an entire resource, keyed on partitions of the resource. 
    ResourceAssignmentBuilder Build an ideal assignment of resources  
    ResourceComputationStage This stage computes all the resources in a cluster. 
    ResourceConfig Full configuration of a Helix resource. 
    ResourceConfig.Builder Assembles a ResourceConfig  
    ResourceConfig.Delta Update context for a ResourceConfig  
    ResourceConfiguration Persisted configuration properties for a resource  
    ResourceConfiguration.Fields  
    ResourceCurrentState  
    ResourceGroupResource  
    ResourceGroupsResource  
    ResourceId Identifies a resource  
    ResourceMonitor  
    ResourceMonitorMBean  
    ResourceValidationStage  
    RestAdminApplication  
    RoutingTableProvider  
    RsyncDaemon  
    RsyncInvoker  
    RUSHMasterSlaveStrategy  
    RUSHrHash  

    S

    ScheduleBean A bean representing how a workflow can be scheduled in Helix  
    ScheduleConfig Configuration for scheduling both one-time and recurring workflows in Helix  
    ScheduledTaskStateModel  
    ScheduledTaskStateModelFactory  
    SchedulerTaskConfig  
    SchedulerTasksResource This resource can be used to send scheduler tasks to the controller. 
    Scope<T extends Id> Represents the scope of an object. 
    Scope.ScopeType  
    ScopedConfigChangeListener Interface to implement to listen for changes to any specified scope. 
    SemiAutoRebalancer Rebalancer for the SEMI_AUTO mode. 
    SensorNameProvider  
    ServiceConfig  
    ServiceConfig  
    ServiceDiscovery  
    ServiceDiscoveryDemo  
    ServiceMetadata  
    SessionId  
    SetupCluster  
    SetupConsumerCluster  
    ShufflingTwoStateStrategy  
    Spectator A cluster spectator that listen on cluster changes  
    SpectatorId  
    Stage Logically independent unit in processing callbacks for cluster changes  
    StageContext  
    StageException  
    StartClusterManager  
    StartClusterManager  
    StatCollector  
    State A state in a state model managed by Helix  
    StateConstraintItemBuilder Build a ConstraintItem corresponding to a state bound  
    StatelessParticipantService  
    StatelessServiceStateModel  
    StatelessServiceStateModelFactory  
    StateMachineEngine Helix participant uses this class to register/remove state model factory State model factory creates state model that handles state transition messages  
    StateModelConfigGenerator  
    StateModelDefId  
    StateModelDefinition Describe the state model  
    StateModelDefinition.Builder Construct a state model  
    StateModelDefinition.StateModelDefinitionProperty  
    StateModelDefinitionValidator Validator logic for a StateModelDefinition. 
    StateModelFactoryId Id representing a state model factory  
    StateModelInfo  
    StateModelParser Finds the method in stateModel to generate  
    StateModelResource  
    StateModelsResource  
    StateTransitionContext  
    StateTransitionDataPoint  
    StateTransitionError  
    StateTransitionHandlerFactory<T extends TransitionHandler>  
    StateTransitionStatMonitor  
    StateTransitionStatMonitor.LATENCY_TYPE  
    StateTransitionStatMonitorMBean  
    StateTransitionTableBuilder  
    StatusDumpTask  
    StatusUpdate Wraps updates to Helix constructs, e.g. 
    StatusUpdateResource  
    StatusUpdatesResource  
    StatusUpdateUtil Util class to create statusUpdates ZK records and error ZK records. 
    StatusUpdateUtil.Level  
    StatusUpdateUtil.StatusUpdateContents  
    StatusUpdateUtil.TaskStatus  
    StatusUpdateUtil.Transition  
    StringSerializer  
    StringTemplate  
    SystemUtil  
    SystemUtil.ProcessStateCode PROCESS STATE CODES  

    T

    TargetProvider  
    TargetProviderResponse  
    TargetState Enumeration of target states for a job. 
    Task The interface that is to be implemented by a specific task implementation. 
    Task  
    TaskAssignmentStage  
    TaskBean Describes task-specific configuration, including an arbitrary map of key-value pairs to pass to the task  
    TaskCallbackContext A wrapper for all information about a task and the job of which it is a part. 
    TaskCluster  
    TaskConfig  
    TaskConfig Configuration for an individual task to be run as part of a job. 
    TaskConstants Constants used in the task framework. 
    TaskDriver CLI for scheduling/canceling workflows  
    TaskExecutionDemo Demo for execution of task Dag using primitives provided by Helix. 
    TaskExecutor  
    TaskFactory A factory for Task objects. 
    TaskFactory  
    TaskPartitionState Enumeration of the states in the "Task" state model. 
    TaskRebalancer Custom rebalancer implementation for the Task state model. 
    TaskResult The result of a task execution. 
    TaskResult.Status An enumeration of status codes. 
    TaskResultStore  
    TaskRunner A wrapping Runnable used to manage the life-cycle of a user-defined Task implementation. 
    TaskState Enumeration of current task states. 
    TaskStateModel  
    TaskStateModel  
    TaskStateModelFactory Factory class for TaskStateModel
    TaskStateModelFactory  
    TaskUtil Static utility methods. 
    Test  
    TestCommand  
    TestCommand.CommandType  
    TestCommand.NodeOpArg  
    TestExecutor a test is structured logically as a list of commands a command has three parts: COMMAND | TRIGGER | ARG'S COMMAND could be: modify, verify, start, stop TRIGGER is optional and consists of start-time, timeout, and expect-value which means the COMMAND is triggered between [start-time, start-time + timeout] and is triggered when the value in concern equals to expect-value ARG's format depends on COMMAND if COMMAND is modify/verify, arg is in form of: in which key is k1 for SIMPLE, k1|index for LIST, and k1|k2 for MAP field if COMMAND is start/stop, arg is a thread handler  
    TestExecutor.ZnodePropertyType SIMPLE: simple field change LIST: list field change MAP: map field change ZNODE: entire znode change  
    TestTrigger  
    Transition Defines a transition from one state to another  
    Transition  
    TransitionHandler  

    U

    UpdateProvisionerConfig Update the provisioner config  
    UserConfig Generic user-defined configuration of Helix components  

    W

    Worker Generic Worker that is a HELIX Participant which on start up joins the cluster and waits for state transitions from Helix. 
    Workflow Houses a job dag and config set to fully describe a job workflow  
    Workflow.Builder Build a workflow incrementally from dependencies and single configs, validate at build time  
    WorkflowBean Bean class used for parsing workflow definitions from YAML. 
    WorkflowConfig Provides a typed interface to workflow level configurations. 
    WorkflowConfig.Builder  
    WorkflowContext Typed interface to the workflow context information stored by TaskRebalancer in the Helix property store  
    WorkflowsResource  
    WriteThroughCache<T>  

    Y

    YAMLClusterSetup Supports HelixAdmin operations specified by a YAML configuration file defining a cluster, resources, participants, etc. 
    YAMLClusterSetup.YAMLClusterConfig Java wrapper for the YAML input file  
    YAMLClusterSetup.YAMLClusterConfig.ParticipantConfig  
    YAMLClusterSetup.YAMLClusterConfig.ResourceConfig  
    YAMLClusterSetup.YAMLClusterConfig.ResourceConfig.ConstraintsConfig  
    YAMLClusterSetup.YAMLClusterConfig.ResourceConfig.ConstraintsConfig.StateConstraintsConfig  
    YAMLClusterSetup.YAMLClusterConfig.ResourceConfig.ConstraintsConfig.TransitionConstraintsConfig  
    YAMLClusterSetup.YAMLClusterConfig.ResourceConfig.StateModelConfig  
    YarnProvisioner  
    YarnProvisionerConfig  

    Z

    ZkAsyncCallbacks  
    ZkBaseDataAccessor<T>  
    ZkBaseDataAccessor.AccessResult structure holding return information  
    ZkCacheBaseDataAccessor<T>  
    ZkCacheEventThread  
    ZkCallbackCache<T>  
    ZkCallbackHandler We need to synchronize on ZkHelixConnection instead of HelixManager to avoid dead-lock. 
    ZkChildResource  
    ZkClient ZKClient does not provide some functionalities, this will be used for quick fixes if any bug found in ZKClient or if we need additional features but can't wait for the new ZkClient jar Ideally we should commit the changes we do here to ZKClient. 
    ZKClientPool  
    ZkCopy Tool for copying a zk/file path to another zk/file path  
    ZKDumper Dumps the Zookeeper file structure on to Disk  
    ZKExceptionHandler  
    ZkGrep utility for grep zk transaction/snapshot logs - to grep a pattern by t1 use: zkgrep --zkCfg zkCfg --by t1 --pattern patterns... 
    ZKHelixAdmin  
    ZkHelixConnection  
    ZkHelixController  
    ZKHelixDataAccessor  
    ZkHelixLeaderElection  
    ZKHelixLock Locking scheme for Helix that uses the ZooKeeper exclusive lock implementation Please use the following lock order convention: Cluster, Participant, Resource, Partition WARNING: this is not a reentrant lock  
    ZKHelixManager  
    ZkHelixMultiClusterController  
    ZkHelixParticipant  
    ZkHelixPropertyStore<T>  
    ZKHelixResolver A ZooKeeper-specific HelixResolver  
    ZkHelixRoleDefaultImpl  
    ZkListener  
    ZkLogCSVFormatter  
    ZKLogFormatter  
    ZKPathDataDumpTask  
    ZkPathResource  
    ZKUtil  
    ZNode  
    ZnodeOpArg  
    ZnodeValue  
    ZNRecord Generic Record Format to store data at a Node This can be used to store simpleFields mapFields listFields  
    ZNRecordAssembler Constructs ZNRecords from collections of ZNRecords  
    ZNRecordBucketizer Operations to divide a ZNRecord into specified buckets  
    ZNRecordDelta A ZNRecord container that specifies how it should be merged with another ZNRecord  
    ZNRecordDelta.MergeOperation Supported methods of updating a ZNRecord  
    ZNRecordJsonSerializer  
    ZNRecordRow A Normalized form of ZNRecord  
    ZNRecordSerializer  
    ZNRecordStreamingSerializer  
    ZNRecordUpdater Class that specifies how a ZNRecord should be updated with another ZNRecord  
    ZNRecordUtil