import quincy beta 17.1.0

[ceph.git] / ceph / src / mds / MDSTableServer.cc

diff --git a/ceph/src/mds/MDSTableServer.cc b/ceph/src/mds/MDSTableServer.cc
index cd7724f5e0317585553206d7597375dc8ccfa043..6e542b4e396560091342fc64cb48689ab55636b8 100644 (file)
--- a/ceph/src/mds/MDSTableServer.cc
+++ b/ceph/src/mds/MDSTableServer.cc
@@ -24,7 +24,9 @@
 #undef dout_prefix
 #define dout_prefix *_dout << "mds." << rank << ".tableserver(" << get_mdstable_name(table) << ") "
 
-void MDSTableServer::handle_request(const MMDSTableRequest::const_ref &req)
+using namespace std;
+
+void MDSTableServer::handle_request(const cref_t<MMDSTableRequest> &req)
 {
   ceph_assert(req->op >= 0);
   switch (req->op) {
@@ -39,19 +41,19 @@ void MDSTableServer::handle_request(const MMDSTableRequest::const_ref &req)
 
 class C_Prepare : public MDSLogContextBase {
   MDSTableServer *server;
-  MMDSTableRequest::const_ref req;
+  cref_t<MMDSTableRequest> req;
   version_t tid;
   MDSRank *get_mds() override { return server->mds; }
 public:
 
-  C_Prepare(MDSTableServer *s, const MMDSTableRequest::const_ref r, version_t v) : server(s), req(r), tid(v) {}
+  C_Prepare(MDSTableServer *s, const cref_t<MMDSTableRequest> r, version_t v) : server(s), req(r), tid(v) {}
   void finish(int r) override {
     server->_prepare_logged(req, tid);
   }
 };
 
 // prepare
-void MDSTableServer::handle_prepare(const MMDSTableRequest::const_ref &req)
+void MDSTableServer::handle_prepare(const cref_t<MMDSTableRequest> &req)
 {
   dout(7) << "handle_prepare " << *req << dendl;
   mds_rank_t from = mds_rank_t(req->get_source().num());
@@ -68,7 +70,7 @@ void MDSTableServer::handle_prepare(const MMDSTableRequest::const_ref &req)
   mds->mdlog->flush();
 }
 
-void MDSTableServer::_prepare_logged(const MMDSTableRequest::const_ref &req, version_t tid)
+void MDSTableServer::_prepare_logged(const cref_t<MMDSTableRequest> &req, version_t tid)
 {
   dout(7) << "_create_logged " << *req << " tid " << tid << dendl;
   mds_rank_t from = mds_rank_t(req->get_source().num());
@@ -80,7 +82,7 @@ void MDSTableServer::_prepare_logged(const MMDSTableRequest::const_ref &req, ver
   _prepare(req->bl, req->reqid, from, out);
   ceph_assert(version == tid);
 
-  auto reply = MMDSTableRequest::create(table, TABLESERVER_OP_AGREE, req->reqid, tid);
+  auto reply = make_message<MMDSTableRequest>(table, TABLESERVER_OP_AGREE, req->reqid, tid);
   reply->bl = std::move(out);
 
   if (_notify_prep(tid)) {
@@ -93,7 +95,7 @@ void MDSTableServer::_prepare_logged(const MMDSTableRequest::const_ref &req, ver
   }
 }
 
-void MDSTableServer::handle_notify_ack(const MMDSTableRequest::const_ref &m)
+void MDSTableServer::handle_notify_ack(const cref_t<MMDSTableRequest> &m)
 {
   dout(7) << __func__ << " " << *m << dendl;
   mds_rank_t from = mds_rank_t(m->get_source().num());
@@ -118,17 +120,17 @@ void MDSTableServer::handle_notify_ack(const MMDSTableRequest::const_ref &m)
 
 class C_Commit : public MDSLogContextBase {
   MDSTableServer *server;
-  MMDSTableRequest::const_ref req;
+  cref_t<MMDSTableRequest> req;
   MDSRank *get_mds() override { return server->mds; }
 public:
-  C_Commit(MDSTableServer *s, const MMDSTableRequest::const_ref &r) : server(s), req(r) {}
+  C_Commit(MDSTableServer *s, const cref_t<MMDSTableRequest> &r) : server(s), req(r) {}
   void finish(int r) override {
     server->_commit_logged(req);
   }
 };
 
 // commit
-void MDSTableServer::handle_commit(const MMDSTableRequest::const_ref &req)
+void MDSTableServer::handle_commit(const cref_t<MMDSTableRequest> &req)
 {
   dout(7) << "handle_commit " << *req << dendl;
 
@@ -153,7 +155,7 @@ void MDSTableServer::handle_commit(const MMDSTableRequest::const_ref &req)
   else if (tid <= version) {
     dout(0) << "got commit for tid " << tid << " <= " << version
            << ", already committed, sending ack." << dendl;
-    auto reply = MMDSTableRequest::create(table, TABLESERVER_OP_ACK, req->reqid, tid);
+    auto reply = make_message<MMDSTableRequest>(table, TABLESERVER_OP_ACK, req->reqid, tid);
     mds->send_message(reply, req->get_connection());
   } 
   else {
@@ -163,7 +165,7 @@ void MDSTableServer::handle_commit(const MMDSTableRequest::const_ref &req)
   }
 }
 
-void MDSTableServer::_commit_logged(const MMDSTableRequest::const_ref &req)
+void MDSTableServer::_commit_logged(const cref_t<MMDSTableRequest> &req)
 {
   dout(7) << "_commit_logged, sending ACK" << dendl;
 
@@ -176,23 +178,23 @@ void MDSTableServer::_commit_logged(const MMDSTableRequest::const_ref &req)
   _commit(tid, req);
   _note_commit(tid);
 
-  auto reply = MMDSTableRequest::create(table, TABLESERVER_OP_ACK, req->reqid, req->get_tid());
+  auto reply = make_message<MMDSTableRequest>(table, TABLESERVER_OP_ACK, req->reqid, req->get_tid());
   mds->send_message_mds(reply, mds_rank_t(req->get_source().num()));
 }
 
 class C_Rollback : public MDSLogContextBase {
   MDSTableServer *server;
-  MMDSTableRequest::const_ref req;
+  cref_t<MMDSTableRequest> req;
   MDSRank *get_mds() override { return server->mds; }
 public:
-  C_Rollback(MDSTableServer *s, const MMDSTableRequest::const_ref &r) : server(s), req(r) {}
+  C_Rollback(MDSTableServer *s, const cref_t<MMDSTableRequest> &r) : server(s), req(r) {}
   void finish(int r) override {
     server->_rollback_logged(req);
   }
 };
 
 // ROLLBACK
-void MDSTableServer::handle_rollback(const MMDSTableRequest::const_ref &req)
+void MDSTableServer::handle_rollback(const cref_t<MMDSTableRequest> &req)
 {
   dout(7) << "handle_rollback " << *req << dendl;
 
@@ -209,7 +211,7 @@ void MDSTableServer::handle_rollback(const MMDSTableRequest::const_ref &req)
                                 new C_Rollback(this, req));
 }
 
-void MDSTableServer::_rollback_logged(const MMDSTableRequest::const_ref &req)
+void MDSTableServer::_rollback_logged(const cref_t<MMDSTableRequest> &req)
 {
   dout(7) << "_rollback_logged " << *req << dendl;
 
@@ -281,13 +283,13 @@ void MDSTableServer::_do_server_recovery()
       next_reqids[who] = p.second.reqid + 1;
 
     version_t tid = p.second.tid;
-    auto reply = MMDSTableRequest::create(table, TABLESERVER_OP_AGREE, p.second.reqid, tid);
+    auto reply = make_message<MMDSTableRequest>(table, TABLESERVER_OP_AGREE, p.second.reqid, tid);
     _get_reply_buffer(tid, &reply->bl);
     mds->send_message_mds(reply, who);
   }
 
   for (auto p : active_clients) {
-    auto reply = MMDSTableRequest::create(table, TABLESERVER_OP_SERVER_READY, next_reqids[p]);
+    auto reply = make_message<MMDSTableRequest>(table, TABLESERVER_OP_SERVER_READY, next_reqids[p]);
     mds->send_message_mds(reply, p);
   }
   recovered = true;
@@ -331,12 +333,12 @@ void MDSTableServer::handle_mds_recovery(mds_rank_t who)
     if (p->second.reqid >= next_reqid)
       next_reqid = p->second.reqid + 1;
 
-    auto reply = MMDSTableRequest::create(table, TABLESERVER_OP_AGREE, p->second.reqid, p->second.tid);
+    auto reply = make_message<MMDSTableRequest>(table, TABLESERVER_OP_AGREE, p->second.reqid, p->second.tid);
     _get_reply_buffer(p->second.tid, &reply->bl);
     mds->send_message_mds(reply, who);
   }
 
-  auto reply = MMDSTableRequest::create(table, TABLESERVER_OP_SERVER_READY, next_reqid);
+  auto reply = make_message<MMDSTableRequest>(table, TABLESERVER_OP_SERVER_READY, next_reqid);
   mds->send_message_mds(reply, who);
 }
 
@@ -346,7 +348,7 @@ void MDSTableServer::handle_mds_failure_or_stop(mds_rank_t who)
 
   active_clients.erase(who);
 
-  list<MMDSTableRequest::ref> rollback;
+  list<ref_t<MMDSTableRequest>> rollback;
   for (auto p = pending_notifies.begin(); p != pending_notifies.end(); ) {
     auto q = p++;
     if (q->second.mds == who) {