lib/client/gnt_cluster.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2010, 2011, 2012, 2013, 2014 Google Inc.
   5 # All rights reserved.
   6 #
   7 # Redistribution and use in source and binary forms, with or without
   8 # modification, are permitted provided that the following conditions are
   9 # met:
  10 #
  11 # 1. Redistributions of source code must retain the above copyright notice,
  12 # this list of conditions and the following disclaimer.
  13 #
  14 # 2. Redistributions in binary form must reproduce the above copyright
  15 # notice, this list of conditions and the following disclaimer in the
  16 # documentation and/or other materials provided with the distribution.
  17 #
  18 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  19 # IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  20 # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  21 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  22 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  23 # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  24 # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  25 # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  26 # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  27 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  28 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29
  30 """Cluster related commands"""
  31
  32 # pylint: disable=W0401,W0613,W0614,C0103
  33 # W0401: Wildcard import ganeti.cli
  34 # W0613: Unused argument, since all functions follow the same API
  35 # W0614: Unused import %s from wildcard import (since we need cli)
  36 # C0103: Invalid name gnt-cluster
  37
  38 from cStringIO import StringIO
  39 import os
  40 import time
  41 import OpenSSL
  42 import tempfile
  43 import itertools
  44
  45 from ganeti.cli import *
  46 from ganeti import bootstrap
  47 from ganeti import compat
  48 from ganeti import constants
  49 from ganeti import config
  50 from ganeti import errors
  51 from ganeti import netutils
  52 from ganeti import objects
  53 from ganeti import opcodes
  54 from ganeti import pathutils
  55 from ganeti import qlang
  56 from ganeti import serializer
  57 from ganeti import ssconf
  58 from ganeti import ssh
  59 from ganeti import uidpool
  60 from ganeti import utils
  61 from ganeti.client import base
  62
  63
  64 ON_OPT = cli_option("--on", default=False,
  65                     action="store_true", dest="on",
  66                     help="Recover from an EPO")
  67
  68 GROUPS_OPT = cli_option("--groups", default=False,
  69                         action="store_true", dest="groups",
  70                         help="Arguments are node groups instead of nodes")
  71
  72 FORCE_FAILOVER = cli_option("--yes-do-it", dest="yes_do_it",
  73                             help="Override interactive check for --no-voting",
  74                             default=False, action="store_true")
  75
  76 FORCE_DISTRIBUTION = cli_option("--yes-do-it", dest="yes_do_it",
  77                                 help="Unconditionally distribute the"
  78                                 " configuration, even if the queue"
  79                                 " is drained",
  80                                 default=False, action="store_true")
  81
  82 TO_OPT = cli_option("--to", default=None, type="string",
  83                     help="The Ganeti version to upgrade to")
  84
  85 RESUME_OPT = cli_option("--resume", default=False, action="store_true",
  86                         help="Resume any pending Ganeti upgrades")
  87
  88 DATA_COLLECTOR_INTERVAL_OPT = cli_option(
  89     "--data-collector-interval", default={}, type="keyval",
  90     help="Set collection intervals in seconds of data collectors.")
  91
  92 _EPO_PING_INTERVAL = 30 # 30 seconds between pings
  93 _EPO_PING_TIMEOUT = 1 # 1 second
  94 _EPO_REACHABLE_TIMEOUT = 15 * 60 # 15 minutes
  95
  96
  97 def _InitEnabledDiskTemplates(opts):
  98   """Initialize the list of enabled disk templates.
  99
 100   """
 101   if opts.enabled_disk_templates:
 102     return opts.enabled_disk_templates.split(",")
 103   else:
 104     return constants.DEFAULT_ENABLED_DISK_TEMPLATES
 105
 106
 107 def _InitVgName(opts, enabled_disk_templates):
 108   """Initialize the volume group name.
 109
 110   @type enabled_disk_templates: list of strings
 111   @param enabled_disk_templates: cluster-wide enabled disk templates
 112
 113   """
 114   vg_name = None
 115   if opts.vg_name is not None:
 116     vg_name = opts.vg_name
 117     if vg_name:
 118       if not utils.IsLvmEnabled(enabled_disk_templates):
 119         ToStdout("You specified a volume group with --vg-name, but you did not"
 120                  " enable any disk template that uses lvm.")
 121     elif utils.IsLvmEnabled(enabled_disk_templates):
 122       raise errors.OpPrereqError(
 123           "LVM disk templates are enabled, but vg name not set.")
 124   elif utils.IsLvmEnabled(enabled_disk_templates):
 125     vg_name = constants.DEFAULT_VG
 126   return vg_name
 127
 128
 129 def _InitDrbdHelper(opts, enabled_disk_templates):
 130   """Initialize the DRBD usermode helper.
 131
 132   """
 133   drbd_enabled = constants.DT_DRBD8 in enabled_disk_templates
 134
 135   if not drbd_enabled and opts.drbd_helper is not None:
 136     ToStdout("Note: You specified a DRBD usermode helper, while DRBD storage"
 137              " is not enabled.")
 138
 139   if drbd_enabled:
 140     if opts.drbd_helper is None:
 141       return constants.DEFAULT_DRBD_HELPER
 142     if opts.drbd_helper == '':
 143       raise errors.OpPrereqError(
 144           "Unsetting the drbd usermode helper while enabling DRBD is not"
 145           " allowed.")
 146
 147   return opts.drbd_helper
 148
 149
 150 @UsesRPC
 151 def InitCluster(opts, args):
 152   """Initialize the cluster.
 153
 154   @param opts: the command line options selected by the user
 155   @type args: list
 156   @param args: should contain only one element, the desired
 157       cluster name
 158   @rtype: int
 159   @return: the desired exit code
 160
 161   """
 162   enabled_disk_templates = _InitEnabledDiskTemplates(opts)
 163
 164   try:
 165     vg_name = _InitVgName(opts, enabled_disk_templates)
 166     drbd_helper = _InitDrbdHelper(opts, enabled_disk_templates)
 167   except errors.OpPrereqError, e:
 168     ToStderr(str(e))
 169     return 1
 170
 171   master_netdev = opts.master_netdev
 172   if master_netdev is None:
 173     nic_mode = opts.nicparams.get(constants.NIC_MODE, None)
 174     if not nic_mode:
 175       # default case, use bridging
 176       master_netdev = constants.DEFAULT_BRIDGE
 177     elif nic_mode == constants.NIC_MODE_OVS:
 178       # default ovs is different from default bridge
 179       master_netdev = constants.DEFAULT_OVS
 180       opts.nicparams[constants.NIC_LINK] = constants.DEFAULT_OVS
 181
 182   hvlist = opts.enabled_hypervisors
 183   if hvlist is None:
 184     hvlist = constants.DEFAULT_ENABLED_HYPERVISOR
 185   hvlist = hvlist.split(",")
 186
 187   hvparams = dict(opts.hvparams)
 188   beparams = opts.beparams
 189   nicparams = opts.nicparams
 190
 191   diskparams = dict(opts.diskparams)
 192
 193   # check the disk template types here, as we cannot rely on the type check done
 194   # by the opcode parameter types
 195   diskparams_keys = set(diskparams.keys())
 196   if not (diskparams_keys <= constants.DISK_TEMPLATES):
 197     unknown = utils.NiceSort(diskparams_keys - constants.DISK_TEMPLATES)
 198     ToStderr("Disk templates unknown: %s" % utils.CommaJoin(unknown))
 199     return 1
 200
 201   # prepare beparams dict
 202   beparams = objects.FillDict(constants.BEC_DEFAULTS, beparams)
 203   utils.ForceDictType(beparams, constants.BES_PARAMETER_COMPAT)
 204
 205   # prepare nicparams dict
 206   nicparams = objects.FillDict(constants.NICC_DEFAULTS, nicparams)
 207   utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
 208
 209   # prepare ndparams dict
 210   if opts.ndparams is None:
 211     ndparams = dict(constants.NDC_DEFAULTS)
 212   else:
 213     ndparams = objects.FillDict(constants.NDC_DEFAULTS, opts.ndparams)
 214     utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
 215
 216   # prepare hvparams dict
 217   for hv in constants.HYPER_TYPES:
 218     if hv not in hvparams:
 219       hvparams[hv] = {}
 220     hvparams[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], hvparams[hv])
 221     utils.ForceDictType(hvparams[hv], constants.HVS_PARAMETER_TYPES)
 222
 223   # prepare diskparams dict
 224   for templ in constants.DISK_TEMPLATES:
 225     if templ not in diskparams:
 226       diskparams[templ] = {}
 227     diskparams[templ] = objects.FillDict(constants.DISK_DT_DEFAULTS[templ],
 228                                          diskparams[templ])
 229     utils.ForceDictType(diskparams[templ], constants.DISK_DT_TYPES)
 230
 231   # prepare ipolicy dict
 232   ipolicy = CreateIPolicyFromOpts(
 233     ispecs_mem_size=opts.ispecs_mem_size,
 234     ispecs_cpu_count=opts.ispecs_cpu_count,
 235     ispecs_disk_count=opts.ispecs_disk_count,
 236     ispecs_disk_size=opts.ispecs_disk_size,
 237     ispecs_nic_count=opts.ispecs_nic_count,
 238     minmax_ispecs=opts.ipolicy_bounds_specs,
 239     std_ispecs=opts.ipolicy_std_specs,
 240     ipolicy_disk_templates=opts.ipolicy_disk_templates,
 241     ipolicy_vcpu_ratio=opts.ipolicy_vcpu_ratio,
 242     ipolicy_spindle_ratio=opts.ipolicy_spindle_ratio,
 243     fill_all=True)
 244
 245   if opts.candidate_pool_size is None:
 246     opts.candidate_pool_size = constants.MASTER_POOL_SIZE_DEFAULT
 247
 248   if opts.mac_prefix is None:
 249     opts.mac_prefix = constants.DEFAULT_MAC_PREFIX
 250
 251   uid_pool = opts.uid_pool
 252   if uid_pool is not None:
 253     uid_pool = uidpool.ParseUidPool(uid_pool)
 254
 255   if opts.prealloc_wipe_disks is None:
 256     opts.prealloc_wipe_disks = False
 257
 258   external_ip_setup_script = opts.use_external_mip_script
 259   if external_ip_setup_script is None:
 260     external_ip_setup_script = False
 261
 262   try:
 263     primary_ip_version = int(opts.primary_ip_version)
 264   except (ValueError, TypeError), err:
 265     ToStderr("Invalid primary ip version value: %s" % str(err))
 266     return 1
 267
 268   master_netmask = opts.master_netmask
 269   try:
 270     if master_netmask is not None:
 271       master_netmask = int(master_netmask)
 272   except (ValueError, TypeError), err:
 273     ToStderr("Invalid master netmask value: %s" % str(err))
 274     return 1
 275
 276   if opts.disk_state:
 277     disk_state = utils.FlatToDict(opts.disk_state)
 278   else:
 279     disk_state = {}
 280
 281   hv_state = dict(opts.hv_state)
 282
 283   if opts.install_image:
 284     install_image = opts.install_image
 285   else:
 286     install_image = ""
 287
 288   if opts.zeroing_image:
 289     zeroing_image = opts.zeroing_image
 290   else:
 291     zeroing_image = ""
 292
 293   compression_tools = _GetCompressionTools(opts)
 294
 295   default_ialloc_params = opts.default_iallocator_params
 296
 297   if opts.enabled_user_shutdown:
 298     enabled_user_shutdown = True
 299   else:
 300     enabled_user_shutdown = False
 301
 302   bootstrap.InitCluster(cluster_name=args[0],
 303                         secondary_ip=opts.secondary_ip,
 304                         vg_name=vg_name,
 305                         mac_prefix=opts.mac_prefix,
 306                         master_netmask=master_netmask,
 307                         master_netdev=master_netdev,
 308                         file_storage_dir=opts.file_storage_dir,
 309                         shared_file_storage_dir=opts.shared_file_storage_dir,
 310                         gluster_storage_dir=opts.gluster_storage_dir,
 311                         enabled_hypervisors=hvlist,
 312                         hvparams=hvparams,
 313                         beparams=beparams,
 314                         nicparams=nicparams,
 315                         ndparams=ndparams,
 316                         diskparams=diskparams,
 317                         ipolicy=ipolicy,
 318                         candidate_pool_size=opts.candidate_pool_size,
 319                         modify_etc_hosts=opts.modify_etc_hosts,
 320                         modify_ssh_setup=opts.modify_ssh_setup,
 321                         maintain_node_health=opts.maintain_node_health,
 322                         drbd_helper=drbd_helper,
 323                         uid_pool=uid_pool,
 324                         default_iallocator=opts.default_iallocator,
 325                         default_iallocator_params=default_ialloc_params,
 326                         primary_ip_version=primary_ip_version,
 327                         prealloc_wipe_disks=opts.prealloc_wipe_disks,
 328                         use_external_mip_script=external_ip_setup_script,
 329                         hv_state=hv_state,
 330                         disk_state=disk_state,
 331                         enabled_disk_templates=enabled_disk_templates,
 332                         install_image=install_image,
 333                         zeroing_image=zeroing_image,
 334                         compression_tools=compression_tools,
 335                         enabled_user_shutdown=enabled_user_shutdown,
 336                         )
 337   op = opcodes.OpClusterPostInit()
 338   SubmitOpCode(op, opts=opts)
 339   return 0
 340
 341
 342 @UsesRPC
 343 def DestroyCluster(opts, args):
 344   """Destroy the cluster.
 345
 346   @param opts: the command line options selected by the user
 347   @type args: list
 348   @param args: should be an empty list
 349   @rtype: int
 350   @return: the desired exit code
 351
 352   """
 353   if not opts.yes_do_it:
 354     ToStderr("Destroying a cluster is irreversible. If you really want"
 355              " destroy this cluster, supply the --yes-do-it option.")
 356     return 1
 357
 358   op = opcodes.OpClusterDestroy()
 359   master_uuid = SubmitOpCode(op, opts=opts)
 360   # if we reached this, the opcode didn't fail; we can proceed to
 361   # shutdown all the daemons
 362   bootstrap.FinalizeClusterDestroy(master_uuid)
 363   return 0
 364
 365
 366 def RenameCluster(opts, args):
 367   """Rename the cluster.
 368
 369   @param opts: the command line options selected by the user
 370   @type args: list
 371   @param args: should contain only one element, the new cluster name
 372   @rtype: int
 373   @return: the desired exit code
 374
 375   """
 376   cl = GetClient()
 377
 378   (cluster_name, ) = cl.QueryConfigValues(["cluster_name"])
 379
 380   new_name = args[0]
 381   if not opts.force:
 382     usertext = ("This will rename the cluster from '%s' to '%s'. If you are"
 383                 " connected over the network to the cluster name, the"
 384                 " operation is very dangerous as the IP address will be"
 385                 " removed from the node and the change may not go through."
 386                 " Continue?") % (cluster_name, new_name)
 387     if not AskUser(usertext):
 388       return 1
 389
 390   op = opcodes.OpClusterRename(name=new_name)
 391   result = SubmitOpCode(op, opts=opts, cl=cl)
 392
 393   if result:
 394     ToStdout("Cluster renamed from '%s' to '%s'", cluster_name, result)
 395
 396   return 0
 397
 398
 399 def ActivateMasterIp(opts, args):
 400   """Activates the master IP.
 401
 402   """
 403   op = opcodes.OpClusterActivateMasterIp()
 404   SubmitOpCode(op)
 405   return 0
 406
 407
 408 def DeactivateMasterIp(opts, args):
 409   """Deactivates the master IP.
 410
 411   """
 412   if not opts.confirm:
 413     usertext = ("This will disable the master IP. All the open connections to"
 414                 " the master IP will be closed. To reach the master you will"
 415                 " need to use its node IP."
 416                 " Continue?")
 417     if not AskUser(usertext):
 418       return 1
 419
 420   op = opcodes.OpClusterDeactivateMasterIp()
 421   SubmitOpCode(op)
 422   return 0
 423
 424
 425 def RedistributeConfig(opts, args):
 426   """Forces push of the cluster configuration.
 427
 428   @param opts: the command line options selected by the user
 429   @type args: list
 430   @param args: empty list
 431   @rtype: int
 432   @return: the desired exit code
 433
 434   """
 435   op = opcodes.OpClusterRedistConf()
 436   if opts.yes_do_it:
 437     SubmitOpCodeToDrainedQueue(op)
 438   else:
 439     SubmitOrSend(op, opts)
 440   return 0
 441
 442
 443 def ShowClusterVersion(opts, args):
 444   """Write version of ganeti software to the standard output.
 445
 446   @param opts: the command line options selected by the user
 447   @type args: list
 448   @param args: should be an empty list
 449   @rtype: int
 450   @return: the desired exit code
 451
 452   """
 453   cl = GetClient()
 454   result = cl.QueryClusterInfo()
 455   ToStdout("Software version: %s", result["software_version"])
 456   ToStdout("Internode protocol: %s", result["protocol_version"])
 457   ToStdout("Configuration format: %s", result["config_version"])
 458   ToStdout("OS api version: %s", result["os_api_version"])
 459   ToStdout("Export interface: %s", result["export_version"])
 460   ToStdout("VCS version: %s", result["vcs_version"])
 461   return 0
 462
 463
 464 def ShowClusterMaster(opts, args):
 465   """Write name of master node to the standard output.
 466
 467   @param opts: the command line options selected by the user
 468   @type args: list
 469   @param args: should be an empty list
 470   @rtype: int
 471   @return: the desired exit code
 472
 473   """
 474   master = bootstrap.GetMaster()
 475   ToStdout(master)
 476   return 0
 477
 478
 479 def _FormatGroupedParams(paramsdict, roman=False):
 480   """Format Grouped parameters (be, nic, disk) by group.
 481
 482   @type paramsdict: dict of dicts
 483   @param paramsdict: {group: {param: value, ...}, ...}
 484   @rtype: dict of dicts
 485   @return: copy of the input dictionaries with strings as values
 486
 487   """
 488   ret = {}
 489   for (item, val) in paramsdict.items():
 490     if isinstance(val, dict):
 491       ret[item] = _FormatGroupedParams(val, roman=roman)
 492     elif roman and isinstance(val, int):
 493       ret[item] = compat.TryToRoman(val)
 494     else:
 495       ret[item] = str(val)
 496   return ret
 497
 498
 499 def _FormatDataCollectors(paramsdict):
 500   """Format Grouped parameters (be, nic, disk) by group.
 501
 502   @type paramsdict: dict of dicts
 503   @param paramsdict: response of QueryClusterInfo
 504   @rtype: dict of dicts
 505   @return: parameter grouped by data collector
 506
 507   """
 508
 509   enabled = paramsdict[constants.DATA_COLLECTORS_ENABLED_NAME]
 510   interval = paramsdict[constants.DATA_COLLECTORS_INTERVAL_NAME]
 511
 512   ret = {}
 513   for key in enabled:
 514     ret[key] = dict(active=enabled[key],
 515                     interval="%.3fs" % (interval[key] / 1e6))
 516   return ret
 517
 518
 519 def ShowClusterConfig(opts, args):
 520   """Shows cluster information.
 521
 522   @param opts: the command line options selected by the user
 523   @type args: list
 524   @param args: should be an empty list
 525   @rtype: int
 526   @return: the desired exit code
 527
 528   """
 529   cl = GetClient()
 530   result = cl.QueryClusterInfo()
 531
 532   if result["tags"]:
 533     tags = utils.CommaJoin(utils.NiceSort(result["tags"]))
 534   else:
 535     tags = "(none)"
 536   if result["reserved_lvs"]:
 537     reserved_lvs = utils.CommaJoin(result["reserved_lvs"])
 538   else:
 539     reserved_lvs = "(none)"
 540
 541   enabled_hv = result["enabled_hypervisors"]
 542   hvparams = dict((k, v) for k, v in result["hvparams"].iteritems()
 543                   if k in enabled_hv)
 544
 545   info = [
 546     ("Cluster name", result["name"]),
 547     ("Cluster UUID", result["uuid"]),
 548
 549     ("Creation time", utils.FormatTime(result["ctime"])),
 550     ("Modification time", utils.FormatTime(result["mtime"])),
 551
 552     ("Master node", result["master"]),
 553
 554     ("Architecture (this node)",
 555      "%s (%s)" % (result["architecture"][0], result["architecture"][1])),
 556
 557     ("Tags", tags),
 558
 559     ("Default hypervisor", result["default_hypervisor"]),
 560     ("Enabled hypervisors", utils.CommaJoin(enabled_hv)),
 561
 562     ("Hypervisor parameters", _FormatGroupedParams(hvparams,
 563                                                    opts.roman_integers)),
 564
 565     ("OS-specific hypervisor parameters",
 566      _FormatGroupedParams(result["os_hvp"], opts.roman_integers)),
 567
 568     ("OS parameters", _FormatGroupedParams(result["osparams"],
 569                                            opts.roman_integers)),
 570
 571     ("Hidden OSes", utils.CommaJoin(result["hidden_os"])),
 572     ("Blacklisted OSes", utils.CommaJoin(result["blacklisted_os"])),
 573
 574     ("Cluster parameters", [
 575       ("candidate pool size",
 576        compat.TryToRoman(result["candidate_pool_size"],
 577                          convert=opts.roman_integers)),
 578       ("maximal number of jobs running simultaneously",
 579        compat.TryToRoman(result["max_running_jobs"],
 580                          convert=opts.roman_integers)),
 581       ("maximal number of jobs simultaneously tracked by the scheduler",
 582        compat.TryToRoman(result["max_tracked_jobs"],
 583                          convert=opts.roman_integers)),
 584       ("mac prefix", result["mac_prefix"]),
 585       ("master netdev", result["master_netdev"]),
 586       ("master netmask", compat.TryToRoman(result["master_netmask"],
 587                                            opts.roman_integers)),
 588       ("use external master IP address setup script",
 589        result["use_external_mip_script"]),
 590       ("lvm volume group", result["volume_group_name"]),
 591       ("lvm reserved volumes", reserved_lvs),
 592       ("drbd usermode helper", result["drbd_usermode_helper"]),
 593       ("file storage path", result["file_storage_dir"]),
 594       ("shared file storage path", result["shared_file_storage_dir"]),
 595       ("gluster storage path", result["gluster_storage_dir"]),
 596       ("maintenance of node health", result["maintain_node_health"]),
 597       ("uid pool", uidpool.FormatUidPool(result["uid_pool"])),
 598       ("default instance allocator", result["default_iallocator"]),
 599       ("default instance allocator parameters",
 600        result["default_iallocator_params"]),
 601       ("primary ip version", compat.TryToRoman(result["primary_ip_version"],
 602                                                opts.roman_integers)),
 603       ("preallocation wipe disks", result["prealloc_wipe_disks"]),
 604       ("OS search path", utils.CommaJoin(pathutils.OS_SEARCH_PATH)),
 605       ("ExtStorage Providers search path",
 606        utils.CommaJoin(pathutils.ES_SEARCH_PATH)),
 607       ("enabled disk templates",
 608        utils.CommaJoin(result["enabled_disk_templates"])),
 609       ("install image", result["install_image"]),
 610       ("instance communication network",
 611        result["instance_communication_network"]),
 612       ("zeroing image", result["zeroing_image"]),
 613       ("compression tools", result["compression_tools"]),
 614       ("enabled user shutdown", result["enabled_user_shutdown"]),
 615       ]),
 616
 617     ("Default node parameters",
 618      _FormatGroupedParams(result["ndparams"], roman=opts.roman_integers)),
 619
 620     ("Default instance parameters",
 621      _FormatGroupedParams(result["beparams"], roman=opts.roman_integers)),
 622
 623     ("Default nic parameters",
 624      _FormatGroupedParams(result["nicparams"], roman=opts.roman_integers)),
 625
 626     ("Default disk parameters",
 627      _FormatGroupedParams(result["diskparams"], roman=opts.roman_integers)),
 628
 629     ("Instance policy - limits for instances",
 630      FormatPolicyInfo(result["ipolicy"], None, True, opts.roman_integers)),
 631     ("Data collectors", _FormatDataCollectors(result)),
 632     ]
 633
 634   PrintGenericInfo(info)
 635   return 0
 636
 637
 638 def ClusterCopyFile(opts, args):
 639   """Copy a file from master to some nodes.
 640
 641   @param opts: the command line options selected by the user
 642   @type args: list
 643   @param args: should contain only one element, the path of
 644       the file to be copied
 645   @rtype: int
 646   @return: the desired exit code
 647
 648   """
 649   filename = args[0]
 650   filename = os.path.abspath(filename)
 651
 652   if not os.path.exists(filename):
 653     raise errors.OpPrereqError("No such filename '%s'" % filename,
 654                                errors.ECODE_INVAL)
 655
 656   cl = GetClient()
 657   qcl = GetClient()
 658   try:
 659     cluster_name = cl.QueryConfigValues(["cluster_name"])[0]
 660
 661     results = GetOnlineNodes(nodes=opts.nodes, cl=qcl, filter_master=True,
 662                              secondary_ips=opts.use_replication_network,
 663                              nodegroup=opts.nodegroup)
 664     ports = GetNodesSshPorts(opts.nodes, qcl)
 665   finally:
 666     cl.Close()
 667     qcl.Close()
 668
 669   srun = ssh.SshRunner(cluster_name)
 670   for (node, port) in zip(results, ports):
 671     if not srun.CopyFileToNode(node, port, filename):
 672       ToStderr("Copy of file %s to node %s:%d failed", filename, node, port)
 673
 674   return 0
 675
 676
 677 def RunClusterCommand(opts, args):
 678   """Run a command on some nodes.
 679
 680   @param opts: the command line options selected by the user
 681   @type args: list
 682   @param args: should contain the command to be run and its arguments
 683   @rtype: int
 684   @return: the desired exit code
 685
 686   """
 687   cl = GetClient()
 688   qcl = GetClient()
 689
 690   command = " ".join(args)
 691
 692   nodes = GetOnlineNodes(nodes=opts.nodes, cl=qcl, nodegroup=opts.nodegroup)
 693   ports = GetNodesSshPorts(nodes, qcl)
 694
 695   cluster_name, master_node = cl.QueryConfigValues(["cluster_name",
 696                                                     "master_node"])
 697
 698   srun = ssh.SshRunner(cluster_name=cluster_name)
 699
 700   # Make sure master node is at list end
 701   if master_node in nodes:
 702     nodes.remove(master_node)
 703     nodes.append(master_node)
 704
 705   for (name, port) in zip(nodes, ports):
 706     result = srun.Run(name, constants.SSH_LOGIN_USER, command, port=port)
 707
 708     if opts.failure_only and result.exit_code == constants.EXIT_SUCCESS:
 709       # Do not output anything for successful commands
 710       continue
 711
 712     ToStdout("------------------------------------------------")
 713     if opts.show_machine_names:
 714       for line in result.output.splitlines():
 715         ToStdout("%s: %s", name, line)
 716     else:
 717       ToStdout("node: %s", name)
 718       ToStdout("%s", result.output)
 719     ToStdout("return code = %s", result.exit_code)
 720
 721   return 0
 722
 723
 724 def VerifyCluster(opts, args):
 725   """Verify integrity of cluster, performing various test on nodes.
 726
 727   @param opts: the command line options selected by the user
 728   @type args: list
 729   @param args: should be an empty list
 730   @rtype: int
 731   @return: the desired exit code
 732
 733   """
 734   skip_checks = []
 735
 736   if opts.skip_nplusone_mem:
 737     skip_checks.append(constants.VERIFY_NPLUSONE_MEM)
 738
 739   cl = GetClient()
 740
 741   op = opcodes.OpClusterVerify(verbose=opts.verbose,
 742                                error_codes=opts.error_codes,
 743                                debug_simulate_errors=opts.simulate_errors,
 744                                skip_checks=skip_checks,
 745                                ignore_errors=opts.ignore_errors,
 746                                group_name=opts.nodegroup,
 747                                verify_clutter=opts.verify_clutter)
 748   result = SubmitOpCode(op, cl=cl, opts=opts)
 749
 750   # Keep track of submitted jobs
 751   jex = JobExecutor(cl=cl, opts=opts)
 752
 753   for (status, job_id) in result[constants.JOB_IDS_KEY]:
 754     jex.AddJobId(None, status, job_id)
 755
 756   results = jex.GetResults()
 757
 758   (bad_jobs, bad_results) = \
 759     map(len,
 760         # Convert iterators to lists
 761         map(list,
 762             # Count errors
 763             map(compat.partial(itertools.ifilterfalse, bool),
 764                 # Convert result to booleans in a tuple
 765                 zip(*((job_success, len(op_results) == 1 and op_results[0])
 766                       for (job_success, op_results) in results)))))
 767
 768   if bad_jobs == 0 and bad_results == 0:
 769     rcode = constants.EXIT_SUCCESS
 770   else:
 771     rcode = constants.EXIT_FAILURE
 772     if bad_jobs > 0:
 773       ToStdout("%s job(s) failed while verifying the cluster.", bad_jobs)
 774
 775   return rcode
 776
 777
 778 def VerifyDisks(opts, args):
 779   """Verify integrity of cluster disks.
 780
 781   @param opts: the command line options selected by the user
 782   @type args: list
 783   @param args: should be an empty list
 784   @rtype: int
 785   @return: the desired exit code
 786
 787   """
 788   cl = GetClient()
 789
 790   op = opcodes.OpClusterVerifyDisks()
 791
 792   result = SubmitOpCode(op, cl=cl, opts=opts)
 793
 794   # Keep track of submitted jobs
 795   jex = JobExecutor(cl=cl, opts=opts)
 796
 797   for (status, job_id) in result[constants.JOB_IDS_KEY]:
 798     jex.AddJobId(None, status, job_id)
 799
 800   retcode = constants.EXIT_SUCCESS
 801
 802   for (status, result) in jex.GetResults():
 803     if not status:
 804       ToStdout("Job failed: %s", result)
 805       continue
 806
 807     ((bad_nodes, instances, missing), ) = result
 808
 809     for node, text in bad_nodes.items():
 810       ToStdout("Error gathering data on node %s: %s",
 811                node, utils.SafeEncode(text[-400:]))
 812       retcode = constants.EXIT_FAILURE
 813       ToStdout("You need to fix these nodes first before fixing instances")
 814
 815     for iname in instances:
 816       if iname in missing:
 817         continue
 818       op = opcodes.OpInstanceActivateDisks(instance_name=iname)
 819       try:
 820         ToStdout("Activating disks for instance '%s'", iname)
 821         SubmitOpCode(op, opts=opts, cl=cl)
 822       except errors.GenericError, err:
 823         nret, msg = FormatError(err)
 824         retcode |= nret
 825         ToStderr("Error activating disks for instance %s: %s", iname, msg)
 826
 827     if missing:
 828       for iname, ival in missing.iteritems():
 829         all_missing = compat.all(x[0] in bad_nodes for x in ival)
 830         if all_missing:
 831           ToStdout("Instance %s cannot be verified as it lives on"
 832                    " broken nodes", iname)
 833         else:
 834           ToStdout("Instance %s has missing logical volumes:", iname)
 835           ival.sort()
 836           for node, vol in ival:
 837             if node in bad_nodes:
 838               ToStdout("\tbroken node %s /dev/%s", node, vol)
 839             else:
 840               ToStdout("\t%s /dev/%s", node, vol)
 841
 842       ToStdout("You need to replace or recreate disks for all the above"
 843                " instances if this message persists after fixing broken nodes.")
 844       retcode = constants.EXIT_FAILURE
 845     elif not instances:
 846       ToStdout("No disks need to be activated.")
 847
 848   return retcode
 849
 850
 851 def RepairDiskSizes(opts, args):
 852   """Verify sizes of cluster disks.
 853
 854   @param opts: the command line options selected by the user
 855   @type args: list
 856   @param args: optional list of instances to restrict check to
 857   @rtype: int
 858   @return: the desired exit code
 859
 860   """
 861   op = opcodes.OpClusterRepairDiskSizes(instances=args)
 862   SubmitOpCode(op, opts=opts)
 863
 864
 865 @UsesRPC
 866 def MasterFailover(opts, args):
 867   """Failover the master node.
 868
 869   This command, when run on a non-master node, will cause the current
 870   master to cease being master, and the non-master to become new
 871   master.
 872
 873   @param opts: the command line options selected by the user
 874   @type args: list
 875   @param args: should be an empty list
 876   @rtype: int
 877   @return: the desired exit code
 878
 879   """
 880   if not opts.no_voting:
 881     # Verify that a majority of nodes is still healthy
 882     if not bootstrap.MajorityHealthy():
 883       ToStderr("Master-failover with voting is only possible if the majority"
 884                " of nodes is still healthy; use the --no-voting option after"
 885                " ensuring by other means that you won't end up in a dual-master"
 886                " scenario.")
 887       return 1
 888   if opts.no_voting and not opts.yes_do_it:
 889     usertext = ("This will perform the failover even if most other nodes"
 890                 " are down, or if this node is outdated. This is dangerous"
 891                 " as it can lead to a non-consistent cluster. Check the"
 892                 " gnt-cluster(8) man page before proceeding. Continue?")
 893     if not AskUser(usertext):
 894       return 1
 895
 896   rvlaue, msgs = bootstrap.MasterFailover(no_voting=opts.no_voting)
 897   for msg in msgs:
 898     ToStderr(msg)
 899   return rvlaue
 900
 901
 902 def MasterPing(opts, args):
 903   """Checks if the master is alive.
 904
 905   @param opts: the command line options selected by the user
 906   @type args: list
 907   @param args: should be an empty list
 908   @rtype: int
 909   @return: the desired exit code
 910
 911   """
 912   try:
 913     cl = GetClient()
 914     cl.QueryClusterInfo()
 915     return 0
 916   except Exception: # pylint: disable=W0703
 917     return 1
 918
 919
 920 def SearchTags(opts, args):
 921   """Searches the tags on all the cluster.
 922
 923   @param opts: the command line options selected by the user
 924   @type args: list
 925   @param args: should contain only one element, the tag pattern
 926   @rtype: int
 927   @return: the desired exit code
 928
 929   """
 930   op = opcodes.OpTagsSearch(pattern=args[0])
 931   result = SubmitOpCode(op, opts=opts)
 932   if not result:
 933     return 1
 934   result = list(result)
 935   result.sort()
 936   for path, tag in result:
 937     ToStdout("%s %s", path, tag)
 938
 939
 940 def _ReadAndVerifyCert(cert_filename, verify_private_key=False):
 941   """Reads and verifies an X509 certificate.
 942
 943   @type cert_filename: string
 944   @param cert_filename: the path of the file containing the certificate to
 945                         verify encoded in PEM format
 946   @type verify_private_key: bool
 947   @param verify_private_key: whether to verify the private key in addition to
 948                              the public certificate
 949   @rtype: string
 950   @return: a string containing the PEM-encoded certificate.
 951
 952   """
 953   try:
 954     pem = utils.ReadFile(cert_filename)
 955   except IOError, err:
 956     raise errors.X509CertError(cert_filename,
 957                                "Unable to read certificate: %s" % str(err))
 958
 959   try:
 960     OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM, pem)
 961   except Exception, err:
 962     raise errors.X509CertError(cert_filename,
 963                                "Unable to load certificate: %s" % str(err))
 964
 965   if verify_private_key:
 966     try:
 967       OpenSSL.crypto.load_privatekey(OpenSSL.crypto.FILETYPE_PEM, pem)
 968     except Exception, err:
 969       raise errors.X509CertError(cert_filename,
 970                                  "Unable to load private key: %s" % str(err))
 971
 972   return pem
 973
 974
 975 def _RenewCrypto(new_cluster_cert, new_rapi_cert, # pylint: disable=R0911
 976                  rapi_cert_filename, new_spice_cert, spice_cert_filename,
 977                  spice_cacert_filename, new_confd_hmac_key, new_cds,
 978                  cds_filename, force, new_node_cert, new_ssh_keys,
 979                  verbose, debug):
 980   """Renews cluster certificates, keys and secrets.
 981
 982   @type new_cluster_cert: bool
 983   @param new_cluster_cert: Whether to generate a new cluster certificate
 984   @type new_rapi_cert: bool
 985   @param new_rapi_cert: Whether to generate a new RAPI certificate
 986   @type rapi_cert_filename: string
 987   @param rapi_cert_filename: Path to file containing new RAPI certificate
 988   @type new_spice_cert: bool
 989   @param new_spice_cert: Whether to generate a new SPICE certificate
 990   @type spice_cert_filename: string
 991   @param spice_cert_filename: Path to file containing new SPICE certificate
 992   @type spice_cacert_filename: string
 993   @param spice_cacert_filename: Path to file containing the certificate of the
 994                                 CA that signed the SPICE certificate
 995   @type new_confd_hmac_key: bool
 996   @param new_confd_hmac_key: Whether to generate a new HMAC key
 997   @type new_cds: bool
 998   @param new_cds: Whether to generate a new cluster domain secret
 999   @type cds_filename: string
1000   @param cds_filename: Path to file containing new cluster domain secret
1001   @type force: bool
1002   @param force: Whether to ask user for confirmation
1003   @type new_node_cert: bool
1004   @param new_node_cert: Whether to generate new node certificates
1005   @type new_ssh_keys: bool
1006   @param new_ssh_keys: Whether to generate new node SSH keys
1007   @type verbose: boolean
1008   @param verbose: show verbose output
1009   @type debug: boolean
1010   @param debug: show debug output
1011
1012   """
1013   ToStdout("Updating certificates now. Running \"gnt-cluster verify\" "
1014            " is recommended after this operation.")
1015
1016   if new_rapi_cert and rapi_cert_filename:
1017     ToStderr("Only one of the --new-rapi-certificate and --rapi-certificate"
1018              " options can be specified at the same time.")
1019     return 1
1020
1021   if new_cds and cds_filename:
1022     ToStderr("Only one of the --new-cluster-domain-secret and"
1023              " --cluster-domain-secret options can be specified at"
1024              " the same time.")
1025     return 1
1026
1027   if new_spice_cert and (spice_cert_filename or spice_cacert_filename):
1028     ToStderr("When using --new-spice-certificate, the --spice-certificate"
1029              " and --spice-ca-certificate must not be used.")
1030     return 1
1031
1032   if bool(spice_cacert_filename) ^ bool(spice_cert_filename):
1033     ToStderr("Both --spice-certificate and --spice-ca-certificate must be"
1034              " specified.")
1035     return 1
1036
1037   rapi_cert_pem, spice_cert_pem, spice_cacert_pem = (None, None, None)
1038   try:
1039     if rapi_cert_filename:
1040       rapi_cert_pem = _ReadAndVerifyCert(rapi_cert_filename, True)
1041     if spice_cert_filename:
1042       spice_cert_pem = _ReadAndVerifyCert(spice_cert_filename, True)
1043       spice_cacert_pem = _ReadAndVerifyCert(spice_cacert_filename)
1044   except errors.X509CertError, err:
1045     ToStderr("Unable to load X509 certificate from %s: %s", err[0], err[1])
1046     return 1
1047
1048   if cds_filename:
1049     try:
1050       cds = utils.ReadFile(cds_filename)
1051     except Exception, err: # pylint: disable=W0703
1052       ToStderr("Can't load new cluster domain secret from %s: %s" %
1053                (cds_filename, str(err)))
1054       return 1
1055   else:
1056     cds = None
1057
1058   if not force:
1059     usertext = ("This requires all daemons on all nodes to be restarted and"
1060                 " may take some time. Continue?")
1061     if not AskUser(usertext):
1062       return 1
1063
1064   def _RenewCryptoInner(ctx):
1065     ctx.feedback_fn("Updating certificates and keys")
1066
1067     bootstrap.GenerateClusterCrypto(False,
1068                                     new_rapi_cert,
1069                                     new_spice_cert,
1070                                     new_confd_hmac_key,
1071                                     new_cds,
1072                                     False,
1073                                     None,
1074                                     rapi_cert_pem=rapi_cert_pem,
1075                                     spice_cert_pem=spice_cert_pem,
1076                                     spice_cacert_pem=spice_cacert_pem,
1077                                     cds=cds)
1078
1079     files_to_copy = []
1080
1081     if new_rapi_cert or rapi_cert_pem:
1082       files_to_copy.append(pathutils.RAPI_CERT_FILE)
1083
1084     if new_spice_cert or spice_cert_pem:
1085       files_to_copy.append(pathutils.SPICE_CERT_FILE)
1086       files_to_copy.append(pathutils.SPICE_CACERT_FILE)
1087
1088     if new_confd_hmac_key:
1089       files_to_copy.append(pathutils.CONFD_HMAC_KEY)
1090
1091     if new_cds or cds:
1092       files_to_copy.append(pathutils.CLUSTER_DOMAIN_SECRET_FILE)
1093
1094     if files_to_copy:
1095       for node_name in ctx.nonmaster_nodes:
1096         port = ctx.ssh_ports[node_name]
1097         ctx.feedback_fn("Copying %s to %s:%d" %
1098                         (", ".join(files_to_copy), node_name, port))
1099         for file_name in files_to_copy:
1100           ctx.ssh.CopyFileToNode(node_name, port, file_name)
1101
1102   def _RenewClientCerts(ctx):
1103     ctx.feedback_fn("Updating client SSL certificates.")
1104
1105     cluster_name = ssconf.SimpleStore().GetClusterName()
1106
1107     for node_name in ctx.nonmaster_nodes + [ctx.master_node]:
1108       ssh_port = ctx.ssh_ports[node_name]
1109       data = {
1110         constants.NDS_CLUSTER_NAME: cluster_name,
1111         constants.NDS_NODE_DAEMON_CERTIFICATE:
1112           utils.ReadFile(pathutils.NODED_CERT_FILE),
1113         constants.NDS_NODE_NAME: node_name,
1114         constants.NDS_ACTION: constants.CRYPTO_ACTION_CREATE,
1115         }
1116
1117       ssh.RunSshCmdWithStdin(
1118           cluster_name,
1119           node_name,
1120           pathutils.SSL_UPDATE,
1121           ssh_port,
1122           data,
1123           debug=ctx.debug,
1124           verbose=ctx.verbose,
1125           use_cluster_key=True,
1126           ask_key=False,
1127           strict_host_check=True)
1128
1129     # Create a temporary ssconf file using the master's client cert digest
1130     # and the 'bootstrap' keyword to enable distribution of all nodes' digests.
1131     master_digest = utils.GetCertificateDigest()
1132     ssconf_master_candidate_certs_filename = os.path.join(
1133         pathutils.DATA_DIR, "%s%s" %
1134         (constants.SSCONF_FILEPREFIX, constants.SS_MASTER_CANDIDATES_CERTS))
1135     utils.WriteFile(
1136         ssconf_master_candidate_certs_filename,
1137         data="%s=%s" % (constants.CRYPTO_BOOTSTRAP, master_digest))
1138     for node_name in ctx.nonmaster_nodes:
1139       port = ctx.ssh_ports[node_name]
1140       ctx.feedback_fn("Copying %s to %s:%d" %
1141                       (ssconf_master_candidate_certs_filename, node_name, port))
1142       ctx.ssh.CopyFileToNode(node_name, port,
1143                              ssconf_master_candidate_certs_filename)
1144
1145     # Write the boostrap entry to the config using wconfd.
1146     config_live_lock = utils.livelock.LiveLock("renew_crypto")
1147     cfg = config.GetConfig(None, config_live_lock)
1148     cfg.AddNodeToCandidateCerts(constants.CRYPTO_BOOTSTRAP, master_digest)
1149     cfg.Update(cfg.GetClusterInfo(), ctx.feedback_fn)
1150
1151   def _RenewServerAndClientCerts(ctx):
1152     ctx.feedback_fn("Updating the cluster SSL certificate.")
1153
1154     master_name = ssconf.SimpleStore().GetMasterNode()
1155     bootstrap.GenerateClusterCrypto(True, # cluster cert
1156                                     False, # rapi cert
1157                                     False, # spice cert
1158                                     False, # confd hmac key
1159                                     False, # cds
1160                                     True, # client cert
1161                                     master_name)
1162
1163     for node_name in ctx.nonmaster_nodes:
1164       port = ctx.ssh_ports[node_name]
1165       server_cert = pathutils.NODED_CERT_FILE
1166       ctx.feedback_fn("Copying %s to %s:%d" %
1167                       (server_cert, node_name, port))
1168       ctx.ssh.CopyFileToNode(node_name, port, server_cert)
1169
1170     _RenewClientCerts(ctx)
1171
1172   if new_rapi_cert or new_spice_cert or new_confd_hmac_key or new_cds:
1173     RunWhileClusterStopped(ToStdout, _RenewCryptoInner)
1174
1175   # If only node certficates are recreated, call _RenewClientCerts only.
1176   if new_node_cert and not new_cluster_cert:
1177     RunWhileDaemonsStopped(ToStdout, [constants.NODED, constants.WCONFD],
1178                            _RenewClientCerts, verbose=verbose, debug=debug)
1179
1180   # If the cluster certificate are renewed, the client certificates need
1181   # to be renewed too.
1182   if new_cluster_cert:
1183     RunWhileDaemonsStopped(ToStdout, [constants.NODED, constants.WCONFD],
1184                            _RenewServerAndClientCerts, verbose=verbose,
1185                            debug=debug)
1186
1187   if new_node_cert or new_cluster_cert or new_ssh_keys:
1188     cl = GetClient()
1189     renew_op = opcodes.OpClusterRenewCrypto(
1190         node_certificates=new_node_cert or new_cluster_cert,
1191         ssh_keys=new_ssh_keys)
1192     SubmitOpCode(renew_op, cl=cl)
1193
1194   ToStdout("All requested certificates and keys have been replaced."
1195            " Running \"gnt-cluster verify\" now is recommended.")
1196
1197   return 0
1198
1199
1200 def _BuildGanetiPubKeys(options, pub_key_file=pathutils.SSH_PUB_KEYS, cl=None,
1201                         get_online_nodes_fn=GetOnlineNodes,
1202                         get_nodes_ssh_ports_fn=GetNodesSshPorts,
1203                         get_node_uuids_fn=GetNodeUUIDs,
1204                         homedir_fn=None):
1205   """Recreates the 'ganeti_pub_key' file by polling all nodes.
1206
1207   """
1208   if os.path.exists(pub_key_file):
1209     utils.CreateBackup(pub_key_file)
1210     utils.RemoveFile(pub_key_file)
1211
1212   ssh.ClearPubKeyFile(pub_key_file)
1213
1214   if not cl:
1215     cl = GetClient()
1216
1217   (cluster_name, master_node) = \
1218     cl.QueryConfigValues(["cluster_name", "master_node"])
1219
1220   online_nodes = get_online_nodes_fn([], cl=cl)
1221   ssh_ports = get_nodes_ssh_ports_fn(online_nodes + [master_node], cl)
1222   ssh_port_map = dict(zip(online_nodes + [master_node], ssh_ports))
1223
1224   node_uuids = get_node_uuids_fn(online_nodes + [master_node], cl)
1225   node_uuid_map = dict(zip(online_nodes + [master_node], node_uuids))
1226
1227   nonmaster_nodes = [name for name in online_nodes
1228                      if name != master_node]
1229
1230   _, pub_key_filename, _ = \
1231     ssh.GetUserFiles(constants.SSH_LOGIN_USER, mkdir=False, dircheck=False,
1232                      kind=constants.SSHK_DSA, _homedir_fn=homedir_fn)
1233
1234   # get the key file of the master node
1235   pub_key = utils.ReadFile(pub_key_filename)
1236   ssh.AddPublicKey(node_uuid_map[master_node], pub_key,
1237                    key_file=pub_key_file)
1238
1239   # get the key files of all non-master nodes
1240   for node in nonmaster_nodes:
1241     pub_key = ssh.ReadRemoteSshPubKeys(pub_key_filename, node, cluster_name,
1242                                        ssh_port_map[node],
1243                                        options.ssh_key_check,
1244                                        options.ssh_key_check)
1245     ssh.AddPublicKey(node_uuid_map[node], pub_key, key_file=pub_key_file)
1246
1247
1248 def RenewCrypto(opts, args):
1249   """Renews cluster certificates, keys and secrets.
1250
1251   """
1252   if opts.new_ssh_keys:
1253     _BuildGanetiPubKeys(opts)
1254   return _RenewCrypto(opts.new_cluster_cert,
1255                       opts.new_rapi_cert,
1256                       opts.rapi_cert,
1257                       opts.new_spice_cert,
1258                       opts.spice_cert,
1259                       opts.spice_cacert,
1260                       opts.new_confd_hmac_key,
1261                       opts.new_cluster_domain_secret,
1262                       opts.cluster_domain_secret,
1263                       opts.force,
1264                       opts.new_node_cert,
1265                       opts.new_ssh_keys,
1266                       opts.verbose,
1267                       opts.debug > 0)
1268
1269
1270 def _GetEnabledDiskTemplates(opts):
1271   """Determine the list of enabled disk templates.
1272
1273   """
1274   if opts.enabled_disk_templates:
1275     return opts.enabled_disk_templates.split(",")
1276   else:
1277     return None
1278
1279
1280 def _GetVgName(opts, enabled_disk_templates):
1281   """Determine the volume group name.
1282
1283   @type enabled_disk_templates: list of strings
1284   @param enabled_disk_templates: cluster-wide enabled disk-templates
1285
1286   """
1287   # consistency between vg name and enabled disk templates
1288   vg_name = None
1289   if opts.vg_name is not None:
1290     vg_name = opts.vg_name
1291   if enabled_disk_templates:
1292     if vg_name and not utils.IsLvmEnabled(enabled_disk_templates):
1293       ToStdout("You specified a volume group with --vg-name, but you did not"
1294                " enable any of the following lvm-based disk templates: %s" %
1295                utils.CommaJoin(constants.DTS_LVM))
1296   return vg_name
1297
1298
1299 def _GetDrbdHelper(opts, enabled_disk_templates):
1300   """Determine the DRBD usermode helper.
1301
1302   """
1303   drbd_helper = opts.drbd_helper
1304   if enabled_disk_templates:
1305     drbd_enabled = constants.DT_DRBD8 in enabled_disk_templates
1306     if not drbd_enabled and opts.drbd_helper:
1307       ToStdout("You specified a DRBD usermode helper with "
1308                " --drbd-usermode-helper while DRBD is not enabled.")
1309   return drbd_helper
1310
1311
1312 def _GetCompressionTools(opts):
1313   """Determine the list of custom compression tools.
1314
1315   """
1316   if opts.compression_tools:
1317     return opts.compression_tools.split(",")
1318   elif opts.compression_tools is None:
1319     return None # To note the parameter was not provided
1320   else:
1321     return constants.IEC_DEFAULT_TOOLS # Resetting to default
1322
1323
1324 def SetClusterParams(opts, args):
1325   """Modify the cluster.
1326
1327   @param opts: the command line options selected by the user
1328   @type args: list
1329   @param args: should be an empty list
1330   @rtype: int
1331   @return: the desired exit code
1332
1333   """
1334   if not (opts.vg_name is not None or
1335           opts.drbd_helper is not None or
1336           opts.enabled_hypervisors or opts.hvparams or
1337           opts.beparams or opts.nicparams or
1338           opts.ndparams or opts.diskparams or
1339           opts.candidate_pool_size is not None or
1340           opts.max_running_jobs is not None or
1341           opts.max_tracked_jobs is not None or
1342           opts.uid_pool is not None or
1343           opts.maintain_node_health is not None or
1344           opts.add_uids is not None or
1345           opts.remove_uids is not None or
1346           opts.default_iallocator is not None or
1347           opts.default_iallocator_params is not None or
1348           opts.reserved_lvs is not None or
1349           opts.mac_prefix is not None or
1350           opts.master_netdev is not None or
1351           opts.master_netmask is not None or
1352           opts.use_external_mip_script is not None or
1353           opts.prealloc_wipe_disks is not None or
1354           opts.hv_state or
1355           opts.enabled_disk_templates or
1356           opts.disk_state or
1357           opts.ipolicy_bounds_specs is not None or
1358           opts.ipolicy_std_specs is not None or
1359           opts.ipolicy_disk_templates is not None or
1360           opts.ipolicy_vcpu_ratio is not None or
1361           opts.ipolicy_spindle_ratio is not None or
1362           opts.modify_etc_hosts is not None or
1363           opts.file_storage_dir is not None or
1364           opts.install_image is not None or
1365           opts.instance_communication_network is not None or
1366           opts.zeroing_image is not None or
1367           opts.shared_file_storage_dir is not None or
1368           opts.compression_tools is not None or
1369           opts.shared_file_storage_dir is not None or
1370           opts.enabled_user_shutdown is not None or
1371           opts.data_collector_interval or
1372           opts.enabled_data_collectors):
1373     ToStderr("Please give at least one of the parameters.")
1374     return 1
1375
1376   enabled_disk_templates = _GetEnabledDiskTemplates(opts)
1377   vg_name = _GetVgName(opts, enabled_disk_templates)
1378
1379   try:
1380     drbd_helper = _GetDrbdHelper(opts, enabled_disk_templates)
1381   except errors.OpPrereqError, e:
1382     ToStderr(str(e))
1383     return 1
1384
1385   hvlist = opts.enabled_hypervisors
1386   if hvlist is not None:
1387     hvlist = hvlist.split(",")
1388
1389   # a list of (name, dict) we can pass directly to dict() (or [])
1390   hvparams = dict(opts.hvparams)
1391   for hv_params in hvparams.values():
1392     utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
1393
1394   diskparams = dict(opts.diskparams)
1395
1396   for dt_params in diskparams.values():
1397     utils.ForceDictType(dt_params, constants.DISK_DT_TYPES)
1398
1399   beparams = opts.beparams
1400   utils.ForceDictType(beparams, constants.BES_PARAMETER_COMPAT)
1401
1402   nicparams = opts.nicparams
1403   utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
1404
1405   ndparams = opts.ndparams
1406   if ndparams is not None:
1407     utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
1408
1409   ipolicy = CreateIPolicyFromOpts(
1410     minmax_ispecs=opts.ipolicy_bounds_specs,
1411     std_ispecs=opts.ipolicy_std_specs,
1412     ipolicy_disk_templates=opts.ipolicy_disk_templates,
1413     ipolicy_vcpu_ratio=opts.ipolicy_vcpu_ratio,
1414     ipolicy_spindle_ratio=opts.ipolicy_spindle_ratio,
1415     )
1416
1417   mnh = opts.maintain_node_health
1418
1419   uid_pool = opts.uid_pool
1420   if uid_pool is not None:
1421     uid_pool = uidpool.ParseUidPool(uid_pool)
1422
1423   add_uids = opts.add_uids
1424   if add_uids is not None:
1425     add_uids = uidpool.ParseUidPool(add_uids)
1426
1427   remove_uids = opts.remove_uids
1428   if remove_uids is not None:
1429     remove_uids = uidpool.ParseUidPool(remove_uids)
1430
1431   if opts.reserved_lvs is not None:
1432     if opts.reserved_lvs == "":
1433       opts.reserved_lvs = []
1434     else:
1435       opts.reserved_lvs = utils.UnescapeAndSplit(opts.reserved_lvs, sep=",")
1436
1437   if opts.master_netmask is not None:
1438     try:
1439       opts.master_netmask = int(opts.master_netmask)
1440     except ValueError:
1441       ToStderr("The --master-netmask option expects an int parameter.")
1442       return 1
1443
1444   ext_ip_script = opts.use_external_mip_script
1445
1446   if opts.disk_state:
1447     disk_state = utils.FlatToDict(opts.disk_state)
1448   else:
1449     disk_state = {}
1450
1451   hv_state = dict(opts.hv_state)
1452
1453   compression_tools = _GetCompressionTools(opts)
1454
1455   enabled_data_collectors = dict(
1456       (k, v.lower().startswith("t"))
1457       for k, v in opts.enabled_data_collectors.items())
1458
1459   unrecognized_data_collectors = [
1460       k for k in enabled_data_collectors.keys()
1461       if k not in constants.DATA_COLLECTOR_NAMES]
1462   if unrecognized_data_collectors:
1463     ToStderr("Data collector names not recognized: %s" %
1464              ", ".join(unrecognized_data_collectors))
1465
1466   try:
1467     data_collector_interval = dict(
1468         (k, long(1e6 * float(v)))
1469         for (k, v) in opts.data_collector_interval.items())
1470   except ValueError:
1471     ToStderr("Can't transform all values to integers: {}".format(
1472         opts.data_collector_interval))
1473     return 1
1474   if any(v <= 0 for v in data_collector_interval):
1475     ToStderr("Some interval times where not above zero.")
1476     return 1
1477
1478   op = opcodes.OpClusterSetParams(
1479     vg_name=vg_name,
1480     drbd_helper=drbd_helper,
1481     enabled_hypervisors=hvlist,
1482     hvparams=hvparams,
1483     os_hvp=None,
1484     beparams=beparams,
1485     nicparams=nicparams,
1486     ndparams=ndparams,
1487     diskparams=diskparams,
1488     ipolicy=ipolicy,
1489     candidate_pool_size=opts.candidate_pool_size,
1490     max_running_jobs=opts.max_running_jobs,
1491     max_tracked_jobs=opts.max_tracked_jobs,
1492     maintain_node_health=mnh,
1493     modify_etc_hosts=opts.modify_etc_hosts,
1494     uid_pool=uid_pool,
1495     add_uids=add_uids,
1496     remove_uids=remove_uids,
1497     default_iallocator=opts.default_iallocator,
1498     default_iallocator_params=opts.default_iallocator_params,
1499     prealloc_wipe_disks=opts.prealloc_wipe_disks,
1500     mac_prefix=opts.mac_prefix,
1501     master_netdev=opts.master_netdev,
1502     master_netmask=opts.master_netmask,
1503     reserved_lvs=opts.reserved_lvs,
1504     use_external_mip_script=ext_ip_script,
1505     hv_state=hv_state,
1506     disk_state=disk_state,
1507     enabled_disk_templates=enabled_disk_templates,
1508     force=opts.force,
1509     file_storage_dir=opts.file_storage_dir,
1510     install_image=opts.install_image,
1511     instance_communication_network=opts.instance_communication_network,
1512     zeroing_image=opts.zeroing_image,
1513     shared_file_storage_dir=opts.shared_file_storage_dir,
1514     compression_tools=compression_tools,
1515     enabled_user_shutdown=opts.enabled_user_shutdown,
1516     enabled_data_collectors=enabled_data_collectors,
1517     data_collector_interval=data_collector_interval,
1518     )
1519   return base.GetResult(None, opts, SubmitOrSend(op, opts))
1520
1521
1522 def QueueOps(opts, args):
1523   """Queue operations.
1524
1525   @param opts: the command line options selected by the user
1526   @type args: list
1527   @param args: should contain only one element, the subcommand
1528   @rtype: int
1529   @return: the desired exit code
1530
1531   """
1532   command = args[0]
1533   client = GetClient()
1534   if command in ("drain", "undrain"):
1535     drain_flag = command == "drain"
1536     client.SetQueueDrainFlag(drain_flag)
1537   elif command == "info":
1538     result = client.QueryConfigValues(["drain_flag"])
1539     if result[0]:
1540       val = "set"
1541     else:
1542       val = "unset"
1543     ToStdout("The drain flag is %s" % val)
1544   else:
1545     raise errors.OpPrereqError("Command '%s' is not valid." % command,
1546                                errors.ECODE_INVAL)
1547
1548   return 0
1549
1550
1551 def _ShowWatcherPause(until):
1552   if until is None or until < time.time():
1553     ToStdout("The watcher is not paused.")
1554   else:
1555     ToStdout("The watcher is paused until %s.", time.ctime(until))
1556
1557
1558 def WatcherOps(opts, args):
1559   """Watcher operations.
1560
1561   @param opts: the command line options selected by the user
1562   @type args: list
1563   @param args: should contain only one element, the subcommand
1564   @rtype: int
1565   @return: the desired exit code
1566
1567   """
1568   command = args[0]
1569   client = GetClient()
1570
1571   if command == "continue":
1572     client.SetWatcherPause(None)
1573     ToStdout("The watcher is no longer paused.")
1574
1575   elif command == "pause":
1576     if len(args) < 2:
1577       raise errors.OpPrereqError("Missing pause duration", errors.ECODE_INVAL)
1578
1579     result = client.SetWatcherPause(time.time() + ParseTimespec(args[1]))
1580     _ShowWatcherPause(result)
1581
1582   elif command == "info":
1583     result = client.QueryConfigValues(["watcher_pause"])
1584     _ShowWatcherPause(result[0])
1585
1586   else:
1587     raise errors.OpPrereqError("Command '%s' is not valid." % command,
1588                                errors.ECODE_INVAL)
1589
1590   return 0
1591
1592
1593 def _OobPower(opts, node_list, power):
1594   """Puts the node in the list to desired power state.
1595
1596   @param opts: The command line options selected by the user
1597   @param node_list: The list of nodes to operate on
1598   @param power: True if they should be powered on, False otherwise
1599   @return: The success of the operation (none failed)
1600
1601   """
1602   if power:
1603     command = constants.OOB_POWER_ON
1604   else:
1605     command = constants.OOB_POWER_OFF
1606
1607   op = opcodes.OpOobCommand(node_names=node_list,
1608                             command=command,
1609                             ignore_status=True,
1610                             timeout=opts.oob_timeout,
1611                             power_delay=opts.power_delay)
1612   result = SubmitOpCode(op, opts=opts)
1613   errs = 0
1614   for node_result in result:
1615     (node_tuple, data_tuple) = node_result
1616     (_, node_name) = node_tuple
1617     (data_status, _) = data_tuple
1618     if data_status != constants.RS_NORMAL:
1619       assert data_status != constants.RS_UNAVAIL
1620       errs += 1
1621       ToStderr("There was a problem changing power for %s, please investigate",
1622                node_name)
1623
1624   if errs > 0:
1625     return False
1626
1627   return True
1628
1629
1630 def _InstanceStart(opts, inst_list, start, no_remember=False):
1631   """Puts the instances in the list to desired state.
1632
1633   @param opts: The command line options selected by the user
1634   @param inst_list: The list of instances to operate on
1635   @param start: True if they should be started, False for shutdown
1636   @param no_remember: If the instance state should be remembered
1637   @return: The success of the operation (none failed)
1638
1639   """
1640   if start:
1641     opcls = opcodes.OpInstanceStartup
1642     text_submit, text_success, text_failed = ("startup", "started", "starting")
1643   else:
1644     opcls = compat.partial(opcodes.OpInstanceShutdown,
1645                            timeout=opts.shutdown_timeout,
1646                            no_remember=no_remember)
1647     text_submit, text_success, text_failed = ("shutdown", "stopped", "stopping")
1648
1649   jex = JobExecutor(opts=opts)
1650
1651   for inst in inst_list:
1652     ToStdout("Submit %s of instance %s", text_submit, inst)
1653     op = opcls(instance_name=inst)
1654     jex.QueueJob(inst, op)
1655
1656   results = jex.GetResults()
1657   bad_cnt = len([1 for (success, _) in results if not success])
1658
1659   if bad_cnt == 0:
1660     ToStdout("All instances have been %s successfully", text_success)
1661   else:
1662     ToStderr("There were errors while %s instances:\n"
1663              "%d error(s) out of %d instance(s)", text_failed, bad_cnt,
1664              len(results))
1665     return False
1666
1667   return True
1668
1669
1670 class _RunWhenNodesReachableHelper(object):
1671   """Helper class to make shared internal state sharing easier.
1672
1673   @ivar success: Indicates if all action_cb calls were successful
1674
1675   """
1676   def __init__(self, node_list, action_cb, node2ip, port, feedback_fn,
1677                _ping_fn=netutils.TcpPing, _sleep_fn=time.sleep):
1678     """Init the object.
1679
1680     @param node_list: The list of nodes to be reachable
1681     @param action_cb: Callback called when a new host is reachable
1682     @type node2ip: dict
1683     @param node2ip: Node to ip mapping
1684     @param port: The port to use for the TCP ping
1685     @param feedback_fn: The function used for feedback
1686     @param _ping_fn: Function to check reachabilty (for unittest use only)
1687     @param _sleep_fn: Function to sleep (for unittest use only)
1688
1689     """
1690     self.down = set(node_list)
1691     self.up = set()
1692     self.node2ip = node2ip
1693     self.success = True
1694     self.action_cb = action_cb
1695     self.port = port
1696     self.feedback_fn = feedback_fn
1697     self._ping_fn = _ping_fn
1698     self._sleep_fn = _sleep_fn
1699
1700   def __call__(self):
1701     """When called we run action_cb.
1702
1703     @raises utils.RetryAgain: When there are still down nodes
1704
1705     """
1706     if not self.action_cb(self.up):
1707       self.success = False
1708
1709     if self.down:
1710       raise utils.RetryAgain()
1711     else:
1712       return self.success
1713
1714   def Wait(self, secs):
1715     """Checks if a host is up or waits remaining seconds.
1716
1717     @param secs: The secs remaining
1718
1719     """
1720     start = time.time()
1721     for node in self.down:
1722       if self._ping_fn(self.node2ip[node], self.port, timeout=_EPO_PING_TIMEOUT,
1723                        live_port_needed=True):
1724         self.feedback_fn("Node %s became available" % node)
1725         self.up.add(node)
1726         self.down -= self.up
1727         # If we have a node available there is the possibility to run the
1728         # action callback successfully, therefore we don't wait and return
1729         return
1730
1731     self._sleep_fn(max(0.0, start + secs - time.time()))
1732
1733
1734 def _RunWhenNodesReachable(node_list, action_cb, interval):
1735   """Run action_cb when nodes become reachable.
1736
1737   @param node_list: The list of nodes to be reachable
1738   @param action_cb: Callback called when a new host is reachable
1739   @param interval: The earliest time to retry
1740
1741   """
1742   client = GetClient()
1743   cluster_info = client.QueryClusterInfo()
1744   if cluster_info["primary_ip_version"] == constants.IP4_VERSION:
1745     family = netutils.IPAddress.family
1746   else:
1747     family = netutils.IP6Address.family
1748
1749   node2ip = dict((node, netutils.GetHostname(node, family=family).ip)
1750                  for node in node_list)
1751
1752   port = netutils.GetDaemonPort(constants.NODED)
1753   helper = _RunWhenNodesReachableHelper(node_list, action_cb, node2ip, port,
1754                                         ToStdout)
1755
1756   try:
1757     return utils.Retry(helper, interval, _EPO_REACHABLE_TIMEOUT,
1758                        wait_fn=helper.Wait)
1759   except utils.RetryTimeout:
1760     ToStderr("Time exceeded while waiting for nodes to become reachable"
1761              " again:\n  - %s", "  - ".join(helper.down))
1762     return False
1763
1764
1765 def _MaybeInstanceStartup(opts, inst_map, nodes_online,
1766                           _instance_start_fn=_InstanceStart):
1767   """Start the instances conditional based on node_states.
1768
1769   @param opts: The command line options selected by the user
1770   @param inst_map: A dict of inst -> nodes mapping
1771   @param nodes_online: A list of nodes online
1772   @param _instance_start_fn: Callback to start instances (unittest use only)
1773   @return: Success of the operation on all instances
1774
1775   """
1776   start_inst_list = []
1777   for (inst, nodes) in inst_map.items():
1778     if not (nodes - nodes_online):
1779       # All nodes the instance lives on are back online
1780       start_inst_list.append(inst)
1781
1782   for inst in start_inst_list:
1783     del inst_map[inst]
1784
1785   if start_inst_list:
1786     return _instance_start_fn(opts, start_inst_list, True)
1787
1788   return True
1789
1790
1791 def _EpoOn(opts, full_node_list, node_list, inst_map):
1792   """Does the actual power on.
1793
1794   @param opts: The command line options selected by the user
1795   @param full_node_list: All nodes to operate on (includes nodes not supporting
1796                          OOB)
1797   @param node_list: The list of nodes to operate on (all need to support OOB)
1798   @param inst_map: A dict of inst -> nodes mapping
1799   @return: The desired exit status
1800
1801   """
1802   if node_list and not _OobPower(opts, node_list, False):
1803     ToStderr("Not all nodes seem to get back up, investigate and start"
1804              " manually if needed")
1805
1806   # Wait for the nodes to be back up
1807   action_cb = compat.partial(_MaybeInstanceStartup, opts, dict(inst_map))
1808
1809   ToStdout("Waiting until all nodes are available again")
1810   if not _RunWhenNodesReachable(full_node_list, action_cb, _EPO_PING_INTERVAL):
1811     ToStderr("Please investigate and start stopped instances manually")
1812     return constants.EXIT_FAILURE
1813
1814   return constants.EXIT_SUCCESS
1815
1816
1817 def _EpoOff(opts, node_list, inst_map):
1818   """Does the actual power off.
1819
1820   @param opts: The command line options selected by the user
1821   @param node_list: The list of nodes to operate on (all need to support OOB)
1822   @param inst_map: A dict of inst -> nodes mapping
1823   @return: The desired exit status
1824
1825   """
1826   if not _InstanceStart(opts, inst_map.keys(), False, no_remember=True):
1827     ToStderr("Please investigate and stop instances manually before continuing")
1828     return constants.EXIT_FAILURE
1829
1830   if not node_list:
1831     return constants.EXIT_SUCCESS
1832
1833   if _OobPower(opts, node_list, False):
1834     return constants.EXIT_SUCCESS
1835   else:
1836     return constants.EXIT_FAILURE
1837
1838
1839 def Epo(opts, args, qcl=None, _on_fn=_EpoOn, _off_fn=_EpoOff,
1840         _confirm_fn=ConfirmOperation,
1841         _stdout_fn=ToStdout, _stderr_fn=ToStderr):
1842   """EPO operations.
1843
1844   @param opts: the command line options selected by the user
1845   @type args: list
1846   @param args: should contain only one element, the subcommand
1847   @rtype: int
1848   @return: the desired exit code
1849
1850   """
1851   if opts.groups and opts.show_all:
1852     _stderr_fn("Only one of --groups or --all are allowed")
1853     return constants.EXIT_FAILURE
1854   elif args and opts.show_all:
1855     _stderr_fn("Arguments in combination with --all are not allowed")
1856     return constants.EXIT_FAILURE
1857
1858   if qcl is None:
1859     # Query client
1860     qcl = GetClient()
1861
1862   if opts.groups:
1863     node_query_list = \
1864       itertools.chain(*qcl.QueryGroups(args, ["node_list"], False))
1865   else:
1866     node_query_list = args
1867
1868   result = qcl.QueryNodes(node_query_list, ["name", "master", "pinst_list",
1869                                             "sinst_list", "powered", "offline"],
1870                           False)
1871
1872   all_nodes = map(compat.fst, result)
1873   node_list = []
1874   inst_map = {}
1875   for (node, master, pinsts, sinsts, powered, offline) in result:
1876     if not offline:
1877       for inst in (pinsts + sinsts):
1878         if inst in inst_map:
1879           if not master:
1880             inst_map[inst].add(node)
1881         elif master:
1882           inst_map[inst] = set()
1883         else:
1884           inst_map[inst] = set([node])
1885
1886     if master and opts.on:
1887       # We ignore the master for turning on the machines, in fact we are
1888       # already operating on the master at this point :)
1889       continue
1890     elif master and not opts.show_all:
1891       _stderr_fn("%s is the master node, please do a master-failover to another"
1892                  " node not affected by the EPO or use --all if you intend to"
1893                  " shutdown the whole cluster", node)
1894       return constants.EXIT_FAILURE
1895     elif powered is None:
1896       _stdout_fn("Node %s does not support out-of-band handling, it can not be"
1897                  " handled in a fully automated manner", node)
1898     elif powered == opts.on:
1899       _stdout_fn("Node %s is already in desired power state, skipping", node)
1900     elif not offline or (offline and powered):
1901       node_list.append(node)
1902
1903   if not (opts.force or _confirm_fn(all_nodes, "nodes", "epo")):
1904     return constants.EXIT_FAILURE
1905
1906   if opts.on:
1907     return _on_fn(opts, all_nodes, node_list, inst_map)
1908   else:
1909     return _off_fn(opts, node_list, inst_map)
1910
1911
1912 def _GetCreateCommand(info):
1913   buf = StringIO()
1914   buf.write("gnt-cluster init")
1915   PrintIPolicyCommand(buf, info["ipolicy"], False)
1916   buf.write(" ")
1917   buf.write(info["name"])
1918   return buf.getvalue()
1919
1920
1921 def ShowCreateCommand(opts, args):
1922   """Shows the command that can be used to re-create the cluster.
1923
1924   Currently it works only for ipolicy specs.
1925
1926   """
1927   cl = GetClient()
1928   result = cl.QueryClusterInfo()
1929   ToStdout(_GetCreateCommand(result))
1930
1931
1932 def _RunCommandAndReport(cmd):
1933   """Run a command and report its output, iff it failed.
1934
1935   @param cmd: the command to execute
1936   @type cmd: list
1937   @rtype: bool
1938   @return: False, if the execution failed.
1939
1940   """
1941   result = utils.RunCmd(cmd)
1942   if result.failed:
1943     ToStderr("Command %s failed: %s; Output %s" %
1944              (cmd, result.fail_reason, result.output))
1945     return False
1946   return True
1947
1948
1949 def _VerifyCommand(cmd):
1950   """Verify that a given command succeeds on all online nodes.
1951
1952   As this function is intended to run during upgrades, it
1953   is implemented in such a way that it still works, if all Ganeti
1954   daemons are down.
1955
1956   @param cmd: the command to execute
1957   @type cmd: list
1958   @rtype: list
1959   @return: the list of node names that are online where
1960       the command failed.
1961
1962   """
1963   command = utils.text.ShellQuoteArgs([str(val) for val in cmd])
1964
1965   nodes = ssconf.SimpleStore().GetOnlineNodeList()
1966   master_node = ssconf.SimpleStore().GetMasterNode()
1967   cluster_name = ssconf.SimpleStore().GetClusterName()
1968
1969   # If master node is in 'nodes', make sure master node is at list end
1970   if master_node in nodes:
1971     nodes.remove(master_node)
1972     nodes.append(master_node)
1973
1974   failed = []
1975
1976   srun = ssh.SshRunner(cluster_name=cluster_name)
1977   for name in nodes:
1978     result = srun.Run(name, constants.SSH_LOGIN_USER, command)
1979     if result.exit_code != 0:
1980       failed.append(name)
1981
1982   return failed
1983
1984
1985 def _VerifyVersionInstalled(versionstring):
1986   """Verify that the given version of ganeti is installed on all online nodes.
1987
1988   Do nothing, if this is the case, otherwise print an appropriate
1989   message to stderr.
1990
1991   @param versionstring: the version to check for
1992   @type versionstring: string
1993   @rtype: bool
1994   @return: True, if the version is installed on all online nodes
1995
1996   """
1997   badnodes = _VerifyCommand(["test", "-d",
1998                              os.path.join(pathutils.PKGLIBDIR, versionstring)])
1999   if badnodes:
2000     ToStderr("Ganeti version %s not installed on nodes %s"
2001              % (versionstring, ", ".join(badnodes)))
2002     return False
2003
2004   return True
2005
2006
2007 def _GetRunning():
2008   """Determine the list of running jobs.
2009
2010   @rtype: list
2011   @return: the number of jobs still running
2012
2013   """
2014   cl = GetClient()
2015   qfilter = qlang.MakeSimpleFilter("status",
2016                                    frozenset([constants.JOB_STATUS_RUNNING]))
2017   return len(cl.Query(constants.QR_JOB, [], qfilter).data)
2018
2019
2020 def _SetGanetiVersion(versionstring):
2021   """Set the active version of ganeti to the given versionstring
2022
2023   @type versionstring: string
2024   @rtype: list
2025   @return: the list of nodes where the version change failed
2026
2027   """
2028   failed = []
2029   if constants.HAS_GNU_LN:
2030     failed.extend(_VerifyCommand(
2031         ["ln", "-s", "-f", "-T",
2032          os.path.join(pathutils.PKGLIBDIR, versionstring),
2033          os.path.join(pathutils.SYSCONFDIR, "ganeti/lib")]))
2034     failed.extend(_VerifyCommand(
2035         ["ln", "-s", "-f", "-T",
2036          os.path.join(pathutils.SHAREDIR, versionstring),
2037          os.path.join(pathutils.SYSCONFDIR, "ganeti/share")]))
2038   else:
2039     failed.extend(_VerifyCommand(
2040         ["rm", "-f", os.path.join(pathutils.SYSCONFDIR, "ganeti/lib")]))
2041     failed.extend(_VerifyCommand(
2042         ["ln", "-s", "-f", os.path.join(pathutils.PKGLIBDIR, versionstring),
2043          os.path.join(pathutils.SYSCONFDIR, "ganeti/lib")]))
2044     failed.extend(_VerifyCommand(
2045         ["rm", "-f", os.path.join(pathutils.SYSCONFDIR, "ganeti/share")]))
2046     failed.extend(_VerifyCommand(
2047         ["ln", "-s", "-f", os.path.join(pathutils.SHAREDIR, versionstring),
2048          os.path.join(pathutils.SYSCONFDIR, "ganeti/share")]))
2049   return list(set(failed))
2050
2051
2052 def _ExecuteCommands(fns):
2053   """Execute a list of functions, in reverse order.
2054
2055   @type fns: list of functions.
2056   @param fns: the functions to be executed.
2057
2058   """
2059   for fn in reversed(fns):
2060     fn()
2061
2062
2063 def _GetConfigVersion():
2064   """Determine the version the configuration file currently has.
2065
2066   @rtype: tuple or None
2067   @return: (major, minor, revision) if the version can be determined,
2068       None otherwise
2069
2070   """
2071   config_data = serializer.LoadJson(utils.ReadFile(pathutils.CLUSTER_CONF_FILE))
2072   try:
2073     config_version = config_data["version"]
2074   except KeyError:
2075     return None
2076   return utils.SplitVersion(config_version)
2077
2078
2079 def _ReadIntentToUpgrade():
2080   """Read the file documenting the intent to upgrade the cluster.
2081
2082   @rtype: (string, string) or (None, None)
2083   @return: (old version, version to upgrade to), if the file exists,
2084       and (None, None) otherwise.
2085
2086   """
2087   if not os.path.isfile(pathutils.INTENT_TO_UPGRADE):
2088     return (None, None)
2089
2090   contentstring = utils.ReadFile(pathutils.INTENT_TO_UPGRADE)
2091   contents = utils.UnescapeAndSplit(contentstring)
2092   if len(contents) != 3:
2093     # file syntactically mal-formed
2094     return (None, None)
2095   return (contents[0], contents[1])
2096
2097
2098 def _WriteIntentToUpgrade(version):
2099   """Write file documenting the intent to upgrade the cluster.
2100
2101   @type version: string
2102   @param version: the version we intent to upgrade to
2103
2104   """
2105   utils.WriteFile(pathutils.INTENT_TO_UPGRADE,
2106                   data=utils.EscapeAndJoin([constants.RELEASE_VERSION, version,
2107                                             "%d" % os.getpid()]))
2108
2109
2110 def _UpgradeBeforeConfigurationChange(versionstring):
2111   """
2112   Carry out all the tasks necessary for an upgrade that happen before
2113   the configuration file, or Ganeti version, changes.
2114
2115   @type versionstring: string
2116   @param versionstring: the version to upgrade to
2117   @rtype: (bool, list)
2118   @return: tuple of a bool indicating success and a list of rollback tasks
2119
2120   """
2121   rollback = []
2122
2123   if not _VerifyVersionInstalled(versionstring):
2124     return (False, rollback)
2125
2126   _WriteIntentToUpgrade(versionstring)
2127   rollback.append(
2128     lambda: utils.RunCmd(["rm", "-f", pathutils.INTENT_TO_UPGRADE]))
2129
2130   ToStdoutAndLoginfo("Draining queue")
2131   client = GetClient()
2132   client.SetQueueDrainFlag(True)
2133
2134   rollback.append(lambda: GetClient().SetQueueDrainFlag(False))
2135
2136   if utils.SimpleRetry(0, _GetRunning,
2137                        constants.UPGRADE_QUEUE_POLL_INTERVAL,
2138                        constants.UPGRADE_QUEUE_DRAIN_TIMEOUT):
2139     ToStderr("Failed to completely empty the queue.")
2140     return (False, rollback)
2141
2142   ToStdoutAndLoginfo("Pausing the watcher for one hour.")
2143   rollback.append(lambda: GetClient().SetWatcherPause(None))
2144   GetClient().SetWatcherPause(time.time() + 60 * 60)
2145
2146   ToStdoutAndLoginfo("Stopping daemons on master node.")
2147   if not _RunCommandAndReport([pathutils.DAEMON_UTIL, "stop-all"]):
2148     return (False, rollback)
2149
2150   if not _VerifyVersionInstalled(versionstring):
2151     utils.RunCmd([pathutils.DAEMON_UTIL, "start-all"])
2152     return (False, rollback)
2153
2154   ToStdoutAndLoginfo("Stopping daemons everywhere.")
2155   rollback.append(lambda: _VerifyCommand([pathutils.DAEMON_UTIL, "start-all"]))
2156   badnodes = _VerifyCommand([pathutils.DAEMON_UTIL, "stop-all"])
2157   if badnodes:
2158     ToStderr("Failed to stop daemons on %s." % (", ".join(badnodes),))
2159     return (False, rollback)
2160
2161   backuptar = os.path.join(pathutils.BACKUP_DIR, "ganeti%d.tar" % time.time())
2162   ToStdoutAndLoginfo("Backing up configuration as %s", backuptar)
2163   if not _RunCommandAndReport(["mkdir", "-p", pathutils.BACKUP_DIR]):
2164     return (False, rollback)
2165
2166   # Create the archive in a safe manner, as it contains sensitive
2167   # information.
2168   (_, tmp_name) = tempfile.mkstemp(prefix=backuptar, dir=pathutils.BACKUP_DIR)
2169   if not _RunCommandAndReport(["tar", "-cf", tmp_name,
2170                                "--exclude=queue/archive",
2171                                pathutils.DATA_DIR]):
2172     return (False, rollback)
2173
2174   os.rename(tmp_name, backuptar)
2175   return (True, rollback)
2176
2177
2178 def _VersionSpecificDowngrade():
2179   """
2180   Perform any additional downrade tasks that are version specific
2181   and need to be done just after the configuration downgrade. This
2182   function needs to be idempotent, so that it can be redone if the
2183   downgrade procedure gets interrupted after changing the
2184   configuration.
2185
2186   Note that this function has to be reset with every version bump.
2187
2188   @return: True upon success
2189   """
2190   ToStdoutAndLoginfo("Performing version-specific downgrade tasks.")
2191
2192   return True
2193
2194
2195 def _SwitchVersionAndConfig(versionstring, downgrade):
2196   """
2197   Switch to the new Ganeti version and change the configuration,
2198   in correct order.
2199
2200   @type versionstring: string
2201   @param versionstring: the version to change to
2202   @type downgrade: bool
2203   @param downgrade: True, if the configuration should be downgraded
2204   @rtype: (bool, list)
2205   @return: tupe of a bool indicating success, and a list of
2206       additional rollback tasks
2207
2208   """
2209   rollback = []
2210   if downgrade:
2211     ToStdoutAndLoginfo("Downgrading configuration")
2212     if not _RunCommandAndReport([pathutils.CFGUPGRADE, "--downgrade", "-f"]):
2213       return (False, rollback)
2214     # Note: version specific downgrades need to be done before switching
2215     # binaries, so that we still have the knowledgeable binary if the downgrade
2216     # process gets interrupted at this point.
2217     if not _VersionSpecificDowngrade():
2218       return (False, rollback)
2219
2220   # Configuration change is the point of no return. From then onwards, it is
2221   # safer to push through the up/dowgrade than to try to roll it back.
2222
2223   ToStdoutAndLoginfo("Switching to version %s on all nodes", versionstring)
2224   rollback.append(lambda: _SetGanetiVersion(constants.DIR_VERSION))
2225   badnodes = _SetGanetiVersion(versionstring)
2226   if badnodes:
2227     ToStderr("Failed to switch to Ganeti version %s on nodes %s"
2228              % (versionstring, ", ".join(badnodes)))
2229     if not downgrade:
2230       return (False, rollback)
2231
2232   # Now that we have changed to the new version of Ganeti we should
2233   # not communicate over luxi any more, as luxi might have changed in
2234   # incompatible ways. Therefore, manually call the corresponding ganeti
2235   # commands using their canonical (version independent) path.
2236
2237   if not downgrade:
2238     ToStdoutAndLoginfo("Upgrading configuration")
2239     if not _RunCommandAndReport([pathutils.CFGUPGRADE, "-f"]):
2240       return (False, rollback)
2241
2242   return (True, rollback)
2243
2244
2245 def _UpgradeAfterConfigurationChange(oldversion):
2246   """
2247   Carry out the upgrade actions necessary after switching to the new
2248   Ganeti version and updating the configuration.
2249
2250   As this part is run at a time where the new version of Ganeti is already
2251   running, no communication should happen via luxi, as this is not a stable
2252   interface. Also, as the configuration change is the point of no return,
2253   all actions are pushed trough, even if some of them fail.
2254
2255   @param oldversion: the version the upgrade started from
2256   @type oldversion: string
2257   @rtype: int
2258   @return: the intended return value
2259
2260   """
2261   returnvalue = 0
2262
2263   ToStdoutAndLoginfo("Ensuring directories everywhere.")
2264   badnodes = _VerifyCommand([pathutils.ENSURE_DIRS])
2265   if badnodes:
2266     ToStderr("Warning: failed to ensure directories on %s." %
2267              (", ".join(badnodes)))
2268     returnvalue = 1
2269
2270   ToStdoutAndLoginfo("Starting daemons everywhere.")
2271   badnodes = _VerifyCommand([pathutils.DAEMON_UTIL, "start-all"])
2272   if badnodes:
2273     ToStderr("Warning: failed to start daemons on %s." % (", ".join(badnodes),))
2274     returnvalue = 1
2275
2276   ToStdoutAndLoginfo("Redistributing the configuration.")
2277   if not _RunCommandAndReport(["gnt-cluster", "redist-conf", "--yes-do-it"]):
2278     returnvalue = 1
2279
2280   ToStdoutAndLoginfo("Restarting daemons everywhere.")
2281   badnodes = _VerifyCommand([pathutils.DAEMON_UTIL, "stop-all"])
2282   badnodes.extend(_VerifyCommand([pathutils.DAEMON_UTIL, "start-all"]))
2283   if badnodes:
2284     ToStderr("Warning: failed to start daemons on %s." %
2285              (", ".join(list(set(badnodes))),))
2286     returnvalue = 1
2287
2288   ToStdoutAndLoginfo("Undraining the queue.")
2289   if not _RunCommandAndReport(["gnt-cluster", "queue", "undrain"]):
2290     returnvalue = 1
2291
2292   _RunCommandAndReport(["rm", "-f", pathutils.INTENT_TO_UPGRADE])
2293
2294   ToStdoutAndLoginfo("Running post-upgrade hooks")
2295   if not _RunCommandAndReport([pathutils.POST_UPGRADE, oldversion]):
2296     returnvalue = 1
2297
2298   ToStdoutAndLoginfo("Unpausing the watcher.")
2299   if not _RunCommandAndReport(["gnt-cluster", "watcher", "continue"]):
2300     returnvalue = 1
2301
2302   ToStdoutAndLoginfo("Verifying cluster.")
2303   if not _RunCommandAndReport(["gnt-cluster", "verify"]):
2304     returnvalue = 1
2305
2306   return returnvalue
2307
2308
2309 def UpgradeGanetiCommand(opts, args):
2310   """Upgrade a cluster to a new ganeti version.
2311
2312   @param opts: the command line options selected by the user
2313   @type args: list
2314   @param args: should be an empty list
2315   @rtype: int
2316   @return: the desired exit code
2317
2318   """
2319   if ((not opts.resume and opts.to is None)
2320       or (opts.resume and opts.to is not None)):
2321     ToStderr("Precisely one of the options --to and --resume"
2322              " has to be given")
2323     return 1
2324
2325   # If we're not told to resume, verify there is no upgrade
2326   # in progress.
2327   if not opts.resume:
2328     oldversion, versionstring = _ReadIntentToUpgrade()
2329     if versionstring is not None:
2330       # An upgrade is going on; verify whether the target matches
2331       if versionstring == opts.to:
2332         ToStderr("An upgrade is already in progress. Target version matches,"
2333                  " resuming.")
2334         opts.resume = True
2335         opts.to = None
2336       else:
2337         ToStderr("An upgrade from %s to %s is in progress; use --resume to"
2338                  " finish it first" % (oldversion, versionstring))
2339         return 1
2340
2341   utils.SetupLogging(pathutils.LOG_COMMANDS, 'gnt-cluster upgrade', debug=1)
2342
2343   oldversion = constants.RELEASE_VERSION
2344
2345   if opts.resume:
2346     ssconf.CheckMaster(False)
2347     oldversion, versionstring = _ReadIntentToUpgrade()
2348     if versionstring is None:
2349       return 0
2350     version = utils.version.ParseVersion(versionstring)
2351     if version is None:
2352       return 1
2353     configversion = _GetConfigVersion()
2354     if configversion is None:
2355       return 1
2356     # If the upgrade we resume was an upgrade between compatible
2357     # versions (like 2.10.0 to 2.10.1), the correct configversion
2358     # does not guarantee that the config has been updated.
2359     # However, in the case of a compatible update with the configuration
2360     # not touched, we are running a different dirversion with the same
2361     # config version.
2362     config_already_modified = \
2363       (utils.IsCorrectConfigVersion(version, configversion) and
2364        not (versionstring != constants.DIR_VERSION and
2365             configversion == (constants.CONFIG_MAJOR, constants.CONFIG_MINOR,
2366                               constants.CONFIG_REVISION)))
2367     if not config_already_modified:
2368       # We have to start from the beginning; however, some daemons might have
2369       # already been stopped, so the only way to get into a well-defined state
2370       # is by starting all daemons again.
2371       _VerifyCommand([pathutils.DAEMON_UTIL, "start-all"])
2372   else:
2373     versionstring = opts.to
2374     config_already_modified = False
2375     version = utils.version.ParseVersion(versionstring)
2376     if version is None:
2377       ToStderr("Could not parse version string %s" % versionstring)
2378       return 1
2379
2380   msg = utils.version.UpgradeRange(version)
2381   if msg is not None:
2382     ToStderr("Cannot upgrade to %s: %s" % (versionstring, msg))
2383     return 1
2384
2385   if not config_already_modified:
2386     success, rollback = _UpgradeBeforeConfigurationChange(versionstring)
2387     if not success:
2388       _ExecuteCommands(rollback)
2389       return 1
2390   else:
2391     rollback = []
2392
2393   downgrade = utils.version.ShouldCfgdowngrade(version)
2394
2395   success, additionalrollback =  \
2396       _SwitchVersionAndConfig(versionstring, downgrade)
2397   if not success:
2398     rollback.extend(additionalrollback)
2399     _ExecuteCommands(rollback)
2400     return 1
2401
2402   return _UpgradeAfterConfigurationChange(oldversion)
2403
2404
2405 commands = {
2406   "init": (
2407     InitCluster, [ArgHost(min=1, max=1)],
2408     [BACKEND_OPT, CP_SIZE_OPT, ENABLED_HV_OPT, GLOBAL_FILEDIR_OPT,
2409      HVLIST_OPT, MAC_PREFIX_OPT, MASTER_NETDEV_OPT, MASTER_NETMASK_OPT,
2410      NIC_PARAMS_OPT, NOMODIFY_ETCHOSTS_OPT, NOMODIFY_SSH_SETUP_OPT,
2411      SECONDARY_IP_OPT, VG_NAME_OPT, MAINTAIN_NODE_HEALTH_OPT, UIDPOOL_OPT,
2412      DRBD_HELPER_OPT, DEFAULT_IALLOCATOR_OPT, DEFAULT_IALLOCATOR_PARAMS_OPT,
2413      PRIMARY_IP_VERSION_OPT, PREALLOC_WIPE_DISKS_OPT, NODE_PARAMS_OPT,
2414      GLOBAL_SHARED_FILEDIR_OPT, USE_EXTERNAL_MIP_SCRIPT, DISK_PARAMS_OPT,
2415      HV_STATE_OPT, DISK_STATE_OPT, ENABLED_DISK_TEMPLATES_OPT,
2416      IPOLICY_STD_SPECS_OPT, GLOBAL_GLUSTER_FILEDIR_OPT, INSTALL_IMAGE_OPT,
2417      ZEROING_IMAGE_OPT, COMPRESSION_TOOLS_OPT,
2418      ENABLED_USER_SHUTDOWN_OPT,
2419      ]
2420      + INSTANCE_POLICY_OPTS + SPLIT_ISPECS_OPTS,
2421     "[opts...] <cluster_name>", "Initialises a new cluster configuration"),
2422   "destroy": (
2423     DestroyCluster, ARGS_NONE, [YES_DOIT_OPT],
2424     "", "Destroy cluster"),
2425   "rename": (
2426     RenameCluster, [ArgHost(min=1, max=1)],
2427     [FORCE_OPT, DRY_RUN_OPT],
2428     "<new_name>",
2429     "Renames the cluster"),
2430   "redist-conf": (
2431     RedistributeConfig, ARGS_NONE, SUBMIT_OPTS +
2432     [DRY_RUN_OPT, PRIORITY_OPT, FORCE_DISTRIBUTION],
2433     "", "Forces a push of the configuration file and ssconf files"
2434     " to the nodes in the cluster"),
2435   "verify": (
2436     VerifyCluster, ARGS_NONE,
2437     [VERBOSE_OPT, DEBUG_SIMERR_OPT, ERROR_CODES_OPT, NONPLUS1_OPT,
2438      DRY_RUN_OPT, PRIORITY_OPT, NODEGROUP_OPT, IGNORE_ERRORS_OPT,
2439      VERIFY_CLUTTER_OPT],
2440     "", "Does a check on the cluster configuration"),
2441   "verify-disks": (
2442     VerifyDisks, ARGS_NONE, [PRIORITY_OPT],
2443     "", "Does a check on the cluster disk status"),
2444   "repair-disk-sizes": (
2445     RepairDiskSizes, ARGS_MANY_INSTANCES, [DRY_RUN_OPT, PRIORITY_OPT],
2446     "[instance...]", "Updates mismatches in recorded disk sizes"),
2447   "master-failover": (
2448     MasterFailover, ARGS_NONE, [NOVOTING_OPT, FORCE_FAILOVER],
2449     "", "Makes the current node the master"),
2450   "master-ping": (
2451     MasterPing, ARGS_NONE, [],
2452     "", "Checks if the master is alive"),
2453   "version": (
2454     ShowClusterVersion, ARGS_NONE, [],
2455     "", "Shows the cluster version"),
2456   "getmaster": (
2457     ShowClusterMaster, ARGS_NONE, [],
2458     "", "Shows the cluster master"),
2459   "copyfile": (
2460     ClusterCopyFile, [ArgFile(min=1, max=1)],
2461     [NODE_LIST_OPT, USE_REPL_NET_OPT, NODEGROUP_OPT],
2462     "[-n node...] <filename>", "Copies a file to all (or only some) nodes"),
2463   "command": (
2464     RunClusterCommand, [ArgCommand(min=1)],
2465     [NODE_LIST_OPT, NODEGROUP_OPT, SHOW_MACHINE_OPT, FAILURE_ONLY_OPT],
2466     "[-n node...] <command>", "Runs a command on all (or only some) nodes"),
2467   "info": (
2468     ShowClusterConfig, ARGS_NONE, [ROMAN_OPT],
2469     "[--roman]", "Show cluster configuration"),
2470   "list-tags": (
2471     ListTags, ARGS_NONE, [], "", "List the tags of the cluster"),
2472   "add-tags": (
2473     AddTags, [ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT] + SUBMIT_OPTS,
2474     "tag...", "Add tags to the cluster"),
2475   "remove-tags": (
2476     RemoveTags, [ArgUnknown()], [TAG_SRC_OPT, PRIORITY_OPT] + SUBMIT_OPTS,
2477     "tag...", "Remove tags from the cluster"),
2478   "search-tags": (
2479     SearchTags, [ArgUnknown(min=1, max=1)], [PRIORITY_OPT], "",
2480     "Searches the tags on all objects on"
2481     " the cluster for a given pattern (regex)"),
2482   "queue": (
2483     QueueOps,
2484     [ArgChoice(min=1, max=1, choices=["drain", "undrain", "info"])],
2485     [], "drain|undrain|info", "Change queue properties"),
2486   "watcher": (
2487     WatcherOps,
2488     [ArgChoice(min=1, max=1, choices=["pause", "continue", "info"]),
2489      ArgSuggest(min=0, max=1, choices=["30m", "1h", "4h"])],
2490     [],
2491     "{pause <timespec>|continue|info}", "Change watcher properties"),
2492   "modify": (
2493     SetClusterParams, ARGS_NONE,
2494     [FORCE_OPT,
2495      BACKEND_OPT, CP_SIZE_OPT, RQL_OPT, MAX_TRACK_OPT, INSTALL_IMAGE_OPT,
2496      INSTANCE_COMMUNICATION_NETWORK_OPT, ENABLED_HV_OPT, HVLIST_OPT,
2497      MAC_PREFIX_OPT, MASTER_NETDEV_OPT, MASTER_NETMASK_OPT, NIC_PARAMS_OPT,
2498      VG_NAME_OPT, MAINTAIN_NODE_HEALTH_OPT, UIDPOOL_OPT, ADD_UIDS_OPT,
2499      REMOVE_UIDS_OPT, DRBD_HELPER_OPT, DEFAULT_IALLOCATOR_OPT,
2500      DEFAULT_IALLOCATOR_PARAMS_OPT, RESERVED_LVS_OPT, DRY_RUN_OPT, PRIORITY_OPT,
2501      PREALLOC_WIPE_DISKS_OPT, NODE_PARAMS_OPT, USE_EXTERNAL_MIP_SCRIPT,
2502      DISK_PARAMS_OPT, HV_STATE_OPT, DISK_STATE_OPT] + SUBMIT_OPTS +
2503      [ENABLED_DISK_TEMPLATES_OPT, IPOLICY_STD_SPECS_OPT, MODIFY_ETCHOSTS_OPT,
2504       ENABLED_USER_SHUTDOWN_OPT] +
2505      INSTANCE_POLICY_OPTS +
2506      [GLOBAL_FILEDIR_OPT, GLOBAL_SHARED_FILEDIR_OPT, ZEROING_IMAGE_OPT,
2507       COMPRESSION_TOOLS_OPT] +
2508      [ENABLED_DATA_COLLECTORS_OPT, DATA_COLLECTOR_INTERVAL_OPT],
2509     "[opts...]",
2510     "Alters the parameters of the cluster"),
2511   "renew-crypto": (
2512     RenewCrypto, ARGS_NONE,
2513     [NEW_CLUSTER_CERT_OPT, NEW_RAPI_CERT_OPT, RAPI_CERT_OPT,
2514      NEW_CONFD_HMAC_KEY_OPT, FORCE_OPT,
2515      NEW_CLUSTER_DOMAIN_SECRET_OPT, CLUSTER_DOMAIN_SECRET_OPT,
2516      NEW_SPICE_CERT_OPT, SPICE_CERT_OPT, SPICE_CACERT_OPT,
2517      NEW_NODE_CERT_OPT, NEW_SSH_KEY_OPT, NOSSH_KEYCHECK_OPT,
2518      VERBOSE_OPT],
2519     "[opts...]",
2520     "Renews cluster certificates, keys and secrets"),
2521   "epo": (
2522     Epo, [ArgUnknown()],
2523     [FORCE_OPT, ON_OPT, GROUPS_OPT, ALL_OPT, OOB_TIMEOUT_OPT,
2524      SHUTDOWN_TIMEOUT_OPT, POWER_DELAY_OPT],
2525     "[opts...] [args]",
2526     "Performs an emergency power-off on given args"),
2527   "activate-master-ip": (
2528     ActivateMasterIp, ARGS_NONE, [], "", "Activates the master IP"),
2529   "deactivate-master-ip": (
2530     DeactivateMasterIp, ARGS_NONE, [CONFIRM_OPT], "",
2531     "Deactivates the master IP"),
2532   "show-ispecs-cmd": (
2533     ShowCreateCommand, ARGS_NONE, [], "",
2534     "Show the command line to re-create the cluster"),
2535   "upgrade": (
2536     UpgradeGanetiCommand, ARGS_NONE, [TO_OPT, RESUME_OPT], "",
2537     "Upgrade (or downgrade) to a new Ganeti version"),
2538   }
2539
2540
2541 #: dictionary with aliases for commands
2542 aliases = {
2543   "masterfailover": "master-failover",
2544   "show": "info",
2545 }
2546
2547
2548 def Main():
2549   return GenericMain(commands, override={"tag_type": constants.TAG_CLUSTER},
2550                      aliases=aliases)