Statistics
| Branch: | Tag: | Revision:

root / tools / cfgupgrade @ 2827d1ac

History | View | Annotate | Download (17 kB)

1
#!/usr/bin/python
2
#
3

    
4
# Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 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
"""Tool to upgrade the configuration file.
23

    
24
This code handles only the types supported by simplejson. As an
25
example, 'set' is a 'list'.
26

    
27
"""
28

    
29

    
30
import os
31
import os.path
32
import sys
33
import optparse
34
import logging
35
import time
36
from cStringIO import StringIO
37

    
38
from ganeti import constants
39
from ganeti import serializer
40
from ganeti import utils
41
from ganeti import cli
42
from ganeti import bootstrap
43
from ganeti import config
44
from ganeti import netutils
45
from ganeti import pathutils
46

    
47

    
48
options = None
49
args = None
50

    
51

    
52
#: Target major version we will upgrade to
53
TARGET_MAJOR = 2
54
#: Target minor version we will upgrade to
55
TARGET_MINOR = 7
56
#: Target major version for downgrade
57
DOWNGRADE_MAJOR = 2
58
#: Target minor version for downgrade
59
DOWNGRADE_MINOR = 7
60

    
61

    
62
class Error(Exception):
63
  """Generic exception"""
64
  pass
65

    
66

    
67
def SetupLogging():
68
  """Configures the logging module.
69

    
70
  """
71
  formatter = logging.Formatter("%(asctime)s: %(message)s")
72

    
73
  stderr_handler = logging.StreamHandler()
74
  stderr_handler.setFormatter(formatter)
75
  if options.debug:
76
    stderr_handler.setLevel(logging.NOTSET)
77
  elif options.verbose:
78
    stderr_handler.setLevel(logging.INFO)
79
  else:
80
    stderr_handler.setLevel(logging.WARNING)
81

    
82
  root_logger = logging.getLogger("")
83
  root_logger.setLevel(logging.NOTSET)
84
  root_logger.addHandler(stderr_handler)
85

    
86

    
87
def CheckHostname(path):
88
  """Ensures hostname matches ssconf value.
89

    
90
  @param path: Path to ssconf file
91

    
92
  """
93
  ssconf_master_node = utils.ReadOneLineFile(path)
94
  hostname = netutils.GetHostname().name
95

    
96
  if ssconf_master_node == hostname:
97
    return True
98

    
99
  logging.warning("Warning: ssconf says master node is '%s', but this"
100
                  " machine's name is '%s'; this tool must be run on"
101
                  " the master node", ssconf_master_node, hostname)
102
  return False
103

    
104

    
105
def _FillIPolicySpecs(default_ipolicy, ipolicy):
106
  if "minmax" in ipolicy:
107
    for (key, spec) in ipolicy["minmax"].items():
108
      for (par, val) in default_ipolicy["minmax"][key].items():
109
        if par not in spec:
110
          spec[par] = val
111

    
112

    
113
def UpgradeIPolicy(ipolicy, default_ipolicy, isgroup):
114
  minmax_keys = ["min", "max"]
115
  if any((k in ipolicy) for k in minmax_keys):
116
    minmax = {}
117
    for key in minmax_keys:
118
      if key in ipolicy:
119
        if ipolicy[key]:
120
          minmax[key] = ipolicy[key]
121
        del ipolicy[key]
122
    if minmax:
123
      ipolicy["minmax"] = minmax
124
  if isgroup and "std" in ipolicy:
125
    del ipolicy["std"]
126
  _FillIPolicySpecs(default_ipolicy, ipolicy)
127

    
128

    
129
def UpgradeNetworks(config_data):
130
  networks = config_data.get("networks", None)
131
  if not networks:
132
    config_data["networks"] = {}
133

    
134

    
135
def UpgradeCluster(config_data):
136
  cluster = config_data.get("cluster", None)
137
  if cluster is None:
138
    raise Error("Cannot find cluster")
139
  ipolicy = cluster.setdefault("ipolicy", None)
140
  if ipolicy:
141
    UpgradeIPolicy(ipolicy, constants.IPOLICY_DEFAULTS, False)
142

    
143

    
144
def UpgradeGroups(config_data):
145
  cl_ipolicy = config_data["cluster"].get("ipolicy")
146
  for group in config_data["nodegroups"].values():
147
    networks = group.get("networks", None)
148
    if not networks:
149
      group["networks"] = {}
150
    ipolicy = group.get("ipolicy", None)
151
    if ipolicy:
152
      if cl_ipolicy is None:
153
        raise Error("A group defines an instance policy but there is no"
154
                    " instance policy at cluster level")
155
      UpgradeIPolicy(ipolicy, cl_ipolicy, True)
156

    
157

    
158
def UpgradeInstances(config_data):
159
  network2uuid = dict((n["name"], n["uuid"])
160
                      for n in config_data["networks"].values())
161
  if "instances" not in config_data:
162
    raise Error("Can't find the 'instances' key in the configuration!")
163

    
164
  for instance, iobj in config_data["instances"].items():
165
    for nic in iobj["nics"]:
166
      name = nic.get("network", None)
167
      if name:
168
        uuid = network2uuid.get(name, None)
169
        if uuid:
170
          print("NIC with network name %s found."
171
                " Substituting with uuid %s." % (name, uuid))
172
          nic["network"] = uuid
173

    
174
    if "disks" not in iobj:
175
      raise Error("Instance '%s' doesn't have a disks entry?!" % instance)
176
    disks = iobj["disks"]
177
    for idx, dobj in enumerate(disks):
178
      expected = "disk/%s" % idx
179
      current = dobj.get("iv_name", "")
180
      if current != expected:
181
        logging.warning("Updating iv_name for instance %s/disk %s"
182
                        " from '%s' to '%s'",
183
                        instance, idx, current, expected)
184
        dobj["iv_name"] = expected
185

    
186

    
187
def UpgradeRapiUsers():
188
  if (os.path.isfile(options.RAPI_USERS_FILE_PRE24) and
189
      not os.path.islink(options.RAPI_USERS_FILE_PRE24)):
190
    if os.path.exists(options.RAPI_USERS_FILE):
191
      raise Error("Found pre-2.4 RAPI users file at %s, but another file"
192
                  " already exists at %s" %
193
                  (options.RAPI_USERS_FILE_PRE24, options.RAPI_USERS_FILE))
194
    logging.info("Found pre-2.4 RAPI users file at %s, renaming to %s",
195
                 options.RAPI_USERS_FILE_PRE24, options.RAPI_USERS_FILE)
196
    if not options.dry_run:
197
      utils.RenameFile(options.RAPI_USERS_FILE_PRE24, options.RAPI_USERS_FILE,
198
                       mkdir=True, mkdir_mode=0750)
199

    
200
  # Create a symlink for RAPI users file
201
  if (not (os.path.islink(options.RAPI_USERS_FILE_PRE24) or
202
           os.path.isfile(options.RAPI_USERS_FILE_PRE24)) and
203
      os.path.isfile(options.RAPI_USERS_FILE)):
204
    logging.info("Creating symlink from %s to %s",
205
                 options.RAPI_USERS_FILE_PRE24, options.RAPI_USERS_FILE)
206
    if not options.dry_run:
207
      os.symlink(options.RAPI_USERS_FILE, options.RAPI_USERS_FILE_PRE24)
208

    
209

    
210
def UpgradeWatcher():
211
  # Remove old watcher state file if it exists
212
  if os.path.exists(options.WATCHER_STATEFILE):
213
    logging.info("Removing watcher state file %s", options.WATCHER_STATEFILE)
214
    if not options.dry_run:
215
      utils.RemoveFile(options.WATCHER_STATEFILE)
216

    
217

    
218
def UpgradeFileStoragePaths(config_data):
219
  # Write file storage paths
220
  if not os.path.exists(options.FILE_STORAGE_PATHS_FILE):
221
    cluster = config_data["cluster"]
222
    file_storage_dir = cluster.get("file_storage_dir")
223
    shared_file_storage_dir = cluster.get("shared_file_storage_dir")
224
    del cluster
225

    
226
    logging.info("Ganeti 2.7 and later only allow whitelisted directories"
227
                 " for file storage; writing existing configuration values"
228
                 " into '%s'",
229
                 options.FILE_STORAGE_PATHS_FILE)
230

    
231
    if file_storage_dir:
232
      logging.info("File storage directory: %s", file_storage_dir)
233
    if shared_file_storage_dir:
234
      logging.info("Shared file storage directory: %s",
235
                   shared_file_storage_dir)
236

    
237
    buf = StringIO()
238
    buf.write("# List automatically generated from configuration by\n")
239
    buf.write("# cfgupgrade at %s\n" % time.asctime())
240
    if file_storage_dir:
241
      buf.write("%s\n" % file_storage_dir)
242
    if shared_file_storage_dir:
243
      buf.write("%s\n" % shared_file_storage_dir)
244
    utils.WriteFile(file_name=options.FILE_STORAGE_PATHS_FILE,
245
                    data=buf.getvalue(),
246
                    mode=0600,
247
                    dry_run=options.dry_run,
248
                    backup=True)
249

    
250

    
251
def UpgradeAll(config_data):
252
  config_data["version"] = constants.BuildVersion(TARGET_MAJOR,
253
                                                  TARGET_MINOR, 0)
254
  UpgradeRapiUsers()
255
  UpgradeWatcher()
256
  UpgradeFileStoragePaths(config_data)
257
  UpgradeNetworks(config_data)
258
  UpgradeCluster(config_data)
259
  UpgradeGroups(config_data)
260
  UpgradeInstances(config_data)
261

    
262

    
263
def DowngradeIPolicy(ipolicy):
264
  # Downgrade IPolicy to 2.7 (stable)
265
  minmax_keys = ["min", "max"]
266
  specs_is_split = any((k in ipolicy) for k in minmax_keys)
267
  if not specs_is_split:
268
    if "minmax" in ipolicy:
269
      minmax = ipolicy["minmax"]
270
      del ipolicy["minmax"]
271
    else:
272
      minmax = {}
273
    for key in minmax_keys:
274
      spec = minmax.get(key, {})
275
      ipolicy[key] = spec
276
    if "std" not in ipolicy:
277
      ipolicy["std"] = {}
278

    
279

    
280
def DowngradeGroups(config_data):
281
  for group in config_data["nodegroups"].values():
282
    ipolicy = group.get("ipolicy", None)
283
    if ipolicy is not None:
284
      DowngradeIPolicy(ipolicy)
285

    
286

    
287
def DowngradeEnabledTemplates(cluster):
288
  # Remove enabled disk templates to downgrade to 2.7
289
  edt_key = "enabled_disk_templates"
290
  if edt_key in cluster:
291
    logging.warning("Removing cluster's enabled disk templates; value = %s",
292
                    utils.CommaJoin(cluster[edt_key]))
293
    del cluster[edt_key]
294

    
295

    
296
def DowngradeCluster(config_data):
297
  cluster = config_data.get("cluster", None)
298
  if cluster is None:
299
    raise Error("Cannot find cluster")
300
  DowngradeEnabledTemplates(cluster)
301
  ipolicy = cluster.get("ipolicy", None)
302
  if ipolicy:
303
    DowngradeIPolicy(ipolicy)
304

    
305

    
306
def DowngradeAll(config_data):
307
  # Any code specific to a particular version should be labeled that way, so
308
  # it can be removed when updating to the next version.
309
  DowngradeCluster(config_data)
310
  DowngradeGroups(config_data)
311

    
312

    
313
def main():
314
  """Main program.
315

    
316
  """
317
  global options, args # pylint: disable=W0603
318

    
319
  # Option parsing
320
  parser = optparse.OptionParser(usage="%prog [--debug|--verbose] [--force]")
321
  parser.add_option("--dry-run", dest="dry_run",
322
                    action="store_true",
323
                    help="Try to do the conversion, but don't write"
324
                         " output file")
325
  parser.add_option(cli.FORCE_OPT)
326
  parser.add_option(cli.DEBUG_OPT)
327
  parser.add_option(cli.VERBOSE_OPT)
328
  parser.add_option("--ignore-hostname", dest="ignore_hostname",
329
                    action="store_true", default=False,
330
                    help="Don't abort if hostname doesn't match")
331
  parser.add_option("--path", help="Convert configuration in this"
332
                    " directory instead of '%s'" % pathutils.DATA_DIR,
333
                    default=pathutils.DATA_DIR, dest="data_dir")
334
  parser.add_option("--confdir",
335
                    help=("Use this directory instead of '%s'" %
336
                          pathutils.CONF_DIR),
337
                    default=pathutils.CONF_DIR, dest="conf_dir")
338
  parser.add_option("--no-verify",
339
                    help="Do not verify configuration after upgrade",
340
                    action="store_true", dest="no_verify", default=False)
341
  parser.add_option("--downgrade",
342
                    help="Downgrade to the previous stable version",
343
                    action="store_true", dest="downgrade", default=False)
344
  (options, args) = parser.parse_args()
345

    
346
  # We need to keep filenames locally because they might be renamed between
347
  # versions.
348
  options.data_dir = os.path.abspath(options.data_dir)
349
  options.CONFIG_DATA_PATH = options.data_dir + "/config.data"
350
  options.SERVER_PEM_PATH = options.data_dir + "/server.pem"
351
  options.KNOWN_HOSTS_PATH = options.data_dir + "/known_hosts"
352
  options.RAPI_CERT_FILE = options.data_dir + "/rapi.pem"
353
  options.SPICE_CERT_FILE = options.data_dir + "/spice.pem"
354
  options.SPICE_CACERT_FILE = options.data_dir + "/spice-ca.pem"
355
  options.RAPI_USERS_FILE = options.data_dir + "/rapi/users"
356
  options.RAPI_USERS_FILE_PRE24 = options.data_dir + "/rapi_users"
357
  options.CONFD_HMAC_KEY = options.data_dir + "/hmac.key"
358
  options.CDS_FILE = options.data_dir + "/cluster-domain-secret"
359
  options.SSCONF_MASTER_NODE = options.data_dir + "/ssconf_master_node"
360
  options.WATCHER_STATEFILE = options.data_dir + "/watcher.data"
361
  options.FILE_STORAGE_PATHS_FILE = options.conf_dir + "/file-storage-paths"
362

    
363
  SetupLogging()
364

    
365
  # Option checking
366
  if args:
367
    raise Error("No arguments expected")
368
  if options.downgrade and not options.no_verify:
369
    options.no_verify = True
370

    
371
  # Check master name
372
  if not (CheckHostname(options.SSCONF_MASTER_NODE) or options.ignore_hostname):
373
    logging.error("Aborting due to hostname mismatch")
374
    sys.exit(constants.EXIT_FAILURE)
375

    
376
  if not options.force:
377
    if options.downgrade:
378
      usertext = ("The configuration is going to be DOWNGRADED to version %s.%s"
379
                  " Some configuration data might be removed if they don't fit"
380
                  " in the old format. Please make sure you have read the"
381
                  " upgrade notes (available in the UPGRADE file and included"
382
                  " in other documentation formats) to understand what they"
383
                  " are. Continue with *DOWNGRADING* the configuration?" %
384
                  (DOWNGRADE_MAJOR, DOWNGRADE_MINOR))
385
    else:
386
      usertext = ("Please make sure you have read the upgrade notes for"
387
                  " Ganeti %s (available in the UPGRADE file and included"
388
                  " in other documentation formats). Continue with upgrading"
389
                  " configuration?" % constants.RELEASE_VERSION)
390
    if not cli.AskUser(usertext):
391
      sys.exit(constants.EXIT_FAILURE)
392

    
393
  # Check whether it's a Ganeti configuration directory
394
  if not (os.path.isfile(options.CONFIG_DATA_PATH) and
395
          os.path.isfile(options.SERVER_PEM_PATH) and
396
          os.path.isfile(options.KNOWN_HOSTS_PATH)):
397
    raise Error(("%s does not seem to be a Ganeti configuration"
398
                 " directory") % options.data_dir)
399

    
400
  if not os.path.isdir(options.conf_dir):
401
    raise Error("Not a directory: %s" % options.conf_dir)
402

    
403
  config_data = serializer.LoadJson(utils.ReadFile(options.CONFIG_DATA_PATH))
404

    
405
  try:
406
    config_version = config_data["version"]
407
  except KeyError:
408
    raise Error("Unable to determine configuration version")
409

    
410
  (config_major, config_minor, config_revision) = \
411
    constants.SplitVersion(config_version)
412

    
413
  logging.info("Found configuration version %s (%d.%d.%d)",
414
               config_version, config_major, config_minor, config_revision)
415

    
416
  if "config_version" in config_data["cluster"]:
417
    raise Error("Inconsistent configuration: found config_version in"
418
                " configuration file")
419

    
420
  # Downgrade to the previous stable version
421
  if options.downgrade:
422
    if config_major != TARGET_MAJOR or config_minor != TARGET_MINOR:
423
      raise Error("Downgrade supported only from the latest version (%s.%s),"
424
                  " found %s (%s.%s.%s) instead" %
425
                  (TARGET_MAJOR, TARGET_MINOR, config_version, config_major,
426
                   config_minor, config_revision))
427
    DowngradeAll(config_data)
428

    
429
  # Upgrade from 2.{0..7} to 2.7
430
  elif config_major == 2 and config_minor in range(0, 8):
431
    if config_revision != 0:
432
      logging.warning("Config revision is %s, not 0", config_revision)
433
    UpgradeAll(config_data)
434

    
435
  elif config_major == TARGET_MAJOR and config_minor == TARGET_MINOR:
436
    logging.info("No changes necessary")
437

    
438
  else:
439
    raise Error("Configuration version %d.%d.%d not supported by this tool" %
440
                (config_major, config_minor, config_revision))
441

    
442
  try:
443
    logging.info("Writing configuration file to %s", options.CONFIG_DATA_PATH)
444
    utils.WriteFile(file_name=options.CONFIG_DATA_PATH,
445
                    data=serializer.DumpJson(config_data),
446
                    mode=0600,
447
                    dry_run=options.dry_run,
448
                    backup=True)
449

    
450
    if not options.dry_run:
451
      bootstrap.GenerateClusterCrypto(
452
        False, False, False, False, False,
453
        nodecert_file=options.SERVER_PEM_PATH,
454
        rapicert_file=options.RAPI_CERT_FILE,
455
        spicecert_file=options.SPICE_CERT_FILE,
456
        spicecacert_file=options.SPICE_CACERT_FILE,
457
        hmackey_file=options.CONFD_HMAC_KEY,
458
        cds_file=options.CDS_FILE)
459

    
460
  except Exception:
461
    logging.critical("Writing configuration failed. It is probably in an"
462
                     " inconsistent state and needs manual intervention.")
463
    raise
464

    
465
  # test loading the config file
466
  all_ok = True
467
  if not (options.dry_run or options.no_verify):
468
    logging.info("Testing the new config file...")
469
    cfg = config.ConfigWriter(cfg_file=options.CONFIG_DATA_PATH,
470
                              accept_foreign=options.ignore_hostname,
471
                              offline=True)
472
    # if we reached this, it's all fine
473
    vrfy = cfg.VerifyConfig()
474
    if vrfy:
475
      logging.error("Errors after conversion:")
476
      for item in vrfy:
477
        logging.error(" - %s", item)
478
      all_ok = False
479
    else:
480
      logging.info("File loaded successfully after upgrading")
481
    del cfg
482

    
483
  if options.downgrade:
484
    action = "downgraded"
485
    out_ver = "%s.%s" % (DOWNGRADE_MAJOR, DOWNGRADE_MINOR)
486
  else:
487
    action = "upgraded"
488
    out_ver = constants.RELEASE_VERSION
489
  if all_ok:
490
    cli.ToStderr("Configuration successfully %s to version %s.",
491
                 action, out_ver)
492
  else:
493
    cli.ToStderr("Configuration %s to version %s, but there are errors."
494
                 "\nPlease review the file.", action, out_ver)
495

    
496

    
497
if __name__ == "__main__":
498
  main()