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

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