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 <[email protected]> Authored: Tue Apr 21 12:11:37 2015 -0700 Committer: Niklas Q. Nielsen <[email protected]> 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"
