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   skip_checks = []
 457   if opts.skip_nplusone_mem:
 458     skip_checks.append(constants.VERIFY_NPLUSONE_MEM)
 459   op = opcodes.OpClusterVerify(skip_checks=skip_checks,
 460                                verbose=opts.verbose,
 461                                error_codes=opts.error_codes,
 462                                debug_simulate_errors=opts.simulate_errors)
 463   if SubmitOpCode(op, opts=opts):
 464     return 0
 465   else:
 466     return 1
 467
 468
 469 def VerifyDisks(opts, args):
 470   """Verify integrity of cluster disks.
 471
 472   @param opts: the command line options selected by the user
 473   @type args: list
 474   @param args: should be an empty list
 475   @rtype: int
 476   @return: the desired exit code
 477
 478   """
 479   cl = GetClient()
 480
 481   op = opcodes.OpClusterVerifyDisks()
 482   result = SubmitOpCode(op, opts=opts, cl=cl)
 483   if not isinstance(result, (list, tuple)) or len(result) != 3:
 484     raise errors.ProgrammerError("Unknown result type for OpClusterVerifyDisks")
 485
 486   bad_nodes, instances, missing = result
 487
 488   retcode = constants.EXIT_SUCCESS
 489
 490   if bad_nodes:
 491     for node, text in bad_nodes.items():
 492       ToStdout("Error gathering data on node %s: %s",
 493                node, utils.SafeEncode(text[-400:]))
 494       retcode |= 1
 495       ToStdout("You need to fix these nodes first before fixing instances")
 496
 497   if instances:
 498     for iname in instances:
 499       if iname in missing:
 500         continue
 501       op = opcodes.OpInstanceActivateDisks(instance_name=iname)
 502       try:
 503         ToStdout("Activating disks for instance '%s'", iname)
 504         SubmitOpCode(op, opts=opts, cl=cl)
 505       except errors.GenericError, err:
 506         nret, msg = FormatError(err)
 507         retcode |= nret
 508         ToStderr("Error activating disks for instance %s: %s", iname, msg)
 509
 510   if missing:
 511     for iname, ival in missing.iteritems():
 512       all_missing = compat.all(x[0] in bad_nodes for x in ival)
 513       if all_missing:
 514         ToStdout("Instance %s cannot be verified as it lives on"
 515                  " broken nodes", iname)
 516       else:
 517         ToStdout("Instance %s has missing logical volumes:", iname)
 518         ival.sort()
 519         for node, vol in ival:
 520           if node in bad_nodes:
 521             ToStdout("\tbroken node %s /dev/%s", node, vol)
 522           else:
 523             ToStdout("\t%s /dev/%s", node, vol)
 524
 525     ToStdout("You need to run replace or recreate disks for all the above"
 526              " instances, if this message persist after fixing nodes.")
 527     retcode |= 1
 528
 529   return retcode
 530
 531
 532 def RepairDiskSizes(opts, args):
 533   """Verify sizes of cluster disks.
 534
 535   @param opts: the command line options selected by the user
 536   @type args: list
 537   @param args: optional list of instances to restrict check to
 538   @rtype: int
 539   @return: the desired exit code
 540
 541   """
 542   op = opcodes.OpClusterRepairDiskSizes(instances=args)
 543   SubmitOpCode(op, opts=opts)
 544
 545
 546 @UsesRPC
 547 def MasterFailover(opts, args):
 548   """Failover the master node.
 549
 550   This command, when run on a non-master node, will cause the current
 551   master to cease being master, and the non-master to become new
 552   master.
 553
 554   @param opts: the command line options selected by the user
 555   @type args: list
 556   @param args: should be an empty list
 557   @rtype: int
 558   @return: the desired exit code
 559
 560   """
 561   if opts.no_voting:
 562     usertext = ("This will perform the failover even if most other nodes"
 563                 " are down, or if this node is outdated. This is dangerous"
 564                 " as it can lead to a non-consistent cluster. Check the"
 565                 " gnt-cluster(8) man page before proceeding. Continue?")
 566     if not AskUser(usertext):
 567       return 1
 568
 569   return bootstrap.MasterFailover(no_voting=opts.no_voting)
 570
 571
 572 def MasterPing(opts, args):
 573   """Checks if the master is alive.
 574
 575   @param opts: the command line options selected by the user
 576   @type args: list
 577   @param args: should be an empty list
 578   @rtype: int
 579   @return: the desired exit code
 580
 581   """
 582   try:
 583     cl = GetClient()
 584     cl.QueryClusterInfo()
 585     return 0
 586   except Exception: # pylint: disable-msg=W0703
 587     return 1
 588
 589
 590 def SearchTags(opts, args):
 591   """Searches the tags on all the cluster.
 592
 593   @param opts: the command line options selected by the user
 594   @type args: list
 595   @param args: should contain only one element, the tag pattern
 596   @rtype: int
 597   @return: the desired exit code
 598
 599   """
 600   op = opcodes.OpTagsSearch(pattern=args[0])
 601   result = SubmitOpCode(op, opts=opts)
 602   if not result:
 603     return 1
 604   result = list(result)
 605   result.sort()
 606   for path, tag in result:
 607     ToStdout("%s %s", path, tag)
 608
 609
 610 def _RenewCrypto(new_cluster_cert, new_rapi_cert, rapi_cert_filename,
 611                  new_confd_hmac_key, new_cds, cds_filename,
 612                  force):
 613   """Renews cluster certificates, keys and secrets.
 614
 615   @type new_cluster_cert: bool
 616   @param new_cluster_cert: Whether to generate a new cluster certificate
 617   @type new_rapi_cert: bool
 618   @param new_rapi_cert: Whether to generate a new RAPI certificate
 619   @type rapi_cert_filename: string
 620   @param rapi_cert_filename: Path to file containing new RAPI certificate
 621   @type new_confd_hmac_key: bool
 622   @param new_confd_hmac_key: Whether to generate a new HMAC key
 623   @type new_cds: bool
 624   @param new_cds: Whether to generate a new cluster domain secret
 625   @type cds_filename: string
 626   @param cds_filename: Path to file containing new cluster domain secret
 627   @type force: bool
 628   @param force: Whether to ask user for confirmation
 629
 630   """
 631   if new_rapi_cert and rapi_cert_filename:
 632     ToStderr("Only one of the --new-rapi-certficate and --rapi-certificate"
 633              " options can be specified at the same time.")
 634     return 1
 635
 636   if new_cds and cds_filename:
 637     ToStderr("Only one of the --new-cluster-domain-secret and"
 638              " --cluster-domain-secret options can be specified at"
 639              " the same time.")
 640     return 1
 641
 642   if rapi_cert_filename:
 643     # Read and verify new certificate
 644     try:
 645       rapi_cert_pem = utils.ReadFile(rapi_cert_filename)
 646
 647       OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,
 648                                       rapi_cert_pem)
 649     except Exception, err: # pylint: disable-msg=W0703
 650       ToStderr("Can't load new RAPI certificate from %s: %s" %
 651                (rapi_cert_filename, str(err)))
 652       return 1
 653
 654     try:
 655       OpenSSL.crypto.load_privatekey(OpenSSL.crypto.FILETYPE_PEM, rapi_cert_pem)
 656     except Exception, err: # pylint: disable-msg=W0703
 657       ToStderr("Can't load new RAPI private key from %s: %s" %
 658                (rapi_cert_filename, str(err)))
 659       return 1
 660
 661   else:
 662     rapi_cert_pem = None
 663
 664   if cds_filename:
 665     try:
 666       cds = utils.ReadFile(cds_filename)
 667     except Exception, err: # pylint: disable-msg=W0703
 668       ToStderr("Can't load new cluster domain secret from %s: %s" %
 669                (cds_filename, str(err)))
 670       return 1
 671   else:
 672     cds = None
 673
 674   if not force:
 675     usertext = ("This requires all daemons on all nodes to be restarted and"
 676                 " may take some time. Continue?")
 677     if not AskUser(usertext):
 678       return 1
 679
 680   def _RenewCryptoInner(ctx):
 681     ctx.feedback_fn("Updating certificates and keys")
 682     bootstrap.GenerateClusterCrypto(new_cluster_cert, new_rapi_cert,
 683                                     new_confd_hmac_key,
 684                                     new_cds,
 685                                     rapi_cert_pem=rapi_cert_pem,
 686                                     cds=cds)
 687
 688     files_to_copy = []
 689
 690     if new_cluster_cert:
 691       files_to_copy.append(constants.NODED_CERT_FILE)
 692
 693     if new_rapi_cert or rapi_cert_pem:
 694       files_to_copy.append(constants.RAPI_CERT_FILE)
 695
 696     if new_confd_hmac_key:
 697       files_to_copy.append(constants.CONFD_HMAC_KEY)
 698
 699     if new_cds or cds:
 700       files_to_copy.append(constants.CLUSTER_DOMAIN_SECRET_FILE)
 701
 702     if files_to_copy:
 703       for node_name in ctx.nonmaster_nodes:
 704         ctx.feedback_fn("Copying %s to %s" %
 705                         (", ".join(files_to_copy), node_name))
 706         for file_name in files_to_copy:
 707           ctx.ssh.CopyFileToNode(node_name, file_name)
 708
 709   RunWhileClusterStopped(ToStdout, _RenewCryptoInner)
 710
 711   ToStdout("All requested certificates and keys have been replaced."
 712            " Running \"gnt-cluster verify\" now is recommended.")
 713
 714   return 0
 715
 716
 717 def RenewCrypto(opts, args):
 718   """Renews cluster certificates, keys and secrets.
 719
 720   """
 721   return _RenewCrypto(opts.new_cluster_cert,
 722                       opts.new_rapi_cert,
 723                       opts.rapi_cert,
 724                       opts.new_confd_hmac_key,
 725                       opts.new_cluster_domain_secret,
 726                       opts.cluster_domain_secret,
 727                       opts.force)
 728
 729
 730 def SetClusterParams(opts, args):
 731   """Modify the cluster.
 732
 733   @param opts: the command line options selected by the user
 734   @type args: list
 735   @param args: should be an empty list
 736   @rtype: int
 737   @return: the desired exit code
 738
 739   """
 740   if not (not opts.lvm_storage or opts.vg_name or
 741           not opts.drbd_storage or opts.drbd_helper or
 742           opts.enabled_hypervisors or opts.hvparams or
 743           opts.beparams or opts.nicparams or opts.ndparams or
 744           opts.candidate_pool_size is not None or
 745           opts.uid_pool is not None or
 746           opts.maintain_node_health is not None or
 747           opts.add_uids is not None or
 748           opts.remove_uids is not None or
 749           opts.default_iallocator is not None or
 750           opts.reserved_lvs is not None or
 751           opts.master_netdev is not None or
 752           opts.prealloc_wipe_disks is not None):
 753     ToStderr("Please give at least one of the parameters.")
 754     return 1
 755
 756   vg_name = opts.vg_name
 757   if not opts.lvm_storage and opts.vg_name:
 758     ToStderr("Options --no-lvm-storage and --vg-name conflict.")
 759     return 1
 760
 761   if not opts.lvm_storage:
 762     vg_name = ""
 763
 764   drbd_helper = opts.drbd_helper
 765   if not opts.drbd_storage and opts.drbd_helper:
 766     ToStderr("Options --no-drbd-storage and --drbd-usermode-helper conflict.")
 767     return 1
 768
 769   if not opts.drbd_storage:
 770     drbd_helper = ""
 771
 772   hvlist = opts.enabled_hypervisors
 773   if hvlist is not None:
 774     hvlist = hvlist.split(",")
 775
 776   # a list of (name, dict) we can pass directly to dict() (or [])
 777   hvparams = dict(opts.hvparams)
 778   for hv_params in hvparams.values():
 779     utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
 780
 781   beparams = opts.beparams
 782   utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
 783
 784   nicparams = opts.nicparams
 785   utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
 786
 787   ndparams = opts.ndparams
 788   if ndparams is not None:
 789     utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
 790
 791   mnh = opts.maintain_node_health
 792
 793   uid_pool = opts.uid_pool
 794   if uid_pool is not None:
 795     uid_pool = uidpool.ParseUidPool(uid_pool)
 796
 797   add_uids = opts.add_uids
 798   if add_uids is not None:
 799     add_uids = uidpool.ParseUidPool(add_uids)
 800
 801   remove_uids = opts.remove_uids
 802   if remove_uids is not None:
 803     remove_uids = uidpool.ParseUidPool(remove_uids)
 804
 805   if opts.reserved_lvs is not None:
 806     if opts.reserved_lvs == "":
 807       opts.reserved_lvs = []
 808     else:
 809       opts.reserved_lvs = utils.UnescapeAndSplit(opts.reserved_lvs, sep=",")
 810
 811   op = opcodes.OpClusterSetParams(vg_name=vg_name,
 812                                   drbd_helper=drbd_helper,
 813                                   enabled_hypervisors=hvlist,
 814                                   hvparams=hvparams,
 815                                   os_hvp=None,
 816                                   beparams=beparams,
 817                                   nicparams=nicparams,
 818                                   ndparams=ndparams,
 819                                   candidate_pool_size=opts.candidate_pool_size,
 820                                   maintain_node_health=mnh,
 821                                   uid_pool=uid_pool,
 822                                   add_uids=add_uids,
 823                                   remove_uids=remove_uids,
 824                                   default_iallocator=opts.default_iallocator,
 825                                   prealloc_wipe_disks=opts.prealloc_wipe_disks,
 826                                   master_netdev=opts.master_netdev,
 827                                   reserved_lvs=opts.reserved_lvs)
 828   SubmitOpCode(op, opts=opts)
 829   return 0
 830
 831
 832 def QueueOps(opts, args):
 833   """Queue operations.
 834
 835   @param opts: the command line options selected by the user
 836   @type args: list
 837   @param args: should contain only one element, the subcommand
 838   @rtype: int
 839   @return: the desired exit code
 840
 841   """
 842   command = args[0]
 843   client = GetClient()
 844   if command in ("drain", "undrain"):
 845     drain_flag = command == "drain"
 846     client.SetQueueDrainFlag(drain_flag)
 847   elif command == "info":
 848     result = client.QueryConfigValues(["drain_flag"])
 849     if result[0]:
 850       val = "set"
 851     else:
 852       val = "unset"
 853     ToStdout("The drain flag is %s" % val)
 854   else:
 855     raise errors.OpPrereqError("Command '%s' is not valid." % command,
 856                                errors.ECODE_INVAL)
 857
 858   return 0
 859
 860
 861 def _ShowWatcherPause(until):
 862   if until is None or until < time.time():
 863     ToStdout("The watcher is not paused.")
 864   else:
 865     ToStdout("The watcher is paused until %s.", time.ctime(until))
 866
 867
 868 def WatcherOps(opts, args):
 869   """Watcher operations.
 870
 871   @param opts: the command line options selected by the user
 872   @type args: list
 873   @param args: should contain only one element, the subcommand
 874   @rtype: int
 875   @return: the desired exit code
 876
 877   """
 878   command = args[0]
 879   client = GetClient()
 880
 881   if command == "continue":
 882     client.SetWatcherPause(None)
 883     ToStdout("The watcher is no longer paused.")
 884
 885   elif command == "pause":
 886     if len(args) < 2:
 887       raise errors.OpPrereqError("Missing pause duration", errors.ECODE_INVAL)
 888
 889     result = client.SetWatcherPause(time.time() + ParseTimespec(args[1]))
 890     _ShowWatcherPause(result)
 891
 892   elif command == "info":
 893     result = client.QueryConfigValues(["watcher_pause"])
 894     _ShowWatcherPause(result[0])
 895
 896   else:
 897     raise errors.OpPrereqError("Command '%s' is not valid." % command,
 898                                errors.ECODE_INVAL)
 899
 900   return 0
 901
 902
 903 def _OobPower(opts, node_list, power):
 904   """Puts the node in the list to desired power state.
 905
 906   @param opts: The command line options selected by the user
 907   @param node_list: The list of nodes to operate on
 908   @param power: True if they should be powered on, False otherwise
 909   @return: The success of the operation (none failed)
 910
 911   """
 912   if power:
 913     command = constants.OOB_POWER_ON
 914   else:
 915     command = constants.OOB_POWER_OFF
 916
 917   op = opcodes.OpOobCommand(node_names=node_list,
 918                             command=command,
 919                             ignore_status=True,
 920                             timeout=opts.oob_timeout,
 921                             power_delay=opts.power_delay)
 922   result = SubmitOpCode(op, opts=opts)
 923   errs = 0
 924   for node_result in result:
 925     (node_tuple, data_tuple) = node_result
 926     (_, node_name) = node_tuple
 927     (data_status, _) = data_tuple
 928     if data_status != constants.RS_NORMAL:
 929       assert data_status != constants.RS_UNAVAIL
 930       errs += 1
 931       ToStderr("There was a problem changing power for %s, please investigate",
 932                node_name)
 933
 934   if errs > 0:
 935     return False
 936
 937   return True
 938
 939
 940 def _InstanceStart(opts, inst_list, start):
 941   """Puts the instances in the list to desired state.
 942
 943   @param opts: The command line options selected by the user
 944   @param inst_list: The list of instances to operate on
 945   @param start: True if they should be started, False for shutdown
 946   @return: The success of the operation (none failed)
 947
 948   """
 949   if start:
 950     opcls = opcodes.OpInstanceStartup
 951     text_submit, text_success, text_failed = ("startup", "started", "starting")
 952   else:
 953     opcls = compat.partial(opcodes.OpInstanceShutdown,
 954                            timeout=opts.shutdown_timeout)
 955     text_submit, text_success, text_failed = ("shutdown", "stopped", "stopping")
 956
 957   jex = JobExecutor(opts=opts)
 958
 959   for inst in inst_list:
 960     ToStdout("Submit %s of instance %s", text_submit, inst)
 961     op = opcls(instance_name=inst)
 962     jex.QueueJob(inst, op)
 963
 964   results = jex.GetResults()
 965   bad_cnt = len([1 for (success, _) in results if not success])
 966
 967   if bad_cnt == 0:
 968     ToStdout("All instances have been %s successfully", text_success)
 969   else:
 970     ToStderr("There were errors while %s instances:\n"
 971              "%d error(s) out of %d instance(s)", text_failed, bad_cnt,
 972              len(results))
 973     return False
 974
 975   return True
 976
 977
 978 class _RunWhenNodesReachableHelper:
 979   """Helper class to make shared internal state sharing easier.
 980
 981   @ivar success: Indicates if all action_cb calls were successful
 982
 983   """
 984   def __init__(self, node_list, action_cb, node2ip, port, feedback_fn,
 985                _ping_fn=netutils.TcpPing, _sleep_fn=time.sleep):
 986     """Init the object.
 987
 988     @param node_list: The list of nodes to be reachable
 989     @param action_cb: Callback called when a new host is reachable
 990     @type node2ip: dict
 991     @param node2ip: Node to ip mapping
 992     @param port: The port to use for the TCP ping
 993     @param feedback_fn: The function used for feedback
 994     @param _ping_fn: Function to check reachabilty (for unittest use only)
 995     @param _sleep_fn: Function to sleep (for unittest use only)
 996
 997     """
 998     self.down = set(node_list)
 999     self.up = set()
1000     self.node2ip = node2ip
1001     self.success = True
1002     self.action_cb = action_cb
1003     self.port = port
1004     self.feedback_fn = feedback_fn
1005     self._ping_fn = _ping_fn
1006     self._sleep_fn = _sleep_fn
1007
1008   def __call__(self):
1009     """When called we run action_cb.
1010
1011     @raises utils.RetryAgain: When there are still down nodes
1012
1013     """
1014     if not self.action_cb(self.up):
1015       self.success = False
1016
1017     if self.down:
1018       raise utils.RetryAgain()
1019     else:
1020       return self.success
1021
1022   def Wait(self, secs):
1023     """Checks if a host is up or waits remaining seconds.
1024
1025     @param secs: The secs remaining
1026
1027     """
1028     start = time.time()
1029     for node in self.down:
1030       if self._ping_fn(self.node2ip[node], self.port, timeout=_EPO_PING_TIMEOUT,
1031                        live_port_needed=True):
1032         self.feedback_fn("Node %s became available" % node)
1033         self.up.add(node)
1034         self.down -= self.up
1035         # If we have a node available there is the possibility to run the
1036         # action callback successfully, therefore we don't wait and return
1037         return
1038
1039     self._sleep_fn(max(0.0, start + secs - time.time()))
1040
1041
1042 def _RunWhenNodesReachable(node_list, action_cb, interval):
1043   """Run action_cb when nodes become reachable.
1044
1045   @param node_list: The list of nodes to be reachable
1046   @param action_cb: Callback called when a new host is reachable
1047   @param interval: The earliest time to retry
1048
1049   """
1050   client = GetClient()
1051   cluster_info = client.QueryClusterInfo()
1052   if cluster_info["primary_ip_version"] == constants.IP4_VERSION:
1053     family = netutils.IPAddress.family
1054   else:
1055     family = netutils.IP6Address.family
1056
1057   node2ip = dict((node, netutils.GetHostname(node, family=family).ip)
1058                  for node in node_list)
1059
1060   port = netutils.GetDaemonPort(constants.NODED)
1061   helper = _RunWhenNodesReachableHelper(node_list, action_cb, node2ip, port,
1062                                         ToStdout)
1063
1064   try:
1065     return utils.Retry(helper, interval, _EPO_REACHABLE_TIMEOUT,
1066                        wait_fn=helper.Wait)
1067   except utils.RetryTimeout:
1068     ToStderr("Time exceeded while waiting for nodes to become reachable"
1069              " again:\n  - %s", "  - ".join(helper.down))
1070     return False
1071
1072
1073 def _MaybeInstanceStartup(opts, inst_map, nodes_online,
1074                           _instance_start_fn=_InstanceStart):
1075   """Start the instances conditional based on node_states.
1076
1077   @param opts: The command line options selected by the user
1078   @param inst_map: A dict of inst -> nodes mapping
1079   @param nodes_online: A list of nodes online
1080   @param _instance_start_fn: Callback to start instances (unittest use only)
1081   @return: Success of the operation on all instances
1082
1083   """
1084   start_inst_list = []
1085   for (inst, nodes) in inst_map.items():
1086     if not (nodes - nodes_online):
1087       # All nodes the instance lives on are back online
1088       start_inst_list.append(inst)
1089
1090   for inst in start_inst_list:
1091     del inst_map[inst]
1092
1093   if start_inst_list:
1094     return _instance_start_fn(opts, start_inst_list, True)
1095
1096   return True
1097
1098
1099 def _EpoOn(opts, full_node_list, node_list, inst_map):
1100   """Does the actual power on.
1101
1102   @param opts: The command line options selected by the user
1103   @param full_node_list: All nodes to operate on (includes nodes not supporting
1104                          OOB)
1105   @param node_list: The list of nodes to operate on (all need to support OOB)
1106   @param inst_map: A dict of inst -> nodes mapping
1107   @return: The desired exit status
1108
1109   """
1110   if node_list and not _OobPower(opts, node_list, False):
1111     ToStderr("Not all nodes seem to get back up, investigate and start"
1112              " manually if needed")
1113
1114   # Wait for the nodes to be back up
1115   action_cb = compat.partial(_MaybeInstanceStartup, opts, dict(inst_map))
1116
1117   ToStdout("Waiting until all nodes are available again")
1118   if not _RunWhenNodesReachable(full_node_list, action_cb, _EPO_PING_INTERVAL):
1119     ToStderr("Please investigate and start stopped instances manually")
1120     return constants.EXIT_FAILURE
1121
1122   return constants.EXIT_SUCCESS
1123
1124
1125 def _EpoOff(opts, node_list, inst_map):
1126   """Does the actual power off.
1127
1128   @param opts: The command line options selected by the user
1129   @param node_list: The list of nodes to operate on (all need to support OOB)
1130   @param inst_map: A dict of inst -> nodes mapping
1131   @return: The desired exit status
1132
1133   """
1134   if not _InstanceStart(opts, inst_map.keys(), False):
1135     ToStderr("Please investigate and stop instances manually before continuing")
1136     return constants.EXIT_FAILURE
1137
1138   if not node_list:
1139     return constants.EXIT_SUCCESS
1140
1141   if _OobPower(opts, node_list, False):
1142     return constants.EXIT_SUCCESS
1143   else:
1144     return constants.EXIT_FAILURE
1145
1146
1147 def Epo(opts, args):
1148   """EPO operations.
1149
1150   @param opts: the command line options selected by the user
1151   @type args: list
1152   @param args: should contain only one element, the subcommand
1153   @rtype: int
1154   @return: the desired exit code
1155
1156   """
1157   if opts.groups and opts.show_all:
1158     ToStderr("Only one of --groups or --all are allowed")
1159     return constants.EXIT_FAILURE
1160   elif args and opts.show_all:
1161     ToStderr("Arguments in combination with --all are not allowed")
1162     return constants.EXIT_FAILURE
1163
1164   client = GetClient()
1165
1166   if opts.groups:
1167     node_query_list = itertools.chain(*client.QueryGroups(names=args,
1168                                                           fields=["node_list"],
1169                                                           use_locking=False))
1170   else:
1171     node_query_list = args
1172
1173   result = client.QueryNodes(names=node_query_list,
1174                              fields=["name", "master", "pinst_list",
1175                                      "sinst_list", "powered", "offline"],
1176                              use_locking=False)
1177   node_list = []
1178   inst_map = {}
1179   for (idx, (node, master, pinsts, sinsts, powered,
1180              offline)) in enumerate(result):
1181     # Normalize the node_query_list as well
1182     if not opts.show_all:
1183       node_query_list[idx] = node
1184     if not offline:
1185       for inst in (pinsts + sinsts):
1186         if inst in inst_map:
1187           if not master:
1188             inst_map[inst].add(node)
1189         elif master:
1190           inst_map[inst] = set()
1191         else:
1192           inst_map[inst] = set([node])
1193
1194     if master and opts.on:
1195       # We ignore the master for turning on the machines, in fact we are
1196       # already operating on the master at this point :)
1197       continue
1198     elif master and not opts.show_all:
1199       ToStderr("%s is the master node, please do a master-failover to another"
1200                " node not affected by the EPO or use --all if you intend to"
1201                " shutdown the whole cluster", node)
1202       return constants.EXIT_FAILURE
1203     elif powered is None:
1204       ToStdout("Node %s does not support out-of-band handling, it can not be"
1205                " handled in a fully automated manner", node)
1206     elif powered == opts.on:
1207       ToStdout("Node %s is already in desired power state, skipping", node)
1208     elif not offline or (offline and powered):
1209       node_list.append(node)
1210
1211   if not opts.force and not ConfirmOperation(node_query_list, "nodes", "epo"):
1212     return constants.EXIT_FAILURE
1213
1214   if opts.on:
1215     return _EpoOn(opts, node_query_list, node_list, inst_map)
1216   else:
1217     return _EpoOff(opts, node_list, inst_map)
1218
1219
1220 commands = {
1221   'init': (
1222     InitCluster, [ArgHost(min=1, max=1)],
1223     [BACKEND_OPT, CP_SIZE_OPT, ENABLED_HV_OPT, GLOBAL_FILEDIR_OPT,
1224      HVLIST_OPT, MAC_PREFIX_OPT, MASTER_NETDEV_OPT, NIC_PARAMS_OPT,
1225      NOLVM_STORAGE_OPT, NOMODIFY_ETCHOSTS_OPT, NOMODIFY_SSH_SETUP_OPT,
1226      SECONDARY_IP_OPT, VG_NAME_OPT, MAINTAIN_NODE_HEALTH_OPT,
1227      UIDPOOL_OPT, DRBD_HELPER_OPT, NODRBD_STORAGE_OPT,
1228      DEFAULT_IALLOCATOR_OPT, PRIMARY_IP_VERSION_OPT, PREALLOC_WIPE_DISKS_OPT,
1229      NODE_PARAMS_OPT, GLOBAL_SHARED_FILEDIR_OPT],
1230     "[opts...] <cluster_name>", "Initialises a new cluster configuration"),
1231   'destroy': (
1232     DestroyCluster, ARGS_NONE, [YES_DOIT_OPT],
1233     "", "Destroy cluster"),
1234   'rename': (
1235     RenameCluster, [ArgHost(min=1, max=1)],
1236     [FORCE_OPT, DRY_RUN_OPT],
1237     "<new_name>",
1238     "Renames the cluster"),
1239   'redist-conf': (
1240     RedistributeConfig, ARGS_NONE, [SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT],
1241     "", "Forces a push of the configuration file and ssconf files"
1242     " to the nodes in the cluster"),
1243   'verify': (
1244     VerifyCluster, ARGS_NONE,
1245     [VERBOSE_OPT, DEBUG_SIMERR_OPT, ERROR_CODES_OPT, NONPLUS1_OPT,
1246      DRY_RUN_OPT, PRIORITY_OPT],
1247     "", "Does a check on the cluster configuration"),
1248   'verify-disks': (
1249     VerifyDisks, ARGS_NONE, [PRIORITY_OPT],
1250     "", "Does a check on the cluster disk status"),
1251   'repair-disk-sizes': (
1252     RepairDiskSizes, ARGS_MANY_INSTANCES, [DRY_RUN_OPT, PRIORITY_OPT],
1253     "", "Updates mismatches in recorded disk sizes"),
1254   'master-failover': (
1255     MasterFailover, ARGS_NONE, [NOVOTING_OPT],
1256     "", "Makes the current node the master"),
1257   'master-ping': (
1258     MasterPing, ARGS_NONE, [],
1259     "", "Checks if the master is alive"),
1260   'version': (
1261     ShowClusterVersion, ARGS_NONE, [],
1262     "", "Shows the cluster version"),
1263   'getmaster': (
1264     ShowClusterMaster, ARGS_NONE, [],
1265     "", "Shows the cluster master"),
1266   'copyfile': (
1267     ClusterCopyFile, [ArgFile(min=1, max=1)],
1268     [NODE_LIST_OPT, USE_REPL_NET_OPT],
1269     "[-n node...] <filename>", "Copies a file to all (or only some) nodes"),
1270   'command': (
1271     RunClusterCommand, [ArgCommand(min=1)],
1272     [NODE_LIST_OPT],
1273     "[-n node...] <command>", "Runs a command on all (or only some) nodes"),
1274   'info': (
1275     ShowClusterConfig, ARGS_NONE, [ROMAN_OPT],
1276     "[--roman]", "Show cluster configuration"),
1277   'list-tags': (
1278     ListTags, ARGS_NONE, [], "", "List the tags of the cluster"),
1279   'add-tags': (
1280     AddTags, [ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT],
1281     "tag...", "Add tags to the cluster"),
1282   'remove-tags': (
1283     RemoveTags, [ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT],
1284     "tag...", "Remove tags from the cluster"),
1285   'search-tags': (
1286     SearchTags, [ArgUnknown(min=1, max=1)], [PRIORITY_OPT], "",
1287     "Searches the tags on all objects on"
1288     " the cluster for a given pattern (regex)"),
1289   'queue': (
1290     QueueOps,
1291     [ArgChoice(min=1, max=1, choices=["drain", "undrain", "info"])],
1292     [], "drain|undrain|info", "Change queue properties"),
1293   'watcher': (
1294     WatcherOps,
1295     [ArgChoice(min=1, max=1, choices=["pause", "continue", "info"]),
1296      ArgSuggest(min=0, max=1, choices=["30m", "1h", "4h"])],
1297     [],
1298     "{pause <timespec>|continue|info}", "Change watcher properties"),
1299   'modify': (
1300     SetClusterParams, ARGS_NONE,
1301     [BACKEND_OPT, CP_SIZE_OPT, ENABLED_HV_OPT, HVLIST_OPT, MASTER_NETDEV_OPT,
1302      NIC_PARAMS_OPT, NOLVM_STORAGE_OPT, VG_NAME_OPT, MAINTAIN_NODE_HEALTH_OPT,
1303      UIDPOOL_OPT, ADD_UIDS_OPT, REMOVE_UIDS_OPT, DRBD_HELPER_OPT,
1304      NODRBD_STORAGE_OPT, DEFAULT_IALLOCATOR_OPT, RESERVED_LVS_OPT,
1305      DRY_RUN_OPT, PRIORITY_OPT, PREALLOC_WIPE_DISKS_OPT, NODE_PARAMS_OPT],
1306     "[opts...]",
1307     "Alters the parameters of the cluster"),
1308   "renew-crypto": (
1309     RenewCrypto, ARGS_NONE,
1310     [NEW_CLUSTER_CERT_OPT, NEW_RAPI_CERT_OPT, RAPI_CERT_OPT,
1311      NEW_CONFD_HMAC_KEY_OPT, FORCE_OPT,
1312      NEW_CLUSTER_DOMAIN_SECRET_OPT, CLUSTER_DOMAIN_SECRET_OPT],
1313     "[opts...]",
1314     "Renews cluster certificates, keys and secrets"),
1315   "epo": (
1316     Epo, [ArgUnknown()],
1317     [FORCE_OPT, ON_OPT, GROUPS_OPT, ALL_OPT, OOB_TIMEOUT_OPT,
1318      SHUTDOWN_TIMEOUT_OPT, POWER_DELAY_OPT],
1319     "[opts...] [args]",
1320     "Performs an emergency power-off on given args"),
1321   }
1322
1323
1324 #: dictionary with aliases for commands
1325 aliases = {
1326   'masterfailover': 'master-failover',
1327 }
1328
1329
1330 def Main():
1331   return GenericMain(commands, override={"tag_type": constants.TAG_CLUSTER},
1332                      aliases=aliases)