1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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 import tempfile
32
33 from ganeti import rpc
34 from ganeti import ssh
35 from ganeti import utils
36 from ganeti import errors
37 from ganeti import config
38 from ganeti import constants
39 from ganeti import objects
40 from ganeti import ssconf
41 from ganeti import serializer
42 from ganeti import hypervisor
43 from ganeti import bdev
44 from ganeti import netutils
45 from ganeti import luxi
46 from ganeti import jstore
47 from ganeti import pathutils
48
49
50
51 _INITCONF_ECID = "initconfig-ecid"
52
53
54 _DAEMON_READY_TIMEOUT = 10.0
55
56
58 """Setup the SSH configuration for the cluster.
59
60 This generates a dsa keypair for root, adds the pub key to the
61 permitted hosts and adds the hostkey to its own known hosts.
62
63 """
64 priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.SSH_LOGIN_USER)
65
66 for name in priv_key, pub_key:
67 if os.path.exists(name):
68 utils.CreateBackup(name)
69 utils.RemoveFile(name)
70
71 result = utils.RunCmd(["ssh-keygen", "-t", "dsa",
72 "-f", priv_key,
73 "-q", "-N", ""])
74 if result.failed:
75 raise errors.OpExecError("Could not generate ssh keypair, error %s" %
76 result.output)
77
78 utils.AddAuthorizedKey(auth_keys, utils.ReadFile(pub_key))
79
80
82 """Writes a new HMAC key.
83
84 @type file_name: str
85 @param file_name: Path to output file
86
87 """
88 utils.WriteFile(file_name, data="%s\n" % utils.GenerateSecret(), mode=0400,
89 backup=True)
90
91
92 -def GenerateClusterCrypto(new_cluster_cert, new_rapi_cert, new_spice_cert,
93 new_confd_hmac_key, new_cds,
94 rapi_cert_pem=None, spice_cert_pem=None,
95 spice_cacert_pem=None, cds=None,
96 nodecert_file=pathutils.NODED_CERT_FILE,
97 rapicert_file=pathutils.RAPI_CERT_FILE,
98 spicecert_file=pathutils.SPICE_CERT_FILE,
99 spicecacert_file=pathutils.SPICE_CACERT_FILE,
100 hmackey_file=pathutils.CONFD_HMAC_KEY,
101 cds_file=pathutils.CLUSTER_DOMAIN_SECRET_FILE):
102 """Updates the cluster certificates, keys and secrets.
103
104 @type new_cluster_cert: bool
105 @param new_cluster_cert: Whether to generate a new cluster certificate
106 @type new_rapi_cert: bool
107 @param new_rapi_cert: Whether to generate a new RAPI certificate
108 @type new_spice_cert: bool
109 @param new_spice_cert: Whether to generate a new SPICE certificate
110 @type new_confd_hmac_key: bool
111 @param new_confd_hmac_key: Whether to generate a new HMAC key
112 @type new_cds: bool
113 @param new_cds: Whether to generate a new cluster domain secret
114 @type rapi_cert_pem: string
115 @param rapi_cert_pem: New RAPI certificate in PEM format
116 @type spice_cert_pem: string
117 @param spice_cert_pem: New SPICE certificate in PEM format
118 @type spice_cacert_pem: string
119 @param spice_cacert_pem: Certificate of the CA that signed the SPICE
120 certificate, in PEM format
121 @type cds: string
122 @param cds: New cluster domain secret
123 @type nodecert_file: string
124 @param nodecert_file: optional override of the node cert file path
125 @type rapicert_file: string
126 @param rapicert_file: optional override of the rapi cert file path
127 @type spicecert_file: string
128 @param spicecert_file: optional override of the spice cert file path
129 @type spicecacert_file: string
130 @param spicecacert_file: optional override of the spice CA cert file path
131 @type hmackey_file: string
132 @param hmackey_file: optional override of the hmac key file path
133
134 """
135
136 cluster_cert_exists = os.path.exists(nodecert_file)
137 if new_cluster_cert or not cluster_cert_exists:
138 if cluster_cert_exists:
139 utils.CreateBackup(nodecert_file)
140
141 logging.debug("Generating new cluster certificate at %s", nodecert_file)
142 utils.GenerateSelfSignedSslCert(nodecert_file)
143
144
145 if new_confd_hmac_key or not os.path.exists(hmackey_file):
146 logging.debug("Writing new confd HMAC key to %s", hmackey_file)
147 GenerateHmacKey(hmackey_file)
148
149
150 rapi_cert_exists = os.path.exists(rapicert_file)
151
152 if rapi_cert_pem:
153
154 logging.debug("Writing RAPI certificate at %s", rapicert_file)
155 utils.WriteFile(rapicert_file, data=rapi_cert_pem, backup=True)
156
157 elif new_rapi_cert or not rapi_cert_exists:
158 if rapi_cert_exists:
159 utils.CreateBackup(rapicert_file)
160
161 logging.debug("Generating new RAPI certificate at %s", rapicert_file)
162 utils.GenerateSelfSignedSslCert(rapicert_file)
163
164
165 spice_cert_exists = os.path.exists(spicecert_file)
166 spice_cacert_exists = os.path.exists(spicecacert_file)
167 if spice_cert_pem:
168
169 logging.debug("Writing SPICE certificate at %s", spicecert_file)
170 utils.WriteFile(spicecert_file, data=spice_cert_pem, backup=True)
171 logging.debug("Writing SPICE CA certificate at %s", spicecacert_file)
172 utils.WriteFile(spicecacert_file, data=spice_cacert_pem, backup=True)
173 elif new_spice_cert or not spice_cert_exists:
174 if spice_cert_exists:
175 utils.CreateBackup(spicecert_file)
176 if spice_cacert_exists:
177 utils.CreateBackup(spicecacert_file)
178
179 logging.debug("Generating new self-signed SPICE certificate at %s",
180 spicecert_file)
181 (_, cert_pem) = utils.GenerateSelfSignedSslCert(spicecert_file)
182
183
184
185 logging.debug("Writing the public certificate to %s",
186 spicecert_file)
187 utils.io.WriteFile(spicecacert_file, mode=0400, data=cert_pem)
188
189
190 if cds:
191 logging.debug("Writing cluster domain secret to %s", cds_file)
192 utils.WriteFile(cds_file, data=cds, backup=True)
193
194 elif new_cds or not os.path.exists(cds_file):
195 logging.debug("Generating new cluster domain secret at %s", cds_file)
196 GenerateHmacKey(cds_file)
197
198
200 """Setup the necessary configuration for the initial node daemon.
201
202 This creates the nodepass file containing the shared password for
203 the cluster, generates the SSL certificate and starts the node daemon.
204
205 @type master_name: str
206 @param master_name: Name of the master node
207
208 """
209
210 GenerateClusterCrypto(True, False, False, False, False)
211
212 result = utils.RunCmd([pathutils.DAEMON_UTIL, "start", constants.NODED])
213 if result.failed:
214 raise errors.OpExecError("Could not start the node daemon, command %s"
215 " had exitcode %s and error %s" %
216 (result.cmd, result.exit_code, result.output))
217
218 _WaitForNodeDaemon(master_name)
219
220
231
232 try:
233 utils.Retry(_CheckNodeDaemon, 1.0, _DAEMON_READY_TIMEOUT)
234 except utils.RetryTimeout:
235 raise errors.OpExecError("Node daemon on %s didn't answer queries within"
236 " %s seconds" % (node_name, _DAEMON_READY_TIMEOUT))
237
238
251
252 try:
253 utils.Retry(_CheckMasterDaemon, 1.0, _DAEMON_READY_TIMEOUT)
254 except utils.RetryTimeout:
255 raise errors.OpExecError("Master daemon didn't answer queries within"
256 " %s seconds" % _DAEMON_READY_TIMEOUT)
257
258
260 """Wait for SSH daemon to become responsive.
261
262 """
263 hostip = netutils.GetHostname(name=hostname, family=family).ip
264
265 def _CheckSshDaemon():
266 if netutils.TcpPing(hostip, port, timeout=1.0, live_port_needed=True):
267 logging.debug("SSH daemon on %s:%s (IP address %s) has become"
268 " responsive", hostname, port, hostip)
269 else:
270 raise utils.RetryAgain()
271
272 try:
273 utils.Retry(_CheckSshDaemon, 1.0, _DAEMON_READY_TIMEOUT)
274 except utils.RetryTimeout:
275 raise errors.OpExecError("SSH daemon on %s:%s (IP address %s) didn't"
276 " become responsive within %s seconds" %
277 (hostname, port, hostip, _DAEMON_READY_TIMEOUT))
278
279
280 -def RunNodeSetupCmd(cluster_name, node, basecmd, debug, verbose,
281 use_cluster_key, ask_key, strict_host_check, data):
282 """Runs a command to configure something on a remote machine.
283
284 @type cluster_name: string
285 @param cluster_name: Cluster name
286 @type node: string
287 @param node: Node name
288 @type basecmd: string
289 @param basecmd: Base command (path on the remote machine)
290 @type debug: bool
291 @param debug: Enable debug output
292 @type verbose: bool
293 @param verbose: Enable verbose output
294 @type use_cluster_key: bool
295 @param use_cluster_key: See L{ssh.SshRunner.BuildCmd}
296 @type ask_key: bool
297 @param ask_key: See L{ssh.SshRunner.BuildCmd}
298 @type strict_host_check: bool
299 @param strict_host_check: See L{ssh.SshRunner.BuildCmd}
300 @param data: JSON-serializable input data for script (passed to stdin)
301
302 """
303 cmd = [basecmd]
304
305
306 if debug:
307 cmd.append("--debug")
308
309 if verbose:
310 cmd.append("--verbose")
311
312 family = ssconf.SimpleStore().GetPrimaryIPFamily()
313 srun = ssh.SshRunner(cluster_name,
314 ipv6=(family == netutils.IP6Address.family))
315 scmd = srun.BuildCmd(node, constants.SSH_LOGIN_USER,
316 utils.ShellQuoteArgs(cmd),
317 batch=False, ask_key=ask_key, quiet=False,
318 strict_host_check=strict_host_check,
319 use_cluster_key=use_cluster_key)
320
321 tempfh = tempfile.TemporaryFile()
322 try:
323 tempfh.write(serializer.DumpJson(data))
324 tempfh.seek(0)
325
326 result = utils.RunCmd(scmd, interactive=True, input_fd=tempfh)
327 finally:
328 tempfh.close()
329
330 if result.failed:
331 raise errors.OpExecError("Command '%s' failed: %s" %
332 (result.cmd, result.fail_reason))
333
334 _WaitForSshDaemon(node, netutils.GetDaemonPort(constants.SSH), family)
335
336
338 """Initialize if needed the file storage.
339
340 @param file_storage_dir: the user-supplied value
341 @return: either empty string (if file storage was disabled at build
342 time) or the normalized path to the storage directory
343
344 """
345 file_storage_dir = os.path.normpath(file_storage_dir)
346
347 if not os.path.isabs(file_storage_dir):
348 raise errors.OpPrereqError("File storage directory '%s' is not an absolute"
349 " path" % file_storage_dir, errors.ECODE_INVAL)
350
351 if not os.path.exists(file_storage_dir):
352 try:
353 os.makedirs(file_storage_dir, 0750)
354 except OSError, err:
355 raise errors.OpPrereqError("Cannot create file storage directory"
356 " '%s': %s" % (file_storage_dir, err),
357 errors.ECODE_ENVIRON)
358
359 if not os.path.isdir(file_storage_dir):
360 raise errors.OpPrereqError("The file storage directory '%s' is not"
361 " a directory." % file_storage_dir,
362 errors.ECODE_ENVIRON)
363 return file_storage_dir
364
365
366 -def InitCluster(cluster_name, mac_prefix,
367 master_netmask, master_netdev, file_storage_dir,
368 shared_file_storage_dir, candidate_pool_size, secondary_ip=None,
369 vg_name=None, beparams=None, nicparams=None, ndparams=None,
370 hvparams=None, diskparams=None, enabled_hypervisors=None,
371 modify_etc_hosts=True, modify_ssh_setup=True,
372 maintain_node_health=False, drbd_helper=None, uid_pool=None,
373 default_iallocator=None, primary_ip_version=None, ipolicy=None,
374 prealloc_wipe_disks=False, use_external_mip_script=False,
375 hv_state=None, disk_state=None, enabled_disk_templates=None):
376 """Initialise the cluster.
377
378 @type candidate_pool_size: int
379 @param candidate_pool_size: master candidate pool size
380 @type enabled_disk_templates: list of string
381 @param enabled_disk_templates: list of disk_templates to be used in this
382 cluster
383
384 """
385
386 if config.ConfigWriter.IsCluster():
387 raise errors.OpPrereqError("Cluster is already initialised",
388 errors.ECODE_STATE)
389
390 if not enabled_hypervisors:
391 raise errors.OpPrereqError("Enabled hypervisors list must contain at"
392 " least one member", errors.ECODE_INVAL)
393 invalid_hvs = set(enabled_hypervisors) - constants.HYPER_TYPES
394 if invalid_hvs:
395 raise errors.OpPrereqError("Enabled hypervisors contains invalid"
396 " entries: %s" % invalid_hvs,
397 errors.ECODE_INVAL)
398
399 if not enabled_disk_templates:
400 raise errors.OpPrereqError("Enabled disk templates list must contain at"
401 " least one member", errors.ECODE_INVAL)
402 invalid_disk_templates = \
403 set(enabled_disk_templates) - constants.DISK_TEMPLATES
404 if invalid_disk_templates:
405 raise errors.OpPrereqError("Enabled disk templates list contains invalid"
406 " entries: %s" % invalid_disk_templates,
407 errors.ECODE_INVAL)
408
409 try:
410 ipcls = netutils.IPAddress.GetClassFromIpVersion(primary_ip_version)
411 except errors.ProgrammerError:
412 raise errors.OpPrereqError("Invalid primary ip version: %d." %
413 primary_ip_version, errors.ECODE_INVAL)
414
415 hostname = netutils.GetHostname(family=ipcls.family)
416 if not ipcls.IsValid(hostname.ip):
417 raise errors.OpPrereqError("This host's IP (%s) is not a valid IPv%d"
418 " address." % (hostname.ip, primary_ip_version),
419 errors.ECODE_INVAL)
420
421 if ipcls.IsLoopback(hostname.ip):
422 raise errors.OpPrereqError("This host's IP (%s) resolves to a loopback"
423 " address. Please fix DNS or %s." %
424 (hostname.ip, pathutils.ETC_HOSTS),
425 errors.ECODE_ENVIRON)
426
427 if not ipcls.Own(hostname.ip):
428 raise errors.OpPrereqError("Inconsistency: this host's name resolves"
429 " to %s,\nbut this ip address does not"
430 " belong to this host" %
431 hostname.ip, errors.ECODE_ENVIRON)
432
433 clustername = netutils.GetHostname(name=cluster_name, family=ipcls.family)
434
435 if netutils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT, timeout=5):
436 raise errors.OpPrereqError("Cluster IP already active",
437 errors.ECODE_NOTUNIQUE)
438
439 if not secondary_ip:
440 if primary_ip_version == constants.IP6_VERSION:
441 raise errors.OpPrereqError("When using a IPv6 primary address, a valid"
442 " IPv4 address must be given as secondary",
443 errors.ECODE_INVAL)
444 secondary_ip = hostname.ip
445
446 if not netutils.IP4Address.IsValid(secondary_ip):
447 raise errors.OpPrereqError("Secondary IP address (%s) has to be a valid"
448 " IPv4 address." % secondary_ip,
449 errors.ECODE_INVAL)
450
451 if not netutils.IP4Address.Own(secondary_ip):
452 raise errors.OpPrereqError("You gave %s as secondary IP,"
453 " but it does not belong to this host." %
454 secondary_ip, errors.ECODE_ENVIRON)
455
456 if master_netmask is not None:
457 if not ipcls.ValidateNetmask(master_netmask):
458 raise errors.OpPrereqError("CIDR netmask (%s) not valid for IPv%s " %
459 (master_netmask, primary_ip_version),
460 errors.ECODE_INVAL)
461 else:
462 master_netmask = ipcls.iplen
463
464 if vg_name is not None:
465
466 vgstatus = utils.CheckVolumeGroupSize(utils.ListVolumeGroups(), vg_name,
467 constants.MIN_VG_SIZE)
468 if vgstatus:
469 raise errors.OpPrereqError("Error: %s\nspecify --no-lvm-storage if"
470 " you are not using lvm" % vgstatus,
471 errors.ECODE_INVAL)
472
473 if drbd_helper is not None:
474 try:
475 curr_helper = bdev.BaseDRBD.GetUsermodeHelper()
476 except errors.BlockDeviceError, err:
477 raise errors.OpPrereqError("Error while checking drbd helper"
478 " (specify --no-drbd-storage if you are not"
479 " using drbd): %s" % str(err),
480 errors.ECODE_ENVIRON)
481 if drbd_helper != curr_helper:
482 raise errors.OpPrereqError("Error: requiring %s as drbd helper but %s"
483 " is the current helper" % (drbd_helper,
484 curr_helper),
485 errors.ECODE_INVAL)
486
487 logging.debug("Stopping daemons (if any are running)")
488 result = utils.RunCmd([pathutils.DAEMON_UTIL, "stop-all"])
489 if result.failed:
490 raise errors.OpExecError("Could not stop daemons, command %s"
491 " had exitcode %s and error '%s'" %
492 (result.cmd, result.exit_code, result.output))
493
494 if constants.ENABLE_FILE_STORAGE:
495 file_storage_dir = _InitFileStorage(file_storage_dir)
496 else:
497 file_storage_dir = ""
498
499 if constants.ENABLE_SHARED_FILE_STORAGE:
500 shared_file_storage_dir = _InitFileStorage(shared_file_storage_dir)
501 else:
502 shared_file_storage_dir = ""
503
504 if not re.match("^[0-9a-z]{2}:[0-9a-z]{2}:[0-9a-z]{2}$", mac_prefix):
505 raise errors.OpPrereqError("Invalid mac prefix given '%s'" % mac_prefix,
506 errors.ECODE_INVAL)
507
508 result = utils.RunCmd(["ip", "link", "show", "dev", master_netdev])
509 if result.failed:
510 raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %
511 (master_netdev,
512 result.output.strip()), errors.ECODE_INVAL)
513
514 dirs = [(pathutils.RUN_DIR, constants.RUN_DIRS_MODE)]
515 utils.EnsureDirs(dirs)
516
517 objects.UpgradeBeParams(beparams)
518 utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
519 utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
520
521 objects.NIC.CheckParameterSyntax(nicparams)
522
523 full_ipolicy = objects.FillIPolicy(constants.IPOLICY_DEFAULTS, ipolicy)
524
525 if ndparams is not None:
526 utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
527 else:
528 ndparams = dict(constants.NDC_DEFAULTS)
529
530
531
532
533 if hv_state:
534 for hvname, hvs_data in hv_state.items():
535 utils.ForceDictType(hvs_data, constants.HVSTS_PARAMETER_TYPES)
536 hv_state[hvname] = objects.Cluster.SimpleFillHvState(hvs_data)
537 else:
538 hv_state = dict((hvname, constants.HVST_DEFAULTS)
539 for hvname in enabled_hypervisors)
540
541
542 if disk_state:
543 for storage, ds_data in disk_state.items():
544 if storage not in constants.DS_VALID_TYPES:
545 raise errors.OpPrereqError("Invalid storage type in disk state: %s" %
546 storage, errors.ECODE_INVAL)
547 for ds_name, state in ds_data.items():
548 utils.ForceDictType(state, constants.DSS_PARAMETER_TYPES)
549 ds_data[ds_name] = objects.Cluster.SimpleFillDiskState(state)
550
551
552 for hv_name, hv_params in hvparams.iteritems():
553 utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
554 hv_class = hypervisor.GetHypervisor(hv_name)
555 hv_class.CheckParameterSyntax(hv_params)
556
557
558 for template, dt_params in diskparams.items():
559 param_keys = set(dt_params.keys())
560 default_param_keys = set(constants.DISK_DT_DEFAULTS[template].keys())
561 if not (param_keys <= default_param_keys):
562 unknown_params = param_keys - default_param_keys
563 raise errors.OpPrereqError("Invalid parameters for disk template %s:"
564 " %s" % (template,
565 utils.CommaJoin(unknown_params)),
566 errors.ECODE_INVAL)
567 utils.ForceDictType(dt_params, constants.DISK_DT_TYPES)
568 if template == constants.DT_DRBD8 and vg_name is not None:
569
570
571 dt_params[constants.DRBD_DEFAULT_METAVG] = vg_name
572
573 try:
574 utils.VerifyDictOptions(diskparams, constants.DISK_DT_DEFAULTS)
575 except errors.OpPrereqError, err:
576 raise errors.OpPrereqError("While verify diskparam options: %s" % err,
577 errors.ECODE_INVAL)
578
579
580 rsa_sshkey = ""
581 dsa_sshkey = ""
582 if os.path.isfile(pathutils.SSH_HOST_RSA_PUB):
583 sshline = utils.ReadFile(pathutils.SSH_HOST_RSA_PUB)
584 rsa_sshkey = sshline.split(" ")[1]
585 if os.path.isfile(pathutils.SSH_HOST_DSA_PUB):
586 sshline = utils.ReadFile(pathutils.SSH_HOST_DSA_PUB)
587 dsa_sshkey = sshline.split(" ")[1]
588 if not rsa_sshkey and not dsa_sshkey:
589 raise errors.OpPrereqError("Failed to find SSH public keys",
590 errors.ECODE_ENVIRON)
591
592 if modify_etc_hosts:
593 utils.AddHostToEtcHosts(hostname.name, hostname.ip)
594
595 if modify_ssh_setup:
596 _InitSSHSetup()
597
598 if default_iallocator is not None:
599 alloc_script = utils.FindFile(default_iallocator,
600 constants.IALLOCATOR_SEARCH_PATH,
601 os.path.isfile)
602 if alloc_script is None:
603 raise errors.OpPrereqError("Invalid default iallocator script '%s'"
604 " specified" % default_iallocator,
605 errors.ECODE_INVAL)
606 elif constants.HTOOLS:
607
608 if utils.FindFile(constants.IALLOC_HAIL,
609 constants.IALLOCATOR_SEARCH_PATH,
610 os.path.isfile):
611 default_iallocator = constants.IALLOC_HAIL
612
613 now = time.time()
614
615
616 cluster_config = objects.Cluster(
617 serial_no=1,
618 rsahostkeypub=rsa_sshkey,
619 dsahostkeypub=dsa_sshkey,
620 highest_used_port=(constants.FIRST_DRBD_PORT - 1),
621 mac_prefix=mac_prefix,
622 volume_group_name=vg_name,
623 tcpudp_port_pool=set(),
624 master_node=hostname.name,
625 master_ip=clustername.ip,
626 master_netmask=master_netmask,
627 master_netdev=master_netdev,
628 cluster_name=clustername.name,
629 file_storage_dir=file_storage_dir,
630 shared_file_storage_dir=shared_file_storage_dir,
631 enabled_hypervisors=enabled_hypervisors,
632 beparams={constants.PP_DEFAULT: beparams},
633 nicparams={constants.PP_DEFAULT: nicparams},
634 ndparams=ndparams,
635 hvparams=hvparams,
636 diskparams=diskparams,
637 candidate_pool_size=candidate_pool_size,
638 modify_etc_hosts=modify_etc_hosts,
639 modify_ssh_setup=modify_ssh_setup,
640 uid_pool=uid_pool,
641 ctime=now,
642 mtime=now,
643 maintain_node_health=maintain_node_health,
644 drbd_usermode_helper=drbd_helper,
645 default_iallocator=default_iallocator,
646 primary_ip_family=ipcls.family,
647 prealloc_wipe_disks=prealloc_wipe_disks,
648 use_external_mip_script=use_external_mip_script,
649 ipolicy=full_ipolicy,
650 hv_state_static=hv_state,
651 disk_state_static=disk_state,
652 enabled_disk_templates=enabled_disk_templates,
653 )
654 master_node_config = objects.Node(name=hostname.name,
655 primary_ip=hostname.ip,
656 secondary_ip=secondary_ip,
657 serial_no=1,
658 master_candidate=True,
659 offline=False, drained=False,
660 ctime=now, mtime=now,
661 )
662 InitConfig(constants.CONFIG_VERSION, cluster_config, master_node_config)
663 cfg = config.ConfigWriter(offline=True)
664 ssh.WriteKnownHostsFile(cfg, pathutils.SSH_KNOWN_HOSTS_FILE)
665 cfg.Update(cfg.GetClusterInfo(), logging.error)
666 ssconf.WriteSsconfFiles(cfg.GetSsconfValues())
667
668
669 _InitGanetiServerSetup(hostname.name)
670
671 logging.debug("Starting daemons")
672 result = utils.RunCmd([pathutils.DAEMON_UTIL, "start-all"])
673 if result.failed:
674 raise errors.OpExecError("Could not start daemons, command %s"
675 " had exitcode %s and error %s" %
676 (result.cmd, result.exit_code, result.output))
677
678 _WaitForMasterDaemon()
679
680
683 """Create the initial cluster configuration.
684
685 It will contain the current node, which will also be the master
686 node, and no instances.
687
688 @type version: int
689 @param version: configuration version
690 @type cluster_config: L{objects.Cluster}
691 @param cluster_config: cluster configuration
692 @type master_node_config: L{objects.Node}
693 @param master_node_config: master node configuration
694 @type cfg_file: string
695 @param cfg_file: configuration file path
696
697 """
698 uuid_generator = config.TemporaryReservationManager()
699 cluster_config.uuid = uuid_generator.Generate([], utils.NewUUID,
700 _INITCONF_ECID)
701 master_node_config.uuid = uuid_generator.Generate([], utils.NewUUID,
702 _INITCONF_ECID)
703 nodes = {
704 master_node_config.name: master_node_config,
705 }
706 default_nodegroup = objects.NodeGroup(
707 uuid=uuid_generator.Generate([], utils.NewUUID, _INITCONF_ECID),
708 name=constants.INITIAL_NODE_GROUP_NAME,
709 members=[master_node_config.name],
710 diskparams={},
711 )
712 nodegroups = {
713 default_nodegroup.uuid: default_nodegroup,
714 }
715 now = time.time()
716 config_data = objects.ConfigData(version=version,
717 cluster=cluster_config,
718 nodegroups=nodegroups,
719 nodes=nodes,
720 instances={},
721 networks={},
722 serial_no=1,
723 ctime=now, mtime=now)
724 utils.WriteFile(cfg_file,
725 data=serializer.Dump(config_data.ToDict()),
726 mode=0600)
727
728
730 """Execute the last steps of cluster destroy
731
732 This function shuts down all the daemons, completing the destroy
733 begun in cmdlib.LUDestroyOpcode.
734
735 """
736 cfg = config.ConfigWriter()
737 modify_ssh_setup = cfg.GetClusterInfo().modify_ssh_setup
738 runner = rpc.BootstrapRunner()
739
740 master_params = cfg.GetMasterNetworkParameters()
741 master_params.name = master
742 ems = cfg.GetUseExternalMipScript()
743 result = runner.call_node_deactivate_master_ip(master_params.name,
744 master_params, ems)
745
746 msg = result.fail_msg
747 if msg:
748 logging.warning("Could not disable the master IP: %s", msg)
749
750 result = runner.call_node_stop_master(master)
751 msg = result.fail_msg
752 if msg:
753 logging.warning("Could not disable the master role: %s", msg)
754
755 result = runner.call_node_leave_cluster(master, modify_ssh_setup)
756 msg = result.fail_msg
757 if msg:
758 logging.warning("Could not shutdown the node daemon and cleanup"
759 " the node: %s", msg)
760
761
763 """Add a node to the cluster.
764
765 This function must be called before the actual opcode, and will ssh
766 to the remote node, copy the needed files, and start ganeti-noded,
767 allowing the master to do the rest via normal rpc calls.
768
769 @param cluster_name: the cluster name
770 @param node: the name of the new node
771
772 """
773 data = {
774 constants.NDS_CLUSTER_NAME: cluster_name,
775 constants.NDS_NODE_DAEMON_CERTIFICATE:
776 utils.ReadFile(pathutils.NODED_CERT_FILE),
777 constants.NDS_SSCONF: ssconf.SimpleStore().ReadAll(),
778 constants.NDS_START_NODE_DAEMON: True,
779 }
780
781 RunNodeSetupCmd(cluster_name, node, pathutils.NODE_DAEMON_SETUP,
782 opts.debug, opts.verbose,
783 True, opts.ssh_key_check, opts.ssh_key_check, data)
784
785 _WaitForNodeDaemon(node)
786
787
789 """Failover the master node.
790
791 This checks that we are not already the master, and will cause the
792 current master to cease being master, and the non-master to become
793 new master.
794
795 @type no_voting: boolean
796 @param no_voting: force the operation without remote nodes agreement
797 (dangerous)
798
799 """
800 sstore = ssconf.SimpleStore()
801
802 old_master, new_master = ssconf.GetMasterAndMyself(sstore)
803 node_list = sstore.GetNodeList()
804 mc_list = sstore.GetMasterCandidates()
805
806 if old_master == new_master:
807 raise errors.OpPrereqError("This commands must be run on the node"
808 " where you want the new master to be."
809 " %s is already the master" %
810 old_master, errors.ECODE_INVAL)
811
812 if new_master not in mc_list:
813 mc_no_master = [name for name in mc_list if name != old_master]
814 raise errors.OpPrereqError("This node is not among the nodes marked"
815 " as master candidates. Only these nodes"
816 " can become masters. Current list of"
817 " master candidates is:\n"
818 "%s" % ("\n".join(mc_no_master)),
819 errors.ECODE_STATE)
820
821 if not no_voting:
822 vote_list = GatherMasterVotes(node_list)
823
824 if vote_list:
825 voted_master = vote_list[0][0]
826 if voted_master is None:
827 raise errors.OpPrereqError("Cluster is inconsistent, most nodes did"
828 " not respond.", errors.ECODE_ENVIRON)
829 elif voted_master != old_master:
830 raise errors.OpPrereqError("I have a wrong configuration, I believe"
831 " the master is %s but the other nodes"
832 " voted %s. Please resync the configuration"
833 " of this node." %
834 (old_master, voted_master),
835 errors.ECODE_STATE)
836
837
838 rcode = 0
839
840 logging.info("Setting master to %s, old master: %s", new_master, old_master)
841
842 try:
843
844
845 cfg = config.ConfigWriter(accept_foreign=True)
846
847 cluster_info = cfg.GetClusterInfo()
848 cluster_info.master_node = new_master
849
850
851 cfg.Update(cluster_info, logging.error)
852 except errors.ConfigurationError, err:
853 logging.error("Error while trying to set the new master: %s",
854 str(err))
855 return 1
856
857
858
859
860
861
862 logging.info("Stopping the master daemon on node %s", old_master)
863
864 runner = rpc.BootstrapRunner()
865 master_params = cfg.GetMasterNetworkParameters()
866 master_params.name = old_master
867 ems = cfg.GetUseExternalMipScript()
868 result = runner.call_node_deactivate_master_ip(master_params.name,
869 master_params, ems)
870
871 msg = result.fail_msg
872 if msg:
873 logging.warning("Could not disable the master IP: %s", msg)
874
875 result = runner.call_node_stop_master(old_master)
876 msg = result.fail_msg
877 if msg:
878 logging.error("Could not disable the master role on the old master"
879 " %s, please disable manually: %s", old_master, msg)
880
881 logging.info("Checking master IP non-reachability...")
882
883 master_ip = sstore.GetMasterIP()
884 total_timeout = 30
885
886
887 def _check_ip():
888 if netutils.TcpPing(master_ip, constants.DEFAULT_NODED_PORT):
889 raise utils.RetryAgain()
890
891 try:
892 utils.Retry(_check_ip, (1, 1.5, 5), total_timeout)
893 except utils.RetryTimeout:
894 logging.warning("The master IP is still reachable after %s seconds,"
895 " continuing but activating the master on the current"
896 " node will probably fail", total_timeout)
897
898 if jstore.CheckDrainFlag():
899 logging.info("Undraining job queue")
900 jstore.SetDrainFlag(False)
901
902 logging.info("Starting the master daemons on the new master")
903
904 result = rpc.BootstrapRunner().call_node_start_master_daemons(new_master,
905 no_voting)
906 msg = result.fail_msg
907 if msg:
908 logging.error("Could not start the master role on the new master"
909 " %s, please check: %s", new_master, msg)
910 rcode = 1
911
912 logging.info("Master failed over from %s to %s", old_master, new_master)
913 return rcode
914
915
917 """Returns the current master node.
918
919 This is a separate function in bootstrap since it's needed by
920 gnt-cluster, and instead of importing directly ssconf, it's better
921 to abstract it in bootstrap, where we do use ssconf in other
922 functions too.
923
924 """
925 sstore = ssconf.SimpleStore()
926
927 old_master, _ = ssconf.GetMasterAndMyself(sstore)
928
929 return old_master
930
931
933 """Check the agreement on who is the master.
934
935 This function will return a list of (node, number of votes), ordered
936 by the number of votes. Errors will be denoted by the key 'None'.
937
938 Note that the sum of votes is the number of nodes this machine
939 knows, whereas the number of entries in the list could be different
940 (if some nodes vote for another master).
941
942 We remove ourselves from the list since we know that (bugs aside)
943 since we use the same source for configuration information for both
944 backend and boostrap, we'll always vote for ourselves.
945
946 @type node_list: list
947 @param node_list: the list of nodes to query for master info; the current
948 node will be removed if it is in the list
949 @rtype: list
950 @return: list of (node, votes)
951
952 """
953 myself = netutils.Hostname.GetSysName()
954 try:
955 node_list.remove(myself)
956 except ValueError:
957 pass
958 if not node_list:
959
960 return []
961 results = rpc.BootstrapRunner().call_master_info(node_list)
962 if not isinstance(results, dict):
963
964 logging.critical("Can't complete rpc call, aborting master startup")
965 return [(None, len(node_list))]
966 votes = {}
967 for node in results:
968 nres = results[node]
969 data = nres.payload
970 msg = nres.fail_msg
971 fail = False
972 if msg:
973 logging.warning("Error contacting node %s: %s", node, msg)
974 fail = True
975
976
977 elif not isinstance(data, (tuple, list)) or len(data) < 3:
978 logging.warning("Invalid data received from node %s: %s", node, data)
979 fail = True
980 if fail:
981 if None not in votes:
982 votes[None] = 0
983 votes[None] += 1
984 continue
985 master_node = data[2]
986 if master_node not in votes:
987 votes[master_node] = 0
988 votes[master_node] += 1
989
990 vote_list = [v for v in votes.items()]
991
992
993
994 vote_list.sort(key=lambda x: (x[1], x[0]), reverse=True)
995
996 return vote_list
997