Synnefo » snf-ganeti

    self.other = kwargs

class LogicalUnit(object):

  """Logical Unit base class.

  HTYPE = None

  REQ_BGL = True

    """Constructor for LogicalUnit.

    This needs to be overridden in derived classes in order to check op

    validity.

    """

    self.proc = processor

    self.op = op

    self.cfg = context.cfg

    self.context = context

    self.rpc = rpc_runner

    # Dictionaries used to declare locking needs to mcpu

    self.needed_locks = None

    self.CheckArguments()

  def CheckArguments(self):

    """Check syntactic validity for the opcode arguments.

    # caller specified names and we must keep the same order

    assert self.names

    missing = set(self.wanted).difference(names)

    if missing:

    """Computes the list of nodes and their attributes.

    """

    if query.CQ_CONFIG in self.requested_data:

      cluster = lu.cfg.GetClusterInfo()

      nodes = lu.cfg.GetAllNodesInfo()

    """

    if self.wanted_names is None:

    self.wanted_instances = \

        map(compat.snd, self.cfg.GetMultiInstanceInfoByName(self.wanted_names))

        per_node_disks[pnode].append((instance, idx, disk))

    assert not (frozenset(per_node_disks.keys()) -

      "Not owning correct locks"

    assert not self.owned_locks(locking.LEVEL_NODE)

    assert not (self.owned_locks(locking.LEVEL_NODE_RES) -

                self.owned_locks(locking.LEVEL_NODE)), \

      "Node locks differ from node resource locks"

    ht_kind = self.op.hypervisor

    if ht_kind in constants.HTS_REQ_PORT:

    # Otherwise the new lock would have to be added in acquired mode.

    assert self.REQ_BGL

    assert locking.BGL in self.owned_locks(locking.LEVEL_CLUSTER)

    # re-read the instance from the configuration after rename

    renamed_inst = self.cfg.GetInstanceInfo(self.instance.uuid)

        ReleaseLocks(self.lu, locking.LEVEL_NODE_ALLOC)

    else:

      secondary_node_uuids = self.instance.secondary_nodes

      if not secondary_node_uuids:

        raise errors.ConfigurationError("No secondary node but using"

      ReleaseLocks(self, locking.LEVEL_NODE_RES, keep=self.op.node_uuids)

      ReleaseLocks(self, locking.LEVEL_NODE_ALLOC)

    if self.op.node_uuids:

      node_uuids = self.op.node_uuids

    else:

    ReleaseLocks(self, locking.LEVEL_NODE)

    # Downgrade lock while waiting for sync

    assert wipe_disks ^ (old_disk_size is None)

           for group_uuid in self.owned_locks(locking.LEVEL_NODEGROUP)

           for node_uuid in self.cfg.GetNodeGroup(group_uuid).members]

      else:

        self._LockInstancesNodes()

    elif level == locking.LEVEL_NODE_RES:

    """Check prerequisites.

    """

    # Verify if node group locks are still correct

    owned_groups = self.owned_locks(locking.LEVEL_NODEGROUP)

    if owned_groups:

           (owned_nodes, self.node_secondary_ip.keys()))

      assert (self.lu.owned_locks(locking.LEVEL_NODE) ==

              self.lu.owned_locks(locking.LEVEL_NODE_RES))

      owned_instances = self.lu.owned_locks(locking.LEVEL_INSTANCE)

      assert list(owned_instances) == [self.instance_name], \

          "Instance '%s' not locked" % self.instance_name

    if not self.disks:

      feedback_fn("No disks need replacement for instance '%s'" %

                  self.instance.name)

  @param keep: Names of locks to retain

  """

  assert not (keep is not None and names is not None), \

         "Only one of the 'names' and the 'keep' parameters can be given"

  else:

    should_release = None

  owned = lu.owned_locks(level)

  if not owned:

    # Not owning any lock at this level, do nothing

    assert len(lu.owned_locks(level)) == (len(retain) + len(release))

    # Release just some locks

    assert frozenset(lu.owned_locks(level)) == frozenset(retain)

  else:

def _ComputeIPolicyNodeViolation(ipolicy, instance, current_group,

import logging

import time

from ganeti import constants

from ganeti import errors

from ganeti import locking

    """Computes the list of nodes and their attributes.

    """

    valid_nodes = [node.uuid

                   for node in lu.cfg.GetAllNodesInfo().values()

                   if not node.offline and node.vm_capable]

"""Logical units dealing with OS."""

from ganeti import locking

from ganeti import qlang

from ganeti import query

    """Computes the list of nodes and their attributes.

    """

    valid_node_uuids = [node.uuid

                        for node in lu.cfg.GetAllNodesInfo().values()

                        if not node.offline and node.vm_capable]

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

ALL_SET = None

def _TimeoutZero():

  """Returns the number zero.

from ganeti import locking

from ganeti import utils

from ganeti import compat

_OP_PREFIX = "Op"

                               " queries) can not submit jobs")

                 _nal_whitelist=_NODE_ALLOC_WHITELIST):

  """Performs consistency checks on locks acquired by a logical unit.

  @type lu: L{cmdlib.LogicalUnit}

  @param lu: Logical unit instance

  """

  if not __debug__:

    return

  for level in [locking.LEVEL_NODE, locking.LEVEL_NODE_RES]:

    # TODO: Verify using actual lock mode, not using LU variables

      if lu.__class__ in _nal_whitelist:

        assert not have_nal, \

          "LU is whitelisted for not acquiring the node allocation lock"

        assert have_nal, \

          ("Node allocation lock must be used if an LU acquires all nodes"

           " or node resources")

    self.rpc = context.rpc

    self.hmclass = hooksmaster.HooksMaster

    self._enable_locks = enable_locks

  def _CheckLocksEnabled(self):

    """Checks if locking is enabled.

    """

    self._CheckLocksEnabled()

    if self._cbs:

    else:

      priority = None

  def _ExecLU(self, lu):

    """Logical Unit execution sequence.

    given LU and its opcodes.

    """

    adding_locks = level in lu.add_locks

    acquiring_locks = level in lu.needed_locks

    if level not in locking.LEVELS:

      if self._cbs:

        self._cbs.NotifyStart()

          self._AcquireLocks(level, needed_locks, share, opportunistic,

                             calc_timeout())

        else:

          # Adding locks

          add_locks = lu.add_locks[level]

          lu.remove_locks[level] = add_locks

          try:

            logging.exception("Detected lock error in level %s for locks"

                              " %s, shared=%s", level, add_locks, share)

            raise errors.OpPrereqError(

          result = self._LockAndExecLU(lu, level + 1, calc_timeout)

        finally:

          if level in lu.remove_locks:

      finally:

    else:

      result = self._LockAndExecLU(lu, level + 1, calc_timeout)

                                     " disabled" % op.OP_ID)

      try:

        lu.ExpandNames()

        assert lu.needed_locks is not None, "needed_locks not set by LU"

            self.context.cfg.DropECReservations(self._ec_id)

      finally:

        # Release BGL if owned

    finally:

      self._cbs = None

    object.__setattr__(self, name, value)

  def AddNode(self, node, ec_id):

    """

    # Add it to the configuration

    # If preseeding fails it'll not be added

    self.jobqueue.AddNode(node)

  def ReaddNode(self, node):

    """Updates a node that's already in the configuration

    # Notify job queue

    self.jobqueue.RemoveNode(node.name)

def _SetWatcherPause(context, until):

  """Creates or removes the watcher pause file.

from cmdlib.testsupport.config_mock import ConfigMock

from cmdlib.testsupport.iallocator_mock import patchIAllocator

from cmdlib.testsupport.netutils_mock import patchNetutils, \

  SetupDefaultNetutilsMock

from cmdlib.testsupport.processor_mock import ProcessorMock

from cmdlib.testsupport.rpc_runner_mock import CreateRpcRunnerMock, \

  RpcResultsBuilder, patchRpc, SetupDefaultRpcModuleMock

from cmdlib.testsupport.ssh_mock import patchSsh

from ganeti.cmdlib.base import LogicalUnit

from ganeti import errors

from ganeti import objects

from ganeti import opcodes

from ganeti import runtime

  # pylint: disable=W0212

  cfg = property(fget=lambda self: self._test_case.cfg)

  # pylint: disable=W0212

  rpc = property(fget=lambda self: self._test_case.rpc)

  def __init__(self, test_case):

    self._test_case = test_case

  def AddNode(self, node, ec_id):

    self._test_case.cfg.AddNode(node, ec_id)

  def ReaddNode(self, node):

    pass

  def RemoveNode(self, node):

    self._test_case.cfg.RemoveNode(node.uuid)

class MockLU(LogicalUnit):

  The environment can be customized via the following fields:

    * C{cfg}: @see L{ConfigMock}

    * C{rpc}: @see L{CreateRpcRunnerMock}

    * C{iallocator_cls}: @see L{patchIAllocator}

    * C{mcpu}: @see L{ProcessorMock}

    """

    self.cfg = ConfigMock()

    self.rpc = CreateRpcRunnerMock()

    self.ctx = GanetiContextMock(self)

    self.mcpu = ProcessorMock(self.ctx)

    @return: A mock LU

    """

  def RpcResultsBuilder(self, use_node_names=False):

    """Creates a pre-configured L{RpcResultBuilder}

    @return: the result of the LU's C{Exec} method

    """

    return self.mcpu.ExecOpCodeAndRecordOutput(opcode)

  def ExecOpCodeExpectException(self, opcode,

    @return: the result of test_func

    """

    return self.mcpu.RunWithLockedLU(opcode, test_func)

  def assertLogContainsMessage(self, expected_msg):

from ganeti import constants

from ganeti import mcpu

class LogRecordingCallback(mcpu.OpExecCbBase):

  """Helper class for log output recording.

    super(ProcessorMock, self).__init__(context, 1, True)

    self.log_entries = []

    self._lu_test_func = None

  def ExecOpCodeAndRecordOutput(self, op):

    """Executes the given opcode and records the output for further inspection.

    self.context = FakeContext()

    # WARNING: here we pass None as RpcRunner instance since we know

    # our usage via HooksMaster will not use lu.rpc

  def testTotalFalse(self):

    """Test complete rpc failure"""

    self.op = opcodes.OpTestDummy(result=False, messages=[], fail=False)

    self.lu = FakeEnvWithCustomPostHookNodesLU(FakeProc(), self.op,

  def _HooksRpc(self, *args):

    self._rpcs.append(args)

  def __init__(self, needed_locks, share_locks):

    self.needed_locks = needed_locks

    self.share_locks = share_locks

class TestVerifyLocks(unittest.TestCase):

  def testNoLocks(self):

    lu = _FakeLuWithLocks({}, {})

                      _mode_whitelist=NotImplemented,

                      _nal_whitelist=NotImplemented)

        level: 0,

        locking.LEVEL_NODE_ALLOC: 0,

        })

  def testDifferentMode(self):

    for level in [locking.LEVEL_NODE, locking.LEVEL_NODE_RES]:

        level: 0,

        locking.LEVEL_NODE_ALLOC: 1,

        })

      try:

      except AssertionError, err:

        self.assertTrue("using the same mode as nodes" in str(err))

      else:

        self.fail("Exception not raised")

      # Once more with the whitelist

                        _nal_whitelist=[])

  def testSameMode(self):

        level: 1,

        locking.LEVEL_NODE_ALLOC: 1,

        })

      try:

                          _nal_whitelist=[])

      except AssertionError, err:

        self.assertTrue("whitelisted to use different modes" in str(err))

        self.fail("Exception not raised")

      # Once more without the whitelist

  def testAllWithoutAllocLock(self):

    for level in [locking.LEVEL_NODE, locking.LEVEL_NODE_RES]:

        level: 0,

        locking.LEVEL_NODE_ALLOC: 0,

        })

      try:

      except AssertionError, err:

        self.assertTrue("allocation lock must be used if" in str(err))

      else:

        self.fail("Exception not raised")

      # Once more with the whitelist

                        _nal_whitelist=[_FakeLuWithLocks])

  def testAllWithAllocLock(self):

        level: 0,

        locking.LEVEL_NODE_ALLOC: 0,

        })

      try:

                          _nal_whitelist=[_FakeLuWithLocks])

      except AssertionError, err:

        self.assertTrue("whitelisted for not acquiring" in str(err))

        self.fail("Exception not raised")

      # Once more without the whitelist

if __name__ == "__main__":