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   """Updates the cluster certificates, keys and secrets.
  85
  86   @type new_cluster_cert: bool
  87   @param new_cluster_cert: Whether to generate a new cluster certificate
  88   @type new_rapi_cert: bool
  89   @param new_rapi_cert: Whether to generate a new RAPI certificate
  90   @type new_confd_hmac_key: bool
  91   @param new_confd_hmac_key: Whether to generate a new HMAC key
  92   @type new_cds: bool
  93   @param new_cds: Whether to generate a new cluster domain secret
  94   @type rapi_cert_pem: string
  95   @param rapi_cert_pem: New RAPI certificate in PEM format
  96   @type cds: string
  97   @param cds: New cluster domain secret
  98   @type nodecert_file: string
  99   @param nodecert_file: optional override of the node cert file path
 100   @type rapicert_file: string
 101   @param rapicert_file: optional override of the rapi cert file path
 102   @type hmackey_file: string
 103   @param hmackey_file: optional override of the hmac key file path
 104
 105   """
 106   # noded SSL certificate
 107   cluster_cert_exists = os.path.exists(nodecert_file)
 108   if new_cluster_cert or not cluster_cert_exists:
 109     if cluster_cert_exists:
 110       utils.CreateBackup(nodecert_file)
 111
 112     logging.debug("Generating new cluster certificate at %s", nodecert_file)
 113     utils.GenerateSelfSignedSslCert(nodecert_file)
 114
 115   # confd HMAC key
 116   if new_confd_hmac_key or not os.path.exists(hmackey_file):
 117     logging.debug("Writing new confd HMAC key to %s", hmackey_file)
 118     GenerateHmacKey(hmackey_file)
 119
 120   # RAPI
 121   rapi_cert_exists = os.path.exists(rapicert_file)
 122
 123   if rapi_cert_pem:
 124     # Assume rapi_pem contains a valid PEM-formatted certificate and key
 125     logging.debug("Writing RAPI certificate at %s", rapicert_file)
 126     utils.WriteFile(rapicert_file, data=rapi_cert_pem, backup=True)
 127
 128   elif new_rapi_cert or not rapi_cert_exists:
 129     if rapi_cert_exists:
 130       utils.CreateBackup(rapicert_file)
 131
 132     logging.debug("Generating new RAPI certificate at %s", rapicert_file)
 133     utils.GenerateSelfSignedSslCert(rapicert_file)
 134
 135   # Cluster domain secret
 136   if cds:
 137     logging.debug("Writing cluster domain secret to %s",
 138                   constants.CLUSTER_DOMAIN_SECRET_FILE)
 139     utils.WriteFile(constants.CLUSTER_DOMAIN_SECRET_FILE,
 140                     data=cds, backup=True)
 141
 142   elif new_cds or not os.path.exists(constants.CLUSTER_DOMAIN_SECRET_FILE):
 143     logging.debug("Generating new cluster domain secret at %s",
 144                   constants.CLUSTER_DOMAIN_SECRET_FILE)
 145     GenerateHmacKey(constants.CLUSTER_DOMAIN_SECRET_FILE)
 146
 147
 148 def _InitGanetiServerSetup(master_name):
 149   """Setup the necessary configuration for the initial node daemon.
 150
 151   This creates the nodepass file containing the shared password for
 152   the cluster and also generates the SSL certificate.
 153
 154   """
 155   # Generate cluster secrets
 156   GenerateClusterCrypto(True, False, False, False)
 157
 158   result = utils.RunCmd([constants.DAEMON_UTIL, "start", constants.NODED])
 159   if result.failed:
 160     raise errors.OpExecError("Could not start the node daemon, command %s"
 161                              " had exitcode %s and error %s" %
 162                              (result.cmd, result.exit_code, result.output))
 163
 164   _WaitForNodeDaemon(master_name)
 165
 166
 167 def _WaitForNodeDaemon(node_name):
 168   """Wait for node daemon to become responsive.
 169
 170   """
 171   def _CheckNodeDaemon():
 172     result = rpc.RpcRunner.call_version([node_name])[node_name]
 173     if result.fail_msg:
 174       raise utils.RetryAgain()
 175
 176   try:
 177     utils.Retry(_CheckNodeDaemon, 1.0, 10.0)
 178   except utils.RetryTimeout:
 179     raise errors.OpExecError("Node daemon on %s didn't answer queries within"
 180                              " 10 seconds" % node_name)
 181
 182
 183 def _InitFileStorage(file_storage_dir):
 184   """Initialize if needed the file storage.
 185
 186   @param file_storage_dir: the user-supplied value
 187   @return: either empty string (if file storage was disabled at build
 188       time) or the normalized path to the storage directory
 189
 190   """
 191   if not constants.ENABLE_FILE_STORAGE:
 192     return ""
 193
 194   file_storage_dir = os.path.normpath(file_storage_dir)
 195
 196   if not os.path.isabs(file_storage_dir):
 197     raise errors.OpPrereqError("The file storage directory you passed is"
 198                                " not an absolute path.", errors.ECODE_INVAL)
 199
 200   if not os.path.exists(file_storage_dir):
 201     try:
 202       os.makedirs(file_storage_dir, 0750)
 203     except OSError, err:
 204       raise errors.OpPrereqError("Cannot create file storage directory"
 205                                  " '%s': %s" % (file_storage_dir, err),
 206                                  errors.ECODE_ENVIRON)
 207
 208   if not os.path.isdir(file_storage_dir):
 209     raise errors.OpPrereqError("The file storage directory '%s' is not"
 210                                " a directory." % file_storage_dir,
 211                                errors.ECODE_ENVIRON)
 212   return file_storage_dir
 213
 214
 215 def InitCluster(cluster_name, mac_prefix,
 216                 master_netdev, file_storage_dir, candidate_pool_size,
 217                 secondary_ip=None, vg_name=None, beparams=None,
 218                 nicparams=None, hvparams=None, enabled_hypervisors=None,
 219                 modify_etc_hosts=True, modify_ssh_setup=True,
 220                 maintain_node_health=False):
 221   """Initialise the cluster.
 222
 223   @type candidate_pool_size: int
 224   @param candidate_pool_size: master candidate pool size
 225
 226   """
 227   # TODO: complete the docstring
 228   if config.ConfigWriter.IsCluster():
 229     raise errors.OpPrereqError("Cluster is already initialised",
 230                                errors.ECODE_STATE)
 231
 232   if not enabled_hypervisors:
 233     raise errors.OpPrereqError("Enabled hypervisors list must contain at"
 234                                " least one member", errors.ECODE_INVAL)
 235   invalid_hvs = set(enabled_hypervisors) - constants.HYPER_TYPES
 236   if invalid_hvs:
 237     raise errors.OpPrereqError("Enabled hypervisors contains invalid"
 238                                " entries: %s" % invalid_hvs,
 239                                errors.ECODE_INVAL)
 240
 241   hostname = utils.GetHostInfo()
 242
 243   if hostname.ip.startswith("127."):
 244     raise errors.OpPrereqError("This host's IP resolves to the private"
 245                                " range (%s). Please fix DNS or %s." %
 246                                (hostname.ip, constants.ETC_HOSTS),
 247                                errors.ECODE_ENVIRON)
 248
 249   if not utils.OwnIpAddress(hostname.ip):
 250     raise errors.OpPrereqError("Inconsistency: this host's name resolves"
 251                                " to %s,\nbut this ip address does not"
 252                                " belong to this host. Aborting." %
 253                                hostname.ip, errors.ECODE_ENVIRON)
 254
 255   clustername = utils.GetHostInfo(utils.HostInfo.NormalizeName(cluster_name))
 256
 257   if utils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT,
 258                    timeout=5):
 259     raise errors.OpPrereqError("Cluster IP already active. Aborting.",
 260                                errors.ECODE_NOTUNIQUE)
 261
 262   if secondary_ip:
 263     if not utils.IsValidIP(secondary_ip):
 264       raise errors.OpPrereqError("Invalid secondary ip given",
 265                                  errors.ECODE_INVAL)
 266     if (secondary_ip != hostname.ip and
 267         not utils.OwnIpAddress(secondary_ip)):
 268       raise errors.OpPrereqError("You gave %s as secondary IP,"
 269                                  " but it does not belong to this host." %
 270                                  secondary_ip, errors.ECODE_ENVIRON)
 271   else:
 272     secondary_ip = hostname.ip
 273
 274   if vg_name is not None:
 275     # Check if volume group is valid
 276     vgstatus = utils.CheckVolumeGroupSize(utils.ListVolumeGroups(), vg_name,
 277                                           constants.MIN_VG_SIZE)
 278     if vgstatus:
 279       raise errors.OpPrereqError("Error: %s\nspecify --no-lvm-storage if"
 280                                  " you are not using lvm" % vgstatus,
 281                                  errors.ECODE_INVAL)
 282
 283   file_storage_dir = _InitFileStorage(file_storage_dir)
 284
 285   if not re.match("^[0-9a-z]{2}:[0-9a-z]{2}:[0-9a-z]{2}$", mac_prefix):
 286     raise errors.OpPrereqError("Invalid mac prefix given '%s'" % mac_prefix,
 287                                errors.ECODE_INVAL)
 288
 289   result = utils.RunCmd(["ip", "link", "show", "dev", master_netdev])
 290   if result.failed:
 291     raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %
 292                                (master_netdev,
 293                                 result.output.strip()), errors.ECODE_INVAL)
 294
 295   dirs = [(constants.RUN_GANETI_DIR, constants.RUN_DIRS_MODE)]
 296   utils.EnsureDirs(dirs)
 297
 298   utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
 299   utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
 300   objects.NIC.CheckParameterSyntax(nicparams)
 301
 302   # hvparams is a mapping of hypervisor->hvparams dict
 303   for hv_name, hv_params in hvparams.iteritems():
 304     utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
 305     hv_class = hypervisor.GetHypervisor(hv_name)
 306     hv_class.CheckParameterSyntax(hv_params)
 307
 308   # set up the inter-node password and certificate
 309   _InitGanetiServerSetup(hostname.name)
 310
 311   # set up ssh config and /etc/hosts
 312   sshline = utils.ReadFile(constants.SSH_HOST_RSA_PUB)
 313   sshkey = sshline.split(" ")[1]
 314
 315   if modify_etc_hosts:
 316     utils.AddHostToEtcHosts(hostname.name)
 317
 318   if modify_ssh_setup:
 319     _InitSSHSetup()
 320
 321   now = time.time()
 322
 323   # init of cluster config file
 324   cluster_config = objects.Cluster(
 325     serial_no=1,
 326     rsahostkeypub=sshkey,
 327     highest_used_port=(constants.FIRST_DRBD_PORT - 1),
 328     mac_prefix=mac_prefix,
 329     volume_group_name=vg_name,
 330     tcpudp_port_pool=set(),
 331     master_node=hostname.name,
 332     master_ip=clustername.ip,
 333     master_netdev=master_netdev,
 334     cluster_name=clustername.name,
 335     file_storage_dir=file_storage_dir,
 336     enabled_hypervisors=enabled_hypervisors,
 337     beparams={constants.PP_DEFAULT: beparams},
 338     nicparams={constants.PP_DEFAULT: nicparams},
 339     hvparams=hvparams,
 340     candidate_pool_size=candidate_pool_size,
 341     modify_etc_hosts=modify_etc_hosts,
 342     modify_ssh_setup=modify_ssh_setup,
 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