def testAcquireNonExistingResource(self):
try:
rm.acquireResource("null", "resource", rm.EXCLUSIVE)
except KeyError:
return
self.fail("Managed to get status on a non existing resource")
def testAcquireNonExistingResource(self):
try:
rm.acquireResource("null", "resource", rm.EXCLUSIVE)
except KeyError:
return
self.fail("Managed to get status on a non existing resource")
def testResourceWrapper(self):
s = StringIO
with rm.acquireResource("string", "test", rm.EXCLUSIVE) as resource:
for attr in dir(s):
if attr == "close":
continue
self.assertTrue(hasattr(resource, attr))
def testResourceWrapper(self):
s = StringIO
with rm.acquireResource("string", "test", rm.EXCLUSIVE) as resource:
for attr in dir(s):
if attr == "close":
continue
self.assertTrue(hasattr(resource, attr))
def testResourceInvalidation(self):
resource = rm.acquireResource("string", "test", rm.EXCLUSIVE)
try:
resource.write("dsada")
except:
self.fail()
resource.release()
self.assertRaises(Exception, resource.write, "test")
def testResourceInvalidation(self):
resource = rm.acquireResource("string", "test", rm.EXCLUSIVE)
try:
resource.write("dsada")
except:
self.fail()
resource.release()
self.assertRaises(Exception, resource.write, "test")
def testResourceStatuses(self):
self.assertEquals(rm._getResourceStatus("storage", "resource"),
rm.LockState.free)
exclusive1 = rm.acquireResource("storage", "resource", rm.EXCLUSIVE)
self.assertEquals(rm._getResourceStatus("storage", "resource"),
rm.LockState.locked)
exclusive1.release()
shared1 = rm.acquireResource("storage", "resource", rm.SHARED)
self.assertEquals(rm._getResourceStatus("storage", "resource"),
rm.LockState.shared)
shared1.release()
try:
self.assertEquals(rm._getResourceStatus("null", "resource"),
rm.LockState.free)
except KeyError:
return
self.fail("Managed to get status on a non existing resource")
def testResourceStatuses(self):
self.assertEquals(rm._getResourceStatus("storage", "resource"),
rm.LockState.free)
exclusive1 = rm.acquireResource("storage", "resource", rm.EXCLUSIVE)
self.assertEquals(rm._getResourceStatus("storage", "resource"),
rm.LockState.locked)
exclusive1.release()
shared1 = rm.acquireResource("storage", "resource", rm.SHARED)
self.assertEquals(rm._getResourceStatus("storage", "resource"),
rm.LockState.shared)
shared1.release()
try:
self.assertEquals(rm._getResourceStatus("null", "resource"),
rm.LockState.free)
except KeyError:
return
self.fail("Managed to get status on a non existing resource")
def testRequestWithBadCallbackOnCancel(self):
def callback(req, res):
raise Exception("BUY MILK!")
blocker = rm.acquireResource("string", "resource", rm.EXCLUSIVE)
req = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
req.cancel()
blocker.release()
def testRequestWithBadCallbackOnCancel(self):
def callback(req, res):
raise Exception("BUY MILK!")
blocker = rm.acquireResource("string", "resource", rm.EXCLUSIVE)
req = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
req.cancel()
blocker.release()
def testAccessAttributeNotExposedByWrapper(self):
with rm.acquireResource("string", "test", rm.EXCLUSIVE) as resource:
try:
resource.THERE_IS_NO_WAY_I_EXIST
except AttributeError:
return
except Exception as ex:
self.fail("Wrong exception was raised. "
"Expected AttributeError got %s",
ex.__class__.__name__)
self.fail("Managed to access an attribute not exposed by wrapper")
def testAccessAttributeNotExposedByWrapper(self):
with rm.acquireResource("string", "test", rm.EXCLUSIVE) as resource:
try:
resource.THERE_IS_NO_WAY_I_EXIST
except AttributeError:
return
except Exception as ex:
self.fail("Wrong exception was raised. "
"Expected AttributeError got %s",
ex.__class__.__name__)
self.fail("Managed to access an attribute not exposed by wrapper")
def _run(self):
sd_manifest = sdCache.produce_manifest(self.params.sd_id)
if not sd_manifest.supports_device_reduce():
raise se.StorageDomainVersionError(
"move device not supported for domain version %s" %
sd_manifest.getVersion())
# TODO: we assume at this point that the domain isn't active and can't
# be activated - we need to ensure that.
with rm.acquireResource(STORAGE, self.params.sd_id, rm.EXCLUSIVE):
with sd_manifest.domain_id(self.host_id), \
sd_manifest.domain_lock(self.host_id):
sd_manifest.movePV(self.params.src_guid, self.params.dst_guids)
def testFailCreateAfterSwitch(self):
resources = []
def callback(req, res):
resources.append(res)
exclusive1 = rm.acquireResource(
"failAfterSwitch", "resource", rm.EXCLUSIVE)
sharedReq1 = rm._registerResource(
"failAfterSwitch", "resource", rm.SHARED, callback)
exclusive1.release()
self.assertTrue(sharedReq1.canceled())
self.assertEquals(resources[0], None)
def testFailCreateAfterSwitch(self):
resources = []
def callback(req, res):
resources.append(res)
exclusive1 = rm.acquireResource(
"failAfterSwitch", "resource", rm.EXCLUSIVE)
sharedReq1 = rm._registerResource(
"failAfterSwitch", "resource", rm.SHARED, callback)
exclusive1.release()
self.assertTrue(sharedReq1.canceled())
self.assertEqual(resources[0], None)
def _run(self):
vol_format = sc.name2type(self.vol_info.vol_format)
with self.sd_manifest.domain_lock(self.host_id):
image_res_ns = sd.getNamespace(sc.IMAGE_NAMESPACE,
self.sd_manifest.sdUUID)
with rm.acquireResource(image_res_ns, self.vol_info.img_id,
rm.EXCLUSIVE):
artifacts = self.sd_manifest.get_volume_artifacts(
self.vol_info.img_id, self.vol_info.vol_id)
artifacts.create(
self.vol_info.virtual_size, vol_format,
self.vol_info.disk_type, self.vol_info.description,
self.vol_info.parent, self.vol_info.initial_size)
artifacts.commit()
def testRequestRecancel(self):
resources = []
def callback(req, res):
resources.insert(0, res)
blocker = rm.acquireResource("string", "resource", rm.EXCLUSIVE)
req = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
req.cancel()
self.assertRaises(rm.RequestAlreadyProcessedError, req.cancel)
blocker.release()
def testRequestRecancel(self):
resources = []
def callback(req, res):
resources.insert(0, res)
blocker = rm.acquireResource("string", "resource", rm.EXCLUSIVE)
req = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
req.cancel()
self.assertRaises(rm.RequestAlreadyProcessedError, req.cancel)
blocker.release()
def _run(self):
vol_format = sc.name2type(self.vol_info.vol_format)
with self.sd_manifest.domain_lock(self.host_id):
image_res_ns = sd.getNamespace(sc.IMAGE_NAMESPACE,
self.sd_manifest.sdUUID)
with rm.acquireResource(image_res_ns, self.vol_info.img_id,
rm.EXCLUSIVE):
artifacts = self.sd_manifest.get_volume_artifacts(
self.vol_info.img_id, self.vol_info.vol_id)
artifacts.create(self.vol_info.virtual_size, vol_format,
self.vol_info.disk_type,
self.vol_info.description,
self.vol_info.parent,
self.vol_info.initial_size)
artifacts.commit()
def testResourceAutorelease(self):
self.log.info("Acquiring resource", extra={'resource': "bob"})
res = rm.acquireResource("storage", "resource", rm.SHARED)
resProxy = proxy(res)
res = None
# wait for object to die
self.log.info("Waiting for request")
try:
while True:
resProxy.granted()
except:
pass
self.log.info("Waiting for autoclean")
while True:
resStatus = rm._getResourceStatus("storage", "resource")
if resStatus == rm.LockState.free:
break
time.sleep(1)
def testResourceAutorelease(self):
self.log.info("Acquiring resource", extra={'resource': "bob"})
res = rm.acquireResource("storage", "resource", rm.SHARED)
resProxy = proxy(res)
res = None
# wait for object to die
self.log.info("Waiting for request")
try:
while True:
resProxy.granted()
except:
pass
self.log.info("Waiting for autoclean")
while True:
resStatus = rm._getResourceStatus("storage", "resource")
if resStatus == rm.LockState.free:
break
time.sleep(1)
def testCancelExclusiveBetweenShared(self):
resources = []
def callback(req, res):
resources.insert(0, res)
exclusive1 = rm.acquireResource("string", "resource", rm.EXCLUSIVE)
sharedReq1 = rm._registerResource(
"string", "resource", rm.SHARED, callback)
sharedReq2 = rm._registerResource(
"string", "resource", rm.SHARED, callback)
exclusiveReq1 = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
sharedReq3 = rm._registerResource(
"string", "resource", rm.SHARED, callback)
sharedReq4 = rm._registerResource(
"string", "resource", rm.SHARED, callback)
self.assertFalse(sharedReq1.granted())
self.assertFalse(sharedReq2.granted())
self.assertFalse(exclusiveReq1.granted())
self.assertFalse(sharedReq3.granted())
self.assertFalse(sharedReq4.granted())
exclusiveReq1.cancel()
resources.pop()
self.assertFalse(sharedReq1.granted())
self.assertFalse(sharedReq2.granted())
self.assertFalse(exclusiveReq1.granted())
self.assertTrue(exclusiveReq1.canceled())
self.assertFalse(sharedReq3.granted())
self.assertFalse(sharedReq4.granted())
exclusive1.release()
self.assertTrue(sharedReq1.granted())
self.assertTrue(sharedReq2.granted())
self.assertTrue(sharedReq3.granted())
self.assertTrue(sharedReq4.granted())
while len(resources) > 0:
resources.pop().release()
def testCancelExclusiveBetweenShared(self):
resources = []
def callback(req, res):
resources.insert(0, res)
exclusive1 = rm.acquireResource("string", "resource", rm.EXCLUSIVE)
sharedReq1 = rm._registerResource(
"string", "resource", rm.SHARED, callback)
sharedReq2 = rm._registerResource(
"string", "resource", rm.SHARED, callback)
exclusiveReq1 = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
sharedReq3 = rm._registerResource(
"string", "resource", rm.SHARED, callback)
sharedReq4 = rm._registerResource(
"string", "resource", rm.SHARED, callback)
self.assertFalse(sharedReq1.granted())
self.assertFalse(sharedReq2.granted())
self.assertFalse(exclusiveReq1.granted())
self.assertFalse(sharedReq3.granted())
self.assertFalse(sharedReq4.granted())
exclusiveReq1.cancel()
resources.pop()
self.assertFalse(sharedReq1.granted())
self.assertFalse(sharedReq2.granted())
self.assertFalse(exclusiveReq1.granted())
self.assertTrue(exclusiveReq1.canceled())
self.assertFalse(sharedReq3.granted())
self.assertFalse(sharedReq4.granted())
exclusive1.release()
self.assertTrue(sharedReq1.granted())
self.assertTrue(sharedReq2.granted())
self.assertTrue(sharedReq3.granted())
self.assertTrue(sharedReq4.granted())
while len(resources) > 0:
resources.pop().release()
def testResourceLockSwitch(self, namespace="string"):
resources = []
def callback(req, res):
resources.insert(0, res)
exclusive1 = rm.acquireResource(namespace, "resource", rm.EXCLUSIVE)
sharedReq1 = rm._registerResource(
namespace, "resource", rm.SHARED, callback)
sharedReq2 = rm._registerResource(
namespace, "resource", rm.SHARED, callback)
exclusive2 = rm._registerResource(
namespace, "resource", rm.EXCLUSIVE, callback)
exclusive3 = rm._registerResource(
namespace, "resource", rm.EXCLUSIVE, callback)
sharedReq3 = rm._registerResource(
namespace, "resource", rm.SHARED, callback)
self.assertEqual(exclusive1.read(), "resource:exclusive")
exclusive1.release()
self.assertEqual(resources[-1].read(), "resource:shared")
resources.pop().release()
self.assertEqual(resources[-1].read(), "")
resources.pop().release()
self.assertEqual(resources[-1].read(), "resource:exclusive")
resources.pop().release()
self.assertEqual(resources[-1].read(), "")
resources.pop().release()
self.assertEqual(resources[-1].read(), "resource:shared")
resources.pop().release()
# This part is to stop pyflakes for complaining, the reason I need the
# resourcesRefs alive is so that the manage will not autocollect during
# the test
hash(sharedReq1)
hash(sharedReq2)
hash(sharedReq3)
hash(exclusive2)
hash(exclusive3)
hash(sharedReq3)
def testResourceLockSwitch(self, namespace="string"):
resources = []
def callback(req, res):
resources.insert(0, res)
exclusive1 = rm.acquireResource(namespace, "resource", rm.EXCLUSIVE)
sharedReq1 = rm._registerResource(
namespace, "resource", rm.SHARED, callback)
sharedReq2 = rm._registerResource(
namespace, "resource", rm.SHARED, callback)
exclusive2 = rm._registerResource(
namespace, "resource", rm.EXCLUSIVE, callback)
exclusive3 = rm._registerResource(
namespace, "resource", rm.EXCLUSIVE, callback)
sharedReq3 = rm._registerResource(
namespace, "resource", rm.SHARED, callback)
self.assertEquals(exclusive1.read(), "resource:exclusive")
exclusive1.release()
self.assertEquals(resources[-1].read(), "resource:shared")
resources.pop().release()
self.assertEquals(resources[-1].read(), "")
resources.pop().release()
self.assertEquals(resources[-1].read(), "resource:exclusive")
resources.pop().release()
self.assertEquals(resources[-1].read(), "")
resources.pop().release()
self.assertEquals(resources[-1].read(), "resource:shared")
resources.pop().release()
# This part is to stop pyflakes for complaining, the reason I need the
# resourcesRefs alive is so that the manage will not autocollect during
# the test
hash(sharedReq1)
hash(sharedReq2)
hash(sharedReq3)
hash(exclusive2)
hash(exclusive3)
hash(sharedReq3)
def testAcquireResourceExclusive(self):
resources = []
def callback(req, res):
resources.append(res)
exclusive1 = rm.acquireResource("storage", "resource", rm.EXCLUSIVE)
sharedReq1 = rm._registerResource(
"storage", "resource", rm.SHARED, callback)
sharedReq2 = rm._registerResource(
"storage", "resource", rm.SHARED, callback)
exclusiveReq1 = rm._registerResource(
"storage", "resource", rm.EXCLUSIVE, callback)
exclusiveReq2 = rm._registerResource(
"storage", "resource", rm.EXCLUSIVE, callback)
self.assertFalse(sharedReq1.granted())
self.assertFalse(sharedReq2.granted())
self.assertFalse(exclusiveReq1.granted())
self.assertFalse(exclusiveReq2.granted())
exclusive1.release()
self.assertTrue(sharedReq1.granted())
self.assertTrue(sharedReq2.granted())
self.assertFalse(exclusiveReq1.granted())
self.assertFalse(exclusiveReq2.granted())
resources.pop().release() # Shared 1
self.assertFalse(exclusiveReq1.granted())
self.assertFalse(exclusiveReq2.granted())
resources.pop().release() # Shared 2
self.assertTrue(exclusiveReq1.granted())
self.assertFalse(exclusiveReq2.granted())
resources.pop().release() # exclusiveReq 1
self.assertTrue(exclusiveReq2.granted())
resources.pop().release() # exclusiveReq 2
def testAcquireResourceExclusive(self):
resources = []
def callback(req, res):
resources.append(res)
exclusive1 = rm.acquireResource("storage", "resource", rm.EXCLUSIVE)
sharedReq1 = rm._registerResource(
"storage", "resource", rm.SHARED, callback)
sharedReq2 = rm._registerResource(
"storage", "resource", rm.SHARED, callback)
exclusiveReq1 = rm._registerResource(
"storage", "resource", rm.EXCLUSIVE, callback)
exclusiveReq2 = rm._registerResource(
"storage", "resource", rm.EXCLUSIVE, callback)
self.assertFalse(sharedReq1.granted())
self.assertFalse(sharedReq2.granted())
self.assertFalse(exclusiveReq1.granted())
self.assertFalse(exclusiveReq2.granted())
exclusive1.release()
self.assertTrue(sharedReq1.granted())
self.assertTrue(sharedReq2.granted())
self.assertFalse(exclusiveReq1.granted())
self.assertFalse(exclusiveReq2.granted())
resources.pop().release() # Shared 1
self.assertFalse(exclusiveReq1.granted())
self.assertFalse(exclusiveReq2.granted())
resources.pop().release() # Shared 2
self.assertTrue(exclusiveReq1.granted())
self.assertFalse(exclusiveReq2.granted())
resources.pop().release() # exclusiveReq 1
self.assertTrue(exclusiveReq2.granted())
resources.pop().release() # exclusiveReq 2
def testRereleaseResource(self):
res = rm.acquireResource("string", "resource", rm.EXCLUSIVE)
res.release()
res.release()
def testResourceAcquireTimeout(self):
exclusive1 = rm.acquireResource("string", "resource", rm.EXCLUSIVE)
self.assertRaises(rm.RequestTimedOutError,
rm.acquireResource, "string", "resource",
rm.EXCLUSIVE, 1)
exclusive1.release()
def testAcquireResourceShared(self):
res1 = rm.acquireResource("storage", "resource", rm.SHARED)
res2 = rm.acquireResource("storage", "resource", rm.SHARED, 10)
res1.release()
res2.release()
def testAcquireResourceShared(self):
res1 = rm.acquireResource("storage", "resource", rm.SHARED)
res2 = rm.acquireResource("storage", "resource", rm.SHARED, 10)
res1.release()
res2.release()
def testRereleaseResource(self):
res = rm.acquireResource("string", "resource", rm.EXCLUSIVE)
res.release()
res.release()
def testResourceAcquireTimeout(self):
exclusive1 = rm.acquireResource("string", "resource", rm.EXCLUSIVE)
self.assertRaises(rm.RequestTimedOutError,
rm.acquireResource, "string", "resource",
rm.EXCLUSIVE, 1)
exclusive1.release()
