/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
/// <exception cref="System.IO.IOException"/>
public override ContainerStatus GetContainerStatus(ContainerId containerId, NodeId
nodeId)
{
ContainerManagementProtocolProxy.ContainerManagementProtocolProxyData proxy = null;
IList <ContainerId> containerIds = new AList <ContainerId>();
containerIds.AddItem(containerId);
try
{
proxy = cmProxy.GetProxy(nodeId.ToString(), containerId);
GetContainerStatusesResponse response = proxy.GetContainerManagementProtocol().GetContainerStatuses
(GetContainerStatusesRequest.NewInstance(containerIds));
if (response.GetFailedRequests() != null && response.GetFailedRequests().Contains
(containerId))
{
Exception t = response.GetFailedRequests()[containerId].DeSerialize();
ParseAndThrowException(t);
}
ContainerStatus containerStatus = response.GetContainerStatuses()[0];
return(containerStatus);
}
finally
{
if (proxy != null)
{
cmProxy.MayBeCloseProxy(proxy);
}
}
}
public virtual void TestContainerManagerInitialization()
{
containerManager.Start();
IPAddress localAddr = Sharpen.Runtime.GetLocalHost();
string fqdn = localAddr.ToString();
if (!localAddr.GetHostAddress().Equals(fqdn))
{
// only check if fqdn is not same as ip
// api returns ip in case of resolution failure
NUnit.Framework.Assert.AreEqual(fqdn, context.GetNodeId().GetHost());
}
// Just do a query for a non-existing container.
bool throwsException = false;
try
{
IList <ContainerId> containerIds = new AList <ContainerId>();
ContainerId id = CreateContainerId(0);
containerIds.AddItem(id);
GetContainerStatusesRequest request = GetContainerStatusesRequest.NewInstance(containerIds
);
GetContainerStatusesResponse response = containerManager.GetContainerStatuses(request
);
if (response.GetFailedRequests().Contains(id))
{
throw response.GetFailedRequests()[id].DeSerialize();
}
}
catch
{
throwsException = true;
}
NUnit.Framework.Assert.IsTrue(throwsException);
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
public virtual GetContainerStatusesResponse GetContainerStatuses(GetContainerStatusesRequest
request)
{
lock (this)
{
IList <ContainerStatus> statuses = new AList <ContainerStatus>();
foreach (ContainerId containerId in request.GetContainerIds())
{
IList <Container> appContainers = containers[containerId.GetApplicationAttemptId()
.GetApplicationId()];
Container container = null;
foreach (Container c in appContainers)
{
if (c.GetId().Equals(containerId))
{
container = c;
}
}
if (container != null && containerStatusMap[container].GetState() != null)
{
statuses.AddItem(containerStatusMap[container]);
}
}
return(GetContainerStatusesResponse.NewInstance(statuses, null));
}
}
/// <exception cref="System.Exception"/>
private void GetContainerStatus(YarnRPC rpc, Token nmToken, ContainerId containerId
, ApplicationAttemptId appAttemptId, NodeId nodeId, bool isExceptionExpected)
{
IList <ContainerId> containerIds = new AList <ContainerId>();
containerIds.AddItem(containerId);
GetContainerStatusesRequest request = GetContainerStatusesRequest.NewInstance(containerIds
);
ContainerManagementProtocol proxy = null;
try
{
proxy = GetContainerManagementProtocolProxy(rpc, nmToken, nodeId, appAttemptId.ToString
());
GetContainerStatusesResponse statuses = proxy.GetContainerStatuses(request);
if (statuses.GetFailedRequests() != null && statuses.GetFailedRequests().Contains
(containerId))
{
ParseAndThrowException(statuses.GetFailedRequests()[containerId].DeSerialize());
}
}
finally
{
if (proxy != null)
{
rpc.StopProxy(proxy, conf);
}
}
}
/// <exception cref="System.IO.IOException"/>
public virtual GetContainerStatusesResponse GetContainerStatuses(GetContainerStatusesRequest
request)
{
IList<ContainerStatus> statuses = new AList<ContainerStatus>();
statuses.AddItem(this.status);
return GetContainerStatusesResponse.NewInstance(statuses, null);
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
public virtual GetContainerStatusesResponse GetContainerStatuses(GetContainerStatusesRequest
request)
{
GetContainerStatusesResponse response = TestRPC.recordFactory.NewRecordInstance <GetContainerStatusesResponse
>();
response.SetContainerStatuses(this.statuses);
return(response);
}
/// <summary>This tests whether a containerId is serialized/deserialized with epoch.</summary>
/// <exception cref="System.IO.IOException"/>
/// <exception cref="System.Exception"/>
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
private void TestContainerTokenWithEpoch(Configuration conf)
{
Log.Info("Running test for serializing/deserializing containerIds");
NMTokenSecretManagerInRM nmTokenSecretManagerInRM = yarnCluster.GetResourceManager
().GetRMContext().GetNMTokenSecretManager();
ApplicationId appId = ApplicationId.NewInstance(1, 1);
ApplicationAttemptId appAttemptId = ApplicationAttemptId.NewInstance(appId, 0);
ContainerId cId = ContainerId.NewContainerId(appAttemptId, (5L << 40) | 3L);
NodeManager nm = yarnCluster.GetNodeManager(0);
NMTokenSecretManagerInNM nmTokenSecretManagerInNM = nm.GetNMContext().GetNMTokenSecretManager
();
string user = "******";
WaitForNMToReceiveNMTokenKey(nmTokenSecretManagerInNM, nm);
NodeId nodeId = nm.GetNMContext().GetNodeId();
// Both id should be equal.
NUnit.Framework.Assert.AreEqual(nmTokenSecretManagerInNM.GetCurrentKey().GetKeyId
(), nmTokenSecretManagerInRM.GetCurrentKey().GetKeyId());
// Creating a normal Container Token
RMContainerTokenSecretManager containerTokenSecretManager = yarnCluster.GetResourceManager
().GetRMContext().GetContainerTokenSecretManager();
Resource r = Resource.NewInstance(1230, 2);
Org.Apache.Hadoop.Yarn.Api.Records.Token containerToken = containerTokenSecretManager
.CreateContainerToken(cId, nodeId, user, r, Priority.NewInstance(0), 0);
ContainerTokenIdentifier containerTokenIdentifier = new ContainerTokenIdentifier(
);
byte[] tokenIdentifierContent = ((byte[])containerToken.GetIdentifier().Array());
DataInputBuffer dib = new DataInputBuffer();
dib.Reset(tokenIdentifierContent, tokenIdentifierContent.Length);
containerTokenIdentifier.ReadFields(dib);
NUnit.Framework.Assert.AreEqual(cId, containerTokenIdentifier.GetContainerID());
NUnit.Framework.Assert.AreEqual(cId.ToString(), containerTokenIdentifier.GetContainerID
().ToString());
Org.Apache.Hadoop.Yarn.Api.Records.Token nmToken = nmTokenSecretManagerInRM.CreateNMToken
(appAttemptId, nodeId, user);
YarnRPC rpc = YarnRPC.Create(conf);
TestStartContainer(rpc, appAttemptId, nodeId, containerToken, nmToken, false);
IList <ContainerId> containerIds = new List <ContainerId>();
containerIds.AddItem(cId);
ContainerManagementProtocol proxy = GetContainerManagementProtocolProxy(rpc, nmToken
, nodeId, user);
GetContainerStatusesResponse res = proxy.GetContainerStatuses(GetContainerStatusesRequest
.NewInstance(containerIds));
NUnit.Framework.Assert.IsNotNull(res.GetContainerStatuses()[0]);
NUnit.Framework.Assert.AreEqual(cId, res.GetContainerStatuses()[0].GetContainerId
());
NUnit.Framework.Assert.AreEqual(cId.ToString(), res.GetContainerStatuses()[0].GetContainerId
().ToString());
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
/// <exception cref="System.IO.IOException"/>
public virtual GetContainerStatusesResponse GetContainerStatuses(GetContainerStatusesRequest
request)
{
IList <ContainerStatus> list = new AList <ContainerStatus>();
list.AddItem(this.status);
GetContainerStatusesResponse response = GetContainerStatusesResponse.NewInstance(
list, null);
return(null);
}
/// <exception cref="Com.Google.Protobuf.ServiceException"/>
public virtual YarnServiceProtos.GetContainerStatusesResponseProto GetContainerStatuses
(RpcController arg0, YarnServiceProtos.GetContainerStatusesRequestProto proto)
{
GetContainerStatusesRequestPBImpl request = new GetContainerStatusesRequestPBImpl
(proto);
try
{
GetContainerStatusesResponse response = real.GetContainerStatuses(request);
return(((GetContainerStatusesResponsePBImpl)response).GetProto());
}
catch (YarnException e)
{
throw new ServiceException(e);
}
catch (IOException e)
{
throw new ServiceException(e);
}
}
public virtual void TestMultipleContainersStopAndGetStatus()
{
containerManager.Start();
IList <StartContainerRequest> startRequest = new AList <StartContainerRequest>();
ContainerLaunchContext containerLaunchContext = recordFactory.NewRecordInstance <ContainerLaunchContext
>();
IList <ContainerId> containerIds = new AList <ContainerId>();
for (int i = 0; i < 10; i++)
{
ContainerId cId = CreateContainerId(i);
string user = null;
if ((i & 1) == 0)
{
// container with even id fail
user = "******";
}
else
{
user = "******";
}
Token containerToken = CreateContainerToken(cId, DummyRmIdentifier, context.GetNodeId
(), user, context.GetContainerTokenSecretManager());
StartContainerRequest request = StartContainerRequest.NewInstance(containerLaunchContext
, containerToken);
startRequest.AddItem(request);
containerIds.AddItem(cId);
}
// start containers
StartContainersRequest requestList = StartContainersRequest.NewInstance(startRequest
);
containerManager.StartContainers(requestList);
// Get container statuses
GetContainerStatusesRequest statusRequest = GetContainerStatusesRequest.NewInstance
(containerIds);
GetContainerStatusesResponse statusResponse = containerManager.GetContainerStatuses
(statusRequest);
NUnit.Framework.Assert.AreEqual(5, statusResponse.GetContainerStatuses().Count);
foreach (ContainerStatus status in statusResponse.GetContainerStatuses())
{
// Containers with odd id should succeed
NUnit.Framework.Assert.AreEqual(1, status.GetContainerId().GetContainerId() & 1);
}
NUnit.Framework.Assert.AreEqual(5, statusResponse.GetFailedRequests().Count);
foreach (KeyValuePair <ContainerId, SerializedException> entry in statusResponse.GetFailedRequests
())
{
// Containers with even id should fail.
NUnit.Framework.Assert.AreEqual(0, entry.Key.GetContainerId() & 1);
NUnit.Framework.Assert.IsTrue(entry.Value.GetMessage().Contains("Reject this container"
));
}
// stop containers
StopContainersRequest stopRequest = StopContainersRequest.NewInstance(containerIds
);
StopContainersResponse stopResponse = containerManager.StopContainers(stopRequest
);
NUnit.Framework.Assert.AreEqual(5, stopResponse.GetSuccessfullyStoppedContainers(
).Count);
foreach (ContainerId id in stopResponse.GetSuccessfullyStoppedContainers())
{
// Containers with odd id should succeed.
NUnit.Framework.Assert.AreEqual(1, id.GetContainerId() & 1);
}
NUnit.Framework.Assert.AreEqual(5, stopResponse.GetFailedRequests().Count);
foreach (KeyValuePair <ContainerId, SerializedException> entry_1 in stopResponse.GetFailedRequests
())
{
// Containers with even id should fail.
NUnit.Framework.Assert.AreEqual(0, entry_1.Key.GetContainerId() & 1);
NUnit.Framework.Assert.IsTrue(entry_1.Value.GetMessage().Contains("Reject this container"
));
}
}
/// <exception cref="System.Exception"/>
private void Test(string rpcClass)
{
Configuration conf = new Configuration();
conf.Set(YarnConfiguration.IpcRpcImpl, rpcClass);
YarnRPC rpc = YarnRPC.Create(conf);
string bindAddr = "localhost:0";
IPEndPoint addr = NetUtils.CreateSocketAddr(bindAddr);
Server server = rpc.GetServer(typeof(ContainerManagementProtocol), new TestRPC.DummyContainerManager
(this), addr, conf, null, 1);
server.Start();
RPC.SetProtocolEngine(conf, typeof(ContainerManagementProtocolPB), typeof(ProtobufRpcEngine
));
ContainerManagementProtocol proxy = (ContainerManagementProtocol)rpc.GetProxy(typeof(
ContainerManagementProtocol), NetUtils.GetConnectAddress(server), conf);
ContainerLaunchContext containerLaunchContext = recordFactory.NewRecordInstance <ContainerLaunchContext
>();
ApplicationId applicationId = ApplicationId.NewInstance(0, 0);
ApplicationAttemptId applicationAttemptId = ApplicationAttemptId.NewInstance(applicationId
, 0);
ContainerId containerId = ContainerId.NewContainerId(applicationAttemptId, 100);
NodeId nodeId = NodeId.NewInstance("localhost", 1234);
Resource resource = Resource.NewInstance(1234, 2);
ContainerTokenIdentifier containerTokenIdentifier = new ContainerTokenIdentifier(
containerId, "localhost", "user", resource, Runtime.CurrentTimeMillis() + 10000,
42, 42, Priority.NewInstance(0), 0);
Token containerToken = NewContainerToken(nodeId, Sharpen.Runtime.GetBytesForString
("password"), containerTokenIdentifier);
StartContainerRequest scRequest = StartContainerRequest.NewInstance(containerLaunchContext
, containerToken);
IList <StartContainerRequest> list = new AList <StartContainerRequest>();
list.AddItem(scRequest);
StartContainersRequest allRequests = StartContainersRequest.NewInstance(list);
proxy.StartContainers(allRequests);
IList <ContainerId> containerIds = new AList <ContainerId>();
containerIds.AddItem(containerId);
GetContainerStatusesRequest gcsRequest = GetContainerStatusesRequest.NewInstance(
containerIds);
GetContainerStatusesResponse response = proxy.GetContainerStatuses(gcsRequest);
IList <ContainerStatus> statuses = response.GetContainerStatuses();
//test remote exception
bool exception = false;
try
{
StopContainersRequest stopRequest = recordFactory.NewRecordInstance <StopContainersRequest
>();
stopRequest.SetContainerIds(containerIds);
proxy.StopContainers(stopRequest);
}
catch (YarnException e)
{
exception = true;
NUnit.Framework.Assert.IsTrue(e.Message.Contains(ExceptionMsg));
NUnit.Framework.Assert.IsTrue(e.Message.Contains(ExceptionCause));
System.Console.Out.WriteLine("Test Exception is " + e.Message);
}
catch (Exception ex)
{
Sharpen.Runtime.PrintStackTrace(ex);
}
NUnit.Framework.Assert.IsTrue(exception);
server.Stop();
NUnit.Framework.Assert.IsNotNull(statuses[0]);
NUnit.Framework.Assert.AreEqual(ContainerState.Running, statuses[0].GetState());
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
public GetContainerStatusesResponse GetContainerStatuses(GetContainerStatusesRequest
request)
{
return(GetContainerStatusesResponse.NewInstance(null, null));
}
