You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mesos.apache.org by nn...@apache.org on 2015/04/21 21:56:33 UTC
[7/9] mesos git commit: Refactored TestAllocator and allocator text
fixture.
Refactored TestAllocator and allocator text fixture.
TestAllocator owns a pointer to a real allocator. Each test should
instantiate and destroy Allocator instances explicitly to avoid not
expected calls.
Review: https://reviews.apache.org/r/31263
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/ab48d54c
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/ab48d54c
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/ab48d54c
Branch: refs/heads/master
Commit: ab48d54c0250bffc5542bf68afd648e6a12025ad
Parents: c97c93e
Author: Alexander Rukletsov <ru...@gmail.com>
Authored: Tue Apr 21 12:11:37 2015 -0700
Committer: Niklas Q. Nielsen <ni...@qni.dk>
Committed: Tue Apr 21 12:11:39 2015 -0700
----------------------------------------------------------------------
src/tests/containerizer.cpp | 2 +-
src/tests/master_allocator_tests.cpp | 525 ++++++++++++++++--------------
src/tests/mesos.hpp | 41 ++-
src/tests/slave_recovery_tests.cpp | 2 +
4 files changed, 310 insertions(+), 260 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/ab48d54c/src/tests/containerizer.cpp
----------------------------------------------------------------------
diff --git a/src/tests/containerizer.cpp b/src/tests/containerizer.cpp
index 26b87ac..80b9105 100644
--- a/src/tests/containerizer.cpp
+++ b/src/tests/containerizer.cpp
@@ -224,7 +224,7 @@ void TestContainerizer::setup()
// verbose.
//
// TODO(bmahler): Update this to use the same style as the
- // TestAllocatorProcess, which allows us to have default actions
+ // TestAllocator, which allows us to have default actions
// 'DoDefault', without requiring each test to put expectations in
// place.
http://git-wip-us.apache.org/repos/asf/mesos/blob/ab48d54c/src/tests/master_allocator_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/master_allocator_tests.cpp b/src/tests/master_allocator_tests.cpp
index f29e90e..8d1a866 100644
--- a/src/tests/master_allocator_tests.cpp
+++ b/src/tests/master_allocator_tests.cpp
@@ -72,12 +72,7 @@ namespace tests {
template <typename T>
-class MasterAllocatorTest : public MesosTest
-{
-protected:
- TestAllocator<T> allocator;
-};
-
+class MasterAllocatorTest : public MesosTest {};
typedef ::testing::Types<HierarchicalDRFAllocator> AllocatorTypes;
@@ -91,24 +86,26 @@ TYPED_TEST_CASE(MasterAllocatorTest, AllocatorTypes);
// the slave's resources are offered to the framework.
TYPED_TEST(MasterAllocatorTest, SingleFramework)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
- Try<PID<Master> > master = this->StartMaster(&this->allocator);
+ EXPECT_CALL(allocator, initialize(_, _, _));
+
+ Try<PID<Master>> master = this->StartMaster(&allocator);
ASSERT_SOME(master);
slave::Flags flags = this->CreateSlaveFlags();
flags.resources = Some("cpus:2;mem:1024;disk:0");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
- Try<PID<Slave> > slave = this->StartSlave(flags);
+ Try<PID<Slave>> slave = this->StartSlave(flags);
ASSERT_SOME(slave);
MockScheduler sched;
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
EXPECT_CALL(sched, registered(_, _, _));
@@ -135,9 +132,11 @@ TYPED_TEST(MasterAllocatorTest, SingleFramework)
// reoffered appropriately.
TYPED_TEST(MasterAllocatorTest, ResourcesUnused)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
+
+ EXPECT_CALL(allocator, initialize(_, _, _));
- Try<PID<Master> > master = this->StartMaster(&this->allocator);
+ Try<PID<Master>> master = this->StartMaster(&allocator);
ASSERT_SOME(master);
MockExecutor exec(DEFAULT_EXECUTOR_ID);
@@ -145,7 +144,7 @@ TYPED_TEST(MasterAllocatorTest, ResourcesUnused)
slave::Flags flags1 = this->CreateSlaveFlags();
flags1.resources = Some("cpus:2;mem:1024");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
Try<PID<Slave> > slave1 = this->StartSlave(&exec, flags1);
ASSERT_SOME(slave1);
@@ -154,7 +153,7 @@ TYPED_TEST(MasterAllocatorTest, ResourcesUnused)
MesosSchedulerDriver driver1(
&sched1, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
EXPECT_CALL(sched1, registered(_, _, _));
@@ -172,8 +171,8 @@ TYPED_TEST(MasterAllocatorTest, ResourcesUnused)
.WillOnce(LaunchTasks(DEFAULT_EXECUTOR_INFO, 1, 1, 512, "*"));
Future<Nothing> recoverResources;
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
- .WillOnce(DoAll(InvokeRecoverResources(&this->allocator),
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
+ .WillOnce(DoAll(InvokeRecoverResources(&allocator),
FutureSatisfy(&recoverResources)));
EXPECT_CALL(exec, registered(_, _, _, _));
@@ -200,7 +199,7 @@ TYPED_TEST(MasterAllocatorTest, ResourcesUnused)
MesosSchedulerDriver driver2(
&sched2, frameworkInfo2, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
EXPECT_CALL(sched2, registered(_, _, _));
@@ -215,7 +214,7 @@ TYPED_TEST(MasterAllocatorTest, ResourcesUnused)
AWAIT_READY(resourceOffers);
// Shut everything down.
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
.WillRepeatedly(DoDefault());
Future<Nothing> shutdown;
@@ -239,15 +238,17 @@ TYPED_TEST(MasterAllocatorTest, ResourcesUnused)
// recoverResources is called for an already removed framework.
TYPED_TEST(MasterAllocatorTest, OutOfOrderDispatch)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
- Try<PID<Master> > master = this->StartMaster(&this->allocator);
+ EXPECT_CALL(allocator, initialize(_, _, _));
+
+ Try<PID<Master>> master = this->StartMaster(&allocator);
ASSERT_SOME(master);
slave::Flags flags1 = this->CreateSlaveFlags();
flags1.resources = Some("cpus:2;mem:1024");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
Try<PID<Slave> > slave1 = this->StartSlave(flags1);
ASSERT_SOME(slave1);
@@ -261,8 +262,8 @@ TYPED_TEST(MasterAllocatorTest, OutOfOrderDispatch)
MesosSchedulerDriver driver1(
&sched1, frameworkInfo1, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, Eq(frameworkInfo1), _))
- .WillOnce(InvokeAddFramework(&this->allocator));
+ EXPECT_CALL(allocator, addFramework(_, Eq(frameworkInfo1), _))
+ .WillOnce(InvokeAddFramework(&allocator));
Future<FrameworkID> frameworkId1;
EXPECT_CALL(sched1, registered(_, _, _))
@@ -285,18 +286,18 @@ TYPED_TEST(MasterAllocatorTest, OutOfOrderDispatch)
// framework has terminated or is inactive.
Future<SlaveID> slaveId;
Future<Resources> savedResources;
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
// "Catches" the recoverResources call from the master, so
// that it doesn't get processed until we redispatch it after
// the removeFramework trigger.
.WillOnce(DoAll(FutureArg<1>(&slaveId),
FutureArg<2>(&savedResources)));
- EXPECT_CALL(this->allocator, deactivateFramework(_));
+ EXPECT_CALL(allocator, deactivateFramework(_));
Future<Nothing> removeFramework;
- EXPECT_CALL(this->allocator, removeFramework(Eq(frameworkId1.get())))
- .WillOnce(DoAll(InvokeRemoveFramework(&this->allocator),
+ EXPECT_CALL(allocator, removeFramework(Eq(frameworkId1.get())))
+ .WillOnce(DoAll(InvokeRemoveFramework(&allocator),
FutureSatisfy(&removeFramework)));
driver1.stop();
@@ -306,13 +307,13 @@ TYPED_TEST(MasterAllocatorTest, OutOfOrderDispatch)
AWAIT_READY(slaveId);
AWAIT_READY(savedResources);
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
.WillOnce(DoDefault()); // For the re-dispatch.
// Re-dispatch the recoverResources call which we "caught"
// earlier now that the framework has been removed, to test
// that recovering resources from a removed framework works.
- this->allocator.recoverResources(
+ allocator.recoverResources(
frameworkId1.get(),
slaveId.get(),
savedResources.get(),
@@ -330,8 +331,8 @@ TYPED_TEST(MasterAllocatorTest, OutOfOrderDispatch)
MesosSchedulerDriver driver2(
&sched2, frameworkInfo2, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, Eq(frameworkInfo2), _))
- .WillOnce(InvokeAddFramework(&this->allocator));
+ EXPECT_CALL(allocator, addFramework(_, Eq(frameworkInfo2), _))
+ .WillOnce(InvokeAddFramework(&allocator));
FrameworkID frameworkId2;
EXPECT_CALL(sched2, registered(_, _, _))
@@ -347,11 +348,11 @@ TYPED_TEST(MasterAllocatorTest, OutOfOrderDispatch)
AWAIT_READY(resourceOffers);
// Called when driver2 stops.
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
.WillRepeatedly(DoDefault());
- EXPECT_CALL(this->allocator, deactivateFramework(_))
+ EXPECT_CALL(allocator, deactivateFramework(_))
.WillRepeatedly(DoDefault());
- EXPECT_CALL(this->allocator, removeFramework(_))
+ EXPECT_CALL(allocator, removeFramework(_))
.WillRepeatedly(DoDefault());
// Shut everything down.
@@ -367,9 +368,11 @@ TYPED_TEST(MasterAllocatorTest, OutOfOrderDispatch)
// is running.
TYPED_TEST(MasterAllocatorTest, SchedulerFailover)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
+
+ EXPECT_CALL(allocator, initialize(_, _, _));
- Try<PID<Master> > master = this->StartMaster(&this->allocator);
+ Try<PID<Master>> master = this->StartMaster(&allocator);
ASSERT_SOME(master);
MockExecutor exec(DEFAULT_EXECUTOR_ID);
@@ -377,7 +380,7 @@ TYPED_TEST(MasterAllocatorTest, SchedulerFailover)
slave::Flags flags = this->CreateSlaveFlags();
flags.resources = Some("cpus:3;mem:1024");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
Try<PID<Slave> > slave = this->StartSlave(&exec, flags);
ASSERT_SOME(slave);
@@ -393,7 +396,7 @@ TYPED_TEST(MasterAllocatorTest, SchedulerFailover)
MesosSchedulerDriver driver1(
&sched1, frameworkInfo1, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
FrameworkID frameworkId;
EXPECT_CALL(sched1, registered(&driver1, _, _))
@@ -412,10 +415,10 @@ TYPED_TEST(MasterAllocatorTest, SchedulerFailover)
// We don't filter the unused resources to make sure that
// they get offered to the framework as soon as it fails over.
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
- .WillOnce(InvokeRecoverResourcesWithFilters(&this->allocator, 0))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
+ .WillOnce(InvokeRecoverResourcesWithFilters(&allocator, 0))
// For subsequent offers.
- .WillRepeatedly(InvokeRecoverResourcesWithFilters(&this->allocator, 0));
+ .WillRepeatedly(InvokeRecoverResourcesWithFilters(&allocator, 0));
EXPECT_CALL(exec, registered(_, _, _, _));
@@ -435,8 +438,8 @@ TYPED_TEST(MasterAllocatorTest, SchedulerFailover)
DROP_PROTOBUFS(UnregisterFrameworkMessage(), _, _);
Future<Nothing> deactivateFramework;
- EXPECT_CALL(this->allocator, deactivateFramework(_))
- .WillOnce(DoAll(InvokeDeactivateFramework(&this->allocator),
+ EXPECT_CALL(allocator, deactivateFramework(_))
+ .WillOnce(DoAll(InvokeDeactivateFramework(&allocator),
FutureSatisfy(&deactivateFramework)));
driver1.stop();
@@ -453,7 +456,7 @@ TYPED_TEST(MasterAllocatorTest, SchedulerFailover)
MesosSchedulerDriver driver2(
&sched2, frameworkInfo2, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, activateFramework(_));
+ EXPECT_CALL(allocator, activateFramework(_));
EXPECT_CALL(sched2, registered(_, frameworkId, _));
@@ -472,10 +475,10 @@ TYPED_TEST(MasterAllocatorTest, SchedulerFailover)
.Times(AtMost(1));
// Shut everything down.
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
.WillRepeatedly(DoDefault());
- EXPECT_CALL(this->allocator, deactivateFramework(_))
+ EXPECT_CALL(allocator, deactivateFramework(_))
.Times(AtMost(1));
driver2.stop();
@@ -489,11 +492,13 @@ TYPED_TEST(MasterAllocatorTest, SchedulerFailover)
// is killed, the tasks resources are returned and reoffered correctly.
TYPED_TEST(MasterAllocatorTest, FrameworkExited)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
+
+ EXPECT_CALL(allocator, initialize(_, _, _));
master::Flags masterFlags = this->CreateMasterFlags();
masterFlags.allocation_interval = Milliseconds(50);
- Try<PID<Master> > master = this->StartMaster(&this->allocator, masterFlags);
+ Try<PID<Master>> master = this->StartMaster(&allocator, masterFlags);
ASSERT_SOME(master);
ExecutorInfo executor1; // Bug in gcc 4.1.*, must assign on next line.
@@ -514,7 +519,7 @@ TYPED_TEST(MasterAllocatorTest, FrameworkExited)
slave::Flags flags = this->CreateSlaveFlags();
flags.resources = Some("cpus:3;mem:1024");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
Try<PID<Slave> > slave = this->StartSlave(&containerizer, flags);
ASSERT_SOME(slave);
@@ -523,7 +528,7 @@ TYPED_TEST(MasterAllocatorTest, FrameworkExited)
MesosSchedulerDriver driver1(
&sched1, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
EXPECT_CALL(sched1, registered(_, _, _));
@@ -541,8 +546,8 @@ TYPED_TEST(MasterAllocatorTest, FrameworkExited)
// The framework does not use all the resources.
Future<Nothing> recoverResources;
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
- .WillOnce(DoAll(InvokeRecoverResources(&this->allocator),
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
+ .WillOnce(DoAll(InvokeRecoverResources(&allocator),
FutureSatisfy(&recoverResources)));
EXPECT_CALL(exec1, registered(_, _, _, _));
@@ -567,7 +572,7 @@ TYPED_TEST(MasterAllocatorTest, FrameworkExited)
MesosSchedulerDriver driver2(
&sched2, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
EXPECT_CALL(sched2, registered(_, _, _));
@@ -585,8 +590,8 @@ TYPED_TEST(MasterAllocatorTest, FrameworkExited)
// The framework 2 does not use all the resources.
Future<Nothing> recoverResources2;
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
- .WillOnce(DoAll(InvokeRecoverResources(&this->allocator),
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
+ .WillOnce(DoAll(InvokeRecoverResources(&allocator),
FutureSatisfy(&recoverResources2)));
EXPECT_CALL(exec2, registered(_, _, _, _));
@@ -602,7 +607,7 @@ TYPED_TEST(MasterAllocatorTest, FrameworkExited)
// Shut everything down but check that framework 2 gets the
// resources from framework 1 after it is shutdown.
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
.WillRepeatedly(DoDefault());
// After we stop framework 1, all of it's resources should
@@ -636,9 +641,11 @@ TYPED_TEST(MasterAllocatorTest, FrameworkExited)
// slave, never offered again.
TYPED_TEST(MasterAllocatorTest, SlaveLost)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
+
+ EXPECT_CALL(allocator, initialize(_, _, _));
- Try<PID<Master> > master = this->StartMaster(&this->allocator);
+ Try<PID<Master>> master = this->StartMaster(&allocator);
ASSERT_SOME(master);
MockExecutor exec(DEFAULT_EXECUTOR_ID);
@@ -646,7 +653,7 @@ TYPED_TEST(MasterAllocatorTest, SlaveLost)
slave::Flags flags1 = this->CreateSlaveFlags();
flags1.resources = Some("cpus:2;mem:1024");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
Try<PID<Slave> > slave1 = this->StartSlave(&exec, flags1);
ASSERT_SOME(slave1);
@@ -655,7 +662,7 @@ TYPED_TEST(MasterAllocatorTest, SlaveLost)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
EXPECT_CALL(sched, registered(_, _, _));
@@ -664,8 +671,8 @@ TYPED_TEST(MasterAllocatorTest, SlaveLost)
.WillOnce(LaunchTasks(DEFAULT_EXECUTOR_INFO, 1, 2, 512, "*"));
Future<Nothing> recoverResources;
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
- .WillOnce(DoAll(InvokeRecoverResources(&this->allocator),
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
+ .WillOnce(DoAll(InvokeRecoverResources(&allocator),
FutureSatisfy(&recoverResources)));
EXPECT_CALL(exec, registered(_, _, _, _));
@@ -691,12 +698,12 @@ TYPED_TEST(MasterAllocatorTest, SlaveLost)
// 'recoverResources' should be called twice, once for the task
// and once for the executor.
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
.Times(2);
Future<Nothing> removeSlave;
- EXPECT_CALL(this->allocator, removeSlave(_))
- .WillOnce(DoAll(InvokeRemoveSlave(&this->allocator),
+ EXPECT_CALL(allocator, removeSlave(_))
+ .WillOnce(DoAll(InvokeRemoveSlave(&allocator),
FutureSatisfy(&removeSlave)));
EXPECT_CALL(exec, shutdown(_))
@@ -713,7 +720,7 @@ TYPED_TEST(MasterAllocatorTest, SlaveLost)
slave::Flags flags2 = this->CreateSlaveFlags();
flags2.resources = string("cpus:3;mem:256;disk:1024;ports:[31000-32000]");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
// Eventually after slave2 is launched, we should get
// an offer that contains all of slave2's resources
@@ -731,13 +738,13 @@ TYPED_TEST(MasterAllocatorTest, SlaveLost)
Resources::parse(flags2.resources.get()).get());
// Shut everything down.
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
.WillRepeatedly(DoDefault());
driver.stop();
driver.join();
- EXPECT_CALL(this->allocator, removeSlave(_))
+ EXPECT_CALL(allocator, removeSlave(_))
.Times(AtMost(1));
this->Shutdown();
@@ -749,11 +756,13 @@ TYPED_TEST(MasterAllocatorTest, SlaveLost)
// resources and offered appropriately.
TYPED_TEST(MasterAllocatorTest, SlaveAdded)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
+
+ EXPECT_CALL(allocator, initialize(_, _, _));
master::Flags masterFlags = this->CreateMasterFlags();
masterFlags.allocation_interval = Milliseconds(50);
- Try<PID<Master> > master = this->StartMaster(&this->allocator, masterFlags);
+ Try<PID<Master>> master = this->StartMaster(&allocator, masterFlags);
ASSERT_SOME(master);
MockExecutor exec(DEFAULT_EXECUTOR_ID);
@@ -761,7 +770,7 @@ TYPED_TEST(MasterAllocatorTest, SlaveAdded)
slave::Flags flags1 = this->CreateSlaveFlags();
flags1.resources = Some("cpus:3;mem:1024");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
Try<PID<Slave> > slave1 = this->StartSlave(&exec, flags1);
ASSERT_SOME(slave1);
@@ -770,7 +779,7 @@ TYPED_TEST(MasterAllocatorTest, SlaveAdded)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
EXPECT_CALL(sched, registered(_, _, _));
@@ -789,9 +798,9 @@ TYPED_TEST(MasterAllocatorTest, SlaveAdded)
// on slave1 from the task launch won't get reoffered
// immediately and will get combined with slave2's
// resources for a single offer.
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
- .WillOnce(InvokeRecoverResourcesWithFilters(&this->allocator, 0.1))
- .WillRepeatedly(InvokeRecoverResourcesWithFilters(&this->allocator, 0));
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
+ .WillOnce(InvokeRecoverResourcesWithFilters(&allocator, 0.1))
+ .WillRepeatedly(InvokeRecoverResourcesWithFilters(&allocator, 0));
EXPECT_CALL(exec, registered(_, _, _, _));
@@ -810,7 +819,7 @@ TYPED_TEST(MasterAllocatorTest, SlaveAdded)
slave::Flags flags2 = this->CreateSlaveFlags();
flags2.resources = Some("cpus:4;mem:2048");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
// After slave2 launches, all of its resources are combined with the
// resources on slave1 that the task isn't using.
@@ -827,7 +836,7 @@ TYPED_TEST(MasterAllocatorTest, SlaveAdded)
.Times(AtMost(1));
// Shut everything down.
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
.WillRepeatedly(DoDefault());
driver.stop();
@@ -841,11 +850,13 @@ TYPED_TEST(MasterAllocatorTest, SlaveAdded)
// resources are recovered and reoffered correctly.
TYPED_TEST(MasterAllocatorTest, TaskFinished)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
+
+ EXPECT_CALL(allocator, initialize(_, _, _));
master::Flags masterFlags = this->CreateMasterFlags();
masterFlags.allocation_interval = Milliseconds(50);
- Try<PID<Master> > master = this->StartMaster(&this->allocator, masterFlags);
+ Try<PID<Master>> master = this->StartMaster(&allocator, masterFlags);
ASSERT_SOME(master);
MockExecutor exec(DEFAULT_EXECUTOR_ID);
@@ -853,7 +864,7 @@ TYPED_TEST(MasterAllocatorTest, TaskFinished)
slave::Flags flags = this->CreateSlaveFlags();
flags.resources = Some("cpus:3;mem:1024");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
Try<PID<Slave> > slave = this->StartSlave(&exec, flags);
ASSERT_SOME(slave);
@@ -862,7 +873,7 @@ TYPED_TEST(MasterAllocatorTest, TaskFinished)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
EXPECT_CALL(sched, registered(_, _, _));
@@ -882,8 +893,8 @@ TYPED_TEST(MasterAllocatorTest, TaskFinished)
// allocator knows about the unused resources so that it can
// aggregate them with the resources from the finished task.
Future<Nothing> recoverResources;
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
- .WillRepeatedly(DoAll(InvokeRecoverResources(&this->allocator),
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
+ .WillRepeatedly(DoAll(InvokeRecoverResources(&allocator),
FutureSatisfy(&recoverResources)));
EXPECT_CALL(exec, registered(_, _, _, _));
@@ -911,7 +922,7 @@ TYPED_TEST(MasterAllocatorTest, TaskFinished)
status.mutable_task_id()->MergeFrom(taskInfo.task_id());
status.set_state(TASK_FINISHED);
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _));
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _));
// After the first task gets killed.
Future<Nothing> resourceOffers;
@@ -926,7 +937,7 @@ TYPED_TEST(MasterAllocatorTest, TaskFinished)
.Times(AtMost(1));
// Shut everything down.
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
.WillRepeatedly(DoDefault());
driver.stop();
@@ -940,11 +951,13 @@ TYPED_TEST(MasterAllocatorTest, TaskFinished)
// and tasks using only cpus are launched.
TYPED_TEST(MasterAllocatorTest, CpusOnlyOfferedAndTaskLaunched)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
+
+ EXPECT_CALL(allocator, initialize(_, _, _));
master::Flags masterFlags = this->CreateMasterFlags();
masterFlags.allocation_interval = Milliseconds(50);
- Try<PID<Master> > master = this->StartMaster(&this->allocator, masterFlags);
+ Try<PID<Master>> master = this->StartMaster(&allocator, masterFlags);
ASSERT_SOME(master);
MockExecutor exec(DEFAULT_EXECUTOR_ID);
@@ -953,7 +966,7 @@ TYPED_TEST(MasterAllocatorTest, CpusOnlyOfferedAndTaskLaunched)
slave::Flags flags = this->CreateSlaveFlags();
flags.resources = Some("cpus:2;mem:0");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
Try<PID<Slave> > slave = this->StartSlave(&exec, flags);
ASSERT_SOME(slave);
@@ -962,7 +975,7 @@ TYPED_TEST(MasterAllocatorTest, CpusOnlyOfferedAndTaskLaunched)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
EXPECT_CALL(sched, registered(_, _, _));
@@ -1016,11 +1029,13 @@ TYPED_TEST(MasterAllocatorTest, CpusOnlyOfferedAndTaskLaunched)
// and tasks using only memory are launched.
TYPED_TEST(MasterAllocatorTest, MemoryOnlyOfferedAndTaskLaunched)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
+
+ EXPECT_CALL(allocator, initialize(_, _, _));
master::Flags masterFlags = this->CreateMasterFlags();
masterFlags.allocation_interval = Milliseconds(50);
- Try<PID<Master> > master = this->StartMaster(&this->allocator, masterFlags);
+ Try<PID<Master>> master = this->StartMaster(&allocator, masterFlags);
ASSERT_SOME(master);
MockExecutor exec(DEFAULT_EXECUTOR_ID);
@@ -1029,7 +1044,7 @@ TYPED_TEST(MasterAllocatorTest, MemoryOnlyOfferedAndTaskLaunched)
slave::Flags flags = this->CreateSlaveFlags();
flags.resources = Some("cpus:0;mem:200");
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
Try<PID<Slave> > slave = this->StartSlave(&exec, flags);
ASSERT_SOME(slave);
@@ -1038,7 +1053,7 @@ TYPED_TEST(MasterAllocatorTest, MemoryOnlyOfferedAndTaskLaunched)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
EXPECT_CALL(sched, registered(_, _, _));
@@ -1105,14 +1120,16 @@ TYPED_TEST(MasterAllocatorTest, Whitelist)
master::Flags masterFlags = this->CreateMasterFlags();
masterFlags.whitelist = path;
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
+
+ EXPECT_CALL(allocator, initialize(_, _, _));
Future<Nothing> updateWhitelist1;
- EXPECT_CALL(this->allocator, updateWhitelist(Option<hashset<string>>(hosts)))
- .WillOnce(DoAll(InvokeUpdateWhitelist(&this->allocator),
+ EXPECT_CALL(allocator, updateWhitelist(Option<hashset<string>>(hosts)))
+ .WillOnce(DoAll(InvokeUpdateWhitelist(&allocator),
FutureSatisfy(&updateWhitelist1)));
- Try<PID<Master> > master = this->StartMaster(&this->allocator, masterFlags);
+ Try<PID<Master>> master = this->StartMaster(&allocator, masterFlags);
ASSERT_SOME(master);
// Make sure the allocator has been given the initial whitelist.
@@ -1123,8 +1140,8 @@ TYPED_TEST(MasterAllocatorTest, Whitelist)
hosts.insert("dummy-slave2");
Future<Nothing> updateWhitelist2;
- EXPECT_CALL(this->allocator, updateWhitelist(Option<hashset<string>>(hosts)))
- .WillOnce(DoAll(InvokeUpdateWhitelist(&this->allocator),
+ EXPECT_CALL(allocator, updateWhitelist(Option<hashset<string>>(hosts)))
+ .WillOnce(DoAll(InvokeUpdateWhitelist(&allocator),
FutureSatisfy(&updateWhitelist2)));
ASSERT_SOME(os::write(path, strings::join("\n", hosts)));
@@ -1143,11 +1160,13 @@ TYPED_TEST(MasterAllocatorTest, Whitelist)
// master's command line flags.
TYPED_TEST(MasterAllocatorTest, RoleTest)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
+ TestAllocator<TypeParam> allocator;
+
+ EXPECT_CALL(allocator, initialize(_, _, _));
master::Flags masterFlags = this->CreateMasterFlags();
masterFlags.roles = Some("role2");
- Try<PID<Master> > master = this->StartMaster(&this->allocator, masterFlags);
+ Try<PID<Master>> master = this->StartMaster(&allocator, masterFlags);
ASSERT_SOME(master);
// Launch a framework with a role that doesn't exist to see that it
@@ -1187,7 +1206,7 @@ TYPED_TEST(MasterAllocatorTest, RoleTest)
.WillOnce(FutureSatisfy(®istered2));
Future<Nothing> addFramework;
- EXPECT_CALL(this->allocator, addFramework(_, _, _))
+ EXPECT_CALL(allocator, addFramework(_, _, _))
.WillOnce(FutureSatisfy(&addFramework));
driver2.start();
@@ -1197,11 +1216,11 @@ TYPED_TEST(MasterAllocatorTest, RoleTest)
// Shut everything down.
Future<Nothing> deactivateFramework;
- EXPECT_CALL(this->allocator, deactivateFramework(_))
+ EXPECT_CALL(allocator, deactivateFramework(_))
.WillOnce(FutureSatisfy(&deactivateFramework));
Future<Nothing> removeFramework;
- EXPECT_CALL(this->allocator, removeFramework(_))
+ EXPECT_CALL(allocator, removeFramework(_))
.WillOnce(FutureSatisfy(&removeFramework));
driver2.stop();
@@ -1223,110 +1242,122 @@ TYPED_TEST(MasterAllocatorTest, RoleTest)
// accounted for correctly.
TYPED_TEST(MasterAllocatorTest, FrameworkReregistersFirst)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
-
- Try<PID<Master> > master = this->StartMaster(&this->allocator);
- ASSERT_SOME(master);
-
+ // Objects that persist after the election of a new master.
+ StandaloneMasterDetector slaveDetector;
+ StandaloneMasterDetector schedulerDetector;
+ MockScheduler sched;
MockExecutor exec(DEFAULT_EXECUTOR_ID);
+ TestingMesosSchedulerDriver driver(&sched, &schedulerDetector);
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ // Explicit scope is to ensure all object associated with the
+ // leading master (e.g. allocator) are destroyed once the master
+ // is shut down. Otherwise subsequent (not expected) calls into
+ // Allocator::recoverResources() are possibly rendering tests flaky.
+ {
+ TestAllocator<TypeParam> allocator;
- StandaloneMasterDetector slaveDetector(master.get());
+ EXPECT_CALL(allocator, initialize(_, _, _));
- slave::Flags flags = this->CreateSlaveFlags();
- flags.resources = Some("cpus:2;mem:1024");
+ Try<PID<Master>> master = this->StartMaster(&allocator);
+ ASSERT_SOME(master);
+ slaveDetector.appoint(master.get());
+ schedulerDetector.appoint(master.get());
- Try<PID<Slave> > slave = this->StartSlave(&exec, &slaveDetector, flags);
- ASSERT_SOME(slave);
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ slave::Flags flags = this->CreateSlaveFlags();
+ flags.resources = Some("cpus:2;mem:1024");
- MockScheduler sched;
- StandaloneMasterDetector schedulerDetector(master.get());
- TestingMesosSchedulerDriver driver(&sched, &schedulerDetector);
+ Try<PID<Slave>> slave = this->StartSlave(&exec, &slaveDetector, flags);
+ ASSERT_SOME(slave);
- EXPECT_CALL(sched, registered(&driver, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
- // The framework should be offered all of the resources on the slave
- // since it is the only framework running.
- EXPECT_CALL(sched, resourceOffers(&driver, OfferEq(2, 1024)))
- .WillOnce(LaunchTasks(DEFAULT_EXECUTOR_INFO, 1, 1, 500, "*"))
- .WillRepeatedly(DeclineOffers());
+ EXPECT_CALL(sched, registered(&driver, _, _));
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _));
+ // The framework should be offered all of the resources on the
+ // slave since it is the only framework running.
+ EXPECT_CALL(sched, resourceOffers(&driver, OfferEq(2, 1024)))
+ .WillOnce(LaunchTasks(DEFAULT_EXECUTOR_INFO, 1, 1, 500, "*"))
+ .WillRepeatedly(DeclineOffers());
- EXPECT_CALL(exec, registered(_, _, _, _));
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _));
- EXPECT_CALL(exec, launchTask(_, _))
- .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));
+ EXPECT_CALL(exec, registered(_, _, _, _));
- Future<TaskStatus> status;
- EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&status));
+ EXPECT_CALL(exec, launchTask(_, _))
+ .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));
- Future<Nothing> _statusUpdateAcknowledgement =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
+ Future<TaskStatus> status;
+ EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&status));
- driver.start();
+ Future<Nothing> _statusUpdateAcknowledgement =
+ FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
- AWAIT_READY(status);
+ driver.start();
- EXPECT_EQ(TASK_RUNNING, status.get().state());
+ AWAIT_READY(status);
- // Make sure the slave handles status update acknowledgement so that
- // it doesn't try to retry the update after master failover.
- AWAIT_READY(_statusUpdateAcknowledgement);
+ EXPECT_EQ(TASK_RUNNING, status.get().state());
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
- .WillRepeatedly(DoDefault());
+ // Make sure the slave handles status update acknowledgement so
+ // that it doesn't try to retry the update after master failover.
+ AWAIT_READY(_statusUpdateAcknowledgement);
- this->ShutdownMasters();
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
+ .WillRepeatedly(DoDefault());
- TestAllocator<TypeParam> allocator2;
+ this->ShutdownMasters();
+ }
- EXPECT_CALL(allocator2, initialize(_, _, _));
+ {
+ TestAllocator<TypeParam> allocator2;
- Future<Nothing> addFramework;
- EXPECT_CALL(allocator2, addFramework(_, _, _))
- .WillOnce(DoAll(InvokeAddFramework(&allocator2),
- FutureSatisfy(&addFramework)));
+ EXPECT_CALL(allocator2, initialize(_, _, _));
- EXPECT_CALL(sched, registered(&driver, _, _));
+ Future<Nothing> addFramework;
+ EXPECT_CALL(allocator2, addFramework(_, _, _))
+ .WillOnce(DoAll(InvokeAddFramework(&allocator2),
+ FutureSatisfy(&addFramework)));
- Try<PID<Master> > master2 = this->StartMaster(&allocator2);
- ASSERT_SOME(master2);
+ EXPECT_CALL(sched, registered(&driver, _, _));
- EXPECT_CALL(sched, disconnected(_));
+ Try<PID<Master>> master2 = this->StartMaster(&allocator2);
+ ASSERT_SOME(master2);
- // Inform the scheduler about the new master.
- schedulerDetector.appoint(master2.get());
+ EXPECT_CALL(sched, disconnected(_));
- AWAIT_READY(addFramework);
+ // Inform the scheduler about the new master.
+ schedulerDetector.appoint(master2.get());
- EXPECT_CALL(allocator2, addSlave(_, _, _, _));
+ AWAIT_READY(addFramework);
- Future<vector<Offer> > resourceOffers2;
- EXPECT_CALL(sched, resourceOffers(&driver, _))
- .WillOnce(FutureArg<1>(&resourceOffers2));
+ EXPECT_CALL(allocator2, addSlave(_, _, _, _));
- // Inform the slave about the new master.
- slaveDetector.appoint(master2.get());
+ Future<vector<Offer>> resourceOffers2;
+ EXPECT_CALL(sched, resourceOffers(&driver, _))
+ .WillOnce(FutureArg<1>(&resourceOffers2));
- AWAIT_READY(resourceOffers2);
+ // Inform the slave about the new master.
+ slaveDetector.appoint(master2.get());
- // Since the task is still running on the slave, the framework
- // should only be offered the resources not being used by the task.
- EXPECT_THAT(resourceOffers2.get(), OfferEq(1, 524));
+ AWAIT_READY(resourceOffers2);
- EXPECT_CALL(exec, shutdown(_))
- .Times(AtMost(1));
+ // Since the task is still running on the slave, the framework
+ // should only be offered the resources not being used by the
+ // task.
+ EXPECT_THAT(resourceOffers2.get(), OfferEq(1, 524));
- // Shut everything down.
- driver.stop();
- driver.join();
+ EXPECT_CALL(exec, shutdown(_))
+ .Times(AtMost(1));
- this->Shutdown();
+ // Shut everything down.
+ driver.stop();
+ driver.join();
+
+ this->Shutdown();
+ }
}
@@ -1336,109 +1367,121 @@ TYPED_TEST(MasterAllocatorTest, FrameworkReregistersFirst)
// accounted for correctly.
TYPED_TEST(MasterAllocatorTest, SlaveReregistersFirst)
{
- EXPECT_CALL(this->allocator, initialize(_, _, _));
-
- Try<PID<Master> > master = this->StartMaster(&this->allocator);
- ASSERT_SOME(master);
-
+ // Objects that persist after the election of a new master.
+ StandaloneMasterDetector slaveDetector;
+ StandaloneMasterDetector schedulerDetector;
+ MockScheduler sched;
MockExecutor exec(DEFAULT_EXECUTOR_ID);
- StandaloneMasterDetector slaveDetector(master.get());
+ TestingMesosSchedulerDriver driver(&sched, &schedulerDetector);
- EXPECT_CALL(this->allocator, addSlave(_, _, _, _));
+ // Explicit scope is to ensure all object associated with the
+ // leading master (e.g. allocator) are destroyed once the master
+ // is shut down. Otherwise subsequent (not expected) calls into
+ // Allocator::recoverResources() are possibly rendering tests flaky.
+ {
+ TestAllocator<TypeParam> allocator;
- slave::Flags flags = this->CreateSlaveFlags();
- flags.resources = Some("cpus:2;mem:1024");
+ EXPECT_CALL(allocator, initialize(_, _, _));
- Try<PID<Slave> > slave = this->StartSlave(&exec, &slaveDetector, flags);
- ASSERT_SOME(slave);
+ Try<PID<Master>> master = this->StartMaster(&allocator);
+ ASSERT_SOME(master);
+ slaveDetector.appoint(master.get());
+ schedulerDetector.appoint(master.get());
- MockScheduler sched;
- StandaloneMasterDetector schedulerDetector(master.get());
- TestingMesosSchedulerDriver driver(&sched, &schedulerDetector);
+ EXPECT_CALL(allocator, addSlave(_, _, _, _));
- EXPECT_CALL(this->allocator, addFramework(_, _, _));
+ slave::Flags flags = this->CreateSlaveFlags();
+ flags.resources = Some("cpus:2;mem:1024");
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _));
+ Try<PID<Slave>> slave = this->StartSlave(&exec, &slaveDetector, flags);
+ ASSERT_SOME(slave);
- EXPECT_CALL(sched, registered(&driver, _, _));
+ EXPECT_CALL(allocator, addFramework(_, _, _));
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _));
- // The framework should be offered all of the resources on the slave
- // since it is the only framework running.
- EXPECT_CALL(sched, resourceOffers(&driver, OfferEq(2, 1024)))
- .WillOnce(LaunchTasks(DEFAULT_EXECUTOR_INFO, 1, 1, 500, "*"))
- .WillRepeatedly(DeclineOffers());
+ EXPECT_CALL(sched, registered(&driver, _, _));
- EXPECT_CALL(exec, registered(_, _, _, _));
+ // The framework should be offered all of the resources on the
+ // slave since it is the only framework running.
+ EXPECT_CALL(sched, resourceOffers(&driver, OfferEq(2, 1024)))
+ .WillOnce(LaunchTasks(DEFAULT_EXECUTOR_INFO, 1, 1, 500, "*"))
+ .WillRepeatedly(DeclineOffers());
- EXPECT_CALL(exec, launchTask(_, _))
- .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));
+ EXPECT_CALL(exec, registered(_, _, _, _));
- Future<TaskStatus> status;
- EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&status));
+ EXPECT_CALL(exec, launchTask(_, _))
+ .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));
- Future<Nothing> _statusUpdateAcknowledgement =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
+ Future<TaskStatus> status;
+ EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&status));
- driver.start();
+ Future<Nothing> _statusUpdateAcknowledgement =
+ FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
- AWAIT_READY(status);
+ driver.start();
- EXPECT_EQ(TASK_RUNNING, status.get().state());
+ AWAIT_READY(status);
- // Make sure the slave handles status update acknowledgement so that
- // it doesn't try to retry the update after master failover.
- AWAIT_READY(_statusUpdateAcknowledgement);
+ EXPECT_EQ(TASK_RUNNING, status.get().state());
- EXPECT_CALL(this->allocator, recoverResources(_, _, _, _))
- .WillRepeatedly(DoDefault());
+ // Make sure the slave handles status update acknowledgement so
+ // that it doesn't try to retry the update after master failover.
+ AWAIT_READY(_statusUpdateAcknowledgement);
- this->ShutdownMasters();
+ EXPECT_CALL(allocator, recoverResources(_, _, _, _))
+ .WillRepeatedly(DoDefault());
- TestAllocator<TypeParam> allocator2;
+ this->ShutdownMasters();
+ }
- EXPECT_CALL(allocator2, initialize(_, _, _));
+ {
+ TestAllocator<TypeParam> allocator2;
- Future<Nothing> addSlave;
- EXPECT_CALL(allocator2, addSlave(_, _, _, _))
- .WillOnce(DoAll(InvokeAddSlave(&allocator2),
- FutureSatisfy(&addSlave)));
+ EXPECT_CALL(allocator2, initialize(_, _, _));
- Try<PID<Master> > master2 = this->StartMaster(&allocator2);
- ASSERT_SOME(master2);
+ Future<Nothing> addSlave;
+ EXPECT_CALL(allocator2, addSlave(_, _, _, _))
+ .WillOnce(DoAll(InvokeAddSlave(&allocator2),
+ FutureSatisfy(&addSlave)));
- // Inform the slave about the new master.
- slaveDetector.appoint(master2.get());
+ Try<PID<Master>> master2 = this->StartMaster(&allocator2);
+ ASSERT_SOME(master2);
- AWAIT_READY(addSlave);
+ // Inform the slave about the new master.
+ slaveDetector.appoint(master2.get());
- EXPECT_CALL(sched, disconnected(_));
+ AWAIT_READY(addSlave);
- EXPECT_CALL(sched, registered(&driver, _, _));
+ EXPECT_CALL(sched, disconnected(_));
- EXPECT_CALL(allocator2, addFramework(_, _, _));
+ EXPECT_CALL(sched, registered(&driver, _, _));
- Future<vector<Offer> > resourceOffers2;
- EXPECT_CALL(sched, resourceOffers(&driver, _))
- .WillOnce(FutureArg<1>(&resourceOffers2));
+ EXPECT_CALL(allocator2, addFramework(_, _, _));
- // Inform the scheduler about the new master.
- schedulerDetector.appoint(master2.get());
+ Future<vector<Offer>> resourceOffers2;
+ EXPECT_CALL(sched, resourceOffers(&driver, _))
+ .WillOnce(FutureArg<1>(&resourceOffers2));
- AWAIT_READY(resourceOffers2);
+ // Inform the scheduler about the new master.
+ schedulerDetector.appoint(master2.get());
- // Since the task is still running on the slave, the framework
- // should only be offered the resources not being used by the task.
- EXPECT_THAT(resourceOffers2.get(), OfferEq(1, 524));
+ AWAIT_READY(resourceOffers2);
- EXPECT_CALL(exec, shutdown(_))
- .Times(AtMost(1));
+ // Since the task is still running on the slave, the framework
+ // should only be offered the resources not being used by the
+ // task.
+ EXPECT_THAT(resourceOffers2.get(), OfferEq(1, 524));
- // Shut everything down.
- driver.stop();
- driver.join();
+ EXPECT_CALL(exec, shutdown(_))
+ .Times(AtMost(1));
- this->Shutdown();
+ // Shut everything down.
+ driver.stop();
+ driver.join();
+
+ this->Shutdown();
+ }
}
} // namespace tests {
http://git-wip-us.apache.org/repos/asf/mesos/blob/ab48d54c/src/tests/mesos.hpp
----------------------------------------------------------------------
diff --git a/src/tests/mesos.hpp b/src/tests/mesos.hpp
index bab45ce..f23fdcb 100644
--- a/src/tests/mesos.hpp
+++ b/src/tests/mesos.hpp
@@ -53,6 +53,8 @@
#include "master/detector.hpp"
#include "master/master.hpp"
+#include "master/allocator/mesos/hierarchical.hpp"
+
#include "slave/slave.hpp"
#include "slave/containerizer/containerizer.hpp"
@@ -765,79 +767,79 @@ public:
ACTION_P(InvokeInitialize, allocator)
{
- allocator->real.initialize(arg0, arg1, arg2);
+ allocator->real->initialize(arg0, arg1, arg2);
}
ACTION_P(InvokeAddFramework, allocator)
{
- allocator->real.addFramework(arg0, arg1, arg2);
+ allocator->real->addFramework(arg0, arg1, arg2);
}
ACTION_P(InvokeRemoveFramework, allocator)
{
- allocator->real.removeFramework(arg0);
+ allocator->real->removeFramework(arg0);
}
ACTION_P(InvokeActivateFramework, allocator)
{
- allocator->real.activateFramework(arg0);
+ allocator->real->activateFramework(arg0);
}
ACTION_P(InvokeDeactivateFramework, allocator)
{
- allocator->real.deactivateFramework(arg0);
+ allocator->real->deactivateFramework(arg0);
}
ACTION_P(InvokeAddSlave, allocator)
{
- allocator->real.addSlave(arg0, arg1, arg2, arg3);
+ allocator->real->addSlave(arg0, arg1, arg2, arg3);
}
ACTION_P(InvokeRemoveSlave, allocator)
{
- allocator->real.removeSlave(arg0);
+ allocator->real->removeSlave(arg0);
}
ACTION_P(InvokeActivateSlave, allocator)
{
- allocator->real.activateSlave(arg0);
+ allocator->real->activateSlave(arg0);
}
ACTION_P(InvokeDeactivateSlave, allocator)
{
- allocator->real.deactivateSlave(arg0);
+ allocator->real->deactivateSlave(arg0);
}
ACTION_P(InvokeUpdateWhitelist, allocator)
{
- allocator->real.updateWhitelist(arg0);
+ allocator->real->updateWhitelist(arg0);
}
ACTION_P(InvokeRequestResources, allocator)
{
- allocator->real.requestResources(arg0, arg1);
+ allocator->real->requestResources(arg0, arg1);
}
ACTION_P(InvokeUpdateAllocation, allocator)
{
- allocator->real.updateAllocation(arg0, arg1, arg2);
+ allocator->real->updateAllocation(arg0, arg1, arg2);
}
ACTION_P(InvokeRecoverResources, allocator)
{
- allocator->real.recoverResources(arg0, arg1, arg2, arg3);
+ allocator->real->recoverResources(arg0, arg1, arg2, arg3);
}
@@ -846,21 +848,24 @@ ACTION_P2(InvokeRecoverResourcesWithFilters, allocator, timeout)
Filters filters;
filters.set_refuse_seconds(timeout);
- allocator->real.recoverResources(arg0, arg1, arg2, filters);
+ allocator->real->recoverResources(arg0, arg1, arg2, filters);
}
ACTION_P(InvokeReviveOffers, allocator)
{
- allocator->real.reviveOffers(arg0);
+ allocator->real->reviveOffers(arg0);
}
-template <typename T = mesos::master::allocator::Allocator>
+template <typename T = master::allocator::HierarchicalDRFAllocator>
class TestAllocator : public mesos::master::allocator::Allocator
{
public:
+ // Actual allocation is done by an instance of real allocator,
+ // which is specified by the template parameter.
TestAllocator()
+ : real(new master::allocator::HierarchicalDRFAllocator())
{
// We use 'ON_CALL' and 'WillByDefault' here to specify the
// default actions (call in to the real allocator). This allows
@@ -942,7 +947,7 @@ public:
.WillRepeatedly(DoDefault());
}
- ~TestAllocator() {}
+ virtual ~TestAllocator() {}
MOCK_METHOD3(initialize, void(
const Duration&,
@@ -1000,7 +1005,7 @@ public:
MOCK_METHOD1(reviveOffers, void(const FrameworkID&));
- T real;
+ process::Owned<mesos::master::allocator::Allocator> real;
};
http://git-wip-us.apache.org/repos/asf/mesos/blob/ab48d54c/src/tests/slave_recovery_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/slave_recovery_tests.cpp b/src/tests/slave_recovery_tests.cpp
index 87f4a6a..713be8f 100644
--- a/src/tests/slave_recovery_tests.cpp
+++ b/src/tests/slave_recovery_tests.cpp
@@ -44,6 +44,8 @@
#include "master/detector.hpp"
#include "master/master.hpp"
+#include "master/allocator/mesos/hierarchical.hpp"
+
#include "slave/gc.hpp"
#include "slave/paths.hpp"
#include "slave/slave.hpp"