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 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 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 _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 _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 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 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()