Synnefo » snf-ganeti » ganeti-local

#!/usr/bin/python

#

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

# pylint: disable-msg=W0401,W0614

# W0401: Wildcard import ganeti.cli

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

import sys

import os

import itertools

import simplejson

from optparse import make_option

from cStringIO import StringIO

from ganeti.cli import *

from ganeti import cli

from ganeti import opcodes

from ganeti import constants

from ganeti import utils

from ganeti import errors

_SHUTDOWN_CLUSTER = "cluster"

_SHUTDOWN_NODES_BOTH = "nodes"

_SHUTDOWN_NODES_PRI = "nodes-pri"

_SHUTDOWN_NODES_SEC = "nodes-sec"

_SHUTDOWN_INSTANCES = "instances"

_VALUE_TRUE = "true"

#: default list of options for L{ListInstances}

_LIST_DEF_FIELDS = [

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

  ]

def _ExpandMultiNames(mode, names):

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

  """

  if mode == _SHUTDOWN_CLUSTER:

    if names:

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

    client = GetClient()

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

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

  elif mode in (_SHUTDOWN_NODES_BOTH,

                _SHUTDOWN_NODES_PRI,

                _SHUTDOWN_NODES_SEC):

    if not names:

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

    client = GetClient()

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

    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 == _SHUTDOWN_NODES_BOTH:

      inames = pri_names + sec_names

    elif mode == _SHUTDOWN_NODES_PRI:

      inames = pri_names

    elif mode == _SHUTDOWN_NODES_SEC:

      inames = sec_names

    else:

      raise errors.ProgrammerError("Unhandled shutdown type")

  elif mode == _SHUTDOWN_INSTANCES:

    if not names:

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

    client = GetClient()

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

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

  else:

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

  return inames

def _ConfirmOperation(inames, text):

  """Ask the user to confirm an operation on a list of instances.

  This function is used to request confirmation for doing an operation

  on a given list of instances.

  @type inames: list

  @param inames: the list of names that we display when

      we ask for confirmation

  @type text: str

  @param text: the operation that the user should confirm

      (e.g. I{shutdown} or I{startup})

  @rtype: boolean

  @return: True or False depending on user's confirmation.

  """

  count = len(inames)

  msg = ("The %s will operate on %d instances.\n"

         "Do you want to continue?" % (text, count))

  affected = ("\nAffected instances:\n" +

              "\n".join(["  %s" % name for name in inames]))

  choices = [('y', True, 'Yes, execute the %s' % text),

             ('n', False, 'No, abort the %s' % text)]

  if count > 20:

    choices.insert(1, ('v', 'v', 'View the list of affected instances'))

    ask = msg

  else:

    ask = msg + affected

  choice = AskUser(ask, choices)

  if choice == 'v':

    choices.pop(1)

    choice = AskUser(msg + affected, choices)

  return choice

def _TransformPath(user_input):

  """Transform a user path into a canonical value.

  This function transforms the a path passed as textual information

  into the constants that the LU code expects.

  """

  if user_input:

    if user_input.lower() == "default":

      result_path = constants.VALUE_DEFAULT

    elif user_input.lower() == "none":

      result_path = constants.VALUE_NONE

    else:

      if not os.path.isabs(user_input):

        raise errors.OpPrereqError("Path '%s' is not an absolute filename" %

                                   user_input)

      result_path = user_input

  else:

    result_path = constants.VALUE_DEFAULT

  return result_path

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

  """

  if opts.output is None:

    selected_fields = _LIST_DEF_FIELDS

  elif opts.output.startswith("+"):

    selected_fields = _LIST_DEF_FIELDS + opts.output[1:].split(",")

  else:

    selected_fields = opts.output.split(",")

  output = GetClient().QueryInstances([], selected_fields)

  if not opts.no_headers:

    headers = {

      "name": "Instance", "os": "OS", "pnode": "Primary_node",

      "snodes": "Secondary_Nodes", "admin_state": "Autostart",

      "oper_state": "Running",

      "oper_ram": "Memory", "disk_template": "Disk_template",

      "ip": "IP_address", "mac": "MAC_address",

      "bridge": "Bridge",

      "sda_size": "Disk/0", "sdb_size": "Disk/1",

      "status": "Status", "tags": "Tags",

      "network_port": "Network_port",

      "hv/kernel_path": "Kernel_path",

      "hv/initrd_path": "Initrd_path",

      "hv/boot_order": "HVM_boot_order",

      "hv/acpi": "HVM_ACPI",

      "hv/pae": "HVM_PAE",

      "hv/cdrom_image_path": "HVM_CDROM_image_path",

      "hv/nic_type": "HVM_NIC_type",

      "hv/disk_type": "HVM_Disk_type",

      "hv/vnc_bind_address": "VNC_bind_address",

      "serial_no": "SerialNo", "hypervisor": "Hypervisor",

      "hvparams": "Hypervisor_parameters",

      "be/memory": "Configured_memory",

      "be/vcpus": "VCPUs",

      "be/auto_balance": "Auto_balance",

      "disk.count": "Disks", "disk.sizes": "Disk_sizes",

      "nic.count": "NICs", "nic.ips": "NIC_IPs",

      "nic.bridges": "NIC_bridges", "nic.macs": "NIC_MACs",

      }

  else:

    headers = None

  unitfields = ["be/memory", "oper_ram", "sd(a|b)_size", "disk\.size/.*"]

  numfields = ["be/memory", "oper_ram", "sd(a|b)_size", "be/vcpus",

               "serial_no", "(disk|nic)\.count", "disk\.size/.*"]

  list_type_fields = ("tags", "disk.sizes",

                      "nic.macs", "nic.ips", "nic.bridges")

  # change raw values to nicer strings

  for row in output:

    for idx, field in enumerate(selected_fields):

      val = row[idx]

      if field == "snodes":

        val = ",".join(val) or "-"

      elif field == "admin_state":

        if val:

          val = "yes"

        else:

          val = "no"

      elif field == "oper_state":

        if val is None:

          val = "(node down)"

        elif val: # True

          val = "running"

        else:

          val = "stopped"

      elif field == "oper_ram":

        if val is None:

          val = "(node down)"

      elif field == "sda_size" or field == "sdb_size":

        if val is None:

          val = "N/A"

      elif field in list_type_fields:

        val = ",".join(str(item) for item in val)

      elif val is None:

        val = "-"

      row[idx] = str(val)

  data = GenerateTable(separator=opts.separator, headers=headers,

                       fields=selected_fields, unitfields=unitfields,

                       numfields=numfields, data=output, units=opts.units)

  for line in data:

    ToStdout(line)

  return 0

def AddInstance(opts, args):

  """Add an instance to the cluster.

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

  @type args: list

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

  @rtype: int

  @return: the desired exit code

  """

  instance = args[0]

  (pnode, snode) = SplitNodeOption(opts.node)

  hypervisor = None

  hvparams = {}

  if opts.hypervisor:

    hypervisor, hvparams = opts.hypervisor

  if opts.nics:

    try:

      nic_max = max(int(nidx[0])+1 for nidx in opts.nics)

    except ValueError, err:

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

    nics = [{}] * nic_max

    for nidx, ndict in opts.nics.items():

      nidx = int(nidx)

      nics[nidx] = ndict

  elif opts.no_nics:

    # no nics

    nics = []

  else:

    # default of one nic, all auto

    nics = [{}]

  if opts.disk_template == constants.DT_DISKLESS:

    if opts.disks:

      raise errors.OpPrereqError("Diskless instance but disk"

                                 " information passed")

    disks = []

  else:

    if not opts.disks:

      raise errors.OpPrereqError("No disk information specified")

    try:

      disk_max = max(int(didx[0])+1 for didx in opts.disks)

    except ValueError, err:

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

    disks = [{}] * disk_max

    for didx, ddict in opts.disks:

      didx = int(didx)

      if "size" not in ddict:

        raise errors.OpPrereqError("Missing size for disk %d" % didx)

      try:

        ddict["size"] = utils.ParseUnit(ddict["size"])

      except ValueError, err:

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

                                   (didx, err))

      disks[didx] = ddict

  ValidateBeParams(opts.beparams)

##  kernel_path = _TransformPath(opts.kernel_path)

##  initrd_path = _TransformPath(opts.initrd_path)

##  hvm_acpi = opts.hvm_acpi == _VALUE_TRUE

##  hvm_pae = opts.hvm_pae == _VALUE_TRUE

##  if ((opts.hvm_cdrom_image_path is not None) and

##      (opts.hvm_cdrom_image_path.lower() == constants.VALUE_NONE)):

##    hvm_cdrom_image_path = None

##  else:

##    hvm_cdrom_image_path = opts.hvm_cdrom_image_path

  op = opcodes.OpCreateInstance(instance_name=instance,

                                disks=disks,

                                disk_template=opts.disk_template,

                                nics=nics,

                                mode=constants.INSTANCE_CREATE,

                                os_type=opts.os, pnode=pnode,

                                snode=snode,

                                start=opts.start, ip_check=opts.ip_check,

                                wait_for_sync=opts.wait_for_sync,

                                hypervisor=hypervisor,

                                hvparams=hvparams,

                                beparams=opts.beparams,

                                iallocator=opts.iallocator,

                                file_storage_dir=opts.file_storage_dir,

                                file_driver=opts.file_driver,

                                )

  SubmitOrSend(op, opts)

  return 0

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": 25,

      "swap_size": 1024,

      "template": "drbd",

      "backend": {

        "memory": 512,

        "vcpus": 1 },

      "os": "etch-image",

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

                    "swap_size": 4 * 1024,

                    "backend": {},

                    "iallocator": None,

                    "primary_node": None,

                    "secondary_node": None,

                    "ip": 'none',

                    "mac": 'auto',

                    "bridge": None,

                    "start": True,

                    "ip_check": True,

                    "hypervisor": None,

                    "file_storage_dir": None,

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

    # Validate special fields

    if spec['primary_node'] is not None:

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

          spec['secondary_node'] is None):

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

                                   ' there was no secondary provided.')

    elif spec['iallocator'] is None:

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

                                 ' or an iallocator.')

    if (spec['hypervisor'] and

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

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

  json_filename = args[0]

  fd = open(json_filename, 'r')

  try:

    instance_data = simplejson.load(fd)

  finally:

    fd.close()

  # Iterate over the instances and do:

  #  * Populate the specs with default value

  #  * Validate the instance specs

  for (name, specs) in instance_data.iteritems():

    specs = _PopulateWithDefaults(specs)

    _Validate(specs)

    hypervisor = None

    hvparams = {}

    if specs['hypervisor']:

      hypervisor, hvparams = specs['hypervisor'].iteritems()

    op = opcodes.OpCreateInstance(instance_name=name,

                                  disk_size=specs['disk_size'],

                                  swap_size=specs['swap_size'],

                                  disk_template=specs['template'],

                                  mode=constants.INSTANCE_CREATE,

                                  os_type=specs['os'],

                                  pnode=specs['primary_node'],

                                  snode=specs['secondary_node'],

                                  ip=specs['ip'], bridge=specs['bridge'],

                                  start=specs['start'],

                                  ip_check=specs['ip_check'],

                                  wait_for_sync=True,

                                  mac=specs['mac'],

                                  iallocator=specs['iallocator'],

                                  hypervisor=hypervisor,

                                  hvparams=hvparams,

                                  beparams=specs['backend'],

                                  file_storage_dir=specs['file_storage_dir'],

                                  file_driver=specs['file_driver'])

    ToStdout("%s: %s", name, cli.SendJob([op]))

  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

  """

  instance_name = args[0]

  if opts.select_os is True:

    op = opcodes.OpDiagnoseOS(output_fields=["name", "valid"], names=[])

    result = SubmitOpCode(op)

    if not result:

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

      return 1

    ToStdout("Available OS templates:")

    number = 0

    choices = []

    for entry in result:

      ToStdout("%3s: %s", number, entry[0])

      choices.append(("%s" % number, entry[0], entry[0]))

      number = number + 1

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

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

                       choices)

    if selected == 'exit':

      ToStdout("User aborted reinstall, exiting")

      return 1

    os_name = selected

  else:

    os_name = opts.os

  if not opts.force:

    usertext = ("This will reinstall the instance %s and remove"

                " all data. Continue?") % instance_name

    if not AskUser(usertext):

      return 1

  op = opcodes.OpReinstallInstance(instance_name=instance_name,

                                   os_type=os_name)

  SubmitOrSend(op, opts)

  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

  if not force:

    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.OpRemoveInstance(instance_name=instance_name,

                                ignore_failures=opts.ignore_failures)

  SubmitOrSend(op, opts)

  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

  """

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

                                new_name=args[1],

                                ignore_ip=opts.ignore_ip)

  SubmitOrSend(op, opts)

  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.OpActivateInstanceDisks(instance_name=instance_name)

  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.OpDeactivateInstanceDisks(instance_name=instance_name)

  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 ValueError, err:

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

  amount = utils.ParseUnit(args[2])

  op = opcodes.OpGrowDisk(instance_name=instance, disk=disk, amount=amount,

                          wait_for_sync=opts.wait_for_sync)

  SubmitOrSend(op, opts)

  return 0

def StartupInstance(opts, args):

  """Startup instances.

  Depending on the options given, this will start one or more

  instances.

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

  @type args: list

  @param args: the instance or node names based on which we

      create the final selection (in conjunction with the

      opts argument)

  @rtype: int

  @return: the desired exit code

  """

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

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

  if not (opts.force_multi or not multi_on

          or _ConfirmOperation(inames, "startup")):

    return 1

  for name in inames:

    op = opcodes.OpStartupInstance(instance_name=name,

                                   force=opts.force,

                                   extra_args=opts.extra_args)

    if multi_on:

      ToStdout("Starting up %s", name)

    try:

      SubmitOrSend(op, opts)

    except JobSubmittedException, err:

      _, txt = FormatError(err)

      ToStdout("%s", txt)

  return 0

def RebootInstance(opts, args):

  """Reboot instance(s).

  Depending on the parameters given, this will reboot one or more

  instances.

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

  @type args: list

  @param args: the instance or node names based on which we

      create the final selection (in conjunction with the

      opts argument)

  @rtype: int

  @return: the desired exit code

  """

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

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

  if not (opts.force_multi or not multi_on

          or _ConfirmOperation(inames, "reboot")):

    return 1

  for name in inames:

    op = opcodes.OpRebootInstance(instance_name=name,

                                  reboot_type=opts.reboot_type,

                                  ignore_secondaries=opts.ignore_secondaries)

    SubmitOrSend(op, opts)

  return 0

def ShutdownInstance(opts, args):

  """Shutdown an instance.

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

  @type args: list

  @param args: the instance or node names based on which we

      create the final selection (in conjunction with the

      opts argument)

  @rtype: int

  @return: the desired exit code

  """

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

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

  if not (opts.force_multi or not multi_on

          or _ConfirmOperation(inames, "shutdown")):

    return 1

  for name in inames:

    op = opcodes.OpShutdownInstance(instance_name=name)

    if multi_on:

      ToStdout("Shutting down %s", name)

    try:

      SubmitOrSend(op, opts)

    except JobSubmittedException, err:

      _, txt = FormatError(err)

      ToStdout("%s", txt)

  return 0

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

  """

  instance_name = args[0]

  new_2ndary = opts.new_secondary

  iallocator = opts.iallocator

  if opts.disks is None:

    disks = []

  else:

    try:

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

    except ValueError, err:

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

  if opts.on_primary == opts.on_secondary: # no -p or -s passed, or both passed

    mode = constants.REPLACE_DISK_ALL

  elif opts.on_primary: # only on primary:

    mode = constants.REPLACE_DISK_PRI

    if new_2ndary is not None or iallocator is not None:

      raise errors.OpPrereqError("Can't change secondary node on primary disk"

                                 " replacement")

  elif opts.on_secondary is not None or iallocator is not None:

    # only on secondary

    mode = constants.REPLACE_DISK_SEC

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

                              remote_node=new_2ndary, mode=mode,

                              iallocator=iallocator)

  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

  """

  instance_name = args[0]

  force = opts.force

  if not force:

    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.OpFailoverInstance(instance_name=instance_name,

                                  ignore_consistency=opts.ignore_consistency)

  SubmitOrSend(op, opts)

  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]

  op = opcodes.OpConnectConsole(instance_name=instance_name)

  cmd = SubmitOpCode(op)

  if opts.show_command:

    ToStdout("%s", utils.ShellQuoteArgs(cmd))

  else:

    try:

      os.execvp(cmd[0], cmd)

    finally:

      ToStderr("Can't run console command %s with arguments:\n'%s'",

               cmd[0], " ".join(cmd))

      os._exit(1)

def _FormatBlockDevInfo(buf, dev, indent_level, static):

  """Show block device information.

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

  left for an inline definition.

  @type buf: StringIO

  @param buf: buffer that will accumulate the output

  @type dev: dict

  @param dev: dictionary with disk information

  @type indent_level: int

  @param indent_level: the indendation level we are at, used for

      the layout of the device tree

  @type static: boolean

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

      runtime information but only static data

  """

  def helper(buf, dtype, status):

    """Format one line for physical device status.

    @type buf: StringIO

    @param buf: buffer that will accumulate the output

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

    """

    if not status:

      buf.write("not active\n")

    else:

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

      if major is None:

        major_string = "N/A"

      else:

        major_string = str(major)

      if minor is None:

        minor_string = "N/A"

      else:

        minor_string = str(minor)

      buf.write("%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 %ds" % estt

          else:

            sync_text += " ETA unknown"

        else:

          sync_text = "in sync"

        if degr:

          degr_text = "*DEGRADED*"

        else:

          degr_text = "ok"

        if ldisk:

          ldisk_text = " *MISSING DISK*"

        else:

          ldisk_text = ""

        buf.write(" %s, status %s%s" % (sync_text, degr_text, ldisk_text))

      elif dtype == constants.LD_LV:

        if ldisk:

          ldisk_text = " *FAILED* (failed drive?)"

        else:

          ldisk_text = ""

        buf.write(ldisk_text)

      buf.write("\n")

  if dev["iv_name"] is not None:

    data = "  - %s, " % dev["iv_name"]

  else:

    data = "  - "

  data += "access mode: %s, " % dev["mode"]

  data += "type: %s" % dev["dev_type"]

  if dev["logical_id"] is not None:

    data += ", logical_id: %s" % (dev["logical_id"],)

  elif dev["physical_id"] is not None:

    data += ", physical_id: %s" % (dev["physical_id"],)

  buf.write("%*s%s\n" % (2*indent_level, "", data))

  if not static:

    buf.write("%*s    primary:   " % (2*indent_level, ""))

    helper(buf, dev["dev_type"], dev["pstatus"])

  if dev["sstatus"] and not static:

    buf.write("%*s    secondary: " % (2*indent_level, ""))

    helper(buf, dev["dev_type"], dev["sstatus"])

  if dev["children"]:

    for child in dev["children"]:

      _FormatBlockDevInfo(buf, child, indent_level+1, static)

def ShowInstanceConfig(opts, args):

  """Compute instance run-time status.

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

  @type args: list

  @param args: either an empty list, and then we query all

      instances, or should contain a list of instance names

  @rtype: int

  @return: the desired exit code

  """

  retcode = 0

  op = opcodes.OpQueryInstanceData(instances=args, static=opts.static)

  result = SubmitOpCode(op)

  if not result:

    ToStdout("No instances.")

    return 1

  buf = StringIO()

  retcode = 0

  for instance_name in result:

    instance = result[instance_name]

    buf.write("Instance name: %s\n" % instance["name"])

    buf.write("State: configured to be %s" % instance["config_state"])

    if not opts.static:

      buf.write(", actual state is %s" % instance["run_state"])

    buf.write("\n")

    ##buf.write("Considered for memory checks in cluster verify: %s\n" %

    ##          instance["auto_balance"])

    buf.write("  Nodes:\n")