public AllocationConfiguration(Configuration conf)
{
minQueueResources = new Dictionary <string, Org.Apache.Hadoop.Yarn.Api.Records.Resource
>();
maxQueueResources = new Dictionary <string, Org.Apache.Hadoop.Yarn.Api.Records.Resource
>();
queueWeights = new Dictionary <string, ResourceWeights>();
queueMaxApps = new Dictionary <string, int>();
userMaxApps = new Dictionary <string, int>();
queueMaxAMShares = new Dictionary <string, float>();
userMaxAppsDefault = int.MaxValue;
queueMaxAppsDefault = int.MaxValue;
queueMaxAMShareDefault = 0.5f;
queueAcls = new Dictionary <string, IDictionary <QueueACL, AccessControlList> >();
minSharePreemptionTimeouts = new Dictionary <string, long>();
fairSharePreemptionTimeouts = new Dictionary <string, long>();
fairSharePreemptionThresholds = new Dictionary <string, float>();
schedulingPolicies = new Dictionary <string, SchedulingPolicy>();
defaultSchedulingPolicy = SchedulingPolicy.DefaultPolicy;
reservableQueues = new HashSet <string>();
configuredQueues = new Dictionary <FSQueueType, ICollection <string> >();
foreach (FSQueueType queueType in FSQueueType.Values())
{
configuredQueues[queueType] = new HashSet <string>();
}
placementPolicy = QueuePlacementPolicy.FromConfiguration(conf, configuredQueues);
}
public virtual void InitTest()
{
configuredQueues = new Dictionary <FSQueueType, ICollection <string> >();
foreach (FSQueueType type in FSQueueType.Values())
{
configuredQueues[type] = new HashSet <string>();
}
}
/// <summary>
/// Make way for the given queue if possible, by removing incompatible
/// queues with no apps in them.
/// </summary>
/// <remarks>
/// Make way for the given queue if possible, by removing incompatible
/// queues with no apps in them. Incompatibility could be due to
/// (1) queueToCreate being currently a parent but needs to change to leaf
/// (2) queueToCreate being currently a leaf but needs to change to parent
/// (3) an existing leaf queue in the ancestry of queueToCreate.
/// We will never remove the root queue or the default queue in this way.
/// </remarks>
/// <returns>true if we can create queueToCreate or it already exists.</returns>
private bool RemoveEmptyIncompatibleQueues(string queueToCreate, FSQueueType queueType
)
{
queueToCreate = EnsureRootPrefix(queueToCreate);
// Ensure queueToCreate is not root and doesn't have the default queue in its
// ancestry.
if (queueToCreate.Equals(RootQueue) || queueToCreate.StartsWith(RootQueue + "." +
YarnConfiguration.DefaultQueueName + "."))
{
return(false);
}
FSQueue queue = queues[queueToCreate];
// Queue exists already.
if (queue != null)
{
if (queue is FSLeafQueue)
{
if (queueType == FSQueueType.Leaf)
{
// if queue is already a leaf then return true
return(true);
}
// remove incompatibility since queue is a leaf currently
// needs to change to a parent.
return(RemoveQueueIfEmpty(queue));
}
else
{
if (queueType == FSQueueType.Parent)
{
return(true);
}
// If it's an existing parent queue and needs to change to leaf,
// remove it if it's empty.
return(RemoveQueueIfEmpty(queue));
}
}
// Queue doesn't exist already. Check if the new queue would be created
// under an existing leaf queue. If so, try removing that leaf queue.
int sepIndex = queueToCreate.Length;
sepIndex = queueToCreate.LastIndexOf('.', sepIndex - 1);
while (sepIndex != -1)
{
string prefixString = Sharpen.Runtime.Substring(queueToCreate, 0, sepIndex);
FSQueue prefixQueue = queues[prefixString];
if (prefixQueue != null && prefixQueue is FSLeafQueue)
{
return(RemoveQueueIfEmpty(prefixQueue));
}
sepIndex = queueToCreate.LastIndexOf('.', sepIndex - 1);
}
return(true);
}
private FSQueue GetQueue(string name, bool create, FSQueueType queueType)
{
name = EnsureRootPrefix(name);
lock (queues)
{
FSQueue queue = queues[name];
if (queue == null && create)
{
// if the queue doesn't exist,create it and return
queue = CreateQueue(name, queueType);
// Update steady fair share for all queues
if (queue != null)
{
rootQueue.RecomputeSteadyShares();
}
}
return(queue);
}
}
/// <summary>Updates the allocation list from the allocation config file.</summary>
/// <remarks>
/// Updates the allocation list from the allocation config file. This file is
/// expected to be in the XML format specified in the design doc.
/// </remarks>
/// <exception cref="System.IO.IOException">if the config file cannot be read.</exception>
/// <exception cref="AllocationConfigurationException">if allocations are invalid.</exception>
/// <exception cref="Javax.Xml.Parsers.ParserConfigurationException">if XML parser is misconfigured.
/// </exception>
/// <exception cref="Org.Xml.Sax.SAXException">if config file is malformed.</exception>
/// <exception cref="Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Scheduler.Fair.AllocationConfigurationException
/// "/>
public virtual void ReloadAllocations()
{
lock (this)
{
if (allocFile == null)
{
return;
}
Log.Info("Loading allocation file " + allocFile);
// Create some temporary hashmaps to hold the new allocs, and we only save
// them in our fields if we have parsed the entire allocs file successfully.
IDictionary <string, Resource> minQueueResources = new Dictionary <string, Resource
>();
IDictionary <string, Resource> maxQueueResources = new Dictionary <string, Resource
>();
IDictionary <string, int> queueMaxApps = new Dictionary <string, int>();
IDictionary <string, int> userMaxApps = new Dictionary <string, int>();
IDictionary <string, float> queueMaxAMShares = new Dictionary <string, float>();
IDictionary <string, ResourceWeights> queueWeights = new Dictionary <string, ResourceWeights
>();
IDictionary <string, SchedulingPolicy> queuePolicies = new Dictionary <string, SchedulingPolicy
>();
IDictionary <string, long> minSharePreemptionTimeouts = new Dictionary <string, long
>();
IDictionary <string, long> fairSharePreemptionTimeouts = new Dictionary <string, long
>();
IDictionary <string, float> fairSharePreemptionThresholds = new Dictionary <string,
float>();
IDictionary <string, IDictionary <QueueACL, AccessControlList> > queueAcls = new Dictionary
<string, IDictionary <QueueACL, AccessControlList> >();
ICollection <string> reservableQueues = new HashSet <string>();
int userMaxAppsDefault = int.MaxValue;
int queueMaxAppsDefault = int.MaxValue;
float queueMaxAMShareDefault = 0.5f;
long defaultFairSharePreemptionTimeout = long.MaxValue;
long defaultMinSharePreemptionTimeout = long.MaxValue;
float defaultFairSharePreemptionThreshold = 0.5f;
SchedulingPolicy defaultSchedPolicy = SchedulingPolicy.DefaultPolicy;
// Reservation global configuration knobs
string planner = null;
string reservationAgent = null;
string reservationAdmissionPolicy = null;
QueuePlacementPolicy newPlacementPolicy = null;
// Remember all queue names so we can display them on web UI, etc.
// configuredQueues is segregated based on whether it is a leaf queue
// or a parent queue. This information is used for creating queues
// and also for making queue placement decisions(QueuePlacementRule.java).
IDictionary <FSQueueType, ICollection <string> > configuredQueues = new Dictionary <FSQueueType
, ICollection <string> >();
foreach (FSQueueType queueType in FSQueueType.Values())
{
configuredQueues[queueType] = new HashSet <string>();
}
// Read and parse the allocations file.
DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.NewInstance();
docBuilderFactory.SetIgnoringComments(true);
DocumentBuilder builder = docBuilderFactory.NewDocumentBuilder();
Document doc = builder.Parse(allocFile);
Element root = doc.GetDocumentElement();
if (!"allocations".Equals(root.GetTagName()))
{
throw new AllocationConfigurationException("Bad fair scheduler config " + "file: top-level element not <allocations>"
);
}
NodeList elements = root.GetChildNodes();
IList <Element> queueElements = new AList <Element>();
Element placementPolicyElement = null;
for (int i = 0; i < elements.GetLength(); i++)
{
Node node = elements.Item(i);
if (node is Element)
{
Element element = (Element)node;
if ("queue".Equals(element.GetTagName()) || "pool".Equals(element.GetTagName()))
{
queueElements.AddItem(element);
}
else
{
if ("user".Equals(element.GetTagName()))
{
string userName = element.GetAttribute("name");
NodeList fields = element.GetChildNodes();
for (int j = 0; j < fields.GetLength(); j++)
{
Node fieldNode = fields.Item(j);
if (!(fieldNode is Element))
{
continue;
}
Element field = (Element)fieldNode;
if ("maxRunningApps".Equals(field.GetTagName()))
{
string text = ((Text)field.GetFirstChild()).GetData().Trim();
int val = System.Convert.ToInt32(text);
userMaxApps[userName] = val;
}
}
}
else
{
if ("userMaxAppsDefault".Equals(element.GetTagName()))
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
int val = System.Convert.ToInt32(text);
userMaxAppsDefault = val;
}
else
{
if ("defaultFairSharePreemptionTimeout".Equals(element.GetTagName()))
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
long val = long.Parse(text) * 1000L;
defaultFairSharePreemptionTimeout = val;
}
else
{
if ("fairSharePreemptionTimeout".Equals(element.GetTagName()))
{
if (defaultFairSharePreemptionTimeout == long.MaxValue)
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
long val = long.Parse(text) * 1000L;
defaultFairSharePreemptionTimeout = val;
}
}
else
{
if ("defaultMinSharePreemptionTimeout".Equals(element.GetTagName()))
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
long val = long.Parse(text) * 1000L;
defaultMinSharePreemptionTimeout = val;
}
else
{
if ("defaultFairSharePreemptionThreshold".Equals(element.GetTagName()))
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
float val = float.ParseFloat(text);
val = Math.Max(Math.Min(val, 1.0f), 0.0f);
defaultFairSharePreemptionThreshold = val;
}
else
{
if ("queueMaxAppsDefault".Equals(element.GetTagName()))
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
int val = System.Convert.ToInt32(text);
queueMaxAppsDefault = val;
}
else
{
if ("queueMaxAMShareDefault".Equals(element.GetTagName()))
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
float val = float.ParseFloat(text);
val = Math.Min(val, 1.0f);
queueMaxAMShareDefault = val;
}
else
{
if ("defaultQueueSchedulingPolicy".Equals(element.GetTagName()) || "defaultQueueSchedulingMode"
.Equals(element.GetTagName()))
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
defaultSchedPolicy = SchedulingPolicy.Parse(text);
}
else
{
if ("queuePlacementPolicy".Equals(element.GetTagName()))
{
placementPolicyElement = element;
}
else
{
if ("reservation-planner".Equals(element.GetTagName()))
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
planner = text;
}
else
{
if ("reservation-agent".Equals(element.GetTagName()))
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
reservationAgent = text;
}
else
{
if ("reservation-policy".Equals(element.GetTagName()))
{
string text = ((Text)element.GetFirstChild()).GetData().Trim();
reservationAdmissionPolicy = text;
}
else
{
Log.Warn("Bad element in allocations file: " + element.GetTagName());
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
// Load queue elements. A root queue can either be included or omitted. If
// it's included, all other queues must be inside it.
foreach (Element element_1 in queueElements)
{
string parent = "root";
if (Sharpen.Runtime.EqualsIgnoreCase(element_1.GetAttribute("name"), "root"))
{
if (queueElements.Count > 1)
{
throw new AllocationConfigurationException("If configuring root queue," + " no other queues can be placed alongside it."
);
}
parent = null;
}
LoadQueue(parent, element_1, minQueueResources, maxQueueResources, queueMaxApps,
userMaxApps, queueMaxAMShares, queueWeights, queuePolicies, minSharePreemptionTimeouts
, fairSharePreemptionTimeouts, fairSharePreemptionThresholds, queueAcls, configuredQueues
, reservableQueues);
}
// Load placement policy and pass it configured queues
Configuration conf = GetConfig();
if (placementPolicyElement != null)
{
newPlacementPolicy = QueuePlacementPolicy.FromXml(placementPolicyElement, configuredQueues
, conf);
}
else
{
newPlacementPolicy = QueuePlacementPolicy.FromConfiguration(conf, configuredQueues
);
}
// Set the min/fair share preemption timeout for the root queue
if (!minSharePreemptionTimeouts.Contains(QueueManager.RootQueue))
{
minSharePreemptionTimeouts[QueueManager.RootQueue] = defaultMinSharePreemptionTimeout;
}
if (!fairSharePreemptionTimeouts.Contains(QueueManager.RootQueue))
{
fairSharePreemptionTimeouts[QueueManager.RootQueue] = defaultFairSharePreemptionTimeout;
}
// Set the fair share preemption threshold for the root queue
if (!fairSharePreemptionThresholds.Contains(QueueManager.RootQueue))
{
fairSharePreemptionThresholds[QueueManager.RootQueue] = defaultFairSharePreemptionThreshold;
}
ReservationQueueConfiguration globalReservationQueueConfig = new ReservationQueueConfiguration
();
if (planner != null)
{
globalReservationQueueConfig.SetPlanner(planner);
}
if (reservationAdmissionPolicy != null)
{
globalReservationQueueConfig.SetReservationAdmissionPolicy(reservationAdmissionPolicy
);
}
if (reservationAgent != null)
{
globalReservationQueueConfig.SetReservationAgent(reservationAgent);
}
AllocationConfiguration info = new AllocationConfiguration(minQueueResources, maxQueueResources
, queueMaxApps, userMaxApps, queueWeights, queueMaxAMShares, userMaxAppsDefault,
queueMaxAppsDefault, queueMaxAMShareDefault, queuePolicies, defaultSchedPolicy,
minSharePreemptionTimeouts, fairSharePreemptionTimeouts, fairSharePreemptionThresholds
, queueAcls, newPlacementPolicy, configuredQueues, globalReservationQueueConfig,
reservableQueues);
lastSuccessfulReload = clock.GetTime();
lastReloadAttemptFailed = false;
reloadListener.OnReload(info);
}
}
/// <summary>
/// Creates a leaf or parent queue based on what is specified in 'queueType'
/// and places it in the tree.
/// </summary>
/// <remarks>
/// Creates a leaf or parent queue based on what is specified in 'queueType'
/// and places it in the tree. Creates any parents that don't already exist.
/// </remarks>
/// <returns>
/// the created queue, if successful. null if not allowed (one of the parent
/// queues in the queue name is already a leaf queue)
/// </returns>
private FSQueue CreateQueue(string name, FSQueueType queueType)
{
IList <string> newQueueNames = new AList <string>();
newQueueNames.AddItem(name);
int sepIndex = name.Length;
FSParentQueue parent = null;
// Move up the queue tree until we reach one that exists.
while (sepIndex != -1)
{
sepIndex = name.LastIndexOf('.', sepIndex - 1);
FSQueue queue;
string curName = null;
curName = Sharpen.Runtime.Substring(name, 0, sepIndex);
queue = queues[curName];
if (queue == null)
{
newQueueNames.AddItem(curName);
}
else
{
if (queue is FSParentQueue)
{
parent = (FSParentQueue)queue;
break;
}
else
{
return(null);
}
}
}
// At this point, parent refers to the deepest existing parent of the
// queue to create.
// Now that we know everything worked out, make all the queues
// and add them to the map.
AllocationConfiguration queueConf = scheduler.GetAllocationConfiguration();
FSLeafQueue leafQueue = null;
for (int i = newQueueNames.Count - 1; i >= 0; i--)
{
string queueName = newQueueNames[i];
if (i == 0 && queueType != FSQueueType.Parent)
{
leafQueue = new FSLeafQueue(name, scheduler, parent);
try
{
leafQueue.SetPolicy(queueConf.GetDefaultSchedulingPolicy());
}
catch (AllocationConfigurationException ex)
{
Log.Warn("Failed to set default scheduling policy " + queueConf.GetDefaultSchedulingPolicy
() + " on new leaf queue.", ex);
}
parent.AddChildQueue(leafQueue);
queues[leafQueue.GetName()] = leafQueue;
leafQueues.AddItem(leafQueue);
leafQueue.UpdatePreemptionVariables();
return(leafQueue);
}
else
{
FSParentQueue newParent = new FSParentQueue(queueName, scheduler, parent);
try
{
newParent.SetPolicy(queueConf.GetDefaultSchedulingPolicy());
}
catch (AllocationConfigurationException ex)
{
Log.Warn("Failed to set default scheduling policy " + queueConf.GetDefaultSchedulingPolicy
() + " on new parent queue.", ex);
}
parent.AddChildQueue(newParent);
queues[newParent.GetName()] = newParent;
newParent.UpdatePreemptionVariables();
parent = newParent;
}
}
return(parent);
}