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