def register():
time.sleep(rnd.randint(0, 4))
rm._registerResource("string",
"resource",
lockTranslator[rnd.randint(0, 1)],
callback)
threadLimit.release()
def register():
time.sleep(rnd.randint(0, 4))
rm._registerResource("string",
"resource",
lockTranslator[rnd.randint(0, 1)],
callback)
threadLimit.release()
def testCancelRequest(self):
resources = []
def callback(req, res):
resources.append(res)
exclusiveReq1 = rm._registerResource(
"storage", "resource", rm.EXCLUSIVE, callback)
exclusiveReq2 = rm._registerResource(
"storage", "resource", rm.EXCLUSIVE, callback)
exclusiveReq3 = rm._registerResource(
"storage", "resource", rm.EXCLUSIVE, callback)
self.assertTrue(exclusiveReq1.granted())
self.assertFalse(exclusiveReq2.canceled())
self.assertFalse(exclusiveReq3.granted())
exclusiveReq2.cancel()
self.assertTrue(exclusiveReq2.canceled())
self.assertEquals(resources.pop(), None) # exclusiveReq 2
resources.pop().release() # exclusiveReq 1
self.assertTrue(exclusiveReq3.granted())
resources.pop().release() # exclusiveReq 3
def testCancelRequest(self):
resources = []
def callback(req, res):
resources.append(res)
exclusiveReq1 = rm._registerResource(
"storage", "resource", rm.EXCLUSIVE, callback)
exclusiveReq2 = rm._registerResource(
"storage", "resource", rm.EXCLUSIVE, callback)
exclusiveReq3 = rm._registerResource(
"storage", "resource", rm.EXCLUSIVE, callback)
self.assertTrue(exclusiveReq1.granted())
self.assertFalse(exclusiveReq2.canceled())
self.assertFalse(exclusiveReq3.granted())
exclusiveReq2.cancel()
self.assertTrue(exclusiveReq2.canceled())
self.assertEquals(resources.pop(), None) # exclusiveReq 2
resources.pop().release() # exclusiveReq 1
self.assertTrue(exclusiveReq3.granted())
resources.pop().release() # exclusiveReq 3
def testRequestRefCmp(self):
resources = []
requests = []
def callback(req, res):
resources.insert(0, res)
requests.insert(0, req)
req1 = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
req2 = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
self.assertNotEqual(req1, req2)
self.assertEqual(req1, req1)
self.assertEqual(req2, req2)
req1.wait()
req1Clone = requests.pop()
self.assertEqual(req1, req1Clone)
self.assertNotEqual(req1Clone, req2)
resources.pop().release()
req2.wait()
req2Clone = requests.pop()
self.assertEqual(req2, req2Clone)
self.assertNotEqual(req1, req2Clone)
self.assertNotEqual(req1Clone, req2Clone)
resources[0].release()
self.assertNotEqual(req1, "STUFF")
def testRequestRefCmp(self):
resources = []
requests = []
def callback(req, res):
resources.insert(0, res)
requests.insert(0, req)
req1 = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
req2 = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
self.assertNotEqual(req1, req2)
self.assertEqual(req1, req1)
self.assertEqual(req2, req2)
req1.wait()
req1Clone = requests.pop()
self.assertEqual(req1, req1Clone)
self.assertNotEqual(req1Clone, req2)
resources.pop().release()
req2.wait()
req2Clone = requests.pop()
self.assertEqual(req2, req2Clone)
self.assertNotEqual(req1, req2Clone)
self.assertNotEqual(req1Clone, req2Clone)
resources[0].release()
self.assertNotEqual(req1, "STUFF")
def testRequestWithBadCallbackOnGrant(self):
def callback(req, res):
res.release()
raise Exception("BUY MILK!")
req = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
req.wait()
def testRequestWithBadCallbackOnGrant(self):
def callback(req, res):
res.release()
raise Exception("BUY MILK!")
req = rm._registerResource(
"string", "resource", rm.EXCLUSIVE, callback)
req.wait()
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 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 testRequestRefStr(self):
resources = []
def callback(req, res):
resources.insert(0, res)
req = rm._registerResource("string", "resource", rm.SHARED, callback)
try:
str(req)
finally:
req.wait()
resources[0].release()
def testRequestRefStr(self):
resources = []
def callback(req, res):
resources.insert(0, res)
req = rm._registerResource("string", "resource", rm.SHARED, callback)
try:
str(req)
finally:
req.wait()
resources[0].release()
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 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 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 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 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 testAccessAttributeNotExposedByRequestRef(self):
resources = []
def callback(req, res):
resources.insert(0, res)
req = rm._registerResource("string", "resource", rm.SHARED, callback)
try:
req.grant()
except AttributeError:
return
except Exception as ex:
self.fail("Wrong exception was raised. "
"Expected AttributeError got %s", ex.__class__.__name__)
finally:
req.wait()
resources[0].release()
self.fail("Managed to access an attribute not exposed by wrapper")
def testAccessAttributeNotExposedByRequestRef(self):
resources = []
def callback(req, res):
resources.insert(0, res)
req = rm._registerResource("string", "resource", rm.SHARED, callback)
try:
req.grant()
except AttributeError:
return
except Exception as ex:
self.fail("Wrong exception was raised. "
"Expected AttributeError got %s", ex.__class__.__name__)
finally:
req.wait()
resources[0].release()
self.fail("Managed to access an attribute not exposed by wrapper")
def testErrorInFactory(self):
req = rm._registerResource(
"error", "resource", rm.EXCLUSIVE, lambda req, res: 1)
self.assertTrue(req.canceled())
def testErrorInFactory(self):
req = rm._registerResource(
"error", "resource", rm.EXCLUSIVE, lambda req, res: 1)
self.assertTrue(req.canceled())
