Revision 24d16f76 test/ganeti.locking_unittest.py
| b/test/ganeti.locking_unittest.py | ||
|---|---|---|
| 30 | 30 |
import random |
| 31 | 31 |
import itertools |
| 32 | 32 |
|
| 33 |
from ganeti import constants |
|
| 33 | 34 |
from ganeti import locking |
| 34 | 35 |
from ganeti import errors |
| 35 | 36 |
from ganeti import utils |
| 36 | 37 |
from ganeti import compat |
| 38 |
from ganeti import objects |
|
| 39 |
from ganeti import query |
|
| 37 | 40 |
|
| 38 | 41 |
import testutils |
| 39 | 42 |
|
| ... | ... | |
| 773 | 776 |
prev.wait() |
| 774 | 777 |
|
| 775 | 778 |
# Check lock information |
| 776 |
self.assertEqual(self.sl.GetInfo(["name"]), [self.sl.name]) |
|
| 777 |
self.assertEqual(self.sl.GetInfo(["mode", "owner"]), |
|
| 778 |
["exclusive", [threading.currentThread().getName()]]) |
|
| 779 |
self.assertEqual(self.sl.GetInfo(["name", "pending"]), |
|
| 780 |
[self.sl.name, |
|
| 781 |
[(["exclusive", "shared"][int(bool(shared))], |
|
| 782 |
sorted([t.getName() for t in threads])) |
|
| 783 |
for acquires in [perprio[i] |
|
| 784 |
for i in sorted(perprio.keys())] |
|
| 785 |
for (shared, _, threads) in acquires]]) |
|
| 779 |
self.assertEqual(self.sl.GetInfo(set()), (self.sl.name, None, None, None)) |
|
| 780 |
self.assertEqual(self.sl.GetInfo(set([query.LQ_MODE, query.LQ_OWNER])), |
|
| 781 |
(self.sl.name, "exclusive", |
|
| 782 |
[threading.currentThread().getName()], None)) |
|
| 783 |
|
|
| 784 |
self._VerifyPrioPending(self.sl.GetInfo(set([query.LQ_PENDING])), perprio) |
|
| 786 | 785 |
|
| 787 | 786 |
# Let threads acquire the lock |
| 788 | 787 |
self.sl.release() |
| ... | ... | |
| 803 | 802 |
|
| 804 | 803 |
self.assertRaises(Queue.Empty, self.done.get_nowait) |
| 805 | 804 |
|
| 805 |
def _VerifyPrioPending(self, (name, mode, owner, pending), perprio): |
|
| 806 |
self.assertEqual(name, self.sl.name) |
|
| 807 |
self.assert_(mode is None) |
|
| 808 |
self.assert_(owner is None) |
|
| 809 |
|
|
| 810 |
self.assertEqual([(pendmode, sorted(waiting)) |
|
| 811 |
for (pendmode, waiting) in pending], |
|
| 812 |
[(["exclusive", "shared"][int(bool(shared))], |
|
| 813 |
sorted(t.getName() for t in threads)) |
|
| 814 |
for acquires in [perprio[i] |
|
| 815 |
for i in sorted(perprio.keys())] |
|
| 816 |
for (shared, _, threads) in acquires]) |
|
| 817 |
|
|
| 806 | 818 |
|
| 807 | 819 |
class TestSharedLockInCondition(_ThreadedTestCase): |
| 808 | 820 |
"""SharedLock as a condition lock tests""" |
| ... | ... | |
| 1638 | 1650 |
locks.append(locking.SharedLock(name, monitor=self.lm)) |
| 1639 | 1651 |
|
| 1640 | 1652 |
self.assertEqual(len(self.lm._locks), len(locks)) |
| 1641 |
|
|
| 1642 |
self.assertEqual(len(self.lm.QueryLocks(["name"], False)),
|
|
| 1643 |
100)
|
|
| 1653 |
result = objects.QueryResponse.FromDict(self.lm.QueryLocks(["name"])) |
|
| 1654 |
self.assertEqual(len(result.fields), 1)
|
|
| 1655 |
self.assertEqual(len(result.data), 100)
|
|
| 1644 | 1656 |
|
| 1645 | 1657 |
# Delete all locks |
| 1646 | 1658 |
del locks[:] |
| ... | ... | |
| 1684 | 1696 |
# Check order in which locks were added |
| 1685 | 1697 |
self.assertEqual([i.name for i in locks], expnames) |
| 1686 | 1698 |
|
| 1687 |
# Sync queries are not supported |
|
| 1688 |
self.assertRaises(NotImplementedError, self.lm.QueryLocks, ["name"], True) |
|
| 1689 |
|
|
| 1690 | 1699 |
# Check query result |
| 1691 |
self.assertEqual(self.lm.QueryLocks(["name", "mode", "owner", "pending"], |
|
| 1692 |
False), |
|
| 1693 |
[[name, None, None, []] |
|
| 1700 |
result = self.lm.QueryLocks(["name", "mode", "owner", "pending"]) |
|
| 1701 |
self.assert_(isinstance(result, dict)) |
|
| 1702 |
response = objects.QueryResponse.FromDict(result) |
|
| 1703 |
self.assertEqual(response.data, |
|
| 1704 |
[[(constants.QRFS_NORMAL, name), |
|
| 1705 |
(constants.QRFS_NORMAL, None), |
|
| 1706 |
(constants.QRFS_NORMAL, None), |
|
| 1707 |
(constants.QRFS_NORMAL, [])] |
|
| 1694 | 1708 |
for name in utils.NiceSort(expnames)]) |
| 1709 |
self.assertEqual(len(response.fields), 4) |
|
| 1710 |
self.assertEqual(["name", "mode", "owner", "pending"], |
|
| 1711 |
[fdef.name for fdef in response.fields]) |
|
| 1695 | 1712 |
|
| 1696 | 1713 |
# Test exclusive acquire |
| 1697 | 1714 |
for tlock in locks[::4]: |
| ... | ... | |
| 1699 | 1716 |
try: |
| 1700 | 1717 |
def _GetExpResult(name): |
| 1701 | 1718 |
if tlock.name == name: |
| 1702 |
return [name, "exclusive", [threading.currentThread().getName()], |
|
| 1703 |
[]] |
|
| 1704 |
return [name, None, None, []] |
|
| 1705 |
|
|
| 1706 |
self.assertEqual(self.lm.QueryLocks(["name", "mode", "owner", |
|
| 1707 |
"pending"], False), |
|
| 1719 |
return [(constants.QRFS_NORMAL, name), |
|
| 1720 |
(constants.QRFS_NORMAL, "exclusive"), |
|
| 1721 |
(constants.QRFS_NORMAL, |
|
| 1722 |
[threading.currentThread().getName()]), |
|
| 1723 |
(constants.QRFS_NORMAL, [])] |
|
| 1724 |
return [(constants.QRFS_NORMAL, name), |
|
| 1725 |
(constants.QRFS_NORMAL, None), |
|
| 1726 |
(constants.QRFS_NORMAL, None), |
|
| 1727 |
(constants.QRFS_NORMAL, [])] |
|
| 1728 |
|
|
| 1729 |
result = self.lm.QueryLocks(["name", "mode", "owner", "pending"]) |
|
| 1730 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, |
|
| 1708 | 1731 |
[_GetExpResult(name) |
| 1709 | 1732 |
for name in utils.NiceSort(expnames)]) |
| 1710 | 1733 |
finally: |
| ... | ... | |
| 1756 | 1779 |
i.wait() |
| 1757 | 1780 |
|
| 1758 | 1781 |
# Check query result |
| 1759 |
for (name, mode, owner) in self.lm.QueryLocks(["name", "mode", |
|
| 1760 |
"owner"], False): |
|
| 1761 |
if name == tlock1.name: |
|
| 1762 |
self.assertEqual(mode, "shared") |
|
| 1763 |
self.assertEqual(set(owner), set(i.getName() for i in tthreads1)) |
|
| 1782 |
result = self.lm.QueryLocks(["name", "mode", "owner"]) |
|
| 1783 |
response = objects.QueryResponse.FromDict(result) |
|
| 1784 |
for (name, mode, owner) in response.data: |
|
| 1785 |
(name_status, name_value) = name |
|
| 1786 |
(owner_status, owner_value) = owner |
|
| 1787 |
|
|
| 1788 |
self.assertEqual(name_status, constants.QRFS_NORMAL) |
|
| 1789 |
self.assertEqual(owner_status, constants.QRFS_NORMAL) |
|
| 1790 |
|
|
| 1791 |
if name_value == tlock1.name: |
|
| 1792 |
self.assertEqual(mode, (constants.QRFS_NORMAL, "shared")) |
|
| 1793 |
self.assertEqual(set(owner_value), |
|
| 1794 |
set(i.getName() for i in tthreads1)) |
|
| 1764 | 1795 |
continue |
| 1765 | 1796 |
|
| 1766 |
if name == tlock2.name: |
|
| 1767 |
self.assertEqual(mode, "shared")
|
|
| 1768 |
self.assertEqual(owner, [tthread2.getName()]) |
|
| 1797 |
if name_value == tlock2.name:
|
|
| 1798 |
self.assertEqual(mode, (constants.QRFS_NORMAL, "shared"))
|
|
| 1799 |
self.assertEqual(owner_value, [tthread2.getName()])
|
|
| 1769 | 1800 |
continue |
| 1770 | 1801 |
|
| 1771 |
if name == tlock3.name: |
|
| 1772 |
self.assertEqual(mode, "exclusive")
|
|
| 1773 |
self.assertEqual(owner, [tthread3.getName()]) |
|
| 1802 |
if name_value == tlock3.name:
|
|
| 1803 |
self.assertEqual(mode, (constants.QRFS_NORMAL, "exclusive"))
|
|
| 1804 |
self.assertEqual(owner_value, [tthread3.getName()])
|
|
| 1774 | 1805 |
continue |
| 1775 | 1806 |
|
| 1776 |
self.assert_(name in expnames) |
|
| 1777 |
self.assert_(mode is None)
|
|
| 1778 |
self.assert_(owner is None) |
|
| 1807 |
self.assert_(name_value in expnames)
|
|
| 1808 |
self.assertEqual(mode, (constants.QRFS_NORMAL, None))
|
|
| 1809 |
self.assert_(owner_value is None)
|
|
| 1779 | 1810 |
|
| 1780 | 1811 |
# Release locks again |
| 1781 | 1812 |
releaseev.set() |
| 1782 | 1813 |
|
| 1783 | 1814 |
self._waitThreads() |
| 1784 | 1815 |
|
| 1785 |
self.assertEqual(self.lm.QueryLocks(["name", "mode", "owner"], False), |
|
| 1786 |
[[name, None, None] |
|
| 1816 |
result = self.lm.QueryLocks(["name", "mode", "owner"]) |
|
| 1817 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, |
|
| 1818 |
[[(constants.QRFS_NORMAL, name), |
|
| 1819 |
(constants.QRFS_NORMAL, None), |
|
| 1820 |
(constants.QRFS_NORMAL, None)] |
|
| 1787 | 1821 |
for name in utils.NiceSort(expnames)]) |
| 1788 | 1822 |
|
| 1789 | 1823 |
def testDelete(self): |
| 1790 | 1824 |
lock = locking.SharedLock("TestLock", monitor=self.lm)
|
| 1791 | 1825 |
|
| 1792 | 1826 |
self.assertEqual(len(self.lm._locks), 1) |
| 1793 |
self.assertEqual(self.lm.QueryLocks(["name", "mode", "owner"], False), |
|
| 1794 |
[[lock.name, None, None]]) |
|
| 1827 |
result = self.lm.QueryLocks(["name", "mode", "owner"]) |
|
| 1828 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, |
|
| 1829 |
[[(constants.QRFS_NORMAL, lock.name), |
|
| 1830 |
(constants.QRFS_NORMAL, None), |
|
| 1831 |
(constants.QRFS_NORMAL, None)]]) |
|
| 1795 | 1832 |
|
| 1796 | 1833 |
lock.delete() |
| 1797 | 1834 |
|
| 1798 |
self.assertEqual(self.lm.QueryLocks(["name", "mode", "owner"], False), |
|
| 1799 |
[[lock.name, "deleted", None]]) |
|
| 1835 |
result = self.lm.QueryLocks(["name", "mode", "owner"]) |
|
| 1836 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, |
|
| 1837 |
[[(constants.QRFS_NORMAL, lock.name), |
|
| 1838 |
(constants.QRFS_NORMAL, "deleted"), |
|
| 1839 |
(constants.QRFS_NORMAL, None)]]) |
|
| 1800 | 1840 |
self.assertEqual(len(self.lm._locks), 1) |
| 1801 | 1841 |
|
| 1802 | 1842 |
def testPending(self): |
| ... | ... | |
| 1815 | 1855 |
lock.acquire() |
| 1816 | 1856 |
try: |
| 1817 | 1857 |
self.assertEqual(len(self.lm._locks), 1) |
| 1818 |
self.assertEqual(self.lm.QueryLocks(["name", "mode", "owner"], False), |
|
| 1819 |
[[lock.name, "exclusive", |
|
| 1820 |
[threading.currentThread().getName()]]]) |
|
| 1858 |
result = self.lm.QueryLocks(["name", "mode", "owner"]) |
|
| 1859 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, |
|
| 1860 |
[[(constants.QRFS_NORMAL, lock.name), |
|
| 1861 |
(constants.QRFS_NORMAL, "exclusive"), |
|
| 1862 |
(constants.QRFS_NORMAL, |
|
| 1863 |
[threading.currentThread().getName()])]]) |
|
| 1821 | 1864 |
|
| 1822 | 1865 |
threads = [] |
| 1823 | 1866 |
|
| ... | ... | |
| 1843 | 1886 |
|
| 1844 | 1887 |
# All acquires are waiting now |
| 1845 | 1888 |
if shared: |
| 1846 |
pending = [("shared", sorted([t.getName() for t in threads]))]
|
|
| 1889 |
pending = [("shared", utils.NiceSort(t.getName() for t in threads))]
|
|
| 1847 | 1890 |
else: |
| 1848 | 1891 |
pending = [("exclusive", [t.getName()]) for t in threads]
|
| 1849 | 1892 |
|
| 1850 |
self.assertEqual(self.lm.QueryLocks(["name", "mode", "owner", |
|
| 1851 |
"pending"], False), |
|
| 1852 |
[[lock.name, "exclusive", |
|
| 1853 |
[threading.currentThread().getName()], |
|
| 1854 |
pending]]) |
|
| 1893 |
result = self.lm.QueryLocks(["name", "mode", "owner", "pending"]) |
|
| 1894 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, |
|
| 1895 |
[[(constants.QRFS_NORMAL, lock.name), |
|
| 1896 |
(constants.QRFS_NORMAL, "exclusive"), |
|
| 1897 |
(constants.QRFS_NORMAL, |
|
| 1898 |
[threading.currentThread().getName()]), |
|
| 1899 |
(constants.QRFS_NORMAL, pending)]]) |
|
| 1855 | 1900 |
|
| 1856 | 1901 |
self.assertEqual(len(self.lm._locks), 1) |
| 1857 | 1902 |
finally: |
| ... | ... | |
| 1860 | 1905 |
self._waitThreads() |
| 1861 | 1906 |
|
| 1862 | 1907 |
# No pending acquires |
| 1863 |
self.assertEqual(self.lm.QueryLocks(["name", "mode", "owner", "pending"], |
|
| 1864 |
False), |
|
| 1865 |
[[lock.name, None, None, []]]) |
|
| 1908 |
result = self.lm.QueryLocks(["name", "mode", "owner", "pending"]) |
|
| 1909 |
self.assertEqual(objects.QueryResponse.FromDict(result).data, |
|
| 1910 |
[[(constants.QRFS_NORMAL, lock.name), |
|
| 1911 |
(constants.QRFS_NORMAL, None), |
|
| 1912 |
(constants.QRFS_NORMAL, None), |
|
| 1913 |
(constants.QRFS_NORMAL, [])]]) |
|
| 1866 | 1914 |
|
| 1867 | 1915 |
self.assertEqual(len(self.lm._locks), 1) |
| 1868 | 1916 |
|
Also available in: Unified diff