def PrintExportList(opts, args): """Prints a list of all the exported system images. @param opts: the command line options selected by the user @type args: list @param args: should be an empty list @rtype: int @return: the desired exit code """ selected_fields = ParseFields(opts.output, _LIST_DEF_FIELDS) qfilter = qlang.MakeSimpleFilter("node", opts.nodes) cl = GetClient() return GenericList(constants.QR_EXPORT, selected_fields, None, opts.units, opts.separator, not opts.no_headers, verbose=opts.verbose, qfilter=qfilter, cl=cl)
def ListJobs(opts, args): """List the jobs @param opts: the command line options selected by the user @type args: list @param args: should be an empty list @rtype: int @return: the desired exit code """ selected_fields = ParseFields(opts.output, _LIST_DEF_FIELDS) if opts.archived and "archived" not in selected_fields: selected_fields.append("archived") qfilter = qlang.MakeSimpleFilter("status", opts.status_filter) cl = GetClient(query=True) return GenericList(constants.QR_JOB, selected_fields, args, None, opts.separator, not opts.no_headers, format_override=_JOB_LIST_FORMAT, verbose=opts.verbose, force_filter=opts.force_filter, namefield="id", qfilter=qfilter, isnumeric=True, cl=cl)
def _BuildFilter(fields, names): """Builds a filter for querying OSes. """ name_filter = qlang.MakeSimpleFilter("name", names) # Legacy behaviour: Hide hidden, blacklisted or invalid OSes if the # respective field is not requested status_filter = [[qlang.OP_NOT, [qlang.OP_TRUE, fname]] for fname in ["hidden", "blacklisted"] if fname not in fields] if "valid" not in fields: status_filter.append([qlang.OP_TRUE, "valid"]) if status_filter: status_filter.insert(0, qlang.OP_AND) else: status_filter = None if name_filter and status_filter: return [qlang.OP_AND, name_filter, status_filter] elif name_filter: return name_filter else: return status_filter
def _MultiJobAction(opts, args, cl, stdout_fn, ask_fn, question, action_fn): """Applies a function to multipe jobs. @param opts: Command line options @type args: list @param args: Job IDs @rtype: int @return: Exit code """ if cl is None: cl = GetClient() if stdout_fn is None: stdout_fn = ToStdout if ask_fn is None: ask_fn = AskUser result = constants.EXIT_SUCCESS if bool(args) ^ (opts.status_filter is None): raise errors.OpPrereqError( "Either a status filter or job ID(s) must be" " specified and never both", errors.ECODE_INVAL) if opts.status_filter is not None: response = cl.Query( constants.QR_JOB, ["id", "status", "summary"], qlang.MakeSimpleFilter("status", opts.status_filter)) jobs = [i for ((_, i), _, _) in response.data] if not jobs: raise errors.OpPrereqError( "No jobs with the requested status have been" " found", errors.ECODE_STATE) if not opts.force: (_, table) = FormatQueryResult(response, header=True, format_override=_JOB_LIST_FORMAT) for line in table: stdout_fn(line) if not ask_fn(question): return constants.EXIT_CONFIRMATION else: jobs = args for job_id in jobs: (success, msg) = action_fn(cl, job_id) if not success: result = constants.EXIT_FAILURE stdout_fn(msg) return result
def _Query(qfilter): # Need to sort as constants.JOBS_PENDING has no stable order assert isinstance(constants.JOBS_PENDING, frozenset) self.assertEqual( sorted(qfilter), sorted(qlang.MakeSimpleFilter("status", constants.JOBS_PENDING))) return [ [(constants.RS_UNAVAIL, None), (constants.RS_UNAVAIL, None), (constants.RS_UNAVAIL, None)], [(constants.RS_NORMAL, 32532), (constants.RS_NORMAL, constants.JOB_STATUS_QUEUED), (constants.RS_NORMAL, ["op1", "op2", "op3"])], ]
def _GetPendingVerifyDisks(cl, uuid): """Checks if there are any currently running or pending group verify jobs and if so, returns their id. """ qfilter = qlang.MakeSimpleFilter( "status", frozenset([ constants.JOB_STATUS_RUNNING, constants.JOB_STATUS_QUEUED, constants.JOB_STATUS_WAITING ])) qresult = cl.Query(constants.QR_JOB, ["id", "summary"], qfilter) ids = [ jobid for ((_, jobid), (_, (job, ))) in qresult.data if job == ("GROUP_VERIFY_DISKS(%s)" % uuid) ] return ids
def ShowJobs(opts, args): """Show detailed information about jobs. @param opts: the command line options selected by the user @type args: list @param args: should contain the job IDs to be queried @rtype: int @return: the desired exit code """ def format_msg(level, text): """Display the text indented.""" ToStdout("%s%s", " " * level, text) def result_helper(value): """Format a result field in a nice way.""" if isinstance(value, (tuple, list)): return "[%s]" % utils.CommaJoin(value) else: return str(value) selected_fields = [ "id", "status", "ops", "opresult", "opstatus", "oplog", "opstart", "opexec", "opend", "received_ts", "start_ts", "end_ts", ] qfilter = qlang.MakeSimpleFilter("id", _ParseJobIds(args)) cl = GetClient(query=True) result = cl.Query(constants.QR_JOB, selected_fields, qfilter).data first = True for entry in result: if not first: format_msg(0, "") else: first = False ((_, job_id), (rs_status, status), (_, ops), (_, opresult), (_, opstatus), (_, oplog), (_, opstart), (_, opexec), (_, opend), (_, recv_ts), (_, start_ts), (_, end_ts)) = entry # Detect non-normal results if rs_status != constants.RS_NORMAL: format_msg(0, "Job ID %s not found" % job_id) continue format_msg(0, "Job ID: %s" % job_id) if status in _USER_JOB_STATUS: status = _USER_JOB_STATUS[status] else: raise errors.ProgrammerError("Unknown job status code '%s'" % status) format_msg(1, "Status: %s" % status) if recv_ts is not None: format_msg(1, "Received: %s" % FormatTimestamp(recv_ts)) else: format_msg(1, "Missing received timestamp (%s)" % str(recv_ts)) if start_ts is not None: if recv_ts is not None: d1 = start_ts[0] - recv_ts[0] + (start_ts[1] - recv_ts[1]) / 1000000.0 delta = " (delta %.6fs)" % d1 else: delta = "" format_msg( 1, "Processing start: %s%s" % (FormatTimestamp(start_ts), delta)) else: format_msg(1, "Processing start: unknown (%s)" % str(start_ts)) if end_ts is not None: if start_ts is not None: d2 = end_ts[0] - start_ts[0] + (end_ts[1] - start_ts[1]) / 1000000.0 delta = " (delta %.6fs)" % d2 else: delta = "" format_msg( 1, "Processing end: %s%s" % (FormatTimestamp(end_ts), delta)) else: format_msg(1, "Processing end: unknown (%s)" % str(end_ts)) if end_ts is not None and recv_ts is not None: d3 = end_ts[0] - recv_ts[0] + (end_ts[1] - recv_ts[1]) / 1000000.0 format_msg(1, "Total processing time: %.6f seconds" % d3) else: format_msg(1, "Total processing time: N/A") format_msg(1, "Opcodes:") for (opcode, result, status, log, s_ts, x_ts, e_ts) in \ zip(ops, opresult, opstatus, oplog, opstart, opexec, opend): format_msg(2, "%s" % opcode["OP_ID"]) format_msg(3, "Status: %s" % status) if isinstance(s_ts, (tuple, list)): format_msg(3, "Processing start: %s" % FormatTimestamp(s_ts)) else: format_msg(3, "No processing start time") if isinstance(x_ts, (tuple, list)): format_msg(3, "Execution start: %s" % FormatTimestamp(x_ts)) else: format_msg(3, "No execution start time") if isinstance(e_ts, (tuple, list)): format_msg(3, "Processing end: %s" % FormatTimestamp(e_ts)) else: format_msg(3, "No processing end time") format_msg(3, "Input fields:") for key in utils.NiceSort(opcode.keys()): if key == "OP_ID": continue val = opcode[key] if isinstance(val, (tuple, list)): val = ",".join([str(item) for item in val]) format_msg(4, "%s: %s" % (key, val)) if result is None: format_msg(3, "No output data") elif isinstance(result, (tuple, list)): if not result: format_msg(3, "Result: empty sequence") else: format_msg(3, "Result:") for elem in result: format_msg(4, result_helper(elem)) elif isinstance(result, dict): if not result: format_msg(3, "Result: empty dictionary") else: format_msg(3, "Result:") for key, val in result.iteritems(): format_msg(4, "%s: %s" % (key, result_helper(val))) else: format_msg(3, "Result: %s" % result) format_msg(3, "Execution log:") for serial, log_ts, log_type, log_msg in log: time_txt = FormatTimestamp(log_ts) encoded = FormatLogMessage(log_type, log_msg) format_msg( 4, "%s:%s:%s %s" % (serial, time_txt, log_type, encoded)) return 0
def CheckArguments(self): self.eq = ExtStorageQuery( qlang.MakeSimpleFilter("name", self.op.names), self.op.output_fields, False)
def _Test(self, field, names, expected, parse_exp=None): if parse_exp is None: parse_exp = names qfilter = qlang.MakeSimpleFilter(field, names) self.assertEqual(qfilter, expected)
def ShowJobs(opts, args): """Show detailed information about jobs. @param opts: the command line options selected by the user @type args: list @param args: should contain the job IDs to be queried @rtype: int @return: the desired exit code """ selected_fields = [ "id", "status", "ops", "opresult", "opstatus", "oplog", "opstart", "opexec", "opend", "received_ts", "start_ts", "end_ts", ] qfilter = qlang.MakeSimpleFilter("id", _ParseJobIds(args)) cl = GetClient() result = cl.Query(constants.QR_JOB, selected_fields, qfilter).data job_info_container = [] for entry in result: ((_, job_id), (rs_status, status), (_, ops), (_, opresult), (_, opstatus), (_, oplog), (_, opstart), (_, opexec), (_, opend), (_, recv_ts), (_, start_ts), (_, end_ts)) = entry # Detect non-normal results if rs_status != constants.RS_NORMAL: job_info_container.append("Job ID %s not found" % job_id) continue # Container for produced data job_info = [("Job ID", job_id)] if status in _USER_JOB_STATUS: status = _USER_JOB_STATUS[status] else: raise errors.ProgrammerError("Unknown job status code '%s'" % status) job_info.append(("Status", status)) _ListJobTimestamp("Received", recv_ts, job_info) _ListJobTimestamp("Processing start", start_ts, job_info, prior_ts=recv_ts) _ListJobTimestamp("Processing end", end_ts, job_info, prior_ts=start_ts) if end_ts is not None and recv_ts is not None: job_info.append(("Total processing time", "%.6f seconds" % _CalcDelta(recv_ts, end_ts))) else: job_info.append(("Total processing time", "N/A")) opcode_container = [] for (opcode, result, status, log, s_ts, x_ts, e_ts) in \ zip(ops, opresult, opstatus, oplog, opstart, opexec, opend): opcode_info = [] opcode_info.append(("Opcode", opcode["OP_ID"])) opcode_info.append(("Status", status)) _ListOpcodeTimestamp("Processing start", s_ts, opcode_info) _ListOpcodeTimestamp("Execution start", x_ts, opcode_info) _ListOpcodeTimestamp("Processing end", e_ts, opcode_info) opcode_info.append(("Input fields", opcode)) opcode_info.append(("Result", result)) exec_log_container = [] for serial, log_ts, log_type, log_msg in log: time_txt = FormatTimestamp(log_ts) encoded = FormatLogMessage(log_type, log_msg) # Arranged in this curious way to preserve the brevity for multiple # logs. This content cannot be exposed as a 4-tuple, as time contains # the colon, causing some YAML parsers to fail. exec_log_info = [ ("Time", time_txt), ("Content", ( serial, log_type, encoded, )), ] exec_log_container.append(exec_log_info) opcode_info.append(("Execution log", exec_log_container)) opcode_container.append(opcode_info) job_info.append(("Opcodes", opcode_container)) job_info_container.append(job_info) PrintGenericInfo(job_info_container) return 0