Synnefo » snf-ganeti

                  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

                # one line for any non-empty string

      logging.error("Can't parse LVS output, no lines? Got '%s'", str(out))

      return False

    out = out.split(",")

    if len(out) != 5:

      logging.error("Can't parse LVS output, len(%s) != 5", str(out))

    self.minor = minor

    self.pe_size = pe_size

    self.stripe_count = stripes

                                      # storage

    self.attached = True

    return True

    BlockDev.SetInfo(self, text)

    # Replace invalid characters

    # Only up to 128 characters are allowed

    text = text[:128]

                                    first_line)

    values = version.groups()

             }

    if values[5] is not None:

    return retval

    super(DRBD8, self).__init__(unique_id, children, size)

    self.major = self._DRBD_MAJOR

    version = self._GetVersion(self._GetProcData())

      _ThrowError("Mismatch in DRBD kernel version and requested ganeti"

                  " usage: kernel is %s.%s, ganeti wants 8.x",

    if (self._lhost is not None and self._lhost == self._rhost and

        self._lport == self._rport):

            pyp.Optional(pyp.restOfLine).suppress())

    # an entire section

    section = section_name + lbrace + pyp.ZeroOrMore(pyp.Group(stmt)) + rbrace

    bnf = pyp.ZeroOrMore(pyp.Group(section ^ stmt))

      # what we aim here is to revert back to the 'drain' method of

      # disk flushes and to disable metadata barriers, in effect going

      # back to pre-8.0.7 behaviour

      assert vmaj == 8

      if vmin == 0: # 8.0.x

        if vrel >= 12:

      elif vmin == 2: # 8.2.x

        if vrel >= 7:

      elif vmaj >= 3: # 8.3.x or newer

    result = utils.RunCmd(args)

    if result.failed:

      _ThrowError("drbd%d: can't attach local disk: %s", minor, result.output)

    if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:

      raise ValueError("Invalid configuration data %s" % str(unique_id))

    self.dev_path = unique_id[1]

      raise ValueError("Full path '%s' lies outside /dev" %

                              os.path.realpath(self.dev_path))

    # TODO: this is just a safety guard checking that we only deal with devices

  """

  if ":" not in value:

  else:

    ident, rest = value.split(":", 1)

                           " (defaults to one space)"))

USEUNITS_OPT = cli_option("--units", default=None,

                          help="Specify units for output (one of h/m/g/t)")

FIELDS_OPT = cli_option("-o", "--output", dest="output", action="store",

  """Splits the value of a --node option.

  """

  else:

    return (value, None)

  """

  if os_variants:

  else:

    return [os_name]

  """

  if choices is None:

  if not choices or not isinstance(choices, list):

    raise errors.ProgrammerError("Invalid choices argument to AskUser")

  for entry in choices:

      raise errors.ProgrammerError("Invalid choices element to AskUser")

  answer = choices[-1][1]

  try:

    chars = [entry[0] for entry in choices]

    chars[-1] = "[%s]" % chars[-1]

    maps = dict([(entry[0], entry[1]) for entry in choices])

    while True:

      f.write(text)

      f.write("/".join(chars))

      f.write(": ")

      line = f.readline(2).strip().lower()

      if line in maps:

        answer = maps[line]

        break

        for entry in choices:

          f.write(" %s - %s\n" % (entry[0], entry[2]))

        f.write("\n")

    retcode = 0

  else:

    obuf.write("Unhandled exception: %s" % msg)

def GenericMain(commands, override=None, aliases=None):

  if separator is None:

    mlens = [0 for name in fields]

  else:

    format_str = separator.replace("%", "%%").join(format_fields)

  for line in data:

    args = []

    if line is None:

    for idx in range(len(fields)):

      if separator is None:

        args.append(mlens[idx])

  """

  if not isinstance (ts, (tuple, list)) or len(ts) != 2:

  sec, usec = ts

  return time.strftime("%F %T", time.localtime(sec)) + ".%06d" % usec

  if not value:

    raise errors.OpPrereqError("Empty time specification passed")

  suffix_map = {

    }

  if value[-1] not in suffix_map:

    try:

      stream.write(txt % args)

    else:

      stream.write(txt)

    stream.flush()

  except IOError, err:

    if err.errno == errno.EPIPE:

commands = {

    InitCluster, [ArgHost(min=1, max=1)],

    [BACKEND_OPT, CP_SIZE_OPT, ENABLED_HV_OPT, GLOBAL_FILEDIR_OPT,

     HVLIST_OPT, MAC_PREFIX_OPT, MASTER_NETDEV_OPT, NIC_PARAMS_OPT,

     DEFAULT_IALLOCATOR_OPT, PRIMARY_IP_VERSION_OPT, PREALLOC_WIPE_DISKS_OPT,

     NODE_PARAMS_OPT, GLOBAL_SHARED_FILEDIR_OPT],

    "[opts...] <cluster_name>", "Initialises a new cluster configuration"),

    DestroyCluster, ARGS_NONE, [YES_DOIT_OPT],

    "", "Destroy cluster"),

    RenameCluster, [ArgHost(min=1, max=1)],

    [FORCE_OPT, DRY_RUN_OPT],

    "<new_name>",

    "Renames the cluster"),

    RedistributeConfig, ARGS_NONE, [SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT],

    "", "Forces a push of the configuration file and ssconf files"

    " to the nodes in the cluster"),

    VerifyCluster, ARGS_NONE,

    [VERBOSE_OPT, DEBUG_SIMERR_OPT, ERROR_CODES_OPT, NONPLUS1_OPT,

     DRY_RUN_OPT, PRIORITY_OPT, NODEGROUP_OPT],

    "", "Does a check on the cluster configuration"),

    VerifyDisks, ARGS_NONE, [PRIORITY_OPT],

    "", "Does a check on the cluster disk status"),

    RepairDiskSizes, ARGS_MANY_INSTANCES, [DRY_RUN_OPT, PRIORITY_OPT],

    "", "Updates mismatches in recorded disk sizes"),

    MasterFailover, ARGS_NONE, [NOVOTING_OPT],

    "", "Makes the current node the master"),

    MasterPing, ARGS_NONE, [],

    "", "Checks if the master is alive"),

    ShowClusterVersion, ARGS_NONE, [],

    "", "Shows the cluster version"),

    ShowClusterMaster, ARGS_NONE, [],

    "", "Shows the cluster master"),

    ClusterCopyFile, [ArgFile(min=1, max=1)],

    [NODE_LIST_OPT, USE_REPL_NET_OPT, NODEGROUP_OPT],

    "[-n node...] <filename>", "Copies a file to all (or only some) nodes"),

    RunClusterCommand, [ArgCommand(min=1)],

    [NODE_LIST_OPT, NODEGROUP_OPT],

    "[-n node...] <command>", "Runs a command on all (or only some) nodes"),

    ShowClusterConfig, ARGS_NONE, [ROMAN_OPT],

    "[--roman]", "Show cluster configuration"),

    ListTags, ARGS_NONE, [], "", "List the tags of the cluster"),

    AddTags, [ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT],

    "tag...", "Add tags to the cluster"),

    RemoveTags, [ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT],

    "tag...", "Remove tags from the cluster"),

    SearchTags, [ArgUnknown(min=1, max=1)], [PRIORITY_OPT], "",

    "Searches the tags on all objects on"

    " the cluster for a given pattern (regex)"),

    QueueOps,

    [ArgChoice(min=1, max=1, choices=["drain", "undrain", "info"])],

    [], "drain|undrain|info", "Change queue properties"),

    WatcherOps,

    [ArgChoice(min=1, max=1, choices=["pause", "continue", "info"]),

     ArgSuggest(min=0, max=1, choices=["30m", "1h", "4h"])],

    [],

    "{pause <timespec>|continue|info}", "Change watcher properties"),

    SetClusterParams, ARGS_NONE,

    [BACKEND_OPT, CP_SIZE_OPT, ENABLED_HV_OPT, HVLIST_OPT, MASTER_NETDEV_OPT,

     NIC_PARAMS_OPT, NOLVM_STORAGE_OPT, VG_NAME_OPT, MAINTAIN_NODE_HEALTH_OPT,

#: dictionary with aliases for commands

aliases = {

}

    while len(row) < 3:

      row.append(None)

    for i in range(3):

        row[i] = None

  nic_dict = [{

    constants.INIC_MAC: v[0],

commands = {

    Delay, [ArgUnknown(min=1, max=1)],

    [cli_option("--no-master", dest="on_master", default=True,

                action="store_false", help="Do not sleep in the master code"),

     DRY_RUN_OPT, PRIORITY_OPT,

     ],

    "[opts...] <duration>", "Executes a TestDelay OpCode"),

    GenericOpCodes, [ArgFile(min=1)],

    [VERBOSE_OPT,

     cli_option("--op-repeat", type="int", default="1", dest="rep_op",

     ],

    "<op_list_file...>", "Submits jobs built from json files"

    " containing a list of serialized opcodes"),

    TestAllocator, [ArgUnknown(min=1)],

    [cli_option("--dir", dest="direction", default=constants.IALLOCATOR_DIR_IN,

                choices=list(constants.VALID_IALLOCATOR_DIRECTIONS),

                    "hvparams": {},

                    "file_storage_dir": None,

                    "force_variant": False,

  def _PopulateWithDefaults(spec):

    """Returns a new hash combined with default values."""

  def _Validate(spec):

    """Validate the instance specs."""

    # Validate fields required under any circumstances

      if required_field not in spec:

        raise errors.OpPrereqError('Required field "%s" is missing.' %

                                   required_field, errors.ECODE_INVAL)

    # Validate special fields

                                   errors.ECODE_INVAL)

                                 errors.ECODE_INVAL)

                                 errors.ECODE_INVAL)

  json_filename = args[0]

    specs = _PopulateWithDefaults(specs)

    _Validate(specs)

    disks = []

      try:

        size = utils.ParseUnit(elem)

      except (TypeError, ValueError), err:

                                   (elem, name, err), errors.ECODE_INVAL)

      disks.append({"size": size})

    utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES)

    tmp_nics = []

          tmp_nics.append({})

        tmp_nics[0][field] = specs[field]

      raise errors.OpPrereqError("'nics' list incompatible with using"

                                 " individual nic fields as well",

                                 errors.ECODE_INVAL)

    elif not tmp_nics:

      tmp_nics = [{}]

    op = opcodes.OpInstanceCreate(instance_name=name,

                                  disks=disks,

                                  mode=constants.INSTANCE_CREATE,

                                  force_variant=specs["force_variant"],

                                  nics=tmp_nics,

                                  wait_for_sync=True,

                                  hypervisor=hypervisor,

                                  hvparams=hvparams,

    jex.QueueJob(name, op)

  # we never want to wait, just show the submitted job IDs

        choices.append(("%s" % number, entry, entry))

        number += 1

    selected = AskUser("Enter OS template number (or x to abort):",

                       choices)

      ToStderr("User aborted reinstall, exiting")

      return 1

      _FormatList(buf, _FormatBlockDevInfo(idx, True, device,

                  opts.roman_integers), 2)

  return retcode

    except (TypeError, ValueError):

      pass

    if disk_op == constants.DDM_ADD:

        raise errors.OpPrereqError("Missing required parameter 'size'",

                                   errors.ECODE_INVAL)

  if (opts.disk_template and

      opts.disk_template in constants.DTS_INT_MIRROR and

  ]

commands = {

    AddInstance, [ArgHost(min=1, max=1)], COMMON_CREATE_OPTS + add_opts,

    "[...] -t disk-type -n node[:secondary-node] -o os-type <name>",

    "Creates and adds a new instance to the cluster"),

    BatchCreate, [ArgFile(min=1, max=1)], [DRY_RUN_OPT, PRIORITY_OPT],

    "<instances.json>",

    "Create a bunch of instances based on specs in the file."),

    ConnectToInstanceConsole, ARGS_ONE_INSTANCE,

    [SHOWCMD_OPT, PRIORITY_OPT],

    "[--show-cmd] <instance>", "Opens a console on the specified instance"),

    FailoverInstance, ARGS_ONE_INSTANCE,

    [FORCE_OPT, IGNORE_CONSIST_OPT, SUBMIT_OPT, SHUTDOWN_TIMEOUT_OPT,

     DRY_RUN_OPT, PRIORITY_OPT, DST_NODE_OPT, IALLOCATOR_OPT],

    "[-f] <instance>", "Stops the instance and starts it on the backup node,"

    " using the remote mirror (only for mirrored instances)"),

    MigrateInstance, ARGS_ONE_INSTANCE,

    [FORCE_OPT, NONLIVE_OPT, MIGRATION_MODE_OPT, CLEANUP_OPT, DRY_RUN_OPT,

     PRIORITY_OPT, DST_NODE_OPT, IALLOCATOR_OPT, ALLOW_FAILOVER_OPT],

    "[-f] <instance>", "Migrate instance to its secondary node"

    " (only for mirrored instances)"),

    MoveInstance, ARGS_ONE_INSTANCE,

    [FORCE_OPT, SUBMIT_OPT, SINGLE_NODE_OPT, SHUTDOWN_TIMEOUT_OPT,

     DRY_RUN_OPT, PRIORITY_OPT, IGNORE_CONSIST_OPT],

    "[-f] <instance>", "Move instance to an arbitrary node"

    " (only for instances of type file and lv)"),

    ShowInstanceConfig, ARGS_MANY_INSTANCES,

    [STATIC_OPT, ALL_OPT, ROMAN_OPT, PRIORITY_OPT],

    "[-s] {--all | <instance>...}",

    "Show information on the specified instance(s)"),

    ListInstances, ARGS_MANY_INSTANCES,

    [NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT, VERBOSE_OPT,

     FORCE_FILTER_OPT],

    [NOHDR_OPT, SEP_OPT],

    "[fields...]",

    "Lists all available fields for instances"),

    ReinstallInstance, [ArgInstance()],

    [FORCE_OPT, OS_OPT, FORCE_VARIANT_OPT, m_force_multi, m_node_opt,

     m_pri_node_opt, m_sec_node_opt, m_clust_opt, m_inst_opt, m_node_tags_opt,

     m_pri_node_tags_opt, m_sec_node_tags_opt, m_inst_tags_opt, SELECT_OS_OPT,

     SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT, OSPARAMS_OPT],

    "[-f] <instance>", "Reinstall a stopped instance"),

    RemoveInstance, ARGS_ONE_INSTANCE,

    [FORCE_OPT, SHUTDOWN_TIMEOUT_OPT, IGNORE_FAILURES_OPT, SUBMIT_OPT,

     DRY_RUN_OPT, PRIORITY_OPT],

    "[-f] <instance>", "Shuts down the instance and removes it"),

    RenameInstance,

    [ArgInstance(min=1, max=1), ArgHost(min=1, max=1)],

    [NOIPCHECK_OPT, NONAMECHECK_OPT, SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT],

    "<instance> <new_name>", "Rename the instance"),

    ReplaceDisks, ARGS_ONE_INSTANCE,

    [AUTO_REPLACE_OPT, DISKIDX_OPT, IALLOCATOR_OPT, EARLY_RELEASE_OPT,

     NEW_SECONDARY_OPT, ON_PRIMARY_OPT, ON_SECONDARY_OPT, SUBMIT_OPT,

     DRY_RUN_OPT, PRIORITY_OPT],

    "[-s|-p|-n NODE|-I NAME] <instance>",

    "Replaces all disks for the instance"),

    SetInstanceParams, ARGS_ONE_INSTANCE,

    [BACKEND_OPT, DISK_OPT, FORCE_OPT, HVOPTS_OPT, NET_OPT, SUBMIT_OPT,

     DISK_TEMPLATE_OPT, SINGLE_NODE_OPT, OS_OPT, FORCE_VARIANT_OPT,

     OSPARAMS_OPT, DRY_RUN_OPT, PRIORITY_OPT, NWSYNC_OPT],

    "<instance>", "Alters the parameters of an instance"),

    GenericManyOps("shutdown", _ShutdownInstance), [ArgInstance()],

    [m_node_opt, m_pri_node_opt, m_sec_node_opt, m_clust_opt,

     m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt,

     m_inst_tags_opt, m_inst_opt, m_force_multi, TIMEOUT_OPT, SUBMIT_OPT,

     DRY_RUN_OPT, PRIORITY_OPT, IGNORE_OFFLINE_OPT, NO_REMEMBER_OPT],

    "<instance>", "Stops an instance"),

    GenericManyOps("startup", _StartupInstance), [ArgInstance()],

    [FORCE_OPT, m_force_multi, m_node_opt, m_pri_node_opt, m_sec_node_opt,

     m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt,

     BACKEND_OPT, DRY_RUN_OPT, PRIORITY_OPT, IGNORE_OFFLINE_OPT,

     NO_REMEMBER_OPT, STARTUP_PAUSED_OPT],

    "<instance>", "Starts an instance"),

    GenericManyOps("reboot", _RebootInstance), [ArgInstance()],

    [m_force_multi, REBOOT_TYPE_OPT, IGNORE_SECONDARIES_OPT, m_node_opt,

     m_pri_node_opt, m_sec_node_opt, m_clust_opt, m_inst_opt, SUBMIT_OPT,

     m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt,

     m_inst_tags_opt, SHUTDOWN_TIMEOUT_OPT, DRY_RUN_OPT, PRIORITY_OPT],

    "<instance>", "Reboots an instance"),

    ActivateDisks, ARGS_ONE_INSTANCE,

    [SUBMIT_OPT, IGNORE_SIZE_OPT, PRIORITY_OPT],

    "<instance>", "Activate an instance's disks"),

    DeactivateDisks, ARGS_ONE_INSTANCE,

    [FORCE_OPT, SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT],

    "[-f] <instance>", "Deactivate an instance's disks"),

    RecreateDisks, ARGS_ONE_INSTANCE,

    [SUBMIT_OPT, DISKIDX_OPT, NODE_PLACEMENT_OPT, DRY_RUN_OPT, PRIORITY_OPT],

    "<instance>", "Recreate an instance's disks"),

    GrowDisk,

    [ArgInstance(min=1, max=1), ArgUnknown(min=1, max=1),

     ArgUnknown(min=1, max=1)],

    [SUBMIT_OPT, NWSYNC_OPT, DRY_RUN_OPT, PRIORITY_OPT],

    "<instance> <disk> <size>", "Grow an instance's disk"),

    ListTags, ARGS_ONE_INSTANCE, [PRIORITY_OPT],

    "<instance_name>", "List the tags of the given instance"),

    AddTags, [ArgInstance(min=1, max=1), ArgUnknown()],

    [TAG_SRC_OPT, PRIORITY_OPT],

    "<instance_name> tag...", "Add tags to the given instance"),

    RemoveTags, [ArgInstance(min=1, max=1), ArgUnknown()],

    [TAG_SRC_OPT, PRIORITY_OPT],

    "<instance_name> tag...", "Remove tags from given instance"),

#: dictionary with aliases for commands

aliases = {

  }

  age = args[0]

    age = -1

  else:

    age = ParseTimespec(age)

commands = {

    ListJobs, [ArgJobId()],

    [NOHDR_OPT, SEP_OPT, FIELDS_OPT],

    "[job_id ...]",

    " op_status, op_result."

    " The default field"

    " list is (in order): %s." % utils.CommaJoin(_LIST_DEF_FIELDS)),

    ArchiveJobs, [ArgJobId(min=1)], [],

    "<job-id> [<job-id> ...]", "Archive specified jobs"),

    AutoArchiveJobs,

    [ArgSuggest(min=1, max=1, choices=["1d", "1w", "4w", "all"])],

    [],

    "<age>", "Auto archive jobs older than the given age"),

    CancelJobs, [ArgJobId(min=1)], [],

    "<job-id> [<job-id> ...]", "Cancel specified jobs"),

    ShowJobs, [ArgJobId(min=1)], [],

    "<job-id> [<job-id> ...]",

    "Show detailed information about the specified jobs"),

    WatchJob, [ArgJobId(min=1, max=1)], [],

    "<job-id>", "Follows a job and prints its output as it arrives"),

  }

  readd = opts.readd

  try:

                           use_locking=False)

    node_exists, sip, is_master = output[0]

  except (errors.OpPrereqError, errors.OpExecError):

    sip = opts.secondary_ip

  # read the cluster name from the master

  cluster_name = output[0]

  if not readd and opts.node_setup:

commands = {

    AddNode, [ArgHost(min=1, max=1)],

    [SECONDARY_IP_OPT, READD_OPT, NOSSH_KEYCHECK_OPT, NODE_FORCE_JOIN_OPT,

     NONODE_SETUP_OPT, VERBOSE_OPT, NODEGROUP_OPT, PRIORITY_OPT,

    "[-f] {-I <iallocator> | -n <dst>} <node>",

    "Relocate the secondary instances from a node"

    " to other nodes"),

    FailoverNode, ARGS_ONE_NODE, [FORCE_OPT, IGNORE_CONSIST_OPT,

                                  IALLOCATOR_OPT, PRIORITY_OPT],

    "[-f] <node>",

    "Stops the primary instances on a node and start them on their"

    " secondary node (only for instances with drbd disk template)"),

    MigrateNode, ARGS_ONE_NODE,

    [FORCE_OPT, NONLIVE_OPT, MIGRATION_MODE_OPT, DST_NODE_OPT,

     IALLOCATOR_OPT, PRIORITY_OPT],

    "[-f] <node>",

    "Migrate all the primary instance on a node away from it"

    " (only for instances of type drbd)"),

    ShowNodeConfig, ARGS_MANY_NODES, [],

    "[<node_name>...]", "Show information about the node(s)"),

    ListNodes, ARGS_MANY_NODES,

    [NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT, VERBOSE_OPT,

     FORCE_FILTER_OPT],

    [NOHDR_OPT, SEP_OPT],

    "[fields...]",

    "Lists all available fields for nodes"),

    SetNodeParams, ARGS_ONE_NODE,

    [FORCE_OPT, SUBMIT_OPT, MC_OPT, DRAINED_OPT, OFFLINE_OPT,

     CAPAB_MASTER_OPT, CAPAB_VM_OPT, SECONDARY_IP_OPT,

     AUTO_PROMOTE_OPT, DRY_RUN_OPT, PRIORITY_OPT, NODE_PARAMS_OPT,

     NODE_POWERED_OPT],

    "<node_name>", "Alters the parameters of a node"),

    PowercycleNode, ARGS_ONE_NODE,

    [FORCE_OPT, CONFIRM_OPT, DRY_RUN_OPT, PRIORITY_OPT],

    "<node_name>", "Tries to forcefully powercycle a node"),

    PowerNode,

    [ArgChoice(min=1, max=1, choices=_LIST_POWER_COMMANDS),

     ArgNode()],

     FORCE_OPT, NOHDR_OPT, SEP_OPT, OOB_TIMEOUT_OPT, POWER_DELAY_OPT],

    "on|off|cycle|status [nodes...]",

    "Change power state of node by calling out-of-band helper."),

    RemoveNode, ARGS_ONE_NODE, [DRY_RUN_OPT, PRIORITY_OPT],

    "<node_name>", "Removes a node from the cluster"),

    ListVolumes, [ArgNode()],

    [NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT, PRIORITY_OPT],

    "[<node_name>...]", "List logical volumes on node(s)"),

    ListStorage, ARGS_MANY_NODES,

    [NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT, _STORAGE_TYPE_OPT,

     PRIORITY_OPT],

    "[<node_name>...]", "List physical volumes on node(s). The available"

    " fields are (see the man page for details): %s." %

    (utils.CommaJoin(_LIST_STOR_HEADERS))),

    ModifyStorage,

    [ArgNode(min=1, max=1),

     ArgChoice(min=1, max=1, choices=_MODIFIABLE_STORAGE_TYPES),

     ArgFile(min=1, max=1)],

    [ALLOCATABLE_OPT, DRY_RUN_OPT, PRIORITY_OPT],

    "<node_name> <storage_type> <name>", "Modify storage volume on a node"),

    RepairStorage,

    [ArgNode(min=1, max=1),

     ArgChoice(min=1, max=1, choices=_REPAIRABLE_STORAGE_TYPES),

    [IGNORE_CONSIST_OPT, DRY_RUN_OPT, PRIORITY_OPT],

    "<node_name> <storage_type> <name>",

    "Repairs a storage volume on a node"),

    ListTags, ARGS_ONE_NODE, [],

    "<node_name>", "List the tags of the given node"),

    AddTags, [ArgNode(min=1, max=1), ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT],

    "<node_name> tag...", "Add tags to the given node"),

    RemoveTags, [ArgNode(min=1, max=1), ArgUnknown()],

    [TAG_SRC_OPT, PRIORITY_OPT],

    "<node_name> tag...", "Remove tags from the given node"),

commands = {

    ListOS, ARGS_NONE, [NOHDR_OPT, PRIORITY_OPT],

    "", "Lists all valid operating systems on the cluster"),

    DiagnoseOS, ARGS_NONE, [PRIORITY_OPT],

    "", "Diagnose all operating systems"),

    ShowOSInfo, [ArgOs()], [PRIORITY_OPT],

    "", "Show detailed information about "

    "operating systems"),

    ModifyOS, ARGS_ONE_OS,

    [HVLIST_OPT, OSPARAMS_OPT, DRY_RUN_OPT, PRIORITY_OPT,

     HID_OS_OPT, BLK_OS_OPT],

  bep = cluster.FillBE(instance)

  hvp = cluster.FillHV(instance)

  args = {

  }

  if override:

    args.update(override)

          self._ErrorIf(test, self.ENODEHOOKS, node_name,

                        "Script %s failed, output:", script)

          if test:

            feedback_fn("%s" % output)

            lu_result = 0

          if field == "node":

            val = node

          elif field == "phys":

          elif field == "vg":

          elif field == "name":

          elif field == "size":

          elif field == "instance":

            val = vol2inst.get((node, vol["vg"] + "/" + vol["name"]), "-")

          else:

  nodeinfo = lu.rpc.call_node_info([node], None, hypervisor_name)

  nodeinfo[node].Raise("Can't get data from node %s" % node,

                       prereq=True, ecode=errors.ECODE_ENVIRON)

  if not isinstance(free_mem, int):

    raise errors.OpPrereqError("Can't compute free memory on node %s, result"

                               " was '%s'" % (node, free_mem),

      disk_images = []

      for idx in range(export_disks):

        if export_info.has_option(constants.INISECT_INS, option):

          # FIXME: are the old os-es, disk sizes, etc. useful?

          export_name = export_info.get(constants.INISECT_INS, option)

      self.src_images = disk_images

      try:

      except (TypeError, ValueError), err:

        raise errors.OpPrereqError("Invalid export file, nic_count is not"

                                   " an integer: %s" % str(err),

      if self.op.instance_name == old_name:

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

          if nic.mac == constants.VALUE_AUTO and exp_nic_count >= idx:

            nic.mac = export_info.get(constants.INISECT_INS, nic_mac_ini)

    # ENDIF: self.op.mode == constants.INSTANCE_IMPORT

            raise errors.OpPrereqError("Invalid IP address '%s'" % nic_ip,

                                       errors.ECODE_INVAL)

      nic_link = nic_dict.get(constants.INIC_LINK, None)

      if nic_bridge and nic_link:

        raise errors.OpPrereqError("Cannot pass 'bridge' and 'link'"

                                   " at the same time", errors.ECODE_INVAL)

      elif nic_bridge and nic_bridge.lower() == constants.VALUE_NONE:

      elif nic_link and nic_link.lower() == constants.VALUE_NONE:

        nic_dict[constants.INIC_LINK] = None

    """

    args = dict()

    if constants.BE_MEMORY in self.be_new:

    if constants.BE_VCPUS in self.be_new:

    # TODO: export disk changes. Note: _BuildInstanceHookEnv* don't export disk

    # information at all.

    if self.op.nics:

      nic_override = dict(self.op.nics)

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

        if idx in nic_override:

          nicparams = self.cluster.SimpleFillNIC(nic.nicparams)

        mode = nicparams[constants.NIC_MODE]

        link = nicparams[constants.NIC_LINK]

      if constants.DDM_ADD in nic_override:

        ip = nic_override[constants.DDM_ADD].get(constants.INIC_IP, None)

        mac = nic_override[constants.DDM_ADD][constants.INIC_MAC]

        nicparams = self.nic_pnew[constants.DDM_ADD]

        mode = nicparams[constants.NIC_MODE]

        link = nicparams[constants.NIC_LINK]

      elif constants.DDM_REMOVE in nic_override:

    env = _BuildInstanceHookEnvByObject(self, self.instance, override=args)

    if self.op.disk_template:

        # Assume the primary node is unreachable and go ahead

        self.warn.append("Can't get info from primary node %s: %s" %

                         (pnode,  msg))

        self.warn.append("Node data from primary node %s doesn't contain"

                         " free memory information" % pnode)

      elif instance_info.fail_msg:

                        instance_info.fail_msg)

      else:

        if instance_info.payload:

        else:

          # Assume instance not running

          # (there is a slight race condition here, but it's not very probable,

          # and we have no other way to check)

          current_mem = 0

        miss_mem = (be_new[constants.BE_MEMORY] - current_mem -

        if miss_mem > 0:

          raise errors.OpPrereqError("This change will prevent the instance"

                                     " from starting, due to %d MB of memory"

            continue

          nres.Raise("Can't get info from secondary node %s" % node,

                     prereq=True, ecode=errors.ECODE_STATE)

            raise errors.OpPrereqError("Secondary node %s didn't return free"

                                       " memory information" % node,

                                       errors.ECODE_STATE)

            raise errors.OpPrereqError("This change will prevent the instance"

                                       " from failover to its secondary node"

                                       " %s, due to not enough memory" % node,

                                 for key in constants.NICS_PARAMETERS

                                 if key in nic_dict])

      new_nic_params = _GetUpdatedParams(old_nic_params,

                                         update_params_dict)

        else:

          nic_ip = old_nic_ip

        if nic_ip is None:

      if constants.INIC_MAC in nic_dict:

        nic_mac = nic_dict[constants.INIC_MAC]

        if nic_mac is None:

                                     errors.ECODE_INVAL)

        elif nic_mac in (constants.VALUE_AUTO, constants.VALUE_GENERATE):

          # otherwise generate the mac

                                nname)

        remote_info = nresult.payload