Synnefo » snf-ganeti » ganeti-local

#

#

# Copyright (C) 2006, 2007 Google Inc.

#

# 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 Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""Module implementing the Ganeti locking code."""

# pylint: disable-msg=W0212

# W0212 since e.g. LockSet methods use (a lot) the internals of

# SharedLock

import os

import select

import threading

import time

import errno

from ganeti import errors

from ganeti import utils

from ganeti import compat

def ssynchronized(mylock, shared=0):

  """Shared Synchronization decorator.

  Calls the function holding the given lock, either in exclusive or shared

  mode. It requires the passed lock to be a SharedLock (or support its

  semantics).

  @type mylock: lockable object or string

  @param mylock: lock to acquire or class member name of the lock to acquire

  """

  def wrap(fn):

    def sync_function(*args, **kwargs):

      if isinstance(mylock, basestring):

        assert args, "cannot ssynchronize on non-class method: self not found"

        # args[0] is "self"

        lock = getattr(args[0], mylock)

      else:

        lock = mylock

      lock.acquire(shared=shared)

      try:

        return fn(*args, **kwargs)

      finally:

        lock.release()

    return sync_function

  return wrap

class RunningTimeout(object):

  """Class to calculate remaining timeout when doing several operations.

  """

  __slots__ = [

    "_allow_negative",

    "_start_time",

    "_time_fn",

    "_timeout",

    ]

  def __init__(self, timeout, allow_negative, _time_fn=time.time):

    """Initializes this class.

    @type timeout: float

    @param timeout: Timeout duration

    @type allow_negative: bool

    @param allow_negative: Whether to return values below zero

    @param _time_fn: Time function for unittests

    """

    object.__init__(self)

    if timeout is not None and timeout < 0.0:

      raise ValueError("Timeout must not be negative")

    self._timeout = timeout

    self._allow_negative = allow_negative

    self._time_fn = _time_fn

    self._start_time = None

  def Remaining(self):

    """Returns the remaining timeout.

    """

    if self._timeout is None:

      return None

    # Get start time on first calculation

    if self._start_time is None:

      self._start_time = self._time_fn()

    # Calculate remaining time

    remaining_timeout = self._start_time + self._timeout - self._time_fn()

    if not self._allow_negative:

      # Ensure timeout is always >= 0

      return max(0.0, remaining_timeout)

    return remaining_timeout

class _SingleNotifyPipeConditionWaiter(object):

  """Helper class for SingleNotifyPipeCondition

  """

  __slots__ = [

    "_fd",

    "_poller",

    ]

  def __init__(self, poller, fd):

    """Constructor for _SingleNotifyPipeConditionWaiter

    @type poller: select.poll

    @param poller: Poller object

    @type fd: int

    @param fd: File descriptor to wait for

    """

    object.__init__(self)

    self._poller = poller

    self._fd = fd

  def __call__(self, timeout):

    """Wait for something to happen on the pipe.

    @type timeout: float or None

    @param timeout: Timeout for waiting (can be None)

    """

    running_timeout = RunningTimeout(timeout, True)

    while True:

      remaining_time = running_timeout.Remaining()

      if remaining_time is not None:

        if remaining_time < 0.0:

          break

        # Our calculation uses seconds, poll() wants milliseconds

        remaining_time *= 1000

      try:

        result = self._poller.poll(remaining_time)

      except EnvironmentError, err:

        if err.errno != errno.EINTR:

          raise

        result = None

      # Check whether we were notified

      if result and result[0][0] == self._fd:

        break

class _BaseCondition(object):

  """Base class containing common code for conditions.

  Some of this code is taken from python's threading module.

  """

  __slots__ = [

    "_lock",

    "acquire",

    "release",

    "_is_owned",

    "_acquire_restore",

    "_release_save",

    ]

  def __init__(self, lock):

    """Constructor for _BaseCondition.

    @type lock: threading.Lock

    @param lock: condition base lock

    """

    object.__init__(self)

    try:

      self._release_save = lock._release_save

    except AttributeError:

      self._release_save = self._base_release_save

    try:

      self._acquire_restore = lock._acquire_restore

    except AttributeError:

      self._acquire_restore = self._base_acquire_restore

    try:

      self._is_owned = lock._is_owned

    except AttributeError:

      self._is_owned = self._base_is_owned

    self._lock = lock

    # Export the lock's acquire() and release() methods

    self.acquire = lock.acquire

    self.release = lock.release

  def _base_is_owned(self):

    """Check whether lock is owned by current thread.

    """

    if self._lock.acquire(0):

      self._lock.release()

      return False

    return True

  def _base_release_save(self):

    self._lock.release()

  def _base_acquire_restore(self, _):

    self._lock.acquire()

  def _check_owned(self):

    """Raise an exception if the current thread doesn't own the lock.

    """

    if not self._is_owned():

      raise RuntimeError("cannot work with un-aquired lock")

class SingleNotifyPipeCondition(_BaseCondition):

  """Condition which can only be notified once.

  This condition class uses pipes and poll, internally, to be able to wait for

  notification with a timeout, without resorting to polling. It is almost

  compatible with Python's threading.Condition, with the following differences:

    - notifyAll can only be called once, and no wait can happen after that

    - notify is not supported, only notifyAll

  """

  __slots__ = [

    "_poller",

    "_read_fd",

    "_write_fd",

    "_nwaiters",

    "_notified",

    ]

  _waiter_class = _SingleNotifyPipeConditionWaiter

  def __init__(self, lock):

    """Constructor for SingleNotifyPipeCondition

    """

    _BaseCondition.__init__(self, lock)

    self._nwaiters = 0

    self._notified = False

    self._read_fd = None

    self._write_fd = None

    self._poller = None

  def _check_unnotified(self):

    """Throws an exception if already notified.

    """

    if self._notified:

      raise RuntimeError("cannot use already notified condition")

  def _Cleanup(self):

    """Cleanup open file descriptors, if any.

    """

    if self._read_fd is not None:

      os.close(self._read_fd)

      self._read_fd = None

    if self._write_fd is not None:

      os.close(self._write_fd)

      self._write_fd = None

    self._poller = None

  def wait(self, timeout=None):

    """Wait for a notification.

    @type timeout: float or None

    @param timeout: Waiting timeout (can be None)

    """

    self._check_owned()

    self._check_unnotified()

    self._nwaiters += 1

    try:

      if self._poller is None:

        (self._read_fd, self._write_fd) = os.pipe()

        self._poller = select.poll()

        self._poller.register(self._read_fd, select.POLLHUP)

      wait_fn = self._waiter_class(self._poller, self._read_fd)

      state = self._release_save()

      try:

        # Wait for notification

        wait_fn(timeout)

      finally:

        # Re-acquire lock

        self._acquire_restore(state)

    finally:

      self._nwaiters -= 1

      if self._nwaiters == 0:

        self._Cleanup()

  def notifyAll(self): # pylint: disable-msg=C0103

    """Close the writing side of the pipe to notify all waiters.

    """

    self._check_owned()

    self._check_unnotified()

    self._notified = True

    if self._write_fd is not None:

      os.close(self._write_fd)

      self._write_fd = None

class PipeCondition(_BaseCondition):

  """Group-only non-polling condition with counters.

  This condition class uses pipes and poll, internally, to be able to wait for

  notification with a timeout, without resorting to polling. It is almost

  compatible with Python's threading.Condition, but only supports notifyAll and

  non-recursive locks. As an additional features it's able to report whether

  there are any waiting threads.

  """

  __slots__ = [

    "_nwaiters",

    "_single_condition",

    ]

  _single_condition_class = SingleNotifyPipeCondition

  def __init__(self, lock):

    """Initializes this class.

    """

    _BaseCondition.__init__(self, lock)

    self._nwaiters = 0

    self._single_condition = self._single_condition_class(self._lock)

  def wait(self, timeout=None):

    """Wait for a notification.

    @type timeout: float or None

    @param timeout: Waiting timeout (can be None)

    """

    self._check_owned()

    # Keep local reference to the pipe. It could be replaced by another thread

    # notifying while we're waiting.

    my_condition = self._single_condition

    assert self._nwaiters >= 0

    self._nwaiters += 1

    try:

      my_condition.wait(timeout)

    finally:

      assert self._nwaiters > 0

      self._nwaiters -= 1

  def notifyAll(self): # pylint: disable-msg=C0103

    """Notify all currently waiting threads.

    """

    self._check_owned()

    self._single_condition.notifyAll()

    self._single_condition = self._single_condition_class(self._lock)

  def has_waiting(self):

    """Returns whether there are active waiters.

    """

    self._check_owned()

    return bool(self._nwaiters)

class SharedLock(object):

  """Implements a shared lock.

  Multiple threads can acquire the lock in a shared way, calling

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

  can call acquire_exclusive().

  The lock prevents starvation but does not guarantee that threads will acquire

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

  eventually do so.

  """

  __slots__ = [

    "__active_shr_c",

    "__inactive_shr_c",

    "__deleted",

    "__exc",

    "__lock",

    "__pending",

    "__shr",

    ]

  __condition_class = PipeCondition

  def __init__(self):

    """Construct a new SharedLock.

    """

    object.__init__(self)

    # Internal lock

    self.__lock = threading.Lock()

    # Queue containing waiting acquires

    self.__pending = []

    # Active and inactive conditions for shared locks

    self.__active_shr_c = self.__condition_class(self.__lock)

    self.__inactive_shr_c = self.__condition_class(self.__lock)

    # Current lock holders

    self.__shr = set()

    self.__exc = None

    # is this lock in the deleted state?

    self.__deleted = False

  def __check_deleted(self):

    """Raises an exception if the lock has been deleted.

    """

    if self.__deleted:

      raise errors.LockError("Deleted lock")

  def __is_sharer(self):

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

    """

    return threading.currentThread() in self.__shr

  def __is_exclusive(self):

    """Is the current thread holding the lock exclusively at this time?

    """

    return threading.currentThread() == self.__exc

  def __is_owned(self, shared=-1):

    """Is the current thread somehow owning the lock at this time?

    This is a private version of the function, which presumes you're holding

    the internal lock.

    """

    if shared < 0:

      return self.__is_sharer() or self.__is_exclusive()

    elif shared:

      return self.__is_sharer()

    else:

      return self.__is_exclusive()

  def _is_owned(self, shared=-1):

    """Is the current thread somehow owning the lock at this time?

    @param shared:

        - < 0: check for any type of ownership (default)

        - 0: check for exclusive ownership

        - > 0: check for shared ownership

    """

    self.__lock.acquire()

    try:

      return self.__is_owned(shared=shared)

    finally:

      self.__lock.release()

  def _count_pending(self):

    """Returns the number of pending acquires.

    @rtype: int

    """

    self.__lock.acquire()

    try:

      return len(self.__pending)

    finally:

      self.__lock.release()

  def __do_acquire(self, shared):

    """Actually acquire the lock.

    """

    if shared:

      self.__shr.add(threading.currentThread())

    else:

      self.__exc = threading.currentThread()

  def __can_acquire(self, shared):

    """Determine whether lock can be acquired.

    """

    if shared:

      return self.__exc is None

    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.

    """

    return self.__pending[0] == cond

  def __acquire_unlocked(self, shared, timeout):

    """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()

    # We cannot acquire the lock if we already have it

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

    # 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

    if shared:

      wait_condition = self.__active_shr_c

      # Check if we're not yet in the queue

      if wait_condition not in self.__pending:

        self.__pending.append(wait_condition)

    else:

      wait_condition = self.__condition_class(self.__lock)

      # Always add to queue

      self.__pending.append(wait_condition)

    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

        wait_condition.wait(timeout)

        self.__check_deleted()

        # A lot of code assumes blocking acquires always succeed. Loop

        # internally for that case.

        if timeout is not None:

          break

      if self.__is_on_top(wait_condition) and self.__can_acquire(shared):

        self.__do_acquire(shared)

        return True

    finally:

      # Remove condition from queue if there are no more waiters

      if not wait_condition.has_waiting() and not self.__deleted:

        self.__pending.remove(wait_condition)

    return False

  def acquire(self, shared=0, timeout=None, test_notify=None):

    """Acquire a shared lock.

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

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

        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

    """

    self.__lock.acquire()

    try:

      # We already got the lock, notify now

      if __debug__ and callable(test_notify):

        test_notify()

      return self.__acquire_unlocked(shared, timeout)

    finally:

      self.__lock.release()

  def release(self):

    """Release a Shared Lock.

    You must have acquired the lock, either in shared or in exclusive mode,

    before calling this function.

    """

    self.__lock.acquire()

    try:

      assert self.__is_exclusive() or self.__is_sharer(), \

        "Cannot release non-owned lock"

      # Autodetect release type

      if self.__is_exclusive():

        self.__exc = None

      else:

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

      # Notify topmost condition in queue

      if self.__pending:

        first_condition = self.__pending[0]

        first_condition.notifyAll()

        if first_condition == self.__active_shr_c:

          self.__active_shr_c = self.__inactive_shr_c

          self.__inactive_shr_c = first_condition

    finally:

      self.__lock.release()

  def delete(self, timeout=None):

    """Delete a Shared Lock.

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

    acquired in exclusive mode if you don't already own it, then the lock

    will be put in a state where any future and pending acquire() fail.

    @type timeout: float

    @param timeout: maximum waiting time before giving up

    """

    self.__lock.acquire()

    try:

      assert not self.__is_sharer(), "Cannot delete() a lock while sharing it"

      self.__check_deleted()

      # The caller is allowed to hold the lock exclusively already.

      acquired = self.__is_exclusive()

      if not acquired:

        acquired = self.__acquire_unlocked(0, timeout)

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

          "Lock wasn't acquired in exclusive mode"

      if acquired:

        self.__deleted = True

        self.__exc = None

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

        while self.__pending:

          self.__pending.pop().notifyAll()

      return acquired

    finally:

      self.__lock.release()

  def _release_save(self):

    shared = self.__is_sharer()

    self.release()

    return shared

  def _acquire_restore(self, shared):

    self.acquire(shared=shared)

# Whenever we want to acquire a full LockSet we pass None as the value

# to acquire.  Hide this behind this nicely named constant.

ALL_SET = None

class _AcquireTimeout(Exception):

  """Internal exception to abort an acquire on a timeout.

  """

class LockSet:

  """Implements a set of locks.

  This abstraction implements a set of shared locks for the same resource type,

  distinguished by name. The user can lock a subset of the resources and the

  LockSet will take care of acquiring the locks always in the same order, thus

  preventing deadlock.

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

  """

  def __init__(self, members=None):

    """Constructs a new LockSet.

    @type members: list of strings

    @param members: initial members of the set

    """

    # Used internally to guarantee coherency.

    self.__lock = SharedLock()

    # The lockdict indexes the relationship name -> lock

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

    self.__lockdict = {}

    if members is not None:

      for name in members:

        self.__lockdict[name] = SharedLock()

    # 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

    # this structure. It is paramount though that *no* other type of access is

    # done to this structure (eg. no looping over its keys). *_owner helper

    # function are defined to guarantee access is correct, but in general never

    # do anything different than __owners[threading.currentThread()], or there

    # will be trouble.

    self.__owners = {}

  def _is_owned(self):

    """Is the current thread a current level owner?"""

    return threading.currentThread() in self.__owners

  def _add_owned(self, name=None):

    """Note the current thread owns the given lock"""

    if name is None:

      if not self._is_owned():

        self.__owners[threading.currentThread()] = set()

    else:

      if self._is_owned():

        self.__owners[threading.currentThread()].add(name)

      else:

        self.__owners[threading.currentThread()] = set([name])

  def _del_owned(self, name=None):

    """Note the current thread owns the given lock"""

    assert not (name is None and self.__lock._is_owned()), \

           "Cannot hold internal lock when deleting owner status"

    if name is not None:

      self.__owners[threading.currentThread()].remove(name)

    # Only remove the key if we don't hold the set-lock as well

    if (not self.__lock._is_owned() and

        not self.__owners[threading.currentThread()]):

      del self.__owners[threading.currentThread()]

  def _list_owned(self):

    """Get the set of resource names owned by the current thread"""

    if self._is_owned():

      return self.__owners[threading.currentThread()].copy()