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