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/04/05 06:34:05 UTC
[mesos] 03/04: Added the `mesos::csi::v1::Client` wrapper.
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 <ch...@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__