Revision 44b4eddc test/ganeti.locking_unittest.py
b/test/ganeti.locking_unittest.py | ||
---|---|---|
689 | 689 |
ev.wait() |
690 | 690 |
|
691 | 691 |
# Check lock information |
692 |
self.assertEqual(self.sl.GetInfo(set([query.LQ_MODE, query.LQ_OWNER])), |
|
693 |
(self.sl.name, "exclusive", [th_excl1.getName()], None))
|
|
694 |
(_, _, _, pending) = self.sl.GetInfo(set([query.LQ_PENDING]))
|
|
692 |
self.assertEqual(self.sl.GetLockInfo(set([query.LQ_MODE, query.LQ_OWNER])),
|
|
693 |
[(self.sl.name, "exclusive", [th_excl1.getName()], None)])
|
|
694 |
[(_, _, _, pending), ] = self.sl.GetLockInfo(set([query.LQ_PENDING]))
|
|
695 | 695 |
self.assertEqual([(pendmode, sorted(waiting)) |
696 | 696 |
for (pendmode, waiting) in pending], |
697 | 697 |
[("exclusive", [th_excl2.getName()]), |
... | ... | |
705 | 705 |
ev.wait() |
706 | 706 |
|
707 | 707 |
# Check lock information again |
708 |
self.assertEqual(self.sl.GetInfo(set([query.LQ_MODE, query.LQ_PENDING])), |
|
709 |
(self.sl.name, "shared", None, |
|
710 |
[("exclusive", [th_excl2.getName()])])) |
|
711 |
(_, _, owner, _) = self.sl.GetInfo(set([query.LQ_OWNER])) |
|
708 |
self.assertEqual(self.sl.GetLockInfo(set([query.LQ_MODE, |
|
709 |
query.LQ_PENDING])), |
|
710 |
[(self.sl.name, "shared", None, |
|
711 |
[("exclusive", [th_excl2.getName()])])]) |
|
712 |
[(_, _, owner, _), ] = self.sl.GetLockInfo(set([query.LQ_OWNER])) |
|
712 | 713 |
self.assertEqual(set(owner), set([th_excl1.getName()] + |
713 | 714 |
[th.getName() for th in th_shared])) |
714 | 715 |
|
... | ... | |
718 | 719 |
|
719 | 720 |
self._waitThreads() |
720 | 721 |
|
721 |
self.assertEqual(self.sl.GetInfo(set([query.LQ_MODE, query.LQ_OWNER, |
|
722 |
query.LQ_PENDING])), |
|
723 |
(self.sl.name, None, None, []))
|
|
722 |
self.assertEqual(self.sl.GetLockInfo(set([query.LQ_MODE, query.LQ_OWNER,
|
|
723 |
query.LQ_PENDING])),
|
|
724 |
[(self.sl.name, None, None, [])])
|
|
724 | 725 |
|
725 | 726 |
@_Repeat |
726 | 727 |
def testMixedAcquireTimeout(self): |
... | ... | |
887 | 888 |
prev.wait() |
888 | 889 |
|
889 | 890 |
# Check lock information |
890 |
self.assertEqual(self.sl.GetInfo(set()), (self.sl.name, None, None, None)) |
|
891 |
self.assertEqual(self.sl.GetInfo(set([query.LQ_MODE, query.LQ_OWNER])), |
|
892 |
(self.sl.name, "exclusive", |
|
893 |
[threading.currentThread().getName()], None)) |
|
891 |
self.assertEqual(self.sl.GetLockInfo(set()), |
|
892 |
[(self.sl.name, None, None, None)]) |
|
893 |
self.assertEqual(self.sl.GetLockInfo(set([query.LQ_MODE, query.LQ_OWNER])), |
|
894 |
[(self.sl.name, "exclusive", |
|
895 |
[threading.currentThread().getName()], None)]) |
|
894 | 896 |
|
895 |
self._VerifyPrioPending(self.sl.GetInfo(set([query.LQ_PENDING])), perprio) |
|
897 |
self._VerifyPrioPending(self.sl.GetLockInfo(set([query.LQ_PENDING])), |
|
898 |
perprio) |
|
896 | 899 |
|
897 | 900 |
# Let threads acquire the lock |
898 | 901 |
self.sl.release() |
... | ... | |
913 | 916 |
|
914 | 917 |
self.assertRaises(Queue.Empty, self.done.get_nowait) |
915 | 918 |
|
916 |
def _VerifyPrioPending(self, (name, mode, owner, pending), perprio):
|
|
919 |
def _VerifyPrioPending(self, ((name, mode, owner, pending), ), perprio):
|
|
917 | 920 |
self.assertEqual(name, self.sl.name) |
918 | 921 |
self.assert_(mode is None) |
919 | 922 |
self.assert_(owner is None) |
... | ... | |
2154 | 2157 |
result = self.lm.QueryLocks(["name", "mode", "owner"]) |
2155 | 2158 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, []) |
2156 | 2159 |
|
2160 |
class _FakeLock: |
|
2161 |
def __init__(self): |
|
2162 |
self._info = [] |
|
2163 |
|
|
2164 |
def AddResult(self, *args): |
|
2165 |
self._info.append(args) |
|
2166 |
|
|
2167 |
def CountPending(self): |
|
2168 |
return len(self._info) |
|
2169 |
|
|
2170 |
def GetLockInfo(self, requested): |
|
2171 |
(exp_requested, result) = self._info.pop(0) |
|
2172 |
|
|
2173 |
if exp_requested != requested: |
|
2174 |
raise Exception("Requested information (%s) does not match" |
|
2175 |
" expectations (%s)" % (requested, exp_requested)) |
|
2176 |
|
|
2177 |
return result |
|
2178 |
|
|
2179 |
def testMultipleResults(self): |
|
2180 |
fl1 = self._FakeLock() |
|
2181 |
fl2 = self._FakeLock() |
|
2182 |
|
|
2183 |
self.lm.RegisterLock(fl1) |
|
2184 |
self.lm.RegisterLock(fl2) |
|
2185 |
|
|
2186 |
# Empty information |
|
2187 |
for i in [fl1, fl2]: |
|
2188 |
i.AddResult(set([query.LQ_MODE, query.LQ_OWNER]), []) |
|
2189 |
result = self.lm.QueryLocks(["name", "mode", "owner"]) |
|
2190 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, []) |
|
2191 |
for i in [fl1, fl2]: |
|
2192 |
self.assertEqual(i.CountPending(), 0) |
|
2193 |
|
|
2194 |
# Check ordering |
|
2195 |
for fn in [lambda x: x, reversed, sorted]: |
|
2196 |
fl1.AddResult(set(), list(fn([ |
|
2197 |
("aaa", None, None, None), |
|
2198 |
("bbb", None, None, None), |
|
2199 |
]))) |
|
2200 |
fl2.AddResult(set(), []) |
|
2201 |
result = self.lm.QueryLocks(["name"]) |
|
2202 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, [ |
|
2203 |
[(constants.RS_NORMAL, "aaa")], |
|
2204 |
[(constants.RS_NORMAL, "bbb")], |
|
2205 |
]) |
|
2206 |
for i in [fl1, fl2]: |
|
2207 |
self.assertEqual(i.CountPending(), 0) |
|
2208 |
|
|
2209 |
for fn2 in [lambda x: x, reversed, sorted]: |
|
2210 |
fl1.AddResult(set([query.LQ_MODE]), list(fn([ |
|
2211 |
# Same name, but different information |
|
2212 |
("aaa", "mode0", None, None), |
|
2213 |
("aaa", "mode1", None, None), |
|
2214 |
("aaa", "mode2", None, None), |
|
2215 |
("aaa", "mode3", None, None), |
|
2216 |
]))) |
|
2217 |
fl2.AddResult(set([query.LQ_MODE]), [ |
|
2218 |
("zzz", "end", None, None), |
|
2219 |
("000", "start", None, None), |
|
2220 |
] + list(fn2([ |
|
2221 |
("aaa", "b200", None, None), |
|
2222 |
("aaa", "b300", None, None), |
|
2223 |
]))) |
|
2224 |
result = self.lm.QueryLocks(["name", "mode"]) |
|
2225 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, [ |
|
2226 |
[(constants.RS_NORMAL, "000"), (constants.RS_NORMAL, "start")], |
|
2227 |
] + list(fn([ |
|
2228 |
# Name is the same, so order must be equal to incoming order |
|
2229 |
[(constants.RS_NORMAL, "aaa"), (constants.RS_NORMAL, "mode0")], |
|
2230 |
[(constants.RS_NORMAL, "aaa"), (constants.RS_NORMAL, "mode1")], |
|
2231 |
[(constants.RS_NORMAL, "aaa"), (constants.RS_NORMAL, "mode2")], |
|
2232 |
[(constants.RS_NORMAL, "aaa"), (constants.RS_NORMAL, "mode3")], |
|
2233 |
])) + list(fn2([ |
|
2234 |
[(constants.RS_NORMAL, "aaa"), (constants.RS_NORMAL, "b200")], |
|
2235 |
[(constants.RS_NORMAL, "aaa"), (constants.RS_NORMAL, "b300")], |
|
2236 |
])) + [ |
|
2237 |
[(constants.RS_NORMAL, "zzz"), (constants.RS_NORMAL, "end")], |
|
2238 |
]) |
|
2239 |
for i in [fl1, fl2]: |
|
2240 |
self.assertEqual(i.CountPending(), 0) |
|
2241 |
|
|
2157 | 2242 |
|
2158 | 2243 |
if __name__ == '__main__': |
2159 | 2244 |
testutils.GanetiTestProgram() |
Also available in: Unified diff