public static void SetupQueueConfiguration(CapacitySchedulerConfiguration conf)
{
// Define default queue
string defQ = CapacitySchedulerConfiguration.Root + ".default";
conf.SetCapacity(defQ, 10);
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "default", "a"
, reservationQ });
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 10);
string dedicated = CapacitySchedulerConfiguration.Root + CapacitySchedulerConfiguration
.Dot + reservationQ;
conf.SetCapacity(dedicated, 80);
// Set as reservation queue
conf.SetReservable(dedicated, true);
// Define 2nd-level queues
string A1 = A + ".a1";
string A2 = A + ".a2";
conf.SetQueues(A, new string[] { "a1", "a2" });
conf.SetCapacity(A1, 30);
conf.SetCapacity(A2, 70);
}
/// <exception cref="System.Exception"/>
public virtual void TestReconnectedNode()
{
CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration();
conf.SetQueues("default", new string[] { "default" });
conf.SetCapacity("default", 100);
FifoScheduler fs = new FifoScheduler();
fs.Init(conf);
fs.Start();
// mock rmContext to avoid NPE.
RMContext context = Org.Mockito.Mockito.Mock <RMContext>();
fs.Reinitialize(conf, null);
fs.SetRMContext(context);
RMNode n1 = MockNodes.NewNodeInfo(0, MockNodes.NewResource(4 * Gb), 1, "127.0.0.2"
);
RMNode n2 = MockNodes.NewNodeInfo(0, MockNodes.NewResource(2 * Gb), 2, "127.0.0.3"
);
fs.Handle(new NodeAddedSchedulerEvent(n1));
fs.Handle(new NodeAddedSchedulerEvent(n2));
fs.Handle(new NodeUpdateSchedulerEvent(n1));
NUnit.Framework.Assert.AreEqual(6 * Gb, fs.GetRootQueueMetrics().GetAvailableMB()
);
// reconnect n1 with downgraded memory
n1 = MockNodes.NewNodeInfo(0, MockNodes.NewResource(2 * Gb), 1, "127.0.0.2");
fs.Handle(new NodeRemovedSchedulerEvent(n1));
fs.Handle(new NodeAddedSchedulerEvent(n1));
fs.Handle(new NodeUpdateSchedulerEvent(n1));
NUnit.Framework.Assert.AreEqual(4 * Gb, fs.GetRootQueueMetrics().GetAvailableMB()
);
fs.Stop();
}
public virtual void UpdateQueueConfiguration(CapacitySchedulerConfiguration conf,
string newQ)
{
// Define default queue
string prefix = CapacitySchedulerConfiguration.Root + CapacitySchedulerConfiguration
.Dot;
string defQ = prefix + "default";
conf.SetCapacity(defQ, 5);
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "default", "a"
, reservationQ, newQ });
string A = prefix + "a";
conf.SetCapacity(A, 5);
string dedicated = prefix + reservationQ;
conf.SetCapacity(dedicated, 80);
// Set as reservation queue
conf.SetReservable(dedicated, true);
conf.SetCapacity(prefix + newQ, 10);
// Set as reservation queue
conf.SetReservable(prefix + newQ, true);
// Define 2nd-level queues
string A1 = A + ".a1";
string A2 = A + ".a2";
conf.SetQueues(A, new string[] { "a1", "a2" });
conf.SetCapacity(A1, 30);
conf.SetCapacity(A2, 70);
}
internal static void SetupFifoQueueConfiguration(CapacitySchedulerConfiguration conf
)
{
// Define default queue
conf.SetQueues("default", new string[] { "default" });
conf.SetCapacity("default", 100);
}
public virtual void TestAdminRefreshQueuesWithFileSystemBasedConfigurationProvider
()
{
configuration.Set(YarnConfiguration.RmConfigurationProviderClass, "org.apache.hadoop.yarn.FileSystemBasedConfigurationProvider"
);
//upload default configurations
UploadDefaultConfiguration();
try
{
rm = new MockRM(configuration);
rm.Init(configuration);
rm.Start();
}
catch (Exception)
{
NUnit.Framework.Assert.Fail("Should not get any exceptions");
}
CapacityScheduler cs = (CapacityScheduler)rm.GetRMContext().GetScheduler();
int maxAppsBefore = cs.GetConfiguration().GetMaximumSystemApplications();
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration();
csConf.Set("yarn.scheduler.capacity.maximum-applications", "5000");
UploadConfiguration(csConf, "capacity-scheduler.xml");
rm.adminService.RefreshQueues(RefreshQueuesRequest.NewInstance());
int maxAppsAfter = cs.GetConfiguration().GetMaximumSystemApplications();
NUnit.Framework.Assert.AreEqual(maxAppsAfter, 5000);
NUnit.Framework.Assert.IsTrue(maxAppsAfter != maxAppsBefore);
}
/// <exception cref="System.Exception"/>
public static FifoScheduler MockFifoScheduler(RMContext rmContext)
{
CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration();
SetupFifoQueueConfiguration(conf);
FifoScheduler fs = new FifoScheduler();
fs.SetConf(new YarnConfiguration());
fs.SetRMContext(rmContext);
fs.Init(conf);
return(fs);
}
public virtual void TestReinitialize()
{
ReservationSystemTestUtil testUtil = new ReservationSystemTestUtil();
CapacityScheduler capScheduler = null;
try
{
capScheduler = testUtil.MockCapacityScheduler(10);
}
catch (IOException e)
{
NUnit.Framework.Assert.Fail(e.Message);
}
CapacityReservationSystem reservationSystem = new CapacityReservationSystem();
CapacitySchedulerConfiguration conf = capScheduler.GetConfiguration();
RMContext mockContext = capScheduler.GetRMContext();
reservationSystem.SetRMContext(mockContext);
try
{
reservationSystem.Reinitialize(capScheduler.GetConfiguration(), mockContext);
}
catch (YarnException e)
{
NUnit.Framework.Assert.Fail(e.Message);
}
// Assert queue in original config
string planQName = testUtil.GetreservationQueueName();
ReservationSystemTestUtil.ValidateReservationQueue(reservationSystem, planQName);
// Dynamically add a plan
string newQ = "reservation";
NUnit.Framework.Assert.IsNull(reservationSystem.GetPlan(newQ));
testUtil.UpdateQueueConfiguration(conf, newQ);
try
{
capScheduler.Reinitialize(conf, mockContext);
}
catch (IOException e)
{
NUnit.Framework.Assert.Fail(e.Message);
}
try
{
reservationSystem.Reinitialize(conf, mockContext);
}
catch (YarnException e)
{
NUnit.Framework.Assert.Fail(e.Message);
}
ReservationSystemTestUtil.ValidateNewReservationQueue(reservationSystem, newQ);
}
/// <exception cref="System.Exception"/>
private void SetupPlanFollower()
{
ReservationSystemTestUtil testUtil = new ReservationSystemTestUtil();
mClock = Org.Mockito.Mockito.Mock <Clock>();
mAgent = Org.Mockito.Mockito.Mock <ReservationAgent>();
string reservationQ = testUtil.GetFullReservationQueueName();
CapacitySchedulerConfiguration csConf = cs.GetConfiguration();
csConf.SetReservationWindow(reservationQ, 20L);
csConf.SetMaximumCapacity(reservationQ, 40);
csConf.SetAverageCapacity(reservationQ, 20);
policy.Init(reservationQ, csConf);
}
internal static void SetupQueueConfiguration(CapacitySchedulerConfiguration conf)
{
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "a", "b", "c" }
);
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 10);
string B = CapacitySchedulerConfiguration.Root + ".b";
conf.SetCapacity(B, 20);
string C = CapacitySchedulerConfiguration.Root + ".c";
conf.SetCapacity(C, 70);
// Define 2nd-level queues
string A1 = A + ".a1";
string A2 = A + ".a2";
conf.SetQueues(A, new string[] { "a1", "a2" });
conf.SetCapacity(A1, 30);
conf.SetCapacity(A2, 70);
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.SetCapacity(B2, 30);
conf.SetCapacity(B3, 20);
string C1 = C + ".c1";
string C2 = C + ".c2";
string C3 = C + ".c3";
string C4 = C + ".c4";
conf.SetQueues(C, new string[] { "c1", "c2", "c3", "c4" });
conf.SetCapacity(C1, 50);
conf.SetCapacity(C2, 10);
conf.SetCapacity(C3, 35);
conf.SetCapacity(C4, 5);
// Define 3rd-level queues
string C11 = C1 + ".c11";
string C12 = C1 + ".c12";
string C13 = C1 + ".c13";
conf.SetQueues(C1, new string[] { "c11", "c12", "c13" });
conf.SetCapacity(C11, 15);
conf.SetCapacity(C12, 45);
conf.SetCapacity(C13, 40);
}
/// <exception cref="System.Exception"/>
public virtual void TestResourceTypes()
{
Dictionary <YarnConfiguration, EnumSet <YarnServiceProtos.SchedulerResourceTypes> >
driver = new Dictionary <YarnConfiguration, EnumSet <YarnServiceProtos.SchedulerResourceTypes
> >();
CapacitySchedulerConfiguration csconf = new CapacitySchedulerConfiguration();
csconf.SetResourceComparator(typeof(DominantResourceCalculator));
YarnConfiguration testCapacityDRConf = new YarnConfiguration(csconf);
testCapacityDRConf.SetClass(YarnConfiguration.RmScheduler, typeof(CapacityScheduler
), typeof(ResourceScheduler));
YarnConfiguration testCapacityDefConf = new YarnConfiguration();
testCapacityDefConf.SetClass(YarnConfiguration.RmScheduler, typeof(CapacityScheduler
), typeof(ResourceScheduler));
YarnConfiguration testFairDefConf = new YarnConfiguration();
testFairDefConf.SetClass(YarnConfiguration.RmScheduler, typeof(FairScheduler), typeof(
ResourceScheduler));
driver[conf] = EnumSet.Of(YarnServiceProtos.SchedulerResourceTypes.Memory);
driver[testCapacityDRConf] = EnumSet.Of(YarnServiceProtos.SchedulerResourceTypes.
Cpu, YarnServiceProtos.SchedulerResourceTypes.Memory);
driver[testCapacityDefConf] = EnumSet.Of(YarnServiceProtos.SchedulerResourceTypes
.Memory);
driver[testFairDefConf] = EnumSet.Of(YarnServiceProtos.SchedulerResourceTypes.Memory
, YarnServiceProtos.SchedulerResourceTypes.Cpu);
foreach (KeyValuePair <YarnConfiguration, EnumSet <YarnServiceProtos.SchedulerResourceTypes
> > entry in driver)
{
EnumSet <YarnServiceProtos.SchedulerResourceTypes> expectedValue = entry.Value;
MockRM rm = new MockRM(entry.Key);
rm.Start();
MockNM nm1 = rm.RegisterNode("127.0.0.1:1234", 6 * Gb);
RMApp app1 = rm.SubmitApp(2048);
nm1.NodeHeartbeat(true);
RMAppAttempt attempt1 = app1.GetCurrentAppAttempt();
MockAM am1 = rm.SendAMLaunched(attempt1.GetAppAttemptId());
RegisterApplicationMasterResponse resp = am1.RegisterAppAttempt();
EnumSet <YarnServiceProtos.SchedulerResourceTypes> types = resp.GetSchedulerResourceTypes
();
Log.Info("types = " + types.ToString());
NUnit.Framework.Assert.AreEqual(expectedValue, types);
rm.Stop();
}
}
public virtual void SetUp()
{
CapacityScheduler spyCs = new CapacityScheduler();
cs = Org.Mockito.Mockito.Spy(spyCs);
scheduler = cs;
rmContext = TestUtils.GetMockRMContext();
spyRMContext = Org.Mockito.Mockito.Spy(rmContext);
ConcurrentMap <ApplicationId, RMApp> spyApps = Org.Mockito.Mockito.Spy(new ConcurrentHashMap
<ApplicationId, RMApp>());
RMApp rmApp = Org.Mockito.Mockito.Mock <RMApp>();
Org.Mockito.Mockito.When(rmApp.GetRMAppAttempt((ApplicationAttemptId)Matchers.Any
())).ThenReturn(null);
Org.Mockito.Mockito.DoReturn(rmApp).When(spyApps)[(ApplicationId)Matchers.Any()];
Org.Mockito.Mockito.When(spyRMContext.GetRMApps()).ThenReturn(spyApps);
Org.Mockito.Mockito.When(spyRMContext.GetScheduler()).ThenReturn(scheduler);
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration();
ReservationSystemTestUtil.SetupQueueConfiguration(csConf);
cs.SetConf(csConf);
csContext = Org.Mockito.Mockito.Mock <CapacitySchedulerContext>();
Org.Mockito.Mockito.When(csContext.GetConfiguration()).ThenReturn(csConf);
Org.Mockito.Mockito.When(csContext.GetConf()).ThenReturn(csConf);
Org.Mockito.Mockito.When(csContext.GetMinimumResourceCapability()).ThenReturn(minAlloc
);
Org.Mockito.Mockito.When(csContext.GetMaximumResourceCapability()).ThenReturn(maxAlloc
);
Org.Mockito.Mockito.When(csContext.GetClusterResource()).ThenReturn(Resources.CreateResource
(100 * 16 * Gb, 100 * 32));
Org.Mockito.Mockito.When(scheduler.GetClusterResource()).ThenReturn(Resources.CreateResource
(125 * Gb, 125));
Org.Mockito.Mockito.When(csContext.GetResourceCalculator()).ThenReturn(new DefaultResourceCalculator
());
RMContainerTokenSecretManager containerTokenSecretManager = new RMContainerTokenSecretManager
(csConf);
containerTokenSecretManager.RollMasterKey();
Org.Mockito.Mockito.When(csContext.GetContainerTokenSecretManager()).ThenReturn(containerTokenSecretManager
);
cs.SetRMContext(spyRMContext);
cs.Init(csConf);
cs.Start();
SetupPlanFollower();
}
/// <exception cref="System.IO.IOException"/>
public static CapacityScheduler MockCapacityScheduler()
{
// stolen from TestCapacityScheduler
CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration();
SetupQueueConfiguration(conf);
CapacityScheduler cs = new CapacityScheduler();
cs.SetConf(new YarnConfiguration());
RMContext rmContext = new RMContextImpl(null, null, null, null, null, null, new RMContainerTokenSecretManager
(conf), new NMTokenSecretManagerInRM(conf), new ClientToAMTokenSecretManagerInRM
(), null);
rmContext.SetNodeLabelManager(new NullRMNodeLabelsManager());
cs.SetRMContext(rmContext);
cs.Init(conf);
return(cs);
}
/// <exception cref="System.IO.IOException"/>
private void UploadDefaultConfiguration()
{
Configuration conf = new Configuration();
UploadConfiguration(conf, "core-site.xml");
YarnConfiguration yarnConf = new YarnConfiguration();
yarnConf.Set(YarnConfiguration.RmConfigurationProviderClass, "org.apache.hadoop.yarn.FileSystemBasedConfigurationProvider"
);
UploadConfiguration(yarnConf, "yarn-site.xml");
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration();
UploadConfiguration(csConf, "capacity-scheduler.xml");
Configuration hadoopPolicyConf = new Configuration(false);
hadoopPolicyConf.AddResource(YarnConfiguration.HadoopPolicyConfigurationFile);
UploadConfiguration(hadoopPolicyConf, "hadoop-policy.xml");
}
private static void SetupQueueConfiguration(CapacitySchedulerConfiguration conf)
{
// Define top-level queues
conf.SetQueues(CapacitySchedulerConfiguration.Root, new string[] { "a", "b" });
string A = CapacitySchedulerConfiguration.Root + ".a";
conf.SetCapacity(A, 10.5f);
conf.SetMaximumCapacity(A, 50);
string B = CapacitySchedulerConfiguration.Root + ".b";
conf.SetCapacity(B, 89.5f);
// 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, 50);
conf.SetUserLimitFactor(A1, 100.0f);
conf.SetCapacity(A2, 70);
conf.SetUserLimitFactor(A2, 100.0f);
string B1 = B + ".b1";
string B2 = B + ".b2";
string B3 = B + ".b3";
conf.SetQueues(B, new string[] { "b1", "b2", "b3" });
conf.SetCapacity(B1, 60);
conf.SetUserLimitFactor(B1, 100.0f);
conf.SetCapacity(B2, 39.5f);
conf.SetUserLimitFactor(B2, 100.0f);
conf.SetCapacity(B3, 0.5f);
conf.SetUserLimitFactor(B3, 100.0f);
conf.SetQueues(A1, new string[] { "a1a", "a1b" });
string A1a = A1 + ".a1a";
conf.SetCapacity(A1a, 85);
string A1b = A1 + ".a1b";
conf.SetCapacity(A1b, 15);
}
/// <exception cref="System.IO.IOException"/>
public virtual CapacityScheduler MockCapacityScheduler(int numContainers)
{
// stolen from TestCapacityScheduler
CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration();
SetupQueueConfiguration(conf);
CapacityScheduler cs = Org.Mockito.Mockito.Spy(new CapacityScheduler());
cs.SetConf(new YarnConfiguration());
RMContext mockRmContext = CreateRMContext(conf);
cs.SetRMContext(mockRmContext);
try
{
cs.ServiceInit(conf);
}
catch (Exception e)
{
NUnit.Framework.Assert.Fail(e.Message);
}
InitializeRMContext(numContainers, cs, mockRmContext);
return(cs);
}
public virtual void TestRMHAWithFileSystemBasedConfiguration()
{
HAServiceProtocol.StateChangeRequestInfo requestInfo = new HAServiceProtocol.StateChangeRequestInfo
(HAServiceProtocol.RequestSource.RequestByUser);
configuration.Set(YarnConfiguration.RmConfigurationProviderClass, "org.apache.hadoop.yarn.FileSystemBasedConfigurationProvider"
);
configuration.SetBoolean(YarnConfiguration.RmHaEnabled, true);
configuration.SetBoolean(YarnConfiguration.AutoFailoverEnabled, false);
configuration.Set(YarnConfiguration.RmHaIds, "rm1,rm2");
int @base = 100;
foreach (string confKey in YarnConfiguration.GetServiceAddressConfKeys(configuration
))
{
configuration.Set(HAUtil.AddSuffix(confKey, "rm1"), "0.0.0.0:" + (@base + 20));
configuration.Set(HAUtil.AddSuffix(confKey, "rm2"), "0.0.0.0:" + (@base + 40));
@base = @base * 2;
}
Configuration conf1 = new Configuration(configuration);
conf1.Set(YarnConfiguration.RmHaId, "rm1");
Configuration conf2 = new Configuration(configuration);
conf2.Set(YarnConfiguration.RmHaId, "rm2");
// upload default configurations
UploadDefaultConfiguration();
MockRM rm1 = null;
MockRM rm2 = null;
try
{
rm1 = new MockRM(conf1);
rm1.Init(conf1);
rm1.Start();
NUnit.Framework.Assert.IsTrue(rm1.GetRMContext().GetHAServiceState() == HAServiceProtocol.HAServiceState
.Standby);
rm2 = new MockRM(conf2);
rm2.Init(conf1);
rm2.Start();
NUnit.Framework.Assert.IsTrue(rm2.GetRMContext().GetHAServiceState() == HAServiceProtocol.HAServiceState
.Standby);
rm1.adminService.TransitionToActive(requestInfo);
NUnit.Framework.Assert.IsTrue(rm1.GetRMContext().GetHAServiceState() == HAServiceProtocol.HAServiceState
.Active);
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration();
csConf.Set("yarn.scheduler.capacity.maximum-applications", "5000");
UploadConfiguration(csConf, "capacity-scheduler.xml");
rm1.adminService.RefreshQueues(RefreshQueuesRequest.NewInstance());
int maxApps = ((CapacityScheduler)rm1.GetRMContext().GetScheduler()).GetConfiguration
().GetMaximumSystemApplications();
NUnit.Framework.Assert.AreEqual(maxApps, 5000);
// Before failover happens, the maxApps is
// still the default value on the standby rm : rm2
int maxAppsBeforeFailOver = ((CapacityScheduler)rm2.GetRMContext().GetScheduler()
).GetConfiguration().GetMaximumSystemApplications();
NUnit.Framework.Assert.AreEqual(maxAppsBeforeFailOver, 10000);
// Do the failover
rm1.adminService.TransitionToStandby(requestInfo);
rm2.adminService.TransitionToActive(requestInfo);
NUnit.Framework.Assert.IsTrue(rm1.GetRMContext().GetHAServiceState() == HAServiceProtocol.HAServiceState
.Standby);
NUnit.Framework.Assert.IsTrue(rm2.GetRMContext().GetHAServiceState() == HAServiceProtocol.HAServiceState
.Active);
int maxAppsAfter = ((CapacityScheduler)rm2.GetRMContext().GetScheduler()).GetConfiguration
().GetMaximumSystemApplications();
NUnit.Framework.Assert.AreEqual(maxAppsAfter, 5000);
}
finally
{
if (rm1 != null)
{
rm1.Stop();
}
if (rm2 != null)
{
rm2.Stop();
}
}
}
public virtual void TestRMInitialsWithFileSystemBasedConfigurationProvider()
{
configuration.Set(YarnConfiguration.RmConfigurationProviderClass, "org.apache.hadoop.yarn.FileSystemBasedConfigurationProvider"
);
// upload configurations
FilePath excludeHostsFile = new FilePath(tmpDir.ToString(), "excludeHosts");
if (excludeHostsFile.Exists())
{
excludeHostsFile.Delete();
}
if (!excludeHostsFile.CreateNewFile())
{
NUnit.Framework.Assert.Fail("Can not create " + "excludeHosts");
}
PrintWriter fileWriter = new PrintWriter(excludeHostsFile);
fileWriter.Write("0.0.0.0:123");
fileWriter.Close();
UploadToRemoteFileSystem(new Path(excludeHostsFile.GetAbsolutePath()));
YarnConfiguration yarnConf = new YarnConfiguration();
yarnConf.Set(YarnConfiguration.YarnAdminAcl, "world:anyone:rwcda");
yarnConf.Set(YarnConfiguration.RmNodesExcludeFilePath, this.workingPath + "/excludeHosts"
);
UploadConfiguration(yarnConf, "yarn-site.xml");
CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration();
csConf.Set("yarn.scheduler.capacity.maximum-applications", "5000");
UploadConfiguration(csConf, "capacity-scheduler.xml");
string aclsString = "alice,bob users,wheel";
Configuration newConf = new Configuration();
newConf.Set("security.applicationclient.protocol.acl", aclsString);
UploadConfiguration(newConf, "hadoop-policy.xml");
Configuration conf = new Configuration();
conf.SetBoolean(CommonConfigurationKeysPublic.HadoopSecurityAuthorization, true);
conf.Set("hadoop.proxyuser.test.groups", "test_groups");
conf.Set("hadoop.proxyuser.test.hosts", "test_hosts");
conf.SetClass(CommonConfigurationKeys.HadoopSecurityGroupMapping, typeof(TestRMAdminService.MockUnixGroupsMapping
), typeof(GroupMappingServiceProvider));
UploadConfiguration(conf, "core-site.xml");
// update the groups
TestRMAdminService.MockUnixGroupsMapping.UpdateGroups();
ResourceManager resourceManager = null;
try
{
try
{
resourceManager = new ResourceManager();
resourceManager.Init(configuration);
resourceManager.Start();
}
catch (Exception)
{
NUnit.Framework.Assert.Fail("Should not get any exceptions");
}
// validate values for excludeHosts
ICollection <string> excludeHosts = resourceManager.GetRMContext().GetNodesListManager
().GetHostsReader().GetExcludedHosts();
NUnit.Framework.Assert.IsTrue(excludeHosts.Count == 1);
NUnit.Framework.Assert.IsTrue(excludeHosts.Contains("0.0.0.0:123"));
// validate values for admin-acls
string aclStringAfter = resourceManager.adminService.GetAccessControlList().GetAclString
().Trim();
NUnit.Framework.Assert.AreEqual(aclStringAfter, "world:anyone:rwcda," + UserGroupInformation
.GetCurrentUser().GetShortUserName());
// validate values for queue configuration
CapacityScheduler cs = (CapacityScheduler)resourceManager.GetRMContext().GetScheduler
();
int maxAppsAfter = cs.GetConfiguration().GetMaximumSystemApplications();
NUnit.Framework.Assert.AreEqual(maxAppsAfter, 5000);
// verify service Acls for AdminService
ServiceAuthorizationManager adminServiceServiceManager = resourceManager.adminService
.GetServer().GetServiceAuthorizationManager();
VerifyServiceACLsRefresh(adminServiceServiceManager, typeof(ApplicationClientProtocolPB
), aclsString);
// verify service ACLs for ClientRMService
ServiceAuthorizationManager clientRMServiceServiceManager = resourceManager.GetRMContext
().GetClientRMService().GetServer().GetServiceAuthorizationManager();
VerifyServiceACLsRefresh(clientRMServiceServiceManager, typeof(ApplicationClientProtocolPB
), aclsString);
// verify service ACLs for ApplicationMasterService
ServiceAuthorizationManager appMasterService = resourceManager.GetRMContext().GetApplicationMasterService
().GetServer().GetServiceAuthorizationManager();
VerifyServiceACLsRefresh(appMasterService, typeof(ApplicationClientProtocolPB), aclsString
);
// verify service ACLs for ResourceTrackerService
ServiceAuthorizationManager RTService = resourceManager.GetRMContext().GetResourceTrackerService
().GetServer().GetServiceAuthorizationManager();
VerifyServiceACLsRefresh(RTService, typeof(ApplicationClientProtocolPB), aclsString
);
// verify ProxyUsers and ProxyHosts
ProxyUsers.RefreshSuperUserGroupsConfiguration(configuration);
NUnit.Framework.Assert.IsTrue(ProxyUsers.GetDefaultImpersonationProvider().GetProxyGroups
()["hadoop.proxyuser.test.groups"].Count == 1);
NUnit.Framework.Assert.IsTrue(ProxyUsers.GetDefaultImpersonationProvider().GetProxyGroups
()["hadoop.proxyuser.test.groups"].Contains("test_groups"));
NUnit.Framework.Assert.IsTrue(ProxyUsers.GetDefaultImpersonationProvider().GetProxyHosts
()["hadoop.proxyuser.test.hosts"].Count == 1);
NUnit.Framework.Assert.IsTrue(ProxyUsers.GetDefaultImpersonationProvider().GetProxyHosts
()["hadoop.proxyuser.test.hosts"].Contains("test_hosts"));
// verify UserToGroupsMappings
IList <string> groupAfter = Groups.GetUserToGroupsMappingService(configuration).GetGroups
(UserGroupInformation.GetCurrentUser().GetUserName());
NUnit.Framework.Assert.IsTrue(groupAfter.Contains("test_group_D") && groupAfter.Contains
("test_group_E") && groupAfter.Contains("test_group_F") && groupAfter.Count == 3
);
}
finally
{
if (resourceManager != null)
{
resourceManager.Stop();
}
}
}
public Yarn()
{
Configuration = new YarnConfiguration();
CapacitySchedulerConfiguration = new CapacitySchedulerConfiguration();
}
public MapReduce()
{
Configuration = new MapReduceConfiguration();
CapacitySchedulerConfiguration = new CapacitySchedulerConfiguration();
}
public Yarn()
{
Configuration = new YarnConfiguration();
CapacitySchedulerConfiguration = new CapacitySchedulerConfiguration();
}
public MapReduce()
{
Configuration = new MapReduceConfiguration();
CapacitySchedulerConfiguration = new CapacitySchedulerConfiguration();
}
