You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mesos.apache.org by vi...@apache.org on 2013/11/19 19:57:48 UTC

[7/8] Replaced usage of old detector with new Master contender and detector abstractions.

http://git-wip-us.apache.org/repos/asf/mesos/blob/f9d1dd81/src/tests/cluster.hpp
----------------------------------------------------------------------
diff --git a/src/tests/cluster.hpp b/src/tests/cluster.hpp
index bea395a..fa64ed1 100644
--- a/src/tests/cluster.hpp
+++ b/src/tests/cluster.hpp
@@ -33,11 +33,11 @@
 #include <stout/path.hpp>
 #include <stout/try.hpp>
 
-#include "detector/detector.hpp"
-
 #include "files/files.hpp"
 
 #include "master/allocator.hpp"
+#include "master/contender.hpp"
+#include "master/detector.hpp"
 #include "master/hierarchical_allocator_process.hpp"
 #include "master/flags.hpp"
 #include "master/master.hpp"
@@ -90,9 +90,7 @@ public:
     Try<Nothing> stop(const process::PID<master::Master>& pid);
 
     // Returns a new master detector for this instance of masters.
-    Owned<MasterDetector> detector(
-        const process::PID<slave::Slave>& pid,
-        const slave::Flags& flags);
+    Owned<MasterDetector> detector();
 
   private:
     // Not copyable, not assignable.
@@ -109,6 +107,7 @@ public:
         : master(NULL),
           allocator(NULL),
           allocatorProcess(NULL),
+          contender(NULL),
           detector(NULL) {}
 
       master::Master* master;
@@ -117,6 +116,7 @@ public:
       state::Storage* storage;
       state::protobuf::State* state;
       master::Registrar* registrar;
+      MasterContender* contender;
       MasterDetector* detector;
     };
 
@@ -145,6 +145,18 @@ public:
         slave::Isolator* isolator,
         const slave::Flags& flags = slave::Flags());
 
+    // Start and manage a new slave injecting the specified Master
+    // Detector. The detector is expected to outlive the launched
+    // slave (i.e., until it is stopped via Slaves::stop).
+    Try<process::PID<slave::Slave> > start(
+        Owned<MasterDetector> detector,
+        const slave::Flags& flags = slave::Flags());
+
+    Try<process::PID<slave::Slave> > start(
+        slave::Isolator* isolator,
+        Owned<MasterDetector> detector,
+        const slave::Flags& flags = slave::Flags());
+
     // Stops and cleans up a slave at the specified PID. If 'shutdown'
     // is true than the slave is sent a shutdown message instead of
     // being terminated.
@@ -168,6 +180,8 @@ public:
           slave(NULL),
           detector(NULL) {}
 
+      // Only register the isolator here if it is created within the
+      // Cluster.
       slave::Isolator* isolator;
       slave::Slave* slave;
       Owned<MasterDetector> detector;
@@ -249,20 +263,30 @@ inline Try<process::PID<master::Master> > Cluster::Masters::start(
   master.state = new state::protobuf::State(master.storage);
   master.registrar = new master::Registrar(master.state);
 
+  if (url.isSome()) {
+    master.contender = new ZooKeeperMasterContender(url.get());
+    master.detector = new ZooKeeperMasterDetector(url.get());
+  } else {
+    master.contender = new StandaloneMasterContender();
+    master.detector = new StandaloneMasterDetector();
+  }
+
   master.master = new master::Master(
       master.allocator,
       master.registrar,
       &cluster->files,
+      master.contender,
+      master.detector,
       flags);
 
-  process::PID<master::Master> pid = process::spawn(master.master);
-
-  if (url.isSome()) {
-    master.detector = new ZooKeeperMasterDetector(url.get(), pid, true, true);
-  } else {
-    master.detector = new BasicMasterDetector(pid);
+  if (url.isNone()) {
+    // This means we are using the StandaloneMasterDetector.
+    dynamic_cast<StandaloneMasterDetector*>(master.detector)->appoint(
+        master.master->self());
   }
 
+  process::PID<master::Master> pid = process::spawn(master.master);
+
   masters[pid] = master;
 
   return pid;
@@ -299,20 +323,30 @@ inline Try<process::PID<master::Master> > Cluster::Masters::start(
   master.state = new state::protobuf::State(master.storage);
   master.registrar = new master::Registrar(master.state);
 
+  if (url.isSome()) {
+    master.contender = new ZooKeeperMasterContender(url.get());
+    master.detector = new ZooKeeperMasterDetector(url.get());
+  } else {
+    master.contender = new StandaloneMasterContender();
+    master.detector = new StandaloneMasterDetector();
+  }
+
   master.master = new master::Master(
       master.allocator,
       master.registrar,
       &cluster->files,
+      master.contender,
+      master.detector,
       flags);
 
-  process::PID<master::Master> pid = process::spawn(master.master);
-
-  if (url.isSome()) {
-    master.detector = new ZooKeeperMasterDetector(url.get(), pid, true, true);
-  } else {
-    master.detector = new BasicMasterDetector(pid);
+  if (url.isNone()) {
+    // This means we are using the StandaloneMasterDetector.
+    dynamic_cast<StandaloneMasterDetector*>(master.detector)->appoint(
+        master.master->self());
   }
 
+  process::PID<master::Master> pid = process::spawn(master.master);
+
   masters[pid] = master;
 
   return pid;
@@ -339,6 +373,7 @@ inline Try<Nothing> Cluster::Masters::stop(
   delete master.state;
   delete master.storage;
 
+  delete master.contender;
   delete master.detector;
 
   masters.erase(pid);
@@ -347,16 +382,15 @@ inline Try<Nothing> Cluster::Masters::stop(
 }
 
 
-inline Owned<MasterDetector> Cluster::Masters::detector(
-    const process::PID<slave::Slave>& pid,
-    const slave::Flags& flags)
+inline Owned<MasterDetector> Cluster::Masters::detector()
 {
   if (url.isSome()) {
-    return new ZooKeeperMasterDetector(url.get(), pid, false, flags.quiet);
+    return new ZooKeeperMasterDetector(url.get());
   }
 
   CHECK(masters.size() == 1);
-  return new BasicMasterDetector(masters.begin()->first, pid);
+
+  return new StandaloneMasterDetector(masters.begin()->first);
 }
 
 
@@ -392,11 +426,12 @@ inline Try<process::PID<slave::Slave> > Cluster::Slaves::start(
   slave.isolator = new slave::ProcessIsolator();
   process::spawn(slave.isolator);
 
-  slave.slave = new slave::Slave(flags, true, slave.isolator, &cluster->files);
-  process::PID<slave::Slave> pid = process::spawn(slave.slave);
-
   // Get a detector for the master(s).
-  slave.detector = masters->detector(pid, flags);
+  slave.detector = masters->detector();
+
+  slave.slave = new slave::Slave(flags, true, slave.detector.get(), slave.isolator,
+      &cluster->files);
+  process::PID<slave::Slave> pid = process::spawn(slave.slave);
 
   slaves[pid] = slave;
 
@@ -408,15 +443,33 @@ inline Try<process::PID<slave::Slave> > Cluster::Slaves::start(
     slave::Isolator* isolator,
     const slave::Flags& flags)
 {
+  return start(isolator, masters->detector(), flags);
+}
+
+
+inline Try<process::PID<slave::Slave> > Cluster::Slaves::start(
+    Owned<MasterDetector> detector,
+    const slave::Flags& flags)
+{
+  return start(new slave::ProcessIsolator(), detector, flags);
+}
+
+
+inline Try<process::PID<slave::Slave> > Cluster::Slaves::start(
+    slave::Isolator* isolator,
+    Owned<MasterDetector> detector,
+    const slave::Flags& flags)
+{
   // TODO(benh): Create a work directory if using the default.
 
   Slave slave;
 
-  slave.slave = new slave::Slave(flags, true, isolator, &cluster->files);
-  process::PID<slave::Slave> pid = process::spawn(slave.slave);
-
   // Get a detector for the master(s).
-  slave.detector = masters->detector(pid, flags);
+  slave.detector = detector;
+
+  slave.slave = new slave::Slave(flags, true, slave.detector.get(),
+      isolator, &cluster->files);
+  process::PID<slave::Slave> pid = process::spawn(slave.slave);
 
   slaves[pid] = slave;
 

http://git-wip-us.apache.org/repos/asf/mesos/blob/f9d1dd81/src/tests/fault_tolerance_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/fault_tolerance_tests.cpp b/src/tests/fault_tolerance_tests.cpp
index d521f4b..6cb5829 100644
--- a/src/tests/fault_tolerance_tests.cpp
+++ b/src/tests/fault_tolerance_tests.cpp
@@ -218,7 +218,10 @@ TEST_F(FaultToleranceTest, PartitionedSlaveReregistration)
 
   MockExecutor exec(DEFAULT_EXECUTOR_ID);
 
-  Try<PID<Slave> > slave = StartSlave(&exec);
+  StandaloneMasterDetector* detector =
+    new StandaloneMasterDetector(master.get());
+
+  Try<PID<Slave> > slave = StartSlave(&exec, Owned<MasterDetector>(detector));
   ASSERT_SOME(slave);
 
   MockScheduler sched;
@@ -318,9 +321,9 @@ TEST_F(FaultToleranceTest, PartitionedSlaveReregistration)
   AWAIT_READY(slaveLost);
 
   // We now complete the partition on the slave side as well. This
-  // is done by simulating a NoMasterDetectedMessage which would
-  // normally occur during a network partition.
-  process::post(slave.get(), NoMasterDetectedMessage());
+  // is done by simulating a master loss event which would normally
+  // occur during a network partition.
+  detector->appoint(None());
 
   Future<Nothing> shutdown;
   EXPECT_CALL(exec, shutdown(_))
@@ -329,9 +332,7 @@ TEST_F(FaultToleranceTest, PartitionedSlaveReregistration)
   shutdownMessage = FUTURE_PROTOBUF(ShutdownMessage(), _, slave.get());
 
   // Have the slave re-register with the master.
-  NewMasterDetectedMessage newMasterDetectedMessage;
-  newMasterDetectedMessage.set_pid(master.get());
-  process::post(slave.get(), newMasterDetectedMessage);
+  detector->appoint(master.get());
 
   // Upon re-registration, the master will shutdown the slave.
   // The slave will then shut down the executor.
@@ -606,8 +607,9 @@ TEST_F(FaultToleranceTest, MasterFailover)
   ASSERT_SOME(master);
 
   MockScheduler sched;
-  MesosSchedulerDriver driver(
-      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
+  StandaloneMasterDetector* detector =
+    new StandaloneMasterDetector(master.get());
+  TestingMesosSchedulerDriver driver(&sched, detector);
 
   Future<process::Message> frameworkRegisteredMessage =
     FUTURE_MESSAGE(Eq(FrameworkRegisteredMessage().GetTypeName()), _, _);
@@ -637,10 +639,7 @@ TEST_F(FaultToleranceTest, MasterFailover)
     .WillOnce(FutureSatisfy(&registered2));
 
   // Simulate a new master detected message to the scheduler.
-  NewMasterDetectedMessage newMasterDetectedMsg;
-  newMasterDetectedMsg.set_pid(master.get());
-
-  process::post(frameworkRegisteredMessage.get().to, newMasterDetectedMsg);
+  detector->appoint(master.get());
 
   // Scheduler should retry authentication.
   AWAIT_READY(authenticateMessage);
@@ -651,6 +650,8 @@ TEST_F(FaultToleranceTest, MasterFailover)
   driver.stop();
   driver.join();
 
+  delete detector;
+
   Shutdown();
 }
 
@@ -863,12 +864,19 @@ TEST_F(FaultToleranceTest, FrameworkReregister)
   Try<PID<Master> > master = StartMaster();
   ASSERT_SOME(master);
 
-  Try<PID<Slave> > slave = StartSlave();
+  Owned<MasterDetector> slaveDetector =
+    new StandaloneMasterDetector(master.get());
+  Try<PID<Slave> > slave = StartSlave(slaveDetector);
   ASSERT_SOME(slave);
 
+
+  // Create a detector for the scheduler driver because we want the
+  // spurious leading master change to be known by the scheduler
+  // driver only.
+  Owned<MasterDetector> schedDetector =
+    new StandaloneMasterDetector(master.get());
   MockScheduler sched;
-  MesosSchedulerDriver driver(
-      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
+  TestingMesosSchedulerDriver driver(&sched, schedDetector.get());
 
   Future<Nothing> registered;
   EXPECT_CALL(sched, registered(&driver, _, _))
@@ -896,12 +904,9 @@ TEST_F(FaultToleranceTest, FrameworkReregister)
   EXPECT_CALL(sched, offerRescinded(&driver, _))
     .Times(AtMost(1));
 
-  // Simulate a spurious newMasterDetected event (e.g., due to ZooKeeper
-  // expiration) at the scheduler.
-  NewMasterDetectedMessage newMasterDetectedMsg;
-  newMasterDetectedMsg.set_pid(master.get());
-
-  process::post(message.get().to, newMasterDetectedMsg);
+  // Simulate a spurious leading master change at the scheduler.
+  dynamic_cast<StandaloneMasterDetector*>(schedDetector.get())->appoint(
+      master.get());
 
   AWAIT_READY(disconnected);
 
@@ -923,8 +928,9 @@ TEST_F(FaultToleranceTest, TaskLost)
   ASSERT_SOME(slave);
 
   MockScheduler sched;
-  MesosSchedulerDriver driver(
-      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
+  StandaloneMasterDetector* detector =
+    new StandaloneMasterDetector(master.get());
+  TestingMesosSchedulerDriver driver(&sched, detector);
 
   EXPECT_CALL(sched, registered(&driver, _, _));
 
@@ -947,8 +953,8 @@ TEST_F(FaultToleranceTest, TaskLost)
   EXPECT_CALL(sched, disconnected(&driver))
     .WillOnce(FutureSatisfy(&disconnected));
 
-  // Simulate a spurious noMasterDetected event at the scheduler.
-  process::post(message.get().to, NoMasterDetectedMessage());
+  // Simulate a spurious master loss event at the scheduler.
+  detector->appoint(None());
 
   AWAIT_READY(disconnected);
 
@@ -1099,12 +1105,14 @@ TEST_F(FaultToleranceTest, ReregisterFrameworkExitedExecutor)
 
   MockExecutor exec(DEFAULT_EXECUTOR_ID);
   TestingIsolator isolator(&exec);
-  Try<PID<Slave> > slave = StartSlave(&isolator);
+  Owned<MasterDetector> slaveDetector = new StandaloneMasterDetector(master.get());
+  Try<PID<Slave> > slave = StartSlave(&isolator, slaveDetector);
   ASSERT_SOME(slave);
 
   MockScheduler sched;
-  MesosSchedulerDriver driver(
-      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
+  Owned<StandaloneMasterDetector> schedDetector =
+    new StandaloneMasterDetector(master.get());
+  TestingMesosSchedulerDriver driver(&sched, schedDetector.get());
 
   Future<process::Message> frameworkRegisteredMessage =
     FUTURE_MESSAGE(Eq(FrameworkRegisteredMessage().GetTypeName()), _, _);
@@ -1153,14 +1161,11 @@ TEST_F(FaultToleranceTest, ReregisterFrameworkExitedExecutor)
   master = StartMaster();
   ASSERT_SOME(master);
 
-  // Simulate a new master detected message to the slave.
-  NewMasterDetectedMessage newMasterDetectedMsg;
-  newMasterDetectedMsg.set_pid(master.get());
-
   Future<SlaveReregisteredMessage> slaveReregisteredMessage =
     FUTURE_PROTOBUF(SlaveReregisteredMessage(), _, _);
 
-  process::post(slave.get(), newMasterDetectedMsg);
+  dynamic_cast<StandaloneMasterDetector*>(slaveDetector.get())->appoint(
+      master.get());
 
   // Wait for the slave to re-register.
   AWAIT_READY(slaveReregisteredMessage);
@@ -1183,7 +1188,7 @@ TEST_F(FaultToleranceTest, ReregisterFrameworkExitedExecutor)
 
   EXPECT_CALL(sched, registered(&driver, _, _));
 
-  process::post(frameworkRegisteredMessage.get().to, newMasterDetectedMsg);
+  schedDetector->appoint(master.get());
 
   AWAIT_READY(frameworkRegisteredMessage2);
 
@@ -1484,7 +1489,8 @@ TEST_F(FaultToleranceTest, SlaveReregisterOnZKExpiration)
   Try<PID<Master> > master = StartMaster();
   ASSERT_SOME(master);
 
-  Try<PID<Slave> > slave = StartSlave();
+  StandaloneMasterDetector* detector = new StandaloneMasterDetector(master.get());
+  Try<PID<Slave> > slave = StartSlave(Owned<MasterDetector>(detector));
   ASSERT_SOME(slave);
 
   MockScheduler sched;
@@ -1505,13 +1511,9 @@ TEST_F(FaultToleranceTest, SlaveReregisterOnZKExpiration)
   Future<SlaveReregisteredMessage> slaveReregisteredMessage =
     FUTURE_PROTOBUF(SlaveReregisteredMessage(), _, _);
 
-  // Simulate a spurious newMasterDetected event (e.g., due to ZooKeeper
+  // Simulate a spurious master change event (e.g., due to ZooKeeper
   // expiration) at the slave.
-
-  NewMasterDetectedMessage message;
-  message.set_pid(master.get());
-
-  process::post(slave.get(), message);
+  detector->appoint(master.get());
 
   AWAIT_READY(slaveReregisteredMessage);
 
@@ -1535,7 +1537,10 @@ TEST_F(FaultToleranceTest, SlaveReregisterTerminatedExecutor)
   MockExecutor exec(DEFAULT_EXECUTOR_ID);
   TestingIsolator isolator(&exec);
 
-  Try<PID<Slave> > slave = StartSlave(&isolator);
+  StandaloneMasterDetector* detector =
+    new StandaloneMasterDetector(master.get());
+  Try<PID<Slave> > slave =
+    StartSlave(&isolator, Owned<MasterDetector>(detector));
   ASSERT_SOME(slave);
 
   MockScheduler sched;
@@ -1580,16 +1585,13 @@ TEST_F(FaultToleranceTest, SlaveReregisterTerminatedExecutor)
 
   AWAIT_READY(executorExitedMessage);
 
-  // Simulate a spurious newMasterDetected event (e.g., due to ZooKeeper
+  // Simulate a spurious master change event (e.g., due to ZooKeeper
   // expiration) at the slave to force re-registration.
   Future<TaskStatus> status2;
   EXPECT_CALL(sched, statusUpdate(&driver, _))
     .WillOnce(FutureArg<1>(&status2));
 
-  NewMasterDetectedMessage message;
-  message.set_pid(master.get());
-
-  process::post(slave.get(), message);
+  detector->appoint(master.get());
 
   AWAIT_READY(status2);
   EXPECT_EQ(TASK_LOST, status2.get().state());
@@ -1609,7 +1611,9 @@ TEST_F(FaultToleranceTest, ReconcileLostTasks)
   Try<PID<Master> > master = StartMaster();
   ASSERT_SOME(master);
 
-  Try<PID<Slave> > slave = StartSlave();
+  StandaloneMasterDetector* detector =
+    new StandaloneMasterDetector(master.get());
+  Try<PID<Slave> > slave = StartSlave(Owned<MasterDetector>(detector));
   ASSERT_SOME(slave);
 
   MockScheduler sched;
@@ -1655,13 +1659,9 @@ TEST_F(FaultToleranceTest, ReconcileLostTasks)
   EXPECT_CALL(sched, statusUpdate(&driver, _))
     .WillOnce(FutureArg<1>(&status));
 
-  // Simulate a spurious newMasterDetected event (e.g., due to ZooKeeper
+  // Simulate a spurious master change event (e.g., due to ZooKeeper
   // expiration) at the slave to force re-registration.
-
-  NewMasterDetectedMessage message;
-  message.set_pid(master.get());
-
-  process::post(slave.get(), message);
+  detector->appoint(master.get());
 
   AWAIT_READY(slaveReregisteredMessage);
 
@@ -1687,7 +1687,9 @@ TEST_F(FaultToleranceTest, ReconcileIncompleteTasks)
 
   MockExecutor exec(DEFAULT_EXECUTOR_ID);
 
-  Try<PID<Slave> > slave = StartSlave(&exec);
+  StandaloneMasterDetector* detector =
+    new StandaloneMasterDetector(master.get());
+  Try<PID<Slave> > slave = StartSlave(&exec, Owned<MasterDetector>(detector));
   ASSERT_SOME(slave);
 
   MockScheduler sched;
@@ -1741,12 +1743,9 @@ TEST_F(FaultToleranceTest, ReconcileIncompleteTasks)
   Future<SlaveReregisteredMessage> slaveReregisteredMessage =
     FUTURE_PROTOBUF(SlaveReregisteredMessage(), _, _);
 
-  // Simulate a spurious newMasterDetected event (e.g., due to ZooKeeper
+  // Simulate a spurious master change event (e.g., due to ZooKeeper
   // expiration) at the slave to force re-registration.
-  NewMasterDetectedMessage message;
-  message.set_pid(master.get());
-
-  process::post(slave.get(), message);
+  detector->appoint(master.get());
 
   AWAIT_READY(slaveReregisteredMessage);
 
@@ -1755,7 +1754,7 @@ TEST_F(FaultToleranceTest, ReconcileIncompleteTasks)
   // the only update the scheduler receives is the retried
   // TASK_FINISHED update.
   // NOTE: The status update manager resends the status update when
-  // it receives a NewMasterDetected message.
+  // it detects a new master.
   Clock::settle();
 
   AWAIT_READY(status);

http://git-wip-us.apache.org/repos/asf/mesos/blob/f9d1dd81/src/tests/gc_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/gc_tests.cpp b/src/tests/gc_tests.cpp
index 5459b78..538976a 100644
--- a/src/tests/gc_tests.cpp
+++ b/src/tests/gc_tests.cpp
@@ -39,13 +39,12 @@
 #include <stout/nothing.hpp>
 #include <stout/os.hpp>
 
-#include "detector/detector.hpp"
-
 #include "logging/logging.hpp"
 
 #include "local/local.hpp"
 
 #include "master/master.hpp"
+#include "master/detector.hpp"
 
 #include "slave/constants.hpp"
 #include "slave/flags.hpp"

http://git-wip-us.apache.org/repos/asf/mesos/blob/f9d1dd81/src/tests/isolator_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/isolator_tests.cpp b/src/tests/isolator_tests.cpp
index ab5b00a..45a41ca 100644
--- a/src/tests/isolator_tests.cpp
+++ b/src/tests/isolator_tests.cpp
@@ -30,9 +30,8 @@
 #include <stout/os.hpp>
 #include <stout/path.hpp>
 
-#include "detector/detector.hpp"
-
 #include "master/master.hpp"
+#include "master/detector.hpp"
 
 #include "slave/flags.hpp"
 #ifdef __linux__

http://git-wip-us.apache.org/repos/asf/mesos/blob/f9d1dd81/src/tests/master_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/master_tests.cpp b/src/tests/master_tests.cpp
index bf790d2..37ee7a0 100644
--- a/src/tests/master_tests.cpp
+++ b/src/tests/master_tests.cpp
@@ -876,12 +876,14 @@ TEST_F(MasterTest, MasterInfoOnReElection)
   Try<PID<Master> > master = StartMaster();
   ASSERT_SOME(master);
 
-  Try<PID<Slave> > slave = StartSlave();
+  StandaloneMasterDetector* detector =
+    new StandaloneMasterDetector(master.get());
+
+  Try<PID<Slave> > slave = StartSlave(Owned<MasterDetector>(detector));
   ASSERT_SOME(slave);
 
   MockScheduler sched;
-  MesosSchedulerDriver driver(
-      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
+  TestingMesosSchedulerDriver driver(&sched, detector);
 
   EXPECT_CALL(sched, registered(&driver, _, _))
     .Times(1);
@@ -896,11 +898,6 @@ TEST_F(MasterTest, MasterInfoOnReElection)
 
   AWAIT_READY(message);
 
-  // Simulate a spurious newMasterDetected event (e.g., due to ZooKeeper
-  // expiration) at the scheduler.
-  NewMasterDetectedMessage newMasterDetectedMsg;
-  newMasterDetectedMsg.set_pid(master.get());
-
   Future<Nothing> disconnected;
   EXPECT_CALL(sched, disconnected(&driver))
     .WillOnce(FutureSatisfy(&disconnected));
@@ -909,7 +906,9 @@ TEST_F(MasterTest, MasterInfoOnReElection)
   EXPECT_CALL(sched, reregistered(&driver, _))
     .WillOnce(FutureArg<1>(&masterInfo));
 
-  process::post(message.get().to, newMasterDetectedMsg);
+  // Simulate a spurious event (e.g., due to ZooKeeper
+  // expiration) at the scheduler.
+  detector->appoint(master.get());
 
   AWAIT_READY(disconnected);
 
@@ -984,12 +983,14 @@ TEST_F(MasterTest, MasterLost)
   Try<PID<Master> > master = StartMaster();
   ASSERT_SOME(master);
 
+  Owned<StandaloneMasterDetector> detector = new StandaloneMasterDetector();
+  detector->appoint(master.get());
+
   Try<PID<Slave> > slave = StartSlave();
   ASSERT_SOME(slave);
 
   MockScheduler sched;
-  MesosSchedulerDriver driver(
-      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);
+  TestingMesosSchedulerDriver driver(&sched, detector.get());
 
   EXPECT_CALL(sched, registered(&driver, _, _))
     .Times(1);
@@ -1008,8 +1009,8 @@ TEST_F(MasterTest, MasterLost)
   EXPECT_CALL(sched, disconnected(&driver))
     .WillOnce(FutureSatisfy(&disconnected));
 
-  // Simulate a spurious noMasterDetected event at the scheduler.
-  process::post(message.get().to, NoMasterDetectedMessage());
+  // Simulate a spurious event at the scheduler.
+  detector->appoint(None());
 
   AWAIT_READY(disconnected);
 

http://git-wip-us.apache.org/repos/asf/mesos/blob/f9d1dd81/src/tests/mesos.cpp
----------------------------------------------------------------------
diff --git a/src/tests/mesos.cpp b/src/tests/mesos.cpp
index 351ffd6..5359394 100644
--- a/src/tests/mesos.cpp
+++ b/src/tests/mesos.cpp
@@ -13,6 +13,7 @@
 #include "tests/isolator.hpp"
 #include "tests/mesos.hpp"
 
+using namespace process;
 
 namespace mesos {
 namespace internal {
@@ -134,6 +135,46 @@ Try<process::PID<slave::Slave> > MesosTest::StartSlave(
 }
 
 
+Try<process::PID<slave::Slave> > MesosTest::StartSlave(
+    slave::Isolator* isolator,
+    Owned<MasterDetector> detector,
+    const Option<slave::Flags>& flags)
+{
+  return cluster.slaves.start(
+      isolator, detector, flags.isNone() ? CreateSlaveFlags() : flags.get());
+}
+
+
+Try<PID<slave::Slave> > MesosTest::StartSlave(
+    Owned<MasterDetector> detector,
+    const Option<slave::Flags>& flags)
+{
+  return cluster.slaves.start(
+      detector, flags.isNone() ? CreateSlaveFlags() : flags.get());
+}
+
+
+Try<PID<slave::Slave> > MesosTest::StartSlave(
+    MockExecutor* executor,
+    Owned<MasterDetector> detector,
+    const Option<slave::Flags>& flags)
+{
+  TestingIsolator* isolator = new TestingIsolator(executor);
+
+  Try<process::PID<slave::Slave> > pid = cluster.slaves.start(
+      isolator, detector, flags.isNone() ? CreateSlaveFlags() : flags.get());
+
+  if (pid.isError()) {
+    delete isolator;
+    return pid;
+  }
+
+  isolators[pid.get()] = isolator;
+
+  return pid;
+}
+
+
 void MesosTest::Stop(const process::PID<master::Master>& pid)
 {
   cluster.masters.stop(pid);

http://git-wip-us.apache.org/repos/asf/mesos/blob/f9d1dd81/src/tests/mesos.hpp
----------------------------------------------------------------------
diff --git a/src/tests/mesos.hpp b/src/tests/mesos.hpp
index ad39c09..3d510b2 100644
--- a/src/tests/mesos.hpp
+++ b/src/tests/mesos.hpp
@@ -20,6 +20,7 @@
 #define __TESTS_MESOS_HPP__
 
 #include <map>
+#include <set>
 #include <string>
 
 #include <mesos/executor.hpp>
@@ -42,6 +43,7 @@
 #include "messages/messages.hpp" // For google::protobuf::Message.
 
 #include "master/allocator.hpp"
+#include "master/detector.hpp"
 #include "master/hierarchical_allocator_process.hpp"
 #include "master/master.hpp"
 
@@ -98,6 +100,24 @@ protected:
       slave::Isolator* isolator,
       const Option<slave::Flags>& flags = None());
 
+  // Starts a slave with the specified isolator, detector and flags.
+  virtual Try<process::PID<slave::Slave> > StartSlave(
+      slave::Isolator* isolator,
+      Owned<MasterDetector> detector,
+      const Option<slave::Flags>& flags = None());
+
+  // Starts a slave with the specified MasterDetector and flags.
+  virtual Try<process::PID<slave::Slave> > StartSlave(
+      Owned<MasterDetector> detector,
+      const Option<slave::Flags>& flags = None());
+
+  // Starts a slave with the specified mock executor, MasterDetector
+  // and flags.
+  virtual Try<process::PID<slave::Slave> > StartSlave(
+      MockExecutor* executor,
+      Owned<MasterDetector> detector,
+      const Option<slave::Flags>& flags = None());
+
   // Stop the specified master.
   virtual void Stop(
       const process::PID<master::Master>& pid);
@@ -306,6 +326,45 @@ public:
 };
 
 
+class TestingMesosSchedulerDriver : public MesosSchedulerDriver
+{
+public:
+  TestingMesosSchedulerDriver(
+      Scheduler* scheduler,
+      const FrameworkInfo& framework,
+      const Credential& credential,
+      MasterDetector* _detector)
+    : MesosSchedulerDriver(scheduler, framework, "", credential)
+  {
+    detector = _detector;
+  }
+
+  // A constructor that uses the DEFAULT_FRAMEWORK_INFO &
+  // DEFAULT_CREDENTIAL.
+  TestingMesosSchedulerDriver(
+      Scheduler* scheduler,
+      MasterDetector* _detector)
+    : MesosSchedulerDriver(
+          scheduler,
+          DEFAULT_FRAMEWORK_INFO,
+          "",
+          DEFAULT_CREDENTIAL)
+  {
+    detector = _detector;
+  }
+
+  ~TestingMesosSchedulerDriver()
+  {
+    // This is necessary because in the base class the detector is
+    // internally created and deleted whereas in the testing driver
+    // it is injected and thus should not be deleted in the
+    // destructor. Setting it to null allows the detector to survive
+    // MesosSchedulerDriver::~MesosSchedulerDriver().
+    detector = NULL;
+  }
+};
+
+
 template <typename T = master::allocator::AllocatorProcess>
 class MockAllocatorProcess : public master::allocator::AllocatorProcess
 {

http://git-wip-us.apache.org/repos/asf/mesos/blob/f9d1dd81/src/tests/slave_recovery_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/slave_recovery_tests.cpp b/src/tests/slave_recovery_tests.cpp
index 3ee7b87..eb2dc33 100644
--- a/src/tests/slave_recovery_tests.cpp
+++ b/src/tests/slave_recovery_tests.cpp
@@ -38,12 +38,11 @@
 
 #include "common/protobuf_utils.hpp"
 
-#include "detector/detector.hpp"
-
 #ifdef __linux__
 #include "linux/cgroups.hpp"
 #endif
 
+#include "master/detector.hpp"
 #include "master/master.hpp"
 
 #include "slave/gc.hpp"
@@ -2321,8 +2320,10 @@ TYPED_TEST(SlaveRecoveryTest, MasterFailover)
   frameworkInfo.CopyFrom(DEFAULT_FRAMEWORK_INFO);
   frameworkInfo.set_checkpoint(true);
 
-  MesosSchedulerDriver driver(
-      &sched, frameworkInfo, master.get(), DEFAULT_CREDENTIAL);
+  Owned<StandaloneMasterDetector> detector =
+    new StandaloneMasterDetector(master.get());
+  TestingMesosSchedulerDriver driver(
+      &sched, frameworkInfo, DEFAULT_CREDENTIAL, detector.get());
 
   EXPECT_CALL(sched, registered(_, _, _));
 
@@ -2366,11 +2367,8 @@ TYPED_TEST(SlaveRecoveryTest, MasterFailover)
   EXPECT_CALL(sched, registered(&driver, _, _))
     .WillOnce(FutureSatisfy(&registered));
 
-  // Simulate a new master detected message to the scheduler.
-  NewMasterDetectedMessage newMasterDetectedMsg;
-  newMasterDetectedMsg.set_pid(master.get());
-
-  process::post(frameworkRegisteredMessage.get().to, newMasterDetectedMsg);
+  // Simulate a new master detected event to the scheduler.
+  detector->appoint(master.get());
 
   // Framework should get a registered callback.
   AWAIT_READY(registered);