Synnefo » snf-ganeti » ganeti-local

#!/usr/bin/python

#

# Copyright (C) 2007, 2008, 2009, 2010 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

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""Tool to upgrade the configuration file.

This code handles only the types supported by simplejson. As an

example, 'set' is a 'list'.

"""

import os

import os.path

import sys

import optparse

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'

class Error(Exception):

  """Generic exception"""

  pass

def SetupLogging():

  """Configures the logging module.

  """

  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)

  root_logger = logging.getLogger("")

  root_logger.setLevel(logging.NOTSET)

  root_logger.addHandler(stderr_handler)

def main():

  """Main program.

  """

  global options, args # pylint: disable-msg=W0603

  program = os.path.basename(sys.argv[0])

  # 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.data_dir = os.path.abspath(options.data_dir)

  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.CONFD_HMAC_KEY = options.data_dir + "/hmac.key"

  SetupLogging()

  # Option checking

  if args:

    raise Error("No arguments expected")

  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)

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

  try:

    config_version = config_data["version"]

  except KeyError:

    raise Error("Unable to determine configuration version")

  (config_major, config_minor, config_revision) = \

    constants.SplitVersion(config_version)

  logging.info("Found configuration version %s (%d.%d.%d)",

               config_version, config_major, config_minor, config_revision)

  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")

    config_data["version"] = constants.BuildVersion(2, 1, 0)

  try:

    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:

      bootstrap.GenerateClusterCrypto(False, False, False,

                                      nodecert_file=options.SERVER_PEM_PATH,

                                      rapicert_file=options.RAPI_CERT_FILE,

                                      hmackey_file=options.CONFD_HMAC_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")

if __name__ == "__main__":

  main()

# vim: set foldmethod=marker :