Synnefo » snf-ganeti

from ganeti.masterd import iallocator

from ganeti import utils

from ganeti.cmdlib.base import LogicalUnit, Tasklet

import ganeti.masterd.instance

  """

  if lu.op.target_node is not None:

  lu.needed_locks[locking.LEVEL_NODE] = []

  lu.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE

  elif level == locking.LEVEL_NODE_RES:

    # Copy node locks

    lu.needed_locks[locking.LEVEL_NODE_RES] = \

class LUInstanceFailover(LogicalUnit):

    else:

      env["OLD_SECONDARY"] = env["NEW_SECONDARY"] = ""

    return env

    instance = self._migrater.instance

    source_node = instance.primary_node

    target_node = self.op.target_node

    env.update({

      "MIGRATE_LIVE": self._migrater.live,

      "MIGRATE_CLEANUP": self.op.cleanup,

    This checks that the instance is in the cluster.

    """

    instance = self.cfg.GetInstanceInfo(instance_name)

    assert instance is not None

    self.instance = instance

                                 errors.ECODE_STATE)

    if instance.disk_template in constants.DTS_EXT_MIRROR:

      if self.lu.op.iallocator:

        assert locking.NAL in self.lu.owned_locks(locking.LEVEL_NODE_ALLOC)

      group_info = self.cfg.GetNodeGroup(nodeinfo.group)

      ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster,

                                                              group_info)

      # self.target_node is already populated, either directly or by the

      # iallocator run

      if len(self.lu.tasklets) == 1:

        # It is safe to release locks only when we're the only tasklet

        # in the LU

    else:

      assert not self.lu.glm.is_owned(locking.LEVEL_NODE_ALLOC)

      group_info = self.cfg.GetNodeGroup(nodeinfo.group)

      ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster,

                                                              group_info)

    i_be = cluster.FillBE(instance)

    # check memory requirements on the secondary node

    if (not self.cleanup and

         (not self.failover or instance.admin_state == constants.ADMINST_UP)):

    else:

      self.lu.LogInfo("Not checking memory on the secondary node as"

                      " instance will not be started")

      self.failover = True

    # check bridge existance

    if not self.cleanup:

      if not self.failover:

        result = self.rpc.call_instance_migratable(instance.primary_node,

                                                   instance)

    self.feedback_fn("* checking disk consistency between source and target")

    for (idx, dev) in enumerate(instance.disks):

        raise errors.OpExecError("Disk %s is degraded or not fully"

                                 " synchronized on target node,"

                                 " aborting migration" % idx)

    # If the instance's disk template is `rbd' or `ext' and there was a

    # successful migration, unmap the device from the source node.

    if self.instance.disk_template in (constants.DT_RBD, constants.DT_EXT):

      self.feedback_fn("* unmapping instance's disks from %s" % source_node)

      for disk in disks:

        result = self.rpc.call_blockdev_shutdown(source_node, (disk, instance))

      self.feedback_fn("* checking disk consistency between source and target")

      for (idx, dev) in enumerate(instance.disks):

        # for drbd, these are drbd over lvm

          if primary_node.offline:

            self.feedback_fn("Node %s is offline, ignoring degraded disk %s on"

                             " target node %s" %

                                 (instance.name, source_node, msg))

    self.feedback_fn("* deactivating the instance's disks on source node")

      raise errors.OpExecError("Can't shut down the instance's disks")

    instance.primary_node = target_node

      logging.info("Starting instance %s on node %s",

                   instance.name, target_node)

      if not disks_ok:

        raise errors.OpExecError("Can't activate the instance's disks")

      self.feedback_fn("* starting the instance on the target node %s" %

                                            False, self.lu.op.reason)

      msg = result.fail_msg

      if msg:

        raise errors.OpExecError("Could not start instance %s on node %s: %s" %

                                 (instance.name, target_node, msg))