Synnefo » snf-ganeti » ganeti-local

#

#

# Copyright (C) 2006, 2007, 2010, 2011, 2012 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.

"""Cluster related commands"""

# pylint: disable=W0401,W0613,W0614,C0103

# W0401: Wildcard import ganeti.cli

# W0613: Unused argument, since all functions follow the same API

# W0614: Unused import %s from wildcard import (since we need cli)

# C0103: Invalid name gnt-cluster

import os.path

import time

import OpenSSL

import itertools

from ganeti.cli import *

from ganeti import opcodes

from ganeti import constants

from ganeti import errors

from ganeti import utils

from ganeti import bootstrap

from ganeti import ssh

from ganeti import objects

from ganeti import uidpool

from ganeti import compat

from ganeti import netutils

ON_OPT = cli_option("--on", default=False,

                    action="store_true", dest="on",

                    help="Recover from an EPO")

GROUPS_OPT = cli_option("--groups", default=False,

                    action="store_true", dest="groups",

                    help="Arguments are node groups instead of nodes")

SHOW_MACHINE_OPT = cli_option("-M", "--show-machine-names", default=False,

                              action="store_true",

                              help="Show machine name for every line in output")

_EPO_PING_INTERVAL = 30 # 30 seconds between pings

_EPO_PING_TIMEOUT = 1 # 1 second

_EPO_REACHABLE_TIMEOUT = 15 * 60 # 15 minutes

@UsesRPC

def InitCluster(opts, args):

  """Initialize the cluster.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should contain only one element, the desired

      cluster name

  @rtype: int

  @return: the desired exit code

  """

  if not opts.lvm_storage and opts.vg_name:

    ToStderr("Options --no-lvm-storage and --vg-name conflict.")

    return 1

  vg_name = opts.vg_name

  if opts.lvm_storage and not opts.vg_name:

    vg_name = constants.DEFAULT_VG

  if not opts.drbd_storage and opts.drbd_helper:

    ToStderr("Options --no-drbd-storage and --drbd-usermode-helper conflict.")

    return 1

  drbd_helper = opts.drbd_helper

  if opts.drbd_storage and not opts.drbd_helper:

    drbd_helper = constants.DEFAULT_DRBD_HELPER

  master_netdev = opts.master_netdev

  if master_netdev is None:

    master_netdev = constants.DEFAULT_BRIDGE

  hvlist = opts.enabled_hypervisors

  if hvlist is None:

    hvlist = constants.DEFAULT_ENABLED_HYPERVISOR

  hvlist = hvlist.split(",")

  hvparams = dict(opts.hvparams)

  beparams = opts.beparams

  nicparams = opts.nicparams

  diskparams = dict(opts.diskparams)

  # check the disk template types here, as we cannot rely on the type check done

  # by the opcode parameter types

  diskparams_keys = set(diskparams.keys())

  if not (diskparams_keys <= constants.DISK_TEMPLATES):

    unknown = utils.NiceSort(diskparams_keys - constants.DISK_TEMPLATES)

    ToStderr("Disk templates unknown: %s" % utils.CommaJoin(unknown))

    return 1

  # prepare beparams dict

  beparams = objects.FillDict(constants.BEC_DEFAULTS, beparams)

  utils.ForceDictType(beparams, constants.BES_PARAMETER_COMPAT)

  # prepare nicparams dict

  nicparams = objects.FillDict(constants.NICC_DEFAULTS, nicparams)

  utils.ForceDictType(nicparams, constants.NICS_PARAMETER_TYPES)

  # prepare ndparams dict

  if opts.ndparams is None:

    ndparams = dict(constants.NDC_DEFAULTS)

  else:

    ndparams = objects.FillDict(constants.NDC_DEFAULTS, opts.ndparams)

    utils.ForceDictType(ndparams, constants.NDS_PARAMETER_TYPES)

  # prepare hvparams dict

  for hv in constants.HYPER_TYPES:

    if hv not in hvparams:

      hvparams[hv] = {}

    hvparams[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], hvparams[hv])

    utils.ForceDictType(hvparams[hv], constants.HVS_PARAMETER_TYPES)

  # prepare diskparams dict

  for templ in constants.DISK_TEMPLATES:

    if templ not in diskparams:

      diskparams[templ] = {}

    diskparams[templ] = objects.FillDict(constants.DISK_DT_DEFAULTS[templ],

                                         diskparams[templ])

    utils.ForceDictType(diskparams[templ], constants.DISK_DT_TYPES)

  # prepare ipolicy dict

  ipolicy_raw = objects.CreateIPolicyFromOpts(

    ispecs_mem_size=opts.ispecs_mem_size,

    ispecs_cpu_count=opts.ispecs_cpu_count,

    ispecs_disk_count=opts.ispecs_disk_count,

    ispecs_disk_size=opts.ispecs_disk_size,

    ispecs_nic_count=opts.ispecs_nic_count,

    ipolicy_disk_templates=opts.ipolicy_disk_templates,

    ipolicy_vcpu_ratio=opts.ipolicy_vcpu_ratio,

    fill_all=True)

  ipolicy = objects.FillIPolicy(constants.IPOLICY_DEFAULTS, ipolicy_raw)

  if opts.candidate_pool_size is None:

    opts.candidate_pool_size = constants.MASTER_POOL_SIZE_DEFAULT

  if opts.mac_prefix is None:

    opts.mac_prefix = constants.DEFAULT_MAC_PREFIX

  uid_pool = opts.uid_pool

  if uid_pool is not None:

    uid_pool = uidpool.ParseUidPool(uid_pool)

  if opts.prealloc_wipe_disks is None:

    opts.prealloc_wipe_disks = False

  external_ip_setup_script = opts.use_external_mip_script

  if external_ip_setup_script is None:

    external_ip_setup_script = False

  try:

    primary_ip_version = int(opts.primary_ip_version)

  except (ValueError, TypeError), err:

    ToStderr("Invalid primary ip version value: %s" % str(err))

    return 1

  master_netmask = opts.master_netmask

  try:

    if master_netmask is not None:

      master_netmask = int(master_netmask)

  except (ValueError, TypeError), err:

    ToStderr("Invalid master netmask value: %s" % str(err))

    return 1

  if opts.disk_state:

    disk_state = utils.FlatToDict(opts.disk_state)

  else:

    disk_state = {}

  hv_state = dict(opts.hv_state)

  bootstrap.InitCluster(cluster_name=args[0],

                        secondary_ip=opts.secondary_ip,

                        vg_name=vg_name,

                        mac_prefix=opts.mac_prefix,

                        master_netmask=master_netmask,

                        master_netdev=master_netdev,

                        file_storage_dir=opts.file_storage_dir,

                        shared_file_storage_dir=opts.shared_file_storage_dir,

                        enabled_hypervisors=hvlist,

                        hvparams=hvparams,

                        beparams=beparams,

                        nicparams=nicparams,

                        ndparams=ndparams,

                        diskparams=diskparams,

                        ipolicy=ipolicy,

                        candidate_pool_size=opts.candidate_pool_size,

                        modify_etc_hosts=opts.modify_etc_hosts,

                        modify_ssh_setup=opts.modify_ssh_setup,

                        maintain_node_health=opts.maintain_node_health,

                        drbd_helper=drbd_helper,

                        uid_pool=uid_pool,

                        default_iallocator=opts.default_iallocator,

                        primary_ip_version=primary_ip_version,

                        prealloc_wipe_disks=opts.prealloc_wipe_disks,

                        use_external_mip_script=external_ip_setup_script,

                        hv_state=hv_state,

                        disk_state=disk_state,

                        )

  op = opcodes.OpClusterPostInit()

  SubmitOpCode(op, opts=opts)

  return 0

@UsesRPC

def DestroyCluster(opts, args):

  """Destroy the cluster.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should be an empty list

  @rtype: int

  @return: the desired exit code

  """

  if not opts.yes_do_it:

    ToStderr("Destroying a cluster is irreversible. If you really want"

             " destroy this cluster, supply the --yes-do-it option.")

    return 1

  op = opcodes.OpClusterDestroy()

  master = SubmitOpCode(op, opts=opts)

  # if we reached this, the opcode didn't fail; we can proceed to

  # shutdown all the daemons

  bootstrap.FinalizeClusterDestroy(master)

  return 0

def RenameCluster(opts, args):

  """Rename the cluster.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should contain only one element, the new cluster name

  @rtype: int

  @return: the desired exit code

  """

  cl = GetClient()

  (cluster_name, ) = cl.QueryConfigValues(["cluster_name"])

  new_name = args[0]

  if not opts.force:

    usertext = ("This will rename the cluster from '%s' to '%s'. If you are"

                " connected over the network to the cluster name, the"

                " operation is very dangerous as the IP address will be"

                " removed from the node and the change may not go through."

                " Continue?") % (cluster_name, new_name)

    if not AskUser(usertext):

      return 1

  op = opcodes.OpClusterRename(name=new_name)

  result = SubmitOpCode(op, opts=opts, cl=cl)

  if result:

    ToStdout("Cluster renamed from '%s' to '%s'", cluster_name, result)

  return 0

def ActivateMasterIp(opts, args):

  """Activates the master IP.

  """

  op = opcodes.OpClusterActivateMasterIp()

  SubmitOpCode(op)

  return 0

def DeactivateMasterIp(opts, args):

  """Deactivates the master IP.

  """

  if not opts.confirm:

    usertext = ("This will disable the master IP. All the open connections to"

                " the master IP will be closed. To reach the master you will"

                " need to use its node IP."

                " Continue?")

    if not AskUser(usertext):

      return 1

  op = opcodes.OpClusterDeactivateMasterIp()

  SubmitOpCode(op)

  return 0

def RedistributeConfig(opts, args):

  """Forces push of the cluster configuration.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: empty list

  @rtype: int

  @return: the desired exit code

  """

  op = opcodes.OpClusterRedistConf()

  SubmitOrSend(op, opts)

  return 0

def ShowClusterVersion(opts, args):

  """Write version of ganeti software to the standard output.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should be an empty list

  @rtype: int

  @return: the desired exit code

  """

  cl = GetClient()

  result = cl.QueryClusterInfo()

  ToStdout("Software version: %s", result["software_version"])

  ToStdout("Internode protocol: %s", result["protocol_version"])

  ToStdout("Configuration format: %s", result["config_version"])

  ToStdout("OS api version: %s", result["os_api_version"])

  ToStdout("Export interface: %s", result["export_version"])

  return 0

def ShowClusterMaster(opts, args):

  """Write name of master node to the standard output.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should be an empty list

  @rtype: int

  @return: the desired exit code

  """

  master = bootstrap.GetMaster()

  ToStdout(master)

  return 0

def _PrintGroupedParams(paramsdict, level=1, roman=False):

  """Print Grouped parameters (be, nic, disk) by group.

  @type paramsdict: dict of dicts

  @param paramsdict: {group: {param: value, ...}, ...}

  @type level: int

  @param level: Level of indention

  """

  indent = "  " * level

  for item, val in sorted(paramsdict.items()):

    if isinstance(val, dict):

      ToStdout("%s- %s:", indent, item)

      _PrintGroupedParams(val, level=level + 1, roman=roman)

    elif roman and isinstance(val, int):

      ToStdout("%s  %s: %s", indent, item, compat.TryToRoman(val))

    else:

      ToStdout("%s  %s: %s", indent, item, val)

def ShowClusterConfig(opts, args):

  """Shows cluster information.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should be an empty list

  @rtype: int

  @return: the desired exit code

  """

  cl = GetClient()

  result = cl.QueryClusterInfo()

  ToStdout("Cluster name: %s", result["name"])

  ToStdout("Cluster UUID: %s", result["uuid"])

  ToStdout("Creation time: %s", utils.FormatTime(result["ctime"]))

  ToStdout("Modification time: %s", utils.FormatTime(result["mtime"]))

  ToStdout("Master node: %s", result["master"])

  ToStdout("Architecture (this node): %s (%s)",

           result["architecture"][0], result["architecture"][1])

  if result["tags"]:

    tags = utils.CommaJoin(utils.NiceSort(result["tags"]))

  else:

    tags = "(none)"

  ToStdout("Tags: %s", tags)

  ToStdout("Default hypervisor: %s", result["default_hypervisor"])

  ToStdout("Enabled hypervisors: %s",

           utils.CommaJoin(result["enabled_hypervisors"]))

  ToStdout("Hypervisor parameters:")

  _PrintGroupedParams(result["hvparams"])

  ToStdout("OS-specific hypervisor parameters:")

  _PrintGroupedParams(result["os_hvp"])

  ToStdout("OS parameters:")

  _PrintGroupedParams(result["osparams"])

  ToStdout("Hidden OSes: %s", utils.CommaJoin(result["hidden_os"]))

  ToStdout("Blacklisted OSes: %s", utils.CommaJoin(result["blacklisted_os"]))

  ToStdout("Cluster parameters:")

  ToStdout("  - candidate pool size: %s",

            compat.TryToRoman(result["candidate_pool_size"],

                              convert=opts.roman_integers))

  ToStdout("  - master netdev: %s", result["master_netdev"])

  ToStdout("  - master netmask: %s", result["master_netmask"])

  ToStdout("  - use external master IP address setup script: %s",

           result["use_external_mip_script"])

  ToStdout("  - lvm volume group: %s", result["volume_group_name"])

  if result["reserved_lvs"]:

    reserved_lvs = utils.CommaJoin(result["reserved_lvs"])

  else:

    reserved_lvs = "(none)"

  ToStdout("  - lvm reserved volumes: %s", reserved_lvs)

  ToStdout("  - drbd usermode helper: %s", result["drbd_usermode_helper"])

  ToStdout("  - file storage path: %s", result["file_storage_dir"])

  ToStdout("  - shared file storage path: %s",

           result["shared_file_storage_dir"])

  ToStdout("  - maintenance of node health: %s",

           result["maintain_node_health"])

  ToStdout("  - uid pool: %s",

            uidpool.FormatUidPool(result["uid_pool"],

                                  roman=opts.roman_integers))

  ToStdout("  - default instance allocator: %s", result["default_iallocator"])

  ToStdout("  - primary ip version: %d", result["primary_ip_version"])

  ToStdout("  - preallocation wipe disks: %s", result["prealloc_wipe_disks"])

  ToStdout("  - OS search path: %s", utils.CommaJoin(constants.OS_SEARCH_PATH))

  ToStdout("Default node parameters:")

  _PrintGroupedParams(result["ndparams"], roman=opts.roman_integers)

  ToStdout("Default instance parameters:")

  _PrintGroupedParams(result["beparams"], roman=opts.roman_integers)

  ToStdout("Default nic parameters:")

  _PrintGroupedParams(result["nicparams"], roman=opts.roman_integers)

  ToStdout("Default disk parameters:")

  _PrintGroupedParams(result["diskparams"], roman=opts.roman_integers)

  ToStdout("Instance policy - limits for instances:")

  for key in constants.IPOLICY_ISPECS:

    ToStdout("  - %s", key)

    _PrintGroupedParams(result["ipolicy"][key], roman=opts.roman_integers)

  ToStdout("  - enabled disk templates: %s",

           utils.CommaJoin(result["ipolicy"][constants.IPOLICY_DTS]))

  for key in constants.IPOLICY_PARAMETERS:

    ToStdout("  - %s: %s", key, result["ipolicy"][key])

  return 0

def ClusterCopyFile(opts, args):

  """Copy a file from master to some nodes.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should contain only one element, the path of

      the file to be copied

  @rtype: int

  @return: the desired exit code

  """

  filename = args[0]

  if not os.path.exists(filename):

    raise errors.OpPrereqError("No such filename '%s'" % filename,

                               errors.ECODE_INVAL)

  cl = GetClient()

  cluster_name = cl.QueryConfigValues(["cluster_name"])[0]

  results = GetOnlineNodes(nodes=opts.nodes, cl=cl, filter_master=True,

                           secondary_ips=opts.use_replication_network,

                           nodegroup=opts.nodegroup)

  srun = ssh.SshRunner(cluster_name=cluster_name)

  for node in results:

    if not srun.CopyFileToNode(node, filename):

      ToStderr("Copy of file %s to node %s failed", filename, node)

  return 0

def RunClusterCommand(opts, args):

  """Run a command on some nodes.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should contain the command to be run and its arguments

  @rtype: int

  @return: the desired exit code

  """

  cl = GetClient()

  command = " ".join(args)

  nodes = GetOnlineNodes(nodes=opts.nodes, cl=cl, nodegroup=opts.nodegroup)

  cluster_name, master_node = cl.QueryConfigValues(["cluster_name",

                                                    "master_node"])

  srun = ssh.SshRunner(cluster_name=cluster_name)

  # Make sure master node is at list end

  if master_node in nodes:

    nodes.remove(master_node)

    nodes.append(master_node)

  for name in nodes:

    result = srun.Run(name, "root", command)

    ToStdout("------------------------------------------------")

    if opts.show_machine_names:

      for line in result.output.splitlines():

        ToStdout("%s: %s", name, line)

    else:

      ToStdout("node: %s", name)

      ToStdout("%s", result.output)

    ToStdout("return code = %s", result.exit_code)

  return 0

def VerifyCluster(opts, args):

  """Verify integrity of cluster, performing various test on nodes.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should be an empty list

  @rtype: int

  @return: the desired exit code

  """

  skip_checks = []

  if opts.skip_nplusone_mem:

    skip_checks.append(constants.VERIFY_NPLUSONE_MEM)

  cl = GetClient()

  op = opcodes.OpClusterVerify(verbose=opts.verbose,

                               error_codes=opts.error_codes,

                               debug_simulate_errors=opts.simulate_errors,

                               skip_checks=skip_checks,

                               ignore_errors=opts.ignore_errors,

                               group_name=opts.nodegroup)

  result = SubmitOpCode(op, cl=cl, opts=opts)

  # Keep track of submitted jobs

  jex = JobExecutor(cl=cl, opts=opts)

  for (status, job_id) in result[constants.JOB_IDS_KEY]:

    jex.AddJobId(None, status, job_id)

  results = jex.GetResults()

  (bad_jobs, bad_results) = \

    map(len,

        # Convert iterators to lists

        map(list,

            # Count errors

            map(compat.partial(itertools.ifilterfalse, bool),

                # Convert result to booleans in a tuple

                zip(*((job_success, len(op_results) == 1 and op_results[0])

                      for (job_success, op_results) in results)))))

  if bad_jobs == 0 and bad_results == 0:

    rcode = constants.EXIT_SUCCESS

  else:

    rcode = constants.EXIT_FAILURE

    if bad_jobs > 0:

      ToStdout("%s job(s) failed while verifying the cluster.", bad_jobs)

  return rcode

def VerifyDisks(opts, args):

  """Verify integrity of cluster disks.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should be an empty list

  @rtype: int

  @return: the desired exit code

  """

  cl = GetClient()

  op = opcodes.OpClusterVerifyDisks()

  result = SubmitOpCode(op, cl=cl, opts=opts)

  # Keep track of submitted jobs

  jex = JobExecutor(cl=cl, opts=opts)

  for (status, job_id) in result[constants.JOB_IDS_KEY]:

    jex.AddJobId(None, status, job_id)

  retcode = constants.EXIT_SUCCESS

  for (status, result) in jex.GetResults():

    if not status:

      ToStdout("Job failed: %s", result)

      continue

    ((bad_nodes, instances, missing), ) = result

    for node, text in bad_nodes.items():

      ToStdout("Error gathering data on node %s: %s",

               node, utils.SafeEncode(text[-400:]))

      retcode = constants.EXIT_FAILURE

      ToStdout("You need to fix these nodes first before fixing instances")

    for iname in instances:

      if iname in missing:

        continue

      op = opcodes.OpInstanceActivateDisks(instance_name=iname)

      try:

        ToStdout("Activating disks for instance '%s'", iname)

        SubmitOpCode(op, opts=opts, cl=cl)

      except errors.GenericError, err:

        nret, msg = FormatError(err)

        retcode |= nret

        ToStderr("Error activating disks for instance %s: %s", iname, msg)

    if missing:

      for iname, ival in missing.iteritems():

        all_missing = compat.all(x[0] in bad_nodes for x in ival)

        if all_missing:

          ToStdout("Instance %s cannot be verified as it lives on"

                   " broken nodes", iname)

        else:

          ToStdout("Instance %s has missing logical volumes:", iname)

          ival.sort()

          for node, vol in ival:

            if node in bad_nodes:

              ToStdout("\tbroken node %s /dev/%s", node, vol)

            else:

              ToStdout("\t%s /dev/%s", node, vol)

      ToStdout("You need to replace or recreate disks for all the above"

               " instances if this message persists after fixing broken nodes.")

      retcode = constants.EXIT_FAILURE

  return retcode

def RepairDiskSizes(opts, args):

  """Verify sizes of cluster disks.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: optional list of instances to restrict check to

  @rtype: int

  @return: the desired exit code

  """

  op = opcodes.OpClusterRepairDiskSizes(instances=args)

  SubmitOpCode(op, opts=opts)

@UsesRPC

def MasterFailover(opts, args):

  """Failover the master node.

  This command, when run on a non-master node, will cause the current

  master to cease being master, and the non-master to become new

  master.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should be an empty list

  @rtype: int

  @return: the desired exit code

  """

  if opts.no_voting:

    usertext = ("This will perform the failover even if most other nodes"

                " are down, or if this node is outdated. This is dangerous"

                " as it can lead to a non-consistent cluster. Check the"

                " gnt-cluster(8) man page before proceeding. Continue?")

    if not AskUser(usertext):

      return 1

  return bootstrap.MasterFailover(no_voting=opts.no_voting)

def MasterPing(opts, args):

  """Checks if the master is alive.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should be an empty list

  @rtype: int

  @return: the desired exit code

  """

  try:

    cl = GetClient()

    cl.QueryClusterInfo()

    return 0

  except Exception: # pylint: disable=W0703

    return 1

def SearchTags(opts, args):

  """Searches the tags on all the cluster.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should contain only one element, the tag pattern

  @rtype: int

  @return: the desired exit code

  """

  op = opcodes.OpTagsSearch(pattern=args[0])

  result = SubmitOpCode(op, opts=opts)

  if not result:

    return 1

  result = list(result)

  result.sort()

  for path, tag in result:

    ToStdout("%s %s", path, tag)

def _ReadAndVerifyCert(cert_filename, verify_private_key=False):

  """Reads and verifies an X509 certificate.

  @type cert_filename: string

  @param cert_filename: the path of the file containing the certificate to

                        verify encoded in PEM format

  @type verify_private_key: bool

  @param verify_private_key: whether to verify the private key in addition to

                             the public certificate

  @rtype: string

  @return: a string containing the PEM-encoded certificate.

  """