diff --git a/test/ganeti.bdev_unittest.py b/test/ganeti.bdev_unittest.py
index b483d5799bb4c2180fe367b2c7effaf041090e4a..d60c73538dda4e9117620fdc5d6642188a4ab3d5 100755
--- a/test/ganeti.bdev_unittest.py
+++ b/test/ganeti.bdev_unittest.py
@@ -312,7 +312,7 @@ class TestDRBD8Status(testutils.GanetiTestCase):
stats = bdev.DRBD8Status(data[4])
self.failUnless(stats.is_in_use)
self.failUnless(stats.is_wfconn and stats.is_primary and
- stats.rrole == 'Unknown' and
+ stats.rrole == "Unknown" and
stats.is_disk_uptodate)
def testMinor6(self):
@@ -329,7 +329,7 @@ class TestDRBD8Status(testutils.GanetiTestCase):
stats = bdev.DRBD8Status(data[8])
self.failUnless(stats.is_in_use)
self.failUnless(stats.is_standalone and
- stats.rrole == 'Unknown' and
+ stats.rrole == "Unknown" and
stats.is_disk_uptodate)
def testDRBD83SyncFine(self):
diff --git a/test/ganeti.cli_unittest.py b/test/ganeti.cli_unittest.py
index 5ab333fcda9f27440a97ae700b5e32cc8906bbd1..5cb486953f5070c71ce9d911aeab15e9b1db44e6 100755
--- a/test/ganeti.cli_unittest.py
+++ b/test/ganeti.cli_unittest.py
@@ -43,14 +43,14 @@ class TestParseTimespec(unittest.TestCase):
def testValidTimes(self):
"""Test valid timespecs"""
test_data = [
- ('1s', 1),
- ('1', 1),
- ('1m', 60),
- ('1h', 60 * 60),
- ('1d', 60 * 60 * 24),
- ('1w', 60 * 60 * 24 * 7),
- ('4h', 4 * 60 * 60),
- ('61m', 61 * 60),
+ ("1s", 1),
+ ("1", 1),
+ ("1m", 60),
+ ("1h", 60 * 60),
+ ("1d", 60 * 60 * 24),
+ ("1w", 60 * 60 * 24 * 7),
+ ("4h", 4 * 60 * 60),
+ ("61m", 61 * 60),
]
for value, expected_result in test_data:
self.failUnlessEqual(cli.ParseTimespec(value), expected_result)
@@ -58,10 +58,10 @@ class TestParseTimespec(unittest.TestCase):
def testInvalidTime(self):
"""Test invalid timespecs"""
test_data = [
- '1y',
- '',
- 'aaa',
- 's',
+ "1y",
+ "",
+ "aaa",
+ "s",
]
for value in test_data:
self.failUnlessRaises(OpPrereqError, cli.ParseTimespec, value)
@@ -128,7 +128,7 @@ class TestToStream(unittest.TestCase):
]:
buf = StringIO()
cli._ToStream(buf, data)
- self.failUnlessEqual(buf.getvalue(), data+'\n')
+ self.failUnlessEqual(buf.getvalue(), data + "\n")
def testParams(self):
buf = StringIO()
diff --git a/test/ganeti.config_unittest.py b/test/ganeti.config_unittest.py
index 7556432a97fcfd05fa10bf9132df4b538236c41d..4f390170a75a6456501fe8f0521fb24a9eacb5a4 100755
--- a/test/ganeti.config_unittest.py
+++ b/test/ganeti.config_unittest.py
@@ -183,14 +183,14 @@ class TestConfigRunner(unittest.TestCase):
CheckSyntax = objects.NIC.CheckParameterSyntax
CheckSyntax(constants.NICC_DEFAULTS)
- CheckSyntax({mode: m_bridged, link: 'br1'})
- CheckSyntax({mode: m_routed, link: 'default'})
+ CheckSyntax({mode: m_bridged, link: "br1"})
+ CheckSyntax({mode: m_routed, link: "default"})
self.assertRaises(errors.ConfigurationError,
- CheckSyntax, {mode: '000invalid', link: 'any'})
+ CheckSyntax, {mode: "000invalid", link: "any"})
self.assertRaises(errors.ConfigurationError,
CheckSyntax, {mode: m_bridged, link: None})
self.assertRaises(errors.ConfigurationError,
- CheckSyntax, {mode: m_bridged, link: ''})
+ CheckSyntax, {mode: m_bridged, link: ""})
def testGetNdParamsDefault(self):
cfg = self._get_object()
diff --git a/test/ganeti.constants_unittest.py b/test/ganeti.constants_unittest.py
index 64f2a631bfee2e6a0bc1c5c4daaab8c90c81cb02..3723e045b7c97d4c2e4c45e2809276a733d9033a 100755
--- a/test/ganeti.constants_unittest.py
+++ b/test/ganeti.constants_unittest.py
@@ -115,9 +115,9 @@ class TestParameterNames(unittest.TestCase):
VALID_NAME = re.compile("^[a-zA-Z_][a-zA-Z0-9_]*$")
def testNoDashes(self):
- for kind, source in [('hypervisor', constants.HVS_PARAMETER_TYPES),
- ('backend', constants.BES_PARAMETER_TYPES),
- ('nic', constants.NICS_PARAMETER_TYPES),
+ for kind, source in [("hypervisor", constants.HVS_PARAMETER_TYPES),
+ ("backend", constants.BES_PARAMETER_TYPES),
+ ("nic", constants.NICS_PARAMETER_TYPES),
("instdisk", constants.IDISK_PARAMS_TYPES),
("instnic", constants.INIC_PARAMS_TYPES),
]:
diff --git a/test/ganeti.hooks_unittest.py b/test/ganeti.hooks_unittest.py
index b6ec2c7531fefcf16624aea9d5787cc0c6f14517..e20fc112ee32d172cf7ea50f25628c781ef9e465 100755
--- a/test/ganeti.hooks_unittest.py
+++ b/test/ganeti.hooks_unittest.py
@@ -206,7 +206,7 @@ def FakeHooksRpcSuccess(node_list, hpath, phase, env):
"""
rr = rpc.RpcResult
return dict([(node, rr((True, [("utest", constants.HKR_SUCCESS, "ok")]),
- node=node, call='FakeScriptOk'))
+ node=node, call="FakeScriptOk"))
for node in node_list])
@@ -225,8 +225,8 @@ class TestHooksMaster(unittest.TestCase):
@return: rpc failure from all nodes
"""
- return dict([(node, rpc.RpcResult('error', failed=True,
- node=node, call='FakeError')) for node in node_list])
+ return dict([(node, rpc.RpcResult("error", failed=True,
+ node=node, call="FakeError")) for node in node_list])
@staticmethod
def _call_script_fail(node_list, hpath, phase, env):
@@ -238,7 +238,7 @@ class TestHooksMaster(unittest.TestCase):
"""
rr = rpc.RpcResult
return dict([(node, rr((True, [("utest", constants.HKR_FAIL, "err")]),
- node=node, call='FakeScriptFail'))
+ node=node, call="FakeScriptFail"))
for node in node_list])
def setUp(self):
diff --git a/test/ganeti.locking_unittest.py b/test/ganeti.locking_unittest.py
index 494994cdba113fea977a30e2ed0df7990dd6336f..098a654b8447e17ffc0d7c4a86de4050469b9281 100755
--- a/test/ganeti.locking_unittest.py
+++ b/test/ganeti.locking_unittest.py
@@ -317,25 +317,25 @@ class TestSharedLock(_ThreadedTestCase):
def _doItSharer(self):
try:
self.sl.acquire(shared=1)
- self.done.put('SHR')
+ self.done.put("SHR")
self.sl.release()
except errors.LockError:
- self.done.put('ERR')
+ self.done.put("ERR")
def _doItExclusive(self):
try:
self.sl.acquire()
- self.done.put('EXC')
+ self.done.put("EXC")
self.sl.release()
except errors.LockError:
- self.done.put('ERR')
+ self.done.put("ERR")
def _doItDelete(self):
try:
self.sl.delete()
- self.done.put('DEL')
+ self.done.put("DEL")
except errors.LockError:
- self.done.put('ERR')
+ self.done.put("ERR")
def testSharersCanCoexist(self):
self.sl.acquire(shared=1)
@@ -350,7 +350,7 @@ class TestSharedLock(_ThreadedTestCase):
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.sl.release()
self._waitThreads()
- self.failUnlessEqual(self.done.get_nowait(), 'EXC')
+ self.failUnlessEqual(self.done.get_nowait(), "EXC")
@_Repeat
def testExclusiveBlocksDelete(self):
@@ -359,7 +359,7 @@ class TestSharedLock(_ThreadedTestCase):
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.sl.release()
self._waitThreads()
- self.failUnlessEqual(self.done.get_nowait(), 'DEL')
+ self.failUnlessEqual(self.done.get_nowait(), "DEL")
self.sl = locking.SharedLock(self.sl.name)
@_Repeat
@@ -369,7 +369,7 @@ class TestSharedLock(_ThreadedTestCase):
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.sl.release()
self._waitThreads()
- self.failUnlessEqual(self.done.get_nowait(), 'SHR')
+ self.failUnlessEqual(self.done.get_nowait(), "SHR")
@_Repeat
def testSharerBlocksExclusive(self):
@@ -378,7 +378,7 @@ class TestSharedLock(_ThreadedTestCase):
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.sl.release()
self._waitThreads()
- self.failUnlessEqual(self.done.get_nowait(), 'EXC')
+ self.failUnlessEqual(self.done.get_nowait(), "EXC")
@_Repeat
def testSharerBlocksDelete(self):
@@ -387,7 +387,7 @@ class TestSharedLock(_ThreadedTestCase):
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.sl.release()
self._waitThreads()
- self.failUnlessEqual(self.done.get_nowait(), 'DEL')
+ self.failUnlessEqual(self.done.get_nowait(), "DEL")
self.sl = locking.SharedLock(self.sl.name)
@_Repeat
@@ -405,8 +405,8 @@ class TestSharedLock(_ThreadedTestCase):
self.sl.release()
self._waitThreads()
# The exclusive passed before
- self.failUnlessEqual(self.done.get_nowait(), 'EXC')
- self.failUnlessEqual(self.done.get_nowait(), 'SHR')
+ self.failUnlessEqual(self.done.get_nowait(), "EXC")
+ self.failUnlessEqual(self.done.get_nowait(), "SHR")
@_Repeat
def testWaitingSharerBlocksExclusive(self):
@@ -423,8 +423,8 @@ class TestSharedLock(_ThreadedTestCase):
self.sl.release()
self._waitThreads()
# The sharer passed before
- self.assertEqual(self.done.get_nowait(), 'SHR')
- self.assertEqual(self.done.get_nowait(), 'EXC')
+ self.assertEqual(self.done.get_nowait(), "SHR")
+ self.assertEqual(self.done.get_nowait(), "EXC")
def testDelete(self):
self.sl.delete()
@@ -474,7 +474,7 @@ class TestSharedLock(_ThreadedTestCase):
self._waitThreads()
# The threads who were pending return ERR
for _ in range(4):
- self.assertEqual(self.done.get_nowait(), 'ERR')
+ self.assertEqual(self.done.get_nowait(), "ERR")
self.sl = locking.SharedLock(self.sl.name)
@_Repeat
@@ -487,10 +487,10 @@ class TestSharedLock(_ThreadedTestCase):
self.sl.delete()
self._waitThreads()
# The two threads who were pending return both ERR
- self.assertEqual(self.done.get_nowait(), 'ERR')
- self.assertEqual(self.done.get_nowait(), 'ERR')
- self.assertEqual(self.done.get_nowait(), 'ERR')
- self.assertEqual(self.done.get_nowait(), 'ERR')
+ self.assertEqual(self.done.get_nowait(), "ERR")
+ self.assertEqual(self.done.get_nowait(), "ERR")
+ self.assertEqual(self.done.get_nowait(), "ERR")
+ self.assertEqual(self.done.get_nowait(), "ERR")
self.sl = locking.SharedLock(self.sl.name)
@_Repeat
@@ -1072,12 +1072,12 @@ class TestSSynchronizedDecorator(_ThreadedTestCase):
@locking.ssynchronized(_decoratorlock)
def _doItExclusive(self):
self.assert_(_decoratorlock.is_owned())
- self.done.put('EXC')
+ self.done.put("EXC")
@locking.ssynchronized(_decoratorlock, shared=1)
def _doItSharer(self):
self.assert_(_decoratorlock.is_owned(shared=1))
- self.done.put('SHR')
+ self.done.put("SHR")
def testDecoratedFunctions(self):
self._doItExclusive()
@@ -1099,7 +1099,7 @@ class TestSSynchronizedDecorator(_ThreadedTestCase):
self.assertRaises(Queue.Empty, self.done.get_nowait)
_decoratorlock.release()
self._waitThreads()
- self.failUnlessEqual(self.done.get_nowait(), 'EXC')
+ self.failUnlessEqual(self.done.get_nowait(), "EXC")
@_Repeat
def testExclusiveBlocksSharer(self):
@@ -1108,7 +1108,7 @@ class TestSSynchronizedDecorator(_ThreadedTestCase):
self.assertRaises(Queue.Empty, self.done.get_nowait)
_decoratorlock.release()
self._waitThreads()
- self.failUnlessEqual(self.done.get_nowait(), 'SHR')
+ self.failUnlessEqual(self.done.get_nowait(), "SHR")
@_Repeat
def testSharerBlocksExclusive(self):
@@ -1117,7 +1117,7 @@ class TestSSynchronizedDecorator(_ThreadedTestCase):
self.assertRaises(Queue.Empty, self.done.get_nowait)
_decoratorlock.release()
self._waitThreads()
- self.failUnlessEqual(self.done.get_nowait(), 'EXC')
+ self.failUnlessEqual(self.done.get_nowait(), "EXC")
class TestLockSet(_ThreadedTestCase):
@@ -1129,7 +1129,7 @@ class TestLockSet(_ThreadedTestCase):
def _setUpLS(self):
"""Helper to (re)initialize the lock set"""
- self.resources = ['one', 'two', 'three']
+ self.resources = ["one", "two", "three"]
self.ls = locking.LockSet(self.resources, "TestLockSet")
def testResources(self):
@@ -1159,140 +1159,140 @@ class TestLockSet(_ThreadedTestCase):
def testAcquireRelease(self):
self.assertFalse(self.ls.check_owned(self.ls._names()))
- self.assert_(self.ls.acquire('one'))
- self.assertEquals(self.ls.list_owned(), set(['one']))
+ self.assert_(self.ls.acquire("one"))
+ self.assertEquals(self.ls.list_owned(), set(["one"]))
self.assertTrue(self.ls.check_owned("one"))
self.assertTrue(self.ls.check_owned("one", shared=0))
self.assertFalse(self.ls.check_owned("one", shared=1))
self.ls.release()
self.assertEquals(self.ls.list_owned(), set())
self.assertFalse(self.ls.check_owned(self.ls._names()))
- self.assertEquals(self.ls.acquire(['one']), set(['one']))
- self.assertEquals(self.ls.list_owned(), set(['one']))
+ self.assertEquals(self.ls.acquire(["one"]), set(["one"]))
+ self.assertEquals(self.ls.list_owned(), set(["one"]))
self.ls.release()
self.assertEquals(self.ls.list_owned(), set())
- self.ls.acquire(['one', 'two', 'three'])
- self.assertEquals(self.ls.list_owned(), set(['one', 'two', 'three']))
+ self.ls.acquire(["one", "two", "three"])
+ self.assertEquals(self.ls.list_owned(), set(["one", "two", "three"]))
self.assertTrue(self.ls.check_owned(self.ls._names()))
self.assertTrue(self.ls.check_owned(self.ls._names(), shared=0))
self.assertFalse(self.ls.check_owned(self.ls._names(), shared=1))
- self.ls.release('one')
+ self.ls.release("one")
self.assertFalse(self.ls.check_owned(["one"]))
self.assertTrue(self.ls.check_owned(["two", "three"]))
self.assertTrue(self.ls.check_owned(["two", "three"], shared=0))
self.assertFalse(self.ls.check_owned(["two", "three"], shared=1))
- self.assertEquals(self.ls.list_owned(), set(['two', 'three']))
- self.ls.release(['three'])
- self.assertEquals(self.ls.list_owned(), set(['two']))
+ self.assertEquals(self.ls.list_owned(), set(["two", "three"]))
+ self.ls.release(["three"])
+ self.assertEquals(self.ls.list_owned(), set(["two"]))
self.ls.release()
self.assertEquals(self.ls.list_owned(), set())
- self.assertEquals(self.ls.acquire(['one', 'three']), set(['one', 'three']))
- self.assertEquals(self.ls.list_owned(), set(['one', 'three']))
+ self.assertEquals(self.ls.acquire(["one", "three"]), set(["one", "three"]))
+ self.assertEquals(self.ls.list_owned(), set(["one", "three"]))
self.ls.release()
self.assertEquals(self.ls.list_owned(), set())
for name in self.ls._names():
self.assertFalse(self.ls.check_owned(name))
def testNoDoubleAcquire(self):
- self.ls.acquire('one')
- self.assertRaises(AssertionError, self.ls.acquire, 'one')
- self.assertRaises(AssertionError, self.ls.acquire, ['two'])
- self.assertRaises(AssertionError, self.ls.acquire, ['two', 'three'])
+ self.ls.acquire("one")
+ self.assertRaises(AssertionError, self.ls.acquire, "one")
+ self.assertRaises(AssertionError, self.ls.acquire, ["two"])
+ self.assertRaises(AssertionError, self.ls.acquire, ["two", "three"])
self.ls.release()
- self.ls.acquire(['one', 'three'])
- self.ls.release('one')
- self.assertRaises(AssertionError, self.ls.acquire, ['two'])
- self.ls.release('three')
+ self.ls.acquire(["one", "three"])
+ self.ls.release("one")
+ self.assertRaises(AssertionError, self.ls.acquire, ["two"])
+ self.ls.release("three")
def testNoWrongRelease(self):
self.assertRaises(AssertionError, self.ls.release)
- self.ls.acquire('one')
- self.assertRaises(AssertionError, self.ls.release, 'two')
+ self.ls.acquire("one")
+ self.assertRaises(AssertionError, self.ls.release, "two")
def testAddRemove(self):
- self.ls.add('four')
+ self.ls.add("four")
self.assertEquals(self.ls.list_owned(), set())
- self.assert_('four' in self.ls._names())
- self.ls.add(['five', 'six', 'seven'], acquired=1)
- self.assert_('five' in self.ls._names())
- self.assert_('six' in self.ls._names())
- self.assert_('seven' in self.ls._names())
- self.assertEquals(self.ls.list_owned(), set(['five', 'six', 'seven']))
- self.assertEquals(self.ls.remove(['five', 'six']), ['five', 'six'])
- self.assert_('five' not in self.ls._names())
- self.assert_('six' not in self.ls._names())
- self.assertEquals(self.ls.list_owned(), set(['seven']))
- self.assertRaises(AssertionError, self.ls.add, 'eight', acquired=1)
- self.ls.remove('seven')
- self.assert_('seven' not in self.ls._names())
+ self.assert_("four" in self.ls._names())
+ self.ls.add(["five", "six", "seven"], acquired=1)
+ self.assert_("five" in self.ls._names())
+ self.assert_("six" in self.ls._names())
+ self.assert_("seven" in self.ls._names())
+ self.assertEquals(self.ls.list_owned(), set(["five", "six", "seven"]))
+ self.assertEquals(self.ls.remove(["five", "six"]), ["five", "six"])
+ self.assert_("five" not in self.ls._names())
+ self.assert_("six" not in self.ls._names())
+ self.assertEquals(self.ls.list_owned(), set(["seven"]))
+ self.assertRaises(AssertionError, self.ls.add, "eight", acquired=1)
+ self.ls.remove("seven")
+ self.assert_("seven" not in self.ls._names())
self.assertEquals(self.ls.list_owned(), set([]))
self.ls.acquire(None, shared=1)
- self.assertRaises(AssertionError, self.ls.add, 'eight')
+ self.assertRaises(AssertionError, self.ls.add, "eight")
self.ls.release()
self.ls.acquire(None)
- self.ls.add('eight', acquired=1)
- self.assert_('eight' in self.ls._names())
- self.assert_('eight' in self.ls.list_owned())
- self.ls.add('nine')
- self.assert_('nine' in self.ls._names())
- self.assert_('nine' not in self.ls.list_owned())
+ self.ls.add("eight", acquired=1)
+ self.assert_("eight" in self.ls._names())
+ self.assert_("eight" in self.ls.list_owned())
+ self.ls.add("nine")
+ self.assert_("nine" in self.ls._names())
+ self.assert_("nine" not in self.ls.list_owned())
self.ls.release()
- self.ls.remove(['two'])
- self.assert_('two' not in self.ls._names())
- self.ls.acquire('three')
- self.assertEquals(self.ls.remove(['three']), ['three'])
- self.assert_('three' not in self.ls._names())
- self.assertEquals(self.ls.remove('three'), [])
- self.assertEquals(self.ls.remove(['one', 'three', 'six']), ['one'])
- self.assert_('one' not in self.ls._names())
+ self.ls.remove(["two"])
+ self.assert_("two" not in self.ls._names())
+ self.ls.acquire("three")
+ self.assertEquals(self.ls.remove(["three"]), ["three"])
+ self.assert_("three" not in self.ls._names())
+ self.assertEquals(self.ls.remove("three"), [])
+ self.assertEquals(self.ls.remove(["one", "three", "six"]), ["one"])
+ self.assert_("one" not in self.ls._names())
def testRemoveNonBlocking(self):
- self.ls.acquire('one')
- self.assertEquals(self.ls.remove('one'), ['one'])
- self.ls.acquire(['two', 'three'])
- self.assertEquals(self.ls.remove(['two', 'three']),
- ['two', 'three'])
+ self.ls.acquire("one")
+ self.assertEquals(self.ls.remove("one"), ["one"])
+ self.ls.acquire(["two", "three"])
+ self.assertEquals(self.ls.remove(["two", "three"]),
+ ["two", "three"])
def testNoDoubleAdd(self):
- self.assertRaises(errors.LockError, self.ls.add, 'two')
- self.ls.add('four')
- self.assertRaises(errors.LockError, self.ls.add, 'four')
+ self.assertRaises(errors.LockError, self.ls.add, "two")
+ self.ls.add("four")
+ self.assertRaises(errors.LockError, self.ls.add, "four")
def testNoWrongRemoves(self):
- self.ls.acquire(['one', 'three'], shared=1)
- # Cannot remove 'two' while holding something which is not a superset
- self.assertRaises(AssertionError, self.ls.remove, 'two')
- # Cannot remove 'three' as we are sharing it
- self.assertRaises(AssertionError, self.ls.remove, 'three')
+ self.ls.acquire(["one", "three"], shared=1)
+ # Cannot remove "two" while holding something which is not a superset
+ self.assertRaises(AssertionError, self.ls.remove, "two")
+ # Cannot remove "three" as we are sharing it
+ self.assertRaises(AssertionError, self.ls.remove, "three")
def testAcquireSetLock(self):
# acquire the set-lock exclusively
- self.assertEquals(self.ls.acquire(None), set(['one', 'two', 'three']))
- self.assertEquals(self.ls.list_owned(), set(['one', 'two', 'three']))
+ self.assertEquals(self.ls.acquire(None), set(["one", "two", "three"]))
+ self.assertEquals(self.ls.list_owned(), set(["one", "two", "three"]))
self.assertEquals(self.ls.is_owned(), True)
- self.assertEquals(self.ls._names(), set(['one', 'two', 'three']))
+ self.assertEquals(self.ls._names(), set(["one", "two", "three"]))
# I can still add/remove elements...
- self.assertEquals(self.ls.remove(['two', 'three']), ['two', 'three'])
- self.assert_(self.ls.add('six'))
+ self.assertEquals(self.ls.remove(["two", "three"]), ["two", "three"])
+ self.assert_(self.ls.add("six"))
self.ls.release()
# share the set-lock
- self.assertEquals(self.ls.acquire(None, shared=1), set(['one', 'six']))
+ self.assertEquals(self.ls.acquire(None, shared=1), set(["one", "six"]))
# adding new elements is not possible
- self.assertRaises(AssertionError, self.ls.add, 'five')
+ self.assertRaises(AssertionError, self.ls.add, "five")
self.ls.release()
def testAcquireWithRepetitions(self):
- self.assertEquals(self.ls.acquire(['two', 'two', 'three'], shared=1),
- set(['two', 'two', 'three']))
- self.ls.release(['two', 'two'])
- self.assertEquals(self.ls.list_owned(), set(['three']))
+ self.assertEquals(self.ls.acquire(["two", "two", "three"], shared=1),
+ set(["two", "two", "three"]))
+ self.ls.release(["two", "two"])
+ self.assertEquals(self.ls.list_owned(), set(["three"]))
def testEmptyAcquire(self):
# Acquire an empty list of locks...
self.assertEquals(self.ls.acquire([]), set())
self.assertEquals(self.ls.list_owned(), set())
# New locks can still be addded
- self.assert_(self.ls.add('six'))
+ self.assert_(self.ls.add("six"))
# "re-acquiring" is not an issue, since we had really acquired nothing
self.assertEquals(self.ls.acquire([], shared=1), set())
self.assertEquals(self.ls.list_owned(), set())
@@ -1302,63 +1302,63 @@ class TestLockSet(_ThreadedTestCase):
def _doLockSet(self, names, shared):
try:
self.ls.acquire(names, shared=shared)
- self.done.put('DONE')
+ self.done.put("DONE")
self.ls.release()
except errors.LockError:
- self.done.put('ERR')
+ self.done.put("ERR")
def _doAddSet(self, names):
try:
self.ls.add(names, acquired=1)
- self.done.put('DONE')
+ self.done.put("DONE")
self.ls.release()
except errors.LockError:
- self.done.put('ERR')
+ self.done.put("ERR")
def _doRemoveSet(self, names):
self.done.put(self.ls.remove(names))
@_Repeat
def testConcurrentSharedAcquire(self):
- self.ls.acquire(['one', 'two'], shared=1)
- self._addThread(target=self._doLockSet, args=(['one', 'two'], 1))
+ self.ls.acquire(["one", "two"], shared=1)
+ self._addThread(target=self._doLockSet, args=(["one", "two"], 1))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
- self._addThread(target=self._doLockSet, args=(['one', 'two', 'three'], 1))
+ self.assertEqual(self.done.get_nowait(), "DONE")
+ self._addThread(target=self._doLockSet, args=(["one", "two", "three"], 1))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
- self._addThread(target=self._doLockSet, args=('three', 1))
+ self.assertEqual(self.done.get_nowait(), "DONE")
+ self._addThread(target=self._doLockSet, args=("three", 1))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
- self._addThread(target=self._doLockSet, args=(['one', 'two'], 0))
- self._addThread(target=self._doLockSet, args=(['two', 'three'], 0))
+ self.assertEqual(self.done.get_nowait(), "DONE")
+ self._addThread(target=self._doLockSet, args=(["one", "two"], 0))
+ self._addThread(target=self._doLockSet, args=(["two", "three"], 0))
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.ls.release()
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
+ self.assertEqual(self.done.get_nowait(), "DONE")
@_Repeat
def testConcurrentExclusiveAcquire(self):
- self.ls.acquire(['one', 'two'])
- self._addThread(target=self._doLockSet, args=('three', 1))
+ self.ls.acquire(["one", "two"])
+ self._addThread(target=self._doLockSet, args=("three", 1))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
- self._addThread(target=self._doLockSet, args=('three', 0))
+ self.assertEqual(self.done.get_nowait(), "DONE")
+ self._addThread(target=self._doLockSet, args=("three", 0))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
self.assertRaises(Queue.Empty, self.done.get_nowait)
- self._addThread(target=self._doLockSet, args=(['one', 'two'], 0))
- self._addThread(target=self._doLockSet, args=(['one', 'two'], 1))
- self._addThread(target=self._doLockSet, args=('one', 0))
- self._addThread(target=self._doLockSet, args=('one', 1))
- self._addThread(target=self._doLockSet, args=(['two', 'three'], 0))
- self._addThread(target=self._doLockSet, args=(['two', 'three'], 1))
+ self._addThread(target=self._doLockSet, args=(["one", "two"], 0))
+ self._addThread(target=self._doLockSet, args=(["one", "two"], 1))
+ self._addThread(target=self._doLockSet, args=("one", 0))
+ self._addThread(target=self._doLockSet, args=("one", 1))
+ self._addThread(target=self._doLockSet, args=(["two", "three"], 0))
+ self._addThread(target=self._doLockSet, args=(["two", "three"], 1))
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.ls.release()
self._waitThreads()
for _ in range(6):
- self.failUnlessEqual(self.done.get_nowait(), 'DONE')
+ self.failUnlessEqual(self.done.get_nowait(), "DONE")
@_Repeat
def testSimpleAcquireTimeoutExpiring(self):
@@ -1412,7 +1412,7 @@ class TestLockSet(_ThreadedTestCase):
@_Repeat
def testDelayedAndExpiringLockAcquire(self):
self._setUpLS()
- self.ls.add(['five', 'six', 'seven', 'eight', 'nine'])
+ self.ls.add(["five", "six", "seven", "eight", "nine"])
for expire in (False, True):
names = sorted(self.ls._names())
@@ -1483,37 +1483,37 @@ class TestLockSet(_ThreadedTestCase):
@_Repeat
def testConcurrentRemove(self):
- self.ls.add('four')
- self.ls.acquire(['one', 'two', 'four'])
- self._addThread(target=self._doLockSet, args=(['one', 'four'], 0))
- self._addThread(target=self._doLockSet, args=(['one', 'four'], 1))
- self._addThread(target=self._doLockSet, args=(['one', 'two'], 0))
- self._addThread(target=self._doLockSet, args=(['one', 'two'], 1))
+ self.ls.add("four")
+ self.ls.acquire(["one", "two", "four"])
+ self._addThread(target=self._doLockSet, args=(["one", "four"], 0))
+ self._addThread(target=self._doLockSet, args=(["one", "four"], 1))
+ self._addThread(target=self._doLockSet, args=(["one", "two"], 0))
+ self._addThread(target=self._doLockSet, args=(["one", "two"], 1))
self.assertRaises(Queue.Empty, self.done.get_nowait)
- self.ls.remove('one')
+ self.ls.remove("one")
self.ls.release()
self._waitThreads()
for i in range(4):
- self.failUnlessEqual(self.done.get_nowait(), 'ERR')
- self.ls.add(['five', 'six'], acquired=1)
- self._addThread(target=self._doLockSet, args=(['three', 'six'], 1))
- self._addThread(target=self._doLockSet, args=(['three', 'six'], 0))
- self._addThread(target=self._doLockSet, args=(['four', 'six'], 1))
- self._addThread(target=self._doLockSet, args=(['four', 'six'], 0))
- self.ls.remove('five')
+ self.failUnlessEqual(self.done.get_nowait(), "ERR")
+ self.ls.add(["five", "six"], acquired=1)
+ self._addThread(target=self._doLockSet, args=(["three", "six"], 1))
+ self._addThread(target=self._doLockSet, args=(["three", "six"], 0))
+ self._addThread(target=self._doLockSet, args=(["four", "six"], 1))
+ self._addThread(target=self._doLockSet, args=(["four", "six"], 0))
+ self.ls.remove("five")
self.ls.release()
self._waitThreads()
for i in range(4):
- self.failUnlessEqual(self.done.get_nowait(), 'DONE')
- self.ls.acquire(['three', 'four'])
- self._addThread(target=self._doRemoveSet, args=(['four', 'six'], ))
+ self.failUnlessEqual(self.done.get_nowait(), "DONE")
+ self.ls.acquire(["three", "four"])
+ self._addThread(target=self._doRemoveSet, args=(["four", "six"], ))
self.assertRaises(Queue.Empty, self.done.get_nowait)
- self.ls.remove('four')
+ self.ls.remove("four")
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), ['six'])
- self._addThread(target=self._doRemoveSet, args=(['two']))
+ self.assertEqual(self.done.get_nowait(), ["six"])
+ self._addThread(target=self._doRemoveSet, args=(["two"]))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), ['two'])
+ self.assertEqual(self.done.get_nowait(), ["two"])
self.ls.release()
# reset lockset
self._setUpLS()
@@ -1525,23 +1525,23 @@ class TestLockSet(_ThreadedTestCase):
# ...another thread can share it too
self._addThread(target=self._doLockSet, args=(None, 1))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
# ...or just share some elements
- self._addThread(target=self._doLockSet, args=(['one', 'three'], 1))
+ self._addThread(target=self._doLockSet, args=(["one", "three"], 1))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
# ...but not add new ones or remove any
- t = self._addThread(target=self._doAddSet, args=(['nine']))
- self._addThread(target=self._doRemoveSet, args=(['two'], ))
+ t = self._addThread(target=self._doAddSet, args=(["nine"]))
+ self._addThread(target=self._doRemoveSet, args=(["two"], ))
self.assertRaises(Queue.Empty, self.done.get_nowait)
# this just releases the set-lock
self.ls.release([])
t.join(60)
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
# release the lock on the actual elements so remove() can proceed too
self.ls.release()
self._waitThreads()
- self.failUnlessEqual(self.done.get_nowait(), ['two'])
+ self.failUnlessEqual(self.done.get_nowait(), ["two"])
# reset lockset
self._setUpLS()
@@ -1552,75 +1552,75 @@ class TestLockSet(_ThreadedTestCase):
# ...no one can do anything else
self._addThread(target=self._doLockSet, args=(None, 1))
self._addThread(target=self._doLockSet, args=(None, 0))
- self._addThread(target=self._doLockSet, args=(['three'], 0))
- self._addThread(target=self._doLockSet, args=(['two'], 1))
- self._addThread(target=self._doAddSet, args=(['nine']))
+ self._addThread(target=self._doLockSet, args=(["three"], 0))
+ self._addThread(target=self._doLockSet, args=(["two"], 1))
+ self._addThread(target=self._doAddSet, args=(["nine"]))
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.ls.release()
self._waitThreads()
for _ in range(5):
- self.assertEqual(self.done.get(True, 1), 'DONE')
+ self.assertEqual(self.done.get(True, 1), "DONE")
# cleanup
self._setUpLS()
@_Repeat
def testConcurrentSetLockAdd(self):
- self.ls.acquire('one')
+ self.ls.acquire("one")
# Another thread wants the whole SetLock
self._addThread(target=self._doLockSet, args=(None, 0))
self._addThread(target=self._doLockSet, args=(None, 1))
self.assertRaises(Queue.Empty, self.done.get_nowait)
- self.assertRaises(AssertionError, self.ls.add, 'four')
+ self.assertRaises(AssertionError, self.ls.add, "four")
self.ls.release()
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
+ self.assertEqual(self.done.get_nowait(), "DONE")
self.ls.acquire(None)
self._addThread(target=self._doLockSet, args=(None, 0))
self._addThread(target=self._doLockSet, args=(None, 1))
self.assertRaises(Queue.Empty, self.done.get_nowait)
- self.ls.add('four')
- self.ls.add('five', acquired=1)
- self.ls.add('six', acquired=1, shared=1)
+ self.ls.add("four")
+ self.ls.add("five", acquired=1)
+ self.ls.add("six", acquired=1, shared=1)
self.assertEquals(self.ls.list_owned(),
- set(['one', 'two', 'three', 'five', 'six']))
+ set(["one", "two", "three", "five", "six"]))
self.assertEquals(self.ls.is_owned(), True)
self.assertEquals(self.ls._names(),
- set(['one', 'two', 'three', 'four', 'five', 'six']))
+ set(["one", "two", "three", "four", "five", "six"]))
self.ls.release()
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
+ self.assertEqual(self.done.get_nowait(), "DONE")
self._setUpLS()
@_Repeat
def testEmptyLockSet(self):
# get the set-lock
- self.assertEqual(self.ls.acquire(None), set(['one', 'two', 'three']))
+ self.assertEqual(self.ls.acquire(None), set(["one", "two", "three"]))
# now empty it...
- self.ls.remove(['one', 'two', 'three'])
+ self.ls.remove(["one", "two", "three"])
# and adds/locks by another thread still wait
- self._addThread(target=self._doAddSet, args=(['nine']))
+ self._addThread(target=self._doAddSet, args=(["nine"]))
self._addThread(target=self._doLockSet, args=(None, 1))
self._addThread(target=self._doLockSet, args=(None, 0))
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.ls.release()
self._waitThreads()
for _ in range(3):
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
# empty it again...
- self.assertEqual(self.ls.remove(['nine']), ['nine'])
+ self.assertEqual(self.ls.remove(["nine"]), ["nine"])
# now share it...
self.assertEqual(self.ls.acquire(None, shared=1), set())
# other sharers can go, adds still wait
self._addThread(target=self._doLockSet, args=(None, 1))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
- self._addThread(target=self._doAddSet, args=(['nine']))
+ self.assertEqual(self.done.get_nowait(), "DONE")
+ self._addThread(target=self._doAddSet, args=(["nine"]))
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.ls.release()
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
self._setUpLS()
def testAcquireWithNamesDowngrade(self):
@@ -1771,13 +1771,12 @@ class TestLockSet(_ThreadedTestCase):
class TestGanetiLockManager(_ThreadedTestCase):
-
def setUp(self):
_ThreadedTestCase.setUp(self)
- self.nodes=['n1', 'n2']
- self.nodegroups=['g1', 'g2']
- self.instances=['i1', 'i2', 'i3']
- self.networks=['net1', 'net2', 'net3']
+ self.nodes = ["n1", "n2"]
+ self.nodegroups = ["g1", "g2"]
+ self.instances = ["i1", "i2", "i3"]
+ self.networks = ["net1", "net2", "net3"]
self.GL = locking.GanetiLockManager(self.nodes, self.nodegroups,
self.instances, self.networks)
@@ -1797,7 +1796,7 @@ class TestGanetiLockManager(_ThreadedTestCase):
self.assertRaises(AssertionError, locking.GanetiLockManager, [], [], [], [])
def testLockNames(self):
- self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(['BGL']))
+ self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(["BGL"]))
self.assertEqual(self.GL._names(locking.LEVEL_NODE), set(self.nodes))
self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP),
set(self.nodegroups))
@@ -1809,7 +1808,7 @@ class TestGanetiLockManager(_ThreadedTestCase):
def testInitAndResources(self):
locking.GanetiLockManager._instance = None
self.GL = locking.GanetiLockManager([], [], [], [])
- self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(['BGL']))
+ self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(["BGL"]))
self.assertEqual(self.GL._names(locking.LEVEL_NODE), set())
self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP), set())
self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE), set())
@@ -1817,7 +1816,7 @@ class TestGanetiLockManager(_ThreadedTestCase):
locking.GanetiLockManager._instance = None
self.GL = locking.GanetiLockManager(self.nodes, self.nodegroups, [], [])
- self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(['BGL']))
+ self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(["BGL"]))
self.assertEqual(self.GL._names(locking.LEVEL_NODE), set(self.nodes))
self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP),
set(self.nodegroups))
@@ -1826,7 +1825,7 @@ class TestGanetiLockManager(_ThreadedTestCase):
locking.GanetiLockManager._instance = None
self.GL = locking.GanetiLockManager([], [], self.instances, [])
- self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(['BGL']))
+ self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(["BGL"]))
self.assertEqual(self.GL._names(locking.LEVEL_NODE), set())
self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP), set())
self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE),
@@ -1834,7 +1833,7 @@ class TestGanetiLockManager(_ThreadedTestCase):
locking.GanetiLockManager._instance = None
self.GL = locking.GanetiLockManager([], [], [], self.networks)
- self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(['BGL']))
+ self.assertEqual(self.GL._names(locking.LEVEL_CLUSTER), set(["BGL"]))
self.assertEqual(self.GL._names(locking.LEVEL_NODE), set())
self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP), set())
self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE), set())
@@ -1842,31 +1841,31 @@ class TestGanetiLockManager(_ThreadedTestCase):
set(self.networks))
def testAcquireRelease(self):
- self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
- self.assertEquals(self.GL.list_owned(locking.LEVEL_CLUSTER), set(['BGL']))
- self.GL.acquire(locking.LEVEL_INSTANCE, ['i1'])
- self.GL.acquire(locking.LEVEL_NODEGROUP, ['g2'])
- self.GL.acquire(locking.LEVEL_NODE, ['n1', 'n2'], shared=1)
+ self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
+ self.assertEquals(self.GL.list_owned(locking.LEVEL_CLUSTER), set(["BGL"]))
+ self.GL.acquire(locking.LEVEL_INSTANCE, ["i1"])
+ self.GL.acquire(locking.LEVEL_NODEGROUP, ["g2"])
+ self.GL.acquire(locking.LEVEL_NODE, ["n1", "n2"], shared=1)
self.assertTrue(self.GL.check_owned(locking.LEVEL_NODE, ["n1", "n2"],
shared=1))
self.assertFalse(self.GL.check_owned(locking.LEVEL_INSTANCE, ["i1", "i3"]))
- self.GL.release(locking.LEVEL_NODE, ['n2'])
- self.assertEquals(self.GL.list_owned(locking.LEVEL_NODE), set(['n1']))
- self.assertEquals(self.GL.list_owned(locking.LEVEL_NODEGROUP), set(['g2']))
- self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(['i1']))
+ self.GL.release(locking.LEVEL_NODE, ["n2"])
+ self.assertEquals(self.GL.list_owned(locking.LEVEL_NODE), set(["n1"]))
+ self.assertEquals(self.GL.list_owned(locking.LEVEL_NODEGROUP), set(["g2"]))
+ self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(["i1"]))
self.GL.release(locking.LEVEL_NODE)
self.assertEquals(self.GL.list_owned(locking.LEVEL_NODE), set())
- self.assertEquals(self.GL.list_owned(locking.LEVEL_NODEGROUP), set(['g2']))
- self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(['i1']))
+ self.assertEquals(self.GL.list_owned(locking.LEVEL_NODEGROUP), set(["g2"]))
+ self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(["i1"]))
self.GL.release(locking.LEVEL_NODEGROUP)
self.GL.release(locking.LEVEL_INSTANCE)
self.assertRaises(errors.LockError, self.GL.acquire,
- locking.LEVEL_INSTANCE, ['i5'])
- self.GL.acquire(locking.LEVEL_INSTANCE, ['i3'], shared=1)
- self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(['i3']))
+ locking.LEVEL_INSTANCE, ["i5"])
+ self.GL.acquire(locking.LEVEL_INSTANCE, ["i3"], shared=1)
+ self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE), set(["i3"]))
def testAcquireWholeSets(self):
- self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
+ self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
self.assertEquals(self.GL.acquire(locking.LEVEL_INSTANCE, None),
set(self.instances))
self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE),
@@ -1885,118 +1884,118 @@ class TestGanetiLockManager(_ThreadedTestCase):
self.GL.release(locking.LEVEL_CLUSTER)
def testAcquireWholeAndPartial(self):
- self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
+ self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
self.assertEquals(self.GL.acquire(locking.LEVEL_INSTANCE, None),
set(self.instances))
self.assertEquals(self.GL.list_owned(locking.LEVEL_INSTANCE),
set(self.instances))
- self.assertEquals(self.GL.acquire(locking.LEVEL_NODE, ['n2'], shared=1),
- set(['n2']))
+ self.assertEquals(self.GL.acquire(locking.LEVEL_NODE, ["n2"], shared=1),
+ set(["n2"]))
self.assertEquals(self.GL.list_owned(locking.LEVEL_NODE),
- set(['n2']))
+ set(["n2"]))
self.GL.release(locking.LEVEL_NODE)
self.GL.release(locking.LEVEL_INSTANCE)
self.GL.release(locking.LEVEL_CLUSTER)
def testBGLDependency(self):
self.assertRaises(AssertionError, self.GL.acquire,
- locking.LEVEL_NODE, ['n1', 'n2'])
+ locking.LEVEL_NODE, ["n1", "n2"])
self.assertRaises(AssertionError, self.GL.acquire,
- locking.LEVEL_INSTANCE, ['i3'])
+ locking.LEVEL_INSTANCE, ["i3"])
self.assertRaises(AssertionError, self.GL.acquire,
- locking.LEVEL_NODEGROUP, ['g1'])
- self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
- self.GL.acquire(locking.LEVEL_NODE, ['n1'])
+ locking.LEVEL_NODEGROUP, ["g1"])
+ self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
+ self.GL.acquire(locking.LEVEL_NODE, ["n1"])
self.assertRaises(AssertionError, self.GL.release,
- locking.LEVEL_CLUSTER, ['BGL'])
+ locking.LEVEL_CLUSTER, ["BGL"])
self.assertRaises(AssertionError, self.GL.release,
locking.LEVEL_CLUSTER)
self.GL.release(locking.LEVEL_NODE)
- self.GL.acquire(locking.LEVEL_INSTANCE, ['i1', 'i2'])
+ self.GL.acquire(locking.LEVEL_INSTANCE, ["i1", "i2"])
self.assertRaises(AssertionError, self.GL.release,
- locking.LEVEL_CLUSTER, ['BGL'])
+ locking.LEVEL_CLUSTER, ["BGL"])
self.assertRaises(AssertionError, self.GL.release,
locking.LEVEL_CLUSTER)
self.GL.release(locking.LEVEL_INSTANCE)
self.GL.acquire(locking.LEVEL_NODEGROUP, None)
- self.GL.release(locking.LEVEL_NODEGROUP, ['g1'])
+ self.GL.release(locking.LEVEL_NODEGROUP, ["g1"])
self.assertRaises(AssertionError, self.GL.release,
- locking.LEVEL_CLUSTER, ['BGL'])
+ locking.LEVEL_CLUSTER, ["BGL"])
self.assertRaises(AssertionError, self.GL.release,
locking.LEVEL_CLUSTER)
self.GL.release(locking.LEVEL_NODEGROUP)
self.GL.release(locking.LEVEL_CLUSTER)
def testWrongOrder(self):
- self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
- self.GL.acquire(locking.LEVEL_NODE, ['n2'])
+ self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
+ self.GL.acquire(locking.LEVEL_NODE, ["n2"])
self.assertRaises(AssertionError, self.GL.acquire,
- locking.LEVEL_NODE, ['n1'])
+ locking.LEVEL_NODE, ["n1"])
self.assertRaises(AssertionError, self.GL.acquire,
- locking.LEVEL_NODEGROUP, ['g1'])
+ locking.LEVEL_NODEGROUP, ["g1"])
self.assertRaises(AssertionError, self.GL.acquire,
- locking.LEVEL_INSTANCE, ['i2'])
+ locking.LEVEL_INSTANCE, ["i2"])
def testModifiableLevels(self):
self.assertRaises(AssertionError, self.GL.add, locking.LEVEL_CLUSTER,
- ['BGL2'])
- self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'])
- self.GL.add(locking.LEVEL_INSTANCE, ['i4'])
- self.GL.remove(locking.LEVEL_INSTANCE, ['i3'])
- self.GL.remove(locking.LEVEL_INSTANCE, ['i1'])
- self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE), set(['i2', 'i4']))
- self.GL.add(locking.LEVEL_NODE, ['n3'])
- self.GL.remove(locking.LEVEL_NODE, ['n1'])
- self.assertEqual(self.GL._names(locking.LEVEL_NODE), set(['n2', 'n3']))
- self.GL.add(locking.LEVEL_NODEGROUP, ['g3'])
- self.GL.remove(locking.LEVEL_NODEGROUP, ['g2'])
- self.GL.remove(locking.LEVEL_NODEGROUP, ['g1'])
- self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP), set(['g3']))
+ ["BGL2"])
+ self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"])
+ self.GL.add(locking.LEVEL_INSTANCE, ["i4"])
+ self.GL.remove(locking.LEVEL_INSTANCE, ["i3"])
+ self.GL.remove(locking.LEVEL_INSTANCE, ["i1"])
+ self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE), set(["i2", "i4"]))
+ self.GL.add(locking.LEVEL_NODE, ["n3"])
+ self.GL.remove(locking.LEVEL_NODE, ["n1"])
+ self.assertEqual(self.GL._names(locking.LEVEL_NODE), set(["n2", "n3"]))
+ self.GL.add(locking.LEVEL_NODEGROUP, ["g3"])
+ self.GL.remove(locking.LEVEL_NODEGROUP, ["g2"])
+ self.GL.remove(locking.LEVEL_NODEGROUP, ["g1"])
+ self.assertEqual(self.GL._names(locking.LEVEL_NODEGROUP), set(["g3"]))
self.assertRaises(AssertionError, self.GL.remove, locking.LEVEL_CLUSTER,
- ['BGL2'])
+ ["BGL2"])
# Helper function to run as a thread that shared the BGL and then acquires
# some locks at another level.
def _doLock(self, level, names, shared):
try:
- self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
+ self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
self.GL.acquire(level, names, shared=shared)
- self.done.put('DONE')
+ self.done.put("DONE")
self.GL.release(level)
self.GL.release(locking.LEVEL_CLUSTER)
except errors.LockError:
- self.done.put('ERR')
+ self.done.put("ERR")
@_Repeat
def testConcurrency(self):
- self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)
+ self.GL.acquire(locking.LEVEL_CLUSTER, ["BGL"], shared=1)
self._addThread(target=self._doLock,
- args=(locking.LEVEL_INSTANCE, 'i1', 1))
+ args=(locking.LEVEL_INSTANCE, "i1", 1))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
- self.GL.acquire(locking.LEVEL_INSTANCE, ['i3'])
+ self.assertEqual(self.done.get_nowait(), "DONE")
+ self.GL.acquire(locking.LEVEL_INSTANCE, ["i3"])
self._addThread(target=self._doLock,
- args=(locking.LEVEL_INSTANCE, 'i1', 1))
+ args=(locking.LEVEL_INSTANCE, "i1", 1))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
self._addThread(target=self._doLock,
- args=(locking.LEVEL_INSTANCE, 'i3', 1))
+ args=(locking.LEVEL_INSTANCE, "i3", 1))
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.GL.release(locking.LEVEL_INSTANCE)
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
- self.GL.acquire(locking.LEVEL_INSTANCE, ['i2'], shared=1)
+ self.assertEqual(self.done.get_nowait(), "DONE")
+ self.GL.acquire(locking.LEVEL_INSTANCE, ["i2"], shared=1)
self._addThread(target=self._doLock,
- args=(locking.LEVEL_INSTANCE, 'i2', 1))
+ args=(locking.LEVEL_INSTANCE, "i2", 1))
self._waitThreads()
- self.assertEqual(self.done.get_nowait(), 'DONE')
+ self.assertEqual(self.done.get_nowait(), "DONE")
self._addThread(target=self._doLock,
- args=(locking.LEVEL_INSTANCE, 'i2', 0))
+ args=(locking.LEVEL_INSTANCE, "i2", 0))
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.GL.release(locking.LEVEL_INSTANCE)
self._waitThreads()
- self.assertEqual(self.done.get(True, 1), 'DONE')
- self.GL.release(locking.LEVEL_CLUSTER, ['BGL'])
+ self.assertEqual(self.done.get(True, 1), "DONE")
+ self.GL.release(locking.LEVEL_CLUSTER, ["BGL"])
class TestLockMonitor(_ThreadedTestCase):
diff --git a/test/ganeti.objects_unittest.py b/test/ganeti.objects_unittest.py
index c4fd4458d32b190c0fc4a210a653c628f4b92c5a..19b75c1ee05a2fb6f85d262f44ef8940f9065835 100755
--- a/test/ganeti.objects_unittest.py
+++ b/test/ganeti.objects_unittest.py
@@ -32,22 +32,22 @@ import testutils
class SimpleObject(objects.ConfigObject):
- __slots__ = ['a', 'b']
+ __slots__ = ["a", "b"]
class TestDictState(unittest.TestCase):
"""Simple dict tansformation tests"""
def testSimpleObjectToDict(self):
- o1 = SimpleObject(a='1')
- self.assertEquals(o1.ToDict(), {'a': '1'})
- self.assertEquals(o1.__getstate__(), {'a': '1'})
+ o1 = SimpleObject(a="1")
+ self.assertEquals(o1.ToDict(), {"a": "1"})
+ self.assertEquals(o1.__getstate__(), {"a": "1"})
self.assertEquals(o1.__getstate__(), o1.ToDict())
o1.a = 2
o1.b = 5
- self.assertEquals(o1.ToDict(), {'a': 2, 'b': 5})
+ self.assertEquals(o1.ToDict(), {"a": 2, "b": 5})
o2 = SimpleObject.FromDict(o1.ToDict())
- self.assertEquals(o1.ToDict(), {'a': 2, 'b': 5})
+ self.assertEquals(o1.ToDict(), {"a": 2, "b": 5})
class TestClusterObject(unittest.TestCase):
diff --git a/test/ganeti.ovf_unittest.py b/test/ganeti.ovf_unittest.py
index da7e92d8afe310c13e807eda9b36466c72a02280..bc724961921246d5a13d617d485bf0ea1075a6b8 100755
--- a/test/ganeti.ovf_unittest.py
+++ b/test/ganeti.ovf_unittest.py
@@ -220,16 +220,16 @@ EXP_PARTIAL_GANETI_DICT = {
"version": "0",
}
EXP_GANETI_DICT = {
- 'tags': None,
- 'auto_balance': 'False',
- 'hypervisor': {
- 'root-path': '/dev/sda',
- 'name': 'xen-pvm',
- 'kernel_args': 'ro'
+ "tags": None,
+ "auto_balance": "False",
+ "hypervisor": {
+ "root-path": "/dev/sda",
+ "name": "xen-pvm",
+ "kernel_args": "ro"
},
- 'version': '0',
- 'disk_template': None,
- 'os': {'name': 'lenny-image'}
+ "version": "0",
+ "disk_template": None,
+ "os": {"name": "lenny-image"}
}
EXP_NAME ="xen-dev-i1"
EXP_VCPUS = 1
diff --git a/test/ganeti.rapi.resources_unittest.py b/test/ganeti.rapi.resources_unittest.py
index e48707c2e41309f5039e6ec155f7f9da121d51ce..1f0d74ebb4b77f44cdb0964703adde8412ae2bc2 100755
--- a/test/ganeti.rapi.resources_unittest.py
+++ b/test/ganeti.rapi.resources_unittest.py
@@ -53,16 +53,16 @@ class MapperTests(unittest.TestCase):
self._TestFailingUri("/instances")
self._TestUri("/version", (rlib2.R_version, [], {}))
- self._TestUri('/2/instances/www.test.com',
+ self._TestUri("/2/instances/www.test.com",
(rlib2.R_2_instances_name,
- ['www.test.com'],
+ ["www.test.com"],
{}))
- self._TestUri('/2/instances/www.test.com/tags?f=5&f=6&alt=html',
+ self._TestUri("/2/instances/www.test.com/tags?f=5&f=6&alt=html",
(rlib2.R_2_instances_name_tags,
- ['www.test.com'],
- {'alt': ['html'],
- 'f': ['5', '6'],
+ ["www.test.com"],
+ {"alt": ["html"],
+ "f": ["5", "6"],
}))
self._TestFailingUri("/tag")
diff --git a/test/ganeti.serializer_unittest.py b/test/ganeti.serializer_unittest.py
index a7472c39598ba181b776031df3ea613724db14c8..75c498c06d0fa9a35d0d77322b3cbe9820dc66bf 100755
--- a/test/ganeti.serializer_unittest.py
+++ b/test/ganeti.serializer_unittest.py
@@ -71,7 +71,7 @@ class TestSerializer(testutils.GanetiTestCase):
def _TestSigned(self, dump_fn, load_fn):
for data in self._TESTDATA:
self.assertEqualValues(load_fn(dump_fn(data, "mykey"), "mykey"),
- (data, ''))
+ (data, ""))
self.assertEqualValues(load_fn(dump_fn(data, "myprivatekey",
salt="mysalt"),
"myprivatekey"),
diff --git a/test/ganeti.utils.io_unittest.py b/test/ganeti.utils.io_unittest.py
index cffea24de1f9414ee5661edc145b17193169ba3e..8cee74bc377b359b97dac6d1f4b5b829a76ebc62 100755
--- a/test/ganeti.utils.io_unittest.py
+++ b/test/ganeti.utils.io_unittest.py
@@ -470,8 +470,8 @@ class TestRemoveFile(unittest.TestCase):
def setUp(self):
"""Create a temp dir and file for each case"""
- self.tmpdir = tempfile.mkdtemp('', 'ganeti-unittest-')
- fd, self.tmpfile = tempfile.mkstemp('', '', self.tmpdir)
+ self.tmpdir = tempfile.mkdtemp("", "ganeti-unittest-")
+ fd, self.tmpfile = tempfile.mkstemp("", "", self.tmpdir)
os.close(fd)
def tearDown(self):
@@ -772,15 +772,15 @@ class TestPidFileFunctions(unittest.TestCase):
self.f_dpn = lambda name: os.path.join(self.dir, "%s.pid" % name)
def testPidFileFunctions(self):
- pid_file = self.f_dpn('test')
- fd = utils.WritePidFile(self.f_dpn('test'))
+ pid_file = self.f_dpn("test")
+ fd = utils.WritePidFile(self.f_dpn("test"))
self.failUnless(os.path.exists(pid_file),
"PID file should have been created")
read_pid = utils.ReadPidFile(pid_file)
self.failUnlessEqual(read_pid, os.getpid())
self.failUnless(utils.IsProcessAlive(read_pid))
self.failUnlessRaises(errors.PidFileLockError, utils.WritePidFile,
- self.f_dpn('test'))
+ self.f_dpn("test"))
os.close(fd)
utils.RemoveFile(self.f_dpn("test"))
self.failIf(os.path.exists(pid_file),
@@ -793,19 +793,19 @@ class TestPidFileFunctions(unittest.TestCase):
self.failUnlessEqual(utils.ReadPidFile(pid_file), 0,
"ReadPidFile should return 0 for invalid pid file")
# but now, even with the file existing, we should be able to lock it
- fd = utils.WritePidFile(self.f_dpn('test'))
+ fd = utils.WritePidFile(self.f_dpn("test"))
os.close(fd)
utils.RemoveFile(self.f_dpn("test"))
self.failIf(os.path.exists(pid_file),
"PID file should not exist anymore")
def testKill(self):
- pid_file = self.f_dpn('child')
+ pid_file = self.f_dpn("child")
r_fd, w_fd = os.pipe()
new_pid = os.fork()
if new_pid == 0: #child
- utils.WritePidFile(self.f_dpn('child'))
- os.write(w_fd, 'a')
+ utils.WritePidFile(self.f_dpn("child"))
+ os.write(w_fd, "a")
signal.pause()
os._exit(0)
return
@@ -829,7 +829,7 @@ class TestPidFileFunctions(unittest.TestCase):
utils.KillProcess(new_pid, waitpid=True)
self.failIf(utils.IsProcessAlive(new_pid))
- utils.RemoveFile(self.f_dpn('child'))
+ utils.RemoveFile(self.f_dpn("child"))
self.failUnlessRaises(errors.ProgrammerError, utils.KillProcess, 0)
def testExceptionType(self):
@@ -844,14 +844,14 @@ class TestPidFileFunctions(unittest.TestCase):
class TestSshKeys(testutils.GanetiTestCase):
"""Test case for the AddAuthorizedKey function"""
- KEY_A = 'ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@key-a'
+ KEY_A = "ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@key-a"
KEY_B = ('command="/usr/bin/fooserver -t --verbose",from="198.51.100.4" '
- 'ssh-dss AAAAB3NzaC1w520smc01ms0jfJs22 root@key-b')
+ "ssh-dss AAAAB3NzaC1w520smc01ms0jfJs22 root@key-b")
def setUp(self):
testutils.GanetiTestCase.setUp(self)
self.tmpname = self._CreateTempFile()
- handle = open(self.tmpname, 'w')
+ handle = open(self.tmpname, "w")
try:
handle.write("%s\n" % TestSshKeys.KEY_A)
handle.write("%s\n" % TestSshKeys.KEY_B)
@@ -860,7 +860,7 @@ class TestSshKeys(testutils.GanetiTestCase):
def testAddingNewKey(self):
utils.AddAuthorizedKey(self.tmpname,
- 'ssh-dss AAAAB3NzaC1kc3MAAACB root@test')
+ "ssh-dss AAAAB3NzaC1kc3MAAACB root@test")
self.assertFileContent(self.tmpname,
"ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@key-a\n"
@@ -870,7 +870,7 @@ class TestSshKeys(testutils.GanetiTestCase):
def testAddingAlmostButNotCompletelyTheSameKey(self):
utils.AddAuthorizedKey(self.tmpname,
- 'ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@test')
+ "ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@test")
# Only significant fields are compared, therefore the key won't be
# updated/added
@@ -893,7 +893,7 @@ class TestSshKeys(testutils.GanetiTestCase):
def testRemovingExistingKeyWithSomeMoreSpaces(self):
utils.RemoveAuthorizedKey(self.tmpname,
- 'ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@key-a')
+ "ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@key-a")
self.assertFileContent(self.tmpname,
'command="/usr/bin/fooserver -t --verbose",from="198.51.100.4"'
@@ -901,7 +901,7 @@ class TestSshKeys(testutils.GanetiTestCase):
def testRemovingNonExistingKey(self):
utils.RemoveAuthorizedKey(self.tmpname,
- 'ssh-dss AAAAB3Nsdfj230xxjxJjsjwjsjdjU root@test')
+ "ssh-dss AAAAB3Nsdfj230xxjxJjsjwjsjdjU root@test")
self.assertFileContent(self.tmpname,
"ssh-dss AAAAB3NzaC1w5256closdj32mZaQU root@key-a\n"
diff --git a/test/ganeti.utils.text_unittest.py b/test/ganeti.utils.text_unittest.py
index 16dd6ace8ee64725eeaf6bb9deb958f282b7b768..181e2f6cfd9fd2ec735c80b28b8cd8d30fb433c5 100755
--- a/test/ganeti.utils.text_unittest.py
+++ b/test/ganeti.utils.text_unittest.py
@@ -261,14 +261,14 @@ class TestShellQuoting(unittest.TestCase):
"""Test case for shell quoting functions"""
def testShellQuote(self):
- self.assertEqual(utils.ShellQuote('abc'), "abc")
+ self.assertEqual(utils.ShellQuote("abc"), "abc")
self.assertEqual(utils.ShellQuote('ab"c'), "'ab\"c'")
self.assertEqual(utils.ShellQuote("a'bc"), "'a'\\''bc'")
self.assertEqual(utils.ShellQuote("a b c"), "'a b c'")
self.assertEqual(utils.ShellQuote("a b\\ c"), "'a b\\ c'")
def testShellQuoteArgs(self):
- self.assertEqual(utils.ShellQuoteArgs(['a', 'b', 'c']), "a b c")
+ self.assertEqual(utils.ShellQuoteArgs(["a", "b", "c"]), "a b c")
self.assertEqual(utils.ShellQuoteArgs(['a', 'b"', 'c']), "a 'b\"' c")
self.assertEqual(utils.ShellQuoteArgs(['a', 'b\'', 'c']), "a 'b'\\\''' c")
diff --git a/test/ganeti.utils_unittest.py b/test/ganeti.utils_unittest.py
index 391b88cce1a3fe8e6418a6298c0573280abcdd6d..343e029fb88280bb9835e9ffa7602b4c38dfdd83 100755
--- a/test/ganeti.utils_unittest.py
+++ b/test/ganeti.utils_unittest.py
@@ -180,29 +180,29 @@ class TestForceDictType(unittest.TestCase):
def testSimpleDict(self):
self.assertEqual(self._fdt({}), {})
- self.assertEqual(self._fdt({'a': 1}), {'a': 1})
- self.assertEqual(self._fdt({'a': '1'}), {'a': 1})
- self.assertEqual(self._fdt({'a': 1, 'b': 1}), {'a':1, 'b': True})
- self.assertEqual(self._fdt({'b': 1, 'c': 'foo'}), {'b': True, 'c': 'foo'})
- self.assertEqual(self._fdt({'b': 1, 'c': False}), {'b': True, 'c': ''})
- self.assertEqual(self._fdt({'b': 'false'}), {'b': False})
- self.assertEqual(self._fdt({'b': 'False'}), {'b': False})
- self.assertEqual(self._fdt({'b': False}), {'b': False})
- self.assertEqual(self._fdt({'b': 'true'}), {'b': True})
- self.assertEqual(self._fdt({'b': 'True'}), {'b': True})
- self.assertEqual(self._fdt({'d': '4'}), {'d': 4})
- self.assertEqual(self._fdt({'d': '4M'}), {'d': 4})
+ self.assertEqual(self._fdt({"a": 1}), {"a": 1})
+ self.assertEqual(self._fdt({"a": "1"}), {"a": 1})
+ self.assertEqual(self._fdt({"a": 1, "b": 1}), {"a":1, "b": True})
+ self.assertEqual(self._fdt({"b": 1, "c": "foo"}), {"b": True, "c": "foo"})
+ self.assertEqual(self._fdt({"b": 1, "c": False}), {"b": True, "c": ""})
+ self.assertEqual(self._fdt({"b": "false"}), {"b": False})
+ self.assertEqual(self._fdt({"b": "False"}), {"b": False})
+ self.assertEqual(self._fdt({"b": False}), {"b": False})
+ self.assertEqual(self._fdt({"b": "true"}), {"b": True})
+ self.assertEqual(self._fdt({"b": "True"}), {"b": True})
+ self.assertEqual(self._fdt({"d": "4"}), {"d": 4})
+ self.assertEqual(self._fdt({"d": "4M"}), {"d": 4})
self.assertEqual(self._fdt({"e": None, }), {"e": None, })
self.assertEqual(self._fdt({"e": "Hello World", }), {"e": "Hello World", })
- self.assertEqual(self._fdt({"e": False, }), {"e": '', })
+ self.assertEqual(self._fdt({"e": False, }), {"e": "", })
self.assertEqual(self._fdt({"b": "hello", }, ["hello"]), {"b": "hello"})
def testErrors(self):
- self.assertRaises(errors.TypeEnforcementError, self._fdt, {'a': 'astring'})
+ self.assertRaises(errors.TypeEnforcementError, self._fdt, {"a": "astring"})
self.assertRaises(errors.TypeEnforcementError, self._fdt, {"b": "hello"})
- self.assertRaises(errors.TypeEnforcementError, self._fdt, {'c': True})
- self.assertRaises(errors.TypeEnforcementError, self._fdt, {'d': 'astring'})
- self.assertRaises(errors.TypeEnforcementError, self._fdt, {'d': '4 L'})
+ self.assertRaises(errors.TypeEnforcementError, self._fdt, {"c": True})
+ self.assertRaises(errors.TypeEnforcementError, self._fdt, {"d": "astring"})
+ self.assertRaises(errors.TypeEnforcementError, self._fdt, {"d": "4 L"})
self.assertRaises(errors.TypeEnforcementError, self._fdt, {"e": object(), })
self.assertRaises(errors.TypeEnforcementError, self._fdt, {"e": [], })
self.assertRaises(errors.TypeEnforcementError, self._fdt, {"x": None, })