Synnefo » snf-ganeti

#

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

from ganeti import netutils

# job id used for resource management at config upgrade time

_UPGRADE_CONFIG_JID = "jid-cfg-upgrade"

#

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

    # shared mode, including itself. In order not to acquire it at all

    # concurrency must be guaranteed with all code acquiring it in shared mode

    # and all code acquiring it exclusively.

    self.acquire = self._lock.acquire

    self.release = self._lock.release

#

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

  the shared lock in the order they queued for it, just that they will

  eventually do so.

  """

  __slots__ = [

    "__active_shr_c",

    "__lock",

    "__pending",

    "__shr",

    ]

  __condition_class = PipeCondition

    """Construct a new SharedLock.

    """

    object.__init__(self)

    # Internal lock

    self.__lock = threading.Lock()

    """

    if self.__deleted:

  def __is_sharer(self):

    """Is the current thread sharing the lock at this time?

    self.__check_deleted()

    # We cannot acquire the lock if we already have it

    # Check whether someone else holds the lock or there are pending acquires.

    if not self.__pending and self.__can_acquire(shared):

  All the locks needed in the same set must be acquired together, though.

  """

    """Constructs a new LockSet.

    @type members: list of strings

    @param members: initial members of the set

    """

    # Used internally to guarantee coherency.

    # The lockdict indexes the relationship name -> lock

    # The order-of-locking is implied by the alphabetical order of names

    self.__lockdict = {}

    # The owner dict contains the set of locks each thread owns. For

    # performance each thread can access its own key without a global lock on

    assert timeout is None or timeout >= 0.0

    # Check we don't already own locks at this level

    # We need to keep track of how long we spent waiting for a lock. The

    # timeout passed to this function is over all lock acquires.

          # element is not there anymore.

          continue

      acquire_list.append((lname, lock))

            # particular element is not there anymore.

            continue

        if not acq_success:

          # Couldn't get lock or timeout occurred

          if timeout is None:

            # This shouldn't happen as SharedLock.acquire(timeout=None) is

            # blocking.

          raise _AcquireTimeout()

        (defaults to all the locks acquired at that level).

    """

    # Support passing in a single resource to release rather than many

    if isinstance(names, basestring):

    else:

      names = set(names)

      assert self._list_owned().issuperset(names), (

    # First of all let's release the "all elements" lock, if set.

    # After this 'add' can work again

    """

    # Check we don't already own locks at this level

    assert not self._is_owned() or self.__lock._is_owned(shared=0), \

    # Support passing in a single resource to add rather than many

    if isinstance(names, basestring):

        # This must be an explicit raise, not an assert, because assert is

        # turned off when using optimization, and this can happen because of

        # concurrency even if the user doesn't want it.

      for lockname in names:

        if acquired:

          lock.acquire(shared=shared)

    # to delete. The ownership must also be exclusive, but that will be checked

    # by the lock itself.

    assert not self._is_owned() or self._list_owned().issuperset(names), (

    removed = []

        removed.append(lname)

      except (KeyError, errors.LockError):

        # This cannot happen if we were already holding it, verify:

      else:

        # If no LockError was raised we are the ones who deleted the lock.

        # This means we can safely remove it from lockdict, as any further or

    # The keyring contains all the locks, at their level and in the correct

    # locking order.

    self.__keyring = {

    }

  def _names(self, level):

#!/usr/bin/python

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# This is used to test the ssynchronize decorator.

# Since it's passed as input to a decorator it must be declared as a global.

#: List for looping tests

ITERATIONS = range(8)

  def setUp(self):

    _ThreadedTestCase.setUp(self)

  def testSequenceAndOwnership(self):

    self.assertFalse(self.sl._is_owned())

    self.sl.release()

    self._waitThreads()

    self.failUnlessEqual(self.done.get_nowait(), 'DEL')

  @_Repeat

  def testExclusiveBlocksSharer(self):

    self.sl.release()

    self._waitThreads()

    self.failUnlessEqual(self.done.get_nowait(), 'DEL')

  @_Repeat

  def testWaitingExclusiveBlocksSharer(self):

    # The threads who were pending return ERR

    for _ in range(4):

      self.assertEqual(self.done.get_nowait(), 'ERR')

  @_Repeat

  def testDeletePendingDeleteExclusiveSharers(self):

    self.assertEqual(self.done.get_nowait(), 'ERR')

    self.assertEqual(self.done.get_nowait(), 'ERR')

    self.assertEqual(self.done.get_nowait(), 'ERR')

  @_Repeat

  def testExclusiveAcquireTimeout(self):

  def setUp(self):

    _ThreadedTestCase.setUp(self)

    self.setCondition()

  def setCondition(self):

  def _setUpLS(self):

    """Helper to (re)initialize the lock set"""

    self.resources = ['one', 'two', 'three']

  def testResources(self):

    self.assertEquals(self.ls._names(), set(self.resources))

    self.assertEquals(newls._names(), set())

  def testAcquireRelease(self):

  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.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.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),