Initial definition of flow-controlled unary type along with code generation for this type

4 files changed, 173 insertions, 1 deletions

diff --git a/include/grpc++/impl/codegen/fc_unary.h b/include/grpc++/impl/codegen/fc_unary.h
new file mode 100644
index 0000000000..abb204939d
--- /dev/null
+++ b/include/grpc++/impl/codegen/fc_unary.h
@@ -0,0 +1,97 @@
+/*
+ *
+ * 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_FC_UNARY_H
+#define GRPCXX_IMPL_CODEGEN_FC_UNARY_H
+
+#include <grpc++/impl/codegen/call.h>
+#include <grpc++/impl/codegen/core_codegen_interface.h>
+#include <grpc++/impl/codegen/server_context.h>
+
+namespace grpc {
+
+/// A class to represent a flow-controlled unary call. This is something
+/// of a hybrid between conventional unary and streaming. This is invoked
+/// through a unary call on the client side, but the server responds to it
+/// as though it were a single-ping-pong streaming call. The server can use
+/// the \a Size method to determine an upper-bound on the size of the message
+/// A key difference relative to streaming: an FCUnary must have exactly 1 Read
+/// and exactly 1 Write, in that order, to function correctly.
+/// Otherwise, the RPC is in error
+template <class RequestType, class ResponseType>
+  class FCUnary GRPC_FINAL {
+ public:
+ FCUnary(Call* call, ServerContext* ctx, int max_message_size): call_(call), ctx_(ctx), max_msg_size_(max_message_size), read_done_(false), write_done_(false) {}
+  ~FCUnary() {}
+  uint32_t Size() {return max_msg_size_;}
+  bool Read(RequestType *request) {
+    if (read_done_) {
+      return false;      
+    }
+    read_done_ = true;
+    CallOpSet<CallOpRecvMessage<RequestType>> ops;
+    ops.RecvMessage(request);
+    call_->PerformOps(&ops);
+    return call_->cq()->Pluck(&ops) && ops.got_message;
+  }
+  bool Write(const ResponseType& response) {return Write(response, WriteOptions());}
+  bool Write(const ResponseType& response, const WriteOptions& options) {
+    if (write_done_ || !read_done_) {
+      return false;      
+    }
+    write_done_ = true;
+    CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage> ops;
+    if (!ops.SendMessage(response, options).ok()) {
+      return false;
+    }
+    if (!ctx_->sent_initial_metadata_) {
+      ops.SendInitialMetadata(ctx_->initial_metadata_,
+                              ctx_->initial_metadata_flags());
+      ctx_->sent_initial_metadata_ = true;
+    } else {
+      return false;
+    }
+    call_->PerformOps(&ops);
+    return call_->cq()->Pluck(&ops);    
+  }
+ private:
+  Call* const call_;
+  ServerContext* const ctx_;
+  const int max_msg_size_;
+  bool read_done_;
+  bool write_done_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCXX_IMPL_CODEGEN_FC_UNARY_H
diff --git a/include/grpc++/impl/codegen/method_handler_impl.h b/include/grpc++/impl/codegen/method_handler_impl.h
index 21ac6c4fb5..ecf481ebb6 100644
--- a/include/grpc++/impl/codegen/method_handler_impl.h
+++ b/include/grpc++/impl/codegen/method_handler_impl.h
@@ -35,6 +35,7 @@
 #define GRPCXX_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H
 
 #include <grpc++/impl/codegen/core_codegen_interface.h>
+#include <grpc++/impl/codegen/fc_unary.h>
 #include <grpc++/impl/codegen/rpc_service_method.h>
 #include <grpc++/impl/codegen/sync_stream.h>
 
@@ -190,6 +191,40 @@ class BidiStreamingHandler : public MethodHandler {
   ServiceType* service_;
 };
 
+// A wrapper class of an application provided rpc method handler
+// specifically to apply to the flow-controlled implementation of a unary
+// method
+template <class ServiceType, class RequestType, class ResponseType>
+class FCUnaryMethodHandler : public MethodHandler {
+ public:
+  FCUnaryMethodHandler(std::function<Status(ServiceType*, ServerContext*,
+					    FCUnary<RequestType,ResponseType>*)>
+                       func, ServiceType* service)
+    : func_(func), service_(service) {}
+
+  void RunHandler(const HandlerParameter& param) GRPC_FINAL {
+    FCUnary<RequestType, ResponseType> fc_unary(param.call,
+						param.server_context,
+						param.max_message_size);
+    Status status = func_(service_, param.server_context, &fc_unary);
+    if (!param.server_context->sent_initial_metadata_) {
+      // means that the write never happened, which is bad
+    } else {
+      CallOpSet<CallOpServerSendStatus> ops;
+      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*,
+                       FCUnary<RequestType, ResponseType>*)>
+    func_;
+  // The class the above handler function lives in.
+  ServiceType* service_;
+};
+
 // Handle unknown method by returning UNIMPLEMENTED error.
 class UnknownMethodHandler : public MethodHandler {
  public:
diff --git a/include/grpc++/impl/codegen/rpc_method.h b/include/grpc++/impl/codegen/rpc_method.h
index 39cb4f75df..53bee3727e 100644
--- a/include/grpc++/impl/codegen/rpc_method.h
+++ b/include/grpc++/impl/codegen/rpc_method.h
@@ -46,7 +46,8 @@ class RpcMethod {
     NORMAL_RPC = 0,
     CLIENT_STREAMING,  // request streaming
     SERVER_STREAMING,  // response streaming
-    BIDI_STREAMING
+    BIDI_STREAMING,
+    FC_UNARY // flow-controlled unary call
   };
 
   RpcMethod(const char* name, RpcType type)
diff --git a/include/grpc++/support/fc_unary.h b/include/grpc++/support/fc_unary.h
new file mode 100644
index 0000000000..7e7dea8feb
--- /dev/null
+++ b/include/grpc++/support/fc_unary.h
@@ -0,0 +1,39 @@
+/*
+ *
+ * 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_SUPPORT_FC_UNARY_H
+#define GRPCXX_SUPPORT_FC_UNARY_H
+
+#include <grpc++/impl/codegen/fc_unary.h>
+
+#endif  // GRPCXX_SUPPORT_FC_UNARY_H