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

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2008, 2010 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
  46 # ec_id for InitConfig's temporary reservation manager
  47 _INITCONF_ECID = "initconfig-ecid"
  48
  49
  50 def _InitSSHSetup():
  51   """Setup the SSH configuration for the cluster.
  52
  53   This generates a dsa keypair for root, adds the pub key to the
  54   permitted hosts and adds the hostkey to its own known hosts.
  55
  56   """
  57   priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)
  58
  59   for name in priv_key, pub_key:
  60     if os.path.exists(name):
  61       utils.CreateBackup(name)
  62     utils.RemoveFile(name)
  63
  64   result = utils.RunCmd(["ssh-keygen", "-t", "dsa",
  65                          "-f", priv_key,
  66                          "-q", "-N", ""])
  67   if result.failed:
  68     raise errors.OpExecError("Could not generate ssh keypair, error %s" %
  69                              result.output)
  70
  71   utils.AddAuthorizedKey(auth_keys, utils.ReadFile(pub_key))
  72
  73
  74 def GenerateHmacKey(file_name):
  75   """Writes a new HMAC key.
  76
  77   @type file_name: str
  78   @param file_name: Path to output file
  79
  80   """
  81   utils.WriteFile(file_name, data="%s\n" % utils.GenerateSecret(), mode=0400,
  82                   backup=True)
  83
  84
  85 def GenerateClusterCrypto(new_cluster_cert, new_rapi_cert, new_confd_hmac_key,
  86                           new_cds, rapi_cert_pem=None, cds=None,
  87                           nodecert_file=constants.NODED_CERT_FILE,
  88                           rapicert_file=constants.RAPI_CERT_FILE,
  89                           hmackey_file=constants.CONFD_HMAC_KEY,
  90                           cds_file=constants.CLUSTER_DOMAIN_SECRET_FILE):
  91   """Updates the cluster certificates, keys and secrets.
  92
  93   @type new_cluster_cert: bool
  94   @param new_cluster_cert: Whether to generate a new cluster certificate
  95   @type new_rapi_cert: bool
  96   @param new_rapi_cert: Whether to generate a new RAPI certificate
  97   @type new_confd_hmac_key: bool
  98   @param new_confd_hmac_key: Whether to generate a new HMAC key
  99   @type new_cds: bool
 100   @param new_cds: Whether to generate a new cluster domain secret
 101   @type rapi_cert_pem: string
 102   @param rapi_cert_pem: New RAPI certificate in PEM format
 103   @type cds: string
 104   @param cds: New cluster domain secret
 105   @type nodecert_file: string
 106   @param nodecert_file: optional override of the node cert file path
 107   @type rapicert_file: string
 108   @param rapicert_file: optional override of the rapi cert file path
 109   @type hmackey_file: string
 110   @param hmackey_file: optional override of the hmac key file path
 111
 112   """
 113   # noded SSL certificate
 114   cluster_cert_exists = os.path.exists(nodecert_file)
 115   if new_cluster_cert or not cluster_cert_exists:
 116     if cluster_cert_exists:
 117       utils.CreateBackup(nodecert_file)
 118
 119     logging.debug("Generating new cluster certificate at %s", nodecert_file)
 120     utils.GenerateSelfSignedSslCert(nodecert_file)
 121
 122   # confd HMAC key
 123   if new_confd_hmac_key or not os.path.exists(hmackey_file):
 124     logging.debug("Writing new confd HMAC key to %s", hmackey_file)
 125     GenerateHmacKey(hmackey_file)
 126
 127   # RAPI
 128   rapi_cert_exists = os.path.exists(rapicert_file)
 129
 130   if rapi_cert_pem:
 131     # Assume rapi_pem contains a valid PEM-formatted certificate and key
 132     logging.debug("Writing RAPI certificate at %s", rapicert_file)
 133     utils.WriteFile(rapicert_file, data=rapi_cert_pem, backup=True)
 134
 135   elif new_rapi_cert or not rapi_cert_exists:
 136     if rapi_cert_exists:
 137       utils.CreateBackup(rapicert_file)
 138
 139     logging.debug("Generating new RAPI certificate at %s", rapicert_file)
 140     utils.GenerateSelfSignedSslCert(rapicert_file)
 141
 142   # Cluster domain secret
 143   if cds:
 144     logging.debug("Writing cluster domain secret to %s", cds_file)
 145     utils.WriteFile(cds_file, data=cds, backup=True)
 146
 147   elif new_cds or not os.path.exists(cds_file):
 148     logging.debug("Generating new cluster domain secret at %s", cds_file)
 149     GenerateHmacKey(cds_file)
 150
 151
 152 def _InitGanetiServerSetup(master_name):
 153   """Setup the necessary configuration for the initial node daemon.
 154
 155   This creates the nodepass file containing the shared password for
 156   the cluster, generates the SSL certificate and starts the node daemon.
 157
 158   @type master_name: str
 159   @param master_name: Name of the master node
 160
 161   """
 162   # Generate cluster secrets
 163   GenerateClusterCrypto(True, False, False, False)
 164
 165   result = utils.RunCmd([constants.DAEMON_UTIL, "start", constants.NODED])
 166   if result.failed:
 167     raise errors.OpExecError("Could not start the node daemon, command %s"
 168                              " had exitcode %s and error %s" %
 169                              (result.cmd, result.exit_code, result.output))
 170
 171   _WaitForNodeDaemon(master_name)
 172
 173
 174 def _WaitForNodeDaemon(node_name):
 175   """Wait for node daemon to become responsive.
 176
 177   """
 178   def _CheckNodeDaemon():
 179     result = rpc.RpcRunner.call_version([node_name])[node_name]
 180     if result.fail_msg:
 181       raise utils.RetryAgain()
 182
 183   try:
 184     utils.Retry(_CheckNodeDaemon, 1.0, 10.0)
 185   except utils.RetryTimeout:
 186     raise errors.OpExecError("Node daemon on %s didn't answer queries within"
 187                              " 10 seconds" % node_name)
 188
 189
 190 def _InitFileStorage(file_storage_dir):
 191   """Initialize if needed the file storage.
 192
 193   @param file_storage_dir: the user-supplied value
 194   @return: either empty string (if file storage was disabled at build
 195       time) or the normalized path to the storage directory
 196
 197   """
 198   if not constants.ENABLE_FILE_STORAGE:
 199     return ""
 200
 201   file_storage_dir = os.path.normpath(file_storage_dir)
 202
 203   if not os.path.isabs(file_storage_dir):
 204     raise errors.OpPrereqError("The file storage directory you passed is"
 205                                " not an absolute path.", errors.ECODE_INVAL)
 206
 207   if not os.path.exists(file_storage_dir):
 208     try:
 209       os.makedirs(file_storage_dir, 0750)
 210     except OSError, err:
 211       raise errors.OpPrereqError("Cannot create file storage directory"
 212                                  " '%s': %s" % (file_storage_dir, err),
 213                                  errors.ECODE_ENVIRON)
 214
 215   if not os.path.isdir(file_storage_dir):
 216     raise errors.OpPrereqError("The file storage directory '%s' is not"
 217                                " a directory." % file_storage_dir,
 218                                errors.ECODE_ENVIRON)
 219   return file_storage_dir
 220
 221
 222 #pylint: disable-msg=R0913
 223 def InitCluster(cluster_name, mac_prefix,
 224                 master_netdev, file_storage_dir, candidate_pool_size,
 225                 secondary_ip=None, vg_name=None, beparams=None,
 226                 nicparams=None, ndparams=None, hvparams=None,
 227                 enabled_hypervisors=None, modify_etc_hosts=True,
 228                 modify_ssh_setup=True, maintain_node_health=False,
 229                 drbd_helper=None, uid_pool=None, default_iallocator=None,
 230                 primary_ip_version=None, prealloc_wipe_disks=False):
 231   """Initialise the cluster.
 232
 233   @type candidate_pool_size: int
 234   @param candidate_pool_size: master candidate pool size
 235
 236   """
 237   # TODO: complete the docstring
 238   if config.ConfigWriter.IsCluster():
 239     raise errors.OpPrereqError("Cluster is already initialised",
 240                                errors.ECODE_STATE)
 241
 242   if not enabled_hypervisors:
 243     raise errors.OpPrereqError("Enabled hypervisors list must contain at"
 244                                " least one member", errors.ECODE_INVAL)
 245   invalid_hvs = set(enabled_hypervisors) - constants.HYPER_TYPES
 246   if invalid_hvs:
 247     raise errors.OpPrereqError("Enabled hypervisors contains invalid"
 248                                " entries: %s" % invalid_hvs,
 249                                errors.ECODE_INVAL)
 250
 251
 252   ipcls = None
 253   if primary_ip_version == constants.IP4_VERSION:
 254     ipcls = netutils.IP4Address
 255   elif primary_ip_version == constants.IP6_VERSION:
 256     ipcls = netutils.IP6Address
 257   else:
 258     raise errors.OpPrereqError("Invalid primary ip version: %d." %
 259                                primary_ip_version)
 260
 261   hostname = netutils.GetHostname(family=ipcls.family)
 262   if not ipcls.IsValid(hostname.ip):
 263     raise errors.OpPrereqError("This host's IP (%s) is not a valid IPv%d"
 264                                " address." % (hostname.ip, primary_ip_version))
 265
 266   if ipcls.IsLoopback(hostname.ip):
 267     raise errors.OpPrereqError("This host's IP (%s) resolves to a loopback"
 268                                " address. Please fix DNS or %s." %
 269                                (hostname.ip, constants.ETC_HOSTS),
 270                                errors.ECODE_ENVIRON)
 271
 272   if not ipcls.Own(hostname.ip):
 273     raise errors.OpPrereqError("Inconsistency: this host's name resolves"
 274                                " to %s,\nbut this ip address does not"
 275                                " belong to this host" %
 276                                hostname.ip, errors.ECODE_ENVIRON)
 277
 278   clustername = netutils.GetHostname(name=cluster_name, family=ipcls.family)
 279
 280   if netutils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT, timeout=5):
 281     raise errors.OpPrereqError("Cluster IP already active",
 282                                errors.ECODE_NOTUNIQUE)
 283
 284   if not secondary_ip:
 285     if primary_ip_version == constants.IP6_VERSION:
 286       raise errors.OpPrereqError("When using a IPv6 primary address, a valid"
 287                                  " IPv4 address must be given as secondary",
 288                                  errors.ECODE_INVAL)
 289     secondary_ip = hostname.ip
 290
 291   if not netutils.IP4Address.IsValid(secondary_ip):
 292     raise errors.OpPrereqError("Secondary IP address (%s) has to be a valid"
 293                                " IPv4 address." % secondary_ip,
 294                                errors.ECODE_INVAL)
 295
 296   if not netutils.IP4Address.Own(secondary_ip):
 297     raise errors.OpPrereqError("You gave %s as secondary IP,"
 298                                " but it does not belong to this host." %
 299                                secondary_ip, errors.ECODE_ENVIRON)
 300
 301   if vg_name is not None:
 302     # Check if volume group is valid
 303     vgstatus = utils.CheckVolumeGroupSize(utils.ListVolumeGroups(), vg_name,
 304                                           constants.MIN_VG_SIZE)
 305     if vgstatus:
 306       raise errors.OpPrereqError("Error: %s\nspecify --no-lvm-storage if"
 307                                  " you are not using lvm" % vgstatus,
 308                                  errors.ECODE_INVAL)
 309
 310   if drbd_helper is not None:
 311     try:
 312       curr_helper = bdev.BaseDRBD.GetUsermodeHelper()
 313     except errors.BlockDeviceError, err:
 314       raise errors.OpPrereqError("Error while checking drbd helper"
 315                                  " (specify --no-drbd-storage if you are not"
 316                                  " using drbd): %s" % str(err),
 317                                  errors.ECODE_ENVIRON)
 318     if drbd_helper != curr_helper:
 319       raise errors.OpPrereqError("Error: requiring %s as drbd helper but %s"
 320                                  " is the current helper" % (drbd_helper,
 321                                                              curr_helper),
 322                                  errors.ECODE_INVAL)
 323
 324   file_storage_dir = _InitFileStorage(file_storage_dir)
 325
 326   if not re.match("^[0-9a-z]{2}:[0-9a-z]{2}:[0-9a-z]{2}$", mac_prefix):
 327     raise errors.OpPrereqError("Invalid mac prefix given '%s'" % mac_prefix,
 328                                errors.ECODE_INVAL)
 329
 330   result = utils.RunCmd(["ip", "link", "show", "dev", master_netdev])
 331   if result.failed:
 332     raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %
 333                                (master_netdev,
 334                                 result.output.strip()), errors.ECODE_INVAL)
 335
 336   dirs = [(constants.RUN_GANETI_DIR, constants.RUN_DIRS_MODE)]
 337   utils.EnsureDirs(dirs)
 338
 339   utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
 340   utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
 341   objects.NIC.CheckParameterSyntax(nicparams)
 342
 343   if ndparams is not None:
 344     utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
 345   else:
 346     ndparams = dict(constants.NDC_DEFAULTS)
 347
 348   # hvparams is a mapping of hypervisor->hvparams dict
 349   for hv_name, hv_params in hvparams.iteritems():
 350     utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
 351     hv_class = hypervisor.GetHypervisor(hv_name)
 352     hv_class.CheckParameterSyntax(hv_params)
 353
 354   # set up ssh config and /etc/hosts
 355   sshline = utils.ReadFile(constants.SSH_HOST_RSA_PUB)
 356   sshkey = sshline.split(" ")[1]
 357
 358   if modify_etc_hosts:
 359     utils.AddHostToEtcHosts(hostname.name, hostname.ip)
 360
 361   if modify_ssh_setup:
 362     _InitSSHSetup()
 363
 364   if default_iallocator is not None:
 365     alloc_script = utils.FindFile(default_iallocator,
 366                                   constants.IALLOCATOR_SEARCH_PATH,
 367                                   os.path.isfile)
 368     if alloc_script is None:
 369       raise errors.OpPrereqError("Invalid default iallocator script '%s'"
 370                                  " specified" % default_iallocator,
 371                                  errors.ECODE_INVAL)
 372
 373   now = time.time()
 374
 375   # init of cluster config file
 376   cluster_config = objects.Cluster(
 377     serial_no=1,
 378     rsahostkeypub=sshkey,
 379     highest_used_port=(constants.FIRST_DRBD_PORT - 1),
 380     mac_prefix=mac_prefix,
 381     volume_group_name=vg_name,
 382     tcpudp_port_pool=set(),
 383     master_node=hostname.name,
 384     master_ip=clustername.ip,
 385     master_netdev=master_netdev,
 386     cluster_name=clustername.name,
 387     file_storage_dir=file_storage_dir,
 388     enabled_hypervisors=enabled_hypervisors,
 389     beparams={constants.PP_DEFAULT: beparams},
 390     nicparams={constants.PP_DEFAULT: nicparams},
 391     ndparams=ndparams,
 392     hvparams=hvparams,
 393     candidate_pool_size=candidate_pool_size,
 394     modify_etc_hosts=modify_etc_hosts,
 395     modify_ssh_setup=modify_ssh_setup,
 396     uid_pool=uid_pool,
 397     ctime=now,
 398     mtime=now,
 399     maintain_node_health=maintain_node_health,
 400     drbd_usermode_helper=drbd_helper,
 401     default_iallocator=default_iallocator,
 402     primary_ip_family=ipcls.family,
 403     prealloc_wipe_disks=prealloc_wipe_disks,
 404     )
 405   master_node_config = objects.Node(name=hostname.name,
 406                                     primary_ip=hostname.ip,
 407                                     secondary_ip=secondary_ip,
 408                                     serial_no=1,
 409                                     master_candidate=True,
 410                                     offline=False, drained=False,
 411                                     ctime=now, mtime=now,
 412                                     )
 413   InitConfig(constants.CONFIG_VERSION, cluster_config, master_node_config)
 414   cfg = config.ConfigWriter(offline=True)
 415   ssh.WriteKnownHostsFile(cfg, constants.SSH_KNOWN_HOSTS_FILE)
 416   cfg.Update(cfg.GetClusterInfo(), logging.error)
 417   backend.WriteSsconfFiles(cfg.GetSsconfValues())
 418
 419   # set up the inter-node password and certificate
 420   _InitGanetiServerSetup(hostname.name)
 421
 422   # start the master ip
 423   # TODO: Review rpc call from bootstrap
 424   # TODO: Warn on failed start master
 425   rpc.RpcRunner.call_node_start_master(hostname.name, True, False)
 426
 427
 428 def InitConfig(version, cluster_config, master_node_config,
 429                cfg_file=constants.CLUSTER_CONF_FILE):
 430   """Create the initial cluster configuration.
 431
 432   It will contain the current node, which will also be the master
 433   node, and no instances.
 434
 435   @type version: int
 436   @param version: configuration version
 437   @type cluster_config: L{objects.Cluster}
 438   @param cluster_config: cluster configuration
 439   @type master_node_config: L{objects.Node}
 440   @param master_node_config: master node configuration
 441   @type cfg_file: string
 442   @param cfg_file: configuration file path
 443
 444   """
 445   uuid_generator = config.TemporaryReservationManager()
 446   cluster_config.uuid = uuid_generator.Generate([], utils.NewUUID,
 447                                                 _INITCONF_ECID)
 448   master_node_config.uuid = uuid_generator.Generate([], utils.NewUUID,
 449                                                     _INITCONF_ECID)
 450   nodes = {
 451     master_node_config.name: master_node_config,
 452     }
 453   default_nodegroup = objects.NodeGroup(
 454     uuid=uuid_generator.Generate([], utils.NewUUID, _INITCONF_ECID),
 455     name=constants.INITIAL_NODE_GROUP_NAME,
 456     members=[master_node_config.name],
 457     )
 458   nodegroups = {
 459     default_nodegroup.uuid: default_nodegroup,
 460     }
 461   now = time.time()
 462   config_data = objects.ConfigData(version=version,
 463                                    cluster=cluster_config,
 464                                    nodegroups=nodegroups,
 465                                    nodes=nodes,
 466                                    instances={},
 467                                    serial_no=1,
 468                                    ctime=now, mtime=now)
 469   utils.WriteFile(cfg_file,
 470                   data=serializer.Dump(config_data.ToDict()),
 471                   mode=0600)
 472
 473
 474 def FinalizeClusterDestroy(master):
 475   """Execute the last steps of cluster destroy
 476
 477   This function shuts down all the daemons, completing the destroy
 478   begun in cmdlib.LUDestroyOpcode.
 479
 480   """
 481   cfg = config.ConfigWriter()
 482   modify_ssh_setup = cfg.GetClusterInfo().modify_ssh_setup
 483   result = rpc.RpcRunner.call_node_stop_master(master, True)
 484   msg = result.fail_msg
 485   if msg:
 486     logging.warning("Could not disable the master role: %s", msg)
 487   result = rpc.RpcRunner.call_node_leave_cluster(master, modify_ssh_setup)
 488   msg = result.fail_msg
 489   if msg:
 490     logging.warning("Could not shutdown the node daemon and cleanup"
 491                     " the node: %s", msg)
 492
 493
 494 def SetupNodeDaemon(cluster_name, node, ssh_key_check):
 495   """Add a node to the cluster.
 496
 497   This function must be called before the actual opcode, and will ssh
 498   to the remote node, copy the needed files, and start ganeti-noded,
 499   allowing the master to do the rest via normal rpc calls.
 500
 501   @param cluster_name: the cluster name
 502   @param node: the name of the new node
 503   @param ssh_key_check: whether to do a strict key check
 504
 505   """
 506   family = ssconf.SimpleStore().GetPrimaryIPFamily()
 507   sshrunner = ssh.SshRunner(cluster_name,
 508                             ipv6=(family == netutils.IP6Address.family))
 509
 510   bind_address = constants.IP4_ADDRESS_ANY
 511   if family == netutils.IP6Address.family:
 512     bind_address = constants.IP6_ADDRESS_ANY
 513
 514   # set up inter-node password and certificate and restarts the node daemon
 515   # and then connect with ssh to set password and start ganeti-noded
 516   # note that all the below variables are sanitized at this point,
 517   # either by being constants or by the checks above
 518   sshrunner.CopyFileToNode(node, constants.NODED_CERT_FILE)
 519   sshrunner.CopyFileToNode(node, constants.RAPI_CERT_FILE)
 520   sshrunner.CopyFileToNode(node, constants.CONFD_HMAC_KEY)
 521   mycommand = ("%s stop-all; %s start %s -b %s" %
 522                (constants.DAEMON_UTIL, constants.DAEMON_UTIL, constants.NODED,
 523                 utils.ShellQuote(bind_address)))
 524
 525   result = sshrunner.Run(node, 'root', mycommand, batch=False,
 526                          ask_key=ssh_key_check,
 527                          use_cluster_key=True,
 528                          strict_host_check=ssh_key_check)
 529   if result.failed:
 530     raise errors.OpExecError("Remote command on node %s, error: %s,"
 531                              " output: %s" %
 532                              (node, result.fail_reason, result.output))
 533
 534   _WaitForNodeDaemon(node)
 535
 536
 537 def MasterFailover(no_voting=False):
 538   """Failover the master node.
 539
 540   This checks that we are not already the master, and will cause the
 541   current master to cease being master, and the non-master to become
 542   new master.
 543
 544   @type no_voting: boolean
 545   @param no_voting: force the operation without remote nodes agreement
 546                       (dangerous)
 547
 548   """
 549   sstore = ssconf.SimpleStore()
 550
 551   old_master, new_master = ssconf.GetMasterAndMyself(sstore)
 552   node_list = sstore.GetNodeList()
 553   mc_list = sstore.GetMasterCandidates()
 554
 555   if old_master == new_master:
 556     raise errors.OpPrereqError("This commands must be run on the node"
 557                                " where you want the new master to be."
 558                                " %s is already the master" %
 559                                old_master, errors.ECODE_INVAL)
 560
 561   if new_master not in mc_list:
 562     mc_no_master = [name for name in mc_list if name != old_master]
 563     raise errors.OpPrereqError("This node is not among the nodes marked"
 564                                " as master candidates. Only these nodes"
 565                                " can become masters. Current list of"
 566                                " master candidates is:\n"
 567                                "%s" % ('\n'.join(mc_no_master)),
 568                                errors.ECODE_STATE)
 569
 570   if not no_voting:
 571     vote_list = GatherMasterVotes(node_list)
 572
 573     if vote_list:
 574       voted_master = vote_list[0][0]
 575       if voted_master is None:
 576         raise errors.OpPrereqError("Cluster is inconsistent, most nodes did"
 577                                    " not respond.", errors.ECODE_ENVIRON)
 578       elif voted_master != old_master:
 579         raise errors.OpPrereqError("I have a wrong configuration, I believe"
 580                                    " the master is %s but the other nodes"
 581                                    " voted %s. Please resync the configuration"
 582                                    " of this node." %
 583                                    (old_master, voted_master),
 584                                    errors.ECODE_STATE)
 585   # end checks
 586
 587   rcode = 0
 588
 589   logging.info("Setting master to %s, old master: %s", new_master, old_master)
 590
 591   try:
 592     # instantiate a real config writer, as we now know we have the
 593     # configuration data
 594     cfg = config.ConfigWriter(accept_foreign=True)
 595
 596     cluster_info = cfg.GetClusterInfo()
 597     cluster_info.master_node = new_master
 598     # this will also regenerate the ssconf files, since we updated the
 599     # cluster info
 600     cfg.Update(cluster_info, logging.error)
 601   except errors.ConfigurationError, err:
 602     logging.error("Error while trying to set the new master: %s",
 603                   str(err))
 604     return 1
 605
 606   # if cfg.Update worked, then it means the old master daemon won't be
 607   # able now to write its own config file (we rely on locking in both
 608   # backend.UploadFile() and ConfigWriter._Write(); hence the next
 609   # step is to kill the old master
 610
 611   logging.info("Stopping the master daemon on node %s", old_master)
 612
 613   result = rpc.RpcRunner.call_node_stop_master(old_master, True)
 614   msg = result.fail_msg
 615   if msg:
 616     logging.error("Could not disable the master role on the old master"
 617                  " %s, please disable manually: %s", old_master, msg)
 618
 619   logging.info("Checking master IP non-reachability...")
 620
 621   master_ip = sstore.GetMasterIP()
 622   total_timeout = 30
 623   # Here we have a phase where no master should be running
 624   def _check_ip():
 625     if netutils.TcpPing(master_ip, constants.DEFAULT_NODED_PORT):
 626       raise utils.RetryAgain()
 627
 628   try:
 629     utils.Retry(_check_ip, (1, 1.5, 5), total_timeout)
 630   except utils.RetryTimeout:
 631     logging.warning("The master IP is still reachable after %s seconds,"
 632                     " continuing but activating the master on the current"
 633                     " node will probably fail", total_timeout)
 634
 635   logging.info("Starting the master daemons on the new master")
 636
 637   result = rpc.RpcRunner.call_node_start_master(new_master, True, no_voting)
 638   msg = result.fail_msg
 639   if msg:
 640     logging.error("Could not start the master role on the new master"
 641                   " %s, please check: %s", new_master, msg)
 642     rcode = 1
 643
 644   logging.info("Master failed over from %s to %s", old_master, new_master)
 645   return rcode
 646
 647
 648 def GetMaster():
 649   """Returns the current master node.
 650
 651   This is a separate function in bootstrap since it's needed by
 652   gnt-cluster, and instead of importing directly ssconf, it's better
 653   to abstract it in bootstrap, where we do use ssconf in other
 654   functions too.
 655
 656   """
 657   sstore = ssconf.SimpleStore()
 658
 659   old_master, _ = ssconf.GetMasterAndMyself(sstore)
 660
 661   return old_master
 662
 663
 664 def GatherMasterVotes(node_list):
 665   """Check the agreement on who is the master.
 666
 667   This function will return a list of (node, number of votes), ordered
 668   by the number of votes. Errors will be denoted by the key 'None'.
 669
 670   Note that the sum of votes is the number of nodes this machine
 671   knows, whereas the number of entries in the list could be different
 672   (if some nodes vote for another master).
 673
 674   We remove ourselves from the list since we know that (bugs aside)
 675   since we use the same source for configuration information for both
 676   backend and boostrap, we'll always vote for ourselves.
 677
 678   @type node_list: list
 679   @param node_list: the list of nodes to query for master info; the current
 680       node will be removed if it is in the list
 681   @rtype: list
 682   @return: list of (node, votes)
 683
 684   """
 685   myself = netutils.Hostname.GetSysName()
 686   try:
 687     node_list.remove(myself)
 688   except ValueError:
 689     pass
 690   if not node_list:
 691     # no nodes left (eventually after removing myself)
 692     return []
 693   results = rpc.RpcRunner.call_master_info(node_list)
 694   if not isinstance(results, dict):
 695     # this should not happen (unless internal error in rpc)
 696     logging.critical("Can't complete rpc call, aborting master startup")
 697     return [(None, len(node_list))]
 698   votes = {}
 699   for node in results:
 700     nres = results[node]
 701     data = nres.payload
 702     msg = nres.fail_msg
 703     fail = False
 704     if msg:
 705       logging.warning("Error contacting node %s: %s", node, msg)
 706       fail = True
 707     # for now we accept both length 3 and 4 (data[3] is primary ip version)
 708     elif not isinstance(data, (tuple, list)) or len(data) < 3:
 709       logging.warning("Invalid data received from node %s: %s", node, data)
 710       fail = True
 711     if fail:
 712       if None not in votes:
 713         votes[None] = 0
 714       votes[None] += 1
 715       continue
 716     master_node = data[2]
 717     if master_node not in votes:
 718       votes[master_node] = 0
 719     votes[master_node] += 1
 720
 721   vote_list = [v for v in votes.items()]
 722   # sort first on number of votes then on name, since we want None
 723   # sorted later if we have the half of the nodes not responding, and
 724   # half voting all for the same master
 725   vote_list.sort(key=lambda x: (x[1], x[0]), reverse=True)
 726
 727   return vote_list