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 22:53:36 UTC
[3/3] mesos git commit: Revert "Fix unit tests that were broken by
the additional...".
Revert "Fix unit tests that were broken by the additional...".
This reverts commit 1e1e409b3906d1a6189d5dfd47b21df7680244f6.
A number of tests have not been updated properly, leading
to multiple failures in the CI.
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/2a742653
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/2a742653
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/2a742653
Branch: refs/heads/master
Commit: 2a742653c3b0f906e3cb59e8f23dd5fbee95c17c
Parents: 5423043
Author: Alexander Rukletsov <al...@apache.org>
Authored: Thu Oct 12 15:49:14 2017 -0700
Committer: Alexander Rukletsov <al...@apache.org>
Committed: Thu Oct 12 15:52:17 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, 269 insertions(+), 1052 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/api_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/api_tests.cpp b/src/tests/api_tests.cpp
index 5bcca85..3d0db3b 100644
--- a/src/tests/api_tests.cpp
+++ b/src/tests/api_tests.cpp
@@ -2300,8 +2300,6 @@ 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);
@@ -2354,11 +2352,9 @@ TEST_P(MasterAPITest, EventAuthorizationFiltering)
Future<Result<v1::master::Event>> event = decoder.read();
EXPECT_TRUE(event.isPending());
- Future<mesos::v1::scheduler::Event::Update> updateRunning1;
+ Future<mesos::v1::scheduler::Event::Update> update;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(DoAll(
- FutureArg<1>(&updateRunning1),
- v1::scheduler::SendAcknowledge(frameworkId, agentId)));
+ .WillOnce(FutureArg<1>(&update));
EXPECT_CALL(executor1, registered(_, _, _, _));
EXPECT_CALL(executor2, registered(_, _, _, _));
@@ -2409,11 +2405,21 @@ 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(updateStarting1);
- // EXPECT_EQ(updateStarting1->status().state(), TASK_STARTING);
+ AWAIT_READY(update);
- AWAIT_READY(updateRunning1);
- EXPECT_EQ(updateRunning1->status().state(), TASK_RUNNING);
+ {
+ 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);
+ }
event = decoder.read();
@@ -2441,9 +2447,8 @@ 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>(&updateRunning2))
+ .WillOnce(FutureArg<1>(&update))
.WillRepeatedly(Return()); // Ignore subsequent updates.
Future<TaskInfo> execTask2;
@@ -2480,7 +2485,7 @@ TEST_P(MasterAPITest, EventAuthorizationFiltering)
mesos.send(call);
}
- AWAIT_READY(updateRunning2);
+ AWAIT_READY(update);
event = decoder.read();
EXPECT_TRUE(event.isPending());
@@ -4438,10 +4443,8 @@ 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();
@@ -4463,9 +4466,6 @@ 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,10 +4546,8 @@ 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();
@@ -4571,9 +4569,6 @@ 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());
@@ -4658,10 +4653,8 @@ 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();
@@ -4686,9 +4679,6 @@ 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());
@@ -4826,10 +4816,8 @@ 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();
@@ -4855,9 +4843,6 @@ 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());
@@ -5567,15 +5552,14 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(AgentAPITest, LaunchNestedContainerSession)
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status))
- .WillRepeatedly(Return());
+ .WillOnce(FutureArg<1>(&status));
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(status);
- ASSERT_EQ(TASK_STARTING, status->state());
+ ASSERT_EQ(TASK_RUNNING, status->state());
// Launch a nested container session that runs a command
// that writes something to stdout and stderr and exits.
@@ -5689,15 +5673,14 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status))
- .WillRepeatedly(Return());
+ .WillOnce(FutureArg<1>(&status));
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(status);
- ASSERT_EQ(TASK_STARTING, status->state());
+ ASSERT_EQ(TASK_RUNNING, status->state());
// Attempt to launch a nested container which does nothing.
@@ -5786,15 +5769,14 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status))
- .WillRepeatedly(Return());
+ .WillOnce(FutureArg<1>(&status));
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(status);
- ASSERT_EQ(TASK_STARTING, status->state());
+ ASSERT_EQ(TASK_RUNNING, status->state());
// Launch a nested container session that runs a command
// that writes something to stdout and stderr and exits.
@@ -5904,15 +5886,14 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status))
- .WillRepeatedly(Return());
+ .WillOnce(FutureArg<1>(&status));
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(status);
- ASSERT_EQ(TASK_STARTING, status->state());
+ ASSERT_EQ(TASK_RUNNING, status->state());
// Launch a nested container session that runs `cat` so that it never exits.
@@ -6209,15 +6190,14 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(
Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&status))
- .WillRepeatedly(Return());
+ .WillOnce(FutureArg<1>(&status));
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(status);
- ASSERT_EQ(TASK_STARTING, status->state());
+ ASSERT_EQ(TASK_RUNNING, status->state());
// Launch a nested container session which runs a shell.
@@ -6816,21 +6796,16 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(
const Offer& offer = offers.get()[0];
- Future<TaskStatus> statusStarting;
- Future<TaskStatus> statusRunning;
+ Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&statusStarting))
- .WillOnce(FutureArg<1>(&statusRunning));
+ .WillOnce(FutureArg<1>(&status));
TaskInfo taskInfo = createTask(offer, "sleep 1000");
driver.acceptOffers({offer.id()}, {LAUNCH({taskInfo})});
- AWAIT_READY(statusStarting);
- ASSERT_EQ(TASK_STARTING, statusStarting->state());
-
- AWAIT_READY(statusRunning);
- ASSERT_EQ(TASK_RUNNING, statusRunning->state());
+ AWAIT_READY(status);
+ ASSERT_EQ(TASK_RUNNING, status->state());
Future<hashset<ContainerID>> containerIds = containerizer->containers();
AWAIT_READY(containerIds);
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/check_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/check_tests.cpp b/src/tests/check_tests.cpp
index 9a56c00..fd15a47 100644
--- a/src/tests/check_tests.cpp
+++ b/src/tests/check_tests.cpp
@@ -288,14 +288,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;
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))
@@ -324,9 +322,6 @@ 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();
@@ -442,14 +437,12 @@ 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))
@@ -471,9 +464,6 @@ 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());
@@ -567,12 +557,10 @@ 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.
@@ -602,14 +590,6 @@ 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();
@@ -680,12 +660,10 @@ 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.
@@ -709,14 +687,6 @@ 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();
@@ -811,13 +781,11 @@ 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))
@@ -839,12 +807,6 @@ 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());
@@ -924,14 +886,12 @@ 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))
@@ -968,9 +928,6 @@ 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());
@@ -1081,11 +1038,9 @@ 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.
@@ -1114,9 +1069,6 @@ 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();
@@ -1219,11 +1171,9 @@ 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.
@@ -1251,14 +1201,6 @@ 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();
@@ -1439,14 +1381,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;
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))
@@ -1475,14 +1415,6 @@ 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();
@@ -1643,14 +1575,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;
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))
@@ -1672,12 +1602,6 @@ 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());
@@ -1812,12 +1736,10 @@ 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.
@@ -1847,14 +1769,6 @@ 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();
@@ -1967,12 +1881,10 @@ 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.
@@ -2024,14 +1936,6 @@ 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();
@@ -2145,13 +2049,11 @@ 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))
@@ -2173,12 +2075,6 @@ 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());
@@ -2301,14 +2197,12 @@ 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))
@@ -2342,9 +2236,6 @@ 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());
@@ -2479,12 +2370,11 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
- constexpr int EXPECTED_UPDATE_COUNT = 5;
- Future<v1::scheduler::Event::Update> updates[EXPECTED_UPDATE_COUNT];
+ Future<v1::scheduler::Event::Update> updates[4];
{
testing::InSequence dummy;
- for (int i = 0; i < EXPECTED_UPDATE_COUNT; i++) {
+ for (int i = 0; i < 4; i++) {
EXPECT_CALL(*scheduler, update(_, _))
.WillOnce(FutureArg<1>(&updates[i]));
}
@@ -2511,12 +2401,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
launchTaskGroup(&mesos, offer, executorInfo, taskGroup);
- enum class Stage { STARTING, INITIAL, RUNNING, CHECKED };
+ enum class Stage { INITIAL, RUNNING, CHECKED };
hashmap<v1::TaskID, Stage> taskStages;
- taskStages.put(taskInfo1.task_id(), Stage::STARTING);
- taskStages.put(taskInfo2.task_id(), Stage::STARTING);
+ taskStages.put(taskInfo1.task_id(), Stage::INITIAL);
+ taskStages.put(taskInfo2.task_id(), Stage::INITIAL);
- for (int i = 0; i < EXPECTED_UPDATE_COUNT; i++ ) {
+ for (int i = 0; i < 4; i++ ) {
AWAIT_READY(updates[i]);
const v1::TaskStatus& taskStatus = updates[i]->status();
@@ -2525,17 +2415,8 @@ 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: {
- v1::TaskState state = taskStatus.state();
- ASSERT_TRUE(state == v1::TASK_RUNNING);
+ ASSERT_EQ(TASK_RUNNING, taskStatus.state());
ASSERT_TRUE(taskStatus.check_status().has_tcp());
ASSERT_FALSE(taskStatus.check_status().tcp().has_succeeded());
@@ -2632,11 +2513,9 @@ 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.
@@ -2665,14 +2544,6 @@ 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();
@@ -2791,11 +2662,9 @@ 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.
@@ -2823,16 +2692,6 @@ 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/2a742653/src/tests/command_executor_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/command_executor_tests.cpp b/src/tests/command_executor_tests.cpp
index 3765132..f706f55 100644
--- a/src/tests/command_executor_tests.cpp
+++ b/src/tests/command_executor_tests.cpp
@@ -125,17 +125,12 @@ 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());
@@ -201,17 +196,12 @@ 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());
@@ -309,14 +299,12 @@ 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))
@@ -324,9 +312,6 @@ 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());
@@ -403,12 +388,10 @@ 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));
@@ -418,11 +401,7 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(HTTPCommandExecutorTest, TerminateWithACK)
driver.launchTasks(offers->front().id(), {task});
- // Scheduler should first receive TASK_STARTING, followed by TASK_RUNNING
- // and TASK_FINISHED.
- AWAIT_READY(statusStarting);
- EXPECT_EQ(TASK_STARTING, statusStarting->state());
-
+ // Scheduler should first receive TASK_RUNNING followed by TASK_FINISHED.
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -485,9 +464,9 @@ TEST_F(HTTPCommandExecutorTest, ExplicitAcknowledgements)
offers->front().resources(),
SLEEP_COMMAND(1000));
- Future<TaskStatus> statusStarting;
+ Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&statusStarting));
+ .WillOnce(FutureArg<1>(&statusRunning));
// Ensure no status update acknowledgements are sent from the driver
// to the master until the explicit acknowledgement is sent.
@@ -499,9 +478,9 @@ TEST_F(HTTPCommandExecutorTest, ExplicitAcknowledgements)
driver.launchTasks(offers->front().id(), {task});
- AWAIT_READY(statusStarting);
- EXPECT_TRUE(statusStarting->has_slave_id());
- EXPECT_EQ(TASK_STARTING, statusStarting->state());
+ AWAIT_READY(statusRunning);
+ EXPECT_TRUE(statusRunning->has_slave_id());
+ EXPECT_EQ(TASK_RUNNING, statusRunning->state());
// Now send the acknowledgement.
Future<mesos::scheduler::Call> acknowledgement = FUTURE_CALL(
@@ -510,7 +489,7 @@ TEST_F(HTTPCommandExecutorTest, ExplicitAcknowledgements)
_,
master.get()->pid);
- driver.acknowledgeStatusUpdate(statusStarting.get());
+ driver.acknowledgeStatusUpdate(statusRunning.get());
AWAIT_READY(acknowledgement);
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/container_logger_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/container_logger_tests.cpp b/src/tests/container_logger_tests.cpp
index 6080203..fb8e441 100644
--- a/src/tests/container_logger_tests.cpp
+++ b/src/tests/container_logger_tests.cpp
@@ -188,20 +188,15 @@ 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());
@@ -301,20 +296,15 @@ 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());
@@ -457,20 +447,15 @@ 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());
@@ -560,20 +545,15 @@ 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/2a742653/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 fd1cd46..cf7b9eb 100644
--- a/src/tests/containerizer/environment_secret_isolator_tests.cpp
+++ b/src/tests/containerizer/environment_secret_isolator_tests.cpp
@@ -107,19 +107,15 @@ TEST_F(EnvironmentSecretIsolatorTest, ResolveSecret)
Resources::parse("cpus:0.1;mem:32").get(),
command);
- // NOTE: Successful tasks will output three status updates.
- Future<TaskStatus> statusStarting;
+ // NOTE: Successful tasks will output two status updates.
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);
@@ -216,11 +212,9 @@ 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));
@@ -228,8 +222,6 @@ 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/2a742653/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 f639cac..0030cd1 100644
--- a/src/tests/containerizer/posix_rlimits_isolator_tests.cpp
+++ b/src/tests/containerizer/posix_rlimits_isolator_tests.cpp
@@ -179,20 +179,14 @@ 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());
@@ -327,20 +321,14 @@ 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());
@@ -488,15 +476,14 @@ 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::STARTING;
- taskStages[task2.task_id()] = Stage::STARTING;
+ taskStages[task1.task_id()] = Stage::INITIAL;
+ taskStages[task2.task_id()] = Stage::INITIAL;
foreach (const Future<TaskStatus>& taskStatus, taskStatuses) {
AWAIT_READY(taskStatus);
@@ -505,13 +492,6 @@ 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/2a742653/src/tests/default_executor_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/default_executor_tests.cpp b/src/tests/default_executor_tests.cpp
index e6adcbb..2b4c643 100644
--- a/src/tests/default_executor_tests.cpp
+++ b/src/tests/default_executor_tests.cpp
@@ -175,14 +175,9 @@ TEST_P(DefaultExecutorTest, TaskRunning)
const v1::Offer& offer = offers->offers(0);
const v1::AgentID& agentId = offer.agent_id();
- Future<v1::scheduler::Event::Update> startingUpdate;
- Future<v1::scheduler::Event::Update> runningUpdate;
+ Future<v1::scheduler::Event::Update> update;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(DoAll(
- FutureArg<1>(&startingUpdate),
- v1::scheduler::SendAcknowledge(frameworkId, agentId)))
- .WillOnce(FutureArg<1>(&runningUpdate))
- .WillRepeatedly(Return());
+ .WillOnce(FutureArg<1>(&update));
v1::TaskInfo taskInfo =
v1::createTask(agentId, resources, SLEEP_COMMAND(1000));
@@ -194,13 +189,11 @@ TEST_P(DefaultExecutorTest, TaskRunning)
{v1::LAUNCH_GROUP(
executorInfo, v1::createTaskGroupInfo({taskInfo}))}));
- AWAIT_READY(startingUpdate);
-
- ASSERT_EQ(TASK_STARTING, startingUpdate->status().state());
- EXPECT_EQ(taskInfo.task_id(), startingUpdate->status().task_id());
- EXPECT_TRUE(startingUpdate->status().has_timestamp());
+ AWAIT_READY(update);
- AWAIT_READY(runningUpdate);
+ ASSERT_EQ(TASK_RUNNING, update->status().state());
+ EXPECT_EQ(taskInfo.task_id(), update->status().task_id());
+ EXPECT_TRUE(update->status().has_timestamp());
// Ensure that the task sandbox symbolic link is created.
EXPECT_TRUE(os::exists(path::join(
@@ -296,26 +289,16 @@ 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>(&startingUpdate1),
- v1::scheduler::SendAcknowledge(frameworkId, agentId)))
- .WillOnce(
- DoAll(
- FutureArg<1>(&startingOrRunningUpdate1),
- v1::scheduler::SendAcknowledge(frameworkId, agentId)))
- .WillOnce(
- DoAll(
- FutureArg<1>(&startingOrRunningUpdate2),
+ FutureArg<1>(&runningUpdate1),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
.WillOnce(
DoAll(
- FutureArg<1>(&runningUpdate1),
+ FutureArg<1>(&runningUpdate2),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
Future<v1::scheduler::Event::Offers> offers2;
@@ -336,19 +319,17 @@ 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{
- startingUpdate1->status().task_id(),
- startingOrRunningUpdate1->status().task_id(),
- startingOrRunningUpdate2->status().task_id(),
- runningUpdate1->status().task_id()};
+ runningUpdate1->status().task_id(),
+ runningUpdate2->status().task_id()};
ASSERT_EQ(tasks1, tasksRunning);
@@ -358,15 +339,10 @@ 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())));
@@ -378,10 +354,6 @@ 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());
@@ -513,22 +485,6 @@ 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");
@@ -537,13 +493,9 @@ 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));
@@ -554,15 +506,6 @@ 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());
@@ -584,8 +527,38 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
.WillOnce(FutureArg<1>(&update2));
// Acknowledge the TASK_RUNNING updates to receive the next updates.
- acknowledge(runningUpdate1);
- acknowledge(runningUpdate2);
+
+ {
+ 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);
+ }
// Updates for the tasks in a task group can be received in any order.
set<pair<v1::TaskID, v1::TaskState>> taskStates;
@@ -683,7 +656,7 @@ TEST_P(DefaultExecutorTest, TaskUsesExecutor)
AWAIT_READY(update);
- ASSERT_EQ(TASK_STARTING, update->status().state());
+ ASSERT_EQ(TASK_RUNNING, update->status().state());
EXPECT_EQ(taskInfo.task_id(), update->status().task_id());
EXPECT_TRUE(update->status().has_timestamp());
}
@@ -848,16 +821,11 @@ 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));
@@ -873,9 +841,6 @@ 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());
@@ -957,21 +922,11 @@ 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(
@@ -990,11 +945,8 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnKillTask)
{v1::LAUNCH_GROUP(
executorInfo, v1::createTaskGroupInfo({taskInfo1, taskInfo2}))}));
- 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(runningUpdate1);
+ ASSERT_EQ(TASK_RUNNING, runningUpdate1->status().state());
AWAIT_READY(runningUpdate2);
ASSERT_EQ(TASK_RUNNING, runningUpdate2->status().state());
@@ -1002,8 +954,6 @@ 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()};
@@ -1120,15 +1070,15 @@ TEST_P(DefaultExecutorTest, ReservedResources)
v1::Offer::Operation launchGroup =
v1::LAUNCH_GROUP(executorInfo, v1::createTaskGroupInfo({taskInfo}));
- Future<v1::scheduler::Event::Update> startingUpdate;
+ Future<v1::scheduler::Event::Update> runningUpdate;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(FutureArg<1>(&startingUpdate));
+ .WillOnce(FutureArg<1>(&runningUpdate));
mesos.send(v1::createCallAccept(frameworkId, offer, {reserve, launchGroup}));
- 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());
}
@@ -1205,17 +1155,9 @@ TEST_P(DefaultExecutorTest, SigkillExecutor)
v1::Resources::parse("cpus:0.1;mem:32;disk:32").get(),
"sleep 1000");
- Future<v1::scheduler::Event::Update> startingUpdate;
- Future<v1::scheduler::Event::Update> runningUpdate;
+ Future<v1::scheduler::Event::Update> update;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(DoAll(
- FutureArg<1>(&startingUpdate),
- v1::scheduler::SendAcknowledge(frameworkId, agentId)))
- .WillOnce(DoAll(
- FutureArg<1>(&runningUpdate),
- v1::scheduler::SendAcknowledge(frameworkId, agentId)))
- .WillRepeatedly(Return());
-
+ .WillOnce(FutureArg<1>(&update));
v1::Offer::Operation launchGroup = v1::LAUNCH_GROUP(
executorInfo,
@@ -1223,19 +1165,14 @@ TEST_P(DefaultExecutorTest, SigkillExecutor)
mesos.send(v1::createCallAccept(frameworkId, offer, {launchGroup}));
- AWAIT_READY(startingUpdate);
-
- ASSERT_EQ(TASK_STARTING, startingUpdate->status().state());
- EXPECT_EQ(taskInfo.task_id(), startingUpdate->status().task_id());
-
- AWAIT_READY(runningUpdate);
+ AWAIT_READY(update);
- 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());
+ 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());
- v1::ContainerStatus status = runningUpdate->status().container_status();
+ v1::ContainerStatus status = update->status().container_status();
ASSERT_TRUE(status.has_container_id());
EXPECT_TRUE(status.container_id().has_parent());
@@ -1506,16 +1443,11 @@ 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(
@@ -1530,10 +1462,6 @@ 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/2a742653/src/tests/disk_quota_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/disk_quota_tests.cpp b/src/tests/disk_quota_tests.cpp
index fc29799..742b6e1 100644
--- a/src/tests/disk_quota_tests.cpp
+++ b/src/tests/disk_quota_tests.cpp
@@ -219,20 +219,14 @@ 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());
@@ -319,11 +313,9 @@ 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));
@@ -333,10 +325,6 @@ 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());
@@ -407,22 +395,16 @@ 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> statusStarting;
- Future<TaskStatus> statusRunning;
+ Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&statusStarting))
- .WillOnce(FutureArg<1>(&statusRunning))
+ .WillOnce(FutureArg<1>(&status))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offer.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());
+ AWAIT_READY(status);
+ EXPECT_EQ(task.task_id(), status->task_id());
+ EXPECT_EQ(TASK_RUNNING, status->state());
Future<hashset<ContainerID>> containers = containerizer->containers();
@@ -541,11 +523,9 @@ 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.
@@ -555,10 +535,6 @@ 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());
@@ -678,22 +654,16 @@ 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> statusStarting;
- Future<TaskStatus> statusRunning;
+ Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&statusStarting))
- .WillOnce(FutureArg<1>(&statusRunning))
+ .WillOnce(FutureArg<1>(&status))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offer.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());
+ AWAIT_READY(status);
+ EXPECT_EQ(task.task_id(), status->task_id());
+ EXPECT_EQ(TASK_RUNNING, status->state());
Future<hashset<ContainerID>> containers = containerizer->containers();
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/fault_tolerance_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/fault_tolerance_tests.cpp b/src/tests/fault_tolerance_tests.cpp
index 33a2220..c34850a 100644
--- a/src/tests/fault_tolerance_tests.cpp
+++ b/src/tests/fault_tolerance_tests.cpp
@@ -2209,10 +2209,8 @@ 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(
@@ -2220,10 +2218,6 @@ 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/2a742653/src/tests/health_check_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/health_check_tests.cpp b/src/tests/health_check_tests.cpp
index 81248f3..f4b50b1 100644
--- a/src/tests/health_check_tests.cpp
+++ b/src/tests/health_check_tests.cpp
@@ -330,20 +330,15 @@ 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());
@@ -405,7 +400,7 @@ TEST_F(HealthCheckTest, HealthyTask)
ASSERT_SOME(parse);
Result<JSON::Value> find = parse->find<JSON::Value>(
- "frameworks[0].tasks[0].statuses[1].healthy");
+ "frameworks[0].tasks[0].statuses[0].healthy");
EXPECT_SOME_TRUE(find);
}
@@ -423,7 +418,7 @@ TEST_F(HealthCheckTest, HealthyTask)
ASSERT_SOME(parse);
Result<JSON::Value> find = parse->find<JSON::Value>(
- "frameworks[0].executors[0].tasks[0].statuses[1].healthy");
+ "frameworks[0].executors[0].tasks[0].statuses[0].healthy");
EXPECT_SOME_TRUE(find);
}
@@ -493,20 +488,15 @@ 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());
@@ -638,12 +628,10 @@ 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));
@@ -651,9 +639,6 @@ 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());
@@ -730,20 +715,15 @@ 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());
@@ -798,14 +778,12 @@ 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))
@@ -814,9 +792,6 @@ 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());
@@ -945,14 +920,12 @@ 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))
@@ -961,9 +934,6 @@ 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());
@@ -1048,7 +1018,6 @@ 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;
@@ -1057,7 +1026,6 @@ 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))
@@ -1067,9 +1035,6 @@ 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());
@@ -1144,20 +1109,15 @@ 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());
@@ -1210,12 +1170,10 @@ 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());
@@ -1274,22 +1232,17 @@ 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());
@@ -1350,13 +1303,11 @@ 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))
@@ -1364,9 +1315,6 @@ 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());
@@ -1447,21 +1395,16 @@ 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());
@@ -1540,21 +1483,16 @@ 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());
@@ -1625,21 +1563,16 @@ 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());
@@ -2384,12 +2317,10 @@ 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));
@@ -2429,9 +2360,6 @@ 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);
@@ -2518,12 +2446,10 @@ 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));
@@ -2569,9 +2495,6 @@ 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/2a742653/src/tests/master_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/master_tests.cpp b/src/tests/master_tests.cpp
index 1a384bb..4c77601 100644
--- a/src/tests/master_tests.cpp
+++ b/src/tests/master_tests.cpp
@@ -2786,34 +2786,22 @@ 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>(&startingStatus))
- .WillOnce(FutureArg<1>(&runningStatus))
- .WillRepeatedly(Return());
-
- Future<Nothing> statusUpdateAck1 = FUTURE_DISPATCH(
- slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
+ .WillOnce(FutureArg<1>(&runningStatus));
- Future<Nothing> statusUpdateAck2 = FUTURE_DISPATCH(
+ Future<Nothing> statusUpdateAck = 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());
- AWAIT_READY(statusUpdateAck2);
+ const SlaveID slaveId = runningStatus->slave_id();
+
+ AWAIT_READY(statusUpdateAck);
// Step 4: Simulate master failover. We leave the slave without a
// master so it does not attempt to re-register.
@@ -6842,31 +6830,20 @@ 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> statusUpdateAck1 = FUTURE_DISPATCH(
- slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
-
- Future<Nothing> statusUpdateAck2 = FUTURE_DISPATCH(
+ Future<Nothing> statusUpdateAck = 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(statusUpdateAck2);
+ AWAIT_READY(statusUpdateAck);
// Simulate master failover. We leave the scheduler without a master
// so it does not attempt to re-register yet.
@@ -7073,33 +7050,22 @@ 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> statusUpdateAck1 = FUTURE_DISPATCH(
- slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
-
- Future<Nothing> statusUpdateAck2 = FUTURE_DISPATCH(
- slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
+ Future<Nothing> statusUpdateAck = 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(statusUpdateAck2);
+ AWAIT_READY(statusUpdateAck);
Clock::pause();
@@ -7452,18 +7418,12 @@ 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());
@@ -7548,18 +7508,12 @@ 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());
@@ -7856,18 +7810,12 @@ 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());
@@ -8321,11 +8269,9 @@ TEST_P(MasterTestPrePostReservationRefinement, LaunchGroup)
v1::TaskGroupInfo taskGroup;
taskGroup.add_tasks()->CopyFrom(taskInfo);
- Future<v1::scheduler::Event::Update> startingUpdate;
- Future<v1::scheduler::Event::Update> runningUpdate;
+ Future<v1::scheduler::Event::Update> update;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(FutureArg<1>(&startingUpdate))
- .WillOnce(FutureArg<1>(&runningUpdate));
+ .WillOnce(FutureArg<1>(&update));
{
Call call;
@@ -8347,17 +8293,11 @@ TEST_P(MasterTestPrePostReservationRefinement, LaunchGroup)
mesos.send(call);
}
- 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);
+ AWAIT_READY(update);
- EXPECT_EQ(TASK_STARTING, runningUpdate->status().state());
- EXPECT_EQ(taskInfo.task_id(), runningUpdate->status().task_id());
- EXPECT_TRUE(runningUpdate->status().has_timestamp());
+ EXPECT_EQ(TASK_RUNNING, update->status().state());
+ EXPECT_EQ(taskInfo.task_id(), update->status().task_id());
+ EXPECT_TRUE(update->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/2a742653/src/tests/master_validation_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/master_validation_tests.cpp b/src/tests/master_validation_tests.cpp
index 7da1be5..f00dd9b 100644
--- a/src/tests/master_validation_tests.cpp
+++ b/src/tests/master_validation_tests.cpp
@@ -1889,10 +1889,8 @@ 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(
@@ -1900,10 +1898,6 @@ 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());