[mesos] 15/21: Added a test `ROOT_CGROUPS_CFS_CommandTaskInfiniteLimits`.

[qi...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

qianzhang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mesos.git

commit 6fa85d888a0555f70c331e84f1c32211758d56f4
Author: Qian Zhang <zh...@gmail.com>
AuthorDate: Sat Mar 7 15:27:33 2020 +0800

    Added a test `ROOT_CGROUPS_CFS_CommandTaskInfiniteLimits`.
    
    Review: https://reviews.apache.org/r/72210
---
 src/tests/containerizer/cgroups_isolator_tests.cpp | 120 +++++++++++++++++++++
 1 file changed, 120 insertions(+)

diff --git a/src/tests/containerizer/cgroups_isolator_tests.cpp b/src/tests/containerizer/cgroups_isolator_tests.cpp
index 71d4604..3578f88 100644
--- a/src/tests/containerizer/cgroups_isolator_tests.cpp
+++ b/src/tests/containerizer/cgroups_isolator_tests.cpp
@@ -14,6 +14,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <limits>
+
 #include <process/gmock.hpp>
 #include <process/gtest.hpp>
 #include <process/queue.hpp>
@@ -729,6 +731,124 @@ TEST_F(CgroupsIsolatorTest, ROOT_CGROUPS_CFS_CommandTaskLimits)
 }
 
 
+// This test verifies that a task launched with infinite resource
+// limits specified will have its CPU and memory's hard limits set
+// correctly to infinite values.
+TEST_F(CgroupsIsolatorTest, ROOT_CGROUPS_CFS_CommandTaskInfiniteLimits)
+{
+  Try<Owned<cluster::Master>> master = StartMaster();
+  ASSERT_SOME(master);
+
+  slave::Flags flags = CreateSlaveFlags();
+  flags.isolation = "cgroups/cpu,cgroups/mem";
+
+  Fetcher fetcher(flags);
+
+  Try<MesosContainerizer*> _containerizer =
+    MesosContainerizer::create(flags, true, &fetcher);
+
+  ASSERT_SOME(_containerizer);
+
+  Owned<MesosContainerizer> containerizer(_containerizer.get());
+
+  Owned<MasterDetector> detector = master.get()->createDetector();
+
+  Try<Owned<cluster::Slave>> slave = StartSlave(
+      detector.get(),
+      containerizer.get());
+
+  ASSERT_SOME(slave);
+
+  MockScheduler sched;
+
+  MesosSchedulerDriver driver(
+      &sched,
+      DEFAULT_FRAMEWORK_INFO,
+      master.get()->pid,
+      DEFAULT_CREDENTIAL);
+
+  EXPECT_CALL(sched, registered(&driver, _, _));
+
+  Future<vector<Offer>> offers;
+  EXPECT_CALL(sched, resourceOffers(&driver, _))
+    .WillOnce(FutureArg<1>(&offers))
+    .WillRepeatedly(Return()); // Ignore subsequent offers.
+
+  driver.start();
+
+  AWAIT_READY(offers);
+  ASSERT_FALSE(offers->empty());
+
+  // Launch a task with infinite resource limits.
+  Value::Scalar cpuLimit, memLimit;
+  cpuLimit.set_value(std::numeric_limits<double>::infinity());
+  memLimit.set_value(std::numeric_limits<double>::infinity());
+
+  google::protobuf::Map<string, Value::Scalar> resourceLimits;
+  resourceLimits.insert({"cpus", cpuLimit});
+  resourceLimits.insert({"mem", memLimit});
+
+  TaskInfo task = createTask(
+      offers.get()[0].slave_id(),
+      offers.get()[0].resources(),
+      "sleep 1000",
+      None(),
+      "test-task",
+      id::UUID::random().toString(),
+      resourceLimits);
+
+  Future<TaskStatus> statusStarting;
+  Future<TaskStatus> statusRunning;
+  EXPECT_CALL(sched, statusUpdate(&driver, _))
+    .WillOnce(FutureArg<1>(&statusStarting))
+    .WillOnce(FutureArg<1>(&statusRunning));
+
+  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());
+
+  Future<hashset<ContainerID>> containers = containerizer->containers();
+  AWAIT_READY(containers);
+  ASSERT_EQ(1u, containers->size());
+
+  ContainerID containerId = *(containers->begin());
+
+  Result<string> cpuHierarchy = cgroups::hierarchy("cpu");
+  ASSERT_SOME(cpuHierarchy);
+
+  Result<string> memoryHierarchy = cgroups::hierarchy("memory");
+  ASSERT_SOME(memoryHierarchy);
+
+  string cgroup = path::join(flags.cgroups_root, containerId.value());
+
+  // The CFS quota should be -1 which means infinite quota.
+  Try<string> quota =
+    cgroups::read(cpuHierarchy.get(), cgroup, "cpu.cfs_quota_us");
+
+  ASSERT_SOME(quota);
+  EXPECT_EQ("-1", strings::trim(quota.get()));
+
+  // Root cgroup (e.g., `/sys/fs/cgroup/memory/`) cannot have any limits set, so
+  // its hard limit must be infinity.
+  Try<Bytes> rootCgrouplimit =
+    cgroups::memory::limit_in_bytes(memoryHierarchy.get(), "");
+
+  ASSERT_SOME(rootCgrouplimit);
+
+  // The memory hard limit should be same as root cgroup's, i.e. infinity.
+  EXPECT_SOME_EQ(
+      rootCgrouplimit.get(),
+      cgroups::memory::limit_in_bytes(memoryHierarchy.get(), cgroup));
+
+  driver.stop();
+  driver.join();
+}
+
+
 // This test verifies the limit swap functionality. Note that We use
 // the default executor here in order to exercise both the increasing
 // and decreasing of the memory limit.