Add support for RequestResponse (#117)

* Add support for RequestResponse

* rebase

* Removed all questions from the code since they are mostly for my understanding, and the code should work properly due to copy-paste reasons
Check the request payload is not sent twice RequestResponseRequesterBase

* Publisher responds with one single RESPONSE frame that has the COMPLETE flag set

Author: lehecka

CMakeLists.txt

@@ -82,6 +82,10 @@ add_library(
   src/automata/ChannelRequester.h
   src/automata/ChannelResponder.cpp
   src/automata/ChannelResponder.h
+  src/automata/RequestResponseRequester.cpp
+  src/automata/RequestResponseRequester.h
+  src/automata/RequestResponseResponder.cpp
+  src/automata/RequestResponseResponder.h
   src/automata/StreamSubscriptionRequesterBase.cpp
   src/automata/StreamSubscriptionRequesterBase.h
   src/automata/StreamSubscriptionResponderBase.cpp

TARGETS

@@ -38,6 +38,8 @@ cxx_library(
         'src/AbstractStreamAutomaton.cpp',
         'src/automata/ChannelRequester.cpp',
         'src/automata/ChannelResponder.cpp',
+        'src/automata/RequestResponseRequester.cpp',
+        'src/automata/RequestResponseResponder.cpp',
         'src/automata/StreamSubscriptionRequesterBase.cpp',
         'src/automata/StreamSubscriptionResponderBase.cpp',
         'src/automata/StreamRequester.cpp',

src/AbstractStreamAutomaton.cpp

@@ -47,6 +47,9 @@ void AbstractStreamAutomaton::onNextFrame(
     case FrameType::REQUEST_N:
       deserializeAndDispatch<Frame_REQUEST_N>(std::move(payload));
       return;
+    case FrameType::REQUEST_RESPONSE:
+      deserializeAndDispatch<Frame_REQUEST_RESPONSE>(std::move(payload));
+      return;
     case FrameType::CANCEL:
       deserializeAndDispatch<Frame_CANCEL>(std::move(payload));
       return;

src/AbstractStreamAutomaton.h

@@ -17,6 +17,7 @@ class ConnectionAutomaton;
 class Frame_REQUEST_STREAM;
 class Frame_REQUEST_SUB;
 class Frame_REQUEST_CHANNEL;
+class Frame_REQUEST_RESPONSE;
 class Frame_REQUEST_N;
 class Frame_CANCEL;
 class Frame_RESPONSE;
@@ -96,6 +97,7 @@ class AbstractStreamAutomaton {
   virtual void onNextFrame(Frame_REQUEST_SUB&& frame) = 0;
   virtual void onNextFrame(Frame_REQUEST_CHANNEL&& frame) = 0;
   virtual void onNextFrame(Frame_REQUEST_N&& frame) = 0;
+  virtual void onNextFrame(Frame_REQUEST_RESPONSE&& frame) = 0;
   virtual void onNextFrame(Frame_CANCEL&& frame) = 0;
   virtual void onNextFrame(Frame_RESPONSE&& frame) = 0;
   virtual void onNextFrame(Frame_ERROR&& frame) = 0;

src/Frame.cpp

@@ -47,6 +47,8 @@ std::ostream& operator<<(std::ostream& os, FrameType type) {
       return os << "REQUEST_CHANNEL";
     case FrameType::REQUEST_N:
       return os << "REQUEST_N";
+    case FrameType::REQUEST_RESPONSE:
+      return os << "REQUEST_RESPONSE";
     case FrameType::REQUEST_FNF:
       return os << "REQUEST_FNF";
     case FrameType::CANCEL:
@@ -192,6 +194,34 @@ std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_N& frame) {
 }
 /// @}
 
+/// @{
+std::unique_ptr<folly::IOBuf> Frame_REQUEST_RESPONSE::serializeOut() {
+  auto queue = createBufferQueue(FrameHeader::kSize + payload_.framingSize());
+  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
+
+  header_.serializeInto(appender);
+  payload_.serializeInto(appender);
+  return queue.move();
+}
+
+bool Frame_REQUEST_RESPONSE::deserializeFrom(std::unique_ptr<folly::IOBuf> in) {
+  folly::io::Cursor cur(in.get());
+  try {
+    header_.deserializeFrom(cur);
+    payload_.deserializeFrom(cur, header_.flags_);
+  } catch (...) {
+    return false;
+  }
+  return true;
+}
+
+std::ostream& operator<<(
+    std::ostream& os,
+    const Frame_REQUEST_RESPONSE& frame) {
+  return os << frame.header_ << ", " << frame.payload_;
+}
+/// @}
+
 /// @{
 std::unique_ptr<folly::IOBuf> Frame_REQUEST_FNF::serializeOut() {
   auto queue = createBufferQueue(FrameHeader::kSize + payload_.framingSize());

src/Frame.h

@@ -38,7 +38,7 @@ enum class FrameType : uint16_t {
   SETUP = 0x0001,
   LEASE = 0x0002,
   KEEPALIVE = 0x0003,
-  // REQUEST_RESPONSE = 0x0004,
+  REQUEST_RESPONSE = 0x0004,
   REQUEST_FNF = 0x0005,
   REQUEST_STREAM = 0x0006,
   REQUEST_SUB = 0x0007,
@@ -218,6 +218,29 @@ class Frame_REQUEST_CHANNEL : public Frame_REQUEST_Base {
       : Frame_REQUEST_CHANNEL(streamId, flags, 0, std::move(payload)) {}
 };
 
+class Frame_REQUEST_RESPONSE {
+ public:
+  static constexpr bool Trait_CarriesAllowance = false;
+
+  Frame_REQUEST_RESPONSE() = default;
+  Frame_REQUEST_RESPONSE(StreamId streamId, FrameFlags flags, Payload payload)
+      : header_(
+            FrameType::REQUEST_RESPONSE,
+            flags | payload.getFlags(),
+            streamId),
+        payload_(std::move(payload)) {
+    payload_.checkFlags(header_.flags_); // to verify the client didn't set
+    // METADATA and provided none
+  }
+
+  std::unique_ptr<folly::IOBuf> serializeOut();
+  bool deserializeFrom(std::unique_ptr<folly::IOBuf> in);
+
+  FrameHeader header_;
+  Payload payload_;
+};
+std::ostream& operator<<(std::ostream&, const Frame_REQUEST_RESPONSE&);
+
 class Frame_REQUEST_FNF {
  public:
   static constexpr bool Trait_CarriesAllowance = false;

src/NullRequestHandler.cpp

@@ -46,6 +46,13 @@ void NullRequestHandler::handleRequestSubscription(
   response.onError(std::runtime_error("NullRequestHandler"));
 }
 
+void NullRequestHandler::handleRequestResponse(
+    Payload /*request*/,
+    Subscriber<Payload>& response) {
+  response.onSubscribe(createManagedInstance<NullSubscription>());
+  response.onError(std::runtime_error("NullRequestHandler"));
+}
+
 void NullRequestHandler::handleFireAndForgetRequest(Payload /*request*/) {}
 
 void NullRequestHandler::handleMetadataPush(

src/NullRequestHandler.h

@@ -35,6 +35,9 @@ class NullRequestHandler : public RequestHandler {
   void handleRequestSubscription(Payload request, Subscriber<Payload>& response)
       override;
 
+  void handleRequestResponse(Payload request, Subscriber<Payload>& response)
+      override;
+
   void handleFireAndForgetRequest(Payload request) override;
 
   void handleMetadataPush(std::unique_ptr<folly::IOBuf> request) override;

src/ReactiveSocket.cpp

@@ -18,6 +18,8 @@
 #include "src/RequestHandler.h"
 #include "src/automata/ChannelRequester.h"
 #include "src/automata/ChannelResponder.h"
+#include "src/automata/RequestResponseRequester.h"
+#include "src/automata/RequestResponseResponder.h"
 #include "src/automata/StreamRequester.h"
 #include "src/automata/StreamResponder.h"
 #include "src/automata/SubscriptionRequester.h"
@@ -166,6 +168,21 @@ void ReactiveSocket::requestFireAndForget(Payload request) {
   connection_->outputFrameOrEnqueue(frame.serializeOut());
 }
 
+void ReactiveSocket::requestResponse(
+    Payload payload,
+    Subscriber<Payload>& responseSink) {
+  // TODO(stupaq): handle any exceptions
+  StreamId streamId = nextStreamId_;
+  nextStreamId_ += 2;
+  RequestResponseRequester::Parameters params = {connection_, streamId};
+  auto automaton = new RequestResponseRequester(params);
+  connection_->addStream(streamId, *automaton);
+  automaton->subscribe(responseSink);
+  responseSink.onSubscribe(*automaton);
+  automaton->onNext(std::move(payload));
+  automaton->start();
+}
+
 void ReactiveSocket::metadataPush(std::unique_ptr<folly::IOBuf> metadata) {
   connection_->outputFrameOrEnqueue(
       Frame_METADATA_PUSH(std::move(metadata)).serializeOut());
@@ -247,6 +264,19 @@ bool ReactiveSocket::createResponder(
       automaton->start();
       break;
     }
+    case FrameType::REQUEST_RESPONSE: {
+      Frame_REQUEST_RESPONSE frame;
+      if (!frame.deserializeFrom(std::move(serializedFrame))) {
+        return false;
+      }
+      SubscriptionResponder::Parameters params = {connection_, streamId};
+      auto automaton = new RequestResponseResponder(params);
+      connection_->addStream(streamId, *automaton);
+      handler_->handleRequestResponse(std::move(frame.payload_), *automaton);
+      automaton->onNextFrame(std::move(frame));
+      automaton->start();
+      break;
+    }
     case FrameType::REQUEST_FNF: {
       Frame_REQUEST_FNF frame;
       if (!frame.deserializeFrom(std::move(serializedFrame))) {

src/ReactiveSocket.h

@@ -78,6 +78,8 @@ class ReactiveSocket {
 
   void requestFireAndForget(Payload request);
 
+  void requestResponse(Payload payload, Subscriber<Payload>& responseSink);
+
   void close();
 
   void onClose(CloseListener listener);