Statistics
| Branch: | Tag: | Revision:

root / lib / bootstrap.py @ 93b19295

History | View | Annotate | Download (33.4 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007, 2008, 2010, 2011, 2012 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
from ganeti import pathutils
48

    
49

    
50
# ec_id for InitConfig's temporary reservation manager
51
_INITCONF_ECID = "initconfig-ecid"
52

    
53
#: After how many seconds daemon must be responsive
54
_DAEMON_READY_TIMEOUT = 10.0
55

    
56

    
57
def _InitSSHSetup():
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.GANETI_RUNAS)
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

    
81
def GenerateHmacKey(file_name):
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
  # noded SSL certificate
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
  # confd HMAC key
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
  # RAPI
150
  rapi_cert_exists = os.path.exists(rapicert_file)
151

    
152
  if rapi_cert_pem:
153
    # Assume rapi_pem contains a valid PEM-formatted certificate and key
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
  # SPICE
165
  spice_cert_exists = os.path.exists(spicecert_file)
166
  spice_cacert_exists = os.path.exists(spicecacert_file)
167
  if spice_cert_pem:
168
    # spice_cert_pem implies also spice_cacert_pem
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
    # Self-signed certificate -> the public certificate is also the CA public
184
    # certificate
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
  # Cluster domain secret
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

    
199
def _InitGanetiServerSetup(master_name):
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
  # Generate cluster secrets
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

    
221
def _WaitForNodeDaemon(node_name):
222
  """Wait for node daemon to become responsive.
223

224
  """
225
  def _CheckNodeDaemon():
226
    # Pylint bug <http://www.logilab.org/ticket/35642>
227
    # pylint: disable=E1101
228
    result = rpc.BootstrapRunner().call_version([node_name])[node_name]
229
    if result.fail_msg:
230
      raise utils.RetryAgain()
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

    
239
def _WaitForMasterDaemon():
240
  """Wait for master daemon to become responsive.
241

242
  """
243
  def _CheckMasterDaemon():
244
    try:
245
      cl = luxi.Client()
246
      (cluster_name, ) = cl.QueryConfigValues(["cluster_name"])
247
    except Exception:
248
      raise utils.RetryAgain()
249

    
250
    logging.debug("Received cluster name %s from master", cluster_name)
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

    
259
def _InitFileStorage(file_storage_dir):
260
  """Initialize if needed the file storage.
261

262
  @param file_storage_dir: the user-supplied value
263
  @return: either empty string (if file storage was disabled at build
264
      time) or the normalized path to the storage directory
265

266
  """
267
  file_storage_dir = os.path.normpath(file_storage_dir)
268

    
269
  if not os.path.isabs(file_storage_dir):
270
    raise errors.OpPrereqError("File storage directory '%s' is not an absolute"
271
                               " path" % file_storage_dir, errors.ECODE_INVAL)
272

    
273
  if not os.path.exists(file_storage_dir):
274
    try:
275
      os.makedirs(file_storage_dir, 0750)
276
    except OSError, err:
277
      raise errors.OpPrereqError("Cannot create file storage directory"
278
                                 " '%s': %s" % (file_storage_dir, err),
279
                                 errors.ECODE_ENVIRON)
280

    
281
  if not os.path.isdir(file_storage_dir):
282
    raise errors.OpPrereqError("The file storage directory '%s' is not"
283
                               " a directory." % file_storage_dir,
284
                               errors.ECODE_ENVIRON)
285
  return file_storage_dir
286

    
287

    
288
def InitCluster(cluster_name, mac_prefix, # pylint: disable=R0913, R0914
289
                master_netmask, master_netdev, file_storage_dir,
290
                shared_file_storage_dir, candidate_pool_size, secondary_ip=None,
291
                vg_name=None, beparams=None, nicparams=None, ndparams=None,
292
                hvparams=None, diskparams=None, enabled_hypervisors=None,
293
                modify_etc_hosts=True, modify_ssh_setup=True,
294
                maintain_node_health=False, drbd_helper=None, uid_pool=None,
295
                default_iallocator=None, primary_ip_version=None, ipolicy=None,
296
                prealloc_wipe_disks=False, use_external_mip_script=False,
297
                hv_state=None, disk_state=None):
298
  """Initialise the cluster.
299

300
  @type candidate_pool_size: int
301
  @param candidate_pool_size: master candidate pool size
302

303
  """
304
  # TODO: complete the docstring
305
  if config.ConfigWriter.IsCluster():
306
    raise errors.OpPrereqError("Cluster is already initialised",
307
                               errors.ECODE_STATE)
308

    
309
  if not enabled_hypervisors:
310
    raise errors.OpPrereqError("Enabled hypervisors list must contain at"
311
                               " least one member", errors.ECODE_INVAL)
312
  invalid_hvs = set(enabled_hypervisors) - constants.HYPER_TYPES
313
  if invalid_hvs:
314
    raise errors.OpPrereqError("Enabled hypervisors contains invalid"
315
                               " entries: %s" % invalid_hvs,
316
                               errors.ECODE_INVAL)
317

    
318
  try:
319
    ipcls = netutils.IPAddress.GetClassFromIpVersion(primary_ip_version)
320
  except errors.ProgrammerError:
321
    raise errors.OpPrereqError("Invalid primary ip version: %d." %
322
                               primary_ip_version, errors.ECODE_INVAL)
323

    
324
  hostname = netutils.GetHostname(family=ipcls.family)
325
  if not ipcls.IsValid(hostname.ip):
326
    raise errors.OpPrereqError("This host's IP (%s) is not a valid IPv%d"
327
                               " address." % (hostname.ip, primary_ip_version),
328
                               errors.ECODE_INVAL)
329

    
330
  if ipcls.IsLoopback(hostname.ip):
331
    raise errors.OpPrereqError("This host's IP (%s) resolves to a loopback"
332
                               " address. Please fix DNS or %s." %
333
                               (hostname.ip, constants.ETC_HOSTS),
334
                               errors.ECODE_ENVIRON)
335

    
336
  if not ipcls.Own(hostname.ip):
337
    raise errors.OpPrereqError("Inconsistency: this host's name resolves"
338
                               " to %s,\nbut this ip address does not"
339
                               " belong to this host" %
340
                               hostname.ip, errors.ECODE_ENVIRON)
341

    
342
  clustername = netutils.GetHostname(name=cluster_name, family=ipcls.family)
343

    
344
  if netutils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT, timeout=5):
345
    raise errors.OpPrereqError("Cluster IP already active",
346
                               errors.ECODE_NOTUNIQUE)
347

    
348
  if not secondary_ip:
349
    if primary_ip_version == constants.IP6_VERSION:
350
      raise errors.OpPrereqError("When using a IPv6 primary address, a valid"
351
                                 " IPv4 address must be given as secondary",
352
                                 errors.ECODE_INVAL)
353
    secondary_ip = hostname.ip
354

    
355
  if not netutils.IP4Address.IsValid(secondary_ip):
356
    raise errors.OpPrereqError("Secondary IP address (%s) has to be a valid"
357
                               " IPv4 address." % secondary_ip,
358
                               errors.ECODE_INVAL)
359

    
360
  if not netutils.IP4Address.Own(secondary_ip):
361
    raise errors.OpPrereqError("You gave %s as secondary IP,"
362
                               " but it does not belong to this host." %
363
                               secondary_ip, errors.ECODE_ENVIRON)
364

    
365
  if master_netmask is not None:
366
    if not ipcls.ValidateNetmask(master_netmask):
367
      raise errors.OpPrereqError("CIDR netmask (%s) not valid for IPv%s " %
368
                                  (master_netmask, primary_ip_version),
369
                                 errors.ECODE_INVAL)
370
  else:
371
    master_netmask = ipcls.iplen
372

    
373
  if vg_name is not None:
374
    # Check if volume group is valid
375
    vgstatus = utils.CheckVolumeGroupSize(utils.ListVolumeGroups(), vg_name,
376
                                          constants.MIN_VG_SIZE)
377
    if vgstatus:
378
      raise errors.OpPrereqError("Error: %s\nspecify --no-lvm-storage if"
379
                                 " you are not using lvm" % vgstatus,
380
                                 errors.ECODE_INVAL)
381

    
382
  if drbd_helper is not None:
383
    try:
384
      curr_helper = bdev.BaseDRBD.GetUsermodeHelper()
385
    except errors.BlockDeviceError, err:
386
      raise errors.OpPrereqError("Error while checking drbd helper"
387
                                 " (specify --no-drbd-storage if you are not"
388
                                 " using drbd): %s" % str(err),
389
                                 errors.ECODE_ENVIRON)
390
    if drbd_helper != curr_helper:
391
      raise errors.OpPrereqError("Error: requiring %s as drbd helper but %s"
392
                                 " is the current helper" % (drbd_helper,
393
                                                             curr_helper),
394
                                 errors.ECODE_INVAL)
395

    
396
  if constants.ENABLE_FILE_STORAGE:
397
    file_storage_dir = _InitFileStorage(file_storage_dir)
398
  else:
399
    file_storage_dir = ""
400

    
401
  if constants.ENABLE_SHARED_FILE_STORAGE:
402
    shared_file_storage_dir = _InitFileStorage(shared_file_storage_dir)
403
  else:
404
    shared_file_storage_dir = ""
405

    
406
  if not re.match("^[0-9a-z]{2}:[0-9a-z]{2}:[0-9a-z]{2}$", mac_prefix):
407
    raise errors.OpPrereqError("Invalid mac prefix given '%s'" % mac_prefix,
408
                               errors.ECODE_INVAL)
409

    
410
  result = utils.RunCmd(["ip", "link", "show", "dev", master_netdev])
411
  if result.failed:
412
    raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %
413
                               (master_netdev,
414
                                result.output.strip()), errors.ECODE_INVAL)
415

    
416
  dirs = [(pathutils.RUN_DIR, constants.RUN_DIRS_MODE)]
417
  utils.EnsureDirs(dirs)
418

    
419
  objects.UpgradeBeParams(beparams)
420
  utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
421
  utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
422

    
423
  objects.NIC.CheckParameterSyntax(nicparams)
424

    
425
  full_ipolicy = objects.FillIPolicy(constants.IPOLICY_DEFAULTS, ipolicy)
426

    
427
  if ndparams is not None:
428
    utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
429
  else:
430
    ndparams = dict(constants.NDC_DEFAULTS)
431

    
432
  # This is ugly, as we modify the dict itself
433
  # FIXME: Make utils.ForceDictType pure functional or write a wrapper
434
  # around it
435
  if hv_state:
436
    for hvname, hvs_data in hv_state.items():
437
      utils.ForceDictType(hvs_data, constants.HVSTS_PARAMETER_TYPES)
438
      hv_state[hvname] = objects.Cluster.SimpleFillHvState(hvs_data)
439
  else:
440
    hv_state = dict((hvname, constants.HVST_DEFAULTS)
441
                    for hvname in enabled_hypervisors)
442

    
443
  # FIXME: disk_state has no default values yet
444
  if disk_state:
445
    for storage, ds_data in disk_state.items():
446
      if storage not in constants.DS_VALID_TYPES:
447
        raise errors.OpPrereqError("Invalid storage type in disk state: %s" %
448
                                   storage, errors.ECODE_INVAL)
449
      for ds_name, state in ds_data.items():
450
        utils.ForceDictType(state, constants.DSS_PARAMETER_TYPES)
451
        ds_data[ds_name] = objects.Cluster.SimpleFillDiskState(state)
452

    
453
  # hvparams is a mapping of hypervisor->hvparams dict
454
  for hv_name, hv_params in hvparams.iteritems():
455
    utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
456
    hv_class = hypervisor.GetHypervisor(hv_name)
457
    hv_class.CheckParameterSyntax(hv_params)
458

    
459
  # diskparams is a mapping of disk-template->diskparams dict
460
  for template, dt_params in diskparams.items():
461
    param_keys = set(dt_params.keys())
462
    default_param_keys = set(constants.DISK_DT_DEFAULTS[template].keys())
463
    if not (param_keys <= default_param_keys):
464
      unknown_params = param_keys - default_param_keys
465
      raise errors.OpPrereqError("Invalid parameters for disk template %s:"
466
                                 " %s" % (template,
467
                                          utils.CommaJoin(unknown_params)),
468
                                 errors.ECODE_INVAL)
469
    utils.ForceDictType(dt_params, constants.DISK_DT_TYPES)
470
  try:
471
    utils.VerifyDictOptions(diskparams, constants.DISK_DT_DEFAULTS)
472
  except errors.OpPrereqError, err:
473
    raise errors.OpPrereqError("While verify diskparam options: %s" % err,
474
                               errors.ECODE_INVAL)
475

    
476
  # set up ssh config and /etc/hosts
477
  sshline = utils.ReadFile(pathutils.SSH_HOST_RSA_PUB)
478
  sshkey = sshline.split(" ")[1]
479

    
480
  if modify_etc_hosts:
481
    utils.AddHostToEtcHosts(hostname.name, hostname.ip)
482

    
483
  if modify_ssh_setup:
484
    _InitSSHSetup()
485

    
486
  if default_iallocator is not None:
487
    alloc_script = utils.FindFile(default_iallocator,
488
                                  constants.IALLOCATOR_SEARCH_PATH,
489
                                  os.path.isfile)
490
    if alloc_script is None:
491
      raise errors.OpPrereqError("Invalid default iallocator script '%s'"
492
                                 " specified" % default_iallocator,
493
                                 errors.ECODE_INVAL)
494
  elif constants.HTOOLS:
495
    # htools was enabled at build-time, we default to it
496
    if utils.FindFile(constants.IALLOC_HAIL,
497
                      constants.IALLOCATOR_SEARCH_PATH,
498
                      os.path.isfile):
499
      default_iallocator = constants.IALLOC_HAIL
500

    
501
  now = time.time()
502

    
503
  # init of cluster config file
504
  cluster_config = objects.Cluster(
505
    serial_no=1,
506
    rsahostkeypub=sshkey,
507
    highest_used_port=(constants.FIRST_DRBD_PORT - 1),
508
    mac_prefix=mac_prefix,
509
    volume_group_name=vg_name,
510
    tcpudp_port_pool=set(),
511
    master_node=hostname.name,
512
    master_ip=clustername.ip,
513
    master_netmask=master_netmask,
514
    master_netdev=master_netdev,
515
    cluster_name=clustername.name,
516
    file_storage_dir=file_storage_dir,
517
    shared_file_storage_dir=shared_file_storage_dir,
518
    enabled_hypervisors=enabled_hypervisors,
519
    beparams={constants.PP_DEFAULT: beparams},
520
    nicparams={constants.PP_DEFAULT: nicparams},
521
    ndparams=ndparams,
522
    hvparams=hvparams,
523
    diskparams=diskparams,
524
    candidate_pool_size=candidate_pool_size,
525
    modify_etc_hosts=modify_etc_hosts,
526
    modify_ssh_setup=modify_ssh_setup,
527
    uid_pool=uid_pool,
528
    ctime=now,
529
    mtime=now,
530
    maintain_node_health=maintain_node_health,
531
    drbd_usermode_helper=drbd_helper,
532
    default_iallocator=default_iallocator,
533
    primary_ip_family=ipcls.family,
534
    prealloc_wipe_disks=prealloc_wipe_disks,
535
    use_external_mip_script=use_external_mip_script,
536
    ipolicy=full_ipolicy,
537
    hv_state_static=hv_state,
538
    disk_state_static=disk_state,
539
    )
540
  master_node_config = objects.Node(name=hostname.name,
541
                                    primary_ip=hostname.ip,
542
                                    secondary_ip=secondary_ip,
543
                                    serial_no=1,
544
                                    master_candidate=True,
545
                                    offline=False, drained=False,
546
                                    ctime=now, mtime=now,
547
                                    )
548
  InitConfig(constants.CONFIG_VERSION, cluster_config, master_node_config)
549
  cfg = config.ConfigWriter(offline=True)
550
  ssh.WriteKnownHostsFile(cfg, pathutils.SSH_KNOWN_HOSTS_FILE)
551
  cfg.Update(cfg.GetClusterInfo(), logging.error)
552
  backend.WriteSsconfFiles(cfg.GetSsconfValues())
553

    
554
  # set up the inter-node password and certificate
555
  _InitGanetiServerSetup(hostname.name)
556

    
557
  logging.debug("Starting daemons")
558
  result = utils.RunCmd([pathutils.DAEMON_UTIL, "start-all"])
559
  if result.failed:
560
    raise errors.OpExecError("Could not start daemons, command %s"
561
                             " had exitcode %s and error %s" %
562
                             (result.cmd, result.exit_code, result.output))
563

    
564
  _WaitForMasterDaemon()
565

    
566

    
567
def InitConfig(version, cluster_config, master_node_config,
568
               cfg_file=pathutils.CLUSTER_CONF_FILE):
569
  """Create the initial cluster configuration.
570

571
  It will contain the current node, which will also be the master
572
  node, and no instances.
573

574
  @type version: int
575
  @param version: configuration version
576
  @type cluster_config: L{objects.Cluster}
577
  @param cluster_config: cluster configuration
578
  @type master_node_config: L{objects.Node}
579
  @param master_node_config: master node configuration
580
  @type cfg_file: string
581
  @param cfg_file: configuration file path
582

583
  """
584
  uuid_generator = config.TemporaryReservationManager()
585
  cluster_config.uuid = uuid_generator.Generate([], utils.NewUUID,
586
                                                _INITCONF_ECID)
587
  master_node_config.uuid = uuid_generator.Generate([], utils.NewUUID,
588
                                                    _INITCONF_ECID)
589
  nodes = {
590
    master_node_config.name: master_node_config,
591
    }
592
  default_nodegroup = objects.NodeGroup(
593
    uuid=uuid_generator.Generate([], utils.NewUUID, _INITCONF_ECID),
594
    name=constants.INITIAL_NODE_GROUP_NAME,
595
    members=[master_node_config.name],
596
    diskparams={},
597
    )
598
  nodegroups = {
599
    default_nodegroup.uuid: default_nodegroup,
600
    }
601
  now = time.time()
602
  config_data = objects.ConfigData(version=version,
603
                                   cluster=cluster_config,
604
                                   nodegroups=nodegroups,
605
                                   nodes=nodes,
606
                                   instances={},
607
                                   serial_no=1,
608
                                   ctime=now, mtime=now)
609
  utils.WriteFile(cfg_file,
610
                  data=serializer.Dump(config_data.ToDict()),
611
                  mode=0600)
612

    
613

    
614
def FinalizeClusterDestroy(master):
615
  """Execute the last steps of cluster destroy
616

617
  This function shuts down all the daemons, completing the destroy
618
  begun in cmdlib.LUDestroyOpcode.
619

620
  """
621
  cfg = config.ConfigWriter()
622
  modify_ssh_setup = cfg.GetClusterInfo().modify_ssh_setup
623
  runner = rpc.BootstrapRunner()
624

    
625
  master_params = cfg.GetMasterNetworkParameters()
626
  master_params.name = master
627
  ems = cfg.GetUseExternalMipScript()
628
  result = runner.call_node_deactivate_master_ip(master_params.name,
629
                                                 master_params, ems)
630

    
631
  msg = result.fail_msg
632
  if msg:
633
    logging.warning("Could not disable the master IP: %s", msg)
634

    
635
  result = runner.call_node_stop_master(master)
636
  msg = result.fail_msg
637
  if msg:
638
    logging.warning("Could not disable the master role: %s", msg)
639

    
640
  result = runner.call_node_leave_cluster(master, modify_ssh_setup)
641
  msg = result.fail_msg
642
  if msg:
643
    logging.warning("Could not shutdown the node daemon and cleanup"
644
                    " the node: %s", msg)
645

    
646

    
647
def SetupNodeDaemon(cluster_name, node, ssh_key_check):
648
  """Add a node to the cluster.
649

650
  This function must be called before the actual opcode, and will ssh
651
  to the remote node, copy the needed files, and start ganeti-noded,
652
  allowing the master to do the rest via normal rpc calls.
653

654
  @param cluster_name: the cluster name
655
  @param node: the name of the new node
656
  @param ssh_key_check: whether to do a strict key check
657

658
  """
659
  sstore = ssconf.SimpleStore()
660
  family = sstore.GetPrimaryIPFamily()
661
  sshrunner = ssh.SshRunner(cluster_name,
662
                            ipv6=(family == netutils.IP6Address.family))
663

    
664
  # set up inter-node password and certificate and restarts the node daemon
665
  # and then connect with ssh to set password and start ganeti-noded
666
  # note that all the below variables are sanitized at this point,
667
  # either by being constants or by the checks above
668
  sshrunner.CopyFileToNode(node, pathutils.NODED_CERT_FILE)
669
  sshrunner.CopyFileToNode(node, pathutils.RAPI_CERT_FILE)
670
  sshrunner.CopyFileToNode(node, pathutils.SPICE_CERT_FILE)
671
  sshrunner.CopyFileToNode(node, pathutils.SPICE_CACERT_FILE)
672
  sshrunner.CopyFileToNode(node, pathutils.CONFD_HMAC_KEY)
673
  for filename in sstore.GetFileList():
674
    sshrunner.CopyFileToNode(node, filename)
675
  mycommand = ("%s stop-all; %s start %s" %
676
               (pathutils.DAEMON_UTIL, pathutils.DAEMON_UTIL, constants.NODED))
677

    
678
  result = sshrunner.Run(node, "root", mycommand, batch=False,
679
                         ask_key=ssh_key_check,
680
                         use_cluster_key=True,
681
                         strict_host_check=ssh_key_check)
682
  if result.failed:
683
    raise errors.OpExecError("Remote command on node %s, error: %s,"
684
                             " output: %s" %
685
                             (node, result.fail_reason, result.output))
686

    
687
  _WaitForNodeDaemon(node)
688

    
689

    
690
def MasterFailover(no_voting=False):
691
  """Failover the master node.
692

693
  This checks that we are not already the master, and will cause the
694
  current master to cease being master, and the non-master to become
695
  new master.
696

697
  @type no_voting: boolean
698
  @param no_voting: force the operation without remote nodes agreement
699
                      (dangerous)
700

701
  """
702
  sstore = ssconf.SimpleStore()
703

    
704
  old_master, new_master = ssconf.GetMasterAndMyself(sstore)
705
  node_list = sstore.GetNodeList()
706
  mc_list = sstore.GetMasterCandidates()
707

    
708
  if old_master == new_master:
709
    raise errors.OpPrereqError("This commands must be run on the node"
710
                               " where you want the new master to be."
711
                               " %s is already the master" %
712
                               old_master, errors.ECODE_INVAL)
713

    
714
  if new_master not in mc_list:
715
    mc_no_master = [name for name in mc_list if name != old_master]
716
    raise errors.OpPrereqError("This node is not among the nodes marked"
717
                               " as master candidates. Only these nodes"
718
                               " can become masters. Current list of"
719
                               " master candidates is:\n"
720
                               "%s" % ("\n".join(mc_no_master)),
721
                               errors.ECODE_STATE)
722

    
723
  if not no_voting:
724
    vote_list = GatherMasterVotes(node_list)
725

    
726
    if vote_list:
727
      voted_master = vote_list[0][0]
728
      if voted_master is None:
729
        raise errors.OpPrereqError("Cluster is inconsistent, most nodes did"
730
                                   " not respond.", errors.ECODE_ENVIRON)
731
      elif voted_master != old_master:
732
        raise errors.OpPrereqError("I have a wrong configuration, I believe"
733
                                   " the master is %s but the other nodes"
734
                                   " voted %s. Please resync the configuration"
735
                                   " of this node." %
736
                                   (old_master, voted_master),
737
                                   errors.ECODE_STATE)
738
  # end checks
739

    
740
  rcode = 0
741

    
742
  logging.info("Setting master to %s, old master: %s", new_master, old_master)
743

    
744
  try:
745
    # instantiate a real config writer, as we now know we have the
746
    # configuration data
747
    cfg = config.ConfigWriter(accept_foreign=True)
748

    
749
    cluster_info = cfg.GetClusterInfo()
750
    cluster_info.master_node = new_master
751
    # this will also regenerate the ssconf files, since we updated the
752
    # cluster info
753
    cfg.Update(cluster_info, logging.error)
754
  except errors.ConfigurationError, err:
755
    logging.error("Error while trying to set the new master: %s",
756
                  str(err))
757
    return 1
758

    
759
  # if cfg.Update worked, then it means the old master daemon won't be
760
  # able now to write its own config file (we rely on locking in both
761
  # backend.UploadFile() and ConfigWriter._Write(); hence the next
762
  # step is to kill the old master
763

    
764
  logging.info("Stopping the master daemon on node %s", old_master)
765

    
766
  runner = rpc.BootstrapRunner()
767
  master_params = cfg.GetMasterNetworkParameters()
768
  master_params.name = old_master
769
  ems = cfg.GetUseExternalMipScript()
770
  result = runner.call_node_deactivate_master_ip(master_params.name,
771
                                                 master_params, ems)
772

    
773
  msg = result.fail_msg
774
  if msg:
775
    logging.warning("Could not disable the master IP: %s", msg)
776

    
777
  result = runner.call_node_stop_master(old_master)
778
  msg = result.fail_msg
779
  if msg:
780
    logging.error("Could not disable the master role on the old master"
781
                  " %s, please disable manually: %s", old_master, msg)
782

    
783
  logging.info("Checking master IP non-reachability...")
784

    
785
  master_ip = sstore.GetMasterIP()
786
  total_timeout = 30
787

    
788
  # Here we have a phase where no master should be running
789
  def _check_ip():
790
    if netutils.TcpPing(master_ip, constants.DEFAULT_NODED_PORT):
791
      raise utils.RetryAgain()
792

    
793
  try:
794
    utils.Retry(_check_ip, (1, 1.5, 5), total_timeout)
795
  except utils.RetryTimeout:
796
    logging.warning("The master IP is still reachable after %s seconds,"
797
                    " continuing but activating the master on the current"
798
                    " node will probably fail", total_timeout)
799

    
800
  if jstore.CheckDrainFlag():
801
    logging.info("Undraining job queue")
802
    jstore.SetDrainFlag(False)
803

    
804
  logging.info("Starting the master daemons on the new master")
805

    
806
  result = rpc.BootstrapRunner().call_node_start_master_daemons(new_master,
807
                                                                no_voting)
808
  msg = result.fail_msg
809
  if msg:
810
    logging.error("Could not start the master role on the new master"
811
                  " %s, please check: %s", new_master, msg)
812
    rcode = 1
813

    
814
  logging.info("Master failed over from %s to %s", old_master, new_master)
815
  return rcode
816

    
817

    
818
def GetMaster():
819
  """Returns the current master node.
820

821
  This is a separate function in bootstrap since it's needed by
822
  gnt-cluster, and instead of importing directly ssconf, it's better
823
  to abstract it in bootstrap, where we do use ssconf in other
824
  functions too.
825

826
  """
827
  sstore = ssconf.SimpleStore()
828

    
829
  old_master, _ = ssconf.GetMasterAndMyself(sstore)
830

    
831
  return old_master
832

    
833

    
834
def GatherMasterVotes(node_list):
835
  """Check the agreement on who is the master.
836

837
  This function will return a list of (node, number of votes), ordered
838
  by the number of votes. Errors will be denoted by the key 'None'.
839

840
  Note that the sum of votes is the number of nodes this machine
841
  knows, whereas the number of entries in the list could be different
842
  (if some nodes vote for another master).
843

844
  We remove ourselves from the list since we know that (bugs aside)
845
  since we use the same source for configuration information for both
846
  backend and boostrap, we'll always vote for ourselves.
847

848
  @type node_list: list
849
  @param node_list: the list of nodes to query for master info; the current
850
      node will be removed if it is in the list
851
  @rtype: list
852
  @return: list of (node, votes)
853

854
  """
855
  myself = netutils.Hostname.GetSysName()
856
  try:
857
    node_list.remove(myself)
858
  except ValueError:
859
    pass
860
  if not node_list:
861
    # no nodes left (eventually after removing myself)
862
    return []
863
  results = rpc.BootstrapRunner().call_master_info(node_list)
864
  if not isinstance(results, dict):
865
    # this should not happen (unless internal error in rpc)
866
    logging.critical("Can't complete rpc call, aborting master startup")
867
    return [(None, len(node_list))]
868
  votes = {}
869
  for node in results:
870
    nres = results[node]
871
    data = nres.payload
872
    msg = nres.fail_msg
873
    fail = False
874
    if msg:
875
      logging.warning("Error contacting node %s: %s", node, msg)
876
      fail = True
877
    # for now we accept both length 3, 4 and 5 (data[3] is primary ip version
878
    # and data[4] is the master netmask)
879
    elif not isinstance(data, (tuple, list)) or len(data) < 3:
880
      logging.warning("Invalid data received from node %s: %s", node, data)
881
      fail = True
882
    if fail:
883
      if None not in votes:
884
        votes[None] = 0
885
      votes[None] += 1
886
      continue
887
    master_node = data[2]
888
    if master_node not in votes:
889
      votes[master_node] = 0
890
    votes[master_node] += 1
891

    
892
  vote_list = [v for v in votes.items()]
893
  # sort first on number of votes then on name, since we want None
894
  # sorted later if we have the half of the nodes not responding, and
895
  # half voting all for the same master
896
  vote_list.sort(key=lambda x: (x[1], x[0]), reverse=True)
897

    
898
  return vote_list