msg/async: replace CONTINUATION_PARAM() with specialized types.

Signed-off-by: Radoslaw Zarzynski <rzarzyns@redhat.com>

diff --git a/src/msg/async/Protocol.h b/src/msg/async/Protocol.h
index b4a29814c5383dca551cb93a21a0bb70729e2531..08a6481240f1dafeb8330caab6f667cf83d0c9c8 100644 (file)
--- a/src/msg/async/Protocol.h
+++ b/src/msg/async/Protocol.h
@@ -28,8 +28,8 @@ public:
 template <class C, typename... Args>
 class CtFun : public Ct<C> {
 private:
-  using fn = Ct<C> *(C::*)(Args...);
-  fn _f;
+  using fn_t = Ct<C> *(C::*)(Args...);
+  fn_t _f;
   std::tuple<Args...> _params;
 
   template <std::size_t... Is>
@@ -38,7 +38,7 @@ private:
   }
 
 public:
-  CtFun(fn f) : _f(f) {}
+  CtFun(fn_t f) : _f(f) {}
 
   inline void setParams(Args... args) { _params = std::make_tuple(args...); }
   inline Ct<C> *call(C *foo) const override {
@@ -46,11 +46,14 @@ public:
   }
 };
 
+
+template <class C> using CONTINUATION_TYPE = CtFun<C>;
+template <class C> using CONTINUATION_TX_TYPE = CtFun<C, int>;
+template <class C> using CONTINUATION_RX_TYPE = CtFun<C, char*, int>;
+
 #define CONTINUATION_DECL(C, F, ...)                    \
   CtFun<C, ##__VA_ARGS__> F##_cont { (&C::F) };
 
-#define CONTINUATION_PARAM(V, C, ...) CtFun<C, ##__VA_ARGS__> &V##_cont
-
 #define CONTINUATION(F) F##_cont
 #define CONTINUE(F, ...) (F##_cont.setParams(__VA_ARGS__), &F##_cont)
 

diff --git a/src/msg/async/ProtocolV1.cc b/src/msg/async/ProtocolV1.cc
index e7aeb4f197a39624218320994ccfca5267305acf..a392529bb9d2db2df0c6c16ad60acd7e5a67a997 100644 (file)
--- a/src/msg/async/ProtocolV1.cc
+++ b/src/msg/async/ProtocolV1.cc
@@ -414,31 +414,33 @@ void ProtocolV1::run_continuation(CtPtr pcontinuation) {
   }
 }
 
-CtPtr ProtocolV1::read(CONTINUATION_PARAM(next, ProtocolV1, char *, int),
+CtPtr ProtocolV1::read(CONTINUATION_RX_TYPE<ProtocolV1> &next,
                        int len, char *buffer) {
   if (!buffer) {
     buffer = temp_buffer;
   }
   ssize_t r = connection->read(len, buffer,
-                               [&CONTINUATION(next), this](char *buffer, int r) {
-                                 CONTINUATION(next).setParams(buffer, r);
-                                 CONTINUATION_RUN(CONTINUATION(next));
+                               [&next, this](char *buffer, int r) {
+                                 next.setParams(buffer, r);
+                                 CONTINUATION_RUN(next);
                                });
   if (r <= 0) {
-    return CONTINUE(next, buffer, r);
+    next.setParams(buffer, r);
+    return &next;
   }
 
   return nullptr;
 }
 
-CtPtr ProtocolV1::write(CONTINUATION_PARAM(next, ProtocolV1, int),
+CtPtr ProtocolV1::write(CONTINUATION_TX_TYPE<ProtocolV1> &next,
                         bufferlist &buffer) {
-  ssize_t r = connection->write(buffer, [&CONTINUATION(next), this](int r) {
-    CONTINUATION(next).setParams(r);
-    CONTINUATION_RUN(CONTINUATION(next));
+  ssize_t r = connection->write(buffer, [&next, this](int r) {
+    next.setParams(r);
+    CONTINUATION_RUN(next);
   });
   if (r <= 0) {
-    return CONTINUE(next, r);
+    next.setParams(r);
+    return &next;
   }
 
   return nullptr;

diff --git a/src/msg/async/ProtocolV1.h b/src/msg/async/ProtocolV1.h
index eb0d7f72d353ab25f3e3143fa2490bd960476e01..6248a6f2e199283095e56f7b04c9605d8bf616a8 100644 (file)
--- a/src/msg/async/ProtocolV1.h
+++ b/src/msg/async/ProtocolV1.h
@@ -145,9 +145,9 @@ protected:
   State state;
 
   void run_continuation(CtPtr pcontinuation);
-  CtPtr read(CONTINUATION_PARAM(next, ProtocolV1, char *, int), int len,
+  CtPtr read(CONTINUATION_RX_TYPE<ProtocolV1> &next, int len,
              char *buffer = nullptr);
-  CtPtr write(CONTINUATION_PARAM(next, ProtocolV1, int), bufferlist &bl);
+  CtPtr write(CONTINUATION_TX_TYPE<ProtocolV1> &next,bufferlist &bl);
   inline CtPtr _fault() {  // helper fault method that stops continuation
     fault();
     return nullptr;

diff --git a/src/msg/async/ProtocolV2.cc b/src/msg/async/ProtocolV2.cc
index 3748755bf84453b788a2e97d3a316b80ff87069f..256c835bd487393125417fb5581d2ba415ce623b 100644 (file)
--- a/src/msg/async/ProtocolV2.cc
+++ b/src/msg/async/ProtocolV2.cc
@@ -698,18 +698,18 @@ uint32_t ProtocolV2::get_epilogue_size() const {
   }
 }
 
-CtPtr ProtocolV2::read(CONTINUATION_PARAM(next, ProtocolV2, char *, int),
+CtPtr ProtocolV2::read(CONTINUATION_RX_TYPE<ProtocolV2> &next,
                        int len, char *buffer) {
   if (!buffer) {
     buffer = temp_buffer;
   }
-  ssize_t r = connection->read(len, buffer,
-                               [&CONTINUATION(next), this](char *buffer, int r) {
-                                 CONTINUATION(next).setParams(buffer, r);
-                                 run_continuation(CONTINUATION(next));
+                               [&next, this](char *buffer, int r) {
+                                 next.setParams(buffer, r);
+                                 run_continuation(next);
                                });
   if (r <= 0) {
-    return CONTINUE(next, buffer, r);
+    next.setParams(buffer, r);
+    return &next;
   }
 
   return nullptr;
@@ -717,24 +717,24 @@ CtPtr ProtocolV2::read(CONTINUATION_PARAM(next, ProtocolV2, char *, int),
 
 template <class F>
 CtPtr ProtocolV2::write(const std::string &desc,
-                        CONTINUATION_PARAM(next, ProtocolV2),
+                        CONTINUATION_TYPE<ProtocolV2> &next,
                         F &frame) {
   ceph::bufferlist bl = frame.get_buffer(session_stream_handlers);
-  return write(desc, CONTINUATION(next), bl);
+  return write(desc, next, bl);
 }
 
 CtPtr ProtocolV2::write(const std::string &desc,
-                        CONTINUATION_PARAM(next, ProtocolV2),
+                        CONTINUATION_TYPE<ProtocolV2> &next,
                         bufferlist &buffer) {
   ssize_t r =
-      connection->write(buffer, [&CONTINUATION(next), desc, this](int r) {
+      connection->write(buffer, [&next, desc, this](int r) {
         if (r < 0) {
           ldout(cct, 1) << __func__ << " " << desc << " write failed r=" << r
                         << " (" << cpp_strerror(r) << ")" << dendl;
           connection->inject_delay();
           _fault();
         }
-        run_continuation(CONTINUATION(next));
+        run_continuation(next);
       });
 
   if (r <= 0) {
@@ -743,7 +743,8 @@ CtPtr ProtocolV2::write(const std::string &desc,
                     << " (" << cpp_strerror(r) << ")" << dendl;
       return _fault();
     }
-    return CONTINUE(next);
+    next.setParams();
+    return &next;
   }
 
   return nullptr;

diff --git a/src/msg/async/ProtocolV2.h b/src/msg/async/ProtocolV2.h
index 084ffe05253f58ae98003fd6be8ec722f3bc48f7..3e8e84a4e0efaf25f09f24c8f70003845aed9ab5 100644 (file)
--- a/src/msg/async/ProtocolV2.h
+++ b/src/msg/async/ProtocolV2.h
@@ -115,13 +115,14 @@ private:
   void run_continuation(Ct<ProtocolV2> *pcontinuation);
   void run_continuation(Ct<ProtocolV2> &continuation);
 
-  Ct<ProtocolV2> *read(CONTINUATION_PARAM(next, ProtocolV2, char *, int),
+  Ct<ProtocolV2> *read(CONTINUATION_RX_TYPE<ProtocolV2> &next,
                        int len, char *buffer = nullptr);
   template <class F>
   Ct<ProtocolV2> *write(const std::string &desc,
-                        CONTINUATION_PARAM(next, ProtocolV2), F &frame);
+                        CONTINUATION_TYPE<ProtocolV2> &next,
+                       F &frame);
   Ct<ProtocolV2> *write(const std::string &desc,
-                        CONTINUATION_PARAM(next, ProtocolV2),
+                        CONTINUATION_TYPE<ProtocolV2> &next,
                         bufferlist &buffer);
 
   void requeue_sent();