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(); }