code.grnet.gr Git - ganeti-local/blob - lib/cli.py

   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 import time
  30 import logging
  31 from cStringIO import StringIO
  32
  33 from ganeti import utils
  34 from ganeti import errors
  35 from ganeti import constants
  36 from ganeti import opcodes
  37 from ganeti import luxi
  38 from ganeti import ssconf
  39 from ganeti import rpc
  40
  41 from optparse import (OptionParser, TitledHelpFormatter,
  42                       Option, OptionValueError)
  43
  44
  45 __all__ = [
  46   # Command line options
  47   "ALLOCATABLE_OPT",
  48   "ALL_OPT",
  49   "AUTO_REPLACE_OPT",
  50   "BACKEND_OPT",
  51   "CLEANUP_OPT",
  52   "CONFIRM_OPT",
  53   "CP_SIZE_OPT",
  54   "DEBUG_OPT",
  55   "DEBUG_SIMERR_OPT",
  56   "DISKIDX_OPT",
  57   "DISK_OPT",
  58   "DISK_TEMPLATE_OPT",
  59   "DRAINED_OPT",
  60   "ENABLED_HV_OPT",
  61   "ERROR_CODES_OPT",
  62   "FIELDS_OPT",
  63   "FILESTORE_DIR_OPT",
  64   "FILESTORE_DRIVER_OPT",
  65   "FORCE_OPT",
  66   "FORCE_VARIANT_OPT",
  67   "GLOBAL_FILEDIR_OPT",
  68   "HVLIST_OPT",
  69   "HVOPTS_OPT",
  70   "HYPERVISOR_OPT",
  71   "IALLOCATOR_OPT",
  72   "IGNORE_CONSIST_OPT",
  73   "IGNORE_FAILURES_OPT",
  74   "IGNORE_SECONDARIES_OPT",
  75   "IGNORE_SIZE_OPT",
  76   "MAC_PREFIX_OPT",
  77   "MASTER_NETDEV_OPT",
  78   "MC_OPT",
  79   "NET_OPT",
  80   "NEW_SECONDARY_OPT",
  81   "NIC_PARAMS_OPT",
  82   "NODE_LIST_OPT",
  83   "NODE_PLACEMENT_OPT",
  84   "NOHDR_OPT",
  85   "NOIPCHECK_OPT",
  86   "NOLVM_STORAGE_OPT",
  87   "NOMODIFY_ETCHOSTS_OPT",
  88   "NONICS_OPT",
  89   "NONLIVE_OPT",
  90   "NONPLUS1_OPT",
  91   "NOSHUTDOWN_OPT",
  92   "NOSTART_OPT",
  93   "NOSSH_KEYCHECK_OPT",
  94   "NOVOTING_OPT",
  95   "NWSYNC_OPT",
  96   "ON_PRIMARY_OPT",
  97   "ON_SECONDARY_OPT",
  98   "OFFLINE_OPT",
  99   "OS_OPT",
 100   "OS_SIZE_OPT",
 101   "READD_OPT",
 102   "REBOOT_TYPE_OPT",
 103   "SECONDARY_IP_OPT",
 104   "SELECT_OS_OPT",
 105   "SEP_OPT",
 106   "SHOWCMD_OPT",
 107   "SINGLE_NODE_OPT",
 108   "SRC_DIR_OPT",
 109   "SRC_NODE_OPT",
 110   "SUBMIT_OPT",
 111   "STATIC_OPT",
 112   "SYNC_OPT",
 113   "TAG_SRC_OPT",
 114   "TIMEOUT_OPT",
 115   "USEUNITS_OPT",
 116   "VERBOSE_OPT",
 117   "VG_NAME_OPT",
 118   "YES_DOIT_OPT",
 119   # Generic functions for CLI programs
 120   "GenericMain",
 121   "GenericInstanceCreate",
 122   "GetClient",
 123   "GetOnlineNodes",
 124   "JobExecutor",
 125   "JobSubmittedException",
 126   "ParseTimespec",
 127   "SubmitOpCode",
 128   "SubmitOrSend",
 129   "UsesRPC",
 130   # Formatting functions
 131   "ToStderr", "ToStdout",
 132   "FormatError",
 133   "GenerateTable",
 134   "AskUser",
 135   "FormatTimestamp",
 136   # Tags functions
 137   "ListTags",
 138   "AddTags",
 139   "RemoveTags",
 140   # command line options support infrastructure
 141   "ARGS_MANY_INSTANCES",
 142   "ARGS_MANY_NODES",
 143   "ARGS_NONE",
 144   "ARGS_ONE_INSTANCE",
 145   "ARGS_ONE_NODE",
 146   "ArgChoice",
 147   "ArgCommand",
 148   "ArgFile",
 149   "ArgHost",
 150   "ArgInstance",
 151   "ArgJobId",
 152   "ArgNode",
 153   "ArgSuggest",
 154   "ArgUnknown",
 155   "OPT_COMPL_INST_ADD_NODES",
 156   "OPT_COMPL_MANY_NODES",
 157   "OPT_COMPL_ONE_IALLOCATOR",
 158   "OPT_COMPL_ONE_INSTANCE",
 159   "OPT_COMPL_ONE_NODE",
 160   "OPT_COMPL_ONE_OS",
 161   "cli_option",
 162   "SplitNodeOption",
 163   "CalculateOSNames",
 164   ]
 165
 166 NO_PREFIX = "no_"
 167 UN_PREFIX = "-"
 168
 169
 170 class _Argument:
 171   def __init__(self, min=0, max=None):
 172     self.min = min
 173     self.max = max
 174
 175   def __repr__(self):
 176     return ("<%s min=%s max=%s>" %
 177             (self.__class__.__name__, self.min, self.max))
 178
 179
 180 class ArgSuggest(_Argument):
 181   """Suggesting argument.
 182
 183   Value can be any of the ones passed to the constructor.
 184
 185   """
 186   def __init__(self, min=0, max=None, choices=None):
 187     _Argument.__init__(self, min=min, max=max)
 188     self.choices = choices
 189
 190   def __repr__(self):
 191     return ("<%s min=%s max=%s choices=%r>" %
 192             (self.__class__.__name__, self.min, self.max, self.choices))
 193
 194
 195 class ArgChoice(ArgSuggest):
 196   """Choice argument.
 197
 198   Value can be any of the ones passed to the constructor. Like L{ArgSuggest},
 199   but value must be one of the choices.
 200
 201   """
 202
 203
 204 class ArgUnknown(_Argument):
 205   """Unknown argument to program (e.g. determined at runtime).
 206
 207   """
 208
 209
 210 class ArgInstance(_Argument):
 211   """Instances argument.
 212
 213   """
 214
 215
 216 class ArgNode(_Argument):
 217   """Node argument.
 218
 219   """
 220
 221 class ArgJobId(_Argument):
 222   """Job ID argument.
 223
 224   """
 225
 226
 227 class ArgFile(_Argument):
 228   """File path argument.
 229
 230   """
 231
 232
 233 class ArgCommand(_Argument):
 234   """Command argument.
 235
 236   """
 237
 238
 239 class ArgHost(_Argument):
 240   """Host argument.
 241
 242   """
 243
 244
 245 ARGS_NONE = []
 246 ARGS_MANY_INSTANCES = [ArgInstance()]
 247 ARGS_MANY_NODES = [ArgNode()]
 248 ARGS_ONE_INSTANCE = [ArgInstance(min=1, max=1)]
 249 ARGS_ONE_NODE = [ArgNode(min=1, max=1)]
 250
 251
 252
 253 def _ExtractTagsObject(opts, args):
 254   """Extract the tag type object.
 255
 256   Note that this function will modify its args parameter.
 257
 258   """
 259   if not hasattr(opts, "tag_type"):
 260     raise errors.ProgrammerError("tag_type not passed to _ExtractTagsObject")
 261   kind = opts.tag_type
 262   if kind == constants.TAG_CLUSTER:
 263     retval = kind, kind
 264   elif kind == constants.TAG_NODE or kind == constants.TAG_INSTANCE:
 265     if not args:
 266       raise errors.OpPrereqError("no arguments passed to the command")
 267     name = args.pop(0)
 268     retval = kind, name
 269   else:
 270     raise errors.ProgrammerError("Unhandled tag type '%s'" % kind)
 271   return retval
 272
 273
 274 def _ExtendTags(opts, args):
 275   """Extend the args if a source file has been given.
 276
 277   This function will extend the tags with the contents of the file
 278   passed in the 'tags_source' attribute of the opts parameter. A file
 279   named '-' will be replaced by stdin.
 280
 281   """
 282   fname = opts.tags_source
 283   if fname is None:
 284     return
 285   if fname == "-":
 286     new_fh = sys.stdin
 287   else:
 288     new_fh = open(fname, "r")
 289   new_data = []
 290   try:
 291     # we don't use the nice 'new_data = [line.strip() for line in fh]'
 292     # because of python bug 1633941
 293     while True:
 294       line = new_fh.readline()
 295       if not line:
 296         break
 297       new_data.append(line.strip())
 298   finally:
 299     new_fh.close()
 300   args.extend(new_data)
 301
 302
 303 def ListTags(opts, args):
 304   """List the tags on a given object.
 305
 306   This is a generic implementation that knows how to deal with all
 307   three cases of tag objects (cluster, node, instance). The opts
 308   argument is expected to contain a tag_type field denoting what
 309   object type we work on.
 310
 311   """
 312   kind, name = _ExtractTagsObject(opts, args)
 313   op = opcodes.OpGetTags(kind=kind, name=name)
 314   result = SubmitOpCode(op)
 315   result = list(result)
 316   result.sort()
 317   for tag in result:
 318     ToStdout(tag)
 319
 320
 321 def AddTags(opts, args):
 322   """Add tags on a given object.
 323
 324   This is a generic implementation that knows how to deal with all
 325   three cases of tag objects (cluster, node, instance). The opts
 326   argument is expected to contain a tag_type field denoting what
 327   object type we work on.
 328
 329   """
 330   kind, name = _ExtractTagsObject(opts, args)
 331   _ExtendTags(opts, args)
 332   if not args:
 333     raise errors.OpPrereqError("No tags to be added")
 334   op = opcodes.OpAddTags(kind=kind, name=name, tags=args)
 335   SubmitOpCode(op)
 336
 337
 338 def RemoveTags(opts, args):
 339   """Remove tags from a given object.
 340
 341   This is a generic implementation that knows how to deal with all
 342   three cases of tag objects (cluster, node, instance). The opts
 343   argument is expected to contain a tag_type field denoting what
 344   object type we work on.
 345
 346   """
 347   kind, name = _ExtractTagsObject(opts, args)
 348   _ExtendTags(opts, args)
 349   if not args:
 350     raise errors.OpPrereqError("No tags to be removed")
 351   op = opcodes.OpDelTags(kind=kind, name=name, tags=args)
 352   SubmitOpCode(op)
 353
 354
 355 def check_unit(option, opt, value):
 356   """OptParsers custom converter for units.
 357
 358   """
 359   try:
 360     return utils.ParseUnit(value)
 361   except errors.UnitParseError, err:
 362     raise OptionValueError("option %s: %s" % (opt, err))
 363
 364
 365 def _SplitKeyVal(opt, data):
 366   """Convert a KeyVal string into a dict.
 367
 368   This function will convert a key=val[,...] string into a dict. Empty
 369   values will be converted specially: keys which have the prefix 'no_'
 370   will have the value=False and the prefix stripped, the others will
 371   have value=True.
 372
 373   @type opt: string
 374   @param opt: a string holding the option name for which we process the
 375       data, used in building error messages
 376   @type data: string
 377   @param data: a string of the format key=val,key=val,...
 378   @rtype: dict
 379   @return: {key=val, key=val}
 380   @raises errors.ParameterError: if there are duplicate keys
 381
 382   """
 383   kv_dict = {}
 384   if data:
 385     for elem in data.split(","):
 386       if "=" in elem:
 387         key, val = elem.split("=", 1)
 388       else:
 389         if elem.startswith(NO_PREFIX):
 390           key, val = elem[len(NO_PREFIX):], False
 391         elif elem.startswith(UN_PREFIX):
 392           key, val = elem[len(UN_PREFIX):], None
 393         else:
 394           key, val = elem, True
 395       if key in kv_dict:
 396         raise errors.ParameterError("Duplicate key '%s' in option %s" %
 397                                     (key, opt))
 398       kv_dict[key] = val
 399   return kv_dict
 400
 401
 402 def check_ident_key_val(option, opt, value):
 403   """Custom parser for ident:key=val,key=val options.
 404
 405   This will store the parsed values as a tuple (ident, {key: val}). As such,
 406   multiple uses of this option via action=append is possible.
 407
 408   """
 409   if ":" not in value:
 410     ident, rest = value, ''
 411   else:
 412     ident, rest = value.split(":", 1)
 413
 414   if ident.startswith(NO_PREFIX):
 415     if rest:
 416       msg = "Cannot pass options when removing parameter groups: %s" % value
 417       raise errors.ParameterError(msg)
 418     retval = (ident[len(NO_PREFIX):], False)
 419   elif ident.startswith(UN_PREFIX):
 420     if rest:
 421       msg = "Cannot pass options when removing parameter groups: %s" % value
 422       raise errors.ParameterError(msg)
 423     retval = (ident[len(UN_PREFIX):], None)
 424   else:
 425     kv_dict = _SplitKeyVal(opt, rest)
 426     retval = (ident, kv_dict)
 427   return retval
 428
 429
 430 def check_key_val(option, opt, value):
 431   """Custom parser class for key=val,key=val options.
 432
 433   This will store the parsed values as a dict {key: val}.
 434
 435   """
 436   return _SplitKeyVal(opt, value)
 437
 438
 439 # completion_suggestion is normally a list. Using numeric values not evaluating
 440 # to False for dynamic completion.
 441 (OPT_COMPL_MANY_NODES,
 442  OPT_COMPL_ONE_NODE,
 443  OPT_COMPL_ONE_INSTANCE,
 444  OPT_COMPL_ONE_OS,
 445  OPT_COMPL_ONE_IALLOCATOR,
 446  OPT_COMPL_INST_ADD_NODES) = range(100, 106)
 447
 448 OPT_COMPL_ALL = frozenset([
 449   OPT_COMPL_MANY_NODES,
 450   OPT_COMPL_ONE_NODE,
 451   OPT_COMPL_ONE_INSTANCE,
 452   OPT_COMPL_ONE_OS,
 453   OPT_COMPL_ONE_IALLOCATOR,
 454   OPT_COMPL_INST_ADD_NODES,
 455   ])
 456
 457
 458 class CliOption(Option):
 459   """Custom option class for optparse.
 460
 461   """
 462   ATTRS = Option.ATTRS + [
 463     "completion_suggest",
 464     ]
 465   TYPES = Option.TYPES + (
 466     "identkeyval",
 467     "keyval",
 468     "unit",
 469     )
 470   TYPE_CHECKER = Option.TYPE_CHECKER.copy()
 471   TYPE_CHECKER["identkeyval"] = check_ident_key_val
 472   TYPE_CHECKER["keyval"] = check_key_val
 473   TYPE_CHECKER["unit"] = check_unit
 474
 475
 476 # optparse.py sets make_option, so we do it for our own option class, too
 477 cli_option = CliOption
 478
 479
 480 _YESNO = ("yes", "no")
 481 _YORNO = "yes|no"
 482
 483 DEBUG_OPT = cli_option("-d", "--debug", default=False,
 484                        action="store_true",
 485                        help="Turn debugging on")
 486
 487 NOHDR_OPT = cli_option("--no-headers", default=False,
 488                        action="store_true", dest="no_headers",
 489                        help="Don't display column headers")
 490
 491 SEP_OPT = cli_option("--separator", default=None,
 492                      action="store", dest="separator",
 493                      help=("Separator between output fields"
 494                            " (defaults to one space)"))
 495
 496 USEUNITS_OPT = cli_option("--units", default=None,
 497                           dest="units", choices=('h', 'm', 'g', 't'),
 498                           help="Specify units for output (one of hmgt)")
 499
 500 FIELDS_OPT = cli_option("-o", "--output", dest="output", action="store",
 501                         type="string", metavar="FIELDS",
 502                         help="Comma separated list of output fields")
 503
 504 FORCE_OPT = cli_option("-f", "--force", dest="force", action="store_true",
 505                        default=False, help="Force the operation")
 506
 507 CONFIRM_OPT = cli_option("--yes", dest="confirm", action="store_true",
 508                          default=False, help="Do not require confirmation")
 509
 510 TAG_SRC_OPT = cli_option("--from", dest="tags_source",
 511                          default=None, help="File with tag names")
 512
 513 SUBMIT_OPT = cli_option("--submit", dest="submit_only",
 514                         default=False, action="store_true",
 515                         help=("Submit the job and return the job ID, but"
 516                               " don't wait for the job to finish"))
 517
 518 SYNC_OPT = cli_option("--sync", dest="do_locking",
 519                       default=False, action="store_true",
 520                       help=("Grab locks while doing the queries"
 521                             " in order to ensure more consistent results"))
 522
 523 _DRY_RUN_OPT = cli_option("--dry-run", default=False,
 524                           action="store_true",
 525                           help=("Do not execute the operation, just run the"
 526                                 " check steps and verify it it could be"
 527                                 " executed"))
 528
 529 VERBOSE_OPT = cli_option("-v", "--verbose", default=False,
 530                          action="store_true",
 531                          help="Increase the verbosity of the operation")
 532
 533 DEBUG_SIMERR_OPT = cli_option("--debug-simulate-errors", default=False,
 534                               action="store_true", dest="simulate_errors",
 535                               help="Debugging option that makes the operation"
 536                               " treat most runtime checks as failed")
 537
 538 NWSYNC_OPT = cli_option("--no-wait-for-sync", dest="wait_for_sync",
 539                         default=True, action="store_false",
 540                         help="Don't wait for sync (DANGEROUS!)")
 541
 542 DISK_TEMPLATE_OPT = cli_option("-t", "--disk-template", dest="disk_template",
 543                                help="Custom disk setup (diskless, file,"
 544                                " plain or drbd)",
 545                                default=None, metavar="TEMPL",
 546                                choices=list(constants.DISK_TEMPLATES))
 547
 548 NONICS_OPT = cli_option("--no-nics", default=False, action="store_true",
 549                         help="Do not create any network cards for"
 550                         " the instance")
 551
 552 FILESTORE_DIR_OPT = cli_option("--file-storage-dir", dest="file_storage_dir",
 553                                help="Relative path under default cluster-wide"
 554                                " file storage dir to store file-based disks",
 555                                default=None, metavar="<DIR>")
 556
 557 FILESTORE_DRIVER_OPT = cli_option("--file-driver", dest="file_driver",
 558                                   help="Driver to use for image files",
 559                                   default="loop", metavar="<DRIVER>",
 560                                   choices=list(constants.FILE_DRIVER))
 561
 562 IALLOCATOR_OPT = cli_option("-I", "--iallocator", metavar="<NAME>",
 563                             help="Select nodes for the instance automatically"
 564                             " using the <NAME> iallocator plugin",
 565                             default=None, type="string",
 566                             completion_suggest=OPT_COMPL_ONE_IALLOCATOR)
 567
 568 OS_OPT = cli_option("-o", "--os-type", dest="os", help="What OS to run",
 569                     metavar="<os>",
 570                     completion_suggest=OPT_COMPL_ONE_OS)
 571
 572 FORCE_VARIANT_OPT = cli_option("--force-variant", dest="force_variant",
 573                                action="store_true", default=False,
 574                                help="Force an unknown variant")
 575
 576 BACKEND_OPT = cli_option("-B", "--backend-parameters", dest="beparams",
 577                          type="keyval", default={},
 578                          help="Backend parameters")
 579
 580 HVOPTS_OPT =  cli_option("-H", "--hypervisor-parameters", type="keyval",
 581                          default={}, dest="hvparams",
 582                          help="Hypervisor parameters")
 583
 584 HYPERVISOR_OPT = cli_option("-H", "--hypervisor-parameters", dest="hypervisor",
 585                             help="Hypervisor and hypervisor options, in the"
 586                             " format hypervisor:option=value,option=value,...",
 587                             default=None, type="identkeyval")
 588
 589 HVLIST_OPT = cli_option("-H", "--hypervisor-parameters", dest="hvparams",
 590                         help="Hypervisor and hypervisor options, in the"
 591                         " format hypervisor:option=value,option=value,...",
 592                         default=[], action="append", type="identkeyval")
 593
 594 NOIPCHECK_OPT = cli_option("--no-ip-check", dest="ip_check", default=True,
 595                            action="store_false",
 596                            help="Don't check that the instance's IP"
 597                            " is alive")
 598
 599 NET_OPT = cli_option("--net",
 600                      help="NIC parameters", default=[],
 601                      dest="nics", action="append", type="identkeyval")
 602
 603 DISK_OPT = cli_option("--disk", help="Disk parameters", default=[],
 604                       dest="disks", action="append", type="identkeyval")
 605
 606 DISKIDX_OPT = cli_option("--disks", dest="disks", default=None,
 607                          help="Comma-separated list of disks"
 608                          " indices to act on (e.g. 0,2) (optional,"
 609                          " defaults to all disks)")
 610
 611 OS_SIZE_OPT = cli_option("-s", "--os-size", dest="sd_size",
 612                          help="Enforces a single-disk configuration using the"
 613                          " given disk size, in MiB unless a suffix is used",
 614                          default=None, type="unit", metavar="<size>")
 615
 616 IGNORE_CONSIST_OPT = cli_option("--ignore-consistency",
 617                                 dest="ignore_consistency",
 618                                 action="store_true", default=False,
 619                                 help="Ignore the consistency of the disks on"
 620                                 " the secondary")
 621
 622 NONLIVE_OPT = cli_option("--non-live", dest="live",
 623                          default=True, action="store_false",
 624                          help="Do a non-live migration (this usually means"
 625                          " freeze the instance, save the state, transfer and"
 626                          " only then resume running on the secondary node)")
 627
 628 NODE_PLACEMENT_OPT = cli_option("-n", "--node", dest="node",
 629                                 help="Target node and optional secondary node",
 630                                 metavar="<pnode>[:<snode>]",
 631                                 completion_suggest=OPT_COMPL_INST_ADD_NODES)
 632
 633 NODE_LIST_OPT = cli_option("-n", "--node", dest="nodes", default=[],
 634                            action="append", metavar="<node>",
 635                            help="Use only this node (can be used multiple"
 636                            " times, if not given defaults to all nodes)",
 637                            completion_suggest=OPT_COMPL_ONE_NODE)
 638
 639 SINGLE_NODE_OPT = cli_option("-n", "--node", dest="node", help="Target node",
 640                              metavar="<node>",
 641                              completion_suggest=OPT_COMPL_ONE_NODE)
 642
 643 NOSTART_OPT = cli_option("--no-start", dest="start", default=True,
 644                          action="store_false",
 645                          help="Don't start the instance after creation")
 646
 647 SHOWCMD_OPT = cli_option("--show-cmd", dest="show_command",
 648                          action="store_true", default=False,
 649                          help="Show command instead of executing it")
 650
 651 CLEANUP_OPT = cli_option("--cleanup", dest="cleanup",
 652                          default=False, action="store_true",
 653                          help="Instead of performing the migration, try to"
 654                          " recover from a failed cleanup. This is safe"
 655                          " to run even if the instance is healthy, but it"
 656                          " will create extra replication traffic and "
 657                          " disrupt briefly the replication (like during the"
 658                          " migration")
 659
 660 STATIC_OPT = cli_option("-s", "--static", dest="static",
 661                         action="store_true", default=False,
 662                         help="Only show configuration data, not runtime data")
 663
 664 ALL_OPT = cli_option("--all", dest="show_all",
 665                      default=False, action="store_true",
 666                      help="Show info on all instances on the cluster."
 667                      " This can take a long time to run, use wisely")
 668
 669 SELECT_OS_OPT = cli_option("--select-os", dest="select_os",
 670                            action="store_true", default=False,
 671                            help="Interactive OS reinstall, lists available"
 672                            " OS templates for selection")
 673
 674 IGNORE_FAILURES_OPT = cli_option("--ignore-failures", dest="ignore_failures",
 675                                  action="store_true", default=False,
 676                                  help="Remove the instance from the cluster"
 677                                  " configuration even if there are failures"
 678                                  " during the removal process")
 679
 680 NEW_SECONDARY_OPT = cli_option("-n", "--new-secondary", dest="dst_node",
 681                                help="Specifies the new secondary node",
 682                                metavar="NODE", default=None,
 683                                completion_suggest=OPT_COMPL_ONE_NODE)
 684
 685 ON_PRIMARY_OPT = cli_option("-p", "--on-primary", dest="on_primary",
 686                             default=False, action="store_true",
 687                             help="Replace the disk(s) on the primary"
 688                             " node (only for the drbd template)")
 689
 690 ON_SECONDARY_OPT = cli_option("-s", "--on-secondary", dest="on_secondary",
 691                               default=False, action="store_true",
 692                               help="Replace the disk(s) on the secondary"
 693                               " node (only for the drbd template)")
 694
 695 AUTO_REPLACE_OPT = cli_option("-a", "--auto", dest="auto",
 696                               default=False, action="store_true",
 697                               help="Automatically replace faulty disks"
 698                               " (only for the drbd template)")
 699
 700 IGNORE_SIZE_OPT = cli_option("--ignore-size", dest="ignore_size",
 701                              default=False, action="store_true",
 702                              help="Ignore current recorded size"
 703                              " (useful for forcing activation when"
 704                              " the recorded size is wrong)")
 705
 706 SRC_NODE_OPT = cli_option("--src-node", dest="src_node", help="Source node",
 707                           metavar="<node>",
 708                           completion_suggest=OPT_COMPL_ONE_NODE)
 709
 710 SRC_DIR_OPT = cli_option("--src-dir", dest="src_dir", help="Source directory",
 711                          metavar="<dir>")
 712
 713 SECONDARY_IP_OPT = cli_option("-s", "--secondary-ip", dest="secondary_ip",
 714                               help="Specify the secondary ip for the node",
 715                               metavar="ADDRESS", default=None)
 716
 717 READD_OPT = cli_option("--readd", dest="readd",
 718                        default=False, action="store_true",
 719                        help="Readd old node after replacing it")
 720
 721 NOSSH_KEYCHECK_OPT = cli_option("--no-ssh-key-check", dest="ssh_key_check",
 722                                 default=True, action="store_false",
 723                                 help="Disable SSH key fingerprint checking")
 724
 725
 726 MC_OPT = cli_option("-C", "--master-candidate", dest="master_candidate",
 727                     choices=_YESNO, default=None, metavar=_YORNO,
 728                     help="Set the master_candidate flag on the node")
 729
 730 OFFLINE_OPT = cli_option("-O", "--offline", dest="offline", metavar=_YORNO,
 731                          choices=_YESNO, default=None,
 732                          help="Set the offline flag on the node")
 733
 734 DRAINED_OPT = cli_option("-D", "--drained", dest="drained", metavar=_YORNO,
 735                          choices=_YESNO, default=None,
 736                          help="Set the drained flag on the node")
 737
 738 ALLOCATABLE_OPT = cli_option("--allocatable", dest="allocatable",
 739                              choices=_YESNO, default=None, metavar=_YORNO,
 740                              help="Set the allocatable flag on a volume")
 741
 742 NOLVM_STORAGE_OPT = cli_option("--no-lvm-storage", dest="lvm_storage",
 743                                help="Disable support for lvm based instances"
 744                                " (cluster-wide)",
 745                                action="store_false", default=True)
 746
 747 ENABLED_HV_OPT = cli_option("--enabled-hypervisors",
 748                             dest="enabled_hypervisors",
 749                             help="Comma-separated list of hypervisors",
 750                             type="string", default=None)
 751
 752 NIC_PARAMS_OPT = cli_option("-N", "--nic-parameters", dest="nicparams",
 753                             type="keyval", default={},
 754                             help="NIC parameters")
 755
 756 CP_SIZE_OPT = cli_option("-C", "--candidate-pool-size", default=None,
 757                          dest="candidate_pool_size", type="int",
 758                          help="Set the candidate pool size")
 759
 760 VG_NAME_OPT = cli_option("-g", "--vg-name", dest="vg_name",
 761                          help="Enables LVM and specifies the volume group"
 762                          " name (cluster-wide) for disk allocation [xenvg]",
 763                          metavar="VG", default=None)
 764
 765 YES_DOIT_OPT = cli_option("--yes-do-it", dest="yes_do_it",
 766                           help="Destroy cluster", action="store_true")
 767
 768 NOVOTING_OPT = cli_option("--no-voting", dest="no_voting",
 769                           help="Skip node agreement check (dangerous)",
 770                           action="store_true", default=False)
 771
 772 MAC_PREFIX_OPT = cli_option("-m", "--mac-prefix", dest="mac_prefix",
 773                             help="Specify the mac prefix for the instance IP"
 774                             " addresses, in the format XX:XX:XX",
 775                             metavar="PREFIX",
 776                             default=None)
 777
 778 MASTER_NETDEV_OPT = cli_option("--master-netdev", dest="master_netdev",
 779                                help="Specify the node interface (cluster-wide)"
 780                                " on which the master IP address will be added "
 781                                " [%s]" % constants.DEFAULT_BRIDGE,
 782                                metavar="NETDEV",
 783                                default=constants.DEFAULT_BRIDGE)
 784
 785
 786 GLOBAL_FILEDIR_OPT = cli_option("--file-storage-dir", dest="file_storage_dir",
 787                                 help="Specify the default directory (cluster-"
 788                                 "wide) for storing the file-based disks [%s]" %
 789                                 constants.DEFAULT_FILE_STORAGE_DIR,
 790                                 metavar="DIR",
 791                                 default=constants.DEFAULT_FILE_STORAGE_DIR)
 792
 793 NOMODIFY_ETCHOSTS_OPT = cli_option("--no-etc-hosts", dest="modify_etc_hosts",
 794                                    help="Don't modify /etc/hosts",
 795                                    action="store_false", default=True)
 796
 797 ERROR_CODES_OPT = cli_option("--error-codes", dest="error_codes",
 798                              help="Enable parseable error messages",
 799                              action="store_true", default=False)
 800
 801 NONPLUS1_OPT = cli_option("--no-nplus1-mem", dest="skip_nplusone_mem",
 802                           help="Skip N+1 memory redundancy tests",
 803                           action="store_true", default=False)
 804
 805 REBOOT_TYPE_OPT = cli_option("-t", "--type", dest="reboot_type",
 806                              help="Type of reboot: soft/hard/full",
 807                              default=constants.INSTANCE_REBOOT_HARD,
 808                              metavar="<REBOOT>",
 809                              choices=list(constants.REBOOT_TYPES))
 810
 811 IGNORE_SECONDARIES_OPT = cli_option("--ignore-secondaries",
 812                                     dest="ignore_secondaries",
 813                                     default=False, action="store_true",
 814                                     help="Ignore errors from secondaries")
 815
 816 NOSHUTDOWN_OPT = cli_option("","--noshutdown", dest="shutdown",
 817                             action="store_false", default=True,
 818                             help="Don't shutdown the instance (unsafe)")
 819
 820 TIMEOUT_OPT = cli_option("--timeout", dest="timeout", type="int",
 821                          default=constants.DEFAULT_SHUTDOWN_TIMEOUT,
 822                          help="Maximum time to wait")
 823
 824
 825 def _ParseArgs(argv, commands, aliases):
 826   """Parser for the command line arguments.
 827
 828   This function parses the arguments and returns the function which
 829   must be executed together with its (modified) arguments.
 830
 831   @param argv: the command line
 832   @param commands: dictionary with special contents, see the design
 833       doc for cmdline handling
 834   @param aliases: dictionary with command aliases {'alias': 'target, ...}
 835
 836   """
 837   if len(argv) == 0:
 838     binary = "<command>"
 839   else:
 840     binary = argv[0].split("/")[-1]
 841
 842   if len(argv) > 1 and argv[1] == "--version":
 843     ToStdout("%s (ganeti) %s", binary, constants.RELEASE_VERSION)
 844     # Quit right away. That way we don't have to care about this special
 845     # argument. optparse.py does it the same.
 846     sys.exit(0)
 847
 848   if len(argv) < 2 or not (argv[1] in commands or
 849                            argv[1] in aliases):
 850     # let's do a nice thing
 851     sortedcmds = commands.keys()
 852     sortedcmds.sort()
 853
 854     ToStdout("Usage: %s {command} [options...] [argument...]", binary)
 855     ToStdout("%s <command> --help to see details, or man %s", binary, binary)
 856     ToStdout("")
 857
 858     # compute the max line length for cmd + usage
 859     mlen = max([len(" %s" % cmd) for cmd in commands])
 860     mlen = min(60, mlen) # should not get here...
 861
 862     # and format a nice command list
 863     ToStdout("Commands:")
 864     for cmd in sortedcmds:
 865       cmdstr = " %s" % (cmd,)
 866       help_text = commands[cmd][4]
 867       help_lines = textwrap.wrap(help_text, 79 - 3 - mlen)
 868       ToStdout("%-*s - %s", mlen, cmdstr, help_lines.pop(0))
 869       for line in help_lines:
 870         ToStdout("%-*s   %s", mlen, "", line)
 871
 872     ToStdout("")
 873
 874     return None, None, None
 875
 876   # get command, unalias it, and look it up in commands
 877   cmd = argv.pop(1)
 878   if cmd in aliases:
 879     if cmd in commands:
 880       raise errors.ProgrammerError("Alias '%s' overrides an existing"
 881                                    " command" % cmd)
 882
 883     if aliases[cmd] not in commands:
 884       raise errors.ProgrammerError("Alias '%s' maps to non-existing"
 885                                    " command '%s'" % (cmd, aliases[cmd]))
 886
 887     cmd = aliases[cmd]
 888
 889   func, args_def, parser_opts, usage, description = commands[cmd]
 890   parser = OptionParser(option_list=parser_opts + [_DRY_RUN_OPT, DEBUG_OPT],
 891                         description=description,
 892                         formatter=TitledHelpFormatter(),
 893                         usage="%%prog %s %s" % (cmd, usage))
 894   parser.disable_interspersed_args()
 895   options, args = parser.parse_args()
 896
 897   if not _CheckArguments(cmd, args_def, args):
 898     return None, None, None
 899
 900   return func, options, args
 901
 902
 903 def _CheckArguments(cmd, args_def, args):
 904   """Verifies the arguments using the argument definition.
 905
 906   Algorithm:
 907
 908     1. Abort with error if values specified by user but none expected.
 909
 910     1. For each argument in definition
 911
 912       1. Keep running count of minimum number of values (min_count)
 913       1. Keep running count of maximum number of values (max_count)
 914       1. If it has an unlimited number of values
 915
 916         1. Abort with error if it's not the last argument in the definition
 917
 918     1. If last argument has limited number of values
 919
 920       1. Abort with error if number of values doesn't match or is too large
 921
 922     1. Abort with error if user didn't pass enough values (min_count)
 923
 924   """
 925   if args and not args_def:
 926     ToStderr("Error: Command %s expects no arguments", cmd)
 927     return False
 928
 929   min_count = None
 930   max_count = None
 931   check_max = None
 932
 933   last_idx = len(args_def) - 1
 934
 935   for idx, arg in enumerate(args_def):
 936     if min_count is None:
 937       min_count = arg.min
 938     elif arg.min is not None:
 939       min_count += arg.min
 940
 941     if max_count is None:
 942       max_count = arg.max
 943     elif arg.max is not None:
 944       max_count += arg.max
 945
 946     if idx == last_idx:
 947       check_max = (arg.max is not None)
 948
 949     elif arg.max is None:
 950       raise errors.ProgrammerError("Only the last argument can have max=None")
 951
 952   if check_max:
 953     # Command with exact number of arguments
 954     if (min_count is not None and max_count is not None and
 955         min_count == max_count and len(args) != min_count):
 956       ToStderr("Error: Command %s expects %d argument(s)", cmd, min_count)
 957       return False
 958
 959     # Command with limited number of arguments
 960     if max_count is not None and len(args) > max_count:
 961       ToStderr("Error: Command %s expects only %d argument(s)",
 962                cmd, max_count)
 963       return False
 964
 965   # Command with some required arguments
 966   if min_count is not None and len(args) < min_count:
 967     ToStderr("Error: Command %s expects at least %d argument(s)",
 968              cmd, min_count)
 969     return False
 970
 971   return True
 972
 973
 974 def SplitNodeOption(value):
 975   """Splits the value of a --node option.
 976
 977   """
 978   if value and ':' in value:
 979     return value.split(':', 1)
 980   else:
 981     return (value, None)
 982
 983
 984 def CalculateOSNames(os_name, os_variants):
 985   """Calculates all the names an OS can be called, according to its variants.
 986
 987   @type os_name: string
 988   @param os_name: base name of the os
 989   @type os_variants: list or None
 990   @param os_variants: list of supported variants
 991   @rtype: list
 992   @return: list of valid names
 993
 994   """
 995   if os_variants:
 996     return ['%s+%s' % (os_name, v) for v in os_variants]
 997   else:
 998     return [os_name]
 999
1000
1001 def UsesRPC(fn):
1002   def wrapper(*args, **kwargs):
1003     rpc.Init()
1004     try:
1005       return fn(*args, **kwargs)
1006     finally:
1007       rpc.Shutdown()
1008   return wrapper
1009
1010
1011 def AskUser(text, choices=None):
1012   """Ask the user a question.
1013
1014   @param text: the question to ask
1015
1016   @param choices: list with elements tuples (input_char, return_value,
1017       description); if not given, it will default to: [('y', True,
1018       'Perform the operation'), ('n', False, 'Do no do the operation')];
1019       note that the '?' char is reserved for help
1020
1021   @return: one of the return values from the choices list; if input is
1022       not possible (i.e. not running with a tty, we return the last
1023       entry from the list
1024
1025   """
1026   if choices is None:
1027     choices = [('y', True, 'Perform the operation'),
1028                ('n', False, 'Do not perform the operation')]
1029   if not choices or not isinstance(choices, list):
1030     raise errors.ProgrammerError("Invalid choices argument to AskUser")
1031   for entry in choices:
1032     if not isinstance(entry, tuple) or len(entry) < 3 or entry[0] == '?':
1033       raise errors.ProgrammerError("Invalid choices element to AskUser")
1034
1035   answer = choices[-1][1]
1036   new_text = []
1037   for line in text.splitlines():
1038     new_text.append(textwrap.fill(line, 70, replace_whitespace=False))
1039   text = "\n".join(new_text)
1040   try:
1041     f = file("/dev/tty", "a+")
1042   except IOError:
1043     return answer
1044   try:
1045     chars = [entry[0] for entry in choices]
1046     chars[-1] = "[%s]" % chars[-1]
1047     chars.append('?')
1048     maps = dict([(entry[0], entry[1]) for entry in choices])
1049     while True:
1050       f.write(text)
1051       f.write('\n')
1052       f.write("/".join(chars))
1053       f.write(": ")
1054       line = f.readline(2).strip().lower()
1055       if line in maps:
1056         answer = maps[line]
1057         break
1058       elif line == '?':
1059         for entry in choices:
1060           f.write(" %s - %s\n" % (entry[0], entry[2]))
1061         f.write("\n")
1062         continue
1063   finally:
1064     f.close()
1065   return answer
1066
1067
1068 class JobSubmittedException(Exception):
1069   """Job was submitted, client should exit.
1070
1071   This exception has one argument, the ID of the job that was
1072   submitted. The handler should print this ID.
1073
1074   This is not an error, just a structured way to exit from clients.
1075
1076   """
1077
1078
1079 def SendJob(ops, cl=None):
1080   """Function to submit an opcode without waiting for the results.
1081
1082   @type ops: list
1083   @param ops: list of opcodes
1084   @type cl: luxi.Client
1085   @param cl: the luxi client to use for communicating with the master;
1086              if None, a new client will be created
1087
1088   """
1089   if cl is None:
1090     cl = GetClient()
1091
1092   job_id = cl.SubmitJob(ops)
1093
1094   return job_id
1095
1096
1097 def PollJob(job_id, cl=None, feedback_fn=None):
1098   """Function to poll for the result of a job.
1099
1100   @type job_id: job identified
1101   @param job_id: the job to poll for results
1102   @type cl: luxi.Client
1103   @param cl: the luxi client to use for communicating with the master;
1104              if None, a new client will be created
1105
1106   """
1107   if cl is None:
1108     cl = GetClient()
1109
1110   prev_job_info = None
1111   prev_logmsg_serial = None
1112
1113   while True:
1114     result = cl.WaitForJobChange(job_id, ["status"], prev_job_info,
1115                                  prev_logmsg_serial)
1116     if not result:
1117       # job not found, go away!
1118       raise errors.JobLost("Job with id %s lost" % job_id)
1119
1120     # Split result, a tuple of (field values, log entries)
1121     (job_info, log_entries) = result
1122     (status, ) = job_info
1123
1124     if log_entries:
1125       for log_entry in log_entries:
1126         (serial, timestamp, _, message) = log_entry
1127         if callable(feedback_fn):
1128           feedback_fn(log_entry[1:])
1129         else:
1130           encoded = utils.SafeEncode(message)
1131           ToStdout("%s %s", time.ctime(utils.MergeTime(timestamp)), encoded)
1132         prev_logmsg_serial = max(prev_logmsg_serial, serial)
1133
1134     # TODO: Handle canceled and archived jobs
1135     elif status in (constants.JOB_STATUS_SUCCESS,
1136                     constants.JOB_STATUS_ERROR,
1137                     constants.JOB_STATUS_CANCELING,
1138                     constants.JOB_STATUS_CANCELED):
1139       break
1140
1141     prev_job_info = job_info
1142
1143   jobs = cl.QueryJobs([job_id], ["status", "opstatus", "opresult"])
1144   if not jobs:
1145     raise errors.JobLost("Job with id %s lost" % job_id)
1146
1147   status, opstatus, result = jobs[0]
1148   if status == constants.JOB_STATUS_SUCCESS:
1149     return result
1150   elif status in (constants.JOB_STATUS_CANCELING,
1151                   constants.JOB_STATUS_CANCELED):
1152     raise errors.OpExecError("Job was canceled")
1153   else:
1154     has_ok = False
1155     for idx, (status, msg) in enumerate(zip(opstatus, result)):
1156       if status == constants.OP_STATUS_SUCCESS:
1157         has_ok = True
1158       elif status == constants.OP_STATUS_ERROR:
1159         errors.MaybeRaise(msg)
1160         if has_ok:
1161           raise errors.OpExecError("partial failure (opcode %d): %s" %
1162                                    (idx, msg))
1163         else:
1164           raise errors.OpExecError(str(msg))
1165     # default failure mode
1166     raise errors.OpExecError(result)
1167
1168
1169 def SubmitOpCode(op, cl=None, feedback_fn=None):
1170   """Legacy function to submit an opcode.
1171
1172   This is just a simple wrapper over the construction of the processor
1173   instance. It should be extended to better handle feedback and
1174   interaction functions.
1175
1176   """
1177   if cl is None:
1178     cl = GetClient()
1179
1180   job_id = SendJob([op], cl)
1181
1182   op_results = PollJob(job_id, cl=cl, feedback_fn=feedback_fn)
1183
1184   return op_results[0]
1185
1186
1187 def SubmitOrSend(op, opts, cl=None, feedback_fn=None):
1188   """Wrapper around SubmitOpCode or SendJob.
1189
1190   This function will decide, based on the 'opts' parameter, whether to
1191   submit and wait for the result of the opcode (and return it), or
1192   whether to just send the job and print its identifier. It is used in
1193   order to simplify the implementation of the '--submit' option.
1194
1195   It will also add the dry-run parameter from the options passed, if true.
1196
1197   """
1198   if opts and opts.dry_run:
1199     op.dry_run = opts.dry_run
1200   if opts and opts.submit_only:
1201     job_id = SendJob([op], cl=cl)
1202     raise JobSubmittedException(job_id)
1203   else:
1204     return SubmitOpCode(op, cl=cl, feedback_fn=feedback_fn)
1205
1206
1207 def GetClient():
1208   # TODO: Cache object?
1209   try:
1210     client = luxi.Client()
1211   except luxi.NoMasterError:
1212     master, myself = ssconf.GetMasterAndMyself()
1213     if master != myself:
1214       raise errors.OpPrereqError("This is not the master node, please connect"
1215                                  " to node '%s' and rerun the command" %
1216                                  master)
1217     else:
1218       raise
1219   return client
1220
1221
1222 def FormatError(err):
1223   """Return a formatted error message for a given error.
1224
1225   This function takes an exception instance and returns a tuple
1226   consisting of two values: first, the recommended exit code, and
1227   second, a string describing the error message (not
1228   newline-terminated).
1229
1230   """
1231   retcode = 1
1232   obuf = StringIO()
1233   msg = str(err)
1234   if isinstance(err, errors.ConfigurationError):
1235     txt = "Corrupt configuration file: %s" % msg
1236     logging.error(txt)
1237     obuf.write(txt + "\n")
1238     obuf.write("Aborting.")
1239     retcode = 2
1240   elif isinstance(err, errors.HooksAbort):
1241     obuf.write("Failure: hooks execution failed:\n")
1242     for node, script, out in err.args[0]:
1243       if out:
1244         obuf.write("  node: %s, script: %s, output: %s\n" %
1245                    (node, script, out))
1246       else:
1247         obuf.write("  node: %s, script: %s (no output)\n" %
1248                    (node, script))
1249   elif isinstance(err, errors.HooksFailure):
1250     obuf.write("Failure: hooks general failure: %s" % msg)
1251   elif isinstance(err, errors.ResolverError):
1252     this_host = utils.HostInfo.SysName()
1253     if err.args[0] == this_host:
1254       msg = "Failure: can't resolve my own hostname ('%s')"
1255     else:
1256       msg = "Failure: can't resolve hostname '%s'"
1257     obuf.write(msg % err.args[0])
1258   elif isinstance(err, errors.OpPrereqError):
1259     obuf.write("Failure: prerequisites not met for this"
1260                " operation:\n%s" % msg)
1261   elif isinstance(err, errors.OpExecError):
1262     obuf.write("Failure: command execution error:\n%s" % msg)
1263   elif isinstance(err, errors.TagError):
1264     obuf.write("Failure: invalid tag(s) given:\n%s" % msg)
1265   elif isinstance(err, errors.JobQueueDrainError):
1266     obuf.write("Failure: the job queue is marked for drain and doesn't"
1267                " accept new requests\n")
1268   elif isinstance(err, errors.JobQueueFull):
1269     obuf.write("Failure: the job queue is full and doesn't accept new"
1270                " job submissions until old jobs are archived\n")
1271   elif isinstance(err, errors.TypeEnforcementError):
1272     obuf.write("Parameter Error: %s" % msg)
1273   elif isinstance(err, errors.ParameterError):
1274     obuf.write("Failure: unknown/wrong parameter name '%s'" % msg)
1275   elif isinstance(err, errors.GenericError):
1276     obuf.write("Unhandled Ganeti error: %s" % msg)
1277   elif isinstance(err, luxi.NoMasterError):
1278     obuf.write("Cannot communicate with the master daemon.\nIs it running"
1279                " and listening for connections?")
1280   elif isinstance(err, luxi.TimeoutError):
1281     obuf.write("Timeout while talking to the master daemon. Error:\n"
1282                "%s" % msg)
1283   elif isinstance(err, luxi.ProtocolError):
1284     obuf.write("Unhandled protocol error while talking to the master daemon:\n"
1285                "%s" % msg)
1286   elif isinstance(err, JobSubmittedException):
1287     obuf.write("JobID: %s\n" % err.args[0])
1288     retcode = 0
1289   else:
1290     obuf.write("Unhandled exception: %s" % msg)
1291   return retcode, obuf.getvalue().rstrip('\n')
1292
1293
1294 def GenericMain(commands, override=None, aliases=None):
1295   """Generic main function for all the gnt-* commands.
1296
1297   Arguments:
1298     - commands: a dictionary with a special structure, see the design doc
1299                 for command line handling.
1300     - override: if not None, we expect a dictionary with keys that will
1301                 override command line options; this can be used to pass
1302                 options from the scripts to generic functions
1303     - aliases: dictionary with command aliases {'alias': 'target, ...}
1304
1305   """
1306   # save the program name and the entire command line for later logging
1307   if sys.argv:
1308     binary = os.path.basename(sys.argv[0]) or sys.argv[0]
1309     if len(sys.argv) >= 2:
1310       binary += " " + sys.argv[1]
1311       old_cmdline = " ".join(sys.argv[2:])
1312     else:
1313       old_cmdline = ""
1314   else:
1315     binary = "<unknown program>"
1316     old_cmdline = ""
1317
1318   if aliases is None:
1319     aliases = {}
1320
1321   try:
1322     func, options, args = _ParseArgs(sys.argv, commands, aliases)
1323   except errors.ParameterError, err:
1324     result, err_msg = FormatError(err)
1325     ToStderr(err_msg)
1326     return 1
1327
1328   if func is None: # parse error
1329     return 1
1330
1331   if override is not None:
1332     for key, val in override.iteritems():
1333       setattr(options, key, val)
1334
1335   utils.SetupLogging(constants.LOG_COMMANDS, debug=options.debug,
1336                      stderr_logging=True, program=binary)
1337
1338   if old_cmdline:
1339     logging.info("run with arguments '%s'", old_cmdline)
1340   else:
1341     logging.info("run with no arguments")
1342
1343   try:
1344     result = func(options, args)
1345   except (errors.GenericError, luxi.ProtocolError,
1346           JobSubmittedException), err:
1347     result, err_msg = FormatError(err)
1348     logging.exception("Error during command processing")
1349     ToStderr(err_msg)
1350
1351   return result
1352
1353
1354 def GenericInstanceCreate(mode, opts, args):
1355   """Add an instance to the cluster via either creation or import.
1356
1357   @param mode: constants.INSTANCE_CREATE or constants.INSTANCE_IMPORT
1358   @param opts: the command line options selected by the user
1359   @type args: list
1360   @param args: should contain only one element, the new instance name
1361   @rtype: int
1362   @return: the desired exit code
1363
1364   """
1365   instance = args[0]
1366
1367   (pnode, snode) = SplitNodeOption(opts.node)
1368
1369   hypervisor = None
1370   hvparams = {}
1371   if opts.hypervisor:
1372     hypervisor, hvparams = opts.hypervisor
1373
1374   if opts.nics:
1375     try:
1376       nic_max = max(int(nidx[0])+1 for nidx in opts.nics)
1377     except ValueError, err:
1378       raise errors.OpPrereqError("Invalid NIC index passed: %s" % str(err))
1379     nics = [{}] * nic_max
1380     for nidx, ndict in opts.nics:
1381       nidx = int(nidx)
1382       if not isinstance(ndict, dict):
1383         msg = "Invalid nic/%d value: expected dict, got %s" % (nidx, ndict)
1384         raise errors.OpPrereqError(msg)
1385       nics[nidx] = ndict
1386   elif opts.no_nics:
1387     # no nics
1388     nics = []
1389   else:
1390     # default of one nic, all auto
1391     nics = [{}]
1392
1393   if opts.disk_template == constants.DT_DISKLESS:
1394     if opts.disks or opts.sd_size is not None:
1395       raise errors.OpPrereqError("Diskless instance but disk"
1396                                  " information passed")
1397     disks = []
1398   else:
1399     if not opts.disks and not opts.sd_size:
1400       raise errors.OpPrereqError("No disk information specified")
1401     if opts.disks and opts.sd_size is not None:
1402       raise errors.OpPrereqError("Please use either the '--disk' or"
1403                                  " '-s' option")
1404     if opts.sd_size is not None:
1405       opts.disks = [(0, {"size": opts.sd_size})]
1406     try:
1407       disk_max = max(int(didx[0])+1 for didx in opts.disks)
1408     except ValueError, err:
1409       raise errors.OpPrereqError("Invalid disk index passed: %s" % str(err))
1410     disks = [{}] * disk_max
1411     for didx, ddict in opts.disks:
1412       didx = int(didx)
1413       if not isinstance(ddict, dict):
1414         msg = "Invalid disk/%d value: expected dict, got %s" % (didx, ddict)
1415         raise errors.OpPrereqError(msg)
1416       elif "size" not in ddict:
1417         raise errors.OpPrereqError("Missing size for disk %d" % didx)
1418       try:
1419         ddict["size"] = utils.ParseUnit(ddict["size"])
1420       except ValueError, err:
1421         raise errors.OpPrereqError("Invalid disk size for disk %d: %s" %
1422                                    (didx, err))
1423       disks[didx] = ddict
1424
1425   utils.ForceDictType(opts.beparams, constants.BES_PARAMETER_TYPES)
1426   utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES)
1427
1428   if mode == constants.INSTANCE_CREATE:
1429     start = opts.start
1430     os_type = opts.os
1431     src_node = None
1432     src_path = None
1433   elif mode == constants.INSTANCE_IMPORT:
1434     start = False
1435     os_type = None
1436     src_node = opts.src_node
1437     src_path = opts.src_dir
1438   else:
1439     raise errors.ProgrammerError("Invalid creation mode %s" % mode)
1440
1441   op = opcodes.OpCreateInstance(instance_name=instance,
1442                                 disks=disks,
1443                                 disk_template=opts.disk_template,
1444                                 nics=nics,
1445                                 pnode=pnode, snode=snode,
1446                                 ip_check=opts.ip_check,
1447                                 wait_for_sync=opts.wait_for_sync,
1448                                 file_storage_dir=opts.file_storage_dir,
1449                                 file_driver=opts.file_driver,
1450                                 iallocator=opts.iallocator,
1451                                 hypervisor=hypervisor,
1452                                 hvparams=hvparams,
1453                                 beparams=opts.beparams,
1454                                 mode=mode,
1455                                 start=start,
1456                                 os_type=os_type,
1457                                 src_node=src_node,
1458                                 src_path=src_path)
1459
1460   SubmitOrSend(op, opts)
1461   return 0
1462
1463
1464 def GenerateTable(headers, fields, separator, data,
1465                   numfields=None, unitfields=None,
1466                   units=None):
1467   """Prints a table with headers and different fields.
1468
1469   @type headers: dict
1470   @param headers: dictionary mapping field names to headers for
1471       the table
1472   @type fields: list
1473   @param fields: the field names corresponding to each row in
1474       the data field
1475   @param separator: the separator to be used; if this is None,
1476       the default 'smart' algorithm is used which computes optimal
1477       field width, otherwise just the separator is used between
1478       each field
1479   @type data: list
1480   @param data: a list of lists, each sublist being one row to be output
1481   @type numfields: list
1482   @param numfields: a list with the fields that hold numeric
1483       values and thus should be right-aligned
1484   @type unitfields: list
1485   @param unitfields: a list with the fields that hold numeric
1486       values that should be formatted with the units field
1487   @type units: string or None
1488   @param units: the units we should use for formatting, or None for
1489       automatic choice (human-readable for non-separator usage, otherwise
1490       megabytes); this is a one-letter string
1491
1492   """
1493   if units is None:
1494     if separator:
1495       units = "m"
1496     else:
1497       units = "h"
1498
1499   if numfields is None:
1500     numfields = []
1501   if unitfields is None:
1502     unitfields = []
1503
1504   numfields = utils.FieldSet(*numfields)
1505   unitfields = utils.FieldSet(*unitfields)
1506
1507   format_fields = []
1508   for field in fields:
1509     if headers and field not in headers:
1510       # TODO: handle better unknown fields (either revert to old
1511       # style of raising exception, or deal more intelligently with
1512       # variable fields)
1513       headers[field] = field
1514     if separator is not None:
1515       format_fields.append("%s")
1516     elif numfields.Matches(field):
1517       format_fields.append("%*s")
1518     else:
1519       format_fields.append("%-*s")
1520
1521   if separator is None:
1522     mlens = [0 for name in fields]
1523     format = ' '.join(format_fields)
1524   else:
1525     format = separator.replace("%", "%%").join(format_fields)
1526
1527   for row in data:
1528     if row is None:
1529       continue
1530     for idx, val in enumerate(row):
1531       if unitfields.Matches(fields[idx]):
1532         try:
1533           val = int(val)
1534         except ValueError:
1535           pass
1536         else:
1537           val = row[idx] = utils.FormatUnit(val, units)
1538       val = row[idx] = str(val)
1539       if separator is None:
1540         mlens[idx] = max(mlens[idx], len(val))
1541
1542   result = []
1543   if headers:
1544     args = []
1545     for idx, name in enumerate(fields):
1546       hdr = headers[name]
1547       if separator is None:
1548         mlens[idx] = max(mlens[idx], len(hdr))
1549         args.append(mlens[idx])
1550       args.append(hdr)
1551     result.append(format % tuple(args))
1552
1553   for line in data:
1554     args = []
1555     if line is None:
1556       line = ['-' for _ in fields]
1557     for idx in range(len(fields)):
1558       if separator is None:
1559         args.append(mlens[idx])
1560       args.append(line[idx])
1561     result.append(format % tuple(args))
1562
1563   return result
1564
1565
1566 def FormatTimestamp(ts):
1567   """Formats a given timestamp.
1568
1569   @type ts: timestamp
1570   @param ts: a timeval-type timestamp, a tuple of seconds and microseconds
1571
1572   @rtype: string
1573   @return: a string with the formatted timestamp
1574
1575   """
1576   if not isinstance (ts, (tuple, list)) or len(ts) != 2:
1577     return '?'
1578   sec, usec = ts
1579   return time.strftime("%F %T", time.localtime(sec)) + ".%06d" % usec
1580
1581
1582 def ParseTimespec(value):
1583   """Parse a time specification.
1584
1585   The following suffixed will be recognized:
1586
1587     - s: seconds
1588     - m: minutes
1589     - h: hours
1590     - d: day
1591     - w: weeks
1592
1593   Without any suffix, the value will be taken to be in seconds.
1594
1595   """
1596   value = str(value)
1597   if not value:
1598     raise errors.OpPrereqError("Empty time specification passed")
1599   suffix_map = {
1600     's': 1,
1601     'm': 60,
1602     'h': 3600,
1603     'd': 86400,
1604     'w': 604800,
1605     }
1606   if value[-1] not in suffix_map:
1607     try:
1608       value = int(value)
1609     except ValueError:
1610       raise errors.OpPrereqError("Invalid time specification '%s'" % value)
1611   else:
1612     multiplier = suffix_map[value[-1]]
1613     value = value[:-1]
1614     if not value: # no data left after stripping the suffix
1615       raise errors.OpPrereqError("Invalid time specification (only"
1616                                  " suffix passed)")
1617     try:
1618       value = int(value) * multiplier
1619     except ValueError:
1620       raise errors.OpPrereqError("Invalid time specification '%s'" % value)
1621   return value
1622
1623
1624 def GetOnlineNodes(nodes, cl=None, nowarn=False):
1625   """Returns the names of online nodes.
1626
1627   This function will also log a warning on stderr with the names of
1628   the online nodes.
1629
1630   @param nodes: if not empty, use only this subset of nodes (minus the
1631       offline ones)
1632   @param cl: if not None, luxi client to use
1633   @type nowarn: boolean
1634   @param nowarn: by default, this function will output a note with the
1635       offline nodes that are skipped; if this parameter is True the
1636       note is not displayed
1637
1638   """
1639   if cl is None:
1640     cl = GetClient()
1641
1642   result = cl.QueryNodes(names=nodes, fields=["name", "offline"],
1643                          use_locking=False)
1644   offline = [row[0] for row in result if row[1]]
1645   if offline and not nowarn:
1646     ToStderr("Note: skipping offline node(s): %s" % ", ".join(offline))
1647   return [row[0] for row in result if not row[1]]
1648
1649
1650 def _ToStream(stream, txt, *args):
1651   """Write a message to a stream, bypassing the logging system
1652
1653   @type stream: file object
1654   @param stream: the file to which we should write
1655   @type txt: str
1656   @param txt: the message
1657
1658   """
1659   if args:
1660     args = tuple(args)
1661     stream.write(txt % args)
1662   else:
1663     stream.write(txt)
1664   stream.write('\n')
1665   stream.flush()
1666
1667
1668 def ToStdout(txt, *args):
1669   """Write a message to stdout only, bypassing the logging system
1670
1671   This is just a wrapper over _ToStream.
1672
1673   @type txt: str
1674   @param txt: the message
1675
1676   """
1677   _ToStream(sys.stdout, txt, *args)
1678
1679
1680 def ToStderr(txt, *args):
1681   """Write a message to stderr only, bypassing the logging system
1682
1683   This is just a wrapper over _ToStream.
1684
1685   @type txt: str
1686   @param txt: the message
1687
1688   """
1689   _ToStream(sys.stderr, txt, *args)
1690
1691
1692 class JobExecutor(object):
1693   """Class which manages the submission and execution of multiple jobs.
1694
1695   Note that instances of this class should not be reused between
1696   GetResults() calls.
1697
1698   """
1699   def __init__(self, cl=None, verbose=True):
1700     self.queue = []
1701     if cl is None:
1702       cl = GetClient()
1703     self.cl = cl
1704     self.verbose = verbose
1705     self.jobs = []
1706
1707   def QueueJob(self, name, *ops):
1708     """Record a job for later submit.
1709
1710     @type name: string
1711     @param name: a description of the job, will be used in WaitJobSet
1712     """
1713     self.queue.append((name, ops))
1714
1715   def SubmitPending(self):
1716     """Submit all pending jobs.
1717
1718     """
1719     results = self.cl.SubmitManyJobs([row[1] for row in self.queue])
1720     for ((status, data), (name, _)) in zip(results, self.queue):
1721       self.jobs.append((status, data, name))
1722
1723   def GetResults(self):
1724     """Wait for and return the results of all jobs.
1725
1726     @rtype: list
1727     @return: list of tuples (success, job results), in the same order
1728         as the submitted jobs; if a job has failed, instead of the result
1729         there will be the error message
1730
1731     """
1732     if not self.jobs:
1733       self.SubmitPending()
1734     results = []
1735     if self.verbose:
1736       ok_jobs = [row[1] for row in self.jobs if row[0]]
1737       if ok_jobs:
1738         ToStdout("Submitted jobs %s", ", ".join(ok_jobs))
1739     for submit_status, jid, name in self.jobs:
1740       if not submit_status:
1741         ToStderr("Failed to submit job for %s: %s", name, jid)
1742         results.append((False, jid))
1743         continue
1744       if self.verbose:
1745         ToStdout("Waiting for job %s for %s...", jid, name)
1746       try:
1747         job_result = PollJob(jid, cl=self.cl)
1748         success = True
1749       except (errors.GenericError, luxi.ProtocolError), err:
1750         _, job_result = FormatError(err)
1751         success = False
1752         # the error message will always be shown, verbose or not
1753         ToStderr("Job %s for %s has failed: %s", jid, name, job_result)
1754
1755       results.append((success, job_result))
1756     return results
1757
1758   def WaitOrShow(self, wait):
1759     """Wait for job results or only print the job IDs.
1760
1761     @type wait: boolean
1762     @param wait: whether to wait or not
1763
1764     """
1765     if wait:
1766       return self.GetResults()
1767     else:
1768       if not self.jobs:
1769         self.SubmitPending()
1770       for status, result, name in self.jobs:
1771         if status:
1772           ToStdout("%s: %s", result, name)
1773         else:
1774           ToStderr("Failure for %s: %s", name, result)