Synnefo » snf-ganeti » ganeti-local

from ganeti import utils

from ganeti.cmdlib.base import LogicalUnit, Tasklet

from ganeti.cmdlib.common import ExpandInstanceName, \

from ganeti.cmdlib.instance_storage import CheckDiskConsistency, \

  ExpandCheckDisks, ShutdownInstanceDisks, AssembleInstanceDisks

from ganeti.cmdlib.instance_utils import BuildInstanceHookEnvByObject, \

  """

  if lu.op.target_node is not None:

  lu.needed_locks[locking.LEVEL_NODE] = []

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

        lu.needed_locks[locking.LEVEL_NODE_ALLOC] = locking.ALL_SET

      else:

        lu.needed_locks[locking.LEVEL_NODE] = [instance.primary_node,

      del lu.recalculate_locks[locking.LEVEL_NODE]

    else:

      lu._LockInstancesNodes() # pylint: disable=W0212

    """

    instance = self._migrater.instance

    env = {

      "IGNORE_CONSISTENCY": self.op.ignore_consistency,

      "SHUTDOWN_TIMEOUT": self.op.shutdown_timeout,

      }

    if instance.disk_template in constants.DTS_INT_MIRROR:

    else:

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

    """

    instance = self._migrater.instance

    env = BuildInstanceHookEnvByObject(self, instance)

    env.update({

      "MIGRATE_LIVE": self._migrater.live,

      "MIGRATE_CLEANUP": self.op.cleanup,

      "ALLOW_RUNTIME_CHANGES": self.op.allow_runtime_changes,

      })

    if instance.disk_template in constants.DTS_INT_MIRROR:

    else:

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

    """

    instance = self._migrater.instance

    return (nl, nl)

  @ivar cleanup: Wheater we cleanup from a failed migration

  @type iallocator: string

  @ivar iallocator: The iallocator used to determine target_node

  @type failover: boolean

  @ivar failover: Whether operation results in failover or migration

  @type fallback: boolean

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

        self._RunAllocator()

      else:

        # BuildHooksEnv

      # Check that the target node is correct in terms of instance policy

      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

        ReleaseLocks(self.lu, locking.LEVEL_NODE,

        ReleaseLocks(self.lu, locking.LEVEL_NODE_ALLOC)

    else:

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

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

                                        " %s disk template" %

                                        instance.disk_template)

        if self.failover:

          text = "failed over"

        else:

                                   " node can be passed)" %

                                   (instance.disk_template, text),

                                   errors.ECODE_INVAL)

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

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

                                                              group_info)

    if (not self.cleanup and

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

      self.tgt_free_mem = CheckNodeFreeMemory(

          i_be[constants.BE_MINMEM], instance.hypervisor,

          self.cfg.GetClusterInfo().hvparams[instance.hypervisor])

    else:

      self.failover = True

    # check bridge existance

    if not self.cleanup:

      if not self.failover:

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

                                                   instance)

          instance.primary_node, instance.name, instance.hypervisor,

          cluster.hvparams[instance.hypervisor])

      remote_info.Raise("Error checking instance on node %s" %

      instance_running = bool(remote_info.payload)

      if instance_running:

        self.current_mem = int(remote_info.payload["memory"])

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

    # FIXME: add a self.ignore_ipolicy option

    ial = iallocator.IAllocator(self.cfg, self.rpc, req)

    ial.Run(self.lu.op.iallocator)

                                 " iallocator '%s': %s" %

                                 (self.lu.op.iallocator, ial.info),

                                 errors.ECODE_NORES)

    self.lu.LogInfo("Selected nodes for instance %s via iallocator %s: %s",

                    self.instance_name, self.lu.op.iallocator,

                    utils.CommaJoin(ial.result))

    all_done = False

    while not all_done:

      all_done = True

                                            self.nodes_ip,

                                            (self.instance.disks,

                                             self.instance))

      min_percent = 100

        node_done, node_percent = nres.payload

        all_done = all_done and node_done

        if node_percent is not None:

          self.feedback_fn("   - progress: %.1f%%" % min_percent)

        time.sleep(2)

    """Demote a node to secondary.

    """

    for dev in self.instance.disks:

                                          self.instance.disks)

  def _GoStandalone(self):

    """Disconnect from the network.

    """

    self.feedback_fn("* changing into standalone mode")

                                               self.instance.disks)

  def _GoReconnect(self, multimaster):

    """Reconnect to the network.

    else:

      msg = "single-master"

    self.feedback_fn("* changing disks into %s mode" % msg)

                                           (self.instance.disks, self.instance),

                                           self.instance.name, multimaster)

  def _ExecCleanup(self):

    """Try to cleanup after a failed migration.

    """

    instance = self.instance

    # check running on only one node

    self.feedback_fn("* checking where the instance actually runs"

                     " (if this hangs, the hypervisor might be in"

                     " a bad state)")

    cluster_hvparams = self.cfg.GetClusterInfo().hvparams

                                        cluster_hvparams)

    if runningon_source and runningon_target:

      raise errors.OpExecError("Instance seems to be running on two nodes,"

    if runningon_target:

      # the migration has actually succeeded, we need to update the config

      self.feedback_fn("* instance running on secondary node (%s),"

      self.cfg.Update(instance, self.feedback_fn)

    else:

      self.feedback_fn("* instance confirmed to be running on its"

    if instance.disk_template in constants.DTS_INT_MIRROR:

      try:

        self._WaitUntilSync()

      except errors.OpExecError:

    """Try to revert the disk status after a failed migration.

    """

    if self.instance.disk_template in constants.DTS_EXT_MIRROR:

      return

    try:

      self._GoStandalone()

      self._GoReconnect(False)

      self._WaitUntilSync()

    """

    instance = self.instance

    migration_info = self.migration_info

    abort_msg = abort_result.fail_msg

    if abort_msg:

      logging.error("Aborting migration failed on target node %s: %s",

      # Don't raise an exception here, as we stil have to try to revert the

      # disk status, even if this step failed.

    abort_result = self.rpc.call_instance_finalize_migration_src(

    abort_msg = abort_result.fail_msg

    if abort_msg:

      logging.error("Aborting migration failed on source node %s: %s",

  def _ExecMigration(self):

    """Migrate an instance.

    """

    instance = self.instance

    # Check for hypervisor version mismatch and warn the user.

    hvspecs = [(instance.hypervisor,

                self.cfg.GetClusterInfo().hvparams[instance.hypervisor])]

                                       None, hvspecs, False)

    for ninfo in nodeinfo.values():

      ninfo.Raise("Unable to retrieve node information from node '%s'" %

                  ninfo.node)

    if ((constants.HV_NODEINFO_KEY_VERSION in src_info) and

        (constants.HV_NODEINFO_KEY_VERSION in dst_info)):

    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)

        raise errors.OpExecError("Memory ballooning not allowed and not enough"

                                 " free memory to fit instance %s on target"

                                 " node %s (have %dMB, need %dMB)" %

                                  self.tgt_free_mem, self.current_mem))

      self.feedback_fn("* setting instance memory to %s" % self.tgt_free_mem)

      rpcres = self.rpc.call_instance_balloon_memory(instance.primary_node,

      rpcres.Raise("Cannot modify instance runtime memory")

    # First get the migration information from the remote node

    msg = result.fail_msg

    if msg:

      log_err = ("Failed fetching source migration information from %s: %s" %

      logging.error(log_err)

      raise errors.OpExecError(log_err)

    if self.instance.disk_template not in constants.DTS_EXT_MIRROR:

      # Then switch the disks to master/master mode

      self._GoStandalone()

      self._GoReconnect(True)

      self._WaitUntilSync()

                                           instance,

                                           migration_info,

    msg = result.fail_msg

    if msg:

      raise errors.OpExecError("Could not pre-migrate instance %s: %s" %

                               (instance.name, msg))

    cluster = self.cfg.GetClusterInfo()

    result = self.rpc.call_instance_migrate(

    msg = result.fail_msg

    if msg:

      logging.error("Instance migration failed, trying to revert"

    self.feedback_fn("* starting memory transfer")

    last_feedback = time.time()

    while True:

                                                           instance)

      msg = result.fail_msg

      ms = result.payload   # MigrationStatus instance

      time.sleep(self._MIGRATION_POLL_INTERVAL)

                                                           instance,

                                                           True,

                                                           self.live)

      raise errors.OpExecError("Could not finalize instance migration: %s" %

                               msg)

    # distribute new instance config to the other nodes

    self.cfg.Update(instance, self.feedback_fn)

                                                           instance,

                                                           migration_info,

                                                           True)

                               msg)

    if self.instance.disk_template not in constants.DTS_EXT_MIRROR:

      self._WaitUntilSync()

      self._GoStandalone()

      self._GoReconnect(False)

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

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

      disks = ExpandCheckDisks(instance, instance.disks)

      for disk in disks:

        msg = result.fail_msg

        if msg:

          logging.error("Migration was successful, but couldn't unmap the"

                        " block device %s on source node %s: %s",

          logging.error("You need to unmap the device %s manually on %s",

    self.feedback_fn("* done")

    instance = self.instance

    primary_node = self.cfg.GetNodeInfo(instance.primary_node)

    if instance.disks_active:

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

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

        # for drbd, these are drbd over lvm

                                    False):

          if primary_node.offline:

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

                             " target node %s" %

          elif not self.ignore_consistency:

            raise errors.OpExecError("Disk %s is degraded on target node,"

                                     " aborting failover" % idx)

    self.feedback_fn("* shutting down instance on source node")

    logging.info("Shutting down instance %s on node %s",

                                             self.shutdown_timeout,

                                             self.lu.op.reason)

    msg = result.fail_msg

        self.lu.LogWarning("Could not shutdown instance %s on node %s,"

                           " proceeding anyway; please make sure node"

                           " %s is down; error details: %s",

      else:

        raise errors.OpExecError("Could not shutdown instance %s on"

                                 " node %s: %s" %

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

    if not ShutdownInstanceDisks(self.lu, instance, ignore_primary=True):

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

    # distribute new instance config to the other nodes

    self.cfg.Update(instance, self.feedback_fn)

    # Only start the instance if it's marked as up

    if instance.admin_state == constants.ADMINST_UP:

      self.feedback_fn("* activating the instance's disks on target node %s" %

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

      disks_ok, _ = AssembleInstanceDisks(self.lu, instance,

                                          ignore_secondaries=True)

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

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

      msg = result.fail_msg

      if msg:

        ShutdownInstanceDisks(self.lu, instance)

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

  def Exec(self, feedback_fn):

    """Perform the migration.

    """

    self.feedback_fn = feedback_fn

    # FIXME: if we implement migrate-to-any in DRBD, this needs fixing

    if self.instance.disk_template in constants.DTS_INT_MIRROR:

      # Otherwise self.target_node has been populated either

      # directly, or through an iallocator.

    if self.failover:

      feedback_fn("Failover instance %s" % self.instance.name)