Synnefo » snf-ganeti

    """Check prerequisites.

    """

    assert self.instance is not None, \

          "Cannot retrieve locked instance %s" % self.op.instance_name

    CheckNodeOnline(self, self.instance.primary_node)

    This checks that the instance and node names are valid.

    """

    assert self.instance is not None, \

          "Cannot retrieve locked instance %s" % self.op.instance_name

    CheckNodeOnline(self, self.instance.primary_node)

    """Remove any export.

    """

    # If the instance was not found we'll try with the name that was passed in.

    # This will only work if it was an FQDN, though.

    fqdn_warn = False

      fqdn_warn = True

    locked_nodes = self.owned_locks(locking.LEVEL_NODE)

    exportlist = self.rpc.call_export_list(locked_nodes)

        self.LogWarning("Failed to query node %s (continuing): %s",

                        self.cfg.GetNodeName(node_uuid), msg)

        continue

        found = True

        msg = result.fail_msg

        if msg:

          logging.error("Could not remove export for instance %s"

                        self.cfg.GetNodeName(node_uuid), msg)

    if fqdn_warn and not found:

from ganeti import locking

from ganeti import query

from ganeti import utils

class ResultWithJobs:

    else:

      assert locking.LEVEL_INSTANCE not in self.needed_locks, \

        "_ExpandAndLockInstance called with instance-level locks set"

    self.needed_locks[locking.LEVEL_INSTANCE] = self.op.instance_name

  def _LockInstancesNodes(self, primary_only=False,

    # of self.recalculate_locks[locking.LEVEL_NODE]

    wanted_node_uuids = []

    locked_i = self.owned_locks(locking.LEVEL_INSTANCE)

      wanted_node_uuids.append(instance.primary_node)

      if not primary_only:

        wanted_node_uuids.extend(instance.secondary_nodes)

  def ExpandNames(self):

    if self.op.instances:

      # Not getting the node allocation lock as only a specific set of

      # instances (and their nodes) is going to be acquired

      self.needed_locks = {

      self.wanted_names = self.owned_locks(locking.LEVEL_INSTANCE)

    self.wanted_instances = \

  def _EnsureChildSizes(self, disk):

    """Ensure children of the disk have the needed disk size.

                                             for nuuid in inst.all_nodes)])

        new_ipolicy = objects.FillIPolicy(self.new_ipolicy, group.ipolicy)

        ipol = masterd.instance.CalculateGroupIPolicy(cluster, group)

        if new:

          violations.update(new)

    for inst in self.all_inst_info.values():

      if inst.primary_node in [node.uuid for node in dangling_nodes]:

      elif inst.primary_node not in self.all_node_info:

    pretty_dangling = [

        "%s (%s)" %

        (node.name,

        for node in dangling_nodes]

    self._ErrorIf(bool(dangling_nodes), constants.CV_ECLUSTERDANGLINGNODES,

    self._ErrorIf(bool(no_node_instances), constants.CV_ECLUSTERDANGLINGINST,

                  None,

                  "the following instances have a non-existing primary-node:"

    return not self.bad

    self.group_uuid = self.cfg.LookupNodeGroup(self.op.group_name)

    # Get instances in node group; this is unsafe and needs verification later

      self.cfg.GetNodeGroupInstances(self.group_uuid, primary_only=True)

    self.needed_locks = {

      locking.LEVEL_NODEGROUP: [self.group_uuid],

      locking.LEVEL_NODE: [],

      # Get members of node group; this is unsafe and needs verification later

      nodes = set(self.cfg.GetNodeGroup(self.group_uuid).members)

      # In Exec(), we warn about mirrored instances that have primary and

      # secondary living in separate node groups. To fully verify that

      # volumes for these instances are healthy, we will need to do an

      # extra call to their secondaries. We ensure here those nodes will

      # be locked.

        # Important: access only the instances whose lock is owned

      self.needed_locks[locking.LEVEL_NODE] = nodes

    self.group_info = self.cfg.GetNodeGroup(self.group_uuid)

    group_node_uuids = set(self.group_info.members)

      self.cfg.GetNodeGroupInstances(self.group_uuid, primary_only=True)

    unlocked_node_uuids = \

        group_node_uuids.difference(self.owned_locks(locking.LEVEL_NODE))

    if unlocked_node_uuids:

      raise errors.OpPrereqError(

        utils.CommaJoin(self.cfg.GetNodeNames(unlocked_node_uuids)),

        errors.ECODE_STATE)

    self.all_node_info = self.cfg.GetAllNodesInfo()

    self.all_inst_info = self.cfg.GetAllInstancesInfo()

    self.my_node_info = dict((node_uuid, self.all_node_info[node_uuid])

                             for node_uuid in group_node_uuids)

    # We detect here the nodes that will need the extra RPC calls for verifying

    # split LV volumes; they should be locked.

          msg = "cannot reach the master IP"

        self._ErrorIf(True, constants.CV_ENODENET, ninfo.name, msg)

    """Verify an instance.

    This function checks to see if the required block devices are

    state.

    """

    groupinfo = self.cfg.GetAllNodeGroupsInfo()

    node_vol_should = {}

    cluster = self.cfg.GetClusterInfo()

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

                                                            self.group_info)

                  utils.CommaJoin(err), code=self.ETYPE_WARNING)

      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:

        # ignore missing volumes on offline or broken nodes

        continue

        test = volume not in n_img.volumes

                      "volume %s missing on node %s", volume,

                    "instance not running on its primary node %s",

    diskdata = [(nname, success, status, idx)

                for (nname, disks) in diskstatus.items()

      # node here

      snode = node_image[nname]

      bad_snode = snode.ghost or snode.offline

                    not success and not bad_snode,

                    "couldn't retrieve status for disk/%s on %s: %s",

                    idx, self.cfg.GetNodeName(nname), bdev_status)

         (bdev_status.is_degraded or

          bdev_status.ldisk_status != constants.LDS_OKAY):

        msg = "disk/%s on %s" % (idx, self.cfg.GetNodeName(nname))

          msg += "; state is '%s'" % \

                 constants.LDS_NAMES[bdev_status.ldisk_status]

    self._ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,

                  code=self.ETYPE_WARNING)

    if any(es_flags.values()):

        # Disk template not compatible with exclusive_storage: no instance

        # node should have the flag set

        es_nodes = [n

                    for (n, es) in es_flags.items()

                    if es]

                    "instance has template %s, which is not supported on nodes"

                    " that have exclusive storage set: %s",

                    utils.CommaJoin(self.cfg.GetNodeNames(es_nodes)))

        self._ErrorIf(disk.spindles is None,

                      "number of spindles not configured for disk %s while"

                      " exclusive storage is enabled, try running"

                      " gnt-cluster repair-disk-sizes", idx)

      instance_groups = {}

      pretty_list = [

        "%s (group %s)" % (utils.CommaJoin(self.cfg.GetNodeNames(nodes)),

                           groupinfo[group].name)

        # Sort so that we always list the primary node first.

        for group, nodes in sorted(instance_groups.items(),

                                   reverse=True)]

      self._ErrorIf(len(instance_groups) > 1,

                    constants.CV_EINSTANCESPLITGROUPS,

                    " different groups: %s", utils.CommaJoin(pretty_list),

                    code=self.ETYPE_WARNING)

    inst_nodes_offline = []

      s_img = node_image[snode]

      self._ErrorIf(s_img.rpc_fail and not s_img.offline, constants.CV_ENODERPC,

      if s_img.offline:

        inst_nodes_offline.append(snode)

    # warn that the instance lives on offline nodes

                  utils.CommaJoin(self.cfg.GetNodeNames(inst_nodes_offline)))

    # ... or ghost/non-vm_capable nodes

                    "instance lives on non-vm_capable node %s",

  def _VerifyOrphanVolumes(self, node_vol_should, node_image, reserved):

    """Verify if there are any unknown volumes in the cluster.

                      self.cfg.GetNodeName(node_uuid),

                      "volume %s is unknown", volume)

    """Verify N+1 Memory Resilience.

    Check that if one single node dies we can still start all the

        # nodes, and that's enough warning

        continue

      #TODO(dynmem): also consider ballooning out other instances

        needed_mem = 0

          if bep[constants.BE_AUTO_BALANCE]:

            needed_mem += bep[constants.BE_MINMEM]

        test = n_img.mfree < needed_mem

    # compute the DRBD minors

    node_drbd = {}

      self._ErrorIf(test, constants.CV_ECLUSTERCFG, None,

        # ghost instance should not be running, but otherwise we

        # don't give double warnings (both ghost instance and

        # unallocated minor in use)

      if test:

      else:

    # and now check them

    used_minors = nresult.get(constants.NV_DRBDLIST, [])

      # we cannot check drbd status

      return

      test = minor not in used_minors and must_exist

      self._ErrorIf(test, constants.CV_ENODEDRBD, ninfo.name,

    for minor in used_minors:

      test = minor not in node_drbd

      self._ErrorIf(test, constants.CV_ENODEDRBD, ninfo.name,

    if test:

      nimg.hyp_fail = True

    else:

  def _UpdateNodeInfo(self, ninfo, nresult, nimg, vg_name):

    """Verifies and computes a node information map

    @type node_uuids: list of strings

    @param node_uuids: Node UUIDs

    @param node_image: Node objects

    @param instanceinfo: Instance objects

    @rtype: {instance: {node: [(succes, payload)]}}

    @return: a dictionary of per-instance dictionaries with nodes as

    diskless = constants.DT_DISKLESS

    for nuuid in node_uuids:

      if not disks:

        # No need to collect data

      # _AnnotateDiskParams makes already copies of the disks

      devonly = []

        self.cfg.SetDiskID(anno_disk, nuuid)

        devonly.append(anno_disk)

                              node.name, idx, i)

              data.append((False, "Invalid result from the remote node"))

    # Add empty entries for diskless instances.

    assert compat.all(len(statuses) == len(instanceinfo[inst].disks) and

                      len(nuuids) <= len(instanceinfo[inst].all_nodes) and

    default_nicpp = cluster.nicparams[constants.PP_DEFAULT]

    if default_nicpp[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:

      bridges.add(default_nicpp[constants.NIC_LINK])

        full_nic = cluster.SimpleFillNIC(nic.nicparams)

        if full_nic[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:

          bridges.add(full_nic[constants.NIC_LINK])

    if oob_paths:

      node_verify_param[constants.NV_OOB_PATHS] = oob_paths

        i_offline += 1

        if nuuid not in node_image:

          gnode = self.NodeImage(uuid=nuuid)

          gnode.ghost = (nuuid not in self.all_node_info)

          node_image[nuuid] = gnode

        nimg = node_image[snode]

        if pnode not in nimg.sbp:

          nimg.sbp[pnode] = []

    es_flags = rpc.GetExclusiveStorageForNodes(self.cfg,

                                               self.my_node_info.keys())

          self._VerifyNodeOS(node_i, nimg, refos_img)

        self._VerifyNodeBridges(node_i, nresult, bridges)

        # can no longer be done from _VerifyInstance below, since some of the

        # wrong instances could be from other node groups.)

                        "instance should not run on node %s", node_i.name)

          self._ErrorIf(not test, constants.CV_ENODEORPHANINSTANCE, node_i.name,

    self._VerifyGroupDRBDVersion(all_nvinfo)

    self._VerifyGroupLVM(node_image, vg_name)

                              node_image[node_uuid], vg_name)

    feedback_fn("* Verifying instance status")

      if verbose:

      # If the instance is non-redundant we cannot survive losing its primary

      # node, so we are not N+1 compliant.

        i_non_redundant.append(instance)

        i_non_a_balanced.append(instance)

    feedback_fn("* Verifying orphan volumes")

    # We will get spurious "unknown volume" warnings if any node of this group

    # is secondary for an instance whose primary is in another group. To avoid

    # them, we find these instances and add their volumes to node_vol_should.

        if (secondary in self.my_node_info

          break

    self._VerifyOrphanVolumes(node_vol_should, node_image, reserved)

  return full_name

  """Wrapper over L{_ExpandItemName} for instance."""

def ExpandNodeUuidAndName(cfg, expected_uuid, name):

  return dict.fromkeys(locking.LEVELS, 1)

  """Checks if the instances in a node group are still correct.

  @type cfg: L{config.ConfigWriter}

  @param cfg: The cluster configuration

  @type group_uuid: string

  @param group_uuid: Node group UUID

  """

    raise errors.OpPrereqError("Instances in node group '%s' changed since"

                               " locks were acquired, wanted '%s', have '%s';"

                               " retry the operation" %

                               (group_uuid,

                                utils.CommaJoin(wanted_instances),

                               errors.ECODE_STATE)

  return wanted_instances

  return (node_uuids, [lu.cfg.GetNodeName(uuid) for uuid in node_uuids])

  """Returns list of checked and expanded instance names.

  @type lu: L{LogicalUnit}

  @param lu: the logical unit on whose behalf we execute

  @raise errors.OpPrereqError: if the instances parameter is wrong type

  @raise errors.OpPrereqError: if any of the passed instances is not found

  """

  else:

def RunPostHook(lu, node_name):

  @type cfg: L{config.ConfigWriter}

  @param cfg: Cluster configuration

  @type instances: dict; string as key, L{objects.Instance} as value

  @type owned_groups: iterable of string

  @param owned_groups: List of owned groups

  @type owned_node_uuids: iterable of string

  @param cur_group_uuid: Optional group UUID to check against instance's groups

  """

    assert owned_node_uuids.issuperset(inst.all_nodes), \

    assert cur_group_uuid is None or cur_group_uuid in inst_groups, \

  """Checks if the owned node groups are still correct for an instance.

  @type cfg: L{config.ConfigWriter}

  @param cfg: The cluster configuration

  @type owned_groups: set or frozenset

  @param owned_groups: List of currently owned node groups

  @type primary_only: boolean

  @param primary_only: Whether to check node groups for only the primary node

  """

  if not owned_groups.issuperset(inst_groups):

    raise errors.OpPrereqError("Instance %s's node groups changed since"

                               " locks were acquired, current groups are"

                               " are '%s', owning groups '%s'; retry the"

                               " operation" %

                                utils.CommaJoin(inst_groups),

                                utils.CommaJoin(owned_groups)),

                               errors.ECODE_STATE)

                                            self.node_data, instance_data)

    if new_splits:

      if not self.op.force:

        raise errors.OpExecError("The following instances get split by this"

        if previous_splits:

          self.LogWarning("In addition, these already-split instances continue"

                          " to be split across groups: %s",

  def Exec(self, feedback_fn):

    """Assign nodes to a new group.

      if len(set(node_data[node_uuid].group

                 for node_uuid in inst.all_nodes)) > 1:

      if len(set(changed_nodes.get(node_uuid, node_data[node_uuid].group)

                 for node_uuid in inst.all_nodes)) > 1:

    return (list(all_split_instances - previously_split_instances),

            list(previously_split_instances & all_split_instances))

        for instance in all_instances.values():

          node = instance.primary_node

          if node in node_to_group:

        if not do_nodes:

          # Do not pass on node information if it was not requested.

      # Lock instances optimistically, needs verification once group lock has

      # been acquired

      self.needed_locks[locking.LEVEL_INSTANCE] = \

  @staticmethod

  def _UpdateAndVerifyDiskParams(old, new):

    """Check prerequisites.

    """

    # Check if locked instances are still correct

    self.group = self.cfg.GetNodeGroup(self.group_uuid)

    cluster = self.cfg.GetClusterInfo()

                                           group_policy=True)

      new_ipolicy = cluster.SimpleFillIPolicy(self.new_ipolicy)

      gmi = ganeti.masterd.instance

      violations = \

          ComputeNewInstanceViolations(gmi.CalculateGroupIPolicy(cluster,

      # Lock instances optimistically, needs verification once node and group

      # locks have been acquired

      self.needed_locks[locking.LEVEL_INSTANCE] = \

    elif level == locking.LEVEL_NODEGROUP:

      assert not self.needed_locks[locking.LEVEL_NODEGROUP]

                           for instance_name in

                             self.owned_locks(locking.LEVEL_INSTANCE)

                           for group_uuid in

      else:

        # No target groups, need to lock all of them

        lock_groups = locking.ALL_SET

      self.needed_locks[locking.LEVEL_NODE].extend(member_node_uuids)

  def CheckPrereq(self):

    owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))

    owned_node_uuids = frozenset(self.owned_locks(locking.LEVEL_NODE))

    assert self.group_uuid in owned_groups

    # Check if locked instances are still correct

    # Get instance information

    # Check if node groups for locked instances are still correct

    CheckInstancesNodeGroups(self.cfg, self.instances,

    return (run_nodes, run_nodes)

  def Exec(self, feedback_fn):

    assert self.group_uuid not in self.target_uuids

                                      target_groups=self.target_uuids)

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

      # Lock instances optimistically, needs verification once node and group

      # locks have been acquired

      self.needed_locks[locking.LEVEL_INSTANCE] = \

    elif level == locking.LEVEL_NODEGROUP:

      assert not self.needed_locks[locking.LEVEL_NODEGROUP]

            # later on

            [group_uuid

             for instance_name in self.owned_locks(locking.LEVEL_INSTANCE)

    elif level == locking.LEVEL_NODE:

      # This will only lock the nodes in the group to be verified which contain

      self.needed_locks[locking.LEVEL_NODE].extend(member_node_uuids)

  def CheckPrereq(self):

    owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))

    owned_node_uuids = frozenset(self.owned_locks(locking.LEVEL_NODE))

    assert self.group_uuid in owned_groups

    # Check if locked instances are still correct

    # Get instance information

    # Check if node groups for locked instances are still correct

    CheckInstancesNodeGroups(self.cfg, self.instances,

  ShareAll, GetDefaultIAllocator, CheckInstanceNodeGroups, \

  LoadNodeEvacResult, CheckIAllocatorOrNode, CheckParamsNotGlobal, \

  IsExclusiveStorageEnabledNode, CheckHVParams, CheckOSParams, \

  ComputeIPolicySpecViolation, CheckInstanceState, ExpandNodeUuidAndName

from ganeti.cmdlib.instance_storage import CreateDisks, \

  CheckNodesFreeDiskPerVG, WipeDisks, WipeOrCleanupDisks, WaitForSync, \

    # instance name verification

    if self.op.name_check:

      # used in CheckPrereq for ip ping check

    else:

      self.check_ip = None

    # this is just a preventive check, but someone might still add this

    # instance in the meantime, and creation will fail at lock-add time

      raise errors.OpPrereqError("Instance '%s' is already in the cluster" %

                                 self.op.instance_name, errors.ECODE_EXISTS)

    else:

      network_port = None

    # This is ugly but we got a chicken-egg problem here

    # We can only take the group disk parameters, as the instance

    # has no disks yet (we are generating them right here).

    nodegroup = self.cfg.GetNodeGroup(self.pnode.group)

    disks = GenerateDiskTemplate(self,

                                 self.op.disk_template,

                                 self.secondaries,

                                 self.disks,

                                 self.instance_file_storage_dir,

                                 feedback_fn,

                                 self.cfg.GetGroupDiskParams(nodegroup))

                            primary_node=self.pnode.uuid,

                            nics=self.nics, disks=disks,

                            disk_template=self.op.disk_template,

    if disk_abort:

      RemoveDisks(self, iobj)

      # Make sure the instance lock gets removed

      self.remove_locks[locking.LEVEL_INSTANCE] = iobj.name

      raise errors.OpExecError("There are some degraded disks for"

    This checks that the instance is in the cluster and is not running.

    """

    assert instance is not None

    CheckNodeOnline(self, instance.primary_node)

    CheckInstanceState(self, instance, INSTANCE_NOT_RUNNING,

                                   (hostname.ip, new_name),

                                   errors.ECODE_NOTUNIQUE)

      raise errors.OpPrereqError("Instance '%s' is already in the cluster" %

                                 new_name, errors.ECODE_EXISTS)

                               self.instance.disks[0].logical_id[1])

      rename_file_storage = True

    # Change the instance lock. This is definitely safe while we hold the BGL.

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

    assert self.REQ_BGL

    self.glm.add(locking.LEVEL_INSTANCE, self.op.new_name)

    # re-read the instance from the configuration after rename

    if rename_file_storage:

      new_file_storage_dir = os.path.dirname(

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

      CreateDisks(self, self.instance, target_node_uuid=target_node.uuid)

    except errors.OpExecError:

      self.LogWarning("Device creation failed")

      raise

    cluster_name = self.cfg.GetClusterInfo().cluster_name

      try:

        RemoveDisks(self, self.instance, target_node_uuid=target_node.uuid)

      finally:

        raise errors.OpExecError("Errors during disk copy: %s" %

                                 (",".join(errs),))

      # Acquire locks for the instance's nodegroups optimistically. Needs

      # to be verified in CheckPrereq

      self.needed_locks[locking.LEVEL_NODEGROUP] = \

    elif level == locking.LEVEL_NODE:

      self._LockInstancesNodes()

      if self.op.disk_template and self.op.remote_node:

    """

    assert self.op.instance_name in self.owned_locks(locking.LEVEL_INSTANCE)

    self.cluster = self.cfg.GetClusterInfo()

    assert self.instance is not None, \

                  constants.IDISK_NAME: d.name}

                 for d in self.instance.disks]

    new_disks = GenerateDiskTemplate(self, self.op.disk_template,

                                     [snode_uuid], disk_info, None, None, 0,

                                     feedback_fn, self.diskparams)

    anno_disks = rpc.AnnotateDiskParams(constants.DT_DRBD8, new_disks,

    disk = \

      GenerateDiskTemplate(self, self.instance.disk_template,

                           self.instance.secondary_nodes, [params], file_path,

                           file_driver, idx, self.Log, self.diskparams)[0]

      try:

        self._DISK_CONVERSIONS[mode](self, feedback_fn)

      except:

        raise

      result.append(("disk_template", self.op.disk_template))

      pass

    elif self.op.offline:

      # Mark instance as offline

      result.append(("admin_state", constants.ADMINST_OFFLINE))

    else:

      # Mark instance as online, but stopped

      result.append(("admin_state", constants.ADMINST_DOWN))

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

        # Lock all groups used by instance optimistically; this requires going

        # via the node before it's locked, requiring verification later on

        lock_groups.update(instance_groups)

      else:

        # No target groups, need to lock all of them

        # Lock all nodes in all potential target groups

        lock_groups = (frozenset(self.owned_locks(locking.LEVEL_NODEGROUP)) -

        member_nodes = [node_uuid

                        for group in lock_groups

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

        self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET

  def CheckPrereq(self):

    owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))

    owned_nodes = frozenset(self.owned_locks(locking.LEVEL_NODE))

    assert (self.req_target_uuids is None or

            owned_groups.issuperset(self.req_target_uuids))

    # Get instance information

    # Check if node groups for locked instance are still correct

    assert owned_nodes.issuperset(self.instance.all_nodes), \

      ("Instance %s's nodes changed while we kept the lock" %

       self.op.instance_name)

                                          owned_groups)

    if self.req_target_uuids:

from ganeti.masterd import iallocator

from ganeti import utils

from ganeti.cmdlib.base import LogicalUnit, Tasklet

  CheckIAllocatorOrNode, ExpandNodeUuidAndName

from ganeti.cmdlib.instance_storage import CheckDiskConsistency, \

  ExpandCheckDisks, ShutdownInstanceDisks, AssembleInstanceDisks

  if level == locking.LEVEL_NODE_ALLOC:

    assert lu.op.instance_name in lu.owned_locks(locking.LEVEL_INSTANCE)

    # Node locks are already declared here rather than at LEVEL_NODE as we need

    # the instance object anyway to declare the node allocation lock.

    _ExpandNamesForMigration(self)

    self._migrater = \

                        self.op.shutdown_timeout, self.op.ignore_ipolicy)

    self.tasklets = [self._migrater]

    _ExpandNamesForMigration(self)

    self._migrater = \

                        self.op.allow_runtime_changes,

                        constants.DEFAULT_SHUTDOWN_TIMEOUT,

                        self.op.ignore_ipolicy)

  _MIGRATION_POLL_INTERVAL = 1      # seconds

  _MIGRATION_FEEDBACK_INTERVAL = 10 # seconds

    """Initializes this class.

    """

    Tasklet.__init__(self, lu)

    # Parameters

    self.instance_name = instance_name

    self.cleanup = cleanup

    self.live = False # will be overridden later

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None

    cluster = self.cfg.GetClusterInfo()

    # FIXME: add a self.ignore_ipolicy option

    req = iallocator.IAReqRelocate(

          relocate_from_node_uuids=[self.instance.primary_node])

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

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    """

    if not self.op.no_remember:

    if self.primary_offline:

      assert self.op.ignore_offline_nodes

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    # If the instance is offline we shouldn't mark it as down, as that

    # resets the offline flag.

    if not self.op.no_remember and self.instance.admin_state in INSTANCE_ONLINE:

    if self.primary_offline:

      assert self.op.ignore_offline_nodes

    This checks that the instance is in the cluster and is not running.

    """

    assert instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    CheckNodeOnline(self, instance.primary_node, "Instance primary node"

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    CheckInstanceState(self, self.instance, INSTANCE_ONLINE)

        raise errors.OpExecError("Could not start instance for"

                                 " full reboot: %s" % msg)

def GetInstanceConsole(cluster, instance, primary_node):

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    CheckNodeOnline(self, self.instance.primary_node)

    lu.share_locks = ShareAll()

    if self.names:

    else:

      self.wanted = locking.ALL_SET

        lu.needed_locks[locking.LEVEL_NODEGROUP] = \

          set(group_uuid

              for instance_name in lu.owned_locks(locking.LEVEL_INSTANCE)

      elif level == locking.LEVEL_NODE:

        lu._LockInstancesNodes() # pylint: disable=W0212

        lu.needed_locks[locking.LEVEL_NETWORK] = \

          frozenset(net_uuid