public _PrivilegedAction_626(YarnRPC rpc, IPEndPoint rmBindAddress, Configuration
conf)
{
this.rpc = rpc;
this.rmBindAddress = rmBindAddress;
this.conf = conf;
}
public _PrivilegedAction_92(ClientCache _enclosing, YarnRPC rpc, string serviceAddr
)
{
this._enclosing = _enclosing;
this.rpc = rpc;
this.serviceAddr = serviceAddr;
}
/// <exception cref="System.Exception"/>
private void StartContainer(YarnRPC rpc, Token nmToken, Token containerToken, NodeId
nodeId, string user)
{
ContainerLaunchContext context = Org.Apache.Hadoop.Yarn.Util.Records.NewRecord <ContainerLaunchContext
>();
StartContainerRequest scRequest = StartContainerRequest.NewInstance(context, containerToken
);
IList <StartContainerRequest> list = new AList <StartContainerRequest>();
list.AddItem(scRequest);
StartContainersRequest allRequests = StartContainersRequest.NewInstance(list);
ContainerManagementProtocol proxy = null;
try
{
proxy = GetContainerManagementProtocolProxy(rpc, nmToken, nodeId, user);
StartContainersResponse response = proxy.StartContainers(allRequests);
foreach (SerializedException ex in response.GetFailedRequests().Values)
{
ParseAndThrowException(ex.DeSerialize());
}
}
finally
{
if (proxy != null)
{
rpc.StopProxy(proxy, conf);
}
}
}
/// <exception cref="System.Exception"/>
protected override void ServiceStart()
{
Configuration conf = GetConfig();
YarnRPC rpc = YarnRPC.Create(conf);
InitializeWebApp(conf);
IPEndPoint address = conf.GetSocketAddr(JHAdminConfig.MrHistoryBindHost, JHAdminConfig
.MrHistoryAddress, JHAdminConfig.DefaultMrHistoryAddress, JHAdminConfig.DefaultMrHistoryPort
);
server = rpc.GetServer(typeof(HSClientProtocol), protocolHandler, address, conf,
jhsDTSecretManager, conf.GetInt(JHAdminConfig.MrHistoryClientThreadCount, JHAdminConfig
.DefaultMrHistoryClientThreadCount));
// Enable service authorization?
if (conf.GetBoolean(CommonConfigurationKeysPublic.HadoopSecurityAuthorization, false
))
{
server.RefreshServiceAcl(conf, new ClientHSPolicyProvider());
}
server.Start();
this.bindAddress = conf.UpdateConnectAddr(JHAdminConfig.MrHistoryBindHost, JHAdminConfig
.MrHistoryAddress, JHAdminConfig.DefaultMrHistoryAddress, server.GetListenerAddress
());
Log.Info("Instantiated HistoryClientService at " + this.bindAddress);
base.ServiceStart();
}
/// <exception cref="System.Exception"/>
private void StopContainer(YarnRPC rpc, Token nmToken, IList <ContainerId> containerId
, ApplicationAttemptId appAttemptId, NodeId nodeId)
{
StopContainersRequest request = StopContainersRequest.NewInstance(containerId);
ContainerManagementProtocol proxy = null;
try
{
proxy = GetContainerManagementProtocolProxy(rpc, nmToken, nodeId, appAttemptId.ToString
());
StopContainersResponse response = proxy.StopContainers(request);
if (response.GetFailedRequests() != null && response.GetFailedRequests().Contains
(containerId))
{
ParseAndThrowException(response.GetFailedRequests()[containerId].DeSerialize());
}
}
catch (Exception)
{
if (proxy != null)
{
rpc.StopProxy(proxy, conf);
}
}
}
internal virtual LocalizationProtocol GetProxy(IPEndPoint nmAddr)
{
YarnRPC rpc = YarnRPC.Create(conf);
return((LocalizationProtocol)rpc.GetProxy(typeof(LocalizationProtocol), nmAddr, conf
));
}
public _PrivilegedAction_113(YarnRPC rpc, IPEndPoint hsAddress, Configuration conf
)
{
this.rpc = rpc;
this.hsAddress = hsAddress;
this.conf = conf;
}
public ContainerManagementProtocolProxy(Configuration conf, NMTokenCache nmTokenCache
)
{
this.conf = new Configuration(conf);
this.nmTokenCache = nmTokenCache;
maxConnectedNMs = conf.GetInt(YarnConfiguration.NmClientMaxNmProxies, YarnConfiguration
.DefaultNmClientMaxNmProxies);
if (maxConnectedNMs < 0)
{
throw new YarnRuntimeException(YarnConfiguration.NmClientMaxNmProxies + " (" + maxConnectedNMs
+ ") can not be less than 0.");
}
Log.Info(YarnConfiguration.NmClientMaxNmProxies + " : " + maxConnectedNMs);
if (maxConnectedNMs > 0)
{
cmProxy = new LinkedHashMap <string, ContainerManagementProtocolProxy.ContainerManagementProtocolProxyData
>();
}
else
{
cmProxy = Sharpen.Collections.EmptyMap();
// Connections are not being cached so ensure connections close quickly
// to avoid creating thousands of RPC client threads on large clusters.
this.conf.SetInt(CommonConfigurationKeysPublic.IpcClientConnectionMaxidletimeKey,
0);
}
rpc = YarnRPC.Create(conf);
}
/// <exception cref="System.Exception"/>
public MRClientProtocol Run()
{
YarnRPC rpc = YarnRPC.Create(conf);
return((MRClientProtocol)rpc.GetProxy(typeof(MRClientProtocol), app.clientService
.GetBindAddress(), conf));
}
/// <exception cref="System.Exception"/>
protected internal virtual void StartServer()
{
Configuration conf = GetConfig();
YarnRPC rpc = YarnRPC.Create(conf);
this.server = (RPC.Server)rpc.GetServer(typeof(ResourceManagerAdministrationProtocol
), this, masterServiceBindAddress, conf, null, conf.GetInt(YarnConfiguration.RmAdminClientThreadCount
, YarnConfiguration.DefaultRmAdminClientThreadCount));
// Enable service authorization?
if (conf.GetBoolean(CommonConfigurationKeysPublic.HadoopSecurityAuthorization, false
))
{
RefreshServiceAcls(GetConfiguration(conf, YarnConfiguration.HadoopPolicyConfigurationFile
), RMPolicyProvider.GetInstance());
}
if (rmContext.IsHAEnabled())
{
RPC.SetProtocolEngine(conf, typeof(HAServiceProtocolPB), typeof(ProtobufRpcEngine
));
HAServiceProtocolServerSideTranslatorPB haServiceProtocolXlator = new HAServiceProtocolServerSideTranslatorPB
(this);
BlockingService haPbService = HAServiceProtocolProtos.HAServiceProtocolService.NewReflectiveBlockingService
(haServiceProtocolXlator);
server.AddProtocol(RPC.RpcKind.RpcProtocolBuffer, typeof(HAServiceProtocol), haPbService
);
}
this.server.Start();
conf.UpdateConnectAddr(YarnConfiguration.RmBindHost, YarnConfiguration.RmAdminAddress
, YarnConfiguration.DefaultRmAdminAddress, server.GetListenerAddress());
}
/// <exception cref="System.Exception"/>
protected override void ServiceStart()
{
Configuration conf = GetConfig();
YarnRPC rpc = YarnRPC.Create(conf);
IPEndPoint masterServiceAddress = conf.GetSocketAddr(YarnConfiguration.RmBindHost
, YarnConfiguration.RmSchedulerAddress, YarnConfiguration.DefaultRmSchedulerAddress
, YarnConfiguration.DefaultRmSchedulerPort);
Configuration serverConf = conf;
// If the auth is not-simple, enforce it to be token-based.
serverConf = new Configuration(conf);
serverConf.Set(CommonConfigurationKeysPublic.HadoopSecurityAuthentication, SaslRpcServer.AuthMethod
.Token.ToString());
this.server = rpc.GetServer(typeof(ApplicationMasterProtocol), this, masterServiceAddress
, serverConf, this.rmContext.GetAMRMTokenSecretManager(), serverConf.GetInt(YarnConfiguration
.RmSchedulerClientThreadCount, YarnConfiguration.DefaultRmSchedulerClientThreadCount
));
// Enable service authorization?
if (conf.GetBoolean(CommonConfigurationKeysPublic.HadoopSecurityAuthorization, false
))
{
InputStream inputStream = this.rmContext.GetConfigurationProvider().GetConfigurationInputStream
(conf, YarnConfiguration.HadoopPolicyConfigurationFile);
if (inputStream != null)
{
conf.AddResource(inputStream);
}
RefreshServiceAcls(conf, RMPolicyProvider.GetInstance());
}
this.server.Start();
this.bindAddress = conf.UpdateConnectAddr(YarnConfiguration.RmBindHost, YarnConfiguration
.RmSchedulerAddress, YarnConfiguration.DefaultRmSchedulerAddress, server.GetListenerAddress
());
base.ServiceStart();
}
public _PrivilegedAction_262(YarnRPC rpc, IPEndPoint serviceAddr, Configuration conf
)
{
this.rpc = rpc;
this.serviceAddr = serviceAddr;
this.conf = conf;
}
public _PrivilegedAction_206(TestAMAuthorization _enclosing, YarnRPC rpc, Configuration
conf)
{
this._enclosing = _enclosing;
this.rpc = rpc;
this.conf = conf;
}
protected internal virtual ClientSCMProtocol CreateClientProxy()
{
YarnRPC rpc = YarnRPC.Create(GetConfig());
return((ClientSCMProtocol)rpc.GetProxy(typeof(ClientSCMProtocol), this.scmAddress
, GetConfig()));
}
/// <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);
}
}
}
public virtual void TestUnknownCall()
{
Configuration conf = new Configuration();
conf.Set(YarnConfiguration.IpcRpcImpl, typeof(HadoopYarnProtoRPC).FullName);
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();
// Any unrelated protocol would do
ApplicationClientProtocol proxy = (ApplicationClientProtocol)rpc.GetProxy(typeof(
ApplicationClientProtocol), NetUtils.GetConnectAddress(server), conf);
try
{
proxy.GetNewApplication(Records.NewRecord <GetNewApplicationRequest>());
NUnit.Framework.Assert.Fail("Excepted RPC call to fail with unknown method.");
}
catch (YarnException e)
{
NUnit.Framework.Assert.IsTrue(e.Message.Matches("Unknown method getNewApplication called on.*"
+ "org.apache.hadoop.yarn.proto.ApplicationClientProtocol" + "\\$ApplicationClientProtocolService\\$BlockingInterface protocol."
));
}
catch (Exception e)
{
Sharpen.Runtime.PrintStackTrace(e);
}
}
/// <exception cref="System.Exception"/>
protected override void ServiceStart()
{
base.ServiceStart();
// ResourceTrackerServer authenticates NodeManager via Kerberos if
// security is enabled, so no secretManager.
Configuration conf = GetConfig();
YarnRPC rpc = YarnRPC.Create(conf);
this.server = rpc.GetServer(typeof(ResourceTracker), this, resourceTrackerAddress
, conf, null, conf.GetInt(YarnConfiguration.RmResourceTrackerClientThreadCount,
YarnConfiguration.DefaultRmResourceTrackerClientThreadCount));
// Enable service authorization?
if (conf.GetBoolean(CommonConfigurationKeysPublic.HadoopSecurityAuthorization, false
))
{
InputStream inputStream = this.rmContext.GetConfigurationProvider().GetConfigurationInputStream
(conf, YarnConfiguration.HadoopPolicyConfigurationFile);
if (inputStream != null)
{
conf.AddResource(inputStream);
}
RefreshServiceAcls(conf, RMPolicyProvider.GetInstance());
}
this.server.Start();
conf.UpdateConnectAddr(YarnConfiguration.RmBindHost, YarnConfiguration.RmResourceTrackerAddress
, YarnConfiguration.DefaultRmResourceTrackerAddress, server.GetListenerAddress()
);
}
public virtual void Setup()
{
conf = CreateConfiguration();
rpc = YarnRPC.Create(conf);
rmAddress = conf.GetSocketAddr(YarnConfiguration.RmAddress, YarnConfiguration.DefaultRmAddress
, YarnConfiguration.DefaultRmPort);
AccessControlList adminACL = new AccessControlList(string.Empty);
conf.Set(YarnConfiguration.YarnAdminAcl, adminACL.GetAclString());
resourceManager = new _MockRM_85(conf);
new _Thread_96(this).Start();
int waitCount = 0;
while (resourceManager.GetServiceState() == Service.STATE.Inited && waitCount++ <
60)
{
Log.Info("Waiting for RM to start...");
Sharpen.Thread.Sleep(1500);
}
if (resourceManager.GetServiceState() != Service.STATE.Started)
{
// RM could have failed.
throw new IOException("ResourceManager failed to start. Final state is " + resourceManager
.GetServiceState());
}
}
/// <exception cref="System.Exception"/>
protected override void ServiceStart()
{
Configuration conf = GetConfig();
YarnRPC rpc = YarnRPC.Create(conf);
IPEndPoint address = conf.GetSocketAddr(YarnConfiguration.TimelineServiceBindHost
, YarnConfiguration.TimelineServiceAddress, YarnConfiguration.DefaultTimelineServiceAddress
, YarnConfiguration.DefaultTimelineServicePort);
Preconditions.CheckArgument(conf.GetInt(YarnConfiguration.TimelineServiceHandlerThreadCount
, YarnConfiguration.DefaultTimelineServiceClientThreadCount) > 0, "%s property value should be greater than zero"
, YarnConfiguration.TimelineServiceHandlerThreadCount);
server = rpc.GetServer(typeof(ApplicationHistoryProtocol), this, address, conf, null
, conf.GetInt(YarnConfiguration.TimelineServiceHandlerThreadCount, YarnConfiguration
.DefaultTimelineServiceClientThreadCount));
// Enable service authorization?
if (conf.GetBoolean(CommonConfigurationKeysPublic.HadoopSecurityAuthorization, false
))
{
RefreshServiceAcls(conf, new TimelinePolicyProvider());
}
server.Start();
this.bindAddress = conf.UpdateConnectAddr(YarnConfiguration.TimelineServiceBindHost
, YarnConfiguration.TimelineServiceAddress, YarnConfiguration.DefaultTimelineServiceAddress
, server.GetListenerAddress());
Log.Info("Instantiated ApplicationHistoryClientService at " + this.bindAddress);
base.ServiceStart();
}
/// <exception cref="System.Exception"/>
protected override void ServiceStart()
{
Configuration conf = GetConfig();
YarnRPC rpc = YarnRPC.Create(conf);
IPEndPoint address = new IPEndPoint(0);
server = rpc.GetServer(typeof(MRClientProtocol), protocolHandler, address, conf,
appContext.GetClientToAMTokenSecretManager(), conf.GetInt(MRJobConfig.MrAmJobClientThreadCount
, MRJobConfig.DefaultMrAmJobClientThreadCount), MRJobConfig.MrAmJobClientPortRange
);
// Enable service authorization?
if (conf.GetBoolean(CommonConfigurationKeysPublic.HadoopSecurityAuthorization, false
))
{
RefreshServiceAcls(conf, new MRAMPolicyProvider());
}
server.Start();
this.bindAddress = NetUtils.CreateSocketAddrForHost(appContext.GetNMHostname(), server
.GetListenerAddress().Port);
Log.Info("Instantiated MRClientService at " + this.bindAddress);
try
{
// Explicitly disabling SSL for map reduce task as we can't allow MR users
// to gain access to keystore file for opening SSL listener. We can trust
// RM/NM to issue SSL certificates but definitely not MR-AM as it is
// running in user-land.
webApp = WebApps.$for <AppContext>("mapreduce", appContext, "ws").WithHttpPolicy(conf
, HttpConfig.Policy.HttpOnly).Start(new AMWebApp());
}
catch (Exception e)
{
Log.Error("Webapps failed to start. Ignoring for now:", e);
}
base.ServiceStart();
}
protected internal override YarnRPC GetYarnRPC()
{
YarnRPC mockRpc = Org.Mockito.Mockito.Mock <YarnRPC>();
Org.Mockito.Mockito.When(mockRpc.GetProxy(Matchers.Any <Type>(), Matchers.Any <IPEndPoint
>(), Matchers.Any <Configuration>())).ThenReturn(mockProxy);
return(mockRpc);
}
public _PrivilegedAction_89(YarnRPC rpc, Type protocol, IPEndPoint serverAddress,
Configuration conf)
{
this.rpc = rpc;
this.protocol = protocol;
this.serverAddress = serverAddress;
this.conf = conf;
}
protected internal static T CreateRetriableProxy <T>(Configuration conf, UserGroupInformation
user, YarnRPC rpc, IPEndPoint serverAddress, RetryPolicy retryPolicy)
{
System.Type protocol = typeof(T);
T proxy = user.DoAs(new _PrivilegedAction_89(rpc, protocol, serverAddress, conf));
return((T)RetryProxy.Create(protocol, proxy, retryPolicy));
}
private HSClientProtocol InstantiateHistoryProxy()
{
string serviceAddr = mrCluster.GetConfig().Get(JHAdminConfig.MrHistoryAddress);
YarnRPC rpc = YarnRPC.Create(conf);
HSClientProtocol historyClient = (HSClientProtocol)rpc.GetProxy(typeof(HSClientProtocol
), NetUtils.CreateSocketAddr(serviceAddr), mrCluster.GetConfig());
return(historyClient);
}
public virtual void Start()
{
Configuration conf = new Configuration();
YarnRPC rpc = YarnRPC.Create(conf);
server = rpc.GetServer(typeof(LocalizationProtocol), this, locAddr, conf, null, 1
);
server.Start();
}
/// <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());
}
public ContainerManagementProtocol Run()
{
Configuration conf = new Configuration();
YarnRPC rpc = YarnRPC.Create(conf);
IPEndPoint containerManagerBindAddress = NetUtils.CreateSocketAddrForHost("127.0.0.1"
, 12345);
return((ContainerManagementProtocol)rpc.GetProxy(typeof(ContainerManagementProtocol
), containerManagerBindAddress, conf));
}
private SCMUploaderProtocol CreateSCMClient(Configuration conf)
{
YarnRPC rpc = YarnRPC.Create(conf);
IPEndPoint scmAddress = conf.GetSocketAddr(YarnConfiguration.ScmUploaderServerAddress
, YarnConfiguration.DefaultScmUploaderServerAddress, YarnConfiguration.DefaultScmUploaderServerPort
);
return((SCMUploaderProtocol)rpc.GetProxy(typeof(SCMUploaderProtocol), scmAddress,
conf));
}
/// <exception cref="System.Exception"/>
private void TestRPCTimeout(string rpcClass)
{
Configuration conf = new Configuration();
// set timeout low for the test
conf.SetInt("yarn.rpc.nm-command-timeout", 3000);
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 TestContainerLaunchRPC.DummyContainerManager
(this), addr, conf, null, 1);
server.Start();
try
{
ContainerManagementProtocol proxy = (ContainerManagementProtocol)rpc.GetProxy(typeof(
ContainerManagementProtocol), server.GetListenerAddress(), 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 = TestRPC.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);
try
{
proxy.StartContainers(allRequests);
}
catch (Exception e)
{
Log.Info(StringUtils.StringifyException(e));
NUnit.Framework.Assert.AreEqual("Error, exception is not: " + typeof(SocketTimeoutException
).FullName, typeof(SocketTimeoutException).FullName, e.GetType().FullName);
return;
}
}
finally
{
server.Stop();
}
NUnit.Framework.Assert.Fail("timeout exception should have occurred!");
}
/// <exception cref="System.IO.IOException"/>
internal virtual MRClientProtocol InstantiateAMProxy(IPEndPoint serviceAddr)
{
Log.Trace("Connecting to ApplicationMaster at: " + serviceAddr);
YarnRPC rpc = YarnRPC.Create(conf);
MRClientProtocol proxy = (MRClientProtocol)rpc.GetProxy(typeof(MRClientProtocol),
serviceAddr, conf);
usingAMProxy.Set(true);
Log.Trace("Connected to ApplicationMaster at: " + serviceAddr);
return(proxy);
}