Synnefo » snf-ganeti

#

#

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

"""Instance related commands"""

# pylint: disable=W0401,W0614,C0103

# W0401: Wildcard import ganeti.cli

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

# C0103: Invalid name gnt-instance

import copy

import itertools

import simplejson

import logging

from cStringIO import StringIO

from ganeti.cli import *

from ganeti import opcodes

from ganeti import constants

from ganeti import compat

from ganeti import utils

from ganeti import errors

from ganeti import netutils

from ganeti import ssh

from ganeti import objects

from ganeti import ht

_EXPAND_CLUSTER = "cluster"

_EXPAND_NODES_BOTH = "nodes"

_EXPAND_NODES_PRI = "nodes-pri"

_EXPAND_NODES_SEC = "nodes-sec"

_EXPAND_NODES_BOTH_BY_TAGS = "nodes-by-tags"

_EXPAND_NODES_PRI_BY_TAGS = "nodes-pri-by-tags"

_EXPAND_NODES_SEC_BY_TAGS = "nodes-sec-by-tags"

_EXPAND_INSTANCES = "instances"

_EXPAND_INSTANCES_BY_TAGS = "instances-by-tags"

_EXPAND_NODES_TAGS_MODES = frozenset([

  _EXPAND_NODES_BOTH_BY_TAGS,

  _EXPAND_NODES_PRI_BY_TAGS,

  _EXPAND_NODES_SEC_BY_TAGS,

  ])

#: default list of options for L{ListInstances}

_LIST_DEF_FIELDS = [

  "name", "hypervisor", "os", "pnode", "status", "oper_ram",

  ]

_MISSING = object()

_ENV_OVERRIDE = frozenset(["list"])

_INST_DATA_VAL = ht.TListOf(ht.TDict)

def _ExpandMultiNames(mode, names, client=None):

  """Expand the given names using the passed mode.

  For _EXPAND_CLUSTER, all instances will be returned. For

  _EXPAND_NODES_PRI/SEC, all instances having those nodes as

  primary/secondary will be returned. For _EXPAND_NODES_BOTH, all

  instances having those nodes as either primary or secondary will be

  returned. For _EXPAND_INSTANCES, the given instances will be

  returned.

  @param mode: one of L{_EXPAND_CLUSTER}, L{_EXPAND_NODES_BOTH},

      L{_EXPAND_NODES_PRI}, L{_EXPAND_NODES_SEC} or

      L{_EXPAND_INSTANCES}

  @param names: a list of names; for cluster, it must be empty,

      and for node and instance it must be a list of valid item

      names (short names are valid as usual, e.g. node1 instead of

      node1.example.com)

  @rtype: list

  @return: the list of names after the expansion

  @raise errors.ProgrammerError: for unknown selection type

  @raise errors.OpPrereqError: for invalid input parameters

  """

  # pylint: disable=W0142

  if client is None:

    client = GetClient()

  if mode == _EXPAND_CLUSTER:

    if names:

      raise errors.OpPrereqError("Cluster filter mode takes no arguments",

                                 errors.ECODE_INVAL)

    idata = client.QueryInstances([], ["name"], False)

    inames = [row[0] for row in idata]

  elif (mode in _EXPAND_NODES_TAGS_MODES or

        mode in (_EXPAND_NODES_BOTH, _EXPAND_NODES_PRI, _EXPAND_NODES_SEC)):

    if mode in _EXPAND_NODES_TAGS_MODES:

      if not names:

        raise errors.OpPrereqError("No node tags passed", errors.ECODE_INVAL)

      ndata = client.QueryNodes([], ["name", "pinst_list",

                                     "sinst_list", "tags"], False)

      ndata = [row for row in ndata if set(row[3]).intersection(names)]

    else:

      if not names:

        raise errors.OpPrereqError("No node names passed", errors.ECODE_INVAL)

      ndata = client.QueryNodes(names, ["name", "pinst_list", "sinst_list"],

                                False)

    ipri = [row[1] for row in ndata]

    pri_names = list(itertools.chain(*ipri))

    isec = [row[2] for row in ndata]

    sec_names = list(itertools.chain(*isec))

    if mode in (_EXPAND_NODES_BOTH, _EXPAND_NODES_BOTH_BY_TAGS):

      inames = pri_names + sec_names

    elif mode in (_EXPAND_NODES_PRI, _EXPAND_NODES_PRI_BY_TAGS):

      inames = pri_names

    elif mode in (_EXPAND_NODES_SEC, _EXPAND_NODES_SEC_BY_TAGS):

      inames = sec_names

    else:

      raise errors.ProgrammerError("Unhandled shutdown type")

  elif mode == _EXPAND_INSTANCES:

    if not names:

      raise errors.OpPrereqError("No instance names passed",

                                 errors.ECODE_INVAL)

    idata = client.QueryInstances(names, ["name"], False)

    inames = [row[0] for row in idata]

  elif mode == _EXPAND_INSTANCES_BY_TAGS:

    if not names:

      raise errors.OpPrereqError("No instance tags passed",

                                 errors.ECODE_INVAL)

    idata = client.QueryInstances([], ["name", "tags"], False)

    inames = [row[0] for row in idata if set(row[1]).intersection(names)]

  else:

    raise errors.OpPrereqError("Unknown mode '%s'" % mode, errors.ECODE_INVAL)

  return inames

def _EnsureInstancesExist(client, names):

  """Check for and ensure the given instance names exist.

  This function will raise an OpPrereqError in case they don't

  exist. Otherwise it will exit cleanly.

  @type client: L{ganeti.luxi.Client}

  @param client: the client to use for the query

  @type names: list

  @param names: the list of instance names to query

  @raise errors.OpPrereqError: in case any instance is missing

  """

  # TODO: change LUInstanceQuery to that it actually returns None

  # instead of raising an exception, or devise a better mechanism

  result = client.QueryInstances(names, ["name"], False)

  for orig_name, row in zip(names, result):

    if row[0] is None:

      raise errors.OpPrereqError("Instance '%s' does not exist" % orig_name,

                                 errors.ECODE_NOENT)

def GenericManyOps(operation, fn):

  """Generic multi-instance operations.

  The will return a wrapper that processes the options and arguments

  given, and uses the passed function to build the opcode needed for

  the specific operation. Thus all the generic loop/confirmation code

  is abstracted into this function.

  """

  def realfn(opts, args):

    if opts.multi_mode is None:

      opts.multi_mode = _EXPAND_INSTANCES

    cl = GetClient()

    inames = _ExpandMultiNames(opts.multi_mode, args, client=cl)

    if not inames:

      if opts.multi_mode == _EXPAND_CLUSTER:

        ToStdout("Cluster is empty, no instances to shutdown")

        return 0

      raise errors.OpPrereqError("Selection filter does not match"

                                 " any instances", errors.ECODE_INVAL)

    multi_on = opts.multi_mode != _EXPAND_INSTANCES or len(inames) > 1

    if not (opts.force_multi or not multi_on

            or ConfirmOperation(inames, "instances", operation)):

      return 1

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

    for name in inames:

      op = fn(name, opts)

      jex.QueueJob(name, op)

    results = jex.WaitOrShow(not opts.submit_only)

    rcode = compat.all(row[0] for row in results)

    return int(not rcode)

  return realfn

def ListInstances(opts, args):

  """List instances and their properties.

  @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

  """

  selected_fields = ParseFields(opts.output, _LIST_DEF_FIELDS)

  fmtoverride = dict.fromkeys(["tags", "disk.sizes", "nic.macs", "nic.ips",

                               "nic.modes", "nic.links", "nic.bridges",

                               "nic.networks",

                               "snodes", "snodes.group", "snodes.group.uuid"],

                              (lambda value: ",".join(str(item)

                                                      for item in value),

                               False))

  return GenericList(constants.QR_INSTANCE, selected_fields, args, opts.units,

                     opts.separator, not opts.no_headers,

                     format_override=fmtoverride, verbose=opts.verbose,

                     force_filter=opts.force_filter)

def ListInstanceFields(opts, args):

  """List instance fields.

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

  @type args: list

  @param args: fields to list, or empty for all

  @rtype: int

  @return: the desired exit code

  """

  return GenericListFields(constants.QR_INSTANCE, args, opts.separator,

                           not opts.no_headers)

def AddInstance(opts, args):

  """Add an instance to the cluster.

  This is just a wrapper over GenericInstanceCreate.

  """

  return GenericInstanceCreate(constants.INSTANCE_CREATE, opts, args)

def BatchCreate(opts, args):

  """Create instances using a definition file.

  This function reads a json file with L{opcodes.OpInstanceCreate}

  serialisations.

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

  @type args: list

  @param args: should contain one element, the json filename

  @rtype: int

  @return: the desired exit code

  """

  (json_filename,) = args

  cl = GetClient()

  try:

    instance_data = simplejson.loads(utils.ReadFile(json_filename))

  except Exception, err: # pylint: disable=W0703

    ToStderr("Can't parse the instance definition file: %s" % str(err))

    return 1

  if not _INST_DATA_VAL(instance_data):

    ToStderr("The instance definition file is not %s" % _INST_DATA_VAL)

    return 1

  instances = []

  possible_params = set(opcodes.OpInstanceCreate.GetAllSlots())

  for (idx, inst) in enumerate(instance_data):

    unknown = set(inst.keys()) - possible_params

    if unknown:

      # TODO: Suggest closest match for more user friendly experience

      raise errors.OpPrereqError("Unknown fields in definition %s: %s" %

                                 (idx, utils.CommaJoin(unknown)),

                                 errors.ECODE_INVAL)

    op = opcodes.OpInstanceCreate(**inst) # pylint: disable=W0142

    op.Validate(False)

    instances.append(op)

  op = opcodes.OpInstanceMultiAlloc(iallocator=opts.iallocator,

                                    instances=instances)

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

  # 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_cnt = len([row for row in results if not row[0]])

  if bad_cnt == 0:

    ToStdout("All instances created successfully.")

    rcode = constants.EXIT_SUCCESS

  else:

    ToStdout("There were %s errors during the creation.", bad_cnt)

    rcode = constants.EXIT_FAILURE

  return rcode

def ReinstallInstance(opts, args):

  """Reinstall an instance.

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

  @type args: list

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

      instance to be reinstalled

  @rtype: int

  @return: the desired exit code

  """

  # first, compute the desired name list

  if opts.multi_mode is None:

    opts.multi_mode = _EXPAND_INSTANCES

  inames = _ExpandMultiNames(opts.multi_mode, args)

  if not inames:

    raise errors.OpPrereqError("Selection filter does not match any instances",

                               errors.ECODE_INVAL)

  # second, if requested, ask for an OS

  if opts.select_os is True:

    op = opcodes.OpOsDiagnose(output_fields=["name", "variants"], names=[])

    result = SubmitOpCode(op, opts=opts)

    if not result:

      ToStdout("Can't get the OS list")

      return 1

    ToStdout("Available OS templates:")

    number = 0

    choices = []

    for (name, variants) in result:

      for entry in CalculateOSNames(name, variants):

        ToStdout("%3s: %s", number, entry)

        choices.append(("%s" % number, entry, entry))

        number += 1

    choices.append(("x", "exit", "Exit gnt-instance reinstall"))

    selected = AskUser("Enter OS template number (or x to abort):",

                       choices)

    if selected == "exit":

      ToStderr("User aborted reinstall, exiting")

      return 1

    os_name = selected

    os_msg = "change the OS to '%s'" % selected

  else:

    os_name = opts.os

    if opts.os is not None:

      os_msg = "change the OS to '%s'" % os_name

    else:

      os_msg = "keep the same OS"

  # third, get confirmation: multi-reinstall requires --force-multi,

  # single-reinstall either --force or --force-multi (--force-multi is

  # a stronger --force)

  multi_on = opts.multi_mode != _EXPAND_INSTANCES or len(inames) > 1

  if multi_on:

    warn_msg = ("Note: this will remove *all* data for the"

                " below instances! It will %s.\n" % os_msg)

    if not (opts.force_multi or

            ConfirmOperation(inames, "instances", "reinstall", extra=warn_msg)):

      return 1

  else:

    if not (opts.force or opts.force_multi):

      usertext = ("This will reinstall the instance '%s' (and %s) which"

                  " removes all data. Continue?") % (inames[0], os_msg)

      if not AskUser(usertext):

        return 1

  jex = JobExecutor(verbose=multi_on, opts=opts)

  for instance_name in inames:

    op = opcodes.OpInstanceReinstall(instance_name=instance_name,

                                     os_type=os_name,

                                     force_variant=opts.force_variant,

                                     osparams=opts.osparams)

    jex.QueueJob(instance_name, op)

  results = jex.WaitOrShow(not opts.submit_only)

  if compat.all(map(compat.fst, results)):

    return constants.EXIT_SUCCESS

  else:

    return constants.EXIT_FAILURE

def RemoveInstance(opts, args):

  """Remove an instance.

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

  @type args: list

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

      the instance to be removed

  @rtype: int

  @return: the desired exit code

  """

  instance_name = args[0]

  force = opts.force

  cl = GetClient()

  if not force:

    _EnsureInstancesExist(cl, [instance_name])

    usertext = ("This will remove the volumes of the instance %s"

                " (including mirrors), thus removing all the data"

                " of the instance. Continue?") % instance_name

    if not AskUser(usertext):

      return 1

  op = opcodes.OpInstanceRemove(instance_name=instance_name,

                                ignore_failures=opts.ignore_failures,

                                shutdown_timeout=opts.shutdown_timeout)

  SubmitOrSend(op, opts, cl=cl)

  return 0

def RenameInstance(opts, args):

  """Rename an instance.

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

  @type args: list

  @param args: should contain two elements, the old and the

      new instance names

  @rtype: int

  @return: the desired exit code

  """

  if not opts.name_check:

    if not AskUser("As you disabled the check of the DNS entry, please verify"

                   " that '%s' is a FQDN. Continue?" % args[1]):

      return 1

  op = opcodes.OpInstanceRename(instance_name=args[0],

                                new_name=args[1],

                                ip_check=opts.ip_check,

                                name_check=opts.name_check)

  result = SubmitOrSend(op, opts)

  if result:

    ToStdout("Instance '%s' renamed to '%s'", args[0], result)

  return 0

def ActivateDisks(opts, args):

  """Activate an instance's disks.

  This serves two purposes:

    - it allows (as long as the instance is not running)

      mounting the disks and modifying them from the node

    - it repairs inactive secondary drbds

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

  @type args: list

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

  @rtype: int

  @return: the desired exit code

  """

  instance_name = args[0]

  op = opcodes.OpInstanceActivateDisks(instance_name=instance_name,

                                       ignore_size=opts.ignore_size,

                                       wait_for_sync=opts.wait_for_sync)

  disks_info = SubmitOrSend(op, opts)

  for host, iname, nname in disks_info:

    ToStdout("%s:%s:%s", host, iname, nname)

  return 0

def DeactivateDisks(opts, args):

  """Deactivate an instance's disks.

  This function takes the instance name, looks for its primary node

  and the tries to shutdown its block devices on that node.

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

  @type args: list

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

  @rtype: int

  @return: the desired exit code

  """

  instance_name = args[0]

  op = opcodes.OpInstanceDeactivateDisks(instance_name=instance_name,

                                         force=opts.force)

  SubmitOrSend(op, opts)

  return 0

def RecreateDisks(opts, args):

  """Recreate an instance's disks.

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

  @type args: list

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

  @rtype: int

  @return: the desired exit code

  """

  instance_name = args[0]

  disks = []

  if opts.disks:

    for didx, ddict in opts.disks:

      didx = int(didx)

      if not ht.TDict(ddict):

        msg = "Invalid disk/%d value: expected dict, got %s" % (didx, ddict)

        raise errors.OpPrereqError(msg, errors.ECODE_INVAL)

      if constants.IDISK_SIZE in ddict:

        try:

          ddict[constants.IDISK_SIZE] = \

            utils.ParseUnit(ddict[constants.IDISK_SIZE])

        except ValueError, err:

          raise errors.OpPrereqError("Invalid disk size for disk %d: %s" %

                                     (didx, err), errors.ECODE_INVAL)

      disks.append((didx, ddict))

    # TODO: Verify modifyable parameters (already done in

    # LUInstanceRecreateDisks, but it'd be nice to have in the client)

  if opts.node:

    if opts.iallocator:

      msg = "At most one of either --nodes or --iallocator can be passed"

      raise errors.OpPrereqError(msg, errors.ECODE_INVAL)

    pnode, snode = SplitNodeOption(opts.node)

    nodes = [pnode]

    if snode is not None:

      nodes.append(snode)

  else:

    nodes = []

  op = opcodes.OpInstanceRecreateDisks(instance_name=instance_name,

                                       disks=disks, nodes=nodes,

                                       iallocator=opts.iallocator)

  SubmitOrSend(op, opts)

  return 0

def GrowDisk(opts, args):

  """Grow an instance's disks.

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

  @type args: list

  @param args: should contain three elements, the target instance name,

      the target disk id, and the target growth

  @rtype: int

  @return: the desired exit code

  """

  instance = args[0]

  disk = args[1]

  try:

    disk = int(disk)

  except (TypeError, ValueError), err:

    raise errors.OpPrereqError("Invalid disk index: %s" % str(err),

                               errors.ECODE_INVAL)

  try:

    amount = utils.ParseUnit(args[2])

  except errors.UnitParseError:

    raise errors.OpPrereqError("Can't parse the given amount '%s'" % args[2],

                               errors.ECODE_INVAL)

  op = opcodes.OpInstanceGrowDisk(instance_name=instance,

                                  disk=disk, amount=amount,

                                  wait_for_sync=opts.wait_for_sync,

                                  absolute=opts.absolute)

  SubmitOrSend(op, opts)

  return 0

def _StartupInstance(name, opts):

  """Startup instances.

  This returns the opcode to start an instance, and its decorator will

  wrap this into a loop starting all desired instances.

  @param name: the name of the instance to act on

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

  @return: the opcode needed for the operation

  """

  op = opcodes.OpInstanceStartup(instance_name=name,

                                 force=opts.force,

                                 ignore_offline_nodes=opts.ignore_offline,

                                 no_remember=opts.no_remember,

                                 startup_paused=opts.startup_paused)

  # do not add these parameters to the opcode unless they're defined

  if opts.hvparams:

    op.hvparams = opts.hvparams

  if opts.beparams:

    op.beparams = opts.beparams

  return op

def _RebootInstance(name, opts):

  """Reboot instance(s).

  This returns the opcode to reboot an instance, and its decorator

  will wrap this into a loop rebooting all desired instances.

  @param name: the name of the instance to act on

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

  @return: the opcode needed for the operation

  """

  return opcodes.OpInstanceReboot(instance_name=name,

                                  reboot_type=opts.reboot_type,

                                  ignore_secondaries=opts.ignore_secondaries,

                                  shutdown_timeout=opts.shutdown_timeout)

def _ShutdownInstance(name, opts):

  """Shutdown an instance.

  This returns the opcode to shutdown an instance, and its decorator

  will wrap this into a loop shutting down all desired instances.

  @param name: the name of the instance to act on

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

  @return: the opcode needed for the operation

  """

  return opcodes.OpInstanceShutdown(instance_name=name,

                                    timeout=opts.timeout,

                                    ignore_offline_nodes=opts.ignore_offline,

                                    no_remember=opts.no_remember)

def ReplaceDisks(opts, args):

  """Replace the disks of an instance

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

  @type args: list

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

  @rtype: int

  @return: the desired exit code

  """

  new_2ndary = opts.dst_node

  iallocator = opts.iallocator

  if opts.disks is None:

    disks = []

  else:

    try:

      disks = [int(i) for i in opts.disks.split(",")]

    except (TypeError, ValueError), err:

      raise errors.OpPrereqError("Invalid disk index passed: %s" % str(err),

                                 errors.ECODE_INVAL)

  cnt = [opts.on_primary, opts.on_secondary, opts.auto,

         new_2ndary is not None, iallocator is not None].count(True)

  if cnt != 1:

    raise errors.OpPrereqError("One and only one of the -p, -s, -a, -n and -I"

                               " options must be passed", errors.ECODE_INVAL)

  elif opts.on_primary:

    mode = constants.REPLACE_DISK_PRI

  elif opts.on_secondary:

    mode = constants.REPLACE_DISK_SEC

  elif opts.auto:

    mode = constants.REPLACE_DISK_AUTO

    if disks:

      raise errors.OpPrereqError("Cannot specify disks when using automatic"

                                 " mode", errors.ECODE_INVAL)

  elif new_2ndary is not None or iallocator is not None:

    # replace secondary

    mode = constants.REPLACE_DISK_CHG

  op = opcodes.OpInstanceReplaceDisks(instance_name=args[0], disks=disks,

                                      remote_node=new_2ndary, mode=mode,

                                      iallocator=iallocator,

                                      early_release=opts.early_release,

                                      ignore_ipolicy=opts.ignore_ipolicy)

  SubmitOrSend(op, opts)

  return 0

def FailoverInstance(opts, args):

  """Failover an instance.

  The failover is done by shutting it down on its present node and

  starting it on the secondary.

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

  @type args: list

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

  @rtype: int

  @return: the desired exit code

  """

  cl = GetClient()

  instance_name = args[0]

  force = opts.force

  iallocator = opts.iallocator

  target_node = opts.dst_node

  if iallocator and target_node:

    raise errors.OpPrereqError("Specify either an iallocator (-I), or a target"

                               " node (-n) but not both", errors.ECODE_INVAL)

  if not force:

    _EnsureInstancesExist(cl, [instance_name])

    usertext = ("Failover will happen to image %s."

                " This requires a shutdown of the instance. Continue?" %

                (instance_name,))

    if not AskUser(usertext):

      return 1

  op = opcodes.OpInstanceFailover(instance_name=instance_name,

                                  ignore_consistency=opts.ignore_consistency,

                                  shutdown_timeout=opts.shutdown_timeout,

                                  iallocator=iallocator,

                                  target_node=target_node,

                                  ignore_ipolicy=opts.ignore_ipolicy)

  SubmitOrSend(op, opts, cl=cl)

  return 0

def MigrateInstance(opts, args):

  """Migrate an instance.

  The migrate is done without shutdown.

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

  @type args: list

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

  @rtype: int

  @return: the desired exit code