Synnefo » snf-ganeti

    ipcls = netutils.IPAddress.GetClassFromIpVersion(primary_ip_version)

  except errors.ProgrammerError:

    raise errors.OpPrereqError("Invalid primary ip version: %d." %

  hostname = netutils.GetHostname(family=ipcls.family)

  if not ipcls.IsValid(hostname.ip):

    raise errors.OpPrereqError("This host's IP (%s) is not a valid IPv%d"

  if ipcls.IsLoopback(hostname.ip):

    raise errors.OpPrereqError("This host's IP (%s) resolves to a loopback"

  if master_netmask is not None:

    if not ipcls.ValidateNetmask(master_netmask):

      raise errors.OpPrereqError("CIDR netmask (%s) not valid for IPv%s " %

  else:

    master_netmask = ipcls.iplen

      unknown_params = param_keys - default_param_keys

      raise errors.OpPrereqError("Invalid parameters for disk template %s:"

                                 " %s" % (template,

    utils.ForceDictType(dt_params, constants.DISK_DT_TYPES)

  try:

    utils.VerifyDictOptions(diskparams, constants.DISK_DT_DEFAULTS)

                constants.TAG_NODE,

                constants.TAG_INSTANCE):

    if not args:

    name = args.pop(0)

    retval = kind, name

  else:

  kind, name = _ExtractTagsObject(opts, args)

  _ExtendTags(opts, args)

  if not args:

  op = opcodes.OpTagsSet(kind=kind, name=name, tags=args)

  SubmitOrSend(op, opts)

  kind, name = _ExtractTagsObject(opts, args)

  _ExtendTags(opts, args)

  if not args:

  op = opcodes.OpTagsDel(kind=kind, name=name, tags=args)

  SubmitOrSend(op, opts)

      ss.GetMasterNode()

    except errors.ConfigurationError:

      raise errors.OpPrereqError("Cluster not initialized or this machine is"

    master, myself = ssconf.GetMasterAndMyself(ss=ss)

    if master != myself:

      raise errors.OpPrereqError("This is not the master node, please connect"

                                 " to node '%s' and rerun the command" %

    raise

  return client

  try:

    nic_max = max(int(nidx[0]) + 1 for nidx in optvalue)

  except (TypeError, ValueError), err:

  nics = [{}] * nic_max

  for nidx, ndict in optvalue:

    if not isinstance(ndict, dict):

      raise errors.OpPrereqError("Invalid nic/%d value: expected dict,"

    utils.ForceDictType(ndict, constants.INIC_PARAMS_TYPES)

  if opts.disk_template == constants.DT_DISKLESS:

    if opts.disks or opts.sd_size is not None:

      raise errors.OpPrereqError("Diskless instance but disk"

    disks = []

  else:

    if (not opts.disks and not opts.sd_size

        and mode == constants.INSTANCE_CREATE):

    if opts.disks and opts.sd_size is not None:

      raise errors.OpPrereqError("Please use either the '--disk' or"

    if opts.sd_size is not None:

      opts.disks = [(0, {constants.IDISK_SIZE: opts.sd_size})]

      try:

        disk_max = max(int(didx[0]) + 1 for didx in opts.disks)

      except ValueError, err:

      disks = [{}] * disk_max

    else:

      disks = []

      didx = int(didx)

      if not isinstance(ddict, dict):

        msg = "Invalid disk/%d value: expected dict, got %s" % (didx, ddict)

      elif constants.IDISK_SIZE in ddict:

        if constants.IDISK_ADOPT in ddict:

          raise errors.OpPrereqError("Only one of 'size' and 'adopt' allowed"

        try:

          ddict[constants.IDISK_SIZE] = \

            utils.ParseUnit(ddict[constants.IDISK_SIZE])

        except ValueError, err:

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

      elif constants.IDISK_ADOPT in ddict:

        if mode == constants.INSTANCE_IMPORT:

          raise errors.OpPrereqError("Disk adoption not allowed for instance"

        ddict[constants.IDISK_SIZE] = 0

      else:

        raise errors.OpPrereqError("Missing size or adoption source for"

      disks[didx] = ddict

  if opts.tags is not None:

  """

  value = str(value)

  if not value:

  suffix_map = {

    "s": 1,

    "m": 60,

    try:

      value = int(value)

    except (TypeError, ValueError):

  else:

    multiplier = suffix_map[value[-1]]

    value = value[:-1]

    if not value: # no data left after stripping the suffix

      raise errors.OpPrereqError("Invalid time specification (only"

    try:

      value = int(value) * multiplier

    except (TypeError, ValueError):

  return value

      if not ht.TDict(ddict):

        msg = "Invalid disk/%d value: expected dict, got %s" % (didx, ddict)

      if constants.IDISK_SIZE in ddict:

        try:

            utils.ParseUnit(ddict[constants.IDISK_SIZE])

        except ValueError, err:

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

      disks.append((didx, ddict))

                                 " cluster-wide default iallocator found;"

                                 " please specify either an iallocator or a"

                                 " node, or set a cluster-wide default"

def _GetDefaultIAllocator(cfg, iallocator):

    ipcls = netutils.IPAddress.GetClassFromIpFamily(ip_family)

  except errors.ProgrammerError:

    raise errors.OpPrereqError("Invalid primary ip family: %s." %

  if not ipcls.ValidateNetmask(netmask):

    raise errors.OpPrereqError("CIDR netmask (%s) not valid" %

class LUClusterSetParams(LogicalUnit):

                              " address" % (instance.name, nic_idx))

      if nic_errors:

        raise errors.OpPrereqError("Cannot apply the change, errors:\n%s" %

    # hypervisor list/parameters

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

                                           self.op.powered == True):

        raise errors.OpPrereqError(("Node %s needs to be turned on before its"

                                    " offline status can be reset") %

    elif self.op.powered is not None:

      raise errors.OpPrereqError(("Unable to change powered state for node %s"

                                  " as it does not support out-of-band"

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

    if (self.op.drained == False or self.op.offline == False or

      if node.offline:

        if affected_instances:

      else:

        # On online nodes, check that no instances are running, and that

        # the node has the new ip and we can reach it.

      if self.target_node == instance.primary_node:

        raise errors.OpPrereqError("Cannot migrate instance %s"

                                   " to its primary (%s)" %

      if len(self.lu.tasklets) == 1:

        # It is safe to release locks only when we're the only tasklet

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

          raise errors.OpPrereqError("Disk template specified in configuration"

                                     " file is not one of the allowed values:"

      else:

        raise errors.OpPrereqError("No disk template specified and the export"

                                   " is missing the disk_template information",

      cfg_storagedir = get_fsd_fn()

      if not cfg_storagedir:

      joinargs.append(cfg_storagedir)

      if self.op.file_storage_dir is not None:

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

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

                                       " missing on its primary node" %

      if be_new[constants.BE_AUTO_BALANCE]:

        for node, nres in nodeinfo.items():

                                                instance.hypervisor)

      remote_info.Raise("Error checking node %s" % instance.primary_node)

      if not remote_info.payload: # not running already

      current_memory = remote_info.payload["memory"]

      if (not self.op.force and

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

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

    def _PrepareNicCreate(_, params, private):

      self._PrepareNicModification(params, private, None, {}, cluster, pnode)

      raise errors.OpPrereqError("Can't compute solution for changing group of"

                                 " instance '%s' using iallocator '%s': %s" %

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

    jobs = _LoadNodeEvacResult(self, ial.result, self.op.early_release, False)

        self.instance.admin_state == constants.ADMINST_UP and

        not self.op.shutdown):

      raise errors.OpPrereqError("Can not remove instance without shutting it"

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

      self.op.target_node = _ExpandNodeName(self.cfg, self.op.target_node)

      try:

        (key_name, hmac_digest, hmac_salt) = self.x509_key_name

      except (TypeError, ValueError), err:

      if not utils.VerifySha1Hmac(cds, key_name, hmac_digest, salt=hmac_salt):

        raise errors.OpPrereqError("HMAC for X509 key name is wrong",

    # Verify the cluster would not be left group-less.

    if len(self.cfg.GetNodeGroupList()) == 1:

                                 errors.ECODE_STATE)

  def BuildHooksEnv(self):

#!/usr/bin/python

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

  """

  if not constants.QEMUIMG_PATH:

    raise errors.OpPrereqError("qemu-img not found at build time, unable"

def LinkFile(old_path, prefix=None, suffix=None, directory=None):

        counter += 1

      else:

        raise errors.OpPrereqError("Error moving the file %s to %s location:"

  return new_path

      self.tree.parse(input_path)

    except (ParseError, xml.parsers.expat.ExpatError), err:

      raise errors.OpPrereqError("Error while reading %s file: %s" %

    # Create a list of all files in the OVF package

    (input_dir, input_file) = os.path.split(input_path)

    for file_name in files_list:

      file_path = utils.PathJoin(input_dir, file_name)

      if not os.path.exists(file_path):

    logging.info("Files in the OVF package: %s", " ".join(files_list))

    self.files_list = files_list

    self.input_dir = input_dir

      for file_name, value in manifest_files.iteritems():

        if sha1_sums.get(utils.PathJoin(self.input_dir, file_name)) != value:

          raise errors.OpPrereqError("SHA1 checksum of %s does not match the"

      logging.info("SHA1 checksums verified")

  def GetInstanceName(self):

      matching_units = [units for units, variants in

        ALLOCATION_UNITS.iteritems() if alloc_units.lower() in variants]

      if matching_units == []:

      units = matching_units[0]

      memory_raw = int(memory.findtext("{%s}VirtualQuantity" % RASD_SCHEMA,

            default=constants.VALUE_AUTO))

      disk_elem = self._GetElementMatchingAttr(disk_search, disk_match)

      if disk_elem is None:

        raise errors.OpPrereqError("%s file corrupted - disk %s not found in"

      disk_name = disk_elem.get("{%s}href" % OVF_SCHEMA)

      disk_compression = disk_elem.get("{%s}compression" % OVF_SCHEMA)

      results.append((disk_name, disk_compression))

    """

    input_path = os.path.abspath(input_path)

    if not os.path.isfile(input_path):

    self.options = options

    self.temp_file_manager = utils.TemporaryFileManager()

    self.temp_dir = None

    # For now we only support gzip, as it is used in ovftool

    if compression != COMPRESSION_TYPE:

      raise errors.OpPrereqError("Unsupported compression type: %s"

    disk_file = os.path.basename(disk_path)

    if action == DECOMPRESS:

      (disk_name, _) = os.path.splitext(disk_file)

    run_result = utils.RunCmd(args, output=new_path)

    if run_result.failed:

      raise errors.OpPrereqError("Disk %s failed with output: %s"

    logging.info("The %s of the disk is completed", action)

    return (COMPRESSION_EXT, new_path)

    run_result = utils.RunCmd(args, cwd=os.getcwd())

    if run_result.failed:

      raise errors.OpPrereqError("Convertion to %s failed, qemu-img output was"

    return (".%s" % disk_format, new_disk_path)

  @staticmethod

    run_result = utils.RunCmd(args, cwd=os.getcwd())

    if run_result.failed:

      raise errors.OpPrereqError("Gathering info about the disk using qemu-img"

    result = run_result.output

    regexp = r"%s" % regexp

    match = re.search(regexp, result)

      disk_format = match.group(1)

    else:

      raise errors.OpPrereqError("No file information matching %s found in:"

    return disk_format

  def Parse(self):

      self._UnpackOVA(input_path)

    else:

      raise errors.OpPrereqError("Unknown file extension; expected %s or %s"

    assert ((input_extension == OVA_EXT and self.temp_dir) or

            (input_extension == OVF_EXT and not self.temp_dir))

    assert self.input_dir in self.input_path

    input_name = None

    if not tarfile.is_tarfile(input_path):

      raise errors.OpPrereqError("The provided %s file is not a proper tar"

    ova_content = tarfile.open(input_path)

    temp_dir = tempfile.mkdtemp()

    self.temp_dir = temp_dir

        utils.PathJoin(temp_dir, file_normname)

      except ValueError, err:

        raise errors.OpPrereqError("File %s inside %s package is not safe" %

      if file_name.endswith(OVF_EXT):

        input_name = file_name

    if not input_name:

      raise errors.OpPrereqError("No %s file in %s package found" %

    logging.warning("Unpacking the %s archive, this may take a while",

      input_path)

    self.input_dir = temp_dir

        extract(self.temp_dir)

    except tarfile.TarError, err:

      raise errors.OpPrereqError("Error while extracting %s archive: %s" %

    logging.info("OVA package extracted to %s directory", self.temp_dir)

  def Parse(self):

    self.results_name = self._GetInfo("instance name", self.options.name,

      self._ParseNameOptions, self.ovf_reader.GetInstanceName)

    if not self.results_name:

    self.output_dir = utils.PathJoin(self.output_dir, self.results_name)

    try:

      utils.Makedirs(self.output_dir)

    except OSError, err:

      raise errors.OpPrereqError("Failed to create directory %s: %s" %

    self.results_template = self._GetInfo("disk template",

      self.options.disk_template, self._ParseTemplateOptions,

    self.results_os = self._GetInfo("OS", self.options.os,

      self._ParseOSOptions, self.ovf_reader.GetOSData)

    if not self.results_os.get("os_name"):

    self.results_backend = self._GetInfo("backend", self.options.beparams,

      self._ParseBackendOptions, self.ovf_reader.GetBackendData)

    if not self.results_disk and not self.results_network:

      raise errors.OpPrereqError("Either disk specification or network"

  @staticmethod

  def _GetInfo(name, cmd_arg, cmd_function, nocmd_function,

          disk_size = utils.ParseUnit(disk_desc["size"])

        except ValueError:

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

        new_path = utils.PathJoin(self.output_dir, str(disk_id))

        args = [

          constants.QEMUIMG_PATH,

        run_result = utils.RunCmd(args)

        if run_result.failed:

          raise errors.OpPrereqError("Creation of disk %s failed, output was:"

        results["disk%s_size" % disk_id] = str(disk_size)

        results["disk%s_dump" % disk_id] = "disk%s.raw" % disk_id

      else:

        raise errors.OpPrereqError("Disks created for import must have their"

    results["disk_count"] = str(len(self.options.disks))

    return results

    for (counter, (disk_name, disk_compression)) in enumerate(disks_list):

      if os.path.dirname(disk_name):

        raise errors.OpPrereqError("Disks are not allowed to have absolute"

      disk, _ = os.path.splitext(disk_name)

      disk_path = utils.PathJoin(self.input_dir, disk_name)

      if disk_compression not in NO_COMPRESSION:

    try:

      utils.WriteFile(output_file_name, data=output_contents)

    except errors.ProgrammerError, err:

    self.Cleanup()

      self.config_parser.read(input_path)

    except ConfigParser.MissingSectionHeaderError, err:

      raise errors.OpPrereqError("Error when trying to read %s: %s" %

    if self.options.ova_package:

      self.temp_dir = tempfile.mkdtemp()

      self.packed_dir = self.output_dir

    else:

      name = self.config_parser.get(constants.INISECT_INS, NAME)

    if name is None:

    return name

  def _ParseVCPUs(self):

    """

    vcpus = self.config_parser.getint(constants.INISECT_BEP, VCPUS)

    if vcpus == 0:

    return vcpus

  def _ParseMemory(self):

    """

    memory = self.config_parser.getint(constants.INISECT_BEP, MEMORY)

    if memory == 0:

    return memory

  def _ParseGaneti(self):

    results["hypervisor"] = {}

    hyp_name = self.config_parser.get(constants.INISECT_INS, HYPERV)

    if hyp_name is None:

    results["hypervisor"]["name"] = hyp_name

    pairs = self.config_parser.items(constants.INISECT_HYP)

    for (name, value) in pairs:

    results["os"] = {}

    os_name = self.config_parser.get(constants.INISECT_EXP, OS)

    if os_name is None:

    results["os"]["name"] = os_name

    pairs = self.config_parser.items(constants.INISECT_OSP)

    for (name, value) in pairs:

      })

      if results[counter]["mode"] not in constants.NIC_VALID_MODES:

        raise errors.OpPrereqError("Network mode %s not recognized"

      counter += 1

    return results

    disk_path = utils.PathJoin(self.input_dir, disk_file)

    results = {}

    if not os.path.isfile(disk_path):

    if os.path.dirname(disk_file):

      raise errors.OpPrereqError("Path for the disk: %s contains a directory"

    disk_name, _ = os.path.splitext(disk_file)

    ext, new_disk_path = self._ConvertDisk(self.options.disk_format, disk_path)

    results["format"] = self.options.disk_format

      utils.Makedirs(self.output_dir)

    except OSError, err:

      raise errors.OpPrereqError("Failed to create directory %s: %s" %

    self.references_files = []

    self.results_name = self._ParseName()

    try:

      utils.WriteFile(path, data=data)

    except errors.ProgrammerError, err:

  @staticmethod

  def _PrepareTarFile(tar_path, files_list):

        utils.Makedirs(self.packed_dir)

      except OSError, err:

        raise errors.OpPrereqError("Failed to create directory %s: %s" %

      self._PrepareTarFile(packed_path, files_list)

    logging.info("Creation of the OVF package was successfull")

    self.Cleanup()

#

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

      (filter_text, ) = args

    except (TypeError, ValueError):

      raise errors.OpPrereqError("Exactly one argument must be given as a"

    result = ParseFilter(filter_text)

  elif args:

                                             qfilter=qfilter))

      elif what == constants.QR_LOCK:

        if qfilter is not None:

        return context.glm.QueryLocks(fields)

      elif what == constants.QR_JOB:

        return queue.QueryJobs(fields, qfilter)

#

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

    if n_elements > 2:

      raise errors.OpPrereqError(

          "Invalid user-id range definition. Only one hyphen allowed: %s"

    try:

      lower = int(boundaries[0])

    except (ValueError, TypeError), err: