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:34 UTC
[1/3] mesos git commit: Revert "Sent TASK_STARTING from the built-in
executors.".
Repository: mesos
Updated Branches:
refs/heads/master 834053d97 -> 2a742653c
Revert "Sent TASK_STARTING from the built-in executors.".
This reverts commit f43710eabb1c0956b368e9f855b26bebcf8cbc7a.
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/54230435
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/54230435
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/54230435
Branch: refs/heads/master
Commit: 542304355e2bc600075823ab9cbd24c8f7446dbe
Parents: 834053d
Author: Alexander Rukletsov <al...@apache.org>
Authored: Thu Oct 12 15:49:08 2017 -0700
Committer: Alexander Rukletsov <al...@apache.org>
Committed: Thu Oct 12 15:51:07 2017 -0700
----------------------------------------------------------------------
docs/high-availability-framework-guide.md | 9 ++---
src/docker/executor.cpp | 8 ----
src/launcher/default_executor.cpp | 52 +++++++++-----------------
src/launcher/executor.cpp | 5 +--
4 files changed, 23 insertions(+), 51 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/54230435/docs/high-availability-framework-guide.md
----------------------------------------------------------------------
diff --git a/docs/high-availability-framework-guide.md b/docs/high-availability-framework-guide.md
index f246773..73743ab 100644
--- a/docs/high-availability-framework-guide.md
+++ b/docs/high-availability-framework-guide.md
@@ -189,11 +189,10 @@ initial state and several possible terminal states:
has not yet started to run. In this state, the task's dependencies are
fetched---for example, using the [Mesos fetcher cache](fetcher.md).
-* The `TASK_STARTING` state is optional. It can be used to describe the fact
- that an executor has learned about the task (and maybe started fetching its
- dependencies) but has not yet started to run it. Custom executors are
- encouraged to send it, to provide a more detailed description of the current
- task state to outside observers.
+* The `TASK_STARTING` state is optional and intended primarily for use by
+ custom executors. It can be used to describe the fact that a custom executor
+ has learned about the task (and maybe started fetching its dependencies) but has
+ not yet started to run it.
* A task transitions to the `TASK_RUNNING` state after it has begun running
successfully (if the task fails to start, it transitions to one of the
http://git-wip-us.apache.org/repos/asf/mesos/blob/54230435/src/docker/executor.cpp
----------------------------------------------------------------------
diff --git a/src/docker/executor.cpp b/src/docker/executor.cpp
index 5f6a0d0..3b0767f 100644
--- a/src/docker/executor.cpp
+++ b/src/docker/executor.cpp
@@ -159,14 +159,6 @@ public:
LOG(INFO) << "Starting task " << taskId.get();
- // Send initial TASK_STARTING update.
- // TODO(alexr): Use `protobuf::createTaskStatus()`
- // instead of manually setting fields.
- TaskStatus starting;
- starting.mutable_task_id()->CopyFrom(task.task_id());
- starting.set_state(TASK_STARTING);
- driver->sendStatusUpdate(starting);
-
CHECK(task.has_container());
CHECK(task.has_command());
http://git-wip-us.apache.org/repos/asf/mesos/blob/54230435/src/launcher/default_executor.cpp
----------------------------------------------------------------------
diff --git a/src/launcher/default_executor.cpp b/src/launcher/default_executor.cpp
index 6447b3d..a376c09 100644
--- a/src/launcher/default_executor.cpp
+++ b/src/launcher/default_executor.cpp
@@ -108,12 +108,6 @@ private:
// `WAIT_NESTED_CONTAINER` call has not been established yet.
Option<Connection> waiting;
- // TODO(bennoe): Create a real state machine instead of adding
- // more and more ad-hoc boolean values.
-
- // Indicates whether a container has been launched.
- bool launched;
-
// Indicates whether a status update acknowledgement
// has been received for any status update.
bool acknowledged;
@@ -324,14 +318,12 @@ protected:
subscribe->add_unacknowledged_updates()->MergeFrom(update);
}
- // Send all unacknowledged tasks. We don't send tasks whose container
- // didn't launch yet, because the agent will learn about once it launches.
- // We also don't send unacknowledged terminated (and hence already removed
- // from `containers`) tasks, because for such tasks `WAIT_NESTED_CONTAINER`
- // call has already succeeded, meaning the agent knows about the tasks and
- // corresponding containers.
+ // Send all unacknowledged tasks. We don't send unacknowledged terminated
+ // (and hence already removed from `containers`) tasks, because for such
+ // tasks `WAIT_NESTED_CONTAINER` call has already succeeded, meaning the
+ // agent knows about the tasks and corresponding containers.
foreachvalue (const Owned<Container>& container, containers) {
- if (container->launched && !container->acknowledged) {
+ if (!container->acknowledged) {
subscribe->add_unacknowledged_tasks()->MergeFrom(container->taskInfo);
}
}
@@ -411,23 +403,6 @@ protected:
containerIds.push_back(containerId);
- containers[task.task_id()] = Owned<Container>(new Container{
- containerId,
- task,
- taskGroup,
- None(),
- None(),
- None(),
- None(),
- false,
- false,
- false,
- false});
-
- // Send out the initial TASK_STARTING update.
- const TaskStatus status = createTaskStatus(task.task_id(), TASK_STARTING);
- forward(status);
-
agent::Call call;
call.set_type(agent::Call::LAUNCH_NESTED_CONTAINER);
@@ -551,8 +526,17 @@ protected:
const TaskInfo& task = taskGroup.tasks().Get(index++);
const TaskID& taskId = task.task_id();
- CHECK(containers.contains(taskId));
- containers.at(taskId)->launched = true;
+ containers[taskId] = Owned<Container>(new Container{
+ containerId,
+ task,
+ taskGroup,
+ None(),
+ None(),
+ None(),
+ None(),
+ false,
+ false,
+ false});
if (task.has_check()) {
Try<Owned<checks::Checker>> checker =
@@ -1392,7 +1376,7 @@ private:
CHECK_EQ(SUBSCRIBED, state);
CHECK_SOME(connectionId);
- CHECK(containers.contains(taskId) && containers.at(taskId)->launched);
+ CHECK(containers.contains(taskId));
const Owned<Container>& container = containers.at(taskId);
@@ -1451,7 +1435,7 @@ private:
LinkedHashMap<UUID, Call::Update> unacknowledgedUpdates;
- // Child containers.
+ // Active child containers.
LinkedHashMap<TaskID, Owned<Container>> containers;
// There can be multiple simulataneous ongoing (re-)connection attempts
http://git-wip-us.apache.org/repos/asf/mesos/blob/54230435/src/launcher/executor.cpp
----------------------------------------------------------------------
diff --git a/src/launcher/executor.cpp b/src/launcher/executor.cpp
index 34f6f7a..0131577 100644
--- a/src/launcher/executor.cpp
+++ b/src/launcher/executor.cpp
@@ -525,10 +525,6 @@ protected:
taskData = TaskData(task);
taskId = task.task_id();
- // Send initial TASK_STARTING update.
- TaskStatus starting = createTaskStatus(taskId.get(), TASK_STARTING);
- forward(starting);
-
// Capture the kill policy.
if (task.has_kill_policy()) {
killPolicy = task.kill_policy();
@@ -1020,6 +1016,7 @@ private:
// If a check for the task has been defined, `check_status` field in each
// task status must be set to a valid `CheckStatusInfo` message even if
// there is no check status available yet.
+ CHECK(taskData.isSome());
if (taskData->taskInfo.has_check()) {
CheckStatusInfo checkStatusInfo;
checkStatusInfo.set_type(taskData->taskInfo.check().type());
[2/3] mesos git commit: Revert "Fix unit tests that were broken by
the additional...".
Posted by al...@apache.org.
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/oversubscription_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/oversubscription_tests.cpp b/src/tests/oversubscription_tests.cpp
index d262bbe..cd98b8f 100644
--- a/src/tests/oversubscription_tests.cpp
+++ b/src/tests/oversubscription_tests.cpp
@@ -757,7 +757,7 @@ TEST_F(OversubscriptionTest, FixedResourceEstimator)
AWAIT_READY(status);
EXPECT_EQ(task.task_id(), status->task_id());
- EXPECT_EQ(TASK_STARTING, status->state());
+ EXPECT_EQ(TASK_RUNNING, status->state());
// Advance the clock for the slave to trigger the calculation of the
// total oversubscribed resources. As we described above, we don't
@@ -1023,20 +1023,15 @@ TEST_F(OversubscriptionTest, QoSCorrectionKill)
TaskInfo task = createTask(offers.get()[0], "sleep 10");
- 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.
driver.launchTasks(offers.get()[0].id(), {task});
- AWAIT_READY(status0);
- ASSERT_EQ(TASK_STARTING, status0->state());
-
AWAIT_READY(status1);
ASSERT_EQ(TASK_RUNNING, status1->state());
@@ -1137,20 +1132,15 @@ TEST_F(OversubscriptionTest, QoSCorrectionKillPartitionAware)
TaskInfo task = createTask(offers.get()[0], "sleep 10");
- 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.
driver.launchTasks(offers.get()[0].id(), {task});
- AWAIT_READY(status0);
- ASSERT_EQ(TASK_STARTING, status0->state());
-
AWAIT_READY(status1);
ASSERT_EQ(TASK_RUNNING, status1->state());
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/partition_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/partition_tests.cpp b/src/tests/partition_tests.cpp
index 7b11264..0597bd2 100644
--- a/src/tests/partition_tests.cpp
+++ b/src/tests/partition_tests.cpp
@@ -215,33 +215,22 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(PartitionTest, ReregisterSlavePartitionAware)
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));
- 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(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());
- AWAIT_READY(statusUpdateAck2);
+ const SlaveID& slaveId = runningStatus->slave_id();
- const SlaveID& slaveId = startingStatus->slave_id();
+ AWAIT_READY(statusUpdateAck);
// Now, induce a partition of the slave by having the master
// timeout the slave.
@@ -583,10 +572,8 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(PartitionTest, ReregisterSlaveNotPartitionAware)
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));
Future<Nothing> statusUpdateAck = FUTURE_DISPATCH(
@@ -887,10 +874,8 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
// Launch `task1` using `sched1`.
TaskInfo task1 = createTask(offer.slave_id(), taskResources, "sleep 60");
- Future<TaskStatus> startingStatus1;
Future<TaskStatus> runningStatus1;
EXPECT_CALL(sched1, statusUpdate(&driver1, _))
- .WillOnce(FutureArg<1>(&startingStatus1))
.WillOnce(FutureArg<1>(&runningStatus1));
Future<Nothing> statusUpdateAck1 = FUTURE_DISPATCH(
@@ -932,10 +917,8 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(
// Launch the second task.
TaskInfo task2 = createTask(offer.slave_id(), taskResources, "sleep 60");
- Future<TaskStatus> startingStatus2;
Future<TaskStatus> runningStatus2;
EXPECT_CALL(sched2, statusUpdate(&driver2, _))
- .WillOnce(FutureArg<1>(&startingStatus2))
.WillOnce(FutureArg<1>(&runningStatus2));
Future<Nothing> statusUpdateAck2 = FUTURE_DISPATCH(
@@ -1153,33 +1136,22 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(PartitionTest, PartitionedSlaveOrphanedTask)
// Launch `task` using `sched`.
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));
- 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(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);
// Now, induce a partition of the slave by having the master
// timeout the slave.
@@ -1432,33 +1404,22 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(PartitionTest, DisconnectedFramework)
// Launch `task` using `sched1`.
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> statusUpdateAck1 = FUTURE_DISPATCH(
slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
- Future<Nothing> statusUpdateAck2 = FUTURE_DISPATCH(
- slave.get()->pid, &Slave::_statusUpdateAcknowledgement);
-
driver1.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(statusUpdateAck1);
// Shutdown the master.
master->reset();
@@ -1612,33 +1573,22 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(PartitionTest, SpuriousSlaveReregistration)
// Launch `task` using `sched`.
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));
- 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(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);
// Simulate a master loss event at the slave and then cause the
// slave to reregister with the master. From the master's
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/persistent_volume_endpoints_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/persistent_volume_endpoints_tests.cpp b/src/tests/persistent_volume_endpoints_tests.cpp
index abc6dbb..7a24bf4 100644
--- a/src/tests/persistent_volume_endpoints_tests.cpp
+++ b/src/tests/persistent_volume_endpoints_tests.cpp
@@ -1987,13 +1987,9 @@ TEST_F(PersistentVolumeEndpointsTest, SlavesEndpointFullResources)
filters.set_refuse_seconds(0);
// Expect a TASK_RUNNING status.
- EXPECT_CALL(sched, statusUpdate(&driver, _))
- .Times(2);
+ EXPECT_CALL(sched, statusUpdate(&driver, _));
- Future<Nothing> _statusUpdateAcknowledgement1 =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
-
- Future<Nothing> _statusUpdateAcknowledgement2 =
+ Future<Nothing> _statusUpdateAcknowledgement =
FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
// Expect another resource offer.
@@ -2003,8 +1999,7 @@ TEST_F(PersistentVolumeEndpointsTest, SlavesEndpointFullResources)
driver.acceptOffers({offer.id()}, {LAUNCH({taskInfo})}, filters);
// Wait for TASK_RUNNING update ack.
- AWAIT_READY(_statusUpdateAcknowledgement1);
- AWAIT_READY(_statusUpdateAcknowledgement2);
+ AWAIT_READY(_statusUpdateAcknowledgement);
response = process::http::get(
master.get()->pid,
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/persistent_volume_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/persistent_volume_tests.cpp b/src/tests/persistent_volume_tests.cpp
index acfeac1..11fe432 100644
--- a/src/tests/persistent_volume_tests.cpp
+++ b/src/tests/persistent_volume_tests.cpp
@@ -806,11 +806,9 @@ TEST_P(PersistentVolumeTest, AccessPersistentVolume)
taskResources,
"echo abc > path1/file");
- 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));
@@ -825,10 +823,6 @@ TEST_P(PersistentVolumeTest, AccessPersistentVolume)
{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());
@@ -988,25 +982,21 @@ TEST_P(PersistentVolumeTest, SharedPersistentVolumeMultipleTasks)
taskResources2.get() + volume,
"echo task2 > path1/file2");
- // We should receive a TASK_STARTING, followed by a TASK_RUNNING
- // and a TASK_FINISHED for each of the 2 tasks.
- // We do not check for the actual task state since it's not the
- // primary objective of the test. We instead verify that the paths
- // are created by the tasks after we receive enough status updates.
+ // We should receive a TASK_RUNNING followed by a TASK_FINISHED for
+ // each of the 2 tasks. We do not check for the actual task state
+ // since it's not the primary objective of the test. We instead
+ // verify that the paths are created by the tasks after we receive
+ // enough status updates.
Future<TaskStatus> status1;
Future<TaskStatus> status2;
Future<TaskStatus> status3;
Future<TaskStatus> status4;
- Future<TaskStatus> status5;
- Future<TaskStatus> status6;
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(FutureArg<1>(&status1))
.WillOnce(FutureArg<1>(&status2))
.WillOnce(FutureArg<1>(&status3))
- .WillOnce(FutureArg<1>(&status4))
- .WillOnce(FutureArg<1>(&status5))
- .WillOnce(FutureArg<1>(&status6));
+ .WillOnce(FutureArg<1>(&status4));
driver.acceptOffers(
{offer.id()},
@@ -1019,8 +1009,6 @@ TEST_P(PersistentVolumeTest, SharedPersistentVolumeMultipleTasks)
AWAIT_READY(status2);
AWAIT_READY(status3);
AWAIT_READY(status4);
- AWAIT_READY(status5);
- AWAIT_READY(status6);
const string& volumePath = slave::paths::getPersistentVolumePath(
slaveFlags.work_dir,
@@ -1270,12 +1258,10 @@ TEST_P(PersistentVolumeTest, SharedPersistentVolumeMultipleFrameworks)
Resources::parse("cpus:1;mem:128").get() + volume,
"echo abc > path1/file1 && sleep 1000");
- // We should receive a TASK_STARTING and a TASK_RUNNING for the launched task.
- Future<TaskStatus> status0;
+ // We should receive a TASK_RUNNING for the launched task.
Future<TaskStatus> status1;
EXPECT_CALL(sched1, statusUpdate(&driver1, _))
- .WillOnce(FutureArg<1>(&status0))
.WillOnce(FutureArg<1>(&status1));
// We use a filter of 0 seconds so the resources will be available
@@ -1289,9 +1275,6 @@ TEST_P(PersistentVolumeTest, SharedPersistentVolumeMultipleFrameworks)
LAUNCH({task1})},
filters);
- AWAIT_READY(status0);
- EXPECT_EQ(TASK_STARTING, status0->state());
-
AWAIT_READY(status1);
EXPECT_EQ(TASK_RUNNING, status1->state());
@@ -1348,13 +1331,11 @@ TEST_P(PersistentVolumeTest, SharedPersistentVolumeMultipleFrameworks)
Resources::parse("cpus:1;mem:256").get() + volume,
"echo abc > path1/file2 && sleep 1000");
- // We should receive a TASK_STARTING and a TASK_RUNNING for the launched task.
+ // We should receive a TASK_RUNNING for the launched task.
Future<TaskStatus> status2;
- Future<TaskStatus> status3;
EXPECT_CALL(sched2, statusUpdate(&driver2, _))
- .WillOnce(FutureArg<1>(&status2))
- .WillOnce(FutureArg<1>(&status3));
+ .WillOnce(FutureArg<1>(&status2));
driver2.acceptOffers(
{offer2.id()},
@@ -1362,10 +1343,7 @@ TEST_P(PersistentVolumeTest, SharedPersistentVolumeMultipleFrameworks)
filters);
AWAIT_READY(status2);
- EXPECT_EQ(TASK_STARTING, status2->state());
-
- AWAIT_READY(status3);
- EXPECT_EQ(TASK_RUNNING, status3->state());
+ EXPECT_EQ(TASK_RUNNING, status2->state());
// Collect metrics based on both frameworks. Note that the `cpus_used` and
// `mem_used` is updated, but `disk_used` does not change since both tasks
@@ -1456,17 +1434,13 @@ TEST_P(PersistentVolumeTest, SharedPersistentVolumeMasterFailover)
taskResources.get() + volume,
"sleep 1000");
- // We should receive a TASK_STARTING and a TASK_RUNNING for each of the tasks.
+ // We should receive a TASK_RUNNING for each of the tasks.
Future<TaskStatus> status1;
Future<TaskStatus> status2;
- Future<TaskStatus> status3;
- Future<TaskStatus> status4;
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(FutureArg<1>(&status1))
- .WillOnce(FutureArg<1>(&status2))
- .WillOnce(FutureArg<1>(&status3))
- .WillOnce(FutureArg<1>(&status4));
+ .WillOnce(FutureArg<1>(&status2));
Future<CheckpointResourcesMessage> checkpointResources =
FUTURE_PROTOBUF(CheckpointResourcesMessage(), _, slave.get()->pid);
@@ -1477,14 +1451,11 @@ TEST_P(PersistentVolumeTest, SharedPersistentVolumeMasterFailover)
LAUNCH({task1, task2})});
AWAIT_READY(checkpointResources);
-
- // We only check the first and the last status, because the two in between
- // could arrive in any order.
AWAIT_READY(status1);
- EXPECT_EQ(TASK_STARTING, status1->state());
+ EXPECT_EQ(TASK_RUNNING, status1->state());
- AWAIT_READY(status4);
- EXPECT_EQ(TASK_RUNNING, status4->state());
+ AWAIT_READY(status2);
+ EXPECT_EQ(TASK_RUNNING, status2->state());
// This is to make sure CheckpointResourcesMessage is processed.
Clock::pause();
@@ -1627,20 +1598,16 @@ TEST_P(PersistentVolumeTest, DestroyPersistentVolumeMultipleTasks)
EXPECT_CALL(sched, resourceOffers(&driver, _))
.WillOnce(FutureArg<1>(&offers));
- // We should receive a TASK_STARTING and a TASK_RUNNING each of the 2 tasks.
- // We track task termination by a TASK_FINISHED for the short-lived task.
+ // We should receive a TASK_RUNNING each of the 2 tasks. We track task
+ // termination by a TASK_FINISHED for the short-lived task.
Future<TaskStatus> status1;
Future<TaskStatus> status2;
Future<TaskStatus> status3;
- Future<TaskStatus> status4;
- Future<TaskStatus> status5;
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(FutureArg<1>(&status1))
.WillOnce(FutureArg<1>(&status2))
- .WillOnce(FutureArg<1>(&status3))
- .WillOnce(FutureArg<1>(&status4))
- .WillOnce(FutureArg<1>(&status5));
+ .WillOnce(FutureArg<1>(&status3));
driver.acceptOffers(
{offer.id()},
@@ -1649,23 +1616,18 @@ TEST_P(PersistentVolumeTest, DestroyPersistentVolumeMultipleTasks)
LAUNCH({task1, task2})},
filters);
- // Wait for TASK_STARTING and TASK_RUNNING for both the tasks,
- // and TASK_FINISHED for the short-lived task.
+ // Wait for TASK_RUNNING for both the tasks, and TASK_FINISHED for
+ // the short-lived task.
AWAIT_READY(status1);
AWAIT_READY(status2);
AWAIT_READY(status3);
- AWAIT_READY(status4);
- AWAIT_READY(status5);
hashset<TaskID> tasksRunning;
hashset<TaskID> tasksFinished;
- vector<Future<TaskStatus>> statuses {
- status1, status2, status3, status4, status5};
+ vector<Future<TaskStatus>> statuses{status1, status2, status3};
foreach (const Future<TaskStatus>& status, statuses) {
- if (status->state() == TASK_STARTING) {
- // ignore
- } else if (status->state() == TASK_RUNNING) {
+ if (status->state() == TASK_RUNNING) {
tasksRunning.insert(status->task_id());
} else {
tasksFinished.insert(status->task_id());
@@ -1724,15 +1686,15 @@ TEST_P(PersistentVolumeTest, DestroyPersistentVolumeMultipleTasks)
// We kill the long-lived task and wait for TASK_KILLED, so we can
// DESTROY the persistent volume once the task terminates.
- Future<TaskStatus> status6;
+ Future<TaskStatus> status4;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&status6));
+ .WillOnce(FutureArg<1>(&status4));
driver.killTask(task1.task_id());
- AWAIT_READY(status6);
- EXPECT_EQ(task1.task_id(), status6->task_id());
- EXPECT_EQ(TASK_KILLED, status6->state());
+ AWAIT_READY(status4);
+ EXPECT_EQ(task1.task_id(), status4->task_id());
+ EXPECT_EQ(TASK_KILLED, status4->state());
EXPECT_CALL(sched, resourceOffers(&driver, _))
.WillOnce(FutureArg<1>(&offers));
@@ -1961,37 +1923,25 @@ TEST_P(PersistentVolumeTest, SlaveRecovery)
taskResources,
"while true; do test -d path1; done");
- 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));
- Future<Nothing> ack1 =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
-
- Future<Nothing> ack2 =
+ Future<Nothing> ack =
FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
driver.acceptOffers(
{offer.id()},
{CREATE(volume), LAUNCH({task})});
- AWAIT_READY(status0);
- EXPECT_EQ(task.task_id(), status0->task_id());
- EXPECT_EQ(TASK_STARTING, status0->state());
-
- // Wait for the ACK to be checkpointed.
- AWAIT_READY(ack1);
-
AWAIT_READY(status1);
EXPECT_EQ(task.task_id(), status1->task_id());
EXPECT_EQ(TASK_RUNNING, status1->state());
// Wait for the ACK to be checkpointed.
- AWAIT_READY(ack2);
+ AWAIT_READY(ack);
// Restart the slave.
slave.get()->terminate();
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/reconciliation_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/reconciliation_tests.cpp b/src/tests/reconciliation_tests.cpp
index 8ae2860..64a1d3d 100644
--- a/src/tests/reconciliation_tests.cpp
+++ b/src/tests/reconciliation_tests.cpp
@@ -1178,33 +1178,22 @@ TEST_F(ReconciliationTest, PartitionedAgentThenMasterFailover)
// Launch `task` using `sched`.
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));
- 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(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);
// Now, induce a partition of the slave by having the master
// timeout the slave.
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/reservation_endpoints_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/reservation_endpoints_tests.cpp b/src/tests/reservation_endpoints_tests.cpp
index 409047c..5a6e9a7 100644
--- a/src/tests/reservation_endpoints_tests.cpp
+++ b/src/tests/reservation_endpoints_tests.cpp
@@ -371,7 +371,6 @@ TEST_F(ReservationEndpointsTest, ReserveAvailableAndOfferedResources)
MesosSchedulerDriver driver(
&sched, frameworkInfo, master.get()->pid, DEFAULT_CREDENTIAL);
- // Expect one TASK_STARTING and one TASK_RUNNING update
EXPECT_CALL(sched, registered(&driver, _, _));
Future<vector<Offer>> offers;
@@ -401,21 +400,16 @@ TEST_F(ReservationEndpointsTest, ReserveAvailableAndOfferedResources)
// recovers 'offered' resources portion.
TaskInfo taskInfo = createTask(offer.slave_id(), available, "sleep 1000");
- // Expect a TASK_STARTING and a TASK_RUNNING status.
- EXPECT_CALL(sched, statusUpdate(_, _)).
- WillRepeatedly(Return());
+ // Expect a TASK_RUNNING status.
+ EXPECT_CALL(sched, statusUpdate(_, _));
- Future<Nothing> _statusUpdateAcknowledgement1 =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
-
- Future<Nothing> _statusUpdateAcknowledgement2 =
+ Future<Nothing> _statusUpdateAcknowledgement =
FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
driver.acceptOffers({offer.id()}, {LAUNCH({taskInfo})});
- // Wait for update acks.
- AWAIT_READY(_statusUpdateAcknowledgement1);
- AWAIT_READY(_statusUpdateAcknowledgement2);
+ // Wait for TASK_RUNNING update ack.
+ AWAIT_READY(_statusUpdateAcknowledgement);
// Summon an offer to receive the 'offered' resources.
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -553,21 +547,16 @@ TEST_F(ReservationEndpointsTest, UnreserveAvailableAndOfferedResources)
// recovers 'offered' resources portion.
TaskInfo taskInfo = createTask(offer.slave_id(), available, "sleep 1000");
- // Expect a TASK_STARTING and a TASK_RUNNING status.
- EXPECT_CALL(sched, statusUpdate(_, _))
- .WillRepeatedly(Return());
+ // Expect a TASK_RUNNING status.
+ EXPECT_CALL(sched, statusUpdate(_, _));
- Future<Nothing> _statusUpdateAcknowledgement1 =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
-
- Future<Nothing> _statusUpdateAcknowledgement2 =
+ Future<Nothing> _statusUpdateAcknowledgement =
FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
driver.acceptOffers({offer.id()}, {LAUNCH({taskInfo})});
- // Wait for update acks from TASK_STARTING and TASK_RUNNING.
- AWAIT_READY(_statusUpdateAcknowledgement1);
- AWAIT_READY(_statusUpdateAcknowledgement2);
+ // Wait for TASK_RUNNING update ack.
+ AWAIT_READY(_statusUpdateAcknowledgement);
// Summon an offer to receive the 'offered' resources.
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -1607,11 +1596,9 @@ TEST_F(ReservationEndpointsTest, AgentStateEndpointResources)
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));
Resources taskResources = Resources::parse(
"cpus(role):2;mem(role):512;cpus:2;mem:1024").get();
@@ -1620,11 +1607,8 @@ TEST_F(ReservationEndpointsTest, AgentStateEndpointResources)
driver.acceptOffers({offer.id()}, {LAUNCH({task})});
- 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<Response> response = process::http::get(
agent.get()->pid,
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/role_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/role_tests.cpp b/src/tests/role_tests.cpp
index 852e2cc..fc4c017 100644
--- a/src/tests/role_tests.cpp
+++ b/src/tests/role_tests.cpp
@@ -986,10 +986,9 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(RoleTest, VolumesInOverlappingHierarchies)
taskResources,
"! (ls -Av path | grep -q .)");
- // We expect three status updates for the task.
- Future<TaskStatus> status0, status1, status2;
+ // We expect two status updates for the task.
+ Future<TaskStatus> status1, status2;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&status0))
.WillOnce(FutureArg<1>(&status1))
.WillOnce(FutureArg<1>(&status2));
@@ -998,11 +997,6 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(RoleTest, VolumesInOverlappingHierarchies)
{offer.id()},
{RESERVE(reservedDisk), 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());
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/scheduler_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/scheduler_tests.cpp b/src/tests/scheduler_tests.cpp
index 6df4d32..4eda96e 100644
--- a/src/tests/scheduler_tests.cpp
+++ b/src/tests/scheduler_tests.cpp
@@ -623,15 +623,11 @@ TEST_P(SchedulerTest, TaskGroupRunning)
taskGroup.add_tasks()->CopyFrom(task1);
taskGroup.add_tasks()->CopyFrom(task2);
- Future<Event::Update> startingUpdate1;
- Future<Event::Update> startingUpdate2;
Future<Event::Update> runningUpdate1;
Future<Event::Update> runningUpdate2;
Future<Event::Update> finishedUpdate1;
Future<Event::Update> finishedUpdate2;
EXPECT_CALL(*scheduler, update(_, _))
- .WillOnce(FutureArg<1>(&startingUpdate1))
- .WillOnce(FutureArg<1>(&startingUpdate2))
.WillOnce(FutureArg<1>(&runningUpdate1))
.WillOnce(FutureArg<1>(&runningUpdate2))
.WillOnce(FutureArg<1>(&finishedUpdate1))
@@ -673,58 +669,14 @@ TEST_P(SchedulerTest, TaskGroupRunning)
EXPECT_EQ(devolve(task2.task_id()),
runTaskGroupMessage->task_group().tasks(1).task_id());
- AWAIT_READY(startingUpdate1);
- ASSERT_EQ(v1::TASK_STARTING, startingUpdate1->status().state());
-
- AWAIT_READY(startingUpdate2);
- ASSERT_EQ(v1::TASK_STARTING, startingUpdate2->status().state());
-
- const hashset<v1::TaskID> tasks{task1.task_id(), task2.task_id()};
-
- // TASK_STARTING updates for the tasks in a
- // task group can be received in any order.
- const hashset<v1::TaskID> tasksStarting{
- startingUpdate1->status().task_id(),
- startingUpdate2->status().task_id()};
-
- ASSERT_EQ(tasks, tasksStarting);
-
- // Acknowledge the TASK_STARTING updates so
- // that subsequent updates can be received.
- {
- Call call;
- call.mutable_framework_id()->CopyFrom(frameworkId);
- call.set_type(Call::ACKNOWLEDGE);
-
- Call::Acknowledge* acknowledge = call.mutable_acknowledge();
- acknowledge->mutable_task_id()->CopyFrom(
- startingUpdate1->status().task_id());
- acknowledge->mutable_agent_id()->CopyFrom(offers->offers(0).agent_id());
- acknowledge->set_uuid(startingUpdate1->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(
- startingUpdate2->status().task_id());
- acknowledge->mutable_agent_id()->CopyFrom(offers->offers(0).agent_id());
- acknowledge->set_uuid(startingUpdate2->status().uuid());
-
- mesos.send(call);
- }
-
AWAIT_READY(runningUpdate1);
ASSERT_EQ(v1::TASK_RUNNING, runningUpdate1->status().state());
AWAIT_READY(runningUpdate2);
ASSERT_EQ(v1::TASK_RUNNING, runningUpdate2->status().state());
+ const hashset<v1::TaskID> tasks{task1.task_id(), task2.task_id()};
+
// TASK_RUNNING updates for the tasks in a
// task group can be received in any order.
const hashset<v1::TaskID> tasksRunning{
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/slave_authorization_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/slave_authorization_tests.cpp b/src/tests/slave_authorization_tests.cpp
index 23e9d0b..4c7d37f 100644
--- a/src/tests/slave_authorization_tests.cpp
+++ b/src/tests/slave_authorization_tests.cpp
@@ -633,12 +633,10 @@ TYPED_TEST(SlaveAuthorizerTest, AuthorizeRunTaskOnAgent)
// The first task should fail since the task user `foo` is not an
// authorized user that can launch a task. However, the second task
// should succeed.
- 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));
@@ -646,19 +644,16 @@ TYPED_TEST(SlaveAuthorizerTest, AuthorizeRunTaskOnAgent)
{offer.id()},
{LAUNCH({task1, task2})});
- // Wait for TASK_FAILED for 1st task, and TASK_STARTING followed by
- // TASK_RUNNING for 2nd task.
- AWAIT_READY(status0);
+ // Wait for TASK_FAILED for 1st task, and TASK_RUNNING for 2nd task.
AWAIT_READY(status1);
AWAIT_READY(status2);
// Validate both the statuses. Note that the order of receiving the
- // status updates for the 2 tasks is not deterministic, but we know
- // that task2's TASK_RUNNING ARRIVES after TASK_STARTING.
- hashmap<TaskID, TaskStatus> statuses;
- statuses[status0->task_id()] = status0.get();
- statuses[status1->task_id()] = status1.get();
- statuses[status2->task_id()] = status2.get();
+ // status updates for the 2 tasks is not deterministic.
+ hashmap<TaskID, TaskStatus> statuses {
+ {status1->task_id(), status1.get()},
+ {status2->task_id(), status2.get()}
+ };
ASSERT_TRUE(statuses.contains(task1.task_id()));
EXPECT_EQ(TASK_ERROR, statuses.at(task1.task_id()).state());
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/slave_recovery_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/slave_recovery_tests.cpp b/src/tests/slave_recovery_tests.cpp
index 8f328e9..30d8c23 100644
--- a/src/tests/slave_recovery_tests.cpp
+++ b/src/tests/slave_recovery_tests.cpp
@@ -252,7 +252,7 @@ TYPED_TEST(SlaveRecoveryTest, RecoverSlaveState)
// Capture the update.
AWAIT_READY(update);
- EXPECT_EQ(TASK_STARTING, update->update().status().state());
+ EXPECT_EQ(TASK_RUNNING, update->update().status().state());
// Wait for the ACK to be checkpointed.
AWAIT_READY(_statusUpdateAcknowledgement);
@@ -423,7 +423,7 @@ TYPED_TEST(SlaveRecoveryTest, RecoverStatusUpdateManager)
ASSERT_SOME(slave);
AWAIT_READY(status);
- EXPECT_EQ(TASK_STARTING, status->state());
+ EXPECT_EQ(TASK_RUNNING, status->state());
driver.stop();
driver.join();
@@ -514,7 +514,7 @@ TYPED_TEST(SlaveRecoveryTest, DISABLED_ReconnectHTTPExecutor)
// Scheduler should receive the recovered update.
AWAIT_READY(status);
- EXPECT_EQ(TASK_STARTING, status->state());
+ EXPECT_EQ(TASK_RUNNING, status->state());
driver.stop();
driver.join();
@@ -762,13 +762,13 @@ TYPED_TEST(SlaveRecoveryTest, ReconnectExecutor)
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
// Drop the first update from the executor.
- Future<StatusUpdateMessage> startingUpdate =
+ Future<StatusUpdateMessage> statusUpdate =
DROP_PROTOBUF(StatusUpdateMessage(), _, _);
driver.launchTasks(offers.get()[0].id(), {task});
// Stop the slave before the status update is received.
- AWAIT_READY(startingUpdate);
+ AWAIT_READY(statusUpdate);
slave.get()->terminate();
@@ -791,15 +791,15 @@ TYPED_TEST(SlaveRecoveryTest, ReconnectExecutor)
// Ensure the executor re-registers.
AWAIT_READY(reregister);
- // Executor should inform about the unacknowledged updates.
- ASSERT_EQ(2, reregister->updates_size());
+ // Executor should inform about the unacknowledged update.
+ ASSERT_EQ(1, reregister->updates_size());
const StatusUpdate& update = reregister->updates(0);
EXPECT_EQ(task.task_id(), update.status().task_id());
- EXPECT_EQ(TASK_STARTING, update.status().state());
+ EXPECT_EQ(TASK_RUNNING, update.status().state());
// Scheduler should receive the recovered update.
AWAIT_READY(status);
- EXPECT_EQ(TASK_STARTING, status->state());
+ EXPECT_EQ(TASK_RUNNING, status->state());
driver.stop();
driver.join();
@@ -846,8 +846,7 @@ TYPED_TEST(SlaveRecoveryTest, ReconnectExecutorRetry)
Future<TaskStatus> statusUpdate;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&statusUpdate))
- .WillRepeatedly(Return()); // Ignore subsequent TASK_RUNNING updates.
+ .WillOnce(FutureArg<1>(&statusUpdate));
driver.start();
@@ -864,7 +863,7 @@ TYPED_TEST(SlaveRecoveryTest, ReconnectExecutorRetry)
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(statusUpdate);
- EXPECT_EQ(TASK_STARTING, statusUpdate->state());
+ EXPECT_EQ(TASK_RUNNING, statusUpdate->state());
// Ensure the acknowledgement is checkpointed.
Clock::settle();
@@ -975,19 +974,12 @@ TYPED_TEST(SlaveRecoveryTest, PingTimeoutDuringRecovery)
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
- Future<TaskStatus> statusUpdate0;
Future<TaskStatus> statusUpdate1;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&statusUpdate0))
.WillOnce(FutureArg<1>(&statusUpdate1));
driver.launchTasks(offers.get()[0].id(), {task});
- AWAIT_READY(statusUpdate0);
- ASSERT_EQ(TASK_STARTING, statusUpdate0->state());
-
- driver.acknowledgeStatusUpdate(statusUpdate0.get());
-
AWAIT_READY(statusUpdate1);
ASSERT_EQ(TASK_RUNNING, statusUpdate1->state());
@@ -1824,7 +1816,7 @@ TYPED_TEST(SlaveRecoveryTest, RecoverCompletedExecutor)
TaskInfo task = createTask(offers1.get()[0], "exit 0");
EXPECT_CALL(sched, statusUpdate(_, _))
- .Times(3); // TASK_STARTING, TASK_RUNNING and TASK_FINISHED updates.
+ .Times(2); // TASK_RUNNING and TASK_FINISHED updates.
EXPECT_CALL(sched, offerRescinded(_, _))
.Times(AtMost(1));
@@ -2447,21 +2439,15 @@ TYPED_TEST(SlaveRecoveryTest, KillTask)
TaskInfo task = createTask(offers1.get()[0], "sleep 1000");
- // Expect a TASK_STARTING and a TASK_RUNNING update
- EXPECT_CALL(sched, statusUpdate(_, _))
- .Times(2);
-
- Future<Nothing> ack1 =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
+ EXPECT_CALL(sched, statusUpdate(_, _));
- Future<Nothing> ack2 =
+ Future<Nothing> ack =
FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
driver.launchTasks(offers1.get()[0].id(), {task});
// Wait for the ACK to be checkpointed.
- AWAIT_READY(ack1);
- AWAIT_READY(ack2);
+ AWAIT_READY(ack);
slave.get()->terminate();
@@ -3082,10 +3068,9 @@ TYPED_TEST(SlaveRecoveryTest, ShutdownSlave)
TaskInfo task = createTask(offers1.get()[0], "sleep 1000");
- Future<Nothing> statusUpdate1, statusUpdate2;
+ Future<Nothing> statusUpdate1;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureSatisfy(&statusUpdate1)) // TASK_STARTING
- .WillOnce(FutureSatisfy(&statusUpdate2)) // TASK_RUNNING
+ .WillOnce(FutureSatisfy(&statusUpdate1))
.WillOnce(Return()); // Ignore TASK_FAILED update.
Future<Message> registerExecutor =
@@ -3097,7 +3082,7 @@ TYPED_TEST(SlaveRecoveryTest, ShutdownSlave)
AWAIT_READY(registerExecutor);
UPID executorPid = registerExecutor->from;
- AWAIT_READY(statusUpdate2); // Wait for TASK_RUNNING update.
+ AWAIT_READY(statusUpdate1); // Wait for TASK_RUNNING update.
EXPECT_CALL(sched, offerRescinded(_, _))
.Times(AtMost(1));
@@ -3201,22 +3186,18 @@ TYPED_TEST(SlaveRecoveryTest, ShutdownSlaveSIGUSR1)
TaskInfo task = createTask(offers.get()[0], "sleep 1000");
- Future<TaskStatus> statusStarting, statusRunning;
+ Future<TaskStatus> status;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&statusStarting))
- .WillOnce(FutureArg<1>(&statusRunning));
+ .WillOnce(FutureArg<1>(&status));
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());
+ AWAIT_READY(status);
+ EXPECT_EQ(TASK_RUNNING, status->state());
- Future<TaskStatus> statusLost;
+ Future<TaskStatus> status2;
EXPECT_CALL(sched, statusUpdate(_, _))
- .WillOnce(FutureArg<1>(&statusLost));
+ .WillOnce(FutureArg<1>(&status2));
Future<Nothing> slaveLost;
EXPECT_CALL(sched, slaveLost(_, _))
@@ -3242,11 +3223,11 @@ TYPED_TEST(SlaveRecoveryTest, ShutdownSlaveSIGUSR1)
AWAIT_READY(executorTerminated);
// The master should send a TASK_LOST and slaveLost.
- AWAIT_READY(statusLost);
+ AWAIT_READY(status2);
- EXPECT_EQ(TASK_LOST, statusLost->state());
- EXPECT_EQ(TaskStatus::SOURCE_MASTER, statusLost->source());
- EXPECT_EQ(TaskStatus::REASON_SLAVE_REMOVED, statusLost->reason());
+ EXPECT_EQ(TASK_LOST, status2->state());
+ EXPECT_EQ(TaskStatus::SOURCE_MASTER, status2->source());
+ EXPECT_EQ(TaskStatus::REASON_SLAVE_REMOVED, status2->reason());
AWAIT_READY(slaveLost);
@@ -3434,21 +3415,16 @@ TYPED_TEST(SlaveRecoveryTest, ReconcileKillTask)
SlaveID slaveId = offers1.get()[0].slave_id();
FrameworkID frameworkId = offers1.get()[0].framework_id();
- // Expecting TASK_STARTING and TASK_RUNNING status.
- EXPECT_CALL(sched, statusUpdate(_, _))
- .Times(2);
-
- Future<Nothing> _statusUpdateAcknowledgement1 =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
+ // Expecting TASK_RUNNING status.
+ EXPECT_CALL(sched, statusUpdate(_, _));
- Future<Nothing> _statusUpdateAcknowledgement2 =
+ Future<Nothing> _statusUpdateAcknowledgement =
FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
driver.launchTasks(offers1.get()[0].id(), {task});
// Wait for TASK_RUNNING update to be acknowledged.
- AWAIT_READY(_statusUpdateAcknowledgement1);
- AWAIT_READY(_statusUpdateAcknowledgement2);
+ AWAIT_READY(_statusUpdateAcknowledgement);
slave.get()->terminate();
@@ -3848,21 +3824,15 @@ TYPED_TEST(SlaveRecoveryTest, SchedulerFailover)
// Create a long running task.
TaskInfo task = createTask(offers1.get()[0], "sleep 1000");
- // Expecting TASK_STARTING and TASK_RUNNING updates
- EXPECT_CALL(sched1, statusUpdate(_, _))
- .Times(2);
+ EXPECT_CALL(sched1, statusUpdate(_, _));
- Future<Nothing> _statusUpdateAcknowledgement1 =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
-
- Future<Nothing> _statusUpdateAcknowledgement2 =
+ Future<Nothing> _statusUpdateAcknowledgement =
FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
driver1.launchTasks(offers1.get()[0].id(), {task});
// Wait for the ACK to be checkpointed.
- AWAIT_READY(_statusUpdateAcknowledgement1);
- AWAIT_READY(_statusUpdateAcknowledgement2);
+ AWAIT_READY(_statusUpdateAcknowledgement);
slave.get()->terminate();
@@ -4005,20 +3975,15 @@ TYPED_TEST(SlaveRecoveryTest, MasterFailover)
TaskInfo task = createTask(offers1.get()[0], "sleep 1000");
- EXPECT_CALL(sched, statusUpdate(_, _))
- .Times(2);
-
- Future<Nothing> _statusUpdateAcknowledgement1 =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
+ EXPECT_CALL(sched, statusUpdate(_, _));
- Future<Nothing> _statusUpdateAcknowledgement2 =
+ Future<Nothing> _statusUpdateAcknowledgement =
FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
driver.launchTasks(offers1.get()[0].id(), {task});
- // Wait for both ACKs to be checkpointed.
- AWAIT_READY(_statusUpdateAcknowledgement1);
- AWAIT_READY(_statusUpdateAcknowledgement2);
+ // Wait for the ACK to be checkpointed.
+ AWAIT_READY(_statusUpdateAcknowledgement);
slave.get()->terminate();
@@ -4152,20 +4117,15 @@ TYPED_TEST(SlaveRecoveryTest, MultipleFrameworks)
// Framework 1 launches a task.
TaskInfo task1 = createTask(offer1, "sleep 1000");
- EXPECT_CALL(sched1, statusUpdate(_, _))
- .Times(2);
+ EXPECT_CALL(sched1, statusUpdate(_, _));
- Future<Nothing> _startingStatusUpdateAcknowledgement1 =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
-
- Future<Nothing> _runningStatusUpdateAcknowledgement1 =
+ Future<Nothing> _statusUpdateAcknowledgement1 =
FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
driver1.launchTasks(offer1.id(), {task1});
// Wait for the ACK to be checkpointed.
- AWAIT_READY(_startingStatusUpdateAcknowledgement1);
- AWAIT_READY(_runningStatusUpdateAcknowledgement1);
+ AWAIT_READY(_statusUpdateAcknowledgement1);
// Framework 2. Enable checkpointing.
FrameworkInfo frameworkInfo2 = DEFAULT_FRAMEWORK_INFO;
@@ -4190,20 +4150,14 @@ TYPED_TEST(SlaveRecoveryTest, MultipleFrameworks)
// Framework 2 launches a task.
TaskInfo task2 = createTask(offers2.get()[0], "sleep 1000");
- EXPECT_CALL(sched2, statusUpdate(_, _))
- .Times(2);
-
- Future<Nothing> _startingStatusUpdateAcknowledgement2 =
- FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
+ EXPECT_CALL(sched2, statusUpdate(_, _));
- Future<Nothing> _runningStatusUpdateAcknowledgement2 =
+ Future<Nothing> _statusUpdateAcknowledgement2 =
FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);
-
driver2.launchTasks(offers2.get()[0].id(), {task2});
// Wait for the ACK to be checkpointed.
- AWAIT_READY(_startingStatusUpdateAcknowledgement2);
- AWAIT_READY(_runningStatusUpdateAcknowledgement2);
+ AWAIT_READY(_statusUpdateAcknowledgement2);
slave.get()->terminate();
@@ -4327,20 +4281,15 @@ TYPED_TEST(SlaveRecoveryTest, MultipleSlaves)
// Launch a long running task in the first slave.
TaskInfo task1 = createTask(offers1.get()[0], "sleep 1000");
- EXPECT_CALL(sched, statusUpdate(_, _))
- .Times(2);
-
- Future<Nothing> _startingStatusUpdateAcknowledgement1 =
- FUTURE_DISPATCH(slave1.get()->pid, &Slave::_statusUpdateAcknowledgement);
+ EXPECT_CALL(sched, statusUpdate(_, _));
- Future<Nothing> _runningStatusUpdateAcknowledgement1 =
+ Future<Nothing> _statusUpdateAcknowledgement1 =
FUTURE_DISPATCH(slave1.get()->pid, &Slave::_statusUpdateAcknowledgement);
driver.launchTasks(offers1.get()[0].id(), {task1});
// Wait for the ACK to be checkpointed.
- AWAIT_READY(_startingStatusUpdateAcknowledgement1);
- AWAIT_READY(_runningStatusUpdateAcknowledgement1);
+ AWAIT_READY(_statusUpdateAcknowledgement1);
Future<vector<Offer>> offers2;
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -4367,20 +4316,15 @@ TYPED_TEST(SlaveRecoveryTest, MultipleSlaves)
// Launch a long running task in each slave.
TaskInfo task2 = createTask(offers2.get()[0], "sleep 1000");
- EXPECT_CALL(sched, statusUpdate(_, _))
- .Times(2);
-
- Future<Nothing> _startingStatusUpdateAcknowledgement2 =
- FUTURE_DISPATCH(slave2.get()->pid, &Slave::_statusUpdateAcknowledgement);
+ EXPECT_CALL(sched, statusUpdate(_, _));
- Future<Nothing> _runningStatusUpdateAcknowledgement2 =
+ Future<Nothing> _statusUpdateAcknowledgement2 =
FUTURE_DISPATCH(slave2.get()->pid, &Slave::_statusUpdateAcknowledgement);
driver.launchTasks(offers2.get()[0].id(), {task2});
// Wait for the ACKs to be checkpointed.
- AWAIT_READY(_startingStatusUpdateAcknowledgement2);
- AWAIT_READY(_runningStatusUpdateAcknowledgement2);
+ AWAIT_READY(_statusUpdateAcknowledgement2);
slave1.get()->terminate();
slave2.get()->terminate();
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/slave_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/slave_tests.cpp b/src/tests/slave_tests.cpp
index 67c8091..6d1e98d 100644
--- a/src/tests/slave_tests.cpp
+++ b/src/tests/slave_tests.cpp
@@ -680,22 +680,16 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(SlaveTest, CommandTaskWithArguments)
task.mutable_command()->MergeFrom(command);
- 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});
- // Scheduler should first receive TASK_STARTING, followed by
- // TASK_RUNNING and TASK_FINISHED from the executor.
- AWAIT_READY(statusStarting);
- EXPECT_EQ(TASK_STARTING, statusStarting->state());
- EXPECT_EQ(TaskStatus::SOURCE_EXECUTOR, statusStarting->source());
-
+ // Scheduler should first receive TASK_RUNNING followed by the
+ // TASK_FINISHED from the executor.
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
EXPECT_EQ(TaskStatus::SOURCE_EXECUTOR, statusRunning->source());
@@ -752,17 +746,12 @@ TEST_F(SlaveTest, CommandTaskWithKillPolicy)
task.mutable_kill_policy()->mutable_grace_period()->set_nanoseconds(
gracePeriod.ns());
- Future<TaskStatus> statusStarting;
Future<TaskStatus> statusRunning;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&statusStarting))
.WillOnce(FutureArg<1>(&statusRunning));
driver.launchTasks(offer.id(), {task});
- AWAIT_READY(statusStarting);
- EXPECT_EQ(TASK_STARTING, statusStarting->state());
-
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -2392,21 +2381,15 @@ TEST_F(SlaveTest, StatisticsEndpointRunningExecutor)
Resources::parse("cpus:1;mem:32").get(),
SLEEP_COMMAND(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));
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());
// Hit the statistics endpoint and expect the response contains the
// resource statistics for the running container.
@@ -5227,21 +5210,16 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(SlaveTest, ExecutorEnvironmentVariables)
task.mutable_command()->MergeFrom(command);
- 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});
- // Scheduler should first receive TASK_STARTING, followed by
- // TASK_STARTING and TASK_FINISHED from the executor.
- AWAIT_READY(statusStarting);
- EXPECT_EQ(TASK_STARTING, statusStarting->state());
-
+ // Scheduler should first receive TASK_RUNNING followed by the
+ // TASK_FINISHED from the executor.
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning->state());
@@ -5587,7 +5565,7 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(SlaveTest, HTTPSchedulerSlaveRestart)
UPID executorPid = registerExecutorMessage->from;
AWAIT_READY(status);
- EXPECT_EQ(TASK_STARTING, status->state());
+ EXPECT_EQ(TASK_RUNNING, status->state());
// Restart the slave.
slave.get()->terminate();
@@ -8201,19 +8179,12 @@ TEST_F_TEMP_DISABLED_ON_WINDOWS(SlaveTest, ExecutorReregistrationTimeoutFlag)
TaskInfo task = createTask(offers->front(), "sleep 1000");
- Future<TaskStatus> statusUpdate0;
Future<TaskStatus> statusUpdate1;
EXPECT_CALL(sched, statusUpdate(&driver, _))
- .WillOnce(FutureArg<1>(&statusUpdate0))
.WillOnce(FutureArg<1>(&statusUpdate1));
driver.launchTasks(offers->front().id(), {task});
- AWAIT_READY(statusUpdate0);
- ASSERT_EQ(TASK_STARTING, statusUpdate0->state());
-
- driver.acknowledgeStatusUpdate(statusUpdate0.get());
-
AWAIT_READY(statusUpdate1);
ASSERT_EQ(TASK_RUNNING, statusUpdate1->state());
http://git-wip-us.apache.org/repos/asf/mesos/blob/2a742653/src/tests/teardown_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/teardown_tests.cpp b/src/tests/teardown_tests.cpp
index 392cacf..5eada4f 100644
--- a/src/tests/teardown_tests.cpp
+++ b/src/tests/teardown_tests.cpp
@@ -353,31 +353,20 @@ TEST_F(TeardownTest, RecoveredFrameworkAfterMasterFailover)
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.
[3/3] mesos git commit: Revert "Fix unit tests that were broken by
the additional...".
Posted by al...@apache.org.
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());