You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mesos.apache.org by al...@apache.org on 2017/10/12 15:52:58 UTC
[3/4] mesos git commit: Fix unit tests that were broken by the
additional TASK_STARTING update.
Fix unit tests that were broken by the additional TASK_STARTING update.
Review: https://reviews.apache.org/r/62213/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/1e1e409b
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/1e1e409b
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/1e1e409b
Branch: refs/heads/master
Commit: 1e1e409b3906d1a6189d5dfd47b21df7680244f6
Parents: f43710e
Author: Benno Evers <be...@mesosphere.com>
Authored: Thu Oct 12 08:24:14 2017 -0700
Committer: Alexander Rukletsov <al...@apache.org>
Committed: Thu Oct 12 08:26:11 2017 -0700
----------------------------------------------------------------------
src/tests/api_tests.cpp | 89 ++++++---
src/tests/check_tests.cpp | 155 ++++++++++++++-
src/tests/command_executor_tests.cpp | 35 +++-
src/tests/container_logger_tests.cpp | 20 ++
.../environment_secret_isolator_tests.cpp | 10 +-
.../posix_rlimits_isolator_tests.cpp | 24 ++-
src/tests/default_executor_tests.cpp | 196 +++++++++++++------
src/tests/disk_quota_tests.cpp | 50 ++++-
src/tests/fault_tolerance_tests.cpp | 6 +
src/tests/health_check_tests.cpp | 81 +++++++-
src/tests/master_tests.cpp | 92 +++++++--
src/tests/master_validation_tests.cpp | 6 +
src/tests/oversubscription_tests.cpp | 12 +-
src/tests/partition_tests.cpp | 66 ++++++-
src/tests/persistent_volume_endpoints_tests.cpp | 11 +-
src/tests/persistent_volume_tests.cpp | 108 +++++++---
src/tests/reconciliation_tests.cpp | 15 +-
src/tests/reservation_endpoints_tests.cpp | 44 +++--
src/tests/role_tests.cpp | 10 +-
src/tests/scheduler_tests.cpp | 52 ++++-
src/tests/slave_authorization_tests.cpp | 17 +-
src/tests/slave_recovery_tests.cpp | 158 ++++++++++-----
src/tests/slave_tests.cpp | 49 ++++-
src/tests/teardown_tests.cpp | 15 +-
24 files changed, 1052 insertions(+), 269 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/api_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/api_tests.cpp b/src/tests/api_tests.cpp
index 3d0db3b..5bcca85 100644
--- a/src/tests/api_tests.cpp
+++ b/src/tests/api_tests.cpp
@@ -2300,6 +2300,8 @@ TEST_P(MasterAPITest, EventAuthorizationFiltering)
AWAIT_READY(offers1);
ASSERT_FALSE(offers1->offers().empty());
+ v1::AgentID agentId(offers1->offers()[0].agent_id());
+
v1::master::Call v1Call;
v1Call.set_type(v1::master::Call::SUBSCRIBE);
@@ -2352,9 +2354,11 @@ TEST_P(MasterAPITest, EventAuthorizationFiltering)
Future<Result<v1::master::Event>> event = decoder.read();
EXPECT_TRUE(event.isPending());
- Future<mesos::v1::scheduler::Event::Update> update;
+ Future<mesos::v1::scheduler::Event::Update> updateRunning1;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(FutureArg<1>(&update));
+ .WillOnce(DoAll(
+ FutureArg<1>(&updateRunning1),
+ v1::scheduler::SendAcknowledge(frameworkId, agentId)));
EXPECT_CALL(executor1, registered(_, _, _, _));
EXPECT_CALL(executor2, registered(_, _, _, _));
@@ -2405,21 +2409,11 @@ TEST_P(MasterAPITest, EventAuthorizationFiltering)
ASSERT_EQ(v1::master::Event::TASK_ADDED, event->get().type());
ASSERT_EQ(task1.task_id(), event->get().task_added().task().task_id());
- AWAIT_READY(update);
+ // AWAIT_READY(updateStarting1);
+ // EXPECT_EQ(updateStarting1->status().state(), TASK_STARTING);
- {
- v1::scheduler::Call call;
- call.mutable_framework_id()->CopyFrom(frameworkId);
- call.set_type(v1::scheduler::Call::ACKNOWLEDGE);
-
- v1::scheduler::Call::Acknowledge* acknowledge =
- call.mutable_acknowledge();
- acknowledge->mutable_task_id()->CopyFrom(task1.task_id());
- acknowledge->mutable_agent_id()->CopyFrom(offer1.agent_id());
- acknowledge->set_uuid(update->status().uuid());
-
- mesos.send(call);
- }
+ AWAIT_READY(updateRunning1);
+ EXPECT_EQ(updateRunning1->status().state(), TASK_RUNNING);
event = decoder.read();
@@ -2447,8 +2441,9 @@ TEST_P(MasterAPITest, EventAuthorizationFiltering)
const v1::Offer& offer2 = offers2->offers(0);
+ Future<mesos::v1::scheduler::Event::Update> updateRunning2;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(FutureArg<1>(&update))
+ .WillOnce(FutureArg<1>(&updateRunning2))
.WillRepeatedly(Return()); // Ignore subsequent updates.
Future<TaskInfo> execTask2;
@@ -2485,7 +2480,7 @@ TEST_P(MasterAPITest, EventAuthorizationFiltering)
mesos.send(call);
}
- AWAIT_READY(update);
+ AWAIT_READY(updateRunning2);
event = decoder.read();
EXPECT_TRUE(event.isPending());
@@ -4443,8 +4438,10 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(AgentAPITest, GetFrameworks)
command.set_value("sleep 1000");
task.mutable_command()->MergeFrom(command);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning));
ContentType contentType = GetParam();
@@ -4466,6 +4463,9 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(AgentAPITest, GetFrameworks)
driver.launchTasks(offer.id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -4546,8 +4546,10 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(AgentAPITest, GetExecutors)
command.set_value("sleep 1000");
task.mutable_command()->MergeFrom(command);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning));
ContentType contentType = GetParam();
@@ -4569,6 +4571,9 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(AgentAPITest, GetExecutors)
driver.launchTasks(offer.id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -4653,8 +4658,10 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(AgentAPITest, GetTasks)
command.set_value("sleep 1000");
task.mutable_command()->MergeFrom(command);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning));
ContentType contentType = GetParam();
@@ -4679,6 +4686,9 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(AgentAPITest, GetTasks)
driver.launchTasks(offer.id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -4816,8 +4826,10 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(AgentAPITest, GetState)
command.set_value("sleep 1000");
task.mutable_command()->MergeFrom(command);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning));
ContentType contentType = GetParam();
@@ -4843,6 +4855,9 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(AgentAPITest, GetState)
driver.launchTasks(offer.id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -5552,14 +5567,15 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(AgentAPITest, LaunchNestedContainerSession)
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status));
+ .WillOnce(FutureArg<1>(&status))
+ .WillRepeatedly(Return());
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(status);
- ASSERT_EQ(TASK_RUNNING, status->state());
+ ASSERT_EQ(TASK_STARTING, status->state());
// Launch a nested container session that runs a command
// that writes something to stdout and stderr and exits.
@@ -5673,14 +5689,15 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status));
+ .WillOnce(FutureArg<1>(&status))
+ .WillRepeatedly(Return());
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(status);
- ASSERT_EQ(TASK_RUNNING, status->state());
+ ASSERT_EQ(TASK_STARTING, status->state());
// Attempt to launch a nested container which does nothing.
@@ -5769,14 +5786,15 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status));
+ .WillOnce(FutureArg<1>(&status))
+ .WillRepeatedly(Return());
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(status);
- ASSERT_EQ(TASK_RUNNING, status->state());
+ ASSERT_EQ(TASK_STARTING, status->state());
// Launch a nested container session that runs a command
// that writes something to stdout and stderr and exits.
@@ -5886,14 +5904,15 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status));
+ .WillOnce(FutureArg<1>(&status))
+ .WillRepeatedly(Return());
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(status);
- ASSERT_EQ(TASK_RUNNING, status->state());
+ ASSERT_EQ(TASK_STARTING, status->state());
// Launch a nested container session that runs `cat` so that it never exits.
@@ -6190,14 +6209,15 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status));
+ .WillOnce(FutureArg<1>(&status))
+ .WillRepeatedly(Return());
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(status);
- ASSERT_EQ(TASK_RUNNING, status->state());
+ ASSERT_EQ(TASK_STARTING, status->state());
// Launch a nested container session which runs a shell.
@@ -6796,16 +6816,21 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(
const Offer& offer = offers.get()[0];
- Future<TaskStatus> status;
+ Future<TaskStatus> statusStarting;
+ Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status));
+ .WillOnce(FutureArg<1>(&statusStarting))
+ .WillOnce(FutureArg<1>(&statusRunning));
TaskInfo taskInfo = createTask(offer, "sleep 1000");
driver.acceptOffers({offer.id()}, {LAUNCH({taskInfo})});
- AWAIT_READY(status);
- ASSERT_EQ(TASK_RUNNING, status->state());
+ AWAIT_READY(statusStarting);
+ ASSERT_EQ(TASK_STARTING, statusStarting->state());
+
+ AWAIT_READY(statusRunning);
+ ASSERT_EQ(TASK_RUNNING, statusRunning->state());
Future<hashset<ContainerID>> containerIds = containerizer->containers();
AWAIT_READY(containerIds);
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/check_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/check_tests.cpp b/src/tests/check_tests.cpp
index fd15a47..9a56c00 100644
--- a/src/tests/check_tests.cpp
+++ b/src/tests/check_tests.cpp
@@ -288,12 +288,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
Future<Event::Update> updateExplicitReconciliation;
Future<Event::Update> updateImplicitReconciliation;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillOnce(FutureArg<1>(&updateExplicitReconciliation))
@@ -322,6 +324,9 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
launchTask(&mesos, offer, taskInfo);
+ AWAIT_READY(updateTaskStarting);
+ acknowledge(&mesos, frameworkId, updateTaskStarting->status());
+
AWAIT_READY(updateTaskRunning);
const v1::TaskStatus& taskRunning = updateTaskRunning->status();
@@ -437,12 +442,14 @@ TEST_F(CommandExecutorCheckTest, CommandCheckStatusChange)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
Future<Event::Update> updateCheckResultChanged;
Future<Event::Update> updateCheckResultBack;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillOnce(FutureArg<1>(&updateCheckResultChanged))
@@ -464,6 +471,9 @@ TEST_F(CommandExecutorCheckTest, CommandCheckStatusChange)
launchTask(&mesos, offer, taskInfo);
+ AWAIT_READY(updateTaskStarting);
+ acknowledge(&mesos, frameworkId, updateTaskStarting->status());
+
AWAIT_READY(updateTaskRunning);
ASSERT_EQ(TASK_RUNNING, updateTaskRunning->status().state());
EXPECT_EQ(taskInfo.task_id(), updateTaskRunning->status().task_id());
@@ -557,10 +567,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillRepeatedly(Return()); // Ignore subsequent updates.
@@ -590,6 +602,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
launchTask(&mesos, offer, taskInfo);
+ AWAIT_READY(updateTaskStarting);
+ const v1::TaskStatus& taskStarting = updateTaskStarting->status();
+
+ ASSERT_EQ(TASK_STARTING, taskStarting.state());
+ EXPECT_EQ(taskInfo.task_id(), taskStarting.task_id());
+
+ acknowledge(&mesos, frameworkId, taskStarting);
+
AWAIT_READY(updateTaskRunning);
const v1::TaskStatus& taskRunning = updateTaskRunning->status();
@@ -660,10 +680,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillRepeatedly(Return()); // Ignore subsequent updates.
@@ -687,6 +709,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
launchTask(&mesos, offer, taskInfo);
+ AWAIT_READY(updateTaskStarting);
+ const v1::TaskStatus& taskStarting = updateTaskStarting->status();
+
+ ASSERT_EQ(TASK_STARTING, taskStarting.state());
+ EXPECT_EQ(taskInfo.task_id(), taskStarting.task_id());
+
+ acknowledge(&mesos, frameworkId, taskStarting);
+
AWAIT_READY(updateTaskRunning);
const v1::TaskStatus& taskRunning = updateTaskRunning->status();
@@ -781,11 +811,13 @@ TEST_F(CommandExecutorCheckTest, CommandCheckTimeout)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
Future<Event::Update> updateCheckResultTimeout;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillOnce(FutureArg<1>(&updateCheckResultTimeout))
@@ -807,6 +839,12 @@ TEST_F(CommandExecutorCheckTest, CommandCheckTimeout)
launchTask(&mesos, offer, taskInfo);
+ AWAIT_READY(updateTaskStarting);
+ ASSERT_EQ(TASK_STARTING, updateTaskStarting->status().state());
+ EXPECT_EQ(taskInfo.task_id(), updateTaskStarting->status().task_id());
+
+ acknowledge(&mesos, frameworkId, updateTaskStarting->status());
+
AWAIT_READY(updateTaskRunning);
ASSERT_EQ(TASK_RUNNING, updateTaskRunning->status().state());
EXPECT_EQ(taskInfo.task_id(), updateTaskRunning->status().task_id());
@@ -886,12 +924,14 @@ TEST_F(CommandExecutorCheckTest, CommandCheckAndHealthCheckNoShadowing)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
Future<Event::Update> updateHealthResult;
Future<Event::Update> updateImplicitReconciliation;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillOnce(FutureArg<1>(&updateHealthResult))
@@ -928,6 +968,9 @@ TEST_F(CommandExecutorCheckTest, CommandCheckAndHealthCheckNoShadowing)
launchTask(&mesos, offer, taskInfo);
+ AWAIT_READY(updateTaskStarting);
+ acknowledge(&mesos, frameworkId, updateTaskStarting->status());
+
AWAIT_READY(updateTaskRunning);
ASSERT_EQ(TASK_RUNNING, updateTaskRunning->status().state());
EXPECT_EQ(taskInfo.task_id(), updateTaskRunning->status().task_id());
@@ -1038,9 +1081,11 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(CommandExecutorCheckTest, HTTPCheckDelivered)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<v1::scheduler::Event::Update> updateTaskStarting;
Future<v1::scheduler::Event::Update> updateTaskRunning;
Future<v1::scheduler::Event::Update> updateCheckResult;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillRepeatedly(Return()); // Ignore subsequent updates.
@@ -1069,6 +1114,9 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(CommandExecutorCheckTest, HTTPCheckDelivered)
launchTask(&mesos, offer, taskInfo);
+ AWAIT_READY(updateTaskStarting);
+ acknowledge(&mesos, frameworkId, updateTaskStarting->status());
+
AWAIT_READY(updateTaskRunning);
const v1::TaskStatus& taskRunning = updateTaskRunning->status();
@@ -1171,9 +1219,11 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(CommandExecutorCheckTest, TCPCheckDelivered)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<v1::scheduler::Event::Update> updateTaskStarting;
Future<v1::scheduler::Event::Update> updateTaskRunning;
Future<v1::scheduler::Event::Update> updateCheckResult;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillRepeatedly(Return()); // Ignore subsequent updates.
@@ -1201,6 +1251,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(CommandExecutorCheckTest, TCPCheckDelivered)
launchTask(&mesos, offer, taskInfo);
+ AWAIT_READY(updateTaskStarting);
+ const v1::TaskStatus& taskStarting = updateTaskStarting->status();
+
+ ASSERT_EQ(TASK_STARTING, taskStarting.state());
+ EXPECT_EQ(taskInfo.task_id(), taskStarting.task_id());
+
+ acknowledge(&mesos, frameworkId, taskStarting);
+
AWAIT_READY(updateTaskRunning);
const v1::TaskStatus& taskRunning = updateTaskRunning->status();
@@ -1381,12 +1439,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
Future<Event::Update> updateExplicitReconciliation;
Future<Event::Update> updateImplicitReconciliation;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillOnce(FutureArg<1>(&updateExplicitReconciliation))
@@ -1415,6 +1475,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
launchTaskGroup(&mesos, offer, executorInfo, taskGroup);
+ AWAIT_READY(updateTaskStarting);
+ const v1::TaskStatus& taskStarting = updateTaskStarting->status();
+
+ ASSERT_EQ(TASK_STARTING, taskStarting.state());
+ EXPECT_EQ(taskInfo.task_id(), taskStarting.task_id());
+
+ acknowledge(&mesos, frameworkId, taskStarting);
+
AWAIT_READY(updateTaskRunning);
const v1::TaskStatus& taskRunning = updateTaskRunning->status();
@@ -1575,12 +1643,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
Future<Event::Update> updateCheckResultChanged;
Future<Event::Update> updateCheckResultBack;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillOnce(FutureArg<1>(&updateCheckResultChanged))
@@ -1602,6 +1672,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
launchTaskGroup(&mesos, offer, executorInfo, taskGroup);
+ AWAIT_READY(updateTaskStarting);
+ ASSERT_EQ(TASK_STARTING, updateTaskStarting->status().state());
+ EXPECT_EQ(taskInfo.task_id(), updateTaskStarting->status().task_id());
+
+ acknowledge(&mesos, frameworkId, updateTaskStarting->status());
+
AWAIT_READY(updateTaskRunning);
ASSERT_EQ(TASK_RUNNING, updateTaskRunning->status().state());
EXPECT_EQ(taskInfo.task_id(), updateTaskRunning->status().task_id());
@@ -1736,10 +1812,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillRepeatedly(Return()); // Ignore subsequent updates.
@@ -1769,6 +1847,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
launchTaskGroup(&mesos, offer, executorInfo, taskGroup);
+ AWAIT_READY(updateTaskStarting);
+ const v1::TaskStatus& taskStarting = updateTaskStarting->status();
+
+ ASSERT_EQ(TASK_STARTING, taskStarting.state());
+ EXPECT_EQ(taskInfo.task_id(), taskStarting.task_id());
+
+ acknowledge(&mesos, frameworkId, taskStarting);
+
AWAIT_READY(updateTaskRunning);
const v1::TaskStatus& taskRunning = updateTaskRunning->status();
@@ -1881,10 +1967,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillRepeatedly(Return()); // Ignore subsequent updates.
@@ -1936,6 +2024,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
launchTaskGroup(&mesos, offer, executorInfo, taskGroup);
+ AWAIT_READY(updateTaskStarting);
+ const v1::TaskStatus& taskStarting = updateTaskStarting->status();
+
+ ASSERT_EQ(TASK_STARTING, taskStarting.state());
+ EXPECT_EQ(taskInfo.task_id(), taskStarting.task_id());
+
+ acknowledge(&mesos, frameworkId, taskStarting);
+
AWAIT_READY(updateTaskRunning);
const v1::TaskStatus& taskRunning = updateTaskRunning->status();
@@ -2049,11 +2145,13 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorCheckTest, CommandCheckTimeout)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
Future<Event::Update> updateCheckResultTimeout;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillOnce(FutureArg<1>(&updateCheckResultTimeout))
@@ -2075,6 +2173,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorCheckTest, CommandCheckTimeout)
launchTaskGroup(&mesos, offer, executorInfo, taskGroup);
+ AWAIT_READY(updateTaskStarting);
+ ASSERT_EQ(TASK_STARTING, updateTaskStarting->status().state());
+ EXPECT_EQ(taskInfo.task_id(), updateTaskStarting->status().task_id());
+
+ acknowledge(&mesos, frameworkId, updateTaskStarting->status());
+
AWAIT_READY(updateTaskRunning);
ASSERT_EQ(TASK_RUNNING, updateTaskRunning->status().state());
EXPECT_EQ(taskInfo.task_id(), updateTaskRunning->status().task_id());
@@ -2197,12 +2301,14 @@ TEST_F(DefaultExecutorCheckTest, CommandCheckAndHealthCheckNoShadowing)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<Event::Update> updateTaskStarting;
Future<Event::Update> updateTaskRunning;
Future<Event::Update> updateCheckResult;
Future<Event::Update> updateHealthResult;
Future<Event::Update> updateImplicitReconciliation;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillOnce(FutureArg<1>(&updateHealthResult))
@@ -2236,6 +2342,9 @@ TEST_F(DefaultExecutorCheckTest, CommandCheckAndHealthCheckNoShadowing)
launchTask(&mesos, offer, taskInfo);
+ AWAIT_READY(updateTaskStarting);
+ acknowledge(&mesos, frameworkId, updateTaskStarting->status());
+
AWAIT_READY(updateTaskRunning);
ASSERT_EQ(TASK_RUNNING, updateTaskRunning->status().state());
EXPECT_EQ(taskInfo.task_id(), updateTaskRunning->status().task_id());
@@ -2370,11 +2479,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
- Future<v1::scheduler::Event::Update> updates[4];
+ constexpr int EXPECTED_UPDATE_COUNT = 5;
+ Future<v1::scheduler::Event::Update> updates[EXPECTED_UPDATE_COUNT];
{
testing::InSequence dummy;
- for (int i = 0; i < 4; i++) {
+ for (int i = 0; i < EXPECTED_UPDATE_COUNT; i++) {
EXPECT_CALL(*scheduler, update(_, _))
.WillOnce(FutureArg<1>(&updates[i]));
}
@@ -2401,12 +2511,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
launchTaskGroup(&mesos, offer, executorInfo, taskGroup);
- enum class Stage { INITIAL, RUNNING, CHECKED };
+ enum class Stage { STARTING, INITIAL, RUNNING, CHECKED };
hashmap<v1::TaskID, Stage> taskStages;
- taskStages.put(taskInfo1.task_id(), Stage::INITIAL);
- taskStages.put(taskInfo2.task_id(), Stage::INITIAL);
+ taskStages.put(taskInfo1.task_id(), Stage::STARTING);
+ taskStages.put(taskInfo2.task_id(), Stage::STARTING);
- for (int i = 0; i < 4; i++ ) {
+ for (int i = 0; i < EXPECTED_UPDATE_COUNT; i++ ) {
AWAIT_READY(updates[i]);
const v1::TaskStatus& taskStatus = updates[i]->status();
@@ -2415,8 +2525,17 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
ASSERT_SOME(taskStage);
switch (taskStage.get()) {
+ case Stage::STARTING: {
+ v1::TaskState state = taskStatus.state();
+ ASSERT_TRUE(state == v1::TASK_STARTING);
+
+ taskStages.put(taskStatus.task_id(), Stage::INITIAL);
+
+ break;
+ }
case Stage::INITIAL: {
- ASSERT_EQ(TASK_RUNNING, taskStatus.state());
+ v1::TaskState state = taskStatus.state();
+ ASSERT_TRUE(state == v1::TASK_RUNNING);
ASSERT_TRUE(taskStatus.check_status().has_tcp());
ASSERT_FALSE(taskStatus.check_status().tcp().has_succeeded());
@@ -2513,9 +2632,11 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorCheckTest, HTTPCheckDelivered)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<v1::scheduler::Event::Update> updateTaskStarting;
Future<v1::scheduler::Event::Update> updateTaskRunning;
Future<v1::scheduler::Event::Update> updateCheckResult;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillRepeatedly(Return()); // Ignore subsequent updates.
@@ -2544,6 +2665,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorCheckTest, HTTPCheckDelivered)
launchTaskGroup(&mesos, offer, executorInfo, taskGroup);
+ AWAIT_READY(updateTaskStarting);
+ const v1::TaskStatus& taskStarting = updateTaskStarting->status();
+
+ ASSERT_EQ(TASK_STARTING, taskStarting.state());
+
+ // Acknowledge (to be able to get the next update).
+ acknowledge(&mesos, frameworkId, taskStarting);
+
AWAIT_READY(updateTaskRunning);
const v1::TaskStatus& taskRunning = updateTaskRunning->status();
@@ -2662,9 +2791,11 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorCheckTest, TCPCheckDelivered)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ Future<v1::scheduler::Event::Update> updateTaskStarting;
Future<v1::scheduler::Event::Update> updateTaskRunning;
Future<v1::scheduler::Event::Update> updateCheckResult;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&updateTaskStarting))
.WillOnce(FutureArg<1>(&updateTaskRunning))
.WillOnce(FutureArg<1>(&updateCheckResult))
.WillRepeatedly(Return()); // Ignore subsequent updates.
@@ -2692,6 +2823,16 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorCheckTest, TCPCheckDelivered)
launchTaskGroup(&mesos, offer, executorInfo, taskGroup);
+ AWAIT_READY(updateTaskStarting);
+ const v1::TaskStatus& taskStarting = updateTaskStarting->status();
+
+ ASSERT_EQ(TASK_STARTING, taskStarting.state());
+ EXPECT_EQ(taskInfo.task_id(), taskStarting.task_id());
+
+ // Acknowledge (to be able to get the next update).
+ acknowledge(&mesos, frameworkId, taskStarting);
+
+
AWAIT_READY(updateTaskRunning);
const v1::TaskStatus& taskRunning = updateTaskRunning->status();
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/command_executor_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/command_executor_tests.cpp b/src/tests/command_executor_tests.cpp
index f706f55..3765132 100644
--- a/src/tests/command_executor_tests.cpp
+++ b/src/tests/command_executor_tests.cpp
@@ -125,12 +125,17 @@ TEST_P(CommandExecutorTest, NoTaskKillingCapability)
offers->front().resources(),
SLEEP_COMMAND(1000));
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(_, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning));
driver.launchTasks(offers->front().id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -196,12 +201,17 @@ TEST_P(CommandExecutorTest, TaskKillingCapability)
offers->front().resources(),
SLEEP_COMMAND(1000));
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(_, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning));
driver.launchTasks(offers->front().id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -299,12 +309,14 @@ TEST_P(CommandExecutorTest, NoTransitionFromKillingToRunning)
vector<TaskInfo> tasks;
tasks.push_back(task);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
Future<TaskStatus> statusKilling;
Future<TaskStatus> statusKilled;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy))
.WillOnce(FutureArg<1>(&statusKilling))
@@ -312,6 +324,9 @@ TEST_P(CommandExecutorTest, NoTransitionFromKillingToRunning)
driver.launchTasks(offers->front().id(), tasks);
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -388,10 +403,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(HTTPCommandExecutorTest, TerminateWithACK)
offers->front().resources(),
"sleep 1");
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusFinished;
EXPECT_CALL(sched, statusUpdate(_, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusFinished));
@@ -401,7 +418,11 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(HTTPCommandExecutorTest, TerminateWithACK)
driver.launchTasks(offers->front().id(), {task});
- // Scheduler should first receive TASK_RUNNING followed by TASK_FINISHED.
+ // Scheduler should first receive TASK_STARTING, followed by TASK_RUNNING
+ // and TASK_FINISHED.
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -464,9 +485,9 @@ TEST_F(HTTPCommandExecutorTest, ExplicitAcknowledgements)
offers->front().resources(),
SLEEP_COMMAND(1000));
- Future<TaskStatus> statusRunning;
+ Future<TaskStatus> statusStarting;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&statusRunning));
+ .WillOnce(FutureArg<1>(&statusStarting));
// Ensure no status update acknowledgements are sent from the driver
// to the master until the explicit acknowledgement is sent.
@@ -478,9 +499,9 @@ TEST_F(HTTPCommandExecutorTest, ExplicitAcknowledgements)
driver.launchTasks(offers->front().id(), {task});
- AWAIT_READY(statusRunning);
- EXPECT_TRUE(statusRunning->has_slave_id());
- EXPECT_EQ(TASK_RUNNING, statusRunning->state());
+ AWAIT_READY(statusStarting);
+ EXPECT_TRUE(statusStarting->has_slave_id());
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
// Now send the acknowledgement.
Future<mesos::scheduler::Call> acknowledgement = FUTURE_CALL(
@@ -489,7 +510,7 @@ TEST_F(HTTPCommandExecutorTest, ExplicitAcknowledgements)
_,
master.get()->pid);
- driver.acknowledgeStatusUpdate(statusRunning.get());
+ driver.acknowledgeStatusUpdate(statusStarting.get());
AWAIT_READY(acknowledgement);
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/container_logger_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/container_logger_tests.cpp b/src/tests/container_logger_tests.cpp
index fb8e441..6080203 100644
--- a/src/tests/container_logger_tests.cpp
+++ b/src/tests/container_logger_tests.cpp
@@ -188,15 +188,20 @@ TEST_F(ContainerLoggerTest, DefaultToSandbox)
// We'll start a task that outputs to stdout.
TaskInfo task = createTask(offers.get()[0], "echo 'Hello World!'");
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusFinished;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusFinished))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -296,15 +301,20 @@ TEST_F(ContainerLoggerTest, LOGROTATE_RotateInSandbox)
"i=0; while [ $i -lt 11264 ]; "
"do printf '%-1024d\\n' $i; i=$((i+1)); done");
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusFinished;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusFinished))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -447,15 +457,20 @@ TEST_F(ContainerLoggerTest, LOGROTATE_CustomRotateOptions)
variable->set_name("CONTAINER_LOGGER_LOGROTATE_STDOUT_OPTIONS");
variable->set_value(customConfig);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusFinished;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusFinished))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -545,15 +560,20 @@ TEST_F(ContainerLoggerTest, LOGROTATE_ModuleFDOwnership)
// Start a task that will keep running until the end of the test.
TaskInfo task = createTask(offers.get()[0], "sleep 100");
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusKilled;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusKilled))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/containerizer/environment_secret_isolator_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/containerizer/environment_secret_isolator_tests.cpp b/src/tests/containerizer/environment_secret_isolator_tests.cpp
index cf7b9eb..fd1cd46 100644
--- a/src/tests/containerizer/environment_secret_isolator_tests.cpp
+++ b/src/tests/containerizer/environment_secret_isolator_tests.cpp
@@ -107,15 +107,19 @@ TEST_F(EnvironmentSecretIsolatorTest, ResolveSecret)
Resources::parse("cpus:0.1;mem:32").get(),
command);
- // NOTE: Successful tasks will output two status updates.
+ // NOTE: Successful tasks will output three status updates.
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusFinished;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusFinished));
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting.get().state());
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
AWAIT_READY(statusFinished);
@@ -212,9 +216,11 @@ TEST_F(EnvironmentSecretIsolatorTest, ResolveSecretDefaultExecutor)
command);
// NOTE: Successful tasks will output two status updates.
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusFinished;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusFinished));
@@ -222,6 +228,8 @@ TEST_F(EnvironmentSecretIsolatorTest, ResolveSecretDefaultExecutor)
driver.acceptOffers({offer.id()}, {LAUNCH_GROUP(executorInfo, taskGroup)});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
AWAIT_READY(statusFinished);
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/containerizer/posix_rlimits_isolator_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/containerizer/posix_rlimits_isolator_tests.cpp b/src/tests/containerizer/posix_rlimits_isolator_tests.cpp
index 0030cd1..f639cac 100644
--- a/src/tests/containerizer/posix_rlimits_isolator_tests.cpp
+++ b/src/tests/containerizer/posix_rlimits_isolator_tests.cpp
@@ -179,14 +179,20 @@ TEST_F(PosixRLimitsIsolatorTest, UnsetLimits)
container->mutable_rlimit_info()->CopyFrom(rlimitInfo);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusFinal;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusFinal));
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(task.task_id(), statusStarting->task_id());
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(task.task_id(), statusRunning->task_id());
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -321,14 +327,20 @@ TEST_F(PosixRLimitsIsolatorTest, TaskExceedingLimit)
container->mutable_rlimit_info()->CopyFrom(rlimitInfo);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusFailed;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusFailed));
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(task.task_id(), statusStarting->task_id());
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(task.task_id(), statusRunning->task_id());
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -476,14 +488,15 @@ TEST_F(PosixRLimitsIsolatorTest, NestedContainers)
// that they transition from TASK_RUNNING to TASK_FINISHED.
enum class Stage
{
+ STARTING,
INITIAL,
RUNNING,
FINISHED
};
hashmap<TaskID, Stage> taskStages;
- taskStages[task1.task_id()] = Stage::INITIAL;
- taskStages[task2.task_id()] = Stage::INITIAL;
+ taskStages[task1.task_id()] = Stage::STARTING;
+ taskStages[task2.task_id()] = Stage::STARTING;
foreach (const Future<TaskStatus>& taskStatus, taskStatuses) {
AWAIT_READY(taskStatus);
@@ -492,6 +505,13 @@ TEST_F(PosixRLimitsIsolatorTest, NestedContainers)
ASSERT_SOME(taskStage);
switch (taskStage.get()) {
+ case Stage::STARTING: {
+ ASSERT_EQ(TASK_STARTING, taskStatus->state())
+ << taskStatus->DebugString();
+
+ taskStages[taskStatus->task_id()] = Stage::INITIAL;
+ break;
+ }
case Stage::INITIAL: {
ASSERT_EQ(TASK_RUNNING, taskStatus->state())
<< taskStatus->DebugString();
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/default_executor_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/default_executor_tests.cpp b/src/tests/default_executor_tests.cpp
index 2b4c643..e6adcbb 100644
--- a/src/tests/default_executor_tests.cpp
+++ b/src/tests/default_executor_tests.cpp
@@ -175,9 +175,14 @@ TEST_P(DefaultExecutorTest, TaskRunning)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
- Future<v1::scheduler::Event::Update> update;
+ Future<v1::scheduler::Event::Update> startingUpdate;
+ Future<v1::scheduler::Event::Update> runningUpdate;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(FutureArg<1>(&update));
+ .WillOnce(DoAll(
+ FutureArg<1>(&startingUpdate),
+ v1::scheduler::SendAcknowledge(frameworkId, agentId)))
+ .WillOnce(FutureArg<1>(&runningUpdate))
+ .WillRepeatedly(Return());
v1::TaskInfo taskInfo =
v1::createTask(agentId, resources, SLEEP_COMMAND(1000));
@@ -189,11 +194,13 @@ TEST_P(DefaultExecutorTest, TaskRunning)
{v1::LAUNCH_GROUP(
executorInfo, v1::createTaskGroupInfo({taskInfo}))}));
- AWAIT_READY(update);
+ AWAIT_READY(startingUpdate);
- ASSERT_EQ(TASK_RUNNING, update->status().state());
- EXPECT_EQ(taskInfo.task_id(), update->status().task_id());
- EXPECT_TRUE(update->status().has_timestamp());
+ ASSERT_EQ(TASK_STARTING, startingUpdate->status().state());
+ EXPECT_EQ(taskInfo.task_id(), startingUpdate->status().task_id());
+ EXPECT_TRUE(startingUpdate->status().has_timestamp());
+
+ AWAIT_READY(runningUpdate);
// Ensure that the task sandbox symbolic link is created.
EXPECT_TRUE(os::exists(path::join(
@@ -289,16 +296,26 @@ TEST_P(DefaultExecutorTest, KillTask)
const hashset<v1::TaskID> tasks1{taskInfo1.task_id(), taskInfo2.task_id()};
+ Future<v1::scheduler::Event::Update> startingUpdate1;
+ Future<v1::scheduler::Event::Update> startingOrRunningUpdate1;
+ Future<v1::scheduler::Event::Update> startingOrRunningUpdate2;
Future<v1::scheduler::Event::Update> runningUpdate1;
- Future<v1::scheduler::Event::Update> runningUpdate2;
EXPECT_CALL(*scheduler, update(_, _))
.WillOnce(
DoAll(
- FutureArg<1>(&runningUpdate1),
+ FutureArg<1>(&startingUpdate1),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
.WillOnce(
DoAll(
- FutureArg<1>(&runningUpdate2),
+ FutureArg<1>(&startingOrRunningUpdate1),
+ v1::scheduler::SendAcknowledge(frameworkId, agentId)))
+ .WillOnce(
+ DoAll(
+ FutureArg<1>(&startingOrRunningUpdate2),
+ v1::scheduler::SendAcknowledge(frameworkId, agentId)))
+ .WillOnce(
+ DoAll(
+ FutureArg<1>(&runningUpdate1),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
Future<v1::scheduler::Event::Offers> offers2;
@@ -319,17 +336,19 @@ TEST_P(DefaultExecutorTest, KillTask)
mesos.send(call);
}
+ AWAIT_READY(startingUpdate1);
+ ASSERT_EQ(TASK_STARTING, startingUpdate1->status().state());
+
AWAIT_READY(runningUpdate1);
ASSERT_EQ(TASK_RUNNING, runningUpdate1->status().state());
- AWAIT_READY(runningUpdate2);
- ASSERT_EQ(TASK_RUNNING, runningUpdate2->status().state());
-
// When running a task, TASK_RUNNING updates for the tasks in a
// task group can be received in any order.
const hashset<v1::TaskID> tasksRunning{
- runningUpdate1->status().task_id(),
- runningUpdate2->status().task_id()};
+ startingUpdate1->status().task_id(),
+ startingOrRunningUpdate1->status().task_id(),
+ startingOrRunningUpdate2->status().task_id(),
+ runningUpdate1->status().task_id()};
ASSERT_EQ(tasks1, tasksRunning);
@@ -339,10 +358,15 @@ TEST_P(DefaultExecutorTest, KillTask)
v1::TaskInfo taskInfo3 =
v1::createTask(agentId, resources, SLEEP_COMMAND(1000));
+ Future<v1::scheduler::Event::Update> startingUpdate3;
Future<v1::scheduler::Event::Update> runningUpdate3;
EXPECT_CALL(*scheduler, update(_, _))
.WillOnce(
DoAll(
+ FutureArg<1>(&startingUpdate3),
+ v1::scheduler::SendAcknowledge(frameworkId, offer2.agent_id())))
+ .WillOnce(
+ DoAll(
FutureArg<1>(&runningUpdate3),
v1::scheduler::SendAcknowledge(frameworkId, offer2.agent_id())));
@@ -354,6 +378,10 @@ TEST_P(DefaultExecutorTest, KillTask)
{v1::LAUNCH_GROUP(
executorInfo, v1::createTaskGroupInfo({taskInfo3}))}));
+ AWAIT_READY(startingUpdate3);
+ ASSERT_EQ(TASK_STARTING, startingUpdate3->status().state());
+ ASSERT_EQ(taskInfo3.task_id(), startingUpdate3->status().task_id());
+
AWAIT_READY(runningUpdate3);
ASSERT_EQ(TASK_RUNNING, runningUpdate3->status().state());
ASSERT_EQ(taskInfo3.task_id(), runningUpdate3->status().task_id());
@@ -485,6 +513,22 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
+ auto acknowledge = [&](const Future<v1::scheduler::Event::Update>& update) {
+ Call call;
+ call.mutable_framework_id()->CopyFrom(frameworkId);
+ call.set_type(Call::ACKNOWLEDGE);
+
+ Call::Acknowledge* acknowledge = call.mutable_acknowledge();
+
+ acknowledge->mutable_task_id()->CopyFrom(
+ update->status().task_id());
+
+ acknowledge->mutable_agent_id()->CopyFrom(agentId);
+ acknowledge->set_uuid(update->status().uuid());
+
+ mesos.send(call);
+ };
+
// The first task exits with a non-zero status code.
v1::TaskInfo taskInfo1 = v1::createTask(agentId, resources, "exit 1");
@@ -493,9 +537,13 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
const hashset<v1::TaskID> tasks{taskInfo1.task_id(), taskInfo2.task_id()};
+ Future<v1::scheduler::Event::Update> startingUpdate1;
+ Future<v1::scheduler::Event::Update> startingUpdate2;
Future<v1::scheduler::Event::Update> runningUpdate1;
Future<v1::scheduler::Event::Update> runningUpdate2;
EXPECT_CALL(*scheduler, update(_, _))
+ .WillOnce(FutureArg<1>(&startingUpdate1))
+ .WillOnce(FutureArg<1>(&startingUpdate2))
.WillOnce(FutureArg<1>(&runningUpdate1))
.WillOnce(FutureArg<1>(&runningUpdate2));
@@ -506,6 +554,15 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
{v1::LAUNCH_GROUP(
executorInfo, v1::createTaskGroupInfo({taskInfo1, taskInfo2}))}));
+ AWAIT_READY(startingUpdate1);
+ ASSERT_EQ(TASK_STARTING, startingUpdate1->status().state());
+
+ AWAIT_READY(startingUpdate2);
+ ASSERT_EQ(TASK_STARTING, startingUpdate2->status().state());
+
+ acknowledge(startingUpdate1);
+ acknowledge(startingUpdate2);
+
AWAIT_READY(runningUpdate1);
ASSERT_EQ(TASK_RUNNING, runningUpdate1->status().state());
@@ -527,38 +584,8 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
.WillOnce(FutureArg<1>(&update2));
// Acknowledge the TASK_RUNNING updates to receive the next updates.
-
- {
- Call call;
- call.mutable_framework_id()->CopyFrom(frameworkId);
- call.set_type(Call::ACKNOWLEDGE);
-
- Call::Acknowledge* acknowledge = call.mutable_acknowledge();
-
- acknowledge->mutable_task_id()->CopyFrom(
- runningUpdate1->status().task_id());
-
- acknowledge->mutable_agent_id()->CopyFrom(offer.agent_id());
- acknowledge->set_uuid(runningUpdate1->status().uuid());
-
- mesos.send(call);
- }
-
- {
- Call call;
- call.mutable_framework_id()->CopyFrom(frameworkId);
- call.set_type(Call::ACKNOWLEDGE);
-
- Call::Acknowledge* acknowledge = call.mutable_acknowledge();
-
- acknowledge->mutable_task_id()->CopyFrom(
- runningUpdate2->status().task_id());
-
- acknowledge->mutable_agent_id()->CopyFrom(offer.agent_id());
- acknowledge->set_uuid(runningUpdate2->status().uuid());
-
- mesos.send(call);
- }
+ acknowledge(runningUpdate1);
+ acknowledge(runningUpdate2);
// Updates for the tasks in a task group can be received in any order.
set<pair<v1::TaskID, v1::TaskState>> taskStates;
@@ -656,7 +683,7 @@ TEST_P(DefaultExecutorTest, TaskUsesExecutor)
AWAIT_READY(update);
- ASSERT_EQ(TASK_RUNNING, update->status().state());
+ ASSERT_EQ(TASK_STARTING, update->status().state());
EXPECT_EQ(taskInfo.task_id(), update->status().task_id());
EXPECT_TRUE(update->status().has_timestamp());
}
@@ -821,11 +848,16 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnTaskFailure)
// The task exits with a non-zero status code.
v1::TaskInfo taskInfo = v1::createTask(agentId, resources, "exit 1");
+ Future<v1::scheduler::Event::Update> startingUpdate;
Future<v1::scheduler::Event::Update> runningUpdate;
Future<v1::scheduler::Event::Update> failedUpdate;
EXPECT_CALL(*scheduler, update(_, _))
.WillOnce(
DoAll(
+ FutureArg<1>(&startingUpdate),
+ v1::scheduler::SendAcknowledge(frameworkId, agentId)))
+ .WillOnce(
+ DoAll(
FutureArg<1>(&runningUpdate),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
.WillOnce(FutureArg<1>(&failedUpdate));
@@ -841,6 +873,9 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnTaskFailure)
{v1::LAUNCH_GROUP(
executorInfo, v1::createTaskGroupInfo({taskInfo}))}));
+ AWAIT_READY(startingUpdate);
+ ASSERT_EQ(TASK_STARTING, startingUpdate->status().state());
+
AWAIT_READY(runningUpdate);
ASSERT_EQ(TASK_RUNNING, runningUpdate->status().state());
@@ -922,11 +957,21 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnKillTask)
const hashset<v1::TaskID> tasks{taskInfo1.task_id(), taskInfo2.task_id()};
+ Future<v1::scheduler::Event::Update> startingUpdate1;
+ Future<v1::scheduler::Event::Update> startingUpdate2;
Future<v1::scheduler::Event::Update> runningUpdate1;
Future<v1::scheduler::Event::Update> runningUpdate2;
EXPECT_CALL(*scheduler, update(_, _))
.WillOnce(
DoAll(
+ FutureArg<1>(&startingUpdate1),
+ v1::scheduler::SendAcknowledge(frameworkId, agentId)))
+ .WillOnce(
+ DoAll(
+ FutureArg<1>(&startingUpdate2),
+ v1::scheduler::SendAcknowledge(frameworkId, agentId)))
+ .WillOnce(
+ DoAll(
FutureArg<1>(&runningUpdate1),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
.WillOnce(
@@ -945,8 +990,11 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnKillTask)
{v1::LAUNCH_GROUP(
executorInfo, v1::createTaskGroupInfo({taskInfo1, taskInfo2}))}));
- AWAIT_READY(runningUpdate1);
- ASSERT_EQ(TASK_RUNNING, runningUpdate1->status().state());
+ AWAIT_READY(startingUpdate1);
+ ASSERT_EQ(TASK_STARTING, startingUpdate1->status().state());
+
+ // We only check the first and last update, because the other two might
+ // arrive in a different order.
AWAIT_READY(runningUpdate2);
ASSERT_EQ(TASK_RUNNING, runningUpdate2->status().state());
@@ -954,6 +1002,8 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnKillTask)
// When running a task, TASK_RUNNING updates for the tasks in a
// task group can be received in any order.
const hashset<v1::TaskID> tasksRunning{
+ startingUpdate1->status().task_id(),
+ startingUpdate2->status().task_id(),
runningUpdate1->status().task_id(),
runningUpdate2->status().task_id()};
@@ -1070,15 +1120,15 @@ TEST_P(DefaultExecutorTest, ReservedResources)
v1::Offer::Operation launchGroup =
v1::LAUNCH_GROUP(executorInfo, v1::createTaskGroupInfo({taskInfo}));
- Future<v1::scheduler::Event::Update> runningUpdate;
+ Future<v1::scheduler::Event::Update> startingUpdate;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(FutureArg<1>(&runningUpdate));
+ .WillOnce(FutureArg<1>(&startingUpdate));
mesos.send(v1::createCallAccept(frameworkId, offer, {reserve, launchGroup}));
- AWAIT_READY(runningUpdate);
- ASSERT_EQ(TASK_RUNNING, runningUpdate->status().state());
- ASSERT_EQ(taskInfo.task_id(), runningUpdate->status().task_id());
+ AWAIT_READY(startingUpdate);
+ ASSERT_EQ(TASK_STARTING, startingUpdate->status().state());
+ ASSERT_EQ(taskInfo.task_id(), startingUpdate->status().task_id());
}
@@ -1155,9 +1205,17 @@ TEST_P(DefaultExecutorTest, SigkillExecutor)
v1::Resources::parse("cpus:0.1;mem:32;disk:32").get(),
"sleep 1000");
- Future<v1::scheduler::Event::Update> update;
+ Future<v1::scheduler::Event::Update> startingUpdate;
+ Future<v1::scheduler::Event::Update> runningUpdate;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(FutureArg<1>(&update));
+ .WillOnce(DoAll(
+ FutureArg<1>(&startingUpdate),
+ v1::scheduler::SendAcknowledge(frameworkId, agentId)))
+ .WillOnce(DoAll(
+ FutureArg<1>(&runningUpdate),
+ v1::scheduler::SendAcknowledge(frameworkId, agentId)))
+ .WillRepeatedly(Return());
+
v1::Offer::Operation launchGroup = v1::LAUNCH_GROUP(
executorInfo,
@@ -1165,14 +1223,19 @@ TEST_P(DefaultExecutorTest, SigkillExecutor)
mesos.send(v1::createCallAccept(frameworkId, offer, {launchGroup}));
- AWAIT_READY(update);
+ AWAIT_READY(startingUpdate);
- ASSERT_EQ(TASK_RUNNING, update->status().state());
- EXPECT_EQ(taskInfo.task_id(), update->status().task_id());
- EXPECT_TRUE(update->status().has_timestamp());
- ASSERT_TRUE(update->status().has_container_status());
+ ASSERT_EQ(TASK_STARTING, startingUpdate->status().state());
+ EXPECT_EQ(taskInfo.task_id(), startingUpdate->status().task_id());
+
+ AWAIT_READY(runningUpdate);
- v1::ContainerStatus status = update->status().container_status();
+ ASSERT_EQ(TASK_RUNNING, runningUpdate->status().state());
+ EXPECT_EQ(taskInfo.task_id(), runningUpdate->status().task_id());
+ EXPECT_TRUE(runningUpdate->status().has_timestamp());
+ ASSERT_TRUE(runningUpdate->status().has_container_status());
+
+ v1::ContainerStatus status = runningUpdate->status().container_status();
ASSERT_TRUE(status.has_container_id());
EXPECT_TRUE(status.container_id().has_parent());
@@ -1443,11 +1506,16 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorTest, TaskWithFileURI)
taskInfo.mutable_command()->add_uris()->set_value("file://" + testFilePath);
+ Future<v1::scheduler::Event::Update> startingUpdate;
Future<v1::scheduler::Event::Update> runningUpdate;
Future<v1::scheduler::Event::Update> finishedUpdate;
EXPECT_CALL(*scheduler, update(_, _))
.WillOnce(
DoAll(
+ FutureArg<1>(&startingUpdate),
+ v1::scheduler::SendAcknowledge(frameworkId, agentId)))
+ .WillOnce(
+ DoAll(
FutureArg<1>(&runningUpdate),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
.WillOnce(
@@ -1462,6 +1530,10 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorTest, TaskWithFileURI)
{v1::LAUNCH_GROUP(
executorInfo, v1::createTaskGroupInfo({taskInfo}))}));
+ AWAIT_READY(startingUpdate);
+ ASSERT_EQ(TASK_STARTING, startingUpdate->status().state());
+ ASSERT_EQ(taskInfo.task_id(), startingUpdate->status().task_id());
+
AWAIT_READY(runningUpdate);
ASSERT_EQ(TASK_RUNNING, runningUpdate->status().state());
ASSERT_EQ(taskInfo.task_id(), runningUpdate->status().task_id());
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/disk_quota_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/disk_quota_tests.cpp b/src/tests/disk_quota_tests.cpp
index 742b6e1..fc29799 100644
--- a/src/tests/disk_quota_tests.cpp
+++ b/src/tests/disk_quota_tests.cpp
@@ -219,14 +219,20 @@ TEST_F(DiskQuotaTest, DiskUsageExceedsQuota)
Resources::parse("cpus:1;mem:128;disk:1").get(),
"dd if=/dev/zero of=file bs=1048576 count=2 && sleep 1000");
+ Future<TaskStatus> status0;
Future<TaskStatus> status1;
Future<TaskStatus> status2;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&status0))
.WillOnce(FutureArg<1>(&status1))
.WillOnce(FutureArg<1>(&status2));
driver.launchTasks(offer.id(), {task});
+ AWAIT_READY(status0);
+ EXPECT_EQ(task.task_id(), status0->task_id());
+ EXPECT_EQ(TASK_STARTING, status0->state());
+
AWAIT_READY(status1);
EXPECT_EQ(task.task_id(), status1->task_id());
EXPECT_EQ(TASK_RUNNING, status1->state());
@@ -313,9 +319,11 @@ TEST_F(DiskQuotaTest, VolumeUsageExceedsQuota)
taskResources,
"dd if=/dev/zero of=volume_path/file bs=1048576 count=2 && sleep 1000");
+ Future<TaskStatus> status0;
Future<TaskStatus> status1;
Future<TaskStatus> status2;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&status0))
.WillOnce(FutureArg<1>(&status1))
.WillOnce(FutureArg<1>(&status2));
@@ -325,6 +333,10 @@ TEST_F(DiskQuotaTest, VolumeUsageExceedsQuota)
{CREATE(volume),
LAUNCH({task})});
+ AWAIT_READY(status0);
+ EXPECT_EQ(task.task_id(), status0->task_id());
+ EXPECT_EQ(TASK_STARTING, status0->state());
+
AWAIT_READY(status1);
EXPECT_EQ(task.task_id(), status1->task_id());
EXPECT_EQ(TASK_RUNNING, status1->state());
@@ -395,16 +407,22 @@ TEST_F(DiskQuotaTest, NoQuotaEnforcement)
Resources::parse("cpus:1;mem:128;disk:1").get(),
"dd if=/dev/zero of=file bs=1048576 count=2 && sleep 1000");
- Future<TaskStatus> status;
+ Future<TaskStatus> statusStarting;
+ Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&status))
+ .WillOnce(FutureArg<1>(&statusStarting))
+ .WillOnce(FutureArg<1>(&statusRunning))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offer.id(), {task});
- AWAIT_READY(status);
- EXPECT_EQ(task.task_id(), status->task_id());
- EXPECT_EQ(TASK_RUNNING, status->state());
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(task.task_id(), statusStarting->task_id());
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
+ AWAIT_READY(statusRunning);
+ EXPECT_EQ(task.task_id(), statusRunning->task_id());
+ EXPECT_EQ(TASK_RUNNING, statusRunning->state());
Future<hashset<ContainerID>> containers = containerizer->containers();
@@ -523,9 +541,11 @@ TEST_F(DiskQuotaTest, ResourceStatistics)
"dd if=/dev/zero of=path1/file bs=1048576 count=2 && "
"sleep 1000");
+ Future<TaskStatus> status0;
Future<TaskStatus> status1;
Future<TaskStatus> status2;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&status0))
.WillOnce(FutureArg<1>(&status1))
.WillOnce(FutureArg<1>(&status2))
.WillRepeatedly(Return()); // Ignore subsequent updates.
@@ -535,6 +555,10 @@ TEST_F(DiskQuotaTest, ResourceStatistics)
{CREATE(volume),
LAUNCH({task})});
+ AWAIT_READY(status0);
+ EXPECT_EQ(task.task_id(), status0->task_id());
+ EXPECT_EQ(TASK_STARTING, status0->state());
+
AWAIT_READY(status1);
EXPECT_EQ(task.task_id(), status1->task_id());
EXPECT_EQ(TASK_RUNNING, status1->state());
@@ -654,16 +678,22 @@ TEST_F(DiskQuotaTest, SlaveRecovery)
Resources::parse("cpus:1;mem:128;disk:3").get(),
"dd if=/dev/zero of=file bs=1048576 count=2 && sleep 1000");
- Future<TaskStatus> status;
+ Future<TaskStatus> statusStarting;
+ Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&status))
+ .WillOnce(FutureArg<1>(&statusStarting))
+ .WillOnce(FutureArg<1>(&statusRunning))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offer.id(), {task});
- AWAIT_READY(status);
- EXPECT_EQ(task.task_id(), status->task_id());
- EXPECT_EQ(TASK_RUNNING, status->state());
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(task.task_id(), statusStarting->task_id());
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
+ AWAIT_READY(statusRunning);
+ EXPECT_EQ(task.task_id(), statusRunning->task_id());
+ EXPECT_EQ(TASK_RUNNING, statusRunning->state());
Future<hashset<ContainerID>> containers = containerizer->containers();
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/fault_tolerance_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/fault_tolerance_tests.cpp b/src/tests/fault_tolerance_tests.cpp
index c34850a..33a2220 100644
--- a/src/tests/fault_tolerance_tests.cpp
+++ b/src/tests/fault_tolerance_tests.cpp
@@ -2209,8 +2209,10 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
TaskInfo task = createTask(offer, "sleep 60");
+ Future<TaskStatus> startingStatus;
Future<TaskStatus> runningStatus;
EXPECT_CALL(sched1, statusUpdate(&driver1, _))
+ .WillOnce(FutureArg<1>(&startingStatus))
.WillOnce(FutureArg<1>(&runningStatus));
Future<Nothing> statusUpdateAck = FUTURE_DISPATCH(
@@ -2218,6 +2220,10 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
driver1.launchTasks(offer.id(), {task});
+ AWAIT_READY(startingStatus);
+ EXPECT_EQ(TASK_STARTING, startingStatus->state());
+ EXPECT_EQ(task.task_id(), startingStatus->task_id());
+
AWAIT_READY(runningStatus);
EXPECT_EQ(TASK_RUNNING, runningStatus->state());
EXPECT_EQ(task.task_id(), runningStatus->task_id());
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/health_check_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/health_check_tests.cpp b/src/tests/health_check_tests.cpp
index f4b50b1..81248f3 100644
--- a/src/tests/health_check_tests.cpp
+++ b/src/tests/health_check_tests.cpp
@@ -330,15 +330,20 @@ TEST_F(HealthCheckTest, HealthyTask)
vector<TaskInfo> tasks =
populateTasks(SLEEP_COMMAND(120), "exit 0", offers.get()[0]);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy));
driver.launchTasks(offers.get()[0].id(), tasks);
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -400,7 +405,7 @@ TEST_F(HealthCheckTest, HealthyTask)
ASSERT_SOME(parse);
Result<JSON::Value> find = parse->find<JSON::Value>(
- "frameworks[0].tasks[0].statuses[0].healthy");
+ "frameworks[0].tasks[0].statuses[1].healthy");
EXPECT_SOME_TRUE(find);
}
@@ -418,7 +423,7 @@ TEST_F(HealthCheckTest, HealthyTask)
ASSERT_SOME(parse);
Result<JSON::Value> find = parse->find<JSON::Value>(
- "frameworks[0].executors[0].tasks[0].statuses[0].healthy");
+ "frameworks[0].executors[0].tasks[0].statuses[1].healthy");
EXPECT_SOME_TRUE(find);
}
@@ -488,15 +493,20 @@ TEST_F(HealthCheckTest, ROOT_HealthyTaskWithContainerImage)
health->set_type(HealthCheck::COMMAND);
health->mutable_command()->set_value("exit 0");
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy));
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -628,10 +638,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(HealthCheckTest, ROOT_DOCKER_DockerHealthyTask)
Invoke(&containerizer,
&MockDockerContainerizer::_launch)));
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy));
@@ -639,6 +651,9 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(HealthCheckTest, ROOT_DOCKER_DockerHealthyTask)
AWAIT_READY(containerId);
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusRunning->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -715,15 +730,20 @@ TEST_F(HealthCheckTest, HealthyTaskNonShell)
vector<TaskInfo> tasks =
populateTasks(SLEEP_COMMAND(120), command, offers.get()[0]);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy));
driver.launchTasks(offers.get()[0].id(), tasks);
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_RUNNING, statusRunning->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -778,12 +798,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(HealthCheckTest, HealthStatusChange)
0,
3);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
Future<TaskStatus> statusUnhealthy;
Future<TaskStatus> statusHealthyAgain;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy))
.WillOnce(FutureArg<1>(&statusUnhealthy))
@@ -792,6 +814,9 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(HealthCheckTest, HealthStatusChange)
driver.launchTasks(offers.get()[0].id(), tasks);
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -920,12 +945,14 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
Invoke(&containerizer,
&MockDockerContainerizer::_launch)));
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusUnhealthy;
Future<TaskStatus> statusHealthy;
Future<TaskStatus> statusUnhealthyAgain;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusUnhealthy))
.WillOnce(FutureArg<1>(&statusHealthy))
@@ -934,6 +961,9 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
driver.launchTasks(offers.get()[0].id(), tasks);
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -1018,6 +1048,7 @@ TEST_F(HealthCheckTest, ConsecutiveFailures)
SLEEP_COMMAND(120), "exit 1", offers.get()[0], 0, 4);
// Expecting four unhealthy updates and one final kill update.
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> status1;
Future<TaskStatus> status2;
@@ -1026,6 +1057,7 @@ TEST_F(HealthCheckTest, ConsecutiveFailures)
Future<TaskStatus> statusKilled;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&status1))
.WillOnce(FutureArg<1>(&status2))
@@ -1035,6 +1067,9 @@ TEST_F(HealthCheckTest, ConsecutiveFailures)
driver.launchTasks(offers.get()[0].id(), tasks);
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -1109,15 +1144,20 @@ TEST_F(HealthCheckTest, EnvironmentSetup)
vector<TaskInfo> tasks = populateTasks(
SLEEP_COMMAND(120), "exit $STATUS", offers.get()[0], 0, None(), env);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy));
driver.launchTasks(offers.get()[0].id(), tasks);
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -1170,10 +1210,12 @@ TEST_F(HealthCheckTest, GracePeriod)
vector<TaskInfo> tasks = populateTasks(
SLEEP_COMMAND(2), falseCommand, offers.get()[0], 9999);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusFinished;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusFinished))
.WillRepeatedly(Return());
@@ -1232,17 +1274,22 @@ TEST_F(HealthCheckTest, CheckCommandTimeout)
1);
// Expecting one unhealthy update and one final kill update.
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusUnhealthy;
Future<TaskStatus> statusKilled;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusUnhealthy))
.WillOnce(FutureArg<1>(&statusKilled));
driver.launchTasks(offers.get()[0].id(), tasks);
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -1303,11 +1350,13 @@ TEST_F(HealthCheckTest, HealthyToUnhealthyTransitionWithinGracePeriod)
9999,
0);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
Future<TaskStatus> statusUnhealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy))
.WillOnce(FutureArg<1>(&statusUnhealthy))
@@ -1315,6 +1364,9 @@ TEST_F(HealthCheckTest, HealthyToUnhealthyTransitionWithinGracePeriod)
driver.launchTasks(offers.get()[0].id(), tasks);
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -1395,16 +1447,21 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(HealthCheckTest, HealthyTaskViaHTTP)
task.mutable_health_check()->CopyFrom(healthCheck);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -1483,16 +1540,21 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(HealthCheckTest, HealthyTaskViaHTTPWithoutType)
task.mutable_health_check()->CopyFrom(healthCheck);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -1563,16 +1625,21 @@ TEST_F(HealthCheckTest, HealthyTaskViaTCP)
task.mutable_health_check()->CopyFrom(healthCheck);
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting->state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -2317,10 +2384,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
AWAIT_READY(offers);
ASSERT_FALSE(offers->empty());
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy));
@@ -2360,6 +2429,9 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
{offers->front().id()}, {LAUNCH_GROUP(executor, taskGroup)});
AWAIT_READY(statusRunning);
+ EXPECT_EQ(TASK_STARTING, statusStarting.get().state());
+
+ AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
AWAIT_READY(statusHealthy);
@@ -2446,10 +2518,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
AWAIT_READY(offers);
ASSERT_FALSE(offers->empty());
+ Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning))
.WillOnce(FutureArg<1>(&statusHealthy));
@@ -2495,6 +2569,9 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
driver.acceptOffers(
{offers->front().id()}, {LAUNCH_GROUP(executor, taskGroup)});
+ AWAIT_READY(statusStarting);
+ EXPECT_EQ(TASK_STARTING, statusStarting.get().state());
+
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/master_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/master_tests.cpp b/src/tests/master_tests.cpp
index 4c77601..1a384bb 100644
--- a/src/tests/master_tests.cpp
+++ b/src/tests/master_tests.cpp
@@ -2786,22 +2786,34 @@ TEST_F(MasterTest, UnreachableTaskAfterFailover)
TaskInfo task = createTask(offers.get()[0], "sleep 100");
+ Future<TaskStatus> startingStatus;
Future<TaskStatus> runningStatus;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&runningStatus));
+ .WillOnce(FutureArg<1>(&startingStatus))
+ .WillOnce(FutureArg<1>(&runningStatus))
+ .WillRepeatedly(Return());
+
+ Future<Nothing> statusUpdateAck1 = FUTURE_DISPATCH(
+ slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
- Future<Nothing> statusUpdateAck = FUTURE_DISPATCH(
+ Future<Nothing> statusUpdateAck2 = FUTURE_DISPATCH(
slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(startingStatus);
+ EXPECT_EQ(TASK_STARTING, startingStatus->state());
+ EXPECT_EQ(task.task_id(), startingStatus->task_id());
+
+ const SlaveID slaveId = startingStatus->slave_id();
+
+ AWAIT_READY(statusUpdateAck1);
+
AWAIT_READY(runningStatus);
EXPECT_EQ(TASK_RUNNING, runningStatus->state());
EXPECT_EQ(task.task_id(), runningStatus->task_id());
- const SlaveID slaveId = runningStatus->slave_id();
-
- AWAIT_READY(statusUpdateAck);
+ AWAIT_READY(statusUpdateAck2);
// Step 4: Simulate master failover. We leave the slave without a
// master so it does not attempt to re-register.
@@ -6830,20 +6842,31 @@ TEST_F(MasterTest, FailoverAgentReregisterFirst)
TaskInfo task = createTask(offers.get()[0], "sleep 100");
+ Future<TaskStatus> startingStatus;
Future<TaskStatus> runningStatus;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&startingStatus))
.WillOnce(FutureArg<1>(&runningStatus));
- Future<Nothing> statusUpdateAck = FUTURE_DISPATCH(
+ Future<Nothing> statusUpdateAck1 = FUTURE_DISPATCH(
+ slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
+
+ Future<Nothing> statusUpdateAck2 = FUTURE_DISPATCH(
slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
driver.launchTasks(offers.get()[0].id(), {task});
+ AWAIT_READY(startingStatus);
+ EXPECT_EQ(TASK_STARTING, startingStatus->state());
+ EXPECT_EQ(task.task_id(), startingStatus->task_id());
+
+ AWAIT_READY(statusUpdateAck1);
+
AWAIT_READY(runningStatus);
EXPECT_EQ(TASK_RUNNING, runningStatus->state());
EXPECT_EQ(task.task_id(), runningStatus->task_id());
- AWAIT_READY(statusUpdateAck);
+ AWAIT_READY(statusUpdateAck2);
// Simulate master failover. We leave the scheduler without a master
// so it does not attempt to re-register yet.
@@ -7050,22 +7073,33 @@ TEST_F(MasterTest, AgentRestartNoReregister)
TaskInfo task = createTask(offer, "sleep 100");
+ Future<TaskStatus> startingStatus;
Future<TaskStatus> runningStatus;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&startingStatus))
.WillOnce(FutureArg<1>(&runningStatus));
- Future<Nothing> statusUpdateAck = FUTURE_DISPATCH(
- slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
+ Future<Nothing> statusUpdateAck1 = FUTURE_DISPATCH(
+ slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
+
+ Future<Nothing> statusUpdateAck2 = FUTURE_DISPATCH(
+ slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
driver.launchTasks(offer.id(), {task});
+ AWAIT_READY(startingStatus);
+ EXPECT_EQ(TASK_STARTING, startingStatus->state());
+ EXPECT_EQ(task.task_id(), startingStatus->task_id());
+
+ AWAIT_READY(statusUpdateAck1);
+
AWAIT_READY(runningStatus);
EXPECT_EQ(TASK_RUNNING, runningStatus->state());
EXPECT_EQ(task.task_id(), runningStatus->task_id());
const SlaveID slaveId = runningStatus->slave_id();
- AWAIT_READY(statusUpdateAck);
+ AWAIT_READY(statusUpdateAck2);
Clock::pause();
@@ -7418,12 +7452,18 @@ TEST_F(MasterTest, TaskWithTinyResources)
Resources::parse("cpus:0.00001;mem:1").get(),
SLEEP_COMMAND(1000));
+ Future<TaskStatus> startingStatus;
Future<TaskStatus> runningStatus;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&startingStatus))
.WillOnce(FutureArg<1>(&runningStatus));
driver.launchTasks(offer.id(), {task});
+ AWAIT_READY(startingStatus);
+ EXPECT_EQ(TASK_STARTING, startingStatus->state());
+ EXPECT_EQ(task.task_id(), startingStatus->task_id());
+
AWAIT_READY(runningStatus);
EXPECT_EQ(TASK_RUNNING, runningStatus->state());
EXPECT_EQ(task.task_id(), runningStatus->task_id());
@@ -7508,12 +7548,18 @@ TEST_F(MasterTest, MultiRoleSchedulerUnsubscribeFromRole)
TaskInfo task = createTask(offer.slave_id(), resources, "sleep 60");
+ Future<TaskStatus> startingStatus;
Future<TaskStatus> runningStatus;
EXPECT_CALL(sched1, statusUpdate(&driver1, _))
+ .WillOnce(FutureArg<1>(&startingStatus))
.WillOnce(FutureArg<1>(&runningStatus));
driver1.launchTasks(offer.id(), {task});
+ AWAIT_READY(startingStatus);
+ EXPECT_EQ(TASK_STARTING, startingStatus->state());
+ EXPECT_EQ(task.task_id(), startingStatus->task_id());
+
AWAIT_READY(runningStatus);
EXPECT_EQ(TASK_RUNNING, runningStatus->state());
EXPECT_EQ(task.task_id(), runningStatus->task_id());
@@ -7810,12 +7856,18 @@ TEST_F(MasterTest, AgentDomainDifferentRegion)
// Check that we can launch a task in a remote region.
TaskInfo task = createTask(offer, "sleep 60");
+ Future<TaskStatus> startingStatus;
Future<TaskStatus> runningStatus;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&startingStatus))
.WillOnce(FutureArg<1>(&runningStatus));
driver.launchTasks(offer.id(), {task});
+ AWAIT_READY(startingStatus);
+ EXPECT_EQ(TASK_STARTING, startingStatus->state());
+ EXPECT_EQ(task.task_id(), startingStatus->task_id());
+
AWAIT_READY(runningStatus);
EXPECT_EQ(TASK_RUNNING, runningStatus->state());
EXPECT_EQ(task.task_id(), runningStatus->task_id());
@@ -8269,9 +8321,11 @@ TEST_P(MasterTestPrePostReservationRefinement, LaunchGroup)
v1::TaskGroupInfo taskGroup;
taskGroup.add_tasks()->CopyFrom(taskInfo);
- Future<v1::scheduler::Event::Update> update;
+ Future<v1::scheduler::Event::Update> startingUpdate;
+ Future<v1::scheduler::Event::Update> runningUpdate;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(FutureArg<1>(&update));
+ .WillOnce(FutureArg<1>(&startingUpdate))
+ .WillOnce(FutureArg<1>(&runningUpdate));
{
Call call;
@@ -8293,11 +8347,17 @@ TEST_P(MasterTestPrePostReservationRefinement, LaunchGroup)
mesos.send(call);
}
- AWAIT_READY(update);
+ AWAIT_READY(startingUpdate);
+
+ EXPECT_EQ(TASK_STARTING, startingUpdate->status().state());
+ EXPECT_EQ(taskInfo.task_id(), startingUpdate->status().task_id());
+ EXPECT_TRUE(startingUpdate->status().has_timestamp());
+
+ AWAIT_READY(runningUpdate);
- EXPECT_EQ(TASK_RUNNING, update->status().state());
- EXPECT_EQ(taskInfo.task_id(), update->status().task_id());
- EXPECT_TRUE(update->status().has_timestamp());
+ EXPECT_EQ(TASK_STARTING, runningUpdate->status().state());
+ EXPECT_EQ(taskInfo.task_id(), runningUpdate->status().task_id());
+ EXPECT_TRUE(runningUpdate->status().has_timestamp());
// Ensure that the task sandbox symbolic link is created.
EXPECT_TRUE(os::exists(path::join(
http://git-wip-us.apache.org/repos/asf/mesos/blob/1e1e409b/src/tests/master_validation_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/master_validation_tests.cpp b/src/tests/master_validation_tests.cpp
index f00dd9b..7da1be5 100644
--- a/src/tests/master_validation_tests.cpp
+++ b/src/tests/master_validation_tests.cpp
@@ -1889,8 +1889,10 @@ TEST_F(TaskValidationTest, TaskReusesUnreachableTaskID)
Offer offer1 = offers1.get()[0];
TaskInfo task1 = createTask(offer1, "sleep 60");
+ Future<TaskStatus> startingStatus;
Future<TaskStatus> runningStatus;
EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&startingStatus))
.WillOnce(FutureArg<1>(&runningStatus));
Future<Nothing> statusUpdateAck = FUTURE_DISPATCH(
@@ -1898,6 +1900,10 @@ TEST_F(TaskValidationTest, TaskReusesUnreachableTaskID)
driver.launchTasks(offer1.id(), {task1});
+ AWAIT_READY(startingStatus);
+ EXPECT_EQ(TASK_STARTING, startingStatus->state());
+ EXPECT_EQ(task1.task_id(), startingStatus->task_id());
+
AWAIT_READY(runningStatus);
EXPECT_EQ(TASK_RUNNING, runningStatus->state());
EXPECT_EQ(task1.task_id(), runningStatus->task_id());