4 # Copyright (C) 2006, 2007, 2010, 2011, 2012 Google Inc.
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.
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.
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
21 """Cluster related commands"""
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
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 from ganeti import pathutils
48 ON_OPT = cli_option("--on", default=False,
49 action="store_true", dest="on",
50 help="Recover from an EPO")
52 GROUPS_OPT = cli_option("--groups", default=False,
53 action="store_true", dest="groups",
54 help="Arguments are node groups instead of nodes")
56 FORCE_FAILOVER = cli_option("--yes-do-it", dest="yes_do_it",
57 help="Override interactive check for --no-voting",
58 default=False, action="store_true")
60 _EPO_PING_INTERVAL = 30 # 30 seconds between pings
61 _EPO_PING_TIMEOUT = 1 # 1 second
62 _EPO_REACHABLE_TIMEOUT = 15 * 60 # 15 minutes
66 def InitCluster(opts, args):
67 """Initialize the cluster.
69 @param opts: the command line options selected by the user
71 @param args: should contain only one element, the desired
74 @return: the desired exit code
77 if not opts.lvm_storage and opts.vg_name:
78 ToStderr("Options --no-lvm-storage and --vg-name conflict.")
81 vg_name = opts.vg_name
82 if opts.lvm_storage and not opts.vg_name:
83 vg_name = constants.DEFAULT_VG
85 if not opts.drbd_storage and opts.drbd_helper:
86 ToStderr("Options --no-drbd-storage and --drbd-usermode-helper conflict.")
89 drbd_helper = opts.drbd_helper
90 if opts.drbd_storage and not opts.drbd_helper:
91 drbd_helper = constants.DEFAULT_DRBD_HELPER
93 master_netdev = opts.master_netdev
94 if master_netdev is None:
95 master_netdev = constants.DEFAULT_BRIDGE
97 hvlist = opts.enabled_hypervisors
99 hvlist = constants.DEFAULT_ENABLED_HYPERVISOR
100 hvlist = hvlist.split(",")
102 hvparams = dict(opts.hvparams)
103 beparams = opts.beparams
104 nicparams = opts.nicparams
106 diskparams = dict(opts.diskparams)
108 # check the disk template types here, as we cannot rely on the type check done
109 # by the opcode parameter types
110 diskparams_keys = set(diskparams.keys())
111 if not (diskparams_keys <= constants.DISK_TEMPLATES):
112 unknown = utils.NiceSort(diskparams_keys - constants.DISK_TEMPLATES)
113 ToStderr("Disk templates unknown: %s" % utils.CommaJoin(unknown))
116 # prepare beparams dict
117 beparams = objects.FillDict(constants.BEC_DEFAULTS, beparams)
118 utils.ForceDictType(beparams, constants.BES_PARAMETER_COMPAT)
120 # prepare nicparams dict
121 nicparams = objects.FillDict(constants.NICC_DEFAULTS, nicparams)
122 utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
124 # prepare ndparams dict
125 if opts.ndparams is None:
126 ndparams = dict(constants.NDC_DEFAULTS)
128 ndparams = objects.FillDict(constants.NDC_DEFAULTS, opts.ndparams)
129 utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
131 # prepare hvparams dict
132 for hv in constants.HYPER_TYPES:
133 if hv not in hvparams:
135 hvparams[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], hvparams[hv])
136 utils.ForceDictType(hvparams[hv], constants.HVS_PARAMETER_TYPES)
138 # prepare diskparams dict
139 for templ in constants.DISK_TEMPLATES:
140 if templ not in diskparams:
141 diskparams[templ] = {}
142 diskparams[templ] = objects.FillDict(constants.DISK_DT_DEFAULTS[templ],
144 utils.ForceDictType(diskparams[templ], constants.DISK_DT_TYPES)
146 # prepare ipolicy dict
147 ipolicy_raw = CreateIPolicyFromOpts(
148 ispecs_mem_size=opts.ispecs_mem_size,
149 ispecs_cpu_count=opts.ispecs_cpu_count,
150 ispecs_disk_count=opts.ispecs_disk_count,
151 ispecs_disk_size=opts.ispecs_disk_size,
152 ispecs_nic_count=opts.ispecs_nic_count,
153 ipolicy_disk_templates=opts.ipolicy_disk_templates,
154 ipolicy_vcpu_ratio=opts.ipolicy_vcpu_ratio,
155 ipolicy_spindle_ratio=opts.ipolicy_spindle_ratio,
157 ipolicy = objects.FillIPolicy(constants.IPOLICY_DEFAULTS, ipolicy_raw)
159 if opts.candidate_pool_size is None:
160 opts.candidate_pool_size = constants.MASTER_POOL_SIZE_DEFAULT
162 if opts.mac_prefix is None:
163 opts.mac_prefix = constants.DEFAULT_MAC_PREFIX
165 uid_pool = opts.uid_pool
166 if uid_pool is not None:
167 uid_pool = uidpool.ParseUidPool(uid_pool)
169 if opts.prealloc_wipe_disks is None:
170 opts.prealloc_wipe_disks = False
172 external_ip_setup_script = opts.use_external_mip_script
173 if external_ip_setup_script is None:
174 external_ip_setup_script = False
177 primary_ip_version = int(opts.primary_ip_version)
178 except (ValueError, TypeError), err:
179 ToStderr("Invalid primary ip version value: %s" % str(err))
182 master_netmask = opts.master_netmask
184 if master_netmask is not None:
185 master_netmask = int(master_netmask)
186 except (ValueError, TypeError), err:
187 ToStderr("Invalid master netmask value: %s" % str(err))
191 disk_state = utils.FlatToDict(opts.disk_state)
195 hv_state = dict(opts.hv_state)
197 bootstrap.InitCluster(cluster_name=args[0],
198 secondary_ip=opts.secondary_ip,
200 mac_prefix=opts.mac_prefix,
201 master_netmask=master_netmask,
202 master_netdev=master_netdev,
203 file_storage_dir=opts.file_storage_dir,
204 shared_file_storage_dir=opts.shared_file_storage_dir,
205 enabled_hypervisors=hvlist,
210 diskparams=diskparams,
212 candidate_pool_size=opts.candidate_pool_size,
213 modify_etc_hosts=opts.modify_etc_hosts,
214 modify_ssh_setup=opts.modify_ssh_setup,
215 maintain_node_health=opts.maintain_node_health,
216 drbd_helper=drbd_helper,
218 default_iallocator=opts.default_iallocator,
219 primary_ip_version=primary_ip_version,
220 prealloc_wipe_disks=opts.prealloc_wipe_disks,
221 use_external_mip_script=external_ip_setup_script,
223 disk_state=disk_state,
225 op = opcodes.OpClusterPostInit()
226 SubmitOpCode(op, opts=opts)
231 def DestroyCluster(opts, args):
232 """Destroy the cluster.
234 @param opts: the command line options selected by the user
236 @param args: should be an empty list
238 @return: the desired exit code
241 if not opts.yes_do_it:
242 ToStderr("Destroying a cluster is irreversible. If you really want"
243 " destroy this cluster, supply the --yes-do-it option.")
246 op = opcodes.OpClusterDestroy()
247 master = SubmitOpCode(op, opts=opts)
248 # if we reached this, the opcode didn't fail; we can proceed to
249 # shutdown all the daemons
250 bootstrap.FinalizeClusterDestroy(master)
254 def RenameCluster(opts, args):
255 """Rename the cluster.
257 @param opts: the command line options selected by the user
259 @param args: should contain only one element, the new cluster name
261 @return: the desired exit code
266 (cluster_name, ) = cl.QueryConfigValues(["cluster_name"])
270 usertext = ("This will rename the cluster from '%s' to '%s'. If you are"
271 " connected over the network to the cluster name, the"
272 " operation is very dangerous as the IP address will be"
273 " removed from the node and the change may not go through."
274 " Continue?") % (cluster_name, new_name)
275 if not AskUser(usertext):
278 op = opcodes.OpClusterRename(name=new_name)
279 result = SubmitOpCode(op, opts=opts, cl=cl)
282 ToStdout("Cluster renamed from '%s' to '%s'", cluster_name, result)
287 def ActivateMasterIp(opts, args):
288 """Activates the master IP.
291 op = opcodes.OpClusterActivateMasterIp()
296 def DeactivateMasterIp(opts, args):
297 """Deactivates the master IP.
301 usertext = ("This will disable the master IP. All the open connections to"
302 " the master IP will be closed. To reach the master you will"
303 " need to use its node IP."
305 if not AskUser(usertext):
308 op = opcodes.OpClusterDeactivateMasterIp()
313 def RedistributeConfig(opts, args):
314 """Forces push of the cluster configuration.
316 @param opts: the command line options selected by the user
318 @param args: empty list
320 @return: the desired exit code
323 op = opcodes.OpClusterRedistConf()
324 SubmitOrSend(op, opts)
328 def ShowClusterVersion(opts, args):
329 """Write version of ganeti software to the standard output.
331 @param opts: the command line options selected by the user
333 @param args: should be an empty list
335 @return: the desired exit code
338 cl = GetClient(query=True)
339 result = cl.QueryClusterInfo()
340 ToStdout("Software version: %s", result["software_version"])
341 ToStdout("Internode protocol: %s", result["protocol_version"])
342 ToStdout("Configuration format: %s", result["config_version"])
343 ToStdout("OS api version: %s", result["os_api_version"])
344 ToStdout("Export interface: %s", result["export_version"])
348 def ShowClusterMaster(opts, args):
349 """Write name of master node to the standard output.
351 @param opts: the command line options selected by the user
353 @param args: should be an empty list
355 @return: the desired exit code
358 master = bootstrap.GetMaster()
363 def _PrintGroupedParams(paramsdict, level=1, roman=False):
364 """Print Grouped parameters (be, nic, disk) by group.
366 @type paramsdict: dict of dicts
367 @param paramsdict: {group: {param: value, ...}, ...}
369 @param level: Level of indention
373 for item, val in sorted(paramsdict.items()):
374 if isinstance(val, dict):
375 ToStdout("%s- %s:", indent, item)
376 _PrintGroupedParams(val, level=level + 1, roman=roman)
377 elif roman and isinstance(val, int):
378 ToStdout("%s %s: %s", indent, item, compat.TryToRoman(val))
380 ToStdout("%s %s: %s", indent, item, val)
383 def ShowClusterConfig(opts, args):
384 """Shows cluster information.
386 @param opts: the command line options selected by the user
388 @param args: should be an empty list
390 @return: the desired exit code
393 cl = GetClient(query=True)
394 result = cl.QueryClusterInfo()
396 ToStdout("Cluster name: %s", result["name"])
397 ToStdout("Cluster UUID: %s", result["uuid"])
399 ToStdout("Creation time: %s", utils.FormatTime(result["ctime"]))
400 ToStdout("Modification time: %s", utils.FormatTime(result["mtime"]))
402 ToStdout("Master node: %s", result["master"])
404 ToStdout("Architecture (this node): %s (%s)",
405 result["architecture"][0], result["architecture"][1])
408 tags = utils.CommaJoin(utils.NiceSort(result["tags"]))
412 ToStdout("Tags: %s", tags)
414 ToStdout("Default hypervisor: %s", result["default_hypervisor"])
415 ToStdout("Enabled hypervisors: %s",
416 utils.CommaJoin(result["enabled_hypervisors"]))
418 ToStdout("Hypervisor parameters:")
419 _PrintGroupedParams(result["hvparams"])
421 ToStdout("OS-specific hypervisor parameters:")
422 _PrintGroupedParams(result["os_hvp"])
424 ToStdout("OS parameters:")
425 _PrintGroupedParams(result["osparams"])
427 ToStdout("Hidden OSes: %s", utils.CommaJoin(result["hidden_os"]))
428 ToStdout("Blacklisted OSes: %s", utils.CommaJoin(result["blacklisted_os"]))
430 ToStdout("Cluster parameters:")
431 ToStdout(" - candidate pool size: %s",
432 compat.TryToRoman(result["candidate_pool_size"],
433 convert=opts.roman_integers))
434 ToStdout(" - master netdev: %s", result["master_netdev"])
435 ToStdout(" - master netmask: %s", result["master_netmask"])
436 ToStdout(" - use external master IP address setup script: %s",
437 result["use_external_mip_script"])
438 ToStdout(" - lvm volume group: %s", result["volume_group_name"])
439 if result["reserved_lvs"]:
440 reserved_lvs = utils.CommaJoin(result["reserved_lvs"])
442 reserved_lvs = "(none)"
443 ToStdout(" - lvm reserved volumes: %s", reserved_lvs)
444 ToStdout(" - drbd usermode helper: %s", result["drbd_usermode_helper"])
445 ToStdout(" - file storage path: %s", result["file_storage_dir"])
446 ToStdout(" - shared file storage path: %s",
447 result["shared_file_storage_dir"])
448 ToStdout(" - maintenance of node health: %s",
449 result["maintain_node_health"])
450 ToStdout(" - uid pool: %s",
451 uidpool.FormatUidPool(result["uid_pool"],
452 roman=opts.roman_integers))
453 ToStdout(" - default instance allocator: %s", result["default_iallocator"])
454 ToStdout(" - primary ip version: %d", result["primary_ip_version"])
455 ToStdout(" - preallocation wipe disks: %s", result["prealloc_wipe_disks"])
456 ToStdout(" - OS search path: %s", utils.CommaJoin(pathutils.OS_SEARCH_PATH))
458 ToStdout("Default node parameters:")
459 _PrintGroupedParams(result["ndparams"], roman=opts.roman_integers)
461 ToStdout("Default instance parameters:")
462 _PrintGroupedParams(result["beparams"], roman=opts.roman_integers)
464 ToStdout("Default nic parameters:")
465 _PrintGroupedParams(result["nicparams"], roman=opts.roman_integers)
467 ToStdout("Default disk parameters:")
468 _PrintGroupedParams(result["diskparams"], roman=opts.roman_integers)
470 ToStdout("Instance policy - limits for instances:")
471 for key in constants.IPOLICY_ISPECS:
472 ToStdout(" - %s", key)
473 _PrintGroupedParams(result["ipolicy"][key], roman=opts.roman_integers)
474 ToStdout(" - enabled disk templates: %s",
475 utils.CommaJoin(result["ipolicy"][constants.IPOLICY_DTS]))
476 for key in constants.IPOLICY_PARAMETERS:
477 ToStdout(" - %s: %s", key, result["ipolicy"][key])
482 def ClusterCopyFile(opts, args):
483 """Copy a file from master to some nodes.
485 @param opts: the command line options selected by the user
487 @param args: should contain only one element, the path of
488 the file to be copied
490 @return: the desired exit code
494 if not os.path.exists(filename):
495 raise errors.OpPrereqError("No such filename '%s'" % filename,
500 cluster_name = cl.QueryConfigValues(["cluster_name"])[0]
502 results = GetOnlineNodes(nodes=opts.nodes, cl=cl, filter_master=True,
503 secondary_ips=opts.use_replication_network,
504 nodegroup=opts.nodegroup)
506 srun = ssh.SshRunner(cluster_name)
508 if not srun.CopyFileToNode(node, filename):
509 ToStderr("Copy of file %s to node %s failed", filename, node)
514 def RunClusterCommand(opts, args):
515 """Run a command on some nodes.
517 @param opts: the command line options selected by the user
519 @param args: should contain the command to be run and its arguments
521 @return: the desired exit code
526 command = " ".join(args)
528 nodes = GetOnlineNodes(nodes=opts.nodes, cl=cl, nodegroup=opts.nodegroup)
530 cluster_name, master_node = cl.QueryConfigValues(["cluster_name",
533 srun = ssh.SshRunner(cluster_name=cluster_name)
535 # Make sure master node is at list end
536 if master_node in nodes:
537 nodes.remove(master_node)
538 nodes.append(master_node)
541 result = srun.Run(name, constants.SSH_LOGIN_USER, command)
543 if opts.failure_only and result.exit_code == constants.EXIT_SUCCESS:
544 # Do not output anything for successful commands
547 ToStdout("------------------------------------------------")
548 if opts.show_machine_names:
549 for line in result.output.splitlines():
550 ToStdout("%s: %s", name, line)
552 ToStdout("node: %s", name)
553 ToStdout("%s", result.output)
554 ToStdout("return code = %s", result.exit_code)
559 def VerifyCluster(opts, args):
560 """Verify integrity of cluster, performing various test on nodes.
562 @param opts: the command line options selected by the user
564 @param args: should be an empty list
566 @return: the desired exit code
571 if opts.skip_nplusone_mem:
572 skip_checks.append(constants.VERIFY_NPLUSONE_MEM)
576 op = opcodes.OpClusterVerify(verbose=opts.verbose,
577 error_codes=opts.error_codes,
578 debug_simulate_errors=opts.simulate_errors,
579 skip_checks=skip_checks,
580 ignore_errors=opts.ignore_errors,
581 group_name=opts.nodegroup)
582 result = SubmitOpCode(op, cl=cl, opts=opts)
584 # Keep track of submitted jobs
585 jex = JobExecutor(cl=cl, opts=opts)
587 for (status, job_id) in result[constants.JOB_IDS_KEY]:
588 jex.AddJobId(None, status, job_id)
590 results = jex.GetResults()
592 (bad_jobs, bad_results) = \
594 # Convert iterators to lists
597 map(compat.partial(itertools.ifilterfalse, bool),
598 # Convert result to booleans in a tuple
599 zip(*((job_success, len(op_results) == 1 and op_results[0])
600 for (job_success, op_results) in results)))))
602 if bad_jobs == 0 and bad_results == 0:
603 rcode = constants.EXIT_SUCCESS
605 rcode = constants.EXIT_FAILURE
607 ToStdout("%s job(s) failed while verifying the cluster.", bad_jobs)
612 def VerifyDisks(opts, args):
613 """Verify integrity of cluster disks.
615 @param opts: the command line options selected by the user
617 @param args: should be an empty list
619 @return: the desired exit code
624 op = opcodes.OpClusterVerifyDisks()
626 result = SubmitOpCode(op, cl=cl, opts=opts)
628 # Keep track of submitted jobs
629 jex = JobExecutor(cl=cl, opts=opts)
631 for (status, job_id) in result[constants.JOB_IDS_KEY]:
632 jex.AddJobId(None, status, job_id)
634 retcode = constants.EXIT_SUCCESS
636 for (status, result) in jex.GetResults():
638 ToStdout("Job failed: %s", result)
641 ((bad_nodes, instances, missing), ) = result
643 for node, text in bad_nodes.items():
644 ToStdout("Error gathering data on node %s: %s",
645 node, utils.SafeEncode(text[-400:]))
646 retcode = constants.EXIT_FAILURE
647 ToStdout("You need to fix these nodes first before fixing instances")
649 for iname in instances:
652 op = opcodes.OpInstanceActivateDisks(instance_name=iname)
654 ToStdout("Activating disks for instance '%s'", iname)
655 SubmitOpCode(op, opts=opts, cl=cl)
656 except errors.GenericError, err:
657 nret, msg = FormatError(err)
659 ToStderr("Error activating disks for instance %s: %s", iname, msg)
662 for iname, ival in missing.iteritems():
663 all_missing = compat.all(x[0] in bad_nodes for x in ival)
665 ToStdout("Instance %s cannot be verified as it lives on"
666 " broken nodes", iname)
668 ToStdout("Instance %s has missing logical volumes:", iname)
670 for node, vol in ival:
671 if node in bad_nodes:
672 ToStdout("\tbroken node %s /dev/%s", node, vol)
674 ToStdout("\t%s /dev/%s", node, vol)
676 ToStdout("You need to replace or recreate disks for all the above"
677 " instances if this message persists after fixing broken nodes.")
678 retcode = constants.EXIT_FAILURE
680 ToStdout("No disks need to be activated.")
685 def RepairDiskSizes(opts, args):
686 """Verify sizes of cluster disks.
688 @param opts: the command line options selected by the user
690 @param args: optional list of instances to restrict check to
692 @return: the desired exit code
695 op = opcodes.OpClusterRepairDiskSizes(instances=args)
696 SubmitOpCode(op, opts=opts)
700 def MasterFailover(opts, args):
701 """Failover the master node.
703 This command, when run on a non-master node, will cause the current
704 master to cease being master, and the non-master to become new
707 @param opts: the command line options selected by the user
709 @param args: should be an empty list
711 @return: the desired exit code
714 if opts.no_voting and not opts.yes_do_it:
715 usertext = ("This will perform the failover even if most other nodes"
716 " are down, or if this node is outdated. This is dangerous"
717 " as it can lead to a non-consistent cluster. Check the"
718 " gnt-cluster(8) man page before proceeding. Continue?")
719 if not AskUser(usertext):
722 return bootstrap.MasterFailover(no_voting=opts.no_voting)
725 def MasterPing(opts, args):
726 """Checks if the master is alive.
728 @param opts: the command line options selected by the user
730 @param args: should be an empty list
732 @return: the desired exit code
737 cl.QueryClusterInfo()
739 except Exception: # pylint: disable=W0703
743 def SearchTags(opts, args):
744 """Searches the tags on all the cluster.
746 @param opts: the command line options selected by the user
748 @param args: should contain only one element, the tag pattern
750 @return: the desired exit code
753 op = opcodes.OpTagsSearch(pattern=args[0])
754 result = SubmitOpCode(op, opts=opts)
757 result = list(result)
759 for path, tag in result:
760 ToStdout("%s %s", path, tag)
763 def _ReadAndVerifyCert(cert_filename, verify_private_key=False):
764 """Reads and verifies an X509 certificate.
766 @type cert_filename: string
767 @param cert_filename: the path of the file containing the certificate to
768 verify encoded in PEM format
769 @type verify_private_key: bool
770 @param verify_private_key: whether to verify the private key in addition to
771 the public certificate
773 @return: a string containing the PEM-encoded certificate.
777 pem = utils.ReadFile(cert_filename)
779 raise errors.X509CertError(cert_filename,
780 "Unable to read certificate: %s" % str(err))
783 OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM, pem)
784 except Exception, err:
785 raise errors.X509CertError(cert_filename,
786 "Unable to load certificate: %s" % str(err))
788 if verify_private_key:
790 OpenSSL.crypto.load_privatekey(OpenSSL.crypto.FILETYPE_PEM, pem)
791 except Exception, err:
792 raise errors.X509CertError(cert_filename,
793 "Unable to load private key: %s" % str(err))
798 def _RenewCrypto(new_cluster_cert, new_rapi_cert, # pylint: disable=R0911
799 rapi_cert_filename, new_spice_cert, spice_cert_filename,
800 spice_cacert_filename, new_confd_hmac_key, new_cds,
801 cds_filename, force):
802 """Renews cluster certificates, keys and secrets.
804 @type new_cluster_cert: bool
805 @param new_cluster_cert: Whether to generate a new cluster certificate
806 @type new_rapi_cert: bool
807 @param new_rapi_cert: Whether to generate a new RAPI certificate
808 @type rapi_cert_filename: string
809 @param rapi_cert_filename: Path to file containing new RAPI certificate
810 @type new_spice_cert: bool
811 @param new_spice_cert: Whether to generate a new SPICE certificate
812 @type spice_cert_filename: string
813 @param spice_cert_filename: Path to file containing new SPICE certificate
814 @type spice_cacert_filename: string
815 @param spice_cacert_filename: Path to file containing the certificate of the
816 CA that signed the SPICE certificate
817 @type new_confd_hmac_key: bool
818 @param new_confd_hmac_key: Whether to generate a new HMAC key
820 @param new_cds: Whether to generate a new cluster domain secret
821 @type cds_filename: string
822 @param cds_filename: Path to file containing new cluster domain secret
824 @param force: Whether to ask user for confirmation
827 if new_rapi_cert and rapi_cert_filename:
828 ToStderr("Only one of the --new-rapi-certificate and --rapi-certificate"
829 " options can be specified at the same time.")
832 if new_cds and cds_filename:
833 ToStderr("Only one of the --new-cluster-domain-secret and"
834 " --cluster-domain-secret options can be specified at"
838 if new_spice_cert and (spice_cert_filename or spice_cacert_filename):
839 ToStderr("When using --new-spice-certificate, the --spice-certificate"
840 " and --spice-ca-certificate must not be used.")
843 if bool(spice_cacert_filename) ^ bool(spice_cert_filename):
844 ToStderr("Both --spice-certificate and --spice-ca-certificate must be"
848 rapi_cert_pem, spice_cert_pem, spice_cacert_pem = (None, None, None)
850 if rapi_cert_filename:
851 rapi_cert_pem = _ReadAndVerifyCert(rapi_cert_filename, True)
852 if spice_cert_filename:
853 spice_cert_pem = _ReadAndVerifyCert(spice_cert_filename, True)
854 spice_cacert_pem = _ReadAndVerifyCert(spice_cacert_filename)
855 except errors.X509CertError, err:
856 ToStderr("Unable to load X509 certificate from %s: %s", err[0], err[1])
861 cds = utils.ReadFile(cds_filename)
862 except Exception, err: # pylint: disable=W0703
863 ToStderr("Can't load new cluster domain secret from %s: %s" %
864 (cds_filename, str(err)))
870 usertext = ("This requires all daemons on all nodes to be restarted and"
871 " may take some time. Continue?")
872 if not AskUser(usertext):
875 def _RenewCryptoInner(ctx):
876 ctx.feedback_fn("Updating certificates and keys")
877 bootstrap.GenerateClusterCrypto(new_cluster_cert,
882 rapi_cert_pem=rapi_cert_pem,
883 spice_cert_pem=spice_cert_pem,
884 spice_cacert_pem=spice_cacert_pem,
890 files_to_copy.append(pathutils.NODED_CERT_FILE)
892 if new_rapi_cert or rapi_cert_pem:
893 files_to_copy.append(pathutils.RAPI_CERT_FILE)
895 if new_spice_cert or spice_cert_pem:
896 files_to_copy.append(pathutils.SPICE_CERT_FILE)
897 files_to_copy.append(pathutils.SPICE_CACERT_FILE)
899 if new_confd_hmac_key:
900 files_to_copy.append(pathutils.CONFD_HMAC_KEY)
903 files_to_copy.append(pathutils.CLUSTER_DOMAIN_SECRET_FILE)
906 for node_name in ctx.nonmaster_nodes:
907 ctx.feedback_fn("Copying %s to %s" %
908 (", ".join(files_to_copy), node_name))
909 for file_name in files_to_copy:
910 ctx.ssh.CopyFileToNode(node_name, file_name)
912 RunWhileClusterStopped(ToStdout, _RenewCryptoInner)
914 ToStdout("All requested certificates and keys have been replaced."
915 " Running \"gnt-cluster verify\" now is recommended.")
920 def RenewCrypto(opts, args):
921 """Renews cluster certificates, keys and secrets.
924 return _RenewCrypto(opts.new_cluster_cert,
930 opts.new_confd_hmac_key,
931 opts.new_cluster_domain_secret,
932 opts.cluster_domain_secret,
936 def SetClusterParams(opts, args):
937 """Modify the cluster.
939 @param opts: the command line options selected by the user
941 @param args: should be an empty list
943 @return: the desired exit code
946 if not (not opts.lvm_storage or opts.vg_name or
947 not opts.drbd_storage or opts.drbd_helper or
948 opts.enabled_hypervisors or opts.hvparams or
949 opts.beparams or opts.nicparams or
950 opts.ndparams or opts.diskparams or
951 opts.candidate_pool_size is not None or
952 opts.uid_pool is not None or
953 opts.maintain_node_health is not None or
954 opts.add_uids is not None or
955 opts.remove_uids is not None or
956 opts.default_iallocator is not None or
957 opts.reserved_lvs is not None or
958 opts.master_netdev is not None or
959 opts.master_netmask is not None or
960 opts.use_external_mip_script is not None or
961 opts.prealloc_wipe_disks is not None or
964 opts.ispecs_mem_size or
965 opts.ispecs_cpu_count or
966 opts.ispecs_disk_count or
967 opts.ispecs_disk_size or
968 opts.ispecs_nic_count or
969 opts.ipolicy_disk_templates is not None or
970 opts.ipolicy_vcpu_ratio is not None or
971 opts.ipolicy_spindle_ratio is not None):
972 ToStderr("Please give at least one of the parameters.")
975 vg_name = opts.vg_name
976 if not opts.lvm_storage and opts.vg_name:
977 ToStderr("Options --no-lvm-storage and --vg-name conflict.")
980 if not opts.lvm_storage:
983 drbd_helper = opts.drbd_helper
984 if not opts.drbd_storage and opts.drbd_helper:
985 ToStderr("Options --no-drbd-storage and --drbd-usermode-helper conflict.")
988 if not opts.drbd_storage:
991 hvlist = opts.enabled_hypervisors
992 if hvlist is not None:
993 hvlist = hvlist.split(",")
995 # a list of (name, dict) we can pass directly to dict() (or [])
996 hvparams = dict(opts.hvparams)
997 for hv_params in hvparams.values():
998 utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
1000 diskparams = dict(opts.diskparams)
1002 for dt_params in diskparams.values():
1003 utils.ForceDictType(dt_params, constants.DISK_DT_TYPES)
1005 beparams = opts.beparams
1006 utils.ForceDictType(beparams, constants.BES_PARAMETER_COMPAT)
1008 nicparams = opts.nicparams
1009 utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
1011 ndparams = opts.ndparams
1012 if ndparams is not None:
1013 utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
1015 ipolicy = CreateIPolicyFromOpts(
1016 ispecs_mem_size=opts.ispecs_mem_size,
1017 ispecs_cpu_count=opts.ispecs_cpu_count,
1018 ispecs_disk_count=opts.ispecs_disk_count,
1019 ispecs_disk_size=opts.ispecs_disk_size,
1020 ispecs_nic_count=opts.ispecs_nic_count,
1021 ipolicy_disk_templates=opts.ipolicy_disk_templates,
1022 ipolicy_vcpu_ratio=opts.ipolicy_vcpu_ratio,
1023 ipolicy_spindle_ratio=opts.ipolicy_spindle_ratio,
1026 mnh = opts.maintain_node_health
1028 uid_pool = opts.uid_pool
1029 if uid_pool is not None:
1030 uid_pool = uidpool.ParseUidPool(uid_pool)
1032 add_uids = opts.add_uids
1033 if add_uids is not None:
1034 add_uids = uidpool.ParseUidPool(add_uids)
1036 remove_uids = opts.remove_uids
1037 if remove_uids is not None:
1038 remove_uids = uidpool.ParseUidPool(remove_uids)
1040 if opts.reserved_lvs is not None:
1041 if opts.reserved_lvs == "":
1042 opts.reserved_lvs = []
1044 opts.reserved_lvs = utils.UnescapeAndSplit(opts.reserved_lvs, sep=",")
1046 if opts.master_netmask is not None:
1048 opts.master_netmask = int(opts.master_netmask)
1050 ToStderr("The --master-netmask option expects an int parameter.")
1053 ext_ip_script = opts.use_external_mip_script
1056 disk_state = utils.FlatToDict(opts.disk_state)
1060 hv_state = dict(opts.hv_state)
1062 op = opcodes.OpClusterSetParams(vg_name=vg_name,
1063 drbd_helper=drbd_helper,
1064 enabled_hypervisors=hvlist,
1068 nicparams=nicparams,
1070 diskparams=diskparams,
1072 candidate_pool_size=opts.candidate_pool_size,
1073 maintain_node_health=mnh,
1076 remove_uids=remove_uids,
1077 default_iallocator=opts.default_iallocator,
1078 prealloc_wipe_disks=opts.prealloc_wipe_disks,
1079 master_netdev=opts.master_netdev,
1080 master_netmask=opts.master_netmask,
1081 reserved_lvs=opts.reserved_lvs,
1082 use_external_mip_script=ext_ip_script,
1084 disk_state=disk_state,
1086 SubmitOrSend(op, opts)
1090 def QueueOps(opts, args):
1091 """Queue operations.
1093 @param opts: the command line options selected by the user
1095 @param args: should contain only one element, the subcommand
1097 @return: the desired exit code
1101 client = GetClient()
1102 if command in ("drain", "undrain"):
1103 drain_flag = command == "drain"
1104 client.SetQueueDrainFlag(drain_flag)
1105 elif command == "info":
1106 result = client.QueryConfigValues(["drain_flag"])
1111 ToStdout("The drain flag is %s" % val)
1113 raise errors.OpPrereqError("Command '%s' is not valid." % command,
1119 def _ShowWatcherPause(until):
1120 if until is None or until < time.time():
1121 ToStdout("The watcher is not paused.")
1123 ToStdout("The watcher is paused until %s.", time.ctime(until))
1126 def WatcherOps(opts, args):
1127 """Watcher operations.
1129 @param opts: the command line options selected by the user
1131 @param args: should contain only one element, the subcommand
1133 @return: the desired exit code
1137 client = GetClient()
1139 if command == "continue":
1140 client.SetWatcherPause(None)
1141 ToStdout("The watcher is no longer paused.")
1143 elif command == "pause":
1145 raise errors.OpPrereqError("Missing pause duration", errors.ECODE_INVAL)
1147 result = client.SetWatcherPause(time.time() + ParseTimespec(args[1]))
1148 _ShowWatcherPause(result)
1150 elif command == "info":
1151 result = client.QueryConfigValues(["watcher_pause"])
1152 _ShowWatcherPause(result[0])
1155 raise errors.OpPrereqError("Command '%s' is not valid." % command,
1161 def _OobPower(opts, node_list, power):
1162 """Puts the node in the list to desired power state.
1164 @param opts: The command line options selected by the user
1165 @param node_list: The list of nodes to operate on
1166 @param power: True if they should be powered on, False otherwise
1167 @return: The success of the operation (none failed)
1171 command = constants.OOB_POWER_ON
1173 command = constants.OOB_POWER_OFF
1175 op = opcodes.OpOobCommand(node_names=node_list,
1178 timeout=opts.oob_timeout,
1179 power_delay=opts.power_delay)
1180 result = SubmitOpCode(op, opts=opts)
1182 for node_result in result:
1183 (node_tuple, data_tuple) = node_result
1184 (_, node_name) = node_tuple
1185 (data_status, _) = data_tuple
1186 if data_status != constants.RS_NORMAL:
1187 assert data_status != constants.RS_UNAVAIL
1189 ToStderr("There was a problem changing power for %s, please investigate",
1198 def _InstanceStart(opts, inst_list, start, no_remember=False):
1199 """Puts the instances in the list to desired state.
1201 @param opts: The command line options selected by the user
1202 @param inst_list: The list of instances to operate on
1203 @param start: True if they should be started, False for shutdown
1204 @param no_remember: If the instance state should be remembered
1205 @return: The success of the operation (none failed)
1209 opcls = opcodes.OpInstanceStartup
1210 text_submit, text_success, text_failed = ("startup", "started", "starting")
1212 opcls = compat.partial(opcodes.OpInstanceShutdown,
1213 timeout=opts.shutdown_timeout,
1214 no_remember=no_remember)
1215 text_submit, text_success, text_failed = ("shutdown", "stopped", "stopping")
1217 jex = JobExecutor(opts=opts)
1219 for inst in inst_list:
1220 ToStdout("Submit %s of instance %s", text_submit, inst)
1221 op = opcls(instance_name=inst)
1222 jex.QueueJob(inst, op)
1224 results = jex.GetResults()
1225 bad_cnt = len([1 for (success, _) in results if not success])
1228 ToStdout("All instances have been %s successfully", text_success)
1230 ToStderr("There were errors while %s instances:\n"
1231 "%d error(s) out of %d instance(s)", text_failed, bad_cnt,
1238 class _RunWhenNodesReachableHelper:
1239 """Helper class to make shared internal state sharing easier.
1241 @ivar success: Indicates if all action_cb calls were successful
1244 def __init__(self, node_list, action_cb, node2ip, port, feedback_fn,
1245 _ping_fn=netutils.TcpPing, _sleep_fn=time.sleep):
1248 @param node_list: The list of nodes to be reachable
1249 @param action_cb: Callback called when a new host is reachable
1251 @param node2ip: Node to ip mapping
1252 @param port: The port to use for the TCP ping
1253 @param feedback_fn: The function used for feedback
1254 @param _ping_fn: Function to check reachabilty (for unittest use only)
1255 @param _sleep_fn: Function to sleep (for unittest use only)
1258 self.down = set(node_list)
1260 self.node2ip = node2ip
1262 self.action_cb = action_cb
1264 self.feedback_fn = feedback_fn
1265 self._ping_fn = _ping_fn
1266 self._sleep_fn = _sleep_fn
1269 """When called we run action_cb.
1271 @raises utils.RetryAgain: When there are still down nodes
1274 if not self.action_cb(self.up):
1275 self.success = False
1278 raise utils.RetryAgain()
1282 def Wait(self, secs):
1283 """Checks if a host is up or waits remaining seconds.
1285 @param secs: The secs remaining
1289 for node in self.down:
1290 if self._ping_fn(self.node2ip[node], self.port, timeout=_EPO_PING_TIMEOUT,
1291 live_port_needed=True):
1292 self.feedback_fn("Node %s became available" % node)
1294 self.down -= self.up
1295 # If we have a node available there is the possibility to run the
1296 # action callback successfully, therefore we don't wait and return
1299 self._sleep_fn(max(0.0, start + secs - time.time()))
1302 def _RunWhenNodesReachable(node_list, action_cb, interval):
1303 """Run action_cb when nodes become reachable.
1305 @param node_list: The list of nodes to be reachable
1306 @param action_cb: Callback called when a new host is reachable
1307 @param interval: The earliest time to retry
1310 client = GetClient()
1311 cluster_info = client.QueryClusterInfo()
1312 if cluster_info["primary_ip_version"] == constants.IP4_VERSION:
1313 family = netutils.IPAddress.family
1315 family = netutils.IP6Address.family
1317 node2ip = dict((node, netutils.GetHostname(node, family=family).ip)
1318 for node in node_list)
1320 port = netutils.GetDaemonPort(constants.NODED)
1321 helper = _RunWhenNodesReachableHelper(node_list, action_cb, node2ip, port,
1325 return utils.Retry(helper, interval, _EPO_REACHABLE_TIMEOUT,
1326 wait_fn=helper.Wait)
1327 except utils.RetryTimeout:
1328 ToStderr("Time exceeded while waiting for nodes to become reachable"
1329 " again:\n - %s", " - ".join(helper.down))
1333 def _MaybeInstanceStartup(opts, inst_map, nodes_online,
1334 _instance_start_fn=_InstanceStart):
1335 """Start the instances conditional based on node_states.
1337 @param opts: The command line options selected by the user
1338 @param inst_map: A dict of inst -> nodes mapping
1339 @param nodes_online: A list of nodes online
1340 @param _instance_start_fn: Callback to start instances (unittest use only)
1341 @return: Success of the operation on all instances
1344 start_inst_list = []
1345 for (inst, nodes) in inst_map.items():
1346 if not (nodes - nodes_online):
1347 # All nodes the instance lives on are back online
1348 start_inst_list.append(inst)
1350 for inst in start_inst_list:
1354 return _instance_start_fn(opts, start_inst_list, True)
1359 def _EpoOn(opts, full_node_list, node_list, inst_map):
1360 """Does the actual power on.
1362 @param opts: The command line options selected by the user
1363 @param full_node_list: All nodes to operate on (includes nodes not supporting
1365 @param node_list: The list of nodes to operate on (all need to support OOB)
1366 @param inst_map: A dict of inst -> nodes mapping
1367 @return: The desired exit status
1370 if node_list and not _OobPower(opts, node_list, False):
1371 ToStderr("Not all nodes seem to get back up, investigate and start"
1372 " manually if needed")
1374 # Wait for the nodes to be back up
1375 action_cb = compat.partial(_MaybeInstanceStartup, opts, dict(inst_map))
1377 ToStdout("Waiting until all nodes are available again")
1378 if not _RunWhenNodesReachable(full_node_list, action_cb, _EPO_PING_INTERVAL):
1379 ToStderr("Please investigate and start stopped instances manually")
1380 return constants.EXIT_FAILURE
1382 return constants.EXIT_SUCCESS
1385 def _EpoOff(opts, node_list, inst_map):
1386 """Does the actual power off.
1388 @param opts: The command line options selected by the user
1389 @param node_list: The list of nodes to operate on (all need to support OOB)
1390 @param inst_map: A dict of inst -> nodes mapping
1391 @return: The desired exit status
1394 if not _InstanceStart(opts, inst_map.keys(), False, no_remember=True):
1395 ToStderr("Please investigate and stop instances manually before continuing")
1396 return constants.EXIT_FAILURE
1399 return constants.EXIT_SUCCESS
1401 if _OobPower(opts, node_list, False):
1402 return constants.EXIT_SUCCESS
1404 return constants.EXIT_FAILURE
1407 def Epo(opts, args, cl=None, _on_fn=_EpoOn, _off_fn=_EpoOff,
1408 _confirm_fn=ConfirmOperation,
1409 _stdout_fn=ToStdout, _stderr_fn=ToStderr):
1412 @param opts: the command line options selected by the user
1414 @param args: should contain only one element, the subcommand
1416 @return: the desired exit code
1419 if opts.groups and opts.show_all:
1420 _stderr_fn("Only one of --groups or --all are allowed")
1421 return constants.EXIT_FAILURE
1422 elif args and opts.show_all:
1423 _stderr_fn("Arguments in combination with --all are not allowed")
1424 return constants.EXIT_FAILURE
1431 itertools.chain(*cl.QueryGroups(args, ["node_list"], False))
1433 node_query_list = args
1435 result = cl.QueryNodes(node_query_list, ["name", "master", "pinst_list",
1436 "sinst_list", "powered", "offline"],
1439 all_nodes = map(compat.fst, result)
1442 for (node, master, pinsts, sinsts, powered, offline) in result:
1444 for inst in (pinsts + sinsts):
1445 if inst in inst_map:
1447 inst_map[inst].add(node)
1449 inst_map[inst] = set()
1451 inst_map[inst] = set([node])
1453 if master and opts.on:
1454 # We ignore the master for turning on the machines, in fact we are
1455 # already operating on the master at this point :)
1457 elif master and not opts.show_all:
1458 _stderr_fn("%s is the master node, please do a master-failover to another"
1459 " node not affected by the EPO or use --all if you intend to"
1460 " shutdown the whole cluster", node)
1461 return constants.EXIT_FAILURE
1462 elif powered is None:
1463 _stdout_fn("Node %s does not support out-of-band handling, it can not be"
1464 " handled in a fully automated manner", node)
1465 elif powered == opts.on:
1466 _stdout_fn("Node %s is already in desired power state, skipping", node)
1467 elif not offline or (offline and powered):
1468 node_list.append(node)
1470 if not (opts.force or _confirm_fn(all_nodes, "nodes", "epo")):
1471 return constants.EXIT_FAILURE
1474 return _on_fn(opts, all_nodes, node_list, inst_map)
1476 return _off_fn(opts, node_list, inst_map)
1481 InitCluster, [ArgHost(min=1, max=1)],
1482 [BACKEND_OPT, CP_SIZE_OPT, ENABLED_HV_OPT, GLOBAL_FILEDIR_OPT,
1483 HVLIST_OPT, MAC_PREFIX_OPT, MASTER_NETDEV_OPT, MASTER_NETMASK_OPT,
1484 NIC_PARAMS_OPT, NOLVM_STORAGE_OPT, NOMODIFY_ETCHOSTS_OPT,
1485 NOMODIFY_SSH_SETUP_OPT, SECONDARY_IP_OPT, VG_NAME_OPT,
1486 MAINTAIN_NODE_HEALTH_OPT, UIDPOOL_OPT, DRBD_HELPER_OPT, NODRBD_STORAGE_OPT,
1487 DEFAULT_IALLOCATOR_OPT, PRIMARY_IP_VERSION_OPT, PREALLOC_WIPE_DISKS_OPT,
1488 NODE_PARAMS_OPT, GLOBAL_SHARED_FILEDIR_OPT, USE_EXTERNAL_MIP_SCRIPT,
1489 DISK_PARAMS_OPT, HV_STATE_OPT, DISK_STATE_OPT] + INSTANCE_POLICY_OPTS,
1490 "[opts...] <cluster_name>", "Initialises a new cluster configuration"),
1492 DestroyCluster, ARGS_NONE, [YES_DOIT_OPT],
1493 "", "Destroy cluster"),
1495 RenameCluster, [ArgHost(min=1, max=1)],
1496 [FORCE_OPT, DRY_RUN_OPT],
1498 "Renames the cluster"),
1500 RedistributeConfig, ARGS_NONE, [SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT],
1501 "", "Forces a push of the configuration file and ssconf files"
1502 " to the nodes in the cluster"),
1504 VerifyCluster, ARGS_NONE,
1505 [VERBOSE_OPT, DEBUG_SIMERR_OPT, ERROR_CODES_OPT, NONPLUS1_OPT,
1506 DRY_RUN_OPT, PRIORITY_OPT, NODEGROUP_OPT, IGNORE_ERRORS_OPT],
1507 "", "Does a check on the cluster configuration"),
1509 VerifyDisks, ARGS_NONE, [PRIORITY_OPT],
1510 "", "Does a check on the cluster disk status"),
1511 "repair-disk-sizes": (
1512 RepairDiskSizes, ARGS_MANY_INSTANCES, [DRY_RUN_OPT, PRIORITY_OPT],
1513 "[instance...]", "Updates mismatches in recorded disk sizes"),
1514 "master-failover": (
1515 MasterFailover, ARGS_NONE, [NOVOTING_OPT, FORCE_FAILOVER],
1516 "", "Makes the current node the master"),
1518 MasterPing, ARGS_NONE, [],
1519 "", "Checks if the master is alive"),
1521 ShowClusterVersion, ARGS_NONE, [],
1522 "", "Shows the cluster version"),
1524 ShowClusterMaster, ARGS_NONE, [],
1525 "", "Shows the cluster master"),
1527 ClusterCopyFile, [ArgFile(min=1, max=1)],
1528 [NODE_LIST_OPT, USE_REPL_NET_OPT, NODEGROUP_OPT],
1529 "[-n node...] <filename>", "Copies a file to all (or only some) nodes"),
1531 RunClusterCommand, [ArgCommand(min=1)],
1532 [NODE_LIST_OPT, NODEGROUP_OPT, SHOW_MACHINE_OPT, FAILURE_ONLY_OPT],
1533 "[-n node...] <command>", "Runs a command on all (or only some) nodes"),
1535 ShowClusterConfig, ARGS_NONE, [ROMAN_OPT],
1536 "[--roman]", "Show cluster configuration"),
1538 ListTags, ARGS_NONE, [], "", "List the tags of the cluster"),
1540 AddTags, [ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT, SUBMIT_OPT],
1541 "tag...", "Add tags to the cluster"),
1543 RemoveTags, [ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT, SUBMIT_OPT],
1544 "tag...", "Remove tags from the cluster"),
1546 SearchTags, [ArgUnknown(min=1, max=1)], [PRIORITY_OPT], "",
1547 "Searches the tags on all objects on"
1548 " the cluster for a given pattern (regex)"),
1551 [ArgChoice(min=1, max=1, choices=["drain", "undrain", "info"])],
1552 [], "drain|undrain|info", "Change queue properties"),
1555 [ArgChoice(min=1, max=1, choices=["pause", "continue", "info"]),
1556 ArgSuggest(min=0, max=1, choices=["30m", "1h", "4h"])],
1558 "{pause <timespec>|continue|info}", "Change watcher properties"),
1560 SetClusterParams, ARGS_NONE,
1561 [BACKEND_OPT, CP_SIZE_OPT, ENABLED_HV_OPT, HVLIST_OPT, MASTER_NETDEV_OPT,
1562 MASTER_NETMASK_OPT, NIC_PARAMS_OPT, NOLVM_STORAGE_OPT, VG_NAME_OPT,
1563 MAINTAIN_NODE_HEALTH_OPT, UIDPOOL_OPT, ADD_UIDS_OPT, REMOVE_UIDS_OPT,
1564 DRBD_HELPER_OPT, NODRBD_STORAGE_OPT, DEFAULT_IALLOCATOR_OPT,
1565 RESERVED_LVS_OPT, DRY_RUN_OPT, PRIORITY_OPT, PREALLOC_WIPE_DISKS_OPT,
1566 NODE_PARAMS_OPT, USE_EXTERNAL_MIP_SCRIPT, DISK_PARAMS_OPT, HV_STATE_OPT,
1567 DISK_STATE_OPT, SUBMIT_OPT] +
1568 INSTANCE_POLICY_OPTS,
1570 "Alters the parameters of the cluster"),
1572 RenewCrypto, ARGS_NONE,
1573 [NEW_CLUSTER_CERT_OPT, NEW_RAPI_CERT_OPT, RAPI_CERT_OPT,
1574 NEW_CONFD_HMAC_KEY_OPT, FORCE_OPT,
1575 NEW_CLUSTER_DOMAIN_SECRET_OPT, CLUSTER_DOMAIN_SECRET_OPT,
1576 NEW_SPICE_CERT_OPT, SPICE_CERT_OPT, SPICE_CACERT_OPT],
1578 "Renews cluster certificates, keys and secrets"),
1580 Epo, [ArgUnknown()],
1581 [FORCE_OPT, ON_OPT, GROUPS_OPT, ALL_OPT, OOB_TIMEOUT_OPT,
1582 SHUTDOWN_TIMEOUT_OPT, POWER_DELAY_OPT],
1584 "Performs an emergency power-off on given args"),
1585 "activate-master-ip": (
1586 ActivateMasterIp, ARGS_NONE, [], "", "Activates the master IP"),
1587 "deactivate-master-ip": (
1588 DeactivateMasterIp, ARGS_NONE, [CONFIRM_OPT], "",
1589 "Deactivates the master IP"),
1593 #: dictionary with aliases for commands
1595 "masterfailover": "master-failover",
1601 return GenericMain(commands, override={"tag_type": constants.TAG_CLUSTER},