[ceph.git] / ceph / src / test / librados / lock.cc

#include "include/rados/librados.h"
#include "include/rados/librados.hpp"
#include "test/librados/test.h"
#include "test/librados/TestCase.h"
#include "cls/lock/cls_lock_client.h"

#include <algorithm>
#include <errno.h>
#include "gtest/gtest.h"
#include <sys/time.h>

using namespace librados;

typedef RadosTest LibRadosLock;
typedef RadosTestPP LibRadosLockPP;
typedef RadosTestEC LibRadosLockEC;
typedef RadosTestECPP LibRadosLockECPP;

TEST_F(LibRadosLock, LockExclusive) {
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL,  0));
  ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
}

TEST_F(LibRadosLockPP, LockExclusivePP) {
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL,  0));
  ASSERT_EQ(-EEXIST, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
}

TEST_F(LibRadosLock, LockShared) {
  ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  ASSERT_EQ(-EEXIST, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
}

TEST_F(LibRadosLockPP, LockSharedPP) {
  ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  ASSERT_EQ(-EEXIST, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
}

TEST_F(LibRadosLock, LockExclusiveDur) {
  struct timeval tv;
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", &tv,  0));
  sleep(1);
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
}

TEST_F(LibRadosLockPP, LockExclusiveDurPP) {
  struct timeval tv;
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", &tv,  0));
  sleep(1);
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
}

TEST_F(LibRadosLock, LockSharedDur) {
  struct timeval tv;
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", &tv, 0));
  sleep(1);
  ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
}

TEST_F(LibRadosLockPP, LockSharedDurPP) {
  struct timeval tv;
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", &tv, 0));
  sleep(1);
  ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
}

TEST_F(LibRadosLock, LockMayRenew) {
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
}

TEST_F(LibRadosLockPP, LockMayRenewPP) {
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(-EEXIST, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
}

TEST_F(LibRadosLock, Unlock) {
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLock", "Cookie"));
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL,  0));
}

TEST_F(LibRadosLockPP, UnlockPP) {
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(0, ioctx.unlock("foo", "TestLock", "Cookie"));
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
}

TEST_F(LibRadosLock, ListLockers) {
  int exclusive;
  char tag[1024];
  char clients[1024];
  char cookies[1024];
  char addresses[1024];
  size_t tag_len = 1024;
  size_t clients_len = 1024;
  size_t cookies_len = 1024;
  size_t addresses_len = 1024;
  std::stringstream sstm;
  sstm << "client." << rados_get_instance_id(cluster);
  std::string me = sstm.str();
  ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLock", "Cookie"));
  ASSERT_EQ(0, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  ASSERT_EQ(-34, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  tag_len = 1024;
  clients_len = 1024;
  cookies_len = 1024;
  addresses_len = 1024;
  ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  ASSERT_EQ(0, exclusive);
  ASSERT_EQ(0, strcmp(tag, "Tag"));
  ASSERT_EQ(strlen("Tag") + 1, tag_len);
  ASSERT_EQ(0, strcmp(me.c_str(), clients));
  ASSERT_EQ(me.size() + 1, clients_len);
  ASSERT_EQ(0, strcmp(cookies, "Cookie"));
  ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
}

TEST_F(LibRadosLockPP, ListLockersPP) {
  std::stringstream sstm;
  sstm << "client." << cluster.get_instance_id();
  std::string me = sstm.str();
  ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  ASSERT_EQ(0, ioctx.unlock("foo", "TestLock", "Cookie"));
  {
    int exclusive;
    std::string tag;
    std::list<librados::locker_t> lockers;
    ASSERT_EQ(0, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
  }
  ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  {
    int exclusive;
    std::string tag;
    std::list<librados::locker_t> lockers;
    ASSERT_EQ(1, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
    std::list<librados::locker_t>::iterator it = lockers.begin();
    ASSERT_FALSE(lockers.end() == it);
    ASSERT_EQ(me, it->client);
    ASSERT_EQ("Cookie", it->cookie);
  }
}

TEST_F(LibRadosLock, BreakLock) {
  int exclusive;
  char tag[1024];
  char clients[1024];
  char cookies[1024];
  char addresses[1024];
  size_t tag_len = 1024;
  size_t clients_len = 1024;
  size_t cookies_len = 1024;
  size_t addresses_len = 1024;
  std::stringstream sstm;
  sstm << "client." << rados_get_instance_id(cluster);
  std::string me = sstm.str();
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  ASSERT_EQ(1, exclusive);
  ASSERT_EQ(0, strcmp(tag, ""));
  ASSERT_EQ(1U, tag_len);
  ASSERT_EQ(0, strcmp(me.c_str(), clients));
  ASSERT_EQ(me.size() + 1, clients_len);
  ASSERT_EQ(0, strcmp(cookies, "Cookie"));
  ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
  ASSERT_EQ(0, rados_break_lock(ioctx, "foo", "TestLock", clients, "Cookie"));
}

TEST_F(LibRadosLockPP, BreakLockPP) {
  int exclusive;
  std::string tag;
  std::list<librados::locker_t> lockers;
  std::stringstream sstm;
  sstm << "client." << cluster.get_instance_id();
  std::string me = sstm.str();
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie",  "", NULL, 0));
  ASSERT_EQ(1, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
  std::list<librados::locker_t>::iterator it = lockers.begin();
  ASSERT_FALSE(lockers.end() == it);
  ASSERT_EQ(me, it->client);
  ASSERT_EQ("Cookie", it->cookie);
  ASSERT_EQ(0, ioctx.break_lock("foo", "TestLock", it->client, "Cookie"));
}

// EC testing
TEST_F(LibRadosLockEC, LockExclusive) {
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL,  0));
  ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
}

TEST_F(LibRadosLockECPP, LockExclusivePP) {
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL,  0));
  ASSERT_EQ(-EEXIST, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
}

TEST_F(LibRadosLockEC, LockShared) {
  ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  ASSERT_EQ(-EEXIST, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
}

TEST_F(LibRadosLockECPP, LockSharedPP) {
  ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  ASSERT_EQ(-EEXIST, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
}

TEST_F(LibRadosLockEC, LockExclusiveDur) {
  struct timeval tv;
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", &tv,  0));
  sleep(1);
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
}

TEST_F(LibRadosLockECPP, LockExclusiveDurPP) {
  struct timeval tv;
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", &tv,  0));
  sleep(1);
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
}

TEST_F(LibRadosLockEC, LockSharedDur) {
  struct timeval tv;
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", &tv, 0));
  sleep(1);
  ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
}

TEST_F(LibRadosLockECPP, LockSharedDurPP) {
  struct timeval tv;
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", &tv, 0));
  sleep(1);
  ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
}

TEST_F(LibRadosLockEC, LockMayRenew) {
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
}

TEST_F(LibRadosLockECPP, LockMayRenewPP) {
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(-EEXIST, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
}

TEST_F(LibRadosLockEC, Unlock) {
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLock", "Cookie"));
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL,  0));
}

TEST_F(LibRadosLockECPP, UnlockPP) {
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(0, ioctx.unlock("foo", "TestLock", "Cookie"));
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
}

TEST_F(LibRadosLockEC, ListLockers) {
  int exclusive;
  char tag[1024];
  char clients[1024];
  char cookies[1024];
  char addresses[1024];
  size_t tag_len = 1024;
  size_t clients_len = 1024;
  size_t cookies_len = 1024;
  size_t addresses_len = 1024;
  std::stringstream sstm;
  sstm << "client." << rados_get_instance_id(cluster);
  std::string me = sstm.str();
  ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  ASSERT_EQ(0, rados_unlock(ioctx, "foo", "TestLock", "Cookie"));
  ASSERT_EQ(0, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  ASSERT_EQ(0, rados_lock_shared(ioctx, "foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  ASSERT_EQ(-34, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  tag_len = 1024;
  clients_len = 1024;
  cookies_len = 1024;
  addresses_len = 1024;
  ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  ASSERT_EQ(0, exclusive);
  ASSERT_EQ(0, strcmp(tag, "Tag"));
  ASSERT_EQ(strlen("Tag") + 1, tag_len);
  ASSERT_EQ(0, strcmp(me.c_str(), clients));
  ASSERT_EQ(me.size() + 1, clients_len);
  ASSERT_EQ(0, strcmp(cookies, "Cookie"));
  ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
}

TEST_F(LibRadosLockECPP, ListLockersPP) {
  std::stringstream sstm;
  sstm << "client." << cluster.get_instance_id();
  std::string me = sstm.str();
  ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  ASSERT_EQ(0, ioctx.unlock("foo", "TestLock", "Cookie"));
  {
    int exclusive;
    std::string tag;
    std::list<librados::locker_t> lockers;
    ASSERT_EQ(0, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
  }
  ASSERT_EQ(0, ioctx.lock_shared("foo", "TestLock", "Cookie", "Tag", "", NULL, 0));
  {
    int exclusive;
    std::string tag;
    std::list<librados::locker_t> lockers;
    ASSERT_EQ(1, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
    std::list<librados::locker_t>::iterator it = lockers.begin();
    ASSERT_FALSE(lockers.end() == it);
    ASSERT_EQ(me, it->client);
    ASSERT_EQ("Cookie", it->cookie);
  }
}

TEST_F(LibRadosLockEC, BreakLock) {
  int exclusive;
  char tag[1024];
  char clients[1024];
  char cookies[1024];
  char addresses[1024];
  size_t tag_len = 1024;
  size_t clients_len = 1024;
  size_t cookies_len = 1024;
  size_t addresses_len = 1024;
  std::stringstream sstm;
  sstm << "client." << rados_get_instance_id(cluster);
  std::string me = sstm.str();
  ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
  ASSERT_EQ(1, rados_list_lockers(ioctx, "foo", "TestLock", &exclusive, tag, &tag_len, clients, &clients_len, cookies, &cookies_len, addresses, &addresses_len ));
  ASSERT_EQ(1, exclusive);
  ASSERT_EQ(0, strcmp(tag, ""));
  ASSERT_EQ(1U, tag_len);
  ASSERT_EQ(0, strcmp(me.c_str(), clients));
  ASSERT_EQ(me.size() + 1, clients_len);
  ASSERT_EQ(0, strcmp(cookies, "Cookie"));
  ASSERT_EQ(strlen("Cookie") + 1, cookies_len);
  ASSERT_EQ(0, rados_break_lock(ioctx, "foo", "TestLock", clients, "Cookie"));
}

TEST_F(LibRadosLockECPP, BreakLockPP) {
  int exclusive;
  std::string tag;
  std::list<librados::locker_t> lockers;
  std::stringstream sstm;
  sstm << "client." << cluster.get_instance_id();
  std::string me = sstm.str();
  ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie",  "", NULL, 0));
  ASSERT_EQ(1, ioctx.list_lockers("foo", "TestLock", &exclusive, &tag, &lockers));
  std::list<librados::locker_t>::iterator it = lockers.begin();
  ASSERT_FALSE(lockers.end() == it);
  ASSERT_EQ(me, it->client);
  ASSERT_EQ("Cookie", it->cookie);
  ASSERT_EQ(0, ioctx.break_lock("foo", "TestLock", it->client, "Cookie"));
}
Commit	Line	Data
7c673cae FG	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
f64942e4	75	TEST_F(LibRadosLock, LockMayRenew) {
7c673cae FG	76	ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
7c673cae FG	77	ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
f64942e4	78	ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
7c673cae FG	79	}
7c673cae FG	80
f64942e4	81	TEST_F(LibRadosLockPP, LockMayRenewPP) {
7c673cae FG	82	ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
7c673cae FG	83	ASSERT_EQ(-EEXIST, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
f64942e4	84	ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
7c673cae FG	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
f64942e4	254	TEST_F(LibRadosLockEC, LockMayRenew) {
7c673cae FG	255	ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
7c673cae FG	256	ASSERT_EQ(-EEXIST, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
f64942e4	257	ASSERT_EQ(0, rados_lock_exclusive(ioctx, "foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
7c673cae FG	258	}
7c673cae FG	259
f64942e4	260	TEST_F(LibRadosLockECPP, LockMayRenewPP) {
7c673cae FG	261	ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
7c673cae FG	262	ASSERT_EQ(-EEXIST, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
f64942e4	263	ASSERT_EQ(0, ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, LOCK_FLAG_MAY_RENEW));
7c673cae FG	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	}