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

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2008, 2010, 2011 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21
  22 """Functions to bootstrap a new cluster.
  23
  24 """
  25
  26 import os
  27 import os.path
  28 import re
  29 import logging
  30 import time
  31
  32 from ganeti import rpc
  33 from ganeti import ssh
  34 from ganeti import utils
  35 from ganeti import errors
  36 from ganeti import config
  37 from ganeti import constants
  38 from ganeti import objects
  39 from ganeti import ssconf
  40 from ganeti import serializer
  41 from ganeti import hypervisor
  42 from ganeti import bdev
  43 from ganeti import netutils
  44 from ganeti import backend
  45 from ganeti import luxi
  46 from ganeti import jstore
  47
  48
  49 # ec_id for InitConfig's temporary reservation manager
  50 _INITCONF_ECID = "initconfig-ecid"
  51
  52 #: After how many seconds daemon must be responsive
  53 _DAEMON_READY_TIMEOUT = 10.0
  54
  55
  56 def _InitSSHSetup():
  57   """Setup the SSH configuration for the cluster.
  58
  59   This generates a dsa keypair for root, adds the pub key to the
  60   permitted hosts and adds the hostkey to its own known hosts.
  61
  62   """
  63   priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)
  64
  65   for name in priv_key, pub_key:
  66     if os.path.exists(name):
  67       utils.CreateBackup(name)
  68     utils.RemoveFile(name)
  69
  70   result = utils.RunCmd(["ssh-keygen", "-t", "dsa",
  71                          "-f", priv_key,
  72                          "-q", "-N", ""])
  73   if result.failed:
  74     raise errors.OpExecError("Could not generate ssh keypair, error %s" %
  75                              result.output)
  76
  77   utils.AddAuthorizedKey(auth_keys, utils.ReadFile(pub_key))
  78
  79
  80 def GenerateHmacKey(file_name):
  81   """Writes a new HMAC key.
  82
  83   @type file_name: str
  84   @param file_name: Path to output file
  85
  86   """
  87   utils.WriteFile(file_name, data="%s\n" % utils.GenerateSecret(), mode=0400,
  88                   backup=True)
  89
  90
  91 def GenerateClusterCrypto(new_cluster_cert, new_rapi_cert, new_spice_cert,
  92                           new_confd_hmac_key, new_cds,
  93                           rapi_cert_pem=None, spice_cert_pem=None,
  94                           spice_cacert_pem=None, cds=None,
  95                           nodecert_file=constants.NODED_CERT_FILE,
  96                           rapicert_file=constants.RAPI_CERT_FILE,
  97                           spicecert_file=constants.SPICE_CERT_FILE,
  98                           spicecacert_file=constants.SPICE_CACERT_FILE,
  99                           hmackey_file=constants.CONFD_HMAC_KEY,
 100                           cds_file=constants.CLUSTER_DOMAIN_SECRET_FILE):
 101   """Updates the cluster certificates, keys and secrets.
 102
 103   @type new_cluster_cert: bool
 104   @param new_cluster_cert: Whether to generate a new cluster certificate
 105   @type new_rapi_cert: bool
 106   @param new_rapi_cert: Whether to generate a new RAPI certificate
 107   @type new_spice_cert: bool
 108   @param new_spice_cert: Whether to generate a new SPICE certificate
 109   @type new_confd_hmac_key: bool
 110   @param new_confd_hmac_key: Whether to generate a new HMAC key
 111   @type new_cds: bool
 112   @param new_cds: Whether to generate a new cluster domain secret
 113   @type rapi_cert_pem: string
 114   @param rapi_cert_pem: New RAPI certificate in PEM format
 115   @type spice_cert_pem: string
 116   @param spice_cert_pem: New SPICE certificate in PEM format
 117   @type spice_cacert_pem: string
 118   @param spice_cacert_pem: Certificate of the CA that signed the SPICE
 119                            certificate, in PEM format
 120   @type cds: string
 121   @param cds: New cluster domain secret
 122   @type nodecert_file: string
 123   @param nodecert_file: optional override of the node cert file path
 124   @type rapicert_file: string
 125   @param rapicert_file: optional override of the rapi cert file path
 126   @type spicecert_file: string
 127   @param spicecert_file: optional override of the spice cert file path
 128   @type spicecacert_file: string
 129   @param spicecacert_file: optional override of the spice CA cert file path
 130   @type hmackey_file: string
 131   @param hmackey_file: optional override of the hmac key file path
 132
 133   """
 134   # noded SSL certificate
 135   cluster_cert_exists = os.path.exists(nodecert_file)
 136   if new_cluster_cert or not cluster_cert_exists:
 137     if cluster_cert_exists:
 138       utils.CreateBackup(nodecert_file)
 139
 140     logging.debug("Generating new cluster certificate at %s", nodecert_file)
 141     utils.GenerateSelfSignedSslCert(nodecert_file)
 142
 143   # confd HMAC key
 144   if new_confd_hmac_key or not os.path.exists(hmackey_file):
 145     logging.debug("Writing new confd HMAC key to %s", hmackey_file)
 146     GenerateHmacKey(hmackey_file)
 147
 148   # RAPI
 149   rapi_cert_exists = os.path.exists(rapicert_file)
 150
 151   if rapi_cert_pem:
 152     # Assume rapi_pem contains a valid PEM-formatted certificate and key
 153     logging.debug("Writing RAPI certificate at %s", rapicert_file)
 154     utils.WriteFile(rapicert_file, data=rapi_cert_pem, backup=True)
 155
 156   elif new_rapi_cert or not rapi_cert_exists:
 157     if rapi_cert_exists:
 158       utils.CreateBackup(rapicert_file)
 159
 160     logging.debug("Generating new RAPI certificate at %s", rapicert_file)
 161     utils.GenerateSelfSignedSslCert(rapicert_file)
 162
 163   # SPICE
 164   spice_cert_exists = os.path.exists(spicecert_file)
 165   spice_cacert_exists = os.path.exists(spicecacert_file)
 166   if spice_cert_pem:
 167     # spice_cert_pem implies also spice_cacert_pem
 168     logging.debug("Writing SPICE certificate at %s", spicecert_file)
 169     utils.WriteFile(spicecert_file, data=spice_cert_pem, backup=True)
 170     logging.debug("Writing SPICE CA certificate at %s", spicecacert_file)
 171     utils.WriteFile(spicecacert_file, data=spice_cacert_pem, backup=True)
 172   elif new_spice_cert or not spice_cert_exists:
 173     if spice_cert_exists:
 174       utils.CreateBackup(spicecert_file)
 175     if spice_cacert_exists:
 176       utils.CreateBackup(spicecacert_file)
 177
 178     logging.debug("Generating new self-signed SPICE certificate at %s",
 179                   spicecert_file)
 180     (_, cert_pem) = utils.GenerateSelfSignedSslCert(spicecert_file)
 181
 182     # Self-signed certificate -> the public certificate is also the CA public
 183     # certificate
 184     logging.debug("Writing the public certificate to %s",
 185                   spicecert_file)
 186     utils.io.WriteFile(spicecacert_file, mode=0400, data=cert_pem)
 187
 188   # Cluster domain secret
 189   if cds:
 190     logging.debug("Writing cluster domain secret to %s", cds_file)
 191     utils.WriteFile(cds_file, data=cds, backup=True)
 192
 193   elif new_cds or not os.path.exists(cds_file):
 194     logging.debug("Generating new cluster domain secret at %s", cds_file)
 195     GenerateHmacKey(cds_file)
 196
 197
 198 def _InitGanetiServerSetup(master_name):
 199   """Setup the necessary configuration for the initial node daemon.
 200
 201   This creates the nodepass file containing the shared password for
 202   the cluster, generates the SSL certificate and starts the node daemon.
 203
 204   @type master_name: str
 205   @param master_name: Name of the master node
 206
 207   """
 208   # Generate cluster secrets
 209   GenerateClusterCrypto(True, False, False, False, False)
 210
 211   result = utils.RunCmd([constants.DAEMON_UTIL, "start", constants.NODED])
 212   if result.failed:
 213     raise errors.OpExecError("Could not start the node daemon, command %s"
 214                              " had exitcode %s and error %s" %
 215                              (result.cmd, result.exit_code, result.output))
 216
 217   _WaitForNodeDaemon(master_name)
 218
 219
 220 def _WaitForNodeDaemon(node_name):
 221   """Wait for node daemon to become responsive.
 222
 223   """
 224   def _CheckNodeDaemon():
 225     result = rpc.BootstrapRunner().call_version([node_name])[node_name]
 226     if result.fail_msg:
 227       raise utils.RetryAgain()
 228
 229   try:
 230     utils.Retry(_CheckNodeDaemon, 1.0, _DAEMON_READY_TIMEOUT)
 231   except utils.RetryTimeout:
 232     raise errors.OpExecError("Node daemon on %s didn't answer queries within"
 233                              " %s seconds" % (node_name, _DAEMON_READY_TIMEOUT))
 234
 235
 236 def _WaitForMasterDaemon():
 237   """Wait for master daemon to become responsive.
 238
 239   """
 240   def _CheckMasterDaemon():
 241     try:
 242       cl = luxi.Client()
 243       (cluster_name, ) = cl.QueryConfigValues(["cluster_name"])
 244     except Exception:
 245       raise utils.RetryAgain()
 246
 247     logging.debug("Received cluster name %s from master", cluster_name)
 248
 249   try:
 250     utils.Retry(_CheckMasterDaemon, 1.0, _DAEMON_READY_TIMEOUT)
 251   except utils.RetryTimeout:
 252     raise errors.OpExecError("Master daemon didn't answer queries within"
 253                              " %s seconds" % _DAEMON_READY_TIMEOUT)
 254
 255
 256 def _InitFileStorage(file_storage_dir):
 257   """Initialize if needed the file storage.
 258
 259   @param file_storage_dir: the user-supplied value
 260   @return: either empty string (if file storage was disabled at build
 261       time) or the normalized path to the storage directory
 262
 263   """
 264   file_storage_dir = os.path.normpath(file_storage_dir)
 265
 266   if not os.path.isabs(file_storage_dir):
 267     raise errors.OpPrereqError("File storage directory '%s' is not an absolute"
 268                                " path" % file_storage_dir, errors.ECODE_INVAL)
 269
 270   if not os.path.exists(file_storage_dir):
 271     try:
 272       os.makedirs(file_storage_dir, 0750)
 273     except OSError, err:
 274       raise errors.OpPrereqError("Cannot create file storage directory"
 275                                  " '%s': %s" % (file_storage_dir, err),
 276                                  errors.ECODE_ENVIRON)
 277
 278   if not os.path.isdir(file_storage_dir):
 279     raise errors.OpPrereqError("The file storage directory '%s' is not"
 280                                " a directory." % file_storage_dir,
 281                                errors.ECODE_ENVIRON)
 282   return file_storage_dir
 283
 284
 285 def InitCluster(cluster_name, mac_prefix, # pylint: disable=R0913, R0914
 286                 master_netmask, master_netdev, file_storage_dir,
 287                 shared_file_storage_dir, candidate_pool_size, secondary_ip=None,
 288                 vg_name=None, beparams=None, nicparams=None, ndparams=None,
 289                 hvparams=None, diskparams=None, enabled_hypervisors=None,
 290                 modify_etc_hosts=True, modify_ssh_setup=True,
 291                 maintain_node_health=False, drbd_helper=None, uid_pool=None,
 292                 default_iallocator=None, primary_ip_version=None, ipolicy=None,
 293                 prealloc_wipe_disks=False, use_external_mip_script=False,
 294                 hv_state=None, disk_state=None):
 295   """Initialise the cluster.
 296
 297   @type candidate_pool_size: int
 298   @param candidate_pool_size: master candidate pool size
 299
 300   """
 301   # TODO: complete the docstring
 302   if config.ConfigWriter.IsCluster():
 303     raise errors.OpPrereqError("Cluster is already initialised",
 304                                errors.ECODE_STATE)
 305
 306   if not enabled_hypervisors:
 307     raise errors.OpPrereqError("Enabled hypervisors list must contain at"
 308                                " least one member", errors.ECODE_INVAL)
 309   invalid_hvs = set(enabled_hypervisors) - constants.HYPER_TYPES
 310   if invalid_hvs:
 311     raise errors.OpPrereqError("Enabled hypervisors contains invalid"
 312                                " entries: %s" % invalid_hvs,
 313                                errors.ECODE_INVAL)
 314
 315   try:
 316     ipcls = netutils.IPAddress.GetClassFromIpVersion(primary_ip_version)
 317   except errors.ProgrammerError:
 318     raise errors.OpPrereqError("Invalid primary ip version: %d." %
 319                                primary_ip_version)
 320
 321   hostname = netutils.GetHostname(family=ipcls.family)
 322   if not ipcls.IsValid(hostname.ip):
 323     raise errors.OpPrereqError("This host's IP (%s) is not a valid IPv%d"
 324                                " address." % (hostname.ip, primary_ip_version))
 325
 326   if ipcls.IsLoopback(hostname.ip):
 327     raise errors.OpPrereqError("This host's IP (%s) resolves to a loopback"
 328                                " address. Please fix DNS or %s." %
 329                                (hostname.ip, constants.ETC_HOSTS),
 330                                errors.ECODE_ENVIRON)
 331
 332   if not ipcls.Own(hostname.ip):
 333     raise errors.OpPrereqError("Inconsistency: this host's name resolves"
 334                                " to %s,\nbut this ip address does not"
 335                                " belong to this host" %
 336                                hostname.ip, errors.ECODE_ENVIRON)
 337
 338   clustername = netutils.GetHostname(name=cluster_name, family=ipcls.family)
 339
 340   if netutils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT, timeout=5):
 341     raise errors.OpPrereqError("Cluster IP already active",
 342                                errors.ECODE_NOTUNIQUE)
 343
 344   if not secondary_ip:
 345     if primary_ip_version == constants.IP6_VERSION:
 346       raise errors.OpPrereqError("When using a IPv6 primary address, a valid"
 347                                  " IPv4 address must be given as secondary",
 348                                  errors.ECODE_INVAL)
 349     secondary_ip = hostname.ip
 350
 351   if not netutils.IP4Address.IsValid(secondary_ip):
 352     raise errors.OpPrereqError("Secondary IP address (%s) has to be a valid"
 353                                " IPv4 address." % secondary_ip,
 354                                errors.ECODE_INVAL)
 355
 356   if not netutils.IP4Address.Own(secondary_ip):
 357     raise errors.OpPrereqError("You gave %s as secondary IP,"
 358                                " but it does not belong to this host." %
 359                                secondary_ip, errors.ECODE_ENVIRON)
 360
 361   if master_netmask is not None:
 362     if not ipcls.ValidateNetmask(master_netmask):
 363       raise errors.OpPrereqError("CIDR netmask (%s) not valid for IPv%s " %
 364                                   (master_netmask, primary_ip_version))
 365   else:
 366     master_netmask = ipcls.iplen
 367
 368   if vg_name is not None:
 369     # Check if volume group is valid
 370     vgstatus = utils.CheckVolumeGroupSize(utils.ListVolumeGroups(), vg_name,
 371                                           constants.MIN_VG_SIZE)
 372     if vgstatus:
 373       raise errors.OpPrereqError("Error: %s\nspecify --no-lvm-storage if"
 374                                  " you are not using lvm" % vgstatus,
 375                                  errors.ECODE_INVAL)
 376
 377   if drbd_helper is not None:
 378     try:
 379       curr_helper = bdev.BaseDRBD.GetUsermodeHelper()
 380     except errors.BlockDeviceError, err:
 381       raise errors.OpPrereqError("Error while checking drbd helper"
 382                                  " (specify --no-drbd-storage if you are not"
 383                                  " using drbd): %s" % str(err),
 384                                  errors.ECODE_ENVIRON)
 385     if drbd_helper != curr_helper:
 386       raise errors.OpPrereqError("Error: requiring %s as drbd helper but %s"
 387                                  " is the current helper" % (drbd_helper,
 388                                                              curr_helper),
 389                                  errors.ECODE_INVAL)
 390
 391   if constants.ENABLE_FILE_STORAGE:
 392     file_storage_dir = _InitFileStorage(file_storage_dir)
 393   else:
 394     file_storage_dir = ""
 395
 396   if constants.ENABLE_SHARED_FILE_STORAGE:
 397     shared_file_storage_dir = _InitFileStorage(shared_file_storage_dir)
 398   else:
 399     shared_file_storage_dir = ""
 400
 401   if not re.match("^[0-9a-z]{2}:[0-9a-z]{2}:[0-9a-z]{2}$", mac_prefix):
 402     raise errors.OpPrereqError("Invalid mac prefix given '%s'" % mac_prefix,
 403                                errors.ECODE_INVAL)
 404
 405   result = utils.RunCmd(["ip", "link", "show", "dev", master_netdev])
 406   if result.failed:
 407     raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %
 408                                (master_netdev,
 409                                 result.output.strip()), errors.ECODE_INVAL)
 410
 411   dirs = [(constants.RUN_GANETI_DIR, constants.RUN_DIRS_MODE)]
 412   utils.EnsureDirs(dirs)
 413
 414   objects.UpgradeBeParams(beparams)
 415   utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
 416   utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
 417   for key, val in ipolicy.items():
 418     if key not in constants.IPOLICY_PARAMETERS:
 419       raise errors.OpPrereqError("'%s' is not a valid key for instance policy"
 420                                  " description", key)
 421     utils.ForceDictType(val, constants.ISPECS_PARAMETER_TYPES)
 422
 423   objects.NIC.CheckParameterSyntax(nicparams)
 424   full_ipolicy = objects.FillDictOfDicts(constants.IPOLICY_DEFAULTS,
 425                                          ipolicy)
 426   objects.InstancePolicy.CheckParameterSyntax(full_ipolicy)
 427
 428   if ndparams is not None:
 429     utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
 430   else:
 431     ndparams = dict(constants.NDC_DEFAULTS)
 432
 433   # This is ugly, as we modify the dict itself
 434   # FIXME: Make utils.ForceDictType pure functional or write a wrapper around it
 435   if hv_state:
 436     for hvname, hvs_data in hv_state.items():
 437       utils.ForceDictType(hvs_data, constants.HVSTS_PARAMETER_TYPES)
 438       hv_state[hvname] = objects.Cluster.SimpleFillHvState(hvs_data)
 439   else:
 440     hv_state = dict((hvname, constants.HVST_DEFAULTS)
 441                     for hvname in enabled_hypervisors)
 442
 443   # FIXME: disk_state has no default values yet
 444   if disk_state:
 445     for storage, ds_data in disk_state.items():
 446       if storage not in constants.DS_VALID_TYPES:
 447         raise errors.OpPrereqError("Invalid storage type in disk state: %s" %
 448                                    storage, errors.ECODE_INVAL)
 449       for ds_name, state in ds_data.items():
 450         utils.ForceDictType(state, constants.DSS_PARAMETER_TYPES)
 451         ds_data[ds_name] = objects.Cluster.SimpleFillDiskState(state)
 452
 453   # hvparams is a mapping of hypervisor->hvparams dict
 454   for hv_name, hv_params in hvparams.iteritems():
 455     utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
 456     hv_class = hypervisor.GetHypervisor(hv_name)
 457     hv_class.CheckParameterSyntax(hv_params)
 458
 459   # diskparams is a mapping of disk-template->diskparams dict
 460   for template, dt_params in diskparams.items():
 461     param_keys = set(dt_params.keys())
 462     default_param_keys = set(constants.DISK_DT_DEFAULTS[template].keys())
 463     if not (param_keys <= default_param_keys):
 464       unknown_params = param_keys - default_param_keys
 465       raise errors.OpPrereqError("Invalid parameters for disk template %s:"
 466                                  " %s" % (template,
 467                                           utils.CommaJoin(unknown_params)))
 468     utils.ForceDictType(dt_params, constants.DISK_DT_TYPES)
 469
 470   # set up ssh config and /etc/hosts
 471   sshline = utils.ReadFile(constants.SSH_HOST_RSA_PUB)
 472   sshkey = sshline.split(" ")[1]
 473
 474   if modify_etc_hosts:
 475     utils.AddHostToEtcHosts(hostname.name, hostname.ip)
 476
 477   if modify_ssh_setup:
 478     _InitSSHSetup()
 479
 480   if default_iallocator is not None:
 481     alloc_script = utils.FindFile(default_iallocator,
 482                                   constants.IALLOCATOR_SEARCH_PATH,
 483                                   os.path.isfile)
 484     if alloc_script is None:
 485       raise errors.OpPrereqError("Invalid default iallocator script '%s'"
 486                                  " specified" % default_iallocator,
 487                                  errors.ECODE_INVAL)
 488   elif constants.HTOOLS:
 489     # htools was enabled at build-time, we default to it
 490     if utils.FindFile(constants.IALLOC_HAIL,
 491                       constants.IALLOCATOR_SEARCH_PATH,
 492                       os.path.isfile):
 493       default_iallocator = constants.IALLOC_HAIL
 494
 495   now = time.time()
 496
 497   # init of cluster config file
 498   cluster_config = objects.Cluster(
 499     serial_no=1,
 500     rsahostkeypub=sshkey,
 501     highest_used_port=(constants.FIRST_DRBD_PORT - 1),
 502     mac_prefix=mac_prefix,
 503     volume_group_name=vg_name,
 504     tcpudp_port_pool=set(),
 505     master_node=hostname.name,
 506     master_ip=clustername.ip,
 507     master_netmask=master_netmask,
 508     master_netdev=master_netdev,
 509     cluster_name=clustername.name,
 510     file_storage_dir=file_storage_dir,
 511     shared_file_storage_dir=shared_file_storage_dir,
 512     enabled_hypervisors=enabled_hypervisors,
 513     beparams={constants.PP_DEFAULT: beparams},
 514     nicparams={constants.PP_DEFAULT: nicparams},
 515     ndparams=ndparams,
 516     hvparams=hvparams,
 517     diskparams=diskparams,
 518     candidate_pool_size=candidate_pool_size,
 519     modify_etc_hosts=modify_etc_hosts,
 520     modify_ssh_setup=modify_ssh_setup,
 521     uid_pool=uid_pool,
 522     ctime=now,
 523     mtime=now,
 524     maintain_node_health=maintain_node_health,
 525     drbd_usermode_helper=drbd_helper,
 526     default_iallocator=default_iallocator,
 527     primary_ip_family=ipcls.family,
 528     prealloc_wipe_disks=prealloc_wipe_disks,
 529     use_external_mip_script=use_external_mip_script,
 530     ipolicy=ipolicy,
 531     hv_state_static=hv_state,
 532     disk_state_static=disk_state,
 533     )
 534   master_node_config = objects.Node(name=hostname.name,
 535                                     primary_ip=hostname.ip,
 536                                     secondary_ip=secondary_ip,
 537                                     serial_no=1,
 538                                     master_candidate=True,
 539                                     offline=False, drained=False,
 540                                     ctime=now, mtime=now,
 541                                     )
 542   InitConfig(constants.CONFIG_VERSION, cluster_config, master_node_config)
 543   cfg = config.ConfigWriter(offline=True)
 544   ssh.WriteKnownHostsFile(cfg, constants.SSH_KNOWN_HOSTS_FILE)
 545   cfg.Update(cfg.GetClusterInfo(), logging.error)
 546   backend.WriteSsconfFiles(cfg.GetSsconfValues())
 547
 548   # set up the inter-node password and certificate
 549   _InitGanetiServerSetup(hostname.name)
 550
 551   logging.debug("Starting daemons")
 552   result = utils.RunCmd([constants.DAEMON_UTIL, "start-all"])
 553   if result.failed:
 554     raise errors.OpExecError("Could not start daemons, command %s"
 555                              " had exitcode %s and error %s" %
 556                              (result.cmd, result.exit_code, result.output))
 557
 558   _WaitForMasterDaemon()
 559
 560
 561 def InitConfig(version, cluster_config, master_node_config,
 562                cfg_file=constants.CLUSTER_CONF_FILE):
 563   """Create the initial cluster configuration.
 564
 565   It will contain the current node, which will also be the master
 566   node, and no instances.
 567
 568   @type version: int
 569   @param version: configuration version
 570   @type cluster_config: L{objects.Cluster}
 571   @param cluster_config: cluster configuration
 572   @type master_node_config: L{objects.Node}
 573   @param master_node_config: master node configuration
 574   @type cfg_file: string
 575   @param cfg_file: configuration file path
 576
 577   """
 578   uuid_generator = config.TemporaryReservationManager()
 579   cluster_config.uuid = uuid_generator.Generate([], utils.NewUUID,
 580                                                 _INITCONF_ECID)
 581   master_node_config.uuid = uuid_generator.Generate([], utils.NewUUID,
 582                                                     _INITCONF_ECID)
 583   nodes = {
 584     master_node_config.name: master_node_config,
 585     }
 586   default_nodegroup = objects.NodeGroup(
 587     uuid=uuid_generator.Generate([], utils.NewUUID, _INITCONF_ECID),
 588     name=constants.INITIAL_NODE_GROUP_NAME,
 589     members=[master_node_config.name],
 590     diskparams=cluster_config.diskparams,
 591     )
 592   nodegroups = {
 593     default_nodegroup.uuid: default_nodegroup,
 594     }
 595   now = time.time()
 596   config_data = objects.ConfigData(version=version,
 597                                    cluster=cluster_config,
 598                                    nodegroups=nodegroups,
 599                                    nodes=nodes,
 600                                    instances={},
 601                                    serial_no=1,
 602                                    ctime=now, mtime=now)
 603   utils.WriteFile(cfg_file,
 604                   data=serializer.Dump(config_data.ToDict()),
 605                   mode=0600)
 606
 607
 608 def FinalizeClusterDestroy(master):
 609   """Execute the last steps of cluster destroy
 610
 611   This function shuts down all the daemons, completing the destroy
 612   begun in cmdlib.LUDestroyOpcode.
 613
 614   """
 615   cfg = config.ConfigWriter()
 616   modify_ssh_setup = cfg.GetClusterInfo().modify_ssh_setup
 617   runner = rpc.BootstrapRunner()
 618
 619   master_params = cfg.GetMasterNetworkParameters()
 620   master_params.name = master
 621   ems = cfg.GetUseExternalMipScript()
 622   result = runner.call_node_deactivate_master_ip(master_params.name,
 623                                                  master_params, ems)
 624
 625   msg = result.fail_msg
 626   if msg:
 627     logging.warning("Could not disable the master IP: %s", msg)
 628
 629   result = runner.call_node_stop_master(master)
 630   msg = result.fail_msg
 631   if msg:
 632     logging.warning("Could not disable the master role: %s", msg)
 633
 634   result = runner.call_node_leave_cluster(master, modify_ssh_setup)
 635   msg = result.fail_msg
 636   if msg:
 637     logging.warning("Could not shutdown the node daemon and cleanup"
 638                     " the node: %s", msg)
 639
 640
 641 def SetupNodeDaemon(cluster_name, node, ssh_key_check):
 642   """Add a node to the cluster.
 643
 644   This function must be called before the actual opcode, and will ssh
 645   to the remote node, copy the needed files, and start ganeti-noded,
 646   allowing the master to do the rest via normal rpc calls.
 647
 648   @param cluster_name: the cluster name
 649   @param node: the name of the new node
 650   @param ssh_key_check: whether to do a strict key check
 651
 652   """
 653   family = ssconf.SimpleStore().GetPrimaryIPFamily()
 654   sshrunner = ssh.SshRunner(cluster_name,
 655                             ipv6=(family == netutils.IP6Address.family))
 656
 657   bind_address = constants.IP4_ADDRESS_ANY
 658   if family == netutils.IP6Address.family:
 659     bind_address = constants.IP6_ADDRESS_ANY
 660
 661   # set up inter-node password and certificate and restarts the node daemon
 662   # and then connect with ssh to set password and start ganeti-noded
 663   # note that all the below variables are sanitized at this point,
 664   # either by being constants or by the checks above
 665   sshrunner.CopyFileToNode(node, constants.NODED_CERT_FILE)
 666   sshrunner.CopyFileToNode(node, constants.RAPI_CERT_FILE)
 667   sshrunner.CopyFileToNode(node, constants.SPICE_CERT_FILE)
 668   sshrunner.CopyFileToNode(node, constants.SPICE_CACERT_FILE)
 669   sshrunner.CopyFileToNode(node, constants.CONFD_HMAC_KEY)
 670   mycommand = ("%s stop-all; %s start %s -b %s" %
 671                (constants.DAEMON_UTIL, constants.DAEMON_UTIL, constants.NODED,
 672                 utils.ShellQuote(bind_address)))
 673
 674   result = sshrunner.Run(node, 'root', mycommand, batch=False,
 675                          ask_key=ssh_key_check,
 676                          use_cluster_key=True,
 677                          strict_host_check=ssh_key_check)
 678   if result.failed:
 679     raise errors.OpExecError("Remote command on node %s, error: %s,"
 680                              " output: %s" %
 681                              (node, result.fail_reason, result.output))
 682
 683   _WaitForNodeDaemon(node)
 684
 685
 686 def MasterFailover(no_voting=False):
 687   """Failover the master node.
 688
 689   This checks that we are not already the master, and will cause the
 690   current master to cease being master, and the non-master to become
 691   new master.
 692
 693   @type no_voting: boolean
 694   @param no_voting: force the operation without remote nodes agreement
 695                       (dangerous)
 696
 697   """
 698   sstore = ssconf.SimpleStore()
 699
 700   old_master, new_master = ssconf.GetMasterAndMyself(sstore)
 701   node_list = sstore.GetNodeList()
 702   mc_list = sstore.GetMasterCandidates()
 703
 704   if old_master == new_master:
 705     raise errors.OpPrereqError("This commands must be run on the node"
 706                                " where you want the new master to be."
 707                                " %s is already the master" %
 708                                old_master, errors.ECODE_INVAL)
 709
 710   if new_master not in mc_list:
 711     mc_no_master = [name for name in mc_list if name != old_master]
 712     raise errors.OpPrereqError("This node is not among the nodes marked"
 713                                " as master candidates. Only these nodes"
 714                                " can become masters. Current list of"
 715                                " master candidates is:\n"
 716                                "%s" % ('\n'.join(mc_no_master)),
 717                                errors.ECODE_STATE)
 718
 719   if not no_voting:
 720     vote_list = GatherMasterVotes(node_list)
 721
 722     if vote_list:
 723       voted_master = vote_list[0][0]
 724       if voted_master is None:
 725         raise errors.OpPrereqError("Cluster is inconsistent, most nodes did"
 726                                    " not respond.", errors.ECODE_ENVIRON)
 727       elif voted_master != old_master:
 728         raise errors.OpPrereqError("I have a wrong configuration, I believe"
 729                                    " the master is %s but the other nodes"
 730                                    " voted %s. Please resync the configuration"
 731                                    " of this node." %
 732                                    (old_master, voted_master),
 733                                    errors.ECODE_STATE)
 734   # end checks
 735
 736   rcode = 0
 737
 738   logging.info("Setting master to %s, old master: %s", new_master, old_master)
 739
 740   try:
 741     # instantiate a real config writer, as we now know we have the
 742     # configuration data
 743     cfg = config.ConfigWriter(accept_foreign=True)
 744
 745     cluster_info = cfg.GetClusterInfo()
 746     cluster_info.master_node = new_master
 747     # this will also regenerate the ssconf files, since we updated the
 748     # cluster info
 749     cfg.Update(cluster_info, logging.error)
 750   except errors.ConfigurationError, err:
 751     logging.error("Error while trying to set the new master: %s",
 752                   str(err))
 753     return 1
 754
 755   # if cfg.Update worked, then it means the old master daemon won't be
 756   # able now to write its own config file (we rely on locking in both
 757   # backend.UploadFile() and ConfigWriter._Write(); hence the next
 758   # step is to kill the old master
 759
 760   logging.info("Stopping the master daemon on node %s", old_master)
 761
 762   runner = rpc.BootstrapRunner()
 763   master_params = cfg.GetMasterNetworkParameters()
 764   master_params.name = old_master
 765   ems = cfg.GetUseExternalMipScript()
 766   result = runner.call_node_deactivate_master_ip(master_params.name,
 767                                                  master_params, ems)
 768
 769   msg = result.fail_msg
 770   if msg:
 771     logging.warning("Could not disable the master IP: %s", msg)
 772
 773   result = runner.call_node_stop_master(old_master)
 774   msg = result.fail_msg
 775   if msg:
 776     logging.error("Could not disable the master role on the old master"
 777                  " %s, please disable manually: %s", old_master, msg)
 778
 779   logging.info("Checking master IP non-reachability...")
 780
 781   master_ip = sstore.GetMasterIP()
 782   total_timeout = 30
 783
 784   # Here we have a phase where no master should be running
 785   def _check_ip():
 786     if netutils.TcpPing(master_ip, constants.DEFAULT_NODED_PORT):
 787       raise utils.RetryAgain()
 788
 789   try:
 790     utils.Retry(_check_ip, (1, 1.5, 5), total_timeout)
 791   except utils.RetryTimeout:
 792     logging.warning("The master IP is still reachable after %s seconds,"
 793                     " continuing but activating the master on the current"
 794                     " node will probably fail", total_timeout)
 795
 796   if jstore.CheckDrainFlag():
 797     logging.info("Undraining job queue")
 798     jstore.SetDrainFlag(False)
 799
 800   logging.info("Starting the master daemons on the new master")
 801
 802   result = rpc.BootstrapRunner().call_node_start_master_daemons(new_master,
 803                                                                 no_voting)
 804   msg = result.fail_msg
 805   if msg:
 806     logging.error("Could not start the master role on the new master"
 807                   " %s, please check: %s", new_master, msg)
 808     rcode = 1
 809
 810   logging.info("Master failed over from %s to %s", old_master, new_master)
 811   return rcode
 812
 813
 814 def GetMaster():
 815   """Returns the current master node.
 816
 817   This is a separate function in bootstrap since it's needed by
 818   gnt-cluster, and instead of importing directly ssconf, it's better
 819   to abstract it in bootstrap, where we do use ssconf in other
 820   functions too.
 821
 822   """
 823   sstore = ssconf.SimpleStore()
 824
 825   old_master, _ = ssconf.GetMasterAndMyself(sstore)
 826
 827   return old_master
 828
 829
 830 def GatherMasterVotes(node_list):
 831   """Check the agreement on who is the master.
 832
 833   This function will return a list of (node, number of votes), ordered
 834   by the number of votes. Errors will be denoted by the key 'None'.
 835
 836   Note that the sum of votes is the number of nodes this machine
 837   knows, whereas the number of entries in the list could be different
 838   (if some nodes vote for another master).
 839
 840   We remove ourselves from the list since we know that (bugs aside)
 841   since we use the same source for configuration information for both
 842   backend and boostrap, we'll always vote for ourselves.
 843
 844   @type node_list: list
 845   @param node_list: the list of nodes to query for master info; the current
 846       node will be removed if it is in the list
 847   @rtype: list
 848   @return: list of (node, votes)
 849
 850   """
 851   myself = netutils.Hostname.GetSysName()
 852   try:
 853     node_list.remove(myself)
 854   except ValueError:
 855     pass
 856   if not node_list:
 857     # no nodes left (eventually after removing myself)
 858     return []
 859   results = rpc.BootstrapRunner().call_master_info(node_list)
 860   if not isinstance(results, dict):
 861     # this should not happen (unless internal error in rpc)
 862     logging.critical("Can't complete rpc call, aborting master startup")
 863     return [(None, len(node_list))]
 864   votes = {}
 865   for node in results:
 866     nres = results[node]
 867     data = nres.payload
 868     msg = nres.fail_msg
 869     fail = False
 870     if msg:
 871       logging.warning("Error contacting node %s: %s", node, msg)
 872       fail = True
 873     # for now we accept both length 3, 4 and 5 (data[3] is primary ip version
 874     # and data[4] is the master netmask)
 875     elif not isinstance(data, (tuple, list)) or len(data) < 3:
 876       logging.warning("Invalid data received from node %s: %s", node, data)
 877       fail = True
 878     if fail:
 879       if None not in votes:
 880         votes[None] = 0
 881       votes[None] += 1
 882       continue
 883     master_node = data[2]
 884     if master_node not in votes:
 885       votes[master_node] = 0
 886     votes[master_node] += 1
 887
 888   vote_list = [v for v in votes.items()]
 889   # sort first on number of votes then on name, since we want None
 890   # sorted later if we have the half of the nodes not responding, and
 891   # half voting all for the same master
 892   vote_list.sort(key=lambda x: (x[1], x[0]), reverse=True)
 893
 894   return vote_list