messenger: remove unused variable

Signed-off-by: Changcheng Liu <changcheng.liu@aliyun.com>

diff --git a/src/ceph_mds.cc b/src/ceph_mds.cc
index 6e0327af85e850bb16f858a7e50a029863c6e93b..b5674befc861dbe3487d0c0461f9a3faa79c8aa5 100644 (file)
--- a/src/ceph_mds.cc
+++ b/src/ceph_mds.cc
@@ -166,8 +166,7 @@ int main(int argc, const char **argv)
   std::string public_msgr_type = g_conf()->ms_public_type.empty() ? g_conf().get_val<std::string>("ms_type") : g_conf()->ms_public_type;
   Messenger *msgr = Messenger::create(g_ceph_context, public_msgr_type,
                                      entity_name_t::MDS(-1), "mds",
-                                     Messenger::get_random_nonce(),
-                                     Messenger::HAS_MANY_CONNECTIONS);
+                                     Messenger::get_random_nonce());
   if (!msgr)
     forker.exit(1);
   msgr->set_cluster_protocol(CEPH_MDS_PROTOCOL);

diff --git a/src/ceph_mon.cc b/src/ceph_mon.cc
index ff2ad22efd35780415fefd66ca73f18d6cdc00b8..71c53d6dbca66810c493dc1235ea79522bfd93c2 100644 (file)
--- a/src/ceph_mon.cc
+++ b/src/ceph_mon.cc
@@ -790,9 +790,7 @@ int main(int argc, const char **argv)
   int rank = monmap.get_rank(g_conf()->name.get_id());
   std::string public_msgr_type = g_conf()->ms_public_type.empty() ? g_conf().get_val<std::string>("ms_type") : g_conf()->ms_public_type;
   Messenger *msgr = Messenger::create(g_ceph_context, public_msgr_type,
-                                     entity_name_t::MON(rank), "mon",
-                                     0,  // zero nonce
-                                     Messenger::HAS_MANY_CONNECTIONS);
+                                     entity_name_t::MON(rank), "mon", 0);
   if (!msgr)
     exit(1);
   msgr->set_cluster_protocol(CEPH_MON_PROTOCOL);
@@ -843,8 +841,7 @@ int main(int argc, const char **argv)
 
   Messenger *mgr_msgr = Messenger::create(g_ceph_context, public_msgr_type,
                                          entity_name_t::MON(rank), "mon-mgrc",
-                                         Messenger::get_pid_nonce(),
-                                         0);
+                                         Messenger::get_pid_nonce());
   if (!mgr_msgr) {
     derr << "unable to create mgr_msgr" << dendl;
     prefork.exit(1);

diff --git a/src/ceph_osd.cc b/src/ceph_osd.cc
index 0a1789626466b6c47220539890eb1ea49890a75c..c75abf838777e6c22cb125bcdac81d50d77c69b6 100644 (file)
--- a/src/ceph_osd.cc
+++ b/src/ceph_osd.cc
@@ -538,30 +538,19 @@ flushjournal_out:
   cluster_msg_type = cluster_msg_type.empty() ? msg_type : cluster_msg_type;
   uint64_t nonce = Messenger::get_pid_nonce();
   Messenger *ms_public = Messenger::create(g_ceph_context, public_msg_type,
-                                          entity_name_t::OSD(whoami), "client",
-                                          nonce,
-                                          Messenger::HAS_HEAVY_TRAFFIC |
-                                          Messenger::HAS_MANY_CONNECTIONS);
+                                          entity_name_t::OSD(whoami), "client", nonce);
   Messenger *ms_cluster = Messenger::create(g_ceph_context, cluster_msg_type,
-                                           entity_name_t::OSD(whoami), "cluster",
-                                           nonce,
-                                           Messenger::HAS_HEAVY_TRAFFIC |
-                                           Messenger::HAS_MANY_CONNECTIONS);
+                                           entity_name_t::OSD(whoami), "cluster", nonce);
   Messenger *ms_hb_back_client = Messenger::create(g_ceph_context, cluster_msg_type,
-                                            entity_name_t::OSD(whoami), "hb_back_client",
-                                            nonce, Messenger::HEARTBEAT);
+                                            entity_name_t::OSD(whoami), "hb_back_client", nonce);
   Messenger *ms_hb_front_client = Messenger::create(g_ceph_context, public_msg_type,
-                                            entity_name_t::OSD(whoami), "hb_front_client",
-                                            nonce, Messenger::HEARTBEAT);
+                                            entity_name_t::OSD(whoami), "hb_front_client", nonce);
   Messenger *ms_hb_back_server = Messenger::create(g_ceph_context, cluster_msg_type,
-                                                  entity_name_t::OSD(whoami), "hb_back_server",
-                                                  nonce, Messenger::HEARTBEAT);
+                                                  entity_name_t::OSD(whoami), "hb_back_server", nonce);
   Messenger *ms_hb_front_server = Messenger::create(g_ceph_context, public_msg_type,
-                                                   entity_name_t::OSD(whoami), "hb_front_server",
-                                                   nonce, Messenger::HEARTBEAT);
+                                                   entity_name_t::OSD(whoami), "hb_front_server", nonce);
   Messenger *ms_objecter = Messenger::create(g_ceph_context, public_msg_type,
-                                            entity_name_t::OSD(whoami), "ms_objecter",
-                                            nonce, 0);
+                                            entity_name_t::OSD(whoami), "ms_objecter", nonce);
   if (!ms_public || !ms_cluster || !ms_hb_front_client || !ms_hb_back_client || !ms_hb_back_server || !ms_hb_front_server || !ms_objecter)
     forker.exit(1);
   ms_cluster->set_cluster_protocol(CEPH_OSD_PROTOCOL);

diff --git a/src/mgr/DaemonServer.cc b/src/mgr/DaemonServer.cc
index 502496ab4564b6422ff4462d9637ecf1347816c4..87c293c924a18a7d591726f3a849c5f1d94e3a02 100644 (file)
--- a/src/mgr/DaemonServer.cc
+++ b/src/mgr/DaemonServer.cc
@@ -111,8 +111,7 @@ int DaemonServer::init(uint64_t gid, entity_addrvec_t client_addrs)
   msgr = Messenger::create(g_ceph_context, public_msgr_type,
                           entity_name_t::MGR(gid),
                           "mgr",
-                          Messenger::get_pid_nonce(),
-                          0);
+                          Messenger::get_pid_nonce());
   msgr->set_default_policy(Messenger::Policy::stateless_server(0));
 
   msgr->set_auth_client(monc);

diff --git a/src/mgr/MgrStandby.cc b/src/mgr/MgrStandby.cc
index 7a84c59061e78f4a0e68c73f26a567cdbe803dac..e72edd72d979d24a3ad2ba3f2f95cfe9713413cb 100644 (file)
--- a/src/mgr/MgrStandby.cc
+++ b/src/mgr/MgrStandby.cc
@@ -44,8 +44,7 @@ MgrStandby::MgrStandby(int argc, const char **argv) :
                     cct->_conf.get_val<std::string>("ms_type"),
                     entity_name_t::MGR(),
                     "mgr",
-                    Messenger::get_pid_nonce(),
-                    0)),
+                    Messenger::get_pid_nonce())),
   objecter{g_ceph_context, client_messenger.get(), &monc, poolctx, 0, 0},
   client{client_messenger.get(), &monc, &objecter},
   mgrc(g_ceph_context, client_messenger.get(), &monc.monmap),

diff --git a/src/msg/Messenger.cc b/src/msg/Messenger.cc
index 464ba394666d7377285ea4658d111bcd9f868f0b..8064a10a0d9b8d4b4fdbc217a8886c67f4616ea1 100644 (file)
--- a/src/msg/Messenger.cc
+++ b/src/msg/Messenger.cc
@@ -15,7 +15,7 @@ Messenger *Messenger::create_client_messenger(CephContext *cct, std::string lnam
   std::string public_msgr_type = cct->_conf->ms_public_type.empty() ? cct->_conf.get_val<std::string>("ms_type") : cct->_conf->ms_public_type;
   auto nonce = get_random_nonce();
   return Messenger::create(cct, public_msgr_type, entity_name_t::CLIENT(),
-                          std::move(lname), nonce, 0);
+                          std::move(lname), nonce);
 }
 
 uint64_t Messenger::get_pid_nonce()
@@ -35,7 +35,7 @@ uint64_t Messenger::get_random_nonce()
 
 Messenger *Messenger::create(CephContext *cct, const std::string &type,
                             entity_name_t name, std::string lname,
-                            uint64_t nonce, uint64_t cflags)
+                            uint64_t nonce)
 {
   int r = -1;
   if (type == "random") {

diff --git a/src/msg/Messenger.h b/src/msg/Messenger.h
index 46071f0ddd47968db1feb7a2bbc2f4cca3f993e3..a3836d3c1e2cba42976ac3bd7ef90efbb2f7dfed 100644 (file)
--- a/src/msg/Messenger.h
+++ b/src/msg/Messenger.h
@@ -117,14 +117,6 @@ public:
   Interceptor *interceptor = nullptr;
 #endif
 
-  /**
-   * Various Messenger conditional config/type flags to allow
-   * different "transport" Messengers to tune themselves
-   */
-  static const int HAS_HEAVY_TRAFFIC    = 0x0001;
-  static const int HAS_MANY_CONNECTIONS = 0x0002;
-  static const int HEARTBEAT            = 0x0004;
-
   /**
    *  The CephContext this Messenger uses. Many other components initialize themselves
    *  from this value.
@@ -165,14 +157,12 @@ public:
    * @param lname logical name of the messenger in this process (e.g., "client")
    * @param nonce nonce value to uniquely identify this instance on the current host
    * @param features bits for the local connection
-   * @param cflags general std::set of flags to configure transport resources
    */
   static Messenger *create(CephContext *cct,
                            const std::string &type,
                            entity_name_t name,
                           std::string lname,
-                           uint64_t nonce,
-                          uint64_t cflags);
+                           uint64_t nonce);
 
   static uint64_t get_random_nonce();
   static uint64_t get_pid_nonce();

diff --git a/src/test/crimson/test_async_echo.cc b/src/test/crimson/test_async_echo.cc
index c9a4e907308eff73fa6aaea3f8b8f17f0aff06a7..4f2d43d9d296c51962159247f9077839601cc3e5 100644 (file)
--- a/src/test/crimson/test_async_echo.cc
+++ b/src/test/crimson/test_async_echo.cc
@@ -24,8 +24,7 @@ struct Server {
   Server(CephContext* cct, const entity_inst_t& entity)
     : dummy_auth(cct), dispatcher(cct)
   {
-    msgr.reset(Messenger::create(cct, "async",
-                                 entity.name, "pong", entity.addr.get_nonce(), 0));
+    msgr.reset(Messenger::create(cct, "async", entity.name, "pong", entity.addr.get_nonce()));
     dummy_auth.auth_registry.refresh_config();
     msgr->set_cluster_protocol(CEPH_OSD_PROTOCOL);
     msgr->set_default_policy(Messenger::Policy::stateless_server(0));
@@ -84,9 +83,7 @@ struct Client {
   Client(CephContext *cct)
     : dummy_auth(cct), dispatcher(cct)
   {
-    msgr.reset(Messenger::create(cct, "async",
-                                 entity_name_t::CLIENT(-1), "ping",
-                                 getpid(), 0));
+    msgr.reset(Messenger::create(cct, "async", entity_name_t::CLIENT(-1), "ping", getpid()));
     dummy_auth.auth_registry.refresh_config();
     msgr->set_cluster_protocol(CEPH_OSD_PROTOCOL);
     msgr->set_default_policy(Messenger::Policy::lossy_client(0));

diff --git a/src/test/crimson/test_messenger_peer.cc b/src/test/crimson/test_messenger_peer.cc
index 17e693a3927853914e926dde2ec381a42d5cb0c3..7b669675ba3ac099e935eea997bc86d5dc8a88f1 100644 (file)
--- a/src/test/crimson/test_messenger_peer.cc
+++ b/src/test/crimson/test_messenger_peer.cc
@@ -105,7 +105,7 @@ class FailoverSuitePeer : public Dispatcher {
 
  private:
   void init(entity_addr_t test_peer_addr, SocketPolicy policy) {
-    peer_msgr.reset(Messenger::create(cct, "async", entity_name_t::OSD(4), "TestPeer", 4, 0));
+    peer_msgr.reset(Messenger::create(cct, "async", entity_name_t::OSD(4), "TestPeer", 4));
     dummy_auth.auth_registry.refresh_config();
     peer_msgr->set_cluster_protocol(CEPH_OSD_PROTOCOL);
     peer_msgr->set_default_policy(policy);
@@ -362,7 +362,7 @@ class FailoverTestPeer : public Dispatcher {
   }
 
   void init(entity_addr_t cmd_peer_addr) {
-    cmd_msgr.reset(Messenger::create(cct, "async", entity_name_t::OSD(3), "CmdSrv", 3, 0));
+    cmd_msgr.reset(Messenger::create(cct, "async", entity_name_t::OSD(3), "CmdSrv", 3));
     dummy_auth.auth_registry.refresh_config();
     cmd_msgr->set_cluster_protocol(CEPH_OSD_PROTOCOL);
     cmd_msgr->set_default_policy(Messenger::Policy::stateless_server(0));

diff --git a/src/test/fio/fio_ceph_messenger.cc b/src/test/fio/fio_ceph_messenger.cc
index 49c8e12e0c12e600b9196b2b30cd4d6b6485ea77..4a4cf4fb575125d88dba96815095d93e7f68500f 100644 (file)
--- a/src/test/fio/fio_ceph_messenger.cc
+++ b/src/test/fio/fio_ceph_messenger.cc
@@ -291,11 +291,6 @@ static Messenger *create_messenger(struct ceph_msgr_options *o)
   std::string lname = o->is_receiver ?
     "receiver" : "sender";
 
-  /* Does anybody really uses those flags in messenger? Seems not. */
-  unsigned flags = o->is_receiver ?
-    Messenger::HAS_HEAVY_TRAFFIC |
-    Messenger::HAS_MANY_CONNECTIONS : 0;
-
   std::string ms_type = o->ms_type != CEPH_MSGR_TYPE_UNDEF ?
     ceph_msgr_types[o->ms_type] :
     g_ceph_context->_conf.get_val<std::string>("ms_type");
@@ -303,7 +298,7 @@ static Messenger *create_messenger(struct ceph_msgr_options *o)
   /* o->td__>pid doesn't set value, so use getpid() instead*/
   auto nonce = o->is_receiver ? 0 : (getpid() + o->td__->thread_number);
   Messenger *msgr = Messenger::create(g_ceph_context, ms_type.c_str(),
-                                     ename, lname, nonce, flags);
+                                     ename, lname, nonce);
   if (o->is_receiver) {
     msgr->set_default_policy(Messenger::Policy::stateless_server(0));
     msgr->bind(hostname_to_addr(o));

diff --git a/src/test/mon/test-mon-msg.cc b/src/test/mon/test-mon-msg.cc
index 4c551cab8109e179acbd86e7895d4f697ba2aa4f..fede9df8f150ba2c3369407b6bb37bdfd902eaa0 100644 (file)
--- a/src/test/mon/test-mon-msg.cc
+++ b/src/test/mon/test-mon-msg.cc
@@ -84,7 +84,7 @@ public:
 
     std::string public_msgr_type = cct->_conf->ms_public_type.empty() ? cct->_conf.get_val<std::string>("ms_type") : cct->_conf->ms_public_type;
     msg = Messenger::create(cct, public_msgr_type, entity_name_t::CLIENT(-1),
-                            "test-mon-msg", 0, 0);
+                            "test-mon-msg", 0);
     ceph_assert(msg != NULL);
     msg->set_default_policy(Messenger::Policy::lossy_client(0));
     dout(0) << __func__ << " starting messenger at "

diff --git a/src/test/mon/test_mon_workloadgen.cc b/src/test/mon/test_mon_workloadgen.cc
index 613a18f247e175b4f648126d72a228b8a7dc9552..64f7bed5e97c2757f8edffae2e098ea2508758ce 100644 (file)
--- a/src/test/mon/test_mon_workloadgen.cc
+++ b/src/test/mon/test_mon_workloadgen.cc
@@ -362,7 +362,7 @@ class OSDStub : public TestStub
     ss << "client-osd" << whoami;
     std::string public_msgr_type = cct->_conf->ms_public_type.empty() ? cct->_conf.get_val<std::string>("ms_type") : cct->_conf->ms_public_type;
     messenger.reset(Messenger::create(cct, public_msgr_type, entity_name_t::OSD(whoami),
-                                     ss.str().c_str(), getpid(), 0));
+                                     ss.str().c_str(), getpid()));
 
     Throttle throttler(g_ceph_context, "osd_client_bytes",
        g_conf()->osd_client_message_size_cap);

diff --git a/src/test/msgr/perf_msgr_client.cc b/src/test/msgr/perf_msgr_client.cc
index cb342755678dcd7037837c8d0446262b4a798a9f..0e5c5ab367f29353c95f4019da3319b3262b8fb5 100644 (file)
--- a/src/test/msgr/perf_msgr_client.cc
+++ b/src/test/msgr/perf_msgr_client.cc
@@ -136,7 +136,7 @@ class MessengerClient {
     addr.set_nonce(0);
     dummy_auth.auth_registry.refresh_config();
     for (int i = 0; i < jobs; ++i) {
-      Messenger *msgr = Messenger::create(g_ceph_context, type, entity_name_t::CLIENT(0), "client", getpid()+i, 0);
+      Messenger *msgr = Messenger::create(g_ceph_context, type, entity_name_t::CLIENT(0), "client", getpid()+i);
       msgr->set_default_policy(Messenger::Policy::lossless_client(0));
       msgr->set_auth_client(&dummy_auth);
       msgr->start();

diff --git a/src/test/msgr/perf_msgr_server.cc b/src/test/msgr/perf_msgr_server.cc
index 4a8e182fc1c08ff26a928ef47f68d0d0b3078c20..f17f90f6d081a6c1c0086c2e4728a249509eefa2 100644 (file)
--- a/src/test/msgr/perf_msgr_server.cc
+++ b/src/test/msgr/perf_msgr_server.cc
@@ -116,7 +116,7 @@ class MessengerServer {
   MessengerServer(const string &t, const string &addr, int threads, int delay):
       msgr(NULL), type(t), bindaddr(addr), dispatcher(threads, delay),
       dummy_auth(g_ceph_context) {
-    msgr = Messenger::create(g_ceph_context, type, entity_name_t::OSD(0), "server", 0, 0);
+    msgr = Messenger::create(g_ceph_context, type, entity_name_t::OSD(0), "server", 0);
     msgr->set_default_policy(Messenger::Policy::stateless_server(0));
     dummy_auth.auth_registry.refresh_config();
       msgr->set_auth_server(&dummy_auth);

diff --git a/src/test/msgr/test_msgr.cc b/src/test/msgr/test_msgr.cc
index 4ddcafabeb5cb7ceacbb39dd1fd24932f550a8f1..3ebe320be1191274eb6cb7de849204d479efbf82 100644 (file)
--- a/src/test/msgr/test_msgr.cc
+++ b/src/test/msgr/test_msgr.cc
@@ -71,8 +71,8 @@ class MessengerTest : public ::testing::TestWithParam<const char*> {
   }
   void SetUp() override {
     lderr(g_ceph_context) << __func__ << " start set up " << GetParam() << dendl;
-    server_msgr = Messenger::create(g_ceph_context, string(GetParam()), entity_name_t::OSD(0), "server", getpid(), 0);
-    client_msgr = Messenger::create(g_ceph_context, string(GetParam()), entity_name_t::CLIENT(-1), "client", getpid(), 0);
+    server_msgr = Messenger::create(g_ceph_context, string(GetParam()), entity_name_t::OSD(0), "server", getpid());
+    client_msgr = Messenger::create(g_ceph_context, string(GetParam()), entity_name_t::CLIENT(-1), "client", getpid());
     server_msgr->set_default_policy(Messenger::Policy::stateless_server(0));
     client_msgr->set_default_policy(Messenger::Policy::lossy_client(0));
     server_msgr->set_auth_client(&dummy_auth);
@@ -1787,7 +1787,7 @@ class SyntheticWorkload {
     char addr[64];
     for (int i = 0; i < servers; ++i) {
       msgr = Messenger::create(g_ceph_context, type, entity_name_t::OSD(0),
-                               "server", getpid()+i, 0);
+                               "server", getpid()+i);
       snprintf(addr, sizeof(addr), "v2:127.0.0.1:%d",
               base_port+i);
       bind_addr.parse(addr);
@@ -1804,7 +1804,7 @@ class SyntheticWorkload {
 
     for (int i = 0; i < clients; ++i) {
       msgr = Messenger::create(g_ceph_context, type, entity_name_t::CLIENT(-1),
-                               "client", getpid()+i+servers, 0);
+                               "client", getpid()+i+servers);
       if (cli_policy.standby) {
         snprintf(addr, sizeof(addr), "v2:127.0.0.1:%d",
                 base_port+i+servers);
@@ -2270,7 +2270,7 @@ class MarkdownDispatcher : public Dispatcher {
 
 // Markdown with external lock
 TEST_P(MessengerTest, MarkdownTest) {
-  Messenger *server_msgr2 = Messenger::create(g_ceph_context, string(GetParam()), entity_name_t::OSD(0), "server", getpid(), 0);
+  Messenger *server_msgr2 = Messenger::create(g_ceph_context, string(GetParam()), entity_name_t::OSD(0), "server", getpid());
   MarkdownDispatcher cli_dispatcher(false), srv_dispatcher(true);
   DummyAuthClientServer dummy_auth(g_ceph_context);
   dummy_auth.auth_registry.refresh_config();

diff --git a/src/test/osd/TestOSDScrub.cc b/src/test/osd/TestOSDScrub.cc
index b61a83dde08bba1cbb83f2c07ff08ac5f7817d61..4e37c474d37e3edeac0b4dcce2998587394c141e 100644 (file)
--- a/src/test/osd/TestOSDScrub.cc
+++ b/src/test/osd/TestOSDScrub.cc
@@ -62,7 +62,7 @@ TEST(TestOSDScrub, scrub_time_permit) {
   std::string cluster_msgr_type = g_conf()->ms_cluster_type.empty() ? g_conf().get_val<std::string>("ms_type") : g_conf()->ms_cluster_type;
   Messenger *ms = Messenger::create(g_ceph_context, cluster_msgr_type,
                                    entity_name_t::OSD(0), "make_checker",
-                                   getpid(), 0);
+                                   getpid());
   ms->set_cluster_protocol(CEPH_OSD_PROTOCOL);
   ms->set_default_policy(Messenger::Policy::stateless_server(0));
   ms->bind(g_conf()->public_addr);

diff --git a/src/tools/crimson/perf_async_msgr.cc b/src/tools/crimson/perf_async_msgr.cc
index 77ffcee0a119be182385d16b48461f46d504a4f4..25d1d410e4931ea5974aa296da9507c1f7a09927 100644 (file)
--- a/src/tools/crimson/perf_async_msgr.cc
+++ b/src/tools/crimson/perf_async_msgr.cc
@@ -19,7 +19,7 @@ struct Server {
   Server(CephContext* cct, unsigned msg_len)
     : dummy_auth(cct), dispatcher(cct, msg_len)
   {
-    msgr.reset(Messenger::create(cct, "async", entity_name_t::OSD(0), "server", 0, 0));
+    msgr.reset(Messenger::create(cct, "async", entity_name_t::OSD(0), "server", 0));
     dummy_auth.auth_registry.refresh_config();
     msgr->set_cluster_protocol(CEPH_OSD_PROTOCOL);
     msgr->set_default_policy(Messenger::Policy::stateless_server(0));