Synnefo » snf-ganeti » ganeti-local

                  result.cmd, result.exit_code, result.output)

  # Raise a custom exception (handled in ganeti-noded)

def GetNodeInfo(vgname, hypervisor_type):

    if vginfo:

      vg_free = int(round(vginfo[0][0], 0))

      vg_size = int(round(vginfo[0][1], 0))

  if hypervisor_type is not None:

    hyper = hypervisor.GetHypervisor(hypervisor_type)

  """

  lvs = {}

  if not vg_names:

    vg_names = []

  result = utils.RunCmd(["lvs", "--noheadings", "--units=m", "--nosuffix",

      logging.error("Invalid line returned from lvs output: '%s'", line)

      continue

    vg_name, name, size, attr = match.groups()

    if virtual:

      # we don't want to report such volumes as existing, since they

      # don't really hold data

          result.output)

  def parse_dev(dev):

  def handle_dev(dev):

    return [parse_dev(x) for x in dev.split(",")]

  def map_line(line):

    line = [v.strip() for v in line]

  all_devs = []

  for line in result.stdout.splitlines():

    else:

      logging.warning("Strange line in the output from lvs: '%s'", line)

  return all_devs

  iinfo = hypervisor.GetHypervisor(hname).GetInstanceInfo(instance)

  if iinfo is not None:

  return output

    if iinfo:

      for name, _, memory, vcpus, state, times in iinfo:

        value = {

          }

        if name in output:

          # we only check static parameters, like memory and vcpus,

          # and not state and time which can change between the

          # invocations of the different hypervisors

            if value[key] != output[name][key]:

              _Fail("Instance %s is running twice"

                    " with different parameters", name)

  create_env = OSEnvironment(instance, inst_os, debug)

  if reinstall:

  logfile = _InstanceLogName("add", instance.os, instance.name)

  inst_os = OSFromDisk(instance.os)

  rename_env = OSEnvironment(instance, inst_os, debug)

  logfile = _InstanceLogName("rename", instance.os,

                             "%s-%s" % (old_name, instance.name))

      it's not required to return anything.

  """

  # pylint: disable-msg=W0613

  clist = []

  if disk.children:

                                                   destcmd)

  # all commands have been checked, so we're safe to combine them

  result = utils.RunCmd(["bash", "-c", command])

  @param err: the exception to format

  """

    detail = errno.errorcode[err.errno]

  else:

    detail = str(err)

  os_files = dict.fromkeys(constants.OS_SCRIPTS)

  if max(api_versions) >= constants.OS_API_V15:

  if max(api_versions) >= constants.OS_API_V20:

  else:

    del os_files[constants.OS_SCRIPT_VERIFY]

  result = {}

  api_version = \

    max(constants.OS_API_VERSIONS.intersection(inst_os.api_versions))

  # OS variants

  if api_version >= constants.OS_API_V15:

    variant = objects.OS.GetVariant(os_name)

    if not variant:

      variant = inst_os.supported_variants[0]

  # OS params

  for pname, pvalue in os_params.items():

  return result

  for attr in ["name", "os", "uuid", "ctime", "mtime", "primary_node"]:

    result["INSTANCE_%s" % attr.upper()] = str(getattr(instance, attr))

  # Disks

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

    real_disk = _OpenRealBD(disk)

    if constants.HV_DISK_TYPE in instance.hvparams:

        instance.hvparams[constants.HV_DISK_TYPE]

    if disk.dev_type in constants.LDS_BLOCK:

    elif disk.dev_type == constants.LD_FILE:

  # NICs

  for idx, nic in enumerate(instance.nics):

    if nic.ip:

    if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:

    if nic.nicparams[constants.NIC_LINK]:

    if constants.HV_NIC_TYPE in instance.hvparams:

        instance.hvparams[constants.HV_NIC_TYPE]

  # HV/BE params

  config = objects.SerializableConfigParser()

  config.add_section(constants.INISECT_EXP)

  config.set(constants.INISECT_EXP, "compression", "none")

  config.add_section(constants.INISECT_INS)

             instance.beparams[constants.BE_MEMORY])

             instance.beparams[constants.BE_VCPUS])

  config.set(constants.INISECT_INS, "tags", " ".join(instance.GetTags()))

  nic_total = 0

  for nic_count, nic in enumerate(instance.nics):

    nic_total += 1

    for param in constants.NICS_PARAMETER_TYPES:

  # TODO: redundant: on load can read nics until it doesn't exist

  disk_total = 0

  for disk_count, disk in enumerate(snap_disks):

    if disk:

      disk_total += 1

  # New-style hypervisor/backend parameters