Synnefo » snf-ganeti

	HBINARY="./htools/hpc-htools" ./htools/offline-test.sh

# E111: indentation is not a multiple of four

# E261: at least two spaces before inline comment

# E501: line too long (80 characters)

# For excluding pep8 expects filenames only, not whole paths

PEP8_EXCLUDE = $(subst $(space),$(comma),$(strip $(notdir $(BUILT_PYTHON_SOURCES))))

#!/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

  sw.Write("}")

  for (fnname, paths) in [

    sw.Write("_ganeti_%s() {", fnname)

    sw.IncIndent()

    try:

The same with pep8, other versions may give you errors::

     $ pep8 --version

To generate unittest coverage reports (``make coverage``), `coverage

<http://pypi.python.org/pypi/coverage>`_ needs to be installed.

               logilab-astng==0.20.1 \

               logilab-common==0.50.3 \

               pylint==0.21.1 \

               coverage

For Haskell development, again all things from the quick install

  except errors.ConfigurationError, err:

    _Fail("Cluster configuration incomplete: %s", err, exc=True)

  return (master_netdev, master_ip, master_node, primary_ip_family,

def RunLocalHooks(hook_opcode, hooks_path, env_builder_fn):

    else:

      source = None

    result[constants.NV_MASTERIP] = netutils.TcpPing(master_ip, port,

  if constants.NV_USERSCRIPTS in what:

    result[constants.NV_USERSCRIPTS] = \

    runparts_results = utils.RunParts(dir_name, env=env, reset_env=True)

      if relstatus == constants.RUNPARTS_SKIP:

        rrval = constants.HKR_SKIP

        output = ""

                                    first_line)

    values = version.groups()

    if values[5] is not None:

      retval["proto2"] = values[5]

  @classmethod

  def _ComputeDiskBarrierArgs(cls, vmaj, vmin, vrel, disabled_barriers,

    """Compute the DRBD command line parameters for disk barriers

    Returns a list of the disk barrier parameters as requested via the

                   "--c-delay-target", params[constants.LDP_DELAY_TARGET],

                   "--c-max-rate", params[constants.LDP_MAX_RATE],

                   "--c-min-rate", params[constants.LDP_MIN_RATE],

    else:

      args.extend(["-r", "%d" % params[constants.LDP_RESYNC_RATE]])

  msg = result.fail_msg

  if msg:

    logging.error("Could not disable the master role on the old master"

  logging.info("Checking master IP non-reachability...")

                            completion_suggest=OPT_COMPL_ONE_IALLOCATOR)

DEFAULT_IALLOCATOR_OPT = cli_option("-I", "--default-iallocator",

OS_OPT = cli_option("-o", "--os-type", dest="os", help="What OS to run",

                    metavar="<os>",

                    completion_suggest=OPT_COMPL_ONE_OS)

OSPARAMS_OPT = cli_option("-O", "--os-parameters", dest="osparams",

FORCE_VARIANT_OPT = cli_option("--force-variant", dest="force_variant",

                               action="store_true", default=False,

SPECS_DISK_SIZE_OPT = cli_option("--specs-disk-size", dest="ispecs_disk_size",

                                 type="keyval", default={},

                                 help="Disk size specs: list of key=value,"

                                 " (in MB or using a unit)")

SPECS_NIC_COUNT_OPT = cli_option("--specs-nic-count", dest="ispecs_nic_count",

                                 " where key is one of min, max, std")

IPOLICY_DISK_TEMPLATES = cli_option("--ipolicy-disk-templates",

IPOLICY_VCPU_RATIO = cli_option("--ipolicy-vcpu-ratio",

                                 dest="ipolicy_vcpu_ratio",

                               " (excluded from allocation operations)"))

CAPAB_MASTER_OPT = cli_option("--master-capable", dest="master_capable",

CAPAB_VM_OPT = cli_option("--vm-capable", dest="vm_capable",

ALLOCATABLE_OPT = cli_option("--allocatable", dest="allocatable",

                             type="bool", default=None, metavar=_YORNO,

                                default=None)

USE_EXTERNAL_MIP_SCRIPT = cli_option("--use-external-mip-script",

GLOBAL_FILEDIR_OPT = cli_option("--file-storage-dir", dest="file_storage_dir",

                                help="Specify the default directory (cluster-"

                                metavar="DIR",

                                default=constants.DEFAULT_FILE_STORAGE_DIR)

NOMODIFY_ETCHOSTS_OPT = cli_option("--no-etc-hosts", dest="modify_etc_hosts",

                                   help="Don't modify /etc/hosts",

                         help="Maximum time to wait")

SHUTDOWN_TIMEOUT_OPT = cli_option("--shutdown-timeout",

INTERVAL_OPT = cli_option("--interval", dest="interval", type="int",

                          default=None,

                                     " certificate"))

SPICE_CERT_OPT = cli_option("--spice-certificate", dest="spice_cert",

SPICE_CACERT_OPT = cli_option("--spice-ca-certificate", dest="spice_cacert",

NEW_SPICE_CERT_OPT = cli_option("--new-spice-certificate",

NEW_CONFD_HMAC_KEY_OPT = cli_option("--new-confd-hmac-key",

                                    dest="new_confd_hmac_key",

                                   " removed from the user-id pool"))

RESERVED_LVS_OPT = cli_option("--reserved-lvs", default=None,

ROMAN_OPT = cli_option("--roman",

                       dest="roman_integers", default=False,

                              help="Specify if the SoR for node is powered")

OOB_TIMEOUT_OPT = cli_option("--oob-timeout", dest="oob_timeout", type="int",

POWER_DELAY_OPT = cli_option("--power-delay", dest="power_delay", type="float",

                             default=constants.OOB_POWER_DELAY,

  elif isinstance(err, errors.OpPrereqError):

    if len(err.args) == 2:

      obuf.write("Failure: prerequisites not met for this"

                 (err.args[1], err.args[0]))

    else:

      obuf.write("Failure: prerequisites not met for this"

                    help="Recover from an EPO")

GROUPS_OPT = cli_option("--groups", default=False,

SHOW_MACHINE_OPT = cli_option("-M", "--show-machine-names", default=False,

                              action="store_true",

  return pem

                 rapi_cert_filename, new_spice_cert, spice_cert_filename,

                 spice_cacert_filename, new_confd_hmac_key, new_cds,

                 cds_filename, force):

      if not names:

        raise errors.OpPrereqError("No node names passed", errors.ECODE_INVAL)

      ndata = client.QueryNodes(names, ["name", "pinst_list", "sinst_list"],

    ipri = [row[1] for row in ndata]

    pri_names = list(itertools.chain(*ipri))

    "summary": (lambda value: ",".join(str(item) for item in value), False),

    }

  fmtoverride.update(dict.fromkeys(["opstart", "opexec", "opend"],

  qfilter = qlang.MakeSimpleFilter("status", opts.status_filter)

                     disk_sizes, spindle_use)

  """Compute if instance specs meets the specs of ipolicy.

  @type ipolicy: dict

      # Always depend on global verification

      depends_fn = lambda: [(-len(jobs), [])]

    # Fix up all parameters

    for op in itertools.chain(*jobs): # pylint: disable=W0142

    if drbd_helper:

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

      _ErrorIf(test, constants.CV_ENODEDRBDHELPER, node,

               "no drbd usermode helper returned")

      if helper_result:

    res_instances = set()

    res_missing = {}

    if nv_dict:

      nodes = utils.NiceSort(set(self.owned_locks(locking.LEVEL_NODE)) &

    files_mc.add(constants.CLUSTER_CONF_FILE)

  # Files which should only be on VM-capable nodes

    for hv_name in cluster.enabled_hypervisors

    for filename in hypervisor.GetHypervisor(hv_name).GetAncillaryFiles()[0])

    for hv_name in cluster.enabled_hypervisors

    for filename in hypervisor.GetHypervisor(hv_name).GetAncillaryFiles()[1])

                    type(result.payload))

    if self.op.command in [

      if result.payload is not None:

        errs.append("%s is expected to not return payload but got '%s'" %

                    (self.op.command, result.payload))

    if not newbie_singlehomed:

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

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

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

                                   " based ping to node daemon port",

                                   errors.ECODE_ENVIRON)

                                 errors.ECODE_INVAL)

    # Boolean value that tells us whether we might be demoting from MC

    if self.op.secondary_ip:

      if not netutils.IP4Address.IsValid(self.op.secondary_ip):

                                 " it a master candidate" % node.name,

                                 errors.ECODE_STATE)

      (ipri, isec) = self.cfg.GetNodeInstances(self.op.node_name)

      if ipri or isec:

        raise errors.OpPrereqError("Node %s hosts instances, cannot unset"

    # Check for ineffective changes

    for attr in self._FLAGS:

        self.LogInfo("Ignoring request to unset flag %s, already unset", attr)

        setattr(self.op, attr, None)

    # TODO: We might query the real power state if it supports OOB

    if _SupportsOob(self.cfg, node):

      if self.op.offline is False and not (node.powered or

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

                                    " offline status can be reset") %

                                   self.op.node_name, errors.ECODE_STATE)

                                 errors.ECODE_STATE)

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

        (self.op.master_capable and not node.master_capable)):

      if _DecideSelfPromotion(self):

        self.op.master_candidate = True

        self.LogInfo("Auto-promoting node to master candidate")

    # If we're no longer master capable, we'll demote ourselves from MC

      self.LogInfo("Demoting from master candidate")

      self.op.master_candidate = False

                                  ial.required_nodes), errors.ECODE_FAULT)

    self.target_node = ial.result[0]

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

  def _WaitUntilSync(self):

    """Poll with custom rpc for disk sync.

      # Don't raise an exception here, as we stil have to try to revert the

      # disk status, even if this step failed.

    abort_msg = abort_result.fail_msg

    if abort_msg:

      logging.error("Aborting migration failed on source node %s: %s",

  }

  """Generate the entire disk layout for a given template type.

  """

    enabled_hvs = cluster.enabled_hypervisors

    if self.op.hypervisor not in enabled_hvs:

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

                                 errors.ECODE_STATE)

    # Check tag validity

        assert not self.needed_locks[locking.LEVEL_NODE]

        # Lock member nodes of all locked groups

      else:

        self._LockInstancesNodes()

    elif level == locking.LEVEL_NODE_RES:

    if self.op.hvparams:

      _CheckGlobalHvParams(self.op.hvparams)

    # Check disk modifications

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

                           " free memory information" % pnode)

        elif instance_info.fail_msg:

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

        else:

          if instance_info.payload:

            current_mem = int(instance_info.payload["memory"])

            self.op.runtime_mem < self.be_proposed[constants.BE_MINMEM])):

        raise errors.OpPrereqError("Instance %s must have memory between %d"

                                   " and %d MB of memory unless --force is"

                                    self.be_proposed[constants.BE_MINMEM],

                                    self.be_proposed[constants.BE_MAXMEM]),

                                   errors.ECODE_INVAL)

                       ht.TItems([ht.TNonEmptyString,

                                  ht.TNonEmptyString,

                                  ht.TListOf(ht.TNonEmptyString),

  _NEVAC_FAILED = \

    ht.TListOf(ht.TAnd(ht.TIsLength(2),

                       ht.TItems([ht.TNonEmptyString,

                                  ht.TMaybeString,

  _NEVAC_RESULT = ht.TAnd(ht.TIsLength(3),

                          ht.TItems([_NEVAC_MOVED, _NEVAC_FAILED, _JOB_LIST]))

#

#

#

# 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

                                        server_port=port,

                                        extra_args=rq.args,

                                        client=self,

      self._callback(client_reply)

    finally:

    """

    cluster = self._config_data.cluster

      ip_family=cluster.primary_ip_family)

    return result

    HV_CPU_MASK: CPU_PINNING_ALL,

    HV_CPU_TYPE: "",

    },

  HT_CHROOT: {

    HV_INIT_SCRIPT: "/ganeti-chroot",

    },

  LD_LV: {

    LDP_STRIPES: _autoconf.LVM_STRIPECOUNT

    },

  LD_RBD: {

    LDP_POOL: "rbd"

    },

    DRBD_MAX_RATE: _DRBD_DEFAULTS[LDP_MAX_RATE],

    DRBD_MIN_RATE: _DRBD_DEFAULTS[LDP_MIN_RATE],

    },

  DT_RBD: {

    RBD_POOL: DISK_LD_DEFAULTS[LD_RBD][LDP_POOL]

    },

#

#

#

# 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

    """

    GanetiBaseAsyncoreDispatcher.__init__(self)

    (self.in_socket, self.out_socket) = socket.socketpair(socket.AF_UNIX,

                                                          socket.SOCK_STREAM)

    self.in_socket.setblocking(0)

#

#

#

# 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 version_number >= (2, 0):

        raise http.HttpVersionNotSupported("Invalid HTTP Version (%s)" %

    elif len(words) == 2:

      version = http.HTTP_0_9

#

#

#

# 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

# must be afile

_FILE_CHECK = (utils.IsNormAbsPath, "must be an absolute normalized path",

# must be a directory

_DIR_CHECK = (utils.IsNormAbsPath, "must be an absolute normalized path",

# CPU mask must be well-formed

# TODO: implement node level check for the CPU mask

       None, None),

    constants.HV_KVM_SPICE_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,

    constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR:

    constants.HV_KVM_SPICE_JPEG_IMG_COMPR:

    constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR:

    constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION:

    constants.HV_KVM_SPICE_AUDIO_COMPR: hv_base.NO_CHECK,

    constants.HV_KVM_SPICE_USE_TLS: hv_base.NO_CHECK,

    constants.HV_KVM_SPICE_TLS_CIPHERS: hv_base.NO_CHECK,

  def _VerifyAffinityPackage():

    if affinity is None:

      raise errors.HypervisorError("affinity Python package not"

  @staticmethod

  def _BuildAffinityCpuMask(cpu_list):

        # If CPU pinning has one non-all entry, map the entire VM to

        # one set of physical CPUs

        cls._VerifyAffinityPackage()

    else:

      # The number of vCPUs mapped should match the number of vCPUs

      # reported by KVM. This was already verified earlier, so

      # For each vCPU, map it to the proper list of physical CPUs

      for vcpu, i in zip(cpu_list, range(len(cpu_list))):

        affinity.set_process_affinity_mask(thread_dict[i],

  def _GetVcpuThreadIds(self, instance_name):

    """Get a mapping of vCPU no. to thread IDs for the instance

      spice_arg = "addr=%s" % spice_address

      if hvp[constants.HV_KVM_SPICE_USE_TLS]:

        tls_ciphers = hvp[constants.HV_KVM_SPICE_TLS_CIPHERS]

        if tls_ciphers:

          spice_arg = "%s,tls-ciphers=%s" % (spice_arg, tls_ciphers)

            tap_extra = ",vhost=on"

          else:

            raise errors.HypervisorError("vhost_net is configured"

      else:

        nic_model = nic_type

    if (v_major, v_min) >= (0, 14):

      logging.debug("Enabling QMP")

      kvm_cmd.extend(["-qmp", "unix:%s,server,nowait" %

    # Configure the network now for starting instances and bridged interfaces,

    # during FinalizeMigration for incoming instances' routed interfaces

      self._CallMonitorCommand(instance_name, "stop")

    migrate_command = ("migrate_set_speed %dm" %

    self._CallMonitorCommand(instance_name, migrate_command)

    migrate_command = ("migrate_set_downtime %dms" %

    self._CallMonitorCommand(instance_name, migrate_command)

    migrate_command = "migrate -d tcp:%s:%s" % (target, port)

      time.sleep(self._MIGRATION_INFO_RETRY_DELAY)

    return objects.MigrationStatus(status=constants.HV_MIGRATION_FAILED,

  def BalloonInstanceMemory(self, instance, mem):

    """Balloon an instance memory to a certain value.

#

#

#

# 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

    # point in acquiring any other lock, unless perhaps we are half way through

    # the migration of the current opcode.

    assert (self._contains_BGL(level, names) or self._BGL_owned()), (

    # Check we don't own locks at the same or upper levels.

    assert not self._upper_owned(level), ("Cannot acquire locks at a level"

    # Acquire the locks in the set.

    return self.__keyring[level].acquire(names, shared=shared, timeout=timeout,

    assert level in LEVELS, "Invalid locking level %s" % level

    assert (not self._contains_BGL(level, names) or

            not self._upper_owned(LEVEL_CLUSTER)), (

    # Release will complain if we don't own the locks already

    return self.__keyring[level].release(names)

    """

    assert level in LEVELS_MOD, "Invalid or immutable level %s" % level

    assert self._BGL_owned(), ("You must own the BGL before performing other"

    assert not self._upper_owned(level), ("Cannot add locks at a level"

    return self.__keyring[level].add(names, acquired=acquired, shared=shared)

  def remove(self, level, names):

    """

    assert level in LEVELS_MOD, "Invalid or immutable level %s" % level

    assert self._BGL_owned(), ("You must own the BGL before performing other"

    # Check we either own the level or don't own anything from here

    # up. LockSet.remove() will check the case in which we don't own

    # all the needed resources, or we have a shared ownership.

#

#

#

# 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

class HooksMaster(object):

  def __init__(self, opcode, hooks_path, nodes, hooks_execution_fn,

    """Base class for hooks masters.

    This class invokes the execution of hooks according to the behaviour

        GetVolumeList()

    """

      node = self.primary_node

    if lvmap is None:

    # code can be removed once upgrading straight from 2.0 is deprecated.

    if self.default_hypervisor is not None:

      self.enabled_hypervisors = ([self.default_hypervisor] +

      self.default_hypervisor = None

    # maintain_node_health added after 2.1.1

  @ivar fields: List of L{QueryFieldDefinition} objects

  """

class MigrationStatus(ConfigObject):

    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)

  ]

CALLS = {

    _Prepare(_IMPEXP_CALLS + _X509_CALLS + _OS_CALLS + _NODE_CALLS +

             _FILE_STORAGE_CALLS + _MISC_CALLS + _INSTANCE_CALLS +

             _BLOCKDEV_CALLS + _STORAGE_CALLS),

    # Locking manager

    self.glm = locking.GanetiLockManager(

    self.cfg.SetContext(self)

  mainloop = daemon.Mainloop()

  server = \

    http.server.HttpServer(mainloop, options.bind_address, options.port,

  server.Start()

  return (mainloop, server)

#

#

#

# 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

  server = \

    http.server.HttpServer(mainloop, options.bind_address, options.port,

  server.Start()

  return (mainloop, server)

  """

  parser = optparse.OptionParser(description="Ganeti Remote API",

  daemon.GenericMain(constants.RAPI, parser, CheckRapi, PrepRapi, ExecRapi,

                     default_ssl_cert=constants.RAPI_CERT_FILE,

#

#

#

# 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 os.path.isfile(file_name):

    raise errors.ProgrammerError("Can't make a backup of a non-file '%s'" %