Synnefo » snf-ganeti » ganeti-local

    """

    instance_name = ExpandInstanceName(self.lu.cfg, self.instance_name)

    cluster = self.cfg.GetClusterInfo()

    if (not self.cleanup and

        not self.failover and self.fallback):

      self.lu.LogInfo("Instance is marked down or offline, fallback allowed,"

                      " switching to failover")

      self.failover = True

      if self.failover:

        text = "failovers"

      else:

        text = "migrations"

      raise errors.OpPrereqError("Instance's disk layout '%s' does not allow"

                                 errors.ECODE_STATE)

      CheckIAllocatorOrNode(self.lu, "iallocator", "target_node")

      if self.lu.op.iallocator:

      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

      target_node_uuid = self.target_node_uuid

        raise errors.OpPrereqError(

          "Cannot migrate instance %s to its primary (%s)" %

          errors.ECODE_STATE)

      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)

      if not secondary_node_uuids:

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

                                        " %s disk template" %

      target_node_uuid = secondary_node_uuids[0]

      if self.lu.op.iallocator or \

        (self.lu.op.target_node_uuid and

                                   " be %s to arbitrary nodes"

                                   " (neither an iallocator nor a target"

                                   " node can be passed)" %

                                   errors.ECODE_INVAL)

      nodeinfo = self.cfg.GetNodeInfo(target_node_uuid)

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

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

                                                              group_info)

    # check memory requirements on the secondary node

    if (not self.cleanup and

      self.tgt_free_mem = CheckNodeFreeMemory(

    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:

      CheckNodeNotDrained(self.lu, target_node_uuid)

      if not self.failover:

        if result.fail_msg and self.fallback:

          self.lu.LogInfo("Can't migrate, instance offline, fallback to"

                          " failover")

    if not (self.failover or self.cleanup):

      remote_info = self.rpc.call_instance_info(

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

      - wait again until disks are fully synchronized

    """

    # 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

    ins_l = self.rpc.call_instance_list(self.all_node_uuids,

                                        cluster_hvparams)

    for node_uuid, result in ins_l.items():

      result.Raise("Can't contact node %s" % node_uuid)

    if runningon_source and runningon_target:

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

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

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

                       " updating config" %

    else:

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

                       " primary node (%s)" %

      self._EnsureSecondary(demoted_node_uuid)

      try:

        self._WaitUntilSync()

    """Call the hypervisor code to abort a started migration.

    """

    abort_result = self.rpc.call_instance_finalize_migration_dst(

    abort_msg = abort_result.fail_msg

    if abort_msg:

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

      # 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",

      - change disks into single-master mode

    """

    # Check for hypervisor version mismatch and warn the user.

    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)):

                         (src_version, dst_version))

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

                                  False):

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

                                 " synchronized on target node,"

        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)

                                                     self.tgt_free_mem)

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

    self.feedback_fn("* preparing %s to accept the instance" %

                                           migration_info,

    msg = result.fail_msg

    if msg:

      self._AbortMigration()

      self._RevertDiskStatus()

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

    self.feedback_fn("* migrating instance to %s" %

    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._AbortMigration()

      self._RevertDiskStatus()

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

    self.feedback_fn("* starting memory transfer")

    last_feedback = time.time()

    while True:

      msg = result.fail_msg

      ms = result.payload   # MigrationStatus instance

      if msg or (ms.status in constants.HV_MIGRATION_FAILED_STATUSES):

        if not msg:

          msg = "hypervisor returned failure"

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

      if result.payload.status != constants.HV_MIGRATION_ACTIVE:

        self.feedback_fn("* memory transfer complete")

      time.sleep(self._MIGRATION_POLL_INTERVAL)

    msg = result.fail_msg

    if msg:

      logging.error("Instance migration succeeded, but finalization failed"

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

                               msg)

    # distribute new instance config to the other nodes

    msg = result.fail_msg

    if msg:

      logging.error("Instance migration succeeded, but finalization failed"

                               msg)

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

      self._WaitUntilSync()

      self._GoStandalone()

      self._GoReconnect(False)

    # 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" %

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

    starting it on the secondary.

    """

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

        # 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" %

                             (primary_node.name, idx,

          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",

                           self.cfg.GetNodeName(source_node_uuid),

                           self.cfg.GetNodeName(source_node_uuid), msg)

      else:

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

                                 " node %s: %s" %

                                  self.cfg.GetNodeName(source_node_uuid), msg))

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

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

    # distribute new instance config to the other nodes

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

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

                                          ignore_secondaries=True)

      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" %

                                            self.lu.op.reason)

      msg = result.fail_msg

      if msg:

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

  def Exec(self, feedback_fn):

    """Perform the migration.