#!/usr/bin/python
#
-# Copyright (C) 2007 Google Inc.
+# Copyright (C) 2007, 2008, 2009 Google Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
"""Tool to upgrade the configuration file.
-The upgrade is done by unpickling the configuration file into custom classes
-derivating from dict. We then update the configuration by modifying these
-dicts. To save the configuration, it's pickled into a buffer and unpickled
-again using the Ganeti objects before being finally pickled into a file.
-
-Not using the custom classes wouldn't allow us to rename or remove attributes
-between versions without loosing their values.
+This code handles only the types supported by simplejson. As an
+example, 'set' is a 'list'.
"""
import os.path
import sys
import optparse
-import cPickle
-import tempfile
-from cStringIO import StringIO
+import logging
+
+from ganeti import constants
+from ganeti import serializer
+from ganeti import utils
+from ganeti import cli
+from ganeti import bootstrap
+from ganeti import config
+
+
+options = None
+args = None
+
+# Dictionary with instance old keys, and new hypervisor keys
+INST_HV_CHG = {
+ 'hvm_pae': constants.HV_PAE,
+ 'vnc_bind_address': constants.HV_VNC_BIND_ADDRESS,
+ 'initrd_path': constants.HV_INITRD_PATH,
+ 'hvm_nic_type': constants.HV_NIC_TYPE,
+ 'kernel_path': constants.HV_KERNEL_PATH,
+ 'hvm_acpi': constants.HV_ACPI,
+ 'hvm_cdrom_image_path': constants.HV_CDROM_IMAGE_PATH,
+ 'hvm_boot_order': constants.HV_BOOT_ORDER,
+ 'hvm_disk_type': constants.HV_DISK_TYPE,
+ }
+
+# Instance beparams changes
+INST_BE_CHG = {
+ 'vcpus': constants.BE_VCPUS,
+ 'memory': constants.BE_MEMORY,
+ 'auto_balance': constants.BE_AUTO_BALANCE,
+ }
+
+# Field names
+F_SERIAL = 'serial_no'
-from ganeti import objects
class Error(Exception):
"""Generic exception"""
pass
-def _BaseFindGlobal(module, name):
- """Helper function for the other FindGlobal functions.
-
- """
- return getattr(sys.modules[module], name)
-
-
-# Internal config representation
-class UpgradeDict(dict):
- """Base class for internal config classes.
+def SetupLogging():
+ """Configures the logging module.
"""
- def __setstate__(self, state):
- self.update(state)
+ formatter = logging.Formatter("%(asctime)s: %(message)s")
+
+ stderr_handler = logging.StreamHandler()
+ stderr_handler.setFormatter(formatter)
+ if options.debug:
+ stderr_handler.setLevel(logging.NOTSET)
+ elif options.verbose:
+ stderr_handler.setLevel(logging.INFO)
+ else:
+ stderr_handler.setLevel(logging.CRITICAL)
- def __getstate__(self):
- return self.copy()
+ root_logger = logging.getLogger("")
+ root_logger.setLevel(logging.NOTSET)
+ root_logger.addHandler(stderr_handler)
-class UpgradeConfigData(UpgradeDict): pass
-class UpgradeCluster(UpgradeDict): pass
-class UpgradeNode(UpgradeDict): pass
-class UpgradeInstance(UpgradeDict): pass
-class UpgradeDisk(UpgradeDict): pass
-class UpgradeNIC(UpgradeDict): pass
-class UpgradeOS(UpgradeDict): pass
+def main():
+ """Main program.
+ """
+ global options, args # pylint: disable-msg=W0603
-_ClassMap = {
- objects.ConfigData: UpgradeConfigData,
- objects.Cluster: UpgradeCluster,
- objects.Node: UpgradeNode,
- objects.Instance: UpgradeInstance,
- objects.Disk: UpgradeDisk,
- objects.NIC: UpgradeNIC,
- objects.OS: UpgradeOS,
-}
+ program = os.path.basename(sys.argv[0])
-# Build mapping dicts
-WriteMapping = dict()
-ReadMapping = dict()
-for key, value in _ClassMap.iteritems():
- WriteMapping[value.__name__] = key
- ReadMapping[key.__name__] = value
+ # Option parsing
+ parser = optparse.OptionParser(usage="%prog [--debug|--verbose] [--force]")
+ parser.add_option('--dry-run', dest='dry_run',
+ action="store_true",
+ help="Try to do the conversion, but don't write"
+ " output file")
+ parser.add_option(cli.FORCE_OPT)
+ parser.add_option(cli.DEBUG_OPT)
+ parser.add_option(cli.VERBOSE_OPT)
+ parser.add_option('--path', help="Convert configuration in this"
+ " directory instead of '%s'" % constants.DATA_DIR,
+ default=constants.DATA_DIR, dest="data_dir")
+ (options, args) = parser.parse_args()
+ # We need to keep filenames locally because they might be renamed between
+ # versions.
+ options.CONFIG_DATA_PATH = options.data_dir + "/config.data"
+ options.SERVER_PEM_PATH = options.data_dir + "/server.pem"
+ options.KNOWN_HOSTS_PATH = options.data_dir + "/known_hosts"
+ options.RAPI_CERT_FILE = options.data_dir + "/rapi.pem"
+ options.HMAC_CLUSTER_KEY = options.data_dir + "/hmac.key"
-# Read config
-def _ReadFindGlobal(module, name):
- """Wraps Ganeti config classes to internal ones.
+ SetupLogging()
- """
- if module == "ganeti.objects" and name in ReadMapping:
- return ReadMapping[name]
+ # Option checking
+ if args:
+ raise Error("No arguments expected")
- return _BaseFindGlobal(module, name)
+ if not options.force:
+ usertext = ("%s MUST be run on the master node. Is this the master"
+ " node and are ALL instances down?" % program)
+ if not cli.AskUser(usertext):
+ sys.exit(1)
+ # Check whether it's a Ganeti configuration directory
+ if not (os.path.isfile(options.CONFIG_DATA_PATH) and
+ os.path.isfile(options.SERVER_PEM_PATH) or
+ os.path.isfile(options.KNOWN_HOSTS_PATH)):
+ raise Error(("%s does not seem to be a known Ganeti configuration"
+ " directory") % options.data_dir)
-def ReadConfig(path):
- """Reads configuration file.
+ config_data = serializer.LoadJson(utils.ReadFile(options.CONFIG_DATA_PATH))
- """
- f = open(path, 'r')
try:
- loader = cPickle.Unpickler(f)
- loader.find_global = _ReadFindGlobal
- data = loader.load()
- finally:
- f.close()
-
- return data
+ config_version = config_data["version"]
+ except KeyError:
+ raise Error("Unable to determine configuration version")
+ (config_major, config_minor, config_revision) = \
+ constants.SplitVersion(config_version)
-# Write config
-def _WriteFindGlobal(module, name):
- """Maps our internal config classes to Ganeti's.
-
- """
- if module == "__main__" and name in WriteMapping:
- return WriteMapping[name]
+ logging.info("Found configuration version %s (%d.%d.%d)",
+ config_version, config_major, config_minor, config_revision)
- return _BaseFindGlobal(module, name)
+ if "config_version" in config_data["cluster"]:
+ raise Error("Inconsistent configuration: found config_version in"
+ " configuration file")
+ if config_major == 2 and config_minor == 0:
+ if config_revision != 0:
+ logging.warning("Config revision is not 0")
-def WriteConfig(path, data, dry_run):
- """Writes the configuration file.
+ config_data["version"] = constants.BuildVersion(2, 1, 0)
- """
- buf = StringIO()
-
- # Write intermediate representation
- dumper = cPickle.Pickler(buf, cPickle.HIGHEST_PROTOCOL)
- dumper.dump(data)
- del dumper
-
- # Convert back to Ganeti objects
- buf.seek(0)
- loader = cPickle.Unpickler(buf)
- loader.find_global = _WriteFindGlobal
- data = loader.load()
-
- # Write target file
- (fd, name) = tempfile.mkstemp(dir=os.path.dirname(path))
- f = os.fdopen(fd, 'w')
try:
- try:
- dumper = cPickle.Pickler(f, cPickle.HIGHEST_PROTOCOL)
- dumper.dump(data)
- f.flush()
- if dry_run:
- os.unlink(name)
- else:
- os.rename(name, path)
- except:
- os.unlink(name)
- raise
- finally:
- f.close()
-
-
-def UpdateFromVersion2To3(cfg):
- """Updates the configuration from version 2 to 3.
-
- """
- if cfg['cluster']['config_version'] != 2:
- return
-
- # Add port pool
- if 'tcpudp_port_pool' not in cfg['cluster']:
- cfg['cluster']['tcpudp_port_pool'] = set()
-
- # Add bridge settings
- if 'default_bridge' not in cfg['cluster']:
- cfg['cluster']['default_bridge'] = 'xen-br0'
- for inst in cfg['instances'].values():
- for nic in inst['nics']:
- if 'bridge' not in nic:
- nic['bridge'] = None
+ logging.info("Writing configuration file to %s", options.CONFIG_DATA_PATH)
+ utils.WriteFile(file_name=options.CONFIG_DATA_PATH,
+ data=serializer.DumpJson(config_data),
+ mode=0600,
+ dry_run=options.dry_run,
+ backup=True)
+
+ if not options.dry_run:
+ if not os.path.exists(options.RAPI_CERT_FILE):
+ logging.debug("Writing RAPI certificate to %s", options.RAPI_CERT_FILE)
+ bootstrap.GenerateSelfSignedSslCert(options.RAPI_CERT_FILE)
+
+ if not os.path.exists(options.HMAC_CLUSTER_KEY):
+ logging.debug("Writing HMAC key to %s", options.HMAC_CLUSTER_KEY)
+ bootstrap.GenerateHmacKey(options.HMAC_CLUSTER_KEY)
+
+ except:
+ logging.critical("Writing configuration failed. It is probably in an"
+ " inconsistent state and needs manual intervention.")
+ raise
+
+ # test loading the config file
+ if not options.dry_run:
+ logging.info("Testing the new config file...")
+ cfg = config.ConfigWriter(cfg_file=options.CONFIG_DATA_PATH,
+ offline=True)
+ # if we reached this, it's all fine
+ vrfy = cfg.VerifyConfig()
+ if vrfy:
+ logging.error("Errors after conversion:")
+ for item in vrfy:
+ logging.error(" - %s", item)
+ del cfg
+ logging.info("File loaded successfully")
- cfg['cluster']['config_version'] = 3
-
-# Main program
if __name__ == "__main__":
- # Option parsing
- parser = optparse.OptionParser()
- parser.add_option('--dry-run', dest='dry_run',
- action="store_true",
- help="Try to do the conversion, but don't write "
- "output file")
- parser.add_option('--verbose', dest='verbose',
- action="store_true",
- help="Verbose output")
- (options, args) = parser.parse_args()
-
- # Option checking
- if args:
- cfg_file = args[0]
- else:
- raise Error, ("Configuration file not specified")
-
- config = ReadConfig(cfg_file)
-
- UpdateFromVersion2To3(config)
-
- if options.verbose:
- import pprint
- pprint.pprint(config)
+ main()
- WriteConfig(cfg_file, config, options.dry_run)
+# vim: set foldmethod=marker :
projects / ganeti-local / blobdiff