X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/3ecf6786a731c0a467f0efcbf6346914e3824ec8..6510a58aeba9fa860c7bea3ef7554afe97a6b1c1:/lib/cli.py?ds=sidebyside

diff --git a/lib/cli.py b/lib/cli.py
index e14df01..62fa111 100644
--- a/lib/cli.py
+++ b/lib/cli.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#
 #
 
 # Copyright (C) 2006, 2007 Google Inc.
@@ -26,20 +26,128 @@ import sys
 import textwrap
 import os.path
 import copy
+from cStringIO import StringIO
 
 from ganeti import utils
 from ganeti import logger
 from ganeti import errors
 from ganeti import mcpu
 from ganeti import constants
+from ganeti import opcodes
 
 from optparse import (OptionParser, make_option, TitledHelpFormatter,
                       Option, OptionValueError, SUPPRESS_HELP)
 
 __all__ = ["DEBUG_OPT", "NOHDR_OPT", "SEP_OPT", "GenericMain", "SubmitOpCode",
-           "cli_option", "OutputTable",
+           "cli_option", "GenerateTable", "AskUser",
            "ARGS_NONE", "ARGS_FIXED", "ARGS_ATLEAST", "ARGS_ANY", "ARGS_ONE",
-           "USEUNITS_OPT", "FIELDS_OPT", "FORCE_OPT"]
+           "USEUNITS_OPT", "FIELDS_OPT", "FORCE_OPT",
+           "ListTags", "AddTags", "RemoveTags", "TAG_SRC_OPT",
+           "FormatError", "SplitNodeOption"
+           ]
+
+
+def _ExtractTagsObject(opts, args):
+  """Extract the tag type object.
+
+  Note that this function will modify its args parameter.
+
+  """
+  if not hasattr(opts, "tag_type"):
+    raise errors.ProgrammerError("tag_type not passed to _ExtractTagsObject")
+  kind = opts.tag_type
+  if kind == constants.TAG_CLUSTER:
+    retval = kind, kind
+  elif kind == constants.TAG_NODE or kind == constants.TAG_INSTANCE:
+    if not args:
+      raise errors.OpPrereqError("no arguments passed to the command")
+    name = args.pop(0)
+    retval = kind, name
+  else:
+    raise errors.ProgrammerError("Unhandled tag type '%s'" % kind)
+  return retval
+
+
+def _ExtendTags(opts, args):
+  """Extend the args if a source file has been given.
+
+  This function will extend the tags with the contents of the file
+  passed in the 'tags_source' attribute of the opts parameter. A file
+  named '-' will be replaced by stdin.
+
+  """
+  fname = opts.tags_source
+  if fname is None:
+    return
+  if fname == "-":
+    new_fh = sys.stdin
+  else:
+    new_fh = open(fname, "r")
+  new_data = []
+  try:
+    # we don't use the nice 'new_data = [line.strip() for line in fh]'
+    # because of python bug 1633941
+    while True:
+      line = new_fh.readline()
+      if not line:
+        break
+      new_data.append(line.strip())
+  finally:
+    new_fh.close()
+  args.extend(new_data)
+
+
+def ListTags(opts, args):
+  """List the tags on a given object.
+
+  This is a generic implementation that knows how to deal with all
+  three cases of tag objects (cluster, node, instance). The opts
+  argument is expected to contain a tag_type field denoting what
+  object type we work on.
+
+  """
+  kind, name = _ExtractTagsObject(opts, args)
+  op = opcodes.OpGetTags(kind=kind, name=name)
+  result = SubmitOpCode(op)
+  result = list(result)
+  result.sort()
+  for tag in result:
+    print tag
+
+
+def AddTags(opts, args):
+  """Add tags on a given object.
+
+  This is a generic implementation that knows how to deal with all
+  three cases of tag objects (cluster, node, instance). The opts
+  argument is expected to contain a tag_type field denoting what
+  object type we work on.
+
+  """
+  kind, name = _ExtractTagsObject(opts, args)
+  _ExtendTags(opts, args)
+  if not args:
+    raise errors.OpPrereqError("No tags to be added")
+  op = opcodes.OpAddTags(kind=kind, name=name, tags=args)
+  SubmitOpCode(op)
+
+
+def RemoveTags(opts, args):
+  """Remove tags from a given object.
+
+  This is a generic implementation that knows how to deal with all
+  three cases of tag objects (cluster, node, instance). The opts
+  argument is expected to contain a tag_type field denoting what
+  object type we work on.
+
+  """
+  kind, name = _ExtractTagsObject(opts, args)
+  _ExtendTags(opts, args)
+  if not args:
+    raise errors.OpPrereqError("No tags to be removed")
+  op = opcodes.OpDelTags(kind=kind, name=name, tags=args)
+  SubmitOpCode(op)
+
 
 DEBUG_OPT = make_option("-d", "--debug", default=False,
                         action="store_true",
@@ -68,6 +176,9 @@ FORCE_OPT = make_option("-f", "--force", dest="force", action="store_true",
 _LOCK_OPT = make_option("--lock-retries", default=None,
                         type="int", help=SUPPRESS_HELP)
 
+TAG_SRC_OPT = make_option("--from", dest="tags_source",
+                          default=None, help="File with tag names")
+
 
 def ARGS_FIXED(val):
   """Macro-like function denoting a fixed number of arguments"""
@@ -85,6 +196,9 @@ ARGS_ANY = ARGS_ATLEAST(0)
 
 
 def check_unit(option, opt, value):
+  """OptParsers custom converter for units.
+
+  """
   try:
     return utils.ParseUnit(value)
   except errors.UnitParseError, err:
@@ -92,6 +206,9 @@ def check_unit(option, opt, value):
 
 
 class CliOption(Option):
+  """Custom option class for optparse.
+
+  """
   TYPES = Option.TYPES + ("unit",)
   TYPE_CHECKER = copy.copy(Option.TYPE_CHECKER)
   TYPE_CHECKER["unit"] = check_unit
@@ -170,33 +287,75 @@ def _ParseArgs(argv, commands):
   return func, options, args
 
 
-def _AskUser(text):
-  """Ask the user a yes/no question.
+def SplitNodeOption(value):
+  """Splits the value of a --node option.
+
+  """
+  if value and ':' in value:
+    return value.split(':', 1)
+  else:
+    return (value, None)
+
+
+def AskUser(text, choices=None):
+  """Ask the user a question.
 
   Args:
-    questionstring - the question to ask.
+    text - the question to ask.
+
+    choices - list with elements tuples (input_char, return_value,
+    description); if not given, it will default to: [('y', True,
+    'Perform the operation'), ('n', False, 'Do no do the operation')];
+    note that the '?' char is reserved for help
 
-  Returns:
-    True or False depending on answer (No for False is default).
+  Returns: one of the return values from the choices list; if input is
+  not possible (i.e. not running with a tty, we return the last entry
+  from the list
 
   """
+  if choices is None:
+    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")
+  for entry in choices:
+    if not isinstance(entry, tuple) or len(entry) < 3 or entry[0] == '?':
+      raise errors.ProgrammerError("Invalid choiches element to AskUser")
+
+  answer = choices[-1][1]
+  new_text = []
+  for line in text.splitlines():
+    new_text.append(textwrap.fill(line, 70, replace_whitespace=False))
+  text = "\n".join(new_text)
   try:
-    f = file("/dev/tty", "r+")
+    f = file("/dev/tty", "a+")
   except IOError:
-    return False
-  answer = False
+    return answer
   try:
-    f.write(textwrap.fill(text))
-    f.write('\n')
-    f.write("y/[n]: ")
-    line = f.readline(16).strip().lower()
-    answer = line in ('y', 'yes')
+    chars = [entry[0] for entry in choices]
+    chars[-1] = "[%s]" % chars[-1]
+    chars.append('?')
+    maps = dict([(entry[0], entry[1]) for entry in choices])
+    while True:
+      f.write(text)
+      f.write('\n')
+      f.write("/".join(chars))
+      f.write(": ")
+      line = f.readline(2).strip().lower()
+      if line in maps:
+        answer = maps[line]
+        break
+      elif line == '?':
+        for entry in choices:
+          f.write(" %s - %s\n" % (entry[0], entry[2]))
+        f.write("\n")
+        continue
   finally:
     f.close()
   return answer
 
 
-def SubmitOpCode(op):
+def SubmitOpCode(op, proc=None, feedback_fn=None):
   """Function to submit an opcode.
 
   This is just a simple wrapper over the construction of the processor
@@ -204,15 +363,72 @@ def SubmitOpCode(op):
   interaction functions.
 
   """
-  proc = mcpu.Processor()
-  return proc.ExecOpCode(op, logger.ToStdout)
+  if feedback_fn is None:
+    feedback_fn = logger.ToStdout
+  if proc is None:
+    proc = mcpu.Processor(feedback=feedback_fn)
+  return proc.ExecOpCode(op)
+
+
+def FormatError(err):
+  """Return a formatted error message for a given error.
 
+  This function takes an exception instance and returns a tuple
+  consisting of two values: first, the recommended exit code, and
+  second, a string describing the error message (not
+  newline-terminated).
 
-def GenericMain(commands):
+  """
+  retcode = 1
+  obuf = StringIO()
+  msg = str(err)
+  if isinstance(err, errors.ConfigurationError):
+    txt = "Corrupt configuration file: %s" % msg
+    logger.Error(txt)
+    obuf.write(txt + "\n")
+    obuf.write("Aborting.")
+    retcode = 2
+  elif isinstance(err, errors.HooksAbort):
+    obuf.write("Failure: hooks execution failed:\n")
+    for node, script, out in err.args[0]:
+      if out:
+        obuf.write("  node: %s, script: %s, output: %s\n" %
+                   (node, script, out))
+      else:
+        obuf.write("  node: %s, script: %s (no output)\n" %
+                   (node, script))
+  elif isinstance(err, errors.HooksFailure):
+    obuf.write("Failure: hooks general failure: %s" % msg)
+  elif isinstance(err, errors.ResolverError):
+    this_host = utils.HostInfo.SysName()
+    if err.args[0] == this_host:
+      msg = "Failure: can't resolve my own hostname ('%s')"
+    else:
+      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)
+  elif isinstance(err, errors.OpExecError):
+    obuf.write("Failure: command execution error:\n%s" % msg)
+  elif isinstance(err, errors.TagError):
+    obuf.write("Failure: invalid tag(s) given:\n%s" % msg)
+  elif isinstance(err, errors.GenericError):
+    obuf.write("Unhandled Ganeti error: %s" % msg)
+  else:
+    obuf.write("Unhandled exception: %s" % msg)
+  return retcode, obuf.getvalue().rstrip('\n')
+
+
+def GenericMain(commands, override=None):
   """Generic main function for all the gnt-* commands.
 
-  Argument: a dictionary with a special structure, see the design doc
-  for command line handling.
+  Arguments:
+    - commands: a dictionary with a special structure, see the design doc
+                for command line handling.
+    - override: if not None, we expect a dictionary with keys that will
+                override command line options; this can be used to pass
+                options from the scripts to generic functions
 
   """
   # save the program name and the entire command line for later logging
@@ -231,7 +447,9 @@ def GenericMain(commands):
   if func is None: # parse error
     return 1
 
-  options._ask_user = _AskUser
+  if override is not None:
+    for key, val in override.iteritems():
+      setattr(options, key, val)
 
   logger.SetupLogging(debug=options.debug, program=binary)
 
@@ -249,30 +467,9 @@ def GenericMain(commands):
   try:
     try:
       result = func(options, args)
-    except errors.ConfigurationError, err:
-      logger.Error("Corrupt configuration file: %s" % err)
-      logger.ToStderr("Aborting.")
-      result = 2
-    except errors.HooksAbort, err:
-      logger.ToStderr("Failure: hooks execution failed:")
-      for node, script, out in err.args[0]:
-        if out:
-          logger.ToStderr("  node: %s, script: %s, output: %s" %
-                          (node, script, out))
-        else:
-          logger.ToStderr("  node: %s, script: %s (no output)" %
-                          (node, script))
-      result = 1
-    except errors.HooksFailure, err:
-      logger.ToStderr("Failure: hooks general failure: %s" % str(err))
-      result = 1
-    except errors.OpPrereqError, err:
-      logger.ToStderr("Failure: prerequisites not met for this"
-                      " operation:\n%s" % str(err))
-      result = 1
-    except errors.OpExecError, err:
-      logger.ToStderr("Failure: command execution error:\n%s" % str(err))
-      result = 1
+    except errors.GenericError, err:
+      result, err_msg = FormatError(err)
+      logger.ToStderr(err_msg)
   finally:
     utils.Unlock('cmd')
     utils.LockCleanup()
@@ -280,8 +477,8 @@ def GenericMain(commands):
   return result
 
 
-def OutputTable(headers, fields, separator, data,
-                numfields=None, unitfields=None):
+def GenerateTable(headers, fields, separator, data,
+                  numfields=None, unitfields=None):
   """Prints a table with headers and different fields.
 
   Args:
@@ -300,6 +497,9 @@ def OutputTable(headers, fields, separator, data,
 
   format_fields = []
   for field in fields:
+    if headers and field not in headers:
+      raise errors.ProgrammerError("Missing header description for field '%s'"
+                                   % field)
     if separator is not None:
       format_fields.append("%s")
     elif field in numfields:
@@ -322,9 +522,11 @@ def OutputTable(headers, fields, separator, data,
           pass
         else:
           val = row[idx] = utils.FormatUnit(val)
+      val = row[idx] = str(val)
       if separator is None:
         mlens[idx] = max(mlens[idx], len(val))
 
+  result = []
   if headers:
     args = []
     for idx, name in enumerate(fields):
@@ -333,7 +535,7 @@ def OutputTable(headers, fields, separator, data,
         mlens[idx] = max(mlens[idx], len(hdr))
         args.append(mlens[idx])
       args.append(hdr)
-    logger.ToStdout(format % tuple(args))
+    result.append(format % tuple(args))
 
   for line in data:
     args = []
@@ -341,4 +543,6 @@ def OutputTable(headers, fields, separator, data,
       if separator is None:
         args.append(mlens[idx])
       args.append(line[idx])
-    logger.ToStdout(format % tuple(args))
+    result.append(format % tuple(args))
+
+  return result