public virtual void TestReconnect() { string hostname1 = "localhost1"; Resource capability = BuilderUtils.NewResource(1024, 1); RegisterNodeManagerRequest request1 = recordFactory.NewRecordInstance <RegisterNodeManagerRequest >(); NodeId nodeId1 = NodeId.NewInstance(hostname1, 0); request1.SetNodeId(nodeId1); request1.SetHttpPort(0); request1.SetResource(capability); resourceTrackerService.RegisterNodeManager(request1); NUnit.Framework.Assert.AreEqual(RMNodeEventType.Started, rmNodeEvents[0].GetType( )); rmNodeEvents.Clear(); resourceTrackerService.RegisterNodeManager(request1); NUnit.Framework.Assert.AreEqual(RMNodeEventType.Reconnected, rmNodeEvents[0].GetType ()); rmNodeEvents.Clear(); resourceTrackerService.RegisterNodeManager(request1); capability = BuilderUtils.NewResource(1024, 2); request1.SetResource(capability); NUnit.Framework.Assert.AreEqual(RMNodeEventType.Reconnected, rmNodeEvents[0].GetType ()); }
public virtual void TestNodeRegistrationVersionLessThanRM() { WriteToHostsFile("host2"); Configuration conf = new Configuration(); conf.Set(YarnConfiguration.RmNodesIncludeFilePath, hostFile.GetAbsolutePath()); conf.Set(YarnConfiguration.RmNodemanagerMinimumVersion, "EqualToRM"); rm = new MockRM(conf); rm.Start(); string nmVersion = "1.9.9"; ResourceTrackerService resourceTrackerService = rm.GetResourceTrackerService(); RegisterNodeManagerRequest req = Org.Apache.Hadoop.Yarn.Util.Records.NewRecord <RegisterNodeManagerRequest >(); NodeId nodeId = NodeId.NewInstance("host2", 1234); Resource capability = BuilderUtils.NewResource(1024, 1); req.SetResource(capability); req.SetNodeId(nodeId); req.SetHttpPort(1234); req.SetNMVersion(nmVersion); // trying to register a invalid node. RegisterNodeManagerResponse response = resourceTrackerService.RegisterNodeManager (req); NUnit.Framework.Assert.AreEqual(NodeAction.Shutdown, response.GetNodeAction()); NUnit.Framework.Assert.IsTrue("Diagnostic message did not contain: 'Disallowed NodeManager " + "Version " + nmVersion + ", is less than the minimum version'", response.GetDiagnosticsMessage ().Contains("Disallowed NodeManager Version " + nmVersion + ", is less than the minimum version " )); }
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> /// <exception cref="System.IO.IOException"/> public override RegisterNodeManagerResponse RegisterNodeManager(RegisterNodeManagerRequest request) { this._enclosing.ResetStartFailoverFlag(true); // make sure failover has been triggered NUnit.Framework.Assert.IsTrue(this._enclosing.WaittingForFailOver()); return(base.RegisterNodeManager(request)); }
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> /// <exception cref="System.IO.IOException"/> public virtual RegisterNodeManagerResponse RegisterNodeManager(RegisterNodeManagerRequest request) { if (exception) { throw new YarnException("testMessage"); } return(recordFactory.NewRecordInstance <RegisterNodeManagerResponse>()); }
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> /// <exception cref="System.IO.IOException"/> public virtual RegisterNodeManagerResponse RegisterNodeManager(RegisterNodeManagerRequest request) { RegisterNodeManagerResponse response = recordFactory.NewRecordInstance <RegisterNodeManagerResponse >(); MasterKey masterKey = new MasterKeyPBImpl(); masterKey.SetKeyId(123); masterKey.SetBytes(ByteBuffer.Wrap(new byte[] { 123 })); response.SetContainerTokenMasterKey(masterKey); response.SetNMTokenMasterKey(masterKey); return(response); }
public virtual void TestCompareRMNodeAfterReconnect() { Configuration yarnConf = new YarnConfiguration(); CapacityScheduler scheduler = new CapacityScheduler(); scheduler.SetConf(yarnConf); ConfigurationProvider configurationProvider = ConfigurationProviderFactory.GetConfigurationProvider (yarnConf); configurationProvider.Init(yarnConf); context.SetConfigurationProvider(configurationProvider); RMNodeLabelsManager nlm = new RMNodeLabelsManager(); nlm.Init(yarnConf); nlm.Start(); context.SetNodeLabelManager(nlm); scheduler.SetRMContext(context); scheduler.Init(yarnConf); scheduler.Start(); dispatcher.Register(typeof(SchedulerEventType), scheduler); string hostname1 = "localhost1"; Resource capability = BuilderUtils.NewResource(4096, 4); RegisterNodeManagerRequest request1 = recordFactory.NewRecordInstance <RegisterNodeManagerRequest >(); NodeId nodeId1 = NodeId.NewInstance(hostname1, 0); request1.SetNodeId(nodeId1); request1.SetHttpPort(0); request1.SetResource(capability); resourceTrackerService.RegisterNodeManager(request1); NUnit.Framework.Assert.IsNotNull(context.GetRMNodes()[nodeId1]); // verify Scheduler and RMContext use same RMNode reference. NUnit.Framework.Assert.IsTrue(scheduler.GetSchedulerNode(nodeId1).GetRMNode() == context.GetRMNodes()[nodeId1]); NUnit.Framework.Assert.AreEqual(context.GetRMNodes()[nodeId1].GetTotalCapability( ), capability); Resource capability1 = BuilderUtils.NewResource(2048, 2); request1.SetResource(capability1); resourceTrackerService.RegisterNodeManager(request1); NUnit.Framework.Assert.IsNotNull(context.GetRMNodes()[nodeId1]); // verify Scheduler and RMContext use same RMNode reference // after reconnect. NUnit.Framework.Assert.IsTrue(scheduler.GetSchedulerNode(nodeId1).GetRMNode() == context.GetRMNodes()[nodeId1]); // verify RMNode's capability is changed. NUnit.Framework.Assert.AreEqual(context.GetRMNodes()[nodeId1].GetTotalCapability( ), capability1); nlm.Stop(); scheduler.Stop(); }
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> /// <exception cref="System.IO.IOException"/> public virtual RegisterNodeManagerResponse RegisterNodeManager(RegisterNodeManagerRequest request) { YarnServerCommonServiceProtos.RegisterNodeManagerRequestProto requestProto = ((RegisterNodeManagerRequestPBImpl )request).GetProto(); try { return(new RegisterNodeManagerResponsePBImpl(proxy.RegisterNodeManager(null, requestProto ))); } catch (ServiceException e) { RPCUtil.UnwrapAndThrowException(e); return(null); } }
public virtual void TestRPCResponseId() { string node = "localhost"; Resource capability = BuilderUtils.NewResource(1024, 1); RegisterNodeManagerRequest request = recordFactory.NewRecordInstance <RegisterNodeManagerRequest >(); nodeId = NodeId.NewInstance(node, 1234); request.SetNodeId(nodeId); request.SetHttpPort(0); request.SetResource(capability); RegisterNodeManagerRequest request1 = recordFactory.NewRecordInstance <RegisterNodeManagerRequest >(); request1.SetNodeId(nodeId); request1.SetHttpPort(0); request1.SetResource(capability); resourceTrackerService.RegisterNodeManager(request1); NodeStatus nodeStatus = recordFactory.NewRecordInstance <NodeStatus>(); nodeStatus.SetNodeId(nodeId); NodeHealthStatus nodeHealthStatus = recordFactory.NewRecordInstance <NodeHealthStatus >(); nodeHealthStatus.SetIsNodeHealthy(true); nodeStatus.SetNodeHealthStatus(nodeHealthStatus); NodeHeartbeatRequest nodeHeartBeatRequest = recordFactory.NewRecordInstance <NodeHeartbeatRequest >(); nodeHeartBeatRequest.SetNodeStatus(nodeStatus); nodeStatus.SetResponseId(0); NodeHeartbeatResponse response = resourceTrackerService.NodeHeartbeat(nodeHeartBeatRequest ); NUnit.Framework.Assert.IsTrue(response.GetResponseId() == 1); nodeStatus.SetResponseId(response.GetResponseId()); response = resourceTrackerService.NodeHeartbeat(nodeHeartBeatRequest); NUnit.Framework.Assert.IsTrue(response.GetResponseId() == 2); /* try calling with less response id */ response = resourceTrackerService.NodeHeartbeat(nodeHeartBeatRequest); NUnit.Framework.Assert.IsTrue(response.GetResponseId() == 2); nodeStatus.SetResponseId(0); response = resourceTrackerService.NodeHeartbeat(nodeHeartBeatRequest); NUnit.Framework.Assert.IsTrue(NodeAction.Resync.Equals(response.GetNodeAction())); NUnit.Framework.Assert.AreEqual("Too far behind rm response id:2 nm response id:0" , response.GetDiagnosticsMessage()); }
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> /// <exception cref="System.IO.IOException"/> public RegisterNodeManagerResponse RegisterNodeManager(RegisterNodeManagerRequest request) { RegisterNodeManagerResponse response; try { response = rt.RegisterNodeManager(request); } catch (YarnException e) { MiniYARNCluster.Log.Info("Exception in node registration from " + request.GetNodeId ().ToString(), e); throw; } return(response); }
public virtual void TestNMExpiry() { string hostname1 = "localhost1"; string hostname2 = "localhost2"; string hostname3 = "localhost3"; Resource capability = BuilderUtils.NewResource(1024, 1); RegisterNodeManagerRequest request1 = recordFactory.NewRecordInstance <RegisterNodeManagerRequest >(); NodeId nodeId1 = NodeId.NewInstance(hostname1, 0); request1.SetNodeId(nodeId1); request1.SetHttpPort(0); request1.SetResource(capability); resourceTrackerService.RegisterNodeManager(request1); RegisterNodeManagerRequest request2 = recordFactory.NewRecordInstance <RegisterNodeManagerRequest >(); NodeId nodeId2 = NodeId.NewInstance(hostname2, 0); request2.SetNodeId(nodeId2); request2.SetHttpPort(0); request2.SetResource(capability); resourceTrackerService.RegisterNodeManager(request2); int waitCount = 0; while (ClusterMetrics.GetMetrics().GetNumLostNMs() != 2 && waitCount++ < 20) { lock (this) { Sharpen.Runtime.Wait(this, 100); } } NUnit.Framework.Assert.AreEqual(2, ClusterMetrics.GetMetrics().GetNumLostNMs()); request3 = recordFactory.NewRecordInstance <RegisterNodeManagerRequest>(); NodeId nodeId3 = NodeId.NewInstance(hostname3, 0); request3.SetNodeId(nodeId3); request3.SetHttpPort(0); request3.SetResource(capability); resourceTrackerService.RegisterNodeManager(request3); /* test to see if hostanme 3 does not expire */ stopT = false; new TestNMExpiry.ThirdNodeHeartBeatThread(this).Start(); NUnit.Framework.Assert.AreEqual(2, ClusterMetrics.GetMetrics().GetNumLostNMs()); stopT = true; }
/// <exception cref="System.Exception"/> public virtual void TestResourceTrackerOnHA() { NodeId nodeId = NodeId.NewInstance("localhost", 0); Resource resource = Resource.NewInstance(2048, 4); // make sure registerNodeManager works when failover happens RegisterNodeManagerRequest request = RegisterNodeManagerRequest.NewInstance(nodeId , 0, resource, YarnVersionInfo.GetVersion(), null, null); resourceTracker.RegisterNodeManager(request); NUnit.Framework.Assert.IsTrue(WaitForNodeManagerToConnect(10000, nodeId)); // restart the failover thread, and make sure nodeHeartbeat works failoverThread = CreateAndStartFailoverThread(); NodeStatus status = NodeStatus.NewInstance(NodeId.NewInstance("localhost", 0), 0, null, null, null); NodeHeartbeatRequest request2 = NodeHeartbeatRequest.NewInstance(status, null, null ); resourceTracker.NodeHeartbeat(request2); }
public virtual void TestNodeRegistrationWithMinimumAllocations() { Configuration conf = new Configuration(); conf.Set(YarnConfiguration.RmSchedulerMinimumAllocationMb, "2048"); conf.Set(YarnConfiguration.RmSchedulerMinimumAllocationVcores, "4"); rm = new MockRM(conf); rm.Start(); ResourceTrackerService resourceTrackerService = rm.GetResourceTrackerService(); RegisterNodeManagerRequest req = Org.Apache.Hadoop.Yarn.Util.Records.NewRecord <RegisterNodeManagerRequest >(); NodeId nodeId = BuilderUtils.NewNodeId("host", 1234); req.SetNodeId(nodeId); Resource capability = BuilderUtils.NewResource(1024, 1); req.SetResource(capability); RegisterNodeManagerResponse response1 = resourceTrackerService.RegisterNodeManager (req); NUnit.Framework.Assert.AreEqual(NodeAction.Shutdown, response1.GetNodeAction()); capability.SetMemory(2048); capability.SetVirtualCores(1); req.SetResource(capability); RegisterNodeManagerResponse response2 = resourceTrackerService.RegisterNodeManager (req); NUnit.Framework.Assert.AreEqual(NodeAction.Shutdown, response2.GetNodeAction()); capability.SetMemory(1024); capability.SetVirtualCores(4); req.SetResource(capability); RegisterNodeManagerResponse response3 = resourceTrackerService.RegisterNodeManager (req); NUnit.Framework.Assert.AreEqual(NodeAction.Shutdown, response3.GetNodeAction()); capability.SetMemory(2048); capability.SetVirtualCores(4); req.SetResource(capability); RegisterNodeManagerResponse response4 = resourceTrackerService.RegisterNodeManager (req); NUnit.Framework.Assert.AreEqual(NodeAction.Normal, response4.GetNodeAction()); }
public virtual void TestResourceTrackerPBClientImpl() { RegisterNodeManagerRequest request = recordFactory.NewRecordInstance <RegisterNodeManagerRequest >(); NUnit.Framework.Assert.IsNotNull(client.RegisterNodeManager(request)); TestResourceTrackerPBClientImpl.ResourceTrackerTestImpl.exception = true; try { client.RegisterNodeManager(request); NUnit.Framework.Assert.Fail("there should be YarnException"); } catch (YarnException e) { NUnit.Framework.Assert.IsTrue(e.Message.StartsWith("testMessage")); } finally { TestResourceTrackerPBClientImpl.ResourceTrackerTestImpl.exception = false; } }
/// <exception cref="System.IO.IOException"/> /// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> public NodeManager(string hostName, int containerManagerPort, int httpPort, string rackName, Resource capability, ResourceManager resourceManager) { this.containerManagerAddress = hostName + ":" + containerManagerPort; this.nodeHttpAddress = hostName + ":" + httpPort; this.rackName = rackName; this.resourceTrackerService = resourceManager.GetResourceTrackerService(); this.capability = capability; Resources.AddTo(available, capability); this.nodeId = NodeId.NewInstance(hostName, containerManagerPort); RegisterNodeManagerRequest request = recordFactory.NewRecordInstance <RegisterNodeManagerRequest >(); request.SetHttpPort(httpPort); request.SetResource(capability); request.SetNodeId(this.nodeId); request.SetNMVersion(YarnVersionInfo.GetVersion()); resourceTrackerService.RegisterNodeManager(request); this.resourceManager = resourceManager; resourceManager.GetResourceScheduler().GetNodeReport(this.nodeId); }
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> /// <exception cref="System.IO.IOException"/> public override RegisterNodeManagerResponse RegisterNodeManager(RegisterNodeManagerRequest request) { if (this._enclosing._enclosing.registerCount == 0) { try { NUnit.Framework.Assert.AreEqual(0, request.GetNMContainerStatuses().Count); } catch (Exception error) { Sharpen.Runtime.PrintStackTrace(error); this._enclosing._enclosing._enclosing.assertionFailedInThread.Set(true); } this._enclosing._enclosing.GetNMContext().GetContainers()[testCompleteContainer.GetContainerId ()] = container; this._enclosing._enclosing.GetNMContext().GetApplications()[testCompleteContainer .GetContainerId().GetApplicationAttemptId().GetApplicationId()] = Org.Mockito.Mockito .Mock <Org.Apache.Hadoop.Yarn.Server.Nodemanager.Containermanager.Application.Application >(); } else { IList <NMContainerStatus> statuses = request.GetNMContainerStatuses(); try { NUnit.Framework.Assert.AreEqual(1, statuses.Count); NUnit.Framework.Assert.AreEqual(testCompleteContainer.GetContainerId(), statuses[ 0].GetContainerId()); } catch (Exception error) { Sharpen.Runtime.PrintStackTrace(error); this._enclosing._enclosing._enclosing.assertionFailedInThread.Set(true); } } this._enclosing._enclosing.registerCount++; return(base.RegisterNodeManager(request)); }
/// <exception cref="System.Exception"/> public virtual RegisterNodeManagerResponse RegisterNode(IList <NMContainerStatus> containerReports, IList <ApplicationId> runningApplications) { RegisterNodeManagerRequest req = Org.Apache.Hadoop.Yarn.Util.Records.NewRecord <RegisterNodeManagerRequest >(); req.SetNodeId(nodeId); req.SetHttpPort(httpPort); Resource resource = BuilderUtils.NewResource(memory, vCores); req.SetResource(resource); req.SetContainerStatuses(containerReports); req.SetNMVersion(version); req.SetRunningApplications(runningApplications); RegisterNodeManagerResponse registrationResponse = resourceTracker.RegisterNodeManager (req); this.currentContainerTokenMasterKey = registrationResponse.GetContainerTokenMasterKey (); this.currentNMTokenMasterKey = registrationResponse.GetNMTokenMasterKey(); return(registrationResponse); }
public virtual void TestNodeRegistrationFailure() { WriteToHostsFile("host1"); Configuration conf = new Configuration(); conf.Set(YarnConfiguration.RmNodesIncludeFilePath, hostFile.GetAbsolutePath()); rm = new MockRM(conf); rm.Start(); ResourceTrackerService resourceTrackerService = rm.GetResourceTrackerService(); RegisterNodeManagerRequest req = Org.Apache.Hadoop.Yarn.Util.Records.NewRecord <RegisterNodeManagerRequest >(); NodeId nodeId = NodeId.NewInstance("host2", 1234); req.SetNodeId(nodeId); req.SetHttpPort(1234); // trying to register a invalid node. RegisterNodeManagerResponse response = resourceTrackerService.RegisterNodeManager (req); NUnit.Framework.Assert.AreEqual(NodeAction.Shutdown, response.GetNodeAction()); NUnit.Framework.Assert.AreEqual("Disallowed NodeManager from host2, Sending SHUTDOWN signal to the NodeManager." , response.GetDiagnosticsMessage()); }
public virtual void TestNodeRegistrationSuccess() { WriteToHostsFile("host2"); Configuration conf = new Configuration(); conf.Set(YarnConfiguration.RmNodesIncludeFilePath, hostFile.GetAbsolutePath()); rm = new MockRM(conf); rm.Start(); ResourceTrackerService resourceTrackerService = rm.GetResourceTrackerService(); RegisterNodeManagerRequest req = Org.Apache.Hadoop.Yarn.Util.Records.NewRecord <RegisterNodeManagerRequest >(); NodeId nodeId = NodeId.NewInstance("host2", 1234); Resource capability = BuilderUtils.NewResource(1024, 1); req.SetResource(capability); req.SetNodeId(nodeId); req.SetHttpPort(1234); req.SetNMVersion(YarnVersionInfo.GetVersion()); // trying to register a invalid node. RegisterNodeManagerResponse response = resourceTrackerService.RegisterNodeManager (req); NUnit.Framework.Assert.AreEqual(NodeAction.Normal, response.GetNodeAction()); }
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> /// <exception cref="System.IO.IOException"/> public virtual RegisterNodeManagerResponse RegisterNodeManager(RegisterNodeManagerRequest request) { // TODO Auto-generated method stub return(null); }
protected internal virtual void RegisterWithRM() { IList <NMContainerStatus> containerReports = GetNMContainerStatuses(); RegisterNodeManagerRequest request = RegisterNodeManagerRequest.NewInstance(nodeId , httpPort, totalResource, nodeManagerVersionId, containerReports, GetRunningApplications ()); if (containerReports != null) { Log.Info("Registering with RM using containers :" + containerReports); } RegisterNodeManagerResponse regNMResponse = resourceTracker.RegisterNodeManager(request ); this.rmIdentifier = regNMResponse.GetRMIdentifier(); // if the Resourcemanager instructs NM to shutdown. if (NodeAction.Shutdown.Equals(regNMResponse.GetNodeAction())) { string message = "Message from ResourceManager: " + regNMResponse.GetDiagnosticsMessage (); throw new YarnRuntimeException("Recieved SHUTDOWN signal from Resourcemanager ,Registration of NodeManager failed, " + message); } // if ResourceManager version is too old then shutdown if (!minimumResourceManagerVersion.Equals("NONE")) { if (minimumResourceManagerVersion.Equals("EqualToNM")) { minimumResourceManagerVersion = nodeManagerVersionId; } string rmVersion = regNMResponse.GetRMVersion(); if (rmVersion == null) { string message = "The Resource Manager's did not return a version. " + "Valid version cannot be checked."; throw new YarnRuntimeException("Shutting down the Node Manager. " + message); } if (VersionUtil.CompareVersions(rmVersion, minimumResourceManagerVersion) < 0) { string message = "The Resource Manager's version (" + rmVersion + ") is less than the minimum " + "allowed version " + minimumResourceManagerVersion; throw new YarnRuntimeException("Shutting down the Node Manager on RM " + "version error, " + message); } } MasterKey masterKey = regNMResponse.GetContainerTokenMasterKey(); // do this now so that its set before we start heartbeating to RM // It is expected that status updater is started by this point and // RM gives the shared secret in registration during // StatusUpdater#start(). if (masterKey != null) { this.context.GetContainerTokenSecretManager().SetMasterKey(masterKey); } masterKey = regNMResponse.GetNMTokenMasterKey(); if (masterKey != null) { this.context.GetNMTokenSecretManager().SetMasterKey(masterKey); } Log.Info("Registered with ResourceManager as " + this.nodeId + " with total resource of " + this.totalResource); Log.Info("Notifying ContainerManager to unblock new container-requests"); ((ContainerManagerImpl)this.context.GetContainerManager()).SetBlockNewContainerRequests (false); }
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> /// <exception cref="System.IO.IOException"/> public virtual RegisterNodeManagerResponse RegisterNodeManager(RegisterNodeManagerRequest request) { NodeId nodeId = request.GetNodeId(); string host = nodeId.GetHost(); int cmPort = nodeId.GetPort(); int httpPort = request.GetHttpPort(); Resource capability = request.GetResource(); string nodeManagerVersion = request.GetNMVersion(); RegisterNodeManagerResponse response = recordFactory.NewRecordInstance <RegisterNodeManagerResponse >(); if (!minimumNodeManagerVersion.Equals("NONE")) { if (minimumNodeManagerVersion.Equals("EqualToRM")) { minimumNodeManagerVersion = YarnVersionInfo.GetVersion(); } if ((nodeManagerVersion == null) || (VersionUtil.CompareVersions(nodeManagerVersion , minimumNodeManagerVersion)) < 0) { string message = "Disallowed NodeManager Version " + nodeManagerVersion + ", is less than the minimum version " + minimumNodeManagerVersion + " sending SHUTDOWN signal to " + "NodeManager."; Log.Info(message); response.SetDiagnosticsMessage(message); response.SetNodeAction(NodeAction.Shutdown); return(response); } } // Check if this node is a 'valid' node if (!this.nodesListManager.IsValidNode(host)) { string message = "Disallowed NodeManager from " + host + ", Sending SHUTDOWN signal to the NodeManager."; Log.Info(message); response.SetDiagnosticsMessage(message); response.SetNodeAction(NodeAction.Shutdown); return(response); } // Check if this node has minimum allocations if (capability.GetMemory() < minAllocMb || capability.GetVirtualCores() < minAllocVcores) { string message = "NodeManager from " + host + " doesn't satisfy minimum allocations, Sending SHUTDOWN" + " signal to the NodeManager."; Log.Info(message); response.SetDiagnosticsMessage(message); response.SetNodeAction(NodeAction.Shutdown); return(response); } response.SetContainerTokenMasterKey(containerTokenSecretManager.GetCurrentKey()); response.SetNMTokenMasterKey(nmTokenSecretManager.GetCurrentKey()); RMNode rmNode = new RMNodeImpl(nodeId, rmContext, host, cmPort, httpPort, Resolve (host), capability, nodeManagerVersion); RMNode oldNode = this.rmContext.GetRMNodes().PutIfAbsent(nodeId, rmNode); if (oldNode == null) { this.rmContext.GetDispatcher().GetEventHandler().Handle(new RMNodeStartedEvent(nodeId , request.GetNMContainerStatuses(), request.GetRunningApplications())); } else { Log.Info("Reconnect from the node at: " + host); this.nmLivelinessMonitor.Unregister(nodeId); // Reset heartbeat ID since node just restarted. oldNode.ResetLastNodeHeartBeatResponse(); this.rmContext.GetDispatcher().GetEventHandler().Handle(new RMNodeReconnectEvent( nodeId, rmNode, request.GetRunningApplications(), request.GetNMContainerStatuses ())); } // On every node manager register we will be clearing NMToken keys if // present for any running application. this.nmTokenSecretManager.RemoveNodeKey(nodeId); this.nmLivelinessMonitor.Register(nodeId); // Handle received container status, this should be processed after new // RMNode inserted if (!rmContext.IsWorkPreservingRecoveryEnabled()) { if (!request.GetNMContainerStatuses().IsEmpty()) { Log.Info("received container statuses on node manager register :" + request.GetNMContainerStatuses ()); foreach (NMContainerStatus status in request.GetNMContainerStatuses()) { HandleNMContainerStatus(status, nodeId); } } } string message_1 = "NodeManager from node " + host + "(cmPort: " + cmPort + " httpPort: " + httpPort + ") " + "registered with capability: " + capability + ", assigned nodeId " + nodeId; Log.Info(message_1); response.SetNodeAction(NodeAction.Normal); response.SetRMIdentifier(ResourceManager.GetClusterTimeStamp()); response.SetRMVersion(YarnVersionInfo.GetVersion()); return(response); }