You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mesos.apache.org by ch...@apache.org on 2019/05/22 04:10:14 UTC
[mesos] branch master updated (421728f -> bf07bbd)
This is an automated email from the ASF dual-hosted git repository.
chhsiao pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/mesos.git.
from 421728f Fixed the race between validating and applying FrameworkInfo updates.
new 365e06c Added a helper to devolve offer operations.
new 06aec42 Changed the `*TaskIdEq` test matchers to take a `TaskID`.
new 3747331 Removed the `TaskStatusUpdateIsTerminalState` matcher.
new bf07bbd Added a unit test for master operation authorization.
The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
src/internal/devolve.cpp | 6 +
src/internal/devolve.hpp | 1 +
src/slave/slave.hpp | 3 +-
src/tests/api_tests.cpp | 8 +-
.../containerizer/nvidia_gpu_isolator_tests.cpp | 21 +-
src/tests/default_executor_tests.cpp | 96 ++--
src/tests/gc_tests.cpp | 20 +-
src/tests/master_authorization_tests.cpp | 597 +++++++++++++++++++++
src/tests/master_tests.cpp | 18 +-
src/tests/mesos.hpp | 141 +++--
src/tests/mock_slave.cpp | 7 +
src/tests/mock_slave.hpp | 6 +
src/tests/partition_tests.cpp | 6 +-
src/tests/slave_tests.cpp | 33 +-
14 files changed, 832 insertions(+), 131 deletions(-)
[mesos] 04/04: Added a unit test for master operation authorization.
Posted by ch...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
chhsiao pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mesos.git
commit bf07bbd1cf103b6e8c23ff3831a11dacf9dfc398
Author: Chun-Hung Hsiao <ch...@mesosphere.io>
AuthorDate: Thu Jan 17 18:48:59 2019 -0800
Added a unit test for master operation authorization.
This test verifies that allowing or denying an action will only result
in a success or failure on specific operations but not other operations
in an accept call. This is a regression test for MESOS-9474 and
MESOS-9480.
Review: https://reviews.apache.org/r/70686
---
src/slave/slave.hpp | 3 +-
src/tests/master_authorization_tests.cpp | 597 +++++++++++++++++++++++++++++++
src/tests/mesos.hpp | 123 +++++--
src/tests/mock_slave.cpp | 7 +
src/tests/mock_slave.hpp | 6 +
5 files changed, 709 insertions(+), 27 deletions(-)
diff --git a/src/slave/slave.hpp b/src/slave/slave.hpp
index c740bf7..6954f53 100644
--- a/src/slave/slave.hpp
+++ b/src/slave/slave.hpp
@@ -268,7 +268,8 @@ public:
void checkpointResourcesMessage(
const std::vector<Resource>& resources);
- void applyOperation(const ApplyOperationMessage& message);
+ // Made 'virtual' for Slave mocking.
+ virtual void applyOperation(const ApplyOperationMessage& message);
// Reconciles pending operations with the master. This is necessary to handle
// cases in which operations were dropped in transit, or in which an agent's
diff --git a/src/tests/master_authorization_tests.cpp b/src/tests/master_authorization_tests.cpp
index f65b621..21e450c 100644
--- a/src/tests/master_authorization_tests.cpp
+++ b/src/tests/master_authorization_tests.cpp
@@ -14,7 +14,10 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include <atomic>
+#include <set>
#include <string>
+#include <utility>
#include <vector>
#include <gmock/gmock.h>
@@ -29,6 +32,7 @@
#include <mesos/module/authorizer.hpp>
#include <process/clock.hpp>
+#include <process/collect.hpp>
#include <process/future.hpp>
#include <process/http.hpp>
#include <process/pid.hpp>
@@ -36,9 +40,16 @@
#include <stout/gtest.hpp>
#include <stout/try.hpp>
+#include <stout/unreachable.hpp>
#include "authorizer/local/authorizer.hpp"
+#include "common/protobuf_utils.hpp"
+#include "common/resources_utils.hpp"
+
+#include "internal/devolve.hpp"
+#include "internal/evolve.hpp"
+
#include "master/master.hpp"
#include "master/allocator/mesos/allocator.hpp"
@@ -57,6 +68,8 @@
namespace http = process::http;
+using google::protobuf::RepeatedPtrField;
+
using mesos::internal::master::Master;
using mesos::internal::master::allocator::MesosAllocatorProcess;
@@ -81,11 +94,14 @@ using std::string;
using std::vector;
using testing::_;
+using testing::AllOf;
using testing::An;
using testing::AtMost;
using testing::DoAll;
using testing::Eq;
+using testing::Invoke;
using testing::Return;
+using testing::Truly;
namespace mesos {
namespace internal {
@@ -2748,6 +2764,587 @@ TEST_F(MasterAuthorizationTest, AuthorizedToRegisterNoStaticReservations)
AWAIT_READY(slaveRegisteredMessage);
}
+
+class MasterOperationAuthorizationTest
+ : public MesosTest,
+ public ::testing::WithParamInterface<authorization::Action>
+{
+public:
+ static Resources createAgentResources(const Resources& resources)
+ {
+ Resources agentResources;
+ foreach (
+ Resource resource,
+ resources - resources.filter(&Resources::hasResourceProvider)) {
+ if (Resources::isPersistentVolume(resource)) {
+ if (resource.disk().has_source()) {
+ resource.mutable_disk()->clear_persistence();
+ resource.mutable_disk()->clear_volume();
+ } else {
+ resource.clear_disk();
+ }
+ }
+
+ agentResources += resource;
+ }
+
+ return agentResources;
+ }
+
+ static vector<v1::Offer::Operation> createOperations(
+ const v1::FrameworkID& frameworkId,
+ const v1::AgentID& agentId,
+ const authorization::Action& action)
+ {
+ switch (action) {
+ case authorization::RUN_TASK: {
+ const v1::Resources taskResources =
+ v1::Resources::parse("cpus:1;mem:32").get();
+
+ v1::ExecutorInfo executorInfo = v1::createExecutorInfo(
+ v1::DEFAULT_EXECUTOR_ID,
+ None(),
+ v1::Resources::parse("cpus:1;mem:32;disk:32").get(),
+ v1::ExecutorInfo::DEFAULT,
+ frameworkId);
+
+ return {v1::LAUNCH(
+ {v1::createTask(agentId, taskResources, ""),
+ v1::createTask(agentId, taskResources, "")}),
+ v1::LAUNCH_GROUP(
+ executorInfo,
+ v1::createTaskGroupInfo(
+ {v1::createTask(agentId, taskResources, ""),
+ v1::createTask(agentId, taskResources, "")}))};
+ }
+ case authorization::RESERVE_RESOURCES: {
+ v1::OperationID operationId;
+ operationId.set_value(id::UUID::random().toString());
+
+ v1::Resources reserved;
+ reserved += v1::createReservedResource(
+ "cpus", "1", v1::createDynamicReservationInfo(
+ "role", v1::DEFAULT_CREDENTIAL.principal()));
+ reserved += v1::createReservedResource(
+ "mem", "32", v1::createDynamicReservationInfo(
+ "role", v1::DEFAULT_CREDENTIAL.principal()));
+
+ return {v1::RESERVE(reserved, std::move(operationId))};
+ }
+ case authorization::UNRESERVE_RESOURCES: {
+ v1::OperationID operationId;
+ operationId.set_value(id::UUID::random().toString());
+
+ v1::Resources reserved;
+ reserved += v1::createReservedResource(
+ "cpus", "1", v1::createDynamicReservationInfo("role"));
+ reserved += v1::createReservedResource(
+ "mem", "32", v1::createDynamicReservationInfo("role"));
+
+ return {v1::UNRESERVE(reserved, std::move(operationId))};
+ }
+ case authorization::CREATE_VOLUME: {
+ v1::OperationID operationId;
+ operationId.set_value(id::UUID::random().toString());
+
+ v1::Resources volumes;
+ volumes += v1::createPersistentVolume(
+ Megabytes(32),
+ "role",
+ id::UUID::random().toString(),
+ "path",
+ None(),
+ None(),
+ v1::DEFAULT_CREDENTIAL.principal());
+ volumes += v1::createPersistentVolume(
+ Megabytes(32),
+ "role",
+ id::UUID::random().toString(),
+ "path",
+ None(),
+ None(),
+ v1::DEFAULT_CREDENTIAL.principal());
+
+ return {v1::CREATE(volumes, std::move(operationId))};
+ }
+ case authorization::DESTROY_VOLUME: {
+ v1::OperationID operationId;
+ operationId.set_value(id::UUID::random().toString());
+
+ v1::Resources volumes;
+ volumes += v1::createPersistentVolume(
+ Megabytes(32), "role", id::UUID::random().toString(), "path");
+ volumes += v1::createPersistentVolume(
+ Megabytes(32), "role", id::UUID::random().toString(), "path");
+
+ return {v1::DESTROY(volumes, std::move(operationId))};
+ }
+ case authorization::RESIZE_VOLUME: {
+ v1::OperationID operationId1;
+ operationId1.set_value(id::UUID::random().toString());
+
+ v1::OperationID operationId2;
+ operationId2.set_value(id::UUID::random().toString());
+
+ return {
+ v1::GROW_VOLUME(
+ v1::createPersistentVolume(
+ Megabytes(32), "role", id::UUID::random().toString(), "path"),
+ v1::Resources::parse("disk", "32", "role").get(),
+ std::move(operationId1)),
+ v1::SHRINK_VOLUME(
+ v1::createPersistentVolume(
+ Megabytes(64), "role", id::UUID::random().toString(), "path"),
+ mesos::v1::internal::values::parse("32")->scalar(),
+ std::move(operationId2))};
+ }
+ case authorization::CREATE_BLOCK_DISK: {
+ v1::OperationID operationId;
+ operationId.set_value(id::UUID::random().toString());
+
+ v1::Resource raw = v1::createDiskResource(
+ "32", "*", None(), None(), v1::createDiskSourceRaw(
+ None(), "profile"));
+ raw.mutable_provider_id()->set_value("provider");
+
+ return {v1::CREATE_DISK(
+ raw,
+ v1::Resource::DiskInfo::Source::BLOCK,
+ None(),
+ std::move(operationId))};
+ }
+ case authorization::DESTROY_BLOCK_DISK: {
+ v1::OperationID operationId;
+ operationId.set_value(id::UUID::random().toString());
+
+ v1::Resource block = v1::createDiskResource(
+ "32", "*", None(), None(), v1::createDiskSourceBlock(
+ id::UUID::random().toString(), "profile"));
+ block.mutable_provider_id()->set_value("provider");
+
+ return {v1::DESTROY_DISK(block, std::move(operationId))};
+ }
+ case authorization::CREATE_MOUNT_DISK: {
+ v1::OperationID operationId;
+ operationId.set_value(id::UUID::random().toString());
+
+ v1::Resource raw = v1::createDiskResource(
+ "32", "*", None(), None(), v1::createDiskSourceRaw(
+ None(), "profile"));
+ raw.mutable_provider_id()->set_value("provider");
+
+ return {v1::CREATE_DISK(
+ raw,
+ v1::Resource::DiskInfo::Source::MOUNT,
+ None(),
+ std::move(operationId))};
+ }
+ case authorization::DESTROY_MOUNT_DISK: {
+ v1::OperationID operationId;
+ operationId.set_value(id::UUID::random().toString());
+
+ v1::Resource mount = v1::createDiskResource(
+ "32", "*", None(), None(), v1::createDiskSourceMount(
+ None(), id::UUID::random().toString(), "profile"));
+ mount.mutable_provider_id()->set_value("provider");
+
+ return {v1::DESTROY_DISK(mount, std::move(operationId))};
+ }
+ case authorization::DESTROY_RAW_DISK: {
+ v1::OperationID operationId;
+ operationId.set_value(id::UUID::random().toString());
+
+ v1::Resource raw = v1::createDiskResource(
+ "32", "*", None(), None(), v1::createDiskSourceRaw(
+ id::UUID::random().toString(), "profile"));
+ raw.mutable_provider_id()->set_value("provider");
+
+ return {v1::DESTROY_DISK(raw, std::move(operationId))};
+ }
+ case authorization::UNKNOWN:
+ case authorization::REGISTER_FRAMEWORK:
+ case authorization::TEARDOWN_FRAMEWORK:
+ case authorization::GET_ENDPOINT_WITH_PATH:
+ case authorization::VIEW_ROLE:
+ case authorization::UPDATE_WEIGHT:
+ case authorization::GET_QUOTA:
+ case authorization::UPDATE_QUOTA:
+ case authorization::VIEW_FRAMEWORK:
+ case authorization::VIEW_TASK:
+ case authorization::VIEW_EXECUTOR:
+ case authorization::ACCESS_SANDBOX:
+ case authorization::ACCESS_MESOS_LOG:
+ case authorization::VIEW_FLAGS:
+ case authorization::LAUNCH_NESTED_CONTAINER:
+ case authorization::KILL_NESTED_CONTAINER:
+ case authorization::WAIT_NESTED_CONTAINER:
+ case authorization::LAUNCH_NESTED_CONTAINER_SESSION:
+ case authorization::ATTACH_CONTAINER_INPUT:
+ case authorization::ATTACH_CONTAINER_OUTPUT:
+ case authorization::VIEW_CONTAINER:
+ case authorization::SET_LOG_LEVEL:
+ case authorization::REMOVE_NESTED_CONTAINER:
+ case authorization::REGISTER_AGENT:
+ case authorization::UPDATE_MAINTENANCE_SCHEDULE:
+ case authorization::GET_MAINTENANCE_SCHEDULE:
+ case authorization::START_MAINTENANCE:
+ case authorization::STOP_MAINTENANCE:
+ case authorization::GET_MAINTENANCE_STATUS:
+ case authorization::MARK_AGENT_GONE:
+ case authorization::LAUNCH_STANDALONE_CONTAINER:
+ case authorization::KILL_STANDALONE_CONTAINER:
+ case authorization::WAIT_STANDALONE_CONTAINER:
+ case authorization::REMOVE_STANDALONE_CONTAINER:
+ case authorization::VIEW_STANDALONE_CONTAINER:
+ case authorization::MODIFY_RESOURCE_PROVIDER_CONFIG:
+ case authorization::MARK_RESOURCE_PROVIDER_GONE:
+ case authorization::VIEW_RESOURCE_PROVIDER:
+ case authorization::PRUNE_IMAGES:
+ return {};
+ }
+
+ UNREACHABLE();
+ }
+};
+
+
+INSTANTIATE_TEST_CASE_P(
+ AllowedAction,
+ MasterOperationAuthorizationTest,
+ ::testing::Values(
+ authorization::RUN_TASK,
+ authorization::RESERVE_RESOURCES,
+ authorization::UNRESERVE_RESOURCES,
+ authorization::CREATE_VOLUME,
+ authorization::DESTROY_VOLUME,
+ authorization::RESIZE_VOLUME,
+ authorization::CREATE_BLOCK_DISK,
+ authorization::DESTROY_BLOCK_DISK,
+ authorization::CREATE_MOUNT_DISK,
+ authorization::DESTROY_MOUNT_DISK),
+ [](const testing::TestParamInfo<authorization::Action>& action) {
+ return authorization::Action_Name(action.param);
+ });
+
+
+// This test verifies that allowing or denying an action will only result in a
+// success or failure on specific operations but not other operations in an
+// accept call. This is a regression test for MESOS-9474 and MESOS-9480.
+TEST_P(MasterOperationAuthorizationTest, Accept)
+{
+ Clock::pause();
+
+ // We use this flag to control when the mock authorizer starts to deny
+ // disallowed actions.
+ std::atomic_bool permissive(true);
+
+ MockAuthorizer authorizer;
+ EXPECT_CALL(authorizer, authorized(_))
+ .WillRepeatedly(Invoke([&](const authorization::Request& request) {
+ return permissive || request.action() == GetParam();
+ }));
+
+ Try<Owned<cluster::Master>> master = StartMaster(&authorizer);
+ ASSERT_SOME(master);
+
+ // First, we create a list of operations to exercise all authorization
+ // actions, and compute the total resources needed by these operations and set
+ // up their expected terminal states.
+ //
+ // NOTE: We create some `RUN_TASK` operations in the beginning and some in the
+ // end for two reasons: 1. These operations doesn't have operation IDs so
+ // needs to be handled differently. 2. By adding some operations for the
+ // `RUN_TASK` action in the end, we can verify that their results are not
+ // affected by preceding authorizations.
+ vector<v1::Offer::Operation> operations;
+ v1::Resources totalResources;
+ hashmap<v1::TaskID, v1::TaskState> expectedTaskStates;
+ hashmap<v1::OperationID, v1::OperationState> expectedOperationStates;
+
+ // NOTE: Because we create operations before getting an offer, we synthesize
+ // the framework ID and agent ID here and check them later.
+ v1::FrameworkID frameworkId;
+ frameworkId.set_value(master.get()->getMasterInfo().id() + "-0000");
+ v1::AgentID agentId;
+ agentId.set_value(master.get()->getMasterInfo().id() + "-S0");
+
+ auto addRunTaskOperations = [&] {
+ foreach (
+ v1::Offer::Operation& operation,
+ createOperations(frameworkId, agentId, authorization::RUN_TASK)) {
+ if (operation.type() == v1::Offer::Operation::LAUNCH) {
+ foreach (const v1::TaskInfo& task, operation.launch().task_infos()) {
+ totalResources += task.resources();
+ totalResources += task.executor().resources();
+
+ expectedTaskStates.put(
+ task.task_id(),
+ authorization::RUN_TASK == GetParam()
+ ? v1::TASK_FINISHED : v1::TASK_ERROR);
+ }
+ } else if (operation.type() == v1::Offer::Operation::LAUNCH_GROUP) {
+ totalResources += operation.launch_group().executor().resources();
+
+ foreach (
+ const v1::TaskInfo& task,
+ operation.launch_group().task_group().tasks()) {
+ totalResources += task.resources();
+
+ expectedTaskStates.put(
+ task.task_id(),
+ authorization::RUN_TASK == GetParam()
+ ? v1::TASK_FINISHED : v1::TASK_ERROR);
+ }
+ }
+
+ operations.push_back(std::move(operation));
+ }
+ };
+
+ addRunTaskOperations();
+
+ for (int i = 0; i < authorization::Action_descriptor()->value_count(); i++) {
+ const authorization::Action action = static_cast<authorization::Action>(
+ authorization::Action_descriptor()->value(i)->number());
+
+ // Skip `RUN_TASK` operations since they are handled separately.
+ if (action == authorization::RUN_TASK) {
+ continue;
+ }
+
+ foreach (
+ v1::Offer::Operation& operation,
+ createOperations(frameworkId, agentId, action)) {
+ Try<Resources> consumed =
+ protobuf::getConsumedResources(devolve(operation));
+ ASSERT_SOME(consumed);
+ totalResources += evolve(consumed.get());
+
+ ASSERT_TRUE(operation.has_id());
+ expectedOperationStates.put(
+ operation.id(),
+ action == GetParam() ? v1::OPERATION_FINISHED : v1::OPERATION_ERROR);
+
+ operations.push_back(std::move(operation));
+ }
+ }
+
+ addRunTaskOperations();
+
+ // Then, we register a mock agent that has sufficient resources to exercise
+ // all operations and simply replies `TASK_FINISHED` or `OPERATION_FINISHED`
+ // for all tasks or operations it receives.
+ //
+ // NOTE: Since dynamic reservations, persistent volumes and resource
+ // provider resources cannot be specified through the `--resources` flag, we
+ // intercept the `RegisterSlaveMessage` and `UpdateSlaveMessage` to inject
+ // resources required by all operations then forward them to the master.
+ Future<RegisterSlaveMessage> registerSlaveMessage =
+ DROP_PROTOBUF(RegisterSlaveMessage(), _, _);
+ Future<SlaveRegisteredMessage> slaveRegisteredMessage =
+ FUTURE_PROTOBUF(SlaveRegisteredMessage(), _, _);
+ Future<UpdateSlaveMessage> updateSlaveMessage =
+ DROP_PROTOBUF(UpdateSlaveMessage(), _, _);
+
+ Owned<MasterDetector> detector = master.get()->createDetector();
+ slave::Flags slaveFlags = CreateSlaveFlags();
+ Try<Owned<cluster::Slave>> slave =
+ StartSlave(detector.get(), slaveFlags, true);
+ ASSERT_SOME(slave);
+ ASSERT_NE(nullptr, slave.get()->mock());
+
+ EXPECT_CALL(*slave.get()->mock(), runTask(_, _, _, _, _, _, _))
+ .WillRepeatedly(Invoke([&](
+ const process::UPID& from,
+ const FrameworkInfo& frameworkInfo,
+ const FrameworkID& frameworkId,
+ const process::UPID& pid,
+ const TaskInfo& task,
+ const std::vector<ResourceVersionUUID>& resourceVersionUuids,
+ const Option<bool>& launchExecutor) {
+ ASSERT_TRUE(frameworkInfo.has_id());
+
+ StatusUpdateMessage message;
+ message.set_pid(slave.get()->pid);
+ *message.mutable_update() = protobuf::createStatusUpdate(
+ frameworkInfo.id(),
+ devolve(agentId),
+ task.task_id(),
+ TASK_FINISHED,
+ TaskStatus::SOURCE_SLAVE,
+ id::UUID::random());
+
+ process::post(slave.get()->pid, master.get()->pid, message);
+ }));
+
+ EXPECT_CALL(*slave.get()->mock(), runTaskGroup(_, _, _, _, _, _))
+ .WillRepeatedly(Invoke([&](
+ const process::UPID& from,
+ const FrameworkInfo& frameworkInfo,
+ const ExecutorInfo& executorInfo,
+ const TaskGroupInfo& taskGroup,
+ const std::vector<ResourceVersionUUID>& resourceVersionUuids,
+ const Option<bool>& launchExecutor) {
+ ASSERT_TRUE(frameworkInfo.has_id());
+
+ foreach (const TaskInfo& task, taskGroup.tasks()) {
+ StatusUpdateMessage message;
+ message.set_pid(slave.get()->pid);
+ *message.mutable_update() = protobuf::createStatusUpdate(
+ frameworkInfo.id(),
+ devolve(agentId),
+ task.task_id(),
+ TASK_FINISHED,
+ TaskStatus::SOURCE_SLAVE,
+ id::UUID::random());
+
+ process::post(slave.get()->pid, master.get()->pid, message);
+ }
+ }));
+
+ EXPECT_CALL(*slave.get()->mock(), applyOperation(_))
+ .WillRepeatedly(Invoke([&](const ApplyOperationMessage& message) {
+ ASSERT_TRUE(message.has_framework_id());
+ ASSERT_TRUE(message.operation_info().has_id());
+
+ process::post(
+ slave.get()->pid,
+ master.get()->pid,
+ protobuf::createUpdateOperationStatusMessage(
+ message.operation_uuid(),
+ protobuf::createOperationStatus(
+ OPERATION_FINISHED,
+ message.operation_info().id(),
+ None(),
+ None(),
+ None(),
+ devolve(agentId)),
+ None(),
+ message.framework_id(),
+ devolve(agentId)));
+ }));
+
+ slave.get()->start();
+
+ // Settle the clock to ensure that the master has been detected by the agent,
+ // then advance the clock to trigger an authentication and a registration.
+ Clock::settle();
+ Clock::advance(slaveFlags.registration_backoff_factor);
+
+ AWAIT_READY(registerSlaveMessage);
+
+ {
+ RegisterSlaveMessage message = registerSlaveMessage.get();
+ *message.mutable_slave()->mutable_resources() =
+ createAgentResources(devolve(totalResources));
+ *message.mutable_checkpointed_resources() =
+ devolve(totalResources).filter(needCheckpointing);
+
+ process::post(slave.get()->pid, master.get()->pid, message);
+ }
+
+ AWAIT_READY(slaveRegisteredMessage);
+ EXPECT_EQ(devolve(agentId), slaveRegisteredMessage->slave_id());
+
+ AWAIT_READY(updateSlaveMessage);
+
+ {
+ UpdateSlaveMessage message = updateSlaveMessage.get();
+ UpdateSlaveMessage::ResourceProvider* resourceProvider =
+ message.mutable_resource_providers()->add_providers();
+ resourceProvider->mutable_info()->mutable_id()->set_value("provider");
+ resourceProvider->mutable_info()->set_type("resource_provider_type");
+ resourceProvider->mutable_info()->set_name("resource_provider_name");
+ *resourceProvider->mutable_total_resources() =
+ devolve(totalResources).filter(&Resources::hasResourceProvider);
+ resourceProvider->mutable_operations();
+ resourceProvider->mutable_resource_version_uuid()->set_value(
+ id::UUID::random().toBytes());
+
+ process::post(slave.get()->pid, master.get()->pid, message);
+ }
+
+ // Settle the clock to ensure that the resource providers has been updated.
+ Clock::settle();
+
+ // Finally, we register a framework to exercise all operations, and check that
+ // only authorized tasks and operations are finished.
+ v1::FrameworkInfo frameworkInfo = v1::DEFAULT_FRAMEWORK_INFO;
+ frameworkInfo.set_roles(0, "role");
+
+ auto scheduler = std::make_shared<v1::MockHTTPScheduler>();
+
+ EXPECT_CALL(*scheduler, connected(_))
+ .WillOnce(v1::scheduler::SendSubscribe(frameworkInfo));
+
+ Future<v1::scheduler::Event::Subscribed> subscribed;
+ EXPECT_CALL(*scheduler, subscribed(_, _)).WillOnce(FutureArg<1>(&subscribed));
+
+ EXPECT_CALL(*scheduler, heartbeat(_))
+ .WillRepeatedly(Return()); // Ignore heartbeats.
+
+ Future<v1::scheduler::Event::Offers> offers;
+ EXPECT_CALL(*scheduler, offers(_, _))
+ .WillOnce(FutureArg<1>(&offers))
+ .WillRepeatedly(Return()); // Ignore subsequent offers.
+
+ v1::scheduler::TestMesos mesos(
+ master.get()->pid, ContentType::PROTOBUF, scheduler);
+
+ AWAIT_READY(subscribed);
+ EXPECT_EQ(frameworkId, subscribed->framework_id());
+
+ // Start to deny disallowed actions.
+ permissive = false;
+
+ AWAIT_READY(offers);
+ ASSERT_EQ(1u, offers->offers_size());
+
+ hashmap<v1::TaskID, Future<v1::scheduler::Event::Update>>
+ actualTaskStatusUpdates;
+ hashmap<v1::OperationID, Future<v1::scheduler::Event::UpdateOperationStatus>>
+ actualOperationStatusUpdates;
+
+ foreachkey (const v1::TaskID& taskId, expectedTaskStates) {
+ EXPECT_CALL(*scheduler, update(_, AllOf(
+ TaskStatusUpdateTaskIdEq(taskId),
+ Truly([](const v1::scheduler::Event::Update& update) {
+ return protobuf::isTerminalState(devolve(update.status()).state());
+ }))))
+ .WillOnce(FutureArg<1>(&actualTaskStatusUpdates[taskId]));
+ }
+
+ foreachkey (const v1::OperationID& operationId, expectedOperationStates) {
+ EXPECT_CALL(*scheduler, updateOperationStatus(_, AllOf(
+ v1::scheduler::OperationStatusUpdateOperationIdEq(operationId),
+ Truly([](const v1::scheduler::Event::UpdateOperationStatus& update) {
+ return protobuf::isTerminalState(devolve(update.status()).state());
+ }))))
+ .WillOnce(FutureArg<1>(&actualOperationStatusUpdates[operationId]));
+ }
+
+ mesos.send(v1::createCallAccept(
+ subscribed->framework_id(),
+ offers->offers(0),
+ operations));
+
+ foreachpair (
+ const v1::TaskID& taskId,
+ const Future<v1::scheduler::Event::Update>& update,
+ actualTaskStatusUpdates) {
+ AWAIT_READY(update);
+ EXPECT_EQ(expectedTaskStates[taskId], update->status().state());
+ }
+
+ foreachpair (
+ const v1::OperationID& operationId,
+ const Future<v1::scheduler::Event::UpdateOperationStatus>& update,
+ actualOperationStatusUpdates) {
+ AWAIT_READY(update);
+ EXPECT_EQ(expectedOperationStates[operationId], update->status().state());
+ }
+}
+
} // namespace tests {
} // namespace internal {
} // namespace mesos {
diff --git a/src/tests/mesos.hpp b/src/tests/mesos.hpp
index c886789..d0c82fa 100644
--- a/src/tests/mesos.hpp
+++ b/src/tests/mesos.hpp
@@ -1321,65 +1321,102 @@ inline typename TOffer::Operation RESERVE(
operation.mutable_reserve()->mutable_resources()->CopyFrom(resources);
if (operationId.isSome()) {
- operation.mutable_id()->CopyFrom(operationId.get());
+ *operation.mutable_id() = operationId.get();
}
return operation;
}
-template <typename TResources, typename TOffer>
-inline typename TOffer::Operation UNRESERVE(const TResources& resources)
+template <typename TResources, typename TOperationID, typename TOffer>
+inline typename TOffer::Operation UNRESERVE(
+ const TResources& resources,
+ const Option<TOperationID>& operationId = None())
{
typename TOffer::Operation operation;
operation.set_type(TOffer::Operation::UNRESERVE);
operation.mutable_unreserve()->mutable_resources()->CopyFrom(resources);
+
+ if (operationId.isSome()) {
+ *operation.mutable_id() = operationId.get();
+ }
+
return operation;
}
-template <typename TResources, typename TOffer>
-inline typename TOffer::Operation CREATE(const TResources& volumes)
+template <typename TResources, typename TOperationID, typename TOffer>
+inline typename TOffer::Operation CREATE(
+ const TResources& volumes,
+ const Option<TOperationID>& operationId = None())
{
typename TOffer::Operation operation;
operation.set_type(TOffer::Operation::CREATE);
operation.mutable_create()->mutable_volumes()->CopyFrom(volumes);
+
+ if (operationId.isSome()) {
+ *operation.mutable_id() = operationId.get();
+ }
+
return operation;
}
-template <typename TResources, typename TOffer>
-inline typename TOffer::Operation DESTROY(const TResources& volumes)
+template <typename TResources, typename TOperationID, typename TOffer>
+inline typename TOffer::Operation DESTROY(
+ const TResources& volumes,
+ const Option<TOperationID>& operationId = None())
{
typename TOffer::Operation operation;
operation.set_type(TOffer::Operation::DESTROY);
operation.mutable_destroy()->mutable_volumes()->CopyFrom(volumes);
+
+ if (operationId.isSome()) {
+ *operation.mutable_id() = operationId.get();
+ }
+
return operation;
}
-template <typename TResource, typename TOffer>
+template <typename TResource, typename TOperationID, typename TOffer>
inline typename TOffer::Operation GROW_VOLUME(
const TResource& volume,
- const TResource& addition)
+ const TResource& addition,
+ const Option<TOperationID>& operationId = None())
{
typename TOffer::Operation operation;
operation.set_type(TOffer::Operation::GROW_VOLUME);
operation.mutable_grow_volume()->mutable_volume()->CopyFrom(volume);
operation.mutable_grow_volume()->mutable_addition()->CopyFrom(addition);
+
+ if (operationId.isSome()) {
+ *operation.mutable_id() = operationId.get();
+ }
+
return operation;
}
-template <typename TResource, typename TOffer, typename TValueScalar>
+template <
+ typename TResource,
+ typename TValueScalar,
+ typename TOperationID,
+ typename TOffer>
inline typename TOffer::Operation SHRINK_VOLUME(
const TResource& volume,
- const TValueScalar& subtract)
+ const TValueScalar& subtract,
+ const Option<TOperationID>& operationId = None())
{
typename TOffer::Operation operation;
operation.set_type(TOffer::Operation::SHRINK_VOLUME);
operation.mutable_shrink_volume()->mutable_volume()->CopyFrom(volume);
operation.mutable_shrink_volume()->mutable_subtract()->CopyFrom(subtract);
+
+ if (operationId.isSome()) {
+ *operation.mutable_id() = operationId.get();
+ }
+
return operation;
}
@@ -1765,35 +1802,40 @@ inline Offer::Operation RESERVE(Args&&... args)
template <typename... Args>
inline Offer::Operation UNRESERVE(Args&&... args)
{
- return common::UNRESERVE<Resources, Offer>(std::forward<Args>(args)...);
+ return common::UNRESERVE<Resources, OperationID, Offer>(
+ std::forward<Args>(args)...);
}
template <typename... Args>
inline Offer::Operation CREATE(Args&&... args)
{
- return common::CREATE<Resources, Offer>(std::forward<Args>(args)...);
+ return common::CREATE<Resources, OperationID, Offer>(
+ std::forward<Args>(args)...);
}
template <typename... Args>
inline Offer::Operation DESTROY(Args&&... args)
{
- return common::DESTROY<Resources, Offer>(std::forward<Args>(args)...);
+ return common::DESTROY<Resources, OperationID, Offer>(
+ std::forward<Args>(args)...);
}
template <typename... Args>
inline Offer::Operation GROW_VOLUME(Args&&... args)
{
- return common::GROW_VOLUME<Resource, Offer>(std::forward<Args>(args)...);
+ return common::GROW_VOLUME<Resource, OperationID, Offer>(
+ std::forward<Args>(args)...);
}
template <typename... Args>
inline Offer::Operation SHRINK_VOLUME(Args&&... args)
{
- return common::SHRINK_VOLUME<Resource, Offer>(std::forward<Args>(args)...);
+ return common::SHRINK_VOLUME<Resource, Value::Scalar, OperationID, Offer>(
+ std::forward<Args>(args)...);
}
@@ -2063,40 +2105,51 @@ inline mesos::v1::Offer::Operation RESERVE(Args&&... args)
template <typename... Args>
inline mesos::v1::Offer::Operation UNRESERVE(Args&&... args)
{
- return common::UNRESERVE<mesos::v1::Resources, mesos::v1::Offer>(
- std::forward<Args>(args)...);
+ return common::UNRESERVE<
+ mesos::v1::Resources,
+ mesos::v1::OperationID,
+ mesos::v1::Offer>(std::forward<Args>(args)...);
}
template <typename... Args>
inline mesos::v1::Offer::Operation CREATE(Args&&... args)
{
- return common::CREATE<mesos::v1::Resources, mesos::v1::Offer>(
- std::forward<Args>(args)...);
+ return common::CREATE<
+ mesos::v1::Resources,
+ mesos::v1::OperationID,
+ mesos::v1::Offer>(std::forward<Args>(args)...);
}
template <typename... Args>
inline mesos::v1::Offer::Operation DESTROY(Args&&... args)
{
- return common::DESTROY<mesos::v1::Resources, mesos::v1::Offer>(
- std::forward<Args>(args)...);
+ return common::DESTROY<
+ mesos::v1::Resources,
+ mesos::v1::OperationID,
+ mesos::v1::Offer>(std::forward<Args>(args)...);
}
template <typename... Args>
inline mesos::v1::Offer::Operation GROW_VOLUME(Args&&... args)
{
- return common::GROW_VOLUME<mesos::v1::Resource, mesos::v1::Offer>(
- std::forward<Args>(args)...);
+ return common::GROW_VOLUME<
+ mesos::v1::Resource,
+ mesos::v1::OperationID,
+ mesos::v1::Offer>(std::forward<Args>(args)...);
}
template <typename... Args>
inline mesos::v1::Offer::Operation SHRINK_VOLUME(Args&&... args)
{
- return common::SHRINK_VOLUME<mesos::v1::Resource, mesos::v1::Offer>(
- std::forward<Args>(args)...);
+ return common::SHRINK_VOLUME<
+ mesos::v1::Resource,
+ mesos::v1::Value::Scalar,
+ mesos::v1::OperationID,
+ mesos::v1::Offer>(std::forward<Args>(args)...);
}
@@ -2745,6 +2798,24 @@ ACTION_P2(SendAcknowledge, frameworkId, agentId)
}
+ACTION_P2(
+ SendAcknowledgeOperationStatus, frameworkId, agentId)
+{
+ Call call;
+ call.set_type(Call::ACKNOWLEDGE_OPERATION_STATUS);
+ call.mutable_framework_id()->CopyFrom(frameworkId);
+
+ Call::AcknowledgeOperationStatus* acknowledge =
+ call.mutable_acknowledge_operation_status();
+
+ acknowledge->mutable_agent_id()->CopyFrom(agentId);
+ acknowledge->set_uuid(arg1.status().uuid().value());
+ acknowledge->mutable_operation_id()->CopyFrom(arg1.status().operation_id());
+
+ arg0->send(call);
+}
+
+
ACTION_P3(
SendAcknowledgeOperationStatus, frameworkId, agentId, resourceProviderId)
{
diff --git a/src/tests/mock_slave.cpp b/src/tests/mock_slave.cpp
index 1122c2a..dd458e3 100644
--- a/src/tests/mock_slave.cpp
+++ b/src/tests/mock_slave.cpp
@@ -153,6 +153,8 @@ MockSlave::MockSlave(
.WillRepeatedly(Invoke(this, &MockSlave::unmocked_shutdownExecutor));
EXPECT_CALL(*this, _shutdownExecutor(_, _))
.WillRepeatedly(Invoke(this, &MockSlave::unmocked__shutdownExecutor));
+ EXPECT_CALL(*this, applyOperation(_))
+ .WillRepeatedly(Invoke(this, &MockSlave::unmocked_applyOperation));
}
@@ -314,6 +316,11 @@ void MockSlave::unmocked__shutdownExecutor(
}
+void MockSlave::unmocked_applyOperation(const ApplyOperationMessage& message)
+{
+ slave::Slave::applyOperation(message);
+}
+
} // namespace tests {
} // namespace internal {
} // namespace mesos {
diff --git a/src/tests/mock_slave.hpp b/src/tests/mock_slave.hpp
index 326a450..c057b40 100644
--- a/src/tests/mock_slave.hpp
+++ b/src/tests/mock_slave.hpp
@@ -253,6 +253,12 @@ public:
void unmocked__shutdownExecutor(
slave::Framework* framework,
slave::Executor* executor);
+
+ MOCK_METHOD1(applyOperation, void(
+ const ApplyOperationMessage& message));
+
+ void unmocked_applyOperation(
+ const ApplyOperationMessage& message);
};
} // namespace tests {
[mesos] 02/04: Changed the `*TaskIdEq` test matchers to take a
`TaskID`.
Posted by ch...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
chhsiao pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mesos.git
commit 06aec4208a506bd14534876e36575bb84a1076ca
Author: Chun-Hung Hsiao <ch...@mesosphere.io>
AuthorDate: Wed May 15 14:19:08 2019 -0700
Changed the `*TaskIdEq` test matchers to take a `TaskID`.
The `TaskStatusTaskIdEq` and `TaskStatusUpdateTaskIdEq` matchers
previously take a `TaskInfo`, which is not very intuitive and
inconsistent with other matchers such as `OptionTaskHasTaskID`. By
making these matchers take a `TaskID` we also reduce coupling of this
matcher and the structure of `TaskInfo`.
Review: https://reviews.apache.org/r/70684
---
src/tests/api_tests.cpp | 8 +-
.../containerizer/nvidia_gpu_isolator_tests.cpp | 4 +-
src/tests/default_executor_tests.cpp | 96 +++++++++++-----------
src/tests/gc_tests.cpp | 20 ++---
src/tests/master_tests.cpp | 18 ++--
src/tests/mesos.hpp | 8 +-
src/tests/partition_tests.cpp | 6 +-
src/tests/slave_tests.cpp | 33 +++++---
8 files changed, 102 insertions(+), 91 deletions(-)
diff --git a/src/tests/api_tests.cpp b/src/tests/api_tests.cpp
index bc19d7e..37d0cb1 100644
--- a/src/tests/api_tests.cpp
+++ b/src/tests/api_tests.cpp
@@ -5025,7 +5025,7 @@ TEST_P(MasterAPITest, UnreachableAgentMarkedGone)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo),
+ TaskStatusUpdateTaskIdEq(taskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(updateSequence)
.WillOnce(DoAll(
@@ -5035,7 +5035,7 @@ TEST_P(MasterAPITest, UnreachableAgentMarkedGone)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo),
+ TaskStatusUpdateTaskIdEq(taskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(updateSequence)
.WillOnce(DoAll(
@@ -5056,7 +5056,7 @@ TEST_P(MasterAPITest, UnreachableAgentMarkedGone)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo),
+ TaskStatusUpdateTaskIdEq(taskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_UNREACHABLE))))
.WillOnce(FutureArg<1>(&unreachableUpdate));
@@ -5092,7 +5092,7 @@ TEST_P(MasterAPITest, UnreachableAgentMarkedGone)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo),
+ TaskStatusUpdateTaskIdEq(taskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_GONE_BY_OPERATOR))))
.WillOnce(FutureArg<1>(&goneUpdate));
diff --git a/src/tests/containerizer/nvidia_gpu_isolator_tests.cpp b/src/tests/containerizer/nvidia_gpu_isolator_tests.cpp
index 7f5bd8c..5e753e7 100644
--- a/src/tests/containerizer/nvidia_gpu_isolator_tests.cpp
+++ b/src/tests/containerizer/nvidia_gpu_isolator_tests.cpp
@@ -306,7 +306,7 @@ TEST_F(NvidiaGpuTest, ROOT_INTERNET_CURL_CGROUPS_NVIDIA_GPU_NvidiaDockerImage)
Future<v1::scheduler::Event::Update> task1Finished;
EXPECT_CALL(*scheduler, update(_, AllOf(
- TaskStatusUpdateTaskIdEq(task1),
+ TaskStatusUpdateTaskIdEq(task1.task_id()),
TaskStatusUpdateIsTerminalState())))
.WillOnce(DoAll(
FutureArg<1>(&task1Finished),
@@ -314,7 +314,7 @@ TEST_F(NvidiaGpuTest, ROOT_INTERNET_CURL_CGROUPS_NVIDIA_GPU_NvidiaDockerImage)
Future<v1::scheduler::Event::Update> task2Failed;
EXPECT_CALL(*scheduler, update(_, AllOf(
- TaskStatusUpdateTaskIdEq(task2),
+ TaskStatusUpdateTaskIdEq(task2.task_id()),
TaskStatusUpdateIsTerminalState())))
.WillOnce(DoAll(
FutureArg<1>(&task2Failed),
diff --git a/src/tests/default_executor_tests.cpp b/src/tests/default_executor_tests.cpp
index 93d7a1c..1c3b488 100644
--- a/src/tests/default_executor_tests.cpp
+++ b/src/tests/default_executor_tests.cpp
@@ -413,7 +413,7 @@ TEST_P(DefaultExecutorTest, KillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task1)
.WillOnce(
@@ -424,7 +424,7 @@ TEST_P(DefaultExecutorTest, KillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task1)
.WillOnce(
@@ -435,7 +435,7 @@ TEST_P(DefaultExecutorTest, KillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_KILLED))))
.InSequence(task1)
.WillOnce(
@@ -451,7 +451,7 @@ TEST_P(DefaultExecutorTest, KillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task2)
.WillOnce(
@@ -462,7 +462,7 @@ TEST_P(DefaultExecutorTest, KillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task2)
.WillOnce(
@@ -473,7 +473,7 @@ TEST_P(DefaultExecutorTest, KillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_KILLED))))
.InSequence(task2)
.WillOnce(
@@ -520,7 +520,7 @@ TEST_P(DefaultExecutorTest, KillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo3),
+ TaskStatusUpdateTaskIdEq(taskInfo3.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task3)
.WillOnce(
@@ -531,7 +531,7 @@ TEST_P(DefaultExecutorTest, KillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo3),
+ TaskStatusUpdateTaskIdEq(taskInfo3.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task3)
.WillOnce(
@@ -542,7 +542,7 @@ TEST_P(DefaultExecutorTest, KillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo3),
+ TaskStatusUpdateTaskIdEq(taskInfo3.task_id()),
TaskStatusUpdateStateEq(v1::TASK_KILLED))))
.InSequence(task3)
.WillOnce(
@@ -667,7 +667,7 @@ TEST_P(DefaultExecutorTest, KillMultipleTasks)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task1)
.WillOnce(
@@ -678,7 +678,7 @@ TEST_P(DefaultExecutorTest, KillMultipleTasks)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task1)
.WillOnce(
@@ -689,7 +689,7 @@ TEST_P(DefaultExecutorTest, KillMultipleTasks)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_KILLED))))
.InSequence(task1)
.WillOnce(
@@ -705,7 +705,7 @@ TEST_P(DefaultExecutorTest, KillMultipleTasks)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task2)
.WillOnce(
@@ -716,7 +716,7 @@ TEST_P(DefaultExecutorTest, KillMultipleTasks)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task2)
.WillOnce(
@@ -727,7 +727,7 @@ TEST_P(DefaultExecutorTest, KillMultipleTasks)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_KILLED))))
.InSequence(task2)
.WillOnce(
@@ -827,7 +827,7 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task1)
.WillOnce(
@@ -838,7 +838,7 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task1)
.WillOnce(
@@ -849,7 +849,7 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_FAILED))))
.InSequence(task1)
.WillOnce(
@@ -865,7 +865,7 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task2)
.WillOnce(
@@ -876,7 +876,7 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task2)
.WillOnce(
@@ -887,7 +887,7 @@ TEST_P(DefaultExecutorTest, KillTaskGroupOnTaskFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_KILLED))))
.InSequence(task2)
.WillOnce(
@@ -1062,7 +1062,7 @@ TEST_P(DefaultExecutorTest, ROOT_ContainerStatusForTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task1)
.WillOnce(
@@ -1073,7 +1073,7 @@ TEST_P(DefaultExecutorTest, ROOT_ContainerStatusForTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task1)
.WillOnce(
@@ -1088,7 +1088,7 @@ TEST_P(DefaultExecutorTest, ROOT_ContainerStatusForTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task2)
.WillOnce(
@@ -1099,7 +1099,7 @@ TEST_P(DefaultExecutorTest, ROOT_ContainerStatusForTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task2)
.WillOnce(
@@ -1309,7 +1309,7 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnKillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task1)
.WillOnce(
@@ -1320,7 +1320,7 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnKillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task1)
.WillOnce(
@@ -1331,7 +1331,7 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnKillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_FINISHED))))
.InSequence(task1)
.WillOnce(
@@ -1347,7 +1347,7 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnKillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task2)
.WillOnce(
@@ -1358,7 +1358,7 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnKillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task2)
.WillOnce(
@@ -1369,7 +1369,7 @@ TEST_P(DefaultExecutorTest, CommitSuicideOnKillTask)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_KILLED))))
.InSequence(task2)
.WillOnce(
@@ -1907,7 +1907,7 @@ TEST_P(DefaultExecutorTest, MaxCompletionTime)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task1)
.WillOnce(
@@ -1918,7 +1918,7 @@ TEST_P(DefaultExecutorTest, MaxCompletionTime)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task1)
.WillOnce(
@@ -1929,7 +1929,7 @@ TEST_P(DefaultExecutorTest, MaxCompletionTime)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo1),
+ TaskStatusUpdateTaskIdEq(taskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_FINISHED))))
.InSequence(task1)
.WillOnce(
@@ -1945,7 +1945,7 @@ TEST_P(DefaultExecutorTest, MaxCompletionTime)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task2)
.WillOnce(
@@ -1956,7 +1956,7 @@ TEST_P(DefaultExecutorTest, MaxCompletionTime)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task2)
.WillOnce(
@@ -1967,7 +1967,7 @@ TEST_P(DefaultExecutorTest, MaxCompletionTime)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo2),
+ TaskStatusUpdateTaskIdEq(taskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_FAILED))))
.InSequence(task2)
.WillOnce(
@@ -1983,7 +1983,7 @@ TEST_P(DefaultExecutorTest, MaxCompletionTime)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo3),
+ TaskStatusUpdateTaskIdEq(taskInfo3.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(task3)
.WillOnce(
@@ -1994,7 +1994,7 @@ TEST_P(DefaultExecutorTest, MaxCompletionTime)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo3),
+ TaskStatusUpdateTaskIdEq(taskInfo3.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(task3)
.WillOnce(
@@ -2005,7 +2005,7 @@ TEST_P(DefaultExecutorTest, MaxCompletionTime)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo3),
+ TaskStatusUpdateTaskIdEq(taskInfo3.task_id()),
TaskStatusUpdateStateEq(v1::TASK_KILLED))))
.InSequence(task3)
.WillOnce(
@@ -4160,7 +4160,7 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorTest, ROOT_LaunchGroupFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(sleepTaskInfo1),
+ TaskStatusUpdateTaskIdEq(sleepTaskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(sleepTask1)
.WillOnce(
@@ -4171,7 +4171,7 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorTest, ROOT_LaunchGroupFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(sleepTaskInfo1),
+ TaskStatusUpdateTaskIdEq(sleepTaskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(sleepTask1)
.WillOnce(
@@ -4182,7 +4182,7 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorTest, ROOT_LaunchGroupFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(sleepTaskInfo1),
+ TaskStatusUpdateTaskIdEq(sleepTaskInfo1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_KILLED))))
.InSequence(sleepTask1)
.WillOnce(
@@ -4198,7 +4198,7 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorTest, ROOT_LaunchGroupFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(sleepTaskInfo2),
+ TaskStatusUpdateTaskIdEq(sleepTaskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(sleepTask2)
.WillOnce(
@@ -4209,7 +4209,7 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorTest, ROOT_LaunchGroupFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(sleepTaskInfo2),
+ TaskStatusUpdateTaskIdEq(sleepTaskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(sleepTask2)
.WillOnce(
@@ -4220,7 +4220,7 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorTest, ROOT_LaunchGroupFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(sleepTaskInfo2),
+ TaskStatusUpdateTaskIdEq(sleepTaskInfo2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_KILLED))))
.InSequence(sleepTask2)
.WillOnce(
@@ -4235,7 +4235,7 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorTest, ROOT_LaunchGroupFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(failingTaskInfo),
+ TaskStatusUpdateTaskIdEq(failingTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(failingTask)
.WillOnce(
@@ -4246,7 +4246,7 @@ TEST_P_TEMP_DISABLED_ON_WINDOWS(DefaultExecutorTest, ROOT_LaunchGroupFailure)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(failingTaskInfo),
+ TaskStatusUpdateTaskIdEq(failingTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_FAILED))))
.InSequence(failingTask)
.WillOnce(
diff --git a/src/tests/gc_tests.cpp b/src/tests/gc_tests.cpp
index a583f1d..2ea4bcb 100644
--- a/src/tests/gc_tests.cpp
+++ b/src/tests/gc_tests.cpp
@@ -734,7 +734,7 @@ TEST_F(GarbageCollectorIntegrationTest, LongLivedDefaultExecutor)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(longLivedTaskInfo),
+ TaskStatusUpdateTaskIdEq(longLivedTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(longTask)
.WillOnce(DoAll(
@@ -744,7 +744,7 @@ TEST_F(GarbageCollectorIntegrationTest, LongLivedDefaultExecutor)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(longLivedTaskInfo),
+ TaskStatusUpdateTaskIdEq(longLivedTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(longTask)
.WillOnce(DoAll(
@@ -759,7 +759,7 @@ TEST_F(GarbageCollectorIntegrationTest, LongLivedDefaultExecutor)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(shortLivedTaskInfo),
+ TaskStatusUpdateTaskIdEq(shortLivedTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(shortTask)
.WillOnce(DoAll(
@@ -769,7 +769,7 @@ TEST_F(GarbageCollectorIntegrationTest, LongLivedDefaultExecutor)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(shortLivedTaskInfo),
+ TaskStatusUpdateTaskIdEq(shortLivedTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(shortTask)
.WillOnce(DoAll(
@@ -779,7 +779,7 @@ TEST_F(GarbageCollectorIntegrationTest, LongLivedDefaultExecutor)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(shortLivedTaskInfo),
+ TaskStatusUpdateTaskIdEq(shortLivedTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_FINISHED))))
.InSequence(shortTask)
.WillOnce(DoAll(
@@ -988,7 +988,7 @@ TEST_F(GarbageCollectorIntegrationTest, LongLivedDefaultExecutorRestart)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(longLivedTaskInfo),
+ TaskStatusUpdateTaskIdEq(longLivedTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(longTask)
.WillOnce(DoAll(
@@ -998,7 +998,7 @@ TEST_F(GarbageCollectorIntegrationTest, LongLivedDefaultExecutorRestart)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(longLivedTaskInfo),
+ TaskStatusUpdateTaskIdEq(longLivedTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(longTask)
.WillOnce(DoAll(
@@ -1013,7 +1013,7 @@ TEST_F(GarbageCollectorIntegrationTest, LongLivedDefaultExecutorRestart)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(shortLivedTaskInfo),
+ TaskStatusUpdateTaskIdEq(shortLivedTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(shortTask)
.WillOnce(DoAll(
@@ -1023,7 +1023,7 @@ TEST_F(GarbageCollectorIntegrationTest, LongLivedDefaultExecutorRestart)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(shortLivedTaskInfo),
+ TaskStatusUpdateTaskIdEq(shortLivedTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(shortTask)
.WillOnce(DoAll(
@@ -1033,7 +1033,7 @@ TEST_F(GarbageCollectorIntegrationTest, LongLivedDefaultExecutorRestart)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(shortLivedTaskInfo),
+ TaskStatusUpdateTaskIdEq(shortLivedTaskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_FINISHED))))
.InSequence(shortTask)
.WillOnce(DoAll(
diff --git a/src/tests/master_tests.cpp b/src/tests/master_tests.cpp
index 964d935..097f1b7 100644
--- a/src/tests/master_tests.cpp
+++ b/src/tests/master_tests.cpp
@@ -6317,7 +6317,7 @@ TEST_F(MasterTest, MasterFailoverLongLivedExecutor)
.WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));
Future<TaskStatus> status1;
- EXPECT_CALL(sched, statusUpdate(&driver, TaskStatusTaskIdEq(task1)))
+ EXPECT_CALL(sched, statusUpdate(&driver, TaskStatusTaskIdEq(task1.task_id())))
.WillOnce(FutureArg<1>(&status1))
.WillRepeatedly(Return());
@@ -6361,7 +6361,7 @@ TEST_F(MasterTest, MasterFailoverLongLivedExecutor)
task2.mutable_task_id()->set_value("2");
Future<TaskStatus> status2;
- EXPECT_CALL(sched, statusUpdate(&driver, TaskStatusTaskIdEq(task2)))
+ EXPECT_CALL(sched, statusUpdate(&driver, TaskStatusTaskIdEq(task2.task_id())))
.WillOnce(FutureArg<1>(&status2))
.WillRepeatedly(Return());
@@ -9903,7 +9903,7 @@ TEST_F(MasterTest, TaskStateMetrics)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(task1),
+ TaskStatusUpdateTaskIdEq(task1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(taskSequence1)
.WillOnce(v1::scheduler::SendAcknowledge(frameworkId, agentId));
@@ -9911,7 +9911,7 @@ TEST_F(MasterTest, TaskStateMetrics)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(task1),
+ TaskStatusUpdateTaskIdEq(task1.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(taskSequence1)
.WillOnce(DoAll(
@@ -9954,7 +9954,7 @@ TEST_F(MasterTest, TaskStateMetrics)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(task2),
+ TaskStatusUpdateTaskIdEq(task2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(taskSequence2)
.WillOnce(v1::scheduler::SendAcknowledge(frameworkId, agentId));
@@ -9962,7 +9962,7 @@ TEST_F(MasterTest, TaskStateMetrics)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(task2),
+ TaskStatusUpdateTaskIdEq(task2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(taskSequence2)
.WillOnce(v1::scheduler::SendAcknowledge(frameworkId, agentId));
@@ -9970,7 +9970,7 @@ TEST_F(MasterTest, TaskStateMetrics)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(task2),
+ TaskStatusUpdateTaskIdEq(task2.task_id()),
TaskStatusUpdateStateEq(v1::TASK_FINISHED))))
.InSequence(taskSequence2)
.WillOnce(FutureArg<1>(&finishedUpdate))
@@ -10281,7 +10281,7 @@ TEST_P(MasterTestPrePostReservationRefinement, LaunchGroup)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo),
+ TaskStatusUpdateTaskIdEq(taskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_STARTING))))
.InSequence(updateSequence)
.WillOnce(DoAll(
@@ -10291,7 +10291,7 @@ TEST_P(MasterTestPrePostReservationRefinement, LaunchGroup)
EXPECT_CALL(
*scheduler,
update(_, AllOf(
- TaskStatusUpdateTaskIdEq(taskInfo),
+ TaskStatusUpdateTaskIdEq(taskInfo.task_id()),
TaskStatusUpdateStateEq(v1::TASK_RUNNING))))
.InSequence(updateSequence)
.WillOnce(FutureArg<1>(&runningUpdate));
diff --git a/src/tests/mesos.hpp b/src/tests/mesos.hpp
index e70e0e1..605a69f 100644
--- a/src/tests/mesos.hpp
+++ b/src/tests/mesos.hpp
@@ -3668,9 +3668,9 @@ MATCHER_P(OffersHaveResource, resource, "")
// This matcher is used to match the task id of a `TaskStatus` message.
-MATCHER_P(TaskStatusTaskIdEq, taskInfo, "")
+MATCHER_P(TaskStatusTaskIdEq, taskId, "")
{
- return arg.task_id() == taskInfo.task_id();
+ return arg.task_id() == taskId;
}
@@ -3683,9 +3683,9 @@ MATCHER_P(TaskStatusStateEq, taskState, "")
// This matcher is used to match the task id of an `Event.update.status`
// message.
-MATCHER_P(TaskStatusUpdateTaskIdEq, taskInfo, "")
+MATCHER_P(TaskStatusUpdateTaskIdEq, taskId, "")
{
- return arg.status().task_id() == taskInfo.task_id();
+ return arg.status().task_id() == taskId;
}
diff --git a/src/tests/partition_tests.cpp b/src/tests/partition_tests.cpp
index 8148aff..ef8080a 100644
--- a/src/tests/partition_tests.cpp
+++ b/src/tests/partition_tests.cpp
@@ -2794,7 +2794,7 @@ TEST_F(PartitionTest, AgentWithTerminalTaskPartitioned)
EXPECT_CALL(
sched,
statusUpdate(&driver, AllOf(
- TaskStatusTaskIdEq(task),
+ TaskStatusTaskIdEq(task.task_id()),
TaskStatusStateEq(TASK_STARTING))))
.InSequence(taskSequence)
.WillOnce(FutureArg<1>(&starting));
@@ -2802,7 +2802,7 @@ TEST_F(PartitionTest, AgentWithTerminalTaskPartitioned)
EXPECT_CALL(
sched,
statusUpdate(&driver, AllOf(
- TaskStatusTaskIdEq(task),
+ TaskStatusTaskIdEq(task.task_id()),
TaskStatusStateEq(TASK_RUNNING))))
.InSequence(taskSequence)
.WillOnce(FutureArg<1>(&running));
@@ -2810,7 +2810,7 @@ TEST_F(PartitionTest, AgentWithTerminalTaskPartitioned)
EXPECT_CALL(
sched,
statusUpdate(&driver, AllOf(
- TaskStatusTaskIdEq(task),
+ TaskStatusTaskIdEq(task.task_id()),
TaskStatusStateEq(TASK_FINISHED))))
.InSequence(taskSequence)
.WillOnce(FutureArg<1>(&finished))
diff --git a/src/tests/slave_tests.cpp b/src/tests/slave_tests.cpp
index 50882a5..c203597 100644
--- a/src/tests/slave_tests.cpp
+++ b/src/tests/slave_tests.cpp
@@ -4956,14 +4956,16 @@ TEST_F(SlaveTest, LaunchTasksReorderUnscheduleGC)
Future<v1::scheduler::Event::Update> taskStarting1, taskStarting2;
Future<v1::scheduler::Event::Update> taskRunning1, taskRunning2;
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo1)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo1.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&taskStarting1),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
.WillOnce(DoAll(
FutureArg<1>(&taskRunning1),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo2)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo2.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&taskStarting2),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
@@ -5092,14 +5094,16 @@ TEST_F(SlaveTest, LaunchTasksReorderTaskAuthorization)
Future<v1::scheduler::Event::Update> taskStarting1, taskStarting2;
Future<v1::scheduler::Event::Update> taskRunning1, taskRunning2;
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo1)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo1.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&taskStarting1),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
.WillOnce(DoAll(
FutureArg<1>(&taskRunning1),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo2)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo2.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&taskStarting2),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
@@ -5229,15 +5233,18 @@ TEST_F(SlaveTest, LaunchTaskGroupsUsingSameExecutorKillFirstTaskGroup)
Future<v1::scheduler::Event::Update> task1Killed;
Future<v1::scheduler::Event::Update> task2Lost;
Future<v1::scheduler::Event::Update> task3Lost;
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo1)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo1.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&task1Killed),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo2)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo2.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&task2Lost),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo3)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo3.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&task3Lost),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
@@ -5455,14 +5462,16 @@ TEST_F(SlaveTest, LaunchTaskGroupsUsingSameExecutorKillLaterTaskGroup)
Future<v1::scheduler::Event::Update> task1Starting, task1Running;
Future<v1::scheduler::Event::Update> task2Killed;
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo1)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo1.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&task1Starting),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
.WillOnce(DoAll(
FutureArg<1>(&task1Running),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo2)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo2.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&task2Killed),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
@@ -5645,14 +5654,16 @@ TEST_F(SlaveTest, ShutdownExecutorWhileTaskLaunching)
Future<v1::scheduler::Event::Update> task1Starting, task1Running;
Future<v1::scheduler::Event::Update> task2Lost;
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo1)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo1.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&task1Starting),
v1::scheduler::SendAcknowledge(frameworkId, agentId)))
.WillOnce(DoAll(
FutureArg<1>(&task1Running),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo2)))
+ EXPECT_CALL(
+ *scheduler, update(_, TaskStatusUpdateTaskIdEq(taskInfo2.task_id())))
.WillOnce(DoAll(
FutureArg<1>(&task2Lost),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
[mesos] 01/04: Added a helper to devolve offer operations.
Posted by ch...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
chhsiao pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mesos.git
commit 365e06c91dc57c04c995c49f19a37f56c94dfdf7
Author: Chun-Hung Hsiao <ch...@mesosphere.io>
AuthorDate: Tue May 21 21:02:06 2019 -0700
Added a helper to devolve offer operations.
Review: https://reviews.apache.org/r/70683
---
src/internal/devolve.cpp | 6 ++++++
src/internal/devolve.hpp | 1 +
2 files changed, 7 insertions(+)
diff --git a/src/internal/devolve.cpp b/src/internal/devolve.cpp
index e23ed3c..1d300b4 100644
--- a/src/internal/devolve.cpp
+++ b/src/internal/devolve.cpp
@@ -104,6 +104,12 @@ Offer devolve(const v1::Offer& offer)
}
+Offer::Operation devolve(const v1::Offer::Operation& operation)
+{
+ return devolve<Offer::Operation>(operation);
+}
+
+
OperationStatus devolve(const v1::OperationStatus& status)
{
OperationStatus _status = devolve<OperationStatus>(status);
diff --git a/src/internal/devolve.hpp b/src/internal/devolve.hpp
index a1f8d8d..fefe86e 100644
--- a/src/internal/devolve.hpp
+++ b/src/internal/devolve.hpp
@@ -60,6 +60,7 @@ FrameworkInfo devolve(const v1::FrameworkInfo& frameworkInfo);
HealthCheck devolve(const v1::HealthCheck& check);
InverseOffer devolve(const v1::InverseOffer& inverseOffer);
Offer devolve(const v1::Offer& offer);
+Offer::Operation devolve(const v1::Offer::Operation& operation);
OperationStatus devolve(const v1::OperationStatus& status);
Resource devolve(const v1::Resource& resource);
ResourceProviderID devolve(const v1::ResourceProviderID& resourceProviderId);
[mesos] 03/04: Removed the `TaskStatusUpdateIsTerminalState`
matcher.
Posted by ch...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
chhsiao pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mesos.git
commit 3747331d05b4372ed57696941a19d6f41cd7670d
Author: Chun-Hung Hsiao <ch...@mesosphere.io>
AuthorDate: Wed May 15 16:13:19 2019 -0700
Removed the `TaskStatusUpdateIsTerminalState` matcher.
The `TaskStatusUpdateIsTerminalState` test matcher does not handle both
v0 and v1 status updates. Since introducing such a matcher in the
`v1::scheduler` namespace is inconsistent and it is not hard to use the
built-in `Truly` matcher to implement the same functionality, this
matcher is removed for now.
Review: https://reviews.apache.org/r/70685
---
src/tests/containerizer/nvidia_gpu_isolator_tests.cpp | 17 ++++++++++++++---
src/tests/mesos.hpp | 10 ----------
2 files changed, 14 insertions(+), 13 deletions(-)
diff --git a/src/tests/containerizer/nvidia_gpu_isolator_tests.cpp b/src/tests/containerizer/nvidia_gpu_isolator_tests.cpp
index 5e753e7..fe82c82 100644
--- a/src/tests/containerizer/nvidia_gpu_isolator_tests.cpp
+++ b/src/tests/containerizer/nvidia_gpu_isolator_tests.cpp
@@ -32,6 +32,8 @@
#include <stout/jsonify.hpp>
#include <stout/os/exists.hpp>
+#include "common/protobuf_utils.hpp"
+
#include "docker/docker.hpp"
#include "master/master.hpp"
@@ -73,6 +75,7 @@ using testing::AtMost;
using testing::DoAll;
using testing::Eq;
using testing::Return;
+using testing::Truly;
namespace mesos {
namespace internal {
@@ -307,7 +310,9 @@ TEST_F(NvidiaGpuTest, ROOT_INTERNET_CURL_CGROUPS_NVIDIA_GPU_NvidiaDockerImage)
Future<v1::scheduler::Event::Update> task1Finished;
EXPECT_CALL(*scheduler, update(_, AllOf(
TaskStatusUpdateTaskIdEq(task1.task_id()),
- TaskStatusUpdateIsTerminalState())))
+ Truly([](const v1::scheduler::Event::Update& update) {
+ return protobuf::isTerminalState(devolve(update.status()).state());
+ }))))
.WillOnce(DoAll(
FutureArg<1>(&task1Finished),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
@@ -315,7 +320,9 @@ TEST_F(NvidiaGpuTest, ROOT_INTERNET_CURL_CGROUPS_NVIDIA_GPU_NvidiaDockerImage)
Future<v1::scheduler::Event::Update> task2Failed;
EXPECT_CALL(*scheduler, update(_, AllOf(
TaskStatusUpdateTaskIdEq(task2.task_id()),
- TaskStatusUpdateIsTerminalState())))
+ Truly([](const v1::scheduler::Event::Update& update) {
+ return protobuf::isTerminalState(devolve(update.status()).state());
+ }))))
.WillOnce(DoAll(
FutureArg<1>(&task2Failed),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
@@ -429,7 +436,11 @@ TEST_F(NvidiaGpuTest, ROOT_INTERNET_CURL_CGROUPS_NVIDIA_GPU_TensorflowGpuImage)
.WillOnce(v1::scheduler::SendAcknowledge(frameworkId, agentId));
Future<v1::scheduler::Event::Update> terminalStatusUpdate;
- EXPECT_CALL(*scheduler, update(_, TaskStatusUpdateIsTerminalState()))
+ EXPECT_CALL(*scheduler, update(
+ _,
+ Truly([](const v1::scheduler::Event::Update& update) {
+ return protobuf::isTerminalState(devolve(update.status()).state());
+ })))
.WillOnce(DoAll(
FutureArg<1>(&terminalStatusUpdate),
v1::scheduler::SendAcknowledge(frameworkId, agentId)));
diff --git a/src/tests/mesos.hpp b/src/tests/mesos.hpp
index 605a69f..c886789 100644
--- a/src/tests/mesos.hpp
+++ b/src/tests/mesos.hpp
@@ -73,8 +73,6 @@
#include "common/http.hpp"
#include "common/protobuf_utils.hpp"
-#include "internal/devolve.hpp"
-
#include "messages/messages.hpp" // For google::protobuf::Message.
#include "master/master.hpp"
@@ -3697,14 +3695,6 @@ MATCHER_P(TaskStatusUpdateStateEq, taskState, "")
}
-// This matcher is used to match an `Event.update.status` message whose state is
-// terminal.
-MATCHER(TaskStatusUpdateIsTerminalState, "")
-{
- return protobuf::isTerminalState(devolve(arg.status()).state());
-}
-
-
// This matcher is used to match the task id of
// `authorization::Request.Object.TaskInfo`.
MATCHER_P(AuthorizationRequestHasTaskID, taskId, "")