Synnefo » snf-ganeti » ganeti-local

  def downgrade(self):

    """Changes the lock mode from exclusive to shared.

    Pending acquires in shared mode on the same priority will go ahead.

    """

    self.__lock.acquire()

    try:

      assert self.__is_owned(), "Lock must be owned"

      if self.__is_exclusive():

        # Do nothing if the lock is already acquired in shared mode

        self.__exc = None

        self.__do_acquire(1)

        # Important: pending shared acquires should only jump ahead if there

        # was a transition from exclusive to shared, otherwise an owner of a

        # shared lock can keep calling this function to push incoming shared

        # acquires

        (priority, prioqueue) = self.__find_first_pending_queue()

        if prioqueue:

          # Is there a pending shared acquire on this priority?

          cond = self.__pending_shared.pop(priority, None)

          if cond:

            assert cond.shared

            assert cond in prioqueue

            # Ensure shared acquire is on top of queue

            if len(prioqueue) > 1:

              prioqueue.remove(cond)

              prioqueue.insert(0, cond)

            # Notify

            cond.notifyAll()

      assert not self.__is_exclusive()

      assert self.__is_sharer()

      return True

    finally:

      self.__lock.release()

  def _get_lock(self):

    """Returns the lockset-internal lock.

    """

    return self.__lock

  def _get_lockdict(self):

    """Returns the lockset-internal lock dictionary.

    Accessing this structure is only safe in single-thread usage or when the

    lockset-internal lock is held.

    """

    return self.__lockdict

  def downgrade(self, names=None):

    """Downgrade a set of resource locks from exclusive to shared mode.

    The locks must have been acquired in exclusive mode.

    """

    assert self._is_owned(), ("downgrade on lockset %s while not owning any"

                              " lock" % self.name)

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

    if isinstance(names, basestring):

      names = [names]

    owned = self._list_owned()

    if names is None:

      names = owned

    else:

      names = set(names)

      assert owned.issuperset(names), \

        ("downgrade() on unheld resources %s (set %s)" %

         (names.difference(owned), self.name))

    for lockname in names:

      self.__lockdict[lockname].downgrade()

    # Do we own the lockset in exclusive mode?

    if self.__lock._is_owned(shared=0):

      # Have all locks been downgraded?

      if not compat.any(lock._is_owned(shared=0)

                        for lock in self.__lockdict.values()):

        self.__lock.downgrade()

        assert self.__lock._is_owned(shared=1)

    return True

  def downgrade(self, level, names=None):

    """Downgrade a set of resource locks from exclusive to shared mode.

    You must have acquired the locks in exclusive mode.

    @type level: member of locking.LEVELS

    @param level: the level at which the locks shall be downgraded

    @type names: list of strings, or None

    @param names: the names of the locks which shall be downgraded

        (defaults to all the locks acquired at the level)

    """

    assert level in LEVELS, "Invalid locking level %s" % level

    return self.__keyring[level].downgrade(names=names)