import sys
import textwrap
import os.path
-import copy
import time
import logging
from cStringIO import StringIO
from ganeti import luxi
from ganeti import ssconf
from ganeti import rpc
+from ganeti import ssh
+from ganeti import compat
-from optparse import (OptionParser, make_option, TitledHelpFormatter,
+from optparse import (OptionParser, TitledHelpFormatter,
Option, OptionValueError)
-__all__ = ["DEBUG_OPT", "NOHDR_OPT", "SEP_OPT", "GenericMain",
- "SubmitOpCode", "GetClient",
- "cli_option", "ikv_option", "keyval_option",
- "GenerateTable", "AskUser",
- "ARGS_NONE", "ARGS_FIXED", "ARGS_ATLEAST", "ARGS_ANY", "ARGS_ONE",
- "USEUNITS_OPT", "FIELDS_OPT", "FORCE_OPT", "SUBMIT_OPT",
- "ListTags", "AddTags", "RemoveTags", "TAG_SRC_OPT",
- "FormatError", "SplitNodeOption", "SubmitOrSend",
- "JobSubmittedException", "FormatTimestamp", "ParseTimespec",
- "ToStderr", "ToStdout", "UsesRPC",
- "GetOnlineNodes", "JobExecutor", "SYNC_OPT", "CONFIRM_OPT",
- ]
+
+__all__ = [
+ # Command line options
+ "ADD_UIDS_OPT",
+ "ALLOCATABLE_OPT",
+ "ALL_OPT",
+ "AUTO_PROMOTE_OPT",
+ "AUTO_REPLACE_OPT",
+ "BACKEND_OPT",
+ "CLEANUP_OPT",
+ "CLUSTER_DOMAIN_SECRET_OPT",
+ "CONFIRM_OPT",
+ "CP_SIZE_OPT",
+ "DEBUG_OPT",
+ "DEBUG_SIMERR_OPT",
+ "DISKIDX_OPT",
+ "DISK_OPT",
+ "DISK_TEMPLATE_OPT",
+ "DRAINED_OPT",
+ "EARLY_RELEASE_OPT",
+ "ENABLED_HV_OPT",
+ "ERROR_CODES_OPT",
+ "FIELDS_OPT",
+ "FILESTORE_DIR_OPT",
+ "FILESTORE_DRIVER_OPT",
+ "FORCE_OPT",
+ "FORCE_VARIANT_OPT",
+ "GLOBAL_FILEDIR_OPT",
+ "HVLIST_OPT",
+ "HVOPTS_OPT",
+ "HYPERVISOR_OPT",
+ "IALLOCATOR_OPT",
+ "IDENTIFY_DEFAULTS_OPT",
+ "IGNORE_CONSIST_OPT",
+ "IGNORE_FAILURES_OPT",
+ "IGNORE_REMOVE_FAILURES_OPT",
+ "IGNORE_SECONDARIES_OPT",
+ "IGNORE_SIZE_OPT",
+ "MAC_PREFIX_OPT",
+ "MAINTAIN_NODE_HEALTH_OPT",
+ "MASTER_NETDEV_OPT",
+ "MC_OPT",
+ "NET_OPT",
+ "NEW_CLUSTER_CERT_OPT",
+ "NEW_CLUSTER_DOMAIN_SECRET_OPT",
+ "NEW_CONFD_HMAC_KEY_OPT",
+ "NEW_RAPI_CERT_OPT",
+ "NEW_SECONDARY_OPT",
+ "NIC_PARAMS_OPT",
+ "NODE_LIST_OPT",
+ "NODE_PLACEMENT_OPT",
+ "NOHDR_OPT",
+ "NOIPCHECK_OPT",
+ "NO_INSTALL_OPT",
+ "NONAMECHECK_OPT",
+ "NOLVM_STORAGE_OPT",
+ "NOMODIFY_ETCHOSTS_OPT",
+ "NOMODIFY_SSH_SETUP_OPT",
+ "NONICS_OPT",
+ "NONLIVE_OPT",
+ "NONPLUS1_OPT",
+ "NOSHUTDOWN_OPT",
+ "NOSTART_OPT",
+ "NOSSH_KEYCHECK_OPT",
+ "NOVOTING_OPT",
+ "NWSYNC_OPT",
+ "ON_PRIMARY_OPT",
+ "ON_SECONDARY_OPT",
+ "OFFLINE_OPT",
+ "OS_OPT",
+ "OS_SIZE_OPT",
+ "RAPI_CERT_OPT",
+ "READD_OPT",
+ "REBOOT_TYPE_OPT",
+ "REMOVE_INSTANCE_OPT",
+ "REMOVE_UIDS_OPT",
+ "SECONDARY_IP_OPT",
+ "SELECT_OS_OPT",
+ "SEP_OPT",
+ "SHOWCMD_OPT",
+ "SHUTDOWN_TIMEOUT_OPT",
+ "SINGLE_NODE_OPT",
+ "SRC_DIR_OPT",
+ "SRC_NODE_OPT",
+ "SUBMIT_OPT",
+ "STATIC_OPT",
+ "SYNC_OPT",
+ "TAG_SRC_OPT",
+ "TIMEOUT_OPT",
+ "UIDPOOL_OPT",
+ "USEUNITS_OPT",
+ "USE_REPL_NET_OPT",
+ "VERBOSE_OPT",
+ "VG_NAME_OPT",
+ "YES_DOIT_OPT",
+ # Generic functions for CLI programs
+ "GenericMain",
+ "GenericInstanceCreate",
+ "GetClient",
+ "GetOnlineNodes",
+ "JobExecutor",
+ "JobSubmittedException",
+ "ParseTimespec",
+ "RunWhileClusterStopped",
+ "SubmitOpCode",
+ "SubmitOrSend",
+ "UsesRPC",
+ # Formatting functions
+ "ToStderr", "ToStdout",
+ "FormatError",
+ "GenerateTable",
+ "AskUser",
+ "FormatTimestamp",
+ # Tags functions
+ "ListTags",
+ "AddTags",
+ "RemoveTags",
+ # command line options support infrastructure
+ "ARGS_MANY_INSTANCES",
+ "ARGS_MANY_NODES",
+ "ARGS_NONE",
+ "ARGS_ONE_INSTANCE",
+ "ARGS_ONE_NODE",
+ "ARGS_ONE_OS",
+ "ArgChoice",
+ "ArgCommand",
+ "ArgFile",
+ "ArgHost",
+ "ArgInstance",
+ "ArgJobId",
+ "ArgNode",
+ "ArgOs",
+ "ArgSuggest",
+ "ArgUnknown",
+ "OPT_COMPL_INST_ADD_NODES",
+ "OPT_COMPL_MANY_NODES",
+ "OPT_COMPL_ONE_IALLOCATOR",
+ "OPT_COMPL_ONE_INSTANCE",
+ "OPT_COMPL_ONE_NODE",
+ "OPT_COMPL_ONE_OS",
+ "cli_option",
+ "SplitNodeOption",
+ "CalculateOSNames",
+ ]
NO_PREFIX = "no_"
UN_PREFIX = "-"
+
+class _Argument:
+ def __init__(self, min=0, max=None): # pylint: disable-msg=W0622
+ self.min = min
+ self.max = max
+
+ def __repr__(self):
+ return ("<%s min=%s max=%s>" %
+ (self.__class__.__name__, self.min, self.max))
+
+
+class ArgSuggest(_Argument):
+ """Suggesting argument.
+
+ Value can be any of the ones passed to the constructor.
+
+ """
+ # pylint: disable-msg=W0622
+ def __init__(self, min=0, max=None, choices=None):
+ _Argument.__init__(self, min=min, max=max)
+ self.choices = choices
+
+ def __repr__(self):
+ return ("<%s min=%s max=%s choices=%r>" %
+ (self.__class__.__name__, self.min, self.max, self.choices))
+
+
+class ArgChoice(ArgSuggest):
+ """Choice argument.
+
+ Value can be any of the ones passed to the constructor. Like L{ArgSuggest},
+ but value must be one of the choices.
+
+ """
+
+
+class ArgUnknown(_Argument):
+ """Unknown argument to program (e.g. determined at runtime).
+
+ """
+
+
+class ArgInstance(_Argument):
+ """Instances argument.
+
+ """
+
+
+class ArgNode(_Argument):
+ """Node argument.
+
+ """
+
+class ArgJobId(_Argument):
+ """Job ID argument.
+
+ """
+
+
+class ArgFile(_Argument):
+ """File path argument.
+
+ """
+
+
+class ArgCommand(_Argument):
+ """Command argument.
+
+ """
+
+
+class ArgHost(_Argument):
+ """Host argument.
+
+ """
+
+
+class ArgOs(_Argument):
+ """OS argument.
+
+ """
+
+
+ARGS_NONE = []
+ARGS_MANY_INSTANCES = [ArgInstance()]
+ARGS_MANY_NODES = [ArgNode()]
+ARGS_ONE_INSTANCE = [ArgInstance(min=1, max=1)]
+ARGS_ONE_NODE = [ArgNode(min=1, max=1)]
+ARGS_ONE_OS = [ArgOs(min=1, max=1)]
+
+
def _ExtractTagsObject(opts, args):
"""Extract the tag type object.
"""
kind, name = _ExtractTagsObject(opts, args)
- op = opcodes.OpGetTags(kind=kind, name=name)
- result = SubmitOpCode(op)
+ cl = GetClient()
+ result = cl.QueryTags(kind, name)
result = list(result)
result.sort()
for tag in result:
- print tag
+ ToStdout(tag)
def AddTags(opts, args):
SubmitOpCode(op)
-DEBUG_OPT = make_option("-d", "--debug", default=False,
- action="store_true",
- help="Turn debugging on")
-
-NOHDR_OPT = make_option("--no-headers", default=False,
- action="store_true", dest="no_headers",
- help="Don't display column headers")
-
-SEP_OPT = make_option("--separator", default=None,
- action="store", dest="separator",
- help="Separator between output fields"
- " (defaults to one space)")
-
-USEUNITS_OPT = make_option("--units", default=None,
- dest="units", choices=('h', 'm', 'g', 't'),
- help="Specify units for output (one of hmgt)")
-
-FIELDS_OPT = make_option("-o", "--output", dest="output", action="store",
- type="string", help="Comma separated list of"
- " output fields",
- metavar="FIELDS")
-
-FORCE_OPT = make_option("-f", "--force", dest="force", action="store_true",
- default=False, help="Force the operation")
-
-CONFIRM_OPT = make_option("--yes", dest="confirm", action="store_true",
- default=False, help="Do not require confirmation")
-
-TAG_SRC_OPT = make_option("--from", dest="tags_source",
- default=None, help="File with tag names")
-
-SUBMIT_OPT = make_option("--submit", dest="submit_only",
- default=False, action="store_true",
- help="Submit the job and return the job ID, but"
- " don't wait for the job to finish")
-
-SYNC_OPT = make_option("--sync", dest="do_locking",
- default=False, action="store_true",
- help="Grab locks while doing the queries"
- " in order to ensure more consistent results")
-
-_DRY_RUN_OPT = make_option("--dry-run", default=False,
- action="store_true",
- help="Do not execute the operation, just run the"
- " check steps and verify it it could be executed")
-
-
-def ARGS_FIXED(val):
- """Macro-like function denoting a fixed number of arguments"""
- return -val
-
-
-def ARGS_ATLEAST(val):
- """Macro-like function denoting a minimum number of arguments"""
- return val
-
-
-ARGS_NONE = None
-ARGS_ONE = ARGS_FIXED(1)
-ARGS_ANY = ARGS_ATLEAST(0)
-
-
-def check_unit(option, opt, value):
+def check_unit(option, opt, value): # pylint: disable-msg=W0613
"""OptParsers custom converter for units.
"""
raise OptionValueError("option %s: %s" % (opt, err))
-class CliOption(Option):
- """Custom option class for optparse.
-
- """
- TYPES = Option.TYPES + ("unit",)
- TYPE_CHECKER = copy.copy(Option.TYPE_CHECKER)
- TYPE_CHECKER["unit"] = check_unit
-
-
def _SplitKeyVal(opt, data):
"""Convert a KeyVal string into a dict.
"""
kv_dict = {}
if data:
- for elem in data.split(","):
+ for elem in utils.UnescapeAndSplit(data, sep=","):
if "=" in elem:
key, val = elem.split("=", 1)
else:
return kv_dict
-def check_ident_key_val(option, opt, value):
- """Custom parser for the IdentKeyVal option type.
+def check_ident_key_val(option, opt, value): # pylint: disable-msg=W0613
+ """Custom parser for ident:key=val,key=val options.
+
+ This will store the parsed values as a tuple (ident, {key: val}). As such,
+ multiple uses of this option via action=append is possible.
"""
if ":" not in value:
return retval
-class IdentKeyValOption(Option):
- """Custom option class for ident:key=val,key=val options.
+def check_key_val(option, opt, value): # pylint: disable-msg=W0613
+ """Custom parser class for key=val,key=val options.
- This will store the parsed values as a tuple (ident, {key: val}). As
- such, multiple uses of this option via action=append is possible.
+ This will store the parsed values as a dict {key: val}.
"""
- TYPES = Option.TYPES + ("identkeyval",)
- TYPE_CHECKER = copy.copy(Option.TYPE_CHECKER)
- TYPE_CHECKER["identkeyval"] = check_ident_key_val
+ return _SplitKeyVal(opt, value)
+
+def check_bool(option, opt, value): # pylint: disable-msg=W0613
+ """Custom parser for yes/no options.
-def check_key_val(option, opt, value):
- """Custom parser for the KeyVal option type.
+ This will store the parsed value as either True or False.
"""
- return _SplitKeyVal(opt, value)
+ value = value.lower()
+ if value == constants.VALUE_FALSE or value == "no":
+ return False
+ elif value == constants.VALUE_TRUE or value == "yes":
+ return True
+ else:
+ raise errors.ParameterError("Invalid boolean value '%s'" % value)
-class KeyValOption(Option):
- """Custom option class for key=val,key=val options.
+# completion_suggestion is normally a list. Using numeric values not evaluating
+# to False for dynamic completion.
+(OPT_COMPL_MANY_NODES,
+ OPT_COMPL_ONE_NODE,
+ OPT_COMPL_ONE_INSTANCE,
+ OPT_COMPL_ONE_OS,
+ OPT_COMPL_ONE_IALLOCATOR,
+ OPT_COMPL_INST_ADD_NODES) = range(100, 106)
+
+OPT_COMPL_ALL = frozenset([
+ OPT_COMPL_MANY_NODES,
+ OPT_COMPL_ONE_NODE,
+ OPT_COMPL_ONE_INSTANCE,
+ OPT_COMPL_ONE_OS,
+ OPT_COMPL_ONE_IALLOCATOR,
+ OPT_COMPL_INST_ADD_NODES,
+ ])
- This will store the parsed values as a dict {key: val}.
+
+class CliOption(Option):
+ """Custom option class for optparse.
"""
- TYPES = Option.TYPES + ("keyval",)
- TYPE_CHECKER = copy.copy(Option.TYPE_CHECKER)
+ ATTRS = Option.ATTRS + [
+ "completion_suggest",
+ ]
+ TYPES = Option.TYPES + (
+ "identkeyval",
+ "keyval",
+ "unit",
+ "bool",
+ )
+ TYPE_CHECKER = Option.TYPE_CHECKER.copy()
+ TYPE_CHECKER["identkeyval"] = check_ident_key_val
TYPE_CHECKER["keyval"] = check_key_val
+ TYPE_CHECKER["unit"] = check_unit
+ TYPE_CHECKER["bool"] = check_bool
# optparse.py sets make_option, so we do it for our own option class, too
cli_option = CliOption
-ikv_option = IdentKeyValOption
-keyval_option = KeyValOption
+
+
+_YORNO = "yes|no"
+
+DEBUG_OPT = cli_option("-d", "--debug", default=0, action="count",
+ help="Increase debugging level")
+
+NOHDR_OPT = cli_option("--no-headers", default=False,
+ action="store_true", dest="no_headers",
+ help="Don't display column headers")
+
+SEP_OPT = cli_option("--separator", default=None,
+ action="store", dest="separator",
+ help=("Separator between output fields"
+ " (defaults to one space)"))
+
+USEUNITS_OPT = cli_option("--units", default=None,
+ dest="units", choices=('h', 'm', 'g', 't'),
+ help="Specify units for output (one of hmgt)")
+
+FIELDS_OPT = cli_option("-o", "--output", dest="output", action="store",
+ type="string", metavar="FIELDS",
+ help="Comma separated list of output fields")
+
+FORCE_OPT = cli_option("-f", "--force", dest="force", action="store_true",
+ default=False, help="Force the operation")
+
+CONFIRM_OPT = cli_option("--yes", dest="confirm", action="store_true",
+ default=False, help="Do not require confirmation")
+
+TAG_SRC_OPT = cli_option("--from", dest="tags_source",
+ default=None, help="File with tag names")
+
+SUBMIT_OPT = cli_option("--submit", dest="submit_only",
+ default=False, action="store_true",
+ help=("Submit the job and return the job ID, but"
+ " don't wait for the job to finish"))
+
+SYNC_OPT = cli_option("--sync", dest="do_locking",
+ default=False, action="store_true",
+ help=("Grab locks while doing the queries"
+ " in order to ensure more consistent results"))
+
+_DRY_RUN_OPT = cli_option("--dry-run", default=False,
+ action="store_true",
+ help=("Do not execute the operation, just run the"
+ " check steps and verify it it could be"
+ " executed"))
+
+VERBOSE_OPT = cli_option("-v", "--verbose", default=False,
+ action="store_true",
+ help="Increase the verbosity of the operation")
+
+DEBUG_SIMERR_OPT = cli_option("--debug-simulate-errors", default=False,
+ action="store_true", dest="simulate_errors",
+ help="Debugging option that makes the operation"
+ " treat most runtime checks as failed")
+
+NWSYNC_OPT = cli_option("--no-wait-for-sync", dest="wait_for_sync",
+ default=True, action="store_false",
+ help="Don't wait for sync (DANGEROUS!)")
+
+DISK_TEMPLATE_OPT = cli_option("-t", "--disk-template", dest="disk_template",
+ help="Custom disk setup (diskless, file,"
+ " plain or drbd)",
+ default=None, metavar="TEMPL",
+ choices=list(constants.DISK_TEMPLATES))
+
+NONICS_OPT = cli_option("--no-nics", default=False, action="store_true",
+ help="Do not create any network cards for"
+ " the instance")
+
+FILESTORE_DIR_OPT = cli_option("--file-storage-dir", dest="file_storage_dir",
+ help="Relative path under default cluster-wide"
+ " file storage dir to store file-based disks",
+ default=None, metavar="<DIR>")
+
+FILESTORE_DRIVER_OPT = cli_option("--file-driver", dest="file_driver",
+ help="Driver to use for image files",
+ default="loop", metavar="<DRIVER>",
+ choices=list(constants.FILE_DRIVER))
+
+IALLOCATOR_OPT = cli_option("-I", "--iallocator", metavar="<NAME>",
+ help="Select nodes for the instance automatically"
+ " using the <NAME> iallocator plugin",
+ default=None, type="string",
+ completion_suggest=OPT_COMPL_ONE_IALLOCATOR)
+
+OS_OPT = cli_option("-o", "--os-type", dest="os", help="What OS to run",
+ metavar="<os>",
+ completion_suggest=OPT_COMPL_ONE_OS)
+
+FORCE_VARIANT_OPT = cli_option("--force-variant", dest="force_variant",
+ action="store_true", default=False,
+ help="Force an unknown variant")
+
+NO_INSTALL_OPT = cli_option("--no-install", dest="no_install",
+ action="store_true", default=False,
+ help="Do not install the OS (will"
+ " enable no-start)")
+
+BACKEND_OPT = cli_option("-B", "--backend-parameters", dest="beparams",
+ type="keyval", default={},
+ help="Backend parameters")
+
+HVOPTS_OPT = cli_option("-H", "--hypervisor-parameters", type="keyval",
+ default={}, dest="hvparams",
+ help="Hypervisor parameters")
+
+HYPERVISOR_OPT = cli_option("-H", "--hypervisor-parameters", dest="hypervisor",
+ help="Hypervisor and hypervisor options, in the"
+ " format hypervisor:option=value,option=value,...",
+ default=None, type="identkeyval")
+
+HVLIST_OPT = cli_option("-H", "--hypervisor-parameters", dest="hvparams",
+ help="Hypervisor and hypervisor options, in the"
+ " format hypervisor:option=value,option=value,...",
+ default=[], action="append", type="identkeyval")
+
+NOIPCHECK_OPT = cli_option("--no-ip-check", dest="ip_check", default=True,
+ action="store_false",
+ help="Don't check that the instance's IP"
+ " is alive")
+
+NONAMECHECK_OPT = cli_option("--no-name-check", dest="name_check",
+ default=True, action="store_false",
+ help="Don't check that the instance's name"
+ " is resolvable")
+
+NET_OPT = cli_option("--net",
+ help="NIC parameters", default=[],
+ dest="nics", action="append", type="identkeyval")
+
+DISK_OPT = cli_option("--disk", help="Disk parameters", default=[],
+ dest="disks", action="append", type="identkeyval")
+
+DISKIDX_OPT = cli_option("--disks", dest="disks", default=None,
+ help="Comma-separated list of disks"
+ " indices to act on (e.g. 0,2) (optional,"
+ " defaults to all disks)")
+
+OS_SIZE_OPT = cli_option("-s", "--os-size", dest="sd_size",
+ help="Enforces a single-disk configuration using the"
+ " given disk size, in MiB unless a suffix is used",
+ default=None, type="unit", metavar="<size>")
+
+IGNORE_CONSIST_OPT = cli_option("--ignore-consistency",
+ dest="ignore_consistency",
+ action="store_true", default=False,
+ help="Ignore the consistency of the disks on"
+ " the secondary")
+
+NONLIVE_OPT = cli_option("--non-live", dest="live",
+ default=True, action="store_false",
+ help="Do a non-live migration (this usually means"
+ " freeze the instance, save the state, transfer and"
+ " only then resume running on the secondary node)")
+
+NODE_PLACEMENT_OPT = cli_option("-n", "--node", dest="node",
+ help="Target node and optional secondary node",
+ metavar="<pnode>[:<snode>]",
+ completion_suggest=OPT_COMPL_INST_ADD_NODES)
+
+NODE_LIST_OPT = cli_option("-n", "--node", dest="nodes", default=[],
+ action="append", metavar="<node>",
+ help="Use only this node (can be used multiple"
+ " times, if not given defaults to all nodes)",
+ completion_suggest=OPT_COMPL_ONE_NODE)
+
+SINGLE_NODE_OPT = cli_option("-n", "--node", dest="node", help="Target node",
+ metavar="<node>",
+ completion_suggest=OPT_COMPL_ONE_NODE)
+
+NOSTART_OPT = cli_option("--no-start", dest="start", default=True,
+ action="store_false",
+ help="Don't start the instance after creation")
+
+SHOWCMD_OPT = cli_option("--show-cmd", dest="show_command",
+ action="store_true", default=False,
+ help="Show command instead of executing it")
+
+CLEANUP_OPT = cli_option("--cleanup", dest="cleanup",
+ default=False, action="store_true",
+ help="Instead of performing the migration, try to"
+ " recover from a failed cleanup. This is safe"
+ " to run even if the instance is healthy, but it"
+ " will create extra replication traffic and "
+ " disrupt briefly the replication (like during the"
+ " migration")
+
+STATIC_OPT = cli_option("-s", "--static", dest="static",
+ action="store_true", default=False,
+ help="Only show configuration data, not runtime data")
+
+ALL_OPT = cli_option("--all", dest="show_all",
+ default=False, action="store_true",
+ help="Show info on all instances on the cluster."
+ " This can take a long time to run, use wisely")
+
+SELECT_OS_OPT = cli_option("--select-os", dest="select_os",
+ action="store_true", default=False,
+ help="Interactive OS reinstall, lists available"
+ " OS templates for selection")
+
+IGNORE_FAILURES_OPT = cli_option("--ignore-failures", dest="ignore_failures",
+ action="store_true", default=False,
+ help="Remove the instance from the cluster"
+ " configuration even if there are failures"
+ " during the removal process")
+
+IGNORE_REMOVE_FAILURES_OPT = cli_option("--ignore-remove-failures",
+ dest="ignore_remove_failures",
+ action="store_true", default=False,
+ help="Remove the instance from the"
+ " cluster configuration even if there"
+ " are failures during the removal"
+ " process")
+
+REMOVE_INSTANCE_OPT = cli_option("--remove-instance", dest="remove_instance",
+ action="store_true", default=False,
+ help="Remove the instance from the cluster")
+
+NEW_SECONDARY_OPT = cli_option("-n", "--new-secondary", dest="dst_node",
+ help="Specifies the new secondary node",
+ metavar="NODE", default=None,
+ completion_suggest=OPT_COMPL_ONE_NODE)
+
+ON_PRIMARY_OPT = cli_option("-p", "--on-primary", dest="on_primary",
+ default=False, action="store_true",
+ help="Replace the disk(s) on the primary"
+ " node (only for the drbd template)")
+
+ON_SECONDARY_OPT = cli_option("-s", "--on-secondary", dest="on_secondary",
+ default=False, action="store_true",
+ help="Replace the disk(s) on the secondary"
+ " node (only for the drbd template)")
+
+AUTO_PROMOTE_OPT = cli_option("--auto-promote", dest="auto_promote",
+ default=False, action="store_true",
+ help="Lock all nodes and auto-promote as needed"
+ " to MC status")
+
+AUTO_REPLACE_OPT = cli_option("-a", "--auto", dest="auto",
+ default=False, action="store_true",
+ help="Automatically replace faulty disks"
+ " (only for the drbd template)")
+
+IGNORE_SIZE_OPT = cli_option("--ignore-size", dest="ignore_size",
+ default=False, action="store_true",
+ help="Ignore current recorded size"
+ " (useful for forcing activation when"
+ " the recorded size is wrong)")
+
+SRC_NODE_OPT = cli_option("--src-node", dest="src_node", help="Source node",
+ metavar="<node>",
+ completion_suggest=OPT_COMPL_ONE_NODE)
+
+SRC_DIR_OPT = cli_option("--src-dir", dest="src_dir", help="Source directory",
+ metavar="<dir>")
+
+SECONDARY_IP_OPT = cli_option("-s", "--secondary-ip", dest="secondary_ip",
+ help="Specify the secondary ip for the node",
+ metavar="ADDRESS", default=None)
+
+READD_OPT = cli_option("--readd", dest="readd",
+ default=False, action="store_true",
+ help="Readd old node after replacing it")
+
+NOSSH_KEYCHECK_OPT = cli_option("--no-ssh-key-check", dest="ssh_key_check",
+ default=True, action="store_false",
+ help="Disable SSH key fingerprint checking")
+
+
+MC_OPT = cli_option("-C", "--master-candidate", dest="master_candidate",
+ type="bool", default=None, metavar=_YORNO,
+ help="Set the master_candidate flag on the node")
+
+OFFLINE_OPT = cli_option("-O", "--offline", dest="offline", metavar=_YORNO,
+ type="bool", default=None,
+ help="Set the offline flag on the node")
+
+DRAINED_OPT = cli_option("-D", "--drained", dest="drained", metavar=_YORNO,
+ type="bool", default=None,
+ help="Set the drained flag on the node")
+
+ALLOCATABLE_OPT = cli_option("--allocatable", dest="allocatable",
+ type="bool", default=None, metavar=_YORNO,
+ help="Set the allocatable flag on a volume")
+
+NOLVM_STORAGE_OPT = cli_option("--no-lvm-storage", dest="lvm_storage",
+ help="Disable support for lvm based instances"
+ " (cluster-wide)",
+ action="store_false", default=True)
+
+ENABLED_HV_OPT = cli_option("--enabled-hypervisors",
+ dest="enabled_hypervisors",
+ help="Comma-separated list of hypervisors",
+ type="string", default=None)
+
+NIC_PARAMS_OPT = cli_option("-N", "--nic-parameters", dest="nicparams",
+ type="keyval", default={},
+ help="NIC parameters")
+
+CP_SIZE_OPT = cli_option("-C", "--candidate-pool-size", default=None,
+ dest="candidate_pool_size", type="int",
+ help="Set the candidate pool size")
+
+VG_NAME_OPT = cli_option("-g", "--vg-name", dest="vg_name",
+ help="Enables LVM and specifies the volume group"
+ " name (cluster-wide) for disk allocation [xenvg]",
+ metavar="VG", default=None)
+
+YES_DOIT_OPT = cli_option("--yes-do-it", dest="yes_do_it",
+ help="Destroy cluster", action="store_true")
+
+NOVOTING_OPT = cli_option("--no-voting", dest="no_voting",
+ help="Skip node agreement check (dangerous)",
+ action="store_true", default=False)
+
+MAC_PREFIX_OPT = cli_option("-m", "--mac-prefix", dest="mac_prefix",
+ help="Specify the mac prefix for the instance IP"
+ " addresses, in the format XX:XX:XX",
+ metavar="PREFIX",
+ default=None)
+
+MASTER_NETDEV_OPT = cli_option("--master-netdev", dest="master_netdev",
+ help="Specify the node interface (cluster-wide)"
+ " on which the master IP address will be added "
+ " [%s]" % constants.DEFAULT_BRIDGE,
+ metavar="NETDEV",
+ default=constants.DEFAULT_BRIDGE)
+
+GLOBAL_FILEDIR_OPT = cli_option("--file-storage-dir", dest="file_storage_dir",
+ help="Specify the default directory (cluster-"
+ "wide) for storing the file-based disks [%s]" %
+ constants.DEFAULT_FILE_STORAGE_DIR,
+ 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",
+ action="store_false", default=True)
+
+NOMODIFY_SSH_SETUP_OPT = cli_option("--no-ssh-init", dest="modify_ssh_setup",
+ help="Don't initialize SSH keys",
+ action="store_false", default=True)
+
+ERROR_CODES_OPT = cli_option("--error-codes", dest="error_codes",
+ help="Enable parseable error messages",
+ action="store_true", default=False)
+
+NONPLUS1_OPT = cli_option("--no-nplus1-mem", dest="skip_nplusone_mem",
+ help="Skip N+1 memory redundancy tests",
+ action="store_true", default=False)
+
+REBOOT_TYPE_OPT = cli_option("-t", "--type", dest="reboot_type",
+ help="Type of reboot: soft/hard/full",
+ default=constants.INSTANCE_REBOOT_HARD,
+ metavar="<REBOOT>",
+ choices=list(constants.REBOOT_TYPES))
+
+IGNORE_SECONDARIES_OPT = cli_option("--ignore-secondaries",
+ dest="ignore_secondaries",
+ default=False, action="store_true",
+ help="Ignore errors from secondaries")
+
+NOSHUTDOWN_OPT = cli_option("--noshutdown", dest="shutdown",
+ action="store_false", default=True,
+ help="Don't shutdown the instance (unsafe)")
+
+TIMEOUT_OPT = cli_option("--timeout", dest="timeout", type="int",
+ default=constants.DEFAULT_SHUTDOWN_TIMEOUT,
+ help="Maximum time to wait")
+
+SHUTDOWN_TIMEOUT_OPT = cli_option("--shutdown-timeout",
+ dest="shutdown_timeout", type="int",
+ default=constants.DEFAULT_SHUTDOWN_TIMEOUT,
+ help="Maximum time to wait for instance shutdown")
+
+EARLY_RELEASE_OPT = cli_option("--early-release",
+ dest="early_release", default=False,
+ action="store_true",
+ help="Release the locks on the secondary"
+ " node(s) early")
+
+NEW_CLUSTER_CERT_OPT = cli_option("--new-cluster-certificate",
+ dest="new_cluster_cert",
+ default=False, action="store_true",
+ help="Generate a new cluster certificate")
+
+RAPI_CERT_OPT = cli_option("--rapi-certificate", dest="rapi_cert",
+ default=None,
+ help="File containing new RAPI certificate")
+
+NEW_RAPI_CERT_OPT = cli_option("--new-rapi-certificate", dest="new_rapi_cert",
+ default=None, action="store_true",
+ help=("Generate a new self-signed RAPI"
+ " certificate"))
+
+NEW_CONFD_HMAC_KEY_OPT = cli_option("--new-confd-hmac-key",
+ dest="new_confd_hmac_key",
+ default=False, action="store_true",
+ help=("Create a new HMAC key for %s" %
+ constants.CONFD))
+
+CLUSTER_DOMAIN_SECRET_OPT = cli_option("--cluster-domain-secret",
+ dest="cluster_domain_secret",
+ default=None,
+ help=("Load new new cluster domain"
+ " secret from file"))
+
+NEW_CLUSTER_DOMAIN_SECRET_OPT = cli_option("--new-cluster-domain-secret",
+ dest="new_cluster_domain_secret",
+ default=False, action="store_true",
+ help=("Create a new cluster domain"
+ " secret"))
+
+USE_REPL_NET_OPT = cli_option("--use-replication-network",
+ dest="use_replication_network",
+ help="Whether to use the replication network"
+ " for talking to the nodes",
+ action="store_true", default=False)
+
+MAINTAIN_NODE_HEALTH_OPT = \
+ cli_option("--maintain-node-health", dest="maintain_node_health",
+ metavar=_YORNO, default=None, type="bool",
+ help="Configure the cluster to automatically maintain node"
+ " health, by shutting down unknown instances, shutting down"
+ " unknown DRBD devices, etc.")
+
+IDENTIFY_DEFAULTS_OPT = \
+ cli_option("--identify-defaults", dest="identify_defaults",
+ default=False, action="store_true",
+ help="Identify which saved instance parameters are equal to"
+ " the current cluster defaults and set them as such, instead"
+ " of marking them as overridden")
+
+UIDPOOL_OPT = cli_option("--uid-pool", default=None,
+ action="store", dest="uid_pool",
+ help=("A list of user-ids or user-id"
+ " ranges separated by commas"))
+
+ADD_UIDS_OPT = cli_option("--add-uids", default=None,
+ action="store", dest="add_uids",
+ help=("A list of user-ids or user-id"
+ " ranges separated by commas, to be"
+ " added to the user-id pool"))
+
+REMOVE_UIDS_OPT = cli_option("--remove-uids", default=None,
+ action="store", dest="remove_uids",
+ help=("A list of user-ids or user-id"
+ " ranges separated by commas, to be"
+ " removed from the user-id pool"))
def _ParseArgs(argv, commands, aliases):
binary = argv[0].split("/")[-1]
if len(argv) > 1 and argv[1] == "--version":
- print "%s (ganeti) %s" % (binary, constants.RELEASE_VERSION)
+ ToStdout("%s (ganeti) %s", binary, constants.RELEASE_VERSION)
# Quit right away. That way we don't have to care about this special
# argument. optparse.py does it the same.
sys.exit(0)
# let's do a nice thing
sortedcmds = commands.keys()
sortedcmds.sort()
- print ("Usage: %(bin)s {command} [options...] [argument...]"
- "\n%(bin)s <command> --help to see details, or"
- " man %(bin)s\n" % {"bin": binary})
+
+ ToStdout("Usage: %s {command} [options...] [argument...]", binary)
+ ToStdout("%s <command> --help to see details, or man %s", binary, binary)
+ ToStdout("")
+
# compute the max line length for cmd + usage
mlen = max([len(" %s" % cmd) for cmd in commands])
mlen = min(60, mlen) # should not get here...
+
# and format a nice command list
- print "Commands:"
+ ToStdout("Commands:")
for cmd in sortedcmds:
cmdstr = " %s" % (cmd,)
help_text = commands[cmd][4]
- help_lines = textwrap.wrap(help_text, 79-3-mlen)
- print "%-*s - %s" % (mlen, cmdstr, help_lines.pop(0))
+ help_lines = textwrap.wrap(help_text, 79 - 3 - mlen)
+ ToStdout("%-*s - %s", mlen, cmdstr, help_lines.pop(0))
for line in help_lines:
- print "%-*s %s" % (mlen, "", line)
- print
+ ToStdout("%-*s %s", mlen, "", line)
+
+ ToStdout("")
+
return None, None, None
# get command, unalias it, and look it up in commands
cmd = aliases[cmd]
- func, nargs, parser_opts, usage, description = commands[cmd]
- parser = OptionParser(option_list=parser_opts + [_DRY_RUN_OPT],
+ func, args_def, parser_opts, usage, description = commands[cmd]
+ parser = OptionParser(option_list=parser_opts + [_DRY_RUN_OPT, DEBUG_OPT],
description=description,
formatter=TitledHelpFormatter(),
usage="%%prog %s %s" % (cmd, usage))
parser.disable_interspersed_args()
options, args = parser.parse_args()
- if nargs is None:
- if len(args) != 0:
- print >> sys.stderr, ("Error: Command %s expects no arguments" % cmd)
- return None, None, None
- elif nargs < 0 and len(args) != -nargs:
- print >> sys.stderr, ("Error: Command %s expects %d argument(s)" %
- (cmd, -nargs))
- return None, None, None
- elif nargs >= 0 and len(args) < nargs:
- print >> sys.stderr, ("Error: Command %s expects at least %d argument(s)" %
- (cmd, nargs))
+
+ if not _CheckArguments(cmd, args_def, args):
return None, None, None
return func, options, args
+def _CheckArguments(cmd, args_def, args):
+ """Verifies the arguments using the argument definition.
+
+ Algorithm:
+
+ 1. Abort with error if values specified by user but none expected.
+
+ 1. For each argument in definition
+
+ 1. Keep running count of minimum number of values (min_count)
+ 1. Keep running count of maximum number of values (max_count)
+ 1. If it has an unlimited number of values
+
+ 1. Abort with error if it's not the last argument in the definition
+
+ 1. If last argument has limited number of values
+
+ 1. Abort with error if number of values doesn't match or is too large
+
+ 1. Abort with error if user didn't pass enough values (min_count)
+
+ """
+ if args and not args_def:
+ ToStderr("Error: Command %s expects no arguments", cmd)
+ return False
+
+ min_count = None
+ max_count = None
+ check_max = None
+
+ last_idx = len(args_def) - 1
+
+ for idx, arg in enumerate(args_def):
+ if min_count is None:
+ min_count = arg.min
+ elif arg.min is not None:
+ min_count += arg.min
+
+ if max_count is None:
+ max_count = arg.max
+ elif arg.max is not None:
+ max_count += arg.max
+
+ if idx == last_idx:
+ check_max = (arg.max is not None)
+
+ elif arg.max is None:
+ raise errors.ProgrammerError("Only the last argument can have max=None")
+
+ if check_max:
+ # Command with exact number of arguments
+ if (min_count is not None and max_count is not None and
+ min_count == max_count and len(args) != min_count):
+ ToStderr("Error: Command %s expects %d argument(s)", cmd, min_count)
+ return False
+
+ # Command with limited number of arguments
+ if max_count is not None and len(args) > max_count:
+ ToStderr("Error: Command %s expects only %d argument(s)",
+ cmd, max_count)
+ return False
+
+ # Command with some required arguments
+ if min_count is not None and len(args) < min_count:
+ ToStderr("Error: Command %s expects at least %d argument(s)",
+ cmd, min_count)
+ return False
+
+ return True
+
+
def SplitNodeOption(value):
"""Splits the value of a --node option.
return (value, None)
+def CalculateOSNames(os_name, os_variants):
+ """Calculates all the names an OS can be called, according to its variants.
+
+ @type os_name: string
+ @param os_name: base name of the os
+ @type os_variants: list or None
+ @param os_variants: list of supported variants
+ @rtype: list
+ @return: list of valid names
+
+ """
+ if os_variants:
+ return ['%s+%s' % (os_name, v) for v in os_variants]
+ else:
+ return [os_name]
+
+
def UsesRPC(fn):
def wrapper(*args, **kwargs):
rpc.Init()
prev_job_info = None
prev_logmsg_serial = None
+ status = None
+
+ notified_queued = False
+ notified_waitlock = False
+
while True:
- result = cl.WaitForJobChange(job_id, ["status"], prev_job_info,
- prev_logmsg_serial)
+ result = cl.WaitForJobChangeOnce(job_id, ["status"], prev_job_info,
+ prev_logmsg_serial)
if not result:
# job not found, go away!
raise errors.JobLost("Job with id %s lost" % job_id)
+ elif result == constants.JOB_NOTCHANGED:
+ if status is not None and not callable(feedback_fn):
+ if status == constants.JOB_STATUS_QUEUED and not notified_queued:
+ ToStderr("Job %s is waiting in queue", job_id)
+ notified_queued = True
+ elif status == constants.JOB_STATUS_WAITLOCK and not notified_waitlock:
+ ToStderr("Job %s is trying to acquire all necessary locks", job_id)
+ notified_waitlock = True
+
+ # Wait again
+ continue
# Split result, a tuple of (field values, log entries)
(job_info, log_entries) = result
feedback_fn(log_entry[1:])
else:
encoded = utils.SafeEncode(message)
- print "%s %s" % (time.ctime(utils.MergeTime(timestamp)), encoded)
+ ToStdout("%s %s", time.ctime(utils.MergeTime(timestamp)), encoded)
prev_logmsg_serial = max(prev_logmsg_serial, serial)
# TODO: Handle canceled and archived jobs
if status == constants.OP_STATUS_SUCCESS:
has_ok = True
elif status == constants.OP_STATUS_ERROR:
+ errors.MaybeRaise(msg)
if has_ok:
raise errors.OpExecError("partial failure (opcode %d): %s" %
(idx, msg))
raise errors.OpExecError(result)
-def SubmitOpCode(op, cl=None, feedback_fn=None):
+def SubmitOpCode(op, cl=None, feedback_fn=None, opts=None):
"""Legacy function to submit an opcode.
This is just a simple wrapper over the construction of the processor
if cl is None:
cl = GetClient()
+ SetGenericOpcodeOpts([op], opts)
+
job_id = SendJob([op], cl)
op_results = PollJob(job_id, cl=cl, feedback_fn=feedback_fn)
whether to just send the job and print its identifier. It is used in
order to simplify the implementation of the '--submit' option.
- It will also add the dry-run parameter from the options passed, if true.
+ It will also process the opcodes if we're sending the via SendJob
+ (otherwise SubmitOpCode does it).
"""
- if opts and opts.dry_run:
- op.dry_run = opts.dry_run
if opts and opts.submit_only:
- job_id = SendJob([op], cl=cl)
+ job = [op]
+ SetGenericOpcodeOpts(job, opts)
+ job_id = SendJob(job, cl=cl)
raise JobSubmittedException(job_id)
else:
- return SubmitOpCode(op, cl=cl, feedback_fn=feedback_fn)
+ return SubmitOpCode(op, cl=cl, feedback_fn=feedback_fn, opts=opts)
+
+
+def SetGenericOpcodeOpts(opcode_list, options):
+ """Processor for generic options.
+
+ This function updates the given opcodes based on generic command
+ line options (like debug, dry-run, etc.).
+
+ @param opcode_list: list of opcodes
+ @param options: command line options or None
+ @return: None (in-place modification)
+
+ """
+ if not options:
+ return
+ for op in opcode_list:
+ op.dry_run = options.dry_run
+ op.debug_level = options.debug
def GetClient():
try:
client = luxi.Client()
except luxi.NoMasterError:
- master, myself = ssconf.GetMasterAndMyself()
+ ss = ssconf.SimpleStore()
+
+ # Try to read ssconf file
+ try:
+ ss.GetMasterNode()
+ except errors.ConfigurationError:
+ raise errors.OpPrereqError("Cluster not initialized or this machine is"
+ " not part of a cluster")
+
+ master, myself = ssconf.GetMasterAndMyself(ss=ss)
if master != myself:
raise errors.OpPrereqError("This is not the master node, please connect"
" to node '%s' and rerun the command" %
master)
- else:
- raise
+ raise
return client
msg = "Failure: can't resolve hostname '%s'"
obuf.write(msg % err.args[0])
elif isinstance(err, errors.OpPrereqError):
- obuf.write("Failure: prerequisites not met for this"
- " operation:\n%s" % msg)
+ if len(err.args) == 2:
+ obuf.write("Failure: prerequisites not met for this"
+ " operation:\nerror type: %s, error details:\n%s" %
+ (err.args[1], err.args[0]))
+ else:
+ obuf.write("Failure: prerequisites not met for this"
+ " operation:\n%s" % msg)
elif isinstance(err, errors.OpExecError):
obuf.write("Failure: command execution error:\n%s" % msg)
elif isinstance(err, errors.TagError):
obuf.write("Parameter Error: %s" % msg)
elif isinstance(err, errors.ParameterError):
obuf.write("Failure: unknown/wrong parameter name '%s'" % msg)
- elif isinstance(err, errors.GenericError):
- obuf.write("Unhandled Ganeti error: %s" % msg)
elif isinstance(err, luxi.NoMasterError):
obuf.write("Cannot communicate with the master daemon.\nIs it running"
" and listening for connections?")
elif isinstance(err, luxi.ProtocolError):
obuf.write("Unhandled protocol error while talking to the master daemon:\n"
"%s" % msg)
+ elif isinstance(err, errors.GenericError):
+ obuf.write("Unhandled Ganeti error: %s" % msg)
elif isinstance(err, JobSubmittedException):
obuf.write("JobID: %s\n" % err.args[0])
retcode = 0
return result
+def GenericInstanceCreate(mode, opts, args):
+ """Add an instance to the cluster via either creation or import.
+
+ @param mode: constants.INSTANCE_CREATE or constants.INSTANCE_IMPORT
+ @param opts: the command line options selected by the user
+ @type args: list
+ @param args: should contain only one element, the new instance name
+ @rtype: int
+ @return: the desired exit code
+
+ """
+ instance = args[0]
+
+ (pnode, snode) = SplitNodeOption(opts.node)
+
+ hypervisor = None
+ hvparams = {}
+ if opts.hypervisor:
+ hypervisor, hvparams = opts.hypervisor
+
+ if opts.nics:
+ try:
+ nic_max = max(int(nidx[0]) + 1 for nidx in opts.nics)
+ except ValueError, err:
+ raise errors.OpPrereqError("Invalid NIC index passed: %s" % str(err))
+ nics = [{}] * nic_max
+ for nidx, ndict in opts.nics:
+ nidx = int(nidx)
+ if not isinstance(ndict, dict):
+ msg = "Invalid nic/%d value: expected dict, got %s" % (nidx, ndict)
+ raise errors.OpPrereqError(msg)
+ nics[nidx] = ndict
+ elif opts.no_nics:
+ # no nics
+ nics = []
+ elif mode == constants.INSTANCE_CREATE:
+ # default of one nic, all auto
+ nics = [{}]
+ else:
+ # mode == import
+ nics = []
+
+ if opts.disk_template == constants.DT_DISKLESS:
+ if opts.disks or opts.sd_size is not None:
+ raise errors.OpPrereqError("Diskless instance but disk"
+ " information passed")
+ disks = []
+ else:
+ if (not opts.disks and not opts.sd_size
+ and mode == constants.INSTANCE_CREATE):
+ raise errors.OpPrereqError("No disk information specified")
+ if opts.disks and opts.sd_size is not None:
+ raise errors.OpPrereqError("Please use either the '--disk' or"
+ " '-s' option")
+ if opts.sd_size is not None:
+ opts.disks = [(0, {"size": opts.sd_size})]
+
+ if opts.disks:
+ try:
+ disk_max = max(int(didx[0]) + 1 for didx in opts.disks)
+ except ValueError, err:
+ raise errors.OpPrereqError("Invalid disk index passed: %s" % str(err))
+ disks = [{}] * disk_max
+ else:
+ disks = []
+ for didx, ddict in opts.disks:
+ didx = int(didx)
+ if not isinstance(ddict, dict):
+ msg = "Invalid disk/%d value: expected dict, got %s" % (didx, ddict)
+ raise errors.OpPrereqError(msg)
+ elif "size" in ddict:
+ if "adopt" in ddict:
+ raise errors.OpPrereqError("Only one of 'size' and 'adopt' allowed"
+ " (disk %d)" % didx)
+ try:
+ ddict["size"] = utils.ParseUnit(ddict["size"])
+ except ValueError, err:
+ raise errors.OpPrereqError("Invalid disk size for disk %d: %s" %
+ (didx, err))
+ elif "adopt" in ddict:
+ if mode == constants.INSTANCE_IMPORT:
+ raise errors.OpPrereqError("Disk adoption not allowed for instance"
+ " import")
+ ddict["size"] = 0
+ else:
+ raise errors.OpPrereqError("Missing size or adoption source for"
+ " disk %d" % didx)
+ disks[didx] = ddict
+
+ utils.ForceDictType(opts.beparams, constants.BES_PARAMETER_TYPES)
+ utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES)
+
+ if mode == constants.INSTANCE_CREATE:
+ start = opts.start
+ os_type = opts.os
+ src_node = None
+ src_path = None
+ no_install = opts.no_install
+ identify_defaults = False
+ elif mode == constants.INSTANCE_IMPORT:
+ start = False
+ os_type = None
+ src_node = opts.src_node
+ src_path = opts.src_dir
+ no_install = None
+ identify_defaults = opts.identify_defaults
+ else:
+ raise errors.ProgrammerError("Invalid creation mode %s" % mode)
+
+ op = opcodes.OpCreateInstance(instance_name=instance,
+ disks=disks,
+ disk_template=opts.disk_template,
+ nics=nics,
+ pnode=pnode, snode=snode,
+ ip_check=opts.ip_check,
+ name_check=opts.name_check,
+ wait_for_sync=opts.wait_for_sync,
+ file_storage_dir=opts.file_storage_dir,
+ file_driver=opts.file_driver,
+ iallocator=opts.iallocator,
+ hypervisor=hypervisor,
+ hvparams=hvparams,
+ beparams=opts.beparams,
+ mode=mode,
+ start=start,
+ os_type=os_type,
+ src_node=src_node,
+ src_path=src_path,
+ no_install=no_install,
+ identify_defaults=identify_defaults)
+
+ SubmitOrSend(op, opts)
+ return 0
+
+
+class _RunWhileClusterStoppedHelper:
+ """Helper class for L{RunWhileClusterStopped} to simplify state management
+
+ """
+ def __init__(self, feedback_fn, cluster_name, master_node, online_nodes):
+ """Initializes this class.
+
+ @type feedback_fn: callable
+ @param feedback_fn: Feedback function
+ @type cluster_name: string
+ @param cluster_name: Cluster name
+ @type master_node: string
+ @param master_node Master node name
+ @type online_nodes: list
+ @param online_nodes: List of names of online nodes
+
+ """
+ self.feedback_fn = feedback_fn
+ self.cluster_name = cluster_name
+ self.master_node = master_node
+ self.online_nodes = online_nodes
+
+ self.ssh = ssh.SshRunner(self.cluster_name)
+
+ self.nonmaster_nodes = [name for name in online_nodes
+ if name != master_node]
+
+ assert self.master_node not in self.nonmaster_nodes
+
+ def _RunCmd(self, node_name, cmd):
+ """Runs a command on the local or a remote machine.
+
+ @type node_name: string
+ @param node_name: Machine name
+ @type cmd: list
+ @param cmd: Command
+
+ """
+ if node_name is None or node_name == self.master_node:
+ # No need to use SSH
+ result = utils.RunCmd(cmd)
+ else:
+ result = self.ssh.Run(node_name, "root", utils.ShellQuoteArgs(cmd))
+
+ if result.failed:
+ errmsg = ["Failed to run command %s" % result.cmd]
+ if node_name:
+ errmsg.append("on node %s" % node_name)
+ errmsg.append(": exitcode %s and error %s" %
+ (result.exit_code, result.output))
+ raise errors.OpExecError(" ".join(errmsg))
+
+ def Call(self, fn, *args):
+ """Call function while all daemons are stopped.
+
+ @type fn: callable
+ @param fn: Function to be called
+
+ """
+ # Pause watcher by acquiring an exclusive lock on watcher state file
+ self.feedback_fn("Blocking watcher")
+ watcher_block = utils.FileLock.Open(constants.WATCHER_STATEFILE)
+ try:
+ # TODO: Currently, this just blocks. There's no timeout.
+ # TODO: Should it be a shared lock?
+ watcher_block.Exclusive(blocking=True)
+
+ # Stop master daemons, so that no new jobs can come in and all running
+ # ones are finished
+ self.feedback_fn("Stopping master daemons")
+ self._RunCmd(None, [constants.DAEMON_UTIL, "stop-master"])
+ try:
+ # Stop daemons on all nodes
+ for node_name in self.online_nodes:
+ self.feedback_fn("Stopping daemons on %s" % node_name)
+ self._RunCmd(node_name, [constants.DAEMON_UTIL, "stop-all"])
+
+ # All daemons are shut down now
+ try:
+ return fn(self, *args)
+ except Exception, err:
+ _, errmsg = FormatError(err)
+ logging.exception("Caught exception")
+ self.feedback_fn(errmsg)
+ raise
+ finally:
+ # Start cluster again, master node last
+ for node_name in self.nonmaster_nodes + [self.master_node]:
+ self.feedback_fn("Starting daemons on %s" % node_name)
+ self._RunCmd(node_name, [constants.DAEMON_UTIL, "start-all"])
+ finally:
+ # Resume watcher
+ watcher_block.Close()
+
+
+def RunWhileClusterStopped(feedback_fn, fn, *args):
+ """Calls a function while all cluster daemons are stopped.
+
+ @type feedback_fn: callable
+ @param feedback_fn: Feedback function
+ @type fn: callable
+ @param fn: Function to be called when daemons are stopped
+
+ """
+ feedback_fn("Gathering cluster information")
+
+ # This ensures we're running on the master daemon
+ cl = GetClient()
+
+ (cluster_name, master_node) = \
+ cl.QueryConfigValues(["cluster_name", "master_node"])
+
+ online_nodes = GetOnlineNodes([], cl=cl)
+
+ # Don't keep a reference to the client. The master daemon will go away.
+ del cl
+
+ assert master_node in online_nodes
+
+ return _RunWhileClusterStoppedHelper(feedback_fn, cluster_name, master_node,
+ online_nodes).Call(fn, *args)
+
+
def GenerateTable(headers, fields, separator, data,
numfields=None, unitfields=None,
units=None):
if unitfields is None:
unitfields = []
- numfields = utils.FieldSet(*numfields)
- unitfields = utils.FieldSet(*unitfields)
+ numfields = utils.FieldSet(*numfields) # pylint: disable-msg=W0142
+ unitfields = utils.FieldSet(*unitfields) # pylint: disable-msg=W0142
format_fields = []
for field in fields:
if unitfields.Matches(fields[idx]):
try:
val = int(val)
- except ValueError:
+ except (TypeError, ValueError):
pass
else:
val = row[idx] = utils.FormatUnit(val, units)
args.append(hdr)
result.append(format % tuple(args))
+ if separator is None:
+ assert len(mlens) == len(fields)
+
+ if fields and not numfields.Matches(fields[-1]):
+ mlens[-1] = 0
+
for line in data:
args = []
if line is None:
line = ['-' for _ in fields]
- for idx in xrange(len(fields)):
+ for idx in range(len(fields)):
if separator is None:
args.append(mlens[idx])
args.append(line[idx])
if value[-1] not in suffix_map:
try:
value = int(value)
- except ValueError:
+ except (TypeError, ValueError):
raise errors.OpPrereqError("Invalid time specification '%s'" % value)
else:
multiplier = suffix_map[value[-1]]
" suffix passed)")
try:
value = int(value) * multiplier
- except ValueError:
+ except (TypeError, ValueError):
raise errors.OpPrereqError("Invalid time specification '%s'" % value)
return value
-def GetOnlineNodes(nodes, cl=None, nowarn=False):
+def GetOnlineNodes(nodes, cl=None, nowarn=False, secondary_ips=False,
+ filter_master=False):
"""Returns the names of online nodes.
This function will also log a warning on stderr with the names of
@param nowarn: by default, this function will output a note with the
offline nodes that are skipped; if this parameter is True the
note is not displayed
+ @type secondary_ips: boolean
+ @param secondary_ips: if True, return the secondary IPs instead of the
+ names, useful for doing network traffic over the replication interface
+ (if any)
+ @type filter_master: boolean
+ @param filter_master: if True, do not return the master node in the list
+ (useful in coordination with secondary_ips where we cannot check our
+ node name against the list)
"""
if cl is None:
cl = GetClient()
- result = cl.QueryNodes(names=nodes, fields=["name", "offline"],
+ if secondary_ips:
+ name_idx = 2
+ else:
+ name_idx = 0
+
+ if filter_master:
+ master_node = cl.QueryConfigValues(["master_node"])[0]
+ filter_fn = lambda x: x != master_node
+ else:
+ filter_fn = lambda _: True
+
+ result = cl.QueryNodes(names=nodes, fields=["name", "offline", "sip"],
use_locking=False)
offline = [row[0] for row in result if row[1]]
if offline and not nowarn:
- ToStderr("Note: skipping offline node(s): %s" % ", ".join(offline))
- return [row[0] for row in result if not row[1]]
+ ToStderr("Note: skipping offline node(s): %s" % utils.CommaJoin(offline))
+ return [row[name_idx] for row in result if not row[1] and filter_fn(row[0])]
def _ToStream(stream, txt, *args):
GetResults() calls.
"""
- def __init__(self, cl=None, verbose=True):
+ def __init__(self, cl=None, verbose=True, opts=None, feedback_fn=None):
self.queue = []
if cl is None:
cl = GetClient()
self.cl = cl
self.verbose = verbose
self.jobs = []
+ self.opts = opts
+ self.feedback_fn = feedback_fn
def QueueJob(self, name, *ops):
"""Record a job for later submit.
@type name: string
@param name: a description of the job, will be used in WaitJobSet
"""
+ SetGenericOpcodeOpts(ops, self.opts)
self.queue.append((name, ops))
def SubmitPending(self):
"""
results = self.cl.SubmitManyJobs([row[1] for row in self.queue])
- for ((status, data), (name, _)) in zip(results, self.queue):
- self.jobs.append((status, data, name))
+ for (idx, ((status, data), (name, _))) in enumerate(zip(results,
+ self.queue)):
+ self.jobs.append((idx, status, data, name))
+
+ def _ChooseJob(self):
+ """Choose a non-waiting/queued job to poll next.
+
+ """
+ assert self.jobs, "_ChooseJob called with empty job list"
+
+ result = self.cl.QueryJobs([i[2] for i in self.jobs], ["status"])
+ assert result
+
+ for job_data, status in zip(self.jobs, result):
+ if status[0] in (constants.JOB_STATUS_QUEUED,
+ constants.JOB_STATUS_WAITLOCK,
+ constants.JOB_STATUS_CANCELING):
+ # job is still waiting
+ continue
+ # good candidate found
+ self.jobs.remove(job_data)
+ return job_data
+
+ # no job found
+ return self.jobs.pop(0)
def GetResults(self):
"""Wait for and return the results of all jobs.
self.SubmitPending()
results = []
if self.verbose:
- ok_jobs = [row[1] for row in self.jobs if row[0]]
+ ok_jobs = [row[2] for row in self.jobs if row[1]]
if ok_jobs:
- ToStdout("Submitted jobs %s", ", ".join(ok_jobs))
- for submit_status, jid, name in self.jobs:
- if not submit_status:
- ToStderr("Failed to submit job for %s: %s", name, jid)
- results.append((False, jid))
- continue
- if self.verbose:
- ToStdout("Waiting for job %s for %s...", jid, name)
+ ToStdout("Submitted jobs %s", utils.CommaJoin(ok_jobs))
+
+ # first, remove any non-submitted jobs
+ self.jobs, failures = compat.partition(self.jobs, lambda x: x[1])
+ for idx, _, jid, name in failures:
+ ToStderr("Failed to submit job for %s: %s", name, jid)
+ results.append((idx, False, jid))
+
+ while self.jobs:
+ (idx, _, jid, name) = self._ChooseJob()
+ ToStdout("Waiting for job %s for %s...", jid, name)
try:
- job_result = PollJob(jid, cl=self.cl)
+ job_result = PollJob(jid, cl=self.cl, feedback_fn=self.feedback_fn)
success = True
except (errors.GenericError, luxi.ProtocolError), err:
_, job_result = FormatError(err)
# the error message will always be shown, verbose or not
ToStderr("Job %s for %s has failed: %s", jid, name, job_result)
- results.append((success, job_result))
+ results.append((idx, success, job_result))
+
+ # sort based on the index, then drop it
+ results.sort()
+ results = [i[1:] for i in results]
+
return results
def WaitOrShow(self, wait):
else:
if not self.jobs:
self.SubmitPending()
- for status, result, name in self.jobs:
+ for _, status, result, name in self.jobs:
if status:
ToStdout("%s: %s", result, name)
else: