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