def test_is_in_transaction(self):
# shared mocks
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive('get_transaction_path') \
.and_return('/transaction/path')
fake_zookeeper = flexmock(name='fake_zoo',
exists='exists',
connected=lambda: True)
fake_zookeeper.should_receive('start')
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
# test when the transaction is running
zk.ZKTransaction.should_receive('is_blacklisted').and_return(False)
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(True)
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(True, transaction.is_in_transaction(self.appid, 1))
# and when it's not
zk.ZKTransaction.should_receive('is_blacklisted').and_return(False)
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(False)
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(False, transaction.is_in_transaction(self.appid, 1))
# and when it's blacklisted
zk.ZKTransaction.should_receive('is_blacklisted').and_return(True)
fake_transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertRaises(zk.ZKTransactionException,
transaction.is_in_transaction, self.appid, 1)
def test_acquire_lock(self):
# mock out waitForConnect
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive('get_lock_root_path').\
and_return('/lock/root/path')
zk.ZKTransaction.should_receive('get_transaction_prefix_path').\
and_return('/rootpath/' + self.appid)
fake_zookeeper = flexmock(name='fake_zoo', get='get',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry')
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
# first, test out getting a lock for a regular transaction, that we don't
# already have the lock for
zk.ZKTransaction.should_receive('is_in_transaction').and_return(False)
zk.ZKTransaction.should_receive('acquire_additional_lock').and_return(True)
transaction = zk.ZKTransaction(host="something")
self.assertEquals(True, transaction.acquire_lock(self.appid, "txid",
"somekey"))
# next, test when we're in a transaction and we already have the lock
zk.ZKTransaction.should_receive('is_in_transaction').and_return(True)
zk.ZKTransaction.should_receive('get_transaction_lock_list_path').\
and_return('/rootpath/' + self.appid + "/tx1")
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_return(['/lock/root/path'])
transaction = zk.ZKTransaction(host="something")
self.assertEquals(True, transaction.acquire_lock(self.appid, "txid",
"somekey"))
# next, test when we're in a non-XG transaction and we're not in the lock
# root path
zk.ZKTransaction.should_receive('is_in_transaction').and_return(True)
zk.ZKTransaction.should_receive('get_transaction_lock_list_path').\
and_return('/rootpath/' + self.appid + "/tx1")
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_return(['/lock/root/path2'])
zk.ZKTransaction.should_receive('is_xg').and_return(False)
transaction = zk.ZKTransaction(host="something")
self.assertRaises(zk.ZKTransactionException, transaction.acquire_lock,
self.appid, "txid", "somekey")
# next, test when we're in a XG transaction and we're not in the lock
# root path
zk.ZKTransaction.should_receive('is_in_transaction').and_return(True)
zk.ZKTransaction.should_receive('get_transaction_lock_list_path').\
and_return('/rootpath/' + self.appid + "/tx1")
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_return(['/lock/root/path2'])
zk.ZKTransaction.should_receive('is_xg').and_return(True)
transaction = zk.ZKTransaction(host="something")
self.assertEquals(True, transaction.acquire_lock(self.appid, "txid",
"somekey"))
def test_acquire_additional_lock(self):
# mock out waitForConnect
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive('check_transaction')
zk.ZKTransaction.should_receive('get_transaction_path').\
and_return('/txn/path')
zk.ZKTransaction.should_receive('get_lock_root_path').\
and_return('/lock/root/path')
zk.ZKTransaction.should_receive('get_transaction_prefix_path').\
and_return('/rootpath/' + self.appid)
fake_zookeeper = flexmock(name='fake_zoo', create='create',
create_async='create_async', get='get', set_async='set_async',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args('create', str, makepath=bool, sequence=bool,
ephemeral=bool, value=str, acl=None).and_return("/some/lock/path")
fake_zookeeper.should_receive('retry').with_args('create_async', str, value=str,
acl=None, ephemeral=bool, makepath=bool, sequence=bool)
fake_zookeeper.should_receive('retry').with_args('create_async', str, value=str,
acl=str, ephemeral=bool, makepath=bool, sequence=bool)
lock_list = ['path1', 'path2', 'path3']
lock_list_str = zk.LOCK_LIST_SEPARATOR.join(lock_list)
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_return([lock_list_str])
fake_zookeeper.should_receive('retry').with_args('set_async', str, str)
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
transaction = zk.ZKTransaction(host="something")
self.assertEquals(True, transaction.acquire_additional_lock(self.appid,
"txid", "somekey", False))
# Test for when we want to create a new ZK node for the lock path
self.assertEquals(True, transaction.acquire_additional_lock(self.appid,
"txid", "somekey", True))
# Test for existing max groups
lock_list = ['path' + str(num+1) for num in range(MAX_GROUPS_FOR_XG)]
lock_list_str = zk.LOCK_LIST_SEPARATOR.join(lock_list)
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_return([lock_list_str])
transaction = zk.ZKTransaction(host="something")
self.assertRaises(zk.ZKTransactionException,
transaction.acquire_additional_lock, self.appid, "txid", "somekey", False)
# Test for when there is a node which already exists.
fake_zookeeper.should_receive('retry').with_args('create', str, str, None,
bool, bool, bool).and_raise(kazoo.exceptions.NodeExistsError)
transaction = zk.ZKTransaction(host="something")
self.assertRaises(zk.ZKTransactionException,
transaction.acquire_additional_lock, self.appid, "txid", "somekey", False)
def test_versions_on_failure(self):
zoo = zk.ZKTransaction()
txid = zoo.get_transaction_id(self.appid, is_xg=True)
zoo.acquire_lock(self.appid, txid, "__allocate11__")
zoo.acquire_lock(self.appid, txid, "__allocate12__")
current_id_1 = zoo.get_valid_transaction_id(self.appid, txid,
"__allocate11__/key")
current_id_2 = zoo.get_valid_transaction_id(self.appid, txid,
"__allocate12__/key")
zoo.register_updated_key(self.appid, current_id_1, txid,
"__allocate11__/key")
zoo.register_updated_key(self.appid, current_id_2, txid,
"__allocate12__/key")
zoo.notify_failed_transaction(self.appid, txid)
self.assertEquals(
current_id_1,
zoo.get_valid_transaction_id(self.appid, txid,
"__allocate11__/key"))
self.assertEquals(
current_id_2,
zoo.get_valid_transaction_id(self.appid, txid,
"__allocate12__/key"))
self.assertRaises(zk.ZKTransactionException, zoo.release_lock,
self.appid, txid)
def test_versions_on_success(self):
zoo = zk.ZKTransaction()
txid = zoo.get_transaction_id(self.appid, is_xg=True)
zoo.acquire_lock(self.appid, txid, "__allocate9__")
zoo.acquire_lock(self.appid, txid, "__allocate10__")
current_id_1 = zoo.get_valid_transaction_id(self.appid, txid,
"__allocate9__/key")
current_id_2 = zoo.get_valid_transaction_id(self.appid, txid,
"__allocate10__/key")
zoo.register_updated_key(self.appid, current_id_1, txid,
"__allocate9__/key")
zoo.register_updated_key(self.appid, current_id_2, txid,
"__allocate10__/key")
self.assertEquals(
txid,
zoo.get_valid_transaction_id(self.appid, txid,
"__allocate9__/key"))
self.assertEquals(
txid,
zoo.get_valid_transaction_id(self.appid, txid,
"__allocate10__/key"))
self.assertEquals(True, zoo.release_lock(self.appid, txid))
def test_create_node(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive(
'get_transaction_prefix_path').with_args(
self.appid).and_return('/rootpath')
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
create='create',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args('create',
str,
value=str,
acl=None,
makepath=bool,
sequence=bool,
ephemeral=bool)
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
# mock out zookeeper.create for txn id
path_to_create = "/rootpath/" + self.appid
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(
None, transaction.create_node('/rootpath/' + self.appid, 'now'))
def test_register_updated_key(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive('get_valid_transaction_path').\
and_return('/txn/path')
zk.ZKTransaction.should_receive('get_transaction_path').\
and_return('/txn/path')
zk.ZKTransaction.should_receive('get_blacklist_root_path').\
and_return("bl_root_path")
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
exists='exists',
set_async='set_async',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(True)
fake_zookeeper.should_receive('retry').with_args('set_async', str, str)
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(
True,
transaction.register_updated_key(self.appid, "1", "2", "somekey"))
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(False)
self.assertRaises(ZKTransactionException,
transaction.register_updated_key, self.appid, "1",
"2", "somekey")
def test_increment_and_get_counter(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive(
'get_transaction_prefix_path').with_args(
self.appid).and_return('/rootpath')
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
create='create',
delete_async='delete_async',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').and_return(None)
fake_counter = flexmock(name='fake_counter', value='value')
fake_counter.value = 1
fake_counter.should_receive('__add__').and_return(2)
fake_zookeeper.should_receive("Counter").and_return(fake_counter)
# mock out deleting the zero id we get the first time around
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
# assert, make sure we got back our id
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals((0, 1),
transaction.increment_and_get_counter(self.appid, 1))
def test_check_transaction(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive(
'get_transaction_prefix_path').with_args(
self.appid).and_return('/rootpath')
zk.ZKTransaction.should_receive('is_blacklisted').and_return(False)
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
exists='exists',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(True)
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(True, transaction.check_transaction(self.appid, 1))
# Check to make sure it raises exception for blacklisted transactions.
zk.ZKTransaction.should_receive('is_blacklisted').and_return(True)
self.assertRaises(zk.ZKTransactionException,
transaction.check_transaction, self.appid, 1)
zk.ZKTransaction.should_receive('is_blacklisted').and_return(False)
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(False)
self.assertRaises(zk.ZKTransactionException,
transaction.check_transaction, self.appid, 1)
def test_create_sequence_node(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive(
'get_transaction_prefix_path').with_args(
self.appid).and_return('/rootpath')
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
create='create',
delete='delete',
connected=lambda: True)
fake_zookeeper.should_receive('start')
# mock out zookeeper.create for txn id
path_to_create = "/rootpath/" + self.appid
zero_path = path_to_create + "/0"
nonzero_path = path_to_create + "/1"
fake_zookeeper.should_receive('retry').with_args('create', str, value=str,
acl=None, makepath=bool, sequence=bool, ephemeral=bool).\
and_return(zero_path).and_return(nonzero_path)
# mock out deleting the zero id we get the first time around
fake_zookeeper.should_receive('retry').with_args('delete', zero_path)
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
# assert, make sure we got back our id
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(1, transaction.create_sequence_node('/rootpath/' + \
self.appid, 'now'))
def test_is_blacklisted(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive('get_blacklist_root_path').\
and_return("bl_root_path")
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
create='create',
exists='exists',
get_children='get_children',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args(
'create', str, str, None, bool, bool, bool).and_return()
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(True)
fake_zookeeper.should_receive('retry').with_args('get_children', str) \
.and_return(['1','2'])
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(True, transaction.is_blacklisted(self.appid, 1))
def get_zookeeper(zk_location_ips):
""" Returns a handler for making ZooKeeper operations.
Args:
zk_location_ips: A list of ZooKeeper location ips.
"""
zookeeper_locations = get_zk_locations_string(zk_location_ips)
zookeeper = zk.ZKTransaction(host=zookeeper_locations, start_gc=False)
return zookeeper
def test_xg_successful_transaction(self):
zoo = zk.ZKTransaction()
txid = zoo.get_transaction_id(self.appid, is_xg=True)
zoo.acquire_lock(self.appid, txid, "__allocate1__")
zoo.acquire_lock(self.appid, txid, "__allocate2__")
zoo.acquire_lock(self.appid, txid, "__allocate3__")
self.assertEquals(True, zoo.release_lock(self.appid, txid))
def test_is_xg(self):
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
exists='exists',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(True)
transaction = zk.ZKTransaction(zk_client=fake_zookeeper)
self.assertEquals(True, transaction.is_xg(self.appid, 1))
def test_try_garbage_collection(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive('update_node')
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
exists='exists',
get='get',
get_children='get_children',
create='create',
delete='delete')
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(True)
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_return([str(time.time() + 10000)])
fake_zookeeper.should_receive('retry').with_args('get_children', str) \
.and_return(['1','2','3'])
fake_zookeeper.should_receive('retry').with_args('create',
str,
value=str,
acl=None,
ephemeral=bool)
fake_zookeeper.should_receive('retry').with_args('delete', str)
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
# Put the last time we ran GC way into the future.
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(
False, transaction.try_garbage_collection(self.appid,
"/some/path"))
# Make it so we recently ran the GC
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_return([str(time.time())])
self.assertEquals(
False, transaction.try_garbage_collection(self.appid,
"/some/path"))
# Make it so we ran the GC a long time ago.
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_return([str(time.time() - 1000)])
self.assertEquals(
True, transaction.try_garbage_collection(self.appid, "/some/path"))
# No node means we have not run the GC before, so run it.
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_raise(kazoo.exceptions.NoNodeError)
self.assertEquals(
True, transaction.try_garbage_collection(self.appid, "/some/path"))
def test_xg_failed_transaction(self):
zoo = zk.ZKTransaction()
txid = zoo.get_transaction_id(self.appid, is_xg=True)
zoo.acquire_lock(self.appid, txid, "__allocate4__")
zoo.acquire_lock(self.appid, txid, "__allocate5__")
zoo.acquire_lock(self.appid, txid, "__allocate6__")
zoo.acquire_lock(self.appid, txid, "__allocate7__")
zoo.acquire_lock(self.appid, txid, "__allocate8__")
self.assertRaises(zk.ZKTransactionException, zoo.acquire_lock,
self.appid, txid, "__allocate9__")
def test_is_xg(self):
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
exists='exists',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(True)
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(True, transaction.is_xg(self.appid, 1))
def test_get_txn_path_before_getting_id(self):
# mock out initializing a ZK connection
flexmock(zk.ZKTransaction)
fake_zookeeper = flexmock(name='fake_zoo')
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry')
zk.ZKTransaction.should_receive('get_app_root_path').and_return(
"app_root_path")
expected = zk.PATH_SEPARATOR.join(
["app_root_path", zk.APP_TX_PATH, zk.APP_TX_PREFIX])
transaction = zk.ZKTransaction(zk_client=fake_zookeeper)
self.assertEquals(
expected, transaction.get_txn_path_before_getting_id(self.appid))
def test_release_lock_with_path(self):
flexmock(zk.ZKTransaction)
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo', delete='delete')
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args('delete', str)
transaction = zk.ZKTransaction(zk_client=fake_zookeeper)
self.assertEquals(True,
transaction.release_lock_with_path('some/path'))
fake_zookeeper.should_receive('retry').with_args('delete', str). \
and_raise(kazoo.exceptions.NoNodeError)
self.assertRaises(ZKTransactionException,
transaction.release_lock_with_path, 'some/path')
def test_get_lock_with_path(self):
flexmock(zk.ZKTransaction)
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo', create='create')
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args(
'create', str, value=str, acl=None,
ephemeral=bool).and_return(True)
transaction = zk.ZKTransaction(zk_client=fake_zookeeper)
self.assertEquals(True, transaction.get_lock_with_path('path'))
fake_zookeeper.should_receive('retry').with_args(
'create', str, value=str, acl=None,
ephemeral=bool).and_raise(kazoo.exceptions.NodeExistsError)
self.assertEquals(False, transaction.get_lock_with_path('some/path'))
def test_get_xg_path(self):
# mock out initializing a ZK connection
flexmock(zk.ZKTransaction)
fake_zookeeper = flexmock(name='fake_zoo')
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry')
tx_id = 100
tx_str = zk.APP_TX_PREFIX + "%010d" % tx_id
zk.ZKTransaction.should_receive('get_app_root_path') \
.and_return("app_root_path")
expected = zk.PATH_SEPARATOR.join(
["app_root_path", zk.APP_TX_PATH, tx_str, zk.XG_PREFIX])
transaction = zk.ZKTransaction(zk_client=fake_zookeeper)
self.assertEquals(expected, transaction.get_xg_path("xxx", 100))
def test_release_lock(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive('check_transaction')
zk.ZKTransaction.should_receive('get_transaction_path').\
and_return('/rootpath')
zk.ZKTransaction.should_receive('get_transaction_lock_list_path').\
and_return('/rootpath')
zk.ZKTransaction.should_receive('is_xg').and_return(False)
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
exists='exists',
get='get',
delete='delete',
delete_async='delete_async',
get_children='get_children',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(True)
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_return(['/1/2/3'])
fake_zookeeper.should_receive('retry').with_args('delete_async', str)
fake_zookeeper.should_receive('retry').with_args('delete', str)
fake_zookeeper.should_receive('retry').with_args('get_children', str) \
.and_return(['1','2'])
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(True, transaction.release_lock(self.appid, 1))
zk.ZKTransaction.should_receive('is_xg').and_return(True)
self.assertEquals(True, transaction.release_lock(self.appid, 1))
# Check to make sure it raises exception for blacklisted transactions.
zk.ZKTransaction.should_receive('is_xg').and_return(False)
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_raise(kazoo.exceptions.NoNodeError)
self.assertRaises(zk.ZKTransactionException, transaction.release_lock,
self.appid, 1)
def test_increment_and_get_counter(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive(
'get_transaction_prefix_path').with_args(
self.appid).and_return('/rootpath')
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
create='create',
delete_async='delete_async',
connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').and_return(None)
flexmock(InspectableCounter).should_receive('__add__').and_return(1)
# assert, make sure we got back our id
transaction = zk.ZKTransaction(zk_client=fake_zookeeper)
self.assertEquals((0, 1),
transaction.increment_and_get_counter(self.appid, 1))
def test_execute_garbage_collection(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive('notify_failed_transaction')
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo',
exists='exists',
get='get',
get_children='get_children')
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry').with_args('exists', str) \
.and_return(True)
fake_zookeeper.should_receive('retry').with_args('get', str) \
.and_return([str(time.time() + 10000)])
fake_zookeeper.should_receive('retry').with_args('get_children', str) \
.and_return(['1','2','3'])
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
transaction = zk.ZKTransaction(host="something", start_gc=False)
transaction.execute_garbage_collection(self.appid, "some/path")
def test_get_transaction_id(self):
# mock out getTransactionRootPath
flexmock(zk.ZKTransaction)
zk.ZKTransaction.should_receive(
'get_transaction_prefix_path').with_args(
self.appid).and_return('/rootpath/' + self.appid)
path_to_create = "/rootpath/" + self.appid + "/" + zk.APP_TX_PREFIX
zk.ZKTransaction.should_receive('get_txn_path_before_getting_id') \
.with_args(self.appid).and_return(path_to_create)
# mock out time.time
flexmock(time)
time.should_receive('time').and_return(1000)
# mock out initializing a ZK connection
fake_zookeeper = flexmock(name='fake_zoo', connected=lambda: True)
fake_zookeeper.should_receive('start')
fake_zookeeper.should_receive('retry')
flexmock(kazoo.client)
kazoo.client.should_receive('KazooClient').and_return(fake_zookeeper)
# mock out making the txn id
zk.ZKTransaction.should_receive('create_sequence_node').with_args(
path_to_create, '1000').and_return(1)
# mock out zookeeper.create for is_xg
xg_path = path_to_create + "/1/" + zk.XG_PREFIX
zk.ZKTransaction.should_receive('get_xg_path').and_return(xg_path)
zk.ZKTransaction.should_receive('create_node').with_args(
xg_path, '1000')
# assert, make sure we got back our id
transaction = zk.ZKTransaction(host="something", start_gc=False)
self.assertEquals(
1, transaction.get_transaction_id(self.appid, is_xg=True))
ret = self.zk.acquire_lock(app, txid2, key)
self.assertTrue(ret)
# get previous valid id
ret = self.zk.get_valid_transaction_id(app, txid, key + "/a")
self.assertEqual(vid, ret)
# update previous valid id
vid = 100L
self.zk.register_updated_key(app, txid2, vid, key + "/a")
# try to get updated previous valid id
ret = self.zk.get_valid_transaction_id(app, txid, key + "/a")
self.assertEqual(vid, ret)
self.assertTrue(self.zk.release_lock(app, txid2))
def setUp(self):
global zkconnection
self.zk = zkconnection
def tearDown(self):
# for debug
self.zk.dump_tree("/appscale/apps")
if __name__ == "__main__":
global zkconnection
zkconnection = zktransaction.ZKTransaction()
if len(sys.argv) > 1 and sys.argv[1] == "dump":
zkconnection.dump_tree("/appscale")
else:
zkconnection.deleteRecursive("/appscale/apps")
test_support.run_unittest(TestZKTransaction)
zkconnection.close()
def test_no_lock_with_notify_failed_transaction(self):
zoo = zk.ZKTransaction()
txid = zoo.get_transaction_id(self.appid, is_xg=False)
zoo.notify_failed_transaction(self.appid, txid)
self.assertRaises(zk.ZKTransactionException, zoo.release_lock,
self.appid, txid)
def test_two_locks_transaction(self):
zoo = zk.ZKTransaction()
txid = zoo.get_transaction_id(self.appid, is_xg=False)
zoo.acquire_lock(self.appid, txid, "__lock_one__")
self.assertRaises(zk.ZKTransactionException, zoo.acquire_lock,
self.appid, txid, "__lock_two__")
def test_no_lock_transaction(self):
zoo = zk.ZKTransaction()
txid = zoo.get_transaction_id(self.appid, is_xg=False)
self.assertEquals(True, zoo.release_lock(self.appid, txid))