private void SetupQueueConfigurationWithLabelsInherit(CapacitySchedulerConfiguration
conf)
{
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "a", "b" });
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "red", 100);
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "blue", 100);
// Set A configuration
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 10);
conf.SetMaximumCapacity(A, 15);
conf.SetQueues(A, new string[] { "a1", "a2" });
conf.SetAccessibleNodeLabels(A, ImmutableSet.Of("red", "blue"));
conf.SetCapacityByLabel(A, "red", 100);
conf.SetCapacityByLabel(A, "blue", 100);
// Set B configuraiton
string B = CapacitySchedulerConfiguration.Root + ".b";
conf.SetCapacity(B, 90);
conf.SetAccessibleNodeLabels(B, CommonNodeLabelsManager.EmptyStringSet);
// Define 2nd-level queues
string A1 = A + ".a1";
string A2 = A + ".a2";
conf.SetCapacity(A1, 30);
conf.SetMaximumCapacity(A1, 45);
conf.SetCapacityByLabel(A1, "red", 50);
conf.SetCapacityByLabel(A1, "blue", 100);
conf.SetCapacity(A2, 70);
conf.SetMaximumCapacity(A2, 85);
conf.SetAccessibleNodeLabels(A2, ImmutableSet.Of("red"));
conf.SetCapacityByLabel(A2, "red", 50);
}
public virtual void TestQueueParsing()
{
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration();
SetupQueueConfiguration(csConf);
YarnConfiguration conf = new YarnConfiguration(csConf);
CapacityScheduler capacityScheduler = new CapacityScheduler();
capacityScheduler.SetConf(conf);
capacityScheduler.SetRMContext(TestUtils.GetMockRMContext());
capacityScheduler.Init(conf);
capacityScheduler.Start();
capacityScheduler.Reinitialize(conf, TestUtils.GetMockRMContext());
CSQueue a = capacityScheduler.GetQueue("a");
NUnit.Framework.Assert.AreEqual(0.10, a.GetAbsoluteCapacity(), Delta);
NUnit.Framework.Assert.AreEqual(0.15, a.GetAbsoluteMaximumCapacity(), Delta);
CSQueue b1 = capacityScheduler.GetQueue("b1");
NUnit.Framework.Assert.AreEqual(0.2 * 0.5, b1.GetAbsoluteCapacity(), Delta);
NUnit.Framework.Assert.AreEqual("Parent B has no MAX_CAP", 0.85, b1.GetAbsoluteMaximumCapacity
(), Delta);
CSQueue c12 = capacityScheduler.GetQueue("c12");
NUnit.Framework.Assert.AreEqual(0.7 * 0.5 * 0.45, c12.GetAbsoluteCapacity(), Delta
);
NUnit.Framework.Assert.AreEqual(0.7 * 0.55 * 0.7, c12.GetAbsoluteMaximumCapacity(
), Delta);
ServiceOperations.StopQuietly(capacityScheduler);
}
/// <summary>
/// Test init a queue configuration, children's capacity for a given label
/// doesn't equals to 100%.
/// </summary>
/// <remarks>
/// Test init a queue configuration, children's capacity for a given label
/// doesn't equals to 100%. This expect IllegalArgumentException thrown.
/// </remarks>
/// <exception cref="System.IO.IOException"/>
public virtual void TestQueueParsingWithSumOfChildLabelCapacityNot100PercentWithWildCard
()
{
nodeLabelManager.AddToCluserNodeLabels(ImmutableSet.Of("red", "blue"));
YarnConfiguration conf = new YarnConfiguration();
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration(conf);
SetupQueueConfigurationWithLabels(csConf);
csConf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root + ".b.b3", "red", 24
);
csConf.SetAccessibleNodeLabels(CapacitySchedulerConfiguration.Root, ImmutableSet.
Of(RMNodeLabelsManager.Any));
csConf.SetAccessibleNodeLabels(CapacitySchedulerConfiguration.Root + ".b", ImmutableSet
.Of(RMNodeLabelsManager.Any));
CapacityScheduler capacityScheduler = new CapacityScheduler();
RMContextImpl rmContext = new RMContextImpl(null, null, null, null, null, null, new
RMContainerTokenSecretManager(csConf), new NMTokenSecretManagerInRM(csConf), new
ClientToAMTokenSecretManagerInRM(), null);
rmContext.SetNodeLabelManager(nodeLabelManager);
capacityScheduler.SetConf(csConf);
capacityScheduler.SetRMContext(rmContext);
capacityScheduler.Init(csConf);
capacityScheduler.Start();
ServiceOperations.StopQuietly(capacityScheduler);
}
public virtual void TestNestedQueueParsingShouldTrimSpaces()
{
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration();
SetupNestedQueueConfigurationWithSpacesShouldBeTrimmed(csConf);
YarnConfiguration conf = new YarnConfiguration(csConf);
CapacityScheduler capacityScheduler = new CapacityScheduler();
capacityScheduler.SetConf(conf);
capacityScheduler.SetRMContext(TestUtils.GetMockRMContext());
capacityScheduler.Init(conf);
capacityScheduler.Start();
capacityScheduler.Reinitialize(conf, TestUtils.GetMockRMContext());
CSQueue a = capacityScheduler.GetQueue("a");
NUnit.Framework.Assert.IsNotNull(a);
NUnit.Framework.Assert.AreEqual(0.10, a.GetAbsoluteCapacity(), Delta);
NUnit.Framework.Assert.AreEqual(0.15, a.GetAbsoluteMaximumCapacity(), Delta);
CSQueue c = capacityScheduler.GetQueue("c");
NUnit.Framework.Assert.IsNotNull(c);
NUnit.Framework.Assert.AreEqual(0.70, c.GetAbsoluteCapacity(), Delta);
NUnit.Framework.Assert.AreEqual(0.70, c.GetAbsoluteMaximumCapacity(), Delta);
CSQueue a1 = capacityScheduler.GetQueue("a1");
NUnit.Framework.Assert.IsNotNull(a1);
NUnit.Framework.Assert.AreEqual(0.10 * 0.6, a1.GetAbsoluteCapacity(), Delta);
NUnit.Framework.Assert.AreEqual(0.15, a1.GetAbsoluteMaximumCapacity(), Delta);
CSQueue a2 = capacityScheduler.GetQueue("a2");
NUnit.Framework.Assert.IsNotNull(a2);
NUnit.Framework.Assert.AreEqual(0.10 * 0.4, a2.GetAbsoluteCapacity(), Delta);
NUnit.Framework.Assert.AreEqual(0.15, a2.GetAbsoluteMaximumCapacity(), Delta);
}
/// <exception cref="System.IO.IOException"/>
public virtual void TestQueueParsingWithMoveQueue()
{
YarnConfiguration conf = new YarnConfiguration();
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration(conf);
csConf.SetQueues("root", new string[] { "a" });
csConf.SetQueues("root.a", new string[] { "x", "y" });
csConf.SetCapacity("root.a", 100);
csConf.SetCapacity("root.a.x", 50);
csConf.SetCapacity("root.a.y", 50);
CapacityScheduler capacityScheduler = new CapacityScheduler();
RMContextImpl rmContext = new RMContextImpl(null, null, null, null, null, null, new
RMContainerTokenSecretManager(csConf), new NMTokenSecretManagerInRM(csConf), new
ClientToAMTokenSecretManagerInRM(), null);
rmContext.SetNodeLabelManager(nodeLabelManager);
capacityScheduler.SetConf(csConf);
capacityScheduler.SetRMContext(rmContext);
capacityScheduler.Init(csConf);
capacityScheduler.Start();
csConf.SetQueues("root", new string[] { "a", "x" });
csConf.SetQueues("root.a", new string[] { "y" });
csConf.SetCapacity("root.x", 50);
csConf.SetCapacity("root.a", 50);
csConf.SetCapacity("root.a.y", 100);
capacityScheduler.Reinitialize(csConf, rmContext);
}
private void SetupNestedQueueConfigurationWithSpacesShouldBeTrimmed(CapacitySchedulerConfiguration
conf)
{
// Define top-level queues
conf.Set(CapacitySchedulerConfiguration.GetQueuePrefix(CapacitySchedulerConfiguration
.Root) + CapacitySchedulerConfiguration.Queues, " a ,b, c");
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 10);
conf.SetMaximumCapacity(A, 15);
string B = CapacitySchedulerConfiguration.Root + ".b";
conf.SetCapacity(B, 20);
string C = CapacitySchedulerConfiguration.Root + ".c";
conf.SetCapacity(C, 70);
conf.SetMaximumCapacity(C, 70);
// sub queues for A
conf.Set(CapacitySchedulerConfiguration.GetQueuePrefix(A) + CapacitySchedulerConfiguration
.Queues, "a1, a2 ");
string A1 = CapacitySchedulerConfiguration.Root + ".a.a1";
conf.SetCapacity(A1, 60);
string A2 = CapacitySchedulerConfiguration.Root + ".a.a2";
conf.SetCapacity(A2, 40);
}
/// <exception cref="System.IO.IOException"/>
public PlanQueue(CapacitySchedulerContext cs, string queueName, CSQueue parent, CSQueue
old)
: base(cs, queueName, parent, old)
{
this.schedulerContext = cs;
// Set the reservation queue attributes for the Plan
CapacitySchedulerConfiguration conf = cs.GetConfiguration();
string queuePath = base.GetQueuePath();
int maxAppsForReservation = conf.GetMaximumApplicationsPerQueue(queuePath);
showReservationsAsQueues = conf.GetShowReservationAsQueues(queuePath);
if (maxAppsForReservation < 0)
{
maxAppsForReservation = (int)(CapacitySchedulerConfiguration.DefaultMaximumSystemApplicatiions
* base.GetAbsoluteCapacity());
}
int userLimit = conf.GetUserLimit(queuePath);
float userLimitFactor = conf.GetUserLimitFactor(queuePath);
int maxAppsPerUserForReservation = (int)(maxAppsForReservation * (userLimit / 100.0f
) * userLimitFactor);
UpdateQuotas(userLimit, userLimitFactor, maxAppsForReservation, maxAppsPerUserForReservation
);
StringBuilder queueInfo = new StringBuilder();
queueInfo.Append("Created Plan Queue: ").Append(queueName).Append("\nwith capacity: ["
).Append(base.GetCapacity()).Append("]\nwith max capacity: [").Append(base.GetMaximumCapacity
()).Append("\nwith max reservation apps: [").Append(maxAppsForReservation).Append
("]\nwith max reservation apps per user: [").Append(maxAppsPerUserForReservation
).Append("]\nwith user limit: [").Append(userLimit).Append("]\nwith user limit factor: ["
).Append(userLimitFactor).Append("].");
Log.Info(queueInfo.ToString());
}
public virtual void Setup()
{
// setup a context / conf
csConf = new CapacitySchedulerConfiguration();
YarnConfiguration conf = new YarnConfiguration();
csContext = Org.Mockito.Mockito.Mock <CapacitySchedulerContext>();
Org.Mockito.Mockito.When(csContext.GetConfiguration()).ThenReturn(csConf);
Org.Mockito.Mockito.When(csContext.GetConf()).ThenReturn(conf);
Org.Mockito.Mockito.When(csContext.GetMinimumResourceCapability()).ThenReturn(Resources
.CreateResource(Gb, 1));
Org.Mockito.Mockito.When(csContext.GetMaximumResourceCapability()).ThenReturn(Resources
.CreateResource(16 * Gb, 32));
Org.Mockito.Mockito.When(csContext.GetClusterResource()).ThenReturn(Resources.CreateResource
(100 * 16 * Gb, 100 * 32));
Org.Mockito.Mockito.When(csContext.GetResourceCalculator()).ThenReturn(resourceCalculator
);
RMContext mockRMContext = TestUtils.GetMockRMContext();
Org.Mockito.Mockito.When(csContext.GetRMContext()).ThenReturn(mockRMContext);
// create a queue
PlanQueue pq = new PlanQueue(csContext, "root", null, null);
reservationQueue = new ReservationQueue(csContext, "a", pq);
}
/// <summary>
/// Do following steps for capacities
/// - Load capacities from configuration
/// - Update absolute capacities for new capacities
/// - Check if capacities/absolute-capacities legal
/// </summary>
public static void LoadUpdateAndCheckCapacities(string queuePath, CapacitySchedulerConfiguration
csConf, QueueCapacities queueCapacities, QueueCapacities parentQueueCapacities)
{
LoadCapacitiesByLabelsFromConf(queuePath, queueCapacities, csConf);
UpdateAbsoluteCapacitiesByNodeLabels(queueCapacities, parentQueueCapacities);
CapacitiesSanityCheck(queuePath, queueCapacities);
}
/// <summary>
/// The specified queue is preemptable if system-wide preemption is turned on
/// unless any queue in the <em>qPath</em> hierarchy has explicitly turned
/// preemption off.
/// </summary>
/// <remarks>
/// The specified queue is preemptable if system-wide preemption is turned on
/// unless any queue in the <em>qPath</em> hierarchy has explicitly turned
/// preemption off.
/// NOTE: Preemptability is inherited from a queue's parent.
/// </remarks>
/// <returns>true if queue has preemption disabled, false otherwise</returns>
private bool IsQueueHierarchyPreemptionDisabled(CSQueue q)
{
CapacitySchedulerConfiguration csConf = csContext.GetConfiguration();
bool systemWidePreemption = csConf.GetBoolean(YarnConfiguration.RmSchedulerEnableMonitors
, YarnConfiguration.DefaultRmSchedulerEnableMonitors);
CSQueue parentQ = q.GetParent();
// If the system-wide preemption switch is turned off, all of the queues in
// the qPath hierarchy have preemption disabled, so return true.
if (!systemWidePreemption)
{
return(true);
}
// If q is the root queue and the system-wide preemption switch is turned
// on, then q does not have preemption disabled (default=false, below)
// unless the preemption_disabled property is explicitly set.
if (parentQ == null)
{
return(csConf.GetPreemptionDisabled(q.GetQueuePath(), false));
}
// If this is not the root queue, inherit the default value for the
// preemption_disabled property from the parent. Preemptability will be
// inherited from the parent's hierarchy unless explicitly overridden at
// this level.
return(csConf.GetPreemptionDisabled(q.GetQueuePath(), parentQ.GetPreemptionDisabled
()));
}
private void SetupQueueConfigurationWithoutLabels(CapacitySchedulerConfiguration
conf)
{
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "a", "b" });
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 10);
conf.SetMaximumCapacity(A, 15);
string B = CapacitySchedulerConfiguration.Root + ".b";
conf.SetCapacity(B, 90);
Log.Info("Setup top-level queues");
// Define 2nd-level queues
string A1 = A + ".a1";
string A2 = A + ".a2";
conf.SetQueues(A, new string[] { "a1", "a2" });
conf.SetCapacity(A1, 30);
conf.SetMaximumCapacity(A1, 45);
conf.SetCapacity(A2, 70);
conf.SetMaximumCapacity(A2, 85);
string B1 = B + ".b1";
string B2 = B + ".b2";
string B3 = B + ".b3";
conf.SetQueues(B, new string[] { "b1", "b2", "b3" });
conf.SetCapacity(B1, 50);
conf.SetMaximumCapacity(B1, 85);
conf.SetCapacity(B2, 30);
conf.SetMaximumCapacity(B2, 35);
conf.SetCapacity(B3, 20);
conf.SetMaximumCapacity(B3, 35);
}
private static void LoadCapacitiesByLabelsFromConf(string queuePath, QueueCapacities
queueCapacities, CapacitySchedulerConfiguration csConf)
{
queueCapacities.ClearConfigurableFields();
ICollection <string> configuredNodelabels = csConf.GetConfiguredNodeLabels(queuePath
);
foreach (string label in configuredNodelabels)
{
if (label.Equals(CommonNodeLabelsManager.NoLabel))
{
queueCapacities.SetCapacity(CommonNodeLabelsManager.NoLabel, csConf.GetNonLabeledQueueCapacity
(queuePath) / 100);
queueCapacities.SetMaximumCapacity(CommonNodeLabelsManager.NoLabel, csConf.GetNonLabeledQueueMaximumCapacity
(queuePath) / 100);
}
else
{
queueCapacities.SetCapacity(label, csConf.GetLabeledQueueCapacity(queuePath, label
) / 100);
queueCapacities.SetMaximumCapacity(label, csConf.GetLabeledQueueMaximumCapacity(queuePath
, label) / 100);
}
}
}
private void SetupQueueConfiguration(CapacitySchedulerConfiguration conf)
{
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { Q1, Q2 });
conf.SetCapacity(Q1Path, 10);
conf.SetCapacity(Q2Path, 90);
Log.Info("Setup top-level queues q1 and q2");
}
private void SetupQueueConfigurationWithLabels(CapacitySchedulerConfiguration conf
)
{
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "a", "b" });
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "red", 100);
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "blue", 100);
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 10);
conf.SetMaximumCapacity(A, 15);
string B = CapacitySchedulerConfiguration.Root + ".b";
conf.SetCapacity(B, 90);
Log.Info("Setup top-level queues");
// Define 2nd-level queues
string A1 = A + ".a1";
string A2 = A + ".a2";
conf.SetQueues(A, new string[] { "a1", "a2" });
conf.SetAccessibleNodeLabels(A, ImmutableSet.Of("red", "blue"));
conf.SetCapacityByLabel(A, "red", 50);
conf.SetMaximumCapacityByLabel(A, "red", 50);
conf.SetCapacityByLabel(A, "blue", 50);
conf.SetCapacity(A1, 30);
conf.SetMaximumCapacity(A1, 45);
conf.SetCapacityByLabel(A1, "red", 50);
conf.SetCapacityByLabel(A1, "blue", 100);
conf.SetCapacity(A2, 70);
conf.SetMaximumCapacity(A2, 85);
conf.SetAccessibleNodeLabels(A2, ImmutableSet.Of("red"));
conf.SetCapacityByLabel(A2, "red", 50);
conf.SetMaximumCapacityByLabel(A2, "red", 60);
string B1 = B + ".b1";
string B2 = B + ".b2";
string B3 = B + ".b3";
conf.SetQueues(B, new string[] { "b1", "b2", "b3" });
conf.SetAccessibleNodeLabels(B, ImmutableSet.Of("red", "blue"));
conf.SetCapacityByLabel(B, "red", 50);
conf.SetCapacityByLabel(B, "blue", 50);
conf.SetCapacity(B1, 50);
conf.SetMaximumCapacity(B1, 85);
conf.SetCapacityByLabel(B1, "red", 50);
conf.SetCapacityByLabel(B1, "blue", 50);
conf.SetCapacity(B2, 30);
conf.SetMaximumCapacity(B2, 35);
conf.SetCapacityByLabel(B2, "red", 25);
conf.SetCapacityByLabel(B2, "blue", 25);
conf.SetCapacity(B3, 20);
conf.SetMaximumCapacity(B3, 35);
conf.SetCapacityByLabel(B3, "red", 25);
conf.SetCapacityByLabel(B3, "blue", 25);
}
public virtual void SetUp()
{
CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration();
SetupPlanQueueConfiguration(conf);
conf.SetClass(YarnConfiguration.RmScheduler, typeof(CapacityScheduler), typeof(ResourceScheduler
));
conf.SetBoolean(YarnConfiguration.RmReservationSystemEnable, false);
rm = new MockRM(conf);
rm.Start();
}
private void SetupSingleLevelQueues(CapacitySchedulerConfiguration conf)
{
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { A, B });
string QA = CapacitySchedulerConfiguration.Root + "." + A;
conf.SetCapacity(QA, 30);
string QB = CapacitySchedulerConfiguration.Root + "." + B;
conf.SetCapacity(QB, 70);
Log.Info("Setup top-level queues a and b");
}
/// <exception cref="System.Exception"/>
public virtual void TestMaxCapacity()
{
CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration();
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "a", "b", "c" }
);
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 50);
conf.SetMaximumCapacity(A, 60);
string B = CapacitySchedulerConfiguration.Root + ".b";
conf.SetCapacity(B, 50);
conf.SetMaximumCapacity(B, 45);
// Should throw an exception
bool fail = false;
CapacityScheduler capacityScheduler;
try
{
capacityScheduler = new CapacityScheduler();
capacityScheduler.SetConf(new YarnConfiguration());
capacityScheduler.Init(conf);
capacityScheduler.Start();
capacityScheduler.Reinitialize(conf, null);
}
catch (ArgumentException)
{
fail = true;
}
NUnit.Framework.Assert.IsTrue("Didn't throw IllegalArgumentException for wrong maxCap"
, fail);
conf.SetMaximumCapacity(B, 60);
// Now this should work
capacityScheduler = new CapacityScheduler();
capacityScheduler.SetConf(new YarnConfiguration());
capacityScheduler.Init(conf);
capacityScheduler.Start();
capacityScheduler.Reinitialize(conf, null);
fail = false;
try
{
LeafQueue a = (LeafQueue)capacityScheduler.GetQueue(A);
a.SetMaxCapacity(45);
}
catch (ArgumentException)
{
fail = true;
}
NUnit.Framework.Assert.IsTrue("Didn't throw IllegalArgumentException for wrong "
+ "setMaxCap", fail);
capacityScheduler.Stop();
}
private Configuration GetConfigurationWithDefaultQueueLabels(Configuration config
)
{
string A = CapacitySchedulerConfiguration.Root + ".a";
string B = CapacitySchedulerConfiguration.Root + ".b";
CapacitySchedulerConfiguration conf = (CapacitySchedulerConfiguration)GetConfigurationWithQueueLabels
(config);
new CapacitySchedulerConfiguration(config);
conf.SetDefaultNodeLabelExpression(A, "x");
conf.SetDefaultNodeLabelExpression(B, "y");
return(conf);
}
/// <exception cref="System.Exception"/>
public virtual void TestRootQueueParsing()
{
CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration();
// non-100 percent value will throw IllegalArgumentException
conf.SetCapacity(CapacitySchedulerConfiguration.Root, 90);
CapacityScheduler capacityScheduler = new CapacityScheduler();
capacityScheduler.SetConf(new YarnConfiguration());
capacityScheduler.Init(conf);
capacityScheduler.Start();
capacityScheduler.Reinitialize(conf, null);
ServiceOperations.StopQuietly(capacityScheduler);
}
private void SetupQueueConfiguration(CapacitySchedulerConfiguration conf)
{
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { A, B });
string QA = CapacitySchedulerConfiguration.Root + "." + A;
conf.SetCapacity(QA, 10);
string QB = CapacitySchedulerConfiguration.Root + "." + B;
conf.SetCapacity(QB, 90);
conf.SetUserLimit(CapacitySchedulerConfiguration.Root + "." + A, 50);
conf.SetUserLimitFactor(CapacitySchedulerConfiguration.Root + "." + A, 5.0f);
Log.Info("Setup top-level queues a and b");
}
private Configuration GetComplexConfigurationWithQueueLabels(Configuration config
)
{
CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration(config);
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "a", "b" });
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "x", 100);
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "y", 100);
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "z", 100);
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 10);
conf.SetMaximumCapacity(A, 10);
conf.SetAccessibleNodeLabels(A, ToSet("x", "y"));
conf.SetCapacityByLabel(A, "x", 100);
conf.SetCapacityByLabel(A, "y", 50);
string B = CapacitySchedulerConfiguration.Root + ".b";
conf.SetCapacity(B, 90);
conf.SetMaximumCapacity(B, 100);
conf.SetAccessibleNodeLabels(B, ToSet("y", "z"));
conf.SetCapacityByLabel(B, "y", 50);
conf.SetCapacityByLabel(B, "z", 100);
// Define 2nd-level queues
string A1 = A + ".a1";
conf.SetQueues(A, new string[] { "a1" });
conf.SetCapacity(A1, 100);
conf.SetMaximumCapacity(A1, 100);
conf.SetAccessibleNodeLabels(A1, ToSet("x", "y"));
conf.SetDefaultNodeLabelExpression(A1, "x");
conf.SetCapacityByLabel(A1, "x", 100);
conf.SetCapacityByLabel(A1, "y", 100);
conf.SetQueues(B, new string[] { "b1", "b2" });
string B1 = B + ".b1";
conf.SetCapacity(B1, 50);
conf.SetMaximumCapacity(B1, 50);
conf.SetAccessibleNodeLabels(B1, RMNodeLabelsManager.EmptyStringSet);
string B2 = B + ".b2";
conf.SetCapacity(B2, 50);
conf.SetMaximumCapacity(B2, 50);
conf.SetAccessibleNodeLabels(B2, ToSet("y", "z"));
conf.SetCapacityByLabel(B2, "y", 100);
conf.SetCapacityByLabel(B2, "z", 100);
return(conf);
}
public virtual void TestQueueParsingWithUnusedLabels()
{
ImmutableSet <string> labels = ImmutableSet.Of("red", "blue");
// Initialize a cluster with labels, but doesn't use them, reinitialize
// shouldn't fail
nodeLabelManager.AddToCluserNodeLabels(labels);
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration();
SetupQueueConfiguration(csConf);
csConf.SetAccessibleNodeLabels(CapacitySchedulerConfiguration.Root, labels);
YarnConfiguration conf = new YarnConfiguration(csConf);
CapacityScheduler capacityScheduler = new CapacityScheduler();
capacityScheduler.SetConf(conf);
RMContextImpl rmContext = new RMContextImpl(null, null, null, null, null, null, new
RMContainerTokenSecretManager(csConf), new NMTokenSecretManagerInRM(csConf), new
ClientToAMTokenSecretManagerInRM(), null);
rmContext.SetNodeLabelManager(nodeLabelManager);
capacityScheduler.SetRMContext(rmContext);
capacityScheduler.Init(conf);
capacityScheduler.Start();
capacityScheduler.Reinitialize(conf, rmContext);
// check root queue's capacity by label -- they should be all zero
CSQueue root = capacityScheduler.GetQueue(CapacitySchedulerConfiguration.Root);
NUnit.Framework.Assert.AreEqual(0, root.GetQueueCapacities().GetCapacity("red"),
Delta);
NUnit.Framework.Assert.AreEqual(0, root.GetQueueCapacities().GetCapacity("blue"),
Delta);
CSQueue a = capacityScheduler.GetQueue("a");
NUnit.Framework.Assert.AreEqual(0.10, a.GetAbsoluteCapacity(), Delta);
NUnit.Framework.Assert.AreEqual(0.15, a.GetAbsoluteMaximumCapacity(), Delta);
CSQueue b1 = capacityScheduler.GetQueue("b1");
NUnit.Framework.Assert.AreEqual(0.2 * 0.5, b1.GetAbsoluteCapacity(), Delta);
NUnit.Framework.Assert.AreEqual("Parent B has no MAX_CAP", 0.85, b1.GetAbsoluteMaximumCapacity
(), Delta);
CSQueue c12 = capacityScheduler.GetQueue("c12");
NUnit.Framework.Assert.AreEqual(0.7 * 0.5 * 0.45, c12.GetAbsoluteCapacity(), Delta
);
NUnit.Framework.Assert.AreEqual(0.7 * 0.55 * 0.7, c12.GetAbsoluteMaximumCapacity(
), Delta);
capacityScheduler.Stop();
}
private Configuration GetConfigurationWithQueueLabels(Configuration config)
{
CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration(config);
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "a", "b", "c" }
);
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "x", 100);
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "y", 100);
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 10);
conf.SetMaximumCapacity(A, 15);
conf.SetAccessibleNodeLabels(A, ToSet("x"));
conf.SetCapacityByLabel(A, "x", 100);
string B = CapacitySchedulerConfiguration.Root + ".b";
conf.SetCapacity(B, 20);
conf.SetAccessibleNodeLabels(B, ToSet("y"));
conf.SetCapacityByLabel(B, "y", 100);
string C = CapacitySchedulerConfiguration.Root + ".c";
conf.SetCapacity(C, 70);
conf.SetMaximumCapacity(C, 70);
conf.SetAccessibleNodeLabels(C, RMNodeLabelsManager.EmptyStringSet);
// Define 2nd-level queues
string A1 = A + ".a1";
conf.SetQueues(A, new string[] { "a1" });
conf.SetCapacity(A1, 100);
conf.SetMaximumCapacity(A1, 100);
conf.SetCapacityByLabel(A1, "x", 100);
string B1 = B + ".b1";
conf.SetQueues(B, new string[] { "b1" });
conf.SetCapacity(B1, 100);
conf.SetMaximumCapacity(B1, 100);
conf.SetCapacityByLabel(B1, "y", 100);
string C1 = C + ".c1";
conf.SetQueues(C, new string[] { "c1" });
conf.SetCapacity(C1, 100);
conf.SetMaximumCapacity(C1, 100);
return(conf);
}
private void SetupSortedQueues(CapacitySchedulerConfiguration conf)
{
// Define queues
csConf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { A, B, C, D }
);
string QA = CapacitySchedulerConfiguration.Root + "." + A;
conf.SetCapacity(QA, 25);
string QB = CapacitySchedulerConfiguration.Root + "." + B;
conf.SetCapacity(QB, 25);
string QC = CapacitySchedulerConfiguration.Root + "." + C;
conf.SetCapacity(QC, 25);
string QD = CapacitySchedulerConfiguration.Root + "." + D;
conf.SetCapacity(QD, 25);
}
private Configuration GetConfigurationWithQueueLabels(Configuration config)
{
CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration(config);
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "a" });
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "x", 100);
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "y", 100);
conf.SetCapacityByLabel(CapacitySchedulerConfiguration.Root, "z", 100);
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 100);
conf.SetAccessibleNodeLabels(A, ImmutableSet.Of("x", "y", "z"));
conf.SetCapacityByLabel(A, "x", 100);
conf.SetCapacityByLabel(A, "y", 100);
conf.SetCapacityByLabel(A, "z", 100);
return(conf);
}
private void SetupPlanQueueConfiguration(CapacitySchedulerConfiguration conf)
{
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "a", "b" });
conf.SetCapacity(A, ACapacity);
conf.SetCapacity(B, BCapacity);
// Define 2nd-level queues
conf.SetQueues(B, new string[] { "b1", "b2", "b3" });
conf.SetCapacity(B1, B1Capacity);
conf.SetUserLimitFactor(B1, 100.0f);
conf.SetCapacity(B2, B2Capacity);
conf.SetUserLimitFactor(B2, 100.0f);
conf.SetCapacity(B3, B3Capacity);
conf.SetUserLimitFactor(B3, 100.0f);
conf.SetReservable(A, true);
conf.SetReservationWindow(A, 86400 * 1000);
conf.SetAverageCapacity(A, 1.0f);
Log.Info("Setup a as a plan queue");
}
private void SetupQueueConfigurationWithSpacesShouldBeTrimmed(CapacitySchedulerConfiguration
conf)
{
// Define top-level queues
conf.Set(CapacitySchedulerConfiguration.GetQueuePrefix(CapacitySchedulerConfiguration
.Root) + CapacitySchedulerConfiguration.Queues, " a ,b, c");
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 10);
conf.SetMaximumCapacity(A, 15);
string B = CapacitySchedulerConfiguration.Root + ".b";
conf.SetCapacity(B, 20);
string C = CapacitySchedulerConfiguration.Root + ".c";
conf.SetCapacity(C, 70);
conf.SetMaximumCapacity(C, 70);
}
public virtual void SetUp()
{
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration();
YarnConfiguration conf = new YarnConfiguration();
SetupQueueConfiguration(csConf);
rmContext = TestUtils.GetMockRMContext();
CapacitySchedulerContext csContext = Org.Mockito.Mockito.Mock <CapacitySchedulerContext
>();
Org.Mockito.Mockito.When(csContext.GetConfiguration()).ThenReturn(csConf);
Org.Mockito.Mockito.When(csContext.GetConf()).ThenReturn(conf);
Org.Mockito.Mockito.When(csContext.GetMinimumResourceCapability()).ThenReturn(Resources
.CreateResource(Gb, 1));
Org.Mockito.Mockito.When(csContext.GetMaximumResourceCapability()).ThenReturn(Resources
.CreateResource(16 * Gb, 32));
Org.Mockito.Mockito.When(csContext.GetClusterResource()).ThenReturn(Resources.CreateResource
(10 * 16 * Gb, 10 * 32));
Org.Mockito.Mockito.When(csContext.GetApplicationComparator()).ThenReturn(CapacityScheduler
.applicationComparator);
Org.Mockito.Mockito.When(csContext.GetQueueComparator()).ThenReturn(CapacityScheduler
.queueComparator);
Org.Mockito.Mockito.When(csContext.GetResourceCalculator()).ThenReturn(resourceCalculator
);
Org.Mockito.Mockito.When(csContext.GetRMContext()).ThenReturn(rmContext);
RMContainerTokenSecretManager containerTokenSecretManager = new RMContainerTokenSecretManager
(conf);
containerTokenSecretManager.RollMasterKey();
Org.Mockito.Mockito.When(csContext.GetContainerTokenSecretManager()).ThenReturn(containerTokenSecretManager
);
IDictionary <string, CSQueue> queues = new Dictionary <string, CSQueue>();
CSQueue root = CapacityScheduler.ParseQueue(csContext, csConf, null, "root", queues
, queues, TestUtils.spyHook);
queue = Org.Mockito.Mockito.Spy(new LeafQueue(csContext, A, root, null));
// Stub out ACL checks
Org.Mockito.Mockito.DoReturn(true).When(queue).HasAccess(Matchers.Any <QueueACL>()
, Matchers.Any <UserGroupInformation>());
// Some default values
Org.Mockito.Mockito.DoReturn(100).When(queue).GetMaxApplications();
Org.Mockito.Mockito.DoReturn(25).When(queue).GetMaxApplicationsPerUser();
}
private void SetupMultiLevelQueues(CapacitySchedulerConfiguration conf)
{
// Define top-level queues
csConf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { A, B, C, D }
);
string QA = CapacitySchedulerConfiguration.Root + "." + A;
conf.SetCapacity(QA, 10);
string QB = CapacitySchedulerConfiguration.Root + "." + B;
conf.SetCapacity(QB, 50);
string QC = CapacitySchedulerConfiguration.Root + "." + C;
conf.SetCapacity(QC, 19.5f);
string QD = CapacitySchedulerConfiguration.Root + "." + D;
conf.SetCapacity(QD, 20.5f);
// Define 2-nd level queues
conf.SetQueues(QA, new string[] { A1, A2 });
conf.SetCapacity(QA + "." + A1, 50);
conf.SetCapacity(QA + "." + A2, 50);
conf.SetQueues(QB, new string[] { B1, B2, B3 });
conf.SetCapacity(QB + "." + B1, 10);
conf.SetCapacity(QB + "." + B2, 20);
conf.SetCapacity(QB + "." + B3, 70);
conf.SetQueues(QC, new string[] { C1 });
string QC1 = QC + "." + C1;
conf.SetCapacity(QC1, 100);
conf.SetQueues(QC1, new string[] { C11 });
string QC11 = QC1 + "." + C11;
conf.SetCapacity(QC11, 100);
conf.SetQueues(QC11, new string[] { C111 });
string QC111 = QC11 + "." + C111;
conf.SetCapacity(QC111, 100);
//Leaf Queue
conf.SetQueues(QC111, new string[] { C1111 });
string QC1111 = QC111 + "." + C1111;
conf.SetCapacity(QC1111, 100);
}
public virtual void TestQueueParsingWithLabelsInherit()
{
nodeLabelManager.AddToCluserNodeLabels(ImmutableSet.Of("red", "blue"));
YarnConfiguration conf = new YarnConfiguration();
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration(conf);
SetupQueueConfigurationWithLabelsInherit(csConf);
CapacityScheduler capacityScheduler = new CapacityScheduler();
RMContextImpl rmContext = new RMContextImpl(null, null, null, null, null, null, new
RMContainerTokenSecretManager(csConf), new NMTokenSecretManagerInRM(csConf), new
ClientToAMTokenSecretManagerInRM(), null);
rmContext.SetNodeLabelManager(nodeLabelManager);
capacityScheduler.SetConf(csConf);
capacityScheduler.SetRMContext(rmContext);
capacityScheduler.Init(csConf);
capacityScheduler.Start();
CheckQueueLabelsInheritConfig(capacityScheduler);
ServiceOperations.StopQuietly(capacityScheduler);
}