fix: generate cpp grpc services (#64)
This commit is contained in:
Lei, HUANG
@@ -0,0 +1,27 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/column.proto
|
||||
|
||||
#include "greptime/v1/column.pb.h"
|
||||
#include "greptime/v1/column.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/column.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fcolumn_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fcolumn_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/column.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fcolumn_2eproto__INCLUDED
|
||||
@@ -0,0 +1,27 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/common.proto
|
||||
|
||||
#include "greptime/v1/common.pb.h"
|
||||
#include "greptime/v1/common.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/common.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fcommon_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fcommon_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/common.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fcommon_2eproto__INCLUDED
|
||||
@@ -0,0 +1,123 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/database.proto
|
||||
|
||||
#include "greptime/v1/database.pb.h"
|
||||
#include "greptime/v1/database.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
static const char* GreptimeDatabase_method_names[] = {
|
||||
"/greptime.v1.GreptimeDatabase/Handle",
|
||||
"/greptime.v1.GreptimeDatabase/HandleRequests",
|
||||
};
|
||||
|
||||
std::unique_ptr< GreptimeDatabase::Stub> GreptimeDatabase::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
|
||||
(void)options;
|
||||
std::unique_ptr< GreptimeDatabase::Stub> stub(new GreptimeDatabase::Stub(channel, options));
|
||||
return stub;
|
||||
}
|
||||
|
||||
GreptimeDatabase::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
|
||||
: channel_(channel), rpcmethod_Handle_(GreptimeDatabase_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_HandleRequests_(GreptimeDatabase_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel)
|
||||
{}
|
||||
|
||||
::grpc::Status GreptimeDatabase::Stub::Handle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::greptime::v1::GreptimeResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::GreptimeRequest, ::greptime::v1::GreptimeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Handle_, context, request, response);
|
||||
}
|
||||
|
||||
void GreptimeDatabase::Stub::async::Handle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest* request, ::greptime::v1::GreptimeResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::GreptimeRequest, ::greptime::v1::GreptimeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Handle_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void GreptimeDatabase::Stub::async::Handle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest* request, ::greptime::v1::GreptimeResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Handle_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::GreptimeResponse>* GreptimeDatabase::Stub::PrepareAsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::GreptimeResponse, ::greptime::v1::GreptimeRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Handle_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::GreptimeResponse>* GreptimeDatabase::Stub::AsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncHandleRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::ClientWriter< ::greptime::v1::GreptimeRequest>* GreptimeDatabase::Stub::HandleRequestsRaw(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response) {
|
||||
return ::grpc::internal::ClientWriterFactory< ::greptime::v1::GreptimeRequest>::Create(channel_.get(), rpcmethod_HandleRequests_, context, response);
|
||||
}
|
||||
|
||||
void GreptimeDatabase::Stub::async::HandleRequests(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::ClientWriteReactor< ::greptime::v1::GreptimeRequest>* reactor) {
|
||||
::grpc::internal::ClientCallbackWriterFactory< ::greptime::v1::GreptimeRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_HandleRequests_, context, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncWriter< ::greptime::v1::GreptimeRequest>* GreptimeDatabase::Stub::AsyncHandleRequestsRaw(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::CompletionQueue* cq, void* tag) {
|
||||
return ::grpc::internal::ClientAsyncWriterFactory< ::greptime::v1::GreptimeRequest>::Create(channel_.get(), cq, rpcmethod_HandleRequests_, context, response, true, tag);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncWriter< ::greptime::v1::GreptimeRequest>* GreptimeDatabase::Stub::PrepareAsyncHandleRequestsRaw(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncWriterFactory< ::greptime::v1::GreptimeRequest>::Create(channel_.get(), cq, rpcmethod_HandleRequests_, context, response, false, nullptr);
|
||||
}
|
||||
|
||||
GreptimeDatabase::Service::Service() {
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
GreptimeDatabase_method_names[0],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< GreptimeDatabase::Service, ::greptime::v1::GreptimeRequest, ::greptime::v1::GreptimeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](GreptimeDatabase::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::GreptimeRequest* req,
|
||||
::greptime::v1::GreptimeResponse* resp) {
|
||||
return service->Handle(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
GreptimeDatabase_method_names[1],
|
||||
::grpc::internal::RpcMethod::CLIENT_STREAMING,
|
||||
new ::grpc::internal::ClientStreamingHandler< GreptimeDatabase::Service, ::greptime::v1::GreptimeRequest, ::greptime::v1::GreptimeResponse>(
|
||||
[](GreptimeDatabase::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
::grpc::ServerReader<::greptime::v1::GreptimeRequest>* reader,
|
||||
::greptime::v1::GreptimeResponse* resp) {
|
||||
return service->HandleRequests(ctx, reader, resp);
|
||||
}, this)));
|
||||
}
|
||||
|
||||
GreptimeDatabase::Service::~Service() {
|
||||
}
|
||||
|
||||
::grpc::Status GreptimeDatabase::Service::Handle(::grpc::ServerContext* context, const ::greptime::v1::GreptimeRequest* request, ::greptime::v1::GreptimeResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status GreptimeDatabase::Service::HandleRequests(::grpc::ServerContext* context, ::grpc::ServerReader< ::greptime::v1::GreptimeRequest>* reader, ::greptime::v1::GreptimeResponse* response) {
|
||||
(void) context;
|
||||
(void) reader;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
|
||||
@@ -0,0 +1,386 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/database.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fdatabase_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fdatabase_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/database.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
class GreptimeDatabase final {
|
||||
public:
|
||||
static constexpr char const* service_full_name() {
|
||||
return "greptime.v1.GreptimeDatabase";
|
||||
}
|
||||
class StubInterface {
|
||||
public:
|
||||
virtual ~StubInterface() {}
|
||||
virtual ::grpc::Status Handle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::greptime::v1::GreptimeResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::GreptimeResponse>> AsyncHandle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::GreptimeResponse>>(AsyncHandleRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::GreptimeResponse>> PrepareAsyncHandle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::GreptimeResponse>>(PrepareAsyncHandleRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientWriterInterface< ::greptime::v1::GreptimeRequest>> HandleRequests(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response) {
|
||||
return std::unique_ptr< ::grpc::ClientWriterInterface< ::greptime::v1::GreptimeRequest>>(HandleRequestsRaw(context, response));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::greptime::v1::GreptimeRequest>> AsyncHandleRequests(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::CompletionQueue* cq, void* tag) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::greptime::v1::GreptimeRequest>>(AsyncHandleRequestsRaw(context, response, cq, tag));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::greptime::v1::GreptimeRequest>> PrepareAsyncHandleRequests(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::greptime::v1::GreptimeRequest>>(PrepareAsyncHandleRequestsRaw(context, response, cq));
|
||||
}
|
||||
class async_interface {
|
||||
public:
|
||||
virtual ~async_interface() {}
|
||||
virtual void Handle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest* request, ::greptime::v1::GreptimeResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void Handle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest* request, ::greptime::v1::GreptimeResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
virtual void HandleRequests(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::ClientWriteReactor< ::greptime::v1::GreptimeRequest>* reactor) = 0;
|
||||
};
|
||||
typedef class async_interface experimental_async_interface;
|
||||
virtual class async_interface* async() { return nullptr; }
|
||||
class async_interface* experimental_async() { return async(); }
|
||||
private:
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::GreptimeResponse>* AsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::GreptimeResponse>* PrepareAsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientWriterInterface< ::greptime::v1::GreptimeRequest>* HandleRequestsRaw(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response) = 0;
|
||||
virtual ::grpc::ClientAsyncWriterInterface< ::greptime::v1::GreptimeRequest>* AsyncHandleRequestsRaw(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::CompletionQueue* cq, void* tag) = 0;
|
||||
virtual ::grpc::ClientAsyncWriterInterface< ::greptime::v1::GreptimeRequest>* PrepareAsyncHandleRequestsRaw(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::CompletionQueue* cq) = 0;
|
||||
};
|
||||
class Stub final : public StubInterface {
|
||||
public:
|
||||
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
::grpc::Status Handle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::greptime::v1::GreptimeResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::GreptimeResponse>> AsyncHandle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::GreptimeResponse>>(AsyncHandleRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::GreptimeResponse>> PrepareAsyncHandle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::GreptimeResponse>>(PrepareAsyncHandleRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientWriter< ::greptime::v1::GreptimeRequest>> HandleRequests(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response) {
|
||||
return std::unique_ptr< ::grpc::ClientWriter< ::greptime::v1::GreptimeRequest>>(HandleRequestsRaw(context, response));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncWriter< ::greptime::v1::GreptimeRequest>> AsyncHandleRequests(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::CompletionQueue* cq, void* tag) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncWriter< ::greptime::v1::GreptimeRequest>>(AsyncHandleRequestsRaw(context, response, cq, tag));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncWriter< ::greptime::v1::GreptimeRequest>> PrepareAsyncHandleRequests(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncWriter< ::greptime::v1::GreptimeRequest>>(PrepareAsyncHandleRequestsRaw(context, response, cq));
|
||||
}
|
||||
class async final :
|
||||
public StubInterface::async_interface {
|
||||
public:
|
||||
void Handle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest* request, ::greptime::v1::GreptimeResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void Handle(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest* request, ::greptime::v1::GreptimeResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
void HandleRequests(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::ClientWriteReactor< ::greptime::v1::GreptimeRequest>* reactor) override;
|
||||
private:
|
||||
friend class Stub;
|
||||
explicit async(Stub* stub): stub_(stub) { }
|
||||
Stub* stub() { return stub_; }
|
||||
Stub* stub_;
|
||||
};
|
||||
class async* async() override { return &async_stub_; }
|
||||
|
||||
private:
|
||||
std::shared_ptr< ::grpc::ChannelInterface> channel_;
|
||||
class async async_stub_{this};
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::GreptimeResponse>* AsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::GreptimeResponse>* PrepareAsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::GreptimeRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientWriter< ::greptime::v1::GreptimeRequest>* HandleRequestsRaw(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response) override;
|
||||
::grpc::ClientAsyncWriter< ::greptime::v1::GreptimeRequest>* AsyncHandleRequestsRaw(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::CompletionQueue* cq, void* tag) override;
|
||||
::grpc::ClientAsyncWriter< ::greptime::v1::GreptimeRequest>* PrepareAsyncHandleRequestsRaw(::grpc::ClientContext* context, ::greptime::v1::GreptimeResponse* response, ::grpc::CompletionQueue* cq) override;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_Handle_;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_HandleRequests_;
|
||||
};
|
||||
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
|
||||
class Service : public ::grpc::Service {
|
||||
public:
|
||||
Service();
|
||||
virtual ~Service();
|
||||
virtual ::grpc::Status Handle(::grpc::ServerContext* context, const ::greptime::v1::GreptimeRequest* request, ::greptime::v1::GreptimeResponse* response);
|
||||
virtual ::grpc::Status HandleRequests(::grpc::ServerContext* context, ::grpc::ServerReader< ::greptime::v1::GreptimeRequest>* reader, ::greptime::v1::GreptimeResponse* response);
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_Handle() {
|
||||
::grpc::Service::MarkMethodAsync(0);
|
||||
}
|
||||
~WithAsyncMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::GreptimeRequest* /*request*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestHandle(::grpc::ServerContext* context, ::greptime::v1::GreptimeRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::GreptimeResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_HandleRequests : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_HandleRequests() {
|
||||
::grpc::Service::MarkMethodAsync(1);
|
||||
}
|
||||
~WithAsyncMethod_HandleRequests() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status HandleRequests(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::greptime::v1::GreptimeRequest>* /*reader*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestHandleRequests(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::greptime::v1::GreptimeResponse, ::greptime::v1::GreptimeRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
typedef WithAsyncMethod_Handle<WithAsyncMethod_HandleRequests<Service > > AsyncService;
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_Handle() {
|
||||
::grpc::Service::MarkMethodCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::GreptimeRequest, ::greptime::v1::GreptimeResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::GreptimeRequest* request, ::greptime::v1::GreptimeResponse* response) { return this->Handle(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_Handle(
|
||||
::grpc::MessageAllocator< ::greptime::v1::GreptimeRequest, ::greptime::v1::GreptimeResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::GreptimeRequest, ::greptime::v1::GreptimeResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::GreptimeRequest* /*request*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Handle(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::GreptimeRequest* /*request*/, ::greptime::v1::GreptimeResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_HandleRequests : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_HandleRequests() {
|
||||
::grpc::Service::MarkMethodCallback(1,
|
||||
new ::grpc::internal::CallbackClientStreamingHandler< ::greptime::v1::GreptimeRequest, ::greptime::v1::GreptimeResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, ::greptime::v1::GreptimeResponse* response) { return this->HandleRequests(context, response); }));
|
||||
}
|
||||
~WithCallbackMethod_HandleRequests() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status HandleRequests(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::greptime::v1::GreptimeRequest>* /*reader*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerReadReactor< ::greptime::v1::GreptimeRequest>* HandleRequests(
|
||||
::grpc::CallbackServerContext* /*context*/, ::greptime::v1::GreptimeResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
typedef WithCallbackMethod_Handle<WithCallbackMethod_HandleRequests<Service > > CallbackService;
|
||||
typedef CallbackService ExperimentalCallbackService;
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_Handle() {
|
||||
::grpc::Service::MarkMethodGeneric(0);
|
||||
}
|
||||
~WithGenericMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::GreptimeRequest* /*request*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_HandleRequests : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_HandleRequests() {
|
||||
::grpc::Service::MarkMethodGeneric(1);
|
||||
}
|
||||
~WithGenericMethod_HandleRequests() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status HandleRequests(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::greptime::v1::GreptimeRequest>* /*reader*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_Handle() {
|
||||
::grpc::Service::MarkMethodRaw(0);
|
||||
}
|
||||
~WithRawMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::GreptimeRequest* /*request*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestHandle(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_HandleRequests : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_HandleRequests() {
|
||||
::grpc::Service::MarkMethodRaw(1);
|
||||
}
|
||||
~WithRawMethod_HandleRequests() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status HandleRequests(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::greptime::v1::GreptimeRequest>* /*reader*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestHandleRequests(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_Handle() {
|
||||
::grpc::Service::MarkMethodRawCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Handle(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::GreptimeRequest* /*request*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Handle(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_HandleRequests : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_HandleRequests() {
|
||||
::grpc::Service::MarkMethodRawCallback(1,
|
||||
new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->HandleRequests(context, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_HandleRequests() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status HandleRequests(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::greptime::v1::GreptimeRequest>* /*reader*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* HandleRequests(
|
||||
::grpc::CallbackServerContext* /*context*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_Handle() {
|
||||
::grpc::Service::MarkMethodStreamed(0,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::GreptimeRequest, ::greptime::v1::GreptimeResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::GreptimeRequest, ::greptime::v1::GreptimeResponse>* streamer) {
|
||||
return this->StreamedHandle(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::GreptimeRequest* /*request*/, ::greptime::v1::GreptimeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedHandle(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::GreptimeRequest,::greptime::v1::GreptimeResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
typedef WithStreamedUnaryMethod_Handle<Service > StreamedUnaryService;
|
||||
typedef Service SplitStreamedService;
|
||||
typedef WithStreamedUnaryMethod_Handle<Service > StreamedService;
|
||||
};
|
||||
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fdatabase_2eproto__INCLUDED
|
||||
@@ -0,0 +1,27 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/ddl.proto
|
||||
|
||||
#include "greptime/v1/ddl.pb.h"
|
||||
#include "greptime/v1/ddl.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/ddl.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fddl_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fddl_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/ddl.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fddl_2eproto__INCLUDED
|
||||
@@ -0,0 +1,88 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/health.proto
|
||||
|
||||
#include "greptime/v1/health.pb.h"
|
||||
#include "greptime/v1/health.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
static const char* HealthCheck_method_names[] = {
|
||||
"/greptime.v1.HealthCheck/HealthCheck",
|
||||
};
|
||||
|
||||
std::unique_ptr< HealthCheck::Stub> HealthCheck::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
|
||||
(void)options;
|
||||
std::unique_ptr< HealthCheck::Stub> stub(new HealthCheck::Stub(channel, options));
|
||||
return stub;
|
||||
}
|
||||
|
||||
HealthCheck::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
|
||||
: channel_(channel), rpcmethod_HealthCheck_(HealthCheck_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
{}
|
||||
|
||||
::grpc::Status HealthCheck::Stub::HealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::greptime::v1::HealthCheckResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::HealthCheckRequest, ::greptime::v1::HealthCheckResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_HealthCheck_, context, request, response);
|
||||
}
|
||||
|
||||
void HealthCheck::Stub::async::HealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest* request, ::greptime::v1::HealthCheckResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::HealthCheckRequest, ::greptime::v1::HealthCheckResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HealthCheck_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void HealthCheck::Stub::async::HealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest* request, ::greptime::v1::HealthCheckResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HealthCheck_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::HealthCheckResponse>* HealthCheck::Stub::PrepareAsyncHealthCheckRaw(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::HealthCheckResponse, ::greptime::v1::HealthCheckRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_HealthCheck_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::HealthCheckResponse>* HealthCheck::Stub::AsyncHealthCheckRaw(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncHealthCheckRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
HealthCheck::Service::Service() {
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
HealthCheck_method_names[0],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< HealthCheck::Service, ::greptime::v1::HealthCheckRequest, ::greptime::v1::HealthCheckResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](HealthCheck::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::HealthCheckRequest* req,
|
||||
::greptime::v1::HealthCheckResponse* resp) {
|
||||
return service->HealthCheck(ctx, req, resp);
|
||||
}, this)));
|
||||
}
|
||||
|
||||
HealthCheck::Service::~Service() {
|
||||
}
|
||||
|
||||
::grpc::Status HealthCheck::Service::HealthCheck(::grpc::ServerContext* context, const ::greptime::v1::HealthCheckRequest* request, ::greptime::v1::HealthCheckResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
|
||||
@@ -0,0 +1,257 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/health.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fhealth_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fhealth_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/health.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
class HealthCheck final {
|
||||
public:
|
||||
static constexpr char const* service_full_name() {
|
||||
return "greptime.v1.HealthCheck";
|
||||
}
|
||||
class StubInterface {
|
||||
public:
|
||||
virtual ~StubInterface() {}
|
||||
virtual ::grpc::Status HealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::greptime::v1::HealthCheckResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::HealthCheckResponse>> AsyncHealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::HealthCheckResponse>>(AsyncHealthCheckRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::HealthCheckResponse>> PrepareAsyncHealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::HealthCheckResponse>>(PrepareAsyncHealthCheckRaw(context, request, cq));
|
||||
}
|
||||
class async_interface {
|
||||
public:
|
||||
virtual ~async_interface() {}
|
||||
virtual void HealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest* request, ::greptime::v1::HealthCheckResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void HealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest* request, ::greptime::v1::HealthCheckResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
};
|
||||
typedef class async_interface experimental_async_interface;
|
||||
virtual class async_interface* async() { return nullptr; }
|
||||
class async_interface* experimental_async() { return async(); }
|
||||
private:
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::HealthCheckResponse>* AsyncHealthCheckRaw(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::HealthCheckResponse>* PrepareAsyncHealthCheckRaw(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
};
|
||||
class Stub final : public StubInterface {
|
||||
public:
|
||||
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
::grpc::Status HealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::greptime::v1::HealthCheckResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::HealthCheckResponse>> AsyncHealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::HealthCheckResponse>>(AsyncHealthCheckRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::HealthCheckResponse>> PrepareAsyncHealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::HealthCheckResponse>>(PrepareAsyncHealthCheckRaw(context, request, cq));
|
||||
}
|
||||
class async final :
|
||||
public StubInterface::async_interface {
|
||||
public:
|
||||
void HealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest* request, ::greptime::v1::HealthCheckResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void HealthCheck(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest* request, ::greptime::v1::HealthCheckResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
private:
|
||||
friend class Stub;
|
||||
explicit async(Stub* stub): stub_(stub) { }
|
||||
Stub* stub() { return stub_; }
|
||||
Stub* stub_;
|
||||
};
|
||||
class async* async() override { return &async_stub_; }
|
||||
|
||||
private:
|
||||
std::shared_ptr< ::grpc::ChannelInterface> channel_;
|
||||
class async async_stub_{this};
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::HealthCheckResponse>* AsyncHealthCheckRaw(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::HealthCheckResponse>* PrepareAsyncHealthCheckRaw(::grpc::ClientContext* context, const ::greptime::v1::HealthCheckRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_HealthCheck_;
|
||||
};
|
||||
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
|
||||
class Service : public ::grpc::Service {
|
||||
public:
|
||||
Service();
|
||||
virtual ~Service();
|
||||
virtual ::grpc::Status HealthCheck(::grpc::ServerContext* context, const ::greptime::v1::HealthCheckRequest* request, ::greptime::v1::HealthCheckResponse* response);
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_HealthCheck : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_HealthCheck() {
|
||||
::grpc::Service::MarkMethodAsync(0);
|
||||
}
|
||||
~WithAsyncMethod_HealthCheck() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status HealthCheck(::grpc::ServerContext* /*context*/, const ::greptime::v1::HealthCheckRequest* /*request*/, ::greptime::v1::HealthCheckResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestHealthCheck(::grpc::ServerContext* context, ::greptime::v1::HealthCheckRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::HealthCheckResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
typedef WithAsyncMethod_HealthCheck<Service > AsyncService;
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_HealthCheck : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_HealthCheck() {
|
||||
::grpc::Service::MarkMethodCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::HealthCheckRequest, ::greptime::v1::HealthCheckResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::HealthCheckRequest* request, ::greptime::v1::HealthCheckResponse* response) { return this->HealthCheck(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_HealthCheck(
|
||||
::grpc::MessageAllocator< ::greptime::v1::HealthCheckRequest, ::greptime::v1::HealthCheckResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::HealthCheckRequest, ::greptime::v1::HealthCheckResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_HealthCheck() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status HealthCheck(::grpc::ServerContext* /*context*/, const ::greptime::v1::HealthCheckRequest* /*request*/, ::greptime::v1::HealthCheckResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* HealthCheck(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::HealthCheckRequest* /*request*/, ::greptime::v1::HealthCheckResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
typedef WithCallbackMethod_HealthCheck<Service > CallbackService;
|
||||
typedef CallbackService ExperimentalCallbackService;
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_HealthCheck : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_HealthCheck() {
|
||||
::grpc::Service::MarkMethodGeneric(0);
|
||||
}
|
||||
~WithGenericMethod_HealthCheck() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status HealthCheck(::grpc::ServerContext* /*context*/, const ::greptime::v1::HealthCheckRequest* /*request*/, ::greptime::v1::HealthCheckResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_HealthCheck : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_HealthCheck() {
|
||||
::grpc::Service::MarkMethodRaw(0);
|
||||
}
|
||||
~WithRawMethod_HealthCheck() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status HealthCheck(::grpc::ServerContext* /*context*/, const ::greptime::v1::HealthCheckRequest* /*request*/, ::greptime::v1::HealthCheckResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestHealthCheck(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_HealthCheck : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_HealthCheck() {
|
||||
::grpc::Service::MarkMethodRawCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->HealthCheck(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_HealthCheck() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status HealthCheck(::grpc::ServerContext* /*context*/, const ::greptime::v1::HealthCheckRequest* /*request*/, ::greptime::v1::HealthCheckResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* HealthCheck(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_HealthCheck : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_HealthCheck() {
|
||||
::grpc::Service::MarkMethodStreamed(0,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::HealthCheckRequest, ::greptime::v1::HealthCheckResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::HealthCheckRequest, ::greptime::v1::HealthCheckResponse>* streamer) {
|
||||
return this->StreamedHealthCheck(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_HealthCheck() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status HealthCheck(::grpc::ServerContext* /*context*/, const ::greptime::v1::HealthCheckRequest* /*request*/, ::greptime::v1::HealthCheckResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedHealthCheck(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::HealthCheckRequest,::greptime::v1::HealthCheckResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
typedef WithStreamedUnaryMethod_HealthCheck<Service > StreamedUnaryService;
|
||||
typedef Service SplitStreamedService;
|
||||
typedef WithStreamedUnaryMethod_HealthCheck<Service > StreamedService;
|
||||
};
|
||||
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fhealth_2eproto__INCLUDED
|
||||
@@ -0,0 +1,132 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/cluster.proto
|
||||
|
||||
#include "greptime/v1/meta/cluster.pb.h"
|
||||
#include "greptime/v1/meta/cluster.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
static const char* Cluster_method_names[] = {
|
||||
"/greptime.v1.meta.Cluster/BatchGet",
|
||||
"/greptime.v1.meta.Cluster/Range",
|
||||
};
|
||||
|
||||
std::unique_ptr< Cluster::Stub> Cluster::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
|
||||
(void)options;
|
||||
std::unique_ptr< Cluster::Stub> stub(new Cluster::Stub(channel, options));
|
||||
return stub;
|
||||
}
|
||||
|
||||
Cluster::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
|
||||
: channel_(channel), rpcmethod_BatchGet_(Cluster_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_Range_(Cluster_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
{}
|
||||
|
||||
::grpc::Status Cluster::Stub::BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::greptime::v1::meta::BatchGetResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_BatchGet_, context, request, response);
|
||||
}
|
||||
|
||||
void Cluster::Stub::async::BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BatchGet_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Cluster::Stub::async::BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BatchGet_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchGetResponse>* Cluster::Stub::PrepareAsyncBatchGetRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::BatchGetResponse, ::greptime::v1::meta::BatchGetRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_BatchGet_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchGetResponse>* Cluster::Stub::AsyncBatchGetRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncBatchGetRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Cluster::Stub::Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::greptime::v1::meta::RangeResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Range_, context, request, response);
|
||||
}
|
||||
|
||||
void Cluster::Stub::async::Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Range_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Cluster::Stub::async::Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Range_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RangeResponse>* Cluster::Stub::PrepareAsyncRangeRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::RangeResponse, ::greptime::v1::meta::RangeRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Range_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RangeResponse>* Cluster::Stub::AsyncRangeRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncRangeRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
Cluster::Service::Service() {
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Cluster_method_names[0],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Cluster::Service, ::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Cluster::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::BatchGetRequest* req,
|
||||
::greptime::v1::meta::BatchGetResponse* resp) {
|
||||
return service->BatchGet(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Cluster_method_names[1],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Cluster::Service, ::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Cluster::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::RangeRequest* req,
|
||||
::greptime::v1::meta::RangeResponse* resp) {
|
||||
return service->Range(ctx, req, resp);
|
||||
}, this)));
|
||||
}
|
||||
|
||||
Cluster::Service::~Service() {
|
||||
}
|
||||
|
||||
::grpc::Status Cluster::Service::BatchGet(::grpc::ServerContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Cluster::Service::Range(::grpc::ServerContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
} // namespace meta
|
||||
|
||||
@@ -0,0 +1,423 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/cluster.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fmeta_2fcluster_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fmeta_2fcluster_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/meta/cluster.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
// Cluster service is used for communication between meta nodes.
|
||||
class Cluster final {
|
||||
public:
|
||||
static constexpr char const* service_full_name() {
|
||||
return "greptime.v1.meta.Cluster";
|
||||
}
|
||||
class StubInterface {
|
||||
public:
|
||||
virtual ~StubInterface() {}
|
||||
// Batch get kvs by input keys from leader's in_memory kv store.
|
||||
virtual ::grpc::Status BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::greptime::v1::meta::BatchGetResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::BatchGetResponse>> AsyncBatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::BatchGetResponse>>(AsyncBatchGetRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::BatchGetResponse>> PrepareAsyncBatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::BatchGetResponse>>(PrepareAsyncBatchGetRaw(context, request, cq));
|
||||
}
|
||||
// Range get the kvs from leader's in_memory kv store.
|
||||
virtual ::grpc::Status Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::greptime::v1::meta::RangeResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RangeResponse>> AsyncRange(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RangeResponse>>(AsyncRangeRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RangeResponse>> PrepareAsyncRange(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RangeResponse>>(PrepareAsyncRangeRaw(context, request, cq));
|
||||
}
|
||||
class async_interface {
|
||||
public:
|
||||
virtual ~async_interface() {}
|
||||
// Batch get kvs by input keys from leader's in_memory kv store.
|
||||
virtual void BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
// Range get the kvs from leader's in_memory kv store.
|
||||
virtual void Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
};
|
||||
typedef class async_interface experimental_async_interface;
|
||||
virtual class async_interface* async() { return nullptr; }
|
||||
class async_interface* experimental_async() { return async(); }
|
||||
private:
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::BatchGetResponse>* AsyncBatchGetRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::BatchGetResponse>* PrepareAsyncBatchGetRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RangeResponse>* AsyncRangeRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RangeResponse>* PrepareAsyncRangeRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
};
|
||||
class Stub final : public StubInterface {
|
||||
public:
|
||||
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
::grpc::Status BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::greptime::v1::meta::BatchGetResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchGetResponse>> AsyncBatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchGetResponse>>(AsyncBatchGetRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchGetResponse>> PrepareAsyncBatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchGetResponse>>(PrepareAsyncBatchGetRaw(context, request, cq));
|
||||
}
|
||||
::grpc::Status Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::greptime::v1::meta::RangeResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RangeResponse>> AsyncRange(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RangeResponse>>(AsyncRangeRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RangeResponse>> PrepareAsyncRange(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RangeResponse>>(PrepareAsyncRangeRaw(context, request, cq));
|
||||
}
|
||||
class async final :
|
||||
public StubInterface::async_interface {
|
||||
public:
|
||||
void BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
void Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
private:
|
||||
friend class Stub;
|
||||
explicit async(Stub* stub): stub_(stub) { }
|
||||
Stub* stub() { return stub_; }
|
||||
Stub* stub_;
|
||||
};
|
||||
class async* async() override { return &async_stub_; }
|
||||
|
||||
private:
|
||||
std::shared_ptr< ::grpc::ChannelInterface> channel_;
|
||||
class async async_stub_{this};
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchGetResponse>* AsyncBatchGetRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchGetResponse>* PrepareAsyncBatchGetRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RangeResponse>* AsyncRangeRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RangeResponse>* PrepareAsyncRangeRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_BatchGet_;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_Range_;
|
||||
};
|
||||
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
|
||||
class Service : public ::grpc::Service {
|
||||
public:
|
||||
Service();
|
||||
virtual ~Service();
|
||||
// Batch get kvs by input keys from leader's in_memory kv store.
|
||||
virtual ::grpc::Status BatchGet(::grpc::ServerContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response);
|
||||
// Range get the kvs from leader's in_memory kv store.
|
||||
virtual ::grpc::Status Range(::grpc::ServerContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response);
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_BatchGet : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_BatchGet() {
|
||||
::grpc::Service::MarkMethodAsync(0);
|
||||
}
|
||||
~WithAsyncMethod_BatchGet() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status BatchGet(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::BatchGetRequest* /*request*/, ::greptime::v1::meta::BatchGetResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestBatchGet(::grpc::ServerContext* context, ::greptime::v1::meta::BatchGetRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::meta::BatchGetResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_Range : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_Range() {
|
||||
::grpc::Service::MarkMethodAsync(1);
|
||||
}
|
||||
~WithAsyncMethod_Range() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RangeRequest* /*request*/, ::greptime::v1::meta::RangeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestRange(::grpc::ServerContext* context, ::greptime::v1::meta::RangeRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::meta::RangeResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
typedef WithAsyncMethod_BatchGet<WithAsyncMethod_Range<Service > > AsyncService;
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_BatchGet : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_BatchGet() {
|
||||
::grpc::Service::MarkMethodCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response) { return this->BatchGet(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_BatchGet(
|
||||
::grpc::MessageAllocator< ::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_BatchGet() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status BatchGet(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::BatchGetRequest* /*request*/, ::greptime::v1::meta::BatchGetResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* BatchGet(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::meta::BatchGetRequest* /*request*/, ::greptime::v1::meta::BatchGetResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_Range : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_Range() {
|
||||
::grpc::Service::MarkMethodCallback(1,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response) { return this->Range(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_Range(
|
||||
::grpc::MessageAllocator< ::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_Range() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RangeRequest* /*request*/, ::greptime::v1::meta::RangeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Range(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::meta::RangeRequest* /*request*/, ::greptime::v1::meta::RangeResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
typedef WithCallbackMethod_BatchGet<WithCallbackMethod_Range<Service > > CallbackService;
|
||||
typedef CallbackService ExperimentalCallbackService;
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_BatchGet : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_BatchGet() {
|
||||
::grpc::Service::MarkMethodGeneric(0);
|
||||
}
|
||||
~WithGenericMethod_BatchGet() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status BatchGet(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::BatchGetRequest* /*request*/, ::greptime::v1::meta::BatchGetResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_Range : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_Range() {
|
||||
::grpc::Service::MarkMethodGeneric(1);
|
||||
}
|
||||
~WithGenericMethod_Range() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RangeRequest* /*request*/, ::greptime::v1::meta::RangeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_BatchGet : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_BatchGet() {
|
||||
::grpc::Service::MarkMethodRaw(0);
|
||||
}
|
||||
~WithRawMethod_BatchGet() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status BatchGet(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::BatchGetRequest* /*request*/, ::greptime::v1::meta::BatchGetResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestBatchGet(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_Range : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_Range() {
|
||||
::grpc::Service::MarkMethodRaw(1);
|
||||
}
|
||||
~WithRawMethod_Range() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RangeRequest* /*request*/, ::greptime::v1::meta::RangeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestRange(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_BatchGet : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_BatchGet() {
|
||||
::grpc::Service::MarkMethodRawCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->BatchGet(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_BatchGet() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status BatchGet(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::BatchGetRequest* /*request*/, ::greptime::v1::meta::BatchGetResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* BatchGet(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_Range : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_Range() {
|
||||
::grpc::Service::MarkMethodRawCallback(1,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Range(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_Range() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RangeRequest* /*request*/, ::greptime::v1::meta::RangeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Range(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_BatchGet : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_BatchGet() {
|
||||
::grpc::Service::MarkMethodStreamed(0,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse>* streamer) {
|
||||
return this->StreamedBatchGet(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_BatchGet() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status BatchGet(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::BatchGetRequest* /*request*/, ::greptime::v1::meta::BatchGetResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedBatchGet(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::meta::BatchGetRequest,::greptime::v1::meta::BatchGetResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_Range : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_Range() {
|
||||
::grpc::Service::MarkMethodStreamed(1,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse>* streamer) {
|
||||
return this->StreamedRange(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_Range() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RangeRequest* /*request*/, ::greptime::v1::meta::RangeResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedRange(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::meta::RangeRequest,::greptime::v1::meta::RangeResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
typedef WithStreamedUnaryMethod_BatchGet<WithStreamedUnaryMethod_Range<Service > > StreamedUnaryService;
|
||||
typedef Service SplitStreamedService;
|
||||
typedef WithStreamedUnaryMethod_BatchGet<WithStreamedUnaryMethod_Range<Service > > StreamedService;
|
||||
};
|
||||
|
||||
} // namespace meta
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fmeta_2fcluster_2eproto__INCLUDED
|
||||
@@ -0,0 +1,29 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/common.proto
|
||||
|
||||
#include "greptime/v1/meta/common.pb.h"
|
||||
#include "greptime/v1/meta/common.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
} // namespace meta
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/common.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fmeta_2fcommon_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fmeta_2fcommon_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/meta/common.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
} // namespace meta
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fmeta_2fcommon_2eproto__INCLUDED
|
||||
@@ -0,0 +1,90 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/ddl.proto
|
||||
|
||||
#include "greptime/v1/meta/ddl.pb.h"
|
||||
#include "greptime/v1/meta/ddl.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
static const char* DdlTask_method_names[] = {
|
||||
"/greptime.v1.meta.DdlTask/SubmitDdlTask",
|
||||
};
|
||||
|
||||
std::unique_ptr< DdlTask::Stub> DdlTask::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
|
||||
(void)options;
|
||||
std::unique_ptr< DdlTask::Stub> stub(new DdlTask::Stub(channel, options));
|
||||
return stub;
|
||||
}
|
||||
|
||||
DdlTask::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
|
||||
: channel_(channel), rpcmethod_SubmitDdlTask_(DdlTask_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
{}
|
||||
|
||||
::grpc::Status DdlTask::Stub::SubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::greptime::v1::meta::SubmitDdlTaskResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::SubmitDdlTaskRequest, ::greptime::v1::meta::SubmitDdlTaskResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SubmitDdlTask_, context, request, response);
|
||||
}
|
||||
|
||||
void DdlTask::Stub::async::SubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest* request, ::greptime::v1::meta::SubmitDdlTaskResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::SubmitDdlTaskRequest, ::greptime::v1::meta::SubmitDdlTaskResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitDdlTask_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void DdlTask::Stub::async::SubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest* request, ::greptime::v1::meta::SubmitDdlTaskResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitDdlTask_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::SubmitDdlTaskResponse>* DdlTask::Stub::PrepareAsyncSubmitDdlTaskRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::SubmitDdlTaskResponse, ::greptime::v1::meta::SubmitDdlTaskRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SubmitDdlTask_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::SubmitDdlTaskResponse>* DdlTask::Stub::AsyncSubmitDdlTaskRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncSubmitDdlTaskRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
DdlTask::Service::Service() {
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
DdlTask_method_names[0],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< DdlTask::Service, ::greptime::v1::meta::SubmitDdlTaskRequest, ::greptime::v1::meta::SubmitDdlTaskResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](DdlTask::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::SubmitDdlTaskRequest* req,
|
||||
::greptime::v1::meta::SubmitDdlTaskResponse* resp) {
|
||||
return service->SubmitDdlTask(ctx, req, resp);
|
||||
}, this)));
|
||||
}
|
||||
|
||||
DdlTask::Service::~Service() {
|
||||
}
|
||||
|
||||
::grpc::Status DdlTask::Service::SubmitDdlTask(::grpc::ServerContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest* request, ::greptime::v1::meta::SubmitDdlTaskResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
} // namespace meta
|
||||
|
||||
@@ -0,0 +1,262 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/ddl.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fmeta_2fddl_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fmeta_2fddl_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/meta/ddl.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
class DdlTask final {
|
||||
public:
|
||||
static constexpr char const* service_full_name() {
|
||||
return "greptime.v1.meta.DdlTask";
|
||||
}
|
||||
class StubInterface {
|
||||
public:
|
||||
virtual ~StubInterface() {}
|
||||
// Submits a DDL task to meta.
|
||||
virtual ::grpc::Status SubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::greptime::v1::meta::SubmitDdlTaskResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::SubmitDdlTaskResponse>> AsyncSubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::SubmitDdlTaskResponse>>(AsyncSubmitDdlTaskRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::SubmitDdlTaskResponse>> PrepareAsyncSubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::SubmitDdlTaskResponse>>(PrepareAsyncSubmitDdlTaskRaw(context, request, cq));
|
||||
}
|
||||
class async_interface {
|
||||
public:
|
||||
virtual ~async_interface() {}
|
||||
// Submits a DDL task to meta.
|
||||
virtual void SubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest* request, ::greptime::v1::meta::SubmitDdlTaskResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void SubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest* request, ::greptime::v1::meta::SubmitDdlTaskResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
};
|
||||
typedef class async_interface experimental_async_interface;
|
||||
virtual class async_interface* async() { return nullptr; }
|
||||
class async_interface* experimental_async() { return async(); }
|
||||
private:
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::SubmitDdlTaskResponse>* AsyncSubmitDdlTaskRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::SubmitDdlTaskResponse>* PrepareAsyncSubmitDdlTaskRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
};
|
||||
class Stub final : public StubInterface {
|
||||
public:
|
||||
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
::grpc::Status SubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::greptime::v1::meta::SubmitDdlTaskResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::SubmitDdlTaskResponse>> AsyncSubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::SubmitDdlTaskResponse>>(AsyncSubmitDdlTaskRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::SubmitDdlTaskResponse>> PrepareAsyncSubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::SubmitDdlTaskResponse>>(PrepareAsyncSubmitDdlTaskRaw(context, request, cq));
|
||||
}
|
||||
class async final :
|
||||
public StubInterface::async_interface {
|
||||
public:
|
||||
void SubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest* request, ::greptime::v1::meta::SubmitDdlTaskResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void SubmitDdlTask(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest* request, ::greptime::v1::meta::SubmitDdlTaskResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
private:
|
||||
friend class Stub;
|
||||
explicit async(Stub* stub): stub_(stub) { }
|
||||
Stub* stub() { return stub_; }
|
||||
Stub* stub_;
|
||||
};
|
||||
class async* async() override { return &async_stub_; }
|
||||
|
||||
private:
|
||||
std::shared_ptr< ::grpc::ChannelInterface> channel_;
|
||||
class async async_stub_{this};
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::SubmitDdlTaskResponse>* AsyncSubmitDdlTaskRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::SubmitDdlTaskResponse>* PrepareAsyncSubmitDdlTaskRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_SubmitDdlTask_;
|
||||
};
|
||||
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
|
||||
class Service : public ::grpc::Service {
|
||||
public:
|
||||
Service();
|
||||
virtual ~Service();
|
||||
// Submits a DDL task to meta.
|
||||
virtual ::grpc::Status SubmitDdlTask(::grpc::ServerContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest* request, ::greptime::v1::meta::SubmitDdlTaskResponse* response);
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_SubmitDdlTask : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_SubmitDdlTask() {
|
||||
::grpc::Service::MarkMethodAsync(0);
|
||||
}
|
||||
~WithAsyncMethod_SubmitDdlTask() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status SubmitDdlTask(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::SubmitDdlTaskRequest* /*request*/, ::greptime::v1::meta::SubmitDdlTaskResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestSubmitDdlTask(::grpc::ServerContext* context, ::greptime::v1::meta::SubmitDdlTaskRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::meta::SubmitDdlTaskResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
typedef WithAsyncMethod_SubmitDdlTask<Service > AsyncService;
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_SubmitDdlTask : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_SubmitDdlTask() {
|
||||
::grpc::Service::MarkMethodCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::SubmitDdlTaskRequest, ::greptime::v1::meta::SubmitDdlTaskResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::meta::SubmitDdlTaskRequest* request, ::greptime::v1::meta::SubmitDdlTaskResponse* response) { return this->SubmitDdlTask(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_SubmitDdlTask(
|
||||
::grpc::MessageAllocator< ::greptime::v1::meta::SubmitDdlTaskRequest, ::greptime::v1::meta::SubmitDdlTaskResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::SubmitDdlTaskRequest, ::greptime::v1::meta::SubmitDdlTaskResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_SubmitDdlTask() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status SubmitDdlTask(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::SubmitDdlTaskRequest* /*request*/, ::greptime::v1::meta::SubmitDdlTaskResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* SubmitDdlTask(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::meta::SubmitDdlTaskRequest* /*request*/, ::greptime::v1::meta::SubmitDdlTaskResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
typedef WithCallbackMethod_SubmitDdlTask<Service > CallbackService;
|
||||
typedef CallbackService ExperimentalCallbackService;
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_SubmitDdlTask : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_SubmitDdlTask() {
|
||||
::grpc::Service::MarkMethodGeneric(0);
|
||||
}
|
||||
~WithGenericMethod_SubmitDdlTask() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status SubmitDdlTask(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::SubmitDdlTaskRequest* /*request*/, ::greptime::v1::meta::SubmitDdlTaskResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_SubmitDdlTask : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_SubmitDdlTask() {
|
||||
::grpc::Service::MarkMethodRaw(0);
|
||||
}
|
||||
~WithRawMethod_SubmitDdlTask() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status SubmitDdlTask(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::SubmitDdlTaskRequest* /*request*/, ::greptime::v1::meta::SubmitDdlTaskResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestSubmitDdlTask(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_SubmitDdlTask : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_SubmitDdlTask() {
|
||||
::grpc::Service::MarkMethodRawCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SubmitDdlTask(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_SubmitDdlTask() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status SubmitDdlTask(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::SubmitDdlTaskRequest* /*request*/, ::greptime::v1::meta::SubmitDdlTaskResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* SubmitDdlTask(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_SubmitDdlTask : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_SubmitDdlTask() {
|
||||
::grpc::Service::MarkMethodStreamed(0,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::meta::SubmitDdlTaskRequest, ::greptime::v1::meta::SubmitDdlTaskResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::meta::SubmitDdlTaskRequest, ::greptime::v1::meta::SubmitDdlTaskResponse>* streamer) {
|
||||
return this->StreamedSubmitDdlTask(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_SubmitDdlTask() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status SubmitDdlTask(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::SubmitDdlTaskRequest* /*request*/, ::greptime::v1::meta::SubmitDdlTaskResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedSubmitDdlTask(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::meta::SubmitDdlTaskRequest,::greptime::v1::meta::SubmitDdlTaskResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
typedef WithStreamedUnaryMethod_SubmitDdlTask<Service > StreamedUnaryService;
|
||||
typedef Service SplitStreamedService;
|
||||
typedef WithStreamedUnaryMethod_SubmitDdlTask<Service > StreamedService;
|
||||
};
|
||||
|
||||
} // namespace meta
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fmeta_2fddl_2eproto__INCLUDED
|
||||
@@ -0,0 +1,124 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/heartbeat.proto
|
||||
|
||||
#include "greptime/v1/meta/heartbeat.pb.h"
|
||||
#include "greptime/v1/meta/heartbeat.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
static const char* Heartbeat_method_names[] = {
|
||||
"/greptime.v1.meta.Heartbeat/Heartbeat",
|
||||
"/greptime.v1.meta.Heartbeat/AskLeader",
|
||||
};
|
||||
|
||||
std::unique_ptr< Heartbeat::Stub> Heartbeat::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
|
||||
(void)options;
|
||||
std::unique_ptr< Heartbeat::Stub> stub(new Heartbeat::Stub(channel, options));
|
||||
return stub;
|
||||
}
|
||||
|
||||
Heartbeat::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
|
||||
: channel_(channel), rpcmethod_Heartbeat_(Heartbeat_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
|
||||
, rpcmethod_AskLeader_(Heartbeat_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
{}
|
||||
|
||||
::grpc::ClientReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>* Heartbeat::Stub::HeartbeatRaw(::grpc::ClientContext* context) {
|
||||
return ::grpc::internal::ClientReaderWriterFactory< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>::Create(channel_.get(), rpcmethod_Heartbeat_, context);
|
||||
}
|
||||
|
||||
void Heartbeat::Stub::async::Heartbeat(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::greptime::v1::meta::HeartbeatRequest,::greptime::v1::meta::HeartbeatResponse>* reactor) {
|
||||
::grpc::internal::ClientCallbackReaderWriterFactory< ::greptime::v1::meta::HeartbeatRequest,::greptime::v1::meta::HeartbeatResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_Heartbeat_, context, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>* Heartbeat::Stub::AsyncHeartbeatRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
|
||||
return ::grpc::internal::ClientAsyncReaderWriterFactory< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>::Create(channel_.get(), cq, rpcmethod_Heartbeat_, context, true, tag);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>* Heartbeat::Stub::PrepareAsyncHeartbeatRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncReaderWriterFactory< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>::Create(channel_.get(), cq, rpcmethod_Heartbeat_, context, false, nullptr);
|
||||
}
|
||||
|
||||
::grpc::Status Heartbeat::Stub::AskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::greptime::v1::meta::AskLeaderResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::AskLeaderRequest, ::greptime::v1::meta::AskLeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AskLeader_, context, request, response);
|
||||
}
|
||||
|
||||
void Heartbeat::Stub::async::AskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest* request, ::greptime::v1::meta::AskLeaderResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::AskLeaderRequest, ::greptime::v1::meta::AskLeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AskLeader_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Heartbeat::Stub::async::AskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest* request, ::greptime::v1::meta::AskLeaderResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AskLeader_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::AskLeaderResponse>* Heartbeat::Stub::PrepareAsyncAskLeaderRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::AskLeaderResponse, ::greptime::v1::meta::AskLeaderRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AskLeader_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::AskLeaderResponse>* Heartbeat::Stub::AsyncAskLeaderRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncAskLeaderRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
Heartbeat::Service::Service() {
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Heartbeat_method_names[0],
|
||||
::grpc::internal::RpcMethod::BIDI_STREAMING,
|
||||
new ::grpc::internal::BidiStreamingHandler< Heartbeat::Service, ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>(
|
||||
[](Heartbeat::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
::grpc::ServerReaderWriter<::greptime::v1::meta::HeartbeatResponse,
|
||||
::greptime::v1::meta::HeartbeatRequest>* stream) {
|
||||
return service->Heartbeat(ctx, stream);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Heartbeat_method_names[1],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Heartbeat::Service, ::greptime::v1::meta::AskLeaderRequest, ::greptime::v1::meta::AskLeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Heartbeat::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::AskLeaderRequest* req,
|
||||
::greptime::v1::meta::AskLeaderResponse* resp) {
|
||||
return service->AskLeader(ctx, req, resp);
|
||||
}, this)));
|
||||
}
|
||||
|
||||
Heartbeat::Service::~Service() {
|
||||
}
|
||||
|
||||
::grpc::Status Heartbeat::Service::Heartbeat(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::greptime::v1::meta::HeartbeatResponse, ::greptime::v1::meta::HeartbeatRequest>* stream) {
|
||||
(void) context;
|
||||
(void) stream;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Heartbeat::Service::AskLeader(::grpc::ServerContext* context, const ::greptime::v1::meta::AskLeaderRequest* request, ::greptime::v1::meta::AskLeaderResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
} // namespace meta
|
||||
|
||||
@@ -0,0 +1,408 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/heartbeat.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fmeta_2fheartbeat_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fmeta_2fheartbeat_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/meta/heartbeat.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
class Heartbeat final {
|
||||
public:
|
||||
static constexpr char const* service_full_name() {
|
||||
return "greptime.v1.meta.Heartbeat";
|
||||
}
|
||||
class StubInterface {
|
||||
public:
|
||||
virtual ~StubInterface() {}
|
||||
// Heartbeat, there may be many contents of the heartbeat, such as:
|
||||
// 1. Metadata to be registered to meta server and discoverable by other
|
||||
// nodes.
|
||||
// 2. Some performance metrics, such as Load, CPU usage, etc.
|
||||
// 3. The number of computing tasks being executed.
|
||||
std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>> Heartbeat(::grpc::ClientContext* context) {
|
||||
return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>>(HeartbeatRaw(context));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>> AsyncHeartbeat(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>>(AsyncHeartbeatRaw(context, cq, tag));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>> PrepareAsyncHeartbeat(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>>(PrepareAsyncHeartbeatRaw(context, cq));
|
||||
}
|
||||
// Ask leader's endpoint.
|
||||
virtual ::grpc::Status AskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::greptime::v1::meta::AskLeaderResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::AskLeaderResponse>> AsyncAskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::AskLeaderResponse>>(AsyncAskLeaderRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::AskLeaderResponse>> PrepareAsyncAskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::AskLeaderResponse>>(PrepareAsyncAskLeaderRaw(context, request, cq));
|
||||
}
|
||||
class async_interface {
|
||||
public:
|
||||
virtual ~async_interface() {}
|
||||
// Heartbeat, there may be many contents of the heartbeat, such as:
|
||||
// 1. Metadata to be registered to meta server and discoverable by other
|
||||
// nodes.
|
||||
// 2. Some performance metrics, such as Load, CPU usage, etc.
|
||||
// 3. The number of computing tasks being executed.
|
||||
virtual void Heartbeat(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::greptime::v1::meta::HeartbeatRequest,::greptime::v1::meta::HeartbeatResponse>* reactor) = 0;
|
||||
// Ask leader's endpoint.
|
||||
virtual void AskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest* request, ::greptime::v1::meta::AskLeaderResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void AskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest* request, ::greptime::v1::meta::AskLeaderResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
};
|
||||
typedef class async_interface experimental_async_interface;
|
||||
virtual class async_interface* async() { return nullptr; }
|
||||
class async_interface* experimental_async() { return async(); }
|
||||
private:
|
||||
virtual ::grpc::ClientReaderWriterInterface< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>* HeartbeatRaw(::grpc::ClientContext* context) = 0;
|
||||
virtual ::grpc::ClientAsyncReaderWriterInterface< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>* AsyncHeartbeatRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
|
||||
virtual ::grpc::ClientAsyncReaderWriterInterface< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>* PrepareAsyncHeartbeatRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::AskLeaderResponse>* AsyncAskLeaderRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::AskLeaderResponse>* PrepareAsyncAskLeaderRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
};
|
||||
class Stub final : public StubInterface {
|
||||
public:
|
||||
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
std::unique_ptr< ::grpc::ClientReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>> Heartbeat(::grpc::ClientContext* context) {
|
||||
return std::unique_ptr< ::grpc::ClientReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>>(HeartbeatRaw(context));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>> AsyncHeartbeat(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>>(AsyncHeartbeatRaw(context, cq, tag));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>> PrepareAsyncHeartbeat(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>>(PrepareAsyncHeartbeatRaw(context, cq));
|
||||
}
|
||||
::grpc::Status AskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::greptime::v1::meta::AskLeaderResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::AskLeaderResponse>> AsyncAskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::AskLeaderResponse>>(AsyncAskLeaderRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::AskLeaderResponse>> PrepareAsyncAskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::AskLeaderResponse>>(PrepareAsyncAskLeaderRaw(context, request, cq));
|
||||
}
|
||||
class async final :
|
||||
public StubInterface::async_interface {
|
||||
public:
|
||||
void Heartbeat(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::greptime::v1::meta::HeartbeatRequest,::greptime::v1::meta::HeartbeatResponse>* reactor) override;
|
||||
void AskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest* request, ::greptime::v1::meta::AskLeaderResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void AskLeader(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest* request, ::greptime::v1::meta::AskLeaderResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
private:
|
||||
friend class Stub;
|
||||
explicit async(Stub* stub): stub_(stub) { }
|
||||
Stub* stub() { return stub_; }
|
||||
Stub* stub_;
|
||||
};
|
||||
class async* async() override { return &async_stub_; }
|
||||
|
||||
private:
|
||||
std::shared_ptr< ::grpc::ChannelInterface> channel_;
|
||||
class async async_stub_{this};
|
||||
::grpc::ClientReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>* HeartbeatRaw(::grpc::ClientContext* context) override;
|
||||
::grpc::ClientAsyncReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>* AsyncHeartbeatRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
|
||||
::grpc::ClientAsyncReaderWriter< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>* PrepareAsyncHeartbeatRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::AskLeaderResponse>* AsyncAskLeaderRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::AskLeaderResponse>* PrepareAsyncAskLeaderRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::AskLeaderRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_Heartbeat_;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_AskLeader_;
|
||||
};
|
||||
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
|
||||
class Service : public ::grpc::Service {
|
||||
public:
|
||||
Service();
|
||||
virtual ~Service();
|
||||
// Heartbeat, there may be many contents of the heartbeat, such as:
|
||||
// 1. Metadata to be registered to meta server and discoverable by other
|
||||
// nodes.
|
||||
// 2. Some performance metrics, such as Load, CPU usage, etc.
|
||||
// 3. The number of computing tasks being executed.
|
||||
virtual ::grpc::Status Heartbeat(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::greptime::v1::meta::HeartbeatResponse, ::greptime::v1::meta::HeartbeatRequest>* stream);
|
||||
// Ask leader's endpoint.
|
||||
virtual ::grpc::Status AskLeader(::grpc::ServerContext* context, const ::greptime::v1::meta::AskLeaderRequest* request, ::greptime::v1::meta::AskLeaderResponse* response);
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_Heartbeat : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_Heartbeat() {
|
||||
::grpc::Service::MarkMethodAsync(0);
|
||||
}
|
||||
~WithAsyncMethod_Heartbeat() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Heartbeat(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::greptime::v1::meta::HeartbeatResponse, ::greptime::v1::meta::HeartbeatRequest>* /*stream*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestHeartbeat(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::greptime::v1::meta::HeartbeatResponse, ::greptime::v1::meta::HeartbeatRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_AskLeader : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_AskLeader() {
|
||||
::grpc::Service::MarkMethodAsync(1);
|
||||
}
|
||||
~WithAsyncMethod_AskLeader() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status AskLeader(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::AskLeaderRequest* /*request*/, ::greptime::v1::meta::AskLeaderResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestAskLeader(::grpc::ServerContext* context, ::greptime::v1::meta::AskLeaderRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::meta::AskLeaderResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
typedef WithAsyncMethod_Heartbeat<WithAsyncMethod_AskLeader<Service > > AsyncService;
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_Heartbeat : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_Heartbeat() {
|
||||
::grpc::Service::MarkMethodCallback(0,
|
||||
new ::grpc::internal::CallbackBidiHandler< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context) { return this->Heartbeat(context); }));
|
||||
}
|
||||
~WithCallbackMethod_Heartbeat() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Heartbeat(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::greptime::v1::meta::HeartbeatResponse, ::greptime::v1::meta::HeartbeatRequest>* /*stream*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerBidiReactor< ::greptime::v1::meta::HeartbeatRequest, ::greptime::v1::meta::HeartbeatResponse>* Heartbeat(
|
||||
::grpc::CallbackServerContext* /*context*/)
|
||||
{ return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_AskLeader : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_AskLeader() {
|
||||
::grpc::Service::MarkMethodCallback(1,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::AskLeaderRequest, ::greptime::v1::meta::AskLeaderResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::meta::AskLeaderRequest* request, ::greptime::v1::meta::AskLeaderResponse* response) { return this->AskLeader(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_AskLeader(
|
||||
::grpc::MessageAllocator< ::greptime::v1::meta::AskLeaderRequest, ::greptime::v1::meta::AskLeaderResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::AskLeaderRequest, ::greptime::v1::meta::AskLeaderResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_AskLeader() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status AskLeader(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::AskLeaderRequest* /*request*/, ::greptime::v1::meta::AskLeaderResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* AskLeader(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::meta::AskLeaderRequest* /*request*/, ::greptime::v1::meta::AskLeaderResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
typedef WithCallbackMethod_Heartbeat<WithCallbackMethod_AskLeader<Service > > CallbackService;
|
||||
typedef CallbackService ExperimentalCallbackService;
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_Heartbeat : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_Heartbeat() {
|
||||
::grpc::Service::MarkMethodGeneric(0);
|
||||
}
|
||||
~WithGenericMethod_Heartbeat() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Heartbeat(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::greptime::v1::meta::HeartbeatResponse, ::greptime::v1::meta::HeartbeatRequest>* /*stream*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_AskLeader : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_AskLeader() {
|
||||
::grpc::Service::MarkMethodGeneric(1);
|
||||
}
|
||||
~WithGenericMethod_AskLeader() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status AskLeader(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::AskLeaderRequest* /*request*/, ::greptime::v1::meta::AskLeaderResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_Heartbeat : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_Heartbeat() {
|
||||
::grpc::Service::MarkMethodRaw(0);
|
||||
}
|
||||
~WithRawMethod_Heartbeat() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Heartbeat(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::greptime::v1::meta::HeartbeatResponse, ::greptime::v1::meta::HeartbeatRequest>* /*stream*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestHeartbeat(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_AskLeader : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_AskLeader() {
|
||||
::grpc::Service::MarkMethodRaw(1);
|
||||
}
|
||||
~WithRawMethod_AskLeader() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status AskLeader(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::AskLeaderRequest* /*request*/, ::greptime::v1::meta::AskLeaderResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestAskLeader(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_Heartbeat : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_Heartbeat() {
|
||||
::grpc::Service::MarkMethodRawCallback(0,
|
||||
new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context) { return this->Heartbeat(context); }));
|
||||
}
|
||||
~WithRawCallbackMethod_Heartbeat() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Heartbeat(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::greptime::v1::meta::HeartbeatResponse, ::greptime::v1::meta::HeartbeatRequest>* /*stream*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* Heartbeat(
|
||||
::grpc::CallbackServerContext* /*context*/)
|
||||
{ return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_AskLeader : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_AskLeader() {
|
||||
::grpc::Service::MarkMethodRawCallback(1,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->AskLeader(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_AskLeader() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status AskLeader(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::AskLeaderRequest* /*request*/, ::greptime::v1::meta::AskLeaderResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* AskLeader(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_AskLeader : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_AskLeader() {
|
||||
::grpc::Service::MarkMethodStreamed(1,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::meta::AskLeaderRequest, ::greptime::v1::meta::AskLeaderResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::meta::AskLeaderRequest, ::greptime::v1::meta::AskLeaderResponse>* streamer) {
|
||||
return this->StreamedAskLeader(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_AskLeader() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status AskLeader(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::AskLeaderRequest* /*request*/, ::greptime::v1::meta::AskLeaderResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedAskLeader(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::meta::AskLeaderRequest,::greptime::v1::meta::AskLeaderResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
typedef WithStreamedUnaryMethod_AskLeader<Service > StreamedUnaryService;
|
||||
typedef Service SplitStreamedService;
|
||||
typedef WithStreamedUnaryMethod_AskLeader<Service > StreamedService;
|
||||
};
|
||||
|
||||
} // namespace meta
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fmeta_2fheartbeat_2eproto__INCLUDED
|
||||
@@ -0,0 +1,132 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/lock.proto
|
||||
|
||||
#include "greptime/v1/meta/lock.pb.h"
|
||||
#include "greptime/v1/meta/lock.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
static const char* Lock_method_names[] = {
|
||||
"/greptime.v1.meta.Lock/Lock",
|
||||
"/greptime.v1.meta.Lock/Unlock",
|
||||
};
|
||||
|
||||
std::unique_ptr< Lock::Stub> Lock::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
|
||||
(void)options;
|
||||
std::unique_ptr< Lock::Stub> stub(new Lock::Stub(channel, options));
|
||||
return stub;
|
||||
}
|
||||
|
||||
Lock::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
|
||||
: channel_(channel), rpcmethod_Lock_(Lock_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_Unlock_(Lock_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
{}
|
||||
|
||||
::grpc::Status Lock::Stub::Lock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::greptime::v1::meta::LockResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::LockRequest, ::greptime::v1::meta::LockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Lock_, context, request, response);
|
||||
}
|
||||
|
||||
void Lock::Stub::async::Lock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest* request, ::greptime::v1::meta::LockResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::LockRequest, ::greptime::v1::meta::LockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Lock_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Lock::Stub::async::Lock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest* request, ::greptime::v1::meta::LockResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Lock_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::LockResponse>* Lock::Stub::PrepareAsyncLockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::LockResponse, ::greptime::v1::meta::LockRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Lock_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::LockResponse>* Lock::Stub::AsyncLockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncLockRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Lock::Stub::Unlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::greptime::v1::meta::UnlockResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::UnlockRequest, ::greptime::v1::meta::UnlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Unlock_, context, request, response);
|
||||
}
|
||||
|
||||
void Lock::Stub::async::Unlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest* request, ::greptime::v1::meta::UnlockResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::UnlockRequest, ::greptime::v1::meta::UnlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Unlock_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Lock::Stub::async::Unlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest* request, ::greptime::v1::meta::UnlockResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Unlock_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::UnlockResponse>* Lock::Stub::PrepareAsyncUnlockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::UnlockResponse, ::greptime::v1::meta::UnlockRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Unlock_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::UnlockResponse>* Lock::Stub::AsyncUnlockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncUnlockRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
Lock::Service::Service() {
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Lock_method_names[0],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Lock::Service, ::greptime::v1::meta::LockRequest, ::greptime::v1::meta::LockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Lock::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::LockRequest* req,
|
||||
::greptime::v1::meta::LockResponse* resp) {
|
||||
return service->Lock(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Lock_method_names[1],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Lock::Service, ::greptime::v1::meta::UnlockRequest, ::greptime::v1::meta::UnlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Lock::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::UnlockRequest* req,
|
||||
::greptime::v1::meta::UnlockResponse* resp) {
|
||||
return service->Unlock(ctx, req, resp);
|
||||
}, this)));
|
||||
}
|
||||
|
||||
Lock::Service::~Service() {
|
||||
}
|
||||
|
||||
::grpc::Status Lock::Service::Lock(::grpc::ServerContext* context, const ::greptime::v1::meta::LockRequest* request, ::greptime::v1::meta::LockResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Lock::Service::Unlock(::grpc::ServerContext* context, const ::greptime::v1::meta::UnlockRequest* request, ::greptime::v1::meta::UnlockResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
} // namespace meta
|
||||
|
||||
@@ -0,0 +1,428 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/lock.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fmeta_2flock_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fmeta_2flock_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/meta/lock.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
class Lock final {
|
||||
public:
|
||||
static constexpr char const* service_full_name() {
|
||||
return "greptime.v1.meta.Lock";
|
||||
}
|
||||
class StubInterface {
|
||||
public:
|
||||
virtual ~StubInterface() {}
|
||||
// Lock acquires a distributed shared lock on a given named lock. On success,
|
||||
// it will return a unique key that exists so long as the lock is held by the
|
||||
// caller.
|
||||
virtual ::grpc::Status Lock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::greptime::v1::meta::LockResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::LockResponse>> AsyncLock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::LockResponse>>(AsyncLockRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::LockResponse>> PrepareAsyncLock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::LockResponse>>(PrepareAsyncLockRaw(context, request, cq));
|
||||
}
|
||||
// Unlock takes a key returned by Lock and releases the hold on lock.
|
||||
virtual ::grpc::Status Unlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::greptime::v1::meta::UnlockResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::UnlockResponse>> AsyncUnlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::UnlockResponse>>(AsyncUnlockRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::UnlockResponse>> PrepareAsyncUnlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::UnlockResponse>>(PrepareAsyncUnlockRaw(context, request, cq));
|
||||
}
|
||||
class async_interface {
|
||||
public:
|
||||
virtual ~async_interface() {}
|
||||
// Lock acquires a distributed shared lock on a given named lock. On success,
|
||||
// it will return a unique key that exists so long as the lock is held by the
|
||||
// caller.
|
||||
virtual void Lock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest* request, ::greptime::v1::meta::LockResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void Lock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest* request, ::greptime::v1::meta::LockResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
// Unlock takes a key returned by Lock and releases the hold on lock.
|
||||
virtual void Unlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest* request, ::greptime::v1::meta::UnlockResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void Unlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest* request, ::greptime::v1::meta::UnlockResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
};
|
||||
typedef class async_interface experimental_async_interface;
|
||||
virtual class async_interface* async() { return nullptr; }
|
||||
class async_interface* experimental_async() { return async(); }
|
||||
private:
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::LockResponse>* AsyncLockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::LockResponse>* PrepareAsyncLockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::UnlockResponse>* AsyncUnlockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::UnlockResponse>* PrepareAsyncUnlockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
};
|
||||
class Stub final : public StubInterface {
|
||||
public:
|
||||
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
::grpc::Status Lock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::greptime::v1::meta::LockResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::LockResponse>> AsyncLock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::LockResponse>>(AsyncLockRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::LockResponse>> PrepareAsyncLock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::LockResponse>>(PrepareAsyncLockRaw(context, request, cq));
|
||||
}
|
||||
::grpc::Status Unlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::greptime::v1::meta::UnlockResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::UnlockResponse>> AsyncUnlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::UnlockResponse>>(AsyncUnlockRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::UnlockResponse>> PrepareAsyncUnlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::UnlockResponse>>(PrepareAsyncUnlockRaw(context, request, cq));
|
||||
}
|
||||
class async final :
|
||||
public StubInterface::async_interface {
|
||||
public:
|
||||
void Lock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest* request, ::greptime::v1::meta::LockResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void Lock(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest* request, ::greptime::v1::meta::LockResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
void Unlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest* request, ::greptime::v1::meta::UnlockResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void Unlock(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest* request, ::greptime::v1::meta::UnlockResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
private:
|
||||
friend class Stub;
|
||||
explicit async(Stub* stub): stub_(stub) { }
|
||||
Stub* stub() { return stub_; }
|
||||
Stub* stub_;
|
||||
};
|
||||
class async* async() override { return &async_stub_; }
|
||||
|
||||
private:
|
||||
std::shared_ptr< ::grpc::ChannelInterface> channel_;
|
||||
class async async_stub_{this};
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::LockResponse>* AsyncLockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::LockResponse>* PrepareAsyncLockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::LockRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::UnlockResponse>* AsyncUnlockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::UnlockResponse>* PrepareAsyncUnlockRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::UnlockRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_Lock_;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_Unlock_;
|
||||
};
|
||||
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
|
||||
class Service : public ::grpc::Service {
|
||||
public:
|
||||
Service();
|
||||
virtual ~Service();
|
||||
// Lock acquires a distributed shared lock on a given named lock. On success,
|
||||
// it will return a unique key that exists so long as the lock is held by the
|
||||
// caller.
|
||||
virtual ::grpc::Status Lock(::grpc::ServerContext* context, const ::greptime::v1::meta::LockRequest* request, ::greptime::v1::meta::LockResponse* response);
|
||||
// Unlock takes a key returned by Lock and releases the hold on lock.
|
||||
virtual ::grpc::Status Unlock(::grpc::ServerContext* context, const ::greptime::v1::meta::UnlockRequest* request, ::greptime::v1::meta::UnlockResponse* response);
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_Lock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_Lock() {
|
||||
::grpc::Service::MarkMethodAsync(0);
|
||||
}
|
||||
~WithAsyncMethod_Lock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Lock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::LockRequest* /*request*/, ::greptime::v1::meta::LockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestLock(::grpc::ServerContext* context, ::greptime::v1::meta::LockRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::meta::LockResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_Unlock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_Unlock() {
|
||||
::grpc::Service::MarkMethodAsync(1);
|
||||
}
|
||||
~WithAsyncMethod_Unlock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Unlock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::UnlockRequest* /*request*/, ::greptime::v1::meta::UnlockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestUnlock(::grpc::ServerContext* context, ::greptime::v1::meta::UnlockRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::meta::UnlockResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
typedef WithAsyncMethod_Lock<WithAsyncMethod_Unlock<Service > > AsyncService;
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_Lock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_Lock() {
|
||||
::grpc::Service::MarkMethodCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::LockRequest, ::greptime::v1::meta::LockResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::meta::LockRequest* request, ::greptime::v1::meta::LockResponse* response) { return this->Lock(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_Lock(
|
||||
::grpc::MessageAllocator< ::greptime::v1::meta::LockRequest, ::greptime::v1::meta::LockResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::LockRequest, ::greptime::v1::meta::LockResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_Lock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Lock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::LockRequest* /*request*/, ::greptime::v1::meta::LockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Lock(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::meta::LockRequest* /*request*/, ::greptime::v1::meta::LockResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_Unlock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_Unlock() {
|
||||
::grpc::Service::MarkMethodCallback(1,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::UnlockRequest, ::greptime::v1::meta::UnlockResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::meta::UnlockRequest* request, ::greptime::v1::meta::UnlockResponse* response) { return this->Unlock(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_Unlock(
|
||||
::grpc::MessageAllocator< ::greptime::v1::meta::UnlockRequest, ::greptime::v1::meta::UnlockResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::UnlockRequest, ::greptime::v1::meta::UnlockResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_Unlock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Unlock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::UnlockRequest* /*request*/, ::greptime::v1::meta::UnlockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Unlock(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::meta::UnlockRequest* /*request*/, ::greptime::v1::meta::UnlockResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
typedef WithCallbackMethod_Lock<WithCallbackMethod_Unlock<Service > > CallbackService;
|
||||
typedef CallbackService ExperimentalCallbackService;
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_Lock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_Lock() {
|
||||
::grpc::Service::MarkMethodGeneric(0);
|
||||
}
|
||||
~WithGenericMethod_Lock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Lock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::LockRequest* /*request*/, ::greptime::v1::meta::LockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_Unlock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_Unlock() {
|
||||
::grpc::Service::MarkMethodGeneric(1);
|
||||
}
|
||||
~WithGenericMethod_Unlock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Unlock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::UnlockRequest* /*request*/, ::greptime::v1::meta::UnlockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_Lock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_Lock() {
|
||||
::grpc::Service::MarkMethodRaw(0);
|
||||
}
|
||||
~WithRawMethod_Lock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Lock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::LockRequest* /*request*/, ::greptime::v1::meta::LockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestLock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_Unlock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_Unlock() {
|
||||
::grpc::Service::MarkMethodRaw(1);
|
||||
}
|
||||
~WithRawMethod_Unlock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Unlock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::UnlockRequest* /*request*/, ::greptime::v1::meta::UnlockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestUnlock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_Lock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_Lock() {
|
||||
::grpc::Service::MarkMethodRawCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Lock(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_Lock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Lock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::LockRequest* /*request*/, ::greptime::v1::meta::LockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Lock(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_Unlock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_Unlock() {
|
||||
::grpc::Service::MarkMethodRawCallback(1,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Unlock(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_Unlock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Unlock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::UnlockRequest* /*request*/, ::greptime::v1::meta::UnlockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Unlock(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_Lock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_Lock() {
|
||||
::grpc::Service::MarkMethodStreamed(0,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::meta::LockRequest, ::greptime::v1::meta::LockResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::meta::LockRequest, ::greptime::v1::meta::LockResponse>* streamer) {
|
||||
return this->StreamedLock(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_Lock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status Lock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::LockRequest* /*request*/, ::greptime::v1::meta::LockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedLock(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::meta::LockRequest,::greptime::v1::meta::LockResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_Unlock : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_Unlock() {
|
||||
::grpc::Service::MarkMethodStreamed(1,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::meta::UnlockRequest, ::greptime::v1::meta::UnlockResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::meta::UnlockRequest, ::greptime::v1::meta::UnlockResponse>* streamer) {
|
||||
return this->StreamedUnlock(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_Unlock() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status Unlock(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::UnlockRequest* /*request*/, ::greptime::v1::meta::UnlockResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedUnlock(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::meta::UnlockRequest,::greptime::v1::meta::UnlockResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
typedef WithStreamedUnaryMethod_Lock<WithStreamedUnaryMethod_Unlock<Service > > StreamedUnaryService;
|
||||
typedef Service SplitStreamedService;
|
||||
typedef WithStreamedUnaryMethod_Lock<WithStreamedUnaryMethod_Unlock<Service > > StreamedService;
|
||||
};
|
||||
|
||||
} // namespace meta
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fmeta_2flock_2eproto__INCLUDED
|
||||
@@ -0,0 +1,174 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/route.proto
|
||||
|
||||
#include "greptime/v1/meta/route.pb.h"
|
||||
#include "greptime/v1/meta/route.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
static const char* Router_method_names[] = {
|
||||
"/greptime.v1.meta.Router/Create",
|
||||
"/greptime.v1.meta.Router/Route",
|
||||
"/greptime.v1.meta.Router/Delete",
|
||||
};
|
||||
|
||||
std::unique_ptr< Router::Stub> Router::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
|
||||
(void)options;
|
||||
std::unique_ptr< Router::Stub> stub(new Router::Stub(channel, options));
|
||||
return stub;
|
||||
}
|
||||
|
||||
Router::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
|
||||
: channel_(channel), rpcmethod_Create_(Router_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_Route_(Router_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_Delete_(Router_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
{}
|
||||
|
||||
::grpc::Status Router::Stub::Create(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::greptime::v1::meta::RouteResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::CreateRequest, ::greptime::v1::meta::RouteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Create_, context, request, response);
|
||||
}
|
||||
|
||||
void Router::Stub::async::Create(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest* request, ::greptime::v1::meta::RouteResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::CreateRequest, ::greptime::v1::meta::RouteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Create_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Router::Stub::async::Create(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest* request, ::greptime::v1::meta::RouteResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Create_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* Router::Stub::PrepareAsyncCreateRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::RouteResponse, ::greptime::v1::meta::CreateRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Create_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* Router::Stub::AsyncCreateRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncCreateRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Router::Stub::Route(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::greptime::v1::meta::RouteResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::RouteRequest, ::greptime::v1::meta::RouteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Route_, context, request, response);
|
||||
}
|
||||
|
||||
void Router::Stub::async::Route(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest* request, ::greptime::v1::meta::RouteResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::RouteRequest, ::greptime::v1::meta::RouteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Route_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Router::Stub::async::Route(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest* request, ::greptime::v1::meta::RouteResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Route_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* Router::Stub::PrepareAsyncRouteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::RouteResponse, ::greptime::v1::meta::RouteRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Route_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* Router::Stub::AsyncRouteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncRouteRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Router::Stub::Delete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::greptime::v1::meta::RouteResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::DeleteRequest, ::greptime::v1::meta::RouteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Delete_, context, request, response);
|
||||
}
|
||||
|
||||
void Router::Stub::async::Delete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest* request, ::greptime::v1::meta::RouteResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::DeleteRequest, ::greptime::v1::meta::RouteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Delete_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Router::Stub::async::Delete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest* request, ::greptime::v1::meta::RouteResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Delete_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* Router::Stub::PrepareAsyncDeleteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::RouteResponse, ::greptime::v1::meta::DeleteRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Delete_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* Router::Stub::AsyncDeleteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncDeleteRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
Router::Service::Service() {
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Router_method_names[0],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Router::Service, ::greptime::v1::meta::CreateRequest, ::greptime::v1::meta::RouteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Router::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::CreateRequest* req,
|
||||
::greptime::v1::meta::RouteResponse* resp) {
|
||||
return service->Create(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Router_method_names[1],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Router::Service, ::greptime::v1::meta::RouteRequest, ::greptime::v1::meta::RouteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Router::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::RouteRequest* req,
|
||||
::greptime::v1::meta::RouteResponse* resp) {
|
||||
return service->Route(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Router_method_names[2],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Router::Service, ::greptime::v1::meta::DeleteRequest, ::greptime::v1::meta::RouteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Router::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::DeleteRequest* req,
|
||||
::greptime::v1::meta::RouteResponse* resp) {
|
||||
return service->Delete(ctx, req, resp);
|
||||
}, this)));
|
||||
}
|
||||
|
||||
Router::Service::~Service() {
|
||||
}
|
||||
|
||||
::grpc::Status Router::Service::Create(::grpc::ServerContext* context, const ::greptime::v1::meta::CreateRequest* request, ::greptime::v1::meta::RouteResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Router::Service::Route(::grpc::ServerContext* context, const ::greptime::v1::meta::RouteRequest* request, ::greptime::v1::meta::RouteResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Router::Service::Delete(::grpc::ServerContext* context, const ::greptime::v1::meta::DeleteRequest* request, ::greptime::v1::meta::RouteResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
} // namespace meta
|
||||
|
||||
@@ -0,0 +1,630 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/route.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fmeta_2froute_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fmeta_2froute_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/meta/route.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
class Router final {
|
||||
public:
|
||||
static constexpr char const* service_full_name() {
|
||||
return "greptime.v1.meta.Router";
|
||||
}
|
||||
class StubInterface {
|
||||
public:
|
||||
virtual ~StubInterface() {}
|
||||
virtual ::grpc::Status Create(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::greptime::v1::meta::RouteResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>> AsyncCreate(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>>(AsyncCreateRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>> PrepareAsyncCreate(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>>(PrepareAsyncCreateRaw(context, request, cq));
|
||||
}
|
||||
// Fetch routing information for tables. The smallest unit is the complete
|
||||
// routing information(all regions) of a table.
|
||||
//
|
||||
// ```text
|
||||
// table_1
|
||||
// table_name
|
||||
// table_schema
|
||||
// regions
|
||||
// region_1
|
||||
// leader_peer
|
||||
// follower_peer_1, follower_peer_2
|
||||
// region_2
|
||||
// leader_peer
|
||||
// follower_peer_1, follower_peer_2, follower_peer_3
|
||||
// region_xxx
|
||||
// table_2
|
||||
// ...
|
||||
// ```
|
||||
//
|
||||
virtual ::grpc::Status Route(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::greptime::v1::meta::RouteResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>> AsyncRoute(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>>(AsyncRouteRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>> PrepareAsyncRoute(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>>(PrepareAsyncRouteRaw(context, request, cq));
|
||||
}
|
||||
virtual ::grpc::Status Delete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::greptime::v1::meta::RouteResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>> AsyncDelete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>>(AsyncDeleteRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>> PrepareAsyncDelete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>>(PrepareAsyncDeleteRaw(context, request, cq));
|
||||
}
|
||||
class async_interface {
|
||||
public:
|
||||
virtual ~async_interface() {}
|
||||
virtual void Create(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest* request, ::greptime::v1::meta::RouteResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void Create(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest* request, ::greptime::v1::meta::RouteResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
// Fetch routing information for tables. The smallest unit is the complete
|
||||
// routing information(all regions) of a table.
|
||||
//
|
||||
// ```text
|
||||
// table_1
|
||||
// table_name
|
||||
// table_schema
|
||||
// regions
|
||||
// region_1
|
||||
// leader_peer
|
||||
// follower_peer_1, follower_peer_2
|
||||
// region_2
|
||||
// leader_peer
|
||||
// follower_peer_1, follower_peer_2, follower_peer_3
|
||||
// region_xxx
|
||||
// table_2
|
||||
// ...
|
||||
// ```
|
||||
//
|
||||
virtual void Route(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest* request, ::greptime::v1::meta::RouteResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void Route(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest* request, ::greptime::v1::meta::RouteResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
virtual void Delete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest* request, ::greptime::v1::meta::RouteResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void Delete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest* request, ::greptime::v1::meta::RouteResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
};
|
||||
typedef class async_interface experimental_async_interface;
|
||||
virtual class async_interface* async() { return nullptr; }
|
||||
class async_interface* experimental_async() { return async(); }
|
||||
private:
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>* AsyncCreateRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>* PrepareAsyncCreateRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>* AsyncRouteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>* PrepareAsyncRouteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>* AsyncDeleteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::meta::RouteResponse>* PrepareAsyncDeleteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
};
|
||||
class Stub final : public StubInterface {
|
||||
public:
|
||||
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
::grpc::Status Create(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::greptime::v1::meta::RouteResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>> AsyncCreate(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>>(AsyncCreateRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>> PrepareAsyncCreate(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>>(PrepareAsyncCreateRaw(context, request, cq));
|
||||
}
|
||||
::grpc::Status Route(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::greptime::v1::meta::RouteResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>> AsyncRoute(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>>(AsyncRouteRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>> PrepareAsyncRoute(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>>(PrepareAsyncRouteRaw(context, request, cq));
|
||||
}
|
||||
::grpc::Status Delete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::greptime::v1::meta::RouteResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>> AsyncDelete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>>(AsyncDeleteRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>> PrepareAsyncDelete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>>(PrepareAsyncDeleteRaw(context, request, cq));
|
||||
}
|
||||
class async final :
|
||||
public StubInterface::async_interface {
|
||||
public:
|
||||
void Create(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest* request, ::greptime::v1::meta::RouteResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void Create(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest* request, ::greptime::v1::meta::RouteResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
void Route(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest* request, ::greptime::v1::meta::RouteResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void Route(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest* request, ::greptime::v1::meta::RouteResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
void Delete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest* request, ::greptime::v1::meta::RouteResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void Delete(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest* request, ::greptime::v1::meta::RouteResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
private:
|
||||
friend class Stub;
|
||||
explicit async(Stub* stub): stub_(stub) { }
|
||||
Stub* stub() { return stub_; }
|
||||
Stub* stub_;
|
||||
};
|
||||
class async* async() override { return &async_stub_; }
|
||||
|
||||
private:
|
||||
std::shared_ptr< ::grpc::ChannelInterface> channel_;
|
||||
class async async_stub_{this};
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* AsyncCreateRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* PrepareAsyncCreateRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::CreateRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* AsyncRouteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* PrepareAsyncRouteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RouteRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* AsyncDeleteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RouteResponse>* PrepareAsyncDeleteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_Create_;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_Route_;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_Delete_;
|
||||
};
|
||||
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
|
||||
class Service : public ::grpc::Service {
|
||||
public:
|
||||
Service();
|
||||
virtual ~Service();
|
||||
virtual ::grpc::Status Create(::grpc::ServerContext* context, const ::greptime::v1::meta::CreateRequest* request, ::greptime::v1::meta::RouteResponse* response);
|
||||
// Fetch routing information for tables. The smallest unit is the complete
|
||||
// routing information(all regions) of a table.
|
||||
//
|
||||
// ```text
|
||||
// table_1
|
||||
// table_name
|
||||
// table_schema
|
||||
// regions
|
||||
// region_1
|
||||
// leader_peer
|
||||
// follower_peer_1, follower_peer_2
|
||||
// region_2
|
||||
// leader_peer
|
||||
// follower_peer_1, follower_peer_2, follower_peer_3
|
||||
// region_xxx
|
||||
// table_2
|
||||
// ...
|
||||
// ```
|
||||
//
|
||||
virtual ::grpc::Status Route(::grpc::ServerContext* context, const ::greptime::v1::meta::RouteRequest* request, ::greptime::v1::meta::RouteResponse* response);
|
||||
virtual ::grpc::Status Delete(::grpc::ServerContext* context, const ::greptime::v1::meta::DeleteRequest* request, ::greptime::v1::meta::RouteResponse* response);
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_Create : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_Create() {
|
||||
::grpc::Service::MarkMethodAsync(0);
|
||||
}
|
||||
~WithAsyncMethod_Create() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Create(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::CreateRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestCreate(::grpc::ServerContext* context, ::greptime::v1::meta::CreateRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::meta::RouteResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_Route : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_Route() {
|
||||
::grpc::Service::MarkMethodAsync(1);
|
||||
}
|
||||
~WithAsyncMethod_Route() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Route(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RouteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestRoute(::grpc::ServerContext* context, ::greptime::v1::meta::RouteRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::meta::RouteResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_Delete : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_Delete() {
|
||||
::grpc::Service::MarkMethodAsync(2);
|
||||
}
|
||||
~WithAsyncMethod_Delete() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::DeleteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestDelete(::grpc::ServerContext* context, ::greptime::v1::meta::DeleteRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::meta::RouteResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
typedef WithAsyncMethod_Create<WithAsyncMethod_Route<WithAsyncMethod_Delete<Service > > > AsyncService;
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_Create : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_Create() {
|
||||
::grpc::Service::MarkMethodCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::CreateRequest, ::greptime::v1::meta::RouteResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::meta::CreateRequest* request, ::greptime::v1::meta::RouteResponse* response) { return this->Create(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_Create(
|
||||
::grpc::MessageAllocator< ::greptime::v1::meta::CreateRequest, ::greptime::v1::meta::RouteResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::CreateRequest, ::greptime::v1::meta::RouteResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_Create() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Create(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::CreateRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Create(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::meta::CreateRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_Route : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_Route() {
|
||||
::grpc::Service::MarkMethodCallback(1,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::RouteRequest, ::greptime::v1::meta::RouteResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::meta::RouteRequest* request, ::greptime::v1::meta::RouteResponse* response) { return this->Route(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_Route(
|
||||
::grpc::MessageAllocator< ::greptime::v1::meta::RouteRequest, ::greptime::v1::meta::RouteResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::RouteRequest, ::greptime::v1::meta::RouteResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_Route() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Route(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RouteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Route(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::meta::RouteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_Delete : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_Delete() {
|
||||
::grpc::Service::MarkMethodCallback(2,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::DeleteRequest, ::greptime::v1::meta::RouteResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::meta::DeleteRequest* request, ::greptime::v1::meta::RouteResponse* response) { return this->Delete(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_Delete(
|
||||
::grpc::MessageAllocator< ::greptime::v1::meta::DeleteRequest, ::greptime::v1::meta::RouteResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::meta::DeleteRequest, ::greptime::v1::meta::RouteResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_Delete() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::DeleteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Delete(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::meta::DeleteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
typedef WithCallbackMethod_Create<WithCallbackMethod_Route<WithCallbackMethod_Delete<Service > > > CallbackService;
|
||||
typedef CallbackService ExperimentalCallbackService;
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_Create : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_Create() {
|
||||
::grpc::Service::MarkMethodGeneric(0);
|
||||
}
|
||||
~WithGenericMethod_Create() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Create(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::CreateRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_Route : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_Route() {
|
||||
::grpc::Service::MarkMethodGeneric(1);
|
||||
}
|
||||
~WithGenericMethod_Route() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Route(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RouteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_Delete : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_Delete() {
|
||||
::grpc::Service::MarkMethodGeneric(2);
|
||||
}
|
||||
~WithGenericMethod_Delete() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::DeleteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_Create : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_Create() {
|
||||
::grpc::Service::MarkMethodRaw(0);
|
||||
}
|
||||
~WithRawMethod_Create() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Create(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::CreateRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestCreate(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_Route : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_Route() {
|
||||
::grpc::Service::MarkMethodRaw(1);
|
||||
}
|
||||
~WithRawMethod_Route() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Route(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RouteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestRoute(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_Delete : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_Delete() {
|
||||
::grpc::Service::MarkMethodRaw(2);
|
||||
}
|
||||
~WithRawMethod_Delete() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::DeleteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestDelete(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_Create : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_Create() {
|
||||
::grpc::Service::MarkMethodRawCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Create(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_Create() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Create(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::CreateRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Create(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_Route : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_Route() {
|
||||
::grpc::Service::MarkMethodRawCallback(1,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Route(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_Route() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Route(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RouteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Route(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_Delete : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_Delete() {
|
||||
::grpc::Service::MarkMethodRawCallback(2,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Delete(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_Delete() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::DeleteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Delete(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_Create : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_Create() {
|
||||
::grpc::Service::MarkMethodStreamed(0,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::meta::CreateRequest, ::greptime::v1::meta::RouteResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::meta::CreateRequest, ::greptime::v1::meta::RouteResponse>* streamer) {
|
||||
return this->StreamedCreate(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_Create() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status Create(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::CreateRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedCreate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::meta::CreateRequest,::greptime::v1::meta::RouteResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_Route : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_Route() {
|
||||
::grpc::Service::MarkMethodStreamed(1,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::meta::RouteRequest, ::greptime::v1::meta::RouteResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::meta::RouteRequest, ::greptime::v1::meta::RouteResponse>* streamer) {
|
||||
return this->StreamedRoute(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_Route() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status Route(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::RouteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedRoute(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::meta::RouteRequest,::greptime::v1::meta::RouteResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_Delete : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_Delete() {
|
||||
::grpc::Service::MarkMethodStreamed(2,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::meta::DeleteRequest, ::greptime::v1::meta::RouteResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::meta::DeleteRequest, ::greptime::v1::meta::RouteResponse>* streamer) {
|
||||
return this->StreamedDelete(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_Delete() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::greptime::v1::meta::DeleteRequest* /*request*/, ::greptime::v1::meta::RouteResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedDelete(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::meta::DeleteRequest,::greptime::v1::meta::RouteResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
typedef WithStreamedUnaryMethod_Create<WithStreamedUnaryMethod_Route<WithStreamedUnaryMethod_Delete<Service > > > StreamedUnaryService;
|
||||
typedef Service SplitStreamedService;
|
||||
typedef WithStreamedUnaryMethod_Create<WithStreamedUnaryMethod_Route<WithStreamedUnaryMethod_Delete<Service > > > StreamedService;
|
||||
};
|
||||
|
||||
} // namespace meta
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fmeta_2froute_2eproto__INCLUDED
|
||||
@@ -0,0 +1,384 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/meta/store.proto
|
||||
|
||||
#include "greptime/v1/meta/store.pb.h"
|
||||
#include "greptime/v1/meta/store.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
namespace meta {
|
||||
|
||||
static const char* Store_method_names[] = {
|
||||
"/greptime.v1.meta.Store/Range",
|
||||
"/greptime.v1.meta.Store/Put",
|
||||
"/greptime.v1.meta.Store/BatchGet",
|
||||
"/greptime.v1.meta.Store/BatchPut",
|
||||
"/greptime.v1.meta.Store/BatchDelete",
|
||||
"/greptime.v1.meta.Store/CompareAndPut",
|
||||
"/greptime.v1.meta.Store/DeleteRange",
|
||||
"/greptime.v1.meta.Store/MoveValue",
|
||||
};
|
||||
|
||||
std::unique_ptr< Store::Stub> Store::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
|
||||
(void)options;
|
||||
std::unique_ptr< Store::Stub> stub(new Store::Stub(channel, options));
|
||||
return stub;
|
||||
}
|
||||
|
||||
Store::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
|
||||
: channel_(channel), rpcmethod_Range_(Store_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_Put_(Store_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_BatchGet_(Store_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_BatchPut_(Store_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_BatchDelete_(Store_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_CompareAndPut_(Store_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_DeleteRange_(Store_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
, rpcmethod_MoveValue_(Store_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
{}
|
||||
|
||||
::grpc::Status Store::Stub::Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::greptime::v1::meta::RangeResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Range_, context, request, response);
|
||||
}
|
||||
|
||||
void Store::Stub::async::Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Range_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Store::Stub::async::Range(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Range_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RangeResponse>* Store::Stub::PrepareAsyncRangeRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::RangeResponse, ::greptime::v1::meta::RangeRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Range_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::RangeResponse>* Store::Stub::AsyncRangeRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::RangeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncRangeRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Store::Stub::Put(::grpc::ClientContext* context, const ::greptime::v1::meta::PutRequest& request, ::greptime::v1::meta::PutResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::PutRequest, ::greptime::v1::meta::PutResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Put_, context, request, response);
|
||||
}
|
||||
|
||||
void Store::Stub::async::Put(::grpc::ClientContext* context, const ::greptime::v1::meta::PutRequest* request, ::greptime::v1::meta::PutResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::PutRequest, ::greptime::v1::meta::PutResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Put_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Store::Stub::async::Put(::grpc::ClientContext* context, const ::greptime::v1::meta::PutRequest* request, ::greptime::v1::meta::PutResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Put_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::PutResponse>* Store::Stub::PrepareAsyncPutRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::PutRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::PutResponse, ::greptime::v1::meta::PutRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Put_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::PutResponse>* Store::Stub::AsyncPutRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::PutRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncPutRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Store::Stub::BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::greptime::v1::meta::BatchGetResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_BatchGet_, context, request, response);
|
||||
}
|
||||
|
||||
void Store::Stub::async::BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BatchGet_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Store::Stub::async::BatchGet(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BatchGet_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchGetResponse>* Store::Stub::PrepareAsyncBatchGetRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::BatchGetResponse, ::greptime::v1::meta::BatchGetRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_BatchGet_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchGetResponse>* Store::Stub::AsyncBatchGetRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchGetRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncBatchGetRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Store::Stub::BatchPut(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchPutRequest& request, ::greptime::v1::meta::BatchPutResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::BatchPutRequest, ::greptime::v1::meta::BatchPutResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_BatchPut_, context, request, response);
|
||||
}
|
||||
|
||||
void Store::Stub::async::BatchPut(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchPutRequest* request, ::greptime::v1::meta::BatchPutResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::BatchPutRequest, ::greptime::v1::meta::BatchPutResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BatchPut_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Store::Stub::async::BatchPut(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchPutRequest* request, ::greptime::v1::meta::BatchPutResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BatchPut_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchPutResponse>* Store::Stub::PrepareAsyncBatchPutRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchPutRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::BatchPutResponse, ::greptime::v1::meta::BatchPutRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_BatchPut_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchPutResponse>* Store::Stub::AsyncBatchPutRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchPutRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncBatchPutRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Store::Stub::BatchDelete(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchDeleteRequest& request, ::greptime::v1::meta::BatchDeleteResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::BatchDeleteRequest, ::greptime::v1::meta::BatchDeleteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_BatchDelete_, context, request, response);
|
||||
}
|
||||
|
||||
void Store::Stub::async::BatchDelete(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchDeleteRequest* request, ::greptime::v1::meta::BatchDeleteResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::BatchDeleteRequest, ::greptime::v1::meta::BatchDeleteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BatchDelete_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Store::Stub::async::BatchDelete(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchDeleteRequest* request, ::greptime::v1::meta::BatchDeleteResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BatchDelete_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchDeleteResponse>* Store::Stub::PrepareAsyncBatchDeleteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchDeleteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::BatchDeleteResponse, ::greptime::v1::meta::BatchDeleteRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_BatchDelete_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::BatchDeleteResponse>* Store::Stub::AsyncBatchDeleteRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::BatchDeleteRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncBatchDeleteRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Store::Stub::CompareAndPut(::grpc::ClientContext* context, const ::greptime::v1::meta::CompareAndPutRequest& request, ::greptime::v1::meta::CompareAndPutResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::CompareAndPutRequest, ::greptime::v1::meta::CompareAndPutResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_CompareAndPut_, context, request, response);
|
||||
}
|
||||
|
||||
void Store::Stub::async::CompareAndPut(::grpc::ClientContext* context, const ::greptime::v1::meta::CompareAndPutRequest* request, ::greptime::v1::meta::CompareAndPutResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::CompareAndPutRequest, ::greptime::v1::meta::CompareAndPutResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CompareAndPut_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Store::Stub::async::CompareAndPut(::grpc::ClientContext* context, const ::greptime::v1::meta::CompareAndPutRequest* request, ::greptime::v1::meta::CompareAndPutResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CompareAndPut_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::CompareAndPutResponse>* Store::Stub::PrepareAsyncCompareAndPutRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::CompareAndPutRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::CompareAndPutResponse, ::greptime::v1::meta::CompareAndPutRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_CompareAndPut_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::CompareAndPutResponse>* Store::Stub::AsyncCompareAndPutRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::CompareAndPutRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncCompareAndPutRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Store::Stub::DeleteRange(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRangeRequest& request, ::greptime::v1::meta::DeleteRangeResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::DeleteRangeRequest, ::greptime::v1::meta::DeleteRangeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeleteRange_, context, request, response);
|
||||
}
|
||||
|
||||
void Store::Stub::async::DeleteRange(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRangeRequest* request, ::greptime::v1::meta::DeleteRangeResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::DeleteRangeRequest, ::greptime::v1::meta::DeleteRangeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteRange_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Store::Stub::async::DeleteRange(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRangeRequest* request, ::greptime::v1::meta::DeleteRangeResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteRange_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::DeleteRangeResponse>* Store::Stub::PrepareAsyncDeleteRangeRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRangeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::DeleteRangeResponse, ::greptime::v1::meta::DeleteRangeRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeleteRange_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::DeleteRangeResponse>* Store::Stub::AsyncDeleteRangeRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::DeleteRangeRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncDeleteRangeRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
::grpc::Status Store::Stub::MoveValue(::grpc::ClientContext* context, const ::greptime::v1::meta::MoveValueRequest& request, ::greptime::v1::meta::MoveValueResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::meta::MoveValueRequest, ::greptime::v1::meta::MoveValueResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_MoveValue_, context, request, response);
|
||||
}
|
||||
|
||||
void Store::Stub::async::MoveValue(::grpc::ClientContext* context, const ::greptime::v1::meta::MoveValueRequest* request, ::greptime::v1::meta::MoveValueResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::meta::MoveValueRequest, ::greptime::v1::meta::MoveValueResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_MoveValue_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void Store::Stub::async::MoveValue(::grpc::ClientContext* context, const ::greptime::v1::meta::MoveValueRequest* request, ::greptime::v1::meta::MoveValueResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_MoveValue_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::MoveValueResponse>* Store::Stub::PrepareAsyncMoveValueRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::MoveValueRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::meta::MoveValueResponse, ::greptime::v1::meta::MoveValueRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_MoveValue_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::meta::MoveValueResponse>* Store::Stub::AsyncMoveValueRaw(::grpc::ClientContext* context, const ::greptime::v1::meta::MoveValueRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncMoveValueRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
Store::Service::Service() {
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Store_method_names[0],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Store::Service, ::greptime::v1::meta::RangeRequest, ::greptime::v1::meta::RangeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Store::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::RangeRequest* req,
|
||||
::greptime::v1::meta::RangeResponse* resp) {
|
||||
return service->Range(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Store_method_names[1],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Store::Service, ::greptime::v1::meta::PutRequest, ::greptime::v1::meta::PutResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Store::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::PutRequest* req,
|
||||
::greptime::v1::meta::PutResponse* resp) {
|
||||
return service->Put(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Store_method_names[2],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Store::Service, ::greptime::v1::meta::BatchGetRequest, ::greptime::v1::meta::BatchGetResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Store::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::BatchGetRequest* req,
|
||||
::greptime::v1::meta::BatchGetResponse* resp) {
|
||||
return service->BatchGet(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Store_method_names[3],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Store::Service, ::greptime::v1::meta::BatchPutRequest, ::greptime::v1::meta::BatchPutResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Store::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::BatchPutRequest* req,
|
||||
::greptime::v1::meta::BatchPutResponse* resp) {
|
||||
return service->BatchPut(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Store_method_names[4],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Store::Service, ::greptime::v1::meta::BatchDeleteRequest, ::greptime::v1::meta::BatchDeleteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Store::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::BatchDeleteRequest* req,
|
||||
::greptime::v1::meta::BatchDeleteResponse* resp) {
|
||||
return service->BatchDelete(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Store_method_names[5],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Store::Service, ::greptime::v1::meta::CompareAndPutRequest, ::greptime::v1::meta::CompareAndPutResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Store::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::CompareAndPutRequest* req,
|
||||
::greptime::v1::meta::CompareAndPutResponse* resp) {
|
||||
return service->CompareAndPut(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Store_method_names[6],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Store::Service, ::greptime::v1::meta::DeleteRangeRequest, ::greptime::v1::meta::DeleteRangeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Store::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::DeleteRangeRequest* req,
|
||||
::greptime::v1::meta::DeleteRangeResponse* resp) {
|
||||
return service->DeleteRange(ctx, req, resp);
|
||||
}, this)));
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
Store_method_names[7],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< Store::Service, ::greptime::v1::meta::MoveValueRequest, ::greptime::v1::meta::MoveValueResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](Store::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::meta::MoveValueRequest* req,
|
||||
::greptime::v1::meta::MoveValueResponse* resp) {
|
||||
return service->MoveValue(ctx, req, resp);
|
||||
}, this)));
|
||||
}
|
||||
|
||||
Store::Service::~Service() {
|
||||
}
|
||||
|
||||
::grpc::Status Store::Service::Range(::grpc::ServerContext* context, const ::greptime::v1::meta::RangeRequest* request, ::greptime::v1::meta::RangeResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Store::Service::Put(::grpc::ServerContext* context, const ::greptime::v1::meta::PutRequest* request, ::greptime::v1::meta::PutResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Store::Service::BatchGet(::grpc::ServerContext* context, const ::greptime::v1::meta::BatchGetRequest* request, ::greptime::v1::meta::BatchGetResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Store::Service::BatchPut(::grpc::ServerContext* context, const ::greptime::v1::meta::BatchPutRequest* request, ::greptime::v1::meta::BatchPutResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Store::Service::BatchDelete(::grpc::ServerContext* context, const ::greptime::v1::meta::BatchDeleteRequest* request, ::greptime::v1::meta::BatchDeleteResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Store::Service::CompareAndPut(::grpc::ServerContext* context, const ::greptime::v1::meta::CompareAndPutRequest* request, ::greptime::v1::meta::CompareAndPutResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Store::Service::DeleteRange(::grpc::ServerContext* context, const ::greptime::v1::meta::DeleteRangeRequest* request, ::greptime::v1::meta::DeleteRangeResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
::grpc::Status Store::Service::MoveValue(::grpc::ServerContext* context, const ::greptime::v1::meta::MoveValueRequest* request, ::greptime::v1::meta::MoveValueResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
} // namespace meta
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,88 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/prom.proto
|
||||
|
||||
#include "greptime/v1/prom.pb.h"
|
||||
#include "greptime/v1/prom.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
static const char* PrometheusGateway_method_names[] = {
|
||||
"/greptime.v1.PrometheusGateway/Handle",
|
||||
};
|
||||
|
||||
std::unique_ptr< PrometheusGateway::Stub> PrometheusGateway::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
|
||||
(void)options;
|
||||
std::unique_ptr< PrometheusGateway::Stub> stub(new PrometheusGateway::Stub(channel, options));
|
||||
return stub;
|
||||
}
|
||||
|
||||
PrometheusGateway::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
|
||||
: channel_(channel), rpcmethod_Handle_(PrometheusGateway_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
|
||||
{}
|
||||
|
||||
::grpc::Status PrometheusGateway::Stub::Handle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::greptime::v1::PromqlResponse* response) {
|
||||
return ::grpc::internal::BlockingUnaryCall< ::greptime::v1::PromqlRequest, ::greptime::v1::PromqlResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Handle_, context, request, response);
|
||||
}
|
||||
|
||||
void PrometheusGateway::Stub::async::Handle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest* request, ::greptime::v1::PromqlResponse* response, std::function<void(::grpc::Status)> f) {
|
||||
::grpc::internal::CallbackUnaryCall< ::greptime::v1::PromqlRequest, ::greptime::v1::PromqlResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Handle_, context, request, response, std::move(f));
|
||||
}
|
||||
|
||||
void PrometheusGateway::Stub::async::Handle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest* request, ::greptime::v1::PromqlResponse* response, ::grpc::ClientUnaryReactor* reactor) {
|
||||
::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Handle_, context, request, response, reactor);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::PromqlResponse>* PrometheusGateway::Stub::PrepareAsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::greptime::v1::PromqlResponse, ::greptime::v1::PromqlRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Handle_, context, request);
|
||||
}
|
||||
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::PromqlResponse>* PrometheusGateway::Stub::AsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
auto* result =
|
||||
this->PrepareAsyncHandleRaw(context, request, cq);
|
||||
result->StartCall();
|
||||
return result;
|
||||
}
|
||||
|
||||
PrometheusGateway::Service::Service() {
|
||||
AddMethod(new ::grpc::internal::RpcServiceMethod(
|
||||
PrometheusGateway_method_names[0],
|
||||
::grpc::internal::RpcMethod::NORMAL_RPC,
|
||||
new ::grpc::internal::RpcMethodHandler< PrometheusGateway::Service, ::greptime::v1::PromqlRequest, ::greptime::v1::PromqlResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
|
||||
[](PrometheusGateway::Service* service,
|
||||
::grpc::ServerContext* ctx,
|
||||
const ::greptime::v1::PromqlRequest* req,
|
||||
::greptime::v1::PromqlResponse* resp) {
|
||||
return service->Handle(ctx, req, resp);
|
||||
}, this)));
|
||||
}
|
||||
|
||||
PrometheusGateway::Service::~Service() {
|
||||
}
|
||||
|
||||
::grpc::Status PrometheusGateway::Service::Handle(::grpc::ServerContext* context, const ::greptime::v1::PromqlRequest* request, ::greptime::v1::PromqlResponse* response) {
|
||||
(void) context;
|
||||
(void) request;
|
||||
(void) response;
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
|
||||
|
||||
} // namespace greptime
|
||||
} // namespace v1
|
||||
|
||||
@@ -0,0 +1,258 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: greptime/v1/prom.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_greptime_2fv1_2fprom_2eproto__INCLUDED
|
||||
#define GRPC_greptime_2fv1_2fprom_2eproto__INCLUDED
|
||||
|
||||
#include "greptime/v1/prom.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace greptime {
|
||||
namespace v1 {
|
||||
|
||||
// PrometheusGateway behaves absolutely the same as Prometheus HTTP API
|
||||
class PrometheusGateway final {
|
||||
public:
|
||||
static constexpr char const* service_full_name() {
|
||||
return "greptime.v1.PrometheusGateway";
|
||||
}
|
||||
class StubInterface {
|
||||
public:
|
||||
virtual ~StubInterface() {}
|
||||
virtual ::grpc::Status Handle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::greptime::v1::PromqlResponse* response) = 0;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::PromqlResponse>> AsyncHandle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::PromqlResponse>>(AsyncHandleRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::PromqlResponse>> PrepareAsyncHandle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::PromqlResponse>>(PrepareAsyncHandleRaw(context, request, cq));
|
||||
}
|
||||
class async_interface {
|
||||
public:
|
||||
virtual ~async_interface() {}
|
||||
virtual void Handle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest* request, ::greptime::v1::PromqlResponse* response, std::function<void(::grpc::Status)>) = 0;
|
||||
virtual void Handle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest* request, ::greptime::v1::PromqlResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
|
||||
};
|
||||
typedef class async_interface experimental_async_interface;
|
||||
virtual class async_interface* async() { return nullptr; }
|
||||
class async_interface* experimental_async() { return async(); }
|
||||
private:
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::PromqlResponse>* AsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
virtual ::grpc::ClientAsyncResponseReaderInterface< ::greptime::v1::PromqlResponse>* PrepareAsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::grpc::CompletionQueue* cq) = 0;
|
||||
};
|
||||
class Stub final : public StubInterface {
|
||||
public:
|
||||
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
::grpc::Status Handle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::greptime::v1::PromqlResponse* response) override;
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::PromqlResponse>> AsyncHandle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::PromqlResponse>>(AsyncHandleRaw(context, request, cq));
|
||||
}
|
||||
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::PromqlResponse>> PrepareAsyncHandle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::grpc::CompletionQueue* cq) {
|
||||
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::greptime::v1::PromqlResponse>>(PrepareAsyncHandleRaw(context, request, cq));
|
||||
}
|
||||
class async final :
|
||||
public StubInterface::async_interface {
|
||||
public:
|
||||
void Handle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest* request, ::greptime::v1::PromqlResponse* response, std::function<void(::grpc::Status)>) override;
|
||||
void Handle(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest* request, ::greptime::v1::PromqlResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
|
||||
private:
|
||||
friend class Stub;
|
||||
explicit async(Stub* stub): stub_(stub) { }
|
||||
Stub* stub() { return stub_; }
|
||||
Stub* stub_;
|
||||
};
|
||||
class async* async() override { return &async_stub_; }
|
||||
|
||||
private:
|
||||
std::shared_ptr< ::grpc::ChannelInterface> channel_;
|
||||
class async async_stub_{this};
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::PromqlResponse>* AsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
::grpc::ClientAsyncResponseReader< ::greptime::v1::PromqlResponse>* PrepareAsyncHandleRaw(::grpc::ClientContext* context, const ::greptime::v1::PromqlRequest& request, ::grpc::CompletionQueue* cq) override;
|
||||
const ::grpc::internal::RpcMethod rpcmethod_Handle_;
|
||||
};
|
||||
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
|
||||
|
||||
class Service : public ::grpc::Service {
|
||||
public:
|
||||
Service();
|
||||
virtual ~Service();
|
||||
virtual ::grpc::Status Handle(::grpc::ServerContext* context, const ::greptime::v1::PromqlRequest* request, ::greptime::v1::PromqlResponse* response);
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithAsyncMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithAsyncMethod_Handle() {
|
||||
::grpc::Service::MarkMethodAsync(0);
|
||||
}
|
||||
~WithAsyncMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::PromqlRequest* /*request*/, ::greptime::v1::PromqlResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestHandle(::grpc::ServerContext* context, ::greptime::v1::PromqlRequest* request, ::grpc::ServerAsyncResponseWriter< ::greptime::v1::PromqlResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
typedef WithAsyncMethod_Handle<Service > AsyncService;
|
||||
template <class BaseClass>
|
||||
class WithCallbackMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithCallbackMethod_Handle() {
|
||||
::grpc::Service::MarkMethodCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::greptime::v1::PromqlRequest, ::greptime::v1::PromqlResponse>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::greptime::v1::PromqlRequest* request, ::greptime::v1::PromqlResponse* response) { return this->Handle(context, request, response); }));}
|
||||
void SetMessageAllocatorFor_Handle(
|
||||
::grpc::MessageAllocator< ::greptime::v1::PromqlRequest, ::greptime::v1::PromqlResponse>* allocator) {
|
||||
::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
|
||||
static_cast<::grpc::internal::CallbackUnaryHandler< ::greptime::v1::PromqlRequest, ::greptime::v1::PromqlResponse>*>(handler)
|
||||
->SetMessageAllocator(allocator);
|
||||
}
|
||||
~WithCallbackMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::PromqlRequest* /*request*/, ::greptime::v1::PromqlResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Handle(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::greptime::v1::PromqlRequest* /*request*/, ::greptime::v1::PromqlResponse* /*response*/) { return nullptr; }
|
||||
};
|
||||
typedef WithCallbackMethod_Handle<Service > CallbackService;
|
||||
typedef CallbackService ExperimentalCallbackService;
|
||||
template <class BaseClass>
|
||||
class WithGenericMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithGenericMethod_Handle() {
|
||||
::grpc::Service::MarkMethodGeneric(0);
|
||||
}
|
||||
~WithGenericMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::PromqlRequest* /*request*/, ::greptime::v1::PromqlResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawMethod_Handle() {
|
||||
::grpc::Service::MarkMethodRaw(0);
|
||||
}
|
||||
~WithRawMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::PromqlRequest* /*request*/, ::greptime::v1::PromqlResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
void RequestHandle(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
|
||||
::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
|
||||
}
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithRawCallbackMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithRawCallbackMethod_Handle() {
|
||||
::grpc::Service::MarkMethodRawCallback(0,
|
||||
new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
|
||||
[this](
|
||||
::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Handle(context, request, response); }));
|
||||
}
|
||||
~WithRawCallbackMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable synchronous version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::PromqlRequest* /*request*/, ::greptime::v1::PromqlResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
virtual ::grpc::ServerUnaryReactor* Handle(
|
||||
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
|
||||
};
|
||||
template <class BaseClass>
|
||||
class WithStreamedUnaryMethod_Handle : public BaseClass {
|
||||
private:
|
||||
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
|
||||
public:
|
||||
WithStreamedUnaryMethod_Handle() {
|
||||
::grpc::Service::MarkMethodStreamed(0,
|
||||
new ::grpc::internal::StreamedUnaryHandler<
|
||||
::greptime::v1::PromqlRequest, ::greptime::v1::PromqlResponse>(
|
||||
[this](::grpc::ServerContext* context,
|
||||
::grpc::ServerUnaryStreamer<
|
||||
::greptime::v1::PromqlRequest, ::greptime::v1::PromqlResponse>* streamer) {
|
||||
return this->StreamedHandle(context,
|
||||
streamer);
|
||||
}));
|
||||
}
|
||||
~WithStreamedUnaryMethod_Handle() override {
|
||||
BaseClassMustBeDerivedFromService(this);
|
||||
}
|
||||
// disable regular version of this method
|
||||
::grpc::Status Handle(::grpc::ServerContext* /*context*/, const ::greptime::v1::PromqlRequest* /*request*/, ::greptime::v1::PromqlResponse* /*response*/) override {
|
||||
abort();
|
||||
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
|
||||
}
|
||||
// replace default version of method with streamed unary
|
||||
virtual ::grpc::Status StreamedHandle(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::greptime::v1::PromqlRequest,::greptime::v1::PromqlResponse>* server_unary_streamer) = 0;
|
||||
};
|
||||
typedef WithStreamedUnaryMethod_Handle<Service > StreamedUnaryService;
|
||||
typedef Service SplitStreamedService;
|
||||
typedef WithStreamedUnaryMethod_Handle<Service > StreamedService;
|
||||
};
|
||||
|
||||
} // namespace v1
|
||||
} // namespace greptime
|
||||
|
||||
|
||||
#endif // GRPC_greptime_2fv1_2fprom_2eproto__INCLUDED
|
||||
@@ -0,0 +1,25 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: prometheus/remote/remote.proto
|
||||
|
||||
#include "prometheus/remote/remote.pb.h"
|
||||
#include "prometheus/remote/remote.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace prometheus {
|
||||
|
||||
} // namespace prometheus
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: prometheus/remote/remote.proto
|
||||
// Original file comments:
|
||||
// Copyright 2016 Prometheus Team
|
||||
// Licensed 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 GRPC_prometheus_2fremote_2fremote_2eproto__INCLUDED
|
||||
#define GRPC_prometheus_2fremote_2fremote_2eproto__INCLUDED
|
||||
|
||||
#include "prometheus/remote/remote.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace prometheus {
|
||||
|
||||
} // namespace prometheus
|
||||
|
||||
|
||||
#endif // GRPC_prometheus_2fremote_2fremote_2eproto__INCLUDED
|
||||
@@ -0,0 +1,25 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: prometheus/remote/types.proto
|
||||
|
||||
#include "prometheus/remote/types.pb.h"
|
||||
#include "prometheus/remote/types.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace prometheus {
|
||||
|
||||
} // namespace prometheus
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: prometheus/remote/types.proto
|
||||
// Original file comments:
|
||||
// Copyright 2017 Prometheus Team
|
||||
// Licensed 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 GRPC_prometheus_2fremote_2ftypes_2eproto__INCLUDED
|
||||
#define GRPC_prometheus_2fremote_2ftypes_2eproto__INCLUDED
|
||||
|
||||
#include "prometheus/remote/types.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace prometheus {
|
||||
|
||||
} // namespace prometheus
|
||||
|
||||
|
||||
#endif // GRPC_prometheus_2fremote_2ftypes_2eproto__INCLUDED
|
||||
@@ -0,0 +1,25 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: substrait_extension/promql_plan.proto
|
||||
|
||||
#include "substrait_extension/promql_plan.pb.h"
|
||||
#include "substrait_extension/promql_plan.grpc.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/impl/channel_interface.h>
|
||||
#include <grpcpp/impl/client_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/rpc_service_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
namespace substrait_extension {
|
||||
|
||||
} // namespace substrait_extension
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
// Generated by the gRPC C++ plugin.
|
||||
// If you make any local change, they will be lost.
|
||||
// source: substrait_extension/promql_plan.proto
|
||||
// Original file comments:
|
||||
// Copyright 2023 Greptime Team
|
||||
//
|
||||
// Licensed 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 GRPC_substrait_5fextension_2fpromql_5fplan_2eproto__INCLUDED
|
||||
#define GRPC_substrait_5fextension_2fpromql_5fplan_2eproto__INCLUDED
|
||||
|
||||
#include "substrait_extension/promql_plan.pb.h"
|
||||
|
||||
#include <functional>
|
||||
#include <grpcpp/generic/async_generic_service.h>
|
||||
#include <grpcpp/support/async_stream.h>
|
||||
#include <grpcpp/support/async_unary_call.h>
|
||||
#include <grpcpp/support/client_callback.h>
|
||||
#include <grpcpp/client_context.h>
|
||||
#include <grpcpp/completion_queue.h>
|
||||
#include <grpcpp/support/message_allocator.h>
|
||||
#include <grpcpp/support/method_handler.h>
|
||||
#include <grpcpp/impl/codegen/proto_utils.h>
|
||||
#include <grpcpp/impl/rpc_method.h>
|
||||
#include <grpcpp/support/server_callback.h>
|
||||
#include <grpcpp/impl/codegen/server_callback_handlers.h>
|
||||
#include <grpcpp/server_context.h>
|
||||
#include <grpcpp/impl/service_type.h>
|
||||
#include <grpcpp/impl/codegen/status.h>
|
||||
#include <grpcpp/support/stub_options.h>
|
||||
#include <grpcpp/support/sync_stream.h>
|
||||
|
||||
namespace substrait_extension {
|
||||
|
||||
} // namespace substrait_extension
|
||||
|
||||
|
||||
#endif // GRPC_substrait_5fextension_2fpromql_5fplan_2eproto__INCLUDED
|
||||
@@ -5,4 +5,5 @@ set -e
|
||||
PROTO_ROOT=./proto
|
||||
CPP_OUTPUT=./c++
|
||||
|
||||
protoc --proto_path=proto/ --cpp_out=${CPP_OUTPUT} $(find ./proto/ -type f -iname "*.proto")
|
||||
protoc -I ${PROTO_ROOT} --cpp_out=${CPP_OUTPUT} $(find ./proto/ -type f -iname "*.proto")
|
||||
protoc -I ${PROTO_ROOT} --grpc_out=${CPP_OUTPUT} --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` $(find ./proto/ -type f -iname "*.proto")
|
||||
|
||||
Reference in New Issue
Block a user