ceph/src/test/librados/lock.cc

   1 #include "include/rados/librados.h"
   2 #include "include/rados/librados.hpp"
   3 #include "test/librados/test.h"
   4 #include "test/librados/TestCase.h"
   5 #include "cls/lock/cls_lock_client.h"
   6
   7 #include <algorithm>
   8 #include <errno.h>
   9 #include "gtest/gtest.h"
  10 #include <sys/time.h>
  11
  12 using namespace librados;
  13
  14 typedef RadosTest LibRadosLock;
  15 typedef RadosTestPP LibRadosLockPP;
  16 typedef RadosTestEC LibRadosLockEC;
  17 typedef RadosTestECPP LibRadosLockECPP;
  18
  19 TEST_F(LibRadosLock, LockExclusive) {
  20   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL,  0));
  21   ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  22 }
  23
  24 TEST_F(LibRadosLockPP, LockExclusivePP) {
  25   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL,  0));
  26   ASSERT_EQ(-EEXIST, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  27 }
  28
  29 TEST_F(LibRadosLock, LockShared) {
  30   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  31   ASSERT_EQ(-EEXIST, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  32 }
  33
  34 TEST_F(LibRadosLockPP, LockSharedPP) {
  35   ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  36   ASSERT_EQ(-EEXIST, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  37 }
  38
  39 TEST_F(LibRadosLock, LockExclusiveDur) {
  40   struct timeval tv;
  41   tv.tv_sec = 1;
  42   tv.tv_usec = 0;
  43   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", &tv,  0));
  44   sleep(1);
  45   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  46 }
  47
  48 TEST_F(LibRadosLockPP, LockExclusiveDurPP) {
  49   struct timeval tv;
  50   tv.tv_sec = 1;
  51   tv.tv_usec = 0;
  52   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", &tv,  0));
  53   sleep(1);
  54   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  55 }
  56
  57 TEST_F(LibRadosLock, LockSharedDur) {
  58   struct timeval tv;
  59   tv.tv_sec = 1;
  60   tv.tv_usec = 0;
  61   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", &tv, 0));
  62   sleep(1);
  63   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  64 }
  65
  66 TEST_F(LibRadosLockPP, LockSharedDurPP) {
  67   struct timeval tv;
  68   tv.tv_sec = 1;
  69   tv.tv_usec = 0;
  70   ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", &tv, 0));
  71   sleep(1);
  72   ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  73 }
  74
  75 TEST_F(LibRadosLock, LockMayRenew) {
  76   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  77   ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  78   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
  79 }
  80
  81 TEST_F(LibRadosLockPP, LockMayRenewPP) {
  82   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  83   ASSERT_EQ(-EEXIST, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  84   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
  85 }
  86
  87 TEST_F(LibRadosLock, Unlock) {
  88   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  89   ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLock", "Cookie"));
  90   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL,  0));
  91 }
  92
  93 TEST_F(LibRadosLockPP, UnlockPP) {
  94   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  95   ASSERT_EQ(0, ioctx.unlock("foo", "TestLock", "Cookie"));
  96   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  97 }
  98
  99 TEST_F(LibRadosLock, ListLockers) {
 100   int exclusive;
 101   char tag[1024];
 102   char clients[1024];
 103   char cookies[1024];
 104   char addresses[1024];
 105   size_t tag_len = 1024;
 106   size_t clients_len = 1024;
 107   size_t cookies_len = 1024;
 108   size_t addresses_len = 1024;
 109   std::stringstream sstm;
 110   sstm << "client." << rados_get_instance_id(cluster);
 111   std::string me = sstm.str();
 112   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 113   ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLock", "Cookie"));
 114   ASSERT_EQ(0, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 115   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 116   ASSERT_EQ(-34, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 117   tag_len = 1024;
 118   clients_len = 1024;
 119   cookies_len = 1024;
 120   addresses_len = 1024;
 121   ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 122   ASSERT_EQ(0, exclusive);
 123   ASSERT_EQ(0, strcmp(tag, "Tag"));
 124   ASSERT_EQ(strlen("Tag") + 1, tag_len);
 125   ASSERT_EQ(0, strcmp(me.c_str(), clients));
 126   ASSERT_EQ(me.size() + 1, clients_len);
 127   ASSERT_EQ(0, strcmp(cookies, "Cookie"));
 128   ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
 129 }
 130
 131 TEST_F(LibRadosLockPP, ListLockersPP) {
 132   std::stringstream sstm;
 133   sstm << "client." << cluster.get_instance_id();
 134   std::string me = sstm.str();
 135   ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 136   ASSERT_EQ(0, ioctx.unlock("foo", "TestLock", "Cookie"));
 137   {
 138     int exclusive;
 139     std::string tag;
 140     std::list<librados::locker_t> lockers;
 141     ASSERT_EQ(0, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
 142   }
 143   ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 144   {
 145     int exclusive;
 146     std::string tag;
 147     std::list<librados::locker_t> lockers;
 148     ASSERT_EQ(1, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
 149     std::list<librados::locker_t>::iterator it = lockers.begin();
 150     ASSERT_FALSE(lockers.end() == it);
 151     ASSERT_EQ(me, it->client);
 152     ASSERT_EQ("Cookie", it->cookie);
 153   }
 154 }
 155
 156 TEST_F(LibRadosLock, BreakLock) {
 157   int exclusive;
 158   char tag[1024];
 159   char clients[1024];
 160   char cookies[1024];
 161   char addresses[1024];
 162   size_t tag_len = 1024;
 163   size_t clients_len = 1024;
 164   size_t cookies_len = 1024;
 165   size_t addresses_len = 1024;
 166   std::stringstream sstm;
 167   sstm << "client." << rados_get_instance_id(cluster);
 168   std::string me = sstm.str();
 169   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
 170   ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 171   ASSERT_EQ(1, exclusive);
 172   ASSERT_EQ(0, strcmp(tag, ""));
 173   ASSERT_EQ(1U, tag_len);
 174   ASSERT_EQ(0, strcmp(me.c_str(), clients));
 175   ASSERT_EQ(me.size() + 1, clients_len);
 176   ASSERT_EQ(0, strcmp(cookies, "Cookie"));
 177   ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
 178   ASSERT_EQ(0, rados_break_lock(ioctx, "foo", "TestLock", clients, "Cookie"));
 179 }
 180
 181 TEST_F(LibRadosLockPP, BreakLockPP) {
 182   int exclusive;
 183   std::string tag;
 184   std::list<librados::locker_t> lockers;
 185   std::stringstream sstm;
 186   sstm << "client." << cluster.get_instance_id();
 187   std::string me = sstm.str();
 188   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie",  "", NULL, 0));
 189   ASSERT_EQ(1, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
 190   std::list<librados::locker_t>::iterator it = lockers.begin();
 191   ASSERT_FALSE(lockers.end() == it);
 192   ASSERT_EQ(me, it->client);
 193   ASSERT_EQ("Cookie", it->cookie);
 194   ASSERT_EQ(0, ioctx.break_lock("foo", "TestLock", it->client, "Cookie"));
 195 }
 196
 197 // EC testing
 198 TEST_F(LibRadosLockEC, LockExclusive) {
 199   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL,  0));
 200   ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
 201 }
 202
 203 TEST_F(LibRadosLockECPP, LockExclusivePP) {
 204   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL,  0));
 205   ASSERT_EQ(-EEXIST, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
 206 }
 207
 208 TEST_F(LibRadosLockEC, LockShared) {
 209   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 210   ASSERT_EQ(-EEXIST, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 211 }
 212
 213 TEST_F(LibRadosLockECPP, LockSharedPP) {
 214   ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 215   ASSERT_EQ(-EEXIST, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 216 }
 217
 218 TEST_F(LibRadosLockEC, LockExclusiveDur) {
 219   struct timeval tv;
 220   tv.tv_sec = 1;
 221   tv.tv_usec = 0;
 222   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", &tv,  0));
 223   sleep(1);
 224   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
 225 }
 226
 227 TEST_F(LibRadosLockECPP, LockExclusiveDurPP) {
 228   struct timeval tv;
 229   tv.tv_sec = 1;
 230   tv.tv_usec = 0;
 231   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", &tv,  0));
 232   sleep(1);
 233   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
 234 }
 235
 236 TEST_F(LibRadosLockEC, LockSharedDur) {
 237   struct timeval tv;
 238   tv.tv_sec = 1;
 239   tv.tv_usec = 0;
 240   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", &tv, 0));
 241   sleep(1);
 242   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 243 }
 244
 245 TEST_F(LibRadosLockECPP, LockSharedDurPP) {
 246   struct timeval tv;
 247   tv.tv_sec = 1;
 248   tv.tv_usec = 0;
 249   ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", &tv, 0));
 250   sleep(1);
 251   ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 252 }
 253
 254 TEST_F(LibRadosLockEC, LockMayRenew) {
 255   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
 256   ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
 257   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
 258 }
 259
 260 TEST_F(LibRadosLockECPP, LockMayRenewPP) {
 261   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
 262   ASSERT_EQ(-EEXIST, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
 263   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
 264 }
 265
 266 TEST_F(LibRadosLockEC, Unlock) {
 267   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
 268   ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLock", "Cookie"));
 269   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL,  0));
 270 }
 271
 272 TEST_F(LibRadosLockECPP, UnlockPP) {
 273   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
 274   ASSERT_EQ(0, ioctx.unlock("foo", "TestLock", "Cookie"));
 275   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
 276 }
 277
 278 TEST_F(LibRadosLockEC, ListLockers) {
 279   int exclusive;
 280   char tag[1024];
 281   char clients[1024];
 282   char cookies[1024];
 283   char addresses[1024];
 284   size_t tag_len = 1024;
 285   size_t clients_len = 1024;
 286   size_t cookies_len = 1024;
 287   size_t addresses_len = 1024;
 288   std::stringstream sstm;
 289   sstm << "client." << rados_get_instance_id(cluster);
 290   std::string me = sstm.str();
 291   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 292   ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLock", "Cookie"));
 293   ASSERT_EQ(0, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 294   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 295   ASSERT_EQ(-34, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 296   tag_len = 1024;
 297   clients_len = 1024;
 298   cookies_len = 1024;
 299   addresses_len = 1024;
 300   ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 301   ASSERT_EQ(0, exclusive);
 302   ASSERT_EQ(0, strcmp(tag, "Tag"));
 303   ASSERT_EQ(strlen("Tag") + 1, tag_len);
 304   ASSERT_EQ(0, strcmp(me.c_str(), clients));
 305   ASSERT_EQ(me.size() + 1, clients_len);
 306   ASSERT_EQ(0, strcmp(cookies, "Cookie"));
 307   ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
 308 }
 309
 310 TEST_F(LibRadosLockECPP, ListLockersPP) {
 311   std::stringstream sstm;
 312   sstm << "client." << cluster.get_instance_id();
 313   std::string me = sstm.str();
 314   ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 315   ASSERT_EQ(0, ioctx.unlock("foo", "TestLock", "Cookie"));
 316   {
 317     int exclusive;
 318     std::string tag;
 319     std::list<librados::locker_t> lockers;
 320     ASSERT_EQ(0, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
 321   }
 322   ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
 323   {
 324     int exclusive;
 325     std::string tag;
 326     std::list<librados::locker_t> lockers;
 327     ASSERT_EQ(1, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
 328     std::list<librados::locker_t>::iterator it = lockers.begin();
 329     ASSERT_FALSE(lockers.end() == it);
 330     ASSERT_EQ(me, it->client);
 331     ASSERT_EQ("Cookie", it->cookie);
 332   }
 333 }
 334
 335 TEST_F(LibRadosLockEC, BreakLock) {
 336   int exclusive;
 337   char tag[1024];
 338   char clients[1024];
 339   char cookies[1024];
 340   char addresses[1024];
 341   size_t tag_len = 1024;
 342   size_t clients_len = 1024;
 343   size_t cookies_len = 1024;
 344   size_t addresses_len = 1024;
 345   std::stringstream sstm;
 346   sstm << "client." << rados_get_instance_id(cluster);
 347   std::string me = sstm.str();
 348   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
 349   ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 350   ASSERT_EQ(1, exclusive);
 351   ASSERT_EQ(0, strcmp(tag, ""));
 352   ASSERT_EQ(1U, tag_len);
 353   ASSERT_EQ(0, strcmp(me.c_str(), clients));
 354   ASSERT_EQ(me.size() + 1, clients_len);
 355   ASSERT_EQ(0, strcmp(cookies, "Cookie"));
 356   ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
 357   ASSERT_EQ(0, rados_break_lock(ioctx, "foo", "TestLock", clients, "Cookie"));
 358 }
 359
 360 TEST_F(LibRadosLockECPP, BreakLockPP) {
 361   int exclusive;
 362   std::string tag;
 363   std::list<librados::locker_t> lockers;
 364   std::stringstream sstm;
 365   sstm << "client." << cluster.get_instance_id();
 366   std::string me = sstm.str();
 367   ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie",  "", NULL, 0));
 368   ASSERT_EQ(1, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
 369   std::list<librados::locker_t>::iterator it = lockers.begin();
 370   ASSERT_FALSE(lockers.end() == it);
 371   ASSERT_EQ(me, it->client);
 372   ASSERT_EQ("Cookie", it->cookie);
 373   ASSERT_EQ(0, ioctx.break_lock("foo", "TestLock", it->client, "Cookie"));
 374 }