From d4b2215f2d14d634f96a80267da35b082284ae45 Mon Sep 17 00:00:00 2001
From: Fuat Geleri <geleri@fb.com>
Date: Mon, 5 Jun 2017 16:21:02 -0700
Subject: [PATCH 1/5] Ability to pretty print in/out frames in rsocket-cpp

---
 src/Payload.cpp                          | 20 +++++--
 src/framing/Frame.cpp                    | 34 ++++++++++-
 src/statemachine/RSocketStateMachine.cpp | 73 ++++++++++++++----------
 src/statemachine/RSocketStateMachine.h   |  6 ++
 4 files changed, 94 insertions(+), 39 deletions(-)

diff --git a/src/Payload.cpp b/src/Payload.cpp
index 60fb4f54e..acac0ed4d 100644
--- a/src/Payload.cpp
+++ b/src/Payload.cpp
@@ -24,15 +24,23 @@ void Payload::checkFlags(FrameFlags flags) const {
 }
 
 std::ostream& operator<<(std::ostream& os, const Payload& payload) {
-  return os << "[metadata: "
+  return os
+            << "[Metadata("
             << (payload.metadata
                     ? folly::to<std::string>(
                           payload.metadata->computeChainDataLength())
-                    : "<null>")
-            << " data: " << (payload.data
-                                 ? folly::to<std::string>(
-                                       payload.data->computeChainDataLength())
-                                 : "<null>")
+                    : "0")
+            << (payload.metadata
+                    ?  "): '" + payload.metadata->cloneAsValue().moveToFbString().substr(0, 80).toStdString() + "'"
+                    : "): <nullptr>")
+            << ", Data("
+            << (payload.data
+                     ? folly::to<std::string>(
+                           payload.data->computeChainDataLength())
+                     : "0")
+            << (payload.data
+                    ? "): '" + payload.data->cloneAsValue().moveToFbString().substr(0, 80).toStdString() + "'"
+                    : "): <nullptr>")
             << "]";
 }
 
diff --git a/src/framing/Frame.cpp b/src/framing/Frame.cpp
index 8314dc3ab..4658d90f3 100644
--- a/src/framing/Frame.cpp
+++ b/src/framing/Frame.cpp
@@ -95,8 +95,34 @@ std::ostream& operator<<(std::ostream& os, ErrorCode errorCode) {
 }
 
 std::ostream& operator<<(std::ostream& os, FrameFlags frameFlags) {
-  std::bitset<16> flags(static_cast<uint16_t>(frameFlags));
-  return os << flags;
+  // TODO Match the Flag names with the AllowedFlags in the Frame declarations
+
+  std::stringstream ss;
+  std::string delimeter = "";
+  if (!!(frameFlags & FrameFlags::NEXT)) {
+    ss << "NEXT";
+    delimeter = "|";
+  }
+  if (!!(frameFlags & FrameFlags::COMPLETE)) {
+    ss << delimeter << "COMPLETE";
+    delimeter = "|";
+  }
+  if (!!(frameFlags & FrameFlags::FOLLOWS)) {
+    ss << delimeter << "FOLLOWS";
+    delimeter = "|";
+  }
+  if (!!(frameFlags & FrameFlags::METADATA)) {
+    ss << delimeter << "METADATA";
+    delimeter = "|";
+  }
+  if (!!(frameFlags & FrameFlags::IGNORE)) {
+    ss << delimeter << "IGNORE";
+    delimeter = "|";
+  }
+  if (!delimeter.empty()) {
+    return os << ss.str();
+  }
+  return os << "EMPTY";
 }
 
 std::ostream& operator<<(std::ostream& os, const FrameHeader& header) {
@@ -184,7 +210,9 @@ std::ostream& operator<<(std::ostream& os, const Frame_KEEPALIVE& frame) {
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_SETUP& frame) {
-  return os << frame.header_ << ", (" << frame.payload_;
+  return os << frame.header_
+            << ", Version: " << frame.versionMajor_ << "." << frame.versionMinor_
+            << ", (" << frame.payload_;
 }
 
 void Frame_SETUP::moveToSetupPayload(SetupParameters& setupPayload) {
diff --git a/src/statemachine/RSocketStateMachine.cpp b/src/statemachine/RSocketStateMachine.cpp
index ff9a3be71..2bfdeeaf1 100644
--- a/src/statemachine/RSocketStateMachine.cpp
+++ b/src/statemachine/RSocketStateMachine.cpp
@@ -272,7 +272,7 @@ void RSocketStateMachine::closeWithError(Frame_ERROR&& error) {
       error.payload_.data->cloneAsValue().moveToFbString().toStdString());
 
   if (frameSerializer_) {
-    outputFrameOrEnqueue(frameSerializer_->serializeOut(std::move(error)));
+    outputFrameOrEnqueue(std::move(error));
   }
   close(std::move(exception), signal);
 }
@@ -442,7 +442,7 @@ void RSocketStateMachine::handleConnectionFrame(
               remoteResumeable_, frame, std::move(payload))) {
         return;
       }
-
+      VLOG(3) << "In: " << frame;
       resumeCache_->resetUpToPosition(frame.position_);
       if (mode_ == ReactiveSocketMode::SERVER) {
         if (!!(frame.header_.flags_ & FrameFlags::KEEPALIVE_RESPOND)) {
@@ -464,6 +464,7 @@ void RSocketStateMachine::handleConnectionFrame(
     case FrameType::METADATA_PUSH: {
       Frame_METADATA_PUSH frame;
       if (deserializeFrameOrError(frame, std::move(payload))) {
+        VLOG(3) << "In: " << frame;
         requestResponder_->handleMetadataPush(std::move(frame.metadata_));
       }
       return;
@@ -473,6 +474,7 @@ void RSocketStateMachine::handleConnectionFrame(
       if (!deserializeFrameOrError(frame, std::move(payload))) {
         return;
       }
+      VLOG(3) << "In: " << frame;
       if (resumeCallback_) {
         if (resumeCache_->isPositionAvailable(frame.position_)) {
           resumeCallback_->onResumeOk();
@@ -494,6 +496,7 @@ void RSocketStateMachine::handleConnectionFrame(
       if (!deserializeFrameOrError(frame, std::move(payload))) {
         return;
       }
+      VLOG(3) << "In: " << frame;
 
       // TODO: handle INVALID_SETUP, UNSUPPORTED_SETUP, REJECTED_SETUP
 
@@ -548,10 +551,12 @@ void RSocketStateMachine::handleStreamFrame(
       if (!deserializeFrameOrError(frameRequestN, std::move(serializedFrame))) {
         return;
       }
+      VLOG(3) << "In: " << frameRequestN;
       stateMachine->handleRequestN(frameRequestN.requestN_);
       break;
     }
     case FrameType::CANCEL: {
+      VLOG(3) << "In: " << Frame_CANCEL();
       stateMachine->handleCancel();
       break;
     }
@@ -560,6 +565,7 @@ void RSocketStateMachine::handleStreamFrame(
       if (!deserializeFrameOrError(framePayload, std::move(serializedFrame))) {
         return;
       }
+      VLOG(3) << "In: " << framePayload;
       stateMachine->handlePayload(
           std::move(framePayload.payload_),
           framePayload.header_.flagsComplete(),
@@ -571,6 +577,7 @@ void RSocketStateMachine::handleStreamFrame(
       if (!deserializeFrameOrError(frameError, std::move(serializedFrame))) {
         return;
       }
+      VLOG(3) << "In: " << frameError;
       stateMachine->handleError(
           std::runtime_error(frameError.payload_.moveDataToString()));
       break;
@@ -615,6 +622,7 @@ void RSocketStateMachine::handleUnknownStream(
       if (!deserializeFrameOrError(frame, std::move(serializedFrame))) {
         return;
       }
+      VLOG(3) << "In: " << frame;
       auto stateMachine =
           streamsFactory_.createChannelResponder(frame.requestN_, streamId);
       auto requestSink = requestResponder_->handleRequestChannelCore(
@@ -627,6 +635,7 @@ void RSocketStateMachine::handleUnknownStream(
       if (!deserializeFrameOrError(frame, std::move(serializedFrame))) {
         return;
       }
+      VLOG(3) << "In: " << frame;
       auto stateMachine =
           streamsFactory_.createStreamResponder(frame.requestN_, streamId);
       requestResponder_->handleRequestStreamCore(
@@ -638,6 +647,7 @@ void RSocketStateMachine::handleUnknownStream(
       if (!deserializeFrameOrError(frame, std::move(serializedFrame))) {
         return;
       }
+      VLOG(3) << "In: " << frame;
       auto stateMachine =
           streamsFactory_.createRequestResponseResponder(streamId);
       requestResponder_->handleRequestResponseCore(
@@ -649,6 +659,7 @@ void RSocketStateMachine::handleUnknownStream(
       if (!deserializeFrameOrError(frame, std::move(serializedFrame))) {
         return;
       }
+      VLOG(3) << "In: " << frame;
       // no stream tracking is necessary
       requestResponder_->handleFireAndForget(
           std::move(frame.payload_), streamId);
@@ -685,6 +696,7 @@ void RSocketStateMachine::sendKeepalive(
   debugCheckCorrectExecutor();
   Frame_KEEPALIVE pingFrame(
       flags, resumeCache_->impliedPosition(), std::move(data));
+  VLOG(3) << "Out: " << pingFrame;
   outputFrameOrEnqueue(
       frameSerializer_->serializeOut(std::move(pingFrame), remoteResumeable_));
 }
@@ -693,12 +705,14 @@ void RSocketStateMachine::tryClientResume(
     const ResumeIdentificationToken& token,
     std::shared_ptr<FrameTransport> frameTransport,
     std::unique_ptr<ClientResumeStatusCallback> resumeCallback) {
+  Frame_RESUME resumeFrame(
+      token,
+      resumeCache_->impliedPosition(),
+      resumeCache_->lastResetPosition(),
+      frameSerializer_->protocolVersion());
+  VLOG(3) << "Out: " << resumeFrame;
   frameTransport->outputFrameOrEnqueue(
-      frameSerializer_->serializeOut(Frame_RESUME(
-          token,
-          resumeCache_->impliedPosition(),
-          resumeCache_->lastResetPosition(),
-          frameSerializer_->protocolVersion())));
+      frameSerializer_->serializeOut(std::move(resumeFrame)));
 
   // if the client was still connected we will disconnected the old connection
   // with a clear error message
@@ -725,8 +739,10 @@ bool RSocketStateMachine::resumeFromPositionOrClose(
 
   if (clientPositionExist &&
       resumeCache_->isPositionAvailable(serverPosition)) {
+    Frame_RESUME_OK resumeOkFrame(resumeCache_->impliedPosition());
+    VLOG(3) << "Out: " << resumeOkFrame;
     frameTransport_->outputFrameOrEnqueue(frameSerializer_->serializeOut(
-        Frame_RESUME_OK(resumeCache_->impliedPosition())));
+        std::move(resumeOkFrame)));
     resumeFromPosition(serverPosition);
     return true;
   } else {
@@ -774,12 +790,12 @@ void RSocketStateMachine::requestFireAndForget(Payload request) {
       streamsFactory().getNextStreamId(),
       FrameFlags::EMPTY,
       std::move(std::move(request)));
-  outputFrameOrEnqueue(frameSerializer_->serializeOut(std::move(frame)));
+  outputFrameOrEnqueue(std::move(frame));
 }
 
 void RSocketStateMachine::metadataPush(std::unique_ptr<folly::IOBuf> metadata) {
-  outputFrameOrEnqueue(
-      frameSerializer_->serializeOut(Frame_METADATA_PUSH(std::move(metadata))));
+  Frame_METADATA_PUSH metadataPushFrame(std::move(metadata));
+  outputFrameOrEnqueue(std::move(metadataPushFrame));
 }
 
 void RSocketStateMachine::outputFrame(std::unique_ptr<folly::IOBuf> frame) {
@@ -874,6 +890,7 @@ void RSocketStateMachine::connectClientSendSetup(
   // TODO: when the server returns back that it doesn't support resumability, we
   // should retry without resumability
 
+  VLOG(3) << "Out: " << frame;
   // making sure we send setup frame first
   frameTransport->outputFrameOrEnqueue(
       frameSerializer_->serializeOut(std::move(frame)));
@@ -889,27 +906,26 @@ void RSocketStateMachine::writeNewStream(
     bool completed) {
   switch (streamType) {
     case StreamType::CHANNEL:
-      outputFrameOrEnqueue(frameSerializer_->serializeOut(Frame_REQUEST_CHANNEL(
+      outputFrameOrEnqueue(Frame_REQUEST_CHANNEL(
           streamId,
           completed ? FrameFlags::COMPLETE : FrameFlags::EMPTY,
           initialRequestN,
-          std::move(payload))));
+          std::move(payload)));
       break;
 
     case StreamType::STREAM:
-      outputFrameOrEnqueue(frameSerializer_->serializeOut(Frame_REQUEST_STREAM(
-          streamId, FrameFlags::EMPTY, initialRequestN, std::move(payload))));
+      outputFrameOrEnqueue(Frame_REQUEST_STREAM(
+          streamId, FrameFlags::EMPTY, initialRequestN, std::move(payload)));
       break;
 
     case StreamType::REQUEST_RESPONSE:
       outputFrameOrEnqueue(
-          frameSerializer_->serializeOut(Frame_REQUEST_RESPONSE(
-              streamId, FrameFlags::EMPTY, std::move(payload))));
+          Frame_REQUEST_RESPONSE(streamId, FrameFlags::EMPTY, std::move(payload)));
       break;
 
     case StreamType::FNF:
-      outputFrameOrEnqueue(frameSerializer_->serializeOut(
-          Frame_REQUEST_FNF(streamId, FrameFlags::EMPTY, std::move(payload))));
+      outputFrameOrEnqueue(
+          Frame_REQUEST_FNF(streamId, FrameFlags::EMPTY, std::move(payload)));
       break;
 
     default:
@@ -918,8 +934,7 @@ void RSocketStateMachine::writeNewStream(
 }
 
 void RSocketStateMachine::writeRequestN(StreamId streamId, uint32_t n) {
-  outputFrameOrEnqueue(
-      frameSerializer_->serializeOut(Frame_REQUEST_N(streamId, n)));
+  outputFrameOrEnqueue(Frame_REQUEST_N(streamId, n));
 }
 
 void RSocketStateMachine::writePayload(
@@ -930,7 +945,7 @@ void RSocketStateMachine::writePayload(
       streamId,
       FrameFlags::NEXT | (complete ? FrameFlags::COMPLETE : FrameFlags::EMPTY),
       std::move(payload));
-  outputFrameOrEnqueue(frameSerializer_->serializeOut(std::move(frame)));
+  outputFrameOrEnqueue(std::move(frame));
 }
 
 void RSocketStateMachine::writeCloseStream(
@@ -939,23 +954,21 @@ void RSocketStateMachine::writeCloseStream(
     Payload payload) {
   switch (signal) {
     case StreamCompletionSignal::COMPLETE:
-      outputFrameOrEnqueue(
-          frameSerializer_->serializeOut(Frame_PAYLOAD::complete(streamId)));
+      outputFrameOrEnqueue(Frame_PAYLOAD::complete(streamId));
       break;
 
     case StreamCompletionSignal::CANCEL:
-      outputFrameOrEnqueue(
-          frameSerializer_->serializeOut(Frame_CANCEL(streamId)));
+      outputFrameOrEnqueue(Frame_CANCEL(streamId));
       break;
 
     case StreamCompletionSignal::ERROR:
-      outputFrameOrEnqueue(frameSerializer_->serializeOut(
-          Frame_ERROR::error(streamId, std::move(payload))));
+      outputFrameOrEnqueue(
+          Frame_ERROR::error(streamId, std::move(payload)));
       break;
 
     case StreamCompletionSignal::APPLICATION_ERROR:
-      outputFrameOrEnqueue(frameSerializer_->serializeOut(
-          Frame_ERROR::applicationError(streamId, std::move(payload))));
+      outputFrameOrEnqueue(
+          Frame_ERROR::applicationError(streamId, std::move(payload)));
       break;
 
     case StreamCompletionSignal::INVALID_SETUP:
diff --git a/src/statemachine/RSocketStateMachine.h b/src/statemachine/RSocketStateMachine.h
index 60c85cf73..2db2bcf3c 100644
--- a/src/statemachine/RSocketStateMachine.h
+++ b/src/statemachine/RSocketStateMachine.h
@@ -139,6 +139,12 @@ class RSocketStateMachine final
 
   void outputFrameOrEnqueue(std::unique_ptr<folly::IOBuf> frame);
 
+  template<typename T>
+  void outputFrameOrEnqueue(T&& frame) {
+    VLOG(3) << "Out: " << frame;
+    outputFrameOrEnqueue(frameSerializer_->serializeOut(std::forward<T>(frame)));
+  }
+
   void requestFireAndForget(Payload request);
 
   template <typename TFrame>

From 2f6dd3501e86ce114a4c18ccab37387a10cd2aef Mon Sep 17 00:00:00 2001
From: Fuat Geleri <geleri@fb.com>
Date: Wed, 7 Jun 2017 18:39:40 -0700
Subject: [PATCH 2/5] Improve the pretty print for operator<<Frame,
 operator<<Payload

---
 src/framing/Frame.cpp | 189 ++++++++++++++++++++++--------------------
 src/framing/Frame.h   |   1 +
 2 files changed, 99 insertions(+), 91 deletions(-)

diff --git a/src/framing/Frame.cpp b/src/framing/Frame.cpp
index db1ce7c5f..9eceeec14 100644
--- a/src/framing/Frame.cpp
+++ b/src/framing/Frame.cpp
@@ -94,135 +94,120 @@ std::ostream& operator<<(std::ostream& os, ErrorCode errorCode) {
   return os << "ErrorCode(" << static_cast<uint32_t>(errorCode) << ")";
 }
 
-std::ostream& operator<<(
-    std::ostream& os,
-    const std::pair<FrameFlags, FrameFlags>& frameFlagsAndAllowedFlags) {
-  FrameFlags frameFlags = frameFlagsAndAllowedFlags.first;
-  FrameFlags allowedFlags = frameFlagsAndAllowedFlags.second;
+constexpr const char sFrameFlags_EMPTY[] = "EMPTY";
+constexpr const char sFrameFlags_METADATA[] = "METADATA";
+constexpr const char sFrameFlags_RESUME_ENABLE[] = "RESUME_ENABLE";
+constexpr const char sFrameFlags_LEASE[] = "LEASE";
+constexpr const char sFrameFlags_KEEPALIVE_RESPOND[] = "KEEPALIVE_RESPOND";
+constexpr const char sFrameFlags_FOLLOWS[] = "FOLLOWS";
+constexpr const char sFrameFlags_COMPLETE[] = "COMPLETE";
+constexpr const char sFrameFlags_NEXT[] = "NEXT";
+
+std::string to_string(FrameFlags frameFlags,
+                      const std::vector<std::pair<FrameFlags, std::string>>& allowedFlags)
+{
   FrameFlags foundFlags = FrameFlags::EMPTY;
 
   std::stringstream ss;
   std::string delimeter = "";
-  if (!!(allowedFlags & FrameFlags::IGNORE)
-      && !!(frameFlags & FrameFlags::IGNORE)) {
-    ss << delimeter << "IGNORE";
-    delimeter = "|";
-    foundFlags |= FrameFlags::IGNORE;
-  }
-  if (!!(allowedFlags & FrameFlags::METADATA)
-      && !!(frameFlags & FrameFlags::METADATA)) {
-    ss << delimeter << "METADATA";
-    delimeter = "|";
-    foundFlags |= FrameFlags::METADATA;
-  }
-  if (!!(allowedFlags & FrameFlags::RESUME_ENABLE)
-      && !!(frameFlags & FrameFlags::RESUME_ENABLE)) {
-    ss << delimeter << "RESUME_ENABLE";
-    delimeter = "|";
-    foundFlags |= FrameFlags::RESUME_ENABLE;
-  }
-  if (!!(allowedFlags & FrameFlags::LEASE)
-      && !!(frameFlags & FrameFlags::LEASE)) {
-    ss << delimeter << "LEASE";
-    delimeter = "|";
-    foundFlags |= FrameFlags::LEASE;
-  }
-  if (!!(allowedFlags & FrameFlags::KEEPALIVE_RESPOND)
-      && !!(frameFlags & FrameFlags::KEEPALIVE_RESPOND)) {
-    ss << delimeter << "KEEPALIVE_RESPOND";
-    delimeter = "|";
-    foundFlags |= FrameFlags::KEEPALIVE_RESPOND;
-  }
-  if (!!(allowedFlags & FrameFlags::FOLLOWS)
-      && !!(frameFlags & FrameFlags::FOLLOWS)) { // FOLLOWS = 0x80,
-    ss << delimeter << "FOLLOWS";
-    delimeter = "|";
-    foundFlags |= FrameFlags::FOLLOWS;
-  }
-  if (!!(allowedFlags & FrameFlags::COMPLETE)
-      && !!(frameFlags & FrameFlags::COMPLETE)) { // COMPLETE = 0x40
-    ss << delimeter << "COMPLETE";
-    delimeter = "|";
-    foundFlags |= FrameFlags::COMPLETE;
-  }
-  if (!!(allowedFlags & FrameFlags::NEXT)
-      && !!(frameFlags & FrameFlags::NEXT)) { // NEXT = 0x20
-    ss << "NEXT";
-    delimeter = "|";
-    foundFlags |= FrameFlags::NEXT;
+  for (auto& pair : allowedFlags) {
+    if (!!(frameFlags & pair.first)) {
+      ss << delimeter << pair.second;
+      delimeter = "|";
+      foundFlags |= pair.first;
+    }
   }
 
   if (foundFlags != frameFlags) {
-    return operator<<(os, frameFlags);
+    ss <<frameFlags;
+  } else if (delimeter.empty()) {
+    ss << sFrameFlags_EMPTY;
   }
-  if (!delimeter.empty()) {
-    return os << ss.str();
-  }
-  return os << "EMPTY";
+  return ss.str();
 }
 
 std::ostream& operator<<(std::ostream& os, FrameFlags frameFlags) {
-  // TODO Match the Flag names with the AllowedFlags in the Frame declarations
   std::bitset<16> flags(static_cast<uint16_t>(frameFlags));
   return os << flags;
 }
 
-std::ostream& operator<<(std::ostream& os, const std::pair<const FrameHeader&, FrameFlags>& headerAndAllowedFlags) {
-  const auto& header = headerAndAllowedFlags.first;
-  return os << header.type_ << "["
-            << std::make_pair(header.flags_, headerAndAllowedFlags.second)
-            << ", " << header.streamId_ << "]";
-}
-
 std::ostream& operator<<(std::ostream& os, const FrameHeader& header) {
   return os << header.type_ << "[" << header.flags_ << ", " << header.streamId_
             << "]";
 }
+
+std::ostream& operator<<(std::ostream& os,
+    const std::pair< const FrameHeader&,
+        const std::vector<std::pair<FrameFlags, std::string>>&
+      > & headerAndAllowedFlags
+  ) {
+  const auto& header = headerAndAllowedFlags.first;
+  const auto& allowedFlags = headerAndAllowedFlags.second;
+  return os << header.type_ << "[" << to_string(header.flags_, allowedFlags)
+            << ", " << header.streamId_ << "]";
+}
+
 /// @}
 
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_Base& frame) {
-  return os << std::make_pair(frame.header_, FrameFlags::EMPTY)
-            << "(" << frame.requestN_ << ", "
+  return os << std::make_pair(frame.header_,
+                              std::vector<std::pair<FrameFlags, std::string>> {})
+            << "("
+            << frame.requestN_ << ", "
             << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_N& frame) {
-  return os << std::make_pair(frame.header_, FrameFlags::EMPTY)
+  return os << std::make_pair(frame.header_,
+                              std::vector<std::pair<FrameFlags, std::string>> {})
             << "(" << frame.requestN_ << ")";
 }
 
-constexpr FrameFlags Frame_REQUEST_RESPONSE::AllowedFlags;
 std::ostream& operator<<(
     std::ostream& os,
     const Frame_REQUEST_RESPONSE& frame) {
-  return os << std::make_pair(frame.header_, Frame_REQUEST_RESPONSE::AllowedFlags)
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+      {FrameFlags::METADATA, sFrameFlags_METADATA},
+      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS} };
+  return os << std::make_pair(frame.header_, allowedFlags)
             << ", " << frame.payload_;
 }
 
-constexpr FrameFlags Frame_REQUEST_FNF::AllowedFlags;
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_FNF& frame) {
-  return os << std::make_pair(frame.header_, Frame_REQUEST_FNF::AllowedFlags)
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+      {FrameFlags::METADATA, sFrameFlags_METADATA},
+      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS} };
+  return os << std::make_pair(frame.header_, allowedFlags)
             << ", " << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_METADATA_PUSH& frame) {
-  return os << std::make_pair(frame.header_, FrameFlags::METADATA) << ", "
+  return os << std::make_pair(frame.header_,
+                              std::vector<std::pair<FrameFlags, std::string>>{})
+            << ", "
             << (frame.metadata_ ? frame.metadata_->computeChainDataLength()
                                 : 0);
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_CANCEL& frame) {
-  return os << std::make_pair(frame.header_, FrameFlags::EMPTY);
+  return os << std::make_pair(frame.header_,
+                              std::vector<std::pair<FrameFlags, std::string>> {});
 }
 
 Frame_PAYLOAD Frame_PAYLOAD::complete(StreamId streamId) {
   return Frame_PAYLOAD(streamId, FrameFlags::COMPLETE, Payload());
 }
 
-constexpr FrameFlags Frame_PAYLOAD::AllowedFlags;
 std::ostream& operator<<(std::ostream& os, const Frame_PAYLOAD& frame) {
-  return os << std::make_pair(frame.header_, Frame_PAYLOAD::AllowedFlags)
-            << ", (" << frame.payload_;
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+      {FrameFlags::METADATA, sFrameFlags_METADATA},
+      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS},
+      {FrameFlags::COMPLETE, sFrameFlags_COMPLETE},
+      {FrameFlags::NEXT, sFrameFlags_NEXT} };
+  return os << std::make_pair(frame.header_, allowedFlags)
+            << ", "
+            << frame.header_.streamId_
+            << "], (" << frame.payload_;
 }
 
 Frame_ERROR Frame_ERROR::unexpectedFrame() {
@@ -255,24 +240,29 @@ Frame_ERROR Frame_ERROR::applicationError(
       streamId, ErrorCode::APPLICATION_ERROR, std::move(payload));
 }
 
-constexpr FrameFlags Frame_ERROR::AllowedFlags;
 std::ostream& operator<<(std::ostream& os, const Frame_ERROR& frame) {
-  return os << std::make_pair(frame.header_, Frame_ERROR::AllowedFlags)
-            << ", " << frame.errorCode_ << ", "
-            << frame.payload_;
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+      {FrameFlags::METADATA, sFrameFlags_METADATA} };
+  return os << std::make_pair(frame.header_, allowedFlags)
+            << ", " << frame.errorCode_
+            << ", " << frame.payload_;
 }
 
-constexpr FrameFlags Frame_KEEPALIVE::AllowedFlags;
 std::ostream& operator<<(std::ostream& os, const Frame_KEEPALIVE& frame) {
-  return os << std::make_pair(frame.header_, Frame_KEEPALIVE::AllowedFlags)
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+      {FrameFlags::KEEPALIVE_RESPOND, sFrameFlags_KEEPALIVE_RESPOND} };
+  return os << std::make_pair(frame.header_, allowedFlags)
             << "(<"
             << (frame.data_ ? frame.data_->computeChainDataLength() : 0)
             << ">)";
 }
 
-constexpr FrameFlags Frame_SETUP::AllowedFlags;
 std::ostream& operator<<(std::ostream& os, const Frame_SETUP& frame) {
-  return os << std::make_pair(frame.header_, Frame_SETUP::AllowedFlags)
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+      {FrameFlags::METADATA, sFrameFlags_METADATA},
+      {FrameFlags::RESUME_ENABLE, sFrameFlags_RESUME_ENABLE},
+      {FrameFlags::LEASE, sFrameFlags_LEASE} };
+  return os << std::make_pair(frame.header_, allowedFlags)
             << ", Version: " << frame.versionMajor_ << "." << frame.versionMinor_
             << ", (" << frame.payload_;
 }
@@ -286,16 +276,18 @@ void Frame_SETUP::moveToSetupPayload(SetupParameters& setupPayload) {
   setupPayload.protocolVersion = ProtocolVersion(versionMajor_, versionMinor_);
 }
 
-constexpr FrameFlags Frame_LEASE::AllowedFlags;
 std::ostream& operator<<(std::ostream& os, const Frame_LEASE& frame) {
-  return os << std::make_pair(frame.header_, Frame_LEASE::AllowedFlags)
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+      {FrameFlags::METADATA, sFrameFlags_METADATA} };
+  return os << std::make_pair(frame.header_, allowedFlags)
             << ", ("
             << (frame.metadata_ ? frame.metadata_->computeChainDataLength() : 0)
             << ")";
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_RESUME& frame) {
-  return os << std::make_pair(frame.header_, FrameFlags::EMPTY)
+  return os << std::make_pair(frame.header_,
+                              std::vector<std::pair<FrameFlags, std::string>>{})
             << ", ("
             << "token"
             << ", @server " << frame.lastReceivedServerPosition_ << ", @client "
@@ -303,14 +295,29 @@ std::ostream& operator<<(std::ostream& os, const Frame_RESUME& frame) {
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_RESUME_OK& frame) {
-  return os << frame.header_ << ", (@" << frame.position_ << ")";
+  return os << std::make_pair(frame.header_,
+                              std::vector<std::pair<FrameFlags, std::string>>{})
+            << ", (@" << frame.position_ << ")";
 }
 
-constexpr FrameFlags Frame_REQUEST_CHANNEL::AllowedFlags;
 std::ostream& operator<<(
     std::ostream& os,
     const Frame_REQUEST_CHANNEL& frame) {
-  return os << std::make_pair(frame.header_, Frame_REQUEST_CHANNEL::AllowedFlags)
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+      {FrameFlags::METADATA, sFrameFlags_METADATA},
+      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS},
+      {FrameFlags::COMPLETE, sFrameFlags_COMPLETE} };
+  return os << std::make_pair(frame.header_, allowedFlags)
+            << ", " << frame.payload_;
+}
+
+std::ostream& operator<<(
+    std::ostream& os,
+    const Frame_REQUEST_STREAM& frame) {
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+      {FrameFlags::METADATA, sFrameFlags_METADATA},
+      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS} };
+  return os << std::make_pair(frame.header_, allowedFlags)
             << ", " << frame.payload_;
 }
 
diff --git a/src/framing/Frame.h b/src/framing/Frame.h
index 75e8f8545..8ec5ea456 100644
--- a/src/framing/Frame.h
+++ b/src/framing/Frame.h
@@ -254,6 +254,7 @@ class Frame_REQUEST_STREAM : public Frame_REQUEST_Base {
             0,
             std::move(payload)) {}
 };
+std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_STREAM& frame);
 
 class Frame_REQUEST_CHANNEL : public Frame_REQUEST_Base {
  public:

From 2440b09bcfc80fe87b4d7f8df667e0b625fe0be4 Mon Sep 17 00:00:00 2001
From: Fuat Geleri <geleri@fb.com>
Date: Fri, 9 Jun 2017 10:02:53 -0700
Subject: [PATCH 3/5] clang-format Payload.cpp and Frame.cpp

---
 src/Payload.cpp       |  32 ++++++----
 src/framing/Frame.cpp | 141 ++++++++++++++++++++----------------------
 2 files changed, 87 insertions(+), 86 deletions(-)

diff --git a/src/Payload.cpp b/src/Payload.cpp
index 338760ed2..5d0a0da10 100644
--- a/src/Payload.cpp
+++ b/src/Payload.cpp
@@ -24,23 +24,29 @@ void Payload::checkFlags(FrameFlags flags) const {
 }
 
 std::ostream& operator<<(std::ostream& os, const Payload& payload) {
-  return os
-            << "[Metadata("
+  return os << "[Metadata("
             << (payload.metadata
                     ? folly::to<std::string>(
                           payload.metadata->computeChainDataLength())
                     : "0")
-            << (payload.metadata
-                    ?  "): '" + payload.metadata->cloneAsValue().moveToFbString().substr(0, 40).toStdString() + "'"
-                    : "): <nullptr>")
+            << (payload.metadata ? "): '" +
+                        payload.metadata->cloneAsValue()
+                            .moveToFbString()
+                            .substr(0, 40)
+                            .toStdString() +
+                        "'"
+                                 : "): <nullptr>")
             << ", Data("
-            << (payload.data
-                     ? folly::to<std::string>(
-                           payload.data->computeChainDataLength())
-                     : "0")
-            << (payload.data
-                    ? "): '" + payload.data->cloneAsValue().moveToFbString().substr(0, 40).toStdString() + "'"
-                    : "): <nullptr>")
+            << (payload.data ? folly::to<std::string>(
+                                   payload.data->computeChainDataLength())
+                             : "0")
+            << (payload.data ? "): '" +
+                        payload.data->cloneAsValue()
+                            .moveToFbString()
+                            .substr(0, 40)
+                            .toStdString() +
+                        "'"
+                             : "): <nullptr>")
             << "]";
 }
 
@@ -79,4 +85,4 @@ FrameFlags Payload::getFlags() const {
   return (metadata != nullptr ? FrameFlags::METADATA : FrameFlags::EMPTY);
 }
 
-} // reactivesocket
+} // namespace rsocket
diff --git a/src/framing/Frame.cpp b/src/framing/Frame.cpp
index 4f7fac0d9..4ce42f5e1 100644
--- a/src/framing/Frame.cpp
+++ b/src/framing/Frame.cpp
@@ -1,11 +1,11 @@
 // Copyright 2004-present Facebook. All Rights Reserved.
 
 #include "src/framing/Frame.h"
-#include <bitset>
-#include <sstream>
 #include <folly/Memory.h>
 #include <folly/Optional.h>
 #include <folly/io/Cursor.h>
+#include <bitset>
+#include <sstream>
 #include "src/RSocketParameters.h"
 
 namespace rsocket {
@@ -95,7 +95,7 @@ std::ostream& operator<<(std::ostream& os, ErrorCode errorCode) {
   return os << "ErrorCode(" << static_cast<uint32_t>(errorCode) << ")";
 }
 
-constexpr const char sFrameFlags_EMPTY[] = "EMPTY";
+constexpr const char sFrameFlags_EMPTY[] = "0x00";
 constexpr const char sFrameFlags_METADATA[] = "METADATA";
 constexpr const char sFrameFlags_RESUME_ENABLE[] = "RESUME_ENABLE";
 constexpr const char sFrameFlags_LEASE[] = "LEASE";
@@ -104,9 +104,9 @@ constexpr const char sFrameFlags_FOLLOWS[] = "FOLLOWS";
 constexpr const char sFrameFlags_COMPLETE[] = "COMPLETE";
 constexpr const char sFrameFlags_NEXT[] = "NEXT";
 
-std::string to_string(FrameFlags frameFlags,
-                      const std::vector<std::pair<FrameFlags, std::string>>& allowedFlags)
-{
+std::string to_string(
+    FrameFlags frameFlags,
+    const std::vector<std::pair<FrameFlags, std::string>>& allowedFlags) {
   FrameFlags foundFlags = FrameFlags::EMPTY;
 
   std::stringstream ss;
@@ -120,7 +120,7 @@ std::string to_string(FrameFlags frameFlags,
   }
 
   if (foundFlags != frameFlags) {
-    ss <<frameFlags;
+    ss << frameFlags;
   } else if (delimeter.empty()) {
     ss << sFrameFlags_EMPTY;
   }
@@ -137,11 +137,12 @@ std::ostream& operator<<(std::ostream& os, const FrameHeader& header) {
             << "]";
 }
 
-std::ostream& operator<<(std::ostream& os,
-    const std::pair< const FrameHeader&,
-        const std::vector<std::pair<FrameFlags, std::string>>&
-      > & headerAndAllowedFlags
-  ) {
+std::ostream& operator<<(
+    std::ostream& os,
+    const std::pair<
+        const FrameHeader&,
+        const std::vector<std::pair<FrameFlags, std::string>>&>&
+        headerAndAllowedFlags) {
   const auto& header = headerAndAllowedFlags.first;
   const auto& allowedFlags = headerAndAllowedFlags.second;
   return os << header.type_ << "[" << to_string(header.flags_, allowedFlags)
@@ -151,48 +152,49 @@ std::ostream& operator<<(std::ostream& os,
 /// @}
 
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_Base& frame) {
-  return os << std::make_pair(frame.header_,
-                              std::vector<std::pair<FrameFlags, std::string>> {})
-            << "("
-            << frame.requestN_ << ", "
-            << frame.payload_;
+  return os << std::make_pair(
+                   frame.header_,
+                   std::vector<std::pair<FrameFlags, std::string>>{})
+            << "(" << frame.requestN_ << ", " << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_N& frame) {
-  return os << std::make_pair(frame.header_,
-                              std::vector<std::pair<FrameFlags, std::string>> {})
+  return os << std::make_pair(
+                   frame.header_,
+                   std::vector<std::pair<FrameFlags, std::string>>{})
             << "(" << frame.requestN_ << ")";
 }
 
 std::ostream& operator<<(
     std::ostream& os,
     const Frame_REQUEST_RESPONSE& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
       {FrameFlags::METADATA, sFrameFlags_METADATA},
-      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS} };
-  return os << std::make_pair(frame.header_, allowedFlags)
-            << ", " << frame.payload_;
+      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS}};
+  return os << std::make_pair(frame.header_, allowedFlags) << ", "
+            << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_FNF& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
       {FrameFlags::METADATA, sFrameFlags_METADATA},
-      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS} };
-  return os << std::make_pair(frame.header_, allowedFlags)
-            << ", " << frame.payload_;
+      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS}};
+  return os << std::make_pair(frame.header_, allowedFlags) << ", "
+            << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_METADATA_PUSH& frame) {
-  return os << std::make_pair(frame.header_,
-                              std::vector<std::pair<FrameFlags, std::string>>{})
+  return os << std::make_pair(
+                   frame.header_,
+                   std::vector<std::pair<FrameFlags, std::string>>{})
             << ", "
             << (frame.metadata_ ? frame.metadata_->computeChainDataLength()
                                 : 0);
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_CANCEL& frame) {
-  return os << std::make_pair(frame.header_,
-                              std::vector<std::pair<FrameFlags, std::string>> {});
+  return os << std::make_pair(
+             frame.header_, std::vector<std::pair<FrameFlags, std::string>>{});
 }
 
 Frame_PAYLOAD Frame_PAYLOAD::complete(StreamId streamId) {
@@ -200,15 +202,13 @@ Frame_PAYLOAD Frame_PAYLOAD::complete(StreamId streamId) {
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_PAYLOAD& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
       {FrameFlags::METADATA, sFrameFlags_METADATA},
       {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS},
       {FrameFlags::COMPLETE, sFrameFlags_COMPLETE},
-      {FrameFlags::NEXT, sFrameFlags_NEXT} };
-  return os << std::make_pair(frame.header_, allowedFlags)
-            << ", "
-            << frame.header_.streamId_
-            << "], (" << frame.payload_;
+      {FrameFlags::NEXT, sFrameFlags_NEXT}};
+  return os << std::make_pair(frame.header_, allowedFlags) << ", "
+            << frame.header_.streamId_ << "], (" << frame.payload_;
 }
 
 Frame_ERROR Frame_ERROR::unexpectedFrame() {
@@ -242,30 +242,28 @@ Frame_ERROR Frame_ERROR::applicationError(
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_ERROR& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
-      {FrameFlags::METADATA, sFrameFlags_METADATA} };
-  return os << std::make_pair(frame.header_, allowedFlags)
-            << ", " << frame.errorCode_
-            << ", " << frame.payload_;
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
+      {FrameFlags::METADATA, sFrameFlags_METADATA}};
+  return os << std::make_pair(frame.header_, allowedFlags) << ", "
+            << frame.errorCode_ << ", " << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_KEEPALIVE& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
-      {FrameFlags::KEEPALIVE_RESPOND, sFrameFlags_KEEPALIVE_RESPOND} };
-  return os << std::make_pair(frame.header_, allowedFlags)
-            << "(<"
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
+      {FrameFlags::KEEPALIVE_RESPOND, sFrameFlags_KEEPALIVE_RESPOND}};
+  return os << std::make_pair(frame.header_, allowedFlags) << "(<"
             << (frame.data_ ? frame.data_->computeChainDataLength() : 0)
             << ">)";
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_SETUP& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
       {FrameFlags::METADATA, sFrameFlags_METADATA},
       {FrameFlags::RESUME_ENABLE, sFrameFlags_RESUME_ENABLE},
-      {FrameFlags::LEASE, sFrameFlags_LEASE} };
+      {FrameFlags::LEASE, sFrameFlags_LEASE}};
   return os << std::make_pair(frame.header_, allowedFlags)
-            << ", Version: " << frame.versionMajor_ << "." << frame.versionMinor_
-            << ", (" << frame.payload_;
+            << ", Version: " << frame.versionMajor_ << "."
+            << frame.versionMinor_ << ", (" << frame.payload_;
 }
 
 void Frame_SETUP::moveToSetupPayload(SetupParameters& setupPayload) {
@@ -278,17 +276,17 @@ void Frame_SETUP::moveToSetupPayload(SetupParameters& setupPayload) {
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_LEASE& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
-      {FrameFlags::METADATA, sFrameFlags_METADATA} };
-  return os << std::make_pair(frame.header_, allowedFlags)
-            << ", ("
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
+      {FrameFlags::METADATA, sFrameFlags_METADATA}};
+  return os << std::make_pair(frame.header_, allowedFlags) << ", ("
             << (frame.metadata_ ? frame.metadata_->computeChainDataLength() : 0)
             << ")";
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_RESUME& frame) {
-  return os << std::make_pair(frame.header_,
-                              std::vector<std::pair<FrameFlags, std::string>>{})
+  return os << std::make_pair(
+                   frame.header_,
+                   std::vector<std::pair<FrameFlags, std::string>>{})
             << ", ("
             << "token"
             << ", @server " << frame.lastReceivedServerPosition_ << ", @client "
@@ -296,30 +294,27 @@ std::ostream& operator<<(std::ostream& os, const Frame_RESUME& frame) {
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_RESUME_OK& frame) {
-  return os << std::make_pair(frame.header_,
-                              std::vector<std::pair<FrameFlags, std::string>>{})
+  return os << std::make_pair(
+                   frame.header_,
+                   std::vector<std::pair<FrameFlags, std::string>>{})
             << ", (@" << frame.position_ << ")";
 }
 
-std::ostream& operator<<(
-    std::ostream& os,
-    const Frame_REQUEST_CHANNEL& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_CHANNEL& frame) {
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
       {FrameFlags::METADATA, sFrameFlags_METADATA},
       {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS},
-      {FrameFlags::COMPLETE, sFrameFlags_COMPLETE} };
-  return os << std::make_pair(frame.header_, allowedFlags)
-            << ", " << frame.payload_;
+      {FrameFlags::COMPLETE, sFrameFlags_COMPLETE}};
+  return os << std::make_pair(frame.header_, allowedFlags) << ", "
+            << frame.payload_;
 }
 
-std::ostream& operator<<(
-    std::ostream& os,
-    const Frame_REQUEST_STREAM& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags {
+std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_STREAM& frame) {
+  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
       {FrameFlags::METADATA, sFrameFlags_METADATA},
-      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS} };
-  return os << std::make_pair(frame.header_, allowedFlags)
-            << ", " << frame.payload_;
+      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS}};
+  return os << std::make_pair(frame.header_, allowedFlags) << ", "
+            << frame.payload_;
 }
 
-} // reactivesocket
+} // namespace rsocket

From 14a05320908158d3e19428f7455672759642ac7f Mon Sep 17 00:00:00 2001
From: Fuat Geleri <geleri@fb.com>
Date: Tue, 13 Jun 2017 18:08:24 -0700
Subject: [PATCH 4/5] Updates, related to Alex's comments

---
 CMakeLists.txt        |   2 +-
 src/framing/Frame.cpp | 162 ++++++++++++++++++------------------------
 2 files changed, 70 insertions(+), 94 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 95b32f3a8..3f334dc19 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -66,7 +66,7 @@ find_package(Threads)
 string(TOLOWER "${CMAKE_BUILD_TYPE}" BUILD_TYPE_LOWER)
 
 if(APPLE)
-  set(OPENSSL_ROOT_DIR "/usr/local/opt/openssl;/usr/local/homebrew/opt/openssl")
+  set(OPENSSL_ROOT_DIR "/usr/local/opt/openssl")
   if("${BUILD_TYPE_LOWER}" MATCHES "debug")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,integer -fno-sanitize=unsigned-integer-overflow")
   endif()
diff --git a/src/framing/Frame.cpp b/src/framing/Frame.cpp
index 4ce42f5e1..ebb1ce464 100644
--- a/src/framing/Frame.cpp
+++ b/src/framing/Frame.cpp
@@ -6,6 +6,7 @@
 #include <folly/io/Cursor.h>
 #include <bitset>
 #include <sstream>
+#include <unordered_map>
 #include "src/RSocketParameters.h"
 
 namespace rsocket {
@@ -95,23 +96,58 @@ std::ostream& operator<<(std::ostream& os, ErrorCode errorCode) {
   return os << "ErrorCode(" << static_cast<uint32_t>(errorCode) << ")";
 }
 
-constexpr const char sFrameFlags_EMPTY[] = "0x00";
-constexpr const char sFrameFlags_METADATA[] = "METADATA";
-constexpr const char sFrameFlags_RESUME_ENABLE[] = "RESUME_ENABLE";
-constexpr const char sFrameFlags_LEASE[] = "LEASE";
-constexpr const char sFrameFlags_KEEPALIVE_RESPOND[] = "KEEPALIVE_RESPOND";
-constexpr const char sFrameFlags_FOLLOWS[] = "FOLLOWS";
-constexpr const char sFrameFlags_COMPLETE[] = "COMPLETE";
-constexpr const char sFrameFlags_NEXT[] = "NEXT";
-
-std::string to_string(
-    FrameFlags frameFlags,
-    const std::vector<std::pair<FrameFlags, std::string>>& allowedFlags) {
+std::string toString(FrameFlags frameFlags, FrameType frameType) {
+  constexpr const char* kEmpty = "0x00";
+  constexpr const char* kMetadata = "METADATA";
+  constexpr const char* kResumeEnable = "RESUME_ENABLE";
+  constexpr const char* kLease = "LEASE";
+  constexpr const char* kKeepaliveRespond = "KEEPALIVE_RESPOND";
+  constexpr const char* kFollows = "FOLLOWS";
+  constexpr const char* kComplete = "COMPLETE";
+  constexpr const char* kNext = "NEXT";
+
+  static std::
+      unordered_map<FrameType, std::vector<std::pair<FrameFlags, std::string>>>
+          flagToNameMap{{FrameType::REQUEST_N, {}},
+                        {FrameType::REQUEST_RESPONSE,
+                         {{FrameFlags::METADATA, kMetadata},
+                          {FrameFlags::FOLLOWS, kFollows}}},
+                        {FrameType::REQUEST_FNF,
+                         {{FrameFlags::METADATA, kMetadata},
+                          {FrameFlags::FOLLOWS, kFollows}}},
+                        {FrameType::METADATA_PUSH, {}},
+                        {FrameType::CANCEL, {}},
+                        {FrameType::PAYLOAD,
+                         {{FrameFlags::METADATA, kMetadata},
+                          {FrameFlags::FOLLOWS, kFollows},
+                          {FrameFlags::COMPLETE, kComplete},
+                          {FrameFlags::NEXT, kNext}}},
+                        {FrameType::ERROR, {{FrameFlags::METADATA, kMetadata}}},
+                        {FrameType::KEEPALIVE,
+                         {{FrameFlags::KEEPALIVE_RESPOND, kKeepaliveRespond}}},
+                        {FrameType::SETUP,
+                         {{FrameFlags::METADATA, kMetadata},
+                          {FrameFlags::RESUME_ENABLE, kResumeEnable},
+                          {FrameFlags::LEASE, kLease}}},
+                        {FrameType::LEASE, {{FrameFlags::METADATA, kMetadata}}},
+                        {FrameType::RESUME, {}},
+                        {FrameType::REQUEST_CHANNEL,
+                         {{FrameFlags::METADATA, kMetadata},
+                          {FrameFlags::FOLLOWS, kFollows},
+                          {FrameFlags::COMPLETE, kComplete}}},
+                        {FrameType::REQUEST_STREAM,
+                         {{FrameFlags::METADATA, kMetadata},
+                          {FrameFlags::FOLLOWS, kFollows}}}};
+
   FrameFlags foundFlags = FrameFlags::EMPTY;
 
+  // Search the corresponding string value for each flag, insert the missing ones as empty
+  const std::vector<std::pair<FrameFlags, std::string>>& allowedFlags =
+      flagToNameMap[frameType];
+
   std::stringstream ss;
   std::string delimeter = "";
-  for (auto& pair : allowedFlags) {
+  for (const auto& pair : allowedFlags) {
     if (!!(frameFlags & pair.first)) {
       ss << delimeter << pair.second;
       delimeter = "|";
@@ -122,7 +158,7 @@ std::string to_string(
   if (foundFlags != frameFlags) {
     ss << frameFlags;
   } else if (delimeter.empty()) {
-    ss << sFrameFlags_EMPTY;
+    ss << kEmpty;
   }
   return ss.str();
 }
@@ -133,68 +169,39 @@ std::ostream& operator<<(std::ostream& os, FrameFlags frameFlags) {
 }
 
 std::ostream& operator<<(std::ostream& os, const FrameHeader& header) {
-  return os << header.type_ << "[" << header.flags_ << ", " << header.streamId_
-            << "]";
-}
-
-std::ostream& operator<<(
-    std::ostream& os,
-    const std::pair<
-        const FrameHeader&,
-        const std::vector<std::pair<FrameFlags, std::string>>&>&
-        headerAndAllowedFlags) {
-  const auto& header = headerAndAllowedFlags.first;
-  const auto& allowedFlags = headerAndAllowedFlags.second;
-  return os << header.type_ << "[" << to_string(header.flags_, allowedFlags)
+  return os << header.type_ << "[" << toString(header.flags_, header.type_)
             << ", " << header.streamId_ << "]";
 }
 
 /// @}
 
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_Base& frame) {
-  return os << std::make_pair(
-                   frame.header_,
-                   std::vector<std::pair<FrameFlags, std::string>>{})
-            << "(" << frame.requestN_ << ", " << frame.payload_;
+  return os << frame.header_ << "(" << frame.requestN_ << ", "
+            << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_N& frame) {
-  return os << std::make_pair(
-                   frame.header_,
-                   std::vector<std::pair<FrameFlags, std::string>>{})
-            << "(" << frame.requestN_ << ")";
+  return os << frame.header_ << "(" << frame.requestN_ << ")";
 }
 
 std::ostream& operator<<(
     std::ostream& os,
     const Frame_REQUEST_RESPONSE& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
-      {FrameFlags::METADATA, sFrameFlags_METADATA},
-      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS}};
-  return os << std::make_pair(frame.header_, allowedFlags) << ", "
-            << frame.payload_;
+  return os << frame.header_ << ", " << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_FNF& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
-      {FrameFlags::METADATA, sFrameFlags_METADATA},
-      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS}};
-  return os << std::make_pair(frame.header_, allowedFlags) << ", "
-            << frame.payload_;
+  return os << frame.header_ << ", " << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_METADATA_PUSH& frame) {
-  return os << std::make_pair(
-                   frame.header_,
-                   std::vector<std::pair<FrameFlags, std::string>>{})
-            << ", "
+  return os << frame.header_ << ", "
             << (frame.metadata_ ? frame.metadata_->computeChainDataLength()
                                 : 0);
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_CANCEL& frame) {
-  return os << std::make_pair(
-             frame.header_, std::vector<std::pair<FrameFlags, std::string>>{});
+  return os << frame.header_;
 }
 
 Frame_PAYLOAD Frame_PAYLOAD::complete(StreamId streamId) {
@@ -202,13 +209,8 @@ Frame_PAYLOAD Frame_PAYLOAD::complete(StreamId streamId) {
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_PAYLOAD& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
-      {FrameFlags::METADATA, sFrameFlags_METADATA},
-      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS},
-      {FrameFlags::COMPLETE, sFrameFlags_COMPLETE},
-      {FrameFlags::NEXT, sFrameFlags_NEXT}};
-  return os << std::make_pair(frame.header_, allowedFlags) << ", "
-            << frame.header_.streamId_ << "], (" << frame.payload_;
+  return os << frame.header_ << ", " << frame.header_.streamId_ << "], ("
+            << frame.payload_;
 }
 
 Frame_ERROR Frame_ERROR::unexpectedFrame() {
@@ -242,27 +244,18 @@ Frame_ERROR Frame_ERROR::applicationError(
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_ERROR& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
-      {FrameFlags::METADATA, sFrameFlags_METADATA}};
-  return os << std::make_pair(frame.header_, allowedFlags) << ", "
-            << frame.errorCode_ << ", " << frame.payload_;
+  return os << frame.header_ << ", " << frame.errorCode_ << ", "
+            << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_KEEPALIVE& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
-      {FrameFlags::KEEPALIVE_RESPOND, sFrameFlags_KEEPALIVE_RESPOND}};
-  return os << std::make_pair(frame.header_, allowedFlags) << "(<"
+  return os << frame.header_ << "(<"
             << (frame.data_ ? frame.data_->computeChainDataLength() : 0)
             << ">)";
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_SETUP& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
-      {FrameFlags::METADATA, sFrameFlags_METADATA},
-      {FrameFlags::RESUME_ENABLE, sFrameFlags_RESUME_ENABLE},
-      {FrameFlags::LEASE, sFrameFlags_LEASE}};
-  return os << std::make_pair(frame.header_, allowedFlags)
-            << ", Version: " << frame.versionMajor_ << "."
+  return os << frame.header_ << ", Version: " << frame.versionMajor_ << "."
             << frame.versionMinor_ << ", (" << frame.payload_;
 }
 
@@ -276,45 +269,28 @@ void Frame_SETUP::moveToSetupPayload(SetupParameters& setupPayload) {
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_LEASE& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
-      {FrameFlags::METADATA, sFrameFlags_METADATA}};
-  return os << std::make_pair(frame.header_, allowedFlags) << ", ("
+  return os << frame.header_ << ", ("
             << (frame.metadata_ ? frame.metadata_->computeChainDataLength() : 0)
             << ")";
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_RESUME& frame) {
-  return os << std::make_pair(
-                   frame.header_,
-                   std::vector<std::pair<FrameFlags, std::string>>{})
-            << ", ("
+  return os << frame.header_ << ", ("
             << "token"
             << ", @server " << frame.lastReceivedServerPosition_ << ", @client "
             << frame.clientPosition_ << ")";
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_RESUME_OK& frame) {
-  return os << std::make_pair(
-                   frame.header_,
-                   std::vector<std::pair<FrameFlags, std::string>>{})
-            << ", (@" << frame.position_ << ")";
+  return os << frame.header_ << ", (@" << frame.position_ << ")";
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_CHANNEL& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
-      {FrameFlags::METADATA, sFrameFlags_METADATA},
-      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS},
-      {FrameFlags::COMPLETE, sFrameFlags_COMPLETE}};
-  return os << std::make_pair(frame.header_, allowedFlags) << ", "
-            << frame.payload_;
+  return os << frame.header_ << ", " << frame.payload_;
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_REQUEST_STREAM& frame) {
-  static const std::vector<std::pair<FrameFlags, std::string>> allowedFlags{
-      {FrameFlags::METADATA, sFrameFlags_METADATA},
-      {FrameFlags::FOLLOWS, sFrameFlags_FOLLOWS}};
-  return os << std::make_pair(frame.header_, allowedFlags) << ", "
-            << frame.payload_;
+  return os << frame.header_ << ", " << frame.payload_;
 }
 
 } // namespace rsocket

From 36f02180abdd5e86600b4e19282e138596c291fd Mon Sep 17 00:00:00 2001
From: Fuat Geleri <geleri@fb.com>
Date: Wed, 14 Jun 2017 12:47:35 -0700
Subject: [PATCH 5/5] convert std::unordered_map to std::map, as
 std::hash<FrameType> doesn't exist

---
 src/framing/Frame.cpp | 89 +++++++++++++++++++++----------------------
 1 file changed, 44 insertions(+), 45 deletions(-)

diff --git a/src/framing/Frame.cpp b/src/framing/Frame.cpp
index ebb1ce464..69b2d7768 100644
--- a/src/framing/Frame.cpp
+++ b/src/framing/Frame.cpp
@@ -5,8 +5,8 @@
 #include <folly/Optional.h>
 #include <folly/io/Cursor.h>
 #include <bitset>
+#include <map>
 #include <sstream>
-#include <unordered_map>
 #include "src/RSocketParameters.h"
 
 namespace rsocket {
@@ -96,71 +96,71 @@ std::ostream& operator<<(std::ostream& os, ErrorCode errorCode) {
   return os << "ErrorCode(" << static_cast<uint32_t>(errorCode) << ")";
 }
 
-std::string toString(FrameFlags frameFlags, FrameType frameType) {
+std::ostream&
+writeFlags(std::ostream& os, FrameFlags frameFlags, FrameType frameType) {
   constexpr const char* kEmpty = "0x00";
   constexpr const char* kMetadata = "METADATA";
   constexpr const char* kResumeEnable = "RESUME_ENABLE";
   constexpr const char* kLease = "LEASE";
-  constexpr const char* kKeepaliveRespond = "KEEPALIVE_RESPOND";
+  constexpr const char* kKeepAliveRespond = "KEEPALIVE_RESPOND";
   constexpr const char* kFollows = "FOLLOWS";
   constexpr const char* kComplete = "COMPLETE";
   constexpr const char* kNext = "NEXT";
 
-  static std::
-      unordered_map<FrameType, std::vector<std::pair<FrameFlags, std::string>>>
-          flagToNameMap{{FrameType::REQUEST_N, {}},
-                        {FrameType::REQUEST_RESPONSE,
-                         {{FrameFlags::METADATA, kMetadata},
-                          {FrameFlags::FOLLOWS, kFollows}}},
-                        {FrameType::REQUEST_FNF,
-                         {{FrameFlags::METADATA, kMetadata},
-                          {FrameFlags::FOLLOWS, kFollows}}},
-                        {FrameType::METADATA_PUSH, {}},
-                        {FrameType::CANCEL, {}},
-                        {FrameType::PAYLOAD,
-                         {{FrameFlags::METADATA, kMetadata},
-                          {FrameFlags::FOLLOWS, kFollows},
-                          {FrameFlags::COMPLETE, kComplete},
-                          {FrameFlags::NEXT, kNext}}},
-                        {FrameType::ERROR, {{FrameFlags::METADATA, kMetadata}}},
-                        {FrameType::KEEPALIVE,
-                         {{FrameFlags::KEEPALIVE_RESPOND, kKeepaliveRespond}}},
-                        {FrameType::SETUP,
-                         {{FrameFlags::METADATA, kMetadata},
-                          {FrameFlags::RESUME_ENABLE, kResumeEnable},
-                          {FrameFlags::LEASE, kLease}}},
-                        {FrameType::LEASE, {{FrameFlags::METADATA, kMetadata}}},
-                        {FrameType::RESUME, {}},
-                        {FrameType::REQUEST_CHANNEL,
-                         {{FrameFlags::METADATA, kMetadata},
-                          {FrameFlags::FOLLOWS, kFollows},
-                          {FrameFlags::COMPLETE, kComplete}}},
-                        {FrameType::REQUEST_STREAM,
-                         {{FrameFlags::METADATA, kMetadata},
-                          {FrameFlags::FOLLOWS, kFollows}}}};
+  static std::map<FrameType, std::vector<std::pair<FrameFlags, std::string>>>
+      flagToNameMap{{FrameType::REQUEST_N, {}},
+                    {FrameType::REQUEST_RESPONSE,
+                     {{FrameFlags::METADATA, kMetadata},
+                      {FrameFlags::FOLLOWS, kFollows}}},
+                    {FrameType::REQUEST_FNF,
+                     {{FrameFlags::METADATA, kMetadata},
+                      {FrameFlags::FOLLOWS, kFollows}}},
+                    {FrameType::METADATA_PUSH, {}},
+                    {FrameType::CANCEL, {}},
+                    {FrameType::PAYLOAD,
+                     {{FrameFlags::METADATA, kMetadata},
+                      {FrameFlags::FOLLOWS, kFollows},
+                      {FrameFlags::COMPLETE, kComplete},
+                      {FrameFlags::NEXT, kNext}}},
+                    {FrameType::ERROR, {{FrameFlags::METADATA, kMetadata}}},
+                    {FrameType::KEEPALIVE,
+                     {{FrameFlags::KEEPALIVE_RESPOND, kKeepAliveRespond}}},
+                    {FrameType::SETUP,
+                     {{FrameFlags::METADATA, kMetadata},
+                      {FrameFlags::RESUME_ENABLE, kResumeEnable},
+                      {FrameFlags::LEASE, kLease}}},
+                    {FrameType::LEASE, {{FrameFlags::METADATA, kMetadata}}},
+                    {FrameType::RESUME, {}},
+                    {FrameType::REQUEST_CHANNEL,
+                     {{FrameFlags::METADATA, kMetadata},
+                      {FrameFlags::FOLLOWS, kFollows},
+                      {FrameFlags::COMPLETE, kComplete}}},
+                    {FrameType::REQUEST_STREAM,
+                     {{FrameFlags::METADATA, kMetadata},
+                      {FrameFlags::FOLLOWS, kFollows}}}};
 
   FrameFlags foundFlags = FrameFlags::EMPTY;
 
-  // Search the corresponding string value for each flag, insert the missing ones as empty
+  // Search the corresponding string value for each flag, insert the missing
+  // ones as empty
   const std::vector<std::pair<FrameFlags, std::string>>& allowedFlags =
       flagToNameMap[frameType];
 
-  std::stringstream ss;
   std::string delimeter = "";
   for (const auto& pair : allowedFlags) {
     if (!!(frameFlags & pair.first)) {
-      ss << delimeter << pair.second;
+      os << delimeter << pair.second;
       delimeter = "|";
       foundFlags |= pair.first;
     }
   }
 
   if (foundFlags != frameFlags) {
-    ss << frameFlags;
+    os << frameFlags;
   } else if (delimeter.empty()) {
-    ss << kEmpty;
+    os << kEmpty;
   }
-  return ss.str();
+  return os;
 }
 
 std::ostream& operator<<(std::ostream& os, FrameFlags frameFlags) {
@@ -169,8 +169,8 @@ std::ostream& operator<<(std::ostream& os, FrameFlags frameFlags) {
 }
 
 std::ostream& operator<<(std::ostream& os, const FrameHeader& header) {
-  return os << header.type_ << "[" << toString(header.flags_, header.type_)
-            << ", " << header.streamId_ << "]";
+  os << header.type_ << "[";
+  return writeFlags(os, header.flags_, header.type_) << ", " << header.streamId_ << "]";
 }
 
 /// @}
@@ -209,8 +209,7 @@ Frame_PAYLOAD Frame_PAYLOAD::complete(StreamId streamId) {
 }
 
 std::ostream& operator<<(std::ostream& os, const Frame_PAYLOAD& frame) {
-  return os << frame.header_ << ", " << frame.header_.streamId_ << "], ("
-            << frame.payload_;
+  return os << frame.header_ << ", (" << frame.payload_;
 }
 
 Frame_ERROR Frame_ERROR::unexpectedFrame() {