All Classes and Interfaces
Class
Description
Abstract class for dynamic auto created queues managed by an implementation
of AbstractManagedParentQueue
An OrderingPolicy which can serve as a baseclass for policies which can be
expressed in terms of comparators
For an application, resource limits and resource requests, decide how to
allocate container.
Provides implementation of
CSQueue methods common for every queue class in Capacity
Scheduler.A container class for automatically created child leaf queues.
Base class for all PlacementProcessors.
Calculate how much resources need to be preempted for each queue,
will be used by
PreemptionCandidatesSelector.Abstract temporary data-structure for tracking resource availability,pending
resource need, current utilization for app/queue.
A strategy class to encapsulate queue capacity setup and resource calculation
logic.
This is the implementation of
ReservationSystem based on the
ResourceSchedulerThis class can be used to track resource usage in queue/user/app.
Use enum here to make implementation more cleaner and readable.
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.
Dispatches ATS related events using multiple threads.
EventType which is used while publishing the events.
TimelinePublishEvent's hash code should be based on application's id this
will ensure all the events related to a particular app goes to particular
thread of MultiThreaded dispatcher.
AbstractUsersManager tracks users in the system.Leader election implementation that uses
ActiveStandbyElector.ActiveUsersManager tracks active users in the system.DAO object to display allocation activities.
Utility for logging scheduler activities
Methods for recording activities from an app
Methods for recording overall activities from one node update
Methods for recording activities from a queue
A class to store node or application allocations.
Class to manage the diagnostics collector.
Utilities for activities.
Collection of activity operation levels.
A planning algorithm that first runs LowCostAligned, and if it fails runs
Greedy.
Thrown when the allocation file for
QueueManager is malformed.Responsible for parsing allocation.xml config file.
Responsible for loading queue configuration properties
from a list of
Elements containing queues.DAO object to display node allocation tag.
Allocation tags under same namespace.
DAO object to display node allocation tags.
In-memory mapping between applications/container-tags and nodes/racks.
Generic store mapping type T to counted tags.
The launch of the AM itself.
AMRM-tokens are per ApplicationAttempt.
Contains all the state data that needs to be stored persistently
for
AMRMTokenSecretManagerDAO object to display application activity.
It contains allocation information for one application within a period of
time.
Factory class to build various application placement policies.
Each placement rule when it successfully places an application onto a queue
returns a PlacementRuleContext which encapsulates the queue the
application was mapped to and any parent queue for the queue (if configured)
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
Simple class to allow users to send information required to create an
ApplicationSubmissionContext which can then be used to submit an app
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.
Manager class to store and check permission for Priority ACLs.
DAO object to display request allocation detailed information.
This class keeps track of all the consumption of an application.
DAO object to display Application timeout information.
This class hosts a set of AppTimeout DAO objects.
Leaf queues which are auto created by an underlying implementation of
AbstractManagedParentQueue.
Auto Created Leaf queue configurations, capacity
Auto deletion policy for auto created queue V2.
A handler for storing and setting auto created queue template settings.
A grouping of Scheduling Requests which are sent to the PlacementAlgorithm
to place as a batch.
Iterator Type.
Tracks blacklists based on failures reported on nodes.
DAO object to display allocation activities.
A storage class that wraps arguments used in a resource calculation iteration.
A group of nodes which can be allocated by scheduler.
Utility methods for
CandidateNodeSet.This policy enforces a time-extended notion of Capacity.
This is the implementation of
QueueACLsManager based on the
CapacityScheduler.This is the implementation of
ReservationsACLsManager based on the
CapacityScheduler.This is the implementation of
ReservationSystem based on the
CapacitySchedulerDifferent resource types supported.
Read-only interface to
CapacityScheduler context.Helper class to describe a queue's type, its creation method and its
eligibility of having auto created children.
Metrics for capacity scheduler.
This class implements a
PlanFollower.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.
Class to store common queue related information, like instances
to necessary manager classes or the global CapacityScheduler
configuration.
Context of the Queues in Capacity Scheduler.
The CentralizedOpportunisticContainerAllocator allocates opportunistic
containers by considering all the nodes present in the cluster, after
modifying the container sizes to respect the limits set by the
ResourceManager.
Configuration holder for class serialization setup
used by the ResourceManager web services layer.
The client interface to the Resource Manager.
Implementations of this class are notified of changes to the cluster's state,
such as node addition, removal and updates.
Represents a node in the cluster from the NodeQueueLoadMonitor's perspective
Properties class used to initialize/change fields in ClusterNode.
Helper library that:
- tracks the state of all cluster
SchedulerNodes
- provides convenience methods to filter and sort nodesThe YARN UI doesn't have centralized login mechanism.
Header for a Web UI column.
A metrics publisher that can publish for a collection of publishers.
Contains logic for computing the fair shares.
A
ConfigurableResource object represents an entity that is used to
configure resources, such as maximum resources of a queue.Interface for determining whether configuration mutations are allowed.
Factory class for creating instances of
ConfigurationMutationACLPolicy.A trie storage to preprocess and store configuration properties for optimised
retrieval.
Contains node labels for all queues extracted from configuration properties.
Version of Scheduler Config.
Marker interface for a Constraint Placement.
This encapsulates an input to the Constraint Placement Algorithm.
Encapsulates the output of the ConstraintPlacementAlgorithm.
The ConstraintPlacementAlgorithm uses the
ConstraintPlacementAlgorithmOutputCollector to collect any output it
spits out.
Proposal to allocate/reserve a new container
The
SchedulerEvent which notifies that a ContainerId
has expired, sent by ContainerAllocationExpirerSimple class to allow users to send information required to create a
ContainerLaunchContext which can then be used as part of the
ApplicationSubmissionContext
Simple event class used to communicate kill reserved containers, mark
containers for preemption and kill already preemption-marked containers.
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.
Class encapsulates all outstanding container increase and decrease
requests for an application.
Holder class that maintains list of container update requests
This is the interface providing functionality to process
application submission context.
This exception is thrown if the request made is not syntactically valid.
Trigger controller publish.
Thrown when the FS-to-CS converter logic encounters a
condition from which it cannot recover (eg. unsupported
settings).
Validates the converted capacity-scheduler.xml by starting
a Capacity Scheduler instance.
diagnostic messages for AMcontainer launching
Reason for the queue to get skipped.
Configuration provider for
CapacityScheduler.This class is responsible for making application submissions to queue
assignments, based on the configured ruleset.
Handles tracking and enforcement for user and queue maxRunningApps
constraints.
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.
Leader election implementation that uses Curator.
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).
Status about a specific decommissioning node.
Default configuration mutation ACL policy.
Basic placement algorithm.
Places apps in the specified default queue.
The default rounding strategy for resource calculation.
Service to renew application delegation tokens.
DeSelectFields make the
/apps api more flexible.Deselect field type, can be boosted in the future.
Generic interface that can be used for collecting diagnostics.
A
BlacklistManager that returns no blacklists.Processor that reject all SchedulingRequests.
Makes scheduling decisions by trying to equalize dominant resource usage.
This class compares two
Schedulable instances according to the
DRF policy.Interface that all embedded leader electors must implement.
The epoch information of RM for work-preserving restart.
This class is used to display an error message to the user in the UI.
A class implements Evaluable interface represents the internal state
of the class can be changed against a given target.
A custom JSON provider that extends
MOXyJsonProvider
to handle JSON marshalling and unmarshalling without including the root element
for configured classes.Simple class representing an execution type request.
FairOrderingPolicy comparison goes through following steps.
1.Fairness based comparison.
This is the implementation of
QueueACLsManager based on the
FairScheduler.Utility methods used by Fair scheduler placement rules.
This is the implementation of
ReservationsACLsManager based on the
FairScheduler.A scheduler that schedules resources between a set of queues.
Shows application information specific to the fair
scheduler as part of the fair scheduler page.
FairScheduler QueueInfo list used for mapping to XML or JSON.
Utility class for the Fair Scheduler.
Makes scheduling decisions by trying to equalize shares of memory.
Class to define client method,params and arguments.
Periodic heart beat from a
ResourceManager participating in
federation to indicate liveliness.Implements
FederationStateStore and provides a service for
participating in the federation membership.Represents an application attempt from the viewpoint of the FIFO or Capacity
scheduler.
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
FifoIntraQueuePreemptionPlugin will handle intra-queue preemption for
priority and user-limit.
An OrderingPolicy which orders SchedulableEntities by input order
This ordering policy is used for pending applications only.
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.File system node attribute implementation.
Represents an application attempt from the viewpoint of the Fair Scheduler.
Parses arguments passed to the FS->CS converter.
Represents options for the converter CLI.
Converts Fair Scheduler configuration (site and fair-scheduler.xml)
to Capacity Scheduler.
Main class that invokes the FS->CS converter.
POJO that holds values for the FS->CS converter.
Builder that can construct FSConfigToCSConfigConverterParams objects.
Class that determines what should happen if the FS->CS converter
encounters a property that is currently not supported.
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.
This class is a main entry-point for any kind of metrics for
custom resources.
A filesystem implementation of
YarnConfigurationStore.Fair Scheduler specific node features.
Converts a Fair Scheduler site configuration to Capacity Scheduler
site configuration.
Helper class to re-generate java POJOs based on the JSON schema.
Generic interface that can be used for collecting diagnostics.
This is the generic implementation of
QueueACLsManager.This Agent employs a simple greedy placement strategy, placing the various
stages of a
ReservationDefinition from the deadline moving backward
towards the arrival.Capacity Management policy for auto created leaf queues
A custom JSON provider that extends
MOXyJsonProvider
to ensure that JSON marshalling and unmarshalling
include the root element for configured classes.A default implementation of
YarnConfigurationStore.This class represents an in memory representation of the state of our
reservation system, and provides accelerated access to both individual
reservations and aggregate utilization of resources over time.
An in memory implementation of a reservation allocation using the
RLESparseResourceAllocationIdentifies over utilized resources within a queue and tries to normalize
them to resolve resource allocation anomalies w.r.t priority and user-limit.
Exception when invalid parameter specified to do placement tags related
queries.
Thrown when Queue Name is malformed.
Abstract invariant checker, that setup common context for invariants
checkers.
This exception represents the violation of an internal invariant.
Used by Load Balancers to find the active ResourceManager.
A planning algorithm consisting of two main phases.
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.
IteratorSelector contains information needed to tell an
OrderingPolicy what to return in an iterator.A JAX-RS
Feature that registers custom MOXy JSON providers
for handling serialization and deserialization of JSON with or without
root elements.This class stores the LeafQueue Template configuration.
This class stores the Configuration Property.
A LevelDB implementation of
YarnConfigurationStore.Changes from 1.0 to 1.1, Addition of ReservationSystem state.
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
Auto Creation enabled Parent queue.
Mapping rule represents a single mapping setting defined by the user.
This interface represents the action part of a MappingRule, action are
responsible to decide what should happen with the actual application
submission.
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.
This class contains all the actions and some helper methods to generate them.
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.
RejectAction represents the action when the application is rejected, this
simply will throw an error on the user's side letting it know the
submission was rejected.
VariableUpdateAction represents the action which alters one of the
mutable variables in the variable context, but doesn't do anything with
the application.
SecondaryGroupVariable represents a conditional variable which is supposed
to evaluate path parts with "%secondary_group".
This class contains all the matcher and some helper methods to generate them.
AndMatcher is a basic boolean matcher which takes multiple other
matcher as it's arguments, and on match it checks if all of them are true.
MatchAllMatcher is a matcher which matches everything.
OrMatcher is a basic boolean matcher which takes multiple other
matcher as its arguments, and on match it checks if any of them are true.
The GroupMatcher will check if any of the user's groups match the provided
group name.
VariableMatcher will check if a provided variable's value matches the
provided value.
This class represents the outcome of an action.
This interface represents a context which contains all methods and data
required by the mapping rules to validate the initial configuration.
This class' functionality needs to be merged into CapacityScheduler
or CapacitySchedulerQueueManager, but that will include a lot of testcase
changes, so temporarily the logic is extracted to this class.
Handles tracking and enforcement for user and queue maxRunningApps
constraints
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.
Provides an table with an overview of many cluster wide metrics and if
per user metrics are enabled it will show an overview of what the
current user is using on the cluster.
This class has the following functionality.
MultiNodePolicySpec contains policyName and timeout.
Common node sorting class which will do sorting based on policy spec.
Node Sorting Manager which runs all sorter threads and policies.
Interface for allowing changing scheduler configurations.
Interface for a scheduler that supports changing configuration at runtime.
CS configuration provider which implements
MutableConfigurationProvider for modifying capacity scheduler
configuration.The response sent by the
ResourceManager to the client for
a request to get a new ReservationId for submitting reservations
using the REST API.DAO for node an attribute record.
DAO for a list of node attributes info.
Manager holding the attributes to Labels.
A
Host can have multiple Nodes.Event capturing details to store the Node Attributes in the backend store.
Event type to store the NodeAttributes.
Event handler class for Node Attributes which sends events to Scheduler.
A read only implementation of the ClusterNodeTracker which exposes a method
to simply return a filtered list of nodes.
Convenience way to filter nodes based on a criteria.
XML element uses to represent NodeIds' list.
Node labels utilities.
The NodeQueueLoadMonitor keeps track of load metrics (such as queue length
and total wait time) associated with Container Queues on the Node Manager.
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.
Resource classification.
This class does nothing when any of the methods are invoked on
SystemMetricsPublisher.
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).
OrderingPolicy is used by the scheduler to order SchedulableEntities for
container assignment and preemption.
XML element uses to represent partitionInfo.
This class represents queue capacities for a given partition
This class represents queue/user resource usage info for a given partition
PendingAsk is the class to include minimal information of how much
resource to ask under constraints (e.g. on one host / rack / node-attributes)
, etc.Result of a resource-request update.
This data structure stores a periodic
RLESparseResourceAllocation.Class to encapsulate a Placed scheduling Request.
Interface for storing and retrieving placement constraints (see
PlacementConstraint).The service that implements the
PlacementConstraintManager interface.An ApplicationMasterServiceProcessor that performs Constrained placement of
Scheduling Requests.
This class contains various static methods used by the Placement Algorithms
to simplify constrained placement.
Factory class for creating instances of
PlacementRule.Abstract base for all Placement Rules.
A Plan represents the central data structure of a reservation system that
maintains the "agenda" for the cluster.
This interface provides read-only access to configuration-type parameter for
a plan.
This interface groups the methods used to modify the state of 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.
Exception thrown by the admission control subsystem when there is a problem
in trying to find an allocation for a user
ReservationSubmissionRequest.This exception is thrown if the user quota is exceed while accepting or
updating a reservation.
This represents a dynamic queue managed by the
ReservationSystem.Traverse Scheduling requests with the most popular tags (count) first.
Indicates that some preconditions were not met
before FS->CS conversion.
Calculate how much resources need to be preempted for each queue,
will be used by
PreemptionCandidatesSelectorInterface for a scheduler that supports preemption/killing
Places apps in queues by the primary group of the submitter.
A Comparator which orders SchedulableEntities by priority.
For two queues with the same priority:
- The queue with less relative used-capacity goes first - today’s behavior
A simple storage class to represent a snapshot of a queue.
This class implement a
SchedulingEditPolicy that is designed to be
paired with the CapacityScheduler.IntraQueuePreemptionOrder will be used to define various priority orders
which could be configured by admin.
Manager for
ProxyCA, which contains the Certificate Authority for
AMs to have certificates for HTTPS communication with the RM Proxy.A configuration mutation ACL policy which checks that user has admin
privileges on all queues they are changing.
This class determines minimum and maximum allocation settings based on the
CapacitySchedulerConfiguration and other queue
properties.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 class that parses
QueueCapacityVector from the capacity
configuration property set for a queue.A storage that encapsulates intermediate calculation values throughout a
full queue capacity update phase.
Contains capacity values with calculation types associated for each
resource.
Represents a capacity type associated with its syntax postfix.
Queue auto refresh policy for queues.
This class interacts with the NodeQueueLoadMonitor to keep track of the
mean and standard deviation of the configured metrics (queue length or queue
wait time) used to characterize the queue load of a specific node.
Encapsulates Queue entitlement and state updates needed
for adjusting capacity dynamically
Updating the queue may involve entitlement updates
and/or QueueState changes
QueueAction can potentially be enhanced
for adding, removing queues for queue management
Event to update scheduler of any queue management changes
Queue Management scheduling policy for managed parent queues which enable
auto child queue creation
Maintains a list of queues as well as scheduling parameters for each queue,
such as guaranteed share allocations, from the fair scheduler config file.
Queue Mapping class to hold the queue mapping information.
Different types of mapping.
Builder class for QueueMapping.
This class determines accessible node labels, configured node labels and the default node
label expression based on the
CapacitySchedulerConfiguration object and other queue
properties.This will be used by
ParentQueue
to decide allocation ordering of child queues.This is a helper class which represents a queue path, and has easy access
methods to get the path's parent or leaf part, or as a whole.
Utility class for Capacity Scheduler queue PlacementRules.
This class is a value class, storing queue properties parsed from the
allocation.xml config file.
Builder class for
QueueProperties.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.
Represents an approach on how to convert a calculated resource from floating point to a whole
number.
Collects all logic that are handling queue state transitions.
QueueStateManager which can be used by Scheduler to manage the queue state.
Represents a warning event that occurred during a queue capacity update phase.
A Comparator which orders SchedulableEntities by isRecovering flag.
This class is used to display a message that the proxy request failed
because of a redirection issue.
Allocate normal (new) containers, considers locality/label, etc.
Rejects all placements.
Event used to release a container.
An entity that seeks to acquire resources to satisfy an user's contract
A ReservationAllocation represents a concrete allocation of resources over
time that satisfy a certain
ReservationDefinition.Simple class that represent a reservation definition.
Simple class represent the request of deleting a given reservation,
selected by its id.
Simple class that represent a response to a delete operation.
Simple class that represent a reservation.
This represents the time duration of the reservation
Invariant checker that checks certain reservation invariants are respected.
Simple class that represent a list of reservations.
This represents a dynamic
LeafQueue managed by the
ReservationSystemSimple class representing a reservation request.
Simple class representing a list of ReservationRequest and the
interpreter which capture the semantic of this list (all/any/order).
The
ReservationsACLsManager is used to check a specified user's
permissons to perform a reservation operation on the
ReservationACLs are used to specify reservation operations.Simple class to allow users to send information required to create an
ReservationSubmissionContext which can then be used to submit a reservation.
This interface is the one implemented by any system that wants to support
Reservations i.e. make
Resource allocations in future.Simple helper class for static methods used to transform across
common formats in tests
Simple class to allow users to send information required to update an
existing reservation.
Simple class that represent the response to a reservation update
request.
Scheduler should implement this interface if it wants to have multi-threading
plus global scheduling functionality
Simple class that represent a resource allocation.
Drives the main logic of resource calculation for all children under a queue.
Resource limits for queues/applications, this means max overall (please note
that, it's not "extra") resource you can get.
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}.
This exception indicate that the reservation that has been attempted, would
exceed the physical resources available in the
Plan at the moment.Interface for the resource profiles manager.
PBImpl class to handle all proto related implementation for
ResourceProfilesManager.
Simple class representing a resource request.
This interface is the one implemented by the schedulers.
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.
This class has the following functionality:
DAO object represents resource utilization of node and containers.
Represents a simple resource floating point value grouped by resource names.
This is a run length encoded sparse data structure that maintains resource
allocations over time.
The set of operators that can be applied to two
RLESparseResourceAllocation during a merge operation.The RMActiveServiceContext is the class that maintains Active service
context.
The interface to an Application in the ResourceManager.
Interface to an Application Attempt in the Resource Manager.
An event class that is used to help with logging information
when an application KILL event is needed.
This service will monitor the applications against the lifetime value given.
Log aggregation logic used by RMApp.
This class manages the list of applications for the resource manager.
This class used for monitor application with applicationId+appTimeoutType.
Manages ResourceManager audit logs.
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.
RMContextImpl class holds two services context.
This class either shuts down
ResourceManager or transitions the
ResourceManager to standby state if a critical thread throws an
uncaught exception.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.
Interface for RMInfo class.
JMX bean listing statuses of all node managers.
Node managers information on available resources
and other static information.
RMNode Decommissioning Event.
This class is used to keep track of all the applications/containers
running on a node.
The transition to put node in decommissioning state.
Status update transition when node is healthy.
Transition to Update a container.
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.
PolicyProvider for YARN ResourceManager protocols.Utility methods to aid serving RM data through the REST and RPC APIs
RMServiceContext class maintains "Always On" services.
State of the ResourceManager
The enum defines state of RMStateStore.
A event used to store ProxyCA information.
A event used to remove an attempt.
Event representing maintaining ReservationSystem state.
Utility methods for
RMStateStore and subclasses.This exception is thrown by ResourceManager if it's loading an incompatible
version of storage on recovery.
This class extends TimelineCollectorManager to provide RM specific
implementations.
The RM webapp
Util class for ResourceManager WebApp.
The protocol between clients and the
ResourceManager to
submit/abort jobs and to get information on applications, cluster metrics,
nodes, queues, ACLs and reservations via REST calls.Constants for
RMWebServiceProtocol.Defines the groupBy types of activities, currently only support
DIAGNOSTIC with which user can query aggregated activities
grouped by allocation state and diagnostic.
Defines the required action of app activities:
REFRESH means to turn on activities recording for the required app,
GET means the required app activities should be involved in response.
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 Schedulable represents an entity that can be scheduled such as an
application or a queue.
A SchedulableEntity is a process to be scheduled.
Represents an application attempt from the viewpoint of the scheduler.
Different state for Application Master, user can see this state from web UI
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.
Represents a YARN Cluster Node from the viewpoint of the scheduler.
Node usage report.
Forwarding SchedulingRequests to be handled by the scheduler, as long as the
scheduler supports SchedulingRequests.
Represents a queue in Scheduler.
Context of the Queues in Scheduler.
Utilities shared by schedulers.
This class contains invalid resource information along with its
resource request.
Scheduling modes, see below for detailed explanations
Manages scheduling monitors.
The SchedulingPolicy is used by the fair scheduler mainly to determine
what a queue's fair share and steady fair share should be as well as
calculating available headroom.
Simple holder class encapsulating a SchedulingRequest
with a placement attempt.
This class encapsulates the response received from the ResourceScheduler's
attemptAllocateOnNode method.
Places apps in queues by the secondary group of the submitter, if the
submitter is a member of more than one group.
Traverse Scheduling Requests in the same order as they arrive
This is the interface for policy that validate new
ReservationAllocations for allocations being added to a Plan.Maintains a list of failed nodes and returns that as long as number of
blacklisted nodes is below a threshold percentage of total nodes.
A simple CandidateNodeSet which keeps an unordered map
This (re)planner scan a period of time from now to a maximum time window (or
the end of the last session, whichever comes first) checking the overall
capacity is not violated.
This is a simple implementation to do affinity or anti-affinity for
inter/intra apps.
Places apps in queues by requested queue of the submitter.
Interface for allocating a single stage in IterativePlanner.
Computes the stage allocation according to the greedy allocation rule.
Computes the stage allocation according to the greedy allocation rule.
A stage allocator that iteratively allocates containers in the
StageAllocatorLowCostAligned.DurationInterval with lowest overall cost.An inner class that represents an interval, typically of length duration.
An auxiliary class used to compute the time interval in which the stage can
be allocated resources by
IterativePlanner.An implementation of
StageExecutionInterval, which sets the execution
interval of the stage.An implementation of
StageExecutionInterval which gives each stage
the maximal possible time interval, given the job constraints.This exception is thrown when Application Data size exceeds limit RM state
store.
Pre process the ApplicationSubmissionContext with server side info.
Interface used to publish app/container events to timelineservice.
This class is used by
TargetApplicationsNamespace.evaluate(TargetApplications) to evaluate
a namespace.Class to describe the namespace of allocation tags, used by
AllocationTags.Namespace to all applications in the cluster.
Namespace defined by a certain application ID.
Namespace to applications that attached with a certain application tag.
Namespace to all applications except itself.
Namespace within application itself.
Temporary data-structure tracking resource availability, pending resource
need, current utilization for an application.
Temporary data-structure tracking resource availability, pending resource
need, current utilization.
This class will save necessary information which copied from
FiCaSchedulerNode.
Temporary data-structure tracking resource availability, pending resource
need, current utilization for an application.
This class is responsible for posting application, appattempt & Container
lifecycle related events to timeline service v1.
This class is responsible for posting application, appattempt & Container
lifecycle related events to timeline service v2.
A planning algorithm that invokes several other planning algorithms according
to a given order.
Thrown by the FS->CS converter if it encounters an
unsupported property.
Places apps in queues by username of the submitter.
UsersManager tracks users in the system and its respective data
structures.User class stores all user related resource usage, application details.
Validate volume capability with the CSI driver.
This class is a key-value store for the variables and their respective values
during an application placement.
Thrown when Capacity Scheduler fails to start up with
the converted configuration.
Major volume interface at RM's view, it maintains the volume states and
state transition according to the CSI volume lifecycle.
AMS processor that handles volume resource requests.
Helper class to build a
Volume.Base volume event class that used to trigger volume state transitions.
Volume events.
This class maintains the volume states and state transition
according to the CSI volume lifecycle.
Main interface for volume manager that manages all volumes.
A service manages all volumes.
A task interface to provision a volume to expected state.
Result of volumes' provisioning.
A provisioning task encapsulates all the logic required by a storage system
to provision a volume.
Volume states
Volume states are defined in the CSI spec, see more in volume lifecycle.
Volume manager states, including all managed volumes and their states.
YarnConfigurationStore exposes the methods needed for retrieving and
persisting
CapacityScheduler configuration via key-value
using write-ahead logging.LogMutation encapsulates the fields needed for configuration mutation
audit logging and recovery.
Factory class for creating instances of
YarnConfigurationStore.This exception is thrown by
YarnConfigurationStore if it's loading
an incompatible persisted schema version.This interface is used by the components to talk to the
scheduler for allocating of resources, cleaning up resources.
A Zookeeper-based implementation of
YarnConfigurationStore.RMStateStore implementation backed by ZooKeeper.Class to capture the performance metrics of ZKRMStateStore.