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 sha
  29 import re
  30 import logging
  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
  41 def _InitSSHSetup(node):
  42   """Setup the SSH configuration for the cluster.
  43
  44
  45   This generates a dsa keypair for root, adds the pub key to the
  46   permitted hosts and adds the hostkey to its own known hosts.
  47
  48   Args:
  49     node: the name of this host as a fqdn
  50
  51   """
  52   priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)
  53
  54   for name in priv_key, pub_key:
  55     if os.path.exists(name):
  56       utils.CreateBackup(name)
  57     utils.RemoveFile(name)
  58
  59   result = utils.RunCmd(["ssh-keygen", "-t", "dsa",
  60                          "-f", priv_key,
  61                          "-q", "-N", ""])
  62   if result.failed:
  63     raise errors.OpExecError("Could not generate ssh keypair, error %s" %
  64                              result.output)
  65
  66   f = open(pub_key, 'r')
  67   try:
  68     utils.AddAuthorizedKey(auth_keys, f.read(8192))
  69   finally:
  70     f.close()
  71
  72
  73 def _InitGanetiServerSetup():
  74   """Setup the necessary configuration for the initial node daemon.
  75
  76   This creates the nodepass file containing the shared password for
  77   the cluster and also generates the SSL certificate.
  78
  79   """
  80   result = utils.RunCmd(["openssl", "req", "-new", "-newkey", "rsa:1024",
  81                          "-days", str(365*5), "-nodes", "-x509",
  82                          "-keyout", constants.SSL_CERT_FILE,
  83                          "-out", constants.SSL_CERT_FILE, "-batch"])
  84   if result.failed:
  85     raise errors.OpExecError("could not generate server ssl cert, command"
  86                              " %s had exitcode %s and error message %s" %
  87                              (result.cmd, result.exit_code, result.output))
  88
  89   os.chmod(constants.SSL_CERT_FILE, 0400)
  90
  91   result = utils.RunCmd([constants.NODE_INITD_SCRIPT, "restart"])
  92
  93   if result.failed:
  94     raise errors.OpExecError("Could not start the node daemon, command %s"
  95                              " had exitcode %s and error %s" %
  96                              (result.cmd, result.exit_code, result.output))
  97
  98
  99 def InitCluster(cluster_name, mac_prefix, def_bridge,
 100                 master_netdev, file_storage_dir, candidate_pool_size,
 101                 secondary_ip=None, vg_name=None, beparams=None, hvparams=None,
 102                 enabled_hypervisors=None, default_hypervisor=None):
 103   """Initialise the cluster.
 104
 105   @type candidate_pool_size: int
 106   @param candidate_pool_size: master candidate pool size
 107
 108   """
 109   # TODO: complete the docstring
 110   if config.ConfigWriter.IsCluster():
 111     raise errors.OpPrereqError("Cluster is already initialised")
 112
 113   hostname = utils.HostInfo()
 114
 115   if hostname.ip.startswith("127."):
 116     raise errors.OpPrereqError("This host's IP resolves to the private"
 117                                " range (%s). Please fix DNS or %s." %
 118                                (hostname.ip, constants.ETC_HOSTS))
 119
 120   if not utils.OwnIpAddress(hostname.ip):
 121     raise errors.OpPrereqError("Inconsistency: this host's name resolves"
 122                                " to %s,\nbut this ip address does not"
 123                                " belong to this host."
 124                                " Aborting." % hostname.ip)
 125
 126   clustername = utils.HostInfo(cluster_name)
 127
 128   if utils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT,
 129                    timeout=5):
 130     raise errors.OpPrereqError("Cluster IP already active. Aborting.")
 131
 132   if secondary_ip:
 133     if not utils.IsValidIP(secondary_ip):
 134       raise errors.OpPrereqError("Invalid secondary ip given")
 135     if (secondary_ip != hostname.ip and
 136         not utils.OwnIpAddress(secondary_ip)):
 137       raise errors.OpPrereqError("You gave %s as secondary IP,"
 138                                  " but it does not belong to this host." %
 139                                  secondary_ip)
 140   else:
 141     secondary_ip = hostname.ip
 142
 143   if vg_name is not None:
 144     # Check if volume group is valid
 145     vgstatus = utils.CheckVolumeGroupSize(utils.ListVolumeGroups(), vg_name,
 146                                           constants.MIN_VG_SIZE)
 147     if vgstatus:
 148       raise errors.OpPrereqError("Error: %s\nspecify --no-lvm-storage if"
 149                                  " you are not using lvm" % vgstatus)
 150
 151   file_storage_dir = os.path.normpath(file_storage_dir)
 152
 153   if not os.path.isabs(file_storage_dir):
 154     raise errors.OpPrereqError("The file storage directory you passed is"
 155                                " not an absolute path.")
 156
 157   if not os.path.exists(file_storage_dir):
 158     try:
 159       os.makedirs(file_storage_dir, 0750)
 160     except OSError, err:
 161       raise errors.OpPrereqError("Cannot create file storage directory"
 162                                  " '%s': %s" %
 163                                  (file_storage_dir, err))
 164
 165   if not os.path.isdir(file_storage_dir):
 166     raise errors.OpPrereqError("The file storage directory '%s' is not"
 167                                " a directory." % file_storage_dir)
 168
 169   if not re.match("^[0-9a-z]{2}:[0-9a-z]{2}:[0-9a-z]{2}$", mac_prefix):
 170     raise errors.OpPrereqError("Invalid mac prefix given '%s'" % mac_prefix)
 171
 172   result = utils.RunCmd(["ip", "link", "show", "dev", master_netdev])
 173   if result.failed:
 174     raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %
 175                                (master_netdev,
 176                                 result.output.strip()))
 177
 178   if not (os.path.isfile(constants.NODE_INITD_SCRIPT) and
 179           os.access(constants.NODE_INITD_SCRIPT, os.X_OK)):
 180     raise errors.OpPrereqError("Init.d script '%s' missing or not"
 181                                " executable." % constants.NODE_INITD_SCRIPT)
 182
 183   utils.CheckBEParams(beparams)
 184
 185   # set up the inter-node password and certificate
 186   _InitGanetiServerSetup()
 187
 188   # set up ssh config and /etc/hosts
 189   f = open(constants.SSH_HOST_RSA_PUB, 'r')
 190   try:
 191     sshline = f.read()
 192   finally:
 193     f.close()
 194   sshkey = sshline.split(" ")[1]
 195
 196   utils.AddHostToEtcHosts(hostname.name)
 197   _InitSSHSetup(hostname.name)
 198
 199   # init of cluster config file
 200   cluster_config = objects.Cluster(
 201     serial_no=1,
 202     rsahostkeypub=sshkey,
 203     highest_used_port=(constants.FIRST_DRBD_PORT - 1),
 204     mac_prefix=mac_prefix,
 205     volume_group_name=vg_name,
 206     default_bridge=def_bridge,
 207     tcpudp_port_pool=set(),
 208     master_node=hostname.name,
 209     master_ip=clustername.ip,
 210     master_netdev=master_netdev,
 211     cluster_name=clustername.name,
 212     file_storage_dir=file_storage_dir,
 213     enabled_hypervisors=enabled_hypervisors,
 214     default_hypervisor=default_hypervisor,
 215     beparams={constants.BEGR_DEFAULT: beparams},
 216     hvparams=hvparams,
 217     candidate_pool_size=candidate_pool_size,
 218     )
 219   master_node_config = objects.Node(name=hostname.name,
 220                                     primary_ip=hostname.ip,
 221                                     secondary_ip=secondary_ip,
 222                                     serial_no=1,
 223                                     master_candidate=True,
 224                                     offline=False,
 225                                     )
 226
 227   sscfg = InitConfig(constants.CONFIG_VERSION,
 228                      cluster_config, master_node_config)
 229   ssh.WriteKnownHostsFile(sscfg, constants.SSH_KNOWN_HOSTS_FILE)
 230   cfg = config.ConfigWriter()
 231   cfg.Update(cfg.GetClusterInfo())
 232
 233   # start the master ip
 234   # TODO: Review rpc call from bootstrap
 235   rpc.RpcRunner.call_node_start_master(hostname.name, True)
 236
 237
 238 def InitConfig(version, cluster_config, master_node_config,
 239                cfg_file=constants.CLUSTER_CONF_FILE):
 240   """Create the initial cluster configuration.
 241
 242   It will contain the current node, which will also be the master
 243   node, and no instances.
 244
 245   @type version: int
 246   @param version: Configuration version
 247   @type cluster_config: objects.Cluster
 248   @param cluster_config: Cluster configuration
 249   @type master_node_config: objects.Node
 250   @param master_node_config: Master node configuration
 251   @type file_name: string
 252   @param file_name: Configuration file path
 253
 254   @rtype: ssconf.SimpleConfigWriter
 255   @returns: Initialized config instance
 256
 257   """
 258   nodes = {
 259     master_node_config.name: master_node_config,
 260     }
 261
 262   config_data = objects.ConfigData(version=version,
 263                                    cluster=cluster_config,
 264                                    nodes=nodes,
 265                                    instances={},
 266                                    serial_no=1)
 267   cfg = ssconf.SimpleConfigWriter.FromDict(config_data.ToDict(), cfg_file)
 268   cfg.Save()
 269
 270   return cfg
 271
 272
 273 def FinalizeClusterDestroy(master):
 274   """Execute the last steps of cluster destroy
 275
 276   This function shuts down all the daemons, completing the destroy
 277   begun in cmdlib.LUDestroyOpcode.
 278
 279   """
 280   result = rpc.RpcRunner.call_node_stop_master(master, True)
 281   if result.failed or not result.data:
 282     logging.warning("Could not disable the master role")
 283   result = rpc.RpcRunner.call_node_leave_cluster(master)
 284   if result.failed or not result.data:
 285     logging.warning("Could not shutdown the node daemon and cleanup the node")
 286
 287
 288 def SetupNodeDaemon(cluster_name, node, ssh_key_check):
 289   """Add a node to the cluster.
 290
 291   This function must be called before the actual opcode, and will ssh
 292   to the remote node, copy the needed files, and start ganeti-noded,
 293   allowing the master to do the rest via normal rpc calls.
 294
 295   @param cluster_name: the cluster name
 296   @param node: the name of the new node
 297   @param ssh_key_check: whether to do a strict key check
 298
 299   """
 300   sshrunner = ssh.SshRunner(cluster_name)
 301   gntpem = utils.ReadFile(constants.SSL_CERT_FILE)
 302   # in the base64 pem encoding, neither '!' nor '.' are valid chars,
 303   # so we use this to detect an invalid certificate; as long as the
 304   # cert doesn't contain this, the here-document will be correctly
 305   # parsed by the shell sequence below
 306   if re.search('^!EOF\.', gntpem, re.MULTILINE):
 307     raise errors.OpExecError("invalid PEM encoding in the SSL certificate")
 308   if not gntpem.endswith("\n"):
 309     raise errors.OpExecError("PEM must end with newline")
 310
 311   # set up inter-node password and certificate and restarts the node daemon
 312   # and then connect with ssh to set password and start ganeti-noded
 313   # note that all the below variables are sanitized at this point,
 314   # either by being constants or by the checks above
 315   mycommand = ("umask 077 && "
 316                "cat > '%s' << '!EOF.' && \n"
 317                "%s!EOF.\n%s restart" %
 318                (constants.SSL_CERT_FILE, gntpem,
 319                 constants.NODE_INITD_SCRIPT))
 320
 321   result = sshrunner.Run(node, 'root', mycommand, batch=False,
 322                          ask_key=ssh_key_check,
 323                          use_cluster_key=False,
 324                          strict_host_check=ssh_key_check)
 325   if result.failed:
 326     raise errors.OpExecError("Remote command on node %s, error: %s,"
 327                              " output: %s" %
 328                              (node, result.fail_reason, result.output))
 329
 330
 331 def MasterFailover():
 332   """Failover the master node.
 333
 334   This checks that we are not already the master, and will cause the
 335   current master to cease being master, and the non-master to become
 336   new master.
 337
 338   """
 339   sstore = ssconf.SimpleStore()
 340
 341   old_master, new_master = ssconf.GetMasterAndMyself(sstore)
 342   node_list = sstore.GetNodeList()
 343   mc_list = sstore.GetMasterCandidates()
 344
 345   if old_master == new_master:
 346     raise errors.OpPrereqError("This commands must be run on the node"
 347                                " where you want the new master to be."
 348                                " %s is already the master" %
 349                                old_master)
 350
 351   if new_master not in mc_list:
 352     mc_no_master = [name for name in mc_list if name != old_master]
 353     raise errors.OpPrereqError("This node is not among the nodes marked"
 354                                " as master candidates. Only these nodes"
 355                                " can become masters. Current list of"
 356                                " master candidates is:\n"
 357                                "%s" % ('\n'.join(mc_no_master)))
 358
 359   vote_list = GatherMasterVotes(node_list)
 360
 361   if vote_list:
 362     voted_master = vote_list[0][0]
 363     if voted_master is None:
 364       raise errors.OpPrereqError("Cluster is inconsistent, most nodes did not"
 365                                  " respond.")
 366     elif voted_master != old_master:
 367       raise errors.OpPrereqError("I have wrong configuration, I believe the"
 368                                  " master is %s but the other nodes voted for"
 369                                  " %s. Please resync the configuration of"
 370                                  " this node." % (old_master, voted_master))
 371   # end checks
 372
 373   rcode = 0
 374
 375   logging.info("Setting master to %s, old master: %s", new_master, old_master)
 376
 377   result = rpc.RpcRunner.call_node_stop_master(old_master, True)
 378   if result.failed or not result.data:
 379     logging.error("Could not disable the master role on the old master"
 380                  " %s, please disable manually", old_master)
 381
 382   # Here we have a phase where no master should be running
 383
 384   # instantiate a real config writer, as we now know we have the
 385   # configuration data
 386   cfg = config.ConfigWriter()
 387
 388   cluster_info = cfg.GetClusterInfo()
 389   cluster_info.master_node = new_master
 390   # this will also regenerate the ssconf files, since we updated the
 391   # cluster info
 392   cfg.Update(cluster_info)
 393
 394   result = rpc.RpcRunner.call_node_start_master(new_master, True)
 395   if result.failed or not result.data:
 396     logging.error("Could not start the master role on the new master"
 397                   " %s, please check", new_master)
 398     rcode = 1
 399
 400   return rcode
 401
 402
 403 def GatherMasterVotes(node_list):
 404   """Check the agreement on who is the master.
 405
 406   This function will return a list of (node, number of votes), ordered
 407   by the number of votes. Errors will be denoted by the key 'None'.
 408
 409   Note that the sum of votes is the number of nodes this machine
 410   knows, whereas the number of entries in the list could be different
 411   (if some nodes vote for another master).
 412
 413   We remove ourselves from the list since we know that (bugs aside)
 414   since we use the same source for configuration information for both
 415   backend and boostrap, we'll always vote for ourselves.
 416
 417   @type node_list: list
 418   @param node_list: the list of nodes to query for master info; the current
 419       node wil be removed if it is in the list
 420   @rtype: list
 421   @return: list of (node, votes)
 422
 423   """
 424   myself = utils.HostInfo().name
 425   try:
 426     node_list.remove(myself)
 427   except ValueError:
 428     pass
 429   if not node_list:
 430     # no nodes left (eventually after removing myself)
 431     return []
 432   results = rpc.RpcRunner.call_master_info(node_list)
 433   if not isinstance(results, dict):
 434     # this should not happen (unless internal error in rpc)
 435     logging.critical("Can't complete rpc call, aborting master startup")
 436     return [(None, len(node_list))]
 437   positive = negative = 0
 438   other_masters = {}
 439   votes = {}
 440   for node in results:
 441     nres = results[node]
 442     data = nres.data
 443     if nres.failed or not isinstance(data, (tuple, list)) or len(data) < 3:
 444       # here the rpc layer should have already logged errors
 445       if None not in votes:
 446         votes[None] = 0
 447       votes[None] += 1
 448       continue
 449     master_node = data[2]
 450     if master_node not in votes:
 451       votes[master_node] = 0
 452     votes[master_node] += 1
 453
 454   vote_list = [v for v in votes.items()]
 455   # sort first on number of votes then on name, since we want None
 456   # sorted later if we have the half of the nodes not responding, and
 457   # half voting all for the same master
 458   vote_list.sort(key=lambda x: (x[1], x[0]), reverse=True)
 459
 460   return vote_list