Statistics
| Branch: | Tag: | Revision:

root / lib / bootstrap.py @ 5b6f9e35

History | View | Annotate | Download (42.2 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
import tempfile
32

    
33
from ganeti.cmdlib import cluster
34
import ganeti.rpc.node as rpc
35
from ganeti import ssh
36
from ganeti import utils
37
from ganeti import errors
38
from ganeti import config
39
from ganeti import constants
40
from ganeti import objects
41
from ganeti import ssconf
42
from ganeti import serializer
43
from ganeti import hypervisor
44
from ganeti.storage import drbd
45
from ganeti.storage import filestorage
46
from ganeti import netutils
47
from ganeti import luxi
48
from ganeti import jstore
49
from ganeti import pathutils
50

    
51

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

    
55
#: After how many seconds daemon must be responsive
56
_DAEMON_READY_TIMEOUT = 10.0
57

    
58

    
59
def _InitSSHSetup():
60
  """Setup the SSH configuration for the cluster.
61

62
  This generates a dsa keypair for root, adds the pub key to the
63
  permitted hosts and adds the hostkey to its own known hosts.
64

65
  """
66
  priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.SSH_LOGIN_USER)
67

    
68
  for name in priv_key, pub_key:
69
    if os.path.exists(name):
70
      utils.CreateBackup(name)
71
    utils.RemoveFile(name)
72

    
73
  result = utils.RunCmd(["ssh-keygen", "-t", "dsa",
74
                         "-f", priv_key,
75
                         "-q", "-N", ""])
76
  if result.failed:
77
    raise errors.OpExecError("Could not generate ssh keypair, error %s" %
78
                             result.output)
79

    
80
  utils.AddAuthorizedKey(auth_keys, utils.ReadFile(pub_key))
81

    
82

    
83
def GenerateHmacKey(file_name):
84
  """Writes a new HMAC key.
85

86
  @type file_name: str
87
  @param file_name: Path to output file
88

89
  """
90
  utils.WriteFile(file_name, data="%s\n" % utils.GenerateSecret(), mode=0400,
91
                  backup=True)
92

    
93

    
94
def GenerateClusterCrypto(new_cluster_cert, new_rapi_cert, new_spice_cert,
95
                          new_confd_hmac_key, new_cds,
96
                          rapi_cert_pem=None, spice_cert_pem=None,
97
                          spice_cacert_pem=None, cds=None,
98
                          nodecert_file=pathutils.NODED_CERT_FILE,
99
                          rapicert_file=pathutils.RAPI_CERT_FILE,
100
                          spicecert_file=pathutils.SPICE_CERT_FILE,
101
                          spicecacert_file=pathutils.SPICE_CACERT_FILE,
102
                          hmackey_file=pathutils.CONFD_HMAC_KEY,
103
                          cds_file=pathutils.CLUSTER_DOMAIN_SECRET_FILE):
104
  """Updates the cluster certificates, keys and secrets.
105

106
  @type new_cluster_cert: bool
107
  @param new_cluster_cert: Whether to generate a new cluster certificate
108
  @type new_rapi_cert: bool
109
  @param new_rapi_cert: Whether to generate a new RAPI certificate
110
  @type new_spice_cert: bool
111
  @param new_spice_cert: Whether to generate a new SPICE certificate
112
  @type new_confd_hmac_key: bool
113
  @param new_confd_hmac_key: Whether to generate a new HMAC key
114
  @type new_cds: bool
115
  @param new_cds: Whether to generate a new cluster domain secret
116
  @type rapi_cert_pem: string
117
  @param rapi_cert_pem: New RAPI certificate in PEM format
118
  @type spice_cert_pem: string
119
  @param spice_cert_pem: New SPICE certificate in PEM format
120
  @type spice_cacert_pem: string
121
  @param spice_cacert_pem: Certificate of the CA that signed the SPICE
122
                           certificate, in PEM format
123
  @type cds: string
124
  @param cds: New cluster domain secret
125
  @type nodecert_file: string
126
  @param nodecert_file: optional override of the node cert file path
127
  @type rapicert_file: string
128
  @param rapicert_file: optional override of the rapi cert file path
129
  @type spicecert_file: string
130
  @param spicecert_file: optional override of the spice cert file path
131
  @type spicecacert_file: string
132
  @param spicecacert_file: optional override of the spice CA cert file path
133
  @type hmackey_file: string
134
  @param hmackey_file: optional override of the hmac key file path
135

136
  """
137
  # noded SSL certificate
138
  cluster_cert_exists = os.path.exists(nodecert_file)
139
  if new_cluster_cert or not cluster_cert_exists:
140
    if cluster_cert_exists:
141
      utils.CreateBackup(nodecert_file)
142

    
143
    logging.debug("Generating new cluster certificate at %s", nodecert_file)
144
    utils.GenerateSelfSignedSslCert(nodecert_file)
145

    
146
  # confd HMAC key
147
  if new_confd_hmac_key or not os.path.exists(hmackey_file):
148
    logging.debug("Writing new confd HMAC key to %s", hmackey_file)
149
    GenerateHmacKey(hmackey_file)
150

    
151
  # RAPI
152
  rapi_cert_exists = os.path.exists(rapicert_file)
153

    
154
  if rapi_cert_pem:
155
    # Assume rapi_pem contains a valid PEM-formatted certificate and key
156
    logging.debug("Writing RAPI certificate at %s", rapicert_file)
157
    utils.WriteFile(rapicert_file, data=rapi_cert_pem, backup=True)
158

    
159
  elif new_rapi_cert or not rapi_cert_exists:
160
    if rapi_cert_exists:
161
      utils.CreateBackup(rapicert_file)
162

    
163
    logging.debug("Generating new RAPI certificate at %s", rapicert_file)
164
    utils.GenerateSelfSignedSslCert(rapicert_file)
165

    
166
  # SPICE
167
  spice_cert_exists = os.path.exists(spicecert_file)
168
  spice_cacert_exists = os.path.exists(spicecacert_file)
169
  if spice_cert_pem:
170
    # spice_cert_pem implies also spice_cacert_pem
171
    logging.debug("Writing SPICE certificate at %s", spicecert_file)
172
    utils.WriteFile(spicecert_file, data=spice_cert_pem, backup=True)
173
    logging.debug("Writing SPICE CA certificate at %s", spicecacert_file)
174
    utils.WriteFile(spicecacert_file, data=spice_cacert_pem, backup=True)
175
  elif new_spice_cert or not spice_cert_exists:
176
    if spice_cert_exists:
177
      utils.CreateBackup(spicecert_file)
178
    if spice_cacert_exists:
179
      utils.CreateBackup(spicecacert_file)
180

    
181
    logging.debug("Generating new self-signed SPICE certificate at %s",
182
                  spicecert_file)
183
    (_, cert_pem) = utils.GenerateSelfSignedSslCert(spicecert_file)
184

    
185
    # Self-signed certificate -> the public certificate is also the CA public
186
    # certificate
187
    logging.debug("Writing the public certificate to %s",
188
                  spicecert_file)
189
    utils.io.WriteFile(spicecacert_file, mode=0400, data=cert_pem)
190

    
191
  # Cluster domain secret
192
  if cds:
193
    logging.debug("Writing cluster domain secret to %s", cds_file)
194
    utils.WriteFile(cds_file, data=cds, backup=True)
195

    
196
  elif new_cds or not os.path.exists(cds_file):
197
    logging.debug("Generating new cluster domain secret at %s", cds_file)
198
    GenerateHmacKey(cds_file)
199

    
200

    
201
def _InitGanetiServerSetup(master_name):
202
  """Setup the necessary configuration for the initial node daemon.
203

204
  This creates the nodepass file containing the shared password for
205
  the cluster, generates the SSL certificate and starts the node daemon.
206

207
  @type master_name: str
208
  @param master_name: Name of the master node
209

210
  """
211
  # Generate cluster secrets
212
  GenerateClusterCrypto(True, False, False, False, False)
213

    
214
  result = utils.RunCmd([pathutils.DAEMON_UTIL, "start", constants.NODED])
215
  if result.failed:
216
    raise errors.OpExecError("Could not start the node daemon, command %s"
217
                             " had exitcode %s and error %s" %
218
                             (result.cmd, result.exit_code, result.output))
219

    
220
  _WaitForNodeDaemon(master_name)
221

    
222

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

226
  """
227
  def _CheckNodeDaemon():
228
    # Pylint bug <http://www.logilab.org/ticket/35642>
229
    # pylint: disable=E1101
230
    result = rpc.BootstrapRunner().call_version([node_name])[node_name]
231
    if result.fail_msg:
232
      raise utils.RetryAgain()
233

    
234
  try:
235
    utils.Retry(_CheckNodeDaemon, 1.0, _DAEMON_READY_TIMEOUT)
236
  except utils.RetryTimeout:
237
    raise errors.OpExecError("Node daemon on %s didn't answer queries within"
238
                             " %s seconds" % (node_name, _DAEMON_READY_TIMEOUT))
239

    
240

    
241
def _WaitForMasterDaemon():
242
  """Wait for master daemon to become responsive.
243

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

    
252
    logging.debug("Received cluster name %s from master", cluster_name)
253

    
254
  try:
255
    utils.Retry(_CheckMasterDaemon, 1.0, _DAEMON_READY_TIMEOUT)
256
  except utils.RetryTimeout:
257
    raise errors.OpExecError("Master daemon didn't answer queries within"
258
                             " %s seconds" % _DAEMON_READY_TIMEOUT)
259

    
260

    
261
def _WaitForSshDaemon(hostname, port, family):
262
  """Wait for SSH daemon to become responsive.
263

264
  """
265
  hostip = netutils.GetHostname(name=hostname, family=family).ip
266

    
267
  def _CheckSshDaemon():
268
    if netutils.TcpPing(hostip, port, timeout=1.0, live_port_needed=True):
269
      logging.debug("SSH daemon on %s:%s (IP address %s) has become"
270
                    " responsive", hostname, port, hostip)
271
    else:
272
      raise utils.RetryAgain()
273

    
274
  try:
275
    utils.Retry(_CheckSshDaemon, 1.0, _DAEMON_READY_TIMEOUT)
276
  except utils.RetryTimeout:
277
    raise errors.OpExecError("SSH daemon on %s:%s (IP address %s) didn't"
278
                             " become responsive within %s seconds" %
279
                             (hostname, port, hostip, _DAEMON_READY_TIMEOUT))
280

    
281

    
282
def RunNodeSetupCmd(cluster_name, node, basecmd, debug, verbose,
283
                    use_cluster_key, ask_key, strict_host_check,
284
                    port, data):
285
  """Runs a command to configure something on a remote machine.
286

287
  @type cluster_name: string
288
  @param cluster_name: Cluster name
289
  @type node: string
290
  @param node: Node name
291
  @type basecmd: string
292
  @param basecmd: Base command (path on the remote machine)
293
  @type debug: bool
294
  @param debug: Enable debug output
295
  @type verbose: bool
296
  @param verbose: Enable verbose output
297
  @type use_cluster_key: bool
298
  @param use_cluster_key: See L{ssh.SshRunner.BuildCmd}
299
  @type ask_key: bool
300
  @param ask_key: See L{ssh.SshRunner.BuildCmd}
301
  @type strict_host_check: bool
302
  @param strict_host_check: See L{ssh.SshRunner.BuildCmd}
303
  @type port: int
304
  @param port: The SSH port of the remote machine or None for the default
305
  @param data: JSON-serializable input data for script (passed to stdin)
306

307
  """
308
  cmd = [basecmd]
309

    
310
  # Pass --debug/--verbose to the external script if set on our invocation
311
  if debug:
312
    cmd.append("--debug")
313

    
314
  if verbose:
315
    cmd.append("--verbose")
316

    
317
  if port is None:
318
    port = netutils.GetDaemonPort(constants.SSH)
319

    
320
  family = ssconf.SimpleStore().GetPrimaryIPFamily()
321
  srun = ssh.SshRunner(cluster_name,
322
                       ipv6=(family == netutils.IP6Address.family))
323
  scmd = srun.BuildCmd(node, constants.SSH_LOGIN_USER,
324
                       utils.ShellQuoteArgs(cmd),
325
                       batch=False, ask_key=ask_key, quiet=False,
326
                       strict_host_check=strict_host_check,
327
                       use_cluster_key=use_cluster_key,
328
                       port=port)
329

    
330
  tempfh = tempfile.TemporaryFile()
331
  try:
332
    tempfh.write(serializer.DumpJson(data))
333
    tempfh.seek(0)
334

    
335
    result = utils.RunCmd(scmd, interactive=True, input_fd=tempfh)
336
  finally:
337
    tempfh.close()
338

    
339
  if result.failed:
340
    raise errors.OpExecError("Command '%s' failed: %s" %
341
                             (result.cmd, result.fail_reason))
342

    
343
  _WaitForSshDaemon(node, port, family)
344

    
345

    
346
def _InitFileStorageDir(file_storage_dir):
347
  """Initialize if needed the file storage.
348

349
  @param file_storage_dir: the user-supplied value
350
  @return: either empty string (if file storage was disabled at build
351
      time) or the normalized path to the storage directory
352

353
  """
354
  file_storage_dir = os.path.normpath(file_storage_dir)
355

    
356
  if not os.path.isabs(file_storage_dir):
357
    raise errors.OpPrereqError("File storage directory '%s' is not an absolute"
358
                               " path" % file_storage_dir, errors.ECODE_INVAL)
359

    
360
  if not os.path.exists(file_storage_dir):
361
    try:
362
      os.makedirs(file_storage_dir, 0750)
363
    except OSError, err:
364
      raise errors.OpPrereqError("Cannot create file storage directory"
365
                                 " '%s': %s" % (file_storage_dir, err),
366
                                 errors.ECODE_ENVIRON)
367

    
368
  if not os.path.isdir(file_storage_dir):
369
    raise errors.OpPrereqError("The file storage directory '%s' is not"
370
                               " a directory." % file_storage_dir,
371
                               errors.ECODE_ENVIRON)
372

    
373
  return file_storage_dir
374

    
375

    
376
def _PrepareFileBasedStorage(
377
    enabled_disk_templates, file_storage_dir,
378
    default_dir, file_disk_template,
379
    init_fn=_InitFileStorageDir, acceptance_fn=None):
380
  """Checks if a file-base storage type is enabled and inits the dir.
381

382
  @type enabled_disk_templates: list of string
383
  @param enabled_disk_templates: list of enabled disk templates
384
  @type file_storage_dir: string
385
  @param file_storage_dir: the file storage directory
386
  @type default_dir: string
387
  @param default_dir: default file storage directory when C{file_storage_dir}
388
      is 'None'
389
  @type file_disk_template: string
390
  @param file_disk_template: a disk template whose storage type is 'ST_FILE' or
391
      'ST_SHARED_FILE'
392
  @rtype: string
393
  @returns: the name of the actual file storage directory
394

395
  """
396
  assert (file_disk_template in utils.storage.GetDiskTemplatesOfStorageTypes(
397
            constants.ST_FILE, constants.ST_SHARED_FILE
398
         ))
399

    
400
  if file_storage_dir is None:
401
    file_storage_dir = default_dir
402
  if not acceptance_fn:
403
    acceptance_fn = \
404
        lambda path: filestorage.CheckFileStoragePathAcceptance(
405
            path, exact_match_ok=True)
406

    
407
  cluster.CheckFileStoragePathVsEnabledDiskTemplates(
408
      logging.warning, file_storage_dir, enabled_disk_templates)
409

    
410
  file_storage_enabled = file_disk_template in enabled_disk_templates
411
  if file_storage_enabled:
412
    try:
413
      acceptance_fn(file_storage_dir)
414
    except errors.FileStoragePathError as e:
415
      raise errors.OpPrereqError(str(e))
416
    result_file_storage_dir = init_fn(file_storage_dir)
417
  else:
418
    result_file_storage_dir = file_storage_dir
419
  return result_file_storage_dir
420

    
421

    
422
def _PrepareFileStorage(
423
    enabled_disk_templates, file_storage_dir, init_fn=_InitFileStorageDir,
424
    acceptance_fn=None):
425
  """Checks if file storage is enabled and inits the dir.
426

427
  @see: C{_PrepareFileBasedStorage}
428

429
  """
430
  return _PrepareFileBasedStorage(
431
      enabled_disk_templates, file_storage_dir,
432
      pathutils.DEFAULT_FILE_STORAGE_DIR, constants.DT_FILE,
433
      init_fn=init_fn, acceptance_fn=acceptance_fn)
434

    
435

    
436
def _PrepareSharedFileStorage(
437
    enabled_disk_templates, file_storage_dir, init_fn=_InitFileStorageDir,
438
    acceptance_fn=None):
439
  """Checks if shared file storage is enabled and inits the dir.
440

441
  @see: C{_PrepareFileBasedStorage}
442

443
  """
444
  return _PrepareFileBasedStorage(
445
      enabled_disk_templates, file_storage_dir,
446
      pathutils.DEFAULT_SHARED_FILE_STORAGE_DIR, constants.DT_SHARED_FILE,
447
      init_fn=init_fn, acceptance_fn=acceptance_fn)
448

    
449

    
450
def _PrepareGlusterStorage(
451
    enabled_disk_templates, file_storage_dir, init_fn=_InitFileStorageDir,
452
    acceptance_fn=None):
453
  """Checks if gluster storage is enabled and inits the dir.
454

455
  @see: C{_PrepareFileBasedStorage}
456

457
  """
458
  return _PrepareFileBasedStorage(
459
      enabled_disk_templates, file_storage_dir,
460
      pathutils.DEFAULT_GLUSTER_STORAGE_DIR, constants.DT_GLUSTER,
461
      init_fn=init_fn, acceptance_fn=acceptance_fn)
462

    
463

    
464
def _InitCheckEnabledDiskTemplates(enabled_disk_templates):
465
  """Checks the sanity of the enabled disk templates.
466

467
  """
468
  if not enabled_disk_templates:
469
    raise errors.OpPrereqError("Enabled disk templates list must contain at"
470
                               " least one member", errors.ECODE_INVAL)
471
  invalid_disk_templates = \
472
    set(enabled_disk_templates) - constants.DISK_TEMPLATES
473
  if invalid_disk_templates:
474
    raise errors.OpPrereqError("Enabled disk templates list contains invalid"
475
                               " entries: %s" % invalid_disk_templates,
476
                               errors.ECODE_INVAL)
477

    
478

    
479
def _RestrictIpolicyToEnabledDiskTemplates(ipolicy, enabled_disk_templates):
480
  """Restricts the ipolicy's disk templates to the enabled ones.
481

482
  This function clears the ipolicy's list of allowed disk templates from the
483
  ones that are not enabled by the cluster.
484

485
  @type ipolicy: dict
486
  @param ipolicy: the instance policy
487
  @type enabled_disk_templates: list of string
488
  @param enabled_disk_templates: the list of cluster-wide enabled disk
489
    templates
490

491
  """
492
  assert constants.IPOLICY_DTS in ipolicy
493
  allowed_disk_templates = ipolicy[constants.IPOLICY_DTS]
494
  restricted_disk_templates = list(set(allowed_disk_templates)
495
                                   .intersection(set(enabled_disk_templates)))
496
  ipolicy[constants.IPOLICY_DTS] = restricted_disk_templates
497

    
498

    
499
def _InitCheckDrbdHelper(drbd_helper, drbd_enabled):
500
  """Checks the DRBD usermode helper.
501

502
  @type drbd_helper: string
503
  @param drbd_helper: name of the DRBD usermode helper that the system should
504
    use
505

506
  """
507
  if not drbd_enabled:
508
    return
509

    
510
  if drbd_helper is not None:
511
    try:
512
      curr_helper = drbd.DRBD8.GetUsermodeHelper()
513
    except errors.BlockDeviceError, err:
514
      raise errors.OpPrereqError("Error while checking drbd helper"
515
                                 " (disable drbd with --enabled-disk-templates"
516
                                 " if you are not using drbd): %s" % str(err),
517
                                 errors.ECODE_ENVIRON)
518
    if drbd_helper != curr_helper:
519
      raise errors.OpPrereqError("Error: requiring %s as drbd helper but %s"
520
                                 " is the current helper" % (drbd_helper,
521
                                                             curr_helper),
522
                                 errors.ECODE_INVAL)
523

    
524

    
525
def InitCluster(cluster_name, mac_prefix, # pylint: disable=R0913, R0914
526
                master_netmask, master_netdev, file_storage_dir,
527
                shared_file_storage_dir, gluster_storage_dir,
528
                candidate_pool_size, secondary_ip=None,
529
                vg_name=None, beparams=None, nicparams=None, ndparams=None,
530
                hvparams=None, diskparams=None, enabled_hypervisors=None,
531
                modify_etc_hosts=True, modify_ssh_setup=True,
532
                maintain_node_health=False, drbd_helper=None, uid_pool=None,
533
                default_iallocator=None, default_iallocator_params=None,
534
                primary_ip_version=None, ipolicy=None,
535
                prealloc_wipe_disks=False, use_external_mip_script=False,
536
                hv_state=None, disk_state=None, enabled_disk_templates=None):
537
  """Initialise the cluster.
538

539
  @type candidate_pool_size: int
540
  @param candidate_pool_size: master candidate pool size
541
  @type enabled_disk_templates: list of string
542
  @param enabled_disk_templates: list of disk_templates to be used in this
543
    cluster
544

545
  """
546
  # TODO: complete the docstring
547
  if config.ConfigWriter.IsCluster():
548
    raise errors.OpPrereqError("Cluster is already initialised",
549
                               errors.ECODE_STATE)
550

    
551
  if not enabled_hypervisors:
552
    raise errors.OpPrereqError("Enabled hypervisors list must contain at"
553
                               " least one member", errors.ECODE_INVAL)
554
  invalid_hvs = set(enabled_hypervisors) - constants.HYPER_TYPES
555
  if invalid_hvs:
556
    raise errors.OpPrereqError("Enabled hypervisors contains invalid"
557
                               " entries: %s" % invalid_hvs,
558
                               errors.ECODE_INVAL)
559

    
560
  _InitCheckEnabledDiskTemplates(enabled_disk_templates)
561

    
562
  try:
563
    ipcls = netutils.IPAddress.GetClassFromIpVersion(primary_ip_version)
564
  except errors.ProgrammerError:
565
    raise errors.OpPrereqError("Invalid primary ip version: %d." %
566
                               primary_ip_version, errors.ECODE_INVAL)
567

    
568
  hostname = netutils.GetHostname(family=ipcls.family)
569
  if not ipcls.IsValid(hostname.ip):
570
    raise errors.OpPrereqError("This host's IP (%s) is not a valid IPv%d"
571
                               " address." % (hostname.ip, primary_ip_version),
572
                               errors.ECODE_INVAL)
573

    
574
  if ipcls.IsLoopback(hostname.ip):
575
    raise errors.OpPrereqError("This host's IP (%s) resolves to a loopback"
576
                               " address. Please fix DNS or %s." %
577
                               (hostname.ip, pathutils.ETC_HOSTS),
578
                               errors.ECODE_ENVIRON)
579

    
580
  if not ipcls.Own(hostname.ip):
581
    raise errors.OpPrereqError("Inconsistency: this host's name resolves"
582
                               " to %s,\nbut this ip address does not"
583
                               " belong to this host" %
584
                               hostname.ip, errors.ECODE_ENVIRON)
585

    
586
  clustername = netutils.GetHostname(name=cluster_name, family=ipcls.family)
587

    
588
  if netutils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT, timeout=5):
589
    raise errors.OpPrereqError("Cluster IP already active",
590
                               errors.ECODE_NOTUNIQUE)
591

    
592
  if not secondary_ip:
593
    if primary_ip_version == constants.IP6_VERSION:
594
      raise errors.OpPrereqError("When using a IPv6 primary address, a valid"
595
                                 " IPv4 address must be given as secondary",
596
                                 errors.ECODE_INVAL)
597
    secondary_ip = hostname.ip
598

    
599
  if not netutils.IP4Address.IsValid(secondary_ip):
600
    raise errors.OpPrereqError("Secondary IP address (%s) has to be a valid"
601
                               " IPv4 address." % secondary_ip,
602
                               errors.ECODE_INVAL)
603

    
604
  if not netutils.IP4Address.Own(secondary_ip):
605
    raise errors.OpPrereqError("You gave %s as secondary IP,"
606
                               " but it does not belong to this host." %
607
                               secondary_ip, errors.ECODE_ENVIRON)
608

    
609
  if master_netmask is not None:
610
    if not ipcls.ValidateNetmask(master_netmask):
611
      raise errors.OpPrereqError("CIDR netmask (%s) not valid for IPv%s " %
612
                                  (master_netmask, primary_ip_version),
613
                                 errors.ECODE_INVAL)
614
  else:
615
    master_netmask = ipcls.iplen
616

    
617
  if vg_name:
618
    # Check if volume group is valid
619
    vgstatus = utils.CheckVolumeGroupSize(utils.ListVolumeGroups(), vg_name,
620
                                          constants.MIN_VG_SIZE)
621
    if vgstatus:
622
      raise errors.OpPrereqError("Error: %s" % vgstatus, errors.ECODE_INVAL)
623

    
624
  drbd_enabled = constants.DT_DRBD8 in enabled_disk_templates
625
  _InitCheckDrbdHelper(drbd_helper, drbd_enabled)
626

    
627
  logging.debug("Stopping daemons (if any are running)")
628
  result = utils.RunCmd([pathutils.DAEMON_UTIL, "stop-all"])
629
  if result.failed:
630
    raise errors.OpExecError("Could not stop daemons, command %s"
631
                             " had exitcode %s and error '%s'" %
632
                             (result.cmd, result.exit_code, result.output))
633

    
634
  file_storage_dir = _PrepareFileStorage(enabled_disk_templates,
635
                                         file_storage_dir)
636
  shared_file_storage_dir = _PrepareSharedFileStorage(enabled_disk_templates,
637
                                                      shared_file_storage_dir)
638

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

    
643
  if not nicparams.get('mode', None) == constants.NIC_MODE_OVS:
644
    # Do not do this check if mode=openvswitch, since the openvswitch is not
645
    # created yet
646
    result = utils.RunCmd(["ip", "link", "show", "dev", master_netdev])
647
    if result.failed:
648
      raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %
649
                                 (master_netdev,
650
                                  result.output.strip()), errors.ECODE_INVAL)
651

    
652
  dirs = [(pathutils.RUN_DIR, constants.RUN_DIRS_MODE)]
653
  utils.EnsureDirs(dirs)
654

    
655
  objects.UpgradeBeParams(beparams)
656
  utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
657
  utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
658

    
659
  objects.NIC.CheckParameterSyntax(nicparams)
660

    
661
  full_ipolicy = objects.FillIPolicy(constants.IPOLICY_DEFAULTS, ipolicy)
662
  _RestrictIpolicyToEnabledDiskTemplates(full_ipolicy, enabled_disk_templates)
663

    
664
  if ndparams is not None:
665
    utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)
666
  else:
667
    ndparams = dict(constants.NDC_DEFAULTS)
668

    
669
  # This is ugly, as we modify the dict itself
670
  # FIXME: Make utils.ForceDictType pure functional or write a wrapper
671
  # around it
672
  if hv_state:
673
    for hvname, hvs_data in hv_state.items():
674
      utils.ForceDictType(hvs_data, constants.HVSTS_PARAMETER_TYPES)
675
      hv_state[hvname] = objects.Cluster.SimpleFillHvState(hvs_data)
676
  else:
677
    hv_state = dict((hvname, constants.HVST_DEFAULTS)
678
                    for hvname in enabled_hypervisors)
679

    
680
  # FIXME: disk_state has no default values yet
681
  if disk_state:
682
    for storage, ds_data in disk_state.items():
683
      if storage not in constants.DS_VALID_TYPES:
684
        raise errors.OpPrereqError("Invalid storage type in disk state: %s" %
685
                                   storage, errors.ECODE_INVAL)
686
      for ds_name, state in ds_data.items():
687
        utils.ForceDictType(state, constants.DSS_PARAMETER_TYPES)
688
        ds_data[ds_name] = objects.Cluster.SimpleFillDiskState(state)
689

    
690
  # hvparams is a mapping of hypervisor->hvparams dict
691
  for hv_name, hv_params in hvparams.iteritems():
692
    utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
693
    hv_class = hypervisor.GetHypervisor(hv_name)
694
    hv_class.CheckParameterSyntax(hv_params)
695

    
696
  # diskparams is a mapping of disk-template->diskparams dict
697
  for template, dt_params in diskparams.items():
698
    param_keys = set(dt_params.keys())
699
    default_param_keys = set(constants.DISK_DT_DEFAULTS[template].keys())
700
    if not (param_keys <= default_param_keys):
701
      unknown_params = param_keys - default_param_keys
702
      raise errors.OpPrereqError("Invalid parameters for disk template %s:"
703
                                 " %s" % (template,
704
                                          utils.CommaJoin(unknown_params)),
705
                                 errors.ECODE_INVAL)
706
    utils.ForceDictType(dt_params, constants.DISK_DT_TYPES)
707
    if template == constants.DT_DRBD8 and vg_name is not None:
708
      # The default METAVG value is equal to the VG name set at init time,
709
      # if provided
710
      dt_params[constants.DRBD_DEFAULT_METAVG] = vg_name
711

    
712
  try:
713
    utils.VerifyDictOptions(diskparams, constants.DISK_DT_DEFAULTS)
714
  except errors.OpPrereqError, err:
715
    raise errors.OpPrereqError("While verify diskparam options: %s" % err,
716
                               errors.ECODE_INVAL)
717

    
718
  # set up ssh config and /etc/hosts
719
  rsa_sshkey = ""
720
  dsa_sshkey = ""
721
  if os.path.isfile(pathutils.SSH_HOST_RSA_PUB):
722
    sshline = utils.ReadFile(pathutils.SSH_HOST_RSA_PUB)
723
    rsa_sshkey = sshline.split(" ")[1]
724
  if os.path.isfile(pathutils.SSH_HOST_DSA_PUB):
725
    sshline = utils.ReadFile(pathutils.SSH_HOST_DSA_PUB)
726
    dsa_sshkey = sshline.split(" ")[1]
727
  if not rsa_sshkey and not dsa_sshkey:
728
    raise errors.OpPrereqError("Failed to find SSH public keys",
729
                               errors.ECODE_ENVIRON)
730

    
731
  if modify_etc_hosts:
732
    utils.AddHostToEtcHosts(hostname.name, hostname.ip)
733

    
734
  if modify_ssh_setup:
735
    _InitSSHSetup()
736

    
737
  if default_iallocator is not None:
738
    alloc_script = utils.FindFile(default_iallocator,
739
                                  constants.IALLOCATOR_SEARCH_PATH,
740
                                  os.path.isfile)
741
    if alloc_script is None:
742
      raise errors.OpPrereqError("Invalid default iallocator script '%s'"
743
                                 " specified" % default_iallocator,
744
                                 errors.ECODE_INVAL)
745
  elif constants.HTOOLS:
746
    # htools was enabled at build-time, we default to it
747
    if utils.FindFile(constants.IALLOC_HAIL,
748
                      constants.IALLOCATOR_SEARCH_PATH,
749
                      os.path.isfile):
750
      default_iallocator = constants.IALLOC_HAIL
751

    
752
  candidate_certs = {}
753

    
754
  now = time.time()
755

    
756
  # init of cluster config file
757
  cluster_config = objects.Cluster(
758
    serial_no=1,
759
    rsahostkeypub=rsa_sshkey,
760
    dsahostkeypub=dsa_sshkey,
761
    highest_used_port=(constants.FIRST_DRBD_PORT - 1),
762
    mac_prefix=mac_prefix,
763
    volume_group_name=vg_name,
764
    tcpudp_port_pool=set(),
765
    master_ip=clustername.ip,
766
    master_netmask=master_netmask,
767
    master_netdev=master_netdev,
768
    cluster_name=clustername.name,
769
    file_storage_dir=file_storage_dir,
770
    shared_file_storage_dir=shared_file_storage_dir,
771
    gluster_storage_dir=gluster_storage_dir,
772
    enabled_hypervisors=enabled_hypervisors,
773
    beparams={constants.PP_DEFAULT: beparams},
774
    nicparams={constants.PP_DEFAULT: nicparams},
775
    ndparams=ndparams,
776
    hvparams=hvparams,
777
    diskparams=diskparams,
778
    candidate_pool_size=candidate_pool_size,
779
    modify_etc_hosts=modify_etc_hosts,
780
    modify_ssh_setup=modify_ssh_setup,
781
    uid_pool=uid_pool,
782
    ctime=now,
783
    mtime=now,
784
    maintain_node_health=maintain_node_health,
785
    drbd_usermode_helper=drbd_helper,
786
    default_iallocator=default_iallocator,
787
    default_iallocator_params=default_iallocator_params,
788
    primary_ip_family=ipcls.family,
789
    prealloc_wipe_disks=prealloc_wipe_disks,
790
    use_external_mip_script=use_external_mip_script,
791
    ipolicy=full_ipolicy,
792
    hv_state_static=hv_state,
793
    disk_state_static=disk_state,
794
    enabled_disk_templates=enabled_disk_templates,
795
    candidate_certs=candidate_certs,
796
    )
797
  master_node_config = objects.Node(name=hostname.name,
798
                                    primary_ip=hostname.ip,
799
                                    secondary_ip=secondary_ip,
800
                                    serial_no=1,
801
                                    master_candidate=True,
802
                                    offline=False, drained=False,
803
                                    ctime=now, mtime=now,
804
                                    )
805
  InitConfig(constants.CONFIG_VERSION, cluster_config, master_node_config)
806
  cfg = config.ConfigWriter(offline=True)
807
  ssh.WriteKnownHostsFile(cfg, pathutils.SSH_KNOWN_HOSTS_FILE)
808
  cfg.Update(cfg.GetClusterInfo(), logging.error)
809
  ssconf.WriteSsconfFiles(cfg.GetSsconfValues())
810

    
811
  # set up the inter-node password and certificate
812
  _InitGanetiServerSetup(hostname.name)
813

    
814
  logging.debug("Starting daemons")
815
  result = utils.RunCmd([pathutils.DAEMON_UTIL, "start-all"])
816
  if result.failed:
817
    raise errors.OpExecError("Could not start daemons, command %s"
818
                             " had exitcode %s and error %s" %
819
                             (result.cmd, result.exit_code, result.output))
820

    
821
  _WaitForMasterDaemon()
822

    
823

    
824
def InitConfig(version, cluster_config, master_node_config,
825
               cfg_file=pathutils.CLUSTER_CONF_FILE):
826
  """Create the initial cluster configuration.
827

828
  It will contain the current node, which will also be the master
829
  node, and no instances.
830

831
  @type version: int
832
  @param version: configuration version
833
  @type cluster_config: L{objects.Cluster}
834
  @param cluster_config: cluster configuration
835
  @type master_node_config: L{objects.Node}
836
  @param master_node_config: master node configuration
837
  @type cfg_file: string
838
  @param cfg_file: configuration file path
839

840
  """
841
  uuid_generator = config.TemporaryReservationManager()
842
  cluster_config.uuid = uuid_generator.Generate([], utils.NewUUID,
843
                                                _INITCONF_ECID)
844
  master_node_config.uuid = uuid_generator.Generate([], utils.NewUUID,
845
                                                    _INITCONF_ECID)
846
  cluster_config.master_node = master_node_config.uuid
847
  nodes = {
848
    master_node_config.uuid: master_node_config,
849
    }
850
  default_nodegroup = objects.NodeGroup(
851
    uuid=uuid_generator.Generate([], utils.NewUUID, _INITCONF_ECID),
852
    name=constants.INITIAL_NODE_GROUP_NAME,
853
    members=[master_node_config.uuid],
854
    diskparams={},
855
    )
856
  nodegroups = {
857
    default_nodegroup.uuid: default_nodegroup,
858
    }
859
  now = time.time()
860
  config_data = objects.ConfigData(version=version,
861
                                   cluster=cluster_config,
862
                                   nodegroups=nodegroups,
863
                                   nodes=nodes,
864
                                   instances={},
865
                                   networks={},
866
                                   serial_no=1,
867
                                   ctime=now, mtime=now)
868
  utils.WriteFile(cfg_file,
869
                  data=serializer.Dump(config_data.ToDict()),
870
                  mode=0600)
871

    
872

    
873
def FinalizeClusterDestroy(master_uuid):
874
  """Execute the last steps of cluster destroy
875

876
  This function shuts down all the daemons, completing the destroy
877
  begun in cmdlib.LUDestroyOpcode.
878

879
  """
880
  cfg = config.ConfigWriter()
881
  modify_ssh_setup = cfg.GetClusterInfo().modify_ssh_setup
882
  runner = rpc.BootstrapRunner()
883

    
884
  master_name = cfg.GetNodeName(master_uuid)
885

    
886
  master_params = cfg.GetMasterNetworkParameters()
887
  master_params.uuid = master_uuid
888
  ems = cfg.GetUseExternalMipScript()
889
  result = runner.call_node_deactivate_master_ip(master_name, master_params,
890
                                                 ems)
891

    
892
  msg = result.fail_msg
893
  if msg:
894
    logging.warning("Could not disable the master IP: %s", msg)
895

    
896
  result = runner.call_node_stop_master(master_name)
897
  msg = result.fail_msg
898
  if msg:
899
    logging.warning("Could not disable the master role: %s", msg)
900

    
901
  result = runner.call_node_leave_cluster(master_name, modify_ssh_setup)
902
  msg = result.fail_msg
903
  if msg:
904
    logging.warning("Could not shutdown the node daemon and cleanup"
905
                    " the node: %s", msg)
906

    
907

    
908
def SetupNodeDaemon(opts, cluster_name, node, ssh_port):
909
  """Add a node to the cluster.
910

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

915
  @param cluster_name: the cluster name
916
  @param node: the name of the new node
917
  @param ssh_port: the SSH port of the new node
918

919
  """
920
  data = {
921
    constants.NDS_CLUSTER_NAME: cluster_name,
922
    constants.NDS_NODE_DAEMON_CERTIFICATE:
923
      utils.ReadFile(pathutils.NODED_CERT_FILE),
924
    constants.NDS_SSCONF: ssconf.SimpleStore().ReadAll(),
925
    constants.NDS_START_NODE_DAEMON: True,
926
    }
927

    
928
  RunNodeSetupCmd(cluster_name, node, pathutils.NODE_DAEMON_SETUP,
929
                  opts.debug, opts.verbose,
930
                  True, opts.ssh_key_check, opts.ssh_key_check,
931
                  ssh_port, data)
932

    
933
  _WaitForNodeDaemon(node)
934

    
935

    
936
def MasterFailover(no_voting=False):
937
  """Failover the master node.
938

939
  This checks that we are not already the master, and will cause the
940
  current master to cease being master, and the non-master to become
941
  new master.
942

943
  @type no_voting: boolean
944
  @param no_voting: force the operation without remote nodes agreement
945
                      (dangerous)
946

947
  """
948
  sstore = ssconf.SimpleStore()
949

    
950
  old_master, new_master = ssconf.GetMasterAndMyself(sstore)
951
  node_names = sstore.GetNodeList()
952
  mc_list = sstore.GetMasterCandidates()
953

    
954
  if old_master == new_master:
955
    raise errors.OpPrereqError("This commands must be run on the node"
956
                               " where you want the new master to be."
957
                               " %s is already the master" %
958
                               old_master, errors.ECODE_INVAL)
959

    
960
  if new_master not in mc_list:
961
    mc_no_master = [name for name in mc_list if name != old_master]
962
    raise errors.OpPrereqError("This node is not among the nodes marked"
963
                               " as master candidates. Only these nodes"
964
                               " can become masters. Current list of"
965
                               " master candidates is:\n"
966
                               "%s" % ("\n".join(mc_no_master)),
967
                               errors.ECODE_STATE)
968

    
969
  if not no_voting:
970
    vote_list = GatherMasterVotes(node_names)
971

    
972
    if vote_list:
973
      voted_master = vote_list[0][0]
974
      if voted_master is None:
975
        raise errors.OpPrereqError("Cluster is inconsistent, most nodes did"
976
                                   " not respond.", errors.ECODE_ENVIRON)
977
      elif voted_master != old_master:
978
        raise errors.OpPrereqError("I have a wrong configuration, I believe"
979
                                   " the master is %s but the other nodes"
980
                                   " voted %s. Please resync the configuration"
981
                                   " of this node." %
982
                                   (old_master, voted_master),
983
                                   errors.ECODE_STATE)
984
  # end checks
985

    
986
  rcode = 0
987

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

    
990
  try:
991
    # instantiate a real config writer, as we now know we have the
992
    # configuration data
993
    cfg = config.ConfigWriter(accept_foreign=True)
994

    
995
    old_master_node = cfg.GetNodeInfoByName(old_master)
996
    if old_master_node is None:
997
      raise errors.OpPrereqError("Could not find old master node '%s' in"
998
                                 " cluster configuration." % old_master,
999
                                 errors.ECODE_NOENT)
1000

    
1001
    cluster_info = cfg.GetClusterInfo()
1002
    new_master_node = cfg.GetNodeInfoByName(new_master)
1003
    if new_master_node is None:
1004
      raise errors.OpPrereqError("Could not find new master node '%s' in"
1005
                                 " cluster configuration." % new_master,
1006
                                 errors.ECODE_NOENT)
1007

    
1008
    cluster_info.master_node = new_master_node.uuid
1009
    # this will also regenerate the ssconf files, since we updated the
1010
    # cluster info
1011
    cfg.Update(cluster_info, logging.error)
1012
  except errors.ConfigurationError, err:
1013
    logging.error("Error while trying to set the new master: %s",
1014
                  str(err))
1015
    return 1
1016

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

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

    
1024
  runner = rpc.BootstrapRunner()
1025
  master_params = cfg.GetMasterNetworkParameters()
1026
  master_params.uuid = old_master_node.uuid
1027
  ems = cfg.GetUseExternalMipScript()
1028
  result = runner.call_node_deactivate_master_ip(old_master,
1029
                                                 master_params, ems)
1030

    
1031
  msg = result.fail_msg
1032
  if msg:
1033
    logging.warning("Could not disable the master IP: %s", msg)
1034

    
1035
  result = runner.call_node_stop_master(old_master)
1036
  msg = result.fail_msg
1037
  if msg:
1038
    logging.error("Could not disable the master role on the old master"
1039
                  " %s, please disable manually: %s", old_master, msg)
1040

    
1041
  logging.info("Checking master IP non-reachability...")
1042

    
1043
  master_ip = sstore.GetMasterIP()
1044
  total_timeout = 30
1045

    
1046
  # Here we have a phase where no master should be running
1047
  def _check_ip():
1048
    if netutils.TcpPing(master_ip, constants.DEFAULT_NODED_PORT):
1049
      raise utils.RetryAgain()
1050

    
1051
  try:
1052
    utils.Retry(_check_ip, (1, 1.5, 5), total_timeout)
1053
  except utils.RetryTimeout:
1054
    logging.warning("The master IP is still reachable after %s seconds,"
1055
                    " continuing but activating the master on the current"
1056
                    " node will probably fail", total_timeout)
1057

    
1058
  if jstore.CheckDrainFlag():
1059
    logging.info("Undraining job queue")
1060
    jstore.SetDrainFlag(False)
1061

    
1062
  logging.info("Starting the master daemons on the new master")
1063

    
1064
  result = rpc.BootstrapRunner().call_node_start_master_daemons(new_master,
1065
                                                                no_voting)
1066
  msg = result.fail_msg
1067
  if msg:
1068
    logging.error("Could not start the master role on the new master"
1069
                  " %s, please check: %s", new_master, msg)
1070
    rcode = 1
1071

    
1072
  logging.info("Master failed over from %s to %s", old_master, new_master)
1073
  return rcode
1074

    
1075

    
1076
def GetMaster():
1077
  """Returns the current master node.
1078

1079
  This is a separate function in bootstrap since it's needed by
1080
  gnt-cluster, and instead of importing directly ssconf, it's better
1081
  to abstract it in bootstrap, where we do use ssconf in other
1082
  functions too.
1083

1084
  """
1085
  sstore = ssconf.SimpleStore()
1086

    
1087
  old_master, _ = ssconf.GetMasterAndMyself(sstore)
1088

    
1089
  return old_master
1090

    
1091

    
1092
def GatherMasterVotes(node_names):
1093
  """Check the agreement on who is the master.
1094

1095
  This function will return a list of (node, number of votes), ordered
1096
  by the number of votes. Errors will be denoted by the key 'None'.
1097

1098
  Note that the sum of votes is the number of nodes this machine
1099
  knows, whereas the number of entries in the list could be different
1100
  (if some nodes vote for another master).
1101

1102
  We remove ourselves from the list since we know that (bugs aside)
1103
  since we use the same source for configuration information for both
1104
  backend and boostrap, we'll always vote for ourselves.
1105

1106
  @type node_names: list
1107
  @param node_names: the list of nodes to query for master info; the current
1108
      node will be removed if it is in the list
1109
  @rtype: list
1110
  @return: list of (node, votes)
1111

1112
  """
1113
  myself = netutils.Hostname.GetSysName()
1114
  try:
1115
    node_names.remove(myself)
1116
  except ValueError:
1117
    pass
1118
  if not node_names:
1119
    # no nodes left (eventually after removing myself)
1120
    return []
1121
  results = rpc.BootstrapRunner().call_master_info(node_names)
1122
  if not isinstance(results, dict):
1123
    # this should not happen (unless internal error in rpc)
1124
    logging.critical("Can't complete rpc call, aborting master startup")
1125
    return [(None, len(node_names))]
1126
  votes = {}
1127
  for node_name in results:
1128
    nres = results[node_name]
1129
    data = nres.payload
1130
    msg = nres.fail_msg
1131
    fail = False
1132
    if msg:
1133
      logging.warning("Error contacting node %s: %s", node_name, msg)
1134
      fail = True
1135
    # for now we accept both length 3, 4 and 5 (data[3] is primary ip version
1136
    # and data[4] is the master netmask)
1137
    elif not isinstance(data, (tuple, list)) or len(data) < 3:
1138
      logging.warning("Invalid data received from node %s: %s",
1139
                      node_name, data)
1140
      fail = True
1141
    if fail:
1142
      if None not in votes:
1143
        votes[None] = 0
1144
      votes[None] += 1
1145
      continue
1146
    master_node = data[2]
1147
    if master_node not in votes:
1148
      votes[master_node] = 0
1149
    votes[master_node] += 1
1150

    
1151
  vote_list = [v for v in votes.items()]
1152
  # sort first on number of votes then on name, since we want None
1153
  # sorted later if we have the half of the nodes not responding, and
1154
  # half voting all for the same master
1155
  vote_list.sort(key=lambda x: (x[1], x[0]), reverse=True)
1156

    
1157
  return vote_list