Statistics
| Branch: | Tag: | Revision:

root / tools / cfgupgrade @ e94fc80c

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 DowngradeStorageTypes(cluster):
288
  # Remove storage types to downgrade to 2.7
289
  if "enabled_storage_types" in cluster:
290
    logging.warning("Removing cluster storage types; value = %s",
291
                    utils.CommaJoin(cluster["enabled_storage_types"]))
292
    del cluster["enabled_storage_types"]
293

    
294

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

    
304

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

    
311

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

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

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

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

    
362
  SetupLogging()
363

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
495

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