crimson/test: implement get_server_addr()

So we can distinguish which messenger test is still pending when we have
bind failure.

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

diff --git a/src/test/crimson/test_messenger.cc b/src/test/crimson/test_messenger.cc
index 0aac58a2a9080116f30469e5a1f04f3e0722b46d..d5699f97526867b5b846e385ba8e2a58f14c7aad 100644 (file)
--- a/src/test/crimson/test_messenger.cc
+++ b/src/test/crimson/test_messenger.cc
@@ -38,6 +38,15 @@ static std::random_device rd;
 static std::default_random_engine rng{rd()};
 static bool verbose = false;
 
+static entity_addr_t get_server_addr() {
+  static int port = 9030;
+  ++port;
+  entity_addr_t saddr;
+  saddr.parse("127.0.0.1", nullptr);
+  saddr.set_port(port);
+  return saddr;
+}
+
 static seastar::future<> test_echo(unsigned rounds,
                                    double keepalive_ratio,
                                    bool v2)
@@ -217,10 +226,8 @@ static seastar::future<> test_echo(unsigned rounds,
   auto client1 = seastar::make_shared<test_state::Client>(rounds, keepalive_ratio);
   auto client2 = seastar::make_shared<test_state::Client>(rounds, keepalive_ratio);
   // start servers and clients
-  entity_addr_t addr1;
-  addr1.parse("127.0.0.1:9010", nullptr);
-  entity_addr_t addr2;
-  addr2.parse("127.0.0.1:9011", nullptr);
+  auto addr1 = get_server_addr();
+  auto addr2 = get_server_addr();
   if (v2) {
     addr1.set_type(entity_addr_t::TYPE_MSGR2);
     addr2.set_type(entity_addr_t::TYPE_MSGR2);
@@ -332,8 +339,7 @@ static seastar::future<> test_concurrent_dispatch(bool v2)
   logger().info("test_concurrent_dispatch(v2={}):", v2);
   auto server = seastar::make_shared<test_state::Server>();
   auto client = seastar::make_shared<test_state::Client>();
-  entity_addr_t addr;
-  addr.parse("127.0.0.1:9010", nullptr);
+  auto addr = get_server_addr();
   if (v2) {
     addr.set_type(entity_addr_t::TYPE_MSGR2);
   } else {
@@ -455,8 +461,7 @@ seastar::future<> test_preemptive_shutdown(bool v2) {
   logger().info("test_preemptive_shutdown(v2={}):", v2);
   auto server = seastar::make_shared<test_state::Server>();
   auto client = seastar::make_shared<test_state::Client>();
-  entity_addr_t addr;
-  addr.parse("127.0.0.1:9010", nullptr);
+  auto addr = get_server_addr();
   if (v2) {
     addr.set_type(entity_addr_t::TYPE_MSGR2);
   } else {

diff --git a/src/test/crimson/test_socket.cc b/src/test/crimson/test_socket.cc
index f3485920f4e0c3376b2e24f6abe39d60f886706b..bfdeeea2a787fd4c9c547aad425cff02b88ff246 100644 (file)
--- a/src/test/crimson/test_socket.cc
+++ b/src/test/crimson/test_socket.cc
@@ -26,15 +26,19 @@ using crimson::net::stop_t;
 using SocketFRef = seastar::foreign_ptr<SocketRef>;
 
 static seastar::logger logger{"crimsontest"};
-static entity_addr_t server_addr = [] {
+static entity_addr_t get_server_addr() {
+  static int port = 9020;
+  ++port;
+  ceph_assert(port < 9030 && "socket and messenger test ports should not overlap");
   entity_addr_t saddr;
-  saddr.parse("127.0.0.1:9020", nullptr);
+  saddr.parse("127.0.0.1", nullptr);
+  saddr.set_port(port);
   return saddr;
-} ();
+}
 
-future<SocketRef> socket_connect() {
-  logger.debug("socket_connect()...");
-  return Socket::connect(server_addr).then([] (auto socket) {
+future<SocketRef> socket_connect(const entity_addr_t& saddr) {
+  logger.debug("socket_connect() to {} ...", saddr);
+  return Socket::connect(saddr).then([] (auto socket) {
     logger.debug("socket_connect() connected");
     return socket;
   });
@@ -42,8 +46,9 @@ future<SocketRef> socket_connect() {
 
 future<> test_refused() {
   logger.info("test_refused()...");
-  return socket_connect().discard_result().then([] {
-    logger.error("test_refused(): connection to {} is not refused", server_addr);
+  auto saddr = get_server_addr();
+  return socket_connect(saddr).discard_result().then([saddr] {
+    logger.error("test_refused(): connection to {} is not refused", saddr);
     ceph_abort();
   }).handle_exception_type([] (const std::system_error& e) {
     if (e.code() != std::errc::connection_refused) {
@@ -61,10 +66,11 @@ future<> test_refused() {
 future<> test_bind_same() {
   logger.info("test_bind_same()...");
   return FixedCPUServerSocket::create().then([] (auto pss1) {
-    return pss1->listen(server_addr).safe_then([] {
+    auto saddr = get_server_addr();
+    return pss1->listen(saddr).safe_then([saddr] {
       // try to bind the same address
-      return FixedCPUServerSocket::create().then([] (auto pss2) {
-        return pss2->listen(server_addr).safe_then([] {
+      return FixedCPUServerSocket::create().then([saddr] (auto pss2) {
+        return pss2->listen(saddr).safe_then([] {
           logger.error("test_bind_same() should raise address_in_use");
           ceph_abort();
         }, FixedCPUServerSocket::listen_ertr::all_same_way(
@@ -84,9 +90,9 @@ future<> test_bind_same() {
         });
       });
     }, FixedCPUServerSocket::listen_ertr::all_same_way(
-        [] (const std::error_code& e) {
+        [saddr] (const std::error_code& e) {
       logger.error("test_bind_same(): there is another instance running at {}",
-                   server_addr);
+                   saddr);
       ceph_abort();
     })).then([pss1] {
       return pss1->destroy();
@@ -100,7 +106,8 @@ future<> test_bind_same() {
 future<> test_accept() {
   logger.info("test_accept()");
   return FixedCPUServerSocket::create().then([] (auto pss) {
-    return pss->listen(server_addr).safe_then([pss] {
+    auto saddr = get_server_addr();
+    return pss->listen(saddr).safe_then([pss] {
       return pss->accept([] (auto socket, auto paddr) {
         // simple accept
         return seastar::sleep(100ms).then([socket = std::move(socket)] () mutable {
@@ -108,17 +115,17 @@ future<> test_accept() {
         });
       });
     }, FixedCPUServerSocket::listen_ertr::all_same_way(
-        [] (const std::error_code& e) {
+        [saddr] (const std::error_code& e) {
       logger.error("test_accept(): there is another instance running at {}",
-                   server_addr);
+                   saddr);
       ceph_abort();
-    })).then([] {
+    })).then([saddr] {
       return seastar::when_all(
-        socket_connect().then([] (auto socket) {
+        socket_connect(saddr).then([] (auto socket) {
           return socket->close().finally([cleanup = std::move(socket)] {}); }),
-        socket_connect().then([] (auto socket) {
+        socket_connect(saddr).then([] (auto socket) {
           return socket->close().finally([cleanup = std::move(socket)] {}); }),
-        socket_connect().then([] (auto socket) {
+        socket_connect(saddr).then([] (auto socket) {
           return socket->close().finally([cleanup = std::move(socket)] {}); })
       ).discard_result();
     }).then([] {
@@ -148,21 +155,22 @@ class SocketFactory {
     assert(seastar::this_shard_id() == 0u);
     auto owner = std::make_unique<SocketFactory>();
     auto psf = owner.get();
-    return seastar::smp::submit_to(1u, [psf] {
-      return FixedCPUServerSocket::create().then([psf] (auto pss) {
+    auto saddr = get_server_addr();
+    return seastar::smp::submit_to(1u, [psf, saddr] {
+      return FixedCPUServerSocket::create().then([psf, saddr] (auto pss) {
         psf->pss = pss;
-        return pss->listen(server_addr
+        return pss->listen(saddr
         ).safe_then([]{}, FixedCPUServerSocket::listen_ertr::all_same_way(
-            [] (const std::error_code& e) {
+            [saddr] (const std::error_code& e) {
           logger.error("dispatch_sockets(): there is another instance running at {}",
-                       server_addr);
+                       saddr);
           ceph_abort();
         }));
       });
-    }).then([psf] {
+    }).then([psf, saddr] {
       return seastar::when_all_succeed(
-        seastar::smp::submit_to(0u, [psf] {
-          return socket_connect().then([psf] (auto socket) {
+        seastar::smp::submit_to(0u, [psf, saddr] {
+          return socket_connect(saddr).then([psf] (auto socket) {
             psf->client_socket = std::move(socket);
           });
         }),