public virtual void TestPutMetrics2()
{
GraphiteSink sink = new GraphiteSink();
IList <MetricsTag> tags = new AList <MetricsTag>();
tags.AddItem(new MetricsTag(MsInfo.Context, "all"));
tags.AddItem(new MetricsTag(MsInfo.Hostname, null));
ICollection <AbstractMetric> metrics = new HashSet <AbstractMetric>();
metrics.AddItem(MakeMetric("foo1", 1));
metrics.AddItem(MakeMetric("foo2", 2));
MetricsRecord record = new MetricsRecordImpl(MsInfo.Context, (long)10000, tags, metrics
);
ArgumentCaptor <string> argument = ArgumentCaptor.ForClass <string>();
GraphiteSink.Graphite mockGraphite = MakeGraphite();
Whitebox.SetInternalState(sink, "graphite", mockGraphite);
sink.PutMetrics(record);
try
{
Org.Mockito.Mockito.Verify(mockGraphite).Write(argument.Capture());
}
catch (IOException e)
{
Runtime.PrintStackTrace(e);
}
string result = argument.GetValue();
Assert.Equal(true, result.Equals("null.all.Context.Context=all.foo1 1 10\n"
+ "null.all.Context.Context=all.foo2 2 10\n") || result.Equals("null.all.Context.Context=all.foo2 2 10\n"
+ "null.all.Context.Context=all.foo1 1 10\n"));
}
public virtual void TestStorageReportHasStorageTypeAndState()
{
// Make sure we are not testing with the default type, that would not
// be a very good test.
NUnit.Framework.Assert.AreNotSame(storageType, StorageType.Default);
NameNode nn = cluster.GetNameNode();
DataNode dn = cluster.GetDataNodes()[0];
// Insert a spy object for the NN RPC.
DatanodeProtocolClientSideTranslatorPB nnSpy = DataNodeTestUtils.SpyOnBposToNN(dn
, nn);
// Trigger a heartbeat so there is an interaction with the spy
// object.
DataNodeTestUtils.TriggerHeartbeat(dn);
// Verify that the callback passed in the expected parameters.
ArgumentCaptor <StorageReport[]> captor = ArgumentCaptor.ForClass <StorageReport[]>
();
Org.Mockito.Mockito.Verify(nnSpy).SendHeartbeat(Matchers.Any <DatanodeRegistration
>(), captor.Capture(), Matchers.AnyLong(), Matchers.AnyLong(), Matchers.AnyInt()
, Matchers.AnyInt(), Matchers.AnyInt(), Org.Mockito.Mockito.Any <VolumeFailureSummary
>());
StorageReport[] reports = captor.GetValue();
foreach (StorageReport report in reports)
{
Assert.AssertThat(report.GetStorage().GetStorageType(), IS.Is(storageType));
Assert.AssertThat(report.GetStorage().GetState(), IS.Is(DatanodeStorage.State.Normal
));
}
}
public static float GetFloatGauge(string name, MetricsRecordBuilder rb)
{
ArgumentCaptor <float> captor = ArgumentCaptor.ForClass <float>();
Org.Mockito.Mockito.Verify(rb, Org.Mockito.Mockito.AtLeast(0)).AddGauge(EqName(Interns.Info
(name, string.Empty)), captor.Capture());
CheckCaptured(captor, name);
return(captor.GetValue());
}
public static long GetLongCounter(string name, MetricsRecordBuilder rb)
{
ArgumentCaptor <long> captor = ArgumentCaptor.ForClass <long>();
Org.Mockito.Mockito.Verify(rb, Org.Mockito.Mockito.AtLeast(0)).AddCounter(EqName(
Interns.Info(name, string.Empty)), captor.Capture());
CheckCaptured(captor, name);
return(captor.GetValue());
}
/// <exception cref="System.Exception"/>
private ReceivedDeletedBlockInfo[] WaitForBlockReceived(ExtendedBlock fakeBlock,
DatanodeProtocolClientSideTranslatorPB mockNN)
{
string fakeBlockPoolId = fakeBlock.GetBlockPoolId();
ArgumentCaptor <StorageReceivedDeletedBlocks[]> captor = ArgumentCaptor.ForClass <StorageReceivedDeletedBlocks
[]>();
GenericTestUtils.WaitFor(new _Supplier_457(mockNN, fakeBlockPoolId, captor), 100,
10000);
return(captor.GetValue()[0].GetBlocks());
}
public virtual void TestCommon()
{
MetricsVisitor visitor = Org.Mockito.Mockito.Mock <MetricsVisitor>();
MetricsRegistry registry = new MetricsRegistry("test");
IList <AbstractMetric> metrics = ((MetricsRecordBuilderImpl)((MetricsRecordBuilderImpl
)((MetricsRecordBuilderImpl)((MetricsRecordBuilderImpl)((MetricsRecordBuilderImpl
)((MetricsRecordBuilderImpl)MetricsLists.Builder("test").AddCounter(Interns.Info
("c1", "int counter"), 1)).AddCounter(Interns.Info("c2", "long counter"), 2L)).AddGauge
(Interns.Info("g1", "int gauge"), 5)).AddGauge(Interns.Info("g2", "long gauge"),
6L)).AddGauge(Interns.Info("g3", "float gauge"), 7f)).AddGauge(Interns.Info("g4"
, "double gauge"), 8d)).Metrics();
foreach (AbstractMetric metric in metrics)
{
metric.Visit(visitor);
}
Org.Mockito.Mockito.Verify(visitor).Counter(c1.Capture(), Eq(1));
Assert.Equal("c1 name", "c1", c1.GetValue().Name());
Assert.Equal("c1 description", "int counter", c1.GetValue().Description
());
Org.Mockito.Mockito.Verify(visitor).Counter(c2.Capture(), Eq(2L));
Assert.Equal("c2 name", "c2", c2.GetValue().Name());
Assert.Equal("c2 description", "long counter", c2.GetValue().Description
());
Org.Mockito.Mockito.Verify(visitor).Gauge(g1.Capture(), Eq(5));
Assert.Equal("g1 name", "g1", g1.GetValue().Name());
Assert.Equal("g1 description", "int gauge", g1.GetValue().Description
());
Org.Mockito.Mockito.Verify(visitor).Gauge(g2.Capture(), Eq(6L));
Assert.Equal("g2 name", "g2", g2.GetValue().Name());
Assert.Equal("g2 description", "long gauge", g2.GetValue().Description
());
Org.Mockito.Mockito.Verify(visitor).Gauge(g3.Capture(), Eq(7f));
Assert.Equal("g3 name", "g3", g3.GetValue().Name());
Assert.Equal("g3 description", "float gauge", g3.GetValue().Description
());
Org.Mockito.Mockito.Verify(visitor).Gauge(g4.Capture(), Eq(8d));
Assert.Equal("g4 name", "g4", g4.GetValue().Name());
Assert.Equal("g4 description", "double gauge", g4.GetValue().Description
());
}
private void VerifyFailedStatus(MRAppMasterTest appMaster, string expectedJobState
)
{
ArgumentCaptor<JobHistoryEvent> captor = ArgumentCaptor.ForClass<JobHistoryEvent>
();
// handle two events: AMStartedEvent and JobUnsuccessfulCompletionEvent
Org.Mockito.Mockito.Verify(appMaster.spyHistoryService, Org.Mockito.Mockito.Times
(2)).HandleEvent(captor.Capture());
HistoryEvent @event = captor.GetValue().GetHistoryEvent();
NUnit.Framework.Assert.IsTrue(@event is JobUnsuccessfulCompletionEvent);
NUnit.Framework.Assert.AreEqual(((JobUnsuccessfulCompletionEvent)@event).GetStatus
(), expectedJobState);
}
public virtual void TestRecovery()
{
FilePath[] localLogDirs = GetLocalLogDirFiles(this.GetType().FullName, 2);
string localLogDirsString = localLogDirs[0].GetAbsolutePath() + "," + localLogDirs
[1].GetAbsolutePath();
conf.Set(YarnConfiguration.NmLogDirs, localLogDirsString);
conf.SetBoolean(YarnConfiguration.LogAggregationEnabled, false);
conf.SetLong(YarnConfiguration.NmLogRetainSeconds, YarnConfiguration.DefaultNmLogRetainSeconds
);
dirsHandler.Init(conf);
NMStateStoreService stateStore = new NMMemoryStateStoreService();
stateStore.Init(conf);
stateStore.Start();
TestNonAggregatingLogHandler.NonAggregatingLogHandlerWithMockExecutor logHandler =
new TestNonAggregatingLogHandler.NonAggregatingLogHandlerWithMockExecutor(this,
dispatcher, mockDelService, dirsHandler, stateStore);
logHandler.Init(conf);
logHandler.Start();
logHandler.Handle(new LogHandlerAppStartedEvent(appId, user, null, ContainerLogsRetentionPolicy
.AllContainers, null));
logHandler.Handle(new LogHandlerContainerFinishedEvent(container11, 0));
logHandler.Handle(new LogHandlerAppFinishedEvent(appId));
// simulate a restart and verify deletion is rescheduled
logHandler.Close();
logHandler = new TestNonAggregatingLogHandler.NonAggregatingLogHandlerWithMockExecutor
(this, dispatcher, mockDelService, dirsHandler, stateStore);
logHandler.Init(conf);
logHandler.Start();
ArgumentCaptor <Runnable> schedArg = ArgumentCaptor.ForClass <Runnable>();
Org.Mockito.Mockito.Verify(logHandler.mockSched).Schedule(schedArg.Capture(), Matchers.AnyLong
(), Matchers.Eq(TimeUnit.Milliseconds));
// execute the runnable and verify another restart has nothing scheduled
schedArg.GetValue().Run();
logHandler.Close();
logHandler = new TestNonAggregatingLogHandler.NonAggregatingLogHandlerWithMockExecutor
(this, dispatcher, mockDelService, dirsHandler, stateStore);
logHandler.Init(conf);
logHandler.Start();
Org.Mockito.Mockito.Verify(logHandler.mockSched, Org.Mockito.Mockito.Never()).Schedule
(Matchers.Any <Runnable>(), Matchers.AnyLong(), Matchers.Any <TimeUnit>());
logHandler.Close();
}
public virtual void TestFilter()
{
FilterConfig config = MockConfig("myuser");
StaticUserWebFilter.StaticUserFilter suf = new StaticUserWebFilter.StaticUserFilter
();
suf.Init(config);
ArgumentCaptor <HttpServletRequestWrapper> wrapperArg = ArgumentCaptor.ForClass <HttpServletRequestWrapper
>();
FilterChain chain = Org.Mockito.Mockito.Mock <FilterChain>();
suf.DoFilter(Org.Mockito.Mockito.Mock <HttpServletRequest>(), Org.Mockito.Mockito.Mock
<ServletResponse>(), chain);
Org.Mockito.Mockito.Verify(chain).DoFilter(wrapperArg.Capture(), Org.Mockito.Mockito
.AnyObject <ServletResponse>());
HttpServletRequestWrapper wrapper = wrapperArg.GetValue();
Assert.Equal("myuser", wrapper.GetUserPrincipal().GetName());
Assert.Equal("myuser", wrapper.GetRemoteUser());
suf.Destroy();
}
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 virtual void TestFailureAndPutMetrics()
{
GraphiteSink sink = new GraphiteSink();
IList <MetricsTag> tags = new AList <MetricsTag>();
tags.AddItem(new MetricsTag(MsInfo.Context, "all"));
tags.AddItem(new MetricsTag(MsInfo.Hostname, "host"));
ICollection <AbstractMetric> metrics = new HashSet <AbstractMetric>();
metrics.AddItem(MakeMetric("foo1", 1.25));
metrics.AddItem(MakeMetric("foo2", 2.25));
MetricsRecord record = new MetricsRecordImpl(MsInfo.Context, (long)10000, tags, metrics
);
GraphiteSink.Graphite mockGraphite = MakeGraphite();
Whitebox.SetInternalState(sink, "graphite", mockGraphite);
// throw exception when first try
Org.Mockito.Mockito.DoThrow(new IOException("IO exception")).When(mockGraphite).Write
(Matchers.AnyString());
sink.PutMetrics(record);
Org.Mockito.Mockito.Verify(mockGraphite).Write(Matchers.AnyString());
Org.Mockito.Mockito.Verify(mockGraphite).Close();
// reset mock and try again
Org.Mockito.Mockito.Reset(mockGraphite);
Org.Mockito.Mockito.When(mockGraphite.IsConnected()).ThenReturn(false);
ArgumentCaptor <string> argument = ArgumentCaptor.ForClass <string>();
sink.PutMetrics(record);
Org.Mockito.Mockito.Verify(mockGraphite).Write(argument.Capture());
string result = argument.GetValue();
Assert.Equal(true, result.Equals("null.all.Context.Context=all.Hostname=host.foo1 1.25 10\n"
+ "null.all.Context.Context=all.Hostname=host.foo2 2.25 10\n") || result.Equals
("null.all.Context.Context=all.Hostname=host.foo2 2.25 10\n" + "null.all.Context.Context=all.Hostname=host.foo1 1.25 10\n"
));
}
public virtual void TestReleaseWhileRunning()
{
DrainDispatcher drainDispatcher = new DrainDispatcher();
EventHandler <RMAppAttemptEvent> appAttemptEventHandler = Org.Mockito.Mockito.Mock
<EventHandler>();
EventHandler generic = Org.Mockito.Mockito.Mock <EventHandler>();
drainDispatcher.Register(typeof(RMAppAttemptEventType), appAttemptEventHandler);
drainDispatcher.Register(typeof(RMNodeEventType), generic);
drainDispatcher.Init(new YarnConfiguration());
drainDispatcher.Start();
NodeId nodeId = BuilderUtils.NewNodeId("host", 3425);
ApplicationId appId = BuilderUtils.NewApplicationId(1, 1);
ApplicationAttemptId appAttemptId = BuilderUtils.NewApplicationAttemptId(appId, 1
);
ContainerId containerId = BuilderUtils.NewContainerId(appAttemptId, 1);
ContainerAllocationExpirer expirer = Org.Mockito.Mockito.Mock <ContainerAllocationExpirer
>();
Resource resource = BuilderUtils.NewResource(512, 1);
Priority priority = BuilderUtils.NewPriority(5);
Container container = BuilderUtils.NewContainer(containerId, nodeId, "host:3465",
resource, priority, null);
ConcurrentMap <ApplicationId, RMApp> rmApps = 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(rmApps)[(ApplicationId)Matchers.Any()];
RMApplicationHistoryWriter writer = Org.Mockito.Mockito.Mock <RMApplicationHistoryWriter
>();
SystemMetricsPublisher publisher = Org.Mockito.Mockito.Mock <SystemMetricsPublisher
>();
RMContext rmContext = Org.Mockito.Mockito.Mock <RMContext>();
Org.Mockito.Mockito.When(rmContext.GetDispatcher()).ThenReturn(drainDispatcher);
Org.Mockito.Mockito.When(rmContext.GetContainerAllocationExpirer()).ThenReturn(expirer
);
Org.Mockito.Mockito.When(rmContext.GetRMApplicationHistoryWriter()).ThenReturn(writer
);
Org.Mockito.Mockito.When(rmContext.GetRMApps()).ThenReturn(rmApps);
Org.Mockito.Mockito.When(rmContext.GetSystemMetricsPublisher()).ThenReturn(publisher
);
Org.Mockito.Mockito.When(rmContext.GetYarnConfiguration()).ThenReturn(new YarnConfiguration
());
RMContainer rmContainer = new RMContainerImpl(container, appAttemptId, nodeId, "user"
, rmContext);
NUnit.Framework.Assert.AreEqual(RMContainerState.New, rmContainer.GetState());
NUnit.Framework.Assert.AreEqual(resource, rmContainer.GetAllocatedResource());
NUnit.Framework.Assert.AreEqual(nodeId, rmContainer.GetAllocatedNode());
NUnit.Framework.Assert.AreEqual(priority, rmContainer.GetAllocatedPriority());
Org.Mockito.Mockito.Verify(writer).ContainerStarted(Matchers.Any <RMContainer>());
Org.Mockito.Mockito.Verify(publisher).ContainerCreated(Matchers.Any <RMContainer>(
), Matchers.AnyLong());
rmContainer.Handle(new RMContainerEvent(containerId, RMContainerEventType.Start));
drainDispatcher.Await();
NUnit.Framework.Assert.AreEqual(RMContainerState.Allocated, rmContainer.GetState(
));
rmContainer.Handle(new RMContainerEvent(containerId, RMContainerEventType.Acquired
));
drainDispatcher.Await();
NUnit.Framework.Assert.AreEqual(RMContainerState.Acquired, rmContainer.GetState()
);
rmContainer.Handle(new RMContainerEvent(containerId, RMContainerEventType.Launched
));
drainDispatcher.Await();
NUnit.Framework.Assert.AreEqual(RMContainerState.Running, rmContainer.GetState());
NUnit.Framework.Assert.AreEqual("http://host:3465/node/containerlogs/container_1_0001_01_000001/user"
, rmContainer.GetLogURL());
// In RUNNING state. Verify RELEASED and associated actions.
Org.Mockito.Mockito.Reset(appAttemptEventHandler);
ContainerStatus containerStatus = SchedulerUtils.CreateAbnormalContainerStatus(containerId
, SchedulerUtils.ReleasedContainer);
rmContainer.Handle(new RMContainerFinishedEvent(containerId, containerStatus, RMContainerEventType
.Released));
drainDispatcher.Await();
NUnit.Framework.Assert.AreEqual(RMContainerState.Released, rmContainer.GetState()
);
NUnit.Framework.Assert.AreEqual(SchedulerUtils.ReleasedContainer, rmContainer.GetDiagnosticsInfo
());
NUnit.Framework.Assert.AreEqual(ContainerExitStatus.Aborted, rmContainer.GetContainerExitStatus
());
NUnit.Framework.Assert.AreEqual(ContainerState.Complete, rmContainer.GetContainerState
());
Org.Mockito.Mockito.Verify(writer).ContainerFinished(Matchers.Any <RMContainer>());
Org.Mockito.Mockito.Verify(publisher).ContainerFinished(Matchers.Any <RMContainer>
(), Matchers.AnyLong());
ArgumentCaptor <RMAppAttemptContainerFinishedEvent> captor = ArgumentCaptor.ForClass
<RMAppAttemptContainerFinishedEvent>();
Org.Mockito.Mockito.Verify(appAttemptEventHandler).Handle(captor.Capture());
RMAppAttemptContainerFinishedEvent cfEvent = captor.GetValue();
NUnit.Framework.Assert.AreEqual(appAttemptId, cfEvent.GetApplicationAttemptId());
NUnit.Framework.Assert.AreEqual(containerStatus, cfEvent.GetContainerStatus());
NUnit.Framework.Assert.AreEqual(RMAppAttemptEventType.ContainerFinished, cfEvent.
GetType());
// In RELEASED state. A FINIHSED event may come in.
rmContainer.Handle(new RMContainerFinishedEvent(containerId, SchedulerUtils.CreateAbnormalContainerStatus
(containerId, "FinishedContainer"), RMContainerEventType.Finished));
NUnit.Framework.Assert.AreEqual(RMContainerState.Released, rmContainer.GetState()
);
}
public virtual void TestTransitionToActive()
{
Org.Mockito.Mockito.DoReturn(StandbyReadyResult).When(mockProtocol).GetServiceStatus
();
NUnit.Framework.Assert.AreEqual(0, RunTool("-transitionToActive", "nn1"));
Org.Mockito.Mockito.Verify(mockProtocol).TransitionToActive(reqInfoCaptor.Capture
());
NUnit.Framework.Assert.AreEqual(HAServiceProtocol.RequestSource.RequestByUser, reqInfoCaptor
.GetValue().GetSource());
}
