test/crimson: use bp_type_t for breakpoint type

Signed-off-by: Yingxin Cheng <yingxin.cheng@intel.com>

diff --git a/src/crimson/net/Interceptor.h b/src/crimson/net/Interceptor.h
index 4bfab745e793bd9736c2e1bc50f0153fe36fd7bf..7a263448cbed4c4df12484817cce344ac23c00e7 100644 (file)
--- a/src/crimson/net/Interceptor.h
+++ b/src/crimson/net/Interceptor.h
@@ -28,15 +28,20 @@ inline const char* get_bp_name(custom_bp_t bp) {
   return bp_names[static_cast<int>(bp)];
 }
 
+enum class bp_type_t {
+  READ = 0,
+  WRITE
+};
+
 struct tag_bp_t {
   ceph::msgr::v2::Tag tag;
-  bool is_write;
+  bp_type_t type;
   bool operator==(const tag_bp_t& x) const {
-    return tag == x.tag && is_write == x.is_write;
+    return tag == x.tag && type == x.type;
   }
   bool operator!=(const tag_bp_t& x) const { return !operator==(x); }
   bool operator<(const tag_bp_t& x) const {
-    return std::tie(tag, is_write) < std::tie(x.tag, x.is_write);
+    return std::tie(tag, type) < std::tie(x.tag, x.type);
   }
 };
 
@@ -44,8 +49,8 @@ struct Breakpoint {
   using var_t = std::variant<custom_bp_t, tag_bp_t>;
   var_t bp;
   Breakpoint(custom_bp_t bp) : bp(bp) { }
-  Breakpoint(ceph::msgr::v2::Tag tag, bool is_write)
-    : bp(tag_bp_t{tag, is_write}) { }
+  Breakpoint(ceph::msgr::v2::Tag tag, bp_type_t type)
+    : bp(tag_bp_t{tag, type}) { }
   bool operator==(const Breakpoint& x) const { return bp == x.bp; }
   bool operator!=(const Breakpoint& x) const { return !operator==(x); }
   bool operator==(const custom_bp_t& x) const { return bp == var_t(x); }
@@ -83,7 +88,7 @@ inline std::ostream& operator<<(std::ostream& out, const Breakpoint& bp) {
                                             "ACK"};
     assert(static_cast<size_t>(tag_bp.tag) < std::size(tag_names));
     return out << tag_names[static_cast<size_t>(tag_bp.tag)]
-               << (tag_bp.is_write ? "_WRITE" : "_READ");
+               << (tag_bp.type == bp_type_t::WRITE ? "_WRITE" : "_READ");
   }
 }
 

diff --git a/src/crimson/net/ProtocolV2.cc b/src/crimson/net/ProtocolV2.cc
index 41328b4f82c096f7201fd70997123aa2b1e648c2..7ec7607a7edbb3c2c4acbecf66911a07ceda57b2 100644 (file)
--- a/src/crimson/net/ProtocolV2.cc
+++ b/src/crimson/net/ProtocolV2.cc
@@ -317,7 +317,7 @@ seastar::future<Tag> ProtocolV2::read_main_preamble()
         rx_segments_desc.emplace_back(main_preamble.segments[idx]);
       }
 
-      INTERCEPT(static_cast<Tag>(main_preamble.tag), false);
+      INTERCEPT(static_cast<Tag>(main_preamble.tag), bp_type_t::READ);
       return static_cast<Tag>(main_preamble.tag);
     });
 }
@@ -400,7 +400,7 @@ seastar::future<> ProtocolV2::write_frame(F &frame, bool flush)
   logger().trace("{} SEND({}) frame: tag={}, num_segments={}, crc={}",
                  conn, bl.length(), (int)main_preamble->tag,
                  (int)main_preamble->num_segments, main_preamble->crc);
-  INTERCEPT(static_cast<Tag>(main_preamble->tag), true);
+  INTERCEPT(static_cast<Tag>(main_preamble->tag), bp_type_t::WRITE);
   if (flush) {
     return write_flush(std::move(bl));
   } else {
@@ -1766,19 +1766,19 @@ ceph::bufferlist ProtocolV2::do_sweep_messages(
   if (unlikely(require_keepalive)) {
     auto keepalive_frame = KeepAliveFrame::Encode();
     bl.append(keepalive_frame.get_buffer(session_stream_handlers));
-    INTERCEPT(ceph::msgr::v2::Tag::KEEPALIVE2, true);
+    INTERCEPT(ceph::msgr::v2::Tag::KEEPALIVE2, bp_type_t::WRITE);
   }
 
   if (unlikely(_keepalive_ack.has_value())) {
     auto keepalive_ack_frame = KeepAliveFrameAck::Encode(*_keepalive_ack);
     bl.append(keepalive_ack_frame.get_buffer(session_stream_handlers));
-    INTERCEPT(ceph::msgr::v2::Tag::KEEPALIVE2_ACK, true);
+    INTERCEPT(ceph::msgr::v2::Tag::KEEPALIVE2_ACK, bp_type_t::WRITE);
   }
 
   if (require_ack && !num_msgs) {
     auto ack_frame = AckFrame::Encode(conn.in_seq);
     bl.append(ack_frame.get_buffer(session_stream_handlers));
-    INTERCEPT(ceph::msgr::v2::Tag::ACK, true);
+    INTERCEPT(ceph::msgr::v2::Tag::ACK, bp_type_t::WRITE);
   }
 
   std::for_each(msgs.begin(), msgs.begin()+num_msgs, [this, &bl](const MessageRef& msg) {
@@ -1807,7 +1807,7 @@ ceph::bufferlist ProtocolV2::do_sweep_messages(
     logger().debug("{} --> #{} === {} ({})",
                   conn, msg->get_seq(), *msg, msg->get_type());
     bl.append(message.get_buffer(session_stream_handlers));
-    INTERCEPT(ceph::msgr::v2::Tag::MESSAGE, true);
+    INTERCEPT(ceph::msgr::v2::Tag::MESSAGE, bp_type_t::WRITE);
   });
 
   return bl;

diff --git a/src/test/crimson/test_messenger.cc b/src/test/crimson/test_messenger.cc
index 184d3e09c22f9f8377db0affe213da2d47f41a67..0f5fc24b4764e4d1d3b588abd814b37ca022d569 100644 (file)
--- a/src/test/crimson/test_messenger.cc
+++ b/src/test/crimson/test_messenger.cc
@@ -581,6 +581,7 @@ seastar::future<> test_preemptive_shutdown(bool v2) {
 }
 
 using ceph::msgr::v2::Tag;
+using ceph::net::bp_type_t;
 using ceph::net::Breakpoint;
 using ceph::net::Connection;
 using ceph::net::ConnectionRef;
@@ -821,15 +822,15 @@ struct TestInterceptor : public Interceptor {
 
     if (bp == custom_bp_t::SOCKET_CONNECTING) {
       ++result->connect_attempts;
-    } else if (bp == tag_bp_t{Tag::CLIENT_IDENT, true}) {
+    } else if (bp == tag_bp_t{Tag::CLIENT_IDENT, bp_type_t::WRITE}) {
       ++result->client_connect_attempts;
-    } else if (bp == tag_bp_t{Tag::SESSION_RECONNECT, true}) {
+    } else if (bp == tag_bp_t{Tag::SESSION_RECONNECT, bp_type_t::WRITE}) {
       ++result->client_reconnect_attempts;
     } else if (bp == custom_bp_t::SOCKET_ACCEPTED) {
       ++result->accept_attempts;
-    } else if (bp == tag_bp_t{Tag::CLIENT_IDENT, false}) {
+    } else if (bp == tag_bp_t{Tag::CLIENT_IDENT, bp_type_t::READ}) {
       ++result->server_connect_attempts;
-    } else if (bp == tag_bp_t{Tag::SESSION_RECONNECT, false}) {
+    } else if (bp == tag_bp_t{Tag::SESSION_RECONNECT, bp_type_t::READ}) {
       ++result->server_reconnect_attempts;
     }
 
@@ -1577,12 +1578,12 @@ test_v2_lossy_early_connect_fault(FailoverTest& test) {
       {custom_bp_t::BANNER_READ},
       {custom_bp_t::BANNER_PAYLOAD_READ},
       {custom_bp_t::SOCKET_CONNECTING},
-      {Tag::HELLO, true},
-      {Tag::HELLO, false},
-      {Tag::AUTH_REQUEST, true},
-      {Tag::AUTH_DONE, false},
-      {Tag::AUTH_SIGNATURE, true},
-      {Tag::AUTH_SIGNATURE, false},
+      {Tag::HELLO, bp_type_t::WRITE},
+      {Tag::HELLO, bp_type_t::READ},
+      {Tag::AUTH_REQUEST, bp_type_t::WRITE},
+      {Tag::AUTH_DONE, bp_type_t::READ},
+      {Tag::AUTH_SIGNATURE, bp_type_t::WRITE},
+      {Tag::AUTH_SIGNATURE, bp_type_t::READ},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -1613,8 +1614,8 @@ test_v2_lossy_early_connect_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_lossy_connect_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<Breakpoint>{
-      {Tag::CLIENT_IDENT, true},
-      {Tag::SERVER_IDENT, false},
+      {Tag::CLIENT_IDENT, bp_type_t::WRITE},
+      {Tag::SERVER_IDENT, bp_type_t::READ},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -1645,8 +1646,8 @@ test_v2_lossy_connect_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_lossy_connected_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<Breakpoint>{
-      {Tag::MESSAGE, true},
-      {Tag::MESSAGE, false},
+      {Tag::MESSAGE, bp_type_t::WRITE},
+      {Tag::MESSAGE, bp_type_t::READ},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -1680,12 +1681,12 @@ test_v2_lossy_early_accept_fault(FailoverTest& test) {
       {custom_bp_t::BANNER_WRITE},
       {custom_bp_t::BANNER_READ},
       {custom_bp_t::BANNER_PAYLOAD_READ},
-      {Tag::HELLO, true},
-      {Tag::HELLO, false},
-      {Tag::AUTH_REQUEST, false},
-      {Tag::AUTH_DONE, true},
-      {Tag::AUTH_SIGNATURE, true},
-      {Tag::AUTH_SIGNATURE, false},
+      {Tag::HELLO, bp_type_t::WRITE},
+      {Tag::HELLO, bp_type_t::READ},
+      {Tag::AUTH_REQUEST, bp_type_t::READ},
+      {Tag::AUTH_DONE, bp_type_t::WRITE},
+      {Tag::AUTH_SIGNATURE, bp_type_t::WRITE},
+      {Tag::AUTH_SIGNATURE, bp_type_t::READ},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -1720,8 +1721,8 @@ test_v2_lossy_early_accept_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_lossy_accept_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<Breakpoint>{
-      {Tag::CLIENT_IDENT, false},
-      {Tag::SERVER_IDENT, true},
+      {Tag::CLIENT_IDENT, bp_type_t::READ},
+      {Tag::SERVER_IDENT, bp_type_t::WRITE},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -1756,8 +1757,8 @@ test_v2_lossy_accept_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_lossy_accepted_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<Breakpoint>{
-      {Tag::MESSAGE, true},
-      {Tag::MESSAGE, false},
+      {Tag::MESSAGE, bp_type_t::WRITE},
+      {Tag::MESSAGE, bp_type_t::READ},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -1788,8 +1789,8 @@ test_v2_lossy_accepted_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_lossless_connect_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<Breakpoint>{
-      {Tag::CLIENT_IDENT, true},
-      {Tag::SERVER_IDENT, false},
+      {Tag::CLIENT_IDENT, bp_type_t::WRITE},
+      {Tag::SERVER_IDENT, bp_type_t::READ},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -1820,8 +1821,8 @@ test_v2_lossless_connect_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_lossless_connected_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<Breakpoint>{
-      {Tag::MESSAGE, true},
-      {Tag::MESSAGE, false},
+      {Tag::MESSAGE, bp_type_t::WRITE},
+      {Tag::MESSAGE, bp_type_t::READ},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -1852,8 +1853,10 @@ test_v2_lossless_connected_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_lossless_reconnect_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<std::pair<Breakpoint, Breakpoint>>{
-      {{Tag::MESSAGE, true}, {Tag::SESSION_RECONNECT, true}},
-      {{Tag::MESSAGE, true}, {Tag::SESSION_RECONNECT_OK, false}},
+      {{Tag::MESSAGE, bp_type_t::WRITE},
+       {Tag::SESSION_RECONNECT, bp_type_t::WRITE}},
+      {{Tag::MESSAGE, bp_type_t::WRITE},
+       {Tag::SESSION_RECONNECT_OK, bp_type_t::READ}},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp_pair) {
       TestInterceptor interceptor;
@@ -1886,8 +1889,8 @@ test_v2_lossless_reconnect_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_lossless_accept_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<Breakpoint>{
-      {Tag::CLIENT_IDENT, false},
-      {Tag::SERVER_IDENT, true},
+      {Tag::CLIENT_IDENT, bp_type_t::READ},
+      {Tag::SERVER_IDENT, bp_type_t::WRITE},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -1922,8 +1925,8 @@ test_v2_lossless_accept_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_lossless_accepted_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<Breakpoint>{
-      {Tag::MESSAGE, true},
-      {Tag::MESSAGE, false},
+      {Tag::MESSAGE, bp_type_t::WRITE},
+      {Tag::MESSAGE, bp_type_t::READ},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -1958,8 +1961,10 @@ test_v2_lossless_accepted_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_lossless_reaccept_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<std::pair<Breakpoint, Breakpoint>>{
-      {{Tag::MESSAGE, false}, {Tag::SESSION_RECONNECT, false}},
-      {{Tag::MESSAGE, false}, {Tag::SESSION_RECONNECT_OK, true}},
+      {{Tag::MESSAGE, bp_type_t::READ},
+       {Tag::SESSION_RECONNECT, bp_type_t::READ}},
+      {{Tag::MESSAGE, bp_type_t::READ},
+       {Tag::SESSION_RECONNECT_OK, bp_type_t::WRITE}},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp_pair) {
       TestInterceptor interceptor;
@@ -1983,7 +1988,7 @@ test_v2_lossless_reaccept_fault(FailoverTest& test) {
           results[0].assert_connect(0, 0, 0, 0);
           results[0].assert_accept(1, 1, 0, 1);
           results[0].assert_reset(0, 0);
-          if (bp == Breakpoint{Tag::SESSION_RECONNECT, false}) {
+          if (bp == Breakpoint{Tag::SESSION_RECONNECT, bp_type_t::READ}) {
             results[1].assert_state_at(conn_state_t::closed);
           } else {
             results[1].assert_state_at(conn_state_t::replaced);
@@ -2004,8 +2009,8 @@ test_v2_lossless_reaccept_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_peer_connect_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<Breakpoint>{
-      {Tag::CLIENT_IDENT, true},
-      {Tag::SERVER_IDENT, false},
+      {Tag::CLIENT_IDENT, bp_type_t::WRITE},
+      {Tag::SERVER_IDENT, bp_type_t::READ},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -2036,8 +2041,8 @@ test_v2_peer_connect_fault(FailoverTest& test) {
 seastar::future<>
 test_v2_peer_accept_fault(FailoverTest& test) {
   return seastar::do_with(std::vector<Breakpoint>{
-      {Tag::CLIENT_IDENT, false},
-      {Tag::SERVER_IDENT, true},
+      {Tag::CLIENT_IDENT, bp_type_t::READ},
+      {Tag::SERVER_IDENT, bp_type_t::WRITE},
   }, [&test] (auto& failure_cases) {
     return seastar::do_for_each(failure_cases, [&test] (auto bp) {
       TestInterceptor interceptor;
@@ -2071,7 +2076,7 @@ test_v2_peer_accept_fault(FailoverTest& test) {
 
 seastar::future<>
 test_v2_peer_connected_fault_reconnect(FailoverTest& test) {
-  auto bp = Breakpoint{Tag::MESSAGE, true};
+  auto bp = Breakpoint{Tag::MESSAGE, bp_type_t::WRITE};
   TestInterceptor interceptor;
   interceptor.make_fault(bp);
   return test.run_suite(
@@ -2097,7 +2102,7 @@ test_v2_peer_connected_fault_reconnect(FailoverTest& test) {
 
 seastar::future<>
 test_v2_peer_connected_fault_reaccept(FailoverTest& test) {
-  auto bp = Breakpoint{Tag::MESSAGE, false};
+  auto bp = Breakpoint{Tag::MESSAGE, bp_type_t::READ};
   TestInterceptor interceptor;
   interceptor.make_fault(bp);
   return test.run_suite(