Synnefo » snf-ganeti

      msg = "Failure: can't resolve hostname '%s'"

    obuf.write(msg % err.args[0])

  elif isinstance(err, errors.OpPrereqError):

  elif isinstance(err, errors.OpExecError):

    obuf.write("Failure: command execution error:\n%s" % msg)

  elif isinstance(err, errors.TagError):

      attr_val = getattr(op, attr_name, None)

      if attr_val is None:

        raise errors.OpPrereqError("Required parameter '%s' missing" %

    self.CheckArguments()

    expanded_name = self.cfg.ExpandInstanceName(self.op.instance_name)

    if expanded_name is None:

      raise errors.OpPrereqError("Instance '%s' not known" %

    self.needed_locks[locking.LEVEL_INSTANCE] = expanded_name

    self.op.instance_name = expanded_name

  """

  if not isinstance(nodes, list):

  if not nodes:

    raise errors.ProgrammerError("_GetWantedNodes should only be called with a"

  for name in nodes:

    node = lu.cfg.ExpandNodeName(name)

    if node is None:

    wanted.append(node)

  return utils.NiceSort(wanted)

  """

  if not isinstance(instances, list):

  if instances:

    wanted = []

    for name in instances:

      instance = lu.cfg.ExpandInstanceName(name)

      if instance is None:

      wanted.append(instance)

  else:

  delta = f.NonMatching(selected)

  if delta:

    raise errors.OpPrereqError("Unknown output fields selected: %s"

def _CheckBooleanOpField(op, name):

  val = getattr(op, name, None)

  if not (val is None or isinstance(val, bool)):

    raise errors.OpPrereqError("Invalid boolean parameter '%s' (%s)" %

  setattr(op, name, val)

  """

  if lu.cfg.GetNodeInfo(node).offline:

def _CheckNodeNotDrained(lu, node):

  """

  if lu.cfg.GetNodeInfo(node).drained:

def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,

  try:

    variant = name.split("+", 1)[1]

  except IndexError:

  if variant not in os_obj.supported_variants:

def _GetNodeInstancesInner(cfg, fn):

    nodelist = self.cfg.GetNodeList()

    if len(nodelist) != 1 or nodelist[0] != master:

      raise errors.OpPrereqError("There are still %d node(s) in"

    instancelist = self.cfg.GetInstanceList()

    if instancelist:

      raise errors.OpPrereqError("There are still %d instance(s) in"

  def Exec(self, feedback_fn):

    """Destroys the cluster.

    """

    self.skip_set = frozenset(self.op.skip_checks)

    if not constants.VERIFY_OPTIONAL_CHECKS.issuperset(self.skip_set):

  def BuildHooksEnv(self):

    """Build hooks env.

  def ExpandNames(self):

    if not isinstance(self.op.instances, list):

    if self.op.instances:

      self.wanted_names = []

      for name in self.op.instances:

        full_name = self.cfg.ExpandInstanceName(name)

        if full_name is None:

        self.wanted_names.append(full_name)

      self.needed_locks = {

        locking.LEVEL_NODE: [],

    old_ip = self.cfg.GetMasterIP()

    if new_name == old_name and new_ip == old_ip:

      raise errors.OpPrereqError("Neither the name nor the IP address of the"

    if new_ip != old_ip:

      if utils.TcpPing(new_ip, constants.DEFAULT_NODED_PORT):

        raise errors.OpPrereqError("The given cluster IP address (%s) is"

                                   " reachable on the network. Aborting." %

    self.op.name = new_name

        self.op.candidate_pool_size = int(self.op.candidate_pool_size)

      except (ValueError, TypeError), err:

        raise errors.OpPrereqError("Invalid candidate_pool_size value: %s" %

      if self.op.candidate_pool_size < 1:

  def ExpandNames(self):

    # FIXME: in the future maybe other cluster params won't require checking on

        for disk in inst.disks:

          if _RecursiveCheckIfLVMBased(disk):

            raise errors.OpPrereqError("Cannot disable lvm storage while"

    node_list = self.acquired_locks[locking.LEVEL_NODE]

                                              constants.MIN_VG_SIZE)

        if vgstatus:

          raise errors.OpPrereqError("Error on node '%s': %s" %

    self.cluster = cluster = self.cfg.GetClusterInfo()

    # validate params changes

    self.new_hvparams = objects.FillDict(cluster.hvparams, {})

    if self.op.hvparams:

      if not isinstance(self.op.hvparams, dict):

      for hv_name, hv_dict in self.op.hvparams.items():

        if hv_name not in self.new_hvparams:

          self.new_hvparams[hv_name] = hv_dict

      self.hv_list = self.op.enabled_hypervisors

      if not self.hv_list:

        raise errors.OpPrereqError("Enabled hypervisors list must contain at"

      invalid_hvs = set(self.hv_list) - constants.HYPER_TYPES

      if invalid_hvs:

        raise errors.OpPrereqError("Enabled hypervisors contains invalid"

    else:

      self.hv_list = cluster.enabled_hypervisors

  def ExpandNames(self):

    if self.op.names:

    _CheckOutputFields(static=self._FIELDS_STATIC,

                       dynamic=self._FIELDS_DYNAMIC,

    """

    node = self.cfg.GetNodeInfo(self.cfg.ExpandNodeName(self.op.node_name))

    if node is None:

    instance_list = self.cfg.GetInstanceList()

    masternode = self.cfg.GetMasterNode()

    if node.name == masternode:

      raise errors.OpPrereqError("Node is the master node,"

    for instance_name in instance_list:

      instance = self.cfg.GetInstanceInfo(instance_name)

      if node.name in instance.all_nodes:

        raise errors.OpPrereqError("Instance %s is still running on the node,"

    self.op.node_name = node.name

    self.node = node

    storage_type = self.op.storage_type

    if storage_type not in constants.VALID_STORAGE_TYPES:

    _CheckOutputFields(static=self._FIELDS_STATIC,

                       dynamic=utils.FieldSet(*constants.VALID_STORAGE_FIELDS),

  def CheckArguments(self):

    node_name = self.cfg.ExpandNodeName(self.op.node_name)

    if node_name is None:

    self.op.node_name = node_name

    storage_type = self.op.storage_type

    if storage_type not in constants.VALID_STORAGE_TYPES:

  def ExpandNames(self):

    self.needed_locks = {

      modifiable = constants.MODIFIABLE_STORAGE_FIELDS[storage_type]

    except KeyError:

      raise errors.OpPrereqError("Storage units of type '%s' can not be"

    diff = set(self.op.changes.keys()) - modifiable

    if diff:

      raise errors.OpPrereqError("The following fields can not be modified for"

                                 " storage units of type '%s': %r" %

  def Exec(self, feedback_fn):

    """Computes the list of nodes and their attributes.

    if secondary_ip is None:

      secondary_ip = primary_ip

    if not utils.IsValidIP(secondary_ip):

    self.op.secondary_ip = secondary_ip

    node_list = cfg.GetNodeList()

    if not self.op.readd and node in node_list:

      raise errors.OpPrereqError("Node %s is already in the configuration" %

    elif self.op.readd and node not in node_list:

    for existing_node_name in node_list:

      existing_node = cfg.GetNodeInfo(existing_node_name)

        if (existing_node.primary_ip != primary_ip or

            existing_node.secondary_ip != secondary_ip):

          raise errors.OpPrereqError("Readded node doesn't have the same IP"

        continue

      if (existing_node.primary_ip == primary_ip or

          existing_node.primary_ip == secondary_ip or

          existing_node.secondary_ip == secondary_ip):

        raise errors.OpPrereqError("New node ip address(es) conflict with"

    # check that the type of the node (single versus dual homed) is the

    # same as for the master

    if master_singlehomed != newbie_singlehomed:

      if master_singlehomed:

        raise errors.OpPrereqError("The master has no private ip but the"

      else:

        raise errors.OpPrereqError("The master has a private ip but the"

    # checks reachability

    if not utils.TcpPing(primary_ip, constants.DEFAULT_NODED_PORT):

    if not newbie_singlehomed:

      # check reachability from my secondary ip to newbie's secondary ip

      if not utils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,

                           source=myself.secondary_ip):

        raise errors.OpPrereqError("Node secondary ip not reachable by TCP"

    if self.op.readd:

      exceptions = [node]

  def CheckArguments(self):

    node_name = self.cfg.ExpandNodeName(self.op.node_name)

    if node_name is None:

    self.op.node_name = node_name

    _CheckBooleanOpField(self.op, 'master_candidate')

    _CheckBooleanOpField(self.op, 'offline')

    _CheckBooleanOpField(self.op, 'drained')

    all_mods = [self.op.offline, self.op.master_candidate, self.op.drained]

    if all_mods.count(None) == 3:

    if all_mods.count(True) > 1:

      raise errors.OpPrereqError("Can't set the node into more than one"

  def ExpandNames(self):

    self.needed_locks = {locking.LEVEL_NODE: self.op.node_name}

      # we can't change the master's node flags

      if self.op.node_name == self.cfg.GetMasterNode():

        raise errors.OpPrereqError("The master role can be changed"

    # Boolean value that tells us whether we're offlining or draining the node

    offline_or_drain = self.op.offline == True or self.op.drained == True

        if self.op.force and offline_or_drain and mc_should == mc_max:

          self.LogWarning(msg)

        else:

    if (self.op.master_candidate == True and

        ((node.offline and not self.op.offline == False) or

         (node.drained and not self.op.drained == False))):

      raise errors.OpPrereqError("Node '%s' is offline or drained, can't set"

    # If we're being deofflined/drained, we'll MC ourself if needed

    if (deoffline_or_drain and not offline_or_drain and not

  def CheckArguments(self):

    node_name = self.cfg.ExpandNodeName(self.op.node_name)

    if node_name is None:

    self.op.node_name = node_name

    if node_name == self.cfg.GetMasterNode() and not self.op.force:

      raise errors.OpPrereqError("The node is the master and the force"

  def ExpandNames(self):

    """Locking for PowercycleNode.

  free_mem = nodeinfo[node].payload.get('memory_free', None)

  if not isinstance(free_mem, int):

    raise errors.OpPrereqError("Can't compute free memory on node %s, result"

  if requested > free_mem:

    raise errors.OpPrereqError("Not enough memory on node %s for %s:"

                               " needed %s MiB, available %s MiB" %

class LUStartupInstance(LogicalUnit):

    if self.beparams:

      if not isinstance(self.beparams, dict):

        raise errors.OpPrereqError("Invalid beparams passed: %s, expected"

      # fill the beparams dict

      utils.ForceDictType(self.beparams, constants.BES_PARAMETER_TYPES)

      self.op.beparams = self.beparams

    if self.hvparams:

      if not isinstance(self.hvparams, dict):

        raise errors.OpPrereqError("Invalid hvparams passed: %s, expected"

      # check hypervisor parameter syntax (locally)

      cluster = self.cfg.GetClusterInfo()

    if instance.disk_template == constants.DT_DISKLESS:

      raise errors.OpPrereqError("Instance '%s' has no disks" %

    if instance.admin_up:

      raise errors.OpPrereqError("Instance '%s' is marked to be up" %

    remote_info = self.rpc.call_instance_info(instance.primary_node,

                                              instance.name,

                                              instance.hypervisor)

    if remote_info.payload:

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

                                 (self.op.instance_name,

    self.op.os_type = getattr(self.op, "os_type", None)

    self.op.force_variant = getattr(self.op, "force_variant", False)

        self.cfg.ExpandNodeName(instance.primary_node))

      if pnode is None:

        raise errors.OpPrereqError("Primary node '%s' is unknown" %

      result = self.rpc.call_os_get(pnode.name, self.op.os_type)

      result.Raise("OS '%s' not in supported OS list for primary node %s" %

                   (self.op.os_type, pnode.name), prereq=True)

    """

    if not isinstance(self.op.disks, list):

    for item in self.op.disks:

      if (not isinstance(item, int) or

          item < 0):

        raise errors.OpPrereqError("Invalid disk specification '%s'" %

  def ExpandNames(self):

    self._ExpandAndLockInstance()

    if instance.disk_template == constants.DT_DISKLESS:

      raise errors.OpPrereqError("Instance '%s' has no disks" %

    if instance.admin_up:

      raise errors.OpPrereqError("Instance '%s' is marked to be up" %

    remote_info = self.rpc.call_instance_info(instance.primary_node,

                                              instance.name,

                                              instance.hypervisor)

    if remote_info.payload:

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

                                 (self.op.instance_name,

    if not self.op.disks:

      self.op.disks = range(len(instance.disks))

    else:

      for idx in self.op.disks:

        if idx >= len(instance.disks):

    self.instance = instance

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

      raise errors.OpPrereqError("Instance '%s' not known" %

    _CheckNodeOnline(self, instance.primary_node)

    if instance.admin_up:

      raise errors.OpPrereqError("Instance '%s' is marked to be up" %

    remote_info = self.rpc.call_instance_info(instance.primary_node,

                                              instance.name,

                                              instance.hypervisor)

    if remote_info.payload:

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

                                 (self.op.instance_name,

    self.instance = instance

    # new name verification

    instance_list = self.cfg.GetInstanceList()

    if new_name in instance_list:

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

    if not getattr(self.op, "ignore_ip", False):

      if utils.TcpPing(name_info.ip, constants.DEFAULT_NODED_PORT):

        raise errors.OpPrereqError("IP %s of instance %s already in use" %

  def Exec(self, feedback_fn):

    bep = self.cfg.GetClusterInfo().FillBE(instance)

    if instance.disk_template not in constants.DTS_NET_MIRROR:

      raise errors.OpPrereqError("Instance's disk layout is not"

    secondary_nodes = instance.secondary_nodes

    if not secondary_nodes:

    target_node = self.cfg.ExpandNodeName(self.op.target_node)

    if target_node is None:

      raise errors.OpPrereqError("Node '%s' not known" %

    self.op.target_node = target_node

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

    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_APPEND

    if target_node == instance.primary_node:

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

    bep = self.cfg.GetClusterInfo().FillBE(instance)

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

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

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

    _CheckNodeOnline(self, target_node)

    _CheckNodeNotDrained(self, target_node)

  def ExpandNames(self):

    self.op.node_name = self.cfg.ExpandNodeName(self.op.node_name)

    if self.op.node_name is None:

    self.needed_locks = {

      locking.LEVEL_NODE: [self.op.node_name],

      self.cfg.ExpandInstanceName(self.instance_name))

    if instance is None:

      raise errors.OpPrereqError("Instance '%s' not known" %

    if instance.disk_template != constants.DT_DRBD8:

      raise errors.OpPrereqError("Instance's disk layout is not"

    secondary_nodes = instance.secondary_nodes

    if not secondary_nodes:

    """

    node_full = self.cfg.ExpandNodeName(node)

    if node_full is None:

    return node_full

  def ExpandNames(self):

    if self.op.mode not in (constants.INSTANCE_CREATE,

                            constants.INSTANCE_IMPORT):

      raise errors.OpPrereqError("Invalid instance creation mode '%s'" %

    # disk template and mirror node verification

    if self.op.disk_template not in constants.DISK_TEMPLATES:

    if self.op.hypervisor is None:

      self.op.hypervisor = self.cfg.GetHypervisorType()

    if self.op.hypervisor not in enabled_hvs:

      raise errors.OpPrereqError("Selected hypervisor (%s) not enabled in the"

                                 " cluster (%s)" % (self.op.hypervisor,

    # check hypervisor parameter syntax (locally)

    utils.ForceDictType(self.op.hvparams, constants.HVS_PARAMETER_TYPES)

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

    if instance_name in self.cfg.GetInstanceList():

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

    self.add_locks[locking.LEVEL_INSTANCE] = instance_name

      else:

        if not utils.IsValidIP(ip):

          raise errors.OpPrereqError("Given IP address '%s' doesn't look"

        nic_ip = ip

      # TODO: check the ip for uniqueness !!

      if nic_mode == constants.NIC_MODE_ROUTED and not nic_ip:

      # MAC address verification

      mac = nic.get("mac", constants.VALUE_AUTO)

      if mac not in (constants.VALUE_AUTO, constants.VALUE_GENERATE):

        if not utils.IsValidMac(mac.lower()):

          raise errors.OpPrereqError("Invalid MAC address specified: %s" %

        else:

          # or validate/reserve the current one

          if self.cfg.IsMacInUse(mac):

            raise errors.OpPrereqError("MAC address %s already in use"

      # bridge verification

      bridge = nic.get("bridge", None)

      link = nic.get("link", None)

      if bridge and link:

        raise errors.OpPrereqError("Cannot pass 'bridge' and 'link'"

      elif bridge and nic_mode == constants.NIC_MODE_ROUTED:

      elif bridge:

        link = bridge

      mode = disk.get("mode", constants.DISK_RDWR)

      if mode not in constants.DISK_ACCESS_SET:

        raise errors.OpPrereqError("Invalid disk access mode '%s'" %

      size = disk.get("size", None)

      if size is None:

      try:

        size = int(size)

      except ValueError:

      self.disks.append({"size": size, "mode": mode})

    # used in CheckPrereq for ip ping check

    if (self.op.file_driver and

        not self.op.file_driver in constants.FILE_DRIVER):

      raise errors.OpPrereqError("Invalid file driver name '%s'" %

    if self.op.file_storage_dir and os.path.isabs(self.op.file_storage_dir):

    ### Node/iallocator related checks

    if [self.op.iallocator, self.op.pnode].count(None) != 1:

      raise errors.OpPrereqError("One and only one of iallocator and primary"

    if self.op.iallocator:

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

        self.op.src_node = None

        if os.path.isabs(src_path):

          raise errors.OpPrereqError("Importing an instance from an absolute"

      else:

        self.op.src_node = src_node = self._ExpandNode(src_node)

        if self.needed_locks[locking.LEVEL_NODE] is not locking.ALL_SET:

    else: # INSTANCE_CREATE

      if getattr(self.op, "os_type", None) is None:

      self.op.force_variant = getattr(self.op, "force_variant", False)

  def _RunAllocator(self):

    if not ial.success:

      raise errors.OpPrereqError("Can't compute nodes using"

    if len(ial.nodes) != ial.required_nodes:

      raise errors.OpPrereqError("iallocator '%s' returned invalid number"

                                 " of nodes (%s), required %s" %

                                 (self.op.iallocator, len(ial.nodes),

    self.op.pnode = ial.nodes[0]

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

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

    if (not self.cfg.GetVGName() and

        self.op.disk_template not in constants.DTS_NOT_LVM):

      raise errors.OpPrereqError("Cluster does not support lvm-based"

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

      src_node = self.op.src_node

            break

        if not found:

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

      _CheckNodeOnline(self, src_node)

      result = self.rpc.call_export_info(src_node, src_path)

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

      if not export_info.has_section(constants.INISECT_EXP):

      ei_version = export_info.get(constants.INISECT_EXP, 'version')

      if (int(ei_version) != constants.EXPORT_VERSION):

        raise errors.OpPrereqError("Wrong export version %s (wanted %d)" %

      # Check that the new instance doesn't have less disks than the export

      instance_disks = len(self.disks)

      if instance_disks < export_disks:

        raise errors.OpPrereqError("Not enough disks to import."

                                   " (instance: %d, export: %d)" %

      self.op.os_type = export_info.get(constants.INISECT_EXP, 'os')

      disk_images = []

    # ip ping checks (we use the same ip that was resolved in ExpandNames)

    if self.op.start and not self.op.ip_check:

      raise errors.OpPrereqError("Cannot ignore IP address conflicts when"

    if self.op.ip_check:

      if utils.TcpPing(self.check_ip, constants.DEFAULT_NODED_PORT):

        raise errors.OpPrereqError("IP %s of instance %s already in use" %

    #### mac address generation

    # By generating here the mac address both the allocator and the hooks get

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

    if pnode.offline:

      raise errors.OpPrereqError("Cannot use offline primary node '%s'" %

    if pnode.drained:

      raise errors.OpPrereqError("Cannot use drained primary node '%s'" %

    self.secondaries = []

    if self.op.disk_template in constants.DTS_NET_MIRROR:

      if self.op.snode is None:

        raise errors.OpPrereqError("The networked disk templates need"

      if self.op.snode == pnode.name:

      _CheckNodeOnline(self, self.op.snode)

      _CheckNodeNotDrained(self, self.op.snode)

      self.secondaries.append(self.op.snode)

        vg_free = info.get('vg_free', None)

        if not isinstance(vg_free, int):

          raise errors.OpPrereqError("Can't compute free disk space on"

        if req_size > vg_free:

          raise errors.OpPrereqError("Not enough disk space on target node %s."

                                     " %d MB available, %d MB required" %

    _CheckHVParams(self, nodenames, self.op.hypervisor, self.op.hvparams)

      remote_node = self.cfg.ExpandNodeName(self.op.remote_node)

      if remote_node is None:

        raise errors.OpPrereqError("Node '%s' not known" %

      self.op.remote_node = remote_node

  def ExpandNames(self):

    self.op.node_name = self.cfg.ExpandNodeName(self.op.node_name)

    if self.op.node_name is None:

    self.needed_locks = {}

      remote_node = self.cfg.ExpandNodeName(self.op.remote_node)

      if remote_node is None:

        raise errors.OpPrereqError("Node '%s' not known" %

      self.op.remote_node = remote_node

      self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_APPEND

    else:

    # Create tasklets for replacing disks for all secondary instances on this

    # node

      if remote_node is None and iallocator is None:

        raise errors.OpPrereqError("When changing the secondary either an"

                                   " iallocator script must be used or the"

      if remote_node is not None and iallocator is not None:

        raise errors.OpPrereqError("Give either the iallocator or the new"

    elif remote_node is not None or iallocator is not None:

      # Not replacing the secondary

      raise errors.OpPrereqError("The iallocator and new node options can"

                                 " only be used when changing the"

  @staticmethod

  def _RunAllocator(lu, iallocator_name, instance_name, relocate_from):

    if not ial.success:

      raise errors.OpPrereqError("Can't compute nodes using iallocator '%s':"

    if len(ial.nodes) != ial.required_nodes:

      raise errors.OpPrereqError("iallocator '%s' returned invalid number"

                                 " of nodes (%s), required %s" %

    remote_node_name = ial.nodes[0]

    if instance.disk_template != constants.DT_DRBD8:

      raise errors.OpPrereqError("Can only run replace disks for DRBD8-based"

    if len(instance.secondary_nodes) != 1:

      raise errors.OpPrereqError("The instance has a strange layout,"

                                 " expected one secondary but found %d" %

    secondary_node = instance.secondary_nodes[0]

    if remote_node == self.instance.primary_node:

      raise errors.OpPrereqError("The specified node is the primary node of"

    if remote_node == secondary_node:

      raise errors.OpPrereqError("The specified node is already the"

    if self.disks and self.mode in (constants.REPLACE_DISK_AUTO,

                                    constants.REPLACE_DISK_CHG):

    if self.mode == constants.REPLACE_DISK_AUTO:

      faulty_primary = self._FindFaultyDisks(instance.primary_node)

      if faulty_primary and faulty_secondary:

        raise errors.OpPrereqError("Instance %s has faulty disks on more than"

                                   " one node and can not be repaired"

      if faulty_primary:

        self.disks = faulty_primary

      return fn(feedback_fn)

    finally:

      if activate_disks:

        _SafeShutdownInstanceDisks(self.lu, self.instance)

  def CheckArguments(self):

    node_name = self.cfg.ExpandNodeName(self.op.node_name)

    if node_name is None:

    self.op.node_name = node_name

    if _FindFaultyInstanceDisks(self.cfg, self.rpc, instance,

                                node_name, True):

      raise errors.OpPrereqError("Instance '%s' has faulty disks on"

  def CheckPrereq(self):

    """Check prerequisites.

    if (constants.SO_FIX_CONSISTENCY not in

        constants.VALID_STORAGE_OPERATIONS.get(storage_type, [])):

      raise errors.OpPrereqError("Storage units of type '%s' can not be"

    # Check whether any instance on this node has faulty disks

    for inst in _GetNodeInstances(self.cfg, self.op.node_name):

    if instance.disk_template not in (constants.DT_PLAIN, constants.DT_DRBD8):

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

    self.disk = instance.FindDisk(self.op.disk)

      vg_free = info.payload.get('vg_free', None)

      if not isinstance(vg_free, int):

        raise errors.OpPrereqError("Can't compute free disk space on"

      if self.op.amount > vg_free:

        raise errors.OpPrereqError("Not enough disk space on target node %s:"

                                   " %d MiB available, %d MiB required" %

  def Exec(self, feedback_fn):

    """Execute disk grow.

    self.share_locks = dict.fromkeys(locking.LEVELS, 1)

    if not isinstance(self.op.instances, list):

    if self.op.instances:

      self.wanted_names = []

      for name in self.op.instances:

        full_name = self.cfg.ExpandInstanceName(name)

        if full_name is None:

        self.wanted_names.append(full_name)

      self.needed_locks[locking.LEVEL_INSTANCE] = self.wanted_names

    else:

    self.op.force = getattr(self.op, "force", False)

    if not (self.op.nics or self.op.disks or

            self.op.hvparams or self.op.beparams):

    # Disk validation

    disk_addremove = 0

        disk_addremove += 1

      else:

        if not isinstance(disk_op, int):

        if not isinstance(disk_dict, dict):

          msg = "Invalid disk value: expected dict, got '%s'" % disk_dict

      if disk_op == constants.DDM_ADD:

        mode = disk_dict.setdefault('mode', constants.DISK_RDWR)

        if mode not in constants.DISK_ACCESS_SET:

        size = disk_dict.get('size', None)

        if size is None:

        try:

          size = int(size)

        except ValueError, err:

          raise errors.OpPrereqError("Invalid disk size parameter: %s" %

        disk_dict['size'] = size

      else:

        # modification of disk

        if 'size' in disk_dict:

          raise errors.OpPrereqError("Disk size change not possible, use"

    if disk_addremove > 1:

      raise errors.OpPrereqError("Only one disk add or remove operation"

    # NIC validation

    nic_addremove = 0

        nic_addremove += 1

      else:

        if not isinstance(nic_op, int):

        if not isinstance(nic_dict, dict):

          msg = "Invalid nic value: expected dict, got '%s'" % nic_dict

      # nic_dict should be a dict

      nic_ip = nic_dict.get('ip', None)

          nic_dict['ip'] = None

        else:

          if not utils.IsValidIP(nic_ip):

      nic_bridge = nic_dict.get('bridge', None)

      nic_link = nic_dict.get('link', None)

      if nic_bridge and nic_link:

        raise errors.OpPrereqError("Cannot pass 'bridge' and 'link'"

      elif nic_bridge and nic_bridge.lower() == constants.VALUE_NONE:

        nic_dict['bridge'] = None

      elif nic_link and nic_link.lower() == constants.VALUE_NONE:

        nic_mac = nic_dict['mac']

        if nic_mac not in (constants.VALUE_AUTO, constants.VALUE_GENERATE):

          if not utils.IsValidMac(nic_mac):

        if nic_op != constants.DDM_ADD and nic_mac == constants.VALUE_AUTO:

          raise errors.OpPrereqError("'auto' is not a valid MAC address when"

    if nic_addremove > 1:

      raise errors.OpPrereqError("Only one NIC add or remove operation"

  def ExpandNames(self):

    self._ExpandAndLockInstance()

        if miss_mem > 0:

          raise errors.OpPrereqError("This change will prevent the instance"

                                     " from starting, due to %d MB of memory"

      if be_new[constants.BE_AUTO_BALANCE]:

        for node, nres in nodeinfo.items():

    for nic_op, nic_dict in self.op.nics:

      if nic_op == constants.DDM_REMOVE:

        if not instance.nics:

        continue

      if nic_op != constants.DDM_ADD:

        # an existing nic

        if nic_op < 0 or nic_op >= len(instance.nics):

          raise errors.OpPrereqError("Invalid NIC index %s, valid values"

                                     " are 0 to %d" %

        old_nic_params = instance.nics[nic_op].nicparams

        old_nic_ip = instance.nics[nic_op].ip

      else:

          if self.force:

            self.warn.append(msg)

          else:

      if new_nic_mode == constants.NIC_MODE_ROUTED:

        if 'ip' in nic_dict:

          nic_ip = nic_dict['ip']

          nic_ip = old_nic_ip

        if nic_ip is None:

          raise errors.OpPrereqError('Cannot set the nic ip to None'

      if 'mac' in nic_dict:

        nic_mac = nic_dict['mac']

        if nic_mac is None:

        elif nic_mac in (constants.VALUE_AUTO, constants.VALUE_GENERATE):

          # otherwise generate the mac

          nic_dict['mac'] = self.cfg.GenerateMAC()

          # or validate/reserve the current one

          if self.cfg.IsMacInUse(nic_mac):

            raise errors.OpPrereqError("MAC address %s already in use"

    # DISK processing

    if self.op.disks and instance.disk_template == constants.DT_DISKLESS:

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

    for disk_op, disk_dict in self.op.disks:

      if disk_op == constants.DDM_REMOVE:

        if len(instance.disks) == 1:

          raise errors.OpPrereqError("Cannot remove the last disk of"

        ins_l = self.rpc.call_instance_list([pnode], [instance.hypervisor])

        ins_l = ins_l[pnode]

        msg = ins_l.fail_msg

        if msg:

          raise errors.OpPrereqError("Can't contact node %s: %s" %

        if instance.name in ins_l.payload:

          raise errors.OpPrereqError("Instance is running, can't remove"

      if (disk_op == constants.DDM_ADD and

          len(instance.nics) >= constants.MAX_DISKS):

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

      if disk_op not in (constants.DDM_ADD, constants.DDM_REMOVE):

        # an existing disk

        if disk_op < 0 or disk_op >= len(instance.disks):

          raise errors.OpPrereqError("Invalid disk index %s, valid values"

                                     " are 0 to %d" %

    return

    if self.dst_node is None:

      # This is wrong node name, not a non-locked node

    _CheckNodeOnline(self, self.dst_node.name)

    _CheckNodeNotDrained(self, self.dst_node.name)

    for disk in self.instance.disks:

      if disk.dev_type == constants.LD_FILE:

        raise errors.OpPrereqError("Export not supported for instances with"

  def Exec(self, feedback_fn):

    """Export an instance to an image in the cluster.

      name = self.cfg.ExpandNodeName(self.op.name)

      if name is None:

        raise errors.OpPrereqError("Invalid node name (%s)" %

      self.op.name = name

      self.needed_locks[locking.LEVEL_NODE] = name

    elif self.op.kind == constants.TAG_INSTANCE:

      name = self.cfg.ExpandInstanceName(self.op.name)

      if name is None:

        raise errors.OpPrereqError("Invalid instance name (%s)" %

      self.op.name = name

      self.needed_locks[locking.LEVEL_INSTANCE] = name

      self.target = self.cfg.GetInstanceInfo(self.op.name)

    else:

      raise errors.OpPrereqError("Wrong tag type requested (%s)" %

class LUGetTags(TagsLU):

      self.re = re.compile(self.op.pattern)

    except re.error, err:

      raise errors.OpPrereqError("Invalid search pattern '%s': %s" %

  def Exec(self, feedback_fn):

    """Returns the tag list.

      diff_names = ["'%s'" % tag for tag in diff_tags]

      diff_names.sort()

      raise errors.OpPrereqError("Tag(s) %s not found" %

  def Exec(self, feedback_fn):

    """Remove the tag from the object.

                                   " IAllocator" % self.name)

    if instance.disk_template not in constants.DTS_NET_MIRROR:

    if len(instance.secondary_nodes) != 1:

    self.required_nodes = 1

    disk_sizes = [{'size': disk.size} for disk in instance.disks]

                   "os", "tags", "nics", "vcpus"]:

        if not hasattr(self.op, attr):

          raise errors.OpPrereqError("Missing attribute '%s' on opcode input" %

      iname = self.cfg.ExpandInstanceName(self.op.name)

      if iname is not None:

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

      if not isinstance(self.op.nics, list):

      for row in self.op.nics:

        if (not isinstance(row, dict) or

            "mac" not in row or

            "ip" not in row or

            "bridge" not in row):

      if not isinstance(self.op.disks, list):

      for row in self.op.disks:

        if (not isinstance(row, dict) or

            "size" not in row or

            not isinstance(row["size"], int) or

            "mode" not in row or

            row["mode"] not in ['r', 'w']):