"ListTags", "AddTags", "RemoveTags", "TAG_SRC_OPT",
"FormatError", "SplitNodeOption", "SubmitOrSend",
"JobSubmittedException", "FormatTimestamp", "ParseTimespec",
- "ValidateBeParams", "ToStderr", "ToStdout", "UsesRPC",
- "GetOnlineNodes", "JobExecutor", "SYNC_OPT",
+ "ToStderr", "ToStdout", "UsesRPC",
+ "GetOnlineNodes", "JobExecutor", "SYNC_OPT", "CONFIRM_OPT",
]
+NO_PREFIX = "no_"
+UN_PREFIX = "-"
def _ExtractTagsObject(opts, args):
"""Extract the tag type object.
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")
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"""
@raises errors.ParameterError: if there are duplicate keys
"""
- NO_PREFIX = "no_"
- UN_PREFIX = "-"
kv_dict = {}
- for elem in data.split(","):
- if "=" in elem:
- key, val = elem.split("=", 1)
- else:
- if elem.startswith(NO_PREFIX):
- key, val = elem[len(NO_PREFIX):], False
- elif elem.startswith(UN_PREFIX):
- key, val = elem[len(UN_PREFIX):], None
+ if data:
+ for elem in data.split(","):
+ if "=" in elem:
+ key, val = elem.split("=", 1)
else:
- key, val = elem, True
- if key in kv_dict:
- raise errors.ParameterError("Duplicate key '%s' in option %s" %
- (key, opt))
- kv_dict[key] = val
+ if elem.startswith(NO_PREFIX):
+ key, val = elem[len(NO_PREFIX):], False
+ elif elem.startswith(UN_PREFIX):
+ key, val = elem[len(UN_PREFIX):], None
+ else:
+ key, val = elem, True
+ if key in kv_dict:
+ raise errors.ParameterError("Duplicate key '%s' in option %s" %
+ (key, opt))
+ kv_dict[key] = val
return kv_dict
"""
if ":" not in value:
- retval = (value, {})
+ ident, rest = value, ''
else:
ident, rest = value.split(":", 1)
+
+ if ident.startswith(NO_PREFIX):
+ if rest:
+ msg = "Cannot pass options when removing parameter groups: %s" % value
+ raise errors.ParameterError(msg)
+ retval = (ident[len(NO_PREFIX):], False)
+ elif ident.startswith(UN_PREFIX):
+ if rest:
+ msg = "Cannot pass options when removing parameter groups: %s" % value
+ raise errors.ParameterError(msg)
+ retval = (ident[len(UN_PREFIX):], None)
+ else:
kv_dict = _SplitKeyVal(opt, rest)
retval = (ident, kv_dict)
return retval
def _ParseArgs(argv, commands, aliases):
"""Parser for the command line arguments.
- This function parses the arguements and returns the function which
+ This function parses the arguments and returns the function which
must be executed together with its (modified) arguments.
@param argv: the command line
cmd = aliases[cmd]
func, nargs, parser_opts, usage, description = commands[cmd]
- parser = OptionParser(option_list=parser_opts,
+ parser = OptionParser(option_list=parser_opts + [_DRY_RUN_OPT],
description=description,
formatter=TitledHelpFormatter(),
usage="%%prog %s %s" % (cmd, usage))
return (value, None)
-def ValidateBeParams(bep):
- """Parse and check the given beparams.
-
- The function will update in-place the given dictionary.
-
- @type bep: dict
- @param bep: input beparams
- @raise errors.ParameterError: if the input values are not OK
- @raise errors.UnitParseError: if the input values are not OK
-
- """
- if constants.BE_MEMORY in bep:
- bep[constants.BE_MEMORY] = utils.ParseUnit(bep[constants.BE_MEMORY])
-
- if constants.BE_VCPUS in bep:
- try:
- bep[constants.BE_VCPUS] = int(bep[constants.BE_VCPUS])
- except ValueError:
- raise errors.ParameterError("Invalid number of VCPUs")
-
-
def UsesRPC(fn):
def wrapper(*args, **kwargs):
rpc.Init()
choices = [('y', True, 'Perform the operation'),
('n', False, 'Do not perform the operation')]
if not choices or not isinstance(choices, list):
- raise errors.ProgrammerError("Invalid choiches argument to AskUser")
+ raise errors.ProgrammerError("Invalid choices argument to AskUser")
for entry in choices:
if not isinstance(entry, tuple) or len(entry) < 3 or entry[0] == '?':
- raise errors.ProgrammerError("Invalid choiches element to AskUser")
+ raise errors.ProgrammerError("Invalid choices element to AskUser")
answer = choices[-1][1]
new_text = []
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.
+
"""
+ if opts and opts.dry_run:
+ op.dry_run = opts.dry_run
if opts and opts.submit_only:
job_id = SendJob([op], cl=cl)
raise JobSubmittedException(job_id)
elif isinstance(err, errors.JobQueueFull):
obuf.write("Failure: the job queue is full and doesn't accept new"
" job submissions until old jobs are archived\n")
+ elif isinstance(err, errors.TypeEnforcementError):
+ 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):
if aliases is None:
aliases = {}
- func, options, args = _ParseArgs(sys.argv, commands, aliases)
+ try:
+ func, options, args = _ParseArgs(sys.argv, commands, aliases)
+ except errors.ParameterError, err:
+ result, err_msg = FormatError(err)
+ ToStderr(err_msg)
+ return 1
+
if func is None: # parse error
return 1
except (errors.GenericError, luxi.ProtocolError,
JobSubmittedException), err:
result, err_msg = FormatError(err)
- logging.exception("Error durring command processing")
+ logging.exception("Error during command processing")
ToStderr(err_msg)
return result
format_fields = []
for field in fields:
if headers and field not in headers:
- # FIXME: handle better unknown fields (either revert to old
+ # TODO: handle better unknown fields (either revert to old
# style of raising exception, or deal more intelligently with
# variable fields)
headers[field] = field
format = separator.replace("%", "%%").join(format_fields)
for row in data:
+ if row is None:
+ continue
for idx, val in enumerate(row):
if unitfields.Matches(fields[idx]):
try:
for line in data:
args = []
+ if line is None:
+ line = ['-' for _ in fields]
for idx in xrange(len(fields)):
if separator is None:
args.append(mlens[idx])
@param ts: a timeval-type timestamp, a tuple of seconds and microseconds
@rtype: string
- @returns: a string with the formatted timestamp
+ @return: a string with the formatted timestamp
"""
if not isinstance (ts, (tuple, list)) or len(ts) != 2:
cl = GetClient()
self.cl = cl
self.verbose = verbose
+ self.jobs = []
def QueueJob(self, name, *ops):
- """Submit a job for execution.
+ """Record a job for later submit.
@type name: string
@param name: a description of the job, will be used in WaitJobSet
"""
- job_id = SendJob(ops, cl=self.cl)
- self.queue.append((job_id, name))
+ self.queue.append((name, ops))
+
+ def SubmitPending(self):
+ """Submit all pending jobs.
+
+ """
+ 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))
def GetResults(self):
"""Wait for and return the results of all jobs.
there will be the error message
"""
+ if not self.jobs:
+ self.SubmitPending()
results = []
if self.verbose:
- ToStdout("Submitted jobs %s", ", ".join(row[0] for row in self.queue))
- for jid, name in self.queue:
+ ok_jobs = [row[1] for row in self.jobs if row[0]]
+ 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)
try:
if wait:
return self.GetResults()
else:
- for jid, name in self.queue:
- ToStdout("%s: %s", jid, name)
+ if not self.jobs:
+ self.SubmitPending()
+ for status, result, name in self.jobs:
+ if status:
+ ToStdout("%s: %s", result, name)
+ else:
+ ToStderr("Failure for %s: %s", name, result)