All Classes

Abstract class for dynamic auto created queues managed by an implementation of AbstractManagedParentQueue

For an application, resource limits and resource requests, decide how to allocate container.

A container class for automatically created child leaf queues.

Calculate how much resources need to be preempted for each queue, will be used by PreemptionCandidatesSelector.

A strategy class to encapsulate queue capacity setup and resource calculation logic.

This class can be used to track resource usage in queue/user/app.

UsageByLabel stores resource array for all resource usage types.

Abstract implementation of SystemMetricsPublisher which is then extended by metrics publisher implementations depending on timeline service version.

EventType which is used while publishing the events.

AbstractUsersManager tracks users in the system.

Leader election implementation that uses ActiveStandbyElector.

DAO object to display allocation activities.

Methods for recording activities from an app

Methods for recording activities from a queue

Class to manage the diagnostics collector.

Responsible for loading queue configuration properties from a list of Elements containing queues.

Allocation tags under same namespace.

In-memory mapping between applications/container-tags and nodes/racks.

The launch of the AM itself.

AMRM-tokens are per ApplicationAttempt.

Factory class to build various application placement policies.

This class will keep all Scheduling env's names which will help in placement calculations.

Contains all the state data that needs to be stored persistently for an Application

This class has the following functionality: 1) Keeps track of pending resource requests when following events happen: - New ResourceRequests are added to scheduler.

PriorityACLConfiguration class is used to parse Application Priority ACL configuration from capcity-scheduler.xml

PriorityACLGroup will hold all ACL related information per priority.

DAO object to display request allocation detailed information.

DAO object to display Application timeout information.

Auto Created Leaf queue configurations, capacity

Iterator Type.

DAO object to display allocation activities.

A group of nodes which can be allocated by scheduler.

This is the implementation of QueueACLsManager based on the CapacityScheduler.

This is the implementation of ReservationSystem based on the CapacityScheduler

Helper class to describe a queue's type, its creation method and its eligibility of having auto created children.

Metrics for capacity scheduler.

This interface provides context for the calculation of ideal allocation and preemption for the CapacityScheduler.

Controls how capacity and resource values are set and calculated for a queue.

Context of the Queues in Capacity Scheduler.

The client interface to the Resource Manager.

Represents a node in the cluster from the NodeQueueLoadMonitor's perspective

Helper library that: - tracks the state of all cluster SchedulerNodes - provides convenience methods to filter and sort nodes

Header for a Web UI column.

Contains logic for computing the fair shares.

Interface for determining whether configuration mutations are allowed.

A trie storage to preprocess and store configuration properties for optimised retrieval.

Contains node labels for all queues extracted from configuration properties.

Marker interface for a Constraint Placement.

Encapsulates the output of the ConstraintPlacementAlgorithm.

Proposal to allocate/reserve a new container

The SchedulerEvent which notifies that a ContainerId has expired, sent by ContainerAllocationExpirer

ContainerRequest is a class to capture resource requests associated with a Container, this will be used by scheduler to recover resource requests if the container preempted or cancelled before AM acquire the container.

Holder class that maintains list of container update requests

This exception is thrown if the request made is not syntactically valid.

Thrown when the FS-to-CS converter logic encounters a condition from which it cannot recover (eg.

Validates the converted capacity-scheduler.xml by starting a Capacity Scheduler instance.

diagnostic messages for AMcontainer launching

Reason for the queue to get skipped.

This class is responsible for making application submissions to queue assignments, based on the configured ruleset.

CSQueue represents a node in the tree of hierarchical queues in the CapacityScheduler.

This class is a main entry-point for any kind of CSQueueMetrics for custom resources.

DecommissioningNodesWatcher is used by ResourceTrackerService to track DECOMMISSIONING nodes to decide when, after all running containers on the node have completed, will be transitioned into DECOMMISSIONED state (NodeManager will be told to shutdown).

Default configuration mutation ACL policy.

Places apps in the specified default queue.

DeSelectFields make the /apps api more flexible.

Generic interface that can be used for collecting diagnostics.

Processor that reject all SchedulingRequests.

This class compares two Schedulable instances according to the DRF policy.

The epoch information of RM for work-preserving restart.

This class is used to display an error message to the user in the UI.

Simple class representing an execution type request.

This is the implementation of QueueACLsManager based on the FairScheduler.

This is the implementation of ReservationsACLsManager based on the FairScheduler.

A scheduler that schedules resources between a set of queues.

FairScheduler QueueInfo list used for mapping to XML or JSON.

Makes scheduling decisions by trying to equalize shares of memory.

Periodic heart beat from a ResourceManager participating in federation to indicate liveliness.

Order FSAppAttempt objects by priority and then by submit time, as in the default scheduler in Hadoop.

A Comparator which orders SchedulableEntities by input order

An OrderingPolicy which orders SchedulableEntities by input order

Similar to FifoOrderingPolicy, but with separate ordering policies for each partition in yarn.scheduler.capacity.<queue-path>.ordering-policy.exclusive-enforced-partitions.

CapacityScheduler configuration provider based on local capacity-scheduler.xml file.

Parses arguments passed to the FS->CS converter.

Converts Fair Scheduler configuration (site and fair-scheduler.xml) to Capacity Scheduler.

POJO that holds values for the FS->CS converter.

Helper class that holds basic information to be passed around FairScheduler classes.

Class to capture the performance metrics of FairScheduler.

Abstract base for all FairScheduler Placement Rules.

Converts a Fair Schedule queue hierarchy to Capacity Scheduler configuration.

Fair Scheduler specific node features.

Helper class to re-generate java POJOs based on the JSON schema.

This Agent employs a simple greedy placement strategy, placing the various stages of a ReservationDefinition from the deadline moving backward towards the arrival.

A default implementation of YarnConfigurationStore.

An in memory implementation of a reservation allocation using the RLESparseResourceAllocation

Exception when invalid parameter specified to do placement tags related queries.

Abstract invariant checker, that setup common context for invariants checkers.

Used by Load Balancers to find the active ResourceManager.

Helper class that provide a list of ReservationRequests and iterates forward or backward depending whether we are allocating left-to-right or right-to-left.

This class stores the Configuration Property.

A LevelDB implementation of YarnConfigurationStore.

This is an implementation of the AppPlacementAllocator that takes into account locality preferences (node, rack, any) when allocating containers.

Simple class to allow users to send information required to create a ContainerLaunchContext which can then be used as part of the ApplicationSubmissionContext

Mapping rule represents a single mapping setting defined by the user.

This class implements the fallback logic for MappingRuleActions, this can be extended to implement the actual logic of the actions, this should be a base class for most actions.

PlaceToQueueAction represents a placement action, contains the pattern of the queue name or path in which the path variables will be substituted with the variable context's respective values.

VariableUpdateAction represents the action which alters one of the mutable variables in the variable context, but doesn't do anything with the application.

This class contains all the matcher and some helper methods to generate them.

MatchAllMatcher is a matcher which matches everything.

The GroupMatcher will check if any of the user's groups match the provided group name.

This class represents the outcome of an action.

In memory implementation of the PlacementConstraintManagerService.

This policy checks at every invocation that a given set of invariants (specified in a file) are respected over QueueMetrics and JvmMetrics.

This class has the following functionality.

Common node sorting class which will do sorting based on policy spec.

Interface for allowing changing scheduler configurations.

CS configuration provider which implements MutableConfigurationProvider for modifying capacity scheduler configuration.

DAO for a list of node attributes info.

A Host can have multiple Nodes.

Event type to store the NodeAttributes.

A read only implementation of the ClusterNodeTracker which exposes a method to simply return a filtered list of nodes.

XML element uses to represent NodeIds' list.

Node labels utilities.

The comparator used to specify the metric against which the load of two Nodes are compared.

Node usage report.

The class that encapsulates response from clusterinfo for updates from the node managers.

This policy enforce a simple physical cluster capacity constraints, by validating that the allocation proposed fits in the current plan.

The OpportunisticContainerAllocatorAMService is started instead of the ApplicationMasterService if opportunistic scheduling is enabled for the YARN cluster (either centralized or distributed opportunistic scheduling).

This class represents queue capacities for a given partition

This class represents queue/user resource usage info for a given partition

Result of a resource-request update.

This data structure stores a periodic RLESparseResourceAllocation.

Interface for storing and retrieving placement constraints (see PlacementConstraint).

An ApplicationMasterServiceProcessor that performs Constrained placement of Scheduling Requests.

Factory class for creating instances of PlacementRule.

Abstract base for all Placement Rules.

This interface provides read-only access to configuration-type parameter for a plan.

A PlanFollower is a component that runs on a timer, and synchronizes the underlying ResourceScheduler with the Plan(s) and viceversa.

An abstract class that follows the general behavior of planning algorithms.

This exception is thrown if the user quota is exceed while accepting or updating a reservation.

Traverse Scheduling requests with the most popular tags (count) first.

Interface for a scheduler that supports preemption/killing

A Comparator which orders SchedulableEntities by priority.

A simple storage class to represent a snapshot of a queue.

IntraQueuePreemptionOrder will be used to define various priority orders which could be configured by admin.

A configuration mutation ACL policy which checks that user has admin privileges on all queues they are changing.

This class determines application lifetime and max parallel apps settings based on the CapacitySchedulerConfiguration and other queue properties.

DAO which wraps PartitionQueueCapacitiesInfo applicable for a queue

A storage that encapsulates intermediate calculation values throughout a full queue capacity update phase.

Queue auto refresh policy for queues.

Encapsulates Queue entitlement and state updates needed for adjusting capacity dynamically

Queue Management scheduling policy for managed parent queues which enable auto child queue creation

Queue Mapping class to hold the queue mapping information.

Builder class for QueueMapping.

This will be used by ParentQueue to decide allocation ordering of child queues.

Utility class for Capacity Scheduler queue PlacementRules.

This class is a value class, storing queue properties parsed from the allocation.xml config file.

QueueResourceQuotas by Labels for following fields by label - EFFECTIVE_MIN_CAPACITY - EFFECTIVE_MAX_CAPACITY This class can be used to track resource usage in queue/user/app.

Collects all logic that are handling queue state transitions.

Represents a warning event that occurred during a queue capacity update phase.

This class is used to display a message that the proxy request failed because of a redirection issue.

Rejects all placements.

An entity that seeks to acquire resources to satisfy an user's contract

Simple class represent the request of deleting a given reservation, selected by its id.

Simple class that represent a reservation.

This represents the time duration of the reservation

Simple class that represent a list of reservations.

Simple class representing a list of ReservationRequest and the interpreter which capture the semantic of this list (all/any/order).

This interface is the one implemented by any system that wants to support Reservations i.e.

Simple class to allow users to send information required to update an existing reservation.

Simple class that represent a resource allocation.

The ResourceManager is the main class that is a set of components.

This is the JMX management interface for ResourceManager.

A JAXB representation of a {link ResourceOption}.

Interface for the resource profiles manager.

Simple class representing a resource request.

DAO which wraps PartitionResourceUsageInfo applicable for a queue/user

Resource Usage by Labels for following fields by label - AM resource (to enforce max-am-resource-by-label after YARN-2637) - Used resource (includes AM resource usage) - Reserved resource - Pending resource - Headroom This class can be used to track resource usage in queue/user/app.

DAO object represents resource utilization of node and containers.

This is a run length encoded sparse data structure that maintains resource allocations over time.

The RMActiveServiceContext is the class that maintains Active service context.

Interface to an Application Attempt in the Resource Manager.

ResourceManager uses this class to write the information of RMApp, RMAppAttempt and RMContainer.

This service will monitor the applications against the lifetime value given.

This class used for monitor application with applicationId+appTimeoutType.

Builder to create and pass a list of arbitrary key value pairs for logging.

Represents the ResourceManager's view of an application container.

The event signifying that a container has been reserved.

SecretManager for ContainerTokens.

Context of the ResourceManager.

Update nodes labels map for ResourceManager periodically.

A ResourceManager specific delegation token secret manager.

Event that indicates a non-recoverable error for the resource manager.

JMX bean for RM info.

JMX bean listing statuses of all node managers.

Node managers information on available resources and other static information.

Interface which is responsible for providing the node -> labels map.

This class is used to create update container event for the containers running on a node.

Utility methods to aid serving RM data through the REST and RPC APIs

The enum defines state of RMStateStore.

A event used to remove an attempt.

Event representing maintaining ReservationSystem state.

This exception is thrown by ResourceManager if it's loading an incompatible version of storage on recovery.

The RM webapp

Util class for ResourceManager WebApp.

Defines the groupBy types of activities, currently only support DIAGNOSTIC with which user can query aggregated activities grouped by allocation state and diagnostic.

A special case that contains the resource calculation of the root queue.

This is UpdateContainerRequest in scheduler side, it contains some pointers to runtime objects like RMContainer, SchedulerNode, etc.

A SchedulableEntity is a process to be scheduled.

Represents an application attempt from the viewpoint of the scheduler.

Represents an application attempt, and the resources that the attempt is using.

Contexts for a container inside scheduler

SchedulerHealth class holds the details of the schedulers operations.

Node usage report.

Represents a queue in Scheduler.

This class contains invalid resource information along with its resource request.

Scheduling modes, see below for detailed explanations

Manages scheduling monitors.

Simple holder class encapsulating a SchedulingRequest with a placement attempt.

Places apps in queues by the secondary group of the submitter, if the submitter is a member of more than one group.

This is the interface for policy that validate new ReservationAllocations for allocations being added to a Plan.

A simple CandidateNodeSet which keeps an unordered map

This is a simple implementation to do affinity or anti-affinity for inter/intra apps.

Interface for allocating a single stage in IterativePlanner.

Computes the stage allocation according to the greedy allocation rule.

An inner class that represents an interval, typically of length duration.

An implementation of StageExecutionInterval, which sets the execution interval of the stage.

This exception is thrown when Application Data size exceeds limit RM state store.

Interface used to publish app/container events to timelineservice.

Class to describe the namespace of allocation tags, used by AllocationTags.

Namespace defined by a certain application ID.

Namespace to all applications except itself.

Temporary data-structure tracking resource availability, pending resource need, current utilization for an application.

This class will save necessary information which copied from FiCaSchedulerNode.

This class is responsible for posting application, appattempt & Container lifecycle related events to timeline service v1.

A planning algorithm that invokes several other planning algorithms according to a given order.

User class stores all user related resource usage, application details.

Validate volume capability with the CSI driver.

Thrown when Capacity Scheduler fails to start up with the converted configuration.

AMS processor that handles volume resource requests.

Base volume event class that used to trigger volume state transitions.

This class maintains the volume states and state transition according to the CSI volume lifecycle.

A service manages all volumes.

Result of volumes' provisioning.

Volume states Volume states are defined in the CSI spec, see more in volume lifecycle.

LogMutation encapsulates the fields needed for configuration mutation audit logging and recovery.

This exception is thrown by YarnConfigurationStore if it's loading an incompatible persisted schema version.

A Zookeeper-based implementation of YarnConfigurationStore.

Class to capture the performance metrics of ZKRMStateStore.