static void SetUpTestCase()
{
ContainerizerTest<MesosContainerizer>::SetUpTestCase();
// Verify that the dd command and its flags used in a bit are valid
// on this system.
ASSERT_SOME_EQ(0, os::system("dd count=1 bs=1M if=/dev/zero of=/dev/null"))
<< "Cannot find a compatible 'dd' command";
}
TEST_F(ZooKeeperTest, LeaderDetector)
{
Group group(server->connectString(), NO_TIMEOUT, "/test/");
// Initialize two members.
Future<Group::Membership> membership1 =
group.join("member 1");
AWAIT_READY(membership1);
Future<Group::Membership> membership2 =
group.join("member 2");
AWAIT_READY(membership2);
LeaderDetector detector(&group);
// Detect the leader.
Future<Option<Group::Membership> > leader =
detector.detect(None());
AWAIT_READY(leader);
ASSERT_SOME_EQ(membership1.get(), leader.get());
// Detect next leader change.
leader = detector.detect(leader.get());
EXPECT_TRUE(leader.isPending());
// Leader doesn't change after cancelling the follower.
Future<bool> cancellation = group.cancel(membership2.get());
AWAIT_READY(cancellation);
EXPECT_TRUE(cancellation.get());
EXPECT_TRUE(leader.isPending());
// Join member 2 back.
membership2 = group.join("member 2");
AWAIT_READY(membership2);
EXPECT_TRUE(leader.isPending());
// Cancelling the incumbent leader allows member 2 to be elected.
cancellation = group.cancel(membership1.get());
AWAIT_READY(cancellation);
EXPECT_TRUE(cancellation.get());
AWAIT_READY(leader);
EXPECT_SOME_EQ(membership2.get(), leader.get());
// Cancelling the only member results in no leader elected.
leader = detector.detect(leader.get().get());
EXPECT_TRUE(leader.isPending());
cancellation = group.cancel(membership2.get());
AWAIT_READY(cancellation);
EXPECT_TRUE(cancellation.get());
AWAIT_READY(leader);
ASSERT_TRUE(leader.get().isNone());
}
// This test verifies that if master receives a status update
// for an already terminated task it forwards it without
// changing the state of the task.
TEST_F(StatusUpdateManagerTest, DuplicatedTerminalStatusUpdate)
{
Try<PID<Master> > master = StartMaster();
ASSERT_SOME(master);
MockExecutor exec(DEFAULT_EXECUTOR_ID);
Try<PID<Slave>> slave = StartSlave(&exec);
ASSERT_SOME(slave);
FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO;
frameworkInfo.set_checkpoint(true); // Enable checkpointing.
MockScheduler sched;
MesosSchedulerDriver driver(
&sched, frameworkInfo, master.get(), DEFAULT_CREDENTIAL);
FrameworkID frameworkId;
EXPECT_CALL(sched, registered(_, _, _))
.WillOnce(SaveArg<1>(&frameworkId));
Future<vector<Offer> > offers;
EXPECT_CALL(sched, resourceOffers(_, _))
.WillOnce(FutureArg<1>(&offers))
.WillRepeatedly(Return()); // Ignore subsequent offers.
driver.start();
AWAIT_READY(offers);
EXPECT_NE(0u, offers.get().size());
ExecutorDriver* execDriver;
EXPECT_CALL(exec, registered(_, _, _, _))
.WillOnce(SaveArg<0>(&execDriver));
// Send a terminal update right away.
EXPECT_CALL(exec, launchTask(_, _))
.WillOnce(SendStatusUpdateFromTask(TASK_FINISHED));
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
.WillOnce(FutureArg<1>(&status));
Future<Nothing> _statusUpdateAcknowledgement =
FUTURE_DISPATCH(slave.get(), &Slave::_statusUpdateAcknowledgement);
driver.launchTasks(offers.get()[0].id(), createTasks(offers.get()[0]));
AWAIT_READY(status);
EXPECT_EQ(TASK_FINISHED, status.get().state());
AWAIT_READY(_statusUpdateAcknowledgement);
Future<TaskStatus> update;
EXPECT_CALL(sched, statusUpdate(_, _))
.WillOnce(FutureArg<1>(&update));
Future<Nothing> _statusUpdateAcknowledgement2 =
FUTURE_DISPATCH(slave.get(), &Slave::_statusUpdateAcknowledgement);
Clock::pause();
// Now send a TASK_KILLED update for the same task.
TaskStatus status2 = status.get();
status2.set_state(TASK_KILLED);
execDriver->sendStatusUpdate(status2);
// Ensure the scheduler receives TASK_KILLED.
AWAIT_READY(update);
EXPECT_EQ(TASK_KILLED, update.get().state());
// Ensure the slave properly handles the ACK.
// Clock::settle() ensures that the slave successfully
// executes Slave::_statusUpdateAcknowledgement().
AWAIT_READY(_statusUpdateAcknowledgement2);
// Verify the latest task status.
Future<process::http::Response> tasks =
process::http::get(master.get(), "tasks");
AWAIT_EXPECT_RESPONSE_STATUS_EQ(process::http::OK().status, tasks);
AWAIT_EXPECT_RESPONSE_HEADER_EQ(APPLICATION_JSON, "Content-Type", tasks);
Try<JSON::Object> parse = JSON::parse<JSON::Object>(tasks.get().body);
ASSERT_SOME(parse);
Result<JSON::String> state = parse.get().find<JSON::String>("tasks[0].state");
ASSERT_SOME_EQ(JSON::String("TASK_FINISHED"), state);
Clock::resume();
EXPECT_CALL(exec, shutdown(_))
.Times(AtMost(1));
driver.stop();
driver.join();
Shutdown();
}