Synnefo » snf-ganeti » ganeti-local

    self.owned_locks = context.glm.list_owned

    self.context = context

    self.rpc = rpc_runner

    self.needed_locks = None

    self.share_locks = dict.fromkeys(locking.LEVELS, 0)

    self.add_locks = {}

    self.remove_locks = {}

    # Used to force good behavior when calling helper functions

    self.recalculate_locks = {}

    # logging

    self.Log = processor.Log # pylint: disable=C0103

    self.LogWarning = processor.LogWarning # pylint: disable=C0103

    if not self._enable_locks:

      raise errors.ProgrammerError("Attempted to use disabled locks")

    """Acquires locks via the Ganeti lock manager.

    @type level: int

    @param names: Lock names

    @type shared: bool

    @param shared: Whether the locks should be acquired in shared mode

    @type timeout: None or float

    @param timeout: Timeout for acquiring the locks

    @raise LockAcquireTimeout: In case locks couldn't be acquired in specified

      priority = None

    acquired = self.context.glm.acquire(level, names, shared=shared,

    if acquired is None:

      raise LockAcquireTimeout()

      lu.DeclareLocks(level)

      share = lu.share_locks[level]

      try:

        assert adding_locks ^ acquiring_locks, \

          # Acquiring locks

          needed_locks = lu.needed_locks[level]

                             calc_timeout())

        else:

          # Adding locks

        # and in a shared fashion otherwise (to prevent concurrent run with

        # an exclusive LU.

        self._AcquireLocks(locking.LEVEL_CLUSTER, locking.BGL,

      elif lu_class.REQ_BGL:

        raise errors.ProgrammerError("Opcode '%s' requires BGL, but locks are"

                                     " disabled" % op.OP_ID)