Synnefo » snf-ganeti » ganeti-local

#

#

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

_SHUTDOWN_CLUSTER = "cluster"

_SHUTDOWN_NODES_BOTH = "nodes"

_SHUTDOWN_NODES_PRI = "nodes-pri"

_SHUTDOWN_NODES_SEC = "nodes-sec"

_SHUTDOWN_NODES_BOTH_BY_TAGS = "nodes-by-tags"

_SHUTDOWN_NODES_PRI_BY_TAGS = "nodes-pri-by-tags"

_SHUTDOWN_NODES_SEC_BY_TAGS = "nodes-sec-by-tags"

_SHUTDOWN_INSTANCES = "instances"

_SHUTDOWN_INSTANCES_BY_TAGS = "instances-by-tags"

_SHUTDOWN_NODES_TAGS_MODES = (

    _SHUTDOWN_NODES_BOTH_BY_TAGS,

    _SHUTDOWN_NODES_PRI_BY_TAGS,

    _SHUTDOWN_NODES_SEC_BY_TAGS)

#: default list of options for L{ListInstances}

_LIST_DEF_FIELDS = [

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

  ]

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

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

  For _SHUTDOWN_CLUSTER, all instances will be returned. For

  _SHUTDOWN_NODES_PRI/SEC, all instances having those nodes as

  primary/secondary will be returned. For _SHUTDOWN_NODES_BOTH, all

  instances having those nodes as either primary or secondary will be

  returned. For _SHUTDOWN_INSTANCES, the given instances will be

  returned.

  @param mode: one of L{_SHUTDOWN_CLUSTER}, L{_SHUTDOWN_NODES_BOTH},

      L{_SHUTDOWN_NODES_PRI}, L{_SHUTDOWN_NODES_SEC} or

      L{_SHUTDOWN_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-msg=W0142

  if client is None:

    client = GetClient()

  if mode == _SHUTDOWN_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 (_SHUTDOWN_NODES_BOTH,

                _SHUTDOWN_NODES_PRI,

                _SHUTDOWN_NODES_SEC) + _SHUTDOWN_NODES_TAGS_MODES:

    if mode in _SHUTDOWN_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 (_SHUTDOWN_NODES_BOTH, _SHUTDOWN_NODES_BOTH_BY_TAGS):

      inames = pri_names + sec_names

    elif mode in (_SHUTDOWN_NODES_PRI, _SHUTDOWN_NODES_PRI_BY_TAGS):

      inames = pri_names

    elif mode in (_SHUTDOWN_NODES_SEC, _SHUTDOWN_NODES_SEC_BY_TAGS):

      inames = sec_names

    else:

      raise errors.ProgrammerError("Unhandled shutdown type")

  elif mode == _SHUTDOWN_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 == _SHUTDOWN_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 = _SHUTDOWN_INSTANCES

    cl = GetClient()

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

    if not inames:

      if opts.multi_mode == _SHUTDOWN_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 != _SHUTDOWN_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",

                               "snodes"],

                              (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 instances defined

  in the form::

    {"instance-name":{

      "disk_size": [20480],

      "template": "drbd",

      "backend": {

        "memory": 512,

        "vcpus": 1 },

      "os": "debootstrap",

      "primary_node": "firstnode",

      "secondary_node": "secondnode",

      "iallocator": "dumb"}

    }

  Note that I{primary_node} and I{secondary_node} have precedence over

  I{iallocator}.

  @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

  """

  _DEFAULT_SPECS = {"disk_size": [20 * 1024],

                    "backend": {},

                    "iallocator": None,

                    "primary_node": None,

                    "secondary_node": None,

                    "nics": None,

                    "start": True,

                    "ip_check": True,

                    "name_check": True,

                    "hypervisor": None,

                    "hvparams": {},

                    "file_storage_dir": None,

                    "force_variant": False,

                    "file_driver": 'loop'}

  def _PopulateWithDefaults(spec):

    """Returns a new hash combined with default values."""

    mydict = _DEFAULT_SPECS.copy()

    mydict.update(spec)

    return mydict

  def _Validate(spec):

    """Validate the instance specs."""

    # Validate fields required under any circumstances

    for required_field in ('os', 'template'):

      if required_field not in spec:

        raise errors.OpPrereqError('Required field "%s" is missing.' %

                                   required_field, errors.ECODE_INVAL)

    # Validate special fields

    if spec['primary_node'] is not None:

      if (spec['template'] in constants.DTS_INT_MIRROR and

          spec['secondary_node'] is None):

        raise errors.OpPrereqError('Template requires secondary node, but'

                                   ' there was no secondary provided.',

                                   errors.ECODE_INVAL)

    elif spec['iallocator'] is None:

      raise errors.OpPrereqError('You have to provide at least a primary_node'

                                 ' or an iallocator.',

                                 errors.ECODE_INVAL)

    if (spec['hvparams'] and

        not isinstance(spec['hvparams'], dict)):

      raise errors.OpPrereqError('Hypervisor parameters must be a dict.',

                                 errors.ECODE_INVAL)

  json_filename = args[0]

  try:

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

  except Exception, err: # pylint: disable-msg=W0703

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

    return 1

  if not isinstance(instance_data, dict):

    ToStderr("The instance definition file is not in dict format.")

    return 1

  jex = JobExecutor(opts=opts)

  # Iterate over the instances and do:

  #  * Populate the specs with default value

  #  * Validate the instance specs

  i_names = utils.NiceSort(instance_data.keys()) # pylint: disable-msg=E1103

  for name in i_names:

    specs = instance_data[name]

    specs = _PopulateWithDefaults(specs)

    _Validate(specs)

    hypervisor = specs['hypervisor']

    hvparams = specs['hvparams']

    disks = []

    for elem in specs['disk_size']:

      try:

        size = utils.ParseUnit(elem)

      except (TypeError, ValueError), err:

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

                                   " instance %s: %s" %

                                   (elem, name, err), errors.ECODE_INVAL)

      disks.append({"size": size})

    utils.ForceDictType(specs['backend'], constants.BES_PARAMETER_TYPES)

    utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES)

    tmp_nics = []

    for field in constants.INIC_PARAMS:

      if field in specs:

        if not tmp_nics:

          tmp_nics.append({})

        tmp_nics[0][field] = specs[field]

    if specs['nics'] is not None and tmp_nics:

      raise errors.OpPrereqError("'nics' list incompatible with using"

                                 " individual nic fields as well",

                                 errors.ECODE_INVAL)

    elif specs['nics'] is not None:

      tmp_nics = specs['nics']

    elif not tmp_nics:

      tmp_nics = [{}]

    op = opcodes.OpInstanceCreate(instance_name=name,

                                  disks=disks,

                                  disk_template=specs['template'],

                                  mode=constants.INSTANCE_CREATE,

                                  os_type=specs['os'],

                                  force_variant=specs["force_variant"],

                                  pnode=specs['primary_node'],

                                  snode=specs['secondary_node'],

                                  nics=tmp_nics,

                                  start=specs['start'],

                                  ip_check=specs['ip_check'],

                                  name_check=specs['name_check'],

                                  wait_for_sync=True,

                                  iallocator=specs['iallocator'],

                                  hypervisor=hypervisor,

                                  hvparams=hvparams,

                                  beparams=specs['backend'],

                                  file_storage_dir=specs['file_storage_dir'],

                                  file_driver=specs['file_driver'])

    jex.QueueJob(name, op)

  # we never want to wait, just show the submitted job IDs

  jex.WaitOrShow(False)

  return 0

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 = _SHUTDOWN_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 != _SHUTDOWN_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)

  jex.WaitOrShow(not opts.submit_only)

  return 0

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)

  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]

  if opts.disks:

    try:

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

    except (ValueError, TypeError), err:

      ToStderr("Invalid disks value: %s" % str(err))

      return 1

  else:

    opts.disks = []

  if opts.node:

    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=opts.disks,

                                       nodes=nodes)

  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 two elements, the instance name

      whose disks we grow and the disk name, e.g. I{sda}

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

  amount = utils.ParseUnit(args[2])

  op = opcodes.OpInstanceGrowDisk(instance_name=instance,

                                  disk=disk, amount=amount,

                                  wait_for_sync=opts.wait_for_sync)

  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)

  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)

  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

  """

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

    if opts.cleanup:

      usertext = ("Instance %s will be recovered from a failed migration."

                  " Note that the migration procedure (including cleanup)" %

                  (instance_name,))

    else:

      usertext = ("Instance %s will be migrated. Note that migration" %

                  (instance_name,))

    usertext += (" might impact the instance if anything goes wrong"

                 " (e.g. due to bugs in the hypervisor). Continue?")

    if not AskUser(usertext):

      return 1

  # this should be removed once --non-live is deprecated

  if not opts.live and opts.migration_mode is not None:

    raise errors.OpPrereqError("Only one of the --non-live and "

                               "--migration-mode options can be passed",

                               errors.ECODE_INVAL)

  if not opts.live: # --non-live passed

    mode = constants.HT_MIGRATION_NONLIVE

  else:

    mode = opts.migration_mode

  op = opcodes.OpInstanceMigrate(instance_name=instance_name, mode=mode,

                                 cleanup=opts.cleanup, iallocator=iallocator,

                                 target_node=target_node,

                                 allow_failover=opts.allow_failover)

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

  return 0

def MoveInstance(opts, args):

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

  """

  cl = GetClient()

  instance_name = args[0]

  force = opts.force

  if not force:

    usertext = ("Instance %s will be moved."

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

                (instance_name,))

    if not AskUser(usertext):

      return 1

  op = opcodes.OpInstanceMove(instance_name=instance_name,

                              target_node=opts.node,

                              shutdown_timeout=opts.shutdown_timeout,

                              ignore_consistency=opts.ignore_consistency)

  SubmitOrSend(op, opts, cl=cl)

  return 0

def ConnectToInstanceConsole(opts, args):

  """Connect to the console 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

  """

  instance_name = args[0]

  cl = GetClient()

  try:

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

    ((console_data, oper_state), ) = \

      cl.QueryInstances([instance_name], ["console", "oper_state"], False)

  finally:

    # Ensure client connection is closed while external commands are run

    cl.Close()

  del cl

  if not console_data:

    if oper_state:

      # Instance is running

      raise errors.OpExecError("Console information for instance %s is"

                               " unavailable" % instance_name)

    else:

      raise errors.OpExecError("Instance %s is not running, can't get console" %

                               instance_name)

  return _DoConsole(objects.InstanceConsole.FromDict(console_data),

                    opts.show_command, cluster_name)

def _DoConsole(console, show_command, cluster_name, feedback_fn=ToStdout,

               _runcmd_fn=utils.RunCmd):

  """Acts based on the result of L{opcodes.OpInstanceConsole}.

  @type console: L{objects.InstanceConsole}

  @param console: Console object

  @type show_command: bool

  @param show_command: Whether to just display commands

  @type cluster_name: string

  @param cluster_name: Cluster name as retrieved from master daemon

  """

  assert console.Validate()

  if console.kind == constants.CONS_MESSAGE:

    feedback_fn(console.message)

  elif console.kind == constants.CONS_VNC:

    feedback_fn("Instance %s has VNC listening on %s:%s (display %s),"

                " URL <vnc://%s:%s/>",

                console.instance, console.host, console.port,

                console.display, console.host, console.port)

  elif console.kind == constants.CONS_SSH:

    # Convert to string if not already one

    if isinstance(console.command, basestring):

      cmd = console.command

    else:

      cmd = utils.ShellQuoteArgs(console.command)

    srun = ssh.SshRunner(cluster_name=cluster_name)

    ssh_cmd = srun.BuildCmd(console.host, console.user, cmd,

                            batch=True, quiet=False, tty=True)

    if show_command:

      feedback_fn(utils.ShellQuoteArgs(ssh_cmd))

    else:

      result = _runcmd_fn(ssh_cmd, interactive=True)

      if result.failed:

        logging.error("Console command \"%s\" failed with reason '%s' and"

                      " output %r", result.cmd, result.fail_reason,

                      result.output)

        raise errors.OpExecError("Connection to console of instance %s failed,"

                                 " please check cluster configuration" %

                                 console.instance)

  else:

    raise errors.GenericError("Unknown console type '%s'" % console.kind)

  return constants.EXIT_SUCCESS

def _FormatLogicalID(dev_type, logical_id, roman):

  """Formats the logical_id of a disk.

  """

  if dev_type == constants.LD_DRBD8:

    node_a, node_b, port, minor_a, minor_b, key = logical_id

    data = [

      ("nodeA", "%s, minor=%s" % (node_a, compat.TryToRoman(minor_a,

                                                            convert=roman))),

      ("nodeB", "%s, minor=%s" % (node_b, compat.TryToRoman(minor_b,

                                                            convert=roman))),

      ("port", compat.TryToRoman(port, convert=roman)),

      ("auth key", key),

      ]

  elif dev_type == constants.LD_LV:

    vg_name, lv_name = logical_id

    data = ["%s/%s" % (vg_name, lv_name)]

  else:

    data = [str(logical_id)]

  return data

def _FormatBlockDevInfo(idx, top_level, dev, static, roman):

  """Show block device information.

  This is only used by L{ShowInstanceConfig}, but it's too big to be

  left for an inline definition.

  @type idx: int

  @param idx: the index of the current disk

  @type top_level: boolean

  @param top_level: if this a top-level disk?

  @type dev: dict

  @param dev: dictionary with disk information

  @type static: boolean

  @param static: wheter the device information doesn't contain

      runtime information but only static data

  @type roman: boolean

  @param roman: whether to try to use roman integers

  @return: a list of either strings, tuples or lists

      (which should be formatted at a higher indent level)

  """

  def helper(dtype, status):

    """Format one line for physical device status.

    @type dtype: str

    @param dtype: a constant from the L{constants.LDS_BLOCK} set

    @type status: tuple

    @param status: a tuple as returned from L{backend.FindBlockDevice}

    @return: the string representing the status

    """

    if not status:

      return "not active"

    txt = ""

    (path, major, minor, syncp, estt, degr, ldisk_status) = status

    if major is None:

      major_string = "N/A"

    else:

      major_string = str(compat.TryToRoman(major, convert=roman))

    if minor is None:

      minor_string = "N/A"

    else:

      minor_string = str(compat.TryToRoman(minor, convert=roman))

    txt += ("%s (%s:%s)" % (path, major_string, minor_string))

    if dtype in (constants.LD_DRBD8, ):

      if syncp is not None:

        sync_text = "*RECOVERING* %5.2f%%," % syncp

        if estt:

          sync_text += " ETA %ss" % compat.TryToRoman(estt, convert=roman)

        else:

          sync_text += " ETA unknown"

      else:

        sync_text = "in sync"

      if degr:

        degr_text = "*DEGRADED*"

      else:

        degr_text = "ok"

      if ldisk_status == constants.LDS_FAULTY:

        ldisk_text = " *MISSING DISK*"

      elif ldisk_status == constants.LDS_UNKNOWN:

        ldisk_text = " *UNCERTAIN STATE*"

      else:

        ldisk_text = ""

      txt += (" %s, status %s%s" % (sync_text, degr_text, ldisk_text))

    elif dtype == constants.LD_LV:

      if ldisk_status == constants.LDS_FAULTY: