Statistics
| Branch: | Tag: | Revision:

root / lib / cli.py @ 2f31098c

History | View | Annotate | Download (15.9 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007 Google Inc.
5
#
6
# This program is free software; you can redistribute it and/or modify
7
# it under the terms of the GNU General Public License as published by
8
# the Free Software Foundation; either version 2 of the License, or
9
# (at your option) any later version.
10
#
11
# This program is distributed in the hope that it will be useful, but
12
# WITHOUT ANY WARRANTY; without even the implied warranty of
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
# General Public License for more details.
15
#
16
# You should have received a copy of the GNU General Public License
17
# along with this program; if not, write to the Free Software
18
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19
# 02110-1301, USA.
20

    
21

    
22
"""Module dealing with command line parsing"""
23

    
24

    
25
import sys
26
import textwrap
27
import os.path
28
import copy
29
from cStringIO import StringIO
30

    
31
from ganeti import utils
32
from ganeti import logger
33
from ganeti import errors
34
from ganeti import mcpu
35
from ganeti import constants
36
from ganeti import opcodes
37

    
38
from optparse import (OptionParser, make_option, TitledHelpFormatter,
39
                      Option, OptionValueError, SUPPRESS_HELP)
40

    
41
__all__ = ["DEBUG_OPT", "NOHDR_OPT", "SEP_OPT", "GenericMain", "SubmitOpCode",
42
           "cli_option", "GenerateTable", "AskUser",
43
           "ARGS_NONE", "ARGS_FIXED", "ARGS_ATLEAST", "ARGS_ANY", "ARGS_ONE",
44
           "USEUNITS_OPT", "FIELDS_OPT", "FORCE_OPT",
45
           "ListTags", "AddTags", "RemoveTags", "TAG_SRC_OPT",
46
           "FormatError",
47
           ]
48

    
49

    
50
def _ExtractTagsObject(opts, args):
51
  """Extract the tag type object.
52

53
  Note that this function will modify its args parameter.
54

55
  """
56
  if not hasattr(opts, "tag_type"):
57
    raise errors.ProgrammerError("tag_type not passed to _ExtractTagsObject")
58
  kind = opts.tag_type
59
  if kind == constants.TAG_CLUSTER:
60
    retval = kind, kind
61
  elif kind == constants.TAG_NODE or kind == constants.TAG_INSTANCE:
62
    if not args:
63
      raise errors.OpPrereqError("no arguments passed to the command")
64
    name = args.pop(0)
65
    retval = kind, name
66
  else:
67
    raise errors.ProgrammerError("Unhandled tag type '%s'" % kind)
68
  return retval
69

    
70

    
71
def _ExtendTags(opts, args):
72
  """Extend the args if a source file has been given.
73

74
  This function will extend the tags with the contents of the file
75
  passed in the 'tags_source' attribute of the opts parameter. A file
76
  named '-' will be replaced by stdin.
77

78
  """
79
  fname = opts.tags_source
80
  if fname is None:
81
    return
82
  if fname == "-":
83
    new_fh = sys.stdin
84
  else:
85
    new_fh = open(fname, "r")
86
  new_data = []
87
  try:
88
    # we don't use the nice 'new_data = [line.strip() for line in fh]'
89
    # because of python bug 1633941
90
    while True:
91
      line = new_fh.readline()
92
      if not line:
93
        break
94
      new_data.append(line.strip())
95
  finally:
96
    new_fh.close()
97
  args.extend(new_data)
98

    
99

    
100
def ListTags(opts, args):
101
  """List the tags on a given object.
102

103
  This is a generic implementation that knows how to deal with all
104
  three cases of tag objects (cluster, node, instance). The opts
105
  argument is expected to contain a tag_type field denoting what
106
  object type we work on.
107

108
  """
109
  kind, name = _ExtractTagsObject(opts, args)
110
  op = opcodes.OpGetTags(kind=kind, name=name)
111
  result = SubmitOpCode(op)
112
  result = list(result)
113
  result.sort()
114
  for tag in result:
115
    print tag
116

    
117

    
118
def AddTags(opts, args):
119
  """Add tags on a given object.
120

121
  This is a generic implementation that knows how to deal with all
122
  three cases of tag objects (cluster, node, instance). The opts
123
  argument is expected to contain a tag_type field denoting what
124
  object type we work on.
125

126
  """
127
  kind, name = _ExtractTagsObject(opts, args)
128
  _ExtendTags(opts, args)
129
  if not args:
130
    raise errors.OpPrereqError("No tags to be added")
131
  op = opcodes.OpAddTags(kind=kind, name=name, tags=args)
132
  SubmitOpCode(op)
133

    
134

    
135
def RemoveTags(opts, args):
136
  """Remove tags from a given object.
137

138
  This is a generic implementation that knows how to deal with all
139
  three cases of tag objects (cluster, node, instance). The opts
140
  argument is expected to contain a tag_type field denoting what
141
  object type we work on.
142

143
  """
144
  kind, name = _ExtractTagsObject(opts, args)
145
  _ExtendTags(opts, args)
146
  if not args:
147
    raise errors.OpPrereqError("No tags to be removed")
148
  op = opcodes.OpDelTags(kind=kind, name=name, tags=args)
149
  SubmitOpCode(op)
150

    
151

    
152
DEBUG_OPT = make_option("-d", "--debug", default=False,
153
                        action="store_true",
154
                        help="Turn debugging on")
155

    
156
NOHDR_OPT = make_option("--no-headers", default=False,
157
                        action="store_true", dest="no_headers",
158
                        help="Don't display column headers")
159

    
160
SEP_OPT = make_option("--separator", default=None,
161
                      action="store", dest="separator",
162
                      help="Separator between output fields"
163
                      " (defaults to one space)")
164

    
165
USEUNITS_OPT = make_option("--human-readable", default=False,
166
                           action="store_true", dest="human_readable",
167
                           help="Print sizes in human readable format")
168

    
169
FIELDS_OPT = make_option("-o", "--output", dest="output", action="store",
170
                         type="string", help="Select output fields",
171
                         metavar="FIELDS")
172

    
173
FORCE_OPT = make_option("-f", "--force", dest="force", action="store_true",
174
                        default=False, help="Force the operation")
175

    
176
_LOCK_OPT = make_option("--lock-retries", default=None,
177
                        type="int", help=SUPPRESS_HELP)
178

    
179
TAG_SRC_OPT = make_option("--from", dest="tags_source",
180
                          default=None, help="File with tag names")
181

    
182
def ARGS_FIXED(val):
183
  """Macro-like function denoting a fixed number of arguments"""
184
  return -val
185

    
186

    
187
def ARGS_ATLEAST(val):
188
  """Macro-like function denoting a minimum number of arguments"""
189
  return val
190

    
191

    
192
ARGS_NONE = None
193
ARGS_ONE = ARGS_FIXED(1)
194
ARGS_ANY = ARGS_ATLEAST(0)
195

    
196

    
197
def check_unit(option, opt, value):
198
  try:
199
    return utils.ParseUnit(value)
200
  except errors.UnitParseError, err:
201
    raise OptionValueError("option %s: %s" % (opt, err))
202

    
203

    
204
class CliOption(Option):
205
  TYPES = Option.TYPES + ("unit",)
206
  TYPE_CHECKER = copy.copy(Option.TYPE_CHECKER)
207
  TYPE_CHECKER["unit"] = check_unit
208

    
209

    
210
# optparse.py sets make_option, so we do it for our own option class, too
211
cli_option = CliOption
212

    
213

    
214
def _ParseArgs(argv, commands):
215
  """Parses the command line and return the function which must be
216
  executed together with its arguments
217

218
  Arguments:
219
    argv: the command line
220

221
    commands: dictionary with special contents, see the design doc for
222
    cmdline handling
223

224
  """
225
  if len(argv) == 0:
226
    binary = "<command>"
227
  else:
228
    binary = argv[0].split("/")[-1]
229

    
230
  if len(argv) > 1 and argv[1] == "--version":
231
    print "%s (ganeti) %s" % (binary, constants.RELEASE_VERSION)
232
    # Quit right away. That way we don't have to care about this special
233
    # argument. optparse.py does it the same.
234
    sys.exit(0)
235

    
236
  if len(argv) < 2 or argv[1] not in commands.keys():
237
    # let's do a nice thing
238
    sortedcmds = commands.keys()
239
    sortedcmds.sort()
240
    print ("Usage: %(bin)s {command} [options...] [argument...]"
241
           "\n%(bin)s <command> --help to see details, or"
242
           " man %(bin)s\n" % {"bin": binary})
243
    # compute the max line length for cmd + usage
244
    mlen = max([len(" %s %s" % (cmd, commands[cmd][3])) for cmd in commands])
245
    mlen = min(60, mlen) # should not get here...
246
    # and format a nice command list
247
    print "Commands:"
248
    for cmd in sortedcmds:
249
      cmdstr = " %s %s" % (cmd, commands[cmd][3])
250
      help_text = commands[cmd][4]
251
      help_lines = textwrap.wrap(help_text, 79-3-mlen)
252
      print "%-*s - %s" % (mlen, cmdstr,
253
                                          help_lines.pop(0))
254
      for line in help_lines:
255
        print "%-*s   %s" % (mlen, "", line)
256
    print
257
    return None, None, None
258
  cmd = argv.pop(1)
259
  func, nargs, parser_opts, usage, description = commands[cmd]
260
  parser_opts.append(_LOCK_OPT)
261
  parser = OptionParser(option_list=parser_opts,
262
                        description=description,
263
                        formatter=TitledHelpFormatter(),
264
                        usage="%%prog %s %s" % (cmd, usage))
265
  parser.disable_interspersed_args()
266
  options, args = parser.parse_args()
267
  if nargs is None:
268
    if len(args) != 0:
269
      print >> sys.stderr, ("Error: Command %s expects no arguments" % cmd)
270
      return None, None, None
271
  elif nargs < 0 and len(args) != -nargs:
272
    print >> sys.stderr, ("Error: Command %s expects %d argument(s)" %
273
                         (cmd, -nargs))
274
    return None, None, None
275
  elif nargs >= 0 and len(args) < nargs:
276
    print >> sys.stderr, ("Error: Command %s expects at least %d argument(s)" %
277
                         (cmd, nargs))
278
    return None, None, None
279

    
280
  return func, options, args
281

    
282

    
283
def AskUser(text, choices=None):
284
  """Ask the user a question.
285

286
  Args:
287
    text - the question to ask.
288

289
    choices - list with elements tuples (input_char, return_value,
290
    description); if not given, it will default to: [('y', True,
291
    'Perform the operation'), ('n', False, 'Do no do the operation')];
292
    note that the '?' char is reserved for help
293

294
  Returns: one of the return values from the choices list; if input is
295
  not possible (i.e. not running with a tty, we return the last entry
296
  from the list
297

298
  """
299
  if choices is None:
300
    choices = [('y', True, 'Perform the operation'),
301
               ('n', False, 'Do not perform the operation')]
302
  if not choices or not isinstance(choices, list):
303
    raise errors.ProgrammerError("Invalid choiches argument to AskUser")
304
  for entry in choices:
305
    if not isinstance(entry, tuple) or len(entry) < 3 or entry[0] == '?':
306
      raise errors.ProgrammerError("Invalid choiches element to AskUser")
307

    
308
  answer = choices[-1][1]
309
  new_text = []
310
  for line in text.splitlines():
311
    new_text.append(textwrap.fill(line, 70, replace_whitespace=False))
312
  text = "\n".join(new_text)
313
  try:
314
    f = file("/dev/tty", "r+")
315
  except IOError:
316
    return answer
317
  try:
318
    chars = [entry[0] for entry in choices]
319
    chars[-1] = "[%s]" % chars[-1]
320
    chars.append('?')
321
    maps = dict([(entry[0], entry[1]) for entry in choices])
322
    while True:
323
      f.write(text)
324
      f.write('\n')
325
      f.write("/".join(chars))
326
      f.write(": ")
327
      line = f.readline(2).strip().lower()
328
      if line in maps:
329
        answer = maps[line]
330
        break
331
      elif line == '?':
332
        for entry in choices:
333
          f.write(" %s - %s\n" % (entry[0], entry[2]))
334
        f.write("\n")
335
        continue
336
  finally:
337
    f.close()
338
  return answer
339

    
340

    
341
def SubmitOpCode(op, proc=None, feedback_fn=None):
342
  """Function to submit an opcode.
343

344
  This is just a simple wrapper over the construction of the processor
345
  instance. It should be extended to better handle feedback and
346
  interaction functions.
347

348
  """
349
  if proc is None:
350
    proc = mcpu.Processor()
351
  if feedback_fn is None:
352
    feedback_fn = logger.ToStdout
353
  return proc.ExecOpCode(op, feedback_fn)
354

    
355

    
356
def FormatError(err):
357
  """Return a formatted error message for a given error.
358

359
  This function takes an exception instance and returns a tuple
360
  consisting of two values: first, the recommended exit code, and
361
  second, a string describing the error message (not
362
  newline-terminated).
363

364
  """
365
  retcode = 1
366
  obuf = StringIO()
367
  if isinstance(err, errors.ConfigurationError):
368
    msg = "Corrupt configuration file: %s" % err
369
    logger.Error(msg)
370
    obuf.write(msg + "\n")
371
    obuf.write("Aborting.")
372
    retcode = 2
373
  elif isinstance(err, errors.HooksAbort):
374
    obuf.write("Failure: hooks execution failed:\n")
375
    for node, script, out in err.args[0]:
376
      if out:
377
        obuf.write("  node: %s, script: %s, output: %s\n" %
378
                   (node, script, out))
379
      else:
380
        obuf.write("  node: %s, script: %s (no output)\n" %
381
                   (node, script))
382
  elif isinstance(err, errors.HooksFailure):
383
    obuf.write("Failure: hooks general failure: %s" % str(err))
384
  elif isinstance(err, errors.ResolverError):
385
    this_host = utils.HostInfo.SysName()
386
    if err.args[0] == this_host:
387
      msg = "Failure: can't resolve my own hostname ('%s')"
388
    else:
389
      msg = "Failure: can't resolve hostname '%s'"
390
    obuf.write(msg % err.args[0])
391
  elif isinstance(err, errors.OpPrereqError):
392
    obuf.write("Failure: prerequisites not met for this"
393
               " operation:\n%s" % str(err))
394
  elif isinstance(err, errors.OpExecError):
395
    obuf.write("Failure: command execution error:\n%s" % str(err))
396
  elif isinstance(err, errors.TagError):
397
    obuf.write("Failure: invalid tag(s) given:\n%s" % str(err))
398
  elif isinstance(err, errors.GenericError):
399
    obuf.write("Unhandled Ganeti error: %s" % str(err))
400
  else:
401
    obuf.write("Unhandled exception: %s" % str(err))
402
  return retcode, obuf.getvalue().rstrip('\n')
403

    
404

    
405
def GenericMain(commands, override=None):
406
  """Generic main function for all the gnt-* commands.
407

408
  Arguments:
409
    - commands: a dictionary with a special structure, see the design doc
410
                for command line handling.
411
    - override: if not None, we expect a dictionary with keys that will
412
                override command line options; this can be used to pass
413
                options from the scripts to generic functions
414

415
  """
416
  # save the program name and the entire command line for later logging
417
  if sys.argv:
418
    binary = os.path.basename(sys.argv[0]) or sys.argv[0]
419
    if len(sys.argv) >= 2:
420
      binary += " " + sys.argv[1]
421
      old_cmdline = " ".join(sys.argv[2:])
422
    else:
423
      old_cmdline = ""
424
  else:
425
    binary = "<unknown program>"
426
    old_cmdline = ""
427

    
428
  func, options, args = _ParseArgs(sys.argv, commands)
429
  if func is None: # parse error
430
    return 1
431

    
432
  if override is not None:
433
    for key, val in override.iteritems():
434
      setattr(options, key, val)
435

    
436
  logger.SetupLogging(debug=options.debug, program=binary)
437

    
438
  try:
439
    utils.Lock('cmd', max_retries=options.lock_retries, debug=options.debug)
440
  except errors.LockError, err:
441
    logger.ToStderr(str(err))
442
    return 1
443

    
444
  if old_cmdline:
445
    logger.Info("run with arguments '%s'" % old_cmdline)
446
  else:
447
    logger.Info("run with no arguments")
448

    
449
  try:
450
    try:
451
      result = func(options, args)
452
    except errors.GenericError, err:
453
      result, err_msg = FormatError(err)
454
      logger.ToStderr(err_msg)
455
  finally:
456
    utils.Unlock('cmd')
457
    utils.LockCleanup()
458

    
459
  return result
460

    
461

    
462
def GenerateTable(headers, fields, separator, data,
463
                  numfields=None, unitfields=None):
464
  """Prints a table with headers and different fields.
465

466
  Args:
467
    headers: Dict of header titles or None if no headers should be shown
468
    fields: List of fields to show
469
    separator: String used to separate fields or None for spaces
470
    data: Data to be printed
471
    numfields: List of fields to be aligned to right
472
    unitfields: List of fields to be formatted as units
473

474
  """
475
  if numfields is None:
476
    numfields = []
477
  if unitfields is None:
478
    unitfields = []
479

    
480
  format_fields = []
481
  for field in fields:
482
    if separator is not None:
483
      format_fields.append("%s")
484
    elif field in numfields:
485
      format_fields.append("%*s")
486
    else:
487
      format_fields.append("%-*s")
488

    
489
  if separator is None:
490
    mlens = [0 for name in fields]
491
    format = ' '.join(format_fields)
492
  else:
493
    format = separator.replace("%", "%%").join(format_fields)
494

    
495
  for row in data:
496
    for idx, val in enumerate(row):
497
      if fields[idx] in unitfields:
498
        try:
499
          val = int(val)
500
        except ValueError:
501
          pass
502
        else:
503
          val = row[idx] = utils.FormatUnit(val)
504
      if separator is None:
505
        mlens[idx] = max(mlens[idx], len(val))
506

    
507
  result = []
508
  if headers:
509
    args = []
510
    for idx, name in enumerate(fields):
511
      hdr = headers[name]
512
      if separator is None:
513
        mlens[idx] = max(mlens[idx], len(hdr))
514
        args.append(mlens[idx])
515
      args.append(hdr)
516
    result.append(format % tuple(args))
517

    
518
  for line in data:
519
    args = []
520
    for idx in xrange(len(fields)):
521
      if separator is None:
522
        args.append(mlens[idx])
523
      args.append(line[idx])
524
    result.append(format % tuple(args))
525

    
526
  return result