public virtual void TestNormalizeRequestWithDominantResourceCalculator()
{
ResourceCalculator resourceCalculator = new DominantResourceCalculator();
Org.Apache.Hadoop.Yarn.Api.Records.Resource minResource = Resources.CreateResource
(1024, 1);
Org.Apache.Hadoop.Yarn.Api.Records.Resource maxResource = Resources.CreateResource
(10240, 10);
Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterResource = Resources.CreateResource
(10 * 1024, 10);
ResourceRequest ask = new ResourceRequestPBImpl();
// case negative memory/vcores
ask.SetCapability(Resources.CreateResource(-1024, -1));
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, clusterResource, minResource
, maxResource);
NUnit.Framework.Assert.AreEqual(minResource, ask.GetCapability());
// case zero memory/vcores
ask.SetCapability(Resources.CreateResource(0, 0));
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, clusterResource, minResource
, maxResource);
NUnit.Framework.Assert.AreEqual(minResource, ask.GetCapability());
NUnit.Framework.Assert.AreEqual(1, ask.GetCapability().GetVirtualCores());
NUnit.Framework.Assert.AreEqual(1024, ask.GetCapability().GetMemory());
// case non-zero memory & zero cores
ask.SetCapability(Resources.CreateResource(1536, 0));
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, clusterResource, minResource
, maxResource);
NUnit.Framework.Assert.AreEqual(Resources.CreateResource(2048, 1), ask.GetCapability
());
NUnit.Framework.Assert.AreEqual(1, ask.GetCapability().GetVirtualCores());
NUnit.Framework.Assert.AreEqual(2048, ask.GetCapability().GetMemory());
}
protected internal virtual void ReleaseContainers(IList <ContainerId> containers,
SchedulerApplicationAttempt attempt)
{
foreach (ContainerId containerId in containers)
{
RMContainer rmContainer = GetRMContainer(containerId);
if (rmContainer == null)
{
if (Runtime.CurrentTimeMillis() - ResourceManager.GetClusterTimeStamp() < nmExpireInterval)
{
Log.Info(containerId + " doesn't exist. Add the container" + " to the release request cache as it maybe on recovery."
);
lock (attempt)
{
attempt.GetPendingRelease().AddItem(containerId);
}
}
else
{
RMAuditLogger.LogFailure(attempt.GetUser(), RMAuditLogger.AuditConstants.ReleaseContainer
, "Unauthorized access or invalid container", "Scheduler", "Trying to release container not owned by app or with invalid id."
, attempt.GetApplicationId(), containerId);
}
}
CompletedContainer(rmContainer, SchedulerUtils.CreateAbnormalContainerStatus(containerId
, SchedulerUtils.ReleasedContainer), RMContainerEventType.Released);
}
}
public virtual void TestCreateAbnormalContainerStatus()
{
ContainerStatus cd = SchedulerUtils.CreateAbnormalContainerStatus(ContainerId.NewContainerId
(ApplicationAttemptId.NewInstance(ApplicationId.NewInstance(Runtime.CurrentTimeMillis
(), 1), 1), 1), "x");
NUnit.Framework.Assert.AreEqual(ContainerExitStatus.Aborted, cd.GetExitStatus());
}
public virtual void TestNormalizeRequest()
{
ResourceCalculator resourceCalculator = new DefaultResourceCalculator();
int minMemory = 1024;
int maxMemory = 8192;
Org.Apache.Hadoop.Yarn.Api.Records.Resource minResource = Resources.CreateResource
(minMemory, 0);
Org.Apache.Hadoop.Yarn.Api.Records.Resource maxResource = Resources.CreateResource
(maxMemory, 0);
ResourceRequest ask = new ResourceRequestPBImpl();
// case negative memory
ask.SetCapability(Resources.CreateResource(-1024));
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, null, minResource, maxResource
);
NUnit.Framework.Assert.AreEqual(minMemory, ask.GetCapability().GetMemory());
// case zero memory
ask.SetCapability(Resources.CreateResource(0));
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, null, minResource, maxResource
);
NUnit.Framework.Assert.AreEqual(minMemory, ask.GetCapability().GetMemory());
// case memory is a multiple of minMemory
ask.SetCapability(Resources.CreateResource(2 * minMemory));
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, null, minResource, maxResource
);
NUnit.Framework.Assert.AreEqual(2 * minMemory, ask.GetCapability().GetMemory());
// case memory is not a multiple of minMemory
ask.SetCapability(Resources.CreateResource(minMemory + 10));
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, null, minResource, maxResource
);
NUnit.Framework.Assert.AreEqual(2 * minMemory, ask.GetCapability().GetMemory());
// case memory is equal to max allowed
ask.SetCapability(Resources.CreateResource(maxMemory));
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, null, minResource, maxResource
);
NUnit.Framework.Assert.AreEqual(maxMemory, ask.GetCapability().GetMemory());
// case memory is just less than max
ask.SetCapability(Resources.CreateResource(maxMemory - 10));
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, null, minResource, maxResource
);
NUnit.Framework.Assert.AreEqual(maxMemory, ask.GetCapability().GetMemory());
// max is not a multiple of min
maxResource = Resources.CreateResource(maxMemory - 10, 0);
ask.SetCapability(Resources.CreateResource(maxMemory - 100));
// multiple of minMemory > maxMemory, then reduce to maxMemory
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, null, minResource, maxResource
);
NUnit.Framework.Assert.AreEqual(maxResource.GetMemory(), ask.GetCapability().GetMemory
());
// ask is more than max
maxResource = Resources.CreateResource(maxMemory, 0);
ask.SetCapability(Resources.CreateResource(maxMemory + 100));
SchedulerUtils.NormalizeRequest(ask, resourceCalculator, null, minResource, maxResource
);
NUnit.Framework.Assert.AreEqual(maxResource.GetMemory(), ask.GetCapability().GetMemory
());
}
/// <exception cref="System.IO.IOException"/>
public virtual void TestNormalizeNodeLabelExpression()
{
// mock queue and scheduler
YarnScheduler scheduler = Org.Mockito.Mockito.Mock <YarnScheduler>();
ICollection <string> queueAccessibleNodeLabels = Sets.NewHashSet();
QueueInfo queueInfo = Org.Mockito.Mockito.Mock <QueueInfo>();
Org.Mockito.Mockito.When(queueInfo.GetQueueName()).ThenReturn("queue");
Org.Mockito.Mockito.When(queueInfo.GetAccessibleNodeLabels()).ThenReturn(queueAccessibleNodeLabels
);
Org.Mockito.Mockito.When(queueInfo.GetDefaultNodeLabelExpression()).ThenReturn(" x "
);
Org.Mockito.Mockito.When(scheduler.GetQueueInfo(Matchers.Any <string>(), Matchers.AnyBoolean
(), Matchers.AnyBoolean())).ThenReturn(queueInfo);
Org.Apache.Hadoop.Yarn.Api.Records.Resource maxResource = Resources.CreateResource
(YarnConfiguration.DefaultRmSchedulerMaximumAllocationMb, YarnConfiguration.DefaultRmSchedulerMaximumAllocationVcores
);
// queue has labels, success cases
try
{
// set queue accessible node labels to [x, y]
queueAccessibleNodeLabels.Clear();
Sharpen.Collections.AddAll(queueAccessibleNodeLabels, Arrays.AsList("x", "y"));
rmContext.GetNodeLabelManager().AddToCluserNodeLabels(ImmutableSet.Of("x", "y"));
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
NUnit.Framework.Assert.IsTrue(resReq.GetNodeLabelExpression().Equals("x"));
resReq.SetNodeLabelExpression(" y ");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
NUnit.Framework.Assert.IsTrue(resReq.GetNodeLabelExpression().Equals("y"));
}
catch (InvalidResourceRequestException e)
{
Sharpen.Runtime.PrintStackTrace(e);
NUnit.Framework.Assert.Fail("Should be valid when request labels is a subset of queue labels"
);
}
finally
{
rmContext.GetNodeLabelManager().RemoveFromClusterNodeLabels(Arrays.AsList("x", "y"
));
}
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.InvalidResourceRequestException
/// "/>
public static void NormalizeAndValidateRequest(ResourceRequest resReq, Org.Apache.Hadoop.Yarn.Api.Records.Resource
maximumResource, string queueName, YarnScheduler scheduler, bool isRecovery, RMContext
rmContext, QueueInfo queueInfo)
{
if (queueInfo == null)
{
try
{
queueInfo = scheduler.GetQueueInfo(queueName, false, false);
}
catch (IOException)
{
}
}
// it is possible queue cannot get when queue mapping is set, just ignore
// the queueInfo here, and move forward
SchedulerUtils.NormalizeNodeLabelExpressionInRequest(resReq, queueInfo);
if (!isRecovery)
{
ValidateResourceRequest(resReq, maximumResource, queueInfo, rmContext);
}
}
public virtual void RecoverContainersOnNode(IList <NMContainerStatus> containerReports
, RMNode nm)
{
lock (this)
{
if (!rmContext.IsWorkPreservingRecoveryEnabled() || containerReports == null || (
containerReports != null && containerReports.IsEmpty()))
{
return;
}
foreach (NMContainerStatus container in containerReports)
{
ApplicationId appId = container.GetContainerId().GetApplicationAttemptId().GetApplicationId
();
RMApp rmApp = rmContext.GetRMApps()[appId];
if (rmApp == null)
{
Log.Error("Skip recovering container " + container + " for unknown application.");
KillOrphanContainerOnNode(nm, container);
continue;
}
// Unmanaged AM recovery is addressed in YARN-1815
if (rmApp.GetApplicationSubmissionContext().GetUnmanagedAM())
{
Log.Info("Skip recovering container " + container + " for unmanaged AM." + rmApp.
GetApplicationId());
KillOrphanContainerOnNode(nm, container);
continue;
}
SchedulerApplication <T> schedulerApp = applications[appId];
if (schedulerApp == null)
{
Log.Info("Skip recovering container " + container + " for unknown SchedulerApplication. Application current state is "
+ rmApp.GetState());
KillOrphanContainerOnNode(nm, container);
continue;
}
Log.Info("Recovering container " + container);
SchedulerApplicationAttempt schedulerAttempt = schedulerApp.GetCurrentAppAttempt(
);
if (!rmApp.GetApplicationSubmissionContext().GetKeepContainersAcrossApplicationAttempts
())
{
// Do not recover containers for stopped attempt or previous attempt.
if (schedulerAttempt.IsStopped() || !schedulerAttempt.GetApplicationAttemptId().Equals
(container.GetContainerId().GetApplicationAttemptId()))
{
Log.Info("Skip recovering container " + container + " for already stopped attempt."
);
KillOrphanContainerOnNode(nm, container);
continue;
}
}
// create container
RMContainer rmContainer = RecoverAndCreateContainer(container, nm);
// recover RMContainer
rmContainer.Handle(new RMContainerRecoverEvent(container.GetContainerId(), container
));
// recover scheduler node
nodes[nm.GetNodeID()].RecoverContainer(rmContainer);
// recover queue: update headroom etc.
Queue queue = schedulerAttempt.GetQueue();
queue.RecoverContainer(clusterResource, schedulerAttempt, rmContainer);
// recover scheduler attempt
schedulerAttempt.RecoverContainer(rmContainer);
// set master container for the current running AMContainer for this
// attempt.
RMAppAttempt appAttempt = rmApp.GetCurrentAppAttempt();
if (appAttempt != null)
{
Container masterContainer = appAttempt.GetMasterContainer();
// Mark current running AMContainer's RMContainer based on the master
// container ID stored in AppAttempt.
if (masterContainer != null && masterContainer.GetId().Equals(rmContainer.GetContainerId
()))
{
((RMContainerImpl)rmContainer).SetAMContainer(true);
}
}
lock (schedulerAttempt)
{
ICollection <ContainerId> releases = schedulerAttempt.GetPendingRelease();
if (releases.Contains(container.GetContainerId()))
{
// release the container
rmContainer.Handle(new RMContainerFinishedEvent(container.GetContainerId(), SchedulerUtils
.CreateAbnormalContainerStatus(container.GetContainerId(), SchedulerUtils.ReleasedContainer
), RMContainerEventType.Released));
releases.Remove(container.GetContainerId());
Log.Info(container.GetContainerId() + " is released by application.");
}
}
}
}
}
public virtual void TestValidateResourceRequest()
{
YarnScheduler mockScheduler = Org.Mockito.Mockito.Mock <YarnScheduler>();
Org.Apache.Hadoop.Yarn.Api.Records.Resource maxResource = Resources.CreateResource
(YarnConfiguration.DefaultRmSchedulerMaximumAllocationMb, YarnConfiguration.DefaultRmSchedulerMaximumAllocationVcores
);
// zero memory
try
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, null, mockScheduler
, rmContext);
}
catch (InvalidResourceRequestException)
{
NUnit.Framework.Assert.Fail("Zero memory should be accepted");
}
// zero vcores
try
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(YarnConfiguration
.DefaultRmSchedulerMinimumAllocationMb, 0);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, null, mockScheduler
, rmContext);
}
catch (InvalidResourceRequestException)
{
NUnit.Framework.Assert.Fail("Zero vcores should be accepted");
}
// max memory
try
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(YarnConfiguration
.DefaultRmSchedulerMaximumAllocationMb, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores
);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, null, mockScheduler
, rmContext);
}
catch (InvalidResourceRequestException)
{
NUnit.Framework.Assert.Fail("Max memory should be accepted");
}
// max vcores
try
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(YarnConfiguration
.DefaultRmSchedulerMinimumAllocationMb, YarnConfiguration.DefaultRmSchedulerMaximumAllocationVcores
);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, null, mockScheduler
, rmContext);
}
catch (InvalidResourceRequestException)
{
NUnit.Framework.Assert.Fail("Max vcores should not be accepted");
}
// negative memory
try
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(-
1, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, null, mockScheduler
, rmContext);
NUnit.Framework.Assert.Fail("Negative memory should not be accepted");
}
catch (InvalidResourceRequestException)
{
}
// expected
// negative vcores
try
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(YarnConfiguration
.DefaultRmSchedulerMinimumAllocationMb, -1);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, null, mockScheduler
, rmContext);
NUnit.Framework.Assert.Fail("Negative vcores should not be accepted");
}
catch (InvalidResourceRequestException)
{
}
// expected
// more than max memory
try
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(YarnConfiguration
.DefaultRmSchedulerMaximumAllocationMb + 1, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores
);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, null, mockScheduler
, rmContext);
NUnit.Framework.Assert.Fail("More than max memory should not be accepted");
}
catch (InvalidResourceRequestException)
{
}
// expected
// more than max vcores
try
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(YarnConfiguration
.DefaultRmSchedulerMinimumAllocationMb, YarnConfiguration.DefaultRmSchedulerMaximumAllocationVcores
+ 1);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, null, mockScheduler
, rmContext);
NUnit.Framework.Assert.Fail("More than max vcores should not be accepted");
}
catch (InvalidResourceRequestException)
{
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void TestValidateResourceRequestWithErrorLabelsPermission()
{
// mock queue and scheduler
YarnScheduler scheduler = Org.Mockito.Mockito.Mock <YarnScheduler>();
ICollection <string> queueAccessibleNodeLabels = Sets.NewHashSet();
QueueInfo queueInfo = Org.Mockito.Mockito.Mock <QueueInfo>();
Org.Mockito.Mockito.When(queueInfo.GetQueueName()).ThenReturn("queue");
Org.Mockito.Mockito.When(queueInfo.GetAccessibleNodeLabels()).ThenReturn(queueAccessibleNodeLabels
);
Org.Mockito.Mockito.When(scheduler.GetQueueInfo(Matchers.Any <string>(), Matchers.AnyBoolean
(), Matchers.AnyBoolean())).ThenReturn(queueInfo);
Org.Apache.Hadoop.Yarn.Api.Records.Resource maxResource = Resources.CreateResource
(YarnConfiguration.DefaultRmSchedulerMaximumAllocationMb, YarnConfiguration.DefaultRmSchedulerMaximumAllocationVcores
);
// queue has labels, success cases
try
{
// set queue accessible node labesl to [x, y]
queueAccessibleNodeLabels.Clear();
Sharpen.Collections.AddAll(queueAccessibleNodeLabels, Arrays.AsList("x", "y"));
rmContext.GetNodeLabelManager().AddToCluserNodeLabels(ImmutableSet.Of("x", "y"));
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
resReq.SetNodeLabelExpression("x");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
resReq.SetNodeLabelExpression("y");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
resReq.SetNodeLabelExpression(string.Empty);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
resReq.SetNodeLabelExpression(" ");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
}
catch (InvalidResourceRequestException e)
{
Sharpen.Runtime.PrintStackTrace(e);
NUnit.Framework.Assert.Fail("Should be valid when request labels is a subset of queue labels"
);
}
finally
{
rmContext.GetNodeLabelManager().RemoveFromClusterNodeLabels(Arrays.AsList("x", "y"
));
}
// same as above, but cluster node labels don't contains label being
// requested. should fail
try
{
// set queue accessible node labesl to [x, y]
queueAccessibleNodeLabels.Clear();
Sharpen.Collections.AddAll(queueAccessibleNodeLabels, Arrays.AsList("x", "y"));
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
resReq.SetNodeLabelExpression("x");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
NUnit.Framework.Assert.Fail("Should fail");
}
catch (InvalidResourceRequestException)
{
}
// queue has labels, failed cases (when ask a label not included by queue)
try
{
// set queue accessible node labesl to [x, y]
queueAccessibleNodeLabels.Clear();
Sharpen.Collections.AddAll(queueAccessibleNodeLabels, Arrays.AsList("x", "y"));
rmContext.GetNodeLabelManager().AddToCluserNodeLabels(ImmutableSet.Of("x", "y"));
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
resReq.SetNodeLabelExpression("z");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
NUnit.Framework.Assert.Fail("Should fail");
}
catch (InvalidResourceRequestException)
{
}
finally
{
rmContext.GetNodeLabelManager().RemoveFromClusterNodeLabels(Arrays.AsList("x", "y"
));
}
// we don't allow specify more than two node labels in a single expression
// now
try
{
// set queue accessible node labesl to [x, y]
queueAccessibleNodeLabels.Clear();
Sharpen.Collections.AddAll(queueAccessibleNodeLabels, Arrays.AsList("x", "y"));
rmContext.GetNodeLabelManager().AddToCluserNodeLabels(ImmutableSet.Of("x", "y"));
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
resReq.SetNodeLabelExpression("x && y");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
NUnit.Framework.Assert.Fail("Should fail");
}
catch (InvalidResourceRequestException)
{
}
finally
{
rmContext.GetNodeLabelManager().RemoveFromClusterNodeLabels(Arrays.AsList("x", "y"
));
}
// queue doesn't have label, succeed (when request no label)
queueAccessibleNodeLabels.Clear();
try
{
// set queue accessible node labels to empty
queueAccessibleNodeLabels.Clear();
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
resReq.SetNodeLabelExpression(string.Empty);
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
resReq.SetNodeLabelExpression(" ");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
}
catch (InvalidResourceRequestException e)
{
Sharpen.Runtime.PrintStackTrace(e);
NUnit.Framework.Assert.Fail("Should be valid when request labels is empty");
}
// queue doesn't have label, failed (when request any label)
try
{
// set queue accessible node labels to empty
queueAccessibleNodeLabels.Clear();
rmContext.GetNodeLabelManager().AddToCluserNodeLabels(ImmutableSet.Of("x"));
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
resReq.SetNodeLabelExpression("x");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
NUnit.Framework.Assert.Fail("Should fail");
}
catch (InvalidResourceRequestException)
{
}
finally
{
rmContext.GetNodeLabelManager().RemoveFromClusterNodeLabels(Arrays.AsList("x"));
}
// queue is "*", always succeeded
try
{
// set queue accessible node labels to empty
queueAccessibleNodeLabels.Clear();
queueAccessibleNodeLabels.AddItem(RMNodeLabelsManager.Any);
rmContext.GetNodeLabelManager().AddToCluserNodeLabels(ImmutableSet.Of("x", "y", "z"
));
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
resReq.SetNodeLabelExpression("x");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
resReq.SetNodeLabelExpression("y");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
resReq.SetNodeLabelExpression("z");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
}
catch (InvalidResourceRequestException e)
{
Sharpen.Runtime.PrintStackTrace(e);
NUnit.Framework.Assert.Fail("Should be valid when queue can access any labels");
}
finally
{
rmContext.GetNodeLabelManager().RemoveFromClusterNodeLabels(Arrays.AsList("x", "y"
, "z"));
}
// same as above, but cluster node labels don't contains label, should fail
try
{
// set queue accessible node labels to empty
queueAccessibleNodeLabels.Clear();
queueAccessibleNodeLabels.AddItem(RMNodeLabelsManager.Any);
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), ResourceRequest.Any, resource, 1);
resReq.SetNodeLabelExpression("x");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
NUnit.Framework.Assert.Fail("Should fail");
}
catch (InvalidResourceRequestException)
{
}
// we don't allow resource name other than ANY and specify label
try
{
// set queue accessible node labesl to [x, y]
queueAccessibleNodeLabels.Clear();
Sharpen.Collections.AddAll(queueAccessibleNodeLabels, Arrays.AsList("x", "y"));
rmContext.GetNodeLabelManager().AddToCluserNodeLabels(ImmutableSet.Of("x", "y"));
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), "rack", resource, 1);
resReq.SetNodeLabelExpression("x");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
NUnit.Framework.Assert.Fail("Should fail");
}
catch (InvalidResourceRequestException)
{
}
finally
{
rmContext.GetNodeLabelManager().RemoveFromClusterNodeLabels(Arrays.AsList("x", "y"
));
}
// we don't allow resource name other than ANY and specify label even if
// queue has accessible label = *
try
{
// set queue accessible node labesl to *
queueAccessibleNodeLabels.Clear();
Sharpen.Collections.AddAll(queueAccessibleNodeLabels, Arrays.AsList(CommonNodeLabelsManager
.Any));
rmContext.GetNodeLabelManager().AddToCluserNodeLabels(ImmutableSet.Of("x"));
Org.Apache.Hadoop.Yarn.Api.Records.Resource resource = Resources.CreateResource(0
, YarnConfiguration.DefaultRmSchedulerMinimumAllocationVcores);
ResourceRequest resReq = BuilderUtils.NewResourceRequest(Org.Mockito.Mockito.Mock
<Priority>(), "rack", resource, 1);
resReq.SetNodeLabelExpression("x");
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maxResource, "queue", scheduler
, rmContext);
NUnit.Framework.Assert.Fail("Should fail");
}
catch (InvalidResourceRequestException)
{
}
finally
{
rmContext.GetNodeLabelManager().RemoveFromClusterNodeLabels(Arrays.AsList("x"));
}
}