cls_lock_client: change modified reference parameters to pointers

This makes it clear which parameters are modified,
as our style guide states.

Signed-off-by: Josh Durgin <josh.durgin@inktank.com>

diff --git a/src/cls/lock/cls_lock_client.cc b/src/cls/lock/cls_lock_client.cc
index 52a41f8abac74a3f7397c86586a9605c4e0cba58..c7893afce2bba50fa735d331b9987b5c20c34939 100644 (file)
--- a/src/cls/lock/cls_lock_client.cc
+++ b/src/cls/lock/cls_lock_client.cc
@@ -32,7 +32,7 @@ namespace rados {
   namespace cls {
     namespace lock {
 
-      void lock(ObjectWriteOperation& rados_op,
+      void lock(ObjectWriteOperation *rados_op,
                 const string& name, ClsLockType type,
                 const string& cookie, const string& tag,
                 const string& description,
@@ -48,10 +48,10 @@ namespace rados {
         op.flags = flags;
         bufferlist in;
         ::encode(op, in);
-        rados_op.exec("lock", "lock", in);
+        rados_op->exec("lock", "lock", in);
       }
 
-      int lock(IoCtx& ioctx,
+      int lock(IoCtx *ioctx,
                const string& oid,
                const string& name, ClsLockType type,
                const string& cookie, const string& tag,
@@ -59,11 +59,11 @@ namespace rados {
               uint8_t flags)
       {
         ObjectWriteOperation op;
-        lock(op, name, type, cookie, tag, description, duration, flags);
-        return ioctx.operate(oid, &op);
+        lock(&op, name, type, cookie, tag, description, duration, flags);
+        return ioctx->operate(oid, &op);
       }
 
-      void unlock(ObjectWriteOperation& rados_op,
+      void unlock(ObjectWriteOperation *rados_op,
                   const string& name, const string& cookie)
       {
         cls_lock_unlock_op op;
@@ -72,18 +72,18 @@ namespace rados {
         bufferlist in;
         ::encode(op, in);
 
-        rados_op.exec("lock", "unlock", in);
+        rados_op->exec("lock", "unlock", in);
       }
 
-      int unlock(IoCtx& ioctx, const string& oid,
+      int unlock(IoCtx *ioctx, const string& oid,
                  const string& name, const string& cookie)
       {
         ObjectWriteOperation op;
-        unlock(op, name, cookie);
-        return ioctx.operate(oid, &op);
+        unlock(&op, name, cookie);
+        return ioctx->operate(oid, &op);
       }
 
-      void break_lock(ObjectWriteOperation& rados_op,
+      void break_lock(ObjectWriteOperation *rados_op,
                       const string& name, const string& cookie,
                       const entity_name_t& locker)
       {
@@ -93,22 +93,22 @@ namespace rados {
         op.locker = locker;
         bufferlist in;
         ::encode(op, in);
-        rados_op.exec("lock", "break_lock", in);
+        rados_op->exec("lock", "break_lock", in);
       }
 
-      int break_lock(IoCtx& ioctx, const string& oid,
+      int break_lock(IoCtx *ioctx, const string& oid,
                      const string& name, const string& cookie,
                      const entity_name_t& locker)
       {
         ObjectWriteOperation op;
-        break_lock(op, name, cookie, locker);
-        return ioctx.operate(oid, &op);
+        break_lock(&op, name, cookie, locker);
+        return ioctx->operate(oid, &op);
       }
 
-      int list_locks(IoCtx& ioctx, const string& oid, list<string> *locks)
+      int list_locks(IoCtx *ioctx, const string& oid, list<string> *locks)
       {
         bufferlist in, out;
-        int r = ioctx.exec(oid, "lock", "list_locks", in, out);
+        int r = ioctx->exec(oid, "lock", "list_locks", in, out);
         if (r < 0)
           return r;
 
@@ -125,7 +125,7 @@ namespace rados {
         return 0;
       }
 
-      int get_lock_info(IoCtx& ioctx, const string& oid, const string& lock,
+      int get_lock_info(IoCtx *ioctx, const string& oid, const string& lock,
                         map<locker_id_t, locker_info_t> *lockers,
                         ClsLockType *lock_type,
                         string *tag)
@@ -134,7 +134,7 @@ namespace rados {
         cls_lock_get_info_op op;
         op.name = lock;
         ::encode(op, in);
-        int r = ioctx.exec(oid, "lock", "get_info", in, out);
+        int r = ioctx->exec(oid, "lock", "get_info", in, out);
         if (r < 0)
           return r;
 
@@ -161,46 +161,46 @@ namespace rados {
         return 0;
       }
 
-      void Lock::lock_shared(ObjectWriteOperation& op)
+      void Lock::lock_shared(ObjectWriteOperation *op)
       {
         lock(op, name, LOCK_SHARED,
              cookie, tag, description, duration, flags);
       }
 
-      int Lock::lock_shared(IoCtx& ioctx, const string& oid)
+      int Lock::lock_shared(IoCtx *ioctx, const string& oid)
       {
         return lock(ioctx, oid, name, LOCK_SHARED,
                     cookie, tag, description, duration, flags);
       }
 
-      void Lock::lock_exclusive(ObjectWriteOperation& op)
+      void Lock::lock_exclusive(ObjectWriteOperation *op)
       {
         lock(op, name, LOCK_EXCLUSIVE,
              cookie, tag, description, duration, flags);
       }
 
-      int Lock::lock_exclusive(IoCtx& ioctx, const string& oid)
+      int Lock::lock_exclusive(IoCtx *ioctx, const string& oid)
       {
         return lock(ioctx, oid, name, LOCK_EXCLUSIVE,
                     cookie, tag, description, duration, flags);
       }
 
-      void Lock::unlock(ObjectWriteOperation& op)
+      void Lock::unlock(ObjectWriteOperation *op)
       {
        rados::cls::lock::unlock(op, name, cookie);
       }
 
-      int Lock::unlock(IoCtx& ioctx, const string& oid)
+      int Lock::unlock(IoCtx *ioctx, const string& oid)
       {
         return rados::cls::lock::unlock(ioctx, oid, name, cookie);
       }
 
-      void Lock::break_lock(ObjectWriteOperation& op, const entity_name_t& locker)
+      void Lock::break_lock(ObjectWriteOperation *op, const entity_name_t& locker)
       {
        rados::cls::lock::break_lock(op, name, cookie, locker);
       }
 
-      int Lock::break_lock(IoCtx& ioctx, const string& oid, const entity_name_t& locker)
+      int Lock::break_lock(IoCtx *ioctx, const string& oid, const entity_name_t& locker)
       {
           return rados::cls::lock::break_lock(ioctx, oid, name, cookie, locker);
       }

diff --git a/src/cls/lock/cls_lock_client.h b/src/cls/lock/cls_lock_client.h
index 29f7a927369dfc6fa3d4ae1315d8afd520483c3e..760f9178d4fcba1531f428bd866f612a797d3b10 100644 (file)
--- a/src/cls/lock/cls_lock_client.h
+++ b/src/cls/lock/cls_lock_client.h
@@ -1,3 +1,6 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
 #ifndef CEPH_CLS_LOCK_CLIENT_H
 #define CEPH_CLS_LOCK_CLIENT_H
 
@@ -12,38 +15,38 @@ namespace rados {
   namespace cls {
     namespace lock {
 
-      extern void lock(librados::ObjectWriteOperation& rados_op,
+      extern void lock(librados::ObjectWriteOperation *rados_op,
                        const std::string& name, ClsLockType type,
                        const std::string& cookie, const std::string& tag,
                        const std::string& description, const utime_t& duration,
-                      uint8_t flags);
+                       uint8_t flags);
 
-      extern int lock(librados::IoCtx& ioctx,
+      extern int lock(librados::IoCtx *ioctx,
                       const std::string& oid,
                       const std::string& name, ClsLockType type,
                       const std::string& cookie, const std::string& tag,
                       const std::string& description, const utime_t& duration,
-                     uint8_t flags);
+                      uint8_t flags);
 
-      extern void unlock(librados::ObjectWriteOperation& rados_op,
+      extern void unlock(librados::ObjectWriteOperation *rados_op,
                          const std::string& name, const std::string& cookie);
 
-      extern int unlock(librados::IoCtx& ioctx, const std::string& oid,
+      extern int unlock(librados::IoCtx *ioctx, const std::string& oid,
                         const std::string& name, const std::string& cookie);
 
-      extern void break_lock(librados::ObjectWriteOperation& op,
+      extern void break_lock(librados::ObjectWriteOperation *op,
                              const std::string& name, const std::string& cookie,
                              const entity_name_t& locker);
 
-      extern int break_lock(librados::IoCtx& ioctx, const std::string& oid,
+      extern int break_lock(librados::IoCtx *ioctx, const std::string& oid,
                             const std::string& name, const std::string& cookie,
                             const entity_name_t& locker);
 
-      extern int list_locks(librados::IoCtx& ioctx, const std::string& oid,
-                           list<std::string> *locks);
-      extern int get_lock_info(librados::IoCtx& ioctx, const std::string& oid,
-                              const std::string& lock,
-                              map<locker_id_t, locker_info_t> *lockers,
+      extern int list_locks(librados::IoCtx *ioctx, const std::string& oid,
+                            list<std::string> *locks);
+      extern int get_lock_info(librados::IoCtx *ioctx, const std::string& oid,
+                               const std::string& lock,
+                               map<locker_id_t, locker_info_t> *lockers,
                                ClsLockType *lock_type,
                                std::string *tag);
 
@@ -72,16 +75,16 @@ namespace rados {
         }
 
         /* ObjectWriteOperation */
-        void lock_exclusive(librados::ObjectWriteOperation& ioctx);
-        void lock_shared(librados::ObjectWriteOperation& ioctx);
-        void unlock(librados::ObjectWriteOperation& ioctx);
-        void break_lock(librados::ObjectWriteOperation& ioctx, const entity_name_t& locker);
+        void lock_exclusive(librados::ObjectWriteOperation *ioctx);
+        void lock_shared(librados::ObjectWriteOperation *ioctx);
+        void unlock(librados::ObjectWriteOperation *ioctx);
+        void break_lock(librados::ObjectWriteOperation *ioctx, const entity_name_t& locker);
 
         /* IoCtx*/
-        int lock_exclusive(librados::IoCtx& ioctx, const std::string& oid);
-        int lock_shared(librados::IoCtx& ioctx, const std::string& oid);
-        int unlock(librados::IoCtx& ioctx, const std::string& oid);
-        int break_lock(librados::IoCtx& ioctx, const std::string& oid,
+        int lock_exclusive(librados::IoCtx *ioctx, const std::string& oid);
+        int lock_shared(librados::IoCtx *ioctx, const std::string& oid);
+        int unlock(librados::IoCtx *ioctx, const std::string& oid);
+        int break_lock(librados::IoCtx *ioctx, const std::string& oid,
                       const entity_name_t& locker);
       };
 

diff --git a/src/rados.cc b/src/rados.cc
index 50131e32f94c9fff0916bfba06d9e958d6d9b6ce..1ec37224e2b3505e2c1d73b71fa70e9e623a764e 100644 (file)
--- a/src/rados.cc
+++ b/src/rados.cc
@@ -844,7 +844,7 @@ public:
 
 static int do_lock_cmd(std::vector<const char*> &nargs,
                        const std::map < std::string, std::string > &opts,
-                       IoCtx ioctx,
+                       IoCtx *ioctx,
                       Formatter *formatter)
 {
   char buf[128];
@@ -1958,7 +1958,7 @@ static int rados_tool_common(const std::map < std::string, std::string > &opts,
     if (!formatter) {
       formatter = new JSONFormatter(pretty_format);
     }
-    ret = do_lock_cmd(nargs, opts, io_ctx, formatter);
+    ret = do_lock_cmd(nargs, opts, &io_ctx, formatter);
   } else {
     cerr << "unrecognized command " << nargs[0] << std::endl;
     usage_exit();

diff --git a/src/test/rados-api/cls_lock.cc b/src/test/rados-api/cls_lock.cc
index bc003df63013efba596f789ff980ff141933d3d4..316bc3f596c9b3d4fc43f0c0702dcb34000e7e21 100644 (file)
--- a/src/test/rados-api/cls_lock.cc
+++ b/src/test/rados-api/cls_lock.cc
@@ -29,7 +29,7 @@ using namespace librados;
 
 using namespace rados::cls::lock;
 
-void lock_info(IoCtx& ioctx, string& oid, string& name, map<locker_id_t, locker_info_t>& lockers,
+void lock_info(IoCtx *ioctx, string& oid, string& name, map<locker_id_t, locker_info_t>& lockers,
               ClsLockType *assert_type, string *assert_tag)
 {
   ClsLockType lock_type = LOCK_NONE;
@@ -55,7 +55,7 @@ void lock_info(IoCtx& ioctx, string& oid, string& name, map<locker_id_t, locker_
   }
 }
 
-void lock_info(IoCtx& ioctx, string& oid, string& name, map<locker_id_t, locker_info_t>& lockers)
+void lock_info(IoCtx *ioctx, string& oid, string& name, map<locker_id_t, locker_info_t>& lockers)
 {
   lock_info(ioctx, oid, name, lockers, NULL, NULL);
 }
@@ -85,54 +85,54 @@ TEST(ClsLock, TestMultiLocking) {
 
   /* test lock object */
 
-  ASSERT_EQ(0, l.lock_exclusive(ioctx, oid));
+  ASSERT_EQ(0, l.lock_exclusive(&ioctx, oid));
 
   /* test exclusive lock */
-  ASSERT_EQ(-EEXIST, l.lock_exclusive(ioctx, oid));
+  ASSERT_EQ(-EEXIST, l.lock_exclusive(&ioctx, oid));
 
   /* test idempotency */
   l.set_renew(true);
-  ASSERT_EQ(0, l.lock_exclusive(ioctx, oid));
+  ASSERT_EQ(0, l.lock_exclusive(&ioctx, oid));
 
   l.set_renew(false);
 
   /* test second client */
   Lock l2(lock_name);
-  ASSERT_EQ(-EBUSY, l2.lock_exclusive(ioctx2, oid));
-  ASSERT_EQ(-EBUSY, l2.lock_shared(ioctx2, oid));
+  ASSERT_EQ(-EBUSY, l2.lock_exclusive(&ioctx2, oid));
+  ASSERT_EQ(-EBUSY, l2.lock_shared(&ioctx2, oid));
 
   list<string> locks;
-  ASSERT_EQ(0, list_locks(ioctx, oid, &locks));
+  ASSERT_EQ(0, list_locks(&ioctx, oid, &locks));
 
   ASSERT_EQ(1, (int)locks.size());
   list<string>::iterator iter = locks.begin();
   map<locker_id_t, locker_info_t> lockers;
-  lock_info(ioctx, oid, *iter, lockers, &lock_type_exclusive, NULL);
+  lock_info(&ioctx, oid, *iter, lockers, &lock_type_exclusive, NULL);
 
   ASSERT_EQ(1, (int)lockers.size());
 
   /* test unlock */
-  ASSERT_EQ(0, l.unlock(ioctx, oid));
+  ASSERT_EQ(0, l.unlock(&ioctx, oid));
   locks.clear();
-  ASSERT_EQ(0, list_locks(ioctx, oid, &locks));
+  ASSERT_EQ(0, list_locks(&ioctx, oid, &locks));
 
   /* test shared lock */
-  ASSERT_EQ(0, l2.lock_shared(ioctx2, oid));
-  ASSERT_EQ(0, l.lock_shared(ioctx, oid));
+  ASSERT_EQ(0, l2.lock_shared(&ioctx2, oid));
+  ASSERT_EQ(0, l.lock_shared(&ioctx, oid));
 
   locks.clear();
-  ASSERT_EQ(0, list_locks(ioctx, oid, &locks));
+  ASSERT_EQ(0, list_locks(&ioctx, oid, &locks));
   ASSERT_EQ(1, (int)locks.size());
   iter = locks.begin();
-  lock_info(ioctx, oid, *iter, lockers, &lock_type_shared, NULL);
+  lock_info(&ioctx, oid, *iter, lockers, &lock_type_shared, NULL);
   ASSERT_EQ(2, (int)lockers.size());
 
   /* test break locks */
   entity_name_t name = entity_name_t::CLIENT(cluster.get_instance_id());
   entity_name_t name2 = entity_name_t::CLIENT(cluster2.get_instance_id());
 
-  l2.break_lock(ioctx2, oid, name);
-  lock_info(ioctx, oid, *iter, lockers);
+  l2.break_lock(&ioctx2, oid, name);
+  lock_info(&ioctx, oid, *iter, lockers);
   ASSERT_EQ(1, (int)lockers.size());
   map<locker_id_t, locker_info_t>::iterator liter = lockers.begin();
   const locker_id_t& id = liter->first;
@@ -141,13 +141,13 @@ TEST(ClsLock, TestMultiLocking) {
   /* test lock tag */
   Lock l_tag(lock_name);
   l_tag.set_tag("non-default tag");
-  ASSERT_EQ(-EBUSY, l_tag.lock_shared(ioctx, oid));
+  ASSERT_EQ(-EBUSY, l_tag.lock_shared(&ioctx, oid));
 
 
   /* test modify description */
   string description = "new description";
   l.set_description(description);
-  ASSERT_EQ(0, l.lock_shared(ioctx, oid));
+  ASSERT_EQ(0, l.lock_shared(&ioctx, oid));
 
   ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
 }
@@ -172,43 +172,43 @@ TEST(ClsLock, TestMeta) {
   ASSERT_EQ(0, ioctx.write(oid, bl, bl.length(), 0));
 
   Lock l(lock_name);
-  ASSERT_EQ(0, l.lock_shared(ioctx, oid));
+  ASSERT_EQ(0, l.lock_shared(&ioctx, oid));
 
   /* test lock tag */
   Lock l_tag(lock_name);
   l_tag.set_tag("non-default tag");
-  ASSERT_EQ(-EBUSY, l_tag.lock_shared(ioctx2, oid));
+  ASSERT_EQ(-EBUSY, l_tag.lock_shared(&ioctx2, oid));
 
 
-  ASSERT_EQ(0, l.unlock(ioctx, oid));
+  ASSERT_EQ(0, l.unlock(&ioctx, oid));
 
   /* test description */
   Lock l2(lock_name);
   string description = "new description";
   l2.set_description(description);
-  ASSERT_EQ(0, l2.lock_shared(ioctx2, oid));
+  ASSERT_EQ(0, l2.lock_shared(&ioctx2, oid));
 
   map<locker_id_t, locker_info_t> lockers;
-  lock_info(ioctx, oid, lock_name, lockers, NULL, NULL);
+  lock_info(&ioctx, oid, lock_name, lockers, NULL, NULL);
   ASSERT_EQ(1, (int)lockers.size());
 
   map<locker_id_t, locker_info_t>::iterator iter = lockers.begin();
   locker_info_t locker = iter->second;
   ASSERT_EQ("new description", locker.description);
 
-  ASSERT_EQ(0, l2.unlock(ioctx2, oid));
+  ASSERT_EQ(0, l2.unlock(&ioctx2, oid));
 
   /* check new tag */
   string new_tag = "new_tag";
   l.set_tag(new_tag);
   l.set_renew(true);
-  ASSERT_EQ(0, l.lock_exclusive(ioctx, oid));
-  lock_info(ioctx, oid, lock_name, lockers, NULL, &new_tag);
+  ASSERT_EQ(0, l.lock_exclusive(&ioctx, oid));
+  lock_info(&ioctx, oid, lock_name, lockers, NULL, &new_tag);
   ASSERT_EQ(1, (int)lockers.size());
   l.set_tag("");
-  ASSERT_EQ(-EBUSY, l.lock_exclusive(ioctx, oid));
+  ASSERT_EQ(-EBUSY, l.lock_exclusive(&ioctx, oid));
   l.set_tag(new_tag);
-  ASSERT_EQ(0, l.lock_exclusive(ioctx, oid));
+  ASSERT_EQ(0, l.lock_exclusive(&ioctx, oid));
 
   ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
 }
@@ -224,26 +224,26 @@ TEST(ClsLock, TestCookie) {
   string lock_name = "mylock";
   Lock l(lock_name);
 
-  ASSERT_EQ(0, l.lock_exclusive(ioctx, oid));
+  ASSERT_EQ(0, l.lock_exclusive(&ioctx, oid));
 
   /* new cookie */
   string cookie = "new cookie";
   l.set_cookie(cookie);
-  ASSERT_EQ(-EBUSY, l.lock_exclusive(ioctx, oid));
-  ASSERT_EQ(-ENOENT, l.unlock(ioctx, oid));
+  ASSERT_EQ(-EBUSY, l.lock_exclusive(&ioctx, oid));
+  ASSERT_EQ(-ENOENT, l.unlock(&ioctx, oid));
   l.set_cookie("");
-  ASSERT_EQ(0, l.unlock(ioctx, oid));
+  ASSERT_EQ(0, l.unlock(&ioctx, oid));
 
   map<locker_id_t, locker_info_t> lockers;
-  lock_info(ioctx, oid, lock_name, lockers);
+  lock_info(&ioctx, oid, lock_name, lockers);
   ASSERT_EQ(0, (int)lockers.size());
 
   l.set_cookie(cookie);
-  ASSERT_EQ(0, l.lock_shared(ioctx, oid));
+  ASSERT_EQ(0, l.lock_shared(&ioctx, oid));
   l.set_cookie("");
-  ASSERT_EQ(0, l.lock_shared(ioctx, oid));
+  ASSERT_EQ(0, l.lock_shared(&ioctx, oid));
 
-  lock_info(ioctx, oid, lock_name, lockers);
+  lock_info(&ioctx, oid, lock_name, lockers);
   ASSERT_EQ(2, (int)lockers.size());
 
   ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
@@ -258,13 +258,13 @@ TEST(ClsLock, TestMultipleLocks) {
 
   string oid = "foo";
   Lock l("lock1");
-  ASSERT_EQ(0, l.lock_exclusive(ioctx, oid));
+  ASSERT_EQ(0, l.lock_exclusive(&ioctx, oid));
 
   Lock l2("lock2");
-  ASSERT_EQ(0, l2.lock_exclusive(ioctx, oid));
+  ASSERT_EQ(0, l2.lock_exclusive(&ioctx, oid));
 
   list<string> locks;
-  ASSERT_EQ(0, list_locks(ioctx, oid, &locks));
+  ASSERT_EQ(0, list_locks(&ioctx, oid, &locks));
 
   ASSERT_EQ(2, (int)locks.size());
 
@@ -281,11 +281,11 @@ TEST(ClsLock, TestLockDuration) {
   string oid = "foo";
   Lock l("lock");
   l.set_duration(utime_t(5, 0));
-  ASSERT_EQ(0, l.lock_exclusive(ioctx, oid));
-  ASSERT_EQ(-EEXIST, l.lock_exclusive(ioctx, oid));
+  ASSERT_EQ(0, l.lock_exclusive(&ioctx, oid));
+  ASSERT_EQ(-EEXIST, l.lock_exclusive(&ioctx, oid));
 
   sleep(5);
-  ASSERT_EQ(0, l.lock_exclusive(ioctx, oid));
+  ASSERT_EQ(0, l.lock_exclusive(&ioctx, oid));
 
   ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));
 }