Synnefo » snf-ganeti » ganeti-local

import errno

import weakref

import logging

from ganeti import errors

from ganeti import utils

_EXCLUSIVE_TEXT = "exclusive"

_SHARED_TEXT = "shared"

def ssynchronized(mylock, shared=0):

  """Shared Synchronization decorator.

    return bool(self._waiters)

class SharedLock(object):

  """Implements a shared lock.

  acquire_shared().  In order to acquire the lock in an exclusive way threads

  can call acquire_exclusive().

  @type name: string

  @ivar name: the name of the lock

  """

  __slots__ = [

    "__weakref__",

    "__deleted",

    "__exc",

    "__lock",

    "__pending",

    "__shr",

    "name",

    ]

  def __init__(self, name, monitor=None):

    """Construct a new SharedLock.

    # Queue containing waiting acquires

    self.__pending = []

    # Current lock holders

    self.__shr = set()

        elif fname == "pending":

          data = []

          info.append(data)

        else:

    """

    self.__lock.acquire()

    try:

    finally:

      self.__lock.release()

    else:

      return len(self.__shr) == 0 and self.__exc is None

  def __is_on_top(self, cond):

    """Checks whether the passed condition is on top of the queue.

    The caller must make sure the queue isn't empty.

    """

    """Acquire a shared lock.

    @param shared: whether to acquire in shared mode; by default an

        exclusive lock will be acquired

    @param timeout: maximum waiting time before giving up

    """

    self.__check_deleted()

    assert not self.__is_owned(), ("double acquire() on a non-recursive lock"

                                   " %s" % self.name)

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

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

      # Apparently not, can acquire lock directly.

      self.__do_acquire(shared)

      return True

    else:

    try:

      # Wait until we become the topmost acquire in the queue or the timeout

      # expires.

      while not (self.__is_on_top(wait_condition) and

                 self.__can_acquire(shared)):

        # Wait for notification

        return True

    finally:

      # Remove condition from queue if there are no more waiters

    return False

    """Acquire a shared lock.

    @type shared: integer (0/1) used as a boolean

        exclusive lock will be acquired

    @type timeout: float

    @param timeout: maximum waiting time before giving up

    @type test_notify: callable or None

    @param test_notify: Special callback function for unittesting

      if __debug__ and callable(test_notify):

        test_notify()

    finally:

      self.__lock.release()

        self.__shr.remove(threading.currentThread())

      # Notify topmost condition in queue

    finally:

      self.__lock.release()

    """Delete a Shared Lock.

    This operation will declare the lock for removal. First the lock will be

    @type timeout: float

    @param timeout: maximum waiting time before giving up

    """

    self.__lock.acquire()

      acquired = self.__is_exclusive()

      if not acquired:

        assert self.__is_exclusive() and not self.__is_sharer(), \

          "Lock wasn't acquired in exclusive mode"

        assert not (self.__exc or self.__shr), "Found owner during deletion"

        # Notify all acquires. They'll throw an error.

      return acquired

    finally:

        self.__lock.release()

    return set(result)

    """Acquire a set of resource locks.

    @type names: list of strings (or string)

        exclusive lock will be acquired

    @type timeout: float or None

    @param timeout: Maximum time to acquire all locks

    @type test_notify: callable or None

    @param test_notify: Special callback function for unittesting

        if isinstance(names, basestring):

          names = [names]

                                    running_timeout.Remaining, test_notify)

      else:

        # Some of them may then be deleted later, but we'll cope with this.

        #

        # We'd like to acquire this lock in a shared way, as it's nice if

        # acquiring them exclusively though they won't be able to do this

        # anyway, though, so we'll get the list lock exclusively as well in

        # order to be able to do add() on the set while owning it.

                                   timeout=running_timeout.Remaining()):

          raise _AcquireTimeout()

        try:

          # note we own the set-lock

          self._add_owned()

                                      running_timeout.Remaining, test_notify)

        except:

          # We shouldn't have problems adding the lock to the owners list, but

    except _AcquireTimeout:

      return None

    """Inner logic for acquiring a number of locks.

    @param names: Names of the locks to be acquired

    @param want_all: Whether all locks in the set should be acquired

    @param shared: Whether to acquire in shared mode

    @param timeout_fn: Function returning remaining timeout

    @param test_notify: Special callback function for unittesting

    """

        try:

          # raises LockError if the lock was deleted

          acq_success = lock.acquire(shared=shared, timeout=timeout,

                                     test_notify=test_notify_fn)

        except errors.LockError:

          if want_all:

        lock = SharedLock(self._GetLockName(lockname), monitor=self.__monitor)

        if acquired:

          lock.acquire(shared=shared)

          # now the lock cannot be deleted, we have it!

          try: