Statistics
| Branch: | Tag: | Revision:

root / lib / bootstrap.py @ a33848a5

History | View | Annotate | Download (18.6 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007, 2008 Google Inc.
5
#
6
# This program is free software; you can redistribute it and/or modify
7
# it under the terms of the GNU General Public License as published by
8
# the Free Software Foundation; either version 2 of the License, or
9
# (at your option) any later version.
10
#
11
# This program is distributed in the hope that it will be useful, but
12
# WITHOUT ANY WARRANTY; without even the implied warranty of
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
# General Public License for more details.
15
#
16
# You should have received a copy of the GNU General Public License
17
# along with this program; if not, write to the Free Software
18
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19
# 02110-1301, USA.
20

    
21

    
22
"""Functions to bootstrap a new cluster.
23

24
"""
25

    
26
import os
27
import os.path
28
import re
29
import logging
30
import tempfile
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

    
43

    
44
def _InitSSHSetup():
45
  """Setup the SSH configuration for the cluster.
46

47
  This generates a dsa keypair for root, adds the pub key to the
48
  permitted hosts and adds the hostkey to its own known hosts.
49

50
  """
51
  priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)
52

    
53
  for name in priv_key, pub_key:
54
    if os.path.exists(name):
55
      utils.CreateBackup(name)
56
    utils.RemoveFile(name)
57

    
58
  result = utils.RunCmd(["ssh-keygen", "-t", "dsa",
59
                         "-f", priv_key,
60
                         "-q", "-N", ""])
61
  if result.failed:
62
    raise errors.OpExecError("Could not generate ssh keypair, error %s" %
63
                             result.output)
64

    
65
  f = open(pub_key, 'r')
66
  try:
67
    utils.AddAuthorizedKey(auth_keys, f.read(8192))
68
  finally:
69
    f.close()
70

    
71

    
72
def _GenerateSelfSignedSslCert(file_name, validity=(365 * 5)):
73
  """Generates a self-signed SSL certificate.
74

75
  @type file_name: str
76
  @param file_name: Path to output file
77
  @type validity: int
78
  @param validity: Validity for certificate in days
79

80
  """
81
  (fd, tmp_file_name) = tempfile.mkstemp(dir=os.path.dirname(file_name))
82
  try:
83
    try:
84
      # Set permissions before writing key
85
      os.chmod(tmp_file_name, 0600)
86

    
87
      result = utils.RunCmd(["openssl", "req", "-new", "-newkey", "rsa:1024",
88
                             "-days", str(validity), "-nodes", "-x509",
89
                             "-keyout", tmp_file_name, "-out", tmp_file_name,
90
                             "-batch"])
91
      if result.failed:
92
        raise errors.OpExecError("Could not generate SSL certificate, command"
93
                                 " %s had exitcode %s and error message %s" %
94
                                 (result.cmd, result.exit_code, result.output))
95

    
96
      # Make read-only
97
      os.chmod(tmp_file_name, 0400)
98

    
99
      os.rename(tmp_file_name, file_name)
100
    finally:
101
      utils.RemoveFile(tmp_file_name)
102
  finally:
103
    os.close(fd)
104

    
105

    
106
def _InitGanetiServerSetup():
107
  """Setup the necessary configuration for the initial node daemon.
108

109
  This creates the nodepass file containing the shared password for
110
  the cluster and also generates the SSL certificate.
111

112
  """
113
  _GenerateSelfSignedSslCert(constants.SSL_CERT_FILE)
114

    
115
  # Don't overwrite existing file
116
  if not os.path.exists(constants.RAPI_CERT_FILE):
117
    _GenerateSelfSignedSslCert(constants.RAPI_CERT_FILE)
118

    
119
  result = utils.RunCmd([constants.NODE_INITD_SCRIPT, "restart"])
120

    
121
  if result.failed:
122
    raise errors.OpExecError("Could not start the node daemon, command %s"
123
                             " had exitcode %s and error %s" %
124
                             (result.cmd, result.exit_code, result.output))
125

    
126

    
127
def InitCluster(cluster_name, mac_prefix,
128
                master_netdev, file_storage_dir, candidate_pool_size,
129
                secondary_ip=None, vg_name=None, beparams=None,
130
                nicparams=None, hvparams=None, enabled_hypervisors=None,
131
                default_hypervisor=None, modify_etc_hosts=True):
132
  """Initialise the cluster.
133

134
  @type candidate_pool_size: int
135
  @param candidate_pool_size: master candidate pool size
136

137
  """
138
  # TODO: complete the docstring
139
  if config.ConfigWriter.IsCluster():
140
    raise errors.OpPrereqError("Cluster is already initialised")
141

    
142
  hostname = utils.HostInfo()
143

    
144
  if hostname.ip.startswith("127."):
145
    raise errors.OpPrereqError("This host's IP resolves to the private"
146
                               " range (%s). Please fix DNS or %s." %
147
                               (hostname.ip, constants.ETC_HOSTS))
148

    
149
  if not utils.OwnIpAddress(hostname.ip):
150
    raise errors.OpPrereqError("Inconsistency: this host's name resolves"
151
                               " to %s,\nbut this ip address does not"
152
                               " belong to this host."
153
                               " Aborting." % hostname.ip)
154

    
155
  clustername = utils.HostInfo(cluster_name)
156

    
157
  if utils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT,
158
                   timeout=5):
159
    raise errors.OpPrereqError("Cluster IP already active. Aborting.")
160

    
161
  if secondary_ip:
162
    if not utils.IsValidIP(secondary_ip):
163
      raise errors.OpPrereqError("Invalid secondary ip given")
164
    if (secondary_ip != hostname.ip and
165
        not utils.OwnIpAddress(secondary_ip)):
166
      raise errors.OpPrereqError("You gave %s as secondary IP,"
167
                                 " but it does not belong to this host." %
168
                                 secondary_ip)
169
  else:
170
    secondary_ip = hostname.ip
171

    
172
  if vg_name is not None:
173
    # Check if volume group is valid
174
    vgstatus = utils.CheckVolumeGroupSize(utils.ListVolumeGroups(), vg_name,
175
                                          constants.MIN_VG_SIZE)
176
    if vgstatus:
177
      raise errors.OpPrereqError("Error: %s\nspecify --no-lvm-storage if"
178
                                 " you are not using lvm" % vgstatus)
179

    
180
  file_storage_dir = os.path.normpath(file_storage_dir)
181

    
182
  if not os.path.isabs(file_storage_dir):
183
    raise errors.OpPrereqError("The file storage directory you passed is"
184
                               " not an absolute path.")
185

    
186
  if not os.path.exists(file_storage_dir):
187
    try:
188
      os.makedirs(file_storage_dir, 0750)
189
    except OSError, err:
190
      raise errors.OpPrereqError("Cannot create file storage directory"
191
                                 " '%s': %s" %
192
                                 (file_storage_dir, err))
193

    
194
  if not os.path.isdir(file_storage_dir):
195
    raise errors.OpPrereqError("The file storage directory '%s' is not"
196
                               " a directory." % file_storage_dir)
197

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

    
201
  result = utils.RunCmd(["ip", "link", "show", "dev", master_netdev])
202
  if result.failed:
203
    raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %
204
                               (master_netdev,
205
                                result.output.strip()))
206

    
207
  if not (os.path.isfile(constants.NODE_INITD_SCRIPT) and
208
          os.access(constants.NODE_INITD_SCRIPT, os.X_OK)):
209
    raise errors.OpPrereqError("Init.d script '%s' missing or not"
210
                               " executable." % constants.NODE_INITD_SCRIPT)
211

    
212
  dirs = [(constants.RUN_GANETI_DIR, constants.RUN_DIRS_MODE)]
213
  utils.EnsureDirs(dirs)
214

    
215
  utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
216
  utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)
217
  objects.NIC.CheckParameterSyntax(nicparams)
218

    
219
  # hvparams is a mapping of hypervisor->hvparams dict
220
  for hv_name, hv_params in hvparams.iteritems():
221
    utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
222
    hv_class = hypervisor.GetHypervisor(hv_name)
223
    hv_class.CheckParameterSyntax(hv_params)
224

    
225
  # set up the inter-node password and certificate
226
  _InitGanetiServerSetup()
227

    
228
  # set up ssh config and /etc/hosts
229
  f = open(constants.SSH_HOST_RSA_PUB, 'r')
230
  try:
231
    sshline = f.read()
232
  finally:
233
    f.close()
234
  sshkey = sshline.split(" ")[1]
235

    
236
  if modify_etc_hosts:
237
    utils.AddHostToEtcHosts(hostname.name)
238

    
239
  _InitSSHSetup()
240

    
241
  # init of cluster config file
242
  cluster_config = objects.Cluster(
243
    serial_no=1,
244
    rsahostkeypub=sshkey,
245
    highest_used_port=(constants.FIRST_DRBD_PORT - 1),
246
    mac_prefix=mac_prefix,
247
    volume_group_name=vg_name,
248
    tcpudp_port_pool=set(),
249
    master_node=hostname.name,
250
    master_ip=clustername.ip,
251
    master_netdev=master_netdev,
252
    cluster_name=clustername.name,
253
    file_storage_dir=file_storage_dir,
254
    enabled_hypervisors=enabled_hypervisors,
255
    default_hypervisor=default_hypervisor,
256
    beparams={constants.PP_DEFAULT: beparams},
257
    nicparams={constants.PP_DEFAULT: nicparams},
258
    hvparams=hvparams,
259
    candidate_pool_size=candidate_pool_size,
260
    modify_etc_hosts=modify_etc_hosts,
261
    )
262
  master_node_config = objects.Node(name=hostname.name,
263
                                    primary_ip=hostname.ip,
264
                                    secondary_ip=secondary_ip,
265
                                    serial_no=1,
266
                                    master_candidate=True,
267
                                    offline=False, drained=False,
268
                                    )
269
  InitConfig(constants.CONFIG_VERSION, cluster_config, master_node_config)
270
  cfg = config.ConfigWriter()
271
  ssh.WriteKnownHostsFile(cfg, constants.SSH_KNOWN_HOSTS_FILE)
272
  cfg.Update(cfg.GetClusterInfo())
273

    
274
  # start the master ip
275
  # TODO: Review rpc call from bootstrap
276
  # TODO: Warn on failed start master
277
  rpc.RpcRunner.call_node_start_master(hostname.name, True, False)
278

    
279

    
280
def InitConfig(version, cluster_config, master_node_config,
281
               cfg_file=constants.CLUSTER_CONF_FILE):
282
  """Create the initial cluster configuration.
283

284
  It will contain the current node, which will also be the master
285
  node, and no instances.
286

287
  @type version: int
288
  @param version: configuration version
289
  @type cluster_config: L{objects.Cluster}
290
  @param cluster_config: cluster configuration
291
  @type master_node_config: L{objects.Node}
292
  @param master_node_config: master node configuration
293
  @type cfg_file: string
294
  @param cfg_file: configuration file path
295

296
  """
297
  nodes = {
298
    master_node_config.name: master_node_config,
299
    }
300

    
301
  config_data = objects.ConfigData(version=version,
302
                                   cluster=cluster_config,
303
                                   nodes=nodes,
304
                                   instances={},
305
                                   serial_no=1)
306
  utils.WriteFile(cfg_file,
307
                  data=serializer.Dump(config_data.ToDict()),
308
                  mode=0600)
309

    
310

    
311
def FinalizeClusterDestroy(master):
312
  """Execute the last steps of cluster destroy
313

314
  This function shuts down all the daemons, completing the destroy
315
  begun in cmdlib.LUDestroyOpcode.
316

317
  """
318
  result = rpc.RpcRunner.call_node_stop_master(master, True)
319
  msg = result.RemoteFailMsg()
320
  if msg:
321
    logging.warning("Could not disable the master role: %s" % msg)
322
  result = rpc.RpcRunner.call_node_leave_cluster(master)
323
  msg = result.RemoteFailMsg()
324
  if msg:
325
    logging.warning("Could not shutdown the node daemon and cleanup"
326
                    " the node: %s", msg)
327

    
328

    
329
def SetupNodeDaemon(cluster_name, node, ssh_key_check):
330
  """Add a node to the cluster.
331

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

336
  @param cluster_name: the cluster name
337
  @param node: the name of the new node
338
  @param ssh_key_check: whether to do a strict key check
339

340
  """
341
  sshrunner = ssh.SshRunner(cluster_name)
342

    
343
  noded_cert = utils.ReadFile(constants.SSL_CERT_FILE)
344
  rapi_cert = utils.ReadFile(constants.RAPI_CERT_FILE)
345

    
346
  # in the base64 pem encoding, neither '!' nor '.' are valid chars,
347
  # so we use this to detect an invalid certificate; as long as the
348
  # cert doesn't contain this, the here-document will be correctly
349
  # parsed by the shell sequence below
350
  if (re.search('^!EOF\.', noded_cert, re.MULTILINE) or
351
      re.search('^!EOF\.', rapi_cert, re.MULTILINE)):
352
    raise errors.OpExecError("invalid PEM encoding in the SSL certificate")
353

    
354
  if not noded_cert.endswith("\n"):
355
    noded_cert += "\n"
356
  if not rapi_cert.endswith("\n"):
357
    rapi_cert += "\n"
358

    
359
  # set up inter-node password and certificate and restarts the node daemon
360
  # and then connect with ssh to set password and start ganeti-noded
361
  # note that all the below variables are sanitized at this point,
362
  # either by being constants or by the checks above
363
  mycommand = ("umask 077 && "
364
               "cat > '%s' << '!EOF.' && \n"
365
               "%s!EOF.\n"
366
               "cat > '%s' << '!EOF.' && \n"
367
               "%s!EOF.\n"
368
               "chmod 0400 %s %s && "
369
               "%s restart" %
370
               (constants.SSL_CERT_FILE, noded_cert,
371
                constants.RAPI_CERT_FILE, rapi_cert,
372
                constants.SSL_CERT_FILE, constants.RAPI_CERT_FILE,
373
                constants.NODE_INITD_SCRIPT))
374

    
375
  result = sshrunner.Run(node, 'root', mycommand, batch=False,
376
                         ask_key=ssh_key_check,
377
                         use_cluster_key=False,
378
                         strict_host_check=ssh_key_check)
379
  if result.failed:
380
    raise errors.OpExecError("Remote command on node %s, error: %s,"
381
                             " output: %s" %
382
                             (node, result.fail_reason, result.output))
383

    
384

    
385
def MasterFailover(no_voting=False):
386
  """Failover the master node.
387

388
  This checks that we are not already the master, and will cause the
389
  current master to cease being master, and the non-master to become
390
  new master.
391

392
  @type no_voting: boolean
393
  @param no_voting: force the operation without remote nodes agreement
394
                      (dangerous)
395

396
  """
397
  sstore = ssconf.SimpleStore()
398

    
399
  old_master, new_master = ssconf.GetMasterAndMyself(sstore)
400
  node_list = sstore.GetNodeList()
401
  mc_list = sstore.GetMasterCandidates()
402

    
403
  if old_master == new_master:
404
    raise errors.OpPrereqError("This commands must be run on the node"
405
                               " where you want the new master to be."
406
                               " %s is already the master" %
407
                               old_master)
408

    
409
  if new_master not in mc_list:
410
    mc_no_master = [name for name in mc_list if name != old_master]
411
    raise errors.OpPrereqError("This node is not among the nodes marked"
412
                               " as master candidates. Only these nodes"
413
                               " can become masters. Current list of"
414
                               " master candidates is:\n"
415
                               "%s" % ('\n'.join(mc_no_master)))
416

    
417
  if not no_voting:
418
    vote_list = GatherMasterVotes(node_list)
419

    
420
    if vote_list:
421
      voted_master = vote_list[0][0]
422
      if voted_master is None:
423
        raise errors.OpPrereqError("Cluster is inconsistent, most nodes did"
424
                                   " not respond.")
425
      elif voted_master != old_master:
426
        raise errors.OpPrereqError("I have a wrong configuration, I believe"
427
                                   " the master is %s but the other nodes"
428
                                   " voted %s. Please resync the configuration"
429
                                   " of this node." %
430
                                   (old_master, voted_master))
431
  # end checks
432

    
433
  rcode = 0
434

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

    
437
  result = rpc.RpcRunner.call_node_stop_master(old_master, True)
438
  msg = result.RemoteFailMsg()
439
  if msg:
440
    logging.error("Could not disable the master role on the old master"
441
                 " %s, please disable manually: %s", old_master, msg)
442

    
443
  # Here we have a phase where no master should be running
444

    
445
  # instantiate a real config writer, as we now know we have the
446
  # configuration data
447
  cfg = config.ConfigWriter()
448

    
449
  cluster_info = cfg.GetClusterInfo()
450
  cluster_info.master_node = new_master
451
  # this will also regenerate the ssconf files, since we updated the
452
  # cluster info
453
  cfg.Update(cluster_info)
454

    
455
  result = rpc.RpcRunner.call_node_start_master(new_master, True, no_voting)
456
  msg = result.RemoteFailMsg()
457
  if msg:
458
    logging.error("Could not start the master role on the new master"
459
                  " %s, please check: %s", new_master, msg)
460
    rcode = 1
461

    
462
  return rcode
463

    
464

    
465
def GetMaster():
466
  """Returns the current master node.
467

468
  This is a separate function in bootstrap since it's needed by
469
  gnt-cluster, and instead of importing directly ssconf, it's better
470
  to abstract it in bootstrap, where we do use ssconf in other
471
  functions too.
472

473
  """
474
  sstore = ssconf.SimpleStore()
475

    
476
  old_master, _ = ssconf.GetMasterAndMyself(sstore)
477

    
478
  return old_master
479

    
480

    
481
def GatherMasterVotes(node_list):
482
  """Check the agreement on who is the master.
483

484
  This function will return a list of (node, number of votes), ordered
485
  by the number of votes. Errors will be denoted by the key 'None'.
486

487
  Note that the sum of votes is the number of nodes this machine
488
  knows, whereas the number of entries in the list could be different
489
  (if some nodes vote for another master).
490

491
  We remove ourselves from the list since we know that (bugs aside)
492
  since we use the same source for configuration information for both
493
  backend and boostrap, we'll always vote for ourselves.
494

495
  @type node_list: list
496
  @param node_list: the list of nodes to query for master info; the current
497
      node will be removed if it is in the list
498
  @rtype: list
499
  @return: list of (node, votes)
500

501
  """
502
  myself = utils.HostInfo().name
503
  try:
504
    node_list.remove(myself)
505
  except ValueError:
506
    pass
507
  if not node_list:
508
    # no nodes left (eventually after removing myself)
509
    return []
510
  results = rpc.RpcRunner.call_master_info(node_list)
511
  if not isinstance(results, dict):
512
    # this should not happen (unless internal error in rpc)
513
    logging.critical("Can't complete rpc call, aborting master startup")
514
    return [(None, len(node_list))]
515
  votes = {}
516
  for node in results:
517
    nres = results[node]
518
    data = nres.payload
519
    msg = nres.RemoteFailMsg()
520
    fail = False
521
    if msg:
522
      logging.warning("Error contacting node %s: %s", node, msg)
523
      fail = True
524
    elif not isinstance(data, (tuple, list)) or len(data) < 3:
525
      logging.warning("Invalid data received from node %s: %s", node, data)
526
      fail = True
527
    if fail:
528
      if None not in votes:
529
        votes[None] = 0
530
      votes[None] += 1
531
      continue
532
    master_node = data[2]
533
    if master_node not in votes:
534
      votes[master_node] = 0
535
    votes[master_node] += 1
536

    
537
  vote_list = [v for v in votes.items()]
538
  # sort first on number of votes then on name, since we want None
539
  # sorted later if we have the half of the nodes not responding, and
540
  # half voting all for the same master
541
  vote_list.sort(key=lambda x: (x[1], x[0]), reverse=True)
542

    
543
  return vote_list