/// <exception cref="System.IO.IOException"/>
/// <exception cref="System.Exception"/>
public override long Renew <_T0>(Org.Apache.Hadoop.Security.Token.Token <_T0> token
, Configuration conf)
{
ApplicationClientProtocol rmClient = GetRmClient(token, conf);
if (rmClient != null)
{
try
{
RenewDelegationTokenRequest request = Records.NewRecord <RenewDelegationTokenRequest
>();
request.SetDelegationToken(ConvertToProtoToken(token));
return(rmClient.RenewDelegationToken(request).GetNextExpirationTime());
}
catch (YarnException e)
{
throw new IOException(e);
}
finally
{
RPC.StopProxy(rmClient);
}
}
else
{
return(localSecretManager.RenewToken((Org.Apache.Hadoop.Security.Token.Token <RMDelegationTokenIdentifier
>)token, GetRenewer(token)));
}
}
public virtual void TesAllJobs()
{
ApplicationClientProtocol applicationsManager = Org.Mockito.Mockito.Mock <ApplicationClientProtocol
>();
GetApplicationsResponse allApplicationsResponse = Org.Apache.Hadoop.Yarn.Util.Records
.NewRecord <GetApplicationsResponse>();
IList <ApplicationReport> applications = new AList <ApplicationReport>();
applications.AddItem(GetApplicationReport(YarnApplicationState.Finished, FinalApplicationStatus
.Failed));
applications.AddItem(GetApplicationReport(YarnApplicationState.Finished, FinalApplicationStatus
.Succeeded));
applications.AddItem(GetApplicationReport(YarnApplicationState.Finished, FinalApplicationStatus
.Killed));
applications.AddItem(GetApplicationReport(YarnApplicationState.Failed, FinalApplicationStatus
.Failed));
allApplicationsResponse.SetApplicationList(applications);
Org.Mockito.Mockito.When(applicationsManager.GetApplications(Org.Mockito.Mockito.
Any <GetApplicationsRequest>())).ThenReturn(allApplicationsResponse);
ResourceMgrDelegate resourceMgrDelegate = new _ResourceMgrDelegate_113(applicationsManager
, new YarnConfiguration());
JobStatus[] allJobs = resourceMgrDelegate.GetAllJobs();
NUnit.Framework.Assert.AreEqual(JobStatus.State.Failed, allJobs[0].GetState());
NUnit.Framework.Assert.AreEqual(JobStatus.State.Succeeded, allJobs[1].GetState());
NUnit.Framework.Assert.AreEqual(JobStatus.State.Killed, allJobs[2].GetState());
NUnit.Framework.Assert.AreEqual(JobStatus.State.Failed, allJobs[3].GetState());
}
/// <exception cref="System.Exception"/>
private ApplicationId SubmitAppAndGetAppId(string submitter, string queueName, bool
setupACLs)
{
GetNewApplicationRequest newAppRequest = GetNewApplicationRequest.NewInstance();
ApplicationClientProtocol submitterClient = GetRMClientForUser(submitter);
ApplicationId applicationId = submitterClient.GetNewApplication(newAppRequest).GetApplicationId
();
Resource resource = BuilderUtils.NewResource(1024, 1);
IDictionary <ApplicationAccessType, string> acls = CreateACLs(submitter, setupACLs
);
ContainerLaunchContext amContainerSpec = ContainerLaunchContext.NewInstance(null,
null, null, null, null, acls);
ApplicationSubmissionContext appSubmissionContext = ApplicationSubmissionContext.
NewInstance(applicationId, "applicationName", queueName, null, amContainerSpec,
false, true, 1, resource, "applicationType");
appSubmissionContext.SetApplicationId(applicationId);
appSubmissionContext.SetQueue(queueName);
SubmitApplicationRequest submitRequest = SubmitApplicationRequest.NewInstance(appSubmissionContext
);
submitterClient.SubmitApplication(submitRequest);
resourceManager.WaitForState(applicationId, RMAppState.Accepted);
return(applicationId);
}
internal PrivilegedAction <SubmitApplicationResponse> SetClientReq(ApplicationClientProtocol
client, SubmitApplicationRequest req)
{
this.client = client;
this.req = req;
return(this);
}
/// <exception cref="System.Exception"/>
public virtual KillApplicationResponse KillApp(ApplicationId appId)
{
ApplicationClientProtocol client = GetClientRMService();
KillApplicationRequest req = KillApplicationRequest.NewInstance(appId);
return(client.ForceKillApplication(req));
}
public static void Setup()
{
RMStateStore store = RMStateStoreFactory.GetStore(conf);
conf.SetBoolean(YarnConfiguration.YarnAclEnable, true);
AccessControlList adminACL = new AccessControlList(string.Empty);
adminACL.AddGroup(SuperGroup);
conf.Set(YarnConfiguration.YarnAdminAcl, adminACL.GetAclString());
resourceManager = new _MockRM_105(conf);
new _Thread_127().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());
}
UserGroupInformation owner = UserGroupInformation.CreateRemoteUser(AppOwner);
rmClient = owner.DoAs(new _PrivilegedExceptionAction_152());
}
// get new application id
/// <exception cref="System.Exception"/>
public virtual GetNewApplicationResponse GetNewAppId()
{
ApplicationClientProtocol client = GetClientRMService();
return(client.GetNewApplication(Org.Apache.Hadoop.Yarn.Util.Records.NewRecord <GetNewApplicationRequest
>()));
}
/// <exception cref="System.Exception"/>
private void VerifyAdministerQueueUserAccess()
{
isQueueUser = true;
AccessControlList viewACL = new AccessControlList(string.Empty);
viewACL.AddGroup(FriendlyGroup);
AccessControlList modifyACL = new AccessControlList(string.Empty);
modifyACL.AddUser(Friend);
ApplicationId applicationId = SubmitAppAndGetAppId(viewACL, modifyACL);
GetApplicationReportRequest appReportRequest = recordFactory.NewRecordInstance <GetApplicationReportRequest
>();
appReportRequest.SetApplicationId(applicationId);
KillApplicationRequest finishAppRequest = recordFactory.NewRecordInstance <KillApplicationRequest
>();
finishAppRequest.SetApplicationId(applicationId);
ApplicationClientProtocol administerQueueUserRmClient = GetRMClientForUser(QueueAdminUser
);
// View as the administerQueueUserRmClient
administerQueueUserRmClient.GetApplicationReport(appReportRequest);
// List apps as administerQueueUserRmClient
NUnit.Framework.Assert.AreEqual("App view by queue-admin-user should list the apps!!"
, 5, administerQueueUserRmClient.GetApplications(recordFactory.NewRecordInstance
<GetApplicationsRequest>()).GetApplicationList().Count);
// Kill app as the administerQueueUserRmClient
administerQueueUserRmClient.ForceKillApplication(finishAppRequest);
resourceManager.WaitForState(applicationId, RMAppState.Killed);
}
/// <exception cref="System.Exception"/>
private static ApplicationClientProtocol CreateMockRMClient(IList <ApplicationId>
finishedApplicaitons, IList <ApplicationId> runningApplications)
{
ApplicationClientProtocol mockProtocol = Org.Mockito.Mockito.Mock <ApplicationClientProtocol
>();
if (finishedApplicaitons != null && !finishedApplicaitons.IsEmpty())
{
foreach (ApplicationId appId in finishedApplicaitons)
{
GetApplicationReportRequest request = GetApplicationReportRequest.NewInstance(appId
);
GetApplicationReportResponse response = CreateApplicationReportWithFinishedApplication
();
Org.Mockito.Mockito.When(mockProtocol.GetApplicationReport(request)).ThenReturn(response
);
}
}
if (runningApplications != null && !runningApplications.IsEmpty())
{
foreach (ApplicationId appId in runningApplications)
{
GetApplicationReportRequest request = GetApplicationReportRequest.NewInstance(appId
);
GetApplicationReportResponse response = CreateApplicationReportWithRunningApplication
();
Org.Mockito.Mockito.When(mockProtocol.GetApplicationReport(request)).ThenReturn(response
);
}
}
return(mockProtocol);
}
/// <summary>
/// Create a direct connection to RM instead of a remote connection when
/// the proxy is running as part of the RM.
/// </summary>
/// <remarks>
/// Create a direct connection to RM instead of a remote connection when
/// the proxy is running as part of the RM. Also create a remote connection to
/// Application History Server if it is enabled.
/// </remarks>
/// <param name="conf">the configuration to use</param>
/// <param name="applicationsManager">what to use to get the RM reports.</param>
public AppReportFetcher(Configuration conf, ApplicationClientProtocol applicationsManager
)
{
if (conf.GetBoolean(YarnConfiguration.ApplicationHistoryEnabled, YarnConfiguration
.DefaultApplicationHistoryEnabled))
{
isAHSEnabled = true;
}
this.conf = conf;
this.applicationsManager = applicationsManager;
if (isAHSEnabled)
{
try
{
historyManager = GetAHSProxy(conf);
}
catch (IOException e)
{
throw new YarnRuntimeException(e);
}
}
else
{
this.historyManager = null;
}
}
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.IO.IOException"/>
/// <exception cref="System.Exception"/>
private long RenewDelegationToken(UserGroupInformation loggedInUser, ApplicationClientProtocol
clientRMService, Org.Apache.Hadoop.Yarn.Api.Records.Token dToken)
{
long nextExpTime = loggedInUser.DoAs(new _PrivilegedExceptionAction_423(dToken, clientRMService
));
return(nextExpTime);
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
/// <exception cref="System.IO.IOException"/>
public virtual ApplicationReport GetApplicationReport(ApplicationId appId)
{
ApplicationClientProtocol client = GetClientRMService();
GetApplicationReportResponse response = client.GetApplicationReport(GetApplicationReportRequest
.NewInstance(appId));
return(response.GetApplicationReport());
}
/// <exception cref="System.IO.IOException"/>
/// <exception cref="System.Exception"/>
private ApplicationClientProtocol GetRMClientForUser(string user)
{
UserGroupInformation userUGI = UserGroupInformation.CreateRemoteUser(user);
ApplicationClientProtocol userClient = userUGI.DoAs(new _PrivilegedExceptionAction_257
(this));
return(userClient);
}
private static void DeleteOldLogDirsFrom(Path dir, long cutoffMillis, FileSystem
fs, ApplicationClientProtocol rmClient)
{
try
{
foreach (FileStatus appDir in fs.ListStatus(dir))
{
if (appDir.IsDirectory() && appDir.GetModificationTime() < cutoffMillis)
{
bool appTerminated = IsApplicationTerminated(ConverterUtils.ToApplicationId(appDir
.GetPath().GetName()), rmClient);
if (appTerminated && ShouldDeleteLogDir(appDir, cutoffMillis, fs))
{
try
{
Log.Info("Deleting aggregated logs in " + appDir.GetPath());
fs.Delete(appDir.GetPath(), true);
}
catch (IOException e)
{
LogIOException("Could not delete " + appDir.GetPath(), e);
}
}
else
{
if (!appTerminated)
{
try
{
foreach (FileStatus node in fs.ListStatus(appDir.GetPath()))
{
if (node.GetModificationTime() < cutoffMillis)
{
try
{
fs.Delete(node.GetPath(), true);
}
catch (IOException ex)
{
LogIOException("Could not delete " + appDir.GetPath(), ex);
}
}
}
}
catch (IOException e)
{
LogIOException("Error reading the contents of " + appDir.GetPath(), e);
}
}
}
}
}
}
catch (IOException e)
{
LogIOException("Could not read the contents of " + dir, e);
}
}
public LogDeletionTask(Configuration conf, long retentionSecs, ApplicationClientProtocol
rmClient)
{
this.conf = conf;
this.retentionMillis = retentionSecs * 1000;
this.suffix = LogAggregationUtils.GetRemoteNodeLogDirSuffix(conf);
this.remoteRootLogDir = new Path(conf.Get(YarnConfiguration.NmRemoteAppLogDir, YarnConfiguration
.DefaultNmRemoteAppLogDir));
this.rmClient = rmClient;
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
/// <exception cref="System.IO.IOException"/>
public virtual void TestHelper(bool isAHSEnabled)
{
conf.SetBoolean(YarnConfiguration.ApplicationHistoryEnabled, isAHSEnabled);
appManager = Org.Mockito.Mockito.Mock <ApplicationClientProtocol>();
Org.Mockito.Mockito.When(appManager.GetApplicationReport(Org.Mockito.Mockito.Any <
GetApplicationReportRequest>())).ThenThrow(new ApplicationNotFoundException(appNotFoundExceptionMsg
));
fetcher = new TestAppReportFetcher.AppReportFetcherForTest(conf, appManager);
ApplicationId appId = ApplicationId.NewInstance(0, 0);
fetcher.GetApplicationReport(appId);
}
/// <exception cref="System.Exception"/>
private void VerifyKillAppSuccess(string submitter, string killer, string queueName
, bool setupACLs)
{
ApplicationId applicationId = SubmitAppAndGetAppId(submitter, queueName, setupACLs
);
KillApplicationRequest finishAppRequest = KillApplicationRequest.NewInstance(applicationId
);
ApplicationClientProtocol ownerClient = GetRMClientForUser(killer);
// Kill app as killer
ownerClient.ForceKillApplication(finishAppRequest);
resourceManager.WaitForState(applicationId, RMAppState.Killed);
}
private ApplicationClientProtocol GetClientRMProtocolWithDT(Org.Apache.Hadoop.Yarn.Api.Records.Token
token, IPEndPoint rmAddress, string user, Configuration conf)
{
// Maybe consider converting to Hadoop token, serialize de-serialize etc
// before trying to renew the token.
UserGroupInformation ugi = UserGroupInformation.CreateRemoteUser(user);
ugi.AddToken(ConverterUtils.ConvertFromYarn(token, rmAddress));
YarnRPC rpc = YarnRPC.Create(conf);
ApplicationClientProtocol clientRMWithDT = ugi.DoAs(new _PrivilegedAction_464(rpc
, rmAddress, conf));
return(clientRMWithDT);
}
/// <exception cref="System.Exception"/>
private void VerifyEnemyAccess()
{
AccessControlList viewACL = new AccessControlList(string.Empty);
viewACL.AddGroup(FriendlyGroup);
AccessControlList modifyACL = new AccessControlList(string.Empty);
modifyACL.AddUser(Friend);
ApplicationId applicationId = SubmitAppAndGetAppId(viewACL, modifyACL);
GetApplicationReportRequest appReportRequest = recordFactory.NewRecordInstance <GetApplicationReportRequest
>();
appReportRequest.SetApplicationId(applicationId);
KillApplicationRequest finishAppRequest = recordFactory.NewRecordInstance <KillApplicationRequest
>();
finishAppRequest.SetApplicationId(applicationId);
ApplicationClientProtocol enemyRmClient = GetRMClientForUser(Enemy);
// View as the enemy
ApplicationReport appReport = enemyRmClient.GetApplicationReport(appReportRequest
).GetApplicationReport();
VerifyEnemyAppReport(appReport);
// List apps as enemy
IList <ApplicationReport> appReports = enemyRmClient.GetApplications(recordFactory
.NewRecordInstance <GetApplicationsRequest>()).GetApplicationList();
NUnit.Framework.Assert.AreEqual("App view by enemy should list the apps!!", 4, appReports
.Count);
foreach (ApplicationReport report in appReports)
{
VerifyEnemyAppReport(report);
}
// Kill app as the enemy
try
{
enemyRmClient.ForceKillApplication(finishAppRequest);
NUnit.Framework.Assert.Fail("App killing by the enemy should fail!!");
}
catch (YarnException e)
{
Log.Info("Got exception while killing app as the enemy", e);
NUnit.Framework.Assert.IsTrue(e.Message.Contains("User enemy cannot perform operation MODIFY_APP on "
+ applicationId));
}
rmClient.ForceKillApplication(finishAppRequest);
}
/// <exception cref="System.Exception"/>
private void VerifyGetClientAMToken(string submitter, string queueAdmin, string queueName
, bool setupACLs)
{
ApplicationId applicationId = SubmitAppAndGetAppId(submitter, queueName, setupACLs
);
GetApplicationReportRequest appReportRequest = GetApplicationReportRequest.NewInstance
(applicationId);
ApplicationClientProtocol submitterClient = GetRMClientForUser(submitter);
ApplicationClientProtocol adMinUserClient = GetRMClientForUser(queueAdmin);
GetApplicationReportResponse submitterGetReport = submitterClient.GetApplicationReport
(appReportRequest);
GetApplicationReportResponse adMinUserGetReport = adMinUserClient.GetApplicationReport
(appReportRequest);
NUnit.Framework.Assert.AreEqual(submitterGetReport.GetApplicationReport().GetClientToAMToken
(), adMinUserGetReport.GetApplicationReport().GetClientToAMToken());
}
/// <exception cref="System.Exception"/>
protected override void ServiceStart()
{
try
{
rmClient = ClientRMProxy.CreateRMProxy <ApplicationClientProtocol>(GetConfig());
if (historyServiceEnabled)
{
historyClient.Start();
}
if (timelineServiceEnabled)
{
timelineClient.Start();
}
}
catch (IOException e)
{
throw new YarnRuntimeException(e);
}
base.ServiceStart();
}
public virtual void TestClusterGetDelegationToken()
{
Configuration conf = new Configuration(false);
Cluster cluster = null;
try
{
conf = new Configuration();
conf.Set(MRConfig.FrameworkName, MRConfig.YarnFrameworkName);
cluster = new Cluster(conf);
YARNRunner yrunner = (YARNRunner)cluster.GetClient();
GetDelegationTokenResponse getDTResponse = recordFactory.NewRecordInstance <GetDelegationTokenResponse
>();
Token rmDTToken = recordFactory.NewRecordInstance <Token>();
rmDTToken.SetIdentifier(ByteBuffer.Wrap(new byte[2]));
rmDTToken.SetKind("Testclusterkind");
rmDTToken.SetPassword(ByteBuffer.Wrap(Sharpen.Runtime.GetBytesForString("testcluster"
)));
rmDTToken.SetService("0.0.0.0:8032");
getDTResponse.SetRMDelegationToken(rmDTToken);
ApplicationClientProtocol cRMProtocol = Org.Mockito.Mockito.Mock <ApplicationClientProtocol
>();
Org.Mockito.Mockito.When(cRMProtocol.GetDelegationToken(Matchers.Any <GetDelegationTokenRequest
>())).ThenReturn(getDTResponse);
ResourceMgrDelegate rmgrDelegate = new _ResourceMgrDelegate_112(cRMProtocol, new
YarnConfiguration(conf));
yrunner.SetResourceMgrDelegate(rmgrDelegate);
Org.Apache.Hadoop.Security.Token.Token t = cluster.GetDelegationToken(new Text(" "
));
NUnit.Framework.Assert.IsTrue("Token kind is instead " + t.GetKind().ToString(),
"Testclusterkind".Equals(t.GetKind().ToString()));
}
finally
{
if (cluster != null)
{
cluster.Close();
}
}
}
/// <exception cref="System.IO.IOException"/>
private static bool IsApplicationTerminated(ApplicationId appId, ApplicationClientProtocol
rmClient)
{
ApplicationReport appReport = null;
try
{
appReport = rmClient.GetApplicationReport(GetApplicationReportRequest.NewInstance
(appId)).GetApplicationReport();
}
catch (ApplicationNotFoundException)
{
return(true);
}
catch (YarnException e)
{
throw new IOException(e);
}
YarnApplicationState currentState = appReport.GetYarnApplicationState();
return(currentState == YarnApplicationState.Failed || currentState == YarnApplicationState
.Killed || currentState == YarnApplicationState.Finished);
}
/// <exception cref="System.Exception"/>
private void VerifyKillAppFailure(string submitter, string killer, string queueName
, bool setupACLs)
{
ApplicationId applicationId = SubmitAppAndGetAppId(submitter, queueName, setupACLs
);
KillApplicationRequest finishAppRequest = KillApplicationRequest.NewInstance(applicationId
);
ApplicationClientProtocol killerClient = GetRMClientForUser(killer);
// Kill app as the killer
try
{
killerClient.ForceKillApplication(finishAppRequest);
NUnit.Framework.Assert.Fail("App killing by the enemy should fail!!");
}
catch (YarnException e)
{
Log.Info("Got exception while killing app as the enemy", e);
NUnit.Framework.Assert.IsTrue(e.Message.Contains("User " + killer + " cannot perform operation MODIFY_APP on "
+ applicationId));
}
GetRMClientForUser(submitter).ForceKillApplication(finishAppRequest);
}
public virtual void TestGetRootQueues()
{
ApplicationClientProtocol applicationsManager = Org.Mockito.Mockito.Mock <ApplicationClientProtocol
>();
GetQueueInfoResponse response = Org.Mockito.Mockito.Mock <GetQueueInfoResponse>();
QueueInfo queueInfo = Org.Mockito.Mockito.Mock <QueueInfo>();
Org.Mockito.Mockito.When(response.GetQueueInfo()).ThenReturn(queueInfo);
try
{
Org.Mockito.Mockito.When(applicationsManager.GetQueueInfo(Org.Mockito.Mockito.Any
<GetQueueInfoRequest>())).ThenReturn(response);
}
catch (YarnException e)
{
throw new IOException(e);
}
ResourceMgrDelegate delegate_ = new _ResourceMgrDelegate_69(applicationsManager,
new YarnConfiguration());
delegate_.GetRootQueues();
ArgumentCaptor <GetQueueInfoRequest> argument = ArgumentCaptor.ForClass <GetQueueInfoRequest
>();
try
{
Org.Mockito.Mockito.Verify(applicationsManager).GetQueueInfo(argument.Capture());
}
catch (YarnException e)
{
throw new IOException(e);
}
NUnit.Framework.Assert.IsTrue("Children of root queue not requested", argument.GetValue
().GetIncludeChildQueues());
NUnit.Framework.Assert.IsTrue("Request wasn't to recurse through children", argument
.GetValue().GetRecursive());
}
public _ResourceMgrDelegate_69(ApplicationClientProtocol applicationsManager, YarnConfiguration
baseArg1)
: base(baseArg1)
{
this.applicationsManager = applicationsManager;
}
public _ResourceMgrDelegate_256(ApplicationClientProtocol clientRMProtocol, YarnConfiguration
baseArg1)
: base(baseArg1)
{
this.clientRMProtocol = clientRMProtocol;
}
/// <exception cref="System.Exception"/>
public virtual void TestResourceMgrDelegate()
{
/* we not want a mock of resource mgr delegate */
ApplicationClientProtocol clientRMProtocol = Org.Mockito.Mockito.Mock <ApplicationClientProtocol
>();
ResourceMgrDelegate delegate_ = new _ResourceMgrDelegate_256(clientRMProtocol, conf
);
/* make sure kill calls finish application master */
Org.Mockito.Mockito.When(clientRMProtocol.ForceKillApplication(Matchers.Any <KillApplicationRequest
>())).ThenReturn(KillApplicationResponse.NewInstance(true));
delegate_.KillApplication(appId);
Org.Mockito.Mockito.Verify(clientRMProtocol).ForceKillApplication(Matchers.Any <KillApplicationRequest
>());
/* make sure getalljobs calls get all applications */
Org.Mockito.Mockito.When(clientRMProtocol.GetApplications(Matchers.Any <GetApplicationsRequest
>())).ThenReturn(recordFactory.NewRecordInstance <GetApplicationsResponse>());
delegate_.GetAllJobs();
Org.Mockito.Mockito.Verify(clientRMProtocol).GetApplications(Matchers.Any <GetApplicationsRequest
>());
/* make sure getapplication report is called */
Org.Mockito.Mockito.When(clientRMProtocol.GetApplicationReport(Matchers.Any <GetApplicationReportRequest
>())).ThenReturn(recordFactory.NewRecordInstance <GetApplicationReportResponse>()
);
delegate_.GetApplicationReport(appId);
Org.Mockito.Mockito.Verify(clientRMProtocol).GetApplicationReport(Matchers.Any <GetApplicationReportRequest
>());
/* make sure metrics is called */
GetClusterMetricsResponse clusterMetricsResponse = recordFactory.NewRecordInstance
<GetClusterMetricsResponse>();
clusterMetricsResponse.SetClusterMetrics(recordFactory.NewRecordInstance <YarnClusterMetrics
>());
Org.Mockito.Mockito.When(clientRMProtocol.GetClusterMetrics(Matchers.Any <GetClusterMetricsRequest
>())).ThenReturn(clusterMetricsResponse);
delegate_.GetClusterMetrics();
Org.Mockito.Mockito.Verify(clientRMProtocol).GetClusterMetrics(Matchers.Any <GetClusterMetricsRequest
>());
Org.Mockito.Mockito.When(clientRMProtocol.GetClusterNodes(Matchers.Any <GetClusterNodesRequest
>())).ThenReturn(recordFactory.NewRecordInstance <GetClusterNodesResponse>());
delegate_.GetActiveTrackers();
Org.Mockito.Mockito.Verify(clientRMProtocol).GetClusterNodes(Matchers.Any <GetClusterNodesRequest
>());
GetNewApplicationResponse newAppResponse = recordFactory.NewRecordInstance <GetNewApplicationResponse
>();
newAppResponse.SetApplicationId(appId);
Org.Mockito.Mockito.When(clientRMProtocol.GetNewApplication(Matchers.Any <GetNewApplicationRequest
>())).ThenReturn(newAppResponse);
delegate_.GetNewJobID();
Org.Mockito.Mockito.Verify(clientRMProtocol).GetNewApplication(Matchers.Any <GetNewApplicationRequest
>());
GetQueueInfoResponse queueInfoResponse = recordFactory.NewRecordInstance <GetQueueInfoResponse
>();
queueInfoResponse.SetQueueInfo(recordFactory.NewRecordInstance <QueueInfo>());
Org.Mockito.Mockito.When(clientRMProtocol.GetQueueInfo(Matchers.Any <GetQueueInfoRequest
>())).ThenReturn(queueInfoResponse);
delegate_.GetQueues();
Org.Mockito.Mockito.Verify(clientRMProtocol).GetQueueInfo(Matchers.Any <GetQueueInfoRequest
>());
GetQueueUserAclsInfoResponse aclResponse = recordFactory.NewRecordInstance <GetQueueUserAclsInfoResponse
>();
Org.Mockito.Mockito.When(clientRMProtocol.GetQueueUserAcls(Matchers.Any <GetQueueUserAclsInfoRequest
>())).ThenReturn(aclResponse);
delegate_.GetQueueAclsForCurrentUser();
Org.Mockito.Mockito.Verify(clientRMProtocol).GetQueueUserAcls(Matchers.Any <GetQueueUserAclsInfoRequest
>());
}
public virtual void SetRMClient(ApplicationClientProtocol rmClient)
{
this.rmClient = rmClient;
}
