Synnefo » snf-ganeti

        "vg_free": int(round(float(valarr[1]), 0)),

        "pv_count": int(valarr[2]),

        }

      logging.exception("Fail to parse vgs output")

  else:

    logging.error("vgs output has the wrong number of fields (expected"

    try:

      major = int(major)

      minor = int(minor)

      logging.error("lvs major/minor cannot be parsed: %s", str(err))

    try:

                  result.fail_reason, result.output)

    try:

      sectors = int(result.stdout)

      _ThrowError("Invalid output from blockdev: '%s'", result.stdout)

    bytes = sectors * 512

    if bytes < 128 * 1024 * 1024: # less than 128MiB

      if unitfields.Matches(fields[idx]):

        try:

          val = int(val)

          pass

        else:

          val = row[idx] = utils.FormatUnit(val, units)

  if value[-1] not in suffix_map:

    try:

      value = int(value)

      raise errors.OpPrereqError("Invalid time specification '%s'" % value)

  else:

    multiplier = suffix_map[value[-1]]

                                 " suffix passed)")

    try:

      value = int(value) * multiplier

      raise errors.OpPrereqError("Invalid time specification '%s'" % value)

  return value

        raise errors.OpPrereqError("Missing disk size")

      try:

        size = int(size)

        raise errors.OpPrereqError("Invalid disk size '%s'" % size)

      self.disks.append({"size": size, "mode": mode})

          raise errors.OpPrereqError("Required disk parameter size missing")

        try:

          size = int(size)

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

                                     str(err))

        disk_dict['size'] = size

                                     " '%s'" % (nname, attr))

          try:

            remote_info[attr] = int(remote_info[attr])

            raise errors.OpExecError("Node '%s' returned invalid value"

                                     " for '%s': %s" % (nname, attr, err))

        # compute memory used by primary instances

    if hdr_content_length:

      try:

        self.content_length = int(hdr_content_length)

        self.content_length = None

      if self.content_length is not None and self.content_length < 0:

        self.content_length = None

      status = int(status)

      if status < 100 or status > 999:

        status = -1

      status = -1

    if status == -1:

        data[2] = int(data[2])

        data[3] = int(data[3])

        data[5] = float(data[5])

        raise errors.HypervisorError("Can't parse output of xm list,"

                                     " line: %s, error: %s" % (line, err))

    try:

      idx = int(idx)

      return self.disks[idx]

      raise errors.OpPrereqError("Invalid disk index: '%s'" % str(err))

    except IndexError:

      raise errors.OpPrereqError("Invalid disk index: %d (instace has disks"

  try:

    pid = int(pf.read())

    logging.info("Can't parse pid file contents", exc_info=True)

    return 0

  if opts.nics:

    try:

      nic_max = max(int(nidx[0])+1 for nidx in opts.nics)

      raise errors.OpPrereqError("Invalid NIC index passed: %s" % str(err))

    nics = [{}] * nic_max

    for nidx, ndict in opts.nics:

      opts.disks = [(0, {"size": opts.sd_size})]

    try:

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

      raise errors.OpPrereqError("Invalid disk index passed: %s" % str(err))

    disks = [{}] * disk_max

    for didx, ddict in opts.disks:

        raise errors.OpPrereqError("Missing size for disk %d" % didx)

      try:

        ddict["size"] = utils.ParseUnit(ddict["size"])

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

                                   (didx, err))

      disks[didx] = ddict

  if opts.nics:

    try:

      nic_max = max(int(nidx[0])+1 for nidx in opts.nics)

      raise errors.OpPrereqError("Invalid NIC index passed: %s" % str(err))

    nics = [{}] * nic_max

    for nidx, ndict in opts.nics:

      opts.disks = [(0, {"size": opts.sd_size})]

    try:

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

      raise errors.OpPrereqError("Invalid disk index passed: %s" % str(err))

    disks = [{}] * disk_max

    for didx, ddict in opts.disks:

        raise errors.OpPrereqError("Missing size for disk %d" % didx)

      try:

        ddict["size"] = utils.ParseUnit(ddict["size"])

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

                                   (didx, err))

      disks[didx] = ddict

    for elem in specs['disk_size']:

      try:

        size = utils.ParseUnit(elem)

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

                                   " instance %s: %s" %

                                   (elem, name, err))

  disk = args[1]

  try:

    disk = int(disk)

    raise errors.OpPrereqError("Invalid disk index: %s" % str(err))

  amount = utils.ParseUnit(args[2])

  op = opcodes.OpGrowDisk(instance_name=instance, disk=disk, amount=amount,

  else:

    try:

      disks = [int(i) for i in opts.disks.split(",")]

      raise errors.OpPrereqError("Invalid disk index passed: %s" % str(err))

  cnt = [opts.on_primary, opts.on_secondary,

         new_2ndary is not None, iallocator is not None].count(True)

    try:

      nic_op = int(nic_op)

      opts.nics[idx] = (nic_op, nic_dict)

      pass

  for idx, (disk_op, disk_dict) in enumerate(opts.disks):

    try:

      disk_op = int(disk_op)

      opts.disks[idx] = (disk_op, disk_dict)

      pass

    if disk_op == constants.DDM_ADD:

      if 'size' not in disk_dict: