Synnefo » snf-ganeti » ganeti-local

#!/usr/bin/python

#

# Copyright (C) 2011 Google Inc.

#

# 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

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""Converter tools between ovf and ganeti config file

"""

# pylint: disable=F0401, E1101

# F0401 because ElementTree is not default for python 2.4

# E1101 makes no sense - pylint assumes that ElementTree object is a tuple

import ConfigParser

import errno

import logging

import os

import os.path

import re

import shutil

import tarfile

import tempfile

import xml.dom.minidom

import xml.parsers.expat

try:

  import xml.etree.ElementTree as ET

except ImportError:

  import elementtree.ElementTree as ET

from ganeti import constants

from ganeti import errors

from ganeti import utils

# Schemas used in OVF format

GANETI_SCHEMA = "http://ganeti"

OVF_SCHEMA = "http://schemas.dmtf.org/ovf/envelope/1"

RASD_SCHEMA = ("http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/"

               "CIM_ResourceAllocationSettingData")

VSSD_SCHEMA = ("http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/"

               "CIM_VirtualSystemSettingData")

XML_SCHEMA = "http://www.w3.org/2001/XMLSchema-instance"

# File extensions in OVF package

OVA_EXT = ".ova"

OVF_EXT = ".ovf"

MF_EXT = ".mf"

CERT_EXT = ".cert"

COMPRESSION_EXT = ".gz"

FILE_EXTENSIONS = [

  OVF_EXT,

  MF_EXT,

  CERT_EXT,

]

COMPRESSION_TYPE = "gzip"

COMPRESS = "compression"

DECOMPRESS = "decompression"

ALLOWED_ACTIONS = [COMPRESS, DECOMPRESS]

# ResourceType values

RASD_TYPE = {

  "vcpus": "3",

  "memory": "4",

  "scsi-controller": "6",

  "ethernet-adapter": "10",

  "disk": "17",

}

# AllocationUnits values and conversion

ALLOCATION_UNITS = {

  'b': ["bytes", "b"],

  'kb': ["kilobytes", "kb", "byte * 2^10", "kibibytes", "kib"],

  'mb': ["megabytes", "mb", "byte * 2^20", "mebibytes", "mib"],

  'gb': ["gigabytes", "gb", "byte * 2^30", "gibibytes", "gib"],

}

CONVERT_UNITS_TO_MB = {

  'b': lambda x: x / (1024 * 1024),

  'kb': lambda x: x / 1024,

  'mb': lambda x: x,

  'gb': lambda x: x * 1024,

}

# Names of the config fields

NAME = "name"

OS = "os"

HYPERV = "hypervisor"

VCPUS = "vcpus"

MEMORY = "memory"

AUTO_BALANCE = "auto_balance"

DISK_TEMPLATE = "disk_template"

TAGS = "tags"

VERSION = "version"

# Instance IDs of System and SCSI controller

SYSTEM_ID = 0

SCSI_ID = 3

# Disk format descriptions

DISK_FORMAT = {

  "raw": "http://en.wikipedia.org/wiki/Byte",

  "vmdk": "http://www.vmware.com/interfaces/specifications/vmdk.html"

          "#monolithicSparse",

  "cow": "http://www.gnome.org/~markmc/qcow-image-format.html",

}

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

  """Create link with a given prefix and suffix.

  This is a wrapper over os.link. It tries to create a hard link for given file,

  but instead of rising error when file exists, the function changes the name

  a little bit.

  @type old_path:string

  @param old_path: path to the file that is to be linked

  @type prefix: string

  @param prefix: prefix of filename for the link

  @type suffix: string

  @param suffix: suffix of the filename for the link

  @type directory: string

  @param directory: directory of the link

  @raise errors.OpPrereqError: when error on linking is different than

    "File exists"

  """

  assert(prefix is not None or suffix is not None)

  if directory is None:

    directory = os.getcwd()

  new_path = utils.PathJoin(directory, "%s%s" % (prefix, suffix))

  counter = 1

  while True:

    try:

      os.link(old_path, new_path)

      break

    except OSError, err:

      if err.errno == errno.EEXIST:

        new_path = utils.PathJoin(directory,

          "%s_%s%s" % (prefix, counter, suffix))

        counter += 1

      else:

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

                                   " %s" % (old_path, new_path, err))

  return new_path

class OVFReader(object):

  """Reader class for OVF files.

  @type files_list: list

  @ivar files_list: list of files in the OVF package

  @type tree: ET.ElementTree

  @ivar tree: XML tree of the .ovf file

  @type schema_name: string

  @ivar schema_name: name of the .ovf file

  @type input_dir: string

  @ivar input_dir: directory in which the .ovf file resides

  """

  def __init__(self, input_path):

    """Initialiaze the reader - load the .ovf file to XML parser.

    It is assumed that names of manifesto (.mf), certificate (.cert) and ovf

    files are the same. In order to account any other files as part of the ovf

    package, they have to be explicitly mentioned in the Resources section

    of the .ovf file.

    @type input_path: string

    @param input_path: absolute path to the .ovf file

    @raise errors.OpPrereqError: when .ovf file is not a proper XML file or some

      of the files mentioned in Resources section do not exist

    """

    self.tree = ET.ElementTree()

    try:

      self.tree.parse(input_path)

    except xml.parsers.expat.ExpatError, err:

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

                                 (OVF_EXT, err))

    # Create a list of all files in the OVF package

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

    (input_name, _) = os.path.splitext(input_file)

    files_directory = utils.ListVisibleFiles(input_dir)

    files_list = []

    for file_name in files_directory:

      (name, extension) = os.path.splitext(file_name)

      if extension in FILE_EXTENSIONS and name == input_name:

        files_list.append(file_name)

    files_list += self._GetAttributes("{%s}References/{%s}File" %

                                      (OVF_SCHEMA, OVF_SCHEMA),

                                      "{%s}href" % OVF_SCHEMA)

    for file_name in files_list:

      file_path = utils.PathJoin(input_dir, file_name)

      if not os.path.exists(file_path):

        raise errors.OpPrereqError("File does not exist: %s" % file_path)

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

    self.files_list = files_list

    self.input_dir = input_dir

    self.schema_name = input_name

  def _GetAttributes(self, path, attribute):

    """Get specified attribute from all nodes accessible using given path.

    Function follows the path from root node to the desired tags using path,

    then reads the apropriate attribute values.

    @type path: string

    @param path: path of nodes to visit

    @type attribute: string

    @param attribute: attribute for which we gather the information

    @rtype: list

    @return: for each accessible tag with the attribute value set, value of the

      attribute

    """

    current_list = self.tree.findall(path)

    results = [x.get(attribute) for x in current_list]

    return filter(None, results)

  def _GetElementMatchingAttr(self, path, match_attr):

    """Searches for element on a path that matches certain attribute value.

    Function follows the path from root node to the desired tags using path,

    then searches for the first one matching the attribute value.

    @type path: string

    @param path: path of nodes to visit

    @type match_attr: tuple

    @param match_attr: pair (attribute, value) for which we search

    @rtype: ET.ElementTree or None

    @return: first element matching match_attr or None if nothing matches

    """

    potential_elements = self.tree.findall(path)

    (attr, val) = match_attr

    for elem in potential_elements:

      if elem.get(attr) == val:

        return elem

    return None

  def _GetElementMatchingText(self, path, match_text):

    """Searches for element on a path that matches certain text value.

    Function follows the path from root node to the desired tags using path,

    then searches for the first one matching the text value.

    @type path: string

    @param path: path of nodes to visit

    @type match_text: tuple

    @param match_text: pair (node, text) for which we search

    @rtype: ET.ElementTree or None

    @return: first element matching match_text or None if nothing matches

    """

    potential_elements = self.tree.findall(path)

    (node, text) = match_text

    for elem in potential_elements:

      if elem.findtext(node) == text:

        return elem

    return None

  @staticmethod

  def _GetDictParameters(root, schema):

    """Reads text in all children and creates the dictionary from the contents.

    @type root: ET.ElementTree or None

    @param root: father of the nodes we want to collect data about

    @type schema: string

    @param schema: schema name to be removed from the tag

    @rtype: dict

    @return: dictionary containing tags and their text contents, tags have their

      schema fragment removed or empty dictionary, when root is None

    """

    if not root:

      return {}

    results = {}

    for element in list(root):

      pref_len = len("{%s}" % schema)

      assert(schema in element.tag)

      tag = element.tag[pref_len:]

      results[tag] = element.text

    return results

  def VerifyManifest(self):

    """Verifies manifest for the OVF package, if one is given.

    @raise errors.OpPrereqError: if SHA1 checksums do not match

    """

    if "%s%s" % (self.schema_name, MF_EXT) in self.files_list:

      logging.warning("Verifying SHA1 checksums, this may take a while")

      manifest_filename = "%s%s" % (self.schema_name, MF_EXT)

      manifest_path = utils.PathJoin(self.input_dir, manifest_filename)

      manifest_content = utils.ReadFile(manifest_path).splitlines()

      manifest_files = {}

      regexp = r"SHA1\((\S+)\)= (\S+)"

      for line in manifest_content:

        match = re.match(regexp, line)

        if match:

          file_name = match.group(1)

          sha1_sum = match.group(2)

          manifest_files[file_name] = sha1_sum

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

        for file_name in self.files_list]

      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:

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

                                     " value in manifest file" % file_name)

      logging.info("SHA1 checksums verified")

  def GetInstanceName(self):

    """Provides information about instance name.

    @rtype: string

    @return: instance name string

    """

    find_name = "{%s}VirtualSystem/{%s}Name" % (OVF_SCHEMA, OVF_SCHEMA)

    return self.tree.findtext(find_name)

  def GetDiskTemplate(self):

    """Returns disk template from .ovf file

    @rtype: string or None

    @return: name of the template

    """

    find_template = ("{%s}GanetiSection/{%s}DiskTemplate" %

                     (GANETI_SCHEMA, GANETI_SCHEMA))

    return self.tree.findtext(find_template)

  def GetHypervisorData(self):

    """Provides hypervisor information - hypervisor name and options.

    @rtype: dict

    @return: dictionary containing name of the used hypervisor and all the

      specified options

    """

    hypervisor_search = ("{%s}GanetiSection/{%s}Hypervisor" %

                         (GANETI_SCHEMA, GANETI_SCHEMA))

    hypervisor_data = self.tree.find(hypervisor_search)

    if not hypervisor_data:

      return {"hypervisor_name": constants.VALUE_AUTO}

    results = {

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

                           default=constants.VALUE_AUTO),

    }

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

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

    return results

  def GetOSData(self):

    """ Provides operating system information - os name and options.

    @rtype: dict

    @return: dictionary containing name and options for the chosen OS

    """

    results = {}

    os_search = ("{%s}GanetiSection/{%s}OperatingSystem" %

                 (GANETI_SCHEMA, GANETI_SCHEMA))

    os_data = self.tree.find(os_search)

    if os_data:

      results["os_name"] = os_data.findtext("{%s}Name" % GANETI_SCHEMA)

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

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

    return results

  def GetBackendData(self):

    """ Provides backend information - vcpus, memory, auto balancing options.

    @rtype: dict

    @return: dictionary containing options for vcpus, memory and auto balance

      settings

    """

    results = {}

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

                   (OVF_SCHEMA, OVF_SCHEMA, OVF_SCHEMA))

    match_vcpus = ("{%s}ResourceType" % RASD_SCHEMA, RASD_TYPE["vcpus"])

    vcpus = self._GetElementMatchingText(find_vcpus, match_vcpus)

    if vcpus:

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

        default=constants.VALUE_AUTO)

    else:

      vcpus_count = constants.VALUE_AUTO

    results["vcpus"] = str(vcpus_count)

    find_memory = find_vcpus

    match_memory = ("{%s}ResourceType" % RASD_SCHEMA, RASD_TYPE["memory"])

    memory = self._GetElementMatchingText(find_memory, match_memory)

    memory_raw = None

    if memory:

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

      matching_units = [units for units, variants in

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

      if matching_units == []:

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

          alloc_units)

      units = matching_units[0]

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

            default=constants.VALUE_AUTO))

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

                   (GANETI_SCHEMA, GANETI_SCHEMA))

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

    results["auto_balance"] = balance

    return results

  def GetTagsData(self):

    """Provides tags information for instance.

    @rtype: string or None

    @return: string of comma-separated tags for the instance

    """

    find_tags = "{%s}GanetiSection/{%s}Tags" % (GANETI_SCHEMA, GANETI_SCHEMA)

    results = self.tree.findtext(find_tags)

    if results:

      return results

    else:

      return None

  def GetVersionData(self):

    """Provides version number read from .ovf file

    @rtype: string

    @return: string containing the version number

    """

    find_version = ("{%s}GanetiSection/{%s}Version" %

                    (GANETI_SCHEMA, GANETI_SCHEMA))

    return self.tree.findtext(find_version)

  def GetNetworkData(self):

    """Provides data about the network in the OVF instance.

    The method gathers the data about networks used by OVF instance. It assumes

    that 'name' tag means something - in essence, if it contains one of the

    words 'bridged' or 'routed' then that will be the mode of this network in

    Ganeti. The information about the network can be either in GanetiSection or

    VirtualHardwareSection.

    @rtype: dict

    @return: dictionary containing all the network information

    """

    results = {}

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

                       (OVF_SCHEMA, OVF_SCHEMA))

    network_names = self._GetAttributes(networks_search,

      "{%s}name" % OVF_SCHEMA)

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

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

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

                        % (OVF_SCHEMA, OVF_SCHEMA, OVF_SCHEMA))

      ganeti_search = ("{%s}GanetiSection/{%s}Network/{%s}Nic" %

                       (GANETI_SCHEMA, GANETI_SCHEMA, GANETI_SCHEMA))

      network_match = ("{%s}Connection" % RASD_SCHEMA, network_name)

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

      network_data = self._GetElementMatchingText(network_search, network_match)

      network_ganeti_data = self._GetElementMatchingAttr(ganeti_search,

        ganeti_match)

      ganeti_data = {}

      if network_ganeti_data:

        ganeti_data["mode"] = network_ganeti_data.findtext("{%s}Mode" %

                                                           GANETI_SCHEMA)

        ganeti_data["mac"] = network_ganeti_data.findtext("{%s}MACAddress" %

                                                          GANETI_SCHEMA)

        ganeti_data["ip"] = network_ganeti_data.findtext("{%s}IPAddress" %

                                                         GANETI_SCHEMA)

        ganeti_data["link"] = network_ganeti_data.findtext("{%s}Link" %

                                                           GANETI_SCHEMA)

      mac_data = None

      if network_data:

        mac_data = network_data.findtext("{%s}Address" % RASD_SCHEMA)

      network_name = network_name.lower()

      # First, some not Ganeti-specific information is collected

      if constants.NIC_MODE_BRIDGED in network_name:

        results["nic%s_mode" % counter] = "bridged"

      elif constants.NIC_MODE_ROUTED in network_name:

        results["nic%s_mode" % counter] = "routed"

      results["nic%s_mac" % counter] = mac_data

      # GanetiSection data overrides 'manually' collected data

      for name, value in ganeti_data.iteritems():

        results["nic%s_%s" % (counter, name)] = value

      # Bridged network has no IP - unless specifically stated otherwise

      if (results.get("nic%s_mode" % counter) == "bridged" and

          not results.get("nic%s_ip" % counter)):

        results["nic%s_ip" % counter] = constants.VALUE_NONE

      for option in required:

        if not results.get("nic%s_%s" % (counter, option)):

          results["nic%s_%s" % (counter, option)] = constants.VALUE_AUTO

    if network_names:

      results["nic_count"] = str(len(network_names))

    return results

  def GetDisksNames(self):

    """Provides list of file names for the disks used by the instance.

    @rtype: list

    @return: list of file names, as referenced in .ovf file

    """

    results = []

    disks_search = "{%s}DiskSection/{%s}Disk" % (OVF_SCHEMA, OVF_SCHEMA)

    disk_ids = self._GetAttributes(disks_search, "{%s}fileRef" % OVF_SCHEMA)

    for disk in disk_ids:

      disk_search = "{%s}References/{%s}File" % (OVF_SCHEMA, OVF_SCHEMA)

      disk_match = ("{%s}id" % OVF_SCHEMA, disk)

      disk_elem = self._GetElementMatchingAttr(disk_search, disk_match)

      if disk_elem is None:

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

                                   " references" % (OVF_EXT, disk))

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

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

      results.append((disk_name, disk_compression))

    return results

def SubElementText(parent, tag, text, attrib={}, **extra):

# pylint: disable=W0102

  """This is just a wrapper on ET.SubElement that always has text content.

  """

  if text is None:

    return None

  elem = ET.SubElement(parent, tag, attrib=attrib, **extra)

  elem.text = str(text)

  return elem

class OVFWriter(object):

  """Writer class for OVF files.

  @type tree: ET.ElementTree

  @ivar tree: XML tree that we are constructing

  @type hardware_list: list

  @ivar hardware_list: list of items prepared for VirtualHardwareSection

  """

  def __init__(self, has_gnt_section):

    """Initialize the writer - set the top element.

    @type has_gnt_section: bool

    @param has_gnt_section: if the Ganeti schema should be added - i.e. this

      means that Ganeti section will be present

    """

    env_attribs = {

      "xmlns:xsi": XML_SCHEMA,

      "xmlns:vssd": VSSD_SCHEMA,

      "xmlns:rasd": RASD_SCHEMA,

      "xmlns:ovf": OVF_SCHEMA,

      "xmlns": OVF_SCHEMA,

      "xml:lang": "en-US",

    }

    if has_gnt_section:

      env_attribs["xmlns:gnt"] = GANETI_SCHEMA

    self.tree = ET.Element("Envelope", attrib=env_attribs)

    self.hardware_list = []

  def SaveDisksData(self, disks):

    """Convert disk information to certain OVF sections.

    @type disks: list

    @param disks: list of dictionaries of disk options from config.ini

    """

    references = ET.SubElement(self.tree, "References")

    disk_section = ET.SubElement(self.tree, "DiskSection")

    for counter, disk in enumerate(disks):

      file_id = "file%s" % counter

      disk_id = "disk%s" % counter

      file_attribs = {

        "ovf:href": disk["path"],

        "ovf:size": str(disk["real-size"]),

        "ovf:id": file_id,

      }

      disk_attribs = {

        "ovf:capacity": str(disk["virt-size"]),

        "ovf:diskId": disk_id,

        "ovf:fileRef": file_id,

        "ovf:format": DISK_FORMAT.get(disk["format"], disk["format"]),

      }

      if "compression" in disk:

        file_attribs["ovf:compression"] = disk["compression"]

      ET.SubElement(references, "File", attrib=file_attribs)

      ET.SubElement(disk_section, "Disk", attrib=disk_attribs)

      # Item in VirtualHardwareSection creation

      disk_item = ET.Element("Item")

      SubElementText(disk_item, "rasd:ElementName", disk_id)

      SubElementText(disk_item, "rasd:ResourceType", RASD_TYPE["disk"])

      SubElementText(disk_item, "rasd:HostResource", "ovf:/disk/%s" % disk_id)

      SubElementText(disk_item, "rasd:Parent", SCSI_ID)

      self.hardware_list.append(disk_item)

  def SaveNetworksData(self, networks):

    """Convert network information to NetworkSection.

    @type networks: list

    @param networks: list of dictionaries of network options form config.ini

    """

    network_section = ET.SubElement(self.tree, "NetworkSection")

    for counter, network in enumerate(networks):

      network_name = "%s%s" % (network["mode"], counter)

      network_attrib = {"ovf:name": network_name}

      ET.SubElement(network_section, "Network", attrib=network_attrib)

      # Item in VirtualHardwareSection creation

      network_item = ET.Element("Item")

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

      SubElementText(network_item, "rasd:ResourceType",

        RASD_TYPE["ethernet-adapter"])

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

      SubElementText(network_item, "rasd:Address", network["mac"])

      self.hardware_list.append(network_item)

  @staticmethod

  def _SaveNameAndParams(root, data):

    """Save name and parameters information under root using data.

    @type root: ET.Element

    @param root: root element for the Name and Parameters

    @type data: dict

    @param data: data from which we gather the values

    """

    assert(data.get("name"))

    name = SubElementText(root, "gnt:Name", data["name"])

    params = ET.SubElement(root, "gnt:Parameters")

    for name, value in data.iteritems():

      if name != "name":

        SubElementText(params, "gnt:%s" % name, value)

  def SaveGanetiData(self, ganeti, networks):

    """Convert Ganeti-specific information to GanetiSection.

    @type ganeti: dict

    @param ganeti: dictionary of Ganeti-specific options from config.ini

    @type networks: list

    @param networks: list of dictionaries of network options form config.ini

    """

    ganeti_section = ET.SubElement(self.tree, "gnt:GanetiSection")

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

    SubElementText(ganeti_section, "gnt:DiskTemplate",

      ganeti.get("disk_template"))

    SubElementText(ganeti_section, "gnt:AutoBalance",

      ganeti.get("auto_balance"))

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

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

    self._SaveNameAndParams(osys, ganeti["os"])

    hypervisor = ET.SubElement(ganeti_section, "gnt:Hypervisor")

    self._SaveNameAndParams(hypervisor, ganeti["hypervisor"])

    network_section = ET.SubElement(ganeti_section, "gnt:Network")

    for counter, network in enumerate(networks):

      network_name = "%s%s" % (network["mode"], counter)

      nic_attrib = {"ovf:name": network_name}

      nic = ET.SubElement(network_section, "gnt:Nic", attrib=nic_attrib)

      SubElementText(nic, "gnt:Mode", network["mode"])

      SubElementText(nic, "gnt:MACAddress", network["mac"])

      SubElementText(nic, "gnt:IPAddress", network["ip"])

      SubElementText(nic, "gnt:Link", network["link"])

  def SaveVirtualSystemData(self, name, vcpus, memory):

    """Convert virtual system information to OVF sections.