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 2b1336d307380768176db072c1dcb70bcbb2f891 Author: Chun-Hung Hsiao <chhs...@mesosphere.io> AuthorDate: Fri Mar 29 16:33:18 2019 -0700 Added the `mesos::csi::v1::Client` wrapper. The differences between CSI v0 and v1 client wrappers are summarized as follows: * Added snapshot related functions: `createSnapshot`, `deleteSnapshot` and `listSnapshots`. * Added volume expansion related functions: `controllerExpandVolume` and `nodeExpandVolume`. * Added volume statistics related functions: `nodeGetVolumeStats`. * Replaced `nodeGetId` with `nodeGetInfo`. Review: https://reviews.apache.org/r/70362 --- src/CMakeLists.txt | 1 + src/Makefile.am | 2 + src/csi/v1_client.cpp | 282 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/csi/v1_client.hpp | 119 +++++++++++++++++++++ 4 files changed, 404 insertions(+) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 0512044..51c7a04 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -242,6 +242,7 @@ set(CSI_SRC csi/v0_utils.cpp csi/v0_volume_manager.cpp csi/v1.cpp + csi/v1_client.cpp csi/volume_manager.cpp) set(DOCKER_SRC diff --git a/src/Makefile.am b/src/Makefile.am index 2f25a84..9c0180f 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -1596,6 +1596,8 @@ libcsi_la_SOURCES = \ csi/v0_volume_manager.hpp \ csi/v0_volume_manager_process.hpp \ csi/v1.cpp \ + csi/v1_client.cpp \ + csi/v1_client.hpp \ csi/volume_manager.cpp \ csi/volume_manager.hpp diff --git a/src/csi/v1_client.cpp b/src/csi/v1_client.cpp new file mode 100644 index 0000000..a19eb55 --- /dev/null +++ b/src/csi/v1_client.cpp @@ -0,0 +1,282 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "csi/v1_client.hpp" + +#include <utility> + +using process::Future; + +using process::grpc::client::CallOptions; + +namespace mesos { +namespace csi { +namespace v1 { + +Future<RPCResult<GetPluginInfoResponse>> +Client::getPluginInfo(GetPluginInfoRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Identity, GetPluginInfo), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<GetPluginCapabilitiesResponse>> +Client::getPluginCapabilities(GetPluginCapabilitiesRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Identity, GetPluginCapabilities), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<ProbeResponse>> Client::probe(ProbeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Identity, Probe), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<CreateVolumeResponse>> +Client::createVolume(CreateVolumeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, CreateVolume), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<DeleteVolumeResponse>> +Client::deleteVolume(DeleteVolumeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, DeleteVolume), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<ControllerPublishVolumeResponse>> +Client::controllerPublishVolume(ControllerPublishVolumeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, ControllerPublishVolume), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<ControllerUnpublishVolumeResponse>> +Client::controllerUnpublishVolume(ControllerUnpublishVolumeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, ControllerUnpublishVolume), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<ValidateVolumeCapabilitiesResponse>> +Client::validateVolumeCapabilities(ValidateVolumeCapabilitiesRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, ValidateVolumeCapabilities), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<ListVolumesResponse>> +Client::listVolumes(ListVolumesRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, ListVolumes), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<GetCapacityResponse>> +Client::getCapacity(GetCapacityRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, GetCapacity), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<ControllerGetCapabilitiesResponse>> +Client::controllerGetCapabilities(ControllerGetCapabilitiesRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, ControllerGetCapabilities), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<CreateSnapshotResponse>> +Client::createSnapshot(CreateSnapshotRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, CreateSnapshot), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<DeleteSnapshotResponse>> +Client::deleteSnapshot(DeleteSnapshotRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, DeleteSnapshot), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<ListSnapshotsResponse>> +Client::listSnapshots(ListSnapshotsRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, ListSnapshots), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<ControllerExpandVolumeResponse>> +Client::controllerExpandVolume(ControllerExpandVolumeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Controller, ControllerExpandVolume), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<NodeStageVolumeResponse>> +Client::nodeStageVolume(NodeStageVolumeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Node, NodeStageVolume), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<NodeUnstageVolumeResponse>> +Client::nodeUnstageVolume(NodeUnstageVolumeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Node, NodeUnstageVolume), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<NodePublishVolumeResponse>> +Client::nodePublishVolume(NodePublishVolumeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Node, NodePublishVolume), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<NodeUnpublishVolumeResponse>> +Client::nodeUnpublishVolume(NodeUnpublishVolumeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Node, NodeUnpublishVolume), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<NodeGetVolumeStatsResponse>> +Client::nodeGetVolumeStats(NodeGetVolumeStatsRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Node, NodeGetVolumeStats), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<NodeExpandVolumeResponse>> +Client::nodeExpandVolume(NodeExpandVolumeRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Node, NodeExpandVolume), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<NodeGetCapabilitiesResponse>> +Client::nodeGetCapabilities(NodeGetCapabilitiesRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Node, NodeGetCapabilities), + std::move(request), + CallOptions()); +} + + +Future<RPCResult<NodeGetInfoResponse>> +Client::nodeGetInfo(NodeGetInfoRequest request) +{ + return runtime.call( + connection, + GRPC_CLIENT_METHOD(Node, NodeGetInfo), + std::move(request), + CallOptions()); +} + +} // namespace v1 { +} // namespace csi { +} // namespace mesos { diff --git a/src/csi/v1_client.hpp b/src/csi/v1_client.hpp new file mode 100644 index 0000000..992276a --- /dev/null +++ b/src/csi/v1_client.hpp @@ -0,0 +1,119 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef __CSI_V1_CLIENT_HPP__ +#define __CSI_V1_CLIENT_HPP__ + +#include <mesos/csi/v1.hpp> + +#include <process/future.hpp> +#include <process/grpc.hpp> + +#include <stout/try.hpp> + +namespace mesos { +namespace csi { +namespace v1 { + +template <typename Response> +using RPCResult = Try<Response, process::grpc::StatusError>; + + +class Client +{ +public: + Client(const process::grpc::client::Connection& _connection, + const process::grpc::client::Runtime& _runtime) + : connection(_connection), runtime(_runtime) {} + + process::Future<RPCResult<GetPluginInfoResponse>> + getPluginInfo(GetPluginInfoRequest request); + + process::Future<RPCResult<GetPluginCapabilitiesResponse>> + getPluginCapabilities(GetPluginCapabilitiesRequest request); + + process::Future<RPCResult<ProbeResponse>> probe(ProbeRequest request); + + process::Future<RPCResult<CreateVolumeResponse>> + createVolume(CreateVolumeRequest request); + + process::Future<RPCResult<DeleteVolumeResponse>> + deleteVolume(DeleteVolumeRequest request); + + process::Future<RPCResult<ControllerPublishVolumeResponse>> + controllerPublishVolume(ControllerPublishVolumeRequest request); + + process::Future<RPCResult<ControllerUnpublishVolumeResponse>> + controllerUnpublishVolume(ControllerUnpublishVolumeRequest request); + + process::Future<RPCResult<ValidateVolumeCapabilitiesResponse>> + validateVolumeCapabilities(ValidateVolumeCapabilitiesRequest request); + + process::Future<RPCResult<ListVolumesResponse>> + listVolumes(ListVolumesRequest request); + + process::Future<RPCResult<GetCapacityResponse>> + getCapacity(GetCapacityRequest request); + + process::Future<RPCResult<ControllerGetCapabilitiesResponse>> + controllerGetCapabilities(ControllerGetCapabilitiesRequest request); + + process::Future<RPCResult<CreateSnapshotResponse>> + createSnapshot(CreateSnapshotRequest request); + + process::Future<RPCResult<DeleteSnapshotResponse>> + deleteSnapshot(DeleteSnapshotRequest request); + + process::Future<RPCResult<ListSnapshotsResponse>> + listSnapshots(ListSnapshotsRequest request); + + process::Future<RPCResult<ControllerExpandVolumeResponse>> + controllerExpandVolume(ControllerExpandVolumeRequest request); + + process::Future<RPCResult<NodeStageVolumeResponse>> + nodeStageVolume(NodeStageVolumeRequest request); + + process::Future<RPCResult<NodeUnstageVolumeResponse>> + nodeUnstageVolume(NodeUnstageVolumeRequest request); + + process::Future<RPCResult<NodePublishVolumeResponse>> + nodePublishVolume(NodePublishVolumeRequest request); + + process::Future<RPCResult<NodeUnpublishVolumeResponse>> + nodeUnpublishVolume(NodeUnpublishVolumeRequest request); + + process::Future<RPCResult<NodeGetVolumeStatsResponse>> + nodeGetVolumeStats(NodeGetVolumeStatsRequest request); + + process::Future<RPCResult<NodeExpandVolumeResponse>> + nodeExpandVolume(NodeExpandVolumeRequest request); + + process::Future<RPCResult<NodeGetCapabilitiesResponse>> + nodeGetCapabilities(NodeGetCapabilitiesRequest request); + + process::Future<RPCResult<NodeGetInfoResponse>> + nodeGetInfo(NodeGetInfoRequest request); + +private: + process::grpc::client::Connection connection; + process::grpc::client::Runtime runtime; +}; + +} // namespace v1 { +} // namespace csi { +} // namespace mesos { + +#endif // __CSI_V1_CLIENT_HPP__