mirror of https://github.com/grpc/grpc.git
yang-g
9 years ago
commit
e464af1a5b
302 changed files with 11947 additions and 6617 deletions
@ -0,0 +1,462 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_ASYNC_STREAM_H |
||||
#define GRPCXX_IMPL_CODEGEN_ASYNC_STREAM_H |
||||
|
||||
#include <grpc++/impl/codegen/channel_interface.h> |
||||
#include <grpc++/impl/codegen/call.h> |
||||
#include <grpc++/impl/codegen/service_type.h> |
||||
#include <grpc++/impl/codegen/server_context.h> |
||||
#include <grpc++/impl/codegen/status.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
class CompletionQueue; |
||||
|
||||
/// Common interface for all client side asynchronous streaming.
|
||||
class ClientAsyncStreamingInterface { |
||||
public: |
||||
virtual ~ClientAsyncStreamingInterface() {} |
||||
|
||||
/// Request notification of the reading of the initial metadata. Completion
|
||||
/// will be notified by \a tag on the associated completion queue.
|
||||
///
|
||||
/// \param[in] tag Tag identifying this request.
|
||||
virtual void ReadInitialMetadata(void* tag) = 0; |
||||
|
||||
/// Request notification completion.
|
||||
///
|
||||
/// \param[out] status To be updated with the operation status.
|
||||
/// \param[in] tag Tag identifying this request.
|
||||
virtual void Finish(Status* status, void* tag) = 0; |
||||
}; |
||||
|
||||
/// An interface that yields a sequence of messages of type \a R.
|
||||
template <class R> |
||||
class AsyncReaderInterface { |
||||
public: |
||||
virtual ~AsyncReaderInterface() {} |
||||
|
||||
/// Read a message of type \a R into \a msg. Completion will be notified by \a
|
||||
/// tag on the associated completion queue.
|
||||
///
|
||||
/// \param[out] msg Where to eventually store the read message.
|
||||
/// \param[in] tag The tag identifying the operation.
|
||||
virtual void Read(R* msg, void* tag) = 0; |
||||
}; |
||||
|
||||
/// An interface that can be fed a sequence of messages of type \a W.
|
||||
template <class W> |
||||
class AsyncWriterInterface { |
||||
public: |
||||
virtual ~AsyncWriterInterface() {} |
||||
|
||||
/// Request the writing of \a msg with identifying tag \a tag.
|
||||
///
|
||||
/// Only one write may be outstanding at any given time. This means that
|
||||
/// after calling Write, one must wait to receive \a tag from the completion
|
||||
/// queue BEFORE calling Write again.
|
||||
///
|
||||
/// \param[in] msg The message to be written.
|
||||
/// \param[in] tag The tag identifying the operation.
|
||||
virtual void Write(const W& msg, void* tag) = 0; |
||||
}; |
||||
|
||||
template <class R> |
||||
class ClientAsyncReaderInterface : public ClientAsyncStreamingInterface, |
||||
public AsyncReaderInterface<R> {}; |
||||
|
||||
template <class R> |
||||
class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface<R> { |
||||
public: |
||||
/// Create a stream and write the first request out.
|
||||
template <class W> |
||||
ClientAsyncReader(ChannelInterface* channel, CompletionQueue* cq, |
||||
const RpcMethod& method, ClientContext* context, |
||||
const W& request, void* tag) |
||||
: context_(context), call_(channel->CreateCall(method, context, cq)) { |
||||
init_ops_.set_output_tag(tag); |
||||
init_ops_.SendInitialMetadata(context->send_initial_metadata_); |
||||
// TODO(ctiller): don't assert
|
||||
GPR_ASSERT(init_ops_.SendMessage(request).ok()); |
||||
init_ops_.ClientSendClose(); |
||||
call_.PerformOps(&init_ops_); |
||||
} |
||||
|
||||
void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { |
||||
GPR_ASSERT(!context_->initial_metadata_received_); |
||||
|
||||
meta_ops_.set_output_tag(tag); |
||||
meta_ops_.RecvInitialMetadata(context_); |
||||
call_.PerformOps(&meta_ops_); |
||||
} |
||||
|
||||
void Read(R* msg, void* tag) GRPC_OVERRIDE { |
||||
read_ops_.set_output_tag(tag); |
||||
if (!context_->initial_metadata_received_) { |
||||
read_ops_.RecvInitialMetadata(context_); |
||||
} |
||||
read_ops_.RecvMessage(msg); |
||||
call_.PerformOps(&read_ops_); |
||||
} |
||||
|
||||
void Finish(Status* status, void* tag) GRPC_OVERRIDE { |
||||
finish_ops_.set_output_tag(tag); |
||||
if (!context_->initial_metadata_received_) { |
||||
finish_ops_.RecvInitialMetadata(context_); |
||||
} |
||||
finish_ops_.ClientRecvStatus(context_, status); |
||||
call_.PerformOps(&finish_ops_); |
||||
} |
||||
|
||||
private: |
||||
ClientContext* context_; |
||||
Call call_; |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, CallOpClientSendClose> |
||||
init_ops_; |
||||
CallOpSet<CallOpRecvInitialMetadata> meta_ops_; |
||||
CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> read_ops_; |
||||
CallOpSet<CallOpRecvInitialMetadata, CallOpClientRecvStatus> finish_ops_; |
||||
}; |
||||
|
||||
/// Common interface for client side asynchronous writing.
|
||||
template <class W> |
||||
class ClientAsyncWriterInterface : public ClientAsyncStreamingInterface, |
||||
public AsyncWriterInterface<W> { |
||||
public: |
||||
/// Signal the client is done with the writes.
|
||||
///
|
||||
/// \param[in] tag The tag identifying the operation.
|
||||
virtual void WritesDone(void* tag) = 0; |
||||
}; |
||||
|
||||
template <class W> |
||||
class ClientAsyncWriter GRPC_FINAL : public ClientAsyncWriterInterface<W> { |
||||
public: |
||||
template <class R> |
||||
ClientAsyncWriter(ChannelInterface* channel, CompletionQueue* cq, |
||||
const RpcMethod& method, ClientContext* context, |
||||
R* response, void* tag) |
||||
: context_(context), call_(channel->CreateCall(method, context, cq)) { |
||||
finish_ops_.RecvMessage(response); |
||||
|
||||
init_ops_.set_output_tag(tag); |
||||
init_ops_.SendInitialMetadata(context->send_initial_metadata_); |
||||
call_.PerformOps(&init_ops_); |
||||
} |
||||
|
||||
void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { |
||||
GPR_ASSERT(!context_->initial_metadata_received_); |
||||
|
||||
meta_ops_.set_output_tag(tag); |
||||
meta_ops_.RecvInitialMetadata(context_); |
||||
call_.PerformOps(&meta_ops_); |
||||
} |
||||
|
||||
void Write(const W& msg, void* tag) GRPC_OVERRIDE { |
||||
write_ops_.set_output_tag(tag); |
||||
// TODO(ctiller): don't assert
|
||||
GPR_ASSERT(write_ops_.SendMessage(msg).ok()); |
||||
call_.PerformOps(&write_ops_); |
||||
} |
||||
|
||||
void WritesDone(void* tag) GRPC_OVERRIDE { |
||||
writes_done_ops_.set_output_tag(tag); |
||||
writes_done_ops_.ClientSendClose(); |
||||
call_.PerformOps(&writes_done_ops_); |
||||
} |
||||
|
||||
void Finish(Status* status, void* tag) GRPC_OVERRIDE { |
||||
finish_ops_.set_output_tag(tag); |
||||
if (!context_->initial_metadata_received_) { |
||||
finish_ops_.RecvInitialMetadata(context_); |
||||
} |
||||
finish_ops_.ClientRecvStatus(context_, status); |
||||
call_.PerformOps(&finish_ops_); |
||||
} |
||||
|
||||
private: |
||||
ClientContext* context_; |
||||
Call call_; |
||||
CallOpSet<CallOpSendInitialMetadata> init_ops_; |
||||
CallOpSet<CallOpRecvInitialMetadata> meta_ops_; |
||||
CallOpSet<CallOpSendMessage> write_ops_; |
||||
CallOpSet<CallOpClientSendClose> writes_done_ops_; |
||||
CallOpSet<CallOpRecvInitialMetadata, CallOpGenericRecvMessage, |
||||
CallOpClientRecvStatus> finish_ops_; |
||||
}; |
||||
|
||||
/// Client-side interface for asynchronous bi-directional streaming.
|
||||
template <class W, class R> |
||||
class ClientAsyncReaderWriterInterface : public ClientAsyncStreamingInterface, |
||||
public AsyncWriterInterface<W>, |
||||
public AsyncReaderInterface<R> { |
||||
public: |
||||
/// Signal the client is done with the writes.
|
||||
///
|
||||
/// \param[in] tag The tag identifying the operation.
|
||||
virtual void WritesDone(void* tag) = 0; |
||||
}; |
||||
|
||||
template <class W, class R> |
||||
class ClientAsyncReaderWriter GRPC_FINAL |
||||
: public ClientAsyncReaderWriterInterface<W, R> { |
||||
public: |
||||
ClientAsyncReaderWriter(ChannelInterface* channel, CompletionQueue* cq, |
||||
const RpcMethod& method, ClientContext* context, |
||||
void* tag) |
||||
: context_(context), call_(channel->CreateCall(method, context, cq)) { |
||||
init_ops_.set_output_tag(tag); |
||||
init_ops_.SendInitialMetadata(context->send_initial_metadata_); |
||||
call_.PerformOps(&init_ops_); |
||||
} |
||||
|
||||
void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { |
||||
GPR_ASSERT(!context_->initial_metadata_received_); |
||||
|
||||
meta_ops_.set_output_tag(tag); |
||||
meta_ops_.RecvInitialMetadata(context_); |
||||
call_.PerformOps(&meta_ops_); |
||||
} |
||||
|
||||
void Read(R* msg, void* tag) GRPC_OVERRIDE { |
||||
read_ops_.set_output_tag(tag); |
||||
if (!context_->initial_metadata_received_) { |
||||
read_ops_.RecvInitialMetadata(context_); |
||||
} |
||||
read_ops_.RecvMessage(msg); |
||||
call_.PerformOps(&read_ops_); |
||||
} |
||||
|
||||
void Write(const W& msg, void* tag) GRPC_OVERRIDE { |
||||
write_ops_.set_output_tag(tag); |
||||
// TODO(ctiller): don't assert
|
||||
GPR_ASSERT(write_ops_.SendMessage(msg).ok()); |
||||
call_.PerformOps(&write_ops_); |
||||
} |
||||
|
||||
void WritesDone(void* tag) GRPC_OVERRIDE { |
||||
writes_done_ops_.set_output_tag(tag); |
||||
writes_done_ops_.ClientSendClose(); |
||||
call_.PerformOps(&writes_done_ops_); |
||||
} |
||||
|
||||
void Finish(Status* status, void* tag) GRPC_OVERRIDE { |
||||
finish_ops_.set_output_tag(tag); |
||||
if (!context_->initial_metadata_received_) { |
||||
finish_ops_.RecvInitialMetadata(context_); |
||||
} |
||||
finish_ops_.ClientRecvStatus(context_, status); |
||||
call_.PerformOps(&finish_ops_); |
||||
} |
||||
|
||||
private: |
||||
ClientContext* context_; |
||||
Call call_; |
||||
CallOpSet<CallOpSendInitialMetadata> init_ops_; |
||||
CallOpSet<CallOpRecvInitialMetadata> meta_ops_; |
||||
CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> read_ops_; |
||||
CallOpSet<CallOpSendMessage> write_ops_; |
||||
CallOpSet<CallOpClientSendClose> writes_done_ops_; |
||||
CallOpSet<CallOpRecvInitialMetadata, CallOpClientRecvStatus> finish_ops_; |
||||
}; |
||||
|
||||
template <class W, class R> |
||||
class ServerAsyncReader GRPC_FINAL : public ServerAsyncStreamingInterface, |
||||
public AsyncReaderInterface<R> { |
||||
public: |
||||
explicit ServerAsyncReader(ServerContext* ctx) |
||||
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} |
||||
|
||||
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { |
||||
GPR_ASSERT(!ctx_->sent_initial_metadata_); |
||||
|
||||
meta_ops_.set_output_tag(tag); |
||||
meta_ops_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
call_.PerformOps(&meta_ops_); |
||||
} |
||||
|
||||
void Read(R* msg, void* tag) GRPC_OVERRIDE { |
||||
read_ops_.set_output_tag(tag); |
||||
read_ops_.RecvMessage(msg); |
||||
call_.PerformOps(&read_ops_); |
||||
} |
||||
|
||||
void Finish(const W& msg, const Status& status, void* tag) { |
||||
finish_ops_.set_output_tag(tag); |
||||
if (!ctx_->sent_initial_metadata_) { |
||||
finish_ops_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
} |
||||
// The response is dropped if the status is not OK.
|
||||
if (status.ok()) { |
||||
finish_ops_.ServerSendStatus(ctx_->trailing_metadata_, |
||||
finish_ops_.SendMessage(msg)); |
||||
} else { |
||||
finish_ops_.ServerSendStatus(ctx_->trailing_metadata_, status); |
||||
} |
||||
call_.PerformOps(&finish_ops_); |
||||
} |
||||
|
||||
void FinishWithError(const Status& status, void* tag) { |
||||
GPR_ASSERT(!status.ok()); |
||||
finish_ops_.set_output_tag(tag); |
||||
if (!ctx_->sent_initial_metadata_) { |
||||
finish_ops_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
} |
||||
finish_ops_.ServerSendStatus(ctx_->trailing_metadata_, status); |
||||
call_.PerformOps(&finish_ops_); |
||||
} |
||||
|
||||
private: |
||||
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } |
||||
|
||||
Call call_; |
||||
ServerContext* ctx_; |
||||
CallOpSet<CallOpSendInitialMetadata> meta_ops_; |
||||
CallOpSet<CallOpRecvMessage<R>> read_ops_; |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, |
||||
CallOpServerSendStatus> finish_ops_; |
||||
}; |
||||
|
||||
template <class W> |
||||
class ServerAsyncWriter GRPC_FINAL : public ServerAsyncStreamingInterface, |
||||
public AsyncWriterInterface<W> { |
||||
public: |
||||
explicit ServerAsyncWriter(ServerContext* ctx) |
||||
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} |
||||
|
||||
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { |
||||
GPR_ASSERT(!ctx_->sent_initial_metadata_); |
||||
|
||||
meta_ops_.set_output_tag(tag); |
||||
meta_ops_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
call_.PerformOps(&meta_ops_); |
||||
} |
||||
|
||||
void Write(const W& msg, void* tag) GRPC_OVERRIDE { |
||||
write_ops_.set_output_tag(tag); |
||||
if (!ctx_->sent_initial_metadata_) { |
||||
write_ops_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
} |
||||
// TODO(ctiller): don't assert
|
||||
GPR_ASSERT(write_ops_.SendMessage(msg).ok()); |
||||
call_.PerformOps(&write_ops_); |
||||
} |
||||
|
||||
void Finish(const Status& status, void* tag) { |
||||
finish_ops_.set_output_tag(tag); |
||||
if (!ctx_->sent_initial_metadata_) { |
||||
finish_ops_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
} |
||||
finish_ops_.ServerSendStatus(ctx_->trailing_metadata_, status); |
||||
call_.PerformOps(&finish_ops_); |
||||
} |
||||
|
||||
private: |
||||
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } |
||||
|
||||
Call call_; |
||||
ServerContext* ctx_; |
||||
CallOpSet<CallOpSendInitialMetadata> meta_ops_; |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage> write_ops_; |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> finish_ops_; |
||||
}; |
||||
|
||||
/// Server-side interface for asynchronous bi-directional streaming.
|
||||
template <class W, class R> |
||||
class ServerAsyncReaderWriter GRPC_FINAL : public ServerAsyncStreamingInterface, |
||||
public AsyncWriterInterface<W>, |
||||
public AsyncReaderInterface<R> { |
||||
public: |
||||
explicit ServerAsyncReaderWriter(ServerContext* ctx) |
||||
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} |
||||
|
||||
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { |
||||
GPR_ASSERT(!ctx_->sent_initial_metadata_); |
||||
|
||||
meta_ops_.set_output_tag(tag); |
||||
meta_ops_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
call_.PerformOps(&meta_ops_); |
||||
} |
||||
|
||||
void Read(R* msg, void* tag) GRPC_OVERRIDE { |
||||
read_ops_.set_output_tag(tag); |
||||
read_ops_.RecvMessage(msg); |
||||
call_.PerformOps(&read_ops_); |
||||
} |
||||
|
||||
void Write(const W& msg, void* tag) GRPC_OVERRIDE { |
||||
write_ops_.set_output_tag(tag); |
||||
if (!ctx_->sent_initial_metadata_) { |
||||
write_ops_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
} |
||||
// TODO(ctiller): don't assert
|
||||
GPR_ASSERT(write_ops_.SendMessage(msg).ok()); |
||||
call_.PerformOps(&write_ops_); |
||||
} |
||||
|
||||
void Finish(const Status& status, void* tag) { |
||||
finish_ops_.set_output_tag(tag); |
||||
if (!ctx_->sent_initial_metadata_) { |
||||
finish_ops_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
} |
||||
finish_ops_.ServerSendStatus(ctx_->trailing_metadata_, status); |
||||
call_.PerformOps(&finish_ops_); |
||||
} |
||||
|
||||
private: |
||||
friend class ::grpc::Server; |
||||
|
||||
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } |
||||
|
||||
Call call_; |
||||
ServerContext* ctx_; |
||||
CallOpSet<CallOpSendInitialMetadata> meta_ops_; |
||||
CallOpSet<CallOpRecvMessage<R>> read_ops_; |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage> write_ops_; |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> finish_ops_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_ASYNC_STREAM_H
|
||||
@ -0,0 +1,156 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_ASYNC_UNARY_CALL_H |
||||
#define GRPCXX_IMPL_CODEGEN_ASYNC_UNARY_CALL_H |
||||
|
||||
#include <grpc++/impl/codegen/call.h> |
||||
#include <grpc++/impl/codegen/channel_interface.h> |
||||
#include <grpc++/impl/codegen/client_context.h> |
||||
#include <grpc++/impl/codegen/server_context.h> |
||||
#include <grpc++/impl/codegen/service_type.h> |
||||
#include <grpc++/impl/codegen/status.h> |
||||
#include <grpc/impl/codegen/log.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
class CompletionQueue; |
||||
|
||||
template <class R> |
||||
class ClientAsyncResponseReaderInterface { |
||||
public: |
||||
virtual ~ClientAsyncResponseReaderInterface() {} |
||||
virtual void ReadInitialMetadata(void* tag) = 0; |
||||
virtual void Finish(R* msg, Status* status, void* tag) = 0; |
||||
}; |
||||
|
||||
template <class R> |
||||
class ClientAsyncResponseReader GRPC_FINAL |
||||
: public ClientAsyncResponseReaderInterface<R> { |
||||
public: |
||||
template <class W> |
||||
ClientAsyncResponseReader(ChannelInterface* channel, CompletionQueue* cq, |
||||
const RpcMethod& method, ClientContext* context, |
||||
const W& request) |
||||
: context_(context), call_(channel->CreateCall(method, context, cq)) { |
||||
init_buf_.SendInitialMetadata(context->send_initial_metadata_); |
||||
// TODO(ctiller): don't assert
|
||||
GPR_ASSERT(init_buf_.SendMessage(request).ok()); |
||||
init_buf_.ClientSendClose(); |
||||
call_.PerformOps(&init_buf_); |
||||
} |
||||
|
||||
void ReadInitialMetadata(void* tag) { |
||||
GPR_ASSERT(!context_->initial_metadata_received_); |
||||
|
||||
meta_buf_.set_output_tag(tag); |
||||
meta_buf_.RecvInitialMetadata(context_); |
||||
call_.PerformOps(&meta_buf_); |
||||
} |
||||
|
||||
void Finish(R* msg, Status* status, void* tag) { |
||||
finish_buf_.set_output_tag(tag); |
||||
if (!context_->initial_metadata_received_) { |
||||
finish_buf_.RecvInitialMetadata(context_); |
||||
} |
||||
finish_buf_.RecvMessage(msg); |
||||
finish_buf_.ClientRecvStatus(context_, status); |
||||
call_.PerformOps(&finish_buf_); |
||||
} |
||||
|
||||
private: |
||||
ClientContext* context_; |
||||
Call call_; |
||||
SneakyCallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, |
||||
CallOpClientSendClose> init_buf_; |
||||
CallOpSet<CallOpRecvInitialMetadata> meta_buf_; |
||||
CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>, |
||||
CallOpClientRecvStatus> finish_buf_; |
||||
}; |
||||
|
||||
template <class W> |
||||
class ServerAsyncResponseWriter GRPC_FINAL |
||||
: public ServerAsyncStreamingInterface { |
||||
public: |
||||
explicit ServerAsyncResponseWriter(ServerContext* ctx) |
||||
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} |
||||
|
||||
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { |
||||
GPR_ASSERT(!ctx_->sent_initial_metadata_); |
||||
|
||||
meta_buf_.set_output_tag(tag); |
||||
meta_buf_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
call_.PerformOps(&meta_buf_); |
||||
} |
||||
|
||||
void Finish(const W& msg, const Status& status, void* tag) { |
||||
finish_buf_.set_output_tag(tag); |
||||
if (!ctx_->sent_initial_metadata_) { |
||||
finish_buf_.SendInitialMetadata(ctx_->initial_metadata_); |
||||
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_); |
||||
} |
||||
|
||||
void FinishWithError(const 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_->sent_initial_metadata_ = true; |
||||
} |
||||
finish_buf_.ServerSendStatus(ctx_->trailing_metadata_, status); |
||||
call_.PerformOps(&finish_buf_); |
||||
} |
||||
|
||||
private: |
||||
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } |
||||
|
||||
Call call_; |
||||
ServerContext* ctx_; |
||||
CallOpSet<CallOpSendInitialMetadata> meta_buf_; |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, |
||||
CallOpServerSendStatus> finish_buf_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
|
||||
@ -0,0 +1,578 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_CALL_H |
||||
#define GRPCXX_IMPL_CODEGEN_CALL_H |
||||
|
||||
#include <functional> |
||||
#include <memory> |
||||
#include <map> |
||||
#include <cstring> |
||||
|
||||
#include <grpc/impl/codegen/alloc.h> |
||||
#include <grpc/impl/codegen/grpc_types.h> |
||||
#include <grpc++/impl/codegen/client_context.h> |
||||
#include <grpc++/impl/codegen/call_hook.h> |
||||
#include <grpc++/impl/codegen/completion_queue_tag.h> |
||||
#include <grpc++/impl/codegen/serialization_traits.h> |
||||
#include <grpc++/impl/codegen/config.h> |
||||
#include <grpc++/impl/codegen/status.h> |
||||
|
||||
struct grpc_byte_buffer; |
||||
|
||||
namespace grpc { |
||||
|
||||
class ByteBuffer; |
||||
class Call; |
||||
class CallHook; |
||||
class CompletionQueue; |
||||
|
||||
void FillMetadataMap( |
||||
grpc_metadata_array* arr, |
||||
std::multimap<grpc::string_ref, grpc::string_ref>* metadata); |
||||
grpc_metadata* FillMetadataArray( |
||||
const std::multimap<grpc::string, grpc::string>& metadata); |
||||
|
||||
/// Per-message write options.
|
||||
class WriteOptions { |
||||
public: |
||||
WriteOptions() : flags_(0) {} |
||||
WriteOptions(const WriteOptions& other) : flags_(other.flags_) {} |
||||
|
||||
/// Clear all flags.
|
||||
inline void Clear() { flags_ = 0; } |
||||
|
||||
/// Returns raw flags bitset.
|
||||
inline uint32_t flags() const { return flags_; } |
||||
|
||||
/// Sets flag for the disabling of compression for the next message write.
|
||||
///
|
||||
/// \sa GRPC_WRITE_NO_COMPRESS
|
||||
inline WriteOptions& set_no_compression() { |
||||
SetBit(GRPC_WRITE_NO_COMPRESS); |
||||
return *this; |
||||
} |
||||
|
||||
/// Clears flag for the disabling of compression for the next message write.
|
||||
///
|
||||
/// \sa GRPC_WRITE_NO_COMPRESS
|
||||
inline WriteOptions& clear_no_compression() { |
||||
ClearBit(GRPC_WRITE_NO_COMPRESS); |
||||
return *this; |
||||
} |
||||
|
||||
/// Get value for the flag indicating whether compression for the next
|
||||
/// message write is forcefully disabled.
|
||||
///
|
||||
/// \sa GRPC_WRITE_NO_COMPRESS
|
||||
inline bool get_no_compression() const { |
||||
return GetBit(GRPC_WRITE_NO_COMPRESS); |
||||
} |
||||
|
||||
/// Sets flag indicating that the write may be buffered and need not go out on
|
||||
/// the wire immediately.
|
||||
///
|
||||
/// \sa GRPC_WRITE_BUFFER_HINT
|
||||
inline WriteOptions& set_buffer_hint() { |
||||
SetBit(GRPC_WRITE_BUFFER_HINT); |
||||
return *this; |
||||
} |
||||
|
||||
/// Clears flag indicating that the write may be buffered and need not go out
|
||||
/// on the wire immediately.
|
||||
///
|
||||
/// \sa GRPC_WRITE_BUFFER_HINT
|
||||
inline WriteOptions& clear_buffer_hint() { |
||||
ClearBit(GRPC_WRITE_BUFFER_HINT); |
||||
return *this; |
||||
} |
||||
|
||||
/// Get value for the flag indicating that the write may be buffered and need
|
||||
/// not go out on the wire immediately.
|
||||
///
|
||||
/// \sa GRPC_WRITE_BUFFER_HINT
|
||||
inline bool get_buffer_hint() const { return GetBit(GRPC_WRITE_BUFFER_HINT); } |
||||
|
||||
WriteOptions& operator=(const WriteOptions& rhs) { |
||||
flags_ = rhs.flags_; |
||||
return *this; |
||||
} |
||||
|
||||
private: |
||||
void SetBit(const uint32_t mask) { flags_ |= mask; } |
||||
|
||||
void ClearBit(const uint32_t mask) { flags_ &= ~mask; } |
||||
|
||||
bool GetBit(const uint32_t mask) const { return (flags_ & mask) != 0; } |
||||
|
||||
uint32_t flags_; |
||||
}; |
||||
|
||||
/// Default argument for CallOpSet. I is unused by the class, but can be
|
||||
/// used for generating multiple names for the same thing.
|
||||
template <int I> |
||||
class CallNoOp { |
||||
protected: |
||||
void AddOp(grpc_op* ops, size_t* nops) {} |
||||
void FinishOp(bool* status, int max_message_size) {} |
||||
}; |
||||
|
||||
class CallOpSendInitialMetadata { |
||||
public: |
||||
CallOpSendInitialMetadata() : send_(false) {} |
||||
|
||||
void SendInitialMetadata( |
||||
const std::multimap<grpc::string, grpc::string>& metadata) { |
||||
send_ = true; |
||||
initial_metadata_count_ = metadata.size(); |
||||
initial_metadata_ = FillMetadataArray(metadata); |
||||
} |
||||
|
||||
protected: |
||||
void AddOp(grpc_op* ops, size_t* nops) { |
||||
if (!send_) return; |
||||
grpc_op* op = &ops[(*nops)++]; |
||||
op->op = GRPC_OP_SEND_INITIAL_METADATA; |
||||
op->flags = 0; |
||||
op->reserved = NULL; |
||||
op->data.send_initial_metadata.count = initial_metadata_count_; |
||||
op->data.send_initial_metadata.metadata = initial_metadata_; |
||||
} |
||||
void FinishOp(bool* status, int max_message_size) { |
||||
if (!send_) return; |
||||
gpr_free(initial_metadata_); |
||||
send_ = false; |
||||
} |
||||
|
||||
bool send_; |
||||
size_t initial_metadata_count_; |
||||
grpc_metadata* initial_metadata_; |
||||
}; |
||||
|
||||
class CallOpSendMessage { |
||||
public: |
||||
CallOpSendMessage() : send_buf_(nullptr), own_buf_(false) {} |
||||
|
||||
/// Send \a message using \a options for the write. The \a options are cleared
|
||||
/// after use.
|
||||
template <class M> |
||||
Status SendMessage(const M& message, |
||||
const WriteOptions& options) GRPC_MUST_USE_RESULT; |
||||
|
||||
template <class M> |
||||
Status SendMessage(const M& message) GRPC_MUST_USE_RESULT; |
||||
|
||||
protected: |
||||
void AddOp(grpc_op* ops, size_t* nops) { |
||||
if (send_buf_ == nullptr) return; |
||||
grpc_op* op = &ops[(*nops)++]; |
||||
op->op = GRPC_OP_SEND_MESSAGE; |
||||
op->flags = write_options_.flags(); |
||||
op->reserved = NULL; |
||||
op->data.send_message = send_buf_; |
||||
// Flags are per-message: clear them after use.
|
||||
write_options_.Clear(); |
||||
} |
||||
void FinishOp(bool* status, int max_message_size) { |
||||
if (own_buf_) grpc_byte_buffer_destroy(send_buf_); |
||||
send_buf_ = nullptr; |
||||
} |
||||
|
||||
private: |
||||
grpc_byte_buffer* send_buf_; |
||||
WriteOptions write_options_; |
||||
bool own_buf_; |
||||
}; |
||||
|
||||
template <class M> |
||||
Status CallOpSendMessage::SendMessage(const M& message, |
||||
const WriteOptions& options) { |
||||
write_options_ = options; |
||||
return SerializationTraits<M>::Serialize(message, &send_buf_, &own_buf_); |
||||
} |
||||
|
||||
template <class M> |
||||
Status CallOpSendMessage::SendMessage(const M& message) { |
||||
return SendMessage(message, WriteOptions()); |
||||
} |
||||
|
||||
template <class R> |
||||
class CallOpRecvMessage { |
||||
public: |
||||
CallOpRecvMessage() : got_message(false), message_(nullptr) {} |
||||
|
||||
void RecvMessage(R* message) { message_ = message; } |
||||
|
||||
bool got_message; |
||||
|
||||
protected: |
||||
void AddOp(grpc_op* ops, size_t* nops) { |
||||
if (message_ == nullptr) return; |
||||
grpc_op* op = &ops[(*nops)++]; |
||||
op->op = GRPC_OP_RECV_MESSAGE; |
||||
op->flags = 0; |
||||
op->reserved = NULL; |
||||
op->data.recv_message = &recv_buf_; |
||||
} |
||||
|
||||
void FinishOp(bool* status, int max_message_size) { |
||||
if (message_ == nullptr) return; |
||||
if (recv_buf_) { |
||||
if (*status) { |
||||
got_message = true; |
||||
*status = SerializationTraits<R>::Deserialize(recv_buf_, message_, |
||||
max_message_size).ok(); |
||||
} else { |
||||
got_message = false; |
||||
grpc_byte_buffer_destroy(recv_buf_); |
||||
} |
||||
} else { |
||||
got_message = false; |
||||
*status = false; |
||||
} |
||||
message_ = nullptr; |
||||
} |
||||
|
||||
private: |
||||
R* message_; |
||||
grpc_byte_buffer* recv_buf_; |
||||
}; |
||||
|
||||
namespace CallOpGenericRecvMessageHelper { |
||||
class DeserializeFunc { |
||||
public: |
||||
virtual Status Deserialize(grpc_byte_buffer* buf, int max_message_size) = 0; |
||||
}; |
||||
|
||||
template <class R> |
||||
class DeserializeFuncType GRPC_FINAL : public DeserializeFunc { |
||||
public: |
||||
DeserializeFuncType(R* message) : message_(message) {} |
||||
Status Deserialize(grpc_byte_buffer* buf, |
||||
int max_message_size) GRPC_OVERRIDE { |
||||
return SerializationTraits<R>::Deserialize(buf, message_, max_message_size); |
||||
} |
||||
|
||||
private: |
||||
R* message_; // Not a managed pointer because management is external to this
|
||||
}; |
||||
} // namespace CallOpGenericRecvMessageHelper
|
||||
|
||||
class CallOpGenericRecvMessage { |
||||
public: |
||||
CallOpGenericRecvMessage() : got_message(false) {} |
||||
|
||||
template <class R> |
||||
void RecvMessage(R* message) { |
||||
deserialize_.reset( |
||||
new CallOpGenericRecvMessageHelper::DeserializeFuncType<R>(message)); |
||||
} |
||||
|
||||
bool got_message; |
||||
|
||||
protected: |
||||
void AddOp(grpc_op* ops, size_t* nops) { |
||||
if (!deserialize_) return; |
||||
grpc_op* op = &ops[(*nops)++]; |
||||
op->op = GRPC_OP_RECV_MESSAGE; |
||||
op->flags = 0; |
||||
op->reserved = NULL; |
||||
op->data.recv_message = &recv_buf_; |
||||
} |
||||
|
||||
void FinishOp(bool* status, int max_message_size) { |
||||
if (!deserialize_) return; |
||||
if (recv_buf_) { |
||||
if (*status) { |
||||
got_message = true; |
||||
*status = deserialize_->Deserialize(recv_buf_, max_message_size).ok(); |
||||
} else { |
||||
got_message = false; |
||||
grpc_byte_buffer_destroy(recv_buf_); |
||||
} |
||||
} else { |
||||
got_message = false; |
||||
*status = false; |
||||
} |
||||
deserialize_.reset(); |
||||
} |
||||
|
||||
private: |
||||
std::unique_ptr<CallOpGenericRecvMessageHelper::DeserializeFunc> deserialize_; |
||||
grpc_byte_buffer* recv_buf_; |
||||
}; |
||||
|
||||
class CallOpClientSendClose { |
||||
public: |
||||
CallOpClientSendClose() : send_(false) {} |
||||
|
||||
void ClientSendClose() { send_ = true; } |
||||
|
||||
protected: |
||||
void AddOp(grpc_op* ops, size_t* nops) { |
||||
if (!send_) return; |
||||
grpc_op* op = &ops[(*nops)++]; |
||||
op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; |
||||
op->flags = 0; |
||||
op->reserved = NULL; |
||||
} |
||||
void FinishOp(bool* status, int max_message_size) { send_ = false; } |
||||
|
||||
private: |
||||
bool send_; |
||||
}; |
||||
|
||||
class CallOpServerSendStatus { |
||||
public: |
||||
CallOpServerSendStatus() : send_status_available_(false) {} |
||||
|
||||
void ServerSendStatus( |
||||
const std::multimap<grpc::string, grpc::string>& trailing_metadata, |
||||
const Status& status) { |
||||
trailing_metadata_count_ = trailing_metadata.size(); |
||||
trailing_metadata_ = FillMetadataArray(trailing_metadata); |
||||
send_status_available_ = true; |
||||
send_status_code_ = static_cast<grpc_status_code>(status.error_code()); |
||||
send_status_details_ = status.error_message(); |
||||
} |
||||
|
||||
protected: |
||||
void AddOp(grpc_op* ops, size_t* nops) { |
||||
if (!send_status_available_) return; |
||||
grpc_op* op = &ops[(*nops)++]; |
||||
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER; |
||||
op->data.send_status_from_server.trailing_metadata_count = |
||||
trailing_metadata_count_; |
||||
op->data.send_status_from_server.trailing_metadata = trailing_metadata_; |
||||
op->data.send_status_from_server.status = send_status_code_; |
||||
op->data.send_status_from_server.status_details = |
||||
send_status_details_.empty() ? nullptr : send_status_details_.c_str(); |
||||
op->flags = 0; |
||||
op->reserved = NULL; |
||||
} |
||||
|
||||
void FinishOp(bool* status, int max_message_size) { |
||||
if (!send_status_available_) return; |
||||
gpr_free(trailing_metadata_); |
||||
send_status_available_ = false; |
||||
} |
||||
|
||||
private: |
||||
bool send_status_available_; |
||||
grpc_status_code send_status_code_; |
||||
grpc::string send_status_details_; |
||||
size_t trailing_metadata_count_; |
||||
grpc_metadata* trailing_metadata_; |
||||
}; |
||||
|
||||
class CallOpRecvInitialMetadata { |
||||
public: |
||||
CallOpRecvInitialMetadata() : recv_initial_metadata_(nullptr) {} |
||||
|
||||
void RecvInitialMetadata(ClientContext* context) { |
||||
context->initial_metadata_received_ = true; |
||||
recv_initial_metadata_ = &context->recv_initial_metadata_; |
||||
} |
||||
|
||||
protected: |
||||
void AddOp(grpc_op* ops, size_t* nops) { |
||||
if (!recv_initial_metadata_) return; |
||||
memset(&recv_initial_metadata_arr_, 0, sizeof(recv_initial_metadata_arr_)); |
||||
grpc_op* op = &ops[(*nops)++]; |
||||
op->op = GRPC_OP_RECV_INITIAL_METADATA; |
||||
op->data.recv_initial_metadata = &recv_initial_metadata_arr_; |
||||
op->flags = 0; |
||||
op->reserved = NULL; |
||||
} |
||||
void FinishOp(bool* status, int max_message_size) { |
||||
if (recv_initial_metadata_ == nullptr) return; |
||||
FillMetadataMap(&recv_initial_metadata_arr_, recv_initial_metadata_); |
||||
recv_initial_metadata_ = nullptr; |
||||
} |
||||
|
||||
private: |
||||
std::multimap<grpc::string_ref, grpc::string_ref>* recv_initial_metadata_; |
||||
grpc_metadata_array recv_initial_metadata_arr_; |
||||
}; |
||||
|
||||
class CallOpClientRecvStatus { |
||||
public: |
||||
CallOpClientRecvStatus() : recv_status_(nullptr) {} |
||||
|
||||
void ClientRecvStatus(ClientContext* context, Status* status) { |
||||
recv_trailing_metadata_ = &context->trailing_metadata_; |
||||
recv_status_ = status; |
||||
} |
||||
|
||||
protected: |
||||
void AddOp(grpc_op* ops, size_t* nops) { |
||||
if (recv_status_ == nullptr) return; |
||||
memset(&recv_trailing_metadata_arr_, 0, |
||||
sizeof(recv_trailing_metadata_arr_)); |
||||
status_details_ = nullptr; |
||||
status_details_capacity_ = 0; |
||||
grpc_op* op = &ops[(*nops)++]; |
||||
op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; |
||||
op->data.recv_status_on_client.trailing_metadata = |
||||
&recv_trailing_metadata_arr_; |
||||
op->data.recv_status_on_client.status = &status_code_; |
||||
op->data.recv_status_on_client.status_details = &status_details_; |
||||
op->data.recv_status_on_client.status_details_capacity = |
||||
&status_details_capacity_; |
||||
op->flags = 0; |
||||
op->reserved = NULL; |
||||
} |
||||
|
||||
void FinishOp(bool* status, int max_message_size) { |
||||
if (recv_status_ == nullptr) return; |
||||
FillMetadataMap(&recv_trailing_metadata_arr_, recv_trailing_metadata_); |
||||
*recv_status_ = Status( |
||||
static_cast<StatusCode>(status_code_), |
||||
status_details_ ? grpc::string(status_details_) : grpc::string()); |
||||
gpr_free(status_details_); |
||||
recv_status_ = nullptr; |
||||
} |
||||
|
||||
private: |
||||
std::multimap<grpc::string_ref, grpc::string_ref>* recv_trailing_metadata_; |
||||
Status* recv_status_; |
||||
grpc_metadata_array recv_trailing_metadata_arr_; |
||||
grpc_status_code status_code_; |
||||
char* status_details_; |
||||
size_t status_details_capacity_; |
||||
}; |
||||
|
||||
/// An abstract collection of call ops, used to generate the
|
||||
/// grpc_call_op structure to pass down to the lower layers,
|
||||
/// and as it is-a CompletionQueueTag, also massages the final
|
||||
/// completion into the correct form for consumption in the C++
|
||||
/// API.
|
||||
class CallOpSetInterface : public CompletionQueueTag { |
||||
public: |
||||
CallOpSetInterface() : max_message_size_(0) {} |
||||
/// Fills in grpc_op, starting from ops[*nops] and moving
|
||||
/// upwards.
|
||||
virtual void FillOps(grpc_op* ops, size_t* nops) = 0; |
||||
|
||||
void set_max_message_size(int max_message_size) { |
||||
max_message_size_ = max_message_size; |
||||
} |
||||
|
||||
protected: |
||||
int max_message_size_; |
||||
}; |
||||
|
||||
/// Primary implementaiton of CallOpSetInterface.
|
||||
/// Since we cannot use variadic templates, we declare slots up to
|
||||
/// the maximum count of ops we'll need in a set. We leverage the
|
||||
/// empty base class optimization to slim this class (especially
|
||||
/// when there are many unused slots used). To avoid duplicate base classes,
|
||||
/// the template parmeter for CallNoOp is varied by argument position.
|
||||
template <class Op1 = CallNoOp<1>, class Op2 = CallNoOp<2>, |
||||
class Op3 = CallNoOp<3>, class Op4 = CallNoOp<4>, |
||||
class Op5 = CallNoOp<5>, class Op6 = CallNoOp<6>> |
||||
class CallOpSet : public CallOpSetInterface, |
||||
public Op1, |
||||
public Op2, |
||||
public Op3, |
||||
public Op4, |
||||
public Op5, |
||||
public Op6 { |
||||
public: |
||||
CallOpSet() : return_tag_(this) {} |
||||
void FillOps(grpc_op* ops, size_t* nops) GRPC_OVERRIDE { |
||||
this->Op1::AddOp(ops, nops); |
||||
this->Op2::AddOp(ops, nops); |
||||
this->Op3::AddOp(ops, nops); |
||||
this->Op4::AddOp(ops, nops); |
||||
this->Op5::AddOp(ops, nops); |
||||
this->Op6::AddOp(ops, nops); |
||||
} |
||||
|
||||
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { |
||||
this->Op1::FinishOp(status, max_message_size_); |
||||
this->Op2::FinishOp(status, max_message_size_); |
||||
this->Op3::FinishOp(status, max_message_size_); |
||||
this->Op4::FinishOp(status, max_message_size_); |
||||
this->Op5::FinishOp(status, max_message_size_); |
||||
this->Op6::FinishOp(status, max_message_size_); |
||||
*tag = return_tag_; |
||||
return true; |
||||
} |
||||
|
||||
void set_output_tag(void* return_tag) { return_tag_ = return_tag; } |
||||
|
||||
private: |
||||
void* return_tag_; |
||||
}; |
||||
|
||||
/// A CallOpSet that does not post completions to the completion queue.
|
||||
///
|
||||
/// Allows hiding some completions that the C core must generate from
|
||||
/// C++ users.
|
||||
template <class Op1 = CallNoOp<1>, class Op2 = CallNoOp<2>, |
||||
class Op3 = CallNoOp<3>, class Op4 = CallNoOp<4>, |
||||
class Op5 = CallNoOp<5>, class Op6 = CallNoOp<6>> |
||||
class SneakyCallOpSet : public CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> { |
||||
public: |
||||
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { |
||||
typedef CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> Base; |
||||
return Base::FinalizeResult(tag, status) && false; |
||||
} |
||||
}; |
||||
|
||||
// Straightforward wrapping of the C call object
|
||||
class Call GRPC_FINAL { |
||||
public: |
||||
/* call is owned by the caller */ |
||||
Call(grpc_call* call, CallHook* call_hook_, CompletionQueue* cq); |
||||
Call(grpc_call* call, CallHook* call_hook_, CompletionQueue* cq, |
||||
int max_message_size); |
||||
|
||||
void PerformOps(CallOpSetInterface* ops); |
||||
|
||||
grpc_call* call() { return call_; } |
||||
CompletionQueue* cq() { return cq_; } |
||||
|
||||
int max_message_size() { return max_message_size_; } |
||||
|
||||
private: |
||||
CallHook* call_hook_; |
||||
CompletionQueue* cq_; |
||||
grpc_call* call_; |
||||
int max_message_size_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_CALL_H
|
||||
@ -0,0 +1,51 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_CALL_HOOK_H |
||||
#define GRPCXX_IMPL_CODEGEN_CALL_HOOK_H |
||||
|
||||
namespace grpc { |
||||
|
||||
class CallOpSetInterface; |
||||
class Call; |
||||
|
||||
/// Channel and Server implement this to allow them to hook performing ops
|
||||
class CallHook { |
||||
public: |
||||
virtual ~CallHook() {} |
||||
virtual void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) = 0; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_CALL_HOOK_H
|
||||
@ -0,0 +1,123 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_CHANNEL_INTERFACE_H |
||||
#define GRPCXX_IMPL_CODEGEN_CHANNEL_INTERFACE_H |
||||
|
||||
#include <grpc++/impl/codegen/status.h> |
||||
#include <grpc++/impl/codegen/time.h> |
||||
#include <grpc/impl/codegen/connectivity_state.h> |
||||
|
||||
namespace grpc { |
||||
class Call; |
||||
class ClientContext; |
||||
class RpcMethod; |
||||
class CallOpSetInterface; |
||||
class CompletionQueue; |
||||
|
||||
template <class R> |
||||
class ClientReader; |
||||
template <class W> |
||||
class ClientWriter; |
||||
template <class W, class R> |
||||
class ClientReaderWriter; |
||||
template <class R> |
||||
class ClientAsyncReader; |
||||
template <class W> |
||||
class ClientAsyncWriter; |
||||
template <class W, class R> |
||||
class ClientAsyncReaderWriter; |
||||
template <class R> |
||||
class ClientAsyncResponseReader; |
||||
|
||||
/// Codegen interface for \a grpc::Channel.
|
||||
class ChannelInterface { |
||||
public: |
||||
virtual ~ChannelInterface() {} |
||||
/// Get the current channel state. If the channel is in IDLE and
|
||||
/// \a try_to_connect is set to true, try to connect.
|
||||
virtual grpc_connectivity_state GetState(bool try_to_connect) = 0; |
||||
|
||||
/// Return the \a tag on \a cq when the channel state is changed or \a
|
||||
/// deadline expires. \a GetState needs to called to get the current state.
|
||||
template <typename T> |
||||
void NotifyOnStateChange(grpc_connectivity_state last_observed, T deadline, |
||||
CompletionQueue* cq, void* tag) { |
||||
TimePoint<T> deadline_tp(deadline); |
||||
NotifyOnStateChangeImpl(last_observed, deadline_tp.raw_time(), cq, tag); |
||||
} |
||||
|
||||
/// Blocking wait for channel state change or \a deadline expiration.
|
||||
/// \a GetState needs to called to get the current state.
|
||||
template <typename T> |
||||
bool WaitForStateChange(grpc_connectivity_state last_observed, T deadline) { |
||||
TimePoint<T> deadline_tp(deadline); |
||||
return WaitForStateChangeImpl(last_observed, deadline_tp.raw_time()); |
||||
} |
||||
|
||||
private: |
||||
template <class R> |
||||
friend class ::grpc::ClientReader; |
||||
template <class W> |
||||
friend class ::grpc::ClientWriter; |
||||
template <class W, class R> |
||||
friend class ::grpc::ClientReaderWriter; |
||||
template <class R> |
||||
friend class ::grpc::ClientAsyncReader; |
||||
template <class W> |
||||
friend class ::grpc::ClientAsyncWriter; |
||||
template <class W, class R> |
||||
friend class ::grpc::ClientAsyncReaderWriter; |
||||
template <class R> |
||||
friend class ::grpc::ClientAsyncResponseReader; |
||||
template <class InputMessage, class OutputMessage> |
||||
friend Status BlockingUnaryCall(ChannelInterface* channel, |
||||
const RpcMethod& method, |
||||
ClientContext* context, |
||||
const InputMessage& request, |
||||
OutputMessage* result); |
||||
friend class ::grpc::RpcMethod; |
||||
virtual Call CreateCall(const RpcMethod& method, ClientContext* context, |
||||
CompletionQueue* cq) = 0; |
||||
virtual void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) = 0; |
||||
virtual void* RegisterMethod(const char* method) = 0; |
||||
virtual void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed, |
||||
gpr_timespec deadline, |
||||
CompletionQueue* cq, void* tag) = 0; |
||||
virtual bool WaitForStateChangeImpl(grpc_connectivity_state last_observed, |
||||
gpr_timespec deadline) = 0; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_CHANNEL_INTERFACE_H
|
||||
@ -0,0 +1,354 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
/// A ClientContext allows the person implementing a service client to:
|
||||
///
|
||||
/// - Add custom metadata key-value pairs that will propagated to the server
|
||||
/// side.
|
||||
/// - Control call settings such as compression and authentication.
|
||||
/// - Initial and trailing metadata coming from the server.
|
||||
/// - Get performance metrics (ie, census).
|
||||
///
|
||||
/// Context settings are only relevant to the call they are invoked with, that
|
||||
/// is to say, they aren't sticky. Some of these settings, such as the
|
||||
/// compression options, can be made persistant at channel construction time
|
||||
/// (see \a grpc::CreateCustomChannel).
|
||||
///
|
||||
/// \warning ClientContext instances should \em not be reused across rpcs.
|
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_CLIENT_CONTEXT_H |
||||
#define GRPCXX_IMPL_CODEGEN_CLIENT_CONTEXT_H |
||||
|
||||
#include <map> |
||||
#include <memory> |
||||
#include <string> |
||||
|
||||
#include <grpc++/impl/codegen/config.h> |
||||
#include <grpc++/impl/codegen/security/auth_context.h> |
||||
#include <grpc++/impl/codegen/status.h> |
||||
#include <grpc++/impl/codegen/string_ref.h> |
||||
#include <grpc++/impl/codegen/sync.h> |
||||
#include <grpc++/impl/codegen/time.h> |
||||
#include <grpc/impl/codegen/compression_types.h> |
||||
#include <grpc/impl/codegen/log.h> |
||||
#include <grpc/impl/codegen/propagation_bits.h> |
||||
#include <grpc/impl/codegen/time.h> |
||||
|
||||
struct census_context; |
||||
struct grpc_call; |
||||
|
||||
namespace grpc { |
||||
|
||||
class Channel; |
||||
class ChannelInterface; |
||||
class CompletionQueue; |
||||
class CallCredentials; |
||||
class RpcMethod; |
||||
template <class R> |
||||
class ClientReader; |
||||
template <class W> |
||||
class ClientWriter; |
||||
template <class W, class R> |
||||
class ClientReaderWriter; |
||||
template <class R> |
||||
class ClientAsyncReader; |
||||
template <class W> |
||||
class ClientAsyncWriter; |
||||
template <class W, class R> |
||||
class ClientAsyncReaderWriter; |
||||
template <class R> |
||||
class ClientAsyncResponseReader; |
||||
class ServerContext; |
||||
|
||||
/// Options for \a ClientContext::FromServerContext specifying which traits from
|
||||
/// the \a ServerContext to propagate (copy) from it into a new \a
|
||||
/// ClientContext.
|
||||
///
|
||||
/// \see ClientContext::FromServerContext
|
||||
class PropagationOptions { |
||||
public: |
||||
PropagationOptions() : propagate_(GRPC_PROPAGATE_DEFAULTS) {} |
||||
|
||||
PropagationOptions& enable_deadline_propagation() { |
||||
propagate_ |= GRPC_PROPAGATE_DEADLINE; |
||||
return *this; |
||||
} |
||||
|
||||
PropagationOptions& disable_deadline_propagation() { |
||||
propagate_ &= ~GRPC_PROPAGATE_DEADLINE; |
||||
return *this; |
||||
} |
||||
|
||||
PropagationOptions& enable_census_stats_propagation() { |
||||
propagate_ |= GRPC_PROPAGATE_CENSUS_STATS_CONTEXT; |
||||
return *this; |
||||
} |
||||
|
||||
PropagationOptions& disable_census_stats_propagation() { |
||||
propagate_ &= ~GRPC_PROPAGATE_CENSUS_STATS_CONTEXT; |
||||
return *this; |
||||
} |
||||
|
||||
PropagationOptions& enable_census_tracing_propagation() { |
||||
propagate_ |= GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT; |
||||
return *this; |
||||
} |
||||
|
||||
PropagationOptions& disable_census_tracing_propagation() { |
||||
propagate_ &= ~GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT; |
||||
return *this; |
||||
} |
||||
|
||||
PropagationOptions& enable_cancellation_propagation() { |
||||
propagate_ |= GRPC_PROPAGATE_CANCELLATION; |
||||
return *this; |
||||
} |
||||
|
||||
PropagationOptions& disable_cancellation_propagation() { |
||||
propagate_ &= ~GRPC_PROPAGATE_CANCELLATION; |
||||
return *this; |
||||
} |
||||
|
||||
uint32_t c_bitmask() const { return propagate_; } |
||||
|
||||
private: |
||||
uint32_t propagate_; |
||||
}; |
||||
|
||||
namespace testing { |
||||
class InteropClientContextInspector; |
||||
} // namespace testing
|
||||
|
||||
class ClientContext { |
||||
public: |
||||
ClientContext(); |
||||
~ClientContext(); |
||||
|
||||
/// Create a new \a ClientContext as a child of an incoming server call,
|
||||
/// according to \a options (\see PropagationOptions).
|
||||
///
|
||||
/// \param server_context The source server context to use as the basis for
|
||||
/// constructing the client context.
|
||||
/// \param options The options controlling what to copy from the \a
|
||||
/// server_context.
|
||||
///
|
||||
/// \return A newly constructed \a ClientContext instance based on \a
|
||||
/// server_context, with traits propagated (copied) according to \a options.
|
||||
static std::unique_ptr<ClientContext> FromServerContext( |
||||
const ServerContext& server_context, |
||||
PropagationOptions options = PropagationOptions()); |
||||
|
||||
/// Add the (\a meta_key, \a meta_value) pair to the metadata associated with
|
||||
/// a client call. These are made available at the server side by the \a
|
||||
/// grpc::ServerContext::client_metadata() method.
|
||||
///
|
||||
/// \warning This method should only be called before invoking the rpc.
|
||||
///
|
||||
/// \param meta_key The metadata key. If \a meta_value is binary data, it must
|
||||
/// end in "-bin".
|
||||
/// \param meta_value The metadata value. If its value is binary, it must be
|
||||
/// base64-encoding (see https://tools.ietf.org/html/rfc4648#section-4) and \a
|
||||
/// meta_key must end in "-bin".
|
||||
void AddMetadata(const grpc::string& meta_key, |
||||
const grpc::string& meta_value); |
||||
|
||||
/// Return a collection of initial metadata key-value pairs. Note that keys
|
||||
/// may happen more than once (ie, a \a std::multimap is returned).
|
||||
///
|
||||
/// \warning This method should only be called after initial metadata has been
|
||||
/// received. For streaming calls, see \a
|
||||
/// ClientReaderInterface::WaitForInitialMetadata().
|
||||
///
|
||||
/// \return A multimap of initial metadata key-value pairs from the server.
|
||||
const std::multimap<grpc::string_ref, grpc::string_ref>& |
||||
GetServerInitialMetadata() { |
||||
GPR_ASSERT(initial_metadata_received_); |
||||
return recv_initial_metadata_; |
||||
} |
||||
|
||||
/// Return a collection of trailing metadata key-value pairs. Note that keys
|
||||
/// may happen more than once (ie, a \a std::multimap is returned).
|
||||
///
|
||||
/// \warning This method is only callable once the stream has finished.
|
||||
///
|
||||
/// \return A multimap of metadata trailing key-value pairs from the server.
|
||||
const std::multimap<grpc::string_ref, grpc::string_ref>& |
||||
GetServerTrailingMetadata() { |
||||
// TODO(yangg) check finished
|
||||
return trailing_metadata_; |
||||
} |
||||
|
||||
/// Set the deadline for the client call.
|
||||
///
|
||||
/// \warning This method should only be called before invoking the rpc.
|
||||
///
|
||||
/// \param deadline the deadline for the client call. Units are determined by
|
||||
/// the type used.
|
||||
template <typename T> |
||||
void set_deadline(const T& deadline) { |
||||
TimePoint<T> deadline_tp(deadline); |
||||
deadline_ = deadline_tp.raw_time(); |
||||
} |
||||
|
||||
#ifndef GRPC_CXX0X_NO_CHRONO |
||||
/// Return the deadline for the client call.
|
||||
std::chrono::system_clock::time_point deadline() { |
||||
return Timespec2Timepoint(deadline_); |
||||
} |
||||
#endif // !GRPC_CXX0X_NO_CHRONO
|
||||
|
||||
/// Return a \a gpr_timespec representation of the client call's deadline.
|
||||
gpr_timespec raw_deadline() { return deadline_; } |
||||
|
||||
/// Set the per call authority header (see
|
||||
/// https://tools.ietf.org/html/rfc7540#section-8.1.2.3).
|
||||
void set_authority(const grpc::string& authority) { authority_ = authority; } |
||||
|
||||
/// Return the authentication context for this client call.
|
||||
///
|
||||
/// \see grpc::AuthContext.
|
||||
std::shared_ptr<const AuthContext> auth_context() const; |
||||
|
||||
/// Set credentials for the client call.
|
||||
///
|
||||
/// A credentials object encapsulates all the state needed by a client to
|
||||
/// authenticate with a server and make various assertions, e.g., about the
|
||||
/// client’s identity, role, or whether it is authorized to make a particular
|
||||
/// call.
|
||||
///
|
||||
/// \see http://www.grpc.io/docs/guides/auth.html
|
||||
void set_credentials(const std::shared_ptr<CallCredentials>& creds) { |
||||
creds_ = creds; |
||||
} |
||||
|
||||
/// Return the compression algorithm to be used by the client call.
|
||||
grpc_compression_algorithm compression_algorithm() const { |
||||
return compression_algorithm_; |
||||
} |
||||
|
||||
/// Set \a algorithm to be the compression algorithm used for the client call.
|
||||
///
|
||||
/// \param algorith The compression algorithm used for the client call.
|
||||
void set_compression_algorithm(grpc_compression_algorithm algorithm); |
||||
|
||||
/// Return the peer uri in a string.
|
||||
///
|
||||
/// \warning This value is never authenticated or subject to any security
|
||||
/// related code. It must not be used for any authentication related
|
||||
/// functionality. Instead, use auth_context.
|
||||
///
|
||||
/// \return The call's peer URI.
|
||||
grpc::string peer() const; |
||||
|
||||
/// Get and set census context.
|
||||
void set_census_context(struct census_context* ccp) { census_context_ = ccp; } |
||||
struct census_context* census_context() const { |
||||
return census_context_; |
||||
} |
||||
|
||||
/// Send a best-effort out-of-band cancel. The call could be in any stage.
|
||||
/// e.g. if it is already finished, it may still return success.
|
||||
///
|
||||
/// There is no guarantee the call will be cancelled.
|
||||
void TryCancel(); |
||||
|
||||
/// Global Callbacks
|
||||
///
|
||||
/// Can be set exactly once per application to install hooks whenever
|
||||
/// a client context is constructed and destructed.
|
||||
class GlobalCallbacks { |
||||
public: |
||||
virtual ~GlobalCallbacks() {} |
||||
virtual void DefaultConstructor(ClientContext* context) = 0; |
||||
virtual void Destructor(ClientContext* context) = 0; |
||||
}; |
||||
static void SetGlobalCallbacks(GlobalCallbacks* callbacks); |
||||
|
||||
private: |
||||
// Disallow copy and assign.
|
||||
ClientContext(const ClientContext&); |
||||
ClientContext& operator=(const ClientContext&); |
||||
|
||||
friend class ::grpc::testing::InteropClientContextInspector; |
||||
friend class CallOpClientRecvStatus; |
||||
friend class CallOpRecvInitialMetadata; |
||||
friend class Channel; |
||||
template <class R> |
||||
friend class ::grpc::ClientReader; |
||||
template <class W> |
||||
friend class ::grpc::ClientWriter; |
||||
template <class W, class R> |
||||
friend class ::grpc::ClientReaderWriter; |
||||
template <class R> |
||||
friend class ::grpc::ClientAsyncReader; |
||||
template <class W> |
||||
friend class ::grpc::ClientAsyncWriter; |
||||
template <class W, class R> |
||||
friend class ::grpc::ClientAsyncReaderWriter; |
||||
template <class R> |
||||
friend class ::grpc::ClientAsyncResponseReader; |
||||
template <class InputMessage, class OutputMessage> |
||||
friend Status BlockingUnaryCall(ChannelInterface* channel, |
||||
const RpcMethod& method, |
||||
ClientContext* context, |
||||
const InputMessage& request, |
||||
OutputMessage* result); |
||||
|
||||
grpc_call* call() { return call_; } |
||||
void set_call(grpc_call* call, const std::shared_ptr<Channel>& channel); |
||||
|
||||
grpc::string authority() { return authority_; } |
||||
|
||||
bool initial_metadata_received_; |
||||
std::shared_ptr<Channel> channel_; |
||||
grpc::mutex mu_; |
||||
grpc_call* call_; |
||||
bool call_canceled_; |
||||
gpr_timespec deadline_; |
||||
grpc::string authority_; |
||||
std::shared_ptr<CallCredentials> creds_; |
||||
mutable std::shared_ptr<const AuthContext> auth_context_; |
||||
struct census_context* census_context_; |
||||
std::multimap<grpc::string, grpc::string> send_initial_metadata_; |
||||
std::multimap<grpc::string_ref, grpc::string_ref> recv_initial_metadata_; |
||||
std::multimap<grpc::string_ref, grpc::string_ref> trailing_metadata_; |
||||
|
||||
grpc_call* propagate_from_call_; |
||||
PropagationOptions propagation_options_; |
||||
|
||||
grpc_compression_algorithm compression_algorithm_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_CLIENT_CONTEXT_H
|
||||
@ -0,0 +1,75 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_CLIENT_UNARY_CALL_H |
||||
#define GRPCXX_IMPL_CODEGEN_CLIENT_UNARY_CALL_H |
||||
|
||||
#include <grpc++/impl/codegen/call.h> |
||||
#include <grpc++/impl/codegen/channel_interface.h> |
||||
#include <grpc++/impl/codegen/config.h> |
||||
#include <grpc++/impl/codegen/status.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
class Channel; |
||||
class ClientContext; |
||||
class CompletionQueue; |
||||
class RpcMethod; |
||||
|
||||
// Wrapper that performs a blocking unary call
|
||||
template <class InputMessage, class OutputMessage> |
||||
Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method, |
||||
ClientContext* context, const InputMessage& request, |
||||
OutputMessage* result) { |
||||
CompletionQueue cq; |
||||
Call call(channel->CreateCall(method, context, &cq)); |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, |
||||
CallOpRecvInitialMetadata, CallOpRecvMessage<OutputMessage>, |
||||
CallOpClientSendClose, CallOpClientRecvStatus> ops; |
||||
Status status = ops.SendMessage(request); |
||||
if (!status.ok()) { |
||||
return status; |
||||
} |
||||
ops.SendInitialMetadata(context->send_initial_metadata_); |
||||
ops.RecvInitialMetadata(context); |
||||
ops.RecvMessage(result); |
||||
ops.ClientSendClose(); |
||||
ops.ClientRecvStatus(context, &status); |
||||
call.PerformOps(&ops); |
||||
GPR_ASSERT((cq.Pluck(&ops) && ops.got_message) || !status.ok()); |
||||
return status; |
||||
} |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_CLIENT_UNARY_CALL_H
|
||||
@ -0,0 +1,202 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
/// A completion queue implements a concurrent producer-consumer queue, with two
|
||||
/// main methods, \a Next and \a AsyncNext.
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_COMPLETION_QUEUE_H |
||||
#define GRPCXX_IMPL_CODEGEN_COMPLETION_QUEUE_H |
||||
|
||||
#include <grpc++/impl/codegen/grpc_library.h> |
||||
#include <grpc++/impl/codegen/status.h> |
||||
#include <grpc++/impl/codegen/time.h> |
||||
|
||||
struct grpc_completion_queue; |
||||
|
||||
namespace grpc { |
||||
|
||||
template <class R> |
||||
class ClientReader; |
||||
template <class W> |
||||
class ClientWriter; |
||||
template <class W, class R> |
||||
class ClientReaderWriter; |
||||
template <class R> |
||||
class ServerReader; |
||||
template <class W> |
||||
class ServerWriter; |
||||
template <class W, class R> |
||||
class ServerReaderWriter; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class RpcMethodHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class ClientStreamingHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class ServerStreamingHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class BidiStreamingHandler; |
||||
class UnknownMethodHandler; |
||||
|
||||
class Channel; |
||||
class ChannelInterface; |
||||
class ClientContext; |
||||
class CompletionQueueTag; |
||||
class CompletionQueue; |
||||
class RpcMethod; |
||||
class Server; |
||||
class ServerBuilder; |
||||
class ServerContext; |
||||
|
||||
/// A thin wrapper around \a grpc_completion_queue (see / \a
|
||||
/// src/core/surface/completion_queue.h).
|
||||
class CompletionQueue : private GrpcLibrary { |
||||
public: |
||||
/// Default constructor. Implicitly creates a \a grpc_completion_queue
|
||||
/// instance.
|
||||
CompletionQueue(); |
||||
|
||||
/// Wrap \a take, taking ownership of the instance.
|
||||
///
|
||||
/// \param take The completion queue instance to wrap. Ownership is taken.
|
||||
explicit CompletionQueue(grpc_completion_queue* take); |
||||
|
||||
/// Destructor. Destroys the owned wrapped completion queue / instance.
|
||||
~CompletionQueue(); |
||||
|
||||
/// Tri-state return for AsyncNext: SHUTDOWN, GOT_EVENT, TIMEOUT.
|
||||
enum NextStatus { |
||||
SHUTDOWN, ///< The completion queue has been shutdown.
|
||||
GOT_EVENT, ///< Got a new event; \a tag will be filled in with its
|
||||
///< associated value; \a ok indicating its success.
|
||||
TIMEOUT ///< deadline was reached.
|
||||
}; |
||||
|
||||
/// Read from the queue, blocking up to \a deadline (or the queue's shutdown).
|
||||
/// Both \a tag and \a ok are updated upon success (if an event is available
|
||||
/// within the \a deadline). A \a tag points to an arbitrary location usually
|
||||
/// employed to uniquely identify an event.
|
||||
///
|
||||
/// \param tag[out] Upon sucess, updated to point to the event's tag.
|
||||
/// \param ok[out] Upon sucess, true if read a regular event, false otherwise.
|
||||
/// \param deadline[in] How long to block in wait for an event.
|
||||
///
|
||||
/// \return The type of event read.
|
||||
template <typename T> |
||||
NextStatus AsyncNext(void** tag, bool* ok, const T& deadline) { |
||||
TimePoint<T> deadline_tp(deadline); |
||||
return AsyncNextInternal(tag, ok, deadline_tp.raw_time()); |
||||
} |
||||
|
||||
/// Read from the queue, blocking until an event is available or the queue is
|
||||
/// shutting down.
|
||||
///
|
||||
/// \param tag[out] Updated to point to the read event's tag.
|
||||
/// \param ok[out] true if read a regular event, false otherwise.
|
||||
///
|
||||
/// \return true if read a regular event, false if the queue is shutting down.
|
||||
bool Next(void** tag, bool* ok) { |
||||
return (AsyncNextInternal(tag, ok, gpr_inf_future(GPR_CLOCK_REALTIME)) != |
||||
SHUTDOWN); |
||||
} |
||||
|
||||
/// Request the shutdown of the queue.
|
||||
///
|
||||
/// \warning This method must be called at some point. Once invoked, \a Next
|
||||
/// will start to return false and \a AsyncNext will return \a
|
||||
/// NextStatus::SHUTDOWN. Only once either one of these methods does that
|
||||
/// (that is, once the queue has been \em drained) can an instance of this
|
||||
/// class be destroyed.
|
||||
void Shutdown(); |
||||
|
||||
/// Returns a \em raw pointer to the underlying \a grpc_completion_queue
|
||||
/// instance.
|
||||
///
|
||||
/// \warning Remember that the returned instance is owned. No transfer of
|
||||
/// owership is performed.
|
||||
grpc_completion_queue* cq() { return cq_; } |
||||
|
||||
private: |
||||
// Friend synchronous wrappers so that they can access Pluck(), which is
|
||||
// a semi-private API geared towards the synchronous implementation.
|
||||
template <class R> |
||||
friend class ::grpc::ClientReader; |
||||
template <class W> |
||||
friend class ::grpc::ClientWriter; |
||||
template <class W, class R> |
||||
friend class ::grpc::ClientReaderWriter; |
||||
template <class R> |
||||
friend class ::grpc::ServerReader; |
||||
template <class W> |
||||
friend class ::grpc::ServerWriter; |
||||
template <class W, class R> |
||||
friend class ::grpc::ServerReaderWriter; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
friend class RpcMethodHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
friend class ClientStreamingHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
friend class ServerStreamingHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
friend class BidiStreamingHandler; |
||||
friend class UnknownMethodHandler; |
||||
friend class ::grpc::Server; |
||||
friend class ::grpc::ServerContext; |
||||
template <class InputMessage, class OutputMessage> |
||||
friend Status BlockingUnaryCall(ChannelInterface* channel, |
||||
const RpcMethod& method, |
||||
ClientContext* context, |
||||
const InputMessage& request, |
||||
OutputMessage* result); |
||||
|
||||
NextStatus AsyncNextInternal(void** tag, bool* ok, gpr_timespec deadline); |
||||
|
||||
/// Wraps \a grpc_completion_queue_pluck.
|
||||
/// \warning Must not be mixed with calls to \a Next.
|
||||
bool Pluck(CompletionQueueTag* tag); |
||||
|
||||
/// Performs a single polling pluck on \a tag.
|
||||
void TryPluck(CompletionQueueTag* tag); |
||||
|
||||
grpc_completion_queue* cq_; // owned
|
||||
}; |
||||
|
||||
/// A specific type of completion queue used by the processing of notifications
|
||||
/// by servers. Instantiated by \a ServerBuilder.
|
||||
class ServerCompletionQueue : public CompletionQueue { |
||||
private: |
||||
friend class ServerBuilder; |
||||
ServerCompletionQueue() {} |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_COMPLETION_QUEUE_H
|
||||
@ -0,0 +1,52 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_COMPLETION_QUEUE_TAG_H |
||||
#define GRPCXX_COMPLETION_QUEUE_TAG_H |
||||
|
||||
namespace grpc { |
||||
|
||||
/// An interface allowing implementors to process and filter event tags.
|
||||
class CompletionQueueTag { |
||||
public: |
||||
virtual ~CompletionQueueTag() {} |
||||
// Called prior to returning from Next(), return value is the status of the
|
||||
// operation (return status is the default thing to do). If this function
|
||||
// returns false, the tag is dropped and not returned from the completion
|
||||
// queue
|
||||
virtual bool FinalizeResult(void** tag, bool* status) = 0; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_COMPLETION_QUEUE_TAG_H
|
||||
@ -0,0 +1,116 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_CONFIG_H |
||||
#define GRPCXX_IMPL_CODEGEN_CONFIG_H |
||||
|
||||
#if !defined(GRPC_NO_AUTODETECT_PLATFORM) |
||||
|
||||
#ifdef _MSC_VER |
||||
// Visual Studio 2010 is 1600.
|
||||
#if _MSC_VER < 1600 |
||||
#error "gRPC is only supported with Visual Studio starting at 2010" |
||||
// Visual Studio 2013 is 1800.
|
||||
#elif _MSC_VER < 1800 |
||||
#define GRPC_CXX0X_NO_FINAL 1 |
||||
#define GRPC_CXX0X_NO_OVERRIDE 1 |
||||
#define GRPC_CXX0X_NO_CHRONO 1 |
||||
#define GRPC_CXX0X_NO_THREAD 1 |
||||
#endif |
||||
#endif // Visual Studio
|
||||
|
||||
#ifndef __clang__ |
||||
#ifdef __GNUC__ |
||||
// nullptr was added in gcc 4.6
|
||||
#if (__GNUC__ * 100 + __GNUC_MINOR__ < 406) |
||||
#define GRPC_CXX0X_NO_NULLPTR 1 |
||||
#endif |
||||
// final and override were added in gcc 4.7
|
||||
#if (__GNUC__ * 100 + __GNUC_MINOR__ < 407) |
||||
#define GRPC_CXX0X_NO_FINAL 1 |
||||
#define GRPC_CXX0X_NO_OVERRIDE 1 |
||||
#endif |
||||
#endif |
||||
#endif |
||||
|
||||
#endif |
||||
|
||||
#ifdef GRPC_CXX0X_NO_FINAL |
||||
#define GRPC_FINAL |
||||
#else |
||||
#define GRPC_FINAL final |
||||
#endif |
||||
|
||||
#ifdef GRPC_CXX0X_NO_OVERRIDE |
||||
#define GRPC_OVERRIDE |
||||
#else |
||||
#define GRPC_OVERRIDE override |
||||
#endif |
||||
|
||||
#ifdef GRPC_CXX0X_NO_NULLPTR |
||||
#include <memory> |
||||
namespace grpc { |
||||
const class { |
||||
public: |
||||
template <class T> |
||||
operator T *() const { |
||||
return static_cast<T *>(0); |
||||
} |
||||
template <class T> |
||||
operator std::unique_ptr<T>() const { |
||||
return std::unique_ptr<T>(static_cast<T *>(0)); |
||||
} |
||||
template <class T> |
||||
operator std::shared_ptr<T>() const { |
||||
return std::shared_ptr<T>(static_cast<T *>(0)); |
||||
} |
||||
operator bool() const { return false; } |
||||
|
||||
private: |
||||
void operator&() const = delete; |
||||
} nullptr = {}; |
||||
} |
||||
#endif |
||||
|
||||
#ifndef GRPC_CUSTOM_STRING |
||||
#include <string> |
||||
#define GRPC_CUSTOM_STRING std::string |
||||
#endif |
||||
|
||||
namespace grpc { |
||||
|
||||
typedef GRPC_CUSTOM_STRING string; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_CONFIG_H
|
||||
@ -0,0 +1,72 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_CONFIG_PROTOBUF_H |
||||
#define GRPCXX_IMPL_CODEGEN_CONFIG_PROTOBUF_H |
||||
|
||||
#ifndef GRPC_CUSTOM_PROTOBUF_INT64 |
||||
#include <google/protobuf/stubs/common.h> |
||||
#define GRPC_CUSTOM_PROTOBUF_INT64 ::google::protobuf::int64 |
||||
#endif |
||||
|
||||
#ifndef GRPC_CUSTOM_MESSAGE |
||||
#include <google/protobuf/message.h> |
||||
#define GRPC_CUSTOM_MESSAGE ::google::protobuf::Message |
||||
#endif |
||||
|
||||
#ifndef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM |
||||
#include <google/protobuf/io/coded_stream.h> |
||||
#include <google/protobuf/io/zero_copy_stream.h> |
||||
#define GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM \ |
||||
::google::protobuf::io::ZeroCopyOutputStream |
||||
#define GRPC_CUSTOM_ZEROCOPYINPUTSTREAM \ |
||||
::google::protobuf::io::ZeroCopyInputStream |
||||
#define GRPC_CUSTOM_CODEDINPUTSTREAM ::google::protobuf::io::CodedInputStream |
||||
#endif |
||||
|
||||
namespace grpc { |
||||
namespace protobuf { |
||||
|
||||
typedef GRPC_CUSTOM_MESSAGE Message; |
||||
typedef GRPC_CUSTOM_PROTOBUF_INT64 int64; |
||||
|
||||
namespace io { |
||||
typedef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM ZeroCopyOutputStream; |
||||
typedef GRPC_CUSTOM_ZEROCOPYINPUTSTREAM ZeroCopyInputStream; |
||||
typedef GRPC_CUSTOM_CODEDINPUTSTREAM CodedInputStream; |
||||
} // namespace io
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_CONFIG_PROTOBUF_H
|
||||
@ -0,0 +1,67 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_GRPC_LIBRARY_H |
||||
#define GRPCXX_IMPL_CODEGEN_GRPC_LIBRARY_H |
||||
|
||||
#include <grpc/impl/codegen/log.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
class GrpcLibraryInterface { |
||||
public: |
||||
virtual void init() = 0; |
||||
virtual void shutdown() = 0; |
||||
}; |
||||
|
||||
extern GrpcLibraryInterface* g_glip; |
||||
|
||||
class GrpcLibrary { |
||||
public: |
||||
GrpcLibrary() { |
||||
GPR_ASSERT(g_glip && |
||||
"gRPC library not initialized. See " |
||||
"grpc::internal::GrpcLibraryInitializer."); |
||||
g_glip->init(); |
||||
} |
||||
virtual ~GrpcLibrary() { |
||||
GPR_ASSERT(g_glip && |
||||
"gRPC library not initialized. See " |
||||
"grpc::internal::GrpcLibraryInitializer."); |
||||
g_glip->shutdown(); |
||||
} |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_GRPC_LIBRARY_H
|
||||
@ -0,0 +1,203 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H |
||||
#define GRPCXX_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H |
||||
|
||||
#include <grpc++/impl/codegen/rpc_service_method.h> |
||||
#include <grpc++/impl/codegen/sync_stream.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
// A wrapper class of an application provided rpc method handler.
|
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class RpcMethodHandler : public MethodHandler { |
||||
public: |
||||
RpcMethodHandler( |
||||
std::function<Status(ServiceType*, ServerContext*, const RequestType*, |
||||
ResponseType*)> func, |
||||
ServiceType* service) |
||||
: func_(func), service_(service) {} |
||||
|
||||
void RunHandler(const HandlerParameter& param) GRPC_FINAL { |
||||
RequestType req; |
||||
Status status = SerializationTraits<RequestType>::Deserialize( |
||||
param.request, &req, param.max_message_size); |
||||
ResponseType rsp; |
||||
if (status.ok()) { |
||||
status = func_(service_, param.server_context, &req, &rsp); |
||||
} |
||||
|
||||
GPR_ASSERT(!param.server_context->sent_initial_metadata_); |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, |
||||
CallOpServerSendStatus> ops; |
||||
ops.SendInitialMetadata(param.server_context->initial_metadata_); |
||||
if (status.ok()) { |
||||
status = ops.SendMessage(rsp); |
||||
} |
||||
ops.ServerSendStatus(param.server_context->trailing_metadata_, status); |
||||
param.call->PerformOps(&ops); |
||||
param.call->cq()->Pluck(&ops); |
||||
} |
||||
|
||||
private: |
||||
// Application provided rpc handler function.
|
||||
std::function<Status(ServiceType*, ServerContext*, const RequestType*, |
||||
ResponseType*)> func_; |
||||
// The class the above handler function lives in.
|
||||
ServiceType* service_; |
||||
}; |
||||
|
||||
// A wrapper class of an application provided client streaming handler.
|
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class ClientStreamingHandler : public MethodHandler { |
||||
public: |
||||
ClientStreamingHandler( |
||||
std::function<Status(ServiceType*, ServerContext*, |
||||
ServerReader<RequestType>*, ResponseType*)> func, |
||||
ServiceType* service) |
||||
: func_(func), service_(service) {} |
||||
|
||||
void RunHandler(const HandlerParameter& param) GRPC_FINAL { |
||||
ServerReader<RequestType> reader(param.call, param.server_context); |
||||
ResponseType rsp; |
||||
Status status = func_(service_, param.server_context, &reader, &rsp); |
||||
|
||||
GPR_ASSERT(!param.server_context->sent_initial_metadata_); |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, |
||||
CallOpServerSendStatus> ops; |
||||
ops.SendInitialMetadata(param.server_context->initial_metadata_); |
||||
if (status.ok()) { |
||||
status = ops.SendMessage(rsp); |
||||
} |
||||
ops.ServerSendStatus(param.server_context->trailing_metadata_, status); |
||||
param.call->PerformOps(&ops); |
||||
param.call->cq()->Pluck(&ops); |
||||
} |
||||
|
||||
private: |
||||
std::function<Status(ServiceType*, ServerContext*, ServerReader<RequestType>*, |
||||
ResponseType*)> func_; |
||||
ServiceType* service_; |
||||
}; |
||||
|
||||
// A wrapper class of an application provided server streaming handler.
|
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class ServerStreamingHandler : public MethodHandler { |
||||
public: |
||||
ServerStreamingHandler( |
||||
std::function<Status(ServiceType*, ServerContext*, const RequestType*, |
||||
ServerWriter<ResponseType>*)> func, |
||||
ServiceType* service) |
||||
: func_(func), service_(service) {} |
||||
|
||||
void RunHandler(const HandlerParameter& param) GRPC_FINAL { |
||||
RequestType req; |
||||
Status status = SerializationTraits<RequestType>::Deserialize( |
||||
param.request, &req, param.max_message_size); |
||||
|
||||
if (status.ok()) { |
||||
ServerWriter<ResponseType> writer(param.call, param.server_context); |
||||
status = func_(service_, param.server_context, &req, &writer); |
||||
} |
||||
|
||||
CallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> ops; |
||||
if (!param.server_context->sent_initial_metadata_) { |
||||
ops.SendInitialMetadata(param.server_context->initial_metadata_); |
||||
} |
||||
ops.ServerSendStatus(param.server_context->trailing_metadata_, status); |
||||
param.call->PerformOps(&ops); |
||||
param.call->cq()->Pluck(&ops); |
||||
} |
||||
|
||||
private: |
||||
std::function<Status(ServiceType*, ServerContext*, const RequestType*, |
||||
ServerWriter<ResponseType>*)> func_; |
||||
ServiceType* service_; |
||||
}; |
||||
|
||||
// A wrapper class of an application provided bidi-streaming handler.
|
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class BidiStreamingHandler : public MethodHandler { |
||||
public: |
||||
BidiStreamingHandler( |
||||
std::function<Status(ServiceType*, ServerContext*, |
||||
ServerReaderWriter<ResponseType, RequestType>*)> |
||||
func, |
||||
ServiceType* service) |
||||
: func_(func), service_(service) {} |
||||
|
||||
void RunHandler(const HandlerParameter& param) GRPC_FINAL { |
||||
ServerReaderWriter<ResponseType, RequestType> stream(param.call, |
||||
param.server_context); |
||||
Status status = func_(service_, param.server_context, &stream); |
||||
|
||||
CallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> ops; |
||||
if (!param.server_context->sent_initial_metadata_) { |
||||
ops.SendInitialMetadata(param.server_context->initial_metadata_); |
||||
} |
||||
ops.ServerSendStatus(param.server_context->trailing_metadata_, status); |
||||
param.call->PerformOps(&ops); |
||||
param.call->cq()->Pluck(&ops); |
||||
} |
||||
|
||||
private: |
||||
std::function<Status(ServiceType*, ServerContext*, |
||||
ServerReaderWriter<ResponseType, RequestType>*)> func_; |
||||
ServiceType* service_; |
||||
}; |
||||
|
||||
// Handle unknown method by returning UNIMPLEMENTED error.
|
||||
class UnknownMethodHandler : public MethodHandler { |
||||
public: |
||||
template <class T> |
||||
static void FillOps(ServerContext* context, T* ops) { |
||||
Status status(StatusCode::UNIMPLEMENTED, ""); |
||||
if (!context->sent_initial_metadata_) { |
||||
ops->SendInitialMetadata(context->initial_metadata_); |
||||
context->sent_initial_metadata_ = true; |
||||
} |
||||
ops->ServerSendStatus(context->trailing_metadata_, status); |
||||
} |
||||
|
||||
void RunHandler(const HandlerParameter& param) GRPC_FINAL { |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> ops; |
||||
FillOps(param.server_context, &ops); |
||||
param.call->PerformOps(&ops); |
||||
param.call->cq()->Pluck(&ops); |
||||
} |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H
|
||||
@ -0,0 +1,76 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_PROTO_UTILS_H |
||||
#define GRPCXX_IMPL_CODEGEN_PROTO_UTILS_H |
||||
|
||||
#include <type_traits> |
||||
|
||||
#include <grpc/impl/codegen/byte_buffer.h> |
||||
#include <grpc++/impl/codegen/serialization_traits.h> |
||||
#include <grpc++/impl/codegen/config_protobuf.h> |
||||
#include <grpc++/impl/codegen/status.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
// Serialize the msg into a buffer created inside the function. The caller
|
||||
// should destroy the returned buffer when done with it. If serialization fails,
|
||||
// false is returned and buffer is left unchanged.
|
||||
Status SerializeProto(const grpc::protobuf::Message& msg, |
||||
grpc_byte_buffer** buffer); |
||||
|
||||
// The caller keeps ownership of buffer and msg.
|
||||
Status DeserializeProto(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg, |
||||
int max_message_size); |
||||
|
||||
template <class T> |
||||
class SerializationTraits<T, typename std::enable_if<std::is_base_of< |
||||
grpc::protobuf::Message, T>::value>::type> { |
||||
public: |
||||
static Status Serialize(const grpc::protobuf::Message& msg, |
||||
grpc_byte_buffer** buffer, bool* own_buffer) { |
||||
*own_buffer = true; |
||||
return SerializeProto(msg, buffer); |
||||
} |
||||
static Status Deserialize(grpc_byte_buffer* buffer, |
||||
grpc::protobuf::Message* msg, |
||||
int max_message_size) { |
||||
auto status = DeserializeProto(buffer, msg, max_message_size); |
||||
grpc_byte_buffer_destroy(buffer); |
||||
return status; |
||||
} |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_PROTO_UTILS_H
|
||||
@ -0,0 +1,73 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_RPC_METHOD_H |
||||
#define GRPCXX_IMPL_CODEGEN_RPC_METHOD_H |
||||
|
||||
#include <memory> |
||||
|
||||
#include <grpc++/impl/codegen/channel_interface.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
class RpcMethod { |
||||
public: |
||||
enum RpcType { |
||||
NORMAL_RPC = 0, |
||||
CLIENT_STREAMING, // request streaming
|
||||
SERVER_STREAMING, // response streaming
|
||||
BIDI_STREAMING |
||||
}; |
||||
|
||||
RpcMethod(const char* name, RpcType type) |
||||
: name_(name), method_type_(type), channel_tag_(NULL) {} |
||||
|
||||
RpcMethod(const char* name, RpcType type, |
||||
const std::shared_ptr<ChannelInterface>& channel) |
||||
: name_(name), |
||||
method_type_(type), |
||||
channel_tag_(channel->RegisterMethod(name)) {} |
||||
|
||||
const char* name() const { return name_; } |
||||
RpcType method_type() const { return method_type_; } |
||||
void* channel_tag() const { return channel_tag_; } |
||||
|
||||
private: |
||||
const char* const name_; |
||||
const RpcType method_type_; |
||||
void* const channel_tag_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_RPC_METHOD_H
|
||||
@ -0,0 +1,92 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_RPC_SERVICE_METHOD_H |
||||
#define GRPCXX_IMPL_CODEGEN_RPC_SERVICE_METHOD_H |
||||
|
||||
#include <climits> |
||||
#include <functional> |
||||
#include <map> |
||||
#include <memory> |
||||
#include <vector> |
||||
|
||||
#include <grpc++/impl/codegen/config.h> |
||||
#include <grpc++/impl/codegen/rpc_method.h> |
||||
#include <grpc++/impl/codegen/status.h> |
||||
|
||||
namespace grpc { |
||||
class ServerContext; |
||||
class StreamContextInterface; |
||||
|
||||
// Base class for running an RPC handler.
|
||||
class MethodHandler { |
||||
public: |
||||
virtual ~MethodHandler() {} |
||||
struct HandlerParameter { |
||||
HandlerParameter(Call* c, ServerContext* context, grpc_byte_buffer* req, |
||||
int max_size) |
||||
: call(c), |
||||
server_context(context), |
||||
request(req), |
||||
max_message_size(max_size) {} |
||||
Call* call; |
||||
ServerContext* server_context; |
||||
// Handler required to grpc_byte_buffer_destroy this
|
||||
grpc_byte_buffer* request; |
||||
int max_message_size; |
||||
}; |
||||
virtual void RunHandler(const HandlerParameter& param) = 0; |
||||
}; |
||||
|
||||
// Server side rpc method class
|
||||
class RpcServiceMethod : public RpcMethod { |
||||
public: |
||||
// Takes ownership of the handler
|
||||
RpcServiceMethod(const char* name, RpcMethod::RpcType type, |
||||
MethodHandler* handler) |
||||
: RpcMethod(name, type), server_tag_(nullptr), handler_(handler) {} |
||||
|
||||
void set_server_tag(void* tag) { server_tag_ = tag; } |
||||
void* server_tag() const { return server_tag_; } |
||||
// if MethodHandler is nullptr, then this is an async method
|
||||
MethodHandler* handler() const { return handler_.get(); } |
||||
void ResetHandler() { handler_.reset(); } |
||||
|
||||
private: |
||||
void* server_tag_; |
||||
std::unique_ptr<MethodHandler> handler_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_RPC_SERVICE_METHOD_H
|
||||
@ -0,0 +1,110 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_SECURITY_AUTH_CONTEXT_H |
||||
#define GRPCXX_IMPL_CODEGEN_SECURITY_AUTH_CONTEXT_H |
||||
|
||||
#include <iterator> |
||||
#include <vector> |
||||
|
||||
#include <grpc++/impl/codegen/config.h> |
||||
#include <grpc++/impl/codegen/string_ref.h> |
||||
|
||||
struct grpc_auth_context; |
||||
struct grpc_auth_property; |
||||
struct grpc_auth_property_iterator; |
||||
|
||||
namespace grpc { |
||||
class SecureAuthContext; |
||||
|
||||
typedef std::pair<grpc::string_ref, grpc::string_ref> AuthProperty; |
||||
|
||||
class AuthPropertyIterator |
||||
: public std::iterator<std::input_iterator_tag, const AuthProperty> { |
||||
public: |
||||
~AuthPropertyIterator(); |
||||
AuthPropertyIterator& operator++(); |
||||
AuthPropertyIterator operator++(int); |
||||
bool operator==(const AuthPropertyIterator& rhs) const; |
||||
bool operator!=(const AuthPropertyIterator& rhs) const; |
||||
const AuthProperty operator*(); |
||||
|
||||
protected: |
||||
AuthPropertyIterator(); |
||||
AuthPropertyIterator(const grpc_auth_property* property, |
||||
const grpc_auth_property_iterator* iter); |
||||
|
||||
private: |
||||
friend class SecureAuthContext; |
||||
const grpc_auth_property* property_; |
||||
// The following items form a grpc_auth_property_iterator.
|
||||
const grpc_auth_context* ctx_; |
||||
size_t index_; |
||||
const char* name_; |
||||
}; |
||||
|
||||
/// Class encapsulating the Authentication Information.
|
||||
///
|
||||
/// It includes the secure identity of the peer, the type of secure transport
|
||||
/// used as well as any other properties required by the authorization layer.
|
||||
class AuthContext { |
||||
public: |
||||
virtual ~AuthContext() {} |
||||
|
||||
/// Returns true if the peer is authenticated.
|
||||
virtual bool IsPeerAuthenticated() const = 0; |
||||
|
||||
/// A peer identity.
|
||||
///
|
||||
/// It is, in general, comprised of one or more properties (in which case they
|
||||
/// have the same name).
|
||||
virtual std::vector<grpc::string_ref> GetPeerIdentity() const = 0; |
||||
virtual grpc::string GetPeerIdentityPropertyName() const = 0; |
||||
|
||||
/// Returns all the property values with the given name.
|
||||
virtual std::vector<grpc::string_ref> FindPropertyValues( |
||||
const grpc::string& name) const = 0; |
||||
|
||||
/// Iteration over all the properties.
|
||||
virtual AuthPropertyIterator begin() const = 0; |
||||
virtual AuthPropertyIterator end() const = 0; |
||||
|
||||
// Mutation functions: should only be used by an AuthMetadataProcessor.
|
||||
virtual void AddProperty(const grpc::string& key, |
||||
const grpc::string_ref& value) = 0; |
||||
virtual bool SetPeerIdentityPropertyName(const grpc::string& name) = 0; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_SECURITY_AUTH_CONTEXT_H
|
||||
@ -0,0 +1,68 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_SERIALIZATION_TRAITS_H |
||||
#define GRPCXX_IMPL_CODEGEN_SERIALIZATION_TRAITS_H |
||||
|
||||
namespace grpc { |
||||
|
||||
/// Defines how to serialize and deserialize some type.
|
||||
///
|
||||
/// Used for hooking different message serialization API's into GRPC.
|
||||
/// Each SerializationTraits implementation must provide the following
|
||||
/// functions:
|
||||
/// static Status Serialize(const Message& msg,
|
||||
/// grpc_byte_buffer** buffer,
|
||||
// bool* own_buffer);
|
||||
/// static Status Deserialize(grpc_byte_buffer* buffer,
|
||||
/// Message* msg,
|
||||
/// int max_message_size);
|
||||
///
|
||||
/// Serialize is required to convert message to a grpc_byte_buffer, and
|
||||
/// to store a pointer to that byte buffer at *buffer. *own_buffer should
|
||||
/// be set to true if the caller owns said byte buffer, or false if
|
||||
/// ownership is retained elsewhere.
|
||||
///
|
||||
/// Deserialize is required to convert buffer into the message stored at
|
||||
/// msg. max_message_size is passed in as a bound on the maximum number of
|
||||
/// message bytes Deserialize should accept.
|
||||
///
|
||||
/// Both functions return a Status, allowing them to explain what went
|
||||
/// wrong if required.
|
||||
template <class Message, |
||||
class UnusedButHereForPartialTemplateSpecialization = void> |
||||
class SerializationTraits; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_SERIALIZATION_TRAITS_H
|
||||
@ -0,0 +1,201 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_SERVER_CONTEXT_H |
||||
#define GRPCXX_IMPL_CODEGEN_SERVER_CONTEXT_H |
||||
|
||||
#include <map> |
||||
#include <memory> |
||||
|
||||
#include <grpc/impl/codegen/compression_types.h> |
||||
#include <grpc/impl/codegen/time.h> |
||||
#include <grpc++/impl/codegen/security/auth_context.h> |
||||
#include <grpc++/impl/codegen/config.h> |
||||
#include <grpc++/impl/codegen/string_ref.h> |
||||
#include <grpc++/impl/codegen/time.h> |
||||
|
||||
struct gpr_timespec; |
||||
struct grpc_metadata; |
||||
struct grpc_call; |
||||
struct census_context; |
||||
|
||||
namespace grpc { |
||||
|
||||
class ClientContext; |
||||
template <class W, class R> |
||||
class ServerAsyncReader; |
||||
template <class W> |
||||
class ServerAsyncWriter; |
||||
template <class W> |
||||
class ServerAsyncResponseWriter; |
||||
template <class W, class R> |
||||
class ServerAsyncReaderWriter; |
||||
template <class R> |
||||
class ServerReader; |
||||
template <class W> |
||||
class ServerWriter; |
||||
template <class W, class R> |
||||
class ServerReaderWriter; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class RpcMethodHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class ClientStreamingHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class ServerStreamingHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
class BidiStreamingHandler; |
||||
class UnknownMethodHandler; |
||||
|
||||
class Call; |
||||
class CallOpBuffer; |
||||
class CompletionQueue; |
||||
class Server; |
||||
class ServerInterface; |
||||
|
||||
namespace testing { |
||||
class InteropServerContextInspector; |
||||
} // namespace testing
|
||||
|
||||
// Interface of server side rpc context.
|
||||
class ServerContext { |
||||
public: |
||||
ServerContext(); // for async calls
|
||||
~ServerContext(); |
||||
|
||||
#ifndef GRPC_CXX0X_NO_CHRONO |
||||
std::chrono::system_clock::time_point deadline() { |
||||
return Timespec2Timepoint(deadline_); |
||||
} |
||||
#endif // !GRPC_CXX0X_NO_CHRONO
|
||||
|
||||
gpr_timespec raw_deadline() { return deadline_; } |
||||
|
||||
void AddInitialMetadata(const grpc::string& key, const grpc::string& value); |
||||
void AddTrailingMetadata(const grpc::string& key, const grpc::string& value); |
||||
|
||||
bool IsCancelled() const; |
||||
|
||||
const std::multimap<grpc::string_ref, grpc::string_ref>& client_metadata() { |
||||
return client_metadata_; |
||||
} |
||||
|
||||
grpc_compression_level compression_level() const { |
||||
return compression_level_; |
||||
} |
||||
void set_compression_level(grpc_compression_level level); |
||||
|
||||
grpc_compression_algorithm compression_algorithm() const { |
||||
return compression_algorithm_; |
||||
} |
||||
void set_compression_algorithm(grpc_compression_algorithm algorithm); |
||||
|
||||
std::shared_ptr<const AuthContext> auth_context() const; |
||||
|
||||
// Return the peer uri in a string.
|
||||
// WARNING: this value is never authenticated or subject to any security
|
||||
// related code. It must not be used for any authentication related
|
||||
// functionality. Instead, use auth_context.
|
||||
grpc::string peer() const; |
||||
|
||||
const struct census_context* census_context() const; |
||||
|
||||
// Async only. Has to be called before the rpc starts.
|
||||
// Returns the tag in completion queue when the rpc finishes.
|
||||
// IsCancelled() can then be called to check whether the rpc was cancelled.
|
||||
void AsyncNotifyWhenDone(void* tag) { |
||||
has_notify_when_done_tag_ = true; |
||||
async_notify_when_done_tag_ = tag; |
||||
} |
||||
|
||||
private: |
||||
friend class ::grpc::testing::InteropServerContextInspector; |
||||
friend class ::grpc::ServerInterface; |
||||
friend class ::grpc::Server; |
||||
template <class W, class R> |
||||
friend class ::grpc::ServerAsyncReader; |
||||
template <class W> |
||||
friend class ::grpc::ServerAsyncWriter; |
||||
template <class W> |
||||
friend class ::grpc::ServerAsyncResponseWriter; |
||||
template <class W, class R> |
||||
friend class ::grpc::ServerAsyncReaderWriter; |
||||
template <class R> |
||||
friend class ::grpc::ServerReader; |
||||
template <class W> |
||||
friend class ::grpc::ServerWriter; |
||||
template <class W, class R> |
||||
friend class ::grpc::ServerReaderWriter; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
friend class RpcMethodHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
friend class ClientStreamingHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
friend class ServerStreamingHandler; |
||||
template <class ServiceType, class RequestType, class ResponseType> |
||||
friend class BidiStreamingHandler; |
||||
friend class UnknownMethodHandler; |
||||
friend class ::grpc::ClientContext; |
||||
|
||||
// Prevent copying.
|
||||
ServerContext(const ServerContext&); |
||||
ServerContext& operator=(const ServerContext&); |
||||
|
||||
class CompletionOp; |
||||
|
||||
void BeginCompletionOp(Call* call); |
||||
|
||||
ServerContext(gpr_timespec deadline, grpc_metadata* metadata, |
||||
size_t metadata_count); |
||||
|
||||
void set_call(grpc_call* call); |
||||
|
||||
CompletionOp* completion_op_; |
||||
bool has_notify_when_done_tag_; |
||||
void* async_notify_when_done_tag_; |
||||
|
||||
gpr_timespec deadline_; |
||||
grpc_call* call_; |
||||
CompletionQueue* cq_; |
||||
bool sent_initial_metadata_; |
||||
mutable std::shared_ptr<const AuthContext> auth_context_; |
||||
std::multimap<grpc::string_ref, grpc::string_ref> client_metadata_; |
||||
std::multimap<grpc::string, grpc::string> initial_metadata_; |
||||
std::multimap<grpc::string, grpc::string> trailing_metadata_; |
||||
|
||||
grpc_compression_level compression_level_; |
||||
grpc_compression_algorithm compression_algorithm_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_SERVER_CONTEXT_H
|
||||
@ -0,0 +1,254 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_SERVER_INTERFACE_H |
||||
#define GRPCXX_IMPL_CODEGEN_SERVER_INTERFACE_H |
||||
|
||||
#include <grpc++/impl/codegen/call_hook.h> |
||||
#include <grpc++/impl/codegen/completion_queue_tag.h> |
||||
#include <grpc++/impl/codegen/rpc_service_method.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
class AsyncGenericService; |
||||
class AsynchronousService; |
||||
class GenericServerContext; |
||||
class RpcService; |
||||
class ServerAsyncStreamingInterface; |
||||
class ServerCompletionQueue; |
||||
class ServerContext; |
||||
class ServerCredentials; |
||||
class Service; |
||||
class ThreadPoolInterface; |
||||
|
||||
/// Models a gRPC server.
|
||||
///
|
||||
/// Servers are configured and started via \a grpc::ServerBuilder.
|
||||
class ServerInterface : public CallHook { |
||||
public: |
||||
virtual ~ServerInterface() {} |
||||
|
||||
/// Shutdown the server, blocking until all rpc processing finishes.
|
||||
/// Forcefully terminate pending calls after \a deadline expires.
|
||||
///
|
||||
/// \param deadline How long to wait until pending rpcs are forcefully
|
||||
/// terminated.
|
||||
template <class T> |
||||
void Shutdown(const T& deadline) { |
||||
ShutdownInternal(TimePoint<T>(deadline).raw_time()); |
||||
} |
||||
|
||||
/// Shutdown the server, waiting for all rpc processing to finish.
|
||||
void Shutdown() { ShutdownInternal(gpr_inf_future(GPR_CLOCK_MONOTONIC)); } |
||||
|
||||
/// Block waiting for all work to complete.
|
||||
///
|
||||
/// \warning The server must be either shutting down or some other thread must
|
||||
/// call \a Shutdown for this function to ever return.
|
||||
virtual void Wait() = 0; |
||||
|
||||
protected: |
||||
friend class AsynchronousService; |
||||
friend class Service; |
||||
|
||||
/// Register a service. This call does not take ownership of the service.
|
||||
/// The service must exist for the lifetime of the Server instance.
|
||||
virtual bool RegisterService(const grpc::string* host, Service* service) = 0; |
||||
|
||||
/// Register a generic service. This call does not take ownership of the
|
||||
/// service. The service must exist for the lifetime of the Server instance.
|
||||
virtual void RegisterAsyncGenericService(AsyncGenericService* service) = 0; |
||||
|
||||
/// Tries to bind \a server to the given \a addr.
|
||||
///
|
||||
/// It can be invoked multiple times.
|
||||
///
|
||||
/// \param addr The address to try to bind to the server (eg, localhost:1234,
|
||||
/// 192.168.1.1:31416, [::1]:27182, etc.).
|
||||
/// \params creds The credentials associated with the server.
|
||||
///
|
||||
/// \return bound port number on sucess, 0 on failure.
|
||||
///
|
||||
/// \warning It's an error to call this method on an already started server.
|
||||
virtual int AddListeningPort(const grpc::string& addr, |
||||
ServerCredentials* creds) = 0; |
||||
|
||||
/// Start the server.
|
||||
///
|
||||
/// \param cqs Completion queues for handling asynchronous services. The
|
||||
/// caller is required to keep all completion queues live until the server is
|
||||
/// destroyed.
|
||||
/// \param num_cqs How many completion queues does \a cqs hold.
|
||||
///
|
||||
/// \return true on a successful shutdown.
|
||||
virtual bool Start(ServerCompletionQueue** cqs, size_t num_cqs) = 0; |
||||
|
||||
/// Process one or more incoming calls.
|
||||
virtual void RunRpc() = 0; |
||||
|
||||
/// Schedule \a RunRpc to run in the threadpool.
|
||||
virtual void ScheduleCallback() = 0; |
||||
|
||||
virtual void ShutdownInternal(gpr_timespec deadline) = 0; |
||||
|
||||
virtual int max_message_size() const = 0; |
||||
|
||||
virtual grpc_server* server() = 0; |
||||
|
||||
virtual void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) = 0; |
||||
|
||||
class BaseAsyncRequest : public CompletionQueueTag { |
||||
public: |
||||
BaseAsyncRequest(ServerInterface* server, ServerContext* context, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, void* tag, |
||||
bool delete_on_finalize); |
||||
virtual ~BaseAsyncRequest() {} |
||||
|
||||
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; |
||||
|
||||
protected: |
||||
ServerInterface* const server_; |
||||
ServerContext* const context_; |
||||
ServerAsyncStreamingInterface* const stream_; |
||||
CompletionQueue* const call_cq_; |
||||
void* const tag_; |
||||
const bool delete_on_finalize_; |
||||
grpc_call* call_; |
||||
grpc_metadata_array initial_metadata_array_; |
||||
}; |
||||
|
||||
class RegisteredAsyncRequest : public BaseAsyncRequest { |
||||
public: |
||||
RegisteredAsyncRequest(ServerInterface* server, ServerContext* context, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, void* tag); |
||||
|
||||
// uses BaseAsyncRequest::FinalizeResult
|
||||
|
||||
protected: |
||||
void IssueRequest(void* registered_method, grpc_byte_buffer** payload, |
||||
ServerCompletionQueue* notification_cq); |
||||
}; |
||||
|
||||
class NoPayloadAsyncRequest GRPC_FINAL : public RegisteredAsyncRequest { |
||||
public: |
||||
NoPayloadAsyncRequest(void* registered_method, ServerInterface* server, |
||||
ServerContext* context, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, |
||||
ServerCompletionQueue* notification_cq, void* tag) |
||||
: RegisteredAsyncRequest(server, context, stream, call_cq, tag) { |
||||
IssueRequest(registered_method, nullptr, notification_cq); |
||||
} |
||||
|
||||
// uses RegisteredAsyncRequest::FinalizeResult
|
||||
}; |
||||
|
||||
template <class Message> |
||||
class PayloadAsyncRequest GRPC_FINAL : public RegisteredAsyncRequest { |
||||
public: |
||||
PayloadAsyncRequest(void* registered_method, ServerInterface* server, |
||||
ServerContext* context, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, |
||||
ServerCompletionQueue* notification_cq, void* tag, |
||||
Message* request) |
||||
: RegisteredAsyncRequest(server, context, stream, call_cq, tag), |
||||
request_(request) { |
||||
IssueRequest(registered_method, &payload_, notification_cq); |
||||
} |
||||
|
||||
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { |
||||
bool serialization_status = |
||||
*status && payload_ && |
||||
SerializationTraits<Message>::Deserialize( |
||||
payload_, request_, server_->max_message_size()).ok(); |
||||
bool ret = RegisteredAsyncRequest::FinalizeResult(tag, status); |
||||
*status = serialization_status&&* status; |
||||
return ret; |
||||
} |
||||
|
||||
private: |
||||
grpc_byte_buffer* payload_; |
||||
Message* const request_; |
||||
}; |
||||
|
||||
class GenericAsyncRequest : public BaseAsyncRequest { |
||||
public: |
||||
GenericAsyncRequest(ServerInterface* server, GenericServerContext* context, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, |
||||
ServerCompletionQueue* notification_cq, void* tag, |
||||
bool delete_on_finalize); |
||||
|
||||
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; |
||||
|
||||
private: |
||||
grpc_call_details call_details_; |
||||
}; |
||||
|
||||
template <class Message> |
||||
void RequestAsyncCall(RpcServiceMethod* method, ServerContext* context, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, |
||||
ServerCompletionQueue* notification_cq, void* tag, |
||||
Message* message) { |
||||
GPR_ASSERT(method); |
||||
new PayloadAsyncRequest<Message>(method->server_tag(), this, context, |
||||
stream, call_cq, notification_cq, tag, |
||||
message); |
||||
} |
||||
|
||||
void RequestAsyncCall(RpcServiceMethod* method, ServerContext* context, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, |
||||
ServerCompletionQueue* notification_cq, void* tag) { |
||||
GPR_ASSERT(method); |
||||
new NoPayloadAsyncRequest(method->server_tag(), this, context, stream, |
||||
call_cq, notification_cq, tag); |
||||
} |
||||
|
||||
void RequestAsyncGenericCall(GenericServerContext* context, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, |
||||
ServerCompletionQueue* notification_cq, |
||||
void* tag) { |
||||
new GenericAsyncRequest(this, context, stream, call_cq, notification_cq, |
||||
tag, true); |
||||
} |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_SERVER_INTERFACE_H
|
||||
@ -0,0 +1,161 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_SERVICE_TYPE_H |
||||
#define GRPCXX_IMPL_CODEGEN_SERVICE_TYPE_H |
||||
|
||||
#include <grpc++/impl/codegen/config.h> |
||||
#include <grpc++/impl/codegen/rpc_service_method.h> |
||||
#include <grpc++/impl/codegen/serialization_traits.h> |
||||
#include <grpc++/impl/codegen/server_interface.h> |
||||
#include <grpc++/impl/codegen/status.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
class Call; |
||||
class CompletionQueue; |
||||
class Server; |
||||
class ServerInterface; |
||||
class ServerCompletionQueue; |
||||
class ServerContext; |
||||
|
||||
class ServerAsyncStreamingInterface { |
||||
public: |
||||
virtual ~ServerAsyncStreamingInterface() {} |
||||
|
||||
virtual void SendInitialMetadata(void* tag) = 0; |
||||
|
||||
private: |
||||
friend class ServerInterface; |
||||
virtual void BindCall(Call* call) = 0; |
||||
}; |
||||
|
||||
class Service { |
||||
public: |
||||
Service() : server_(nullptr) {} |
||||
virtual ~Service() {} |
||||
|
||||
bool has_async_methods() const { |
||||
for (auto it = methods_.begin(); it != methods_.end(); ++it) { |
||||
if (*it && (*it)->handler() == nullptr) { |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
bool has_synchronous_methods() const { |
||||
for (auto it = methods_.begin(); it != methods_.end(); ++it) { |
||||
if (*it && (*it)->handler() != nullptr) { |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
bool has_generic_methods() const { |
||||
for (auto it = methods_.begin(); it != methods_.end(); ++it) { |
||||
if (it->get() == nullptr) { |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
protected: |
||||
template <class Message> |
||||
void RequestAsyncUnary(int index, ServerContext* context, Message* request, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, |
||||
ServerCompletionQueue* notification_cq, void* tag) { |
||||
server_->RequestAsyncCall(methods_[index].get(), context, stream, call_cq, |
||||
notification_cq, tag, request); |
||||
} |
||||
void RequestAsyncClientStreaming(int index, ServerContext* context, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, |
||||
ServerCompletionQueue* notification_cq, |
||||
void* tag) { |
||||
server_->RequestAsyncCall(methods_[index].get(), context, stream, call_cq, |
||||
notification_cq, tag); |
||||
} |
||||
template <class Message> |
||||
void RequestAsyncServerStreaming(int index, ServerContext* context, |
||||
Message* request, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, |
||||
ServerCompletionQueue* notification_cq, |
||||
void* tag) { |
||||
server_->RequestAsyncCall(methods_[index].get(), context, stream, call_cq, |
||||
notification_cq, tag, request); |
||||
} |
||||
void RequestAsyncBidiStreaming(int index, ServerContext* context, |
||||
ServerAsyncStreamingInterface* stream, |
||||
CompletionQueue* call_cq, |
||||
ServerCompletionQueue* notification_cq, |
||||
void* tag) { |
||||
server_->RequestAsyncCall(methods_[index].get(), context, stream, call_cq, |
||||
notification_cq, tag); |
||||
} |
||||
|
||||
void AddMethod(RpcServiceMethod* method) { methods_.emplace_back(method); } |
||||
|
||||
void MarkMethodAsync(int index) { |
||||
if (methods_[index].get() == nullptr) { |
||||
gpr_log(GPR_ERROR, |
||||
"Cannot mark the method as 'async' because it has already been " |
||||
"marked as 'generic'."); |
||||
return; |
||||
} |
||||
methods_[index]->ResetHandler(); |
||||
} |
||||
|
||||
void MarkMethodGeneric(int index) { |
||||
if (methods_[index]->handler() == nullptr) { |
||||
gpr_log(GPR_ERROR, |
||||
"Cannot mark the method as 'generic' because it has already been " |
||||
"marked as 'async'."); |
||||
} |
||||
methods_[index].reset(); |
||||
} |
||||
|
||||
private: |
||||
friend class Server; |
||||
friend class ServerInterface; |
||||
ServerInterface* server_; |
||||
std::vector<std::unique_ptr<RpcServiceMethod>> methods_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_SERVICE_TYPE_H
|
||||
@ -0,0 +1,76 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_STATUS_H |
||||
#define GRPCXX_IMPL_CODEGEN_STATUS_H |
||||
|
||||
#include <grpc++/impl/codegen/config.h> |
||||
#include <grpc++/impl/codegen/status_code_enum.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
/// Did it work? If it didn't, why?
|
||||
///
|
||||
/// See \a grpc::StatusCode for details on the available code and their meaning.
|
||||
class Status { |
||||
public: |
||||
/// Construct an OK instance.
|
||||
Status() : code_(StatusCode::OK) {} |
||||
|
||||
/// Construct an instance with associated \a code and \a details (also
|
||||
// referred to as "error_message").
|
||||
Status(StatusCode code, const grpc::string& details) |
||||
: code_(code), details_(details) {} |
||||
|
||||
// Pre-defined special status objects.
|
||||
/// An OK pre-defined instance.
|
||||
static const Status& OK; |
||||
/// A CANCELLED pre-defined instance.
|
||||
static const Status& CANCELLED; |
||||
|
||||
/// Return the instance's error code.
|
||||
StatusCode error_code() const { return code_; } |
||||
/// Return the instance's error message.
|
||||
grpc::string error_message() const { return details_; } |
||||
|
||||
/// Is the status OK?
|
||||
bool ok() const { return code_ == StatusCode::OK; } |
||||
|
||||
private: |
||||
StatusCode code_; |
||||
grpc::string details_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_STATUS_H
|
||||
@ -0,0 +1,152 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_STATUS_CODE_ENUM_H |
||||
#define GRPCXX_IMPL_CODEGEN_STATUS_CODE_ENUM_H |
||||
|
||||
namespace grpc { |
||||
|
||||
enum StatusCode { |
||||
/// Not an error; returned on success.
|
||||
OK = 0, |
||||
|
||||
/// The operation was cancelled (typically by the caller).
|
||||
CANCELLED = 1, |
||||
|
||||
/// Unknown error. An example of where this error may be returned is if a
|
||||
/// Status value received from another address space belongs to an error-space
|
||||
/// that is not known in this address space. Also errors raised by APIs that
|
||||
/// do not return enough error information may be converted to this error.
|
||||
UNKNOWN = 2, |
||||
|
||||
/// Client specified an invalid argument. Note that this differs from
|
||||
/// FAILED_PRECONDITION. INVALID_ARGUMENT indicates arguments that are
|
||||
/// problematic regardless of the state of the system (e.g., a malformed file
|
||||
/// name).
|
||||
INVALID_ARGUMENT = 3, |
||||
|
||||
/// Deadline expired before operation could complete. For operations that
|
||||
/// change the state of the system, this error may be returned even if the
|
||||
/// operation has completed successfully. For example, a successful response
|
||||
/// from a server could have been delayed long enough for the deadline to
|
||||
/// expire.
|
||||
DEADLINE_EXCEEDED = 4, |
||||
|
||||
/// Some requested entity (e.g., file or directory) was not found.
|
||||
NOT_FOUND = 5, |
||||
|
||||
/// Some entity that we attempted to create (e.g., file or directory) already
|
||||
/// exists.
|
||||
ALREADY_EXISTS = 6, |
||||
|
||||
/// The caller does not have permission to execute the specified operation.
|
||||
/// PERMISSION_DENIED must not be used for rejections caused by exhausting
|
||||
/// some resource (use RESOURCE_EXHAUSTED instead for those errors).
|
||||
/// PERMISSION_DENIED must not be used if the caller can not be identified
|
||||
/// (use UNAUTHENTICATED instead for those errors).
|
||||
PERMISSION_DENIED = 7, |
||||
|
||||
/// The request does not have valid authentication credentials for the
|
||||
/// operation.
|
||||
UNAUTHENTICATED = 16, |
||||
|
||||
/// Some resource has been exhausted, perhaps a per-user quota, or perhaps the
|
||||
/// entire file system is out of space.
|
||||
RESOURCE_EXHAUSTED = 8, |
||||
|
||||
/// Operation was rejected because the system is not in a state required for
|
||||
/// the operation's execution. For example, directory to be deleted may be
|
||||
/// non-empty, an rmdir operation is applied to a non-directory, etc.
|
||||
///
|
||||
/// A litmus test that may help a service implementor in deciding
|
||||
/// between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:
|
||||
/// (a) Use UNAVAILABLE if the client can retry just the failing call.
|
||||
/// (b) Use ABORTED if the client should retry at a higher-level
|
||||
/// (e.g., restarting a read-modify-write sequence).
|
||||
/// (c) Use FAILED_PRECONDITION if the client should not retry until
|
||||
/// the system state has been explicitly fixed. E.g., if an "rmdir"
|
||||
/// fails because the directory is non-empty, FAILED_PRECONDITION
|
||||
/// should be returned since the client should not retry unless
|
||||
/// they have first fixed up the directory by deleting files from it.
|
||||
/// (d) Use FAILED_PRECONDITION if the client performs conditional
|
||||
/// REST Get/Update/Delete on a resource and the resource on the
|
||||
/// server does not match the condition. E.g., conflicting
|
||||
/// read-modify-write on the same resource.
|
||||
FAILED_PRECONDITION = 9, |
||||
|
||||
/// The operation was aborted, typically due to a concurrency issue like
|
||||
/// sequencer check failures, transaction aborts, etc.
|
||||
///
|
||||
/// See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,
|
||||
/// and UNAVAILABLE.
|
||||
ABORTED = 10, |
||||
|
||||
/// Operation was attempted past the valid range. E.g., seeking or reading
|
||||
/// past end of file.
|
||||
///
|
||||
/// Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed
|
||||
/// if the system state changes. For example, a 32-bit file system will
|
||||
/// generate INVALID_ARGUMENT if asked to read at an offset that is not in the
|
||||
/// range [0,2^32-1], but it will generate OUT_OF_RANGE if asked to read from
|
||||
/// an offset past the current file size.
|
||||
///
|
||||
/// There is a fair bit of overlap between FAILED_PRECONDITION and
|
||||
/// OUT_OF_RANGE. We recommend using OUT_OF_RANGE (the more specific error)
|
||||
/// when it applies so that callers who are iterating through a space can
|
||||
/// easily look for an OUT_OF_RANGE error to detect when they are done.
|
||||
OUT_OF_RANGE = 11, |
||||
|
||||
/// Operation is not implemented or not supported/enabled in this service.
|
||||
UNIMPLEMENTED = 12, |
||||
|
||||
/// Internal errors. Means some invariants expected by underlying System has
|
||||
/// been broken. If you see one of these errors, Something is very broken.
|
||||
INTERNAL = 13, |
||||
|
||||
/// The service is currently unavailable. This is a most likely a transient
|
||||
/// condition and may be corrected by retrying with a backoff.
|
||||
///
|
||||
/// See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,
|
||||
/// and UNAVAILABLE.
|
||||
UNAVAILABLE = 14, |
||||
|
||||
/// Unrecoverable data loss or corruption.
|
||||
DATA_LOSS = 15, |
||||
|
||||
/// Force users to include a default branch:
|
||||
DO_NOT_USE = -1 |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_STATUS_CODE_ENUM_H
|
||||
@ -0,0 +1,123 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_STRING_REF_H |
||||
#define GRPCXX_IMPL_CODEGEN_STRING_REF_H |
||||
|
||||
#include <iterator> |
||||
#include <iosfwd> |
||||
|
||||
#include <grpc++/impl/codegen/config.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
/// This class is a non owning reference to a string.
|
||||
///
|
||||
/// It should be a strict subset of the upcoming std::string_ref.
|
||||
///
|
||||
/// \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
|
||||
///
|
||||
/// The constexpr is dropped or replaced with const for legacy compiler
|
||||
/// compatibility.
|
||||
class string_ref { |
||||
public: |
||||
// types
|
||||
typedef const char* const_iterator; |
||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; |
||||
|
||||
// constants
|
||||
const static size_t npos; |
||||
|
||||
// construct/copy.
|
||||
string_ref() : data_(nullptr), length_(0) {} |
||||
string_ref(const string_ref& other) |
||||
: data_(other.data_), length_(other.length_) {} |
||||
string_ref& operator=(const string_ref& rhs); |
||||
string_ref(const char* s); |
||||
string_ref(const char* s, size_t l) : data_(s), length_(l) {} |
||||
string_ref(const grpc::string& s) : data_(s.data()), length_(s.length()) {} |
||||
|
||||
// iterators
|
||||
const_iterator begin() const { return data_; } |
||||
const_iterator end() const { return data_ + length_; } |
||||
const_iterator cbegin() const { return data_; } |
||||
const_iterator cend() const { return data_ + length_; } |
||||
const_reverse_iterator rbegin() const { |
||||
return const_reverse_iterator(end()); |
||||
} |
||||
const_reverse_iterator rend() const { |
||||
return const_reverse_iterator(begin()); |
||||
} |
||||
const_reverse_iterator crbegin() const { |
||||
return const_reverse_iterator(end()); |
||||
} |
||||
const_reverse_iterator crend() const { |
||||
return const_reverse_iterator(begin()); |
||||
} |
||||
|
||||
// capacity
|
||||
size_t size() const { return length_; } |
||||
size_t length() const { return length_; } |
||||
size_t max_size() const { return length_; } |
||||
bool empty() const { return length_ == 0; } |
||||
|
||||
// element access
|
||||
const char* data() const { return data_; } |
||||
|
||||
// string operations
|
||||
int compare(string_ref x) const; |
||||
bool starts_with(string_ref x) const; |
||||
bool ends_with(string_ref x) const; |
||||
size_t find(string_ref s) const; |
||||
size_t find(char c) const; |
||||
|
||||
string_ref substr(size_t pos, size_t n = npos) const; |
||||
|
||||
private: |
||||
const char* data_; |
||||
size_t length_; |
||||
}; |
||||
|
||||
// Comparison operators
|
||||
bool operator==(string_ref x, string_ref y); |
||||
bool operator!=(string_ref x, string_ref y); |
||||
bool operator<(string_ref x, string_ref y); |
||||
bool operator>(string_ref x, string_ref y); |
||||
bool operator<=(string_ref x, string_ref y); |
||||
bool operator>=(string_ref x, string_ref y); |
||||
|
||||
std::ostream& operator<<(std::ostream& stream, const string_ref& string); |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_STRING_REF_H
|
||||
@ -0,0 +1,43 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_STUB_OPTIONS_H |
||||
#define GRPCXX_IMPL_CODEGEN_STUB_OPTIONS_H |
||||
|
||||
namespace grpc { |
||||
|
||||
class StubOptions {}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_STUB_OPTIONS_H
|
||||
@ -0,0 +1,45 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_SYNC_H |
||||
#define GRPCXX_IMPL_CODEGEN_SYNC_H |
||||
|
||||
#include <grpc++/impl/codegen/config.h> |
||||
|
||||
#ifdef GRPC_CXX0X_NO_THREAD |
||||
#include <grpc++/impl/codegen/sync_no_cxx11.h> |
||||
#else |
||||
#include <grpc++/impl/codegen/sync_cxx11.h> |
||||
#endif |
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_SYNC_H
|
||||
@ -0,0 +1,49 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_SYNC_CXX11_H |
||||
#define GRPCXX_IMPL_CODEGEN_SYNC_CXX11_H |
||||
|
||||
#include <condition_variable> |
||||
#include <mutex> |
||||
|
||||
namespace grpc { |
||||
|
||||
using std::condition_variable; |
||||
using std::mutex; |
||||
using std::lock_guard; |
||||
using std::unique_lock; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_SYNC_CXX11_H
|
||||
@ -0,0 +1,105 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_SYNC_NO_CXX11_H |
||||
#define GRPCXX_IMPL_CODEGEN_SYNC_NO_CXX11_H |
||||
|
||||
#include <grpc/impl/codegen/sync.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
template <class mutex> |
||||
class lock_guard; |
||||
class condition_variable; |
||||
|
||||
class mutex { |
||||
public: |
||||
mutex() { gpr_mu_init(&mu_); } |
||||
~mutex() { gpr_mu_destroy(&mu_); } |
||||
|
||||
private: |
||||
::gpr_mu mu_; |
||||
template <class mutex> |
||||
friend class lock_guard; |
||||
friend class condition_variable; |
||||
}; |
||||
|
||||
template <class mutex> |
||||
class lock_guard { |
||||
public: |
||||
lock_guard(mutex &mu) : mu_(mu), locked(true) { gpr_mu_lock(&mu.mu_); } |
||||
~lock_guard() { unlock_internal(); } |
||||
|
||||
protected: |
||||
void lock_internal() { |
||||
if (!locked) gpr_mu_lock(&mu_.mu_); |
||||
locked = true; |
||||
} |
||||
void unlock_internal() { |
||||
if (locked) gpr_mu_unlock(&mu_.mu_); |
||||
locked = false; |
||||
} |
||||
|
||||
private: |
||||
mutex &mu_; |
||||
bool locked; |
||||
friend class condition_variable; |
||||
}; |
||||
|
||||
template <class mutex> |
||||
class unique_lock : public lock_guard<mutex> { |
||||
public: |
||||
unique_lock(mutex &mu) : lock_guard<mutex>(mu) {} |
||||
void lock() { this->lock_internal(); } |
||||
void unlock() { this->unlock_internal(); } |
||||
}; |
||||
|
||||
class condition_variable { |
||||
public: |
||||
condition_variable() { gpr_cv_init(&cv_); } |
||||
~condition_variable() { gpr_cv_destroy(&cv_); } |
||||
void wait(lock_guard<mutex> &mu) { |
||||
mu.locked = false; |
||||
gpr_cv_wait(&cv_, &mu.mu_.mu_, gpr_inf_future(GPR_CLOCK_REALTIME)); |
||||
mu.locked = true; |
||||
} |
||||
void notify_one() { gpr_cv_signal(&cv_); } |
||||
void notify_all() { gpr_cv_broadcast(&cv_); } |
||||
|
||||
private: |
||||
gpr_cv cv_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_SYNC_NO_CXX11_H
|
||||
@ -0,0 +1,415 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_SYNC_STREAM_H |
||||
#define GRPCXX_IMPL_CODEGEN_SYNC_STREAM_H |
||||
|
||||
#include <grpc++/impl/codegen/call.h> |
||||
#include <grpc++/impl/codegen/channel_interface.h> |
||||
#include <grpc++/impl/codegen/client_context.h> |
||||
#include <grpc++/impl/codegen/completion_queue.h> |
||||
#include <grpc++/impl/codegen/server_context.h> |
||||
#include <grpc++/impl/codegen/service_type.h> |
||||
#include <grpc++/impl/codegen/status.h> |
||||
#include <grpc/impl/codegen/log.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
/// Common interface for all synchronous client side streaming.
|
||||
class ClientStreamingInterface { |
||||
public: |
||||
virtual ~ClientStreamingInterface() {} |
||||
|
||||
/// Wait until the stream finishes, and return the final status. When the
|
||||
/// client side declares it has no more message to send, either implicitly or
|
||||
/// by calling \a WritesDone(), it needs to make sure there is no more message
|
||||
/// to be received from the server, either implicitly or by getting a false
|
||||
/// from a \a Read().
|
||||
///
|
||||
/// This function will return either:
|
||||
/// - when all incoming messages have been read and the server has returned
|
||||
/// status.
|
||||
/// - OR when the server has returned a non-OK status.
|
||||
virtual Status Finish() = 0; |
||||
}; |
||||
|
||||
/// An interface that yields a sequence of messages of type \a R.
|
||||
template <class R> |
||||
class ReaderInterface { |
||||
public: |
||||
virtual ~ReaderInterface() {} |
||||
|
||||
/// Blocking read a message and parse to \a msg. Returns \a true on success.
|
||||
///
|
||||
/// \param[out] msg The read message.
|
||||
///
|
||||
/// \return \a false when there will be no more incoming messages, either
|
||||
/// because the other side has called \a WritesDone() or the stream has failed
|
||||
/// (or been cancelled).
|
||||
virtual bool Read(R* msg) = 0; |
||||
}; |
||||
|
||||
/// An interface that can be fed a sequence of messages of type \a W.
|
||||
template <class W> |
||||
class WriterInterface { |
||||
public: |
||||
virtual ~WriterInterface() {} |
||||
|
||||
/// Blocking write \a msg to the stream with options.
|
||||
///
|
||||
/// \param msg The message to be written to the stream.
|
||||
/// \param options Options affecting the write operation.
|
||||
///
|
||||
/// \return \a true on success, \a false when the stream has been closed.
|
||||
virtual bool Write(const W& msg, const WriteOptions& options) = 0; |
||||
|
||||
/// Blocking write \a msg to the stream with default options.
|
||||
///
|
||||
/// \param msg The message to be written to the stream.
|
||||
///
|
||||
/// \return \a true on success, \a false when the stream has been closed.
|
||||
inline bool Write(const W& msg) { return Write(msg, WriteOptions()); } |
||||
}; |
||||
|
||||
/// Client-side interface for streaming reads of message of type \a R.
|
||||
template <class R> |
||||
class ClientReaderInterface : public ClientStreamingInterface, |
||||
public ReaderInterface<R> { |
||||
public: |
||||
/// Blocking wait for initial metadata from server. The received metadata
|
||||
/// can only be accessed after this call returns. Should only be called before
|
||||
/// the first read. Calling this method is optional, and if it is not called
|
||||
/// the metadata will be available in ClientContext after the first read.
|
||||
virtual void WaitForInitialMetadata() = 0; |
||||
}; |
||||
|
||||
template <class R> |
||||
class ClientReader GRPC_FINAL : public ClientReaderInterface<R> { |
||||
public: |
||||
/// Blocking create a stream and write the first request out.
|
||||
template <class W> |
||||
ClientReader(ChannelInterface* channel, const RpcMethod& method, |
||||
ClientContext* context, const W& request) |
||||
: context_(context), call_(channel->CreateCall(method, context, &cq_)) { |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, |
||||
CallOpClientSendClose> ops; |
||||
ops.SendInitialMetadata(context->send_initial_metadata_); |
||||
// TODO(ctiller): don't assert
|
||||
GPR_ASSERT(ops.SendMessage(request).ok()); |
||||
ops.ClientSendClose(); |
||||
call_.PerformOps(&ops); |
||||
cq_.Pluck(&ops); |
||||
} |
||||
|
||||
void WaitForInitialMetadata() GRPC_OVERRIDE { |
||||
GPR_ASSERT(!context_->initial_metadata_received_); |
||||
|
||||
CallOpSet<CallOpRecvInitialMetadata> ops; |
||||
ops.RecvInitialMetadata(context_); |
||||
call_.PerformOps(&ops); |
||||
cq_.Pluck(&ops); /// status ignored
|
||||
} |
||||
|
||||
bool Read(R* msg) GRPC_OVERRIDE { |
||||
CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> ops; |
||||
if (!context_->initial_metadata_received_) { |
||||
ops.RecvInitialMetadata(context_); |
||||
} |
||||
ops.RecvMessage(msg); |
||||
call_.PerformOps(&ops); |
||||
return cq_.Pluck(&ops) && ops.got_message; |
||||
} |
||||
|
||||
Status Finish() GRPC_OVERRIDE { |
||||
CallOpSet<CallOpClientRecvStatus> ops; |
||||
Status status; |
||||
ops.ClientRecvStatus(context_, &status); |
||||
call_.PerformOps(&ops); |
||||
GPR_ASSERT(cq_.Pluck(&ops)); |
||||
return status; |
||||
} |
||||
|
||||
private: |
||||
ClientContext* context_; |
||||
CompletionQueue cq_; |
||||
Call call_; |
||||
}; |
||||
|
||||
/// Client-side interface for streaming writes of message of type \a W.
|
||||
template <class W> |
||||
class ClientWriterInterface : public ClientStreamingInterface, |
||||
public WriterInterface<W> { |
||||
public: |
||||
/// Half close writing from the client.
|
||||
/// Block until writes are completed.
|
||||
///
|
||||
/// \return Whether the writes were successful.
|
||||
virtual bool WritesDone() = 0; |
||||
}; |
||||
|
||||
template <class W> |
||||
class ClientWriter : public ClientWriterInterface<W> { |
||||
public: |
||||
/// Blocking create a stream.
|
||||
template <class R> |
||||
ClientWriter(ChannelInterface* channel, const RpcMethod& method, |
||||
ClientContext* context, R* response) |
||||
: context_(context), call_(channel->CreateCall(method, context, &cq_)) { |
||||
finish_ops_.RecvMessage(response); |
||||
|
||||
CallOpSet<CallOpSendInitialMetadata> ops; |
||||
ops.SendInitialMetadata(context->send_initial_metadata_); |
||||
call_.PerformOps(&ops); |
||||
cq_.Pluck(&ops); |
||||
} |
||||
|
||||
using WriterInterface<W>::Write; |
||||
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { |
||||
CallOpSet<CallOpSendMessage> ops; |
||||
if (!ops.SendMessage(msg, options).ok()) { |
||||
return false; |
||||
} |
||||
call_.PerformOps(&ops); |
||||
return cq_.Pluck(&ops); |
||||
} |
||||
|
||||
bool WritesDone() GRPC_OVERRIDE { |
||||
CallOpSet<CallOpClientSendClose> ops; |
||||
ops.ClientSendClose(); |
||||
call_.PerformOps(&ops); |
||||
return cq_.Pluck(&ops); |
||||
} |
||||
|
||||
/// Read the final response and wait for the final status.
|
||||
Status Finish() GRPC_OVERRIDE { |
||||
Status status; |
||||
finish_ops_.ClientRecvStatus(context_, &status); |
||||
call_.PerformOps(&finish_ops_); |
||||
GPR_ASSERT(cq_.Pluck(&finish_ops_)); |
||||
return status; |
||||
} |
||||
|
||||
private: |
||||
ClientContext* context_; |
||||
CallOpSet<CallOpGenericRecvMessage, CallOpClientRecvStatus> finish_ops_; |
||||
CompletionQueue cq_; |
||||
Call call_; |
||||
}; |
||||
|
||||
/// Client-side interface for bi-directional streaming.
|
||||
template <class W, class R> |
||||
class ClientReaderWriterInterface : public ClientStreamingInterface, |
||||
public WriterInterface<W>, |
||||
public ReaderInterface<R> { |
||||
public: |
||||
/// Blocking wait for initial metadata from server. The received metadata
|
||||
/// can only be accessed after this call returns. Should only be called before
|
||||
/// the first read. Calling this method is optional, and if it is not called
|
||||
/// the metadata will be available in ClientContext after the first read.
|
||||
virtual void WaitForInitialMetadata() = 0; |
||||
|
||||
/// Block until writes are completed.
|
||||
///
|
||||
/// \return Whether the writes were successful.
|
||||
virtual bool WritesDone() = 0; |
||||
}; |
||||
|
||||
template <class W, class R> |
||||
class ClientReaderWriter GRPC_FINAL : public ClientReaderWriterInterface<W, R> { |
||||
public: |
||||
/// Blocking create a stream.
|
||||
ClientReaderWriter(ChannelInterface* channel, const RpcMethod& method, |
||||
ClientContext* context) |
||||
: context_(context), call_(channel->CreateCall(method, context, &cq_)) { |
||||
CallOpSet<CallOpSendInitialMetadata> ops; |
||||
ops.SendInitialMetadata(context->send_initial_metadata_); |
||||
call_.PerformOps(&ops); |
||||
cq_.Pluck(&ops); |
||||
} |
||||
|
||||
void WaitForInitialMetadata() GRPC_OVERRIDE { |
||||
GPR_ASSERT(!context_->initial_metadata_received_); |
||||
|
||||
CallOpSet<CallOpRecvInitialMetadata> ops; |
||||
ops.RecvInitialMetadata(context_); |
||||
call_.PerformOps(&ops); |
||||
cq_.Pluck(&ops); // status ignored
|
||||
} |
||||
|
||||
bool Read(R* msg) GRPC_OVERRIDE { |
||||
CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> ops; |
||||
if (!context_->initial_metadata_received_) { |
||||
ops.RecvInitialMetadata(context_); |
||||
} |
||||
ops.RecvMessage(msg); |
||||
call_.PerformOps(&ops); |
||||
return cq_.Pluck(&ops) && ops.got_message; |
||||
} |
||||
|
||||
using WriterInterface<W>::Write; |
||||
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { |
||||
CallOpSet<CallOpSendMessage> ops; |
||||
if (!ops.SendMessage(msg, options).ok()) return false; |
||||
call_.PerformOps(&ops); |
||||
return cq_.Pluck(&ops); |
||||
} |
||||
|
||||
bool WritesDone() GRPC_OVERRIDE { |
||||
CallOpSet<CallOpClientSendClose> ops; |
||||
ops.ClientSendClose(); |
||||
call_.PerformOps(&ops); |
||||
return cq_.Pluck(&ops); |
||||
} |
||||
|
||||
Status Finish() GRPC_OVERRIDE { |
||||
CallOpSet<CallOpClientRecvStatus> ops; |
||||
Status status; |
||||
ops.ClientRecvStatus(context_, &status); |
||||
call_.PerformOps(&ops); |
||||
GPR_ASSERT(cq_.Pluck(&ops)); |
||||
return status; |
||||
} |
||||
|
||||
private: |
||||
ClientContext* context_; |
||||
CompletionQueue cq_; |
||||
Call call_; |
||||
}; |
||||
|
||||
template <class R> |
||||
class ServerReader GRPC_FINAL : public ReaderInterface<R> { |
||||
public: |
||||
ServerReader(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {} |
||||
|
||||
void SendInitialMetadata() { |
||||
GPR_ASSERT(!ctx_->sent_initial_metadata_); |
||||
|
||||
CallOpSet<CallOpSendInitialMetadata> ops; |
||||
ops.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
call_->PerformOps(&ops); |
||||
call_->cq()->Pluck(&ops); |
||||
} |
||||
|
||||
bool Read(R* msg) GRPC_OVERRIDE { |
||||
CallOpSet<CallOpRecvMessage<R>> ops; |
||||
ops.RecvMessage(msg); |
||||
call_->PerformOps(&ops); |
||||
return call_->cq()->Pluck(&ops) && ops.got_message; |
||||
} |
||||
|
||||
private: |
||||
Call* const call_; |
||||
ServerContext* const ctx_; |
||||
}; |
||||
|
||||
template <class W> |
||||
class ServerWriter GRPC_FINAL : public WriterInterface<W> { |
||||
public: |
||||
ServerWriter(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {} |
||||
|
||||
void SendInitialMetadata() { |
||||
GPR_ASSERT(!ctx_->sent_initial_metadata_); |
||||
|
||||
CallOpSet<CallOpSendInitialMetadata> ops; |
||||
ops.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
call_->PerformOps(&ops); |
||||
call_->cq()->Pluck(&ops); |
||||
} |
||||
|
||||
using WriterInterface<W>::Write; |
||||
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage> ops; |
||||
if (!ops.SendMessage(msg, options).ok()) { |
||||
return false; |
||||
} |
||||
if (!ctx_->sent_initial_metadata_) { |
||||
ops.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
} |
||||
call_->PerformOps(&ops); |
||||
return call_->cq()->Pluck(&ops); |
||||
} |
||||
|
||||
private: |
||||
Call* const call_; |
||||
ServerContext* const ctx_; |
||||
}; |
||||
|
||||
/// Server-side interface for bi-directional streaming.
|
||||
template <class W, class R> |
||||
class ServerReaderWriter GRPC_FINAL : public WriterInterface<W>, |
||||
public ReaderInterface<R> { |
||||
public: |
||||
ServerReaderWriter(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {} |
||||
|
||||
void SendInitialMetadata() { |
||||
GPR_ASSERT(!ctx_->sent_initial_metadata_); |
||||
|
||||
CallOpSet<CallOpSendInitialMetadata> ops; |
||||
ops.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
call_->PerformOps(&ops); |
||||
call_->cq()->Pluck(&ops); |
||||
} |
||||
|
||||
bool Read(R* msg) GRPC_OVERRIDE { |
||||
CallOpSet<CallOpRecvMessage<R>> ops; |
||||
ops.RecvMessage(msg); |
||||
call_->PerformOps(&ops); |
||||
return call_->cq()->Pluck(&ops) && ops.got_message; |
||||
} |
||||
|
||||
using WriterInterface<W>::Write; |
||||
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { |
||||
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage> ops; |
||||
if (!ops.SendMessage(msg, options).ok()) { |
||||
return false; |
||||
} |
||||
if (!ctx_->sent_initial_metadata_) { |
||||
ops.SendInitialMetadata(ctx_->initial_metadata_); |
||||
ctx_->sent_initial_metadata_ = true; |
||||
} |
||||
call_->PerformOps(&ops); |
||||
return call_->cq()->Pluck(&ops); |
||||
} |
||||
|
||||
private: |
||||
Call* const call_; |
||||
ServerContext* const ctx_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_SYNC_STREAM_H
|
||||
@ -0,0 +1,111 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_CODEGEN_TIME_H |
||||
#define GRPCXX_IMPL_CODEGEN_TIME_H |
||||
|
||||
#include <grpc++/impl/codegen/config.h> |
||||
#include <grpc/impl/codegen/time.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
/* If you are trying to use CompletionQueue::AsyncNext with a time class that
|
||||
isn't either gpr_timespec or std::chrono::system_clock::time_point, you |
||||
will most likely be looking at this comment as your compiler will have |
||||
fired an error below. In order to fix this issue, you have two potential |
||||
solutions: |
||||
|
||||
1. Use gpr_timespec or std::chrono::system_clock::time_point instead |
||||
2. Specialize the TimePoint class with whichever time class that you |
||||
want to use here. See below for two examples of how to do this. |
||||
*/ |
||||
|
||||
template <typename T> |
||||
class TimePoint { |
||||
public: |
||||
TimePoint(const T& time) { you_need_a_specialization_of_TimePoint(); } |
||||
gpr_timespec raw_time() { |
||||
gpr_timespec t; |
||||
return t; |
||||
} |
||||
|
||||
private: |
||||
void you_need_a_specialization_of_TimePoint(); |
||||
}; |
||||
|
||||
template <> |
||||
class TimePoint<gpr_timespec> { |
||||
public: |
||||
TimePoint(const gpr_timespec& time) : time_(time) {} |
||||
gpr_timespec raw_time() { return time_; } |
||||
|
||||
private: |
||||
gpr_timespec time_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#ifndef GRPC_CXX0X_NO_CHRONO |
||||
|
||||
#include <chrono> |
||||
|
||||
#include <grpc/impl/codegen/time.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
// from and to should be absolute time.
|
||||
void Timepoint2Timespec(const std::chrono::system_clock::time_point& from, |
||||
gpr_timespec* to); |
||||
void TimepointHR2Timespec( |
||||
const std::chrono::high_resolution_clock::time_point& from, |
||||
gpr_timespec* to); |
||||
|
||||
std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t); |
||||
|
||||
template <> |
||||
class TimePoint<std::chrono::system_clock::time_point> { |
||||
public: |
||||
TimePoint(const std::chrono::system_clock::time_point& time) { |
||||
Timepoint2Timespec(time, &time_); |
||||
} |
||||
gpr_timespec raw_time() const { return time_; } |
||||
|
||||
private: |
||||
gpr_timespec time_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // !GRPC_CXX0X_NO_CHRONO
|
||||
|
||||
#endif // GRPCXX_IMPL_CODEGEN_TIME_H
|
||||
@ -0,0 +1,39 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_IMPL_METHOD_HANDLER_IMPL_H |
||||
#define GRPCXX_IMPL_METHOD_HANDLER_IMPL_H |
||||
|
||||
#include <grpc++/impl/codegen/method_handler_impl.h> |
||||
|
||||
#endif // GRPCXX_IMPL_METHOD_HANDLER_IMPL_H
|
||||
@ -0,0 +1,72 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_ALLOC_H |
||||
#define GRPC_IMPL_CODEGEN_ALLOC_H |
||||
|
||||
#include <stddef.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef struct gpr_allocation_functions { |
||||
void *(*malloc_fn)(size_t size); |
||||
void *(*realloc_fn)(void *ptr, size_t size); |
||||
void (*free_fn)(void *ptr); |
||||
} gpr_allocation_functions; |
||||
|
||||
/* malloc, never returns NULL */ |
||||
void *gpr_malloc(size_t size); |
||||
/* free */ |
||||
void gpr_free(void *ptr); |
||||
/* realloc, never returns NULL */ |
||||
void *gpr_realloc(void *p, size_t size); |
||||
/* aligned malloc, never returns NULL, will align to 1 << alignment_log */ |
||||
void *gpr_malloc_aligned(size_t size, size_t alignment_log); |
||||
/* free memory allocated by gpr_malloc_aligned */ |
||||
void gpr_free_aligned(void *ptr); |
||||
|
||||
/** Request the family of allocation functions in \a functions be used. NOTE
|
||||
* that this request will be honored in a *best effort* basis and that no |
||||
* guarantees are made about the default functions (eg, malloc) being called. */ |
||||
void gpr_set_allocation_functions(gpr_allocation_functions functions); |
||||
|
||||
/** Return the family of allocation functions currently in effect. */ |
||||
gpr_allocation_functions gpr_get_allocation_functions(); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_ALLOC_H */ |
||||
@ -0,0 +1,92 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_ATM_H |
||||
#define GRPC_IMPL_CODEGEN_ATM_H |
||||
|
||||
/* This interface provides atomic operations and barriers.
|
||||
It is internal to gpr support code and should not be used outside it. |
||||
|
||||
If an operation with acquire semantics precedes another memory access by the |
||||
same thread, the operation will precede that other access as seen by other |
||||
threads. |
||||
|
||||
If an operation with release semantics follows another memory access by the |
||||
same thread, the operation will follow that other access as seen by other |
||||
threads. |
||||
|
||||
Routines with "acq" or "full" in the name have acquire semantics. Routines |
||||
with "rel" or "full" in the name have release semantics. Routines with |
||||
"no_barrier" in the name have neither acquire not release semantics. |
||||
|
||||
The routines may be implemented as macros. |
||||
|
||||
// Atomic operations act on an intergral_type gpr_atm that is guaranteed to
|
||||
// be the same size as a pointer.
|
||||
typedef intptr_t gpr_atm; |
||||
|
||||
// A memory barrier, providing both acquire and release semantics, but not
|
||||
// otherwise acting on memory.
|
||||
void gpr_atm_full_barrier(void); |
||||
|
||||
// Atomically return *p, with acquire semantics.
|
||||
gpr_atm gpr_atm_acq_load(gpr_atm *p); |
||||
|
||||
// Atomically set *p = value, with release semantics.
|
||||
void gpr_atm_rel_store(gpr_atm *p, gpr_atm value); |
||||
|
||||
// Atomically add delta to *p, and return the old value of *p, with
|
||||
// the barriers specified.
|
||||
gpr_atm gpr_atm_no_barrier_fetch_add(gpr_atm *p, gpr_atm delta); |
||||
gpr_atm gpr_atm_full_fetch_add(gpr_atm *p, gpr_atm delta); |
||||
|
||||
// Atomically, if *p==o, set *p=n and return non-zero otherwise return 0,
|
||||
// with the barriers specified if the operation succeeds.
|
||||
int gpr_atm_no_barrier_cas(gpr_atm *p, gpr_atm o, gpr_atm n); |
||||
int gpr_atm_acq_cas(gpr_atm *p, gpr_atm o, gpr_atm n); |
||||
int gpr_atm_rel_cas(gpr_atm *p, gpr_atm o, gpr_atm n); |
||||
*/ |
||||
|
||||
#include <grpc/impl/codegen/port_platform.h> |
||||
|
||||
#if defined(GPR_GCC_ATOMIC) |
||||
#include <grpc/impl/codegen/atm_gcc_atomic.h> |
||||
#elif defined(GPR_GCC_SYNC) |
||||
#include <grpc/impl/codegen/atm_gcc_sync.h> |
||||
#elif defined(GPR_WIN32_ATOMIC) |
||||
#include <grpc/impl/codegen/atm_win32.h> |
||||
#else |
||||
#error could not determine platform for atm |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_ATM_H */ |
||||
@ -0,0 +1,72 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_ATM_GCC_ATOMIC_H |
||||
#define GRPC_IMPL_CODEGEN_ATM_GCC_ATOMIC_H |
||||
|
||||
/* atm_platform.h for gcc and gcc-like compilers with the
|
||||
__atomic_* interface. */ |
||||
#include <grpc/impl/codegen/port_platform.h> |
||||
|
||||
typedef intptr_t gpr_atm; |
||||
|
||||
#define gpr_atm_full_barrier() (__atomic_thread_fence(__ATOMIC_SEQ_CST)) |
||||
|
||||
#define gpr_atm_acq_load(p) (__atomic_load_n((p), __ATOMIC_ACQUIRE)) |
||||
#define gpr_atm_no_barrier_load(p) (__atomic_load_n((p), __ATOMIC_RELAXED)) |
||||
#define gpr_atm_rel_store(p, value) \ |
||||
(__atomic_store_n((p), (intptr_t)(value), __ATOMIC_RELEASE)) |
||||
#define gpr_atm_no_barrier_store(p, value) \ |
||||
(__atomic_store_n((p), (intptr_t)(value), __ATOMIC_RELAXED)) |
||||
|
||||
#define gpr_atm_no_barrier_fetch_add(p, delta) \ |
||||
(__atomic_fetch_add((p), (intptr_t)(delta), __ATOMIC_RELAXED)) |
||||
#define gpr_atm_full_fetch_add(p, delta) \ |
||||
(__atomic_fetch_add((p), (intptr_t)(delta), __ATOMIC_ACQ_REL)) |
||||
|
||||
static __inline int gpr_atm_no_barrier_cas(gpr_atm *p, gpr_atm o, gpr_atm n) { |
||||
return __atomic_compare_exchange_n(p, &o, n, 0, __ATOMIC_RELAXED, |
||||
__ATOMIC_RELAXED); |
||||
} |
||||
|
||||
static __inline int gpr_atm_acq_cas(gpr_atm *p, gpr_atm o, gpr_atm n) { |
||||
return __atomic_compare_exchange_n(p, &o, n, 0, __ATOMIC_ACQUIRE, |
||||
__ATOMIC_RELAXED); |
||||
} |
||||
|
||||
static __inline int gpr_atm_rel_cas(gpr_atm *p, gpr_atm o, gpr_atm n) { |
||||
return __atomic_compare_exchange_n(p, &o, n, 0, __ATOMIC_RELEASE, |
||||
__ATOMIC_RELAXED); |
||||
} |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_ATM_GCC_ATOMIC_H */ |
||||
@ -0,0 +1,87 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_ATM_GCC_SYNC_H |
||||
#define GRPC_IMPL_CODEGEN_ATM_GCC_SYNC_H |
||||
|
||||
/* variant of atm_platform.h for gcc and gcc-like compiers with __sync_*
|
||||
interface */ |
||||
#include <grpc/impl/codegen/port_platform.h> |
||||
|
||||
typedef intptr_t gpr_atm; |
||||
|
||||
#define GPR_ATM_COMPILE_BARRIER_() __asm__ __volatile__("" : : : "memory") |
||||
|
||||
#if defined(__i386) || defined(__x86_64__) |
||||
/* All loads are acquire loads and all stores are release stores. */ |
||||
#define GPR_ATM_LS_BARRIER_() GPR_ATM_COMPILE_BARRIER_() |
||||
#else |
||||
#define GPR_ATM_LS_BARRIER_() gpr_atm_full_barrier() |
||||
#endif |
||||
|
||||
#define gpr_atm_full_barrier() (__sync_synchronize()) |
||||
|
||||
static __inline gpr_atm gpr_atm_acq_load(const gpr_atm *p) { |
||||
gpr_atm value = *p; |
||||
GPR_ATM_LS_BARRIER_(); |
||||
return value; |
||||
} |
||||
|
||||
static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm *p) { |
||||
gpr_atm value = *p; |
||||
GPR_ATM_COMPILE_BARRIER_(); |
||||
return value; |
||||
} |
||||
|
||||
static __inline void gpr_atm_rel_store(gpr_atm *p, gpr_atm value) { |
||||
GPR_ATM_LS_BARRIER_(); |
||||
*p = value; |
||||
} |
||||
|
||||
static __inline void gpr_atm_no_barrier_store(gpr_atm *p, gpr_atm value) { |
||||
GPR_ATM_COMPILE_BARRIER_(); |
||||
*p = value; |
||||
} |
||||
|
||||
#undef GPR_ATM_LS_BARRIER_ |
||||
#undef GPR_ATM_COMPILE_BARRIER_ |
||||
|
||||
#define gpr_atm_no_barrier_fetch_add(p, delta) \ |
||||
gpr_atm_full_fetch_add((p), (delta)) |
||||
#define gpr_atm_full_fetch_add(p, delta) (__sync_fetch_and_add((p), (delta))) |
||||
|
||||
#define gpr_atm_no_barrier_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n)) |
||||
#define gpr_atm_acq_cas(p, o, n) (__sync_bool_compare_and_swap((p), (o), (n))) |
||||
#define gpr_atm_rel_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n)) |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_ATM_GCC_SYNC_H */ |
||||
@ -0,0 +1,125 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_ATM_WIN32_H |
||||
#define GRPC_IMPL_CODEGEN_ATM_WIN32_H |
||||
|
||||
/* Win32 variant of atm_platform.h */ |
||||
#include <grpc/impl/codegen/port_platform.h> |
||||
|
||||
typedef intptr_t gpr_atm; |
||||
|
||||
#define gpr_atm_full_barrier MemoryBarrier |
||||
|
||||
static __inline gpr_atm gpr_atm_acq_load(const gpr_atm *p) { |
||||
gpr_atm result = *p; |
||||
gpr_atm_full_barrier(); |
||||
return result; |
||||
} |
||||
|
||||
static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm *p) { |
||||
/* TODO(dklempner): Can we implement something better here? */ |
||||
return gpr_atm_acq_load(p); |
||||
} |
||||
|
||||
static __inline void gpr_atm_rel_store(gpr_atm *p, gpr_atm value) { |
||||
gpr_atm_full_barrier(); |
||||
*p = value; |
||||
} |
||||
|
||||
static __inline void gpr_atm_no_barrier_store(gpr_atm *p, gpr_atm value) { |
||||
/* TODO(ctiller): Can we implement something better here? */ |
||||
gpr_atm_rel_store(p, value); |
||||
} |
||||
|
||||
static __inline int gpr_atm_no_barrier_cas(gpr_atm *p, gpr_atm o, gpr_atm n) { |
||||
/* InterlockedCompareExchangePointerNoFence() not available on vista or
|
||||
windows7 */ |
||||
#ifdef GPR_ARCH_64 |
||||
return o == (gpr_atm)InterlockedCompareExchangeAcquire64( |
||||
(volatile LONGLONG *)p, (LONGLONG)n, (LONGLONG)o); |
||||
#else |
||||
return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG *)p, |
||||
(LONG)n, (LONG)o); |
||||
#endif |
||||
} |
||||
|
||||
static __inline int gpr_atm_acq_cas(gpr_atm *p, gpr_atm o, gpr_atm n) { |
||||
#ifdef GPR_ARCH_64 |
||||
return o == (gpr_atm)InterlockedCompareExchangeAcquire64( |
||||
(volatile LONGLONG *)p, (LONGLONG)n, (LONGLONG)o); |
||||
#else |
||||
return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG *)p, |
||||
(LONG)n, (LONG)o); |
||||
#endif |
||||
} |
||||
|
||||
static __inline int gpr_atm_rel_cas(gpr_atm *p, gpr_atm o, gpr_atm n) { |
||||
#ifdef GPR_ARCH_64 |
||||
return o == (gpr_atm)InterlockedCompareExchangeRelease64( |
||||
(volatile LONGLONG *)p, (LONGLONG)n, (LONGLONG)o); |
||||
#else |
||||
return o == (gpr_atm)InterlockedCompareExchangeRelease((volatile LONG *)p, |
||||
(LONG)n, (LONG)o); |
||||
#endif |
||||
} |
||||
|
||||
static __inline gpr_atm gpr_atm_no_barrier_fetch_add(gpr_atm *p, |
||||
gpr_atm delta) { |
||||
/* Use the CAS operation to get pointer-sized fetch and add */ |
||||
gpr_atm old; |
||||
do { |
||||
old = *p; |
||||
} while (!gpr_atm_no_barrier_cas(p, old, old + delta)); |
||||
return old; |
||||
} |
||||
|
||||
static __inline gpr_atm gpr_atm_full_fetch_add(gpr_atm *p, gpr_atm delta) { |
||||
/* Use a CAS operation to get pointer-sized fetch and add */ |
||||
gpr_atm old; |
||||
#ifdef GPR_ARCH_64 |
||||
do { |
||||
old = *p; |
||||
} while (old != (gpr_atm)InterlockedCompareExchange64((volatile LONGLONG *)p, |
||||
(LONGLONG)old + delta, |
||||
(LONGLONG)old)); |
||||
#else |
||||
do { |
||||
old = *p; |
||||
} while (old != (gpr_atm)InterlockedCompareExchange( |
||||
(volatile LONG *)p, (LONG)old + delta, (LONG)old)); |
||||
#endif |
||||
return old; |
||||
} |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_ATM_WIN32_H */ |
||||
@ -0,0 +1,120 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_BYTE_BUFFER_H |
||||
#define GRPC_IMPL_CODEGEN_BYTE_BUFFER_H |
||||
|
||||
#include <grpc/impl/codegen/compression_types.h> |
||||
#include <grpc/impl/codegen/slice_buffer.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef enum { |
||||
GRPC_BB_RAW |
||||
/* Future types may include GRPC_BB_PROTOBUF, etc. */ |
||||
} grpc_byte_buffer_type; |
||||
|
||||
struct grpc_byte_buffer { |
||||
void *reserved; |
||||
grpc_byte_buffer_type type; |
||||
union { |
||||
struct { |
||||
void *reserved[8]; |
||||
} reserved; |
||||
struct { |
||||
grpc_compression_algorithm compression; |
||||
gpr_slice_buffer slice_buffer; |
||||
} raw; |
||||
} data; |
||||
}; |
||||
typedef struct grpc_byte_buffer grpc_byte_buffer; |
||||
|
||||
/** Returns a RAW byte buffer instance over the given slices (up to \a nslices).
|
||||
* |
||||
* Increases the reference count for all \a slices processed. The user is |
||||
* responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/ |
||||
grpc_byte_buffer *grpc_raw_byte_buffer_create(gpr_slice *slices, |
||||
size_t nslices); |
||||
|
||||
/** Returns a *compressed* RAW byte buffer instance over the given slices (up to
|
||||
* \a nslices). The \a compression argument defines the compression algorithm |
||||
* used to generate the data in \a slices. |
||||
* |
||||
* Increases the reference count for all \a slices processed. The user is |
||||
* responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/ |
||||
grpc_byte_buffer *grpc_raw_compressed_byte_buffer_create( |
||||
gpr_slice *slices, size_t nslices, grpc_compression_algorithm compression); |
||||
|
||||
/** Copies input byte buffer \a bb.
|
||||
* |
||||
* Increases the reference count of all the source slices. The user is |
||||
* responsible for calling grpc_byte_buffer_destroy over the returned copy. */ |
||||
grpc_byte_buffer *grpc_byte_buffer_copy(grpc_byte_buffer *bb); |
||||
|
||||
/** Returns the size of the given byte buffer, in bytes. */ |
||||
size_t grpc_byte_buffer_length(grpc_byte_buffer *bb); |
||||
|
||||
/** Destroys \a byte_buffer deallocating all its memory. */ |
||||
void grpc_byte_buffer_destroy(grpc_byte_buffer *byte_buffer); |
||||
|
||||
/** Reader for byte buffers. Iterates over slices in the byte buffer */ |
||||
struct grpc_byte_buffer_reader; |
||||
typedef struct grpc_byte_buffer_reader grpc_byte_buffer_reader; |
||||
|
||||
/** Initialize \a reader to read over \a buffer */ |
||||
void grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader, |
||||
grpc_byte_buffer *buffer); |
||||
|
||||
/** Cleanup and destroy \a reader */ |
||||
void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader *reader); |
||||
|
||||
/** Updates \a slice with the next piece of data from from \a reader and returns
|
||||
* 1. Returns 0 at the end of the stream. Caller is responsible for calling |
||||
* gpr_slice_unref on the result. */ |
||||
int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader *reader, |
||||
gpr_slice *slice); |
||||
|
||||
/** Merge all data from \a reader into single slice */ |
||||
gpr_slice grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader *reader); |
||||
|
||||
/** Returns a RAW byte buffer instance from the output of \a reader. */ |
||||
grpc_byte_buffer *grpc_raw_byte_buffer_from_reader( |
||||
grpc_byte_buffer_reader *reader); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_BYTE_BUFFER_H */ |
||||
@ -0,0 +1,73 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H |
||||
#define GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/** To be used in channel arguments */ |
||||
#define GRPC_COMPRESSION_ALGORITHM_ARG "grpc.compression_algorithm" |
||||
#define GRPC_COMPRESSION_ALGORITHM_STATE_ARG "grpc.compression_algorithm_state" |
||||
|
||||
/* The various compression algorithms supported by GRPC */ |
||||
typedef enum { |
||||
GRPC_COMPRESS_NONE = 0, |
||||
GRPC_COMPRESS_DEFLATE, |
||||
GRPC_COMPRESS_GZIP, |
||||
/* TODO(ctiller): snappy */ |
||||
GRPC_COMPRESS_ALGORITHMS_COUNT |
||||
} grpc_compression_algorithm; |
||||
|
||||
typedef enum { |
||||
GRPC_COMPRESS_LEVEL_NONE = 0, |
||||
GRPC_COMPRESS_LEVEL_LOW, |
||||
GRPC_COMPRESS_LEVEL_MED, |
||||
GRPC_COMPRESS_LEVEL_HIGH, |
||||
GRPC_COMPRESS_LEVEL_COUNT |
||||
} grpc_compression_level; |
||||
|
||||
typedef struct grpc_compression_options { |
||||
uint32_t enabled_algorithms_bitset; /**< All algs are enabled by default */ |
||||
grpc_compression_algorithm default_compression_algorithm; /**< for channel */ |
||||
} grpc_compression_options; |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H */ |
||||
@ -0,0 +1,59 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H |
||||
#define GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/** Connectivity state of a channel. */ |
||||
typedef enum { |
||||
/** channel is idle */ |
||||
GRPC_CHANNEL_IDLE, |
||||
/** channel is connecting */ |
||||
GRPC_CHANNEL_CONNECTING, |
||||
/** channel is ready for work */ |
||||
GRPC_CHANNEL_READY, |
||||
/** channel has seen a failure but expects to recover */ |
||||
GRPC_CHANNEL_TRANSIENT_FAILURE, |
||||
/** channel has seen a failure that it cannot recover from */ |
||||
GRPC_CHANNEL_FATAL_FAILURE |
||||
} grpc_connectivity_state; |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H */ |
||||
@ -0,0 +1,373 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_GRPC_TYPES_H |
||||
#define GRPC_IMPL_CODEGEN_GRPC_TYPES_H |
||||
|
||||
#include <grpc/impl/codegen/byte_buffer.h> |
||||
#include <grpc/impl/codegen/status.h> |
||||
|
||||
#include <stddef.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/** Completion Queues enable notification of the completion of asynchronous
|
||||
actions. */ |
||||
typedef struct grpc_completion_queue grpc_completion_queue; |
||||
|
||||
/** An alarm associated with a completion queue. */ |
||||
typedef struct grpc_alarm grpc_alarm; |
||||
|
||||
/** The Channel interface allows creation of Call objects. */ |
||||
typedef struct grpc_channel grpc_channel; |
||||
|
||||
/** A server listens to some port and responds to request calls */ |
||||
typedef struct grpc_server grpc_server; |
||||
|
||||
/** A Call represents an RPC. When created, it is in a configuration state
|
||||
allowing properties to be set until it is invoked. After invoke, the Call |
||||
can have messages written to it and read from it. */ |
||||
typedef struct grpc_call grpc_call; |
||||
|
||||
/** Type specifier for grpc_arg */ |
||||
typedef enum { |
||||
GRPC_ARG_STRING, |
||||
GRPC_ARG_INTEGER, |
||||
GRPC_ARG_POINTER |
||||
} grpc_arg_type; |
||||
|
||||
/** A single argument... each argument has a key and a value
|
||||
|
||||
A note on naming keys: |
||||
Keys are namespaced into groups, usually grouped by library, and are |
||||
keys for module XYZ are named XYZ.key1, XYZ.key2, etc. Module names must |
||||
be restricted to the regex [A-Za-z][_A-Za-z0-9]{,15}. |
||||
Key names must be restricted to the regex [A-Za-z][_A-Za-z0-9]{,47}. |
||||
|
||||
GRPC core library keys are prefixed by grpc. |
||||
|
||||
Library authors are strongly encouraged to \#define symbolic constants for |
||||
their keys so that it's possible to change them in the future. */ |
||||
typedef struct { |
||||
grpc_arg_type type; |
||||
char *key; |
||||
union { |
||||
char *string; |
||||
int integer; |
||||
struct { |
||||
void *p; |
||||
void *(*copy)(void *p); |
||||
void (*destroy)(void *p); |
||||
} pointer; |
||||
} value; |
||||
} grpc_arg; |
||||
|
||||
/** An array of arguments that can be passed around.
|
||||
|
||||
Used to set optional channel-level configuration. |
||||
These configuration options are modelled as key-value pairs as defined |
||||
by grpc_arg; keys are strings to allow easy backwards-compatible extension |
||||
by arbitrary parties. |
||||
All evaluation is performed at channel creation time (i.e. the values in |
||||
this structure need only live through the creation invocation). */ |
||||
typedef struct { |
||||
size_t num_args; |
||||
grpc_arg *args; |
||||
} grpc_channel_args; |
||||
|
||||
/* Channel argument keys: */ |
||||
/** Enable census for tracing and stats collection */ |
||||
#define GRPC_ARG_ENABLE_CENSUS "grpc.census" |
||||
/** Maximum number of concurrent incoming streams to allow on a http2
|
||||
connection */ |
||||
#define GRPC_ARG_MAX_CONCURRENT_STREAMS "grpc.max_concurrent_streams" |
||||
/** Maximum message length that the channel can receive */ |
||||
#define GRPC_ARG_MAX_MESSAGE_LENGTH "grpc.max_message_length" |
||||
/** Initial sequence number for http2 transports */ |
||||
#define GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER \ |
||||
"grpc.http2.initial_sequence_number" |
||||
/** Amount to read ahead on individual streams. Defaults to 64kb, larger
|
||||
values can help throughput on high-latency connections. |
||||
NOTE: at some point we'd like to auto-tune this, and this parameter |
||||
will become a no-op. */ |
||||
#define GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES "grpc.http2.lookahead_bytes" |
||||
/** How much memory to use for hpack decoding */ |
||||
#define GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER \ |
||||
"grpc.http2.hpack_table_size.decoder" |
||||
/** How much memory to use for hpack encoding */ |
||||
#define GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER \ |
||||
"grpc.http2.hpack_table_size.encoder" |
||||
/** Default authority to pass if none specified on call construction */ |
||||
#define GRPC_ARG_DEFAULT_AUTHORITY "grpc.default_authority" |
||||
/** Primary user agent: goes at the start of the user-agent metadata
|
||||
sent on each request */ |
||||
#define GRPC_ARG_PRIMARY_USER_AGENT_STRING "grpc.primary_user_agent" |
||||
/** Secondary user agent: goes at the end of the user-agent metadata
|
||||
sent on each request */ |
||||
#define GRPC_ARG_SECONDARY_USER_AGENT_STRING "grpc.secondary_user_agent" |
||||
/* The caller of the secure_channel_create functions may override the target
|
||||
name used for SSL host name checking using this channel argument which is of |
||||
type GRPC_ARG_STRING. This *should* be used for testing only. |
||||
If this argument is not specified, the name used for SSL host name checking |
||||
will be the target parameter (assuming that the secure channel is an SSL |
||||
channel). If this parameter is specified and the underlying is not an SSL |
||||
channel, it will just be ignored. */ |
||||
#define GRPC_SSL_TARGET_NAME_OVERRIDE_ARG "grpc.ssl_target_name_override" |
||||
|
||||
/** Result of a grpc call. If the caller satisfies the prerequisites of a
|
||||
particular operation, the grpc_call_error returned will be GRPC_CALL_OK. |
||||
Receiving any other value listed here is an indication of a bug in the |
||||
caller. */ |
||||
typedef enum grpc_call_error { |
||||
/** everything went ok */ |
||||
GRPC_CALL_OK = 0, |
||||
/** something failed, we don't know what */ |
||||
GRPC_CALL_ERROR, |
||||
/** this method is not available on the server */ |
||||
GRPC_CALL_ERROR_NOT_ON_SERVER, |
||||
/** this method is not available on the client */ |
||||
GRPC_CALL_ERROR_NOT_ON_CLIENT, |
||||
/** this method must be called before server_accept */ |
||||
GRPC_CALL_ERROR_ALREADY_ACCEPTED, |
||||
/** this method must be called before invoke */ |
||||
GRPC_CALL_ERROR_ALREADY_INVOKED, |
||||
/** this method must be called after invoke */ |
||||
GRPC_CALL_ERROR_NOT_INVOKED, |
||||
/** this call is already finished
|
||||
(writes_done or write_status has already been called) */ |
||||
GRPC_CALL_ERROR_ALREADY_FINISHED, |
||||
/** there is already an outstanding read/write operation on the call */ |
||||
GRPC_CALL_ERROR_TOO_MANY_OPERATIONS, |
||||
/** the flags value was illegal for this call */ |
||||
GRPC_CALL_ERROR_INVALID_FLAGS, |
||||
/** invalid metadata was passed to this call */ |
||||
GRPC_CALL_ERROR_INVALID_METADATA, |
||||
/** invalid message was passed to this call */ |
||||
GRPC_CALL_ERROR_INVALID_MESSAGE, |
||||
/** completion queue for notification has not been registered with the
|
||||
server */ |
||||
GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE, |
||||
/** this batch of operations leads to more operations than allowed */ |
||||
GRPC_CALL_ERROR_BATCH_TOO_BIG |
||||
} grpc_call_error; |
||||
|
||||
/* Write Flags: */ |
||||
/** Hint that the write may be buffered and need not go out on the wire
|
||||
immediately. GRPC is free to buffer the message until the next non-buffered |
||||
write, or until writes_done, but it need not buffer completely or at all. */ |
||||
#define GRPC_WRITE_BUFFER_HINT (0x00000001u) |
||||
/** Force compression to be disabled for a particular write
|
||||
(start_write/add_metadata). Illegal on invoke/accept. */ |
||||
#define GRPC_WRITE_NO_COMPRESS (0x00000002u) |
||||
/** Mask of all valid flags. */ |
||||
#define GRPC_WRITE_USED_MASK (GRPC_WRITE_BUFFER_HINT | GRPC_WRITE_NO_COMPRESS) |
||||
|
||||
/** A single metadata element */ |
||||
typedef struct grpc_metadata { |
||||
const char *key; |
||||
const char *value; |
||||
size_t value_length; |
||||
uint32_t flags; |
||||
|
||||
/** The following fields are reserved for grpc internal use.
|
||||
There is no need to initialize them, and they will be set to garbage |
||||
during calls to grpc. */ |
||||
struct { |
||||
void *obfuscated[4]; |
||||
} internal_data; |
||||
} grpc_metadata; |
||||
|
||||
/** The type of completion (for grpc_event) */ |
||||
typedef enum grpc_completion_type { |
||||
/** Shutting down */ |
||||
GRPC_QUEUE_SHUTDOWN, |
||||
/** No event before timeout */ |
||||
GRPC_QUEUE_TIMEOUT, |
||||
/** Operation completion */ |
||||
GRPC_OP_COMPLETE |
||||
} grpc_completion_type; |
||||
|
||||
/** The result of an operation.
|
||||
|
||||
Returned by a completion queue when the operation started with tag. */ |
||||
typedef struct grpc_event { |
||||
/** The type of the completion. */ |
||||
grpc_completion_type type; |
||||
/** non-zero if the operation was successful, 0 upon failure.
|
||||
Only GRPC_OP_COMPLETE can succeed or fail. */ |
||||
int success; |
||||
/** The tag passed to grpc_call_start_batch etc to start this operation.
|
||||
Only GRPC_OP_COMPLETE has a tag. */ |
||||
void *tag; |
||||
} grpc_event; |
||||
|
||||
typedef struct { |
||||
size_t count; |
||||
size_t capacity; |
||||
grpc_metadata *metadata; |
||||
} grpc_metadata_array; |
||||
|
||||
typedef struct { |
||||
char *method; |
||||
size_t method_capacity; |
||||
char *host; |
||||
size_t host_capacity; |
||||
gpr_timespec deadline; |
||||
void *reserved; |
||||
} grpc_call_details; |
||||
|
||||
typedef enum { |
||||
/** Send initial metadata: one and only one instance MUST be sent for each
|
||||
call, unless the call was cancelled - in which case this can be skipped. |
||||
This op completes after all bytes of metadata have been accepted by |
||||
outgoing flow control. */ |
||||
GRPC_OP_SEND_INITIAL_METADATA = 0, |
||||
/** Send a message: 0 or more of these operations can occur for each call.
|
||||
This op completes after all bytes for the message have been accepted by |
||||
outgoing flow control. */ |
||||
GRPC_OP_SEND_MESSAGE, |
||||
/** Send a close from the client: one and only one instance MUST be sent from
|
||||
the client, unless the call was cancelled - in which case this can be |
||||
skipped. |
||||
This op completes after all bytes for the call (including the close) |
||||
have passed outgoing flow control. */ |
||||
GRPC_OP_SEND_CLOSE_FROM_CLIENT, |
||||
/** Send status from the server: one and only one instance MUST be sent from
|
||||
the server unless the call was cancelled - in which case this can be |
||||
skipped. |
||||
This op completes after all bytes for the call (including the status) |
||||
have passed outgoing flow control. */ |
||||
GRPC_OP_SEND_STATUS_FROM_SERVER, |
||||
/** Receive initial metadata: one and only one MUST be made on the client,
|
||||
must not be made on the server. |
||||
This op completes after all initial metadata has been read from the |
||||
peer. */ |
||||
GRPC_OP_RECV_INITIAL_METADATA, |
||||
/** Receive a message: 0 or more of these operations can occur for each call.
|
||||
This op completes after all bytes of the received message have been |
||||
read, or after a half-close has been received on this call. */ |
||||
GRPC_OP_RECV_MESSAGE, |
||||
/** Receive status on the client: one and only one must be made on the client.
|
||||
This operation always succeeds, meaning ops paired with this operation |
||||
will also appear to succeed, even though they may not have. In that case |
||||
the status will indicate some failure. |
||||
This op completes after all activity on the call has completed. */ |
||||
GRPC_OP_RECV_STATUS_ON_CLIENT, |
||||
/** Receive close on the server: one and only one must be made on the
|
||||
server. |
||||
This op completes after the close has been received by the server. */ |
||||
GRPC_OP_RECV_CLOSE_ON_SERVER |
||||
} grpc_op_type; |
||||
|
||||
/** Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT
|
||||
which has no arguments) */ |
||||
typedef struct grpc_op { |
||||
/** Operation type, as defined by grpc_op_type */ |
||||
grpc_op_type op; |
||||
/** Write flags bitset for grpc_begin_messages */ |
||||
uint32_t flags; |
||||
/** Reserved for future usage */ |
||||
void *reserved; |
||||
union { |
||||
/** Reserved for future usage */ |
||||
struct { |
||||
void *reserved[8]; |
||||
} reserved; |
||||
struct { |
||||
size_t count; |
||||
grpc_metadata *metadata; |
||||
} send_initial_metadata; |
||||
grpc_byte_buffer *send_message; |
||||
struct { |
||||
size_t trailing_metadata_count; |
||||
grpc_metadata *trailing_metadata; |
||||
grpc_status_code status; |
||||
const char *status_details; |
||||
} send_status_from_server; |
||||
/** ownership of the array is with the caller, but ownership of the elements
|
||||
stays with the call object (ie key, value members are owned by the call |
||||
object, recv_initial_metadata->array is owned by the caller). |
||||
After the operation completes, call grpc_metadata_array_destroy on this |
||||
value, or reuse it in a future op. */ |
||||
grpc_metadata_array *recv_initial_metadata; |
||||
/** ownership of the byte buffer is moved to the caller; the caller must
|
||||
call grpc_byte_buffer_destroy on this value, or reuse it in a future op. |
||||
*/ |
||||
grpc_byte_buffer **recv_message; |
||||
struct { |
||||
/** ownership of the array is with the caller, but ownership of the
|
||||
elements stays with the call object (ie key, value members are owned |
||||
by the call object, trailing_metadata->array is owned by the caller). |
||||
After the operation completes, call grpc_metadata_array_destroy on |
||||
this |
||||
value, or reuse it in a future op. */ |
||||
grpc_metadata_array *trailing_metadata; |
||||
grpc_status_code *status; |
||||
/** status_details is a buffer owned by the application before the op
|
||||
completes and after the op has completed. During the operation |
||||
status_details may be reallocated to a size larger than |
||||
*status_details_capacity, in which case *status_details_capacity will |
||||
be updated with the new array capacity. |
||||
|
||||
Pre-allocating space: |
||||
size_t my_capacity = 8; |
||||
char *my_details = gpr_malloc(my_capacity); |
||||
x.status_details = &my_details; |
||||
x.status_details_capacity = &my_capacity; |
||||
|
||||
Not pre-allocating space: |
||||
size_t my_capacity = 0; |
||||
char *my_details = NULL; |
||||
x.status_details = &my_details; |
||||
x.status_details_capacity = &my_capacity; |
||||
|
||||
After the call: |
||||
gpr_free(my_details); */ |
||||
char **status_details; |
||||
size_t *status_details_capacity; |
||||
} recv_status_on_client; |
||||
struct { |
||||
/** out argument, set to 1 if the call failed in any way (seen as a
|
||||
cancellation on the server), or 0 if the call succeeded */ |
||||
int *cancelled; |
||||
} recv_close_on_server; |
||||
} data; |
||||
} grpc_op; |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_GRPC_TYPES_H */ |
||||
@ -0,0 +1,108 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_LOG_H |
||||
#define GRPC_IMPL_CODEGEN_LOG_H |
||||
|
||||
#include <stdlib.h> /* for abort() */ |
||||
#include <stdarg.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/* GPR log API.
|
||||
|
||||
Usage (within grpc): |
||||
|
||||
int argument1 = 3; |
||||
char* argument2 = "hello"; |
||||
gpr_log(GPR_DEBUG, "format string %d", argument1); |
||||
gpr_log(GPR_INFO, "hello world"); |
||||
gpr_log(GPR_ERROR, "%d %s!!", argument1, argument2); */ |
||||
|
||||
/* The severity of a log message - use the #defines below when calling into
|
||||
gpr_log to additionally supply file and line data */ |
||||
typedef enum gpr_log_severity { |
||||
GPR_LOG_SEVERITY_DEBUG, |
||||
GPR_LOG_SEVERITY_INFO, |
||||
GPR_LOG_SEVERITY_ERROR |
||||
} gpr_log_severity; |
||||
|
||||
/* Returns a string representation of the log severity */ |
||||
const char *gpr_log_severity_string(gpr_log_severity severity); |
||||
|
||||
/* Macros to build log contexts at various severity levels */ |
||||
#define GPR_DEBUG __FILE__, __LINE__, GPR_LOG_SEVERITY_DEBUG |
||||
#define GPR_INFO __FILE__, __LINE__, GPR_LOG_SEVERITY_INFO |
||||
#define GPR_ERROR __FILE__, __LINE__, GPR_LOG_SEVERITY_ERROR |
||||
|
||||
/* Log a message. It's advised to use GPR_xxx above to generate the context
|
||||
* for each message */ |
||||
void gpr_log(const char *file, int line, gpr_log_severity severity, |
||||
const char *format, ...); |
||||
|
||||
void gpr_log_message(const char *file, int line, gpr_log_severity severity, |
||||
const char *message); |
||||
|
||||
/* Log overrides: applications can use this API to intercept logging calls
|
||||
and use their own implementations */ |
||||
|
||||
typedef struct { |
||||
const char *file; |
||||
int line; |
||||
gpr_log_severity severity; |
||||
const char *message; |
||||
} gpr_log_func_args; |
||||
|
||||
typedef void (*gpr_log_func)(gpr_log_func_args *args); |
||||
void gpr_set_log_function(gpr_log_func func); |
||||
|
||||
/* abort() the process if x is zero, having written a line to the log.
|
||||
|
||||
Intended for internal invariants. If the error can be recovered from, |
||||
without the possibility of corruption, or might best be reflected via |
||||
an exception in a higher-level language, consider returning error code. */ |
||||
#define GPR_ASSERT(x) \ |
||||
do { \
|
||||
if (!(x)) { \
|
||||
gpr_log(GPR_ERROR, "assertion failed: %s", #x); \
|
||||
abort(); \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_LOG_H */ |
||||
@ -0,0 +1,340 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_PORT_PLATFORM_H |
||||
#define GRPC_IMPL_CODEGEN_PORT_PLATFORM_H |
||||
|
||||
/* Get windows.h included everywhere (we need it) */ |
||||
#if defined(_WIN64) || defined(WIN64) || defined(_WIN32) || defined(WIN32) |
||||
#ifndef WIN32_LEAN_AND_MEAN |
||||
#define GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED |
||||
#define WIN32_LEAN_AND_MEAN |
||||
#endif /* WIN32_LEAN_AND_MEAN */ |
||||
|
||||
#ifndef NOMINMAX |
||||
#define GRPC_NOMINMX_WAS_NOT_DEFINED |
||||
#define NOMINMAX |
||||
#endif /* NOMINMAX */ |
||||
|
||||
#ifndef _WIN32_WINNT |
||||
#error \ |
||||
"Please compile grpc with _WIN32_WINNT of at least 0x600 (aka Windows Vista)" |
||||
#else /* !defined(_WIN32_WINNT) */ |
||||
#if (_WIN32_WINNT < 0x0600) |
||||
#error \ |
||||
"Please compile grpc with _WIN32_WINNT of at least 0x600 (aka Windows Vista)" |
||||
#endif /* _WIN32_WINNT < 0x0600 */ |
||||
#endif /* defined(_WIN32_WINNT) */ |
||||
|
||||
#include <windows.h> |
||||
|
||||
#ifdef GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED |
||||
#undef GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED |
||||
#undef WIN32_LEAN_AND_MEAN |
||||
#endif /* GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED */ |
||||
|
||||
#ifdef GRPC_NOMINMAX_WAS_NOT_DEFINED |
||||
#undef GRPC_NOMINMAX_WAS_NOT_DEFINED |
||||
#undef NOMINMAX |
||||
#endif /* GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED */ |
||||
#endif /* defined(_WIN64) || defined(WIN64) || defined(_WIN32) || \ |
||||
defined(WIN32) */ |
||||
|
||||
/* Override this file with one for your platform if you need to redefine
|
||||
things. */ |
||||
|
||||
#if !defined(GPR_NO_AUTODETECT_PLATFORM) |
||||
#if defined(_WIN64) || defined(WIN64) |
||||
#define GPR_PLATFORM_STRING "windows" |
||||
#define GPR_WIN32 1 |
||||
#define GPR_ARCH_64 1 |
||||
#define GPR_GETPID_IN_PROCESS_H 1 |
||||
#define GPR_WINSOCK_SOCKET 1 |
||||
#ifdef __GNUC__ |
||||
#define GPR_GCC_ATOMIC 1 |
||||
#define GPR_GCC_TLS 1 |
||||
#else |
||||
#define GPR_WIN32_ATOMIC 1 |
||||
#define GPR_MSVC_TLS 1 |
||||
#endif |
||||
#define GPR_WINDOWS_CRASH_HANDLER 1 |
||||
#elif defined(_WIN32) || defined(WIN32) |
||||
#define GPR_PLATFORM_STRING "windows" |
||||
#define GPR_ARCH_32 1 |
||||
#define GPR_WIN32 1 |
||||
#define GPR_GETPID_IN_PROCESS_H 1 |
||||
#define GPR_WINSOCK_SOCKET 1 |
||||
#ifdef __GNUC__ |
||||
#define GPR_GCC_ATOMIC 1 |
||||
#define GPR_GCC_TLS 1 |
||||
#else |
||||
#define GPR_WIN32_ATOMIC 1 |
||||
#define GPR_MSVC_TLS 1 |
||||
#endif |
||||
#define GPR_WINDOWS_CRASH_HANDLER 1 |
||||
#elif defined(ANDROID) || defined(__ANDROID__) |
||||
#define GPR_PLATFORM_STRING "android" |
||||
#define GPR_ANDROID 1 |
||||
#define GPR_ARCH_32 1 |
||||
#define GPR_CPU_LINUX 1 |
||||
#define GPR_GCC_SYNC 1 |
||||
#define GPR_GCC_TLS 1 |
||||
#define GPR_POSIX_MULTIPOLL_WITH_POLL 1 |
||||
#define GPR_POSIX_WAKEUP_FD 1 |
||||
#define GPR_LINUX_EVENTFD 1 |
||||
#define GPR_POSIX_SOCKET 1 |
||||
#define GPR_POSIX_SOCKETADDR 1 |
||||
#define GPR_POSIX_SOCKETUTILS 1 |
||||
#define GPR_POSIX_ENV 1 |
||||
#define GPR_POSIX_FILE 1 |
||||
#define GPR_POSIX_STRING 1 |
||||
#define GPR_POSIX_SUBPROCESS 1 |
||||
#define GPR_POSIX_SYNC 1 |
||||
#define GPR_POSIX_TIME 1 |
||||
#define GPR_GETPID_IN_UNISTD_H 1 |
||||
#define GPR_HAVE_MSG_NOSIGNAL 1 |
||||
#elif defined(__linux__) |
||||
#define GPR_POSIX_CRASH_HANDLER 1 |
||||
#define GPR_PLATFORM_STRING "linux" |
||||
#ifndef _BSD_SOURCE |
||||
#define _BSD_SOURCE |
||||
#endif |
||||
#ifndef _DEFAULT_SOURCE |
||||
#define _DEFAULT_SOURCE |
||||
#endif |
||||
#ifndef _GNU_SOURCE |
||||
#define _GNU_SOURCE |
||||
#endif |
||||
#include <features.h> |
||||
#define GPR_CPU_LINUX 1 |
||||
#define GPR_GCC_ATOMIC 1 |
||||
#define GPR_GCC_TLS 1 |
||||
#define GPR_LINUX 1 |
||||
#define GPR_LINUX_MULTIPOLL_WITH_EPOLL 1 |
||||
#define GPR_POSIX_WAKEUP_FD 1 |
||||
#define GPR_POSIX_SOCKET 1 |
||||
#define GPR_POSIX_SOCKETADDR 1 |
||||
#ifdef __GLIBC_PREREQ |
||||
#if __GLIBC_PREREQ(2, 9) |
||||
#define GPR_LINUX_EVENTFD 1 |
||||
#endif |
||||
#if __GLIBC_PREREQ(2, 10) |
||||
#define GPR_LINUX_SOCKETUTILS 1 |
||||
#endif |
||||
#if __GLIBC_PREREQ(2, 17) |
||||
#define GPR_LINUX_ENV 1 |
||||
#endif |
||||
#endif |
||||
#ifndef GPR_LINUX_EVENTFD |
||||
#define GPR_POSIX_NO_SPECIAL_WAKEUP_FD 1 |
||||
#endif |
||||
#ifndef GPR_LINUX_SOCKETUTILS |
||||
#define GPR_POSIX_SOCKETUTILS |
||||
#endif |
||||
#ifndef GPR_LINUX_ENV |
||||
#define GPR_POSIX_ENV 1 |
||||
#endif |
||||
#define GPR_POSIX_FILE 1 |
||||
#define GPR_POSIX_STRING 1 |
||||
#define GPR_POSIX_SUBPROCESS 1 |
||||
#define GPR_POSIX_SYNC 1 |
||||
#define GPR_POSIX_TIME 1 |
||||
#define GPR_GETPID_IN_UNISTD_H 1 |
||||
#define GPR_HAVE_MSG_NOSIGNAL 1 |
||||
#ifdef _LP64 |
||||
#define GPR_ARCH_64 1 |
||||
#else /* _LP64 */ |
||||
#define GPR_ARCH_32 1 |
||||
#endif /* _LP64 */ |
||||
#elif defined(__APPLE__) |
||||
#include <TargetConditionals.h> |
||||
#ifndef _BSD_SOURCE |
||||
#define _BSD_SOURCE |
||||
#endif |
||||
#define GPR_MSG_IOVLEN_TYPE int |
||||
#if TARGET_OS_IPHONE |
||||
#define GPR_FORBID_UNREACHABLE_CODE 1 |
||||
#define GPR_PLATFORM_STRING "ios" |
||||
#define GPR_CPU_IPHONE 1 |
||||
#define GPR_PTHREAD_TLS 1 |
||||
#else /* TARGET_OS_IPHONE */ |
||||
#define GPR_PLATFORM_STRING "osx" |
||||
#define GPR_CPU_POSIX 1 |
||||
#define GPR_GCC_TLS 1 |
||||
#define GPR_POSIX_CRASH_HANDLER 1 |
||||
#endif |
||||
#define GPR_GCC_ATOMIC 1 |
||||
#define GPR_POSIX_LOG 1 |
||||
#define GPR_POSIX_MULTIPOLL_WITH_POLL 1 |
||||
#define GPR_POSIX_WAKEUP_FD 1 |
||||
#define GPR_POSIX_NO_SPECIAL_WAKEUP_FD 1 |
||||
#define GPR_POSIX_SOCKET 1 |
||||
#define GPR_POSIX_SOCKETADDR 1 |
||||
#define GPR_POSIX_SOCKETUTILS 1 |
||||
#define GPR_POSIX_ENV 1 |
||||
#define GPR_POSIX_FILE 1 |
||||
#define GPR_POSIX_STRING 1 |
||||
#define GPR_POSIX_SUBPROCESS 1 |
||||
#define GPR_POSIX_SYNC 1 |
||||
#define GPR_POSIX_TIME 1 |
||||
#define GPR_GETPID_IN_UNISTD_H 1 |
||||
#define GPR_HAVE_SO_NOSIGPIPE 1 |
||||
#ifdef _LP64 |
||||
#define GPR_ARCH_64 1 |
||||
#else /* _LP64 */ |
||||
#define GPR_ARCH_32 1 |
||||
#endif /* _LP64 */ |
||||
#elif defined(__FreeBSD__) |
||||
#define GPR_PLATFORM_STRING "freebsd" |
||||
#ifndef _BSD_SOURCE |
||||
#define _BSD_SOURCE |
||||
#endif |
||||
#define GPR_CPU_POSIX 1 |
||||
#define GPR_GCC_ATOMIC 1 |
||||
#define GPR_GCC_TLS 1 |
||||
#define GPR_POSIX_LOG 1 |
||||
#define GPR_POSIX_MULTIPOLL_WITH_POLL 1 |
||||
#define GPR_POSIX_WAKEUP_FD 1 |
||||
#define GPR_POSIX_NO_SPECIAL_WAKEUP_FD 1 |
||||
#define GPR_POSIX_SOCKET 1 |
||||
#define GPR_POSIX_SOCKETADDR 1 |
||||
#define GPR_POSIX_SOCKETUTILS 1 |
||||
#define GPR_POSIX_ENV 1 |
||||
#define GPR_POSIX_FILE 1 |
||||
#define GPR_POSIX_STRING 1 |
||||
#define GPR_POSIX_SUBPROCESS 1 |
||||
#define GPR_POSIX_SYNC 1 |
||||
#define GPR_POSIX_TIME 1 |
||||
#define GPR_GETPID_IN_UNISTD_H 1 |
||||
#define GPR_HAVE_SO_NOSIGPIPE 1 |
||||
#ifdef _LP64 |
||||
#define GPR_ARCH_64 1 |
||||
#else /* _LP64 */ |
||||
#define GPR_ARCH_32 1 |
||||
#endif /* _LP64 */ |
||||
#else |
||||
#error Could not auto-detect platform |
||||
#endif |
||||
#endif /* GPR_NO_AUTODETECT_PLATFORM */ |
||||
|
||||
#ifndef GPR_PLATFORM_STRING |
||||
#warning "GPR_PLATFORM_STRING not auto-detected" |
||||
#define GPR_PLATFORM_STRING "unknown" |
||||
#endif |
||||
|
||||
#ifdef GPR_GCOV |
||||
#undef GPR_FORBID_UNREACHABLE_CODE |
||||
#define GPR_FORBID_UNREACHABLE_CODE 1 |
||||
#endif |
||||
|
||||
/* For a common case, assume that the platform has a C99-like stdint.h */ |
||||
|
||||
#include <stdint.h> |
||||
|
||||
/* Cache line alignment */ |
||||
#ifndef GPR_CACHELINE_SIZE_LOG |
||||
#if defined(__i386__) || defined(__x86_64__) |
||||
#define GPR_CACHELINE_SIZE_LOG 6 |
||||
#endif |
||||
#ifndef GPR_CACHELINE_SIZE_LOG |
||||
/* A reasonable default guess. Note that overestimates tend to waste more
|
||||
space, while underestimates tend to waste more time. */ |
||||
#define GPR_CACHELINE_SIZE_LOG 6 |
||||
#endif /* GPR_CACHELINE_SIZE_LOG */ |
||||
#endif /* GPR_CACHELINE_SIZE_LOG */ |
||||
|
||||
#define GPR_CACHELINE_SIZE (1 << GPR_CACHELINE_SIZE_LOG) |
||||
|
||||
/* scrub GCC_ATOMIC if it's not available on this compiler */ |
||||
#if defined(GPR_GCC_ATOMIC) && !defined(__ATOMIC_RELAXED) |
||||
#undef GPR_GCC_ATOMIC |
||||
#define GPR_GCC_SYNC 1 |
||||
#endif |
||||
|
||||
/* Validate platform combinations */ |
||||
#if defined(GPR_GCC_ATOMIC) + defined(GPR_GCC_SYNC) + \ |
||||
defined(GPR_WIN32_ATOMIC) != \
|
||||
1 |
||||
#error Must define exactly one of GPR_GCC_ATOMIC, GPR_GCC_SYNC, GPR_WIN32_ATOMIC |
||||
#endif |
||||
|
||||
#if defined(GPR_ARCH_32) + defined(GPR_ARCH_64) != 1 |
||||
#error Must define exactly one of GPR_ARCH_32, GPR_ARCH_64 |
||||
#endif |
||||
|
||||
#if defined(GPR_CPU_LINUX) + defined(GPR_CPU_POSIX) + defined(GPR_WIN32) + \ |
||||
defined(GPR_CPU_IPHONE) + defined(GPR_CPU_CUSTOM) != \
|
||||
1 |
||||
#error Must define exactly one of GPR_CPU_LINUX, GPR_CPU_POSIX, GPR_WIN32, GPR_CPU_IPHONE, GPR_CPU_CUSTOM |
||||
#endif |
||||
|
||||
#if defined(GPR_POSIX_MULTIPOLL_WITH_POLL) && !defined(GPR_POSIX_SOCKET) |
||||
#error Must define GPR_POSIX_SOCKET to use GPR_POSIX_MULTIPOLL_WITH_POLL |
||||
#endif |
||||
|
||||
#if defined(GPR_POSIX_SOCKET) + defined(GPR_WINSOCK_SOCKET) + \ |
||||
defined(GPR_CUSTOM_SOCKET) != \
|
||||
1 |
||||
#error Must define exactly one of GPR_POSIX_SOCKET, GPR_WINSOCK_SOCKET, GPR_CUSTOM_SOCKET |
||||
#endif |
||||
|
||||
#if defined(GPR_MSVC_TLS) + defined(GPR_GCC_TLS) + defined(GPR_PTHREAD_TLS) + \ |
||||
defined(GPR_CUSTOM_TLS) != \
|
||||
1 |
||||
#error Must define exactly one of GPR_MSVC_TLS, GPR_GCC_TLS, GPR_PTHREAD_TLS, GPR_CUSTOM_TLS |
||||
#endif |
||||
|
||||
/* maximum alignment needed for any type on this platform, rounded up to a
|
||||
power of two */ |
||||
#define GPR_MAX_ALIGNMENT 16 |
||||
|
||||
#ifndef GRPC_MUST_USE_RESULT |
||||
#ifdef __GNUC__ |
||||
#define GRPC_MUST_USE_RESULT __attribute__((warn_unused_result)) |
||||
#else |
||||
#define GRPC_MUST_USE_RESULT |
||||
#endif |
||||
#endif |
||||
|
||||
#if GPR_FORBID_UNREACHABLE_CODE |
||||
#define GPR_UNREACHABLE_CODE(STATEMENT) |
||||
#else |
||||
#define GPR_UNREACHABLE_CODE(STATEMENT) \ |
||||
do { \
|
||||
gpr_log(GPR_ERROR, "Should never reach here."); \
|
||||
abort(); \
|
||||
STATEMENT; \
|
||||
} while (0) |
||||
#endif /* GPR_FORBID_UNREACHABLE_CODE */ |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_PORT_PLATFORM_H */ |
||||
@ -0,0 +1,67 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_H |
||||
#define GRPC_IMPL_CODEGEN_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/* Propagation bits: this can be bitwise or-ed to form propagation_mask for
|
||||
* grpc_call */ |
||||
/** Propagate deadline */ |
||||
#define GRPC_PROPAGATE_DEADLINE ((uint32_t)1) |
||||
/** Propagate census context */ |
||||
#define GRPC_PROPAGATE_CENSUS_STATS_CONTEXT ((uint32_t)2) |
||||
#define GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT ((uint32_t)4) |
||||
/** Propagate cancellation */ |
||||
#define GRPC_PROPAGATE_CANCELLATION ((uint32_t)8) |
||||
|
||||
/* Default propagation mask: clients of the core API are encouraged to encode
|
||||
deltas from this in their implementations... ie write: |
||||
GRPC_PROPAGATE_DEFAULTS & ~GRPC_PROPAGATE_DEADLINE to disable deadline |
||||
propagation. Doing so gives flexibility in the future to define new |
||||
propagation types that are default inherited or not. */ |
||||
#define GRPC_PROPAGATE_DEFAULTS \ |
||||
((uint32_t)(( \
|
||||
0xffff | GRPC_PROPAGATE_DEADLINE | GRPC_PROPAGATE_CENSUS_STATS_CONTEXT | \
|
||||
GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT | GRPC_PROPAGATE_CANCELLATION))) |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_H */ |
||||
@ -0,0 +1,182 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_SLICE_H |
||||
#define GRPC_IMPL_CODEGEN_SLICE_H |
||||
|
||||
#include <grpc/impl/codegen/sync.h> |
||||
|
||||
#include <stddef.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/* Slice API
|
||||
|
||||
A slice represents a contiguous reference counted array of bytes. |
||||
It is cheap to take references to a slice, and it is cheap to create a |
||||
slice pointing to a subset of another slice. |
||||
|
||||
The data-structure for slices is exposed here to allow non-gpr code to |
||||
build slices from whatever data they have available. |
||||
|
||||
When defining interfaces that handle slices, care should be taken to define |
||||
reference ownership semantics (who should call unref?) and mutability |
||||
constraints (is the callee allowed to modify the slice?) */ |
||||
|
||||
/* Reference count container for gpr_slice. Contains function pointers to
|
||||
increment and decrement reference counts. Implementations should cleanup |
||||
when the reference count drops to zero. |
||||
Typically client code should not touch this, and use gpr_slice_malloc, |
||||
gpr_slice_new, or gpr_slice_new_with_len instead. */ |
||||
typedef struct gpr_slice_refcount { |
||||
void (*ref)(void *); |
||||
void (*unref)(void *); |
||||
} gpr_slice_refcount; |
||||
|
||||
#define GPR_SLICE_INLINED_SIZE (sizeof(size_t) + sizeof(uint8_t *) - 1) |
||||
|
||||
/* A gpr_slice s, if initialized, represents the byte range
|
||||
s.bytes[0..s.length-1]. |
||||
|
||||
It can have an associated ref count which has a destruction routine to be run |
||||
when the ref count reaches zero (see gpr_slice_new() and grp_slice_unref()). |
||||
Multiple gpr_slice values may share a ref count. |
||||
|
||||
If the slice does not have a refcount, it represents an inlined small piece |
||||
of data that is copied by value. */ |
||||
typedef struct gpr_slice { |
||||
struct gpr_slice_refcount *refcount; |
||||
union { |
||||
struct { |
||||
uint8_t *bytes; |
||||
size_t length; |
||||
} refcounted; |
||||
struct { |
||||
uint8_t length; |
||||
uint8_t bytes[GPR_SLICE_INLINED_SIZE]; |
||||
} inlined; |
||||
} data; |
||||
} gpr_slice; |
||||
|
||||
#define GPR_SLICE_START_PTR(slice) \ |
||||
((slice).refcount ? (slice).data.refcounted.bytes \
|
||||
: (slice).data.inlined.bytes) |
||||
#define GPR_SLICE_LENGTH(slice) \ |
||||
((slice).refcount ? (slice).data.refcounted.length \
|
||||
: (slice).data.inlined.length) |
||||
#define GPR_SLICE_SET_LENGTH(slice, newlen) \ |
||||
((slice).refcount ? ((slice).data.refcounted.length = (size_t)(newlen)) \
|
||||
: ((slice).data.inlined.length = (uint8_t)(newlen))) |
||||
#define GPR_SLICE_END_PTR(slice) \ |
||||
GPR_SLICE_START_PTR(slice) + GPR_SLICE_LENGTH(slice) |
||||
#define GPR_SLICE_IS_EMPTY(slice) (GPR_SLICE_LENGTH(slice) == 0) |
||||
|
||||
/* Increment the refcount of s. Requires slice is initialized.
|
||||
Returns s. */ |
||||
gpr_slice gpr_slice_ref(gpr_slice s); |
||||
|
||||
/* Decrement the ref count of s. If the ref count of s reaches zero, all
|
||||
slices sharing the ref count are destroyed, and considered no longer |
||||
initialized. If s is ultimately derived from a call to gpr_slice_new(start, |
||||
len, dest) where dest!=NULL , then (*dest)(start) is called, else if s is |
||||
ultimately derived from a call to gpr_slice_new_with_len(start, len, dest) |
||||
where dest!=NULL , then (*dest)(start, len). Requires s initialized. */ |
||||
void gpr_slice_unref(gpr_slice s); |
||||
|
||||
/* Create a slice pointing at some data. Calls malloc to allocate a refcount
|
||||
for the object, and arranges that destroy will be called with the pointer |
||||
passed in at destruction. */ |
||||
gpr_slice gpr_slice_new(void *p, size_t len, void (*destroy)(void *)); |
||||
|
||||
/* Equivalent to gpr_slice_new, but with a two argument destroy function that
|
||||
also takes the slice length. */ |
||||
gpr_slice gpr_slice_new_with_len(void *p, size_t len, |
||||
void (*destroy)(void *, size_t)); |
||||
|
||||
/* Equivalent to gpr_slice_new(malloc(len), len, free), but saves one malloc()
|
||||
call. |
||||
Aborts if malloc() fails. */ |
||||
gpr_slice gpr_slice_malloc(size_t length); |
||||
|
||||
/* Create a slice by copying a string.
|
||||
Does not preserve null terminators. |
||||
Equivalent to: |
||||
size_t len = strlen(source); |
||||
gpr_slice slice = gpr_slice_malloc(len); |
||||
memcpy(slice->data, source, len); */ |
||||
gpr_slice gpr_slice_from_copied_string(const char *source); |
||||
|
||||
/* Create a slice by copying a buffer.
|
||||
Equivalent to: |
||||
gpr_slice slice = gpr_slice_malloc(len); |
||||
memcpy(slice->data, source, len); */ |
||||
gpr_slice gpr_slice_from_copied_buffer(const char *source, size_t len); |
||||
|
||||
/* Create a slice pointing to constant memory */ |
||||
gpr_slice gpr_slice_from_static_string(const char *source); |
||||
|
||||
/* Return a result slice derived from s, which shares a ref count with s, where
|
||||
result.data==s.data+begin, and result.length==end-begin. |
||||
The ref count of s is increased by one. |
||||
Requires s initialized, begin <= end, begin <= s.length, and |
||||
end <= source->length. */ |
||||
gpr_slice gpr_slice_sub(gpr_slice s, size_t begin, size_t end); |
||||
|
||||
/* The same as gpr_slice_sub, but without altering the ref count */ |
||||
gpr_slice gpr_slice_sub_no_ref(gpr_slice s, size_t begin, size_t end); |
||||
|
||||
/* Splits s into two: modifies s to be s[0:split], and returns a new slice,
|
||||
sharing a refcount with s, that contains s[split:s.length]. |
||||
Requires s intialized, split <= s.length */ |
||||
gpr_slice gpr_slice_split_tail(gpr_slice *s, size_t split); |
||||
|
||||
/* Splits s into two: modifies s to be s[split:s.length], and returns a new
|
||||
slice, sharing a refcount with s, that contains s[0:split]. |
||||
Requires s intialized, split <= s.length */ |
||||
gpr_slice gpr_slice_split_head(gpr_slice *s, size_t split); |
||||
|
||||
gpr_slice gpr_empty_slice(void); |
||||
|
||||
/* Returns <0 if a < b, ==0 if a == b, >0 if a > b
|
||||
The order is arbitrary, and is not guaranteed to be stable across different |
||||
versions of the API. */ |
||||
int gpr_slice_cmp(gpr_slice a, gpr_slice b); |
||||
int gpr_slice_str_cmp(gpr_slice a, const char *b); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_SLICE_H */ |
||||
@ -0,0 +1,102 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_SLICE_BUFFER_H |
||||
#define GRPC_IMPL_CODEGEN_SLICE_BUFFER_H |
||||
|
||||
#include <grpc/impl/codegen/slice.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 8 |
||||
|
||||
/* Represents an expandable array of slices, to be interpreted as a single item
|
||||
TODO(ctiller): inline some small number of elements into the struct, to |
||||
avoid per-call allocations */ |
||||
typedef struct { |
||||
/* slices in the array */ |
||||
gpr_slice *slices; |
||||
/* the number of slices in the array */ |
||||
size_t count; |
||||
/* the number of slices allocated in the array */ |
||||
size_t capacity; |
||||
/* the combined length of all slices in the array */ |
||||
size_t length; |
||||
/* inlined elements to avoid allocations */ |
||||
gpr_slice inlined[GRPC_SLICE_BUFFER_INLINE_ELEMENTS]; |
||||
} gpr_slice_buffer; |
||||
|
||||
/* initialize a slice buffer */ |
||||
void gpr_slice_buffer_init(gpr_slice_buffer *sb); |
||||
/* destroy a slice buffer - unrefs any held elements */ |
||||
void gpr_slice_buffer_destroy(gpr_slice_buffer *sb); |
||||
/* Add an element to a slice buffer - takes ownership of the slice.
|
||||
This function is allowed to concatenate the passed in slice to the end of |
||||
some other slice if desired by the slice buffer. */ |
||||
void gpr_slice_buffer_add(gpr_slice_buffer *sb, gpr_slice slice); |
||||
/* add an element to a slice buffer - takes ownership of the slice and returns
|
||||
the index of the slice. |
||||
Guarantees that the slice will not be concatenated at the end of another |
||||
slice (i.e. the data for this slice will begin at the first byte of the |
||||
slice at the returned index in sb->slices) |
||||
The implementation MAY decide to concatenate data at the end of a small |
||||
slice added in this fashion. */ |
||||
size_t gpr_slice_buffer_add_indexed(gpr_slice_buffer *sb, gpr_slice slice); |
||||
void gpr_slice_buffer_addn(gpr_slice_buffer *sb, gpr_slice *slices, size_t n); |
||||
/* add a very small (less than 8 bytes) amount of data to the end of a slice
|
||||
buffer: returns a pointer into which to add the data */ |
||||
uint8_t *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, size_t len); |
||||
/* pop the last buffer, but don't unref it */ |
||||
void gpr_slice_buffer_pop(gpr_slice_buffer *sb); |
||||
/* clear a slice buffer, unref all elements */ |
||||
void gpr_slice_buffer_reset_and_unref(gpr_slice_buffer *sb); |
||||
/* swap the contents of two slice buffers */ |
||||
void gpr_slice_buffer_swap(gpr_slice_buffer *a, gpr_slice_buffer *b); |
||||
/* move all of the elements of src into dst */ |
||||
void gpr_slice_buffer_move_into(gpr_slice_buffer *src, gpr_slice_buffer *dst); |
||||
/* remove n bytes from the end of a slice buffer */ |
||||
void gpr_slice_buffer_trim_end(gpr_slice_buffer *src, size_t n, |
||||
gpr_slice_buffer *garbage); |
||||
/* move the first n bytes of src into dst */ |
||||
void gpr_slice_buffer_move_first(gpr_slice_buffer *src, size_t n, |
||||
gpr_slice_buffer *dst); |
||||
/* take the first slice in the slice buffer */ |
||||
gpr_slice gpr_slice_buffer_take_first(gpr_slice_buffer *src); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_SLICE_BUFFER_H */ |
||||
@ -0,0 +1,163 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_STATUS_H |
||||
#define GRPC_IMPL_CODEGEN_STATUS_H |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef enum { |
||||
/* Not an error; returned on success */ |
||||
GRPC_STATUS_OK = 0, |
||||
|
||||
/* The operation was cancelled (typically by the caller). */ |
||||
GRPC_STATUS_CANCELLED = 1, |
||||
|
||||
/* Unknown error. An example of where this error may be returned is
|
||||
if a Status value received from another address space belongs to |
||||
an error-space that is not known in this address space. Also |
||||
errors raised by APIs that do not return enough error information |
||||
may be converted to this error. */ |
||||
GRPC_STATUS_UNKNOWN = 2, |
||||
|
||||
/* Client specified an invalid argument. Note that this differs
|
||||
from FAILED_PRECONDITION. INVALID_ARGUMENT indicates arguments |
||||
that are problematic regardless of the state of the system |
||||
(e.g., a malformed file name). */ |
||||
GRPC_STATUS_INVALID_ARGUMENT = 3, |
||||
|
||||
/* Deadline expired before operation could complete. For operations
|
||||
that change the state of the system, this error may be returned |
||||
even if the operation has completed successfully. For example, a |
||||
successful response from a server could have been delayed long |
||||
enough for the deadline to expire. */ |
||||
GRPC_STATUS_DEADLINE_EXCEEDED = 4, |
||||
|
||||
/* Some requested entity (e.g., file or directory) was not found. */ |
||||
GRPC_STATUS_NOT_FOUND = 5, |
||||
|
||||
/* Some entity that we attempted to create (e.g., file or directory)
|
||||
already exists. */ |
||||
GRPC_STATUS_ALREADY_EXISTS = 6, |
||||
|
||||
/* The caller does not have permission to execute the specified
|
||||
operation. PERMISSION_DENIED must not be used for rejections |
||||
caused by exhausting some resource (use RESOURCE_EXHAUSTED |
||||
instead for those errors). PERMISSION_DENIED must not be |
||||
used if the caller can not be identified (use UNAUTHENTICATED |
||||
instead for those errors). */ |
||||
GRPC_STATUS_PERMISSION_DENIED = 7, |
||||
|
||||
/* The request does not have valid authentication credentials for the
|
||||
operation. */ |
||||
GRPC_STATUS_UNAUTHENTICATED = 16, |
||||
|
||||
/* Some resource has been exhausted, perhaps a per-user quota, or
|
||||
perhaps the entire file system is out of space. */ |
||||
GRPC_STATUS_RESOURCE_EXHAUSTED = 8, |
||||
|
||||
/* Operation was rejected because the system is not in a state
|
||||
required for the operation's execution. For example, directory |
||||
to be deleted may be non-empty, an rmdir operation is applied to |
||||
a non-directory, etc. |
||||
|
||||
A litmus test that may help a service implementor in deciding |
||||
between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE: |
||||
(a) Use UNAVAILABLE if the client can retry just the failing call. |
||||
(b) Use ABORTED if the client should retry at a higher-level |
||||
(e.g., restarting a read-modify-write sequence). |
||||
(c) Use FAILED_PRECONDITION if the client should not retry until |
||||
the system state has been explicitly fixed. E.g., if an "rmdir" |
||||
fails because the directory is non-empty, FAILED_PRECONDITION |
||||
should be returned since the client should not retry unless |
||||
they have first fixed up the directory by deleting files from it. |
||||
(d) Use FAILED_PRECONDITION if the client performs conditional |
||||
REST Get/Update/Delete on a resource and the resource on the |
||||
server does not match the condition. E.g., conflicting |
||||
read-modify-write on the same resource. */ |
||||
GRPC_STATUS_FAILED_PRECONDITION = 9, |
||||
|
||||
/* The operation was aborted, typically due to a concurrency issue
|
||||
like sequencer check failures, transaction aborts, etc. |
||||
|
||||
See litmus test above for deciding between FAILED_PRECONDITION, |
||||
ABORTED, and UNAVAILABLE. */ |
||||
GRPC_STATUS_ABORTED = 10, |
||||
|
||||
/* Operation was attempted past the valid range. E.g., seeking or
|
||||
reading past end of file. |
||||
|
||||
Unlike INVALID_ARGUMENT, this error indicates a problem that may |
||||
be fixed if the system state changes. For example, a 32-bit file |
||||
system will generate INVALID_ARGUMENT if asked to read at an |
||||
offset that is not in the range [0,2^32-1], but it will generate |
||||
OUT_OF_RANGE if asked to read from an offset past the current |
||||
file size. |
||||
|
||||
There is a fair bit of overlap between FAILED_PRECONDITION and |
||||
OUT_OF_RANGE. We recommend using OUT_OF_RANGE (the more specific |
||||
error) when it applies so that callers who are iterating through |
||||
a space can easily look for an OUT_OF_RANGE error to detect when |
||||
they are done. */ |
||||
GRPC_STATUS_OUT_OF_RANGE = 11, |
||||
|
||||
/* Operation is not implemented or not supported/enabled in this service. */ |
||||
GRPC_STATUS_UNIMPLEMENTED = 12, |
||||
|
||||
/* Internal errors. Means some invariants expected by underlying
|
||||
system has been broken. If you see one of these errors, |
||||
something is very broken. */ |
||||
GRPC_STATUS_INTERNAL = 13, |
||||
|
||||
/* The service is currently unavailable. This is a most likely a
|
||||
transient condition and may be corrected by retrying with |
||||
a backoff. |
||||
|
||||
See litmus test above for deciding between FAILED_PRECONDITION, |
||||
ABORTED, and UNAVAILABLE. */ |
||||
GRPC_STATUS_UNAVAILABLE = 14, |
||||
|
||||
/* Unrecoverable data loss or corruption. */ |
||||
GRPC_STATUS_DATA_LOSS = 15, |
||||
|
||||
/* Force users to include a default branch: */ |
||||
GRPC_STATUS__DO_NOT_USE = -1 |
||||
} grpc_status_code; |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_STATUS_H */ |
||||
@ -0,0 +1,315 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_SYNC_H |
||||
#define GRPC_IMPL_CODEGEN_SYNC_H |
||||
/* Synchronization primitives for GPR.
|
||||
|
||||
The type gpr_mu provides a non-reentrant mutex (lock). |
||||
|
||||
The type gpr_cv provides a condition variable. |
||||
|
||||
The type gpr_once provides for one-time initialization. |
||||
|
||||
The type gpr_event provides one-time-setting, reading, and |
||||
waiting of a void*, with memory barriers. |
||||
|
||||
The type gpr_refcount provides an object reference counter, |
||||
with memory barriers suitable to control |
||||
object lifetimes. |
||||
|
||||
The type gpr_stats_counter provides an atomic statistics counter. It |
||||
provides no memory barriers. |
||||
*/ |
||||
|
||||
/* Platform-specific type declarations of gpr_mu and gpr_cv. */ |
||||
#include <grpc/impl/codegen/port_platform.h> |
||||
#include <grpc/impl/codegen/sync_generic.h> |
||||
|
||||
#if defined(GPR_POSIX_SYNC) |
||||
#include <grpc/impl/codegen/sync_posix.h> |
||||
#elif defined(GPR_WIN32) |
||||
#include <grpc/impl/codegen/sync_win32.h> |
||||
#elif !defined(GPR_CUSTOM_SYNC) |
||||
#error Unable to determine platform for sync |
||||
#endif |
||||
|
||||
#include <grpc/impl/codegen/time.h> /* for gpr_timespec */ |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/* --- Mutex interface ---
|
||||
|
||||
At most one thread may hold an exclusive lock on a mutex at any given time. |
||||
Actions taken by a thread that holds a mutex exclusively happen after |
||||
actions taken by all previous holders of the mutex. Variables of type |
||||
gpr_mu are uninitialized when first declared. */ |
||||
|
||||
/* Initialize *mu. Requires: *mu uninitialized. */ |
||||
void gpr_mu_init(gpr_mu *mu); |
||||
|
||||
/* Cause *mu no longer to be initialized, freeing any memory in use. Requires:
|
||||
*mu initialized; no other concurrent operation on *mu. */ |
||||
void gpr_mu_destroy(gpr_mu *mu); |
||||
|
||||
/* Wait until no thread has a lock on *mu, cause the calling thread to own an
|
||||
exclusive lock on *mu, then return. May block indefinitely or crash if the |
||||
calling thread has a lock on *mu. Requires: *mu initialized. */ |
||||
void gpr_mu_lock(gpr_mu *mu); |
||||
|
||||
/* Release an exclusive lock on *mu held by the calling thread. Requires: *mu
|
||||
initialized; the calling thread holds an exclusive lock on *mu. */ |
||||
void gpr_mu_unlock(gpr_mu *mu); |
||||
|
||||
/* Without blocking, attempt to acquire an exclusive lock on *mu for the
|
||||
calling thread, then return non-zero iff success. Fail, if any thread holds |
||||
the lock; succeeds with high probability if no thread holds the lock. |
||||
Requires: *mu initialized. */ |
||||
int gpr_mu_trylock(gpr_mu *mu); |
||||
|
||||
/* --- Condition variable interface ---
|
||||
|
||||
A while-loop should be used with gpr_cv_wait() when waiting for conditions |
||||
to become true. See the example below. Variables of type gpr_cv are |
||||
uninitialized when first declared. */ |
||||
|
||||
/* Initialize *cv. Requires: *cv uninitialized. */ |
||||
void gpr_cv_init(gpr_cv *cv); |
||||
|
||||
/* Cause *cv no longer to be initialized, freeing any memory in use. Requires:
|
||||
*cv initialized; no other concurrent operation on *cv.*/ |
||||
void gpr_cv_destroy(gpr_cv *cv); |
||||
|
||||
/* Atomically release *mu and wait on *cv. When the calling thread is woken
|
||||
from *cv or the deadline abs_deadline is exceeded, execute gpr_mu_lock(mu) |
||||
and return whether the deadline was exceeded. Use |
||||
abs_deadline==gpr_inf_future for no deadline. May return even when not |
||||
woken explicitly. Requires: *mu and *cv initialized; the calling thread |
||||
holds an exclusive lock on *mu. */ |
||||
int gpr_cv_wait(gpr_cv *cv, gpr_mu *mu, gpr_timespec abs_deadline); |
||||
|
||||
/* If any threads are waiting on *cv, wake at least one.
|
||||
Clients may treat this as an optimization of gpr_cv_broadcast() |
||||
for use in the case where waking more than one waiter is not useful. |
||||
Requires: *cv initialized. */ |
||||
void gpr_cv_signal(gpr_cv *cv); |
||||
|
||||
/* Wake all threads waiting on *cv. Requires: *cv initialized. */ |
||||
void gpr_cv_broadcast(gpr_cv *cv); |
||||
|
||||
/* --- One-time initialization ---
|
||||
|
||||
gpr_once must be declared with static storage class, and initialized with |
||||
GPR_ONCE_INIT. e.g., |
||||
static gpr_once once_var = GPR_ONCE_INIT; */ |
||||
|
||||
/* Ensure that (*init_routine)() has been called exactly once (for the
|
||||
specified gpr_once instance) and then return. |
||||
If multiple threads call gpr_once() on the same gpr_once instance, one of |
||||
them will call (*init_routine)(), and the others will block until that call |
||||
finishes.*/ |
||||
void gpr_once_init(gpr_once *once, void (*init_routine)(void)); |
||||
|
||||
/* --- One-time event notification ---
|
||||
|
||||
These operations act on a gpr_event, which should be initialized with |
||||
gpr_ev_init(), or with GPR_EVENT_INIT if static, e.g., |
||||
static gpr_event event_var = GPR_EVENT_INIT; |
||||
It requires no destruction. */ |
||||
|
||||
/* Initialize *ev. */ |
||||
void gpr_event_init(gpr_event *ev); |
||||
|
||||
/* Set *ev so that gpr_event_get() and gpr_event_wait() will return value.
|
||||
Requires: *ev initialized; value != NULL; no prior or concurrent calls to |
||||
gpr_event_set(ev, ...) since initialization. */ |
||||
void gpr_event_set(gpr_event *ev, void *value); |
||||
|
||||
/* Return the value set by gpr_event_set(ev, ...), or NULL if no such call has
|
||||
completed. If the result is non-NULL, all operations that occurred prior to |
||||
the gpr_event_set(ev, ...) set will be visible after this call returns. |
||||
Requires: *ev initialized. This operation is faster than acquiring a mutex |
||||
on most platforms. */ |
||||
void *gpr_event_get(gpr_event *ev); |
||||
|
||||
/* Wait until *ev is set by gpr_event_set(ev, ...), or abs_deadline is
|
||||
exceeded, then return gpr_event_get(ev). Requires: *ev initialized. Use |
||||
abs_deadline==gpr_inf_future for no deadline. When the event has been |
||||
signalled before the call, this operation is faster than acquiring a mutex |
||||
on most platforms. */ |
||||
void *gpr_event_wait(gpr_event *ev, gpr_timespec abs_deadline); |
||||
|
||||
/* --- Reference counting ---
|
||||
|
||||
These calls act on the type gpr_refcount. It requires no destruction. */ |
||||
|
||||
/* Initialize *r to value n. */ |
||||
void gpr_ref_init(gpr_refcount *r, int n); |
||||
|
||||
/* Increment the reference count *r. Requires *r initialized. */ |
||||
void gpr_ref(gpr_refcount *r); |
||||
|
||||
/* Increment the reference count *r by n. Requires *r initialized, n > 0. */ |
||||
void gpr_refn(gpr_refcount *r, int n); |
||||
|
||||
/* Decrement the reference count *r and return non-zero iff it has reached
|
||||
zero. . Requires *r initialized. */ |
||||
int gpr_unref(gpr_refcount *r); |
||||
|
||||
/* --- Stats counters ---
|
||||
|
||||
These calls act on the integral type gpr_stats_counter. It requires no |
||||
destruction. Static instances may be initialized with |
||||
gpr_stats_counter c = GPR_STATS_INIT; |
||||
Beware: These operations do not imply memory barriers. Do not use them to |
||||
synchronize other events. */ |
||||
|
||||
/* Initialize *c to the value n. */ |
||||
void gpr_stats_init(gpr_stats_counter *c, intptr_t n); |
||||
|
||||
/* *c += inc. Requires: *c initialized. */ |
||||
void gpr_stats_inc(gpr_stats_counter *c, intptr_t inc); |
||||
|
||||
/* Return *c. Requires: *c initialized. */ |
||||
intptr_t gpr_stats_read(const gpr_stats_counter *c); |
||||
|
||||
/* ==================Example use of interface===================
|
||||
A producer-consumer queue of up to N integers, |
||||
illustrating the use of the calls in this interface. */ |
||||
#if 0 |
||||
|
||||
#define N 4 |
||||
|
||||
typedef struct queue { |
||||
gpr_cv non_empty; /* Signalled when length becomes non-zero. */ |
||||
gpr_cv non_full; /* Signalled when length becomes non-N. */ |
||||
gpr_mu mu; /* Protects all fields below.
|
||||
(That is, except during initialization or |
||||
destruction, the fields below should be accessed |
||||
only by a thread that holds mu.) */ |
||||
int head; /* Index of head of queue 0..N-1. */ |
||||
int length; /* Number of valid elements in queue 0..N. */ |
||||
int elem[N]; /* elem[head .. head+length-1] are queue elements. */ |
||||
} queue; |
||||
|
||||
/* Initialize *q. */ |
||||
void queue_init(queue *q) { |
||||
gpr_mu_init(&q->mu); |
||||
gpr_cv_init(&q->non_empty); |
||||
gpr_cv_init(&q->non_full); |
||||
q->head = 0; |
||||
q->length = 0; |
||||
} |
||||
|
||||
/* Free storage associated with *q. */ |
||||
void queue_destroy(queue *q) { |
||||
gpr_mu_destroy(&q->mu); |
||||
gpr_cv_destroy(&q->non_empty); |
||||
gpr_cv_destroy(&q->non_full); |
||||
} |
||||
|
||||
/* Wait until there is room in *q, then append x to *q. */ |
||||
void queue_append(queue *q, int x) { |
||||
gpr_mu_lock(&q->mu); |
||||
/* To wait for a predicate without a deadline, loop on the negation of the
|
||||
predicate, and use gpr_cv_wait(..., gpr_inf_future) inside the loop |
||||
to release the lock, wait, and reacquire on each iteration. Code that |
||||
makes the condition true should use gpr_cv_broadcast() on the |
||||
corresponding condition variable. The predicate must be on state |
||||
protected by the lock. */ |
||||
while (q->length == N) { |
||||
gpr_cv_wait(&q->non_full, &q->mu, gpr_inf_future); |
||||
} |
||||
if (q->length == 0) { /* Wake threads blocked in queue_remove(). */ |
||||
/* It's normal to use gpr_cv_broadcast() or gpr_signal() while
|
||||
holding the lock. */ |
||||
gpr_cv_broadcast(&q->non_empty); |
||||
} |
||||
q->elem[(q->head + q->length) % N] = x; |
||||
q->length++; |
||||
gpr_mu_unlock(&q->mu); |
||||
} |
||||
|
||||
/* If it can be done without blocking, append x to *q and return non-zero.
|
||||
Otherwise return 0. */ |
||||
int queue_try_append(queue *q, int x) { |
||||
int result = 0; |
||||
if (gpr_mu_trylock(&q->mu)) { |
||||
if (q->length != N) { |
||||
if (q->length == 0) { /* Wake threads blocked in queue_remove(). */ |
||||
gpr_cv_broadcast(&q->non_empty); |
||||
} |
||||
q->elem[(q->head + q->length) % N] = x; |
||||
q->length++; |
||||
result = 1; |
||||
} |
||||
gpr_mu_unlock(&q->mu); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
/* Wait until the *q is non-empty or deadline abs_deadline passes. If the
|
||||
queue is non-empty, remove its head entry, place it in *head, and return |
||||
non-zero. Otherwise return 0. */ |
||||
int queue_remove(queue *q, int *head, gpr_timespec abs_deadline) { |
||||
int result = 0; |
||||
gpr_mu_lock(&q->mu); |
||||
/* To wait for a predicate with a deadline, loop on the negation of the
|
||||
predicate or until gpr_cv_wait() returns true. Code that makes |
||||
the condition true should use gpr_cv_broadcast() on the corresponding |
||||
condition variable. The predicate must be on state protected by the |
||||
lock. */ |
||||
while (q->length == 0 && |
||||
!gpr_cv_wait(&q->non_empty, &q->mu, abs_deadline)) { |
||||
} |
||||
if (q->length != 0) { /* Queue is non-empty. */ |
||||
result = 1; |
||||
if (q->length == N) { /* Wake threads blocked in queue_append(). */ |
||||
gpr_cv_broadcast(&q->non_full); |
||||
} |
||||
*head = q->elem[q->head]; |
||||
q->head = (q->head + 1) % N; |
||||
q->length--; |
||||
} /* else deadline exceeded */ |
||||
gpr_mu_unlock(&q->mu); |
||||
return result; |
||||
} |
||||
#endif /* 0 */ |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_SYNC_H */ |
||||
@ -0,0 +1,55 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_SYNC_GENERIC_H |
||||
#define GRPC_IMPL_CODEGEN_SYNC_GENERIC_H |
||||
/* Generic type defintions for gpr_sync. */ |
||||
|
||||
#include <grpc/impl/codegen/atm.h> |
||||
|
||||
/* gpr_event */ |
||||
typedef struct { gpr_atm state; } gpr_event; |
||||
|
||||
#define GPR_EVENT_INIT \ |
||||
{ 0 } |
||||
|
||||
/* gpr_refcount */ |
||||
typedef struct { gpr_atm count; } gpr_refcount; |
||||
|
||||
/* gpr_stats_counter */ |
||||
typedef struct { gpr_atm value; } gpr_stats_counter; |
||||
|
||||
#define GPR_STATS_INIT \ |
||||
{ 0 } |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_SYNC_GENERIC_H */ |
||||
@ -0,0 +1,47 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_SYNC_POSIX_H |
||||
#define GRPC_IMPL_CODEGEN_SYNC_POSIX_H |
||||
|
||||
#include <grpc/impl/codegen/sync_generic.h> |
||||
|
||||
#include <pthread.h> |
||||
|
||||
typedef pthread_mutex_t gpr_mu; |
||||
typedef pthread_cond_t gpr_cv; |
||||
typedef pthread_once_t gpr_once; |
||||
|
||||
#define GPR_ONCE_INIT PTHREAD_ONCE_INIT |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_SYNC_POSIX_H */ |
||||
@ -0,0 +1,49 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_SYNC_WIN32_H |
||||
#define GRPC_IMPL_CODEGEN_SYNC_WIN32_H |
||||
|
||||
#include <grpc/impl/codegen/sync_generic.h> |
||||
|
||||
typedef struct { |
||||
CRITICAL_SECTION cs; /* Not an SRWLock until Vista is unsupported */ |
||||
int locked; |
||||
} gpr_mu; |
||||
|
||||
typedef CONDITION_VARIABLE gpr_cv; |
||||
|
||||
typedef INIT_ONCE gpr_once; |
||||
#define GPR_ONCE_INIT INIT_ONCE_STATIC_INIT |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_SYNC_WIN32_H */ |
||||
@ -0,0 +1,128 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_IMPL_CODEGEN_TIME_H |
||||
#define GRPC_IMPL_CODEGEN_TIME_H |
||||
/* Time support.
|
||||
We use gpr_timespec, which is analogous to struct timespec. On some |
||||
machines, absolute times may be in local time. */ |
||||
|
||||
#include <grpc/impl/codegen/port_platform.h> |
||||
#include <stddef.h> |
||||
#include <time.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/* The clocks we support. */ |
||||
typedef enum { |
||||
/* Monotonic clock. Epoch undefined. Always moves forwards. */ |
||||
GPR_CLOCK_MONOTONIC = 0, |
||||
/* Realtime clock. May jump forwards or backwards. Settable by
|
||||
the system administrator. Has its epoch at 0:00:00 UTC 1 Jan 1970. */ |
||||
GPR_CLOCK_REALTIME, |
||||
/* CPU cycle time obtained by rdtsc instruction on x86 platforms. Epoch
|
||||
undefined. Degrades to GPR_CLOCK_REALTIME on other platforms. */ |
||||
GPR_CLOCK_PRECISE, |
||||
/* Unmeasurable clock type: no base, created by taking the difference
|
||||
between two times */ |
||||
GPR_TIMESPAN |
||||
} gpr_clock_type; |
||||
|
||||
typedef struct gpr_timespec { |
||||
int64_t tv_sec; |
||||
int32_t tv_nsec; |
||||
/** Against which clock was this time measured? (or GPR_TIMESPAN if
|
||||
this is a relative time meaure) */ |
||||
gpr_clock_type clock_type; |
||||
} gpr_timespec; |
||||
|
||||
/* Time constants. */ |
||||
gpr_timespec gpr_time_0(gpr_clock_type type); /* The zero time interval. */ |
||||
gpr_timespec gpr_inf_future(gpr_clock_type type); /* The far future */ |
||||
gpr_timespec gpr_inf_past(gpr_clock_type type); /* The far past. */ |
||||
|
||||
#define GPR_MS_PER_SEC 1000 |
||||
#define GPR_US_PER_SEC 1000000 |
||||
#define GPR_NS_PER_SEC 1000000000 |
||||
#define GPR_NS_PER_MS 1000000 |
||||
#define GPR_NS_PER_US 1000 |
||||
#define GPR_US_PER_MS 1000 |
||||
|
||||
/* initialize time subsystem */ |
||||
void gpr_time_init(void); |
||||
|
||||
/* Return the current time measured from the given clocks epoch. */ |
||||
gpr_timespec gpr_now(gpr_clock_type clock); |
||||
|
||||
/* Convert a timespec from one clock to another */ |
||||
gpr_timespec gpr_convert_clock_type(gpr_timespec t, |
||||
gpr_clock_type target_clock); |
||||
|
||||
/* Return -ve, 0, or +ve according to whether a < b, a == b, or a > b
|
||||
respectively. */ |
||||
int gpr_time_cmp(gpr_timespec a, gpr_timespec b); |
||||
|
||||
gpr_timespec gpr_time_max(gpr_timespec a, gpr_timespec b); |
||||
gpr_timespec gpr_time_min(gpr_timespec a, gpr_timespec b); |
||||
|
||||
/* Add and subtract times. Calculations saturate at infinities. */ |
||||
gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b); |
||||
gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b); |
||||
|
||||
/* Return a timespec representing a given number of time units. LONG_MIN is
|
||||
interpreted as gpr_inf_past, and LONG_MAX as gpr_inf_future. */ |
||||
gpr_timespec gpr_time_from_micros(long x, gpr_clock_type clock_type); |
||||
gpr_timespec gpr_time_from_nanos(long x, gpr_clock_type clock_type); |
||||
gpr_timespec gpr_time_from_millis(long x, gpr_clock_type clock_type); |
||||
gpr_timespec gpr_time_from_seconds(long x, gpr_clock_type clock_type); |
||||
gpr_timespec gpr_time_from_minutes(long x, gpr_clock_type clock_type); |
||||
gpr_timespec gpr_time_from_hours(long x, gpr_clock_type clock_type); |
||||
|
||||
int32_t gpr_time_to_millis(gpr_timespec timespec); |
||||
|
||||
/* Return 1 if two times are equal or within threshold of each other,
|
||||
0 otherwise */ |
||||
int gpr_time_similar(gpr_timespec a, gpr_timespec b, gpr_timespec threshold); |
||||
|
||||
/* Sleep until at least 'until' - an absolute timeout */ |
||||
void gpr_sleep_until(gpr_timespec until); |
||||
|
||||
double gpr_timespec_to_micros(gpr_timespec t); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* GRPC_IMPL_CODEGEN_TIME_H */ |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue