Revision aaae9bc0 test/ganeti.locking_unittest.py
| b/test/ganeti.locking_unittest.py | ||
|---|---|---|
| 230 | 230 |
self.assertEqual(self.done.get(True, 1), 'ERR') |
| 231 | 231 |
|
| 232 | 232 |
|
| 233 |
class TestLockSet(unittest.TestCase): |
|
| 234 |
"""LockSet tests""" |
|
| 235 |
|
|
| 236 |
def setUp(self): |
|
| 237 |
self.resources = ['one', 'two', 'three'] |
|
| 238 |
self.ls = locking.LockSet(self.resources) |
|
| 239 |
# helper threads use the 'done' queue to tell the master they finished. |
|
| 240 |
self.done = Queue.Queue(0) |
|
| 241 |
|
|
| 242 |
def testResources(self): |
|
| 243 |
self.assertEquals(self.ls._names(), set(self.resources)) |
|
| 244 |
newls = locking.LockSet() |
|
| 245 |
self.assertEquals(newls._names(), set()) |
|
| 246 |
|
|
| 247 |
def testAcquireRelease(self): |
|
| 248 |
self.ls.acquire('one')
|
|
| 249 |
self.assertEquals(self.ls._list_owned(), set(['one'])) |
|
| 250 |
self.ls.release() |
|
| 251 |
self.assertEquals(self.ls._list_owned(), set()) |
|
| 252 |
self.ls.acquire(['one']) |
|
| 253 |
self.assertEquals(self.ls._list_owned(), set(['one'])) |
|
| 254 |
self.ls.release() |
|
| 255 |
self.assertEquals(self.ls._list_owned(), set()) |
|
| 256 |
self.ls.acquire(['one', 'two', 'three']) |
|
| 257 |
self.assertEquals(self.ls._list_owned(), set(['one', 'two', 'three'])) |
|
| 258 |
self.ls.release('one')
|
|
| 259 |
self.assertEquals(self.ls._list_owned(), set(['two', 'three'])) |
|
| 260 |
self.ls.release(['three']) |
|
| 261 |
self.assertEquals(self.ls._list_owned(), set(['two'])) |
|
| 262 |
self.ls.release() |
|
| 263 |
self.assertEquals(self.ls._list_owned(), set()) |
|
| 264 |
self.ls.acquire(['one', 'three']) |
|
| 265 |
self.assertEquals(self.ls._list_owned(), set(['one', 'three'])) |
|
| 266 |
self.ls.release() |
|
| 267 |
self.assertEquals(self.ls._list_owned(), set()) |
|
| 268 |
|
|
| 269 |
def testNoDoubleAcquire(self): |
|
| 270 |
self.ls.acquire('one')
|
|
| 271 |
self.assertRaises(AssertionError, self.ls.acquire, 'one') |
|
| 272 |
self.assertRaises(AssertionError, self.ls.acquire, ['two']) |
|
| 273 |
self.assertRaises(AssertionError, self.ls.acquire, ['two', 'three']) |
|
| 274 |
self.ls.release() |
|
| 275 |
self.ls.acquire(['one', 'three']) |
|
| 276 |
self.ls.release('one')
|
|
| 277 |
self.assertRaises(AssertionError, self.ls.acquire, ['two']) |
|
| 278 |
self.ls.release('three')
|
|
| 279 |
|
|
| 280 |
def testNoWrongRelease(self): |
|
| 281 |
self.assertRaises(AssertionError, self.ls.release) |
|
| 282 |
self.ls.acquire('one')
|
|
| 283 |
self.assertRaises(AssertionError, self.ls.release, 'two') |
|
| 284 |
|
|
| 285 |
def testAddRemove(self): |
|
| 286 |
self.ls.add('four')
|
|
| 287 |
self.assertEquals(self.ls._list_owned(), set()) |
|
| 288 |
self.assert_('four' in self.ls._names())
|
|
| 289 |
self.ls.add(['five', 'six', 'seven'], acquired=1) |
|
| 290 |
self.assert_('five' in self.ls._names())
|
|
| 291 |
self.assert_('six' in self.ls._names())
|
|
| 292 |
self.assert_('seven' in self.ls._names())
|
|
| 293 |
self.assertEquals(self.ls._list_owned(), set(['five', 'six', 'seven'])) |
|
| 294 |
self.ls.remove(['five', 'six']) |
|
| 295 |
self.assert_('five' not in self.ls._names())
|
|
| 296 |
self.assert_('six' not in self.ls._names())
|
|
| 297 |
self.assertEquals(self.ls._list_owned(), set(['seven'])) |
|
| 298 |
self.ls.add('eight', acquired=1, shared=1)
|
|
| 299 |
self.assert_('eight' in self.ls._names())
|
|
| 300 |
self.assertEquals(self.ls._list_owned(), set(['seven', 'eight'])) |
|
| 301 |
self.ls.remove('seven')
|
|
| 302 |
self.assert_('seven' not in self.ls._names())
|
|
| 303 |
self.assertEquals(self.ls._list_owned(), set(['eight'])) |
|
| 304 |
self.ls.release() |
|
| 305 |
self.ls.remove(['two']) |
|
| 306 |
self.assert_('two' not in self.ls._names())
|
|
| 307 |
self.ls.acquire('three')
|
|
| 308 |
self.ls.remove(['three']) |
|
| 309 |
self.assert_('three' not in self.ls._names())
|
|
| 310 |
self.assertEquals(self.ls.remove('three'), ['three'])
|
|
| 311 |
self.assertEquals(self.ls.remove(['one', 'three', 'six']), ['three', 'six']) |
|
| 312 |
self.assert_('one' not in self.ls._names())
|
|
| 313 |
|
|
| 314 |
def testRemoveNonBlocking(self): |
|
| 315 |
self.assertRaises(NotImplementedError, self.ls.remove, 'one', blocking=0) |
|
| 316 |
self.ls.acquire('one')
|
|
| 317 |
self.assertEquals(self.ls.remove('one', blocking=0), [])
|
|
| 318 |
self.ls.acquire(['two', 'three']) |
|
| 319 |
self.assertEquals(self.ls.remove(['two', 'three'], blocking=0), []) |
|
| 320 |
|
|
| 321 |
def testNoDoubleAdd(self): |
|
| 322 |
self.assertRaises(errors.LockError, self.ls.add, 'two') |
|
| 323 |
self.ls.add('four')
|
|
| 324 |
self.assertRaises(errors.LockError, self.ls.add, 'four') |
|
| 325 |
|
|
| 326 |
def testNoWrongRemoves(self): |
|
| 327 |
self.ls.acquire(['one', 'three'], shared=1) |
|
| 328 |
# Cannot remove 'two' while holding something which is not a superset |
|
| 329 |
self.assertRaises(AssertionError, self.ls.remove, 'two') |
|
| 330 |
# Cannot remove 'three' as we are sharing it |
|
| 331 |
self.assertRaises(AssertionError, self.ls.remove, 'three') |
|
| 332 |
|
|
| 333 |
def _doLockSet(self, set, shared): |
|
| 334 |
try: |
|
| 335 |
self.ls.acquire(set, shared=shared) |
|
| 336 |
self.done.put('DONE')
|
|
| 337 |
self.ls.release() |
|
| 338 |
except errors.LockError: |
|
| 339 |
self.done.put('ERR')
|
|
| 340 |
|
|
| 341 |
def _doRemoveSet(self, set): |
|
| 342 |
self.done.put(self.ls.remove(set)) |
|
| 343 |
|
|
| 344 |
def testConcurrentSharedAcquire(self): |
|
| 345 |
self.ls.acquire(['one', 'two'], shared=1) |
|
| 346 |
Thread(target=self._doLockSet, args=(['one', 'two'], 1)).start() |
|
| 347 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 348 |
Thread(target=self._doLockSet, args=(['one', 'two', 'three'], 1)).start() |
|
| 349 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 350 |
Thread(target=self._doLockSet, args=('three', 1)).start()
|
|
| 351 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 352 |
Thread(target=self._doLockSet, args=(['one', 'two'], 0)).start() |
|
| 353 |
Thread(target=self._doLockSet, args=(['two', 'three'], 0)).start() |
|
| 354 |
self.assertRaises(Queue.Empty, self.done.get, True, 0.2) |
|
| 355 |
self.ls.release() |
|
| 356 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 357 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 358 |
|
|
| 359 |
def testConcurrentExclusiveAcquire(self): |
|
| 360 |
self.ls.acquire(['one', 'two']) |
|
| 361 |
Thread(target=self._doLockSet, args=('three', 1)).start()
|
|
| 362 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 363 |
Thread(target=self._doLockSet, args=('three', 0)).start()
|
|
| 364 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 365 |
Thread(target=self._doLockSet, args=(['one', 'two'], 0)).start() |
|
| 366 |
Thread(target=self._doLockSet, args=(['one', 'two'], 1)).start() |
|
| 367 |
Thread(target=self._doLockSet, args=('one', 0)).start()
|
|
| 368 |
Thread(target=self._doLockSet, args=('one', 1)).start()
|
|
| 369 |
Thread(target=self._doLockSet, args=(['two', 'three'], 0)).start() |
|
| 370 |
Thread(target=self._doLockSet, args=(['two', 'three'], 1)).start() |
|
| 371 |
self.assertRaises(Queue.Empty, self.done.get, True, 0.2) |
|
| 372 |
self.ls.release() |
|
| 373 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 374 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 375 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 376 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 377 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 378 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 379 |
|
|
| 380 |
def testConcurrentRemove(self): |
|
| 381 |
self.ls.add('four')
|
|
| 382 |
self.ls.acquire(['one', 'two', 'four']) |
|
| 383 |
Thread(target=self._doLockSet, args=(['one', 'four'], 0)).start() |
|
| 384 |
Thread(target=self._doLockSet, args=(['one', 'four'], 1)).start() |
|
| 385 |
Thread(target=self._doLockSet, args=(['one', 'two'], 0)).start() |
|
| 386 |
Thread(target=self._doLockSet, args=(['one', 'two'], 1)).start() |
|
| 387 |
self.assertRaises(Queue.Empty, self.done.get, True, 0.2) |
|
| 388 |
self.ls.remove('one')
|
|
| 389 |
self.ls.release() |
|
| 390 |
self.assertEqual(self.done.get(True, 1), 'ERR') |
|
| 391 |
self.assertEqual(self.done.get(True, 1), 'ERR') |
|
| 392 |
self.assertEqual(self.done.get(True, 1), 'ERR') |
|
| 393 |
self.assertEqual(self.done.get(True, 1), 'ERR') |
|
| 394 |
self.ls.add(['five', 'six'], acquired=1) |
|
| 395 |
Thread(target=self._doLockSet, args=(['three', 'six'], 1)).start() |
|
| 396 |
Thread(target=self._doLockSet, args=(['three', 'six'], 0)).start() |
|
| 397 |
Thread(target=self._doLockSet, args=(['four', 'six'], 1)).start() |
|
| 398 |
Thread(target=self._doLockSet, args=(['four', 'six'], 0)).start() |
|
| 399 |
self.ls.remove('five')
|
|
| 400 |
self.ls.release() |
|
| 401 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 402 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 403 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 404 |
self.assertEqual(self.done.get(True, 1), 'DONE') |
|
| 405 |
self.ls.acquire(['three', 'four']) |
|
| 406 |
Thread(target=self._doRemoveSet, args=(['four', 'six'], )).start() |
|
| 407 |
self.assertRaises(Queue.Empty, self.done.get, True, 0.2) |
|
| 408 |
self.ls.remove('four')
|
|
| 409 |
self.assertEqual(self.done.get(True, 1), ['four']) |
|
| 410 |
Thread(target=self._doRemoveSet, args=(['two'])).start() |
|
| 411 |
self.assertEqual(self.done.get(True, 1), []) |
|
| 412 |
self.ls.release() |
|
| 413 |
|
|
| 414 |
|
|
| 233 | 415 |
if __name__ == '__main__': |
| 234 | 416 |
unittest.main() |
| 235 | 417 |
#suite = unittest.TestLoader().loadTestsFromTestCase(TestSharedLock) |
Also available in: Unified diff