Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Revert "Remove `include/grpcpp/impl/codegen/async_unary_call.h` (#30945)" (#30950)

Browse Source 
This reverts commit 7dbc73d4f3.
pull/30956/head
Craig Tiller 2 years ago committed by GitHub
parent a81b61113c
commit 0c454fa875
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 400 additions and 400 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 399
      include/grpcpp/impl/codegen/async_unary_call.h
  2. 395
      include/grpcpp/support/async_unary_call.h
  3. 4
      src/compiler/cpp_generator.cc
  4. 2
      test/cpp/codegen/compiler_test_golden

399
include/grpcpp/impl/codegen/async_unary_call.h
Unescape View File

@ -19,9 +19,402 @@
#ifndef GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H #ifndef GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
#define GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H #define GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
// IWYU pragma: private // IWYU pragma: private, include <grpcpp/support/async_unary_call.h>
/// TODO(chengyuc): Remove this file after solving compatibility. #include <grpcpp/impl/codegen/call.h>
#include <grpcpp/support/async_unary_call.h> #include <grpcpp/impl/codegen/call_op_set.h>
#include <grpcpp/impl/codegen/call_op_set_interface.h>
#include <grpcpp/impl/codegen/channel_interface.h>
#include <grpcpp/impl/codegen/client_context.h>
#include <grpcpp/impl/codegen/server_context.h>
#include <grpcpp/impl/codegen/service_type.h>
#include <grpcpp/impl/codegen/status.h>
namespace grpc {
// Forward declaration for use in Helper class
template <class R>
class ClientAsyncResponseReader;
/// An interface relevant for async client side unary RPCs (which send
/// one request message to a server and receive one response message).
template <class R>
class ClientAsyncResponseReaderInterface {
public:
virtual ~ClientAsyncResponseReaderInterface() {}
/// Start the call that was set up by the constructor, but only if the
/// constructor was invoked through the "Prepare" API which doesn't actually
/// start the call
virtual void StartCall() = 0;
/// Request notification of the reading of initial metadata. Completion
/// will be notified by \a tag on the associated completion queue.
/// This call is optional, but if it is used, it cannot be used concurrently
/// with or after the \a Finish method.
///
/// \param[in] tag Tag identifying this request.
virtual void ReadInitialMetadata(void* tag) = 0;
/// Request to receive the server's response \a msg and final \a status for
/// the call, and to notify \a tag on this call's completion queue when
/// finished.
///
/// This function will return when either:
/// - when the server's response message and status have been received.
/// - when the server has returned a non-OK status (no message expected in
/// this case).
/// - when the call failed for some reason and the library generated a
/// non-OK status.
///
/// \param[in] tag Tag identifying this request.
/// \param[out] status To be updated with the operation status.
/// \param[out] msg To be filled in with the server's response message.
virtual void Finish(R* msg, grpc::Status* status, void* tag) = 0;
};
namespace internal {
class ClientAsyncResponseReaderHelper {
public:
/// Start a call and write the request out if \a start is set.
/// \a tag will be notified on \a cq when the call has been started (i.e.
/// intitial metadata sent) and \a request has been written out.
/// If \a start is not set, the actual call must be initiated by StartCall
/// Note that \a context will be used to fill in custom initial metadata
/// used to send to the server when starting the call.
///
/// Optionally pass in a base class for request and response types so that the
/// internal functions and structs can be templated based on that, allowing
/// reuse across RPCs (e.g., MessageLite for protobuf). Since constructors
/// can't have an explicit template parameter, the last argument is an
/// extraneous parameter just to provide the needed type information.
template <class R, class W, class BaseR = R, class BaseW = W>
static ClientAsyncResponseReader<R>* Create(
grpc::ChannelInterface* channel, grpc::CompletionQueue* cq,
const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
const W& request) /* __attribute__((noinline)) */ {
grpc::internal::Call call = channel->CreateCall(method, context, cq);
ClientAsyncResponseReader<R>* result =
new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
call.call(), sizeof(ClientAsyncResponseReader<R>)))
ClientAsyncResponseReader<R>(call, context);
SetupRequest<BaseR, BaseW>(
call.call(), &result->single_buf_, &result->read_initial_metadata_,
&result->finish_, static_cast<const BaseW&>(request));
return result;
}
// Various helper functions to reduce templating use
template <class R, class W>
static void SetupRequest(
grpc_call* call,
grpc::internal::CallOpSendInitialMetadata** single_buf_ptr,
std::function<void(ClientContext*, internal::Call*,
internal::CallOpSendInitialMetadata*, void*)>*
read_initial_metadata,
std::function<
void(ClientContext*, internal::Call*, bool initial_metadata_read,
internal::CallOpSendInitialMetadata*,
internal::CallOpSetInterface**, void*, Status*, void*)>* finish,
const W& request) {
using SingleBufType =
grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
grpc::internal::CallOpSendMessage,
grpc::internal::CallOpClientSendClose,
grpc::internal::CallOpRecvInitialMetadata,
grpc::internal::CallOpRecvMessage<R>,
grpc::internal::CallOpClientRecvStatus>;
SingleBufType* single_buf =
new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
call, sizeof(SingleBufType))) SingleBufType;
*single_buf_ptr = single_buf;
// TODO(ctiller): don't assert
GPR_CODEGEN_ASSERT(single_buf->SendMessage(request).ok());
single_buf->ClientSendClose();
// The purpose of the following functions is to type-erase the actual
// templated type of the CallOpSet being used by hiding that type inside the
// function definition rather than specifying it as an argument of the
// function or a member of the class. The type-erased CallOpSet will get
// static_cast'ed back to the real type so that it can be used properly.
*read_initial_metadata =
[](ClientContext* context, internal::Call* call,
internal::CallOpSendInitialMetadata* single_buf_view, void* tag) {
auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
single_buf->set_output_tag(tag);
single_buf->RecvInitialMetadata(context);
call->PerformOps(single_buf);
};
// Note that this function goes one step further than the previous one
// because it type-erases the message being written down to a void*. This
// will be static-cast'ed back to the class specified here by hiding that
// class information inside the function definition. Note that this feature
// expects the class being specified here for R to be a base-class of the
// "real" R without any multiple-inheritance (as applies in protbuf wrt
// MessageLite)
*finish = [](ClientContext* context, internal::Call* call,
bool initial_metadata_read,
internal::CallOpSendInitialMetadata* single_buf_view,
internal::CallOpSetInterface** finish_buf_ptr, void* msg,
Status* status, void* tag) {
if (initial_metadata_read) {
using FinishBufType =
grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>,
grpc::internal::CallOpClientRecvStatus>;
FinishBufType* finish_buf =
new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
call->call(), sizeof(FinishBufType))) FinishBufType;
*finish_buf_ptr = finish_buf;
finish_buf->set_output_tag(tag);
finish_buf->RecvMessage(static_cast<R*>(msg));
finish_buf->AllowNoMessage();
finish_buf->ClientRecvStatus(context, status);
call->PerformOps(finish_buf);
} else {
auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
single_buf->set_output_tag(tag);
single_buf->RecvInitialMetadata(context);
single_buf->RecvMessage(static_cast<R*>(msg));
single_buf->AllowNoMessage();
single_buf->ClientRecvStatus(context, status);
call->PerformOps(single_buf);
}
};
}
static void StartCall(grpc::ClientContext* context,
grpc::internal::CallOpSendInitialMetadata* single_buf) {
single_buf->SendInitialMetadata(&context->send_initial_metadata_,
context->initial_metadata_flags());
}
};
// TODO(vjpai): This templated factory is deprecated and will be replaced by
//. the non-templated helper as soon as possible.
template <class R>
class ClientAsyncResponseReaderFactory {
public:
template <class W>
static ClientAsyncResponseReader<R>* Create(
grpc::ChannelInterface* channel, grpc::CompletionQueue* cq,
const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
const W& request, bool start) {
auto* result = ClientAsyncResponseReaderHelper::Create<R>(
channel, cq, method, context, request);
if (start) {
result->StartCall();
}
return result;
}
};
} // namespace internal
/// Async API for client-side unary RPCs, where the message response
/// received from the server is of type \a R.
template <class R>
class ClientAsyncResponseReader final
: public ClientAsyncResponseReaderInterface<R> {
public:
// always allocated against a call arena, no memory free required
static void operator delete(void* /*ptr*/, std::size_t size) {
GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncResponseReader));
}
// This operator should never be called as the memory should be freed as part
// of the arena destruction. It only exists to provide a matching operator
// delete to the operator new so that some compilers will not complain (see
// https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
// there are no tests catching the compiler warning.
static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
void StartCall() override {
GPR_CODEGEN_DEBUG_ASSERT(!started_);
started_ = true;
internal::ClientAsyncResponseReaderHelper::StartCall(context_, single_buf_);
}
/// See \a ClientAsyncResponseReaderInterface::ReadInitialMetadata for
/// semantics.
///
/// Side effect:
/// - the \a ClientContext associated with this call is updated with
/// possible initial and trailing metadata sent from the server.
void ReadInitialMetadata(void* tag) override {
GPR_CODEGEN_DEBUG_ASSERT(started_);
GPR_CODEGEN_DEBUG_ASSERT(!context_->initial_metadata_received_);
read_initial_metadata_(context_, &call_, single_buf_, tag);
initial_metadata_read_ = true;
}
/// See \a ClientAsyncResponseReaderInterface::Finish for semantics.
///
/// Side effect:
/// - the \a ClientContext associated with this call is updated with
/// possible initial and trailing metadata sent from the server.
void Finish(R* msg, grpc::Status* status, void* tag) override {
GPR_CODEGEN_DEBUG_ASSERT(started_);
finish_(context_, &call_, initial_metadata_read_, single_buf_, &finish_buf_,
static_cast<void*>(msg), status, tag);
}
private:
friend class internal::ClientAsyncResponseReaderHelper;
grpc::ClientContext* const context_;
grpc::internal::Call call_;
bool started_ = false;
bool initial_metadata_read_ = false;
ClientAsyncResponseReader(grpc::internal::Call call,
grpc::ClientContext* context)
: context_(context), call_(call) {}
// disable operator new
static void* operator new(std::size_t size);
static void* operator new(std::size_t /*size*/, void* p) { return p; }
internal::CallOpSendInitialMetadata* single_buf_;
internal::CallOpSetInterface* finish_buf_ = nullptr;
std::function<void(ClientContext*, internal::Call*,
internal::CallOpSendInitialMetadata*, void*)>
read_initial_metadata_;
std::function<void(ClientContext*, internal::Call*,
bool initial_metadata_read,
internal::CallOpSendInitialMetadata*,
internal::CallOpSetInterface**, void*, Status*, void*)>
finish_;
};
/// Async server-side API for handling unary calls, where the single
/// response message sent to the client is of type \a W.
template <class W>
class ServerAsyncResponseWriter final
: public grpc::internal::ServerAsyncStreamingInterface {
public:
explicit ServerAsyncResponseWriter(grpc::ServerContext* ctx)
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
/// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
///
/// Side effect:
/// The initial metadata that will be sent to the client from this op will
/// be taken from the \a ServerContext associated with the call.
///
/// \param[in] tag Tag identifying this request.
void SendInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
meta_buf_.set_output_tag(tag);
meta_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
ctx_->initial_metadata_flags());
if (ctx_->compression_level_set()) {
meta_buf_.set_compression_level(ctx_->compression_level());
}
ctx_->sent_initial_metadata_ = true;
call_.PerformOps(&meta_buf_);
}
/// Indicate that the stream is to be finished and request notification
/// when the server has sent the appropriate signals to the client to
/// end the call. Should not be used concurrently with other operations.
///
/// \param[in] tag Tag identifying this request.
/// \param[in] status To be sent to the client as the result of the call.
/// \param[in] msg Message to be sent to the client.
///
/// Side effect:
/// - also sends initial metadata if not already sent (using the
/// \a ServerContext associated with this call).
///
/// Note: if \a status has a non-OK code, then \a msg will not be sent,
/// and the client will receive only the status with possible trailing
/// metadata.
///
/// gRPC doesn't take ownership or a reference to msg and status, so it is
/// safe to deallocate them once the Finish operation is complete (i.e. a
/// result arrives in the completion queue).
void Finish(const W& msg, const grpc::Status& status, void* tag) {
finish_buf_.set_output_tag(tag);
finish_buf_.set_core_cq_tag(&finish_buf_);
if (!ctx_->sent_initial_metadata_) {
finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
ctx_->initial_metadata_flags());
if (ctx_->compression_level_set()) {
finish_buf_.set_compression_level(ctx_->compression_level());
}
ctx_->sent_initial_metadata_ = true;
}
// The response is dropped if the status is not OK.
if (status.ok()) {
finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_,
finish_buf_.SendMessage(msg));
} else {
finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
}
call_.PerformOps(&finish_buf_);
}
/// Indicate that the stream is to be finished with a non-OK status,
/// and request notification for when the server has finished sending the
/// appropriate signals to the client to end the call.
/// Should not be used concurrently with other operations.
///
/// \param[in] tag Tag identifying this request.
/// \param[in] status To be sent to the client as the result of the call.
/// - Note: \a status must have a non-OK code.
///
/// Side effect:
/// - also sends initial metadata if not already sent (using the
/// \a ServerContext associated with this call).
///
/// gRPC doesn't take ownership or a reference to status, so it is safe to
/// deallocate them once the Finish operation is complete (i.e. a result
/// arrives in the completion queue).
void FinishWithError(const grpc::Status& status, void* tag) {
GPR_CODEGEN_ASSERT(!status.ok());
finish_buf_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) {
finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
ctx_->initial_metadata_flags());
if (ctx_->compression_level_set()) {
finish_buf_.set_compression_level(ctx_->compression_level());
}
ctx_->sent_initial_metadata_ = true;
}
finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
call_.PerformOps(&finish_buf_);
}
private:
void BindCall(grpc::internal::Call* call) override { call_ = *call; }
grpc::internal::Call call_;
grpc::ServerContext* ctx_;
grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
meta_buf_;
grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
grpc::internal::CallOpSendMessage,
grpc::internal::CallOpServerSendStatus>
finish_buf_;
};
} // namespace grpc
namespace std {
template <class R>
class default_delete<grpc::ClientAsyncResponseReader<R>> {
public:
void operator()(void* /*p*/) {}
};
template <class R>
class default_delete<grpc::ClientAsyncResponseReaderInterface<R>> {
public:
void operator()(void* /*p*/) {}
};
} // namespace std
#endif // GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H #endif // GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H

395
include/grpcpp/support/async_unary_call.h
Unescape View File

@ -19,399 +19,6 @@
#ifndef GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H #ifndef GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H
#define GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H #define GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H
#include <grpc/grpc.h> #include <grpcpp/impl/codegen/async_unary_call.h> // IWYU pragma: export
#include <grpcpp/client_context.h>
#include <grpcpp/impl/call.h>
#include <grpcpp/impl/codegen/call_op_set.h>
#include <grpcpp/impl/codegen/call_op_set_interface.h>
#include <grpcpp/impl/codegen/channel_interface.h>
#include <grpcpp/impl/service_type.h>
#include <grpcpp/server_context.h>
#include <grpcpp/support/status.h>
namespace grpc {
// Forward declaration for use in Helper class
template <class R>
class ClientAsyncResponseReader;
/// An interface relevant for async client side unary RPCs (which send
/// one request message to a server and receive one response message).
template <class R>
class ClientAsyncResponseReaderInterface {
public:
virtual ~ClientAsyncResponseReaderInterface() {}
/// Start the call that was set up by the constructor, but only if the
/// constructor was invoked through the "Prepare" API which doesn't actually
/// start the call
virtual void StartCall() = 0;
/// Request notification of the reading of initial metadata. Completion
/// will be notified by \a tag on the associated completion queue.
/// This call is optional, but if it is used, it cannot be used concurrently
/// with or after the \a Finish method.
///
/// \param[in] tag Tag identifying this request.
virtual void ReadInitialMetadata(void* tag) = 0;
/// Request to receive the server's response \a msg and final \a status for
/// the call, and to notify \a tag on this call's completion queue when
/// finished.
///
/// This function will return when either:
/// - when the server's response message and status have been received.
/// - when the server has returned a non-OK status (no message expected in
/// this case).
/// - when the call failed for some reason and the library generated a
/// non-OK status.
///
/// \param[in] tag Tag identifying this request.
/// \param[out] status To be updated with the operation status.
/// \param[out] msg To be filled in with the server's response message.
virtual void Finish(R* msg, grpc::Status* status, void* tag) = 0;
};
namespace internal {
class ClientAsyncResponseReaderHelper {
public:
/// Start a call and write the request out if \a start is set.
/// \a tag will be notified on \a cq when the call has been started (i.e.
/// intitial metadata sent) and \a request has been written out.
/// If \a start is not set, the actual call must be initiated by StartCall
/// Note that \a context will be used to fill in custom initial metadata
/// used to send to the server when starting the call.
///
/// Optionally pass in a base class for request and response types so that the
/// internal functions and structs can be templated based on that, allowing
/// reuse across RPCs (e.g., MessageLite for protobuf). Since constructors
/// can't have an explicit template parameter, the last argument is an
/// extraneous parameter just to provide the needed type information.
template <class R, class W, class BaseR = R, class BaseW = W>
static ClientAsyncResponseReader<R>* Create(
grpc::ChannelInterface* channel, grpc::CompletionQueue* cq,
const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
const W& request) /* __attribute__((noinline)) */ {
grpc::internal::Call call = channel->CreateCall(method, context, cq);
ClientAsyncResponseReader<R>* result = new (grpc_call_arena_alloc(
call.call(), sizeof(ClientAsyncResponseReader<R>)))
ClientAsyncResponseReader<R>(call, context);
SetupRequest<BaseR, BaseW>(
call.call(), &result->single_buf_, &result->read_initial_metadata_,
&result->finish_, static_cast<const BaseW&>(request));
return result;
}
// Various helper functions to reduce templating use
template <class R, class W>
static void SetupRequest(
grpc_call* call,
grpc::internal::CallOpSendInitialMetadata** single_buf_ptr,
std::function<void(ClientContext*, internal::Call*,
internal::CallOpSendInitialMetadata*, void*)>*
read_initial_metadata,
std::function<
void(ClientContext*, internal::Call*, bool initial_metadata_read,
internal::CallOpSendInitialMetadata*,
internal::CallOpSetInterface**, void*, Status*, void*)>* finish,
const W& request) {
using SingleBufType =
grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
grpc::internal::CallOpSendMessage,
grpc::internal::CallOpClientSendClose,
grpc::internal::CallOpRecvInitialMetadata,
grpc::internal::CallOpRecvMessage<R>,
grpc::internal::CallOpClientRecvStatus>;
SingleBufType* single_buf =
new (grpc_call_arena_alloc(call, sizeof(SingleBufType))) SingleBufType;
*single_buf_ptr = single_buf;
// TODO(ctiller): don't assert
GPR_ASSERT(single_buf->SendMessage(request).ok());
single_buf->ClientSendClose();
// The purpose of the following functions is to type-erase the actual
// templated type of the CallOpSet being used by hiding that type inside the
// function definition rather than specifying it as an argument of the
// function or a member of the class. The type-erased CallOpSet will get
// static_cast'ed back to the real type so that it can be used properly.
*read_initial_metadata =
[](ClientContext* context, internal::Call* call,
internal::CallOpSendInitialMetadata* single_buf_view, void* tag) {
auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
single_buf->set_output_tag(tag);
single_buf->RecvInitialMetadata(context);
call->PerformOps(single_buf);
};
// Note that this function goes one step further than the previous one
// because it type-erases the message being written down to a void*. This
// will be static-cast'ed back to the class specified here by hiding that
// class information inside the function definition. Note that this feature
// expects the class being specified here for R to be a base-class of the
// "real" R without any multiple-inheritance (as applies in protbuf wrt
// MessageLite)
*finish = [](ClientContext* context, internal::Call* call,
bool initial_metadata_read,
internal::CallOpSendInitialMetadata* single_buf_view,
internal::CallOpSetInterface** finish_buf_ptr, void* msg,
Status* status, void* tag) {
if (initial_metadata_read) {
using FinishBufType =
grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>,
grpc::internal::CallOpClientRecvStatus>;
FinishBufType* finish_buf =
new (grpc_call_arena_alloc(call->call(), sizeof(FinishBufType)))
FinishBufType;
*finish_buf_ptr = finish_buf;
finish_buf->set_output_tag(tag);
finish_buf->RecvMessage(static_cast<R*>(msg));
finish_buf->AllowNoMessage();
finish_buf->ClientRecvStatus(context, status);
call->PerformOps(finish_buf);
} else {
auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
single_buf->set_output_tag(tag);
single_buf->RecvInitialMetadata(context);
single_buf->RecvMessage(static_cast<R*>(msg));
single_buf->AllowNoMessage();
single_buf->ClientRecvStatus(context, status);
call->PerformOps(single_buf);
}
};
}
static void StartCall(grpc::ClientContext* context,
grpc::internal::CallOpSendInitialMetadata* single_buf) {
single_buf->SendInitialMetadata(&context->send_initial_metadata_,
context->initial_metadata_flags());
}
};
// TODO(vjpai): This templated factory is deprecated and will be replaced by
//. the non-templated helper as soon as possible.
template <class R>
class ClientAsyncResponseReaderFactory {
public:
template <class W>
static ClientAsyncResponseReader<R>* Create(
grpc::ChannelInterface* channel, grpc::CompletionQueue* cq,
const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
const W& request, bool start) {
auto* result = ClientAsyncResponseReaderHelper::Create<R>(
channel, cq, method, context, request);
if (start) {
result->StartCall();
}
return result;
}
};
} // namespace internal
/// Async API for client-side unary RPCs, where the message response
/// received from the server is of type \a R.
template <class R>
class ClientAsyncResponseReader final
: public ClientAsyncResponseReaderInterface<R> {
public:
// always allocated against a call arena, no memory free required
static void operator delete(void* /*ptr*/, std::size_t size) {
GPR_ASSERT(size == sizeof(ClientAsyncResponseReader));
}
// This operator should never be called as the memory should be freed as part
// of the arena destruction. It only exists to provide a matching operator
// delete to the operator new so that some compilers will not complain (see
// https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
// there are no tests catching the compiler warning.
static void operator delete(void*, void*) { GPR_ASSERT(false); }
void StartCall() override {
GPR_DEBUG_ASSERT(!started_);
started_ = true;
internal::ClientAsyncResponseReaderHelper::StartCall(context_, single_buf_);
}
/// See \a ClientAsyncResponseReaderInterface::ReadInitialMetadata for
/// semantics.
///
/// Side effect:
/// - the \a ClientContext associated with this call is updated with
/// possible initial and trailing metadata sent from the server.
void ReadInitialMetadata(void* tag) override {
GPR_DEBUG_ASSERT(started_);
GPR_DEBUG_ASSERT(!context_->initial_metadata_received_);
read_initial_metadata_(context_, &call_, single_buf_, tag);
initial_metadata_read_ = true;
}
/// See \a ClientAsyncResponseReaderInterface::Finish for semantics.
///
/// Side effect:
/// - the \a ClientContext associated with this call is updated with
/// possible initial and trailing metadata sent from the server.
void Finish(R* msg, grpc::Status* status, void* tag) override {
GPR_DEBUG_ASSERT(started_);
finish_(context_, &call_, initial_metadata_read_, single_buf_, &finish_buf_,
static_cast<void*>(msg), status, tag);
}
private:
friend class internal::ClientAsyncResponseReaderHelper;
grpc::ClientContext* const context_;
grpc::internal::Call call_;
bool started_ = false;
bool initial_metadata_read_ = false;
ClientAsyncResponseReader(grpc::internal::Call call,
grpc::ClientContext* context)
: context_(context), call_(call) {}
// disable operator new
static void* operator new(std::size_t size);
static void* operator new(std::size_t /*size*/, void* p) { return p; }
internal::CallOpSendInitialMetadata* single_buf_;
internal::CallOpSetInterface* finish_buf_ = nullptr;
std::function<void(ClientContext*, internal::Call*,
internal::CallOpSendInitialMetadata*, void*)>
read_initial_metadata_;
std::function<void(ClientContext*, internal::Call*,
bool initial_metadata_read,
internal::CallOpSendInitialMetadata*,
internal::CallOpSetInterface**, void*, Status*, void*)>
finish_;
};
/// Async server-side API for handling unary calls, where the single
/// response message sent to the client is of type \a W.
template <class W>
class ServerAsyncResponseWriter final
: public grpc::internal::ServerAsyncStreamingInterface {
public:
explicit ServerAsyncResponseWriter(grpc::ServerContext* ctx)
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
/// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
///
/// Side effect:
/// The initial metadata that will be sent to the client from this op will
/// be taken from the \a ServerContext associated with the call.
///
/// \param[in] tag Tag identifying this request.
void SendInitialMetadata(void* tag) override {
GPR_ASSERT(!ctx_->sent_initial_metadata_);
meta_buf_.set_output_tag(tag);
meta_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
ctx_->initial_metadata_flags());
if (ctx_->compression_level_set()) {
meta_buf_.set_compression_level(ctx_->compression_level());
}
ctx_->sent_initial_metadata_ = true;
call_.PerformOps(&meta_buf_);
}
/// Indicate that the stream is to be finished and request notification
/// when the server has sent the appropriate signals to the client to
/// end the call. Should not be used concurrently with other operations.
///
/// \param[in] tag Tag identifying this request.
/// \param[in] status To be sent to the client as the result of the call.
/// \param[in] msg Message to be sent to the client.
///
/// Side effect:
/// - also sends initial metadata if not already sent (using the
/// \a ServerContext associated with this call).
///
/// Note: if \a status has a non-OK code, then \a msg will not be sent,
/// and the client will receive only the status with possible trailing
/// metadata.
///
/// gRPC doesn't take ownership or a reference to msg and status, so it is
/// safe to deallocate them once the Finish operation is complete (i.e. a
/// result arrives in the completion queue).
void Finish(const W& msg, const grpc::Status& status, void* tag) {
finish_buf_.set_output_tag(tag);
finish_buf_.set_core_cq_tag(&finish_buf_);
if (!ctx_->sent_initial_metadata_) {
finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
ctx_->initial_metadata_flags());
if (ctx_->compression_level_set()) {
finish_buf_.set_compression_level(ctx_->compression_level());
}
ctx_->sent_initial_metadata_ = true;
}
// The response is dropped if the status is not OK.
if (status.ok()) {
finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_,
finish_buf_.SendMessage(msg));
} else {
finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
}
call_.PerformOps(&finish_buf_);
}
/// Indicate that the stream is to be finished with a non-OK status,
/// and request notification for when the server has finished sending the
/// appropriate signals to the client to end the call.
/// Should not be used concurrently with other operations.
///
/// \param[in] tag Tag identifying this request.
/// \param[in] status To be sent to the client as the result of the call.
/// - Note: \a status must have a non-OK code.
///
/// Side effect:
/// - also sends initial metadata if not already sent (using the
/// \a ServerContext associated with this call).
///
/// gRPC doesn't take ownership or a reference to status, so it is safe to
/// deallocate them once the Finish operation is complete (i.e. a result
/// arrives in the completion queue).
void FinishWithError(const grpc::Status& status, void* tag) {
GPR_ASSERT(!status.ok());
finish_buf_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) {
finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
ctx_->initial_metadata_flags());
if (ctx_->compression_level_set()) {
finish_buf_.set_compression_level(ctx_->compression_level());
}
ctx_->sent_initial_metadata_ = true;
}
finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
call_.PerformOps(&finish_buf_);
}
private:
void BindCall(grpc::internal::Call* call) override { call_ = *call; }
grpc::internal::Call call_;
grpc::ServerContext* ctx_;
grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
meta_buf_;
grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
grpc::internal::CallOpSendMessage,
grpc::internal::CallOpServerSendStatus>
finish_buf_;
};
} // namespace grpc
namespace std {
template <class R>
class default_delete<grpc::ClientAsyncResponseReader<R>> {
public:
void operator()(void* /*p*/) {}
};
template <class R>
class default_delete<grpc::ClientAsyncResponseReaderInterface<R>> {
public:
void operator()(void* /*p*/) {}
};
} // namespace std
#endif // GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H #endif // GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H

4
src/compiler/cpp_generator.cc
Unescape View File

@ -139,7 +139,7 @@ std::string GetHeaderIncludes(grpc_generator::File* file,
"functional", "functional",
"grpcpp/impl/codegen/async_generic_service.h", "grpcpp/impl/codegen/async_generic_service.h",
"grpcpp/impl/codegen/async_stream.h", "grpcpp/impl/codegen/async_stream.h",
"grpcpp/support/async_unary_call.h", "grpcpp/impl/codegen/async_unary_call.h",
"grpcpp/impl/codegen/client_callback.h", "grpcpp/impl/codegen/client_callback.h",
"grpcpp/impl/codegen/client_context.h", "grpcpp/impl/codegen/client_context.h",
"grpcpp/impl/codegen/completion_queue.h", "grpcpp/impl/codegen/completion_queue.h",
@ -1649,7 +1649,7 @@ std::string GetSourceIncludes(grpc_generator::File* file,
static const char* headers_strs[] = { static const char* headers_strs[] = {
"functional", "functional",
"grpcpp/impl/codegen/async_stream.h", "grpcpp/impl/codegen/async_stream.h",
"grpcpp/support/async_unary_call.h", "grpcpp/impl/codegen/async_unary_call.h",
"grpcpp/impl/codegen/channel_interface.h", "grpcpp/impl/codegen/channel_interface.h",
"grpcpp/impl/codegen/client_unary_call.h", "grpcpp/impl/codegen/client_unary_call.h",
"grpcpp/impl/codegen/client_callback.h", "grpcpp/impl/codegen/client_callback.h",

2
test/cpp/codegen/compiler_test_golden
Unescape View File

@ -29,7 +29,7 @@
#include <functional> #include <functional>
#include <grpcpp/impl/codegen/async_generic_service.h> #include <grpcpp/impl/codegen/async_generic_service.h>
#include <grpcpp/impl/codegen/async_stream.h> #include <grpcpp/impl/codegen/async_stream.h>
#include <grpcpp/support/async_unary_call.h> #include <grpcpp/impl/codegen/async_unary_call.h>
#include <grpcpp/impl/codegen/client_callback.h> #include <grpcpp/impl/codegen/client_callback.h>
#include <grpcpp/impl/codegen/client_context.h> #include <grpcpp/impl/codegen/client_context.h>
#include <grpcpp/impl/codegen/completion_queue.h> #include <grpcpp/impl/codegen/completion_queue.h>

Write Preview
Loading…
Cancel
Save