Synnefo » snf-ganeti

#   - at levels LEVEL_NODE and LEVEL_INSTANCE reside node and instance locks.

#   If you need more than one node, or more than one instance, acquire them at

#   the same time.

LEVEL_CLUSTER = 0

LEVEL_NODE = 1

LEVEL_INSTANCE = 2

LEVELS = [LEVEL_CLUSTER,

          LEVEL_NODE,

# Lock levels which are modifiable

LEVELS_MOD = [LEVEL_NODE, LEVEL_INSTANCE]

BGL = 'BGL'

class GanetiLockManager:

      LEVEL_CLUSTER: LockSet([BGL]),

      LEVEL_NODE: LockSet(nodes),

      LEVEL_INSTANCE: LockSet(instances),

    }

  def _names(self, level):

    self.assertEqual(self.GL._names(locking.LEVEL_NODE), set(self.nodes))

    self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE),

                     set(self.instances))

  def testInitAndResources(self):

    locking.GanetiLockManager._instance = None

    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_INSTANCE), set())

    locking.GanetiLockManager._instance = None

    self.GL = locking.GanetiLockManager(nodes=self.nodes)

    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_INSTANCE), set())

    locking.GanetiLockManager._instance = None

    self.GL = locking.GanetiLockManager(instances=self.instances)

    self.assertEqual(self.GL._names(locking.LEVEL_NODE), set())

    self.assertEqual(self.GL._names(locking.LEVEL_INSTANCE),

                     set(self.instances))

  def testAcquireRelease(self):

    self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)

    self.GL.acquire(locking.LEVEL_NODE, ['n1'])

    self.assertEquals(self.GL._list_owned(locking.LEVEL_NODE), set(['n1']))

    self.GL.acquire(locking.LEVEL_INSTANCE, ['i1', 'i2'])

    self.GL.release(locking.LEVEL_INSTANCE, ['i2'])

    self.assertEquals(self.GL._list_owned(locking.LEVEL_INSTANCE), set(['i1']))

    self.GL.release(locking.LEVEL_NODE)

    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.assertRaises(AssertionError, self.GL.release,

                      locking.LEVEL_CLUSTER)

    self.GL.release(locking.LEVEL_INSTANCE)

  def testWrongOrder(self):

    self.GL.acquire(locking.LEVEL_CLUSTER, ['BGL'], shared=1)

                      locking.LEVEL_NODE, ['n1'])

    self.assertRaises(AssertionError, self.GL.acquire,

                      locking.LEVEL_INSTANCE, ['i2'])

  # Helper function to run as a thread that shared the BGL and then acquires

  # some locks at another level.

    self.assertEqual(self.done.get(True, 1), 'DONE')

    self.GL.acquire(locking.LEVEL_NODE, ['n1'])

    self.GL.acquire(locking.LEVEL_INSTANCE, ['i3'])

    Thread(target=self._doLock, args=(locking.LEVEL_INSTANCE, 'i1', 1)).start()

    self.assertEqual(self.done.get(True, 1), 'DONE')

    Thread(target=self._doLock, args=(locking.LEVEL_INSTANCE, 'i3', 1)).start()

    self.assertRaises(Queue.Empty, self.done.get, True, 0.2)

    self.GL.release(locking.LEVEL_INSTANCE)

    self.assertEqual(self.done.get(True, 1), 'DONE')

    self.GL.acquire(locking.LEVEL_INSTANCE, ['i2'], shared=1)