Synnefo » snf-ganeti » ganeti-local

    """Check prerequisites.

    """

    assert self.instance is not None, \

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

    CheckNodeOnline(self, self.instance.primary_node)

    """Prepares an instance for an export.

    """

    if self.op.mode == constants.EXPORT_MODE_REMOTE:

      salt = utils.GenerateSecret(8)

      feedback_fn("Generating X509 certificate on %s" %

                                              constants.RIE_CERT_VALIDITY)

      result.Raise("Can't create X509 key and certificate on %s" %

                   self.cfg.GetNodeName(result.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)

      if len(self.op.target_node) != len(self.instance.disks):

        raise errors.OpPrereqError(("Received destination information for %s"

                                    " disks, but instance %s has %s disks") %

                                    len(self.instance.disks)),

                                   errors.ECODE_INVAL)

    """

    assert self.op.mode in constants.EXPORT_MODES

    if self.op.shutdown:

      # shutdown the instance, but not the disks

                                               self.op.shutdown_timeout,

                                               self.op.reason)

      # TODO: Maybe ignore failures if ignore_remove_failures is set

      result.Raise("Could not shutdown instance %s on"

                                 self.cfg.GetNodeName(src_node_uuid)))

    # set the disks ID correctly since call_instance_start needs the

    # correct drbd minor to create the symlinks

      self.cfg.SetDiskID(disk, src_node_uuid)

    if activate_disks:

      # Activate the instance disks if we'exporting a stopped instance

    try:

      helper = masterd.instance.ExportInstanceHelper(self, feedback_fn,

      helper.CreateSnapshots()

      try:

        if (self.op.shutdown and

            not self.op.remove_instance):

          assert not activate_disks

          result = self.rpc.call_instance_start(src_node_uuid,

          msg = result.fail_msg

          if msg:

            feedback_fn("Failed to start instance: %s" % msg)

            raise errors.OpExecError("Could not start instance: %s" % msg)

        if self.op.mode == constants.EXPORT_MODE_LOCAL:

        helper.Cleanup()

      # Check for backwards compatibility

      assert compat.all(isinstance(i, bool) for i in dresults), \

             "Not all results are boolean: %r" % dresults

    finally:

      if activate_disks:

    if not (compat.all(dresults) and fin_resu):

      failures = []

    # Remove instance if requested

    if self.op.remove_instance:

                     self.op.ignore_remove_failures)

    if self.op.mode == constants.EXPORT_MODE_LOCAL:

         reasonable values in the respose)

    """

    # main result, nresult should be a non-empty dict

    test = not nresult or not isinstance(nresult, dict)

                  "unable to verify node: no data returned")

    if test:

      return False

    test = not (remote_version and

                isinstance(remote_version, (list, tuple)) and

                len(remote_version) == 2)

    if test:

      return False

    test = local_version != remote_version[0]

    if test:

      return False

    # full package version

    self._ErrorIf(constants.RELEASE_VERSION != remote_version[1],

                  "software version mismatch: master %s, node %s",

                  constants.RELEASE_VERSION, remote_version[1],

                  code=self.ETYPE_WARNING)

    if ninfo.vm_capable and isinstance(hyp_result, dict):

      for hv_name, hv_result in hyp_result.iteritems():

        test = hv_result is not None

    hvp_result = nresult.get(constants.NV_HVPARAMS, None)

    if ninfo.vm_capable and isinstance(hvp_result, list):

      for item, hv_name, hv_result in hvp_result:

    test = nresult.get(constants.NV_NODESETUP,

                       ["Missing NODESETUP results"])

    return True

    @param nvinfo_endtime: the end time of the RPC call

    """

    ntime = nresult.get(constants.NV_TIME, None)

    try:

      ntime_merged = utils.MergeTime(ntime)

    except (ValueError, TypeError):

      return

    if ntime_merged < (nvinfo_starttime - constants.NODE_MAX_CLOCK_SKEW):

    else:

      ntime_diff = None

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

    """Check the node LVM results and update info for cross-node checks.

    if vg_name is None:

      return

    # checks vg existence and size > 20G

    vglist = nresult.get(constants.NV_VGLIST, None)

    test = not vglist

    if not test:

      vgstatus = utils.CheckVolumeGroupSize(vglist, vg_name,

                                            constants.MIN_VG_SIZE)

    # Check PVs

    (errmsgs, pvminmax) = CheckNodePVs(nresult, self._exclusive_storage)

    for em in errmsgs:

    if pvminmax is not None:

      (nimg.pv_min, nimg.pv_max) = pvminmax

    if not bridges:

      return

    missing = nresult.get(constants.NV_BRIDGES, None)

    test = not isinstance(missing, list)

    if not test:

  def _VerifyNodeUserScripts(self, ninfo, nresult):

    """Check the results of user scripts presence and executability on the node

    @param nresult: the remote results for the node

    """

    test = not constants.NV_USERSCRIPTS in nresult

                  "did not return user scripts information")

    broken_scripts = nresult.get(constants.NV_USERSCRIPTS, None)

    if not test:

                    "user scripts not present or not executable: %s" %

                    utils.CommaJoin(sorted(broken_scripts)))

    @param nresult: the remote results for the node

    """

    test = constants.NV_NODELIST not in nresult

    if not test:

      if nresult[constants.NV_NODELIST]:

        for a_node, a_msg in nresult[constants.NV_NODELIST].items():

    test = constants.NV_NODENETTEST not in nresult

    if not test:

      if nresult[constants.NV_NODENETTEST]:

        nlist = utils.NiceSort(nresult[constants.NV_NODENETTEST].keys())

        for anode in nlist:

    test = constants.NV_MASTERIP not in nresult

    if not test:

      if not nresult[constants.NV_MASTERIP]:

        if ninfo.uuid == self.master_node:

          msg = "the master node cannot reach the master IP (not configured?)"

        else:

          msg = "cannot reach the master IP"

  def _VerifyInstance(self, instance, inst_config, node_image,

                      diskstatus):

    state.

    """

    pnode = inst_config.primary_node

    pnode_img = node_image[pnode]

    groupinfo = self.cfg.GetAllNodeGroupsInfo()

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

                                                            self.group_info)

    err = ComputeIPolicyInstanceViolation(ipolicy, inst_config, self.cfg)

    for node in node_vol_should:

      n_img = node_image[node]

        continue

      for volume in node_vol_should[node]:

        test = volume not in n_img.volumes

    if inst_config.admin_state == constants.ADMINST_UP:

      test = instance not in pnode_img.instances and not pnode_img.offline

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

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

      # node here

      snode = node_image[nname]

      bad_snode = snode.ghost or snode.offline

    es_flags = rpc.GetExclusiveStorageForNodes(self.cfg,

                                               inst_config.all_nodes)

                    inst_config.disk_template,

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

      for (idx, disk) in enumerate(inst_config.disks):

    if inst_config.disk_template in constants.DTS_INT_MIRROR:

      instance_nodes = utils.NiceSort(inst_config.all_nodes)

    inst_nodes_offline = []

    for snode in inst_config.secondary_nodes:

      s_img = node_image[snode]

      if s_img.offline:

        inst_nodes_offline.append(snode)

    # warn that the instance lives on offline nodes

    # ... or ghost/non-vm_capable nodes

    for node in inst_config.all_nodes:

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

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

        L{ganeti.config.ConfigWriter.ComputeDRBDMap}

    """

    if drbd_helper:

      helper_result = nresult.get(constants.NV_DRBDHELPER, None)

      test = (helper_result is None)

      if helper_result:

        status, payload = helper_result

        test = not status

        test = status and (payload != drbd_helper)

    # compute the DRBD minors

    node_drbd = {}

    for minor, instance in drbd_map[ninfo.uuid].items():

      test = instance not in instanceinfo

        # ghost instance should not be running, but otherwise we

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

        # unallocated minor in use)

    # and now check them

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

    test = not isinstance(used_minors, (tuple, list))

    if test:

      # we cannot check drbd status

      return

    for minor, (iname, must_exist) in node_drbd.items():

      test = minor not in used_minors and must_exist

    for minor in used_minors:

      test = minor not in node_drbd

  def _UpdateNodeOS(self, ninfo, nresult, nimg):

    """Builds the node OS structures.

    @param nimg: the node image object

    """

    remote_os = nresult.get(constants.NV_OSLIST, None)

    test = (not isinstance(remote_os, list) or

            not compat.all(isinstance(v, list) and len(v) == 7

                           for v in remote_os))

    nimg.os_fail = test

    @param base: the 'template' node we match against (e.g. from the master)

    """

    assert not nimg.os_fail, "Entered _VerifyNodeOS with failed OS rpc?"

    beautify_params = lambda l: ["%s: %s" % (k, v) for (k, v) in l]

    for os_name, os_data in nimg.oslist.items():

      assert os_data, "Empty OS status for OS %s?!" % os_name

      f_path, f_status, f_diag, f_var, f_param, f_api = os_data[0]

      # comparisons with the 'base' image

      test = os_name not in base.oslist

      if test:

        continue

      assert base.oslist[os_name], "Base node has empty OS status?"

                         ("variants list", f_var, b_var),

                         ("parameters", beautify_params(f_param),

                          beautify_params(b_param))]:

    # check any missing OSes

    missing = set(base.oslist.keys()).difference(nimg.oslist.keys())

  def _VerifyFileStoragePaths(self, ninfo, nresult, is_master):

    """Verifies paths in L{pathutils.FILE_STORAGE_PATHS_FILE}.

    @param is_master: Whether node is the master node

    """

    if (is_master and

        (constants.ENABLE_FILE_STORAGE or

         constants.ENABLE_SHARED_FILE_STORAGE)):

        fspaths = nresult[constants.NV_FILE_STORAGE_PATHS]

      except KeyError:

        # This should never happen

                      "Node did not return forbidden file storage paths")

      else:

                      "Found forbidden file storage paths: %s",

                      utils.CommaJoin(fspaths))

    else:

      self._ErrorIf(constants.NV_FILE_STORAGE_PATHS in nresult,

                    "Node should not have returned forbidden file storage"

                    " paths")

    @param nresult: the remote results for the node

    """

    # We just have to verify the paths on master and/or master candidates

    # as the oob helper is invoked on the master

    if ((ninfo.master_candidate or ninfo.master_capable) and

        constants.NV_OOB_PATHS in nresult):

      for path_result in nresult[constants.NV_OOB_PATHS]:

        self._ErrorIf(path_result, constants.CV_ENODEOOBPATH,

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

    """Verifies and updates the node volume data.

    @param vg_name: the configured VG name

    """

    nimg.lvm_fail = True

    lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")

    if vg_name is None:

      pass

    elif isinstance(lvdata, basestring):

    elif not isinstance(lvdata, dict):

    else:

      nimg.volumes = lvdata

      nimg.lvm_fail = False

    @param vg_name: the configured VG name

    """

    # try to read free memory (from the hypervisor)

    hv_info = nresult.get(constants.NV_HVINFO, None)

    test = not isinstance(hv_info, dict) or "memory_free" not in hv_info

    if not test:

      try:

        nimg.mfree = int(hv_info["memory_free"])

      except (ValueError, TypeError):

    # FIXME: devise a free space model for file based instances as well

    if vg_name is not None:

      test = (constants.NV_VGLIST not in nresult or

              vg_name not in nresult[constants.NV_VGLIST])

      if not test:

        try:

          nimg.dfree = int(nresult[constants.NV_VGLIST][vg_name])

        except (ValueError, TypeError):

  def _CollectDiskInfo(self, node_uuids, node_image, instanceinfo):

    """Gets per-disk status information for all instances.

      return True

    self.bad = False

    verbose = self.op.verbose

    self._feedback_fn = feedback_fn

        feedback_fn("* Verifying node %s (%s)" % (node_i.name, ntype))

      msg = all_nvinfo[node_i.uuid].fail_msg

      if msg:

        nimg.rpc_fail = True

        continue

        for inst in non_primary_inst:

          test = inst in self.all_inst_info

    self._VerifyGroupDRBDVersion(all_nvinfo)

    self._VerifyGroupLVM(node_image, vg_name)

  """

  hm = lu.proc.BuildHooksManager(lu)

  try:

  except Exception, err: # pylint: disable=W0703

    lu.LogWarning("Errors occurred running hooks on %s: %s",

                  node_name, err)

    """

    self.needed_locks = {}

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

    if self.op.iallocator:

      # TODO: Find a solution to not lock all nodes in the cluster, e.g. by

    """

    assert self.op.mode == constants.INSTANCE_IMPORT

      locked_nodes = self.owned_locks(locking.LEVEL_NODE)

      exp_list = self.rpc.call_export_list(locked_nodes)

      found = False

      for node in exp_list:

        if exp_list[node].fail_msg:

          continue

          found = True

          self.op.src_node = node

          break

      if not found:

        raise errors.OpPrereqError("No export found for relative path %s" %

    export_info = objects.SerializableConfigParser.Loads(str(result.payload))

    if not export_info.has_section(constants.INISECT_EXP):

    """Create and add the instance to the cluster.

    """

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

                self.owned_locks(locking.LEVEL_NODE)), \

      "Node locks differ from node resource locks"

    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,

        CreateDisks(self, iobj)

      except errors.OpExecError:

        self.LogWarning("Device creation failed")

        raise

    self.cfg.AddInstance(iobj, self.proc.GetECId())

            for idx, success in enumerate(result.payload):

              if not success:

                logging.warn("pause-sync of instance %s for disk %d failed",

          feedback_fn("* running the instance OS create scripts...")

          # FIXME: pass debug option from opcode to backend

            for idx, success in enumerate(result.payload):

              if not success:

                logging.warn("resume-sync of instance %s for disk %d failed",

          os_add_result.Raise("Could not add os for instance %s"

      else:

        if self.op.mode == constants.INSTANCE_IMPORT:

                                                  iobj, transfers)

          if not compat.all(import_result):

            self.LogWarning("Some disks for instance %s on node %s were not"

          rename_from = self._old_instance_name

            # TODO: Should the instance still be started, even if some disks

            # failed to import (valid for local imports, too)?

            self.LogWarning("Some disks for instance %s on node %s were not"

          rename_from = self.source_instance_name

                                       % self.op.mode)

        # Run rename script on newly imported instance

        result = self.rpc.call_instance_run_rename(self.pnode.uuid, iobj,

                                                   rename_from,

                                                   self.op.debug_level)

        result.Warn("Failed to run rename script for %s on node %s" %

    assert not self.owned_locks(locking.LEVEL_NODE_RES)

    if self.op.start:

      iobj.admin_state = constants.ADMINST_UP

      self.cfg.Update(iobj, feedback_fn)

      feedback_fn("* starting instance...")

      result = self.rpc.call_instance_start(self.pnode.uuid, (iobj, None, None),

                                            False, self.op.reason)

    """Rename the instance.

    """

    rename_file_storage = False

      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:

                                                     old_file_storage_dir,

                                                     new_file_storage_dir)

      result.Raise("Could not rename on node %s directory '%s' to '%s'"

                   " (but the instance has been renamed in Ganeti)" %

                    old_file_storage_dir, new_file_storage_dir))

    # update info on disks

        self.cfg.SetDiskID(disk, node_uuid)

        result = self.rpc.call_blockdev_setinfo(node_uuid, disk, info)

        result.Warn("Error setting info on node %s for disk %s" %

                    (self.cfg.GetNodeName(node_uuid), idx), self.LogWarning)

    try:

      result.Warn("Could not run OS rename script for instance %s on node %s"

                  " (but the instance has been renamed in Ganeti)" %

                  self.LogWarning)

    finally:

class LUInstanceRemove(LogicalUnit):

    """Remove the instance.

    """

                                             self.op.shutdown_timeout,

                                             self.op.reason)

    if self.op.ignore_failures:

      result.Warn("Warning: can't shutdown instance", feedback_fn)

    else:

      result.Raise("Could not shutdown instance %s on node %s" %

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

            self.owned_locks(locking.LEVEL_NODE_RES))

                self.owned_locks(locking.LEVEL_NODE)), \

      "Not owning correct locks"

class LUInstanceMove(LogicalUnit):

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

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

      raise errors.OpPrereqError("Disk template %s not suitable for copying" %

    target_node = self.cfg.GetNodeInfo(self.op.target_node_uuid)

    assert target_node is not None, \

      "Cannot retrieve locked node %s" % self.op.target_node

    self.target_node_uuid = target_node.uuid

      raise errors.OpPrereqError("Instance %s is already on the node %s" %

                                 errors.ECODE_STATE)

      if dsk.dev_type not in (constants.LD_LV, constants.LD_FILE):

        raise errors.OpPrereqError("Instance disk %d has a complex layout,"

                                   " cannot copy" % idx, errors.ECODE_STATE)

    cluster = self.cfg.GetClusterInfo()

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

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

                           ignore=self.op.ignore_ipolicy)

      # check memory requirements on the secondary node

      CheckNodeFreeMemory(

          self, target_node.uuid, "failing over instance %s" %

    else:

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

                   " instance will not be started")

    # check bridge existance

  def Exec(self, feedback_fn):

    """Move an instance.

    the data over (slow) and starting it on the new node.

    """

    target_node = self.cfg.GetNodeInfo(self.target_node_uuid)

    self.LogInfo("Shutting down instance %s on source node %s",

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

            self.owned_locks(locking.LEVEL_NODE_RES))

                                             self.op.shutdown_timeout,

                                             self.op.reason)

    if self.op.ignore_consistency:

      result.Warn("Could not shutdown instance %s on node %s. Proceeding"

                  " anyway. Please make sure node %s is down. Error details" %

                  self.LogWarning)

    else:

      result.Raise("Could not shutdown instance %s on node %s" %

    # create the target disks

    try:

    except errors.OpExecError:

      self.LogWarning("Device creation failed")

      raise

    cluster_name = self.cfg.GetClusterInfo().cluster_name

    errs = []

    # activate, get path, copy the data over

      self.LogInfo("Copying data for disk %d", idx)

      if result.fail_msg:

        self.LogWarning("Can't assemble newly created disk %d: %s",

                        idx, result.fail_msg)

        errs.append(result.fail_msg)

        break

      dev_path = result.payload

                                             target_node.name, dev_path,

                                             cluster_name)

      if result.fail_msg:

    if errs:

      self.LogWarning("Some disks failed to copy, aborting")

      try:

      finally:

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

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

    self.LogInfo("Removing the disks on the original node")

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

      self.LogInfo("Starting instance %s on node %s",

                                          ignore_secondaries=True)

      if not disks_ok:

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

      result = self.rpc.call_instance_start(target_node.uuid,

                                            self.op.reason)

      msg = result.fail_msg

      if msg:

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

class LUInstanceMultiAlloc(NoHooksLU):

  def _PreCheckDiskTemplate(self, pnode_info):

    """CheckPrereq checks related to a new disk template."""

    # Arguments are passed to avoid configuration lookups

      raise errors.OpPrereqError("Instance already has disk template %s" %

        self.op.disk_template) not in self._DISK_CONVERSIONS:

      raise errors.OpPrereqError("Unsupported disk template conversion from"

                                                self.op.disk_template),

                                 errors.ECODE_INVAL)

                       msg="cannot change disk template")

    if self.op.disk_template in constants.DTS_INT_MIRROR:

      if self.op.remote_node_uuid == pnode_uuid:

      CheckNodeOnline(self, self.op.remote_node_uuid)

      CheckNodeNotDrained(self, self.op.remote_node_uuid)

      # FIXME: here we assume that the old instance type is DT_PLAIN

      disks = [{constants.IDISK_SIZE: d.size,

                constants.IDISK_VG: d.logical_id[0]}

      required = ComputeDiskSizePerVG(self.op.disk_template, disks)

      CheckNodesFreeDiskPerVG(self, [self.op.remote_node_uuid], required)

      snode_info = self.cfg.GetNodeInfo(self.op.remote_node_uuid)

      snode_group = self.cfg.GetNodeGroup(snode_info.group)

                                                              snode_group)

                             ignore=self.op.ignore_ipolicy)

      if pnode_info.group != snode_info.group:

        self.LogWarning("The primary and secondary nodes are in two"

      has_es = lambda n: IsExclusiveStorageEnabledNode(self.cfg, n)

      if compat.any(map(has_es, nodes)):

        errmsg = ("Cannot convert disk template from %s to %s when exclusive"

                                           self.op.disk_template))

        raise errors.OpPrereqError(errmsg, errors.ECODE_STATE)

    @param ispec: instance specs to be updated with the new disks

    """

    excl_stor = compat.any(

      )

    # Check disk modifications. This is done here and not in CheckArguments

    # (as with NICs), because we need to know the instance's disk template

    ver_fn = lambda op, par: self._VerifyDiskModification(op, par, excl_stor)

      self._CheckMods("disk", self.op.disks, {}, ver_fn)

    else:

      self._CheckMods("disk", self.op.disks, constants.IDISK_PARAMS_TYPES,

    self.diskmod = _PrepareContainerMods(self.op.disks, None)

    # Check the validity of the `provider' parameter

      for mod in self.diskmod:

        ext_provider = mod[2].get(constants.IDISK_PROVIDER, None)

        if mod[0] == constants.DDM_ADD:

                                      constants.DT_EXT),

                                     errors.ECODE_INVAL)

      raise errors.OpPrereqError("Disk operations not supported for"

                                 " diskless instances", errors.ECODE_INVAL)

      disk.name = params.get(constants.IDISK_NAME, None)

    # Verify disk changes (operating on a copy)

    _ApplyContainerMods("disk", disks, None, self.diskmod, None,

                        _PrepareDiskMod, None)

    utils.ValidateDeviceNames("disk", disks)

      raise errors.OpPrereqError("Instance has too many disks (%d), cannot add"

                                 " more" % constants.MAX_DISKS,

                                 errors.ECODE_STATE)

    disk_sizes.extend(params["size"] for (op, idx, params, private) in

                      self.diskmod if op == constants.DDM_ADD)

    ispec[constants.ISPEC_DISK_COUNT] = len(disk_sizes)

    ispec[constants.ISPEC_DISK_SIZE] = disk_sizes

    if self.op.offline is not None and self.op.offline:

                         msg="can't change to offline")

  def CheckPrereq(self):

    """

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

    assert self.instance is not None, \

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

    self.warn = []

        not self.op.force):

      # verify that the instance is not up

      instance_info = self.rpc.call_instance_info(

      if instance_info.fail_msg:

        self.warn.append("Can't get instance runtime information: %s" %

                         instance_info.fail_msg)

                                   errors.ECODE_STATE)

    assert pnode_uuid in self.owned_locks(locking.LEVEL_NODE)

    pnode_info = self.cfg.GetNodeInfo(pnode_uuid)

    #_CheckInstanceNodeGroups(self.cfg, self.op.instance_name, owned_groups)

    # OS change

    if self.op.os_name and not self.op.force:

                     self.op.force_variant)

      instance_os = self.op.os_name

    else:

    assert not (self.op.disk_template and self.op.disks), \

      "Can't modify disk template and apply disk changes at the same time"

    # hvparams processing

    if self.op.hvparams:

      utils.ForceDictType(i_hvdict, constants.HVS_PARAMETER_TYPES)

      # local check