Synnefo » snf-ganeti » ganeti-local

    except OSError, err:

      if err.errno == errno.EEXIST:

        new_path = utils.PathJoin(directory,

        counter += 1

      else:

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

          sha1_sum = match.group(2)

          manifest_files[file_name] = sha1_sum

      files_with_paths = [utils.PathJoin(self.input_dir, file_name)

      sha1_sums = utils.FingerprintFiles(files_with_paths)

      for file_name, value in manifest_files.iteritems():

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

      return {"hypervisor_name": constants.VALUE_AUTO}

    results = {

      "hypervisor_name": hypervisor_data.findtext("{%s}Name" % GANETI_SCHEMA,

    }

    parameters = hypervisor_data.find("{%s}Parameters" % GANETI_SCHEMA)

    results.update(self._GetDictParameters(parameters, GANETI_SCHEMA))

    vcpus = self._GetElementMatchingText(find_vcpus, match_vcpus)

    if vcpus:

      vcpus_count = vcpus.findtext("{%s}VirtualQuantity" % RASD_SCHEMA,

    else:

      vcpus_count = constants.VALUE_AUTO

    results["vcpus"] = str(vcpus_count)

    memory_raw = None

    if memory:

      alloc_units = memory.findtext("{%s}AllocationUnits" % RASD_SCHEMA)

      if matching_units == []:

        raise errors.OpPrereqError("Unit %s for RAM memory unknown" %

                                   alloc_units, errors.ECODE_INVAL)

      units = matching_units[0]

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

      memory_count = CONVERT_UNITS_TO_MB[units](memory_raw)

    else:

      memory_count = constants.VALUE_AUTO

    results["memory"] = str(memory_count)

    find_balance = ("{%s}GanetiSection/{%s}AutoBalance" %

    balance = self.tree.findtext(find_balance, default=constants.VALUE_AUTO)

    results["auto_balance"] = balance

    networks_search = ("{%s}NetworkSection/{%s}Network" %

                       (OVF_SCHEMA, OVF_SCHEMA))

    network_names = self._GetAttributes(networks_search,

    required = ["ip", "mac", "link", "mode"]

    for (counter, network_name) in enumerate(network_names):

      network_search = ("{%s}VirtualSystem/{%s}VirtualHardwareSection/{%s}Item"

      ganeti_match = ("{%s}name" % OVF_SCHEMA, network_name)

      network_data = self._GetElementMatchingText(network_search, network_match)

      network_ganeti_data = self._GetElementMatchingAttr(ganeti_search,

      ganeti_data = {}

      if network_ganeti_data:

      SubElementText(network_item, "rasd:ElementName", network_name)

      SubElementText(network_item, "rasd:InstanceID", self.next_instance_id)

      SubElementText(network_item, "rasd:ResourceType",

      self.hardware_list.append(network_item)

      self.next_instance_id += 1

    SubElementText(ganeti_section, "gnt:Version", ganeti.get("version"))

    SubElementText(ganeti_section, "gnt:DiskTemplate",

    SubElementText(ganeti_section, "gnt:AutoBalance",

    SubElementText(ganeti_section, "gnt:Tags", ganeti.get("tags"))

    osys = ET.SubElement(ganeti_section, "gnt:OperatingSystem")

    name_section.text = name

    os_attrib = {"ovf:id": "0"}

    os_section = ET.SubElement(virtual_system, "OperatingSystemSection",

    SubElementText(os_section, "Info", "Installed guest operating system")

    hardware_section = ET.SubElement(virtual_system, "VirtualHardwareSection")

    SubElementText(hardware_section, "Info", "Virtual hardware requirements")

    # Item for vcpus

    vcpus_item = ET.SubElement(hardware_section, "Item")

    SubElementText(vcpus_item, "rasd:ElementName",

    SubElementText(vcpus_item, "rasd:InstanceID", INSTANCE_ID["vcpus"])

    SubElementText(vcpus_item, "rasd:ResourceType", RASD_TYPE["vcpus"])

    SubElementText(vcpus_item, "rasd:VirtualQuantity", vcpus)

    elif action == COMPRESS:

      prefix = disk_file

    new_path = utils.GetClosedTempfile(suffix=COMPRESSION_EXT, prefix=prefix,

    self.temp_file_manager.Add(new_path)

    args = ["gzip", "-c", disk_path]

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

      logging.warning("Conversion of disk image to %s format, this may take"

                      " a while", disk_format)

    self.temp_file_manager.Add(new_disk_path)

    args = [

      constants.QEMUIMG_PATH,

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

                                 (OVF_EXT, OVA_EXT), errors.ECODE_ENVIRON)

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

    self.input_dir = temp_dir

    self.input_path = utils.PathJoin(self.temp_dir, input_name)

    try:

    """

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

    if not self.results_name:

      raise errors.OpPrereqError("Name of instance not provided",

                                 errors.ECODE_INVAL)

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

                                 (self.output_dir, err), errors.ECODE_ENVIRON)

      self.ovf_reader.GetDiskTemplate)

    if not self.results_template:

      logging.info("Disk template not given")

      self.ovf_reader.GetHypervisorData)

    assert self.results_hypervisor["hypervisor_name"]

    if self.results_hypervisor["hypervisor_name"] == constants.VALUE_AUTO:

      logging.debug("Default hypervisor settings from the cluster will be used")

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

      raise errors.OpPrereqError("OS name must be provided",

                                 errors.ECODE_INVAL)

      self._ParseBackendOptions, self.ovf_reader.GetBackendData)

    assert self.results_backend.get("vcpus")

    assert self.results_backend.get("memory")

    assert self.results_backend.get("auto_balance") is not None

    ovf_version = self.ovf_reader.GetVersionData()

    if ovf_version:

    else:

      self.results_version = constants.EXPORT_VERSION

      ignore_test=self.results_template == constants.DT_DISKLESS)

    if not self.results_disk and not self.results_network:

  @staticmethod

  def _GetInfo(name, cmd_arg, cmd_function, nocmd_function,

    """Get information about some section - e.g. disk, network, hypervisor.

    @type name: string

      results = cmd_function()

    else:

      logging.info("Information for %s will be parsed from %s file",

      results = nocmd_function()

    logging.info("Options for %s were succesfully read", name)

    return results

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

      if disk_compression not in NO_COMPRESSION:

        _, disk_path = self._CompressDisk(disk_path, disk_compression,

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

      if self._GetDiskQemuInfo(disk_path, "file format: (\S+)") != "raw":

        logging.info("Conversion to raw format is required")

      ext, new_disk_path = self._ConvertDisk("raw", disk_path)

      final_disk_path = LinkFile(new_disk_path, prefix=disk, suffix=ext,

      final_name = os.path.basename(final_disk_path)

      disk_size = os.path.getsize(final_disk_path) / (1024 * 1024)

      results["disk%s_dump" % counter] = final_name

    results[constants.INISECT_HYP].update(self.results_hypervisor)

    output_file_name = utils.PathJoin(self.output_dir,

    output = []

    for section, options in results.iteritems():

  """

  def get(self, section, options, raw=None, vars=None): # pylint: disable=W0622

    try:

    except ConfigParser.NoOptionError:

      result = None

    return result

        break

      results.append({

        "mode": self.config_parser.get(constants.INISECT_INS,

        "mac": self.config_parser.get(constants.INISECT_INS,

        "ip": self.config_parser.get(constants.INISECT_INS,

        "link": data_link,

      })

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

    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

    if compression:

      ext2, new_disk_path = self._CompressDisk(new_disk_path, "gzip",

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

      results["compression"] = "gzip"

      ext += ext2

    final_disk_path = LinkFile(new_disk_path, prefix=disk_name, suffix=ext,

    final_disk_name = os.path.basename(final_disk_path)

    results["real-size"] = os.path.getsize(final_disk_path)

    results["path"] = final_disk_name

      self.ovf_writer.SaveGanetiData(self.results_ganeti, self.results_network)

    self.ovf_writer.SaveVirtualSystemData(self.results_name, self.results_vcpus,

    data = self.ovf_writer.PrettyXmlDump()

    utils.WriteFile(self.output_path, data=data)