public virtual void Init(Clock clock, ResourceScheduler sched, ICollection <Plan>
plans)
{
this.clock = clock;
this.scheduler = sched;
Sharpen.Collections.AddAll(this.plans, plans);
}
public TestRMAppManager(TestAppManager _enclosing, RMContext context, ClientToAMTokenSecretManagerInRM
clientToAMSecretManager, YarnScheduler scheduler, ApplicationMasterService masterService
, ApplicationACLsManager applicationACLsManager, Configuration conf)
: base(context, scheduler, masterService, applicationACLsManager, conf)
{
this._enclosing = _enclosing;
}
public MyClientRMService(RMContext rmContext, YarnScheduler scheduler, RMAppManager
rmAppManager, ApplicationACLsManager applicationACLsManager, QueueACLsManager queueACLsManager
, RMDelegationTokenSecretManager rmDTSecretManager)
: base(rmContext, scheduler, rmAppManager, applicationACLsManager, queueACLsManager
, rmDTSecretManager)
{
this.rmContext = rmContext;
}
public ApplicationMasterService(RMContext rmContext, YarnScheduler scheduler)
: base(typeof(Org.Apache.Hadoop.Yarn.Server.Resourcemanager.ApplicationMasterService
).FullName)
{
this.amLivelinessMonitor = rmContext.GetAMLivelinessMonitor();
this.rScheduler = scheduler;
this.rmContext = rmContext;
}
public MyRMAppManager(RMContext context, YarnScheduler scheduler, ApplicationMasterService
masterService, ApplicationACLsManager applicationACLsManager, Configuration conf
)
: base(context, scheduler, masterService, applicationACLsManager, conf)
{
this.conf = conf;
this.rmContext = context;
}
public CustomedClientRMService(MiniYARNClusterForHATesting _enclosing, RMContext
rmContext, YarnScheduler scheduler, RMAppManager rmAppManager, ApplicationACLsManager
applicationACLsManager, QueueACLsManager queueACLsManager, RMDelegationTokenSecretManager
rmDTSecretManager)
: base(rmContext, scheduler, rmAppManager, applicationACLsManager, queueACLsManager
, rmDTSecretManager)
{
this._enclosing = _enclosing;
}
private void CheckTaskContainersHost(ApplicationAttemptId attemptId, ContainerId
containerId, ResourceManager rm, string host)
{
YarnScheduler scheduler = rm.GetRMContext().GetScheduler();
SchedulerAppReport appReport = scheduler.GetSchedulerAppInfo(attemptId);
NUnit.Framework.Assert.IsTrue(appReport.GetLiveContainers().Count > 0);
foreach (RMContainer c in appReport.GetLiveContainers())
{
if (c.GetContainerId().Equals(containerId))
{
NUnit.Framework.Assert.AreEqual(host, c.GetAllocatedNode().GetHost());
}
}
}
/// <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"
));
}
}
public RMAppManager(RMContext context, YarnScheduler scheduler, ApplicationMasterService
masterService, ApplicationACLsManager applicationACLsManager, Configuration conf
)
{
this.rmContext = context;
this.scheduler = scheduler;
this.masterService = masterService;
this.applicationACLsManager = applicationACLsManager;
this.conf = conf;
this.maxCompletedAppsInMemory = conf.GetInt(YarnConfiguration.RmMaxCompletedApplications
, YarnConfiguration.DefaultRmMaxCompletedApplications);
this.maxCompletedAppsInStateStore = conf.GetInt(YarnConfiguration.RmStateStoreMaxCompletedApplications
, YarnConfiguration.DefaultRmStateStoreMaxCompletedApplications);
if (this.maxCompletedAppsInStateStore > this.maxCompletedAppsInMemory)
{
this.maxCompletedAppsInStateStore = this.maxCompletedAppsInMemory;
}
}
public virtual void SetUp()
{
InlineDispatcher rmDispatcher = new InlineDispatcher();
rmContext = new RMContextImpl(rmDispatcher, null, null, null, Org.Mockito.Mockito.Mock
<DelegationTokenRenewer>(), null, null, null, null, null);
NodesListManager nodesListManager = Org.Mockito.Mockito.Mock <NodesListManager>();
HostsFileReader reader = Org.Mockito.Mockito.Mock <HostsFileReader>();
Org.Mockito.Mockito.When(nodesListManager.GetHostsReader()).ThenReturn(reader);
((RMContextImpl)rmContext).SetNodesListManager(nodesListManager);
scheduler = Org.Mockito.Mockito.Mock <YarnScheduler>();
Org.Mockito.Mockito.DoAnswer(new _Answer_115(this)).When(scheduler).Handle(Matchers.Any
<SchedulerEvent>());
rmDispatcher.Register(typeof(SchedulerEventType), new TestRMNodeTransitions.TestSchedulerEventDispatcher
(this));
rmDispatcher.Register(typeof(NodesListManagerEventType), new TestRMNodeTransitions.TestNodeListManagerEventDispatcher
(this));
NodeId nodeId = BuilderUtils.NewNodeId("localhost", 0);
node = new RMNodeImpl(nodeId, rmContext, null, 0, 0, null, null, null);
nodesListManagerEvent = null;
}
/// <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"));
}
}
/// <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, RMContext rmContext
)
{
NormalizeAndValidateRequest(resReq, maximumResource, queueName, scheduler, false,
rmContext, null);
}
/// <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 CustomedApplicationMasterService(MiniYARNClusterForHATesting _enclosing, RMContext
rmContext, YarnScheduler scheduler)
: base(rmContext, scheduler)
{
this._enclosing = _enclosing;
}
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)
{
}
}
/// <summary>
/// Utility method to validate a list resource requests, by insuring that the
/// requested memory/vcore is non-negative and not greater than max
/// </summary>
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.InvalidResourceRequestException
/// "/>
public static void NormalizeAndValidateRequests(IList <ResourceRequest> ask, Resource
maximumResource, string queueName, YarnScheduler scheduler, RMContext rmContext
)
{
QueueInfo queueInfo = null;
try
{
queueInfo = scheduler.GetQueueInfo(queueName, false, false);
}
catch (IOException)
{
}
foreach (ResourceRequest resReq in ask)
{
SchedulerUtils.NormalizeAndvalidateRequest(resReq, maximumResource, queueName, scheduler
, rmContext, queueInfo);
}
}
public _ApplicationMasterService_581(RMContext baseArg1, YarnScheduler baseArg2)
: base(baseArg1, baseArg2)
{
}
public _ClientRMService_541(RMContext baseArg1, YarnScheduler baseArg2, RMAppManager
baseArg3, ApplicationACLsManager baseArg4, QueueACLsManager baseArg5, RMDelegationTokenSecretManager
baseArg6)
: base(baseArg1, baseArg2, baseArg3, baseArg4, baseArg5, baseArg6)
{
}
