Statistics
| Branch: | Tag: | Revision:

root / lib / cli.py @ 797506fc

History | View | Annotate | Download (57.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 time
29
import logging
30
from cStringIO import StringIO
31

    
32
from ganeti import utils
33
from ganeti import errors
34
from ganeti import constants
35
from ganeti import opcodes
36
from ganeti import luxi
37
from ganeti import ssconf
38
from ganeti import rpc
39

    
40
from optparse import (OptionParser, TitledHelpFormatter,
41
                      Option, OptionValueError)
42

    
43

    
44
__all__ = [
45
  # Command line options
46
  "ALLOCATABLE_OPT",
47
  "ALL_OPT",
48
  "AUTO_REPLACE_OPT",
49
  "BACKEND_OPT",
50
  "CLEANUP_OPT",
51
  "CONFIRM_OPT",
52
  "CP_SIZE_OPT",
53
  "DEBUG_OPT",
54
  "DEBUG_SIMERR_OPT",
55
  "DISKIDX_OPT",
56
  "DISK_OPT",
57
  "DISK_TEMPLATE_OPT",
58
  "DRAINED_OPT",
59
  "ENABLED_HV_OPT",
60
  "ERROR_CODES_OPT",
61
  "FIELDS_OPT",
62
  "FILESTORE_DIR_OPT",
63
  "FILESTORE_DRIVER_OPT",
64
  "FORCE_OPT",
65
  "FORCE_VARIANT_OPT",
66
  "GLOBAL_FILEDIR_OPT",
67
  "HVLIST_OPT",
68
  "HVOPTS_OPT",
69
  "HYPERVISOR_OPT",
70
  "IALLOCATOR_OPT",
71
  "IGNORE_CONSIST_OPT",
72
  "IGNORE_FAILURES_OPT",
73
  "IGNORE_SECONDARIES_OPT",
74
  "IGNORE_SIZE_OPT",
75
  "MAC_PREFIX_OPT",
76
  "MASTER_NETDEV_OPT",
77
  "MC_OPT",
78
  "NET_OPT",
79
  "NEW_SECONDARY_OPT",
80
  "NIC_PARAMS_OPT",
81
  "NODE_LIST_OPT",
82
  "NODE_PLACEMENT_OPT",
83
  "NOHDR_OPT",
84
  "NOIPCHECK_OPT",
85
  "NONAMECHECK_OPT",
86
  "NOLVM_STORAGE_OPT",
87
  "NOMODIFY_ETCHOSTS_OPT",
88
  "NOMODIFY_SSH_SETUP_OPT",
89
  "NONICS_OPT",
90
  "NONLIVE_OPT",
91
  "NONPLUS1_OPT",
92
  "NOSHUTDOWN_OPT",
93
  "NOSTART_OPT",
94
  "NOSSH_KEYCHECK_OPT",
95
  "NOVOTING_OPT",
96
  "NWSYNC_OPT",
97
  "ON_PRIMARY_OPT",
98
  "ON_SECONDARY_OPT",
99
  "OFFLINE_OPT",
100
  "OS_OPT",
101
  "OS_SIZE_OPT",
102
  "READD_OPT",
103
  "REBOOT_TYPE_OPT",
104
  "SECONDARY_IP_OPT",
105
  "SELECT_OS_OPT",
106
  "SEP_OPT",
107
  "SHOWCMD_OPT",
108
  "SHUTDOWN_TIMEOUT_OPT",
109
  "SINGLE_NODE_OPT",
110
  "SRC_DIR_OPT",
111
  "SRC_NODE_OPT",
112
  "SUBMIT_OPT",
113
  "STATIC_OPT",
114
  "SYNC_OPT",
115
  "TAG_SRC_OPT",
116
  "TIMEOUT_OPT",
117
  "USEUNITS_OPT",
118
  "VERBOSE_OPT",
119
  "VG_NAME_OPT",
120
  "YES_DOIT_OPT",
121
  # Generic functions for CLI programs
122
  "GenericMain",
123
  "GenericInstanceCreate",
124
  "GetClient",
125
  "GetOnlineNodes",
126
  "JobExecutor",
127
  "JobSubmittedException",
128
  "ParseTimespec",
129
  "SubmitOpCode",
130
  "SubmitOrSend",
131
  "UsesRPC",
132
  # Formatting functions
133
  "ToStderr", "ToStdout",
134
  "FormatError",
135
  "GenerateTable",
136
  "AskUser",
137
  "FormatTimestamp",
138
  # Tags functions
139
  "ListTags",
140
  "AddTags",
141
  "RemoveTags",
142
  # command line options support infrastructure
143
  "ARGS_MANY_INSTANCES",
144
  "ARGS_MANY_NODES",
145
  "ARGS_NONE",
146
  "ARGS_ONE_INSTANCE",
147
  "ARGS_ONE_NODE",
148
  "ArgChoice",
149
  "ArgCommand",
150
  "ArgFile",
151
  "ArgHost",
152
  "ArgInstance",
153
  "ArgJobId",
154
  "ArgNode",
155
  "ArgSuggest",
156
  "ArgUnknown",
157
  "OPT_COMPL_INST_ADD_NODES",
158
  "OPT_COMPL_MANY_NODES",
159
  "OPT_COMPL_ONE_IALLOCATOR",
160
  "OPT_COMPL_ONE_INSTANCE",
161
  "OPT_COMPL_ONE_NODE",
162
  "OPT_COMPL_ONE_OS",
163
  "cli_option",
164
  "SplitNodeOption",
165
  "CalculateOSNames",
166
  ]
167

    
168
NO_PREFIX = "no_"
169
UN_PREFIX = "-"
170

    
171

    
172
class _Argument:
173
  def __init__(self, min=0, max=None): # pylint: disable-msg=W0622
174
    self.min = min
175
    self.max = max
176

    
177
  def __repr__(self):
178
    return ("<%s min=%s max=%s>" %
179
            (self.__class__.__name__, self.min, self.max))
180

    
181

    
182
class ArgSuggest(_Argument):
183
  """Suggesting argument.
184

185
  Value can be any of the ones passed to the constructor.
186

187
  """
188
  # pylint: disable-msg=W0622
189
  def __init__(self, min=0, max=None, choices=None):
190
    _Argument.__init__(self, min=min, max=max)
191
    self.choices = choices
192

    
193
  def __repr__(self):
194
    return ("<%s min=%s max=%s choices=%r>" %
195
            (self.__class__.__name__, self.min, self.max, self.choices))
196

    
197

    
198
class ArgChoice(ArgSuggest):
199
  """Choice argument.
200

201
  Value can be any of the ones passed to the constructor. Like L{ArgSuggest},
202
  but value must be one of the choices.
203

204
  """
205

    
206

    
207
class ArgUnknown(_Argument):
208
  """Unknown argument to program (e.g. determined at runtime).
209

210
  """
211

    
212

    
213
class ArgInstance(_Argument):
214
  """Instances argument.
215

216
  """
217

    
218

    
219
class ArgNode(_Argument):
220
  """Node argument.
221

222
  """
223

    
224
class ArgJobId(_Argument):
225
  """Job ID argument.
226

227
  """
228

    
229

    
230
class ArgFile(_Argument):
231
  """File path argument.
232

233
  """
234

    
235

    
236
class ArgCommand(_Argument):
237
  """Command argument.
238

239
  """
240

    
241

    
242
class ArgHost(_Argument):
243
  """Host argument.
244

245
  """
246

    
247

    
248
ARGS_NONE = []
249
ARGS_MANY_INSTANCES = [ArgInstance()]
250
ARGS_MANY_NODES = [ArgNode()]
251
ARGS_ONE_INSTANCE = [ArgInstance(min=1, max=1)]
252
ARGS_ONE_NODE = [ArgNode(min=1, max=1)]
253

    
254

    
255

    
256
def _ExtractTagsObject(opts, args):
257
  """Extract the tag type object.
258

259
  Note that this function will modify its args parameter.
260

261
  """
262
  if not hasattr(opts, "tag_type"):
263
    raise errors.ProgrammerError("tag_type not passed to _ExtractTagsObject")
264
  kind = opts.tag_type
265
  if kind == constants.TAG_CLUSTER:
266
    retval = kind, kind
267
  elif kind == constants.TAG_NODE or kind == constants.TAG_INSTANCE:
268
    if not args:
269
      raise errors.OpPrereqError("no arguments passed to the command")
270
    name = args.pop(0)
271
    retval = kind, name
272
  else:
273
    raise errors.ProgrammerError("Unhandled tag type '%s'" % kind)
274
  return retval
275

    
276

    
277
def _ExtendTags(opts, args):
278
  """Extend the args if a source file has been given.
279

280
  This function will extend the tags with the contents of the file
281
  passed in the 'tags_source' attribute of the opts parameter. A file
282
  named '-' will be replaced by stdin.
283

284
  """
285
  fname = opts.tags_source
286
  if fname is None:
287
    return
288
  if fname == "-":
289
    new_fh = sys.stdin
290
  else:
291
    new_fh = open(fname, "r")
292
  new_data = []
293
  try:
294
    # we don't use the nice 'new_data = [line.strip() for line in fh]'
295
    # because of python bug 1633941
296
    while True:
297
      line = new_fh.readline()
298
      if not line:
299
        break
300
      new_data.append(line.strip())
301
  finally:
302
    new_fh.close()
303
  args.extend(new_data)
304

    
305

    
306
def ListTags(opts, args):
307
  """List the tags on a given object.
308

309
  This is a generic implementation that knows how to deal with all
310
  three cases of tag objects (cluster, node, instance). The opts
311
  argument is expected to contain a tag_type field denoting what
312
  object type we work on.
313

314
  """
315
  kind, name = _ExtractTagsObject(opts, args)
316
  op = opcodes.OpGetTags(kind=kind, name=name)
317
  result = SubmitOpCode(op)
318
  result = list(result)
319
  result.sort()
320
  for tag in result:
321
    ToStdout(tag)
322

    
323

    
324
def AddTags(opts, args):
325
  """Add tags on a given object.
326

327
  This is a generic implementation that knows how to deal with all
328
  three cases of tag objects (cluster, node, instance). The opts
329
  argument is expected to contain a tag_type field denoting what
330
  object type we work on.
331

332
  """
333
  kind, name = _ExtractTagsObject(opts, args)
334
  _ExtendTags(opts, args)
335
  if not args:
336
    raise errors.OpPrereqError("No tags to be added")
337
  op = opcodes.OpAddTags(kind=kind, name=name, tags=args)
338
  SubmitOpCode(op)
339

    
340

    
341
def RemoveTags(opts, args):
342
  """Remove tags from a given object.
343

344
  This is a generic implementation that knows how to deal with all
345
  three cases of tag objects (cluster, node, instance). The opts
346
  argument is expected to contain a tag_type field denoting what
347
  object type we work on.
348

349
  """
350
  kind, name = _ExtractTagsObject(opts, args)
351
  _ExtendTags(opts, args)
352
  if not args:
353
    raise errors.OpPrereqError("No tags to be removed")
354
  op = opcodes.OpDelTags(kind=kind, name=name, tags=args)
355
  SubmitOpCode(op)
356

    
357

    
358
def check_unit(option, opt, value): # pylint: disable-msg=W0613
359
  """OptParsers custom converter for units.
360

361
  """
362
  try:
363
    return utils.ParseUnit(value)
364
  except errors.UnitParseError, err:
365
    raise OptionValueError("option %s: %s" % (opt, err))
366

    
367

    
368
def _SplitKeyVal(opt, data):
369
  """Convert a KeyVal string into a dict.
370

371
  This function will convert a key=val[,...] string into a dict. Empty
372
  values will be converted specially: keys which have the prefix 'no_'
373
  will have the value=False and the prefix stripped, the others will
374
  have value=True.
375

376
  @type opt: string
377
  @param opt: a string holding the option name for which we process the
378
      data, used in building error messages
379
  @type data: string
380
  @param data: a string of the format key=val,key=val,...
381
  @rtype: dict
382
  @return: {key=val, key=val}
383
  @raises errors.ParameterError: if there are duplicate keys
384

385
  """
386
  kv_dict = {}
387
  if data:
388
    for elem in data.split(","):
389
      if "=" in elem:
390
        key, val = elem.split("=", 1)
391
      else:
392
        if elem.startswith(NO_PREFIX):
393
          key, val = elem[len(NO_PREFIX):], False
394
        elif elem.startswith(UN_PREFIX):
395
          key, val = elem[len(UN_PREFIX):], None
396
        else:
397
          key, val = elem, True
398
      if key in kv_dict:
399
        raise errors.ParameterError("Duplicate key '%s' in option %s" %
400
                                    (key, opt))
401
      kv_dict[key] = val
402
  return kv_dict
403

    
404

    
405
def check_ident_key_val(option, opt, value):  # pylint: disable-msg=W0613
406
  """Custom parser for ident:key=val,key=val options.
407

408
  This will store the parsed values as a tuple (ident, {key: val}). As such,
409
  multiple uses of this option via action=append is possible.
410

411
  """
412
  if ":" not in value:
413
    ident, rest = value, ''
414
  else:
415
    ident, rest = value.split(":", 1)
416

    
417
  if ident.startswith(NO_PREFIX):
418
    if rest:
419
      msg = "Cannot pass options when removing parameter groups: %s" % value
420
      raise errors.ParameterError(msg)
421
    retval = (ident[len(NO_PREFIX):], False)
422
  elif ident.startswith(UN_PREFIX):
423
    if rest:
424
      msg = "Cannot pass options when removing parameter groups: %s" % value
425
      raise errors.ParameterError(msg)
426
    retval = (ident[len(UN_PREFIX):], None)
427
  else:
428
    kv_dict = _SplitKeyVal(opt, rest)
429
    retval = (ident, kv_dict)
430
  return retval
431

    
432

    
433
def check_key_val(option, opt, value):  # pylint: disable-msg=W0613
434
  """Custom parser class for key=val,key=val options.
435

436
  This will store the parsed values as a dict {key: val}.
437

438
  """
439
  return _SplitKeyVal(opt, value)
440

    
441

    
442
# completion_suggestion is normally a list. Using numeric values not evaluating
443
# to False for dynamic completion.
444
(OPT_COMPL_MANY_NODES,
445
 OPT_COMPL_ONE_NODE,
446
 OPT_COMPL_ONE_INSTANCE,
447
 OPT_COMPL_ONE_OS,
448
 OPT_COMPL_ONE_IALLOCATOR,
449
 OPT_COMPL_INST_ADD_NODES) = range(100, 106)
450

    
451
OPT_COMPL_ALL = frozenset([
452
  OPT_COMPL_MANY_NODES,
453
  OPT_COMPL_ONE_NODE,
454
  OPT_COMPL_ONE_INSTANCE,
455
  OPT_COMPL_ONE_OS,
456
  OPT_COMPL_ONE_IALLOCATOR,
457
  OPT_COMPL_INST_ADD_NODES,
458
  ])
459

    
460

    
461
class CliOption(Option):
462
  """Custom option class for optparse.
463

464
  """
465
  ATTRS = Option.ATTRS + [
466
    "completion_suggest",
467
    ]
468
  TYPES = Option.TYPES + (
469
    "identkeyval",
470
    "keyval",
471
    "unit",
472
    )
473
  TYPE_CHECKER = Option.TYPE_CHECKER.copy()
474
  TYPE_CHECKER["identkeyval"] = check_ident_key_val
475
  TYPE_CHECKER["keyval"] = check_key_val
476
  TYPE_CHECKER["unit"] = check_unit
477

    
478

    
479
# optparse.py sets make_option, so we do it for our own option class, too
480
cli_option = CliOption
481

    
482

    
483
_YESNO = ("yes", "no")
484
_YORNO = "yes|no"
485

    
486
DEBUG_OPT = cli_option("-d", "--debug", default=False,
487
                       action="store_true",
488
                       help="Turn debugging on")
489

    
490
NOHDR_OPT = cli_option("--no-headers", default=False,
491
                       action="store_true", dest="no_headers",
492
                       help="Don't display column headers")
493

    
494
SEP_OPT = cli_option("--separator", default=None,
495
                     action="store", dest="separator",
496
                     help=("Separator between output fields"
497
                           " (defaults to one space)"))
498

    
499
USEUNITS_OPT = cli_option("--units", default=None,
500
                          dest="units", choices=('h', 'm', 'g', 't'),
501
                          help="Specify units for output (one of hmgt)")
502

    
503
FIELDS_OPT = cli_option("-o", "--output", dest="output", action="store",
504
                        type="string", metavar="FIELDS",
505
                        help="Comma separated list of output fields")
506

    
507
FORCE_OPT = cli_option("-f", "--force", dest="force", action="store_true",
508
                       default=False, help="Force the operation")
509

    
510
CONFIRM_OPT = cli_option("--yes", dest="confirm", action="store_true",
511
                         default=False, help="Do not require confirmation")
512

    
513
TAG_SRC_OPT = cli_option("--from", dest="tags_source",
514
                         default=None, help="File with tag names")
515

    
516
SUBMIT_OPT = cli_option("--submit", dest="submit_only",
517
                        default=False, action="store_true",
518
                        help=("Submit the job and return the job ID, but"
519
                              " don't wait for the job to finish"))
520

    
521
SYNC_OPT = cli_option("--sync", dest="do_locking",
522
                      default=False, action="store_true",
523
                      help=("Grab locks while doing the queries"
524
                            " in order to ensure more consistent results"))
525

    
526
_DRY_RUN_OPT = cli_option("--dry-run", default=False,
527
                          action="store_true",
528
                          help=("Do not execute the operation, just run the"
529
                                " check steps and verify it it could be"
530
                                " executed"))
531

    
532
VERBOSE_OPT = cli_option("-v", "--verbose", default=False,
533
                         action="store_true",
534
                         help="Increase the verbosity of the operation")
535

    
536
DEBUG_SIMERR_OPT = cli_option("--debug-simulate-errors", default=False,
537
                              action="store_true", dest="simulate_errors",
538
                              help="Debugging option that makes the operation"
539
                              " treat most runtime checks as failed")
540

    
541
NWSYNC_OPT = cli_option("--no-wait-for-sync", dest="wait_for_sync",
542
                        default=True, action="store_false",
543
                        help="Don't wait for sync (DANGEROUS!)")
544

    
545
DISK_TEMPLATE_OPT = cli_option("-t", "--disk-template", dest="disk_template",
546
                               help="Custom disk setup (diskless, file,"
547
                               " plain or drbd)",
548
                               default=None, metavar="TEMPL",
549
                               choices=list(constants.DISK_TEMPLATES))
550

    
551
NONICS_OPT = cli_option("--no-nics", default=False, action="store_true",
552
                        help="Do not create any network cards for"
553
                        " the instance")
554

    
555
FILESTORE_DIR_OPT = cli_option("--file-storage-dir", dest="file_storage_dir",
556
                               help="Relative path under default cluster-wide"
557
                               " file storage dir to store file-based disks",
558
                               default=None, metavar="<DIR>")
559

    
560
FILESTORE_DRIVER_OPT = cli_option("--file-driver", dest="file_driver",
561
                                  help="Driver to use for image files",
562
                                  default="loop", metavar="<DRIVER>",
563
                                  choices=list(constants.FILE_DRIVER))
564

    
565
IALLOCATOR_OPT = cli_option("-I", "--iallocator", metavar="<NAME>",
566
                            help="Select nodes for the instance automatically"
567
                            " using the <NAME> iallocator plugin",
568
                            default=None, type="string",
569
                            completion_suggest=OPT_COMPL_ONE_IALLOCATOR)
570

    
571
OS_OPT = cli_option("-o", "--os-type", dest="os", help="What OS to run",
572
                    metavar="<os>",
573
                    completion_suggest=OPT_COMPL_ONE_OS)
574

    
575
FORCE_VARIANT_OPT = cli_option("--force-variant", dest="force_variant",
576
                               action="store_true", default=False,
577
                               help="Force an unknown variant")
578

    
579
BACKEND_OPT = cli_option("-B", "--backend-parameters", dest="beparams",
580
                         type="keyval", default={},
581
                         help="Backend parameters")
582

    
583
HVOPTS_OPT =  cli_option("-H", "--hypervisor-parameters", type="keyval",
584
                         default={}, dest="hvparams",
585
                         help="Hypervisor parameters")
586

    
587
HYPERVISOR_OPT = cli_option("-H", "--hypervisor-parameters", dest="hypervisor",
588
                            help="Hypervisor and hypervisor options, in the"
589
                            " format hypervisor:option=value,option=value,...",
590
                            default=None, type="identkeyval")
591

    
592
HVLIST_OPT = cli_option("-H", "--hypervisor-parameters", dest="hvparams",
593
                        help="Hypervisor and hypervisor options, in the"
594
                        " format hypervisor:option=value,option=value,...",
595
                        default=[], action="append", type="identkeyval")
596

    
597
NOIPCHECK_OPT = cli_option("--no-ip-check", dest="ip_check", default=True,
598
                           action="store_false",
599
                           help="Don't check that the instance's IP"
600
                           " is alive")
601

    
602
NONAMECHECK_OPT = cli_option("--no-name-check", dest="name_check",
603
                             default=True, action="store_false",
604
                             help="Don't check that the instance's name"
605
                             " is resolvable")
606

    
607
NET_OPT = cli_option("--net",
608
                     help="NIC parameters", default=[],
609
                     dest="nics", action="append", type="identkeyval")
610

    
611
DISK_OPT = cli_option("--disk", help="Disk parameters", default=[],
612
                      dest="disks", action="append", type="identkeyval")
613

    
614
DISKIDX_OPT = cli_option("--disks", dest="disks", default=None,
615
                         help="Comma-separated list of disks"
616
                         " indices to act on (e.g. 0,2) (optional,"
617
                         " defaults to all disks)")
618

    
619
OS_SIZE_OPT = cli_option("-s", "--os-size", dest="sd_size",
620
                         help="Enforces a single-disk configuration using the"
621
                         " given disk size, in MiB unless a suffix is used",
622
                         default=None, type="unit", metavar="<size>")
623

    
624
IGNORE_CONSIST_OPT = cli_option("--ignore-consistency",
625
                                dest="ignore_consistency",
626
                                action="store_true", default=False,
627
                                help="Ignore the consistency of the disks on"
628
                                " the secondary")
629

    
630
NONLIVE_OPT = cli_option("--non-live", dest="live",
631
                         default=True, action="store_false",
632
                         help="Do a non-live migration (this usually means"
633
                         " freeze the instance, save the state, transfer and"
634
                         " only then resume running on the secondary node)")
635

    
636
NODE_PLACEMENT_OPT = cli_option("-n", "--node", dest="node",
637
                                help="Target node and optional secondary node",
638
                                metavar="<pnode>[:<snode>]",
639
                                completion_suggest=OPT_COMPL_INST_ADD_NODES)
640

    
641
NODE_LIST_OPT = cli_option("-n", "--node", dest="nodes", default=[],
642
                           action="append", metavar="<node>",
643
                           help="Use only this node (can be used multiple"
644
                           " times, if not given defaults to all nodes)",
645
                           completion_suggest=OPT_COMPL_ONE_NODE)
646

    
647
SINGLE_NODE_OPT = cli_option("-n", "--node", dest="node", help="Target node",
648
                             metavar="<node>",
649
                             completion_suggest=OPT_COMPL_ONE_NODE)
650

    
651
NOSTART_OPT = cli_option("--no-start", dest="start", default=True,
652
                         action="store_false",
653
                         help="Don't start the instance after creation")
654

    
655
SHOWCMD_OPT = cli_option("--show-cmd", dest="show_command",
656
                         action="store_true", default=False,
657
                         help="Show command instead of executing it")
658

    
659
CLEANUP_OPT = cli_option("--cleanup", dest="cleanup",
660
                         default=False, action="store_true",
661
                         help="Instead of performing the migration, try to"
662
                         " recover from a failed cleanup. This is safe"
663
                         " to run even if the instance is healthy, but it"
664
                         " will create extra replication traffic and "
665
                         " disrupt briefly the replication (like during the"
666
                         " migration")
667

    
668
STATIC_OPT = cli_option("-s", "--static", dest="static",
669
                        action="store_true", default=False,
670
                        help="Only show configuration data, not runtime data")
671

    
672
ALL_OPT = cli_option("--all", dest="show_all",
673
                     default=False, action="store_true",
674
                     help="Show info on all instances on the cluster."
675
                     " This can take a long time to run, use wisely")
676

    
677
SELECT_OS_OPT = cli_option("--select-os", dest="select_os",
678
                           action="store_true", default=False,
679
                           help="Interactive OS reinstall, lists available"
680
                           " OS templates for selection")
681

    
682
IGNORE_FAILURES_OPT = cli_option("--ignore-failures", dest="ignore_failures",
683
                                 action="store_true", default=False,
684
                                 help="Remove the instance from the cluster"
685
                                 " configuration even if there are failures"
686
                                 " during the removal process")
687

    
688
NEW_SECONDARY_OPT = cli_option("-n", "--new-secondary", dest="dst_node",
689
                               help="Specifies the new secondary node",
690
                               metavar="NODE", default=None,
691
                               completion_suggest=OPT_COMPL_ONE_NODE)
692

    
693
ON_PRIMARY_OPT = cli_option("-p", "--on-primary", dest="on_primary",
694
                            default=False, action="store_true",
695
                            help="Replace the disk(s) on the primary"
696
                            " node (only for the drbd template)")
697

    
698
ON_SECONDARY_OPT = cli_option("-s", "--on-secondary", dest="on_secondary",
699
                              default=False, action="store_true",
700
                              help="Replace the disk(s) on the secondary"
701
                              " node (only for the drbd template)")
702

    
703
AUTO_REPLACE_OPT = cli_option("-a", "--auto", dest="auto",
704
                              default=False, action="store_true",
705
                              help="Automatically replace faulty disks"
706
                              " (only for the drbd template)")
707

    
708
IGNORE_SIZE_OPT = cli_option("--ignore-size", dest="ignore_size",
709
                             default=False, action="store_true",
710
                             help="Ignore current recorded size"
711
                             " (useful for forcing activation when"
712
                             " the recorded size is wrong)")
713

    
714
SRC_NODE_OPT = cli_option("--src-node", dest="src_node", help="Source node",
715
                          metavar="<node>",
716
                          completion_suggest=OPT_COMPL_ONE_NODE)
717

    
718
SRC_DIR_OPT = cli_option("--src-dir", dest="src_dir", help="Source directory",
719
                         metavar="<dir>")
720

    
721
SECONDARY_IP_OPT = cli_option("-s", "--secondary-ip", dest="secondary_ip",
722
                              help="Specify the secondary ip for the node",
723
                              metavar="ADDRESS", default=None)
724

    
725
READD_OPT = cli_option("--readd", dest="readd",
726
                       default=False, action="store_true",
727
                       help="Readd old node after replacing it")
728

    
729
NOSSH_KEYCHECK_OPT = cli_option("--no-ssh-key-check", dest="ssh_key_check",
730
                                default=True, action="store_false",
731
                                help="Disable SSH key fingerprint checking")
732

    
733

    
734
MC_OPT = cli_option("-C", "--master-candidate", dest="master_candidate",
735
                    choices=_YESNO, default=None, metavar=_YORNO,
736
                    help="Set the master_candidate flag on the node")
737

    
738
OFFLINE_OPT = cli_option("-O", "--offline", dest="offline", metavar=_YORNO,
739
                         choices=_YESNO, default=None,
740
                         help="Set the offline flag on the node")
741

    
742
DRAINED_OPT = cli_option("-D", "--drained", dest="drained", metavar=_YORNO,
743
                         choices=_YESNO, default=None,
744
                         help="Set the drained flag on the node")
745

    
746
ALLOCATABLE_OPT = cli_option("--allocatable", dest="allocatable",
747
                             choices=_YESNO, default=None, metavar=_YORNO,
748
                             help="Set the allocatable flag on a volume")
749

    
750
NOLVM_STORAGE_OPT = cli_option("--no-lvm-storage", dest="lvm_storage",
751
                               help="Disable support for lvm based instances"
752
                               " (cluster-wide)",
753
                               action="store_false", default=True)
754

    
755
ENABLED_HV_OPT = cli_option("--enabled-hypervisors",
756
                            dest="enabled_hypervisors",
757
                            help="Comma-separated list of hypervisors",
758
                            type="string", default=None)
759

    
760
NIC_PARAMS_OPT = cli_option("-N", "--nic-parameters", dest="nicparams",
761
                            type="keyval", default={},
762
                            help="NIC parameters")
763

    
764
CP_SIZE_OPT = cli_option("-C", "--candidate-pool-size", default=None,
765
                         dest="candidate_pool_size", type="int",
766
                         help="Set the candidate pool size")
767

    
768
VG_NAME_OPT = cli_option("-g", "--vg-name", dest="vg_name",
769
                         help="Enables LVM and specifies the volume group"
770
                         " name (cluster-wide) for disk allocation [xenvg]",
771
                         metavar="VG", default=None)
772

    
773
YES_DOIT_OPT = cli_option("--yes-do-it", dest="yes_do_it",
774
                          help="Destroy cluster", action="store_true")
775

    
776
NOVOTING_OPT = cli_option("--no-voting", dest="no_voting",
777
                          help="Skip node agreement check (dangerous)",
778
                          action="store_true", default=False)
779

    
780
MAC_PREFIX_OPT = cli_option("-m", "--mac-prefix", dest="mac_prefix",
781
                            help="Specify the mac prefix for the instance IP"
782
                            " addresses, in the format XX:XX:XX",
783
                            metavar="PREFIX",
784
                            default=None)
785

    
786
MASTER_NETDEV_OPT = cli_option("--master-netdev", dest="master_netdev",
787
                               help="Specify the node interface (cluster-wide)"
788
                               " on which the master IP address will be added "
789
                               " [%s]" % constants.DEFAULT_BRIDGE,
790
                               metavar="NETDEV",
791
                               default=constants.DEFAULT_BRIDGE)
792

    
793

    
794
GLOBAL_FILEDIR_OPT = cli_option("--file-storage-dir", dest="file_storage_dir",
795
                                help="Specify the default directory (cluster-"
796
                                "wide) for storing the file-based disks [%s]" %
797
                                constants.DEFAULT_FILE_STORAGE_DIR,
798
                                metavar="DIR",
799
                                default=constants.DEFAULT_FILE_STORAGE_DIR)
800

    
801
NOMODIFY_ETCHOSTS_OPT = cli_option("--no-etc-hosts", dest="modify_etc_hosts",
802
                                   help="Don't modify /etc/hosts",
803
                                   action="store_false", default=True)
804

    
805
NOMODIFY_SSH_SETUP_OPT = cli_option("--no-ssh-init", dest="modify_ssh_setup",
806
                                    help="Don't initialize SSH keys",
807
                                    action="store_false", default=True)
808

    
809
ERROR_CODES_OPT = cli_option("--error-codes", dest="error_codes",
810
                             help="Enable parseable error messages",
811
                             action="store_true", default=False)
812

    
813
NONPLUS1_OPT = cli_option("--no-nplus1-mem", dest="skip_nplusone_mem",
814
                          help="Skip N+1 memory redundancy tests",
815
                          action="store_true", default=False)
816

    
817
REBOOT_TYPE_OPT = cli_option("-t", "--type", dest="reboot_type",
818
                             help="Type of reboot: soft/hard/full",
819
                             default=constants.INSTANCE_REBOOT_HARD,
820
                             metavar="<REBOOT>",
821
                             choices=list(constants.REBOOT_TYPES))
822

    
823
IGNORE_SECONDARIES_OPT = cli_option("--ignore-secondaries",
824
                                    dest="ignore_secondaries",
825
                                    default=False, action="store_true",
826
                                    help="Ignore errors from secondaries")
827

    
828
NOSHUTDOWN_OPT = cli_option("--noshutdown", dest="shutdown",
829
                            action="store_false", default=True,
830
                            help="Don't shutdown the instance (unsafe)")
831

    
832
TIMEOUT_OPT = cli_option("--timeout", dest="timeout", type="int",
833
                         default=constants.DEFAULT_SHUTDOWN_TIMEOUT,
834
                         help="Maximum time to wait")
835

    
836
SHUTDOWN_TIMEOUT_OPT = cli_option("--shutdown-timeout",
837
                         dest="shutdown_timeout", type="int",
838
                         default=constants.DEFAULT_SHUTDOWN_TIMEOUT,
839
                         help="Maximum time to wait for instance shutdown")
840

    
841

    
842
def _ParseArgs(argv, commands, aliases):
843
  """Parser for the command line arguments.
844

845
  This function parses the arguments and returns the function which
846
  must be executed together with its (modified) arguments.
847

848
  @param argv: the command line
849
  @param commands: dictionary with special contents, see the design
850
      doc for cmdline handling
851
  @param aliases: dictionary with command aliases {'alias': 'target, ...}
852

853
  """
854
  if len(argv) == 0:
855
    binary = "<command>"
856
  else:
857
    binary = argv[0].split("/")[-1]
858

    
859
  if len(argv) > 1 and argv[1] == "--version":
860
    ToStdout("%s (ganeti) %s", binary, constants.RELEASE_VERSION)
861
    # Quit right away. That way we don't have to care about this special
862
    # argument. optparse.py does it the same.
863
    sys.exit(0)
864

    
865
  if len(argv) < 2 or not (argv[1] in commands or
866
                           argv[1] in aliases):
867
    # let's do a nice thing
868
    sortedcmds = commands.keys()
869
    sortedcmds.sort()
870

    
871
    ToStdout("Usage: %s {command} [options...] [argument...]", binary)
872
    ToStdout("%s <command> --help to see details, or man %s", binary, binary)
873
    ToStdout("")
874

    
875
    # compute the max line length for cmd + usage
876
    mlen = max([len(" %s" % cmd) for cmd in commands])
877
    mlen = min(60, mlen) # should not get here...
878

    
879
    # and format a nice command list
880
    ToStdout("Commands:")
881
    for cmd in sortedcmds:
882
      cmdstr = " %s" % (cmd,)
883
      help_text = commands[cmd][4]
884
      help_lines = textwrap.wrap(help_text, 79 - 3 - mlen)
885
      ToStdout("%-*s - %s", mlen, cmdstr, help_lines.pop(0))
886
      for line in help_lines:
887
        ToStdout("%-*s   %s", mlen, "", line)
888

    
889
    ToStdout("")
890

    
891
    return None, None, None
892

    
893
  # get command, unalias it, and look it up in commands
894
  cmd = argv.pop(1)
895
  if cmd in aliases:
896
    if cmd in commands:
897
      raise errors.ProgrammerError("Alias '%s' overrides an existing"
898
                                   " command" % cmd)
899

    
900
    if aliases[cmd] not in commands:
901
      raise errors.ProgrammerError("Alias '%s' maps to non-existing"
902
                                   " command '%s'" % (cmd, aliases[cmd]))
903

    
904
    cmd = aliases[cmd]
905

    
906
  func, args_def, parser_opts, usage, description = commands[cmd]
907
  parser = OptionParser(option_list=parser_opts + [_DRY_RUN_OPT, DEBUG_OPT],
908
                        description=description,
909
                        formatter=TitledHelpFormatter(),
910
                        usage="%%prog %s %s" % (cmd, usage))
911
  parser.disable_interspersed_args()
912
  options, args = parser.parse_args()
913

    
914
  if not _CheckArguments(cmd, args_def, args):
915
    return None, None, None
916

    
917
  return func, options, args
918

    
919

    
920
def _CheckArguments(cmd, args_def, args):
921
  """Verifies the arguments using the argument definition.
922

923
  Algorithm:
924

925
    1. Abort with error if values specified by user but none expected.
926

927
    1. For each argument in definition
928

929
      1. Keep running count of minimum number of values (min_count)
930
      1. Keep running count of maximum number of values (max_count)
931
      1. If it has an unlimited number of values
932

933
        1. Abort with error if it's not the last argument in the definition
934

935
    1. If last argument has limited number of values
936

937
      1. Abort with error if number of values doesn't match or is too large
938

939
    1. Abort with error if user didn't pass enough values (min_count)
940

941
  """
942
  if args and not args_def:
943
    ToStderr("Error: Command %s expects no arguments", cmd)
944
    return False
945

    
946
  min_count = None
947
  max_count = None
948
  check_max = None
949

    
950
  last_idx = len(args_def) - 1
951

    
952
  for idx, arg in enumerate(args_def):
953
    if min_count is None:
954
      min_count = arg.min
955
    elif arg.min is not None:
956
      min_count += arg.min
957

    
958
    if max_count is None:
959
      max_count = arg.max
960
    elif arg.max is not None:
961
      max_count += arg.max
962

    
963
    if idx == last_idx:
964
      check_max = (arg.max is not None)
965

    
966
    elif arg.max is None:
967
      raise errors.ProgrammerError("Only the last argument can have max=None")
968

    
969
  if check_max:
970
    # Command with exact number of arguments
971
    if (min_count is not None and max_count is not None and
972
        min_count == max_count and len(args) != min_count):
973
      ToStderr("Error: Command %s expects %d argument(s)", cmd, min_count)
974
      return False
975

    
976
    # Command with limited number of arguments
977
    if max_count is not None and len(args) > max_count:
978
      ToStderr("Error: Command %s expects only %d argument(s)",
979
               cmd, max_count)
980
      return False
981

    
982
  # Command with some required arguments
983
  if min_count is not None and len(args) < min_count:
984
    ToStderr("Error: Command %s expects at least %d argument(s)",
985
             cmd, min_count)
986
    return False
987

    
988
  return True
989

    
990

    
991
def SplitNodeOption(value):
992
  """Splits the value of a --node option.
993

994
  """
995
  if value and ':' in value:
996
    return value.split(':', 1)
997
  else:
998
    return (value, None)
999

    
1000

    
1001
def CalculateOSNames(os_name, os_variants):
1002
  """Calculates all the names an OS can be called, according to its variants.
1003

1004
  @type os_name: string
1005
  @param os_name: base name of the os
1006
  @type os_variants: list or None
1007
  @param os_variants: list of supported variants
1008
  @rtype: list
1009
  @return: list of valid names
1010

1011
  """
1012
  if os_variants:
1013
    return ['%s+%s' % (os_name, v) for v in os_variants]
1014
  else:
1015
    return [os_name]
1016

    
1017

    
1018
def UsesRPC(fn):
1019
  def wrapper(*args, **kwargs):
1020
    rpc.Init()
1021
    try:
1022
      return fn(*args, **kwargs)
1023
    finally:
1024
      rpc.Shutdown()
1025
  return wrapper
1026

    
1027

    
1028
def AskUser(text, choices=None):
1029
  """Ask the user a question.
1030

1031
  @param text: the question to ask
1032

1033
  @param choices: list with elements tuples (input_char, return_value,
1034
      description); if not given, it will default to: [('y', True,
1035
      'Perform the operation'), ('n', False, 'Do no do the operation')];
1036
      note that the '?' char is reserved for help
1037

1038
  @return: one of the return values from the choices list; if input is
1039
      not possible (i.e. not running with a tty, we return the last
1040
      entry from the list
1041

1042
  """
1043
  if choices is None:
1044
    choices = [('y', True, 'Perform the operation'),
1045
               ('n', False, 'Do not perform the operation')]
1046
  if not choices or not isinstance(choices, list):
1047
    raise errors.ProgrammerError("Invalid choices argument to AskUser")
1048
  for entry in choices:
1049
    if not isinstance(entry, tuple) or len(entry) < 3 or entry[0] == '?':
1050
      raise errors.ProgrammerError("Invalid choices element to AskUser")
1051

    
1052
  answer = choices[-1][1]
1053
  new_text = []
1054
  for line in text.splitlines():
1055
    new_text.append(textwrap.fill(line, 70, replace_whitespace=False))
1056
  text = "\n".join(new_text)
1057
  try:
1058
    f = file("/dev/tty", "a+")
1059
  except IOError:
1060
    return answer
1061
  try:
1062
    chars = [entry[0] for entry in choices]
1063
    chars[-1] = "[%s]" % chars[-1]
1064
    chars.append('?')
1065
    maps = dict([(entry[0], entry[1]) for entry in choices])
1066
    while True:
1067
      f.write(text)
1068
      f.write('\n')
1069
      f.write("/".join(chars))
1070
      f.write(": ")
1071
      line = f.readline(2).strip().lower()
1072
      if line in maps:
1073
        answer = maps[line]
1074
        break
1075
      elif line == '?':
1076
        for entry in choices:
1077
          f.write(" %s - %s\n" % (entry[0], entry[2]))
1078
        f.write("\n")
1079
        continue
1080
  finally:
1081
    f.close()
1082
  return answer
1083

    
1084

    
1085
class JobSubmittedException(Exception):
1086
  """Job was submitted, client should exit.
1087

1088
  This exception has one argument, the ID of the job that was
1089
  submitted. The handler should print this ID.
1090

1091
  This is not an error, just a structured way to exit from clients.
1092

1093
  """
1094

    
1095

    
1096
def SendJob(ops, cl=None):
1097
  """Function to submit an opcode without waiting for the results.
1098

1099
  @type ops: list
1100
  @param ops: list of opcodes
1101
  @type cl: luxi.Client
1102
  @param cl: the luxi client to use for communicating with the master;
1103
             if None, a new client will be created
1104

1105
  """
1106
  if cl is None:
1107
    cl = GetClient()
1108

    
1109
  job_id = cl.SubmitJob(ops)
1110

    
1111
  return job_id
1112

    
1113

    
1114
def PollJob(job_id, cl=None, feedback_fn=None):
1115
  """Function to poll for the result of a job.
1116

1117
  @type job_id: job identified
1118
  @param job_id: the job to poll for results
1119
  @type cl: luxi.Client
1120
  @param cl: the luxi client to use for communicating with the master;
1121
             if None, a new client will be created
1122

1123
  """
1124
  if cl is None:
1125
    cl = GetClient()
1126

    
1127
  prev_job_info = None
1128
  prev_logmsg_serial = None
1129

    
1130
  while True:
1131
    result = cl.WaitForJobChange(job_id, ["status"], prev_job_info,
1132
                                 prev_logmsg_serial)
1133
    if not result:
1134
      # job not found, go away!
1135
      raise errors.JobLost("Job with id %s lost" % job_id)
1136

    
1137
    # Split result, a tuple of (field values, log entries)
1138
    (job_info, log_entries) = result
1139
    (status, ) = job_info
1140

    
1141
    if log_entries:
1142
      for log_entry in log_entries:
1143
        (serial, timestamp, _, message) = log_entry
1144
        if callable(feedback_fn):
1145
          feedback_fn(log_entry[1:])
1146
        else:
1147
          encoded = utils.SafeEncode(message)
1148
          ToStdout("%s %s", time.ctime(utils.MergeTime(timestamp)), encoded)
1149
        prev_logmsg_serial = max(prev_logmsg_serial, serial)
1150

    
1151
    # TODO: Handle canceled and archived jobs
1152
    elif status in (constants.JOB_STATUS_SUCCESS,
1153
                    constants.JOB_STATUS_ERROR,
1154
                    constants.JOB_STATUS_CANCELING,
1155
                    constants.JOB_STATUS_CANCELED):
1156
      break
1157

    
1158
    prev_job_info = job_info
1159

    
1160
  jobs = cl.QueryJobs([job_id], ["status", "opstatus", "opresult"])
1161
  if not jobs:
1162
    raise errors.JobLost("Job with id %s lost" % job_id)
1163

    
1164
  status, opstatus, result = jobs[0]
1165
  if status == constants.JOB_STATUS_SUCCESS:
1166
    return result
1167
  elif status in (constants.JOB_STATUS_CANCELING,
1168
                  constants.JOB_STATUS_CANCELED):
1169
    raise errors.OpExecError("Job was canceled")
1170
  else:
1171
    has_ok = False
1172
    for idx, (status, msg) in enumerate(zip(opstatus, result)):
1173
      if status == constants.OP_STATUS_SUCCESS:
1174
        has_ok = True
1175
      elif status == constants.OP_STATUS_ERROR:
1176
        errors.MaybeRaise(msg)
1177
        if has_ok:
1178
          raise errors.OpExecError("partial failure (opcode %d): %s" %
1179
                                   (idx, msg))
1180
        else:
1181
          raise errors.OpExecError(str(msg))
1182
    # default failure mode
1183
    raise errors.OpExecError(result)
1184

    
1185

    
1186
def SubmitOpCode(op, cl=None, feedback_fn=None):
1187
  """Legacy function to submit an opcode.
1188

1189
  This is just a simple wrapper over the construction of the processor
1190
  instance. It should be extended to better handle feedback and
1191
  interaction functions.
1192

1193
  """
1194
  if cl is None:
1195
    cl = GetClient()
1196

    
1197
  job_id = SendJob([op], cl)
1198

    
1199
  op_results = PollJob(job_id, cl=cl, feedback_fn=feedback_fn)
1200

    
1201
  return op_results[0]
1202

    
1203

    
1204
def SubmitOrSend(op, opts, cl=None, feedback_fn=None):
1205
  """Wrapper around SubmitOpCode or SendJob.
1206

1207
  This function will decide, based on the 'opts' parameter, whether to
1208
  submit and wait for the result of the opcode (and return it), or
1209
  whether to just send the job and print its identifier. It is used in
1210
  order to simplify the implementation of the '--submit' option.
1211

1212
  It will also add the dry-run parameter from the options passed, if true.
1213

1214
  """
1215
  if opts and opts.dry_run:
1216
    op.dry_run = opts.dry_run
1217
  if opts and opts.submit_only:
1218
    job_id = SendJob([op], cl=cl)
1219
    raise JobSubmittedException(job_id)
1220
  else:
1221
    return SubmitOpCode(op, cl=cl, feedback_fn=feedback_fn)
1222

    
1223

    
1224
def GetClient():
1225
  # TODO: Cache object?
1226
  try:
1227
    client = luxi.Client()
1228
  except luxi.NoMasterError:
1229
    ss = ssconf.SimpleStore()
1230

    
1231
    # Try to read ssconf file
1232
    try:
1233
      ss.GetMasterNode()
1234
    except errors.ConfigurationError:
1235
      raise errors.OpPrereqError("Cluster not initialized or this machine is"
1236
                                 " not part of a cluster")
1237

    
1238
    master, myself = ssconf.GetMasterAndMyself(ss=ss)
1239
    if master != myself:
1240
      raise errors.OpPrereqError("This is not the master node, please connect"
1241
                                 " to node '%s' and rerun the command" %
1242
                                 master)
1243
    raise
1244
  return client
1245

    
1246

    
1247
def FormatError(err):
1248
  """Return a formatted error message for a given error.
1249

1250
  This function takes an exception instance and returns a tuple
1251
  consisting of two values: first, the recommended exit code, and
1252
  second, a string describing the error message (not
1253
  newline-terminated).
1254

1255
  """
1256
  retcode = 1
1257
  obuf = StringIO()
1258
  msg = str(err)
1259
  if isinstance(err, errors.ConfigurationError):
1260
    txt = "Corrupt configuration file: %s" % msg
1261
    logging.error(txt)
1262
    obuf.write(txt + "\n")
1263
    obuf.write("Aborting.")
1264
    retcode = 2
1265
  elif isinstance(err, errors.HooksAbort):
1266
    obuf.write("Failure: hooks execution failed:\n")
1267
    for node, script, out in err.args[0]:
1268
      if out:
1269
        obuf.write("  node: %s, script: %s, output: %s\n" %
1270
                   (node, script, out))
1271
      else:
1272
        obuf.write("  node: %s, script: %s (no output)\n" %
1273
                   (node, script))
1274
  elif isinstance(err, errors.HooksFailure):
1275
    obuf.write("Failure: hooks general failure: %s" % msg)
1276
  elif isinstance(err, errors.ResolverError):
1277
    this_host = utils.HostInfo.SysName()
1278
    if err.args[0] == this_host:
1279
      msg = "Failure: can't resolve my own hostname ('%s')"
1280
    else:
1281
      msg = "Failure: can't resolve hostname '%s'"
1282
    obuf.write(msg % err.args[0])
1283
  elif isinstance(err, errors.OpPrereqError):
1284
    if len(err.args) == 2:
1285
      obuf.write("Failure: prerequisites not met for this"
1286
               " operation:\nerror type: %s, error details:\n%s" %
1287
                 (err.args[1], err.args[0]))
1288
    else:
1289
      obuf.write("Failure: prerequisites not met for this"
1290
                 " operation:\n%s" % msg)
1291
  elif isinstance(err, errors.OpExecError):
1292
    obuf.write("Failure: command execution error:\n%s" % msg)
1293
  elif isinstance(err, errors.TagError):
1294
    obuf.write("Failure: invalid tag(s) given:\n%s" % msg)
1295
  elif isinstance(err, errors.JobQueueDrainError):
1296
    obuf.write("Failure: the job queue is marked for drain and doesn't"
1297
               " accept new requests\n")
1298
  elif isinstance(err, errors.JobQueueFull):
1299
    obuf.write("Failure: the job queue is full and doesn't accept new"
1300
               " job submissions until old jobs are archived\n")
1301
  elif isinstance(err, errors.TypeEnforcementError):
1302
    obuf.write("Parameter Error: %s" % msg)
1303
  elif isinstance(err, errors.ParameterError):
1304
    obuf.write("Failure: unknown/wrong parameter name '%s'" % msg)
1305
  elif isinstance(err, luxi.NoMasterError):
1306
    obuf.write("Cannot communicate with the master daemon.\nIs it running"
1307
               " and listening for connections?")
1308
  elif isinstance(err, luxi.TimeoutError):
1309
    obuf.write("Timeout while talking to the master daemon. Error:\n"
1310
               "%s" % msg)
1311
  elif isinstance(err, luxi.ProtocolError):
1312
    obuf.write("Unhandled protocol error while talking to the master daemon:\n"
1313
               "%s" % msg)
1314
  elif isinstance(err, errors.GenericError):
1315
    obuf.write("Unhandled Ganeti error: %s" % msg)
1316
  elif isinstance(err, JobSubmittedException):
1317
    obuf.write("JobID: %s\n" % err.args[0])
1318
    retcode = 0
1319
  else:
1320
    obuf.write("Unhandled exception: %s" % msg)
1321
  return retcode, obuf.getvalue().rstrip('\n')
1322

    
1323

    
1324
def GenericMain(commands, override=None, aliases=None):
1325
  """Generic main function for all the gnt-* commands.
1326

1327
  Arguments:
1328
    - commands: a dictionary with a special structure, see the design doc
1329
                for command line handling.
1330
    - override: if not None, we expect a dictionary with keys that will
1331
                override command line options; this can be used to pass
1332
                options from the scripts to generic functions
1333
    - aliases: dictionary with command aliases {'alias': 'target, ...}
1334

1335
  """
1336
  # save the program name and the entire command line for later logging
1337
  if sys.argv:
1338
    binary = os.path.basename(sys.argv[0]) or sys.argv[0]
1339
    if len(sys.argv) >= 2:
1340
      binary += " " + sys.argv[1]
1341
      old_cmdline = " ".join(sys.argv[2:])
1342
    else:
1343
      old_cmdline = ""
1344
  else:
1345
    binary = "<unknown program>"
1346
    old_cmdline = ""
1347

    
1348
  if aliases is None:
1349
    aliases = {}
1350

    
1351
  try:
1352
    func, options, args = _ParseArgs(sys.argv, commands, aliases)
1353
  except errors.ParameterError, err:
1354
    result, err_msg = FormatError(err)
1355
    ToStderr(err_msg)
1356
    return 1
1357

    
1358
  if func is None: # parse error
1359
    return 1
1360

    
1361
  if override is not None:
1362
    for key, val in override.iteritems():
1363
      setattr(options, key, val)
1364

    
1365
  utils.SetupLogging(constants.LOG_COMMANDS, debug=options.debug,
1366
                     stderr_logging=True, program=binary)
1367

    
1368
  if old_cmdline:
1369
    logging.info("run with arguments '%s'", old_cmdline)
1370
  else:
1371
    logging.info("run with no arguments")
1372

    
1373
  try:
1374
    result = func(options, args)
1375
  except (errors.GenericError, luxi.ProtocolError,
1376
          JobSubmittedException), err:
1377
    result, err_msg = FormatError(err)
1378
    logging.exception("Error during command processing")
1379
    ToStderr(err_msg)
1380

    
1381
  return result
1382

    
1383

    
1384
def GenericInstanceCreate(mode, opts, args):
1385
  """Add an instance to the cluster via either creation or import.
1386

1387
  @param mode: constants.INSTANCE_CREATE or constants.INSTANCE_IMPORT
1388
  @param opts: the command line options selected by the user
1389
  @type args: list
1390
  @param args: should contain only one element, the new instance name
1391
  @rtype: int
1392
  @return: the desired exit code
1393

1394
  """
1395
  instance = args[0]
1396

    
1397
  (pnode, snode) = SplitNodeOption(opts.node)
1398

    
1399
  hypervisor = None
1400
  hvparams = {}
1401
  if opts.hypervisor:
1402
    hypervisor, hvparams = opts.hypervisor
1403

    
1404
  if opts.nics:
1405
    try:
1406
      nic_max = max(int(nidx[0]) + 1 for nidx in opts.nics)
1407
    except ValueError, err:
1408
      raise errors.OpPrereqError("Invalid NIC index passed: %s" % str(err))
1409
    nics = [{}] * nic_max
1410
    for nidx, ndict in opts.nics:
1411
      nidx = int(nidx)
1412
      if not isinstance(ndict, dict):
1413
        msg = "Invalid nic/%d value: expected dict, got %s" % (nidx, ndict)
1414
        raise errors.OpPrereqError(msg)
1415
      nics[nidx] = ndict
1416
  elif opts.no_nics:
1417
    # no nics
1418
    nics = []
1419
  else:
1420
    # default of one nic, all auto
1421
    nics = [{}]
1422

    
1423
  if opts.disk_template == constants.DT_DISKLESS:
1424
    if opts.disks or opts.sd_size is not None:
1425
      raise errors.OpPrereqError("Diskless instance but disk"
1426
                                 " information passed")
1427
    disks = []
1428
  else:
1429
    if not opts.disks and not opts.sd_size:
1430
      raise errors.OpPrereqError("No disk information specified")
1431
    if opts.disks and opts.sd_size is not None:
1432
      raise errors.OpPrereqError("Please use either the '--disk' or"
1433
                                 " '-s' option")
1434
    if opts.sd_size is not None:
1435
      opts.disks = [(0, {"size": opts.sd_size})]
1436
    try:
1437
      disk_max = max(int(didx[0]) + 1 for didx in opts.disks)
1438
    except ValueError, err:
1439
      raise errors.OpPrereqError("Invalid disk index passed: %s" % str(err))
1440
    disks = [{}] * disk_max
1441
    for didx, ddict in opts.disks:
1442
      didx = int(didx)
1443
      if not isinstance(ddict, dict):
1444
        msg = "Invalid disk/%d value: expected dict, got %s" % (didx, ddict)
1445
        raise errors.OpPrereqError(msg)
1446
      elif "size" not in ddict:
1447
        raise errors.OpPrereqError("Missing size for disk %d" % didx)
1448
      try:
1449
        ddict["size"] = utils.ParseUnit(ddict["size"])
1450
      except ValueError, err:
1451
        raise errors.OpPrereqError("Invalid disk size for disk %d: %s" %
1452
                                   (didx, err))
1453
      disks[didx] = ddict
1454

    
1455
  utils.ForceDictType(opts.beparams, constants.BES_PARAMETER_TYPES)
1456
  utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES)
1457

    
1458
  if mode == constants.INSTANCE_CREATE:
1459
    start = opts.start
1460
    os_type = opts.os
1461
    src_node = None
1462
    src_path = None
1463
  elif mode == constants.INSTANCE_IMPORT:
1464
    start = False
1465
    os_type = None
1466
    src_node = opts.src_node
1467
    src_path = opts.src_dir
1468
  else:
1469
    raise errors.ProgrammerError("Invalid creation mode %s" % mode)
1470

    
1471
  op = opcodes.OpCreateInstance(instance_name=instance,
1472
                                disks=disks,
1473
                                disk_template=opts.disk_template,
1474
                                nics=nics,
1475
                                pnode=pnode, snode=snode,
1476
                                ip_check=opts.ip_check,
1477
                                name_check=opts.name_check,
1478
                                wait_for_sync=opts.wait_for_sync,
1479
                                file_storage_dir=opts.file_storage_dir,
1480
                                file_driver=opts.file_driver,
1481
                                iallocator=opts.iallocator,
1482
                                hypervisor=hypervisor,
1483
                                hvparams=hvparams,
1484
                                beparams=opts.beparams,
1485
                                mode=mode,
1486
                                start=start,
1487
                                os_type=os_type,
1488
                                src_node=src_node,
1489
                                src_path=src_path)
1490

    
1491
  SubmitOrSend(op, opts)
1492
  return 0
1493

    
1494

    
1495
def GenerateTable(headers, fields, separator, data,
1496
                  numfields=None, unitfields=None,
1497
                  units=None):
1498
  """Prints a table with headers and different fields.
1499

1500
  @type headers: dict
1501
  @param headers: dictionary mapping field names to headers for
1502
      the table
1503
  @type fields: list
1504
  @param fields: the field names corresponding to each row in
1505
      the data field
1506
  @param separator: the separator to be used; if this is None,
1507
      the default 'smart' algorithm is used which computes optimal
1508
      field width, otherwise just the separator is used between
1509
      each field
1510
  @type data: list
1511
  @param data: a list of lists, each sublist being one row to be output
1512
  @type numfields: list
1513
  @param numfields: a list with the fields that hold numeric
1514
      values and thus should be right-aligned
1515
  @type unitfields: list
1516
  @param unitfields: a list with the fields that hold numeric
1517
      values that should be formatted with the units field
1518
  @type units: string or None
1519
  @param units: the units we should use for formatting, or None for
1520
      automatic choice (human-readable for non-separator usage, otherwise
1521
      megabytes); this is a one-letter string
1522

1523
  """
1524
  if units is None:
1525
    if separator:
1526
      units = "m"
1527
    else:
1528
      units = "h"
1529

    
1530
  if numfields is None:
1531
    numfields = []
1532
  if unitfields is None:
1533
    unitfields = []
1534

    
1535
  numfields = utils.FieldSet(*numfields)   # pylint: disable-msg=W0142
1536
  unitfields = utils.FieldSet(*unitfields) # pylint: disable-msg=W0142
1537

    
1538
  format_fields = []
1539
  for field in fields:
1540
    if headers and field not in headers:
1541
      # TODO: handle better unknown fields (either revert to old
1542
      # style of raising exception, or deal more intelligently with
1543
      # variable fields)
1544
      headers[field] = field
1545
    if separator is not None:
1546
      format_fields.append("%s")
1547
    elif numfields.Matches(field):
1548
      format_fields.append("%*s")
1549
    else:
1550
      format_fields.append("%-*s")
1551

    
1552
  if separator is None:
1553
    mlens = [0 for name in fields]
1554
    format = ' '.join(format_fields)
1555
  else:
1556
    format = separator.replace("%", "%%").join(format_fields)
1557

    
1558
  for row in data:
1559
    if row is None:
1560
      continue
1561
    for idx, val in enumerate(row):
1562
      if unitfields.Matches(fields[idx]):
1563
        try:
1564
          val = int(val)
1565
        except ValueError:
1566
          pass
1567
        else:
1568
          val = row[idx] = utils.FormatUnit(val, units)
1569
      val = row[idx] = str(val)
1570
      if separator is None:
1571
        mlens[idx] = max(mlens[idx], len(val))
1572

    
1573
  result = []
1574
  if headers:
1575
    args = []
1576
    for idx, name in enumerate(fields):
1577
      hdr = headers[name]
1578
      if separator is None:
1579
        mlens[idx] = max(mlens[idx], len(hdr))
1580
        args.append(mlens[idx])
1581
      args.append(hdr)
1582
    result.append(format % tuple(args))
1583

    
1584
  for line in data:
1585
    args = []
1586
    if line is None:
1587
      line = ['-' for _ in fields]
1588
    for idx in range(len(fields)):
1589
      if separator is None:
1590
        args.append(mlens[idx])
1591
      args.append(line[idx])
1592
    result.append(format % tuple(args))
1593

    
1594
  return result
1595

    
1596

    
1597
def FormatTimestamp(ts):
1598
  """Formats a given timestamp.
1599

1600
  @type ts: timestamp
1601
  @param ts: a timeval-type timestamp, a tuple of seconds and microseconds
1602

1603
  @rtype: string
1604
  @return: a string with the formatted timestamp
1605

1606
  """
1607
  if not isinstance (ts, (tuple, list)) or len(ts) != 2:
1608
    return '?'
1609
  sec, usec = ts
1610
  return time.strftime("%F %T", time.localtime(sec)) + ".%06d" % usec
1611

    
1612

    
1613
def ParseTimespec(value):
1614
  """Parse a time specification.
1615

1616
  The following suffixed will be recognized:
1617

1618
    - s: seconds
1619
    - m: minutes
1620
    - h: hours
1621
    - d: day
1622
    - w: weeks
1623

1624
  Without any suffix, the value will be taken to be in seconds.
1625

1626
  """
1627
  value = str(value)
1628
  if not value:
1629
    raise errors.OpPrereqError("Empty time specification passed")
1630
  suffix_map = {
1631
    's': 1,
1632
    'm': 60,
1633
    'h': 3600,
1634
    'd': 86400,
1635
    'w': 604800,
1636
    }
1637
  if value[-1] not in suffix_map:
1638
    try:
1639
      value = int(value)
1640
    except ValueError:
1641
      raise errors.OpPrereqError("Invalid time specification '%s'" % value)
1642
  else:
1643
    multiplier = suffix_map[value[-1]]
1644
    value = value[:-1]
1645
    if not value: # no data left after stripping the suffix
1646
      raise errors.OpPrereqError("Invalid time specification (only"
1647
                                 " suffix passed)")
1648
    try:
1649
      value = int(value) * multiplier
1650
    except ValueError:
1651
      raise errors.OpPrereqError("Invalid time specification '%s'" % value)
1652
  return value
1653

    
1654

    
1655
def GetOnlineNodes(nodes, cl=None, nowarn=False):
1656
  """Returns the names of online nodes.
1657

1658
  This function will also log a warning on stderr with the names of
1659
  the online nodes.
1660

1661
  @param nodes: if not empty, use only this subset of nodes (minus the
1662
      offline ones)
1663
  @param cl: if not None, luxi client to use
1664
  @type nowarn: boolean
1665
  @param nowarn: by default, this function will output a note with the
1666
      offline nodes that are skipped; if this parameter is True the
1667
      note is not displayed
1668

1669
  """
1670
  if cl is None:
1671
    cl = GetClient()
1672

    
1673
  result = cl.QueryNodes(names=nodes, fields=["name", "offline"],
1674
                         use_locking=False)
1675
  offline = [row[0] for row in result if row[1]]
1676
  if offline and not nowarn:
1677
    ToStderr("Note: skipping offline node(s): %s" % utils.CommaJoin(offline))
1678
  return [row[0] for row in result if not row[1]]
1679

    
1680

    
1681
def _ToStream(stream, txt, *args):
1682
  """Write a message to a stream, bypassing the logging system
1683

1684
  @type stream: file object
1685
  @param stream: the file to which we should write
1686
  @type txt: str
1687
  @param txt: the message
1688

1689
  """
1690
  if args:
1691
    args = tuple(args)
1692
    stream.write(txt % args)
1693
  else:
1694
    stream.write(txt)
1695
  stream.write('\n')
1696
  stream.flush()
1697

    
1698

    
1699
def ToStdout(txt, *args):
1700
  """Write a message to stdout only, bypassing the logging system
1701

1702
  This is just a wrapper over _ToStream.
1703

1704
  @type txt: str
1705
  @param txt: the message
1706

1707
  """
1708
  _ToStream(sys.stdout, txt, *args)
1709

    
1710

    
1711
def ToStderr(txt, *args):
1712
  """Write a message to stderr only, bypassing the logging system
1713

1714
  This is just a wrapper over _ToStream.
1715

1716
  @type txt: str
1717
  @param txt: the message
1718

1719
  """
1720
  _ToStream(sys.stderr, txt, *args)
1721

    
1722

    
1723
class JobExecutor(object):
1724
  """Class which manages the submission and execution of multiple jobs.
1725

1726
  Note that instances of this class should not be reused between
1727
  GetResults() calls.
1728

1729
  """
1730
  def __init__(self, cl=None, verbose=True):
1731
    self.queue = []
1732
    if cl is None:
1733
      cl = GetClient()
1734
    self.cl = cl
1735
    self.verbose = verbose
1736
    self.jobs = []
1737

    
1738
  def QueueJob(self, name, *ops):
1739
    """Record a job for later submit.
1740

1741
    @type name: string
1742
    @param name: a description of the job, will be used in WaitJobSet
1743
    """
1744
    self.queue.append((name, ops))
1745

    
1746
  def SubmitPending(self):
1747
    """Submit all pending jobs.
1748

1749
    """
1750
    results = self.cl.SubmitManyJobs([row[1] for row in self.queue])
1751
    for ((status, data), (name, _)) in zip(results, self.queue):
1752
      self.jobs.append((status, data, name))
1753

    
1754
  def GetResults(self):
1755
    """Wait for and return the results of all jobs.
1756

1757
    @rtype: list
1758
    @return: list of tuples (success, job results), in the same order
1759
        as the submitted jobs; if a job has failed, instead of the result
1760
        there will be the error message
1761

1762
    """
1763
    if not self.jobs:
1764
      self.SubmitPending()
1765
    results = []
1766
    if self.verbose:
1767
      ok_jobs = [row[1] for row in self.jobs if row[0]]
1768
      if ok_jobs:
1769
        ToStdout("Submitted jobs %s", utils.CommaJoin(ok_jobs))
1770
    for submit_status, jid, name in self.jobs:
1771
      if not submit_status:
1772
        ToStderr("Failed to submit job for %s: %s", name, jid)
1773
        results.append((False, jid))
1774
        continue
1775
      if self.verbose:
1776
        ToStdout("Waiting for job %s for %s...", jid, name)
1777
      try:
1778
        job_result = PollJob(jid, cl=self.cl)
1779
        success = True
1780
      except (errors.GenericError, luxi.ProtocolError), err:
1781
        _, job_result = FormatError(err)
1782
        success = False
1783
        # the error message will always be shown, verbose or not
1784
        ToStderr("Job %s for %s has failed: %s", jid, name, job_result)
1785

    
1786
      results.append((success, job_result))
1787
    return results
1788

    
1789
  def WaitOrShow(self, wait):
1790
    """Wait for job results or only print the job IDs.
1791

1792
    @type wait: boolean
1793
    @param wait: whether to wait or not
1794

1795
    """
1796
    if wait:
1797
      return self.GetResults()
1798
    else:
1799
      if not self.jobs:
1800
        self.SubmitPending()
1801
      for status, result, name in self.jobs:
1802
        if status:
1803
          ToStdout("%s: %s", result, name)
1804
        else:
1805
          ToStderr("Failure for %s: %s", name, result)