mesos git commit: Added unit test for killing the default executor process.

[gi...@apache.org]

Repository: mesos
Updated Branches:
  refs/heads/master 2d435fe84 -> 9ca2cc8ae


Added unit test for killing the default executor process.

Review: https://reviews.apache.org/r/61981


Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/9ca2cc8a
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/9ca2cc8a
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/9ca2cc8a

Branch: refs/heads/master
Commit: 9ca2cc8ae751905f078b056b265fb4511ea8e5f4
Parents: 2d435fe
Author: Gilbert Song <so...@gmail.com>
Authored: Tue Aug 29 17:31:35 2017 -0700
Committer: Gilbert Song <so...@gmail.com>
Committed: Thu Aug 31 23:23:51 2017 -0700

----------------------------------------------------------------------
 src/tests/default_executor_tests.cpp | 129 ++++++++++++++++++++++++++++++
 1 file changed, 129 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/mesos/blob/9ca2cc8a/src/tests/default_executor_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/default_executor_tests.cpp b/src/tests/default_executor_tests.cpp
index 138c428..8b6edf7 100644
--- a/src/tests/default_executor_tests.cpp
+++ b/src/tests/default_executor_tests.cpp
@@ -49,6 +49,8 @@
 #include "tests/containerizer.hpp"
 #include "tests/mesos.hpp"
 
+#include "slave/containerizer/mesos/containerizer.hpp"
+
 using mesos::master::detector::MasterDetector;
 
 using mesos::v1::scheduler::Call;
@@ -71,6 +73,12 @@ using testing::DoAll;
 using testing::Return;
 using testing::WithParamInterface;
 
+using mesos::internal::slave::Containerizer;
+using mesos::internal::slave::Fetcher;
+using mesos::internal::slave::MesosContainerizer;
+
+using mesos::slave::ContainerTermination;
+
 namespace mesos {
 namespace internal {
 namespace tests {
@@ -1373,6 +1381,127 @@ TEST_P(DefaultExecutorTest, ReservedResources)
 }
 
 
+// This is a regression test for MESOS-7926. It verifies that if
+// the default executor process is killed, the future of the nested
+// container destroy will be discarded and that discard will
+// not propagate back to the executor container destroy, to make
+// sure the executor container destroy can be finished correctly.
+TEST_P(DefaultExecutorTest, SigkillExecutor)
+{
+  Try<Owned<cluster::Master>> master = StartMaster();
+  ASSERT_SOME(master);
+
+  slave::Flags flags = CreateSlaveFlags();
+  flags.containerizers = GetParam();
+
+  Fetcher fetcher(flags);
+
+  Try<MesosContainerizer*> create =
+    MesosContainerizer::create(flags, true, &fetcher);
+
+  ASSERT_SOME(create);
+
+  Owned<Containerizer> containerizer(create.get());
+
+  Owned<MasterDetector> detector = master.get()->createDetector();
+
+  Try<Owned<cluster::Slave>> slave = StartSlave(
+      detector.get(),
+      containerizer.get(),
+      flags);
+
+  ASSERT_SOME(slave);
+
+  auto scheduler = std::make_shared<v1::MockHTTPScheduler>();
+
+  Future<Nothing> connected;
+  EXPECT_CALL(*scheduler, connected(_))
+    .WillOnce(DoAll(v1::scheduler::SendSubscribe(v1::DEFAULT_FRAMEWORK_INFO),
+                    FutureSatisfy(&connected)));
+
+  v1::scheduler::TestMesos mesos(
+      master.get()->pid,
+      ContentType::PROTOBUF,
+      scheduler);
+
+  AWAIT_READY(connected);
+
+  Future<v1::scheduler::Event::Subscribed> subscribed;
+  EXPECT_CALL(*scheduler, subscribed(_, _))
+    .WillOnce(FutureArg<1>(&subscribed));
+
+  Future<v1::scheduler::Event::Offers> offers;
+  EXPECT_CALL(*scheduler, offers(_, _))
+    .WillOnce(FutureArg<1>(&offers));
+
+  EXPECT_CALL(*scheduler, heartbeat(_))
+    .WillRepeatedly(Return()); // Ignore heartbeats.
+
+  AWAIT_READY(subscribed);
+
+  v1::FrameworkID frameworkId(subscribed->framework_id());
+  v1::ExecutorInfo executorInfo = v1::createExecutorInfo(
+      "test_default_executor",
+      None(),
+      "cpus:0.1;mem:32;disk:32",
+      v1::ExecutorInfo::DEFAULT);
+
+  // Update `executorInfo` with the subscribed `frameworkId`.
+  executorInfo.mutable_framework_id()->CopyFrom(frameworkId);
+
+  AWAIT_READY(offers);
+  ASSERT_FALSE(offers->offers().empty());
+
+  const v1::Offer& offer = offers->offers(0);
+  const v1::AgentID& agentId = offer.agent_id();
+
+  v1::TaskInfo taskInfo = v1::createTask(
+      agentId,
+      v1::Resources::parse("cpus:0.1;mem:32;disk:32").get(),
+      "sleep 1000");
+
+  Future<v1::scheduler::Event::Update> update;
+  EXPECT_CALL(*scheduler, update(_, _))
+    .WillOnce(FutureArg<1>(&update));
+
+  v1::Offer::Operation launchGroup = v1::LAUNCH_GROUP(
+      executorInfo,
+      v1::createTaskGroupInfo({taskInfo}));
+
+  mesos.send(v1::createCallAccept(frameworkId, offer, {launchGroup}));
+
+  AWAIT_READY(update);
+
+  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 = update->status().container_status();
+
+  ASSERT_TRUE(status.has_container_id());
+  EXPECT_TRUE(status.container_id().has_parent());
+
+  v1::ContainerID executorContainerId = status.container_id().parent();
+
+  Future<Option<ContainerTermination>> wait =
+    containerizer->wait(devolve(executorContainerId));
+
+  Future<ContainerStatus> executorStatus =
+    containerizer->status(devolve(executorContainerId));
+
+  AWAIT_READY(executorStatus);
+  ASSERT_TRUE(executorStatus->has_executor_pid());
+
+  ASSERT_SOME(os::killtree(executorStatus->executor_pid(), SIGKILL));
+
+  AWAIT_READY(wait);
+  ASSERT_SOME(wait.get());
+  ASSERT_TRUE(wait.get()->has_status());
+  EXPECT_WTERMSIG_EQ(SIGKILL, wait.get()->status());
+}
+
+
 #ifdef __linux__
 // This test verifies that tasks from two different
 // task groups can share the same pid namespace.