ceph/src/test/librados/lock.cc

   1 #include "include/rados/librados.h"
   2 #include "test/librados/test.h"
   3 #include "test/librados/TestCase.h"
   4 #include "cls/lock/cls_lock_client.h"
   5
   6 #include <algorithm>
   7 #include <chrono>
   8 #include <thread>
   9 #include <errno.h>
  10 #include "gtest/gtest.h"
  11 #include <sys/time.h>
  12
  13 using namespace std::chrono_literals;
  14
  15 typedef RadosTest LibRadosLock;
  16 typedef RadosTestEC LibRadosLockEC;
  17
  18
  19 TEST_F(LibRadosLock, LockExclusive) {
  20   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock1", "Cookie", "", NULL,  0));
  21   ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock1", "Cookie", "", NULL, 0));
  22 }
  23
  24 TEST_F(LibRadosLock, LockShared) {
  25   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock2", "Cookie", "Tag", "", NULL, 0));
  26   ASSERT_EQ(-EEXIST, rados_lock_shared(ioctx, "foo", "TestLock2", "Cookie", "Tag", "", NULL, 0));
  27 }
  28
  29 TEST_F(LibRadosLock, LockExclusiveDur) {
  30   struct timeval tv;
  31   tv.tv_sec = 1;
  32   tv.tv_usec = 0;
  33   auto lock_exclusive = [this](timeval* tv) {
  34     return rados_lock_exclusive(ioctx, "foo", "TestLock3", "Cookie", "", tv, 0);
  35   };
  36   constexpr int expected = 0;
  37   ASSERT_EQ(expected, lock_exclusive(&tv));
  38   ASSERT_EQ(expected, wait_until(1.0s, 0.1s, expected, lock_exclusive, nullptr));
  39 }
  40
  41 TEST_F(LibRadosLock, LockSharedDur) {
  42   struct timeval tv;
  43   tv.tv_sec = 1;
  44   tv.tv_usec = 0;
  45   auto lock_shared = [this](timeval* tv) {
  46     return rados_lock_shared(ioctx, "foo", "TestLock4", "Cookie", "Tag", "", tv, 0);
  47   };
  48   constexpr int expected = 0;
  49   ASSERT_EQ(expected, lock_shared(&tv));
  50   ASSERT_EQ(expected, wait_until(1.0s, 0.1s, expected, lock_shared, nullptr));
  51 }
  52
  53
  54 TEST_F(LibRadosLock, LockMayRenew) {
  55   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock5", "Cookie", "", NULL, 0));
  56   ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock5", "Cookie", "", NULL, 0));
  57   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock5", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
  58 }
  59
  60 TEST_F(LibRadosLock, Unlock) {
  61   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock6", "Cookie", "", NULL, 0));
  62   ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLock6", "Cookie"));
  63   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock6", "Cookie", "", NULL,  0));
  64 }
  65
  66 TEST_F(LibRadosLock, ListLockers) {
  67   int exclusive;
  68   char tag[1024];
  69   char clients[1024];
  70   char cookies[1024];
  71   char addresses[1024];
  72   size_t tag_len = 1024;
  73   size_t clients_len = 1024;
  74   size_t cookies_len = 1024;
  75   size_t addresses_len = 1024;
  76   std::stringstream sstm;
  77   sstm << "client." << rados_get_instance_id(cluster);
  78   std::string me = sstm.str();
  79   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock7", "Cookie", "Tag", "", NULL, 0));
  80   ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLock7", "Cookie"));
  81   ASSERT_EQ(0, rados_list_lockers(ioctx, "foo", "TestLock7", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  82   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock7", "Cookie", "Tag", "", NULL, 0));
  83   ASSERT_EQ(-34, rados_list_lockers(ioctx, "foo", "TestLock7", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  84   tag_len = 1024;
  85   clients_len = 1024;
  86   cookies_len = 1024;
  87   addresses_len = 1024;
  88   ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLock7", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  89   ASSERT_EQ(0, exclusive);
  90   ASSERT_EQ(0, strcmp(tag, "Tag"));
  91   ASSERT_EQ(strlen("Tag") + 1, tag_len);
  92   ASSERT_EQ(0, strcmp(me.c_str(), clients));
  93   ASSERT_EQ(me.size() + 1, clients_len);
  94   ASSERT_EQ(0, strcmp(cookies, "Cookie"));
  95   ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
  96 }
  97
  98 TEST_F(LibRadosLock, BreakLock) {
  99   int exclusive;
 100   char tag[1024];
 101   char clients[1024];
 102   char cookies[1024];
 103   char addresses[1024];
 104   size_t tag_len = 1024;
 105   size_t clients_len = 1024;
 106   size_t cookies_len = 1024;
 107   size_t addresses_len = 1024;
 108   std::stringstream sstm;
 109   sstm << "client." << rados_get_instance_id(cluster);
 110   std::string me = sstm.str();
 111   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock8", "Cookie", "", NULL, 0));
 112   ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLock8", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 113   ASSERT_EQ(1, exclusive);
 114   ASSERT_EQ(0, strcmp(tag, ""));
 115   ASSERT_EQ(1U, tag_len);
 116   ASSERT_EQ(0, strcmp(me.c_str(), clients));
 117   ASSERT_EQ(me.size() + 1, clients_len);
 118   ASSERT_EQ(0, strcmp(cookies, "Cookie"));
 119   ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
 120   ASSERT_EQ(0, rados_break_lock(ioctx, "foo", "TestLock8", clients, "Cookie"));
 121 }
 122
 123 // EC testing
 124 TEST_F(LibRadosLockEC, LockExclusive) {
 125   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLockEC1", "Cookie", "", NULL,  0));
 126   ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLockEC1", "Cookie", "", NULL, 0));
 127 }
 128
 129 TEST_F(LibRadosLockEC, LockShared) {
 130   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLockEC2", "Cookie", "Tag", "", NULL, 0));
 131   ASSERT_EQ(-EEXIST, rados_lock_shared(ioctx, "foo", "TestLockEC2", "Cookie", "Tag", "", NULL, 0));
 132 }
 133
 134 TEST_F(LibRadosLockEC, LockExclusiveDur) {
 135   struct timeval tv;
 136   tv.tv_sec = 1;
 137   tv.tv_usec = 0;
 138   auto lock_exclusive = [this](timeval* tv) {
 139     return rados_lock_exclusive(ioctx, "foo", "TestLockEC3", "Cookie", "", tv, 0);
 140   };
 141   constexpr int expected = 0;
 142   ASSERT_EQ(expected, lock_exclusive(&tv));
 143   ASSERT_EQ(expected, wait_until(1.0s, 0.1s, expected, lock_exclusive, nullptr));
 144 }
 145
 146 TEST_F(LibRadosLockEC, LockSharedDur) {
 147   struct timeval tv;
 148   tv.tv_sec = 1;
 149   tv.tv_usec = 0;
 150   auto lock_shared = [this](timeval* tv) {
 151     return rados_lock_shared(ioctx, "foo", "TestLockEC4", "Cookie", "Tag", "", tv, 0);
 152   };
 153   constexpr int expected = 0;
 154   ASSERT_EQ(expected, lock_shared(&tv));
 155   ASSERT_EQ(expected, wait_until(1.0s, 0.1s, expected, lock_shared, nullptr));
 156 }
 157
 158
 159 TEST_F(LibRadosLockEC, LockMayRenew) {
 160   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLockEC5", "Cookie", "", NULL, 0));
 161   ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLockEC5", "Cookie", "", NULL, 0));
 162   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLockEC5", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
 163 }
 164
 165 TEST_F(LibRadosLockEC, Unlock) {
 166   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLockEC6", "Cookie", "", NULL, 0));
 167   ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLockEC6", "Cookie"));
 168   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLockEC6", "Cookie", "", NULL,  0));
 169 }
 170
 171 TEST_F(LibRadosLockEC, ListLockers) {
 172   int exclusive;
 173   char tag[1024];
 174   char clients[1024];
 175   char cookies[1024];
 176   char addresses[1024];
 177   size_t tag_len = 1024;
 178   size_t clients_len = 1024;
 179   size_t cookies_len = 1024;
 180   size_t addresses_len = 1024;
 181   std::stringstream sstm;
 182   sstm << "client." << rados_get_instance_id(cluster);
 183   std::string me = sstm.str();
 184   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLockEC7", "Cookie", "Tag", "", NULL, 0));
 185   ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLockEC7", "Cookie"));
 186   ASSERT_EQ(0, rados_list_lockers(ioctx, "foo", "TestLockEC7", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 187   ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLockEC7", "Cookie", "Tag", "", NULL, 0));
 188   ASSERT_EQ(-34, rados_list_lockers(ioctx, "foo", "TestLockEC7", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 189   tag_len = 1024;
 190   clients_len = 1024;
 191   cookies_len = 1024;
 192   addresses_len = 1024;
 193   ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLockEC7", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 194   ASSERT_EQ(0, exclusive);
 195   ASSERT_EQ(0, strcmp(tag, "Tag"));
 196   ASSERT_EQ(strlen("Tag") + 1, tag_len);
 197   ASSERT_EQ(0, strcmp(me.c_str(), clients));
 198   ASSERT_EQ(me.size() + 1, clients_len);
 199   ASSERT_EQ(0, strcmp(cookies, "Cookie"));
 200   ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
 201 }
 202
 203 TEST_F(LibRadosLockEC, BreakLock) {
 204   int exclusive;
 205   char tag[1024];
 206   char clients[1024];
 207   char cookies[1024];
 208   char addresses[1024];
 209   size_t tag_len = 1024;
 210   size_t clients_len = 1024;
 211   size_t cookies_len = 1024;
 212   size_t addresses_len = 1024;
 213   std::stringstream sstm;
 214   sstm << "client." << rados_get_instance_id(cluster);
 215   std::string me = sstm.str();
 216   ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLockEC8", "Cookie", "", NULL, 0));
 217   ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLockEC8", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
 218   ASSERT_EQ(1, exclusive);
 219   ASSERT_EQ(0, strcmp(tag, ""));
 220   ASSERT_EQ(1U, tag_len);
 221   ASSERT_EQ(0, strcmp(me.c_str(), clients));
 222   ASSERT_EQ(me.size() + 1, clients_len);
 223   ASSERT_EQ(0, strcmp(cookies, "Cookie"));
 224   ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
 225   ASSERT_EQ(0, rados_break_lock(ioctx, "foo", "TestLockEC8", clients, "Cookie"));
 226 }
 227