You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mesos.apache.org by vi...@apache.org on 2016/02/09 20:18:09 UTC
[1/4] mesos git commit: Introduced an callback interface for testing
HTTP based executors.
Repository: mesos
Updated Branches:
refs/heads/master 6b0a304b5 -> 1c1ee8be2
Introduced an callback interface for testing HTTP based executors.
This change introduces a versioned callback interface for testing HTTP based
executors. The reasoning is similar to `MESOS-3339` , the corresponding issue
for schedulers.
Review: https://reviews.apache.org/r/41288/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/49c8895b
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/49c8895b
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/49c8895b
Branch: refs/heads/master
Commit: 49c8895bd1302a2b98c4a80e6d2050a41715ab20
Parents: 6b0a304
Author: Anand Mazumdar <ma...@gmail.com>
Authored: Tue Feb 9 11:16:58 2016 -0800
Committer: Vinod Kone <vi...@gmail.com>
Committed: Tue Feb 9 11:16:58 2016 -0800
----------------------------------------------------------------------
src/tests/mesos.hpp | 99 ++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 99 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/49c8895b/src/tests/mesos.hpp
----------------------------------------------------------------------
diff --git a/src/tests/mesos.hpp b/src/tests/mesos.hpp
index e07d8aa..e382d91 100644
--- a/src/tests/mesos.hpp
+++ b/src/tests/mesos.hpp
@@ -28,6 +28,10 @@
#include <mesos/executor.hpp>
#include <mesos/scheduler.hpp>
+#include <mesos/v1/executor.hpp>
+
+#include <mesos/v1/executor/executor.hpp>
+
#include <mesos/authorizer/authorizer.hpp>
#include <mesos/fetcher/fetcher.hpp>
@@ -880,6 +884,101 @@ public:
};
+namespace executor {
+
+// A generic mock HTTP executor to be used in tests with gmock.
+template <typename Mesos, typename Event>
+class MockHTTPExecutor
+{
+public:
+ MOCK_METHOD1_T(connected, void(Mesos*));
+ MOCK_METHOD1_T(disconnected, void(Mesos*));
+ MOCK_METHOD2_T(subscribed, void(Mesos*, const typename Event::Subscribed&));
+ MOCK_METHOD2_T(launch, void(Mesos*, const typename Event::Launch&));
+ MOCK_METHOD2_T(kill, void(Mesos*, const typename Event::Kill&));
+ MOCK_METHOD2_T(message, void(Mesos*, const typename Event::Message&));
+ MOCK_METHOD2_T(shutdown, void(Mesos*, const typename Event::Shutdown&));
+ MOCK_METHOD2_T(error, void(Mesos*, const typename Event::Error&));
+ MOCK_METHOD2_T(acknowledged,
+ void(Mesos*, const typename Event::Acknowledged&));
+
+ void event(Mesos* mesos, const Event& event)
+ {
+ switch(event.type()) {
+ case Event::SUBSCRIBED:
+ subscribed(mesos, event.subscribed());
+ break;
+ case Event::LAUNCH:
+ launch(mesos, event.launch());
+ break;
+ case Event::KILL:
+ kill(mesos, event.kill());
+ break;
+ case Event::ACKNOWLEDGED:
+ acknowledged(mesos, event.acknowledged());
+ break;
+ case Event::MESSAGE:
+ message(mesos, event.message());
+ break;
+ case Event::SHUTDOWN:
+ shutdown(mesos, event.shutdown());
+ break;
+ case Event::ERROR:
+ error(mesos, event.error());
+ break;
+ }
+ }
+};
+
+
+// A generic testing interface for the executor library that can be used to
+// test the library across various versions.
+template <typename Mesos, typename Event>
+class TestMesos : public Mesos
+{
+public:
+ TestMesos(
+ ContentType contentType,
+ const std::shared_ptr<MockHTTPExecutor<Mesos, Event>>& _executor)
+ : Mesos(
+ contentType,
+ lambda::bind(&MockHTTPExecutor<Mesos, Event>::connected,
+ _executor,
+ this),
+ lambda::bind(&MockHTTPExecutor<Mesos, Event>::disconnected,
+ _executor,
+ this),
+ lambda::bind(&TestMesos<Mesos, Event>::events,
+ this,
+ lambda::_1)),
+ executor(_executor) {}
+
+protected:
+ void events(std::queue<Event> events)
+ {
+ while(!events.empty()) {
+ Event event = std::move(events.front());
+ events.pop();
+ executor->event(this, event);
+ }
+ }
+
+private:
+ std::shared_ptr<MockHTTPExecutor<Mesos, Event>> executor;
+};
+
+
+using TestV1Mesos =
+ TestMesos<mesos::v1::executor::Mesos, mesos::v1::executor::Event>;
+
+} // namespace executor {
+
+
+using MockV1HTTPExecutor =
+ executor::MockHTTPExecutor<
+ mesos::v1::executor::Mesos, mesos::v1::executor::Event>;
+
+
class MockGarbageCollector : public slave::GarbageCollector
{
public:
[2/4] mesos git commit: Introduced gtest actions for subscribe,
sending updates.
Posted by vi...@apache.org.
Introduced gtest actions for subscribe, sending updates.
This change adds some gtest actions that can be used to subscribe/send status
updates using the executor library. These are in similar vein to the existing
actions like `SendStatusUpdateFromTask`.
Review: https://reviews.apache.org/r/43225/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/97d35271
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/97d35271
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/97d35271
Branch: refs/heads/master
Commit: 97d35271d18eeb2b0c487aab65c74c95b25f4614
Parents: 49c8895
Author: Anand Mazumdar <ma...@gmail.com>
Authored: Tue Feb 9 11:17:20 2016 -0800
Committer: Vinod Kone <vi...@gmail.com>
Committed: Tue Feb 9 11:17:20 2016 -0800
----------------------------------------------------------------------
src/tests/mesos.hpp | 57 ++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 57 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/97d35271/src/tests/mesos.hpp
----------------------------------------------------------------------
diff --git a/src/tests/mesos.hpp b/src/tests/mesos.hpp
index e382d91..c0997db 100644
--- a/src/tests/mesos.hpp
+++ b/src/tests/mesos.hpp
@@ -971,6 +971,63 @@ private:
using TestV1Mesos =
TestMesos<mesos::v1::executor::Mesos, mesos::v1::executor::Event>;
+
+// TODO(anand): Move these actions to the `v1::executor` namespace.
+ACTION_P2(SendSubscribe, frameworkId, executorId)
+{
+ v1::executor::Call call;
+ call.mutable_framework_id()->CopyFrom(frameworkId);
+ call.mutable_executor_id()->CopyFrom(executorId);
+
+ call.set_type(v1::executor::Call::SUBSCRIBE);
+
+ call.mutable_subscribe();
+
+ arg0->send(call);
+}
+
+
+ACTION_P3(SendUpdateFromTask, frameworkId, executorId, state)
+{
+ v1::TaskStatus status;
+ status.mutable_task_id()->CopyFrom(arg1.task().task_id());
+ status.mutable_executor_id()->CopyFrom(executorId);
+ status.set_state(state);
+ status.set_source(v1::TaskStatus::SOURCE_EXECUTOR);
+ status.set_uuid(UUID::random().toBytes());
+
+ v1::executor::Call call;
+ call.mutable_framework_id()->CopyFrom(frameworkId);
+ call.mutable_executor_id()->CopyFrom(executorId);
+
+ call.set_type(v1::executor::Call::UPDATE);
+
+ call.mutable_update()->mutable_status()->CopyFrom(status);
+
+ arg0->send(call);
+}
+
+
+ACTION_P3(SendUpdateFromTaskID, frameworkId, executorId, state)
+{
+ v1::TaskStatus status;
+ status.mutable_task_id()->CopyFrom(arg1.task_id());
+ status.mutable_executor_id()->CopyFrom(executorId);
+ status.set_state(state);
+ status.set_source(v1::TaskStatus::SOURCE_EXECUTOR);
+ status.set_uuid(UUID::random().toBytes());
+
+ v1::executor::Call call;
+ call.mutable_framework_id()->CopyFrom(frameworkId);
+ call.mutable_executor_id()->CopyFrom(executorId);
+
+ call.set_type(v1::executor::Call::UPDATE);
+
+ call.mutable_update()->mutable_status()->CopyFrom(status);
+
+ arg0->send(call);
+}
+
} // namespace executor {
[4/4] mesos git commit: Modified the scheduler tests to use the new
executor HTTP based library.
Posted by vi...@apache.org.
Modified the scheduler tests to use the new executor HTTP based library.
This change modifies the existing scheduler tests to use the new executor HTTP
library instead of the old driver based interface.
Review: https://reviews.apache.org/r/41291/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/1c1ee8be
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/1c1ee8be
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/1c1ee8be
Branch: refs/heads/master
Commit: 1c1ee8be2cc5f675bf9706a3880ea633277df456
Parents: 37bb5eb
Author: Anand Mazumdar <ma...@gmail.com>
Authored: Tue Feb 9 11:17:50 2016 -0800
Committer: Vinod Kone <vi...@gmail.com>
Committed: Tue Feb 9 11:17:50 2016 -0800
----------------------------------------------------------------------
src/tests/scheduler_tests.cpp | 179 ++++++++++++++++++++++++++-----------
1 file changed, 128 insertions(+), 51 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/1c1ee8be/src/tests/scheduler_tests.cpp
----------------------------------------------------------------------
diff --git a/src/tests/scheduler_tests.cpp b/src/tests/scheduler_tests.cpp
index 4e2db2a..37f1709 100644
--- a/src/tests/scheduler_tests.cpp
+++ b/src/tests/scheduler_tests.cpp
@@ -195,9 +195,10 @@ TEST_P(SchedulerTest, TaskRunning)
Try<PID<Master>> master = StartMaster(flags);
ASSERT_SOME(master);
- MockExecutor exec(DEFAULT_EXECUTOR_ID);
+ ExecutorID executorId = DEFAULT_EXECUTOR_ID;
- TestContainerizer containerizer(&exec);
+ auto executor = std::make_shared<MockV1HTTPExecutor>();
+ TestContainerizer containerizer(executorId, executor);
Try<PID<Slave>> slave = StartSlave(&containerizer);
ASSERT_SOME(slave);
@@ -243,11 +244,18 @@ TEST_P(SchedulerTest, TaskRunning)
EXPECT_EQ(Event::OFFERS, event.get().type());
EXPECT_NE(0, event.get().offers().offers().size());
- EXPECT_CALL(exec, registered(_, _, _, _))
- .Times(1);
+ EXPECT_CALL(*executor, connected(_))
+ .WillOnce(executor::SendSubscribe(id, evolve(executorId)));
- EXPECT_CALL(exec, launchTask(_, _))
- .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));
+ EXPECT_CALL(*executor, subscribed(_, _));
+
+ EXPECT_CALL(*executor, launch(_, _))
+ .WillOnce(executor::SendUpdateFromTask(
+ id, evolve(executorId), v1::TASK_RUNNING));
+
+ Future<Nothing> acknowledged;
+ EXPECT_CALL(*executor, acknowledged(_, _))
+ .WillOnce(FutureSatisfy(&acknowledged));
Future<Nothing> update;
EXPECT_CALL(containerizer, update(_, _))
@@ -282,16 +290,21 @@ TEST_P(SchedulerTest, TaskRunning)
mesos.send(call);
}
+ AWAIT_READY(acknowledged);
+
event = events.get();
AWAIT_READY(event);
EXPECT_EQ(Event::UPDATE, event.get().type());
EXPECT_EQ(v1::TASK_RUNNING, event.get().update().status().state());
EXPECT_TRUE(event.get().update().status().has_executor_id());
- EXPECT_EQ(exec.id, devolve(event.get().update().status().executor_id()));
+ EXPECT_EQ(executorId, devolve(event.get().update().status().executor_id()));
AWAIT_READY(update);
- EXPECT_CALL(exec, shutdown(_))
+ EXPECT_CALL(*executor, shutdown(_, _))
+ .Times(AtMost(1));
+
+ EXPECT_CALL(*executor, disconnected(_))
.Times(AtMost(1));
Shutdown(); // Must shutdown before 'containerizer' gets deallocated.
@@ -306,9 +319,10 @@ TEST_P(SchedulerTest, ReconcileTask)
Try<PID<Master>> master = StartMaster(flags);
ASSERT_SOME(master);
- MockExecutor exec(DEFAULT_EXECUTOR_ID);
+ ExecutorID executorId = DEFAULT_EXECUTOR_ID;
- TestContainerizer containerizer(&exec);
+ auto executor = std::make_shared<MockV1HTTPExecutor>();
+ TestContainerizer containerizer(executorId, executor);
Try<PID<Slave>> slave = StartSlave(&containerizer);
ASSERT_SOME(slave);
@@ -354,11 +368,18 @@ TEST_P(SchedulerTest, ReconcileTask)
EXPECT_EQ(Event::OFFERS, event.get().type());
EXPECT_NE(0, event.get().offers().offers().size());
- EXPECT_CALL(exec, registered(_, _, _, _))
- .Times(1);
+ EXPECT_CALL(*executor, connected(_))
+ .WillOnce(executor::SendSubscribe(id, evolve(executorId)));
+
+ EXPECT_CALL(*executor, subscribed(_, _));
+
+ EXPECT_CALL(*executor, launch(_, _))
+ .WillOnce(executor::SendUpdateFromTask(
+ id, evolve(executorId), v1::TASK_RUNNING));
- EXPECT_CALL(exec, launchTask(_, _))
- .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));
+ Future<Nothing> acknowledged;
+ EXPECT_CALL(*executor, acknowledged(_, _))
+ .WillOnce(FutureSatisfy(&acknowledged));
v1::Offer offer = event.get().offers().offers(0);
@@ -380,6 +401,8 @@ TEST_P(SchedulerTest, ReconcileTask)
mesos.send(call);
}
+ AWAIT_READY(acknowledged);
+
event = events.get();
AWAIT_READY(event);
EXPECT_EQ(Event::UPDATE, event.get().type());
@@ -404,7 +427,10 @@ TEST_P(SchedulerTest, ReconcileTask)
EXPECT_EQ(v1::TaskStatus::REASON_RECONCILIATION,
event.get().update().status().reason());
- EXPECT_CALL(exec, shutdown(_))
+ EXPECT_CALL(*executor, shutdown(_, _))
+ .Times(AtMost(1));
+
+ EXPECT_CALL(*executor, disconnected(_))
.Times(AtMost(1));
Shutdown(); // Must shutdown before 'containerizer' gets deallocated.
@@ -419,9 +445,10 @@ TEST_P(SchedulerTest, KillTask)
Try<PID<Master>> master = StartMaster(flags);
ASSERT_SOME(master);
- MockExecutor exec(DEFAULT_EXECUTOR_ID);
+ ExecutorID executorId = DEFAULT_EXECUTOR_ID;
- TestContainerizer containerizer(&exec);
+ auto executor = std::make_shared<MockV1HTTPExecutor>();
+ TestContainerizer containerizer(executorId, executor);
Try<PID<Slave>> slave = StartSlave(&containerizer);
ASSERT_SOME(slave);
@@ -467,11 +494,19 @@ TEST_P(SchedulerTest, KillTask)
EXPECT_EQ(Event::OFFERS, event.get().type());
EXPECT_NE(0, event.get().offers().offers().size());
- EXPECT_CALL(exec, registered(_, _, _, _))
- .Times(1);
+ EXPECT_CALL(*executor, connected(_))
+ .WillOnce(executor::SendSubscribe(id, evolve(executorId)));
+
+ EXPECT_CALL(*executor, subscribed(_, _));
- EXPECT_CALL(exec, launchTask(_, _))
- .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));
+ EXPECT_CALL(*executor, launch(_, _))
+ .WillOnce(executor::SendUpdateFromTask(
+ id, evolve(executorId), v1::TASK_RUNNING));
+
+ Future<Nothing> acknowledged;
+ EXPECT_CALL(*executor, acknowledged(_, _))
+ .WillOnce(FutureSatisfy(&acknowledged))
+ .WillRepeatedly(Return());
v1::Offer offer = event.get().offers().offers(0);
@@ -493,6 +528,8 @@ TEST_P(SchedulerTest, KillTask)
mesos.send(call);
}
+ AWAIT_READY(acknowledged);
+
event = events.get();
AWAIT_READY(event);
EXPECT_EQ(Event::UPDATE, event.get().type());
@@ -512,8 +549,9 @@ TEST_P(SchedulerTest, KillTask)
mesos.send(call);
}
- EXPECT_CALL(exec, killTask(_, _))
- .WillOnce(SendStatusUpdateFromTaskID(TASK_KILLED));
+ EXPECT_CALL(*executor, kill(_, _))
+ .WillOnce(executor::SendUpdateFromTaskID(
+ id, evolve(executorId), v1::TASK_KILLED));
{
Call call;
@@ -532,7 +570,10 @@ TEST_P(SchedulerTest, KillTask)
EXPECT_EQ(Event::UPDATE, event.get().type());
EXPECT_EQ(v1::TASK_KILLED, event.get().update().status().state());
- EXPECT_CALL(exec, shutdown(_))
+ EXPECT_CALL(*executor, shutdown(_, _))
+ .Times(AtMost(1));
+
+ EXPECT_CALL(*executor, disconnected(_))
.Times(AtMost(1));
Shutdown(); // Must shutdown before 'containerizer' gets deallocated.
@@ -547,9 +588,10 @@ TEST_P(SchedulerTest, ShutdownExecutor)
Try<PID<Master>> master = StartMaster(flags);
ASSERT_SOME(master);
- MockExecutor exec(DEFAULT_EXECUTOR_ID);
+ ExecutorID executorId = DEFAULT_EXECUTOR_ID;
- TestContainerizer containerizer(&exec);
+ auto executor = std::make_shared<MockV1HTTPExecutor>();
+ TestContainerizer containerizer(executorId, executor);
Try<PID<Slave>> slave = StartSlave(&containerizer);
ASSERT_SOME(slave);
@@ -595,11 +637,18 @@ TEST_P(SchedulerTest, ShutdownExecutor)
EXPECT_EQ(Event::OFFERS, event.get().type());
EXPECT_NE(0, event.get().offers().offers().size());
- EXPECT_CALL(exec, registered(_, _, _, _))
- .Times(1);
+ EXPECT_CALL(*executor, connected(_))
+ .WillOnce(executor::SendSubscribe(id, evolve(executorId)));
+
+ EXPECT_CALL(*executor, subscribed(_, _));
- EXPECT_CALL(exec, launchTask(_, _))
- .WillOnce(SendStatusUpdateFromTask(TASK_FINISHED));
+ EXPECT_CALL(*executor, launch(_, _))
+ .WillOnce(executor::SendUpdateFromTask(
+ id, evolve(executorId), v1::TASK_FINISHED));
+
+ Future<Nothing> acknowledged;
+ EXPECT_CALL(*executor, acknowledged(_, _))
+ .WillOnce(FutureSatisfy(&acknowledged));
v1::Offer offer = event.get().offers().offers(0);
@@ -621,13 +670,15 @@ TEST_P(SchedulerTest, ShutdownExecutor)
mesos.send(call);
}
+ AWAIT_READY(acknowledged);
+
event = events.get();
AWAIT_READY(event);
EXPECT_EQ(Event::UPDATE, event.get().type());
EXPECT_EQ(v1::TASK_FINISHED, event.get().update().status().state());
Future<Nothing> shutdown;
- EXPECT_CALL(exec, shutdown(_))
+ EXPECT_CALL(*executor, shutdown(_, _))
.WillOnce(FutureSatisfy(&shutdown));
{
@@ -643,14 +694,13 @@ TEST_P(SchedulerTest, ShutdownExecutor)
}
AWAIT_READY(shutdown);
- containerizer.destroy(devolve(id), DEFAULT_EXECUTOR_ID);
+ containerizer.destroy(devolve(id), executorId);
// Executor termination results in a 'FAILURE' event.
event = events.get();
AWAIT_READY(event);
EXPECT_EQ(Event::FAILURE, event.get().type());
- v1::ExecutorID executorId(DEFAULT_V1_EXECUTOR_ID);
- EXPECT_EQ(executorId, event.get().failure().executor_id());
+ EXPECT_EQ(evolve(executorId), event.get().failure().executor_id());
Shutdown(); // Must shutdown before 'containerizer' gets deallocated.
}
@@ -664,9 +714,10 @@ TEST_P(SchedulerTest, Teardown)
Try<PID<Master>> master = StartMaster(flags);
ASSERT_SOME(master);
- MockExecutor exec(DEFAULT_EXECUTOR_ID);
+ ExecutorID executorId = DEFAULT_EXECUTOR_ID;
- TestContainerizer containerizer(&exec);
+ auto executor = std::make_shared<MockV1HTTPExecutor>();
+ TestContainerizer containerizer(executorId, executor);
Try<PID<Slave>> slave = StartSlave(&containerizer);
ASSERT_SOME(slave);
@@ -712,11 +763,18 @@ TEST_P(SchedulerTest, Teardown)
EXPECT_EQ(Event::OFFERS, event.get().type());
EXPECT_NE(0, event.get().offers().offers().size());
- EXPECT_CALL(exec, registered(_, _, _, _))
- .Times(1);
+ EXPECT_CALL(*executor, connected(_))
+ .WillOnce(executor::SendSubscribe(id, evolve(executorId)));
- EXPECT_CALL(exec, launchTask(_, _))
- .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));
+ EXPECT_CALL(*executor, subscribed(_, _));
+
+ EXPECT_CALL(*executor, launch(_, _))
+ .WillOnce(executor::SendUpdateFromTask(
+ id, evolve(executorId), v1::TASK_RUNNING));
+
+ Future<Nothing> acknowledged;
+ EXPECT_CALL(*executor, acknowledged(_, _))
+ .WillOnce(FutureSatisfy(&acknowledged));
v1::Offer offer = event.get().offers().offers(0);
@@ -738,13 +796,15 @@ TEST_P(SchedulerTest, Teardown)
mesos.send(call);
}
+ AWAIT_READY(acknowledged);
+
event = events.get();
AWAIT_READY(event);
EXPECT_EQ(Event::UPDATE, event.get().type());
EXPECT_EQ(v1::TASK_RUNNING, event.get().update().status().state());
Future<Nothing> shutdown;
- EXPECT_CALL(exec, shutdown(_))
+ EXPECT_CALL(*executor, shutdown(_, _))
.WillOnce(FutureSatisfy(&shutdown));
{
@@ -1060,9 +1120,10 @@ TEST_P(SchedulerTest, Message)
Try<PID<Master>> master = StartMaster(flags);
ASSERT_SOME(master);
- MockExecutor exec(DEFAULT_EXECUTOR_ID);
+ ExecutorID executorId = DEFAULT_EXECUTOR_ID;
- TestContainerizer containerizer(&exec);
+ auto executor = std::make_shared<MockV1HTTPExecutor>();
+ TestContainerizer containerizer(executorId, executor);
Try<PID<Slave>> slave = StartSlave(&containerizer);
ASSERT_SOME(slave);
@@ -1108,11 +1169,18 @@ TEST_P(SchedulerTest, Message)
EXPECT_EQ(Event::OFFERS, event.get().type());
EXPECT_NE(0, event.get().offers().offers().size());
- EXPECT_CALL(exec, registered(_, _, _, _))
- .Times(1);
+ EXPECT_CALL(*executor, connected(_))
+ .WillOnce(executor::SendSubscribe(id, evolve(executorId)));
- EXPECT_CALL(exec, launchTask(_, _))
- .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));
+ EXPECT_CALL(*executor, subscribed(_, _));
+
+ EXPECT_CALL(*executor, launch(_, _))
+ .WillOnce(executor::SendUpdateFromTask(
+ id, evolve(executorId), v1::TASK_RUNNING));
+
+ Future<Nothing> acknowledged;
+ EXPECT_CALL(*executor, acknowledged(_, _))
+ .WillOnce(FutureSatisfy(&acknowledged));
v1::Offer offer = event.get().offers().offers(0);
@@ -1134,14 +1202,16 @@ TEST_P(SchedulerTest, Message)
mesos.send(call);
}
+ AWAIT_READY(acknowledged);
+
event = events.get();
AWAIT_READY(event);
EXPECT_EQ(Event::UPDATE, event.get().type());
EXPECT_EQ(v1::TASK_RUNNING, event.get().update().status().state());
- Future<string> data;
- EXPECT_CALL(exec, frameworkMessage(_, _))
- .WillOnce(FutureArg<1>(&data));
+ Future<v1::executor::Event::Message> message;
+ EXPECT_CALL(*executor, message(_, _))
+ .WillOnce(FutureArg<1>(&message));
{
Call call;
@@ -1156,7 +1226,14 @@ TEST_P(SchedulerTest, Message)
mesos.send(call);
}
- AWAIT_ASSERT_EQ("hello world", data);
+ AWAIT_READY(message);
+ ASSERT_EQ("hello world", message->data());
+
+ EXPECT_CALL(*executor, shutdown(_, _))
+ .Times(AtMost(1));
+
+ EXPECT_CALL(*executor, disconnected(_))
+ .Times(AtMost(1));
Shutdown(); // Must shutdown before 'containerizer' gets deallocated.
}
[3/4] mesos git commit: Modified `TestContainerizer` to handle HTTP
based executors.
Posted by vi...@apache.org.
Modified `TestContainerizer` to handle HTTP based executors.
This change modifies the `TestContainerizer` class to handle HTTP based
executors. Previously, the containerizer test class only used to handle the
driver interface.
Review: https://reviews.apache.org/r/41290/
Project: http://git-wip-us.apache.org/repos/asf/mesos/repo
Commit: http://git-wip-us.apache.org/repos/asf/mesos/commit/37bb5ebc
Tree: http://git-wip-us.apache.org/repos/asf/mesos/tree/37bb5ebc
Diff: http://git-wip-us.apache.org/repos/asf/mesos/diff/37bb5ebc
Branch: refs/heads/master
Commit: 37bb5ebc7c181b35afd24a2cf55df68f63916fb5
Parents: 97d3527
Author: Anand Mazumdar <ma...@gmail.com>
Authored: Tue Feb 9 11:17:37 2016 -0800
Committer: Vinod Kone <vi...@gmail.com>
Committed: Tue Feb 9 11:17:37 2016 -0800
----------------------------------------------------------------------
src/tests/containerizer.cpp | 43 ++++++++++++++++++++++++++++++++--------
src/tests/containerizer.hpp | 11 ++++++++++
2 files changed, 46 insertions(+), 8 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/mesos/blob/37bb5ebc/src/tests/containerizer.cpp
----------------------------------------------------------------------
diff --git a/src/tests/containerizer.cpp b/src/tests/containerizer.cpp
index 15c8b19..c6772ce 100644
--- a/src/tests/containerizer.cpp
+++ b/src/tests/containerizer.cpp
@@ -23,6 +23,7 @@
#include "tests/mesos.hpp"
using std::map;
+using std::shared_ptr;
using std::string;
using testing::_;
@@ -31,12 +32,23 @@ using testing::Return;
using namespace process;
+using mesos::v1::executor::Mesos;
+
namespace mesos {
namespace internal {
namespace tests {
TestContainerizer::TestContainerizer(
+ const ExecutorID& executorId,
+ const shared_ptr<MockV1HTTPExecutor>& executor)
+{
+ v1Executors[executorId] = executor;
+ setup();
+}
+
+
+TestContainerizer::TestContainerizer(
const hashmap<ExecutorID, Executor*>& _executors)
: executors(_executors)
{
@@ -90,7 +102,8 @@ Future<bool> TestContainerizer::_launch(
<< "' of framework " << executorInfo.framework_id()
<< " because it is already launched";
- CHECK(executors.contains(executorInfo.executor_id()))
+ CHECK(executors.contains(executorInfo.executor_id()) ||
+ v1Executors.contains(executorInfo.executor_id()))
<< "Failed to launch executor '" << executorInfo.executor_id()
<< "' of framework " << executorInfo.framework_id()
<< " because it is unknown to the containerizer";
@@ -101,8 +114,6 @@ Future<bool> TestContainerizer::_launch(
executorInfo.executor_id());
containers_[key] = containerId;
- Executor* executor = executors[executorInfo.executor_id()];
-
// We need to synchronize all reads and writes to the environment as this is
// global state.
// TODO(jmlvanre): Even this is not sufficient, as other aspects of the code
@@ -115,9 +126,6 @@ Future<bool> TestContainerizer::_launch(
// Since the constructor for `MesosExecutorDriver` reads environment
// variables to load flags, even it needs to be within this synchronization
// section.
- Owned<MesosExecutorDriver> driver(new MesosExecutorDriver(executor));
- drivers[containerId] = driver;
-
// Prepare additional environment variables for the executor.
// TODO(benh): Need to get flags passed into the TestContainerizer
// in order to properly use here.
@@ -145,13 +153,28 @@ Future<bool> TestContainerizer::_launch(
// code where we do this as well and it's likely we can do this once
// in 'executorEnvironment()'.
foreach (const Environment::Variable& variable,
- executorInfo.command().environment().variables()) {
+ executorInfo.command().environment().variables()) {
os::setenv(variable.name(), variable.value());
}
os::setenv("MESOS_LOCAL", "1");
- driver->start();
+ if (executors.contains(executorInfo.executor_id())) {
+ Executor* executor = executors[executorInfo.executor_id()];
+
+ Owned<MesosExecutorDriver> driver(new MesosExecutorDriver(executor));
+ drivers[containerId] = driver;
+
+ driver->start();
+ } else {
+ shared_ptr<MockV1HTTPExecutor> executor =
+ v1Executors[executorInfo.executor_id()];
+
+ Owned<executor::TestV1Mesos> mesos(
+ new executor::TestV1Mesos(ContentType::PROTOBUF, executor));
+
+ v1Libraries[containerId] = mesos;
+ }
os::unsetenv("MESOS_LOCAL");
@@ -234,6 +257,10 @@ void TestContainerizer::destroy(const ContainerID& containerId)
drivers.erase(containerId);
}
+ if (v1Libraries.contains(containerId)) {
+ v1Libraries.erase(containerId);
+ }
+
if (promises.contains(containerId)) {
containerizer::Termination termination;
termination.set_message("Killed executor");
http://git-wip-us.apache.org/repos/asf/mesos/blob/37bb5ebc/src/tests/containerizer.hpp
----------------------------------------------------------------------
diff --git a/src/tests/containerizer.hpp b/src/tests/containerizer.hpp
index bd9ee2c..67fbe7f 100644
--- a/src/tests/containerizer.hpp
+++ b/src/tests/containerizer.hpp
@@ -20,6 +20,7 @@
#include <unistd.h>
#include <map>
+#include <memory>
#include <string>
#include <mesos/executor.hpp>
@@ -27,6 +28,8 @@
#include <mesos/resources.hpp>
#include <mesos/type_utils.hpp>
+#include <mesos/v1/executor.hpp>
+
#include <process/dispatch.hpp>
#include <process/future.hpp>
#include <process/gmock.hpp>
@@ -42,6 +45,8 @@
#include "slave/slave.hpp"
#include "slave/state.hpp"
+#include "tests/mesos.hpp"
+
namespace mesos {
namespace internal {
namespace tests {
@@ -52,6 +57,10 @@ class MockExecutor;
class TestContainerizer : public slave::Containerizer
{
public:
+ TestContainerizer(
+ const ExecutorID& executorId,
+ const std::shared_ptr<MockV1HTTPExecutor>& executor);
+
TestContainerizer(const hashmap<ExecutorID, Executor*>& executors);
TestContainerizer(const ExecutorID& executorId, Executor* executor);
@@ -124,9 +133,11 @@ private:
const ContainerID& containerId);
hashmap<ExecutorID, Executor*> executors;
+ hashmap<ExecutorID, std::shared_ptr<MockV1HTTPExecutor>> v1Executors;
hashmap<std::pair<FrameworkID, ExecutorID>, ContainerID> containers_;
hashmap<ContainerID, process::Owned<MesosExecutorDriver> > drivers;
+ hashmap<ContainerID, process::Owned<executor::TestV1Mesos> > v1Libraries;
hashmap<ContainerID,
process::Owned<process::Promise<containerizer::Termination> > > promises;
};