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 2016/10/27 13:49:36 UTC
[1/6] mesos git commit: Added the health check test helper.
Repository: mesos
Updated Branches:
refs/heads/master e5ea4f48b -> 388bc4d08
Added the health check test helper.
This patch updates the test helper with a simple HTTP server that
listens on given IP and port to facilitate testing health checks.
Review: https://reviews.apache.org/r/52786/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/eeb97dfa
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/eeb97dfa
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/eeb97dfa
Branch: refs/heads/master
Commit: eeb97dfa05533c392b1d0ca49a435cbea262452f
Parents: e5ea4f4
Author: haosdent huang <ha...@gmail.com>
Authored: Thu Oct 27 14:22:50 2016 +0200
Committer: Alexander Rukletsov <al...@apache.org>
Committed: Thu Oct 27 14:22:50 2016 +0200
----------------------------------------------------------------------
src/Makefile.am | 3 ++
src/tests/CMakeLists.txt | 1 +
src/tests/health_check_test_helper.cpp | 76 +++++++++++++++++++++++++++++
src/tests/health_check_test_helper.hpp | 56 +++++++++++++++++++++
src/tests/test_helper_main.cpp | 3 ++
5 files changed, 139 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/eeb97dfa/src/Makefile.am
----------------------------------------------------------------------
diff --git a/src/Makefile.am b/src/Makefile.am
index 769e998..c2f9e44 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -995,6 +995,7 @@ libmesos_no_3rdparty_la_SOURCES += \
tests/containerizer.hpp \
tests/environment.hpp \
tests/flags.hpp \
+ tests/health_check_test_helper.hpp \
tests/limiter.hpp \
tests/mesos.hpp \
tests/mock_docker.hpp \
@@ -1933,6 +1934,7 @@ check_PROGRAMS += test-helper
test_helper_SOURCES = \
tests/active_user_test_helper.cpp \
tests/flags.cpp \
+ tests/health_check_test_helper.cpp \
tests/resources_utils.cpp \
tests/test_helper_main.cpp \
tests/utils.cpp \
@@ -2103,6 +2105,7 @@ mesos_tests_SOURCES = \
tests/gc_tests.cpp \
tests/hdfs_tests.cpp \
tests/health_check_tests.cpp \
+ tests/health_check_test_helper.cpp \
tests/hierarchical_allocator_tests.cpp \
tests/hook_tests.cpp \
tests/http_authentication_tests.cpp \
http://git-wip-us.apache.org/repos/asf/mesos/blob/eeb97dfa/src/tests/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index 18d6b15..cf583ea 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -21,6 +21,7 @@ set(TEST_HELPER_SRC
${TEST_HELPER_SRC}
active_user_test_helper.cpp
flags.cpp
+ health_check_test_helper.cpp
resources_utils.cpp
test_helper_main.cpp
utils.cpp
http://git-wip-us.apache.org/repos/asf/mesos/blob/eeb97dfa/src/tests/health_check_test_helper.cpp
----------------------------------------------------------------------
diff --git a/src/tests/health_check_test_helper.cpp b/src/tests/health_check_test_helper.cpp
new file mode 100644
index 0000000..88352c1
--- /dev/null
+++ b/src/tests/health_check_test_helper.cpp
@@ -0,0 +1,76 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "tests/health_check_test_helper.hpp"
+
+#include <cstdlib>
+
+#include <process/id.hpp>
+#include <process/process.hpp>
+
+#include <stout/os.hpp>
+#include <stout/stringify.hpp>
+
+using process::Process;
+
+using std::cerr;
+using std::endl;
+
+namespace mesos {
+namespace internal {
+namespace tests {
+
+const char HealthCheckTestHelper::NAME[] = "HealthCheck";
+
+
+class HttpServer : public Process<HttpServer>
+{
+public:
+ HttpServer()
+ : ProcessBase(process::ID::generate("http-server")) {}
+};
+
+
+HealthCheckTestHelper::Flags::Flags()
+{
+ add(&Flags::ip,
+ "ip",
+ "IP address to listen on.");
+
+ add(&Flags::port,
+ "port",
+ "Port to listen on.");
+}
+
+
+int HealthCheckTestHelper::execute()
+{
+ os::setenv("LIBPROCESS_IP", flags.ip);
+ os::setenv("LIBPROCESS_PORT", stringify(flags.port));
+
+ HttpServer* server = new HttpServer();
+
+ process::spawn(server);
+ process::wait(server->self());
+
+ delete server;
+
+ return EXIT_SUCCESS;
+}
+
+} // namespace tests {
+} // namespace internal {
+} // namespace mesos {
http://git-wip-us.apache.org/repos/asf/mesos/blob/eeb97dfa/src/tests/health_check_test_helper.hpp
----------------------------------------------------------------------
diff --git a/src/tests/health_check_test_helper.hpp b/src/tests/health_check_test_helper.hpp
new file mode 100644
index 0000000..cdedf09
--- /dev/null
+++ b/src/tests/health_check_test_helper.hpp
@@ -0,0 +1,56 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef __HEALTH_CHECK_TEST_HELPER_HPP__
+#define __HEALTH_CHECK_TEST_HELPER_HPP__
+
+#include <cstdint>
+#include <string>
+
+#include <stout/flags.hpp>
+#include <stout/subcommand.hpp>
+
+namespace mesos {
+namespace internal {
+namespace tests {
+
+class HealthCheckTestHelper : public Subcommand
+{
+public:
+ static const char NAME[];
+
+ struct Flags : public virtual flags::FlagsBase
+ {
+ Flags();
+
+ std::string ip;
+ uint16_t port;
+ };
+
+ HealthCheckTestHelper() : Subcommand(NAME) {}
+
+ Flags flags;
+
+protected:
+ virtual int execute();
+ virtual flags::FlagsBase* getFlags() { return &flags; }
+};
+
+} // namespace tests {
+} // namespace internal {
+} // namespace mesos {
+
+#endif // __HEALTH_CHECK_TEST_HELPER_HPP__
http://git-wip-us.apache.org/repos/asf/mesos/blob/eeb97dfa/src/tests/test_helper_main.cpp
----------------------------------------------------------------------
diff --git a/src/tests/test_helper_main.cpp b/src/tests/test_helper_main.cpp
index 129a5e4..42a8ec6 100644
--- a/src/tests/test_helper_main.cpp
+++ b/src/tests/test_helper_main.cpp
@@ -18,6 +18,7 @@
#include <stout/subcommand.hpp>
#include "tests/active_user_test_helper.hpp"
+#include "tests/health_check_test_helper.hpp"
#include "tests/containerizer/memory_test_helper.hpp"
#ifdef __linux__
@@ -26,6 +27,7 @@
#endif
using mesos::internal::tests::ActiveUserTestHelper;
+using mesos::internal::tests::HealthCheckTestHelper;
using mesos::internal::tests::MemoryTestHelper;
#ifdef __linux__
using mesos::internal::tests::CapabilitiesTestHelper;
@@ -44,5 +46,6 @@ int main(int argc, char** argv)
new SetnsTestHelper(),
#endif
new ActiveUserTestHelper(),
+ new HealthCheckTestHelper(),
new MemoryTestHelper());
}
[5/6] mesos git commit: Renamed `flags` to `agentFlags` in health
check tests.
Posted by al...@apache.org.
Renamed `flags` to `agentFlags` in health check tests.
This patch renames `slave` to `agent` in health check tests as well.
Review: https://reviews.apache.org/r/52561/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/02d09e58
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/02d09e58
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/02d09e58
Branch: refs/heads/master
Commit: 02d09e58d5010c1f0ce97be8d1e3ed5337d964a6
Parents: 189550f
Author: haosdent huang <ha...@gmail.com>
Authored: Thu Oct 27 14:26:59 2016 +0200
Committer: Alexander Rukletsov <al...@apache.org>
Committed: Thu Oct 27 15:18:00 2016 +0200
----------------------------------------------------------------------
src/tests/health_check_tests.cpp | 95 +++++++++++++++++------------------
1 file changed, 47 insertions(+), 48 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/02d09e58/src/tests/health_check_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/health_check_tests.cpp b/src/tests/health_check_tests.cpp
index 790943c..80bd26f 100644
--- a/src/tests/health_check_tests.cpp
+++ b/src/tests/health_check_tests.cpp
@@ -235,8 +235,8 @@ TEST_F(HealthCheckTest, HealthyTask)
ASSERT_SOME(master);
Owned<MasterDetector> detector = master.get()->createDetector();
- Try<Owned<cluster::Slave>> slave = StartSlave(detector.get());
- ASSERT_SOME(slave);
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get());
+ ASSERT_SOME(agent);
MockScheduler sched;
MesosSchedulerDriver driver(
@@ -284,7 +284,6 @@ TEST_F(HealthCheckTest, HealthyTask)
// Send a task status to trigger explicit reconciliation.
const TaskID taskId = statusHealth.get().task_id();
- const SlaveID slaveId = statusHealth.get().slave_id();
status.mutable_task_id()->CopyFrom(taskId);
// State is not checked by reconciliation, but is required to be
@@ -330,10 +329,10 @@ TEST_F(HealthCheckTest, HealthyTask)
EXPECT_SOME_TRUE(find);
}
- // Verify that task health is exposed in the slave's state endpoint.
+ // Verify that task health is exposed in the agent's state endpoint.
{
Future<http::Response> response = http::get(
- slave.get()->pid,
+ agent.get()->pid,
"state",
None(),
createBasicAuthHeaders(DEFAULT_CREDENTIAL));
@@ -367,15 +366,15 @@ TEST_F(HealthCheckTest, ROOT_HealthyTaskWithContainerImage)
ASSERT_TRUE(os::exists(path::join(directory, "alpine.tar")));
- slave::Flags flags = CreateSlaveFlags();
- flags.isolation = "docker/runtime,filesystem/linux";
- flags.image_providers = "docker";
- flags.docker_registry = directory;
- flags.docker_store_dir = path::join(os::getcwd(), "store");
+ slave::Flags agentFlags = CreateSlaveFlags();
+ agentFlags.isolation = "docker/runtime,filesystem/linux";
+ agentFlags.image_providers = "docker";
+ agentFlags.docker_registry = directory;
+ agentFlags.docker_store_dir = path::join(os::getcwd(), "store");
Owned<MasterDetector> detector = master.get()->createDetector();
- Try<Owned<cluster::Slave>> slave = StartSlave(detector.get(), flags);
- ASSERT_SOME(slave);
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get(), agentFlags);
+ ASSERT_SOME(agent);
MockScheduler sched;
MesosSchedulerDriver driver(
@@ -447,10 +446,10 @@ TEST_F(HealthCheckTest, ROOT_HealthyTaskWithContainerImage)
EXPECT_SOME_TRUE(find);
}
- // Verify that task health is exposed in the slave's state endpoint.
+ // Verify that task health is exposed in the agent's state endpoint.
{
Future<http::Response> response = http::get(
- slave.get()->pid,
+ agent.get()->pid,
"state",
None(),
createBasicAuthHeaders(DEFAULT_CREDENTIAL));
@@ -489,25 +488,25 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTask)
Try<Owned<cluster::Master>> master = StartMaster();
ASSERT_SOME(master);
- slave::Flags flags = CreateSlaveFlags();
+ slave::Flags agentFlags = CreateSlaveFlags();
Fetcher fetcher;
Try<ContainerLogger*> logger =
- ContainerLogger::create(flags.container_logger);
+ ContainerLogger::create(agentFlags.container_logger);
ASSERT_SOME(logger);
MockDockerContainerizer containerizer(
- flags,
+ agentFlags,
&fetcher,
Owned<ContainerLogger>(logger.get()),
docker);
Owned<MasterDetector> detector = master.get()->createDetector();
- Try<Owned<cluster::Slave>> slave =
- StartSlave(detector.get(), &containerizer, flags);
- ASSERT_SOME(slave);
+ Try<Owned<cluster::Slave>> agent =
+ StartSlave(detector.get(), &containerizer, agentFlags);
+ ASSERT_SOME(agent);
MockScheduler sched;
MesosSchedulerDriver driver(
@@ -571,8 +570,8 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTask)
AWAIT_READY(termination);
EXPECT_SOME(termination.get());
- slave.get()->terminate();
- slave->reset();
+ agent.get()->terminate();
+ agent->reset();
Future<std::list<Docker::Container>> containers =
docker->ps(true, slave::DOCKER_NAME_PREFIX);
@@ -593,8 +592,8 @@ TEST_F(HealthCheckTest, HealthyTaskNonShell)
ASSERT_SOME(master);
Owned<MasterDetector> detector = master.get()->createDetector();
- Try<Owned<cluster::Slave>> slave = StartSlave(detector.get());
- ASSERT_SOME(slave);
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get());
+ ASSERT_SOME(agent);
MockScheduler sched;
MesosSchedulerDriver driver(
@@ -649,8 +648,8 @@ TEST_F(HealthCheckTest, HealthStatusChange)
ASSERT_SOME(master);
Owned<MasterDetector> detector = master.get()->createDetector();
- Try<Owned<cluster::Slave>> slave = StartSlave(detector.get());
- ASSERT_SOME(slave);
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get());
+ ASSERT_SOME(agent);
MockScheduler sched;
MesosSchedulerDriver driver(
@@ -728,10 +727,10 @@ TEST_F(HealthCheckTest, HealthStatusChange)
EXPECT_SOME_TRUE(find);
}
- // Verify that task health is exposed in the slave's state endpoint.
+ // Verify that task health is exposed in the agent's state endpoint.
{
Future<http::Response> response = http::get(
- slave.get()->pid,
+ agent.get()->pid,
"state",
None(),
createBasicAuthHeaders(DEFAULT_CREDENTIAL));
@@ -769,11 +768,11 @@ TEST_F(HealthCheckTest, HealthStatusChange)
EXPECT_SOME_FALSE(find);
}
- // Verify that the task health change is reflected in the slave's
+ // Verify that the task health change is reflected in the agent's
// state endpoint.
{
Future<http::Response> response = http::get(
- slave.get()->pid,
+ agent.get()->pid,
"state",
None(),
createBasicAuthHeaders(DEFAULT_CREDENTIAL));
@@ -811,11 +810,11 @@ TEST_F(HealthCheckTest, HealthStatusChange)
EXPECT_SOME_TRUE(find);
}
- // Verify through slave's state endpoint that the task is back to a
+ // Verify through agent's state endpoint that the task is back to a
// healthy state.
{
Future<http::Response> response = http::get(
- slave.get()->pid,
+ agent.get()->pid,
"state",
None(),
createBasicAuthHeaders(DEFAULT_CREDENTIAL));
@@ -853,25 +852,25 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthStatusChange)
Try<Owned<cluster::Master>> master = StartMaster();
ASSERT_SOME(master);
- slave::Flags flags = CreateSlaveFlags();
+ slave::Flags agentFlags = CreateSlaveFlags();
Fetcher fetcher;
Try<ContainerLogger*> logger =
- ContainerLogger::create(flags.container_logger);
+ ContainerLogger::create(agentFlags.container_logger);
ASSERT_SOME(logger);
MockDockerContainerizer containerizer(
- flags,
+ agentFlags,
&fetcher,
Owned<ContainerLogger>(logger.get()),
docker);
Owned<MasterDetector> detector = master.get()->createDetector();
- Try<Owned<cluster::Slave>> slave =
- StartSlave(detector.get(), &containerizer, flags);
- ASSERT_SOME(slave);
+ Try<Owned<cluster::Slave>> agent =
+ StartSlave(detector.get(), &containerizer, agentFlags);
+ ASSERT_SOME(agent);
MockScheduler sched;
MesosSchedulerDriver driver(
@@ -966,8 +965,8 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthStatusChange)
AWAIT_READY(termination);
EXPECT_SOME(termination.get());
- slave.get()->terminate();
- slave->reset();
+ agent.get()->terminate();
+ agent->reset();
Future<std::list<Docker::Container>> containers =
docker->ps(true, slave::DOCKER_NAME_PREFIX);
@@ -988,8 +987,8 @@ TEST_F(HealthCheckTest, ConsecutiveFailures)
ASSERT_SOME(master);
Owned<MasterDetector> detector = master.get()->createDetector();
- Try<Owned<cluster::Slave>> slave = StartSlave(detector.get());
- ASSERT_SOME(slave);
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get());
+ ASSERT_SOME(agent);
MockScheduler sched;
MesosSchedulerDriver driver(
@@ -1065,8 +1064,8 @@ TEST_F(HealthCheckTest, EnvironmentSetup)
ASSERT_SOME(master);
Owned<MasterDetector> detector = master.get()->createDetector();
- Try<Owned<cluster::Slave>> slave = StartSlave(detector.get());
- ASSERT_SOME(slave);
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get());
+ ASSERT_SOME(agent);
MockScheduler sched;
MesosSchedulerDriver driver(
@@ -1119,8 +1118,8 @@ TEST_F(HealthCheckTest, GracePeriod)
ASSERT_SOME(master);
Owned<MasterDetector> detector = master.get()->createDetector();
- Try<Owned<cluster::Slave>> slave = StartSlave(detector.get());
- ASSERT_SOME(slave);
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get());
+ ASSERT_SOME(agent);
MockScheduler sched;
MesosSchedulerDriver driver(
@@ -1175,8 +1174,8 @@ TEST_F(HealthCheckTest, CheckCommandTimeout)
ASSERT_SOME(master);
Owned<MasterDetector> detector = master.get()->createDetector();
- Try<Owned<cluster::Slave>> slave = StartSlave(detector.get());
- ASSERT_SOME(slave);
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get());
+ ASSERT_SOME(agent);
MockScheduler sched;
MesosSchedulerDriver driver(
[6/6] mesos git commit: Minor clean ups in `health_check_tests.cpp`
for consistency.
Posted by al...@apache.org.
Minor clean ups in `health_check_tests.cpp` for consistency.
* Replace `Testing` to `Tests` in comments.
* Remove redundant `.Times(1)`.
* Fix typos.
Review: https://reviews.apache.org/r/52563/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/388bc4d0
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/388bc4d0
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/388bc4d0
Branch: refs/heads/master
Commit: 388bc4d08c574b8e1870e3758d6f1135e7f9f66d
Parents: 02d09e5
Author: haosdent huang <ha...@gmail.com>
Authored: Thu Oct 27 14:27:46 2016 +0200
Committer: Alexander Rukletsov <al...@apache.org>
Committed: Thu Oct 27 15:48:46 2016 +0200
----------------------------------------------------------------------
src/tests/health_check_tests.cpp | 146 +++++++++++++++++-----------------
1 file changed, 73 insertions(+), 73 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/388bc4d0/src/tests/health_check_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/health_check_tests.cpp b/src/tests/health_check_tests.cpp
index 80bd26f..b1a8942 100644
--- a/src/tests/health_check_tests.cpp
+++ b/src/tests/health_check_tests.cpp
@@ -228,7 +228,10 @@ TEST_F(HealthCheckTest, HealthCheckProtobufValidation)
}
-// Testing a healthy task reporting one healthy status to scheduler.
+// This test creates a healthy task and verifies that the healthy
+// status is reflected in the status updates sent as reconciliation
+// answers, and in the state endpoint of both the master and the
+// agent.
TEST_F(HealthCheckTest, HealthyTask)
{
Try<Owned<cluster::Master>> master = StartMaster();
@@ -242,8 +245,7 @@ TEST_F(HealthCheckTest, HealthyTask)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);
- EXPECT_CALL(sched, registered(&driver, _, _))
- .Times(1);
+ EXPECT_CALL(sched, registered(&driver, _, _));
Future<vector<Offer>> offers;
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -259,21 +261,21 @@ TEST_F(HealthCheckTest, HealthyTask)
populateTasks("sleep 120", "exit 0", offers.get()[0]);
Future<TaskStatus> statusRunning;
- Future<TaskStatus> statusHealth;
+ Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(FutureArg<1>(&statusRunning))
- .WillOnce(FutureArg<1>(&statusHealth));
+ .WillOnce(FutureArg<1>(&statusHealthy));
driver.launchTasks(offers.get()[0].id(), tasks);
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
- AWAIT_READY(statusHealth);
- EXPECT_EQ(TASK_RUNNING, statusHealth.get().state());
- EXPECT_TRUE(statusHealth.get().has_healthy());
- EXPECT_TRUE(statusHealth.get().healthy());
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().has_healthy());
+ EXPECT_TRUE(statusHealthy.get().healthy());
Future<TaskStatus> explicitReconciliation;
EXPECT_CALL(sched, statusUpdate(&driver, _))
@@ -283,7 +285,7 @@ TEST_F(HealthCheckTest, HealthyTask)
TaskStatus status;
// Send a task status to trigger explicit reconciliation.
- const TaskID taskId = statusHealth.get().task_id();
+ const TaskID taskId = statusHealthy.get().task_id();
status.mutable_task_id()->CopyFrom(taskId);
// State is not checked by reconciliation, but is required to be
@@ -352,8 +354,10 @@ TEST_F(HealthCheckTest, HealthyTask)
}
-// Testing a healthy task with a container image using mesos
-// containerizer reporting one healthy status to scheduler.
+// This test creates a healthy task with a container image using mesos
+// containerizer and verifies that the healthy status is reported to the
+// scheduler and is reflected in the state endpoints of both the master
+// and the agent.
TEST_F(HealthCheckTest, ROOT_HealthyTaskWithContainerImage)
{
Try<Owned<cluster::Master>> master = StartMaster();
@@ -380,8 +384,7 @@ TEST_F(HealthCheckTest, ROOT_HealthyTaskWithContainerImage)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);
- EXPECT_CALL(sched, registered(&driver, _, _))
- .Times(1);
+ EXPECT_CALL(sched, registered(&driver, _, _));
Future<vector<Offer>> offers;
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -412,21 +415,21 @@ TEST_F(HealthCheckTest, ROOT_HealthyTaskWithContainerImage)
health->mutable_command()->set_value("exit 0");
Future<TaskStatus> statusRunning;
- Future<TaskStatus> statusHealth;
+ Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(FutureArg<1>(&statusRunning))
- .WillOnce(FutureArg<1>(&statusHealth));
+ .WillOnce(FutureArg<1>(&statusHealthy));
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
- AWAIT_READY(statusHealth);
- EXPECT_EQ(TASK_RUNNING, statusHealth.get().state());
- EXPECT_TRUE(statusHealth.get().has_healthy());
- EXPECT_TRUE(statusHealth.get().healthy());
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().has_healthy());
+ EXPECT_TRUE(statusHealthy.get().healthy());
// Verify that task health is exposed in the master's state endpoint.
{
@@ -469,8 +472,8 @@ TEST_F(HealthCheckTest, ROOT_HealthyTaskWithContainerImage)
}
-// Testing a healthy task reporting one healthy status to scheduler for
-// docker executor.
+// This test creates a healthy task using the Docker executor and
+// verifies that the healthy status is reported to the scheduler.
TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTask)
{
Shared<Docker> docker(new MockDocker(
@@ -512,8 +515,7 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTask)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);
- EXPECT_CALL(sched, registered(&driver, _, _))
- .Times(1);
+ EXPECT_CALL(sched, registered(&driver, _, _));
Future<vector<Offer>> offers;
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -543,11 +545,11 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTask)
&MockDockerContainerizer::_launch)));
Future<TaskStatus> statusRunning;
- Future<TaskStatus> statusHealth;
+ Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(FutureArg<1>(&statusRunning))
- .WillOnce(FutureArg<1>(&statusHealth));
+ .WillOnce(FutureArg<1>(&statusHealthy));
driver.launchTasks(offers.get()[0].id(), tasks);
@@ -556,10 +558,10 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTask)
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
- AWAIT_READY(statusHealth);
- EXPECT_EQ(TASK_RUNNING, statusHealth.get().state());
- EXPECT_TRUE(statusHealth.get().has_healthy());
- EXPECT_TRUE(statusHealth.get().healthy());
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().has_healthy());
+ EXPECT_TRUE(statusHealthy.get().healthy());
Future<Option<ContainerTermination>> termination =
containerizer.wait(containerId.get());
@@ -599,8 +601,7 @@ TEST_F(HealthCheckTest, HealthyTaskNonShell)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);
- EXPECT_CALL(sched, registered(&driver, _, _))
- .Times(1);
+ EXPECT_CALL(sched, registered(&driver, _, _));
Future<vector<Offer>> offers;
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -621,27 +622,29 @@ TEST_F(HealthCheckTest, HealthyTaskNonShell)
populateTasks("sleep 120", command, offers.get()[0]);
Future<TaskStatus> statusRunning;
- Future<TaskStatus> statusHealth;
+ Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(FutureArg<1>(&statusRunning))
- .WillOnce(FutureArg<1>(&statusHealth));
+ .WillOnce(FutureArg<1>(&statusHealthy));
driver.launchTasks(offers.get()[0].id(), tasks);
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
- AWAIT_READY(statusHealth);
- EXPECT_EQ(TASK_RUNNING, statusHealth.get().state());
- EXPECT_TRUE(statusHealth.get().healthy());
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().healthy());
driver.stop();
driver.join();
}
-// Testing health status change reporting to scheduler.
+// This test creates a task whose health flaps, and verifies that the
+// health status updates are sent to the framework and reflected in the
+// state endpoint of both the master and the agent.
TEST_F(HealthCheckTest, HealthStatusChange)
{
Try<Owned<cluster::Master>> master = StartMaster();
@@ -834,7 +837,9 @@ TEST_F(HealthCheckTest, HealthStatusChange)
}
-// Testing health status change reporting to scheduler for docker executor.
+// This test creates a task that uses the Docker executor and whose
+// health flaps. It then verifies that the health status updates are
+// sent to the scheduler.
TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthStatusChange)
{
Shared<Docker> docker(new MockDocker(
@@ -980,7 +985,8 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthStatusChange)
}
-// Testing killing task after number of consecutive failures.
+// This test ensures that a task is killed if the number of maximum
+// health check failures is reached.
TEST_F(HealthCheckTest, ConsecutiveFailures)
{
Try<Owned<cluster::Master>> master = StartMaster();
@@ -994,8 +1000,7 @@ TEST_F(HealthCheckTest, ConsecutiveFailures)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);
- EXPECT_CALL(sched, registered(&driver, _, _))
- .Times(1);
+ EXPECT_CALL(sched, registered(&driver, _, _));
Future<vector<Offer>> offers;
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -1057,7 +1062,8 @@ TEST_F(HealthCheckTest, ConsecutiveFailures)
}
-// Testing command using environment variable.
+// Tests that the task's env variables are copied to the env used to
+// execute COMMAND health checks.
TEST_F(HealthCheckTest, EnvironmentSetup)
{
Try<Owned<cluster::Master>> master = StartMaster();
@@ -1071,8 +1077,7 @@ TEST_F(HealthCheckTest, EnvironmentSetup)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);
- EXPECT_CALL(sched, registered(&driver, _, _))
- .Times(1);
+ EXPECT_CALL(sched, registered(&driver, _, _));
Future<vector<Offer>> offers;
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -1091,20 +1096,20 @@ TEST_F(HealthCheckTest, EnvironmentSetup)
"sleep 120", "exit $STATUS", offers.get()[0], 0, None(), env);
Future<TaskStatus> statusRunning;
- Future<TaskStatus> statusHealth;
+ Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(FutureArg<1>(&statusRunning))
- .WillOnce(FutureArg<1>(&statusHealth));
+ .WillOnce(FutureArg<1>(&statusHealthy));
driver.launchTasks(offers.get()[0].id(), tasks);
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
- AWAIT_READY(statusHealth);
- EXPECT_EQ(TASK_RUNNING, statusHealth.get().state());
- EXPECT_TRUE(statusHealth.get().healthy());
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().healthy());
driver.stop();
driver.join();
@@ -1125,8 +1130,7 @@ TEST_F(HealthCheckTest, GracePeriod)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);
- EXPECT_CALL(sched, registered(&driver, _, _))
- .Times(1);
+ EXPECT_CALL(sched, registered(&driver, _, _));
Future<vector<Offer>> offers;
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -1167,7 +1171,8 @@ TEST_F(HealthCheckTest, GracePeriod)
}
-// Testing continue running health check when check command timeout.
+// This test creates a task with a health check command that will time
+// out, and verifies that the health check is retried after the timeout.
TEST_F(HealthCheckTest, CheckCommandTimeout)
{
Try<Owned<cluster::Master>> master = StartMaster();
@@ -1181,8 +1186,7 @@ TEST_F(HealthCheckTest, CheckCommandTimeout)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);
- EXPECT_CALL(sched, registered(&driver, _, _))
- .Times(1);
+ EXPECT_CALL(sched, registered(&driver, _, _));
Future<vector<Offer>> offers;
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -1226,7 +1230,7 @@ TEST_F(HealthCheckTest, CheckCommandTimeout)
}
-// Testing a healthy task via HTTP without specifying `type`. HTTP health
+// Tests a healthy task via HTTP without specifying `type`. HTTP health
// checks without `type` are allowed for backwards compatibility with the
// v0 and v1 API.
//
@@ -1240,9 +1244,6 @@ TEST_F(HealthCheckTest, DISABLED_HealthyTaskViaHTTPWithoutType)
Try<Owned<cluster::Master>> master = StartMaster(masterFlags);
ASSERT_SOME(master);
- slave::Flags flags = CreateSlaveFlags();
- flags.isolation = "posix/cpu,posix/mem";
-
Owned<MasterDetector> detector = master.get()->createDetector();
Try<Owned<cluster::Slave>> agent = StartSlave(detector.get());
ASSERT_SOME(agent);
@@ -1251,8 +1252,7 @@ TEST_F(HealthCheckTest, DISABLED_HealthyTaskViaHTTPWithoutType)
MesosSchedulerDriver driver(
&sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);
- EXPECT_CALL(sched, registered(&driver, _, _))
- .Times(1);
+ EXPECT_CALL(sched, registered(&driver, _, _));
Future<vector<Offer>> offers;
EXPECT_CALL(sched, resourceOffers(&driver, _))
@@ -1278,21 +1278,21 @@ TEST_F(HealthCheckTest, DISABLED_HealthyTaskViaHTTPWithoutType)
task.mutable_health_check()->CopyFrom(healthCheck);
Future<TaskStatus> statusRunning;
- Future<TaskStatus> statusHealth;
+ Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(FutureArg<1>(&statusRunning))
- .WillOnce(FutureArg<1>(&statusHealth));
+ .WillOnce(FutureArg<1>(&statusHealthy));
driver.launchTasks(offers.get()[0].id(), {task});
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
- AWAIT_READY(statusHealth);
- EXPECT_EQ(TASK_RUNNING, statusHealth.get().state());
- EXPECT_TRUE(statusHealth.get().has_healthy());
- EXPECT_TRUE(statusHealth.get().healthy());
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().has_healthy());
+ EXPECT_TRUE(statusHealthy.get().healthy());
driver.stop();
driver.join();
@@ -1918,11 +1918,11 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTaskViaTCP)
&MockDockerContainerizer::_launch)));
Future<TaskStatus> statusRunning;
- Future<TaskStatus> statusHealth;
+ Future<TaskStatus> statusHealthy;
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(FutureArg<1>(&statusRunning))
- .WillOnce(FutureArg<1>(&statusHealth))
+ .WillOnce(FutureArg<1>(&statusHealthy))
.WillRepeatedly(Return()); // Ignore subsequent updates.
driver.launchTasks(offers.get()[0].id(), {task});
@@ -1932,10 +1932,10 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTaskViaTCP)
AWAIT_READY(statusRunning);
EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
- AWAIT_READY(statusHealth);
- EXPECT_EQ(TASK_RUNNING, statusHealth.get().state());
- EXPECT_TRUE(statusHealth.get().has_healthy());
- EXPECT_TRUE(statusHealth.get().healthy());
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().has_healthy());
+ EXPECT_TRUE(statusHealthy.get().healthy());
Future<Option<ContainerTermination>> termination =
containerizer.wait(containerId.get());
[4/6] mesos git commit: Avoided temporary `MockDocker` pointers in
health check tests.
Posted by al...@apache.org.
Avoided temporary `MockDocker` pointers in health check tests.
Review: https://reviews.apache.org/r/52560/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/189550fc
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/189550fc
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/189550fc
Branch: refs/heads/master
Commit: 189550fca3806ca4e768f7f83c298270b783f52a
Parents: 2fa0c4a
Author: haosdent huang <ha...@gmail.com>
Authored: Thu Oct 27 14:26:42 2016 +0200
Committer: Alexander Rukletsov <al...@apache.org>
Committed: Thu Oct 27 15:18:00 2016 +0200
----------------------------------------------------------------------
src/tests/health_check_tests.cpp | 12 ++++--------
1 file changed, 4 insertions(+), 8 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/189550fc/src/tests/health_check_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/health_check_tests.cpp b/src/tests/health_check_tests.cpp
index 1bd9650..790943c 100644
--- a/src/tests/health_check_tests.cpp
+++ b/src/tests/health_check_tests.cpp
@@ -474,10 +474,8 @@ TEST_F(HealthCheckTest, ROOT_HealthyTaskWithContainerImage)
// docker executor.
TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTask)
{
- MockDocker* mockDocker =
- new MockDocker(tests::flags.docker, tests::flags.docker_socket);
-
- Shared<Docker> docker(mockDocker);
+ Shared<Docker> docker(new MockDocker(
+ tests::flags.docker, tests::flags.docker_socket));
Try<Nothing> validateResult = docker->validateVersion(Version(1, 3, 0));
ASSERT_SOME(validateResult)
@@ -840,10 +838,8 @@ TEST_F(HealthCheckTest, HealthStatusChange)
// Testing health status change reporting to scheduler for docker executor.
TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthStatusChange)
{
- MockDocker* mockDocker =
- new MockDocker(tests::flags.docker, tests::flags.docker_socket);
-
- Shared<Docker> docker(mockDocker);
+ Shared<Docker> docker(new MockDocker(
+ tests::flags.docker, tests::flags.docker_socket));
Try<Nothing> validateResult = docker->validateVersion(Version(1, 3, 0));
ASSERT_SOME(validateResult)
[3/6] mesos git commit: Added test cases for TCP health check.
Posted by al...@apache.org.
Added test cases for TCP health check.
Review: https://reviews.apache.org/r/52251/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/2fa0c4aa
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/2fa0c4aa
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/2fa0c4aa
Branch: refs/heads/master
Commit: 2fa0c4aa8bf1d6309fbcdf5297e0d8b31cea2b84
Parents: a0a7755
Author: haosdent huang <ha...@gmail.com>
Authored: Thu Oct 27 14:26:34 2016 +0200
Committer: Alexander Rukletsov <al...@apache.org>
Committed: Thu Oct 27 15:17:59 2016 +0200
----------------------------------------------------------------------
src/tests/health_check_tests.cpp | 295 ++++++++++++++++++++++++++++++++++
1 file changed, 295 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/2fa0c4aa/src/tests/health_check_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/health_check_tests.cpp b/src/tests/health_check_tests.cpp
index 67b50ab..1bd9650 100644
--- a/src/tests/health_check_tests.cpp
+++ b/src/tests/health_check_tests.cpp
@@ -1460,6 +1460,83 @@ TEST_F(HealthCheckTest, HealthyTaskViaHTTP)
}
+// Tests a healthy non-contained task via TCP.
+//
+// NOTE: This test is almost identical to HealthyTaskViaHTTP
+// with the difference being TCP health check.
+TEST_F(HealthCheckTest, HealthyTaskViaTCP)
+{
+ master::Flags masterFlags = CreateMasterFlags();
+ masterFlags.allocation_interval = Milliseconds(50);
+ Try<Owned<cluster::Master>> master = StartMaster(masterFlags);
+ ASSERT_SOME(master);
+
+ Owned<MasterDetector> detector = master.get()->createDetector();
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get());
+ ASSERT_SOME(agent);
+
+ 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);
+ EXPECT_NE(0u, offers.get().size());
+
+ const uint16_t testPort = 31001;
+
+ // Use `test-helper` to launch a simple HTTP
+ // server to respond to TCP health checks.
+ const string command = strings::format(
+ "%s %s --ip=127.0.0.1 --port=%u",
+ getTestHelperPath("test-helper"),
+ HealthCheckTestHelper::NAME,
+ testPort).get();
+
+ TaskInfo task = createTask(offers.get()[0], command);
+
+ // Set `grace_period_seconds` here because it takes some time to
+ // launch the HTTP server to serve requests.
+ HealthCheck healthCheck;
+ healthCheck.set_type(HealthCheck::TCP);
+ healthCheck.mutable_tcp()->set_port(testPort);
+ healthCheck.set_delay_seconds(0);
+ healthCheck.set_interval_seconds(0);
+ healthCheck.set_grace_period_seconds(15);
+
+ task.mutable_health_check()->CopyFrom(healthCheck);
+
+ Future<TaskStatus> statusRunning;
+ Future<TaskStatus> statusHealthy;
+
+ EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusRunning))
+ .WillOnce(FutureArg<1>(&statusHealthy))
+ .WillRepeatedly(Return()); // Ignore subsequent updates.
+
+ driver.launchTasks(offers.get()[0].id(), {task});
+
+ AWAIT_READY(statusRunning);
+ EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
+
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().has_healthy());
+ EXPECT_TRUE(statusHealthy.get().healthy());
+
+ driver.stop();
+ driver.join();
+}
+
+
// Tests a healthy task via HTTP with a container image using mesos
// containerizer. To emulate a task responsive to HTTP health checks,
// starts Netcat in the docker "alpine" image.
@@ -1545,6 +1622,95 @@ TEST_F(HealthCheckTest, ROOT_INTERNET_CURL_HealthyTaskViaHTTPWithContainerImage)
}
+// Tests a healthy task via TCP with a container image using mesos
+// containerizer. To emulate a task responsive to TCP health checks,
+// starts Netcat in the docker "alpine" image.
+//
+// NOTE: This test is almost identical to
+// ROOT_INTERNET_CURL_HealthyTaskViaHTTPWithContainerImage
+// with the difference being TCP health check.
+TEST_F(HealthCheckTest, ROOT_INTERNET_CURL_HealthyTaskViaTCPWithContainerImage)
+{
+ master::Flags masterFlags = CreateMasterFlags();
+ masterFlags.allocation_interval = Milliseconds(50);
+ Try<Owned<cluster::Master>> master = StartMaster(masterFlags);
+ ASSERT_SOME(master);
+
+ slave::Flags agentFlags = CreateSlaveFlags();
+ agentFlags.isolation = "docker/runtime,filesystem/linux";
+ agentFlags.image_providers = "docker";
+
+ Owned<MasterDetector> detector = master.get()->createDetector();
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get(), agentFlags);
+ ASSERT_SOME(agent);
+
+ 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);
+ EXPECT_NE(0u, offers.get().size());
+
+ const uint16_t testPort = 31001;
+
+ // Use Netcat to launch a HTTP server.
+ const string command = strings::format(
+ "nc -lk -p %u -e echo -e \"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\"",
+ testPort).get();
+
+ TaskInfo task = createTask(offers.get()[0], command);
+
+ Image image;
+ image.set_type(Image::DOCKER);
+ image.mutable_docker()->set_name("alpine");
+
+ ContainerInfo* container = task.mutable_container();
+ container->set_type(ContainerInfo::MESOS);
+ container->mutable_mesos()->mutable_image()->CopyFrom(image);
+
+ // Set `grace_period_seconds` here because it takes some time to
+ // launch Netcat to serve requests.
+ HealthCheck healthCheck;
+ healthCheck.set_type(HealthCheck::TCP);
+ healthCheck.mutable_tcp()->set_port(testPort);
+ healthCheck.set_delay_seconds(0);
+ healthCheck.set_interval_seconds(0);
+ healthCheck.set_grace_period_seconds(15);
+
+ task.mutable_health_check()->CopyFrom(healthCheck);
+
+ Future<TaskStatus> statusRunning;
+ Future<TaskStatus> statusHealthy;
+
+ EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusRunning))
+ .WillOnce(FutureArg<1>(&statusHealthy))
+ .WillRepeatedly(Return()); // Ignore subsequent updates.
+
+ driver.launchTasks(offers.get()[0].id(), {task});
+
+ AWAIT_READY(statusRunning);
+ EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
+
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().has_healthy());
+ EXPECT_TRUE(statusHealthy.get().healthy());
+
+ driver.stop();
+ driver.join();
+}
+
+
// Tests a healthy docker task via HTTP. To emulate a task responsive
// to HTTP health checks, starts Netcat in the docker "alpine" image.
TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTaskViaHTTP)
@@ -1670,6 +1836,135 @@ TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTaskViaHTTP)
}
}
+
+// Tests a healthy docker task via TCP. To emulate a task responsive
+// to TCP health checks, starts Netcat in the docker "alpine" image.
+//
+// NOTE: This test is almost identical to ROOT_DOCKER_DockerHealthyTaskViaHTTP
+// with the difference being TCP health check.
+TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTaskViaTCP)
+{
+ Shared<Docker> docker(new MockDocker(
+ tests::flags.docker, tests::flags.docker_socket));
+
+ Try<Owned<cluster::Master>> master = StartMaster();
+ ASSERT_SOME(master);
+
+ slave::Flags agentFlags = CreateSlaveFlags();
+
+ Fetcher fetcher;
+
+ Try<ContainerLogger*> logger =
+ ContainerLogger::create(agentFlags.container_logger);
+ ASSERT_SOME(logger);
+
+ MockDockerContainerizer containerizer(
+ agentFlags,
+ &fetcher,
+ Owned<ContainerLogger>(logger.get()),
+ docker);
+
+ Owned<MasterDetector> detector = master.get()->createDetector();
+ Try<Owned<cluster::Slave>> agent =
+ StartSlave(detector.get(), &containerizer, agentFlags);
+ ASSERT_SOME(agent);
+
+ 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);
+ EXPECT_NE(0u, offers.get().size());
+
+ const uint16_t testPort = 31001;
+
+ // Use Netcat to launch a HTTP server.
+ const string command = strings::format(
+ "nc -lk -p %u -e echo -e \"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\"",
+ testPort).get();
+
+ TaskInfo task = createTask(offers.get()[0], command);
+
+ // The docker container runs in bridge network mode.
+ //
+ // TODO(tnachen): Use local image to test if possible.
+ ContainerInfo containerInfo;
+ containerInfo.set_type(ContainerInfo::DOCKER);
+ containerInfo.mutable_docker()->set_image("alpine");
+ containerInfo.mutable_docker()->set_network(
+ ContainerInfo::DockerInfo::BRIDGE);
+
+ task.mutable_container()->CopyFrom(containerInfo);
+
+ // Set `grace_period_seconds` here because it takes some time to
+ // launch Netcat to serve requests.
+ HealthCheck healthCheck;
+ healthCheck.set_type(HealthCheck::TCP);
+ healthCheck.mutable_tcp()->set_port(testPort);
+ healthCheck.set_delay_seconds(0);
+ healthCheck.set_interval_seconds(0);
+ healthCheck.set_grace_period_seconds(15);
+
+ task.mutable_health_check()->CopyFrom(healthCheck);
+
+ Future<ContainerID> containerId;
+ EXPECT_CALL(containerizer, launch(_, _, _, _, _, _, _, _))
+ .WillOnce(DoAll(FutureArg<0>(&containerId),
+ Invoke(&containerizer,
+ &MockDockerContainerizer::_launch)));
+
+ Future<TaskStatus> statusRunning;
+ Future<TaskStatus> statusHealth;
+
+ EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusRunning))
+ .WillOnce(FutureArg<1>(&statusHealth))
+ .WillRepeatedly(Return()); // Ignore subsequent updates.
+
+ driver.launchTasks(offers.get()[0].id(), {task});
+
+ AWAIT_READY(containerId);
+
+ AWAIT_READY(statusRunning);
+ EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
+
+ AWAIT_READY(statusHealth);
+ EXPECT_EQ(TASK_RUNNING, statusHealth.get().state());
+ EXPECT_TRUE(statusHealth.get().has_healthy());
+ EXPECT_TRUE(statusHealth.get().healthy());
+
+ Future<Option<ContainerTermination>> termination =
+ containerizer.wait(containerId.get());
+
+ driver.stop();
+ driver.join();
+
+ AWAIT_READY(termination);
+ EXPECT_SOME(termination.get());
+
+ agent.get()->terminate();
+ agent->reset();
+
+ Future<std::list<Docker::Container>> containers =
+ docker->ps(true, slave::DOCKER_NAME_PREFIX);
+
+ AWAIT_READY(containers);
+
+ // Clean up all mesos launched docker containers.
+ foreach (const Docker::Container& container, containers.get()) {
+ AWAIT_READY_FOR(docker->rm(container.id, true), Seconds(30));
+ }
+}
+
} // namespace tests {
} // namespace internal {
} // namespace mesos {
[2/6] mesos git commit: Added test cases for HTTP health check.
Posted by al...@apache.org.
Added test cases for HTTP health check.
Review: https://reviews.apache.org/r/52250/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/a0a7755a
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/a0a7755a
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/a0a7755a
Branch: refs/heads/master
Commit: a0a7755a6dee9aadab2bf9a64ba39270238e39b8
Parents: eeb97df
Author: haosdent huang <ha...@gmail.com>
Authored: Thu Oct 27 14:26:25 2016 +0200
Committer: Alexander Rukletsov <al...@apache.org>
Committed: Thu Oct 27 15:16:31 2016 +0200
----------------------------------------------------------------------
src/tests/health_check_tests.cpp | 287 ++++++++++++++++++++++++++++++++++
1 file changed, 287 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/a0a7755a/src/tests/health_check_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/health_check_tests.cpp b/src/tests/health_check_tests.cpp
index 1d1676d..67b50ab 100644
--- a/src/tests/health_check_tests.cpp
+++ b/src/tests/health_check_tests.cpp
@@ -32,6 +32,7 @@
#include "tests/containerizer.hpp"
#include "tests/flags.hpp"
+#include "tests/health_check_test_helper.hpp"
#include "tests/mesos.hpp"
#include "tests/mock_docker.hpp"
#include "tests/utils.hpp"
@@ -1383,6 +1384,292 @@ TEST_F(HealthCheckTest, HealthyToUnhealthyTransitionWithinGracePeriod)
driver.join();
}
+
+// Tests a healthy non-contained task via HTTP.
+TEST_F(HealthCheckTest, HealthyTaskViaHTTP)
+{
+ master::Flags masterFlags = CreateMasterFlags();
+ masterFlags.allocation_interval = Milliseconds(50);
+ Try<Owned<cluster::Master>> master = StartMaster(masterFlags);
+ ASSERT_SOME(master);
+
+ Owned<MasterDetector> detector = master.get()->createDetector();
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get());
+ ASSERT_SOME(agent);
+
+ 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);
+ EXPECT_NE(0u, offers.get().size());
+
+ const uint16_t testPort = 31001;
+
+ // Use `test-helper` to launch a simple HTTP
+ // server to respond to HTTP health checks.
+ const string command = strings::format(
+ "%s %s --ip=127.0.0.1 --port=%u",
+ getTestHelperPath("test-helper"),
+ HealthCheckTestHelper::NAME,
+ testPort).get();
+
+ TaskInfo task = createTask(offers.get()[0], command);
+
+ // Set `grace_period_seconds` here because it takes some time to
+ // launch the HTTP server to serve requests.
+ HealthCheck healthCheck;
+ healthCheck.set_type(HealthCheck::HTTP);
+ healthCheck.mutable_http()->set_port(testPort);
+ healthCheck.mutable_http()->set_path("/help");
+ healthCheck.set_delay_seconds(0);
+ healthCheck.set_interval_seconds(0);
+ healthCheck.set_grace_period_seconds(15);
+
+ task.mutable_health_check()->CopyFrom(healthCheck);
+
+ Future<TaskStatus> statusRunning;
+ Future<TaskStatus> statusHealthy;
+
+ EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusRunning))
+ .WillOnce(FutureArg<1>(&statusHealthy))
+ .WillRepeatedly(Return()); // Ignore subsequent updates.
+
+ driver.launchTasks(offers.get()[0].id(), {task});
+
+ AWAIT_READY(statusRunning);
+ EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
+
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().has_healthy());
+ EXPECT_TRUE(statusHealthy.get().healthy());
+
+ driver.stop();
+ driver.join();
+}
+
+
+// Tests a healthy task via HTTP with a container image using mesos
+// containerizer. To emulate a task responsive to HTTP health checks,
+// starts Netcat in the docker "alpine" image.
+TEST_F(HealthCheckTest, ROOT_INTERNET_CURL_HealthyTaskViaHTTPWithContainerImage)
+{
+ master::Flags masterFlags = CreateMasterFlags();
+ masterFlags.allocation_interval = Milliseconds(50);
+ Try<Owned<cluster::Master>> master = StartMaster(masterFlags);
+ ASSERT_SOME(master);
+
+ slave::Flags agentFlags = CreateSlaveFlags();
+ agentFlags.isolation = "docker/runtime,filesystem/linux";
+ agentFlags.image_providers = "docker";
+
+ Owned<MasterDetector> detector = master.get()->createDetector();
+ Try<Owned<cluster::Slave>> agent = StartSlave(detector.get(), agentFlags);
+ ASSERT_SOME(agent);
+
+ 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);
+ EXPECT_NE(0u, offers.get().size());
+
+ const uint16_t testPort = 31001;
+
+ // Use Netcat to launch a HTTP server.
+ const string command = strings::format(
+ "nc -lk -p %u -e echo -e \"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\"",
+ testPort).get();
+
+ TaskInfo task = createTask(offers.get()[0], command);
+
+ Image image;
+ image.set_type(Image::DOCKER);
+ image.mutable_docker()->set_name("alpine");
+
+ ContainerInfo* container = task.mutable_container();
+ container->set_type(ContainerInfo::MESOS);
+ container->mutable_mesos()->mutable_image()->CopyFrom(image);
+
+ // Set `grace_period_seconds` here because it takes some time to
+ // launch Netcat to serve requests.
+ HealthCheck healthCheck;
+ healthCheck.set_type(HealthCheck::HTTP);
+ healthCheck.mutable_http()->set_port(testPort);
+ healthCheck.set_delay_seconds(0);
+ healthCheck.set_interval_seconds(0);
+ healthCheck.set_grace_period_seconds(15);
+
+ task.mutable_health_check()->CopyFrom(healthCheck);
+
+ Future<TaskStatus> statusRunning;
+ Future<TaskStatus> statusHealthy;
+
+ EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusRunning))
+ .WillOnce(FutureArg<1>(&statusHealthy))
+ .WillRepeatedly(Return()); // Ignore subsequent updates.
+
+ driver.launchTasks(offers.get()[0].id(), {task});
+
+ AWAIT_READY(statusRunning);
+ EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
+
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().has_healthy());
+ EXPECT_TRUE(statusHealthy.get().healthy());
+
+ driver.stop();
+ driver.join();
+}
+
+
+// Tests a healthy docker task via HTTP. To emulate a task responsive
+// to HTTP health checks, starts Netcat in the docker "alpine" image.
+TEST_F(HealthCheckTest, ROOT_DOCKER_DockerHealthyTaskViaHTTP)
+{
+ Shared<Docker> docker(new MockDocker(
+ tests::flags.docker, tests::flags.docker_socket));
+
+ Try<Owned<cluster::Master>> master = StartMaster();
+ ASSERT_SOME(master);
+
+ slave::Flags agentFlags = CreateSlaveFlags();
+
+ Fetcher fetcher;
+
+ Try<ContainerLogger*> logger =
+ ContainerLogger::create(agentFlags.container_logger);
+ ASSERT_SOME(logger);
+
+ MockDockerContainerizer containerizer(
+ agentFlags,
+ &fetcher,
+ Owned<ContainerLogger>(logger.get()),
+ docker);
+
+ Owned<MasterDetector> detector = master.get()->createDetector();
+ Try<Owned<cluster::Slave>> agent =
+ StartSlave(detector.get(), &containerizer, agentFlags);
+ ASSERT_SOME(agent);
+
+ 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);
+ EXPECT_NE(0u, offers.get().size());
+
+ const uint16_t testPort = 31001;
+
+ // Use Netcat to launch a HTTP server.
+ const string command = strings::format(
+ "nc -lk -p %u -e echo -e \"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\"",
+ testPort).get();
+
+ TaskInfo task = createTask(offers.get()[0], command);
+
+ // The docker container runs in bridge network mode.
+ //
+ // TODO(tnachen): Use local image to test if possible.
+ ContainerInfo containerInfo;
+ containerInfo.set_type(ContainerInfo::DOCKER);
+ containerInfo.mutable_docker()->set_image("alpine");
+ containerInfo.mutable_docker()->set_network(
+ ContainerInfo::DockerInfo::BRIDGE);
+
+ task.mutable_container()->CopyFrom(containerInfo);
+
+ // Set `grace_period_seconds` here because it takes some time to
+ // launch Netcat to serve requests.
+ HealthCheck healthCheck;
+ healthCheck.set_type(HealthCheck::HTTP);
+ healthCheck.mutable_http()->set_port(testPort);
+ healthCheck.set_delay_seconds(0);
+ healthCheck.set_interval_seconds(0);
+ healthCheck.set_grace_period_seconds(15);
+
+ task.mutable_health_check()->CopyFrom(healthCheck);
+
+ Future<ContainerID> containerId;
+ EXPECT_CALL(containerizer, launch(_, _, _, _, _, _, _, _))
+ .WillOnce(DoAll(FutureArg<0>(&containerId),
+ Invoke(&containerizer,
+ &MockDockerContainerizer::_launch)));
+
+ Future<TaskStatus> statusRunning;
+ Future<TaskStatus> statusHealthy;
+
+ EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(FutureArg<1>(&statusRunning))
+ .WillOnce(FutureArg<1>(&statusHealthy))
+ .WillRepeatedly(Return()); // Ignore subsequent updates.
+
+ driver.launchTasks(offers.get()[0].id(), {task});
+
+ AWAIT_READY(containerId);
+
+ AWAIT_READY(statusRunning);
+ EXPECT_EQ(TASK_RUNNING, statusRunning.get().state());
+
+ AWAIT_READY(statusHealthy);
+ EXPECT_EQ(TASK_RUNNING, statusHealthy.get().state());
+ EXPECT_TRUE(statusHealthy.get().has_healthy());
+ EXPECT_TRUE(statusHealthy.get().healthy());
+
+ Future<Option<ContainerTermination>> termination =
+ containerizer.wait(containerId.get());
+
+ driver.stop();
+ driver.join();
+
+ AWAIT_READY(termination);
+ EXPECT_SOME(termination.get());
+
+ agent.get()->terminate();
+ agent->reset();
+
+ Future<std::list<Docker::Container>> containers =
+ docker->ps(true, slave::DOCKER_NAME_PREFIX);
+
+ AWAIT_READY(containers);
+
+ // Clean up all mesos launched docker containers.
+ foreach (const Docker::Container& container, containers.get()) {
+ AWAIT_READY_FOR(docker->rm(container.id, true), Seconds(30));
+ }
+}
+
} // namespace tests {
} // namespace internal {
} // namespace mesos {