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

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2010, 2011 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 """Cluster related commands"""
  22
  23 # pylint: disable-msg=W0401,W0613,W0614,C0103
  24 # W0401: Wildcard import ganeti.cli
  25 # W0613: Unused argument, since all functions follow the same API
  26 # W0614: Unused import %s from wildcard import (since we need cli)
  27 # C0103: Invalid name gnt-cluster
  28
  29 import os.path
  30 import time
  31 import OpenSSL
  32 import itertools
  33
  34 from ganeti.cli import *
  35 from ganeti import opcodes
  36 from ganeti import constants
  37 from ganeti import errors
  38 from ganeti import utils
  39 from ganeti import bootstrap
  40 from ganeti import ssh
  41 from ganeti import objects
  42 from ganeti import uidpool
  43 from ganeti import compat
  44 from ganeti import netutils
  45
  46
  47 ON_OPT = cli_option("--on", default=False,
  48                     action="store_true", dest="on",
  49                     help="Recover from an EPO")
  50
  51 GROUPS_OPT = cli_option("--groups", default=False,
  52                     action="store_true", dest="groups",
  53                     help="Arguments are node groups instead of nodes")
  54
  55 _EPO_PING_INTERVAL = 30 # 30 seconds between pings
  56 _EPO_PING_TIMEOUT = 1 # 1 second
  57 _EPO_REACHABLE_TIMEOUT = 15 * 60 # 15 minutes
  58
  59
  60 @UsesRPC
  61 def InitCluster(opts, args):
  62   """Initialize the cluster.
  63
  64   @param opts: the command line options selected by the user
  65   @type args: list
  66   @param args: should contain only one element, the desired
  67       cluster name
  68   @rtype: int
  69   @return: the desired exit code
  70
  71   """
  72   if not opts.lvm_storage and opts.vg_name:
  73     ToStderr("Options --no-lvm-storage and --vg-name conflict.")
  74     return 1
  75
  76   vg_name = opts.vg_name
  77   if opts.lvm_storage and not opts.vg_name:
  78     vg_name = constants.DEFAULT_VG
  79
  80   if not opts.drbd_storage and opts.drbd_helper:
  81     ToStderr("Options --no-drbd-storage and --drbd-usermode-helper conflict.")
  82     return 1
  83
  84   drbd_helper = opts.drbd_helper
  85   if opts.drbd_storage and not opts.drbd_helper:
  86     drbd_helper = constants.DEFAULT_DRBD_HELPER
  87
  88   master_netdev = opts.master_netdev
  89   if master_netdev is None:
  90     master_netdev = constants.DEFAULT_BRIDGE
  91
  92   hvlist = opts.enabled_hypervisors
  93   if hvlist is None:
  94     hvlist = constants.DEFAULT_ENABLED_HYPERVISOR
  95   hvlist = hvlist.split(",")
  96
  97   hvparams = dict(opts.hvparams)
  98   beparams = opts.beparams
  99   nicparams = opts.nicparams
 100
 101   # prepare beparams dict
 102   beparams = objects.FillDict(constants.BEC_DEFAULTS, beparams)
 103   utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
 104
 105   # prepare nicparams dict
 106   nicparams = objects.FillDict(constants.NICC_DEFAULTS, nicparams)
 107   utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
 108
 109   # prepare ndparams dict
 110   if opts.ndparams is None:
 111     ndparams = dict(constants.NDC_DEFAULTS)
 112   else:
 113     ndparams = objects.FillDict(constants.NDC_DEFAULTS, opts.ndparams)
 114     utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
 115
 116   # prepare hvparams dict
 117   for hv in constants.HYPER_TYPES:
 118     if hv not in hvparams:
 119       hvparams[hv] = {}
 120     hvparams[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], hvparams[hv])
 121     utils.ForceDictType(hvparams[hv], constants.HVS_PARAMETER_TYPES)
 122
 123   if opts.candidate_pool_size is None:
 124     opts.candidate_pool_size = constants.MASTER_POOL_SIZE_DEFAULT
 125
 126   if opts.mac_prefix is None:
 127     opts.mac_prefix = constants.DEFAULT_MAC_PREFIX
 128
 129   uid_pool = opts.uid_pool
 130   if uid_pool is not None:
 131     uid_pool = uidpool.ParseUidPool(uid_pool)
 132
 133   if opts.prealloc_wipe_disks is None:
 134     opts.prealloc_wipe_disks = False
 135
 136   try:
 137     primary_ip_version = int(opts.primary_ip_version)
 138   except (ValueError, TypeError), err:
 139     ToStderr("Invalid primary ip version value: %s" % str(err))
 140     return 1
 141
 142   bootstrap.InitCluster(cluster_name=args[0],
 143                         secondary_ip=opts.secondary_ip,
 144                         vg_name=vg_name,
 145                         mac_prefix=opts.mac_prefix,
 146                         master_netdev=master_netdev,
 147                         file_storage_dir=opts.file_storage_dir,
 148                         shared_file_storage_dir=opts.shared_file_storage_dir,
 149                         enabled_hypervisors=hvlist,
 150                         hvparams=hvparams,
 151                         beparams=beparams,
 152                         nicparams=nicparams,
 153                         ndparams=ndparams,
 154                         candidate_pool_size=opts.candidate_pool_size,
 155                         modify_etc_hosts=opts.modify_etc_hosts,
 156                         modify_ssh_setup=opts.modify_ssh_setup,
 157                         maintain_node_health=opts.maintain_node_health,
 158                         drbd_helper=drbd_helper,
 159                         uid_pool=uid_pool,
 160                         default_iallocator=opts.default_iallocator,
 161                         primary_ip_version=primary_ip_version,
 162                         prealloc_wipe_disks=opts.prealloc_wipe_disks,
 163                         )
 164   op = opcodes.OpClusterPostInit()
 165   SubmitOpCode(op, opts=opts)
 166   return 0
 167
 168
 169 @UsesRPC
 170 def DestroyCluster(opts, args):
 171   """Destroy the cluster.
 172
 173   @param opts: the command line options selected by the user
 174   @type args: list
 175   @param args: should be an empty list
 176   @rtype: int
 177   @return: the desired exit code
 178
 179   """
 180   if not opts.yes_do_it:
 181     ToStderr("Destroying a cluster is irreversible. If you really want"
 182              " destroy this cluster, supply the --yes-do-it option.")
 183     return 1
 184
 185   op = opcodes.OpClusterDestroy()
 186   master = SubmitOpCode(op, opts=opts)
 187   # if we reached this, the opcode didn't fail; we can proceed to
 188   # shutdown all the daemons
 189   bootstrap.FinalizeClusterDestroy(master)
 190   return 0
 191
 192
 193 def RenameCluster(opts, args):
 194   """Rename the cluster.
 195
 196   @param opts: the command line options selected by the user
 197   @type args: list
 198   @param args: should contain only one element, the new cluster name
 199   @rtype: int
 200   @return: the desired exit code
 201
 202   """
 203   cl = GetClient()
 204
 205   (cluster_name, ) = cl.QueryConfigValues(["cluster_name"])
 206
 207   new_name = args[0]
 208   if not opts.force:
 209     usertext = ("This will rename the cluster from '%s' to '%s'. If you are"
 210                 " connected over the network to the cluster name, the"
 211                 " operation is very dangerous as the IP address will be"
 212                 " removed from the node and the change may not go through."
 213                 " Continue?") % (cluster_name, new_name)
 214     if not AskUser(usertext):
 215       return 1
 216
 217   op = opcodes.OpClusterRename(name=new_name)
 218   result = SubmitOpCode(op, opts=opts, cl=cl)
 219
 220   if result:
 221     ToStdout("Cluster renamed from '%s' to '%s'", cluster_name, result)
 222
 223   return 0
 224
 225
 226 def RedistributeConfig(opts, args):
 227   """Forces push of the cluster configuration.
 228
 229   @param opts: the command line options selected by the user
 230   @type args: list
 231   @param args: empty list
 232   @rtype: int
 233   @return: the desired exit code
 234
 235   """
 236   op = opcodes.OpClusterRedistConf()
 237   SubmitOrSend(op, opts)
 238   return 0
 239
 240
 241 def ShowClusterVersion(opts, args):
 242   """Write version of ganeti software to the standard output.
 243
 244   @param opts: the command line options selected by the user
 245   @type args: list
 246   @param args: should be an empty list
 247   @rtype: int
 248   @return: the desired exit code
 249
 250   """
 251   cl = GetClient()
 252   result = cl.QueryClusterInfo()
 253   ToStdout("Software version: %s", result["software_version"])
 254   ToStdout("Internode protocol: %s", result["protocol_version"])
 255   ToStdout("Configuration format: %s", result["config_version"])
 256   ToStdout("OS api version: %s", result["os_api_version"])
 257   ToStdout("Export interface: %s", result["export_version"])
 258   return 0
 259
 260
 261 def ShowClusterMaster(opts, args):
 262   """Write name of master node to the standard output.
 263
 264   @param opts: the command line options selected by the user
 265   @type args: list
 266   @param args: should be an empty list
 267   @rtype: int
 268   @return: the desired exit code
 269
 270   """
 271   master = bootstrap.GetMaster()
 272   ToStdout(master)
 273   return 0
 274
 275
 276 def _PrintGroupedParams(paramsdict, level=1, roman=False):
 277   """Print Grouped parameters (be, nic, disk) by group.
 278
 279   @type paramsdict: dict of dicts
 280   @param paramsdict: {group: {param: value, ...}, ...}
 281   @type level: int
 282   @param level: Level of indention
 283
 284   """
 285   indent = "  " * level
 286   for item, val in sorted(paramsdict.items()):
 287     if isinstance(val, dict):
 288       ToStdout("%s- %s:", indent, item)
 289       _PrintGroupedParams(val, level=level + 1, roman=roman)
 290     elif roman and isinstance(val, int):
 291       ToStdout("%s  %s: %s", indent, item, compat.TryToRoman(val))
 292     else:
 293       ToStdout("%s  %s: %s", indent, item, val)
 294
 295
 296 def ShowClusterConfig(opts, args):
 297   """Shows cluster information.
 298
 299   @param opts: the command line options selected by the user
 300   @type args: list
 301   @param args: should be an empty list
 302   @rtype: int
 303   @return: the desired exit code
 304
 305   """
 306   cl = GetClient()
 307   result = cl.QueryClusterInfo()
 308
 309   ToStdout("Cluster name: %s", result["name"])
 310   ToStdout("Cluster UUID: %s", result["uuid"])
 311
 312   ToStdout("Creation time: %s", utils.FormatTime(result["ctime"]))
 313   ToStdout("Modification time: %s", utils.FormatTime(result["mtime"]))
 314
 315   ToStdout("Master node: %s", result["master"])
 316
 317   ToStdout("Architecture (this node): %s (%s)",
 318            result["architecture"][0], result["architecture"][1])
 319
 320   if result["tags"]:
 321     tags = utils.CommaJoin(utils.NiceSort(result["tags"]))
 322   else:
 323     tags = "(none)"
 324
 325   ToStdout("Tags: %s", tags)
 326
 327   ToStdout("Default hypervisor: %s", result["default_hypervisor"])
 328   ToStdout("Enabled hypervisors: %s",
 329            utils.CommaJoin(result["enabled_hypervisors"]))
 330
 331   ToStdout("Hypervisor parameters:")
 332   _PrintGroupedParams(result["hvparams"])
 333
 334   ToStdout("OS-specific hypervisor parameters:")
 335   _PrintGroupedParams(result["os_hvp"])
 336
 337   ToStdout("OS parameters:")
 338   _PrintGroupedParams(result["osparams"])
 339
 340   ToStdout("Hidden OSes: %s", utils.CommaJoin(result["hidden_os"]))
 341   ToStdout("Blacklisted OSes: %s", utils.CommaJoin(result["blacklisted_os"]))
 342
 343   ToStdout("Cluster parameters:")
 344   ToStdout("  - candidate pool size: %s",
 345             compat.TryToRoman(result["candidate_pool_size"],
 346                               convert=opts.roman_integers))
 347   ToStdout("  - master netdev: %s", result["master_netdev"])
 348   ToStdout("  - lvm volume group: %s", result["volume_group_name"])
 349   if result["reserved_lvs"]:
 350     reserved_lvs = utils.CommaJoin(result["reserved_lvs"])
 351   else:
 352     reserved_lvs = "(none)"
 353   ToStdout("  - lvm reserved volumes: %s", reserved_lvs)
 354   ToStdout("  - drbd usermode helper: %s", result["drbd_usermode_helper"])
 355   ToStdout("  - file storage path: %s", result["file_storage_dir"])
 356   ToStdout("  - shared file storage path: %s",
 357            result["shared_file_storage_dir"])
 358   ToStdout("  - maintenance of node health: %s",
 359            result["maintain_node_health"])
 360   ToStdout("  - uid pool: %s",
 361             uidpool.FormatUidPool(result["uid_pool"],
 362                                   roman=opts.roman_integers))
 363   ToStdout("  - default instance allocator: %s", result["default_iallocator"])
 364   ToStdout("  - primary ip version: %d", result["primary_ip_version"])
 365   ToStdout("  - preallocation wipe disks: %s", result["prealloc_wipe_disks"])
 366
 367   ToStdout("Default node parameters:")
 368   _PrintGroupedParams(result["ndparams"], roman=opts.roman_integers)
 369
 370   ToStdout("Default instance parameters:")
 371   _PrintGroupedParams(result["beparams"], roman=opts.roman_integers)
 372
 373   ToStdout("Default nic parameters:")
 374   _PrintGroupedParams(result["nicparams"], roman=opts.roman_integers)
 375
 376   return 0
 377
 378
 379 def ClusterCopyFile(opts, args):
 380   """Copy a file from master to some nodes.
 381
 382   @param opts: the command line options selected by the user
 383   @type args: list
 384   @param args: should contain only one element, the path of
 385       the file to be copied
 386   @rtype: int
 387   @return: the desired exit code
 388
 389   """
 390   filename = args[0]
 391   if not os.path.exists(filename):
 392     raise errors.OpPrereqError("No such filename '%s'" % filename,
 393                                errors.ECODE_INVAL)
 394
 395   cl = GetClient()
 396
 397   cluster_name = cl.QueryConfigValues(["cluster_name"])[0]
 398
 399   results = GetOnlineNodes(nodes=opts.nodes, cl=cl, filter_master=True,
 400                            secondary_ips=opts.use_replication_network)
 401
 402   srun = ssh.SshRunner(cluster_name=cluster_name)
 403   for node in results:
 404     if not srun.CopyFileToNode(node, filename):
 405       ToStderr("Copy of file %s to node %s failed", filename, node)
 406
 407   return 0
 408
 409
 410 def RunClusterCommand(opts, args):
 411   """Run a command on some nodes.
 412
 413   @param opts: the command line options selected by the user
 414   @type args: list
 415   @param args: should contain the command to be run and its arguments
 416   @rtype: int
 417   @return: the desired exit code
 418
 419   """
 420   cl = GetClient()
 421
 422   command = " ".join(args)
 423
 424   nodes = GetOnlineNodes(nodes=opts.nodes, cl=cl)
 425
 426   cluster_name, master_node = cl.QueryConfigValues(["cluster_name",
 427                                                     "master_node"])
 428
 429   srun = ssh.SshRunner(cluster_name=cluster_name)
 430
 431   # Make sure master node is at list end
 432   if master_node in nodes:
 433     nodes.remove(master_node)
 434     nodes.append(master_node)
 435
 436   for name in nodes:
 437     result = srun.Run(name, "root", command)
 438     ToStdout("------------------------------------------------")
 439     ToStdout("node: %s", name)
 440     ToStdout("%s", result.output)
 441     ToStdout("return code = %s", result.exit_code)
 442
 443   return 0
 444
 445
 446 def VerifyCluster(opts, args):
 447   """Verify integrity of cluster, performing various test on nodes.
 448
 449   @param opts: the command line options selected by the user
 450   @type args: list
 451   @param args: should be an empty list
 452   @rtype: int
 453   @return: the desired exit code
 454
 455   """
 456   simulate = opts.simulate_errors
 457   skip_checks = []
 458
 459   if opts.nodegroup is None:
 460     # Verify cluster config.
 461     op = opcodes.OpClusterVerifyConfig(verbose=opts.verbose,
 462                                        error_codes=opts.error_codes,
 463                                        debug_simulate_errors=simulate)
 464
 465     success, all_groups = SubmitOpCode(op, opts=opts)
 466   else:
 467     success = True
 468     all_groups = [opts.nodegroup]
 469
 470   if opts.skip_nplusone_mem:
 471     skip_checks.append(constants.VERIFY_NPLUSONE_MEM)
 472
 473   jex = JobExecutor(opts=opts, verbose=False)
 474
 475   for group in all_groups:
 476     op = opcodes.OpClusterVerifyGroup(group_name=group,
 477                                       skip_checks=skip_checks,
 478                                       verbose=opts.verbose,
 479                                       error_codes=opts.error_codes,
 480                                       debug_simulate_errors=simulate)
 481     jex.QueueJob("group " + group, op)
 482
 483   results = jex.GetResults()
 484   success &= compat.all(r[1][0] for r in results)
 485
 486   if success:
 487     return constants.EXIT_SUCCESS
 488   else:
 489     return constants.EXIT_FAILURE
 490
 491
 492 def VerifyDisks(opts, args):
 493   """Verify integrity of cluster disks.
 494
 495   @param opts: the command line options selected by the user
 496   @type args: list
 497   @param args: should be an empty list
 498   @rtype: int
 499   @return: the desired exit code
 500
 501   """
 502   cl = GetClient()
 503
 504   op = opcodes.OpClusterVerifyDisks()
 505   result = SubmitOpCode(op, opts=opts, cl=cl)
 506   if not isinstance(result, (list, tuple)) or len(result) != 3:
 507     raise errors.ProgrammerError("Unknown result type for OpClusterVerifyDisks")
 508
 509   bad_nodes, instances, missing = result
 510
 511   retcode = constants.EXIT_SUCCESS
 512
 513   if bad_nodes:
 514     for node, text in bad_nodes.items():
 515       ToStdout("Error gathering data on node %s: %s",
 516                node, utils.SafeEncode(text[-400:]))
 517       retcode |= 1
 518       ToStdout("You need to fix these nodes first before fixing instances")
 519
 520   if instances:
 521     for iname in instances:
 522       if iname in missing:
 523         continue
 524       op = opcodes.OpInstanceActivateDisks(instance_name=iname)
 525       try:
 526         ToStdout("Activating disks for instance '%s'", iname)
 527         SubmitOpCode(op, opts=opts, cl=cl)
 528       except errors.GenericError, err:
 529         nret, msg = FormatError(err)
 530         retcode |= nret
 531         ToStderr("Error activating disks for instance %s: %s", iname, msg)
 532
 533   if missing:
 534     for iname, ival in missing.iteritems():
 535       all_missing = compat.all(x[0] in bad_nodes for x in ival)
 536       if all_missing:
 537         ToStdout("Instance %s cannot be verified as it lives on"
 538                  " broken nodes", iname)
 539       else:
 540         ToStdout("Instance %s has missing logical volumes:", iname)
 541         ival.sort()
 542         for node, vol in ival:
 543           if node in bad_nodes:
 544             ToStdout("\tbroken node %s /dev/%s", node, vol)
 545           else:
 546             ToStdout("\t%s /dev/%s", node, vol)
 547
 548     ToStdout("You need to run replace or recreate disks for all the above"
 549              " instances, if this message persist after fixing nodes.")
 550     retcode |= 1
 551
 552   return retcode
 553
 554
 555 def RepairDiskSizes(opts, args):
 556   """Verify sizes of cluster disks.
 557
 558   @param opts: the command line options selected by the user
 559   @type args: list
 560   @param args: optional list of instances to restrict check to
 561   @rtype: int
 562   @return: the desired exit code
 563
 564   """
 565   op = opcodes.OpClusterRepairDiskSizes(instances=args)
 566   SubmitOpCode(op, opts=opts)
 567
 568
 569 @UsesRPC
 570 def MasterFailover(opts, args):
 571   """Failover the master node.
 572
 573   This command, when run on a non-master node, will cause the current
 574   master to cease being master, and the non-master to become new
 575   master.
 576
 577   @param opts: the command line options selected by the user
 578   @type args: list
 579   @param args: should be an empty list
 580   @rtype: int
 581   @return: the desired exit code
 582
 583   """
 584   if opts.no_voting:
 585     usertext = ("This will perform the failover even if most other nodes"
 586                 " are down, or if this node is outdated. This is dangerous"
 587                 " as it can lead to a non-consistent cluster. Check the"
 588                 " gnt-cluster(8) man page before proceeding. Continue?")
 589     if not AskUser(usertext):
 590       return 1
 591
 592   return bootstrap.MasterFailover(no_voting=opts.no_voting)
 593
 594
 595 def MasterPing(opts, args):
 596   """Checks if the master is alive.
 597
 598   @param opts: the command line options selected by the user
 599   @type args: list
 600   @param args: should be an empty list
 601   @rtype: int
 602   @return: the desired exit code
 603
 604   """
 605   try:
 606     cl = GetClient()
 607     cl.QueryClusterInfo()
 608     return 0
 609   except Exception: # pylint: disable-msg=W0703
 610     return 1
 611
 612
 613 def SearchTags(opts, args):
 614   """Searches the tags on all the cluster.
 615
 616   @param opts: the command line options selected by the user
 617   @type args: list
 618   @param args: should contain only one element, the tag pattern
 619   @rtype: int
 620   @return: the desired exit code
 621
 622   """
 623   op = opcodes.OpTagsSearch(pattern=args[0])
 624   result = SubmitOpCode(op, opts=opts)
 625   if not result:
 626     return 1
 627   result = list(result)
 628   result.sort()
 629   for path, tag in result:
 630     ToStdout("%s %s", path, tag)
 631
 632
 633 def _RenewCrypto(new_cluster_cert, new_rapi_cert, rapi_cert_filename,
 634                  new_confd_hmac_key, new_cds, cds_filename,
 635                  force):
 636   """Renews cluster certificates, keys and secrets.
 637
 638   @type new_cluster_cert: bool
 639   @param new_cluster_cert: Whether to generate a new cluster certificate
 640   @type new_rapi_cert: bool
 641   @param new_rapi_cert: Whether to generate a new RAPI certificate
 642   @type rapi_cert_filename: string
 643   @param rapi_cert_filename: Path to file containing new RAPI certificate
 644   @type new_confd_hmac_key: bool
 645   @param new_confd_hmac_key: Whether to generate a new HMAC key
 646   @type new_cds: bool
 647   @param new_cds: Whether to generate a new cluster domain secret
 648   @type cds_filename: string
 649   @param cds_filename: Path to file containing new cluster domain secret
 650   @type force: bool
 651   @param force: Whether to ask user for confirmation
 652
 653   """
 654   if new_rapi_cert and rapi_cert_filename:
 655     ToStderr("Only one of the --new-rapi-certficate and --rapi-certificate"
 656              " options can be specified at the same time.")
 657     return 1
 658
 659   if new_cds and cds_filename:
 660     ToStderr("Only one of the --new-cluster-domain-secret and"
 661              " --cluster-domain-secret options can be specified at"
 662              " the same time.")
 663     return 1
 664
 665   if rapi_cert_filename:
 666     # Read and verify new certificate
 667     try:
 668       rapi_cert_pem = utils.ReadFile(rapi_cert_filename)
 669
 670       OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,
 671                                       rapi_cert_pem)
 672     except Exception, err: # pylint: disable-msg=W0703
 673       ToStderr("Can't load new RAPI certificate from %s: %s" %
 674                (rapi_cert_filename, str(err)))
 675       return 1
 676
 677     try:
 678       OpenSSL.crypto.load_privatekey(OpenSSL.crypto.FILETYPE_PEM, rapi_cert_pem)
 679     except Exception, err: # pylint: disable-msg=W0703
 680       ToStderr("Can't load new RAPI private key from %s: %s" %
 681                (rapi_cert_filename, str(err)))
 682       return 1
 683
 684   else:
 685     rapi_cert_pem = None
 686
 687   if cds_filename:
 688     try:
 689       cds = utils.ReadFile(cds_filename)
 690     except Exception, err: # pylint: disable-msg=W0703
 691       ToStderr("Can't load new cluster domain secret from %s: %s" %
 692                (cds_filename, str(err)))
 693       return 1
 694   else:
 695     cds = None
 696
 697   if not force:
 698     usertext = ("This requires all daemons on all nodes to be restarted and"
 699                 " may take some time. Continue?")
 700     if not AskUser(usertext):
 701       return 1
 702
 703   def _RenewCryptoInner(ctx):
 704     ctx.feedback_fn("Updating certificates and keys")
 705     bootstrap.GenerateClusterCrypto(new_cluster_cert, new_rapi_cert,
 706                                     new_confd_hmac_key,
 707                                     new_cds,
 708                                     rapi_cert_pem=rapi_cert_pem,
 709                                     cds=cds)
 710
 711     files_to_copy = []
 712
 713     if new_cluster_cert:
 714       files_to_copy.append(constants.NODED_CERT_FILE)
 715
 716     if new_rapi_cert or rapi_cert_pem:
 717       files_to_copy.append(constants.RAPI_CERT_FILE)
 718
 719     if new_confd_hmac_key:
 720       files_to_copy.append(constants.CONFD_HMAC_KEY)
 721
 722     if new_cds or cds:
 723       files_to_copy.append(constants.CLUSTER_DOMAIN_SECRET_FILE)
 724
 725     if files_to_copy:
 726       for node_name in ctx.nonmaster_nodes:
 727         ctx.feedback_fn("Copying %s to %s" %
 728                         (", ".join(files_to_copy), node_name))
 729         for file_name in files_to_copy:
 730           ctx.ssh.CopyFileToNode(node_name, file_name)
 731
 732   RunWhileClusterStopped(ToStdout, _RenewCryptoInner)
 733
 734   ToStdout("All requested certificates and keys have been replaced."
 735            " Running \"gnt-cluster verify\" now is recommended.")
 736
 737   return 0
 738
 739
 740 def RenewCrypto(opts, args):
 741   """Renews cluster certificates, keys and secrets.
 742
 743   """
 744   return _RenewCrypto(opts.new_cluster_cert,
 745                       opts.new_rapi_cert,
 746                       opts.rapi_cert,
 747                       opts.new_confd_hmac_key,
 748                       opts.new_cluster_domain_secret,
 749                       opts.cluster_domain_secret,
 750                       opts.force)
 751
 752
 753 def SetClusterParams(opts, args):
 754   """Modify the cluster.
 755
 756   @param opts: the command line options selected by the user
 757   @type args: list
 758   @param args: should be an empty list
 759   @rtype: int
 760   @return: the desired exit code
 761
 762   """
 763   if not (not opts.lvm_storage or opts.vg_name or
 764           not opts.drbd_storage or opts.drbd_helper or
 765           opts.enabled_hypervisors or opts.hvparams or
 766           opts.beparams or opts.nicparams or opts.ndparams or
 767           opts.candidate_pool_size is not None or
 768           opts.uid_pool is not None or
 769           opts.maintain_node_health is not None or
 770           opts.add_uids is not None or
 771           opts.remove_uids is not None or
 772           opts.default_iallocator is not None or
 773           opts.reserved_lvs is not None or
 774           opts.master_netdev is not None or
 775           opts.prealloc_wipe_disks is not None):
 776     ToStderr("Please give at least one of the parameters.")
 777     return 1
 778
 779   vg_name = opts.vg_name
 780   if not opts.lvm_storage and opts.vg_name:
 781     ToStderr("Options --no-lvm-storage and --vg-name conflict.")
 782     return 1
 783
 784   if not opts.lvm_storage:
 785     vg_name = ""
 786
 787   drbd_helper = opts.drbd_helper
 788   if not opts.drbd_storage and opts.drbd_helper:
 789     ToStderr("Options --no-drbd-storage and --drbd-usermode-helper conflict.")
 790     return 1
 791
 792   if not opts.drbd_storage:
 793     drbd_helper = ""
 794
 795   hvlist = opts.enabled_hypervisors
 796   if hvlist is not None:
 797     hvlist = hvlist.split(",")
 798
 799   # a list of (name, dict) we can pass directly to dict() (or [])
 800   hvparams = dict(opts.hvparams)
 801   for hv_params in hvparams.values():
 802     utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
 803
 804   beparams = opts.beparams
 805   utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
 806
 807   nicparams = opts.nicparams
 808   utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
 809
 810   ndparams = opts.ndparams
 811   if ndparams is not None:
 812     utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
 813
 814   mnh = opts.maintain_node_health
 815
 816   uid_pool = opts.uid_pool
 817   if uid_pool is not None:
 818     uid_pool = uidpool.ParseUidPool(uid_pool)
 819
 820   add_uids = opts.add_uids
 821   if add_uids is not None:
 822     add_uids = uidpool.ParseUidPool(add_uids)
 823
 824   remove_uids = opts.remove_uids
 825   if remove_uids is not None:
 826     remove_uids = uidpool.ParseUidPool(remove_uids)
 827
 828   if opts.reserved_lvs is not None:
 829     if opts.reserved_lvs == "":
 830       opts.reserved_lvs = []
 831     else:
 832       opts.reserved_lvs = utils.UnescapeAndSplit(opts.reserved_lvs, sep=",")
 833
 834   op = opcodes.OpClusterSetParams(vg_name=vg_name,
 835                                   drbd_helper=drbd_helper,
 836                                   enabled_hypervisors=hvlist,
 837                                   hvparams=hvparams,
 838                                   os_hvp=None,
 839                                   beparams=beparams,
 840                                   nicparams=nicparams,
 841                                   ndparams=ndparams,
 842                                   candidate_pool_size=opts.candidate_pool_size,
 843                                   maintain_node_health=mnh,
 844                                   uid_pool=uid_pool,
 845                                   add_uids=add_uids,
 846                                   remove_uids=remove_uids,
 847                                   default_iallocator=opts.default_iallocator,
 848                                   prealloc_wipe_disks=opts.prealloc_wipe_disks,
 849                                   master_netdev=opts.master_netdev,
 850                                   reserved_lvs=opts.reserved_lvs)
 851   SubmitOpCode(op, opts=opts)
 852   return 0
 853
 854
 855 def QueueOps(opts, args):
 856   """Queue operations.
 857
 858   @param opts: the command line options selected by the user
 859   @type args: list
 860   @param args: should contain only one element, the subcommand
 861   @rtype: int
 862   @return: the desired exit code
 863
 864   """
 865   command = args[0]
 866   client = GetClient()
 867   if command in ("drain", "undrain"):
 868     drain_flag = command == "drain"
 869     client.SetQueueDrainFlag(drain_flag)
 870   elif command == "info":
 871     result = client.QueryConfigValues(["drain_flag"])
 872     if result[0]:
 873       val = "set"
 874     else:
 875       val = "unset"
 876     ToStdout("The drain flag is %s" % val)
 877   else:
 878     raise errors.OpPrereqError("Command '%s' is not valid." % command,
 879                                errors.ECODE_INVAL)
 880
 881   return 0
 882
 883
 884 def _ShowWatcherPause(until):
 885   if until is None or until < time.time():
 886     ToStdout("The watcher is not paused.")
 887   else:
 888     ToStdout("The watcher is paused until %s.", time.ctime(until))
 889
 890
 891 def WatcherOps(opts, args):
 892   """Watcher operations.
 893
 894   @param opts: the command line options selected by the user
 895   @type args: list
 896   @param args: should contain only one element, the subcommand
 897   @rtype: int
 898   @return: the desired exit code
 899
 900   """
 901   command = args[0]
 902   client = GetClient()
 903
 904   if command == "continue":
 905     client.SetWatcherPause(None)
 906     ToStdout("The watcher is no longer paused.")
 907
 908   elif command == "pause":
 909     if len(args) < 2:
 910       raise errors.OpPrereqError("Missing pause duration", errors.ECODE_INVAL)
 911
 912     result = client.SetWatcherPause(time.time() + ParseTimespec(args[1]))
 913     _ShowWatcherPause(result)
 914
 915   elif command == "info":
 916     result = client.QueryConfigValues(["watcher_pause"])
 917     _ShowWatcherPause(result[0])
 918
 919   else:
 920     raise errors.OpPrereqError("Command '%s' is not valid." % command,
 921                                errors.ECODE_INVAL)
 922
 923   return 0
 924
 925
 926 def _OobPower(opts, node_list, power):
 927   """Puts the node in the list to desired power state.
 928
 929   @param opts: The command line options selected by the user
 930   @param node_list: The list of nodes to operate on
 931   @param power: True if they should be powered on, False otherwise
 932   @return: The success of the operation (none failed)
 933
 934   """
 935   if power:
 936     command = constants.OOB_POWER_ON
 937   else:
 938     command = constants.OOB_POWER_OFF
 939
 940   op = opcodes.OpOobCommand(node_names=node_list,
 941                             command=command,
 942                             ignore_status=True,
 943                             timeout=opts.oob_timeout,
 944                             power_delay=opts.power_delay)
 945   result = SubmitOpCode(op, opts=opts)
 946   errs = 0
 947   for node_result in result:
 948     (node_tuple, data_tuple) = node_result
 949     (_, node_name) = node_tuple
 950     (data_status, _) = data_tuple
 951     if data_status != constants.RS_NORMAL:
 952       assert data_status != constants.RS_UNAVAIL
 953       errs += 1
 954       ToStderr("There was a problem changing power for %s, please investigate",
 955                node_name)
 956
 957   if errs > 0:
 958     return False
 959
 960   return True
 961
 962
 963 def _InstanceStart(opts, inst_list, start):
 964   """Puts the instances in the list to desired state.
 965
 966   @param opts: The command line options selected by the user
 967   @param inst_list: The list of instances to operate on
 968   @param start: True if they should be started, False for shutdown
 969   @return: The success of the operation (none failed)
 970
 971   """
 972   if start:
 973     opcls = opcodes.OpInstanceStartup
 974     text_submit, text_success, text_failed = ("startup", "started", "starting")
 975   else:
 976     opcls = compat.partial(opcodes.OpInstanceShutdown,
 977                            timeout=opts.shutdown_timeout)
 978     text_submit, text_success, text_failed = ("shutdown", "stopped", "stopping")
 979
 980   jex = JobExecutor(opts=opts)
 981
 982   for inst in inst_list:
 983     ToStdout("Submit %s of instance %s", text_submit, inst)
 984     op = opcls(instance_name=inst)
 985     jex.QueueJob(inst, op)
 986
 987   results = jex.GetResults()
 988   bad_cnt = len([1 for (success, _) in results if not success])
 989
 990   if bad_cnt == 0:
 991     ToStdout("All instances have been %s successfully", text_success)
 992   else:
 993     ToStderr("There were errors while %s instances:\n"
 994              "%d error(s) out of %d instance(s)", text_failed, bad_cnt,
 995              len(results))
 996     return False
 997
 998   return True
 999
1000
1001 class _RunWhenNodesReachableHelper:
1002   """Helper class to make shared internal state sharing easier.
1003
1004   @ivar success: Indicates if all action_cb calls were successful
1005
1006   """
1007   def __init__(self, node_list, action_cb, node2ip, port, feedback_fn,
1008                _ping_fn=netutils.TcpPing, _sleep_fn=time.sleep):
1009     """Init the object.
1010
1011     @param node_list: The list of nodes to be reachable
1012     @param action_cb: Callback called when a new host is reachable
1013     @type node2ip: dict
1014     @param node2ip: Node to ip mapping
1015     @param port: The port to use for the TCP ping
1016     @param feedback_fn: The function used for feedback
1017     @param _ping_fn: Function to check reachabilty (for unittest use only)
1018     @param _sleep_fn: Function to sleep (for unittest use only)
1019
1020     """
1021     self.down = set(node_list)
1022     self.up = set()
1023     self.node2ip = node2ip
1024     self.success = True
1025     self.action_cb = action_cb
1026     self.port = port
1027     self.feedback_fn = feedback_fn
1028     self._ping_fn = _ping_fn
1029     self._sleep_fn = _sleep_fn
1030
1031   def __call__(self):
1032     """When called we run action_cb.
1033
1034     @raises utils.RetryAgain: When there are still down nodes
1035
1036     """
1037     if not self.action_cb(self.up):
1038       self.success = False
1039
1040     if self.down:
1041       raise utils.RetryAgain()
1042     else:
1043       return self.success
1044
1045   def Wait(self, secs):
1046     """Checks if a host is up or waits remaining seconds.
1047
1048     @param secs: The secs remaining
1049
1050     """
1051     start = time.time()
1052     for node in self.down:
1053       if self._ping_fn(self.node2ip[node], self.port, timeout=_EPO_PING_TIMEOUT,
1054                        live_port_needed=True):
1055         self.feedback_fn("Node %s became available" % node)
1056         self.up.add(node)
1057         self.down -= self.up
1058         # If we have a node available there is the possibility to run the
1059         # action callback successfully, therefore we don't wait and return
1060         return
1061
1062     self._sleep_fn(max(0.0, start + secs - time.time()))
1063
1064
1065 def _RunWhenNodesReachable(node_list, action_cb, interval):
1066   """Run action_cb when nodes become reachable.
1067
1068   @param node_list: The list of nodes to be reachable
1069   @param action_cb: Callback called when a new host is reachable
1070   @param interval: The earliest time to retry
1071
1072   """
1073   client = GetClient()
1074   cluster_info = client.QueryClusterInfo()
1075   if cluster_info["primary_ip_version"] == constants.IP4_VERSION:
1076     family = netutils.IPAddress.family
1077   else:
1078     family = netutils.IP6Address.family
1079
1080   node2ip = dict((node, netutils.GetHostname(node, family=family).ip)
1081                  for node in node_list)
1082
1083   port = netutils.GetDaemonPort(constants.NODED)
1084   helper = _RunWhenNodesReachableHelper(node_list, action_cb, node2ip, port,
1085                                         ToStdout)
1086
1087   try:
1088     return utils.Retry(helper, interval, _EPO_REACHABLE_TIMEOUT,
1089                        wait_fn=helper.Wait)
1090   except utils.RetryTimeout:
1091     ToStderr("Time exceeded while waiting for nodes to become reachable"
1092              " again:\n  - %s", "  - ".join(helper.down))
1093     return False
1094
1095
1096 def _MaybeInstanceStartup(opts, inst_map, nodes_online,
1097                           _instance_start_fn=_InstanceStart):
1098   """Start the instances conditional based on node_states.
1099
1100   @param opts: The command line options selected by the user
1101   @param inst_map: A dict of inst -> nodes mapping
1102   @param nodes_online: A list of nodes online
1103   @param _instance_start_fn: Callback to start instances (unittest use only)
1104   @return: Success of the operation on all instances
1105
1106   """
1107   start_inst_list = []
1108   for (inst, nodes) in inst_map.items():
1109     if not (nodes - nodes_online):
1110       # All nodes the instance lives on are back online
1111       start_inst_list.append(inst)
1112
1113   for inst in start_inst_list:
1114     del inst_map[inst]
1115
1116   if start_inst_list:
1117     return _instance_start_fn(opts, start_inst_list, True)
1118
1119   return True
1120
1121
1122 def _EpoOn(opts, full_node_list, node_list, inst_map):
1123   """Does the actual power on.
1124
1125   @param opts: The command line options selected by the user
1126   @param full_node_list: All nodes to operate on (includes nodes not supporting
1127                          OOB)
1128   @param node_list: The list of nodes to operate on (all need to support OOB)
1129   @param inst_map: A dict of inst -> nodes mapping
1130   @return: The desired exit status
1131
1132   """
1133   if node_list and not _OobPower(opts, node_list, False):
1134     ToStderr("Not all nodes seem to get back up, investigate and start"
1135              " manually if needed")
1136
1137   # Wait for the nodes to be back up
1138   action_cb = compat.partial(_MaybeInstanceStartup, opts, dict(inst_map))
1139
1140   ToStdout("Waiting until all nodes are available again")
1141   if not _RunWhenNodesReachable(full_node_list, action_cb, _EPO_PING_INTERVAL):
1142     ToStderr("Please investigate and start stopped instances manually")
1143     return constants.EXIT_FAILURE
1144
1145   return constants.EXIT_SUCCESS
1146
1147
1148 def _EpoOff(opts, node_list, inst_map):
1149   """Does the actual power off.
1150
1151   @param opts: The command line options selected by the user
1152   @param node_list: The list of nodes to operate on (all need to support OOB)
1153   @param inst_map: A dict of inst -> nodes mapping
1154   @return: The desired exit status
1155
1156   """
1157   if not _InstanceStart(opts, inst_map.keys(), False):
1158     ToStderr("Please investigate and stop instances manually before continuing")
1159     return constants.EXIT_FAILURE
1160
1161   if not node_list:
1162     return constants.EXIT_SUCCESS
1163
1164   if _OobPower(opts, node_list, False):
1165     return constants.EXIT_SUCCESS
1166   else:
1167     return constants.EXIT_FAILURE
1168
1169
1170 def Epo(opts, args):
1171   """EPO operations.
1172
1173   @param opts: the command line options selected by the user
1174   @type args: list
1175   @param args: should contain only one element, the subcommand
1176   @rtype: int
1177   @return: the desired exit code
1178
1179   """
1180   if opts.groups and opts.show_all:
1181     ToStderr("Only one of --groups or --all are allowed")
1182     return constants.EXIT_FAILURE
1183   elif args and opts.show_all:
1184     ToStderr("Arguments in combination with --all are not allowed")
1185     return constants.EXIT_FAILURE
1186
1187   client = GetClient()
1188
1189   if opts.groups:
1190     node_query_list = itertools.chain(*client.QueryGroups(names=args,
1191                                                           fields=["node_list"],
1192                                                           use_locking=False))
1193   else:
1194     node_query_list = args
1195
1196   result = client.QueryNodes(names=node_query_list,
1197                              fields=["name", "master", "pinst_list",
1198                                      "sinst_list", "powered", "offline"],
1199                              use_locking=False)
1200   node_list = []
1201   inst_map = {}
1202   for (idx, (node, master, pinsts, sinsts, powered,
1203              offline)) in enumerate(result):
1204     # Normalize the node_query_list as well
1205     if not opts.show_all:
1206       node_query_list[idx] = node
1207     if not offline:
1208       for inst in (pinsts + sinsts):
1209         if inst in inst_map:
1210           if not master:
1211             inst_map[inst].add(node)
1212         elif master:
1213           inst_map[inst] = set()
1214         else:
1215           inst_map[inst] = set([node])
1216
1217     if master and opts.on:
1218       # We ignore the master for turning on the machines, in fact we are
1219       # already operating on the master at this point :)
1220       continue
1221     elif master and not opts.show_all:
1222       ToStderr("%s is the master node, please do a master-failover to another"
1223                " node not affected by the EPO or use --all if you intend to"
1224                " shutdown the whole cluster", node)
1225       return constants.EXIT_FAILURE
1226     elif powered is None:
1227       ToStdout("Node %s does not support out-of-band handling, it can not be"
1228                " handled in a fully automated manner", node)
1229     elif powered == opts.on:
1230       ToStdout("Node %s is already in desired power state, skipping", node)
1231     elif not offline or (offline and powered):
1232       node_list.append(node)
1233
1234   if not opts.force and not ConfirmOperation(node_query_list, "nodes", "epo"):
1235     return constants.EXIT_FAILURE
1236
1237   if opts.on:
1238     return _EpoOn(opts, node_query_list, node_list, inst_map)
1239   else:
1240     return _EpoOff(opts, node_list, inst_map)
1241
1242
1243 commands = {
1244   'init': (
1245     InitCluster, [ArgHost(min=1, max=1)],
1246     [BACKEND_OPT, CP_SIZE_OPT, ENABLED_HV_OPT, GLOBAL_FILEDIR_OPT,
1247      HVLIST_OPT, MAC_PREFIX_OPT, MASTER_NETDEV_OPT, NIC_PARAMS_OPT,
1248      NOLVM_STORAGE_OPT, NOMODIFY_ETCHOSTS_OPT, NOMODIFY_SSH_SETUP_OPT,
1249      SECONDARY_IP_OPT, VG_NAME_OPT, MAINTAIN_NODE_HEALTH_OPT,
1250      UIDPOOL_OPT, DRBD_HELPER_OPT, NODRBD_STORAGE_OPT,
1251      DEFAULT_IALLOCATOR_OPT, PRIMARY_IP_VERSION_OPT, PREALLOC_WIPE_DISKS_OPT,
1252      NODE_PARAMS_OPT, GLOBAL_SHARED_FILEDIR_OPT],
1253     "[opts...] <cluster_name>", "Initialises a new cluster configuration"),
1254   'destroy': (
1255     DestroyCluster, ARGS_NONE, [YES_DOIT_OPT],
1256     "", "Destroy cluster"),
1257   'rename': (
1258     RenameCluster, [ArgHost(min=1, max=1)],
1259     [FORCE_OPT, DRY_RUN_OPT],
1260     "<new_name>",
1261     "Renames the cluster"),
1262   'redist-conf': (
1263     RedistributeConfig, ARGS_NONE, [SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT],
1264     "", "Forces a push of the configuration file and ssconf files"
1265     " to the nodes in the cluster"),
1266   'verify': (
1267     VerifyCluster, ARGS_NONE,
1268     [VERBOSE_OPT, DEBUG_SIMERR_OPT, ERROR_CODES_OPT, NONPLUS1_OPT,
1269      DRY_RUN_OPT, PRIORITY_OPT, NODEGROUP_OPT],
1270     "", "Does a check on the cluster configuration"),
1271   'verify-disks': (
1272     VerifyDisks, ARGS_NONE, [PRIORITY_OPT],
1273     "", "Does a check on the cluster disk status"),
1274   'repair-disk-sizes': (
1275     RepairDiskSizes, ARGS_MANY_INSTANCES, [DRY_RUN_OPT, PRIORITY_OPT],
1276     "", "Updates mismatches in recorded disk sizes"),
1277   'master-failover': (
1278     MasterFailover, ARGS_NONE, [NOVOTING_OPT],
1279     "", "Makes the current node the master"),
1280   'master-ping': (
1281     MasterPing, ARGS_NONE, [],
1282     "", "Checks if the master is alive"),
1283   'version': (
1284     ShowClusterVersion, ARGS_NONE, [],
1285     "", "Shows the cluster version"),
1286   'getmaster': (
1287     ShowClusterMaster, ARGS_NONE, [],
1288     "", "Shows the cluster master"),
1289   'copyfile': (
1290     ClusterCopyFile, [ArgFile(min=1, max=1)],
1291     [NODE_LIST_OPT, USE_REPL_NET_OPT],
1292     "[-n node...] <filename>", "Copies a file to all (or only some) nodes"),
1293   'command': (
1294     RunClusterCommand, [ArgCommand(min=1)],
1295     [NODE_LIST_OPT],
1296     "[-n node...] <command>", "Runs a command on all (or only some) nodes"),
1297   'info': (
1298     ShowClusterConfig, ARGS_NONE, [ROMAN_OPT],
1299     "[--roman]", "Show cluster configuration"),
1300   'list-tags': (
1301     ListTags, ARGS_NONE, [], "", "List the tags of the cluster"),
1302   'add-tags': (
1303     AddTags, [ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT],
1304     "tag...", "Add tags to the cluster"),
1305   'remove-tags': (
1306     RemoveTags, [ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT],
1307     "tag...", "Remove tags from the cluster"),
1308   'search-tags': (
1309     SearchTags, [ArgUnknown(min=1, max=1)], [PRIORITY_OPT], "",
1310     "Searches the tags on all objects on"
1311     " the cluster for a given pattern (regex)"),
1312   'queue': (
1313     QueueOps,
1314     [ArgChoice(min=1, max=1, choices=["drain", "undrain", "info"])],
1315     [], "drain|undrain|info", "Change queue properties"),
1316   'watcher': (
1317     WatcherOps,
1318     [ArgChoice(min=1, max=1, choices=["pause", "continue", "info"]),
1319      ArgSuggest(min=0, max=1, choices=["30m", "1h", "4h"])],
1320     [],
1321     "{pause <timespec>|continue|info}", "Change watcher properties"),
1322   'modify': (
1323     SetClusterParams, ARGS_NONE,
1324     [BACKEND_OPT, CP_SIZE_OPT, ENABLED_HV_OPT, HVLIST_OPT, MASTER_NETDEV_OPT,
1325      NIC_PARAMS_OPT, NOLVM_STORAGE_OPT, VG_NAME_OPT, MAINTAIN_NODE_HEALTH_OPT,
1326      UIDPOOL_OPT, ADD_UIDS_OPT, REMOVE_UIDS_OPT, DRBD_HELPER_OPT,
1327      NODRBD_STORAGE_OPT, DEFAULT_IALLOCATOR_OPT, RESERVED_LVS_OPT,
1328      DRY_RUN_OPT, PRIORITY_OPT, PREALLOC_WIPE_DISKS_OPT, NODE_PARAMS_OPT],
1329     "[opts...]",
1330     "Alters the parameters of the cluster"),
1331   "renew-crypto": (
1332     RenewCrypto, ARGS_NONE,
1333     [NEW_CLUSTER_CERT_OPT, NEW_RAPI_CERT_OPT, RAPI_CERT_OPT,
1334      NEW_CONFD_HMAC_KEY_OPT, FORCE_OPT,
1335      NEW_CLUSTER_DOMAIN_SECRET_OPT, CLUSTER_DOMAIN_SECRET_OPT],
1336     "[opts...]",
1337     "Renews cluster certificates, keys and secrets"),
1338   "epo": (
1339     Epo, [ArgUnknown()],
1340     [FORCE_OPT, ON_OPT, GROUPS_OPT, ALL_OPT, OOB_TIMEOUT_OPT,
1341      SHUTDOWN_TIMEOUT_OPT, POWER_DELAY_OPT],
1342     "[opts...] [args]",
1343     "Performs an emergency power-off on given args"),
1344   }
1345
1346
1347 #: dictionary with aliases for commands
1348 aliases = {
1349   'masterfailover': 'master-failover',
1350 }
1351
1352
1353 def Main():
1354   return GenericMain(commands, override={"tag_type": constants.TAG_CLUSTER},
1355                      aliases=aliases)