Sort the instance names in batcher
[ganeti-local] / scripts / gnt-instance
index d89cce9..80afc41 100755 (executable)
 # 02110-1301, USA.
 
 
 # 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 sys
 import os
 import itertools
+import simplejson
 from optparse import make_option
 from cStringIO import StringIO
 
 from ganeti.cli import *
 from optparse import make_option
 from cStringIO import StringIO
 
 from ganeti.cli import *
+from ganeti import cli
 from ganeti import opcodes
 from ganeti import opcodes
-from ganeti import logger
 from ganeti import constants
 from ganeti import utils
 from ganeti import errors
 from ganeti import constants
 from ganeti import utils
 from ganeti import errors
@@ -39,30 +44,43 @@ _SHUTDOWN_NODES_PRI = "nodes-pri"
 _SHUTDOWN_NODES_SEC = "nodes-sec"
 _SHUTDOWN_INSTANCES = "instances"
 
 _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.
 
 def _ExpandMultiNames(mode, names):
   """Expand the given names using the passed mode.
 
-  Args:
-    - mode, which can be one of _SHUTDOWN_CLUSTER, _SHUTDOWN_NODES_BOTH,
-      _SHUTDOWN_NODES_PRI, _SHUTDOWN_NODES_SEC or _SHUTDOWN_INSTANCES
-    - names, which is 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)
-
   For _SHUTDOWN_CLUSTER, all instances will be returned. For
   _SHUTDOWN_NODES_PRI/SEC, all instances having those nodes as
   For _SHUTDOWN_CLUSTER, all instances will be returned. For
   _SHUTDOWN_NODES_PRI/SEC, all instances having those nodes as
-  primary/secondary will be shutdown. For _SHUTDOWN_NODES_BOTH, all
+  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.
 
   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")
   """
   if mode == _SHUTDOWN_CLUSTER:
     if names:
       raise errors.OpPrereqError("Cluster filter mode takes no arguments")
-    op = opcodes.OpQueryInstances(output_fields=["name"], names=[])
-    idata = SubmitOpCode(op)
+    client = GetClient()
+    idata = client.QueryInstances([], ["name"])
     inames = [row[0] for row in idata]
 
   elif mode in (_SHUTDOWN_NODES_BOTH,
     inames = [row[0] for row in idata]
 
   elif mode in (_SHUTDOWN_NODES_BOTH,
@@ -70,9 +88,8 @@ def _ExpandMultiNames(mode, names):
                 _SHUTDOWN_NODES_SEC):
     if not names:
       raise errors.OpPrereqError("No node names passed")
                 _SHUTDOWN_NODES_SEC):
     if not names:
       raise errors.OpPrereqError("No node names passed")
-    op = opcodes.OpQueryNodes(output_fields=["name", "pinst_list",
-                                             "sinst_list"], names=names)
-    ndata = SubmitOpCode(op)
+    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]
     ipri = [row[1] for row in ndata]
     pri_names = list(itertools.chain(*ipri))
     isec = [row[2] for row in ndata]
@@ -89,8 +106,8 @@ def _ExpandMultiNames(mode, names):
   elif mode == _SHUTDOWN_INSTANCES:
     if not names:
       raise errors.OpPrereqError("No instance names passed")
   elif mode == _SHUTDOWN_INSTANCES:
     if not names:
       raise errors.OpPrereqError("No instance names passed")
-    op = opcodes.OpQueryInstances(output_fields=["name"], names=names)
-    idata = SubmitOpCode(op)
+    client = GetClient()
+    idata = client.QueryInstances(names, ["name"])
     inames = [row[0] for row in idata]
 
   else:
     inames = [row[0] for row in idata]
 
   else:
@@ -105,11 +122,14 @@ def _ConfirmOperation(inames, text):
   This function is used to request confirmation for doing an operation
   on a given list of instances.
 
   This function is used to request confirmation for doing an operation
   on a given list of instances.
 
-  The inames argument is what the selection algorithm computed, and
-  the text argument is the operation we should tell the user to
-  confirm (e.g. 'shutdown' or 'startup').
-
-  Returns: boolean depending on user's confirmation.
+  @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)
 
   """
   count = len(inames)
@@ -130,7 +150,7 @@ def _ConfirmOperation(inames, text):
   choice = AskUser(ask, choices)
   if choice == 'v':
     choices.pop(1)
   choice = AskUser(ask, choices)
   if choice == 'v':
     choices.pop(1)
-    choice = AskUser(choices, msg + affected)
+    choice = AskUser(msg + affected, choices)
   return choice
 
 
   return choice
 
 
@@ -160,34 +180,60 @@ def _TransformPath(user_input):
 def ListInstances(opts, args):
   """List instances and their properties.
 
 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:
   """
   if opts.output is None:
-    selected_fields = ["name", "os", "pnode", "admin_state",
-                       "oper_state", "oper_ram"]
+    selected_fields = _LIST_DEF_FIELDS
+  elif opts.output.startswith("+"):
+    selected_fields = _LIST_DEF_FIELDS + opts.output[1:].split(",")
   else:
     selected_fields = opts.output.split(",")
 
   else:
     selected_fields = opts.output.split(",")
 
-  op = opcodes.OpQueryInstances(output_fields=selected_fields, names=[])
-  output = SubmitOpCode(op)
+  output = GetClient().QueryInstances([], selected_fields)
 
   if not opts.no_headers:
 
   if not opts.no_headers:
-    headers = {"name": "Instance", "os": "OS", "pnode": "Primary_node",
-               "snodes": "Secondary_Nodes", "admin_state": "Autostart",
-               "oper_state": "Status", "admin_ram": "Configured_memory",
-               "oper_ram": "Memory", "disk_template": "Disk_template",
-               "ip": "IP Address", "mac": "MAC Address",
-               "bridge": "Bridge",
-               "sda_size": "Disk/0", "sdb_size": "Disk/1"}
+    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
 
   else:
     headers = None
 
-  if opts.human_readable:
-    unitfields = ["admin_ram", "oper_ram", "sda_size", "sdb_size"]
-  else:
-    unitfields = None
-
-  numfields = ["admin_ram", "oper_ram", "sda_size", "sdb_size"]
+  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):
   # change raw values to nicer strings
   for row in output:
     for idx, field in enumerate(selected_fields):
@@ -212,14 +258,18 @@ def ListInstances(opts, args):
       elif field == "sda_size" or field == "sdb_size":
         if val is None:
           val = "N/A"
       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,
       row[idx] = str(val)
 
   data = GenerateTable(separator=opts.separator, headers=headers,
                        fields=selected_fields, unitfields=unitfields,
-                       numfields=numfields, data=output)
+                       numfields=numfields, data=output, units=opts.units)
 
   for line in data:
 
   for line in data:
-    logger.ToStdout(line)
+    ToStdout(line)
 
   return 0
 
 
   return 0
 
@@ -227,50 +277,263 @@ def ListInstances(opts, args):
 def AddInstance(opts, args):
   """Add an instance to the cluster.
 
 def AddInstance(opts, args):
   """Add an instance to the cluster.
 
-  Args:
-    opts - class with options as members
-    args - list with a single element, the instance name
-  Opts used:
-    mem - amount of memory to allocate to instance (MiB)
-    size - amount of disk space to allocate to instance (MiB)
-    os - which OS to run on instance
-    node - node to run new instance on
+  @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)
 
 
   """
   instance = args[0]
 
   (pnode, snode) = SplitNodeOption(opts.node)
 
-  kernel_path = _TransformPath(opts.kernel_path)
-  initrd_path = _TransformPath(opts.initrd_path)
-
-  op = opcodes.OpCreateInstance(instance_name=instance, mem_size=opts.mem,
-                                disk_size=opts.size, swap_size=opts.swap,
+  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,
                                 disk_template=opts.disk_template,
+                                nics=nics,
                                 mode=constants.INSTANCE_CREATE,
                                 os_type=opts.os, pnode=pnode,
                                 mode=constants.INSTANCE_CREATE,
                                 os_type=opts.os, pnode=pnode,
-                                snode=snode, vcpus=opts.vcpus,
-                                ip=opts.ip, bridge=opts.bridge,
+                                snode=snode,
                                 start=opts.start, ip_check=opts.ip_check,
                                 wait_for_sync=opts.wait_for_sync,
                                 start=opts.start, ip_check=opts.ip_check,
                                 wait_for_sync=opts.wait_for_sync,
-                                mac=opts.mac,
-                                kernel_path=kernel_path,
-                                initrd_path=initrd_path,
-                                hvm_boot_order=opts.hvm_boot_order)
-  SubmitOpCode(op)
+                                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": [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,
+                    "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
+  i_names = utils.NiceSort(instance_data.keys())
+  for name in i_names:
+    specs = instance_data[name]
+    specs = _PopulateWithDefaults(specs)
+    _Validate(specs)
+
+    hypervisor = None
+    hvparams = {}
+    if specs['hypervisor']:
+      hypervisor, hvparams = specs['hypervisor'].iteritems()
+
+    disks = []
+    for elem in specs['disk_size']:
+      try:
+        size = utils.ParseUnit(elem)
+      except ValueError, err:
+        raise errors.OpPrereqError("Invalid disk size '%s' for"
+                                   " instance %s: %s" %
+                                   (elem, name, err))
+      disks.append({"size": size})
+
+    nic0 = {'ip': specs['ip'], 'bridge': specs['bridge'], 'mac': specs['mac']}
+
+    op = opcodes.OpCreateInstance(instance_name=name,
+                                  disks=disks,
+                                  disk_template=specs['template'],
+                                  mode=constants.INSTANCE_CREATE,
+                                  os_type=specs['os'],
+                                  pnode=specs['primary_node'],
+                                  snode=specs['secondary_node'],
+                                  nics=[nic0],
+                                  start=specs['start'],
+                                  ip_check=specs['ip_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'])
+
+    ToStdout("%s: %s", name, cli.SendJob([op]))
+
   return 0
 
 
 def ReinstallInstance(opts, args):
   """Reinstall an instance.
 
   return 0
 
 
 def ReinstallInstance(opts, args):
   """Reinstall an instance.
 
-  Args:
-    opts - class with options as members
-    args - list containing a single element, the instance name
+  @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]
 
 
   """
   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 opts.force:
     usertext = ("This will reinstall the instance %s and remove"
                 " all data. Continue?") % instance_name
@@ -278,8 +541,8 @@ def ReinstallInstance(opts, args):
       return 1
 
   op = opcodes.OpReinstallInstance(instance_name=instance_name,
       return 1
 
   op = opcodes.OpReinstallInstance(instance_name=instance_name,
-                                   os_type=opts.os)
-  SubmitOpCode(op)
+                                   os_type=os_name)
+  SubmitOrSend(op, opts)
 
   return 0
 
 
   return 0
 
@@ -287,9 +550,12 @@ def ReinstallInstance(opts, args):
 def RemoveInstance(opts, args):
   """Remove an instance.
 
 def RemoveInstance(opts, args):
   """Remove an instance.
 
-  Args:
-    opts - class with options as members
-    args - list containing a single element, the instance name
+  @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]
 
   """
   instance_name = args[0]
@@ -304,23 +570,25 @@ def RemoveInstance(opts, args):
 
   op = opcodes.OpRemoveInstance(instance_name=instance_name,
                                 ignore_failures=opts.ignore_failures)
 
   op = opcodes.OpRemoveInstance(instance_name=instance_name,
                                 ignore_failures=opts.ignore_failures)
-  SubmitOpCode(op)
+  SubmitOrSend(op, opts)
   return 0
 
 
 def RenameInstance(opts, args):
   """Rename an instance.
 
   return 0
 
 
 def RenameInstance(opts, args):
   """Rename an instance.
 
-  Args:
-    opts - class with options as members
-    args - list containing two elements, the instance name and the new name
+  @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)
 
   """
   op = opcodes.OpRenameInstance(instance_name=args[0],
                                 new_name=args[1],
                                 ignore_ip=opts.ignore_ip)
-  SubmitOpCode(op)
-
+  SubmitOrSend(op, opts)
   return 0
 
 
   return 0
 
 
@@ -328,38 +596,81 @@ def ActivateDisks(opts, args):
   """Activate an instance's disks.
 
   This serves two purposes:
   """Activate an instance's disks.
 
   This serves two purposes:
-    - it allows one (as long as the instance is not running) to mount
-    the disks and modify them from the node
+    - it allows (as long as the instance is not running)
+      mounting the disks and modifying them from the node
     - it repairs inactive secondary drbds
 
     - 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)
   """
   instance_name = args[0]
   op = opcodes.OpActivateInstanceDisks(instance_name=instance_name)
-  disks_info = SubmitOpCode(op)
+  disks_info = SubmitOrSend(op, opts)
   for host, iname, nname in disks_info:
   for host, iname, nname in disks_info:
-    print "%s:%s:%s" % (host, iname, nname)
+    ToStdout("%s:%s:%s", host, iname, nname)
   return 0
 
 
 def DeactivateDisks(opts, args):
   return 0
 
 
 def DeactivateDisks(opts, args):
-  """Command-line interface for _ShutdownInstanceBlockDevices.
+  """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.
 
 
   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)
   """
   instance_name = args[0]
   op = opcodes.OpDeactivateInstanceDisks(instance_name=instance_name)
-  SubmitOpCode(op)
+  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):
   return 0
 
 
 def StartupInstance(opts, args):
-  """Startup an instance.
+  """Startup instances.
 
 
-  Args:
-    opts - class with options as members
-    args - list containing a single element, the instance name
+  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:
 
   """
   if opts.multi_mode is None:
@@ -376,16 +687,28 @@ def StartupInstance(opts, args):
                                    force=opts.force,
                                    extra_args=opts.extra_args)
     if multi_on:
                                    force=opts.force,
                                    extra_args=opts.extra_args)
     if multi_on:
-      logger.ToStdout("Starting up %s" % name)
-    SubmitOpCode(op)
+      ToStdout("Starting up %s", name)
+    try:
+      SubmitOrSend(op, opts)
+    except JobSubmittedException, err:
+      _, txt = FormatError(err)
+      ToStdout("%s", txt)
   return 0
 
   return 0
 
+
 def RebootInstance(opts, args):
 def RebootInstance(opts, args):
-  """Reboot an instance
+  """Reboot instance(s).
 
 
-  Args:
-    opts - class with options as members
-    args - list containing a single element, the instance name
+  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:
 
   """
   if opts.multi_mode is None:
@@ -402,15 +725,20 @@ def RebootInstance(opts, args):
                                   reboot_type=opts.reboot_type,
                                   ignore_secondaries=opts.ignore_secondaries)
 
                                   reboot_type=opts.reboot_type,
                                   ignore_secondaries=opts.ignore_secondaries)
 
-    SubmitOpCode(op)
+    SubmitOrSend(op, opts)
   return 0
 
   return 0
 
+
 def ShutdownInstance(opts, args):
   """Shutdown an instance.
 
 def ShutdownInstance(opts, args):
   """Shutdown an instance.
 
-  Args:
-    opts - class with options as members
-    args - list containing a single element, the instance name
+  @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:
 
   """
   if opts.multi_mode is None:
@@ -425,68 +753,52 @@ def ShutdownInstance(opts, args):
   for name in inames:
     op = opcodes.OpShutdownInstance(instance_name=name)
     if multi_on:
   for name in inames:
     op = opcodes.OpShutdownInstance(instance_name=name)
     if multi_on:
-      logger.ToStdout("Shutting down %s" % name)
-    SubmitOpCode(op)
-  return 0
-
-
-def AddMDDRBDComponent(opts, args):
-  """Add a new component to a remote_raid1 disk.
-
-  Args:
-    opts - class with options as members
-    args - list with a single element, the instance name
-
-  """
-  op = opcodes.OpAddMDDRBDComponent(instance_name=args[0],
-                                    disk_name=opts.disk,
-                                    remote_node=opts.node)
-  SubmitOpCode(op)
-  return 0
-
-
-def RemoveMDDRBDComponent(opts, args):
-  """Remove a component from a remote_raid1 disk.
-
-  Args:
-    opts - class with options as members
-    args - list with a single element, the instance name
-
-  """
-  op = opcodes.OpRemoveMDDRBDComponent(instance_name=args[0],
-                                       disk_name=opts.disk,
-                                       disk_id=opts.port)
-  SubmitOpCode(op)
+      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
 
   return 0
 
 
 def ReplaceDisks(opts, args):
   """Replace the disks of an instance
 
-  Args:
-    opts - class with options as members
-    args - list with a single element, the instance name
+  @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
 
   """
   instance_name = args[0]
   new_2ndary = opts.new_secondary
+  iallocator = opts.iallocator
   if opts.disks is None:
   if opts.disks is None:
-    disks = ["sda", "sdb"]
+    disks = []
   else:
   else:
-    disks = opts.disks.split(",")
-  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:
+    try:
+      disks = [int(i) for i in opts.disks.split(",")]
+    except ValueError, err:
+      raise errors.OpPrereqError("Invalid disk index passed: %s" % str(err))
+  cnt = [opts.on_primary, opts.on_secondary,
+         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, -n and -i"
+                               " options must be passed")
+  elif opts.on_primary:
     mode = constants.REPLACE_DISK_PRI
     mode = constants.REPLACE_DISK_PRI
-    if new_2ndary is not None:
-      raise errors.OpPrereqError("Can't change secondary node on primary disk"
-                                 " replacement")
-  elif opts.on_secondary is not None: # only on secondary
+  elif opts.on_secondary:
     mode = constants.REPLACE_DISK_SEC
     mode = constants.REPLACE_DISK_SEC
+  elif new_2ndary is not None or iallocator is not None:
+    # replace secondary
+    mode = constants.REPLACE_DISK_CHG
 
   op = opcodes.OpReplaceDisks(instance_name=args[0], disks=disks,
 
   op = opcodes.OpReplaceDisks(instance_name=args[0], disks=disks,
-                              remote_node=new_2ndary, mode=mode)
-  SubmitOpCode(op)
+                              remote_node=new_2ndary, mode=mode,
+                              iallocator=iallocator)
+  SubmitOrSend(op, opts)
   return 0
 
 
   return 0
 
 
@@ -496,11 +808,11 @@ def FailoverInstance(opts, args):
   The failover is done by shutting it down on its present node and
   starting it on the secondary.
 
   The failover is done by shutting it down on its present node and
   starting it on the secondary.
 
-  Args:
-    opts - class with options as members
-    args - list with a single element, the instance name
-  Opts used:
-    force - whether to failover without asking questions.
+  @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]
 
   """
   instance_name = args[0]
@@ -515,6 +827,41 @@ def FailoverInstance(opts, args):
 
   op = opcodes.OpFailoverInstance(instance_name=instance_name,
                                   ignore_consistency=opts.ignore_consistency)
 
   op = opcodes.OpFailoverInstance(instance_name=instance_name,
                                   ignore_consistency=opts.ignore_consistency)
+  SubmitOrSend(op, opts)
+  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
+
+  """
+  instance_name = args[0]
+  force = opts.force
+
+  if not force:
+    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 += (" is **experimental** in this version."
+                " This might impact the instance if anything goes wrong."
+                " Continue?")
+    if not AskUser(usertext):
+      return 1
+
+  op = opcodes.OpMigrateInstance(instance_name=instance_name, live=opts.live,
+                                 cleanup=opts.cleanup)
   SubmitOpCode(op)
   return 0
 
   SubmitOpCode(op)
   return 0
 
@@ -522,97 +869,201 @@ def FailoverInstance(opts, args):
 def ConnectToInstanceConsole(opts, args):
   """Connect to the console of an instance.
 
 def ConnectToInstanceConsole(opts, args):
   """Connect to the console of an instance.
 
-  Args:
-    opts - class with options as members
-    args - list with a single element, the instance name
+  @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)
 
   """
   instance_name = args[0]
 
   op = opcodes.OpConnectConsole(instance_name=instance_name)
-  cmd, argv = SubmitOpCode(op)
-  # drop lock and exec so other commands can run while we have console
-  utils.Unlock("cmd")
-  try:
-    os.execvp(cmd, argv)
-  finally:
-    sys.stderr.write("Can't run console command %s with arguments:\n'%s'" %
-                     (cmd, " ".join(argv)))
-    os._exit(1)
+  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 _FormatLogicalID(dev_type, logical_id):
+  """Formats the logical_id of a disk.
 
 
-def _FormatBlockDevInfo(buf, dev, indent_level):
+  """
+  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, minor_a)),
+      ("nodeB", "%s, minor=%s" % (node_b, minor_b)),
+      ("port", port),
+      ("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):
   """Show block device information.
 
   """Show block device information.
 
-  This is only used by ShowInstanceConfig(), but it's too big to be
+  This is only used by L{ShowInstanceConfig}, but it's too big to be
   left for an inline definition.
 
   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
+  @return: a list of either strings, tuples or lists
+      (which should be formatted at a higher indent level)
+
   """
   """
-  def helper(buf, dtype, status):
-    """Format one line for phsyical device status."""
+  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:
     if not status:
-      buf.write("not active\n")
+      return "not active"
+    txt = ""
+    (path, major, minor, syncp, estt, degr, ldisk) = status
+    if major is None:
+      major_string = "N/A"
     else:
     else:
-      (path, major, minor, syncp, estt, degr, ldisk) = status
-      buf.write("%s (%d:%d)" % (path, major, minor))
-      if dtype in (constants.LD_MD_R1, constants.LD_DRBD7, 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")
+      major_string = str(major)
 
 
-  if dev["iv_name"] is not None:
-    data = "  - %s, " % dev["iv_name"]
+    if minor is None:
+      minor_string = "N/A"
+    else:
+      minor_string = str(minor)
+
+    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 %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 = ""
+      txt += (" %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 = ""
+      txt += ldisk_text
+    return txt
+
+  # the header
+  if top_level:
+    if dev["iv_name"] is not None:
+      txt = dev["iv_name"]
+    else:
+      txt = "disk %d" % idx
   else:
   else:
-    data = "  - "
-  data += "type: %s" % dev["dev_type"]
+    txt = "child %d" % idx
+  d1 = ["- %s: %s" % (txt, dev["dev_type"])]
+  data = []
+  if top_level:
+    data.append(("access mode", dev["mode"]))
   if dev["logical_id"] is not None:
   if dev["logical_id"] is not None:
-    data += ", logical_id: %s" % (dev["logical_id"],)
+    try:
+      l_id = _FormatLogicalID(dev["dev_type"], dev["logical_id"])
+    except ValueError:
+      l_id = [str(dev["logical_id"])]
+    if len(l_id) == 1:
+      data.append(("logical_id", l_id[0]))
+    else:
+      data.extend(l_id)
   elif dev["physical_id"] is not None:
   elif dev["physical_id"] is not None:
-    data += ", physical_id: %s" % (dev["physical_id"],)
-  buf.write("%*s%s\n" % (2*indent_level, "", data))
-  buf.write("%*s    primary:   " % (2*indent_level, ""))
-  helper(buf, dev["dev_type"], dev["pstatus"])
-
-  if dev["sstatus"]:
-    buf.write("%*s    secondary: " % (2*indent_level, ""))
-    helper(buf, dev["dev_type"], dev["sstatus"])
+    data.append("physical_id:")
+    data.append([dev["physical_id"]])
+  if not static:
+    data.append(("on primary", helper(dev["dev_type"], dev["pstatus"])))
+  if dev["sstatus"] and not static:
+    data.append(("on secondary", helper(dev["dev_type"], dev["sstatus"])))
 
   if dev["children"]:
 
   if dev["children"]:
-    for child in dev["children"]:
-      _FormatBlockDevInfo(buf, child, indent_level+1)
+    data.append("child devices:")
+    for c_idx, child in enumerate(dev["children"]):
+      data.append(_FormatBlockDevInfo(c_idx, False, child, static))
+  d1.append(data)
+  return d1
+
 
 
+def _FormatList(buf, data, indent_level):
+  """Formats a list of data at a given indent level.
+
+  If the element of the list is:
+    - a string, it is simply formatted as is
+    - a tuple, it will be split into key, value and the all the
+      values in a list will be aligned all at the same start column
+    - a list, will be recursively formatted
+
+  @type buf: StringIO
+  @param buf: the buffer into which we write the output
+  @param data: the list to format
+  @type indent_level: int
+  @param indent_level: the indent level to format at
+
+  """
+  max_tlen = max([len(elem[0]) for elem in data
+                 if isinstance(elem, tuple)] or [0])
+  for elem in data:
+    if isinstance(elem, basestring):
+      buf.write("%*s%s\n" % (2*indent_level, "", elem))
+    elif isinstance(elem, tuple):
+      key, value = elem
+      spacer = "%*s" % (max_tlen - len(key), "")
+      buf.write("%*s%s:%s %s\n" % (2*indent_level, "", key, spacer, value))
+    elif isinstance(elem, list):
+      _FormatList(buf, elem, indent_level+1)
 
 def ShowInstanceConfig(opts, args):
   """Compute instance run-time status.
 
 
 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
   """
   retcode = 0
-  op = opcodes.OpQueryInstanceData(instances=args)
+  op = opcodes.OpQueryInstanceData(instances=args, static=opts.static)
   result = SubmitOpCode(op)
   result = SubmitOpCode(op)
-
   if not result:
   if not result:
-    logger.ToStdout("No instances.")
+    ToStdout("No instances.")
     return 1
 
   buf = StringIO()
     return 1
 
   buf = StringIO()
@@ -620,81 +1071,139 @@ def ShowInstanceConfig(opts, args):
   for instance_name in result:
     instance = result[instance_name]
     buf.write("Instance name: %s\n" % instance["name"])
   for instance_name in result:
     instance = result[instance_name]
     buf.write("Instance name: %s\n" % instance["name"])
-    buf.write("State: configured to be %s, actual state is %s\n" %
-              (instance["config_state"], instance["run_state"]))
+    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")
     buf.write("    - primary: %s\n" % instance["pnode"])
     buf.write("    - secondaries: %s\n" % ", ".join(instance["snodes"]))
     buf.write("  Operating system: %s\n" % instance["os"])
     buf.write("  Nodes:\n")
     buf.write("    - primary: %s\n" % instance["pnode"])
     buf.write("    - secondaries: %s\n" % ", ".join(instance["snodes"]))
     buf.write("  Operating system: %s\n" % instance["os"])
-    buf.write("  Allocated network port: %s\n" % instance["network_port"])
-    if instance["kernel_path"] in (None, constants.VALUE_DEFAULT):
-      kpath = "(default: %s)" % constants.XEN_KERNEL
-    else:
-      kpath = instance["kernel_path"]
-    buf.write("  Kernel path: %s\n" % kpath)
-    if instance["initrd_path"] in (None, constants.VALUE_DEFAULT):
-      initrd = "(default: %s)" % constants.XEN_INITRD
-    elif instance["initrd_path"] == constants.VALUE_NONE:
-      initrd = "(none)"
+    if instance.has_key("network_port"):
+      buf.write("  Allocated network port: %s\n" % instance["network_port"])
+    buf.write("  Hypervisor: %s\n" % instance["hypervisor"])
+    if instance["hypervisor"] == constants.HT_XEN_PVM:
+      hvattrs = ((constants.HV_KERNEL_PATH, "kernel path"),
+                 (constants.HV_INITRD_PATH, "initrd path"))
+    elif instance["hypervisor"] == constants.HT_XEN_HVM:
+      hvattrs = ((constants.HV_BOOT_ORDER, "boot order"),
+                 (constants.HV_ACPI, "ACPI"),
+                 (constants.HV_PAE, "PAE"),
+                 (constants.HV_CDROM_IMAGE_PATH, "virtual CDROM"),
+                 (constants.HV_NIC_TYPE, "NIC type"),
+                 (constants.HV_DISK_TYPE, "Disk type"),
+                 (constants.HV_VNC_BIND_ADDRESS, "VNC bind address"),
+                 )
+      # custom console information for HVM
+      vnc_bind_address = instance["hv_actual"][constants.HV_VNC_BIND_ADDRESS]
+      if vnc_bind_address == constants.BIND_ADDRESS_GLOBAL:
+        vnc_console_port = "%s:%s" % (instance["pnode"],
+                                      instance["network_port"])
+      elif vnc_bind_address == constants.LOCALHOST_IP_ADDRESS:
+        vnc_console_port = "%s:%s on node %s" % (vnc_bind_address,
+                                                 instance["network_port"],
+                                                 instance["pnode"])
+      else:
+        vnc_console_port = "%s:%s" % (vnc_bind_address,
+                                      instance["network_port"])
+      buf.write("    - console connection: vnc to %s\n" % vnc_console_port)
+
     else:
     else:
-      initrd = instance["initrd_path"]
-    buf.write("       initrd: %s\n" % initrd)
+      # auto-handle other hypervisor types
+      hvattrs = [(key, key) for key in instance["hv_actual"]]
+
+    for key, desc in hvattrs:
+      if key in instance["hv_instance"]:
+        val = instance["hv_instance"][key]
+      else:
+        val = "default (%s)" % instance["hv_actual"][key]
+      buf.write("    - %s: %s\n" % (desc, val))
     buf.write("  Hardware:\n")
     buf.write("  Hardware:\n")
-    buf.write("    - VCPUs: %d\n" % instance["vcpus"])
-    buf.write("    - memory: %dMiB\n" % instance["memory"])
-    buf.write("    - NICs: %s\n" %
-        ", ".join(["{MAC: %s, IP: %s, bridge: %s}" %
-                   (mac, ip, bridge)
-                     for mac, ip, bridge in instance["nics"]]))
-    buf.write("  Block devices:\n")
-
-    for device in instance["disks"]:
-      _FormatBlockDevInfo(buf, device, 1)
-
-  logger.ToStdout(buf.getvalue().rstrip('\n'))
+    buf.write("    - VCPUs: %d\n" %
+              instance["be_actual"][constants.BE_VCPUS])
+    buf.write("    - memory: %dMiB\n" %
+              instance["be_actual"][constants.BE_MEMORY])
+    buf.write("    - NICs:\n")
+    for idx, (mac, ip, bridge) in enumerate(instance["nics"]):
+      buf.write("      - nic/%d: MAC: %s, IP: %s, bridge: %s\n" %
+                (idx, mac, ip, bridge))
+    buf.write("  Disks:\n")
+
+    for idx, device in enumerate(instance["disks"]):
+      _FormatList(buf, _FormatBlockDevInfo(idx, True, device, opts.static), 2)
+
+  ToStdout(buf.getvalue().rstrip('\n'))
   return retcode
 
 
   return retcode
 
 
-def SetInstanceParms(opts, args):
+def SetInstanceParams(opts, args):
   """Modifies an instance.
 
   All parameters take effect only at the next restart of the instance.
 
   """Modifies an instance.
 
   All parameters take effect only at the next restart of the instance.
 
-  Args:
-    opts - class with options as members
-    args - list with a single element, the instance name
-  Opts used:
-    memory - the new memory size
-    vcpus - the new number of cpus
-    mac - the new MAC address of the 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
 
   """
 
   """
-  if not (opts.mem or opts.vcpus or opts.ip or opts.bridge or opts.mac or
-          opts.kernel_path or opts.initrd_path or opts.hvm_boot_order):
-    logger.ToStdout("Please give at least one of the parameters.")
+  if not (opts.nics or opts.disks or
+          opts.hypervisor or opts.beparams):
+    ToStderr("Please give at least one of the parameters.")
     return 1
 
     return 1
 
-  kernel_path = _TransformPath(opts.kernel_path)
-  initrd_path = _TransformPath(opts.initrd_path)
-  if opts.hvm_boot_order.lower() == 'default':
-    hvm_boot_order = constants.VALUE_DEFAULT
-  else:
-    hvm_boot_order = opts.hvm_boot_order
-
-  op = opcodes.OpSetInstanceParms(instance_name=args[0], mem=opts.mem,
-                                  vcpus=opts.vcpus, ip=opts.ip,
-                                  bridge=opts.bridge, mac=opts.mac,
-                                  kernel_path=opts.kernel_path,
-                                  initrd_path=opts.initrd_path,
-                                  hvm_boot_order=hvm_boot_order)
-  result = SubmitOpCode(op)
+  for param in opts.beparams:
+    if opts.beparams[param].lower() == "default":
+      opts.beparams[param] = constants.VALUE_DEFAULT
+    elif opts.beparams[param].lower() == "none":
+      opts.beparams[param] = constants.VALUE_NONE
+    elif param == constants.BE_MEMORY:
+      opts.beparams[constants.BE_MEMORY] = \
+        utils.ParseUnit(opts.beparams[constants.BE_MEMORY])
+
+  for param in opts.hypervisor:
+    if opts.hypervisor[param].lower() == "default":
+      opts.hypervisor[param] = constants.VALUE_DEFAULT
+    elif opts.hypervisor[param].lower() == "none":
+      opts.hypervisor[param] = constants.VALUE_NONE
+
+  for idx, (nic_op, nic_dict) in enumerate(opts.nics):
+    try:
+      nic_op = int(nic_op)
+      opts.nics[idx] = (nic_op, nic_dict)
+    except ValueError:
+      pass
+
+  for idx, (disk_op, disk_dict) in enumerate(opts.disks):
+    try:
+      disk_op = int(disk_op)
+      opts.disks[idx] = (disk_op, disk_dict)
+    except ValueError:
+      pass
+    if disk_op == constants.DDM_ADD:
+      if 'size' not in disk_dict:
+        raise errors.OpPrereqError("Missing required parameter 'size'")
+      disk_dict['size'] = utils.ParseUnit(disk_dict['size'])
+
+  op = opcodes.OpSetInstanceParams(instance_name=args[0],
+                                   nics=opts.nics,
+                                   disks=opts.disks,
+                                   hvparams=opts.hypervisor,
+                                   beparams=opts.beparams,
+                                   force=opts.force)
+
+  # even if here we process the result, we allow submit only
+  result = SubmitOrSend(op, opts)
 
   if result:
 
   if result:
-    logger.ToStdout("Modified instance %s" % args[0])
+    ToStdout("Modified instance %s", args[0])
     for param, data in result:
     for param, data in result:
-      logger.ToStdout(" - %-5s -> %s" % (param, data))
-    logger.ToStdout("Please don't forget that these parameters take effect"
-                    " only at the next start of the instance.")
+      ToStdout(" - %-5s -> %s", param, data)
+    ToStdout("Please don't forget that these parameters take effect"
+             " only at the next start of the instance.")
   return 0
 
 
   return 0
 
 
@@ -738,63 +1247,61 @@ add_opts = [
   make_option("-n", "--node", dest="node",
               help="Target node and optional secondary node",
               metavar="<pnode>[:<snode>]"),
   make_option("-n", "--node", dest="node",
               help="Target node and optional secondary node",
               metavar="<pnode>[:<snode>]"),
-  cli_option("-s", "--os-size", dest="size", help="Disk size, in MiB unless"
-             " a suffix is used",
-             default=20 * 1024, type="unit", metavar="<size>"),
-  cli_option("--swap-size", dest="swap", help="Swap size, in MiB unless a"
-             " suffix is used",
-             default=4 * 1024, type="unit", metavar="<size>"),
   os_opt,
   os_opt,
-  cli_option("-m", "--memory", dest="mem", help="Memory size (in MiB)",
-              default=128, type="unit", metavar="<mem>"),
-  make_option("-p", "--cpu", dest="vcpus", help="Number of virtual CPUs",
-              default=1, type="int", metavar="<PROC>"),
+  keyval_option("-B", "--backend", dest="beparams",
+                type="keyval", default={},
+                help="Backend parameters"),
   make_option("-t", "--disk-template", dest="disk_template",
   make_option("-t", "--disk-template", dest="disk_template",
-              help="Custom disk setup (diskless, plain, local_raid1,"
-              " remote_raid1 or drbd)", default=None, metavar="TEMPL"),
-  make_option("-i", "--ip", dest="ip",
-              help="IP address ('none' [default], 'auto', or specify address)",
-              default='none', type="string", metavar="<ADDRESS>"),
-  make_option("--mac", dest="mac",
-              help="MAC address ('auto' [default], or specify address)",
-              default='auto', type="string", metavar="<MACADDRESS>"),
+              help="Custom disk setup (diskless, file, plain or drbd)",
+              default=None, metavar="TEMPL"),
+  ikv_option("--disk", help="Disk information",
+             default=[], dest="disks",
+             action="append",
+             type="identkeyval"),
+  ikv_option("--net", help="NIC information",
+             default=[], dest="nics",
+             action="append",
+             type="identkeyval"),
+  make_option("--no-nics", default=False, action="store_true",
+              help="Do not create any network cards for the instance"),
   make_option("--no-wait-for-sync", dest="wait_for_sync", default=True,
               action="store_false", help="Don't wait for sync (DANGEROUS!)"),
   make_option("--no-wait-for-sync", dest="wait_for_sync", default=True,
               action="store_false", help="Don't wait for sync (DANGEROUS!)"),
-  make_option("-b", "--bridge", dest="bridge",
-              help="Bridge to connect this instance to",
-              default=None, metavar="<bridge>"),
   make_option("--no-start", dest="start", default=True,
               action="store_false", help="Don't start the instance after"
               " creation"),
   make_option("--no-ip-check", dest="ip_check", default=True,
               action="store_false", help="Don't check that the instance's IP"
               " is alive (only valid with --no-start)"),
   make_option("--no-start", dest="start", default=True,
               action="store_false", help="Don't start the instance after"
               " creation"),
   make_option("--no-ip-check", dest="ip_check", default=True,
               action="store_false", help="Don't check that the instance's IP"
               " is alive (only valid with --no-start)"),
-  make_option("--kernel", dest="kernel_path",
-              help="Path to the instances' kernel (or 'default')",
-              default=None,
-              type="string", metavar="<FILENAME>"),
-  make_option("--initrd", dest="initrd_path",
-              help="Path to the instances' initrd (or 'none', or 'default')",
-              default=None,
-              type="string", metavar="<FILENAME>"),
-  make_option("--hvm-boot-order", dest="hvm_boot_order",
-              help="boot device order for HVM (one or more of [acdn])",
-              default=None, type="string", metavar="<BOOTORDER>"),
+  make_option("--file-storage-dir", dest="file_storage_dir",
+              help="Relative path under default cluster-wide file storage dir"
+              " to store file-based disks", default=None,
+              metavar="<DIR>"),
+  make_option("--file-driver", dest="file_driver", help="Driver to use"
+              " for image files", default="loop", metavar="<DRIVER>"),
+  make_option("-I", "--iallocator", metavar="<NAME>",
+              help="Select nodes for the instance automatically using the"
+              " <NAME> iallocator plugin", default=None, type="string"),
+  ikv_option("-H", "--hypervisor", dest="hypervisor",
+              help="Hypervisor and hypervisor options, in the format"
+              " hypervisor:option=value,option=value,...", default=None,
+              type="identkeyval"),
+  SUBMIT_OPT,
   ]
 
 commands = {
   'add': (AddInstance, ARGS_ONE, add_opts,
   ]
 
 commands = {
   'add': (AddInstance, ARGS_ONE, add_opts,
-          "[opts...] <name>",
+          "[...] -t disk-type -n node[:secondary-node] -o os-type <name>",
           "Creates and adds a new instance to the cluster"),
           "Creates and adds a new instance to the cluster"),
-  'add-mirror': (AddMDDRBDComponent, ARGS_ONE,
-                [DEBUG_OPT, node_opt,
-                 make_option("-b", "--disk", dest="disk", metavar="sdX",
-                             help=("The name of the instance disk for which to"
-                                   " add the mirror"))],
-                "-n node -b disk <instance>",
-                "Creates a new mirror for the instance"),
-  'console': (ConnectToInstanceConsole, ARGS_ONE, [DEBUG_OPT],
-              "<instance>",
+  'batch-create': (BatchCreate, ARGS_ONE,
+                   [DEBUG_OPT],
+                   "<instances_file.json>",
+                   "Create a bunch of instances based on specs in the file."),
+  'console': (ConnectToInstanceConsole, ARGS_ONE,
+              [DEBUG_OPT,
+               make_option("--show-cmd", dest="show_command",
+                           action="store_true", default=False,
+                           help=("Show command instead of executing it"))],
+              "[--show-cmd] <instance>",
               "Opens a console on the specified instance"),
   'failover': (FailoverInstance, ARGS_ONE,
                [DEBUG_OPT, FORCE_OPT,
               "Opens a console on the specified instance"),
   'failover': (FailoverInstance, ARGS_ONE,
                [DEBUG_OPT, FORCE_OPT,
@@ -802,17 +1309,57 @@ commands = {
                             action="store_true", default=False,
                             help="Ignore the consistency of the disks on"
                             " the secondary"),
                             action="store_true", default=False,
                             help="Ignore the consistency of the disks on"
                             " the secondary"),
+                SUBMIT_OPT,
                 ],
                "[-f] <instance>",
                "Stops the instance and starts it on the backup node, using"
                 ],
                "[-f] <instance>",
                "Stops the instance and starts it on the backup node, using"
-               " the remote mirror (only for instances of type remote_raid1)"),
-  'info': (ShowInstanceConfig, ARGS_ANY, [DEBUG_OPT], "[<instance>...]",
-           "Show information on the specified instance"),
+               " the remote mirror (only for instances of type drbd)"),
+  'migrate': (MigrateInstance, ARGS_ONE,
+               [DEBUG_OPT, FORCE_OPT,
+                make_option("--non-live", dest="live",
+                            default=True, action="store_false",
+                            help="Do a non-live migration (this usually means"
+                            " freeze the instance, save the state,"
+                            " transfer and only then resume running on the"
+                            " secondary node)"),
+                make_option("--cleanup", dest="cleanup",
+                            default=False, action="store_true",
+                            help="Instead of performing the migration, try to"
+                            " recover from a failed cleanup. This is safe"
+                            " to run even if the instance is healthy, but it"
+                            " will create extra replication traffic and "
+                            " disrupt briefly the replication (like during the"
+                            " migration"),
+                ],
+               "[-f] <instance>",
+               "Migrate instance to its secondary node"
+               " (only for instances of type drbd)"),
+  'info': (ShowInstanceConfig, ARGS_ANY,
+           [DEBUG_OPT,
+            make_option("-s", "--static", dest="static",
+                        action="store_true", default=False,
+                        help="Only show configuration data, not runtime data"),
+            ], "[-s] [<instance>...]",
+           "Show information on the specified instance(s)"),
   'list': (ListInstances, ARGS_NONE,
   'list': (ListInstances, ARGS_NONE,
-           [DEBUG_OPT, NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT],
-           "", "Lists the instances and their status"),
-  'reinstall': (ReinstallInstance, ARGS_ONE, [DEBUG_OPT, FORCE_OPT, os_opt],
-                "[-f] <instance>", "Reinstall the instance"),
+           [DEBUG_OPT, NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT], "",
+           "Lists the instances and their status. The available fields are"
+           " (see the man page for details): status, oper_state, oper_ram,"
+           " name, os, pnode, snodes, admin_state, admin_ram, disk_template,"
+           " ip, mac, bridge, sda_size, sdb_size, vcpus, serial_no,"
+           " hypervisor."
+           " The default field"
+           " list is (in order): %s." % ", ".join(_LIST_DEF_FIELDS),
+           ),
+  'reinstall': (ReinstallInstance, ARGS_ONE,
+                [DEBUG_OPT, FORCE_OPT, os_opt,
+                 make_option("--select-os", dest="select_os",
+                             action="store_true", default=False,
+                             help="Interactive OS reinstall, lists available"
+                             " OS templates for selection"),
+                 SUBMIT_OPT,
+                 ],
+                "[-f] <instance>", "Reinstall a stopped instance"),
   'remove': (RemoveInstance, ARGS_ONE,
              [DEBUG_OPT, FORCE_OPT,
               make_option("--ignore-failures", dest="ignore_failures",
   'remove': (RemoveInstance, ARGS_ONE,
              [DEBUG_OPT, FORCE_OPT,
               make_option("--ignore-failures", dest="ignore_failures",
@@ -820,33 +1367,24 @@ commands = {
                           help=("Remove the instance from the cluster even"
                                 " if there are failures during the removal"
                                 " process (shutdown, disk removal, etc.)")),
                           help=("Remove the instance from the cluster even"
                                 " if there are failures during the removal"
                                 " process (shutdown, disk removal, etc.)")),
+              SUBMIT_OPT,
               ],
              "[-f] <instance>", "Shuts down the instance and removes it"),
               ],
              "[-f] <instance>", "Shuts down the instance and removes it"),
-  'remove-mirror': (RemoveMDDRBDComponent, ARGS_ONE,
-                   [DEBUG_OPT, node_opt,
-                    make_option("-b", "--disk", dest="disk", metavar="sdX",
-                                help=("The name of the instance disk"
-                                      " for which to add the mirror")),
-                    make_option("-p", "--port", dest="port", metavar="PORT",
-                                help=("The port of the drbd device"
-                                      " which to remove from the mirror"),
-                                type="int"),
-                    ],
-                   "-b disk -p port <instance>",
-                   "Removes a mirror from the instance"),
   'rename': (RenameInstance, ARGS_FIXED(2),
              [DEBUG_OPT,
               make_option("--no-ip-check", dest="ignore_ip",
                           help="Do not check that the IP of the new name"
                           " is alive",
                           default=False, action="store_true"),
   'rename': (RenameInstance, ARGS_FIXED(2),
              [DEBUG_OPT,
               make_option("--no-ip-check", dest="ignore_ip",
                           help="Do not check that the IP of the new name"
                           " is alive",
                           default=False, action="store_true"),
+              SUBMIT_OPT,
               ],
              "<instance> <new_name>", "Rename the instance"),
   'replace-disks': (ReplaceDisks, ARGS_ONE,
                     [DEBUG_OPT,
                      make_option("-n", "--new-secondary", dest="new_secondary",
                                  help=("New secondary node (for secondary"
               ],
              "<instance> <new_name>", "Rename the instance"),
   'replace-disks': (ReplaceDisks, ARGS_ONE,
                     [DEBUG_OPT,
                      make_option("-n", "--new-secondary", dest="new_secondary",
                                  help=("New secondary node (for secondary"
-                                       " node change)"), metavar="NODE"),
+                                       " node change)"), metavar="NODE",
+                                 default=None),
                      make_option("-p", "--on-primary", dest="on_primary",
                                  default=False, action="store_true",
                                  help=("Replace the disk(s) on the primary"
                      make_option("-p", "--on-primary", dest="on_primary",
                                  default=False, action="store_true",
                                  help=("Replace the disk(s) on the primary"
@@ -859,43 +1397,40 @@ commands = {
                                  help=("Comma-separated list of disks"
                                        " to replace (e.g. sda) (optional,"
                                        " defaults to all disks")),
                                  help=("Comma-separated list of disks"
                                        " to replace (e.g. sda) (optional,"
                                        " defaults to all disks")),
+                     make_option("-i", "--iallocator", metavar="<NAME>",
+                                 help="Select new secondary for the instance"
+                                 " automatically using the"
+                                 " <NAME> iallocator plugin (enables"
+                                 " secondary node replacement)",
+                                 default=None, type="string"),
+                     SUBMIT_OPT,
                      ],
                      ],
-                    "[-n NODE] <instance>",
+                    "[-s|-p|-n NODE] <instance>",
                     "Replaces all disks for the instance"),
                     "Replaces all disks for the instance"),
-  'modify': (SetInstanceParms, ARGS_ONE,
+  'modify': (SetInstanceParams, ARGS_ONE,
              [DEBUG_OPT, FORCE_OPT,
              [DEBUG_OPT, FORCE_OPT,
-              cli_option("-m", "--memory", dest="mem",
-                         help="Memory size",
-                         default=None, type="unit", metavar="<mem>"),
-              make_option("-p", "--cpu", dest="vcpus",
-                          help="Number of virtual CPUs",
-                          default=None, type="int", metavar="<PROC>"),
-              make_option("-i", "--ip", dest="ip",
-                          help="IP address ('none' or numeric IP)",
-                          default=None, type="string", metavar="<ADDRESS>"),
-              make_option("-b", "--bridge", dest="bridge",
-                          help="Bridge to connect this instance to",
-                          default=None, type="string", metavar="<bridge>"),
-              make_option("--mac", dest="mac",
-                          help="MAC address", default=None,
-                          type="string", metavar="<MACADDRESS>"),
-              make_option("--kernel", dest="kernel_path",
-                          help="Path to the instances' kernel (or"
-                          " 'default')", default=None,
-                          type="string", metavar="<FILENAME>"),
-              make_option("--initrd", dest="initrd_path",
-                          help="Path to the instances' initrd (or 'none', or"
-                          " 'default')", default=None,
-                          type="string", metavar="<FILENAME>"),
-              make_option("--hvm-boot-order", dest="hvm_boot_order",
-                          help="boot device order for HVM"
-                          "(either one or more of [acdn] or 'default')",
-                          default=None, type="string", metavar="<BOOTORDER>"),
+              keyval_option("-H", "--hypervisor", type="keyval",
+                            default={}, dest="hypervisor",
+                            help="Change hypervisor parameters"),
+              keyval_option("-B", "--backend", type="keyval",
+                            default={}, dest="beparams",
+                            help="Change backend parameters"),
+              ikv_option("--disk", help="Disk changes",
+                         default=[], dest="disks",
+                         action="append",
+                         type="identkeyval"),
+              ikv_option("--net", help="NIC changes",
+                         default=[], dest="nics",
+                         action="append",
+                         type="identkeyval"),
+              SUBMIT_OPT,
               ],
              "<instance>", "Alters the parameters of an instance"),
   'shutdown': (ShutdownInstance, ARGS_ANY,
                [DEBUG_OPT, m_node_opt, m_pri_node_opt, m_sec_node_opt,
               ],
              "<instance>", "Alters the parameters of an instance"),
   'shutdown': (ShutdownInstance, ARGS_ANY,
                [DEBUG_OPT, m_node_opt, m_pri_node_opt, m_sec_node_opt,
-                m_clust_opt, m_inst_opt, m_force_multi],
+                m_clust_opt, m_inst_opt, m_force_multi,
+                SUBMIT_OPT,
+                ],
                "<instance>", "Stops an instance"),
   'startup': (StartupInstance, ARGS_ANY,
               [DEBUG_OPT, FORCE_OPT, m_force_multi,
                "<instance>", "Stops an instance"),
   'startup': (StartupInstance, ARGS_ANY,
               [DEBUG_OPT, FORCE_OPT, m_force_multi,
@@ -904,6 +1439,7 @@ commands = {
                            default=None, type="string", metavar="<PARAMS>"),
                m_node_opt, m_pri_node_opt, m_sec_node_opt,
                m_clust_opt, m_inst_opt,
                            default=None, type="string", metavar="<PARAMS>"),
                m_node_opt, m_pri_node_opt, m_sec_node_opt,
                m_clust_opt, m_inst_opt,
+               SUBMIT_OPT,
                ],
             "<instance>", "Starts an instance"),
 
                ],
             "<instance>", "Starts an instance"),
 
@@ -914,29 +1450,46 @@ commands = {
                            default=None, type="string", metavar="<PARAMS>"),
                make_option("-t", "--type", dest="reboot_type",
                            help="Type of reboot: soft/hard/full",
                            default=None, type="string", metavar="<PARAMS>"),
                make_option("-t", "--type", dest="reboot_type",
                            help="Type of reboot: soft/hard/full",
-                           default=constants.INSTANCE_REBOOT_SOFT,
+                           default=constants.INSTANCE_REBOOT_HARD,
                            type="string", metavar="<REBOOT>"),
                make_option("--ignore-secondaries", dest="ignore_secondaries",
                            default=False, action="store_true",
                            help="Ignore errors from secondaries"),
                m_node_opt, m_pri_node_opt, m_sec_node_opt,
                m_clust_opt, m_inst_opt,
                            type="string", metavar="<REBOOT>"),
                make_option("--ignore-secondaries", dest="ignore_secondaries",
                            default=False, action="store_true",
                            help="Ignore errors from secondaries"),
                m_node_opt, m_pri_node_opt, m_sec_node_opt,
                m_clust_opt, m_inst_opt,
+               SUBMIT_OPT,
                ],
             "<instance>", "Reboots an instance"),
                ],
             "<instance>", "Reboots an instance"),
-  'activate-disks': (ActivateDisks, ARGS_ONE, [DEBUG_OPT],
+  'activate-disks': (ActivateDisks, ARGS_ONE, [DEBUG_OPT, SUBMIT_OPT],
                      "<instance>",
                      "Activate an instance's disks"),
                      "<instance>",
                      "Activate an instance's disks"),
-  'deactivate-disks': (DeactivateDisks, ARGS_ONE, [DEBUG_OPT],
+  'deactivate-disks': (DeactivateDisks, ARGS_ONE, [DEBUG_OPT, SUBMIT_OPT],
                        "<instance>",
                        "Deactivate an instance's disks"),
                        "<instance>",
                        "Deactivate an instance's disks"),
+  'grow-disk': (GrowDisk, ARGS_FIXED(3),
+                [DEBUG_OPT, SUBMIT_OPT,
+                 make_option("--no-wait-for-sync",
+                             dest="wait_for_sync", default=True,
+                             action="store_false",
+                             help="Don't wait for sync (DANGEROUS!)"),
+                 ],
+                "<instance> <disk> <size>", "Grow an instance's disk"),
   'list-tags': (ListTags, ARGS_ONE, [DEBUG_OPT],
   'list-tags': (ListTags, ARGS_ONE, [DEBUG_OPT],
-                "<node_name>", "List the tags of the given instance"),
+                "<instance_name>", "List the tags of the given instance"),
   'add-tags': (AddTags, ARGS_ATLEAST(1), [DEBUG_OPT, TAG_SRC_OPT],
   'add-tags': (AddTags, ARGS_ATLEAST(1), [DEBUG_OPT, TAG_SRC_OPT],
-               "<node_name> tag...", "Add tags to the given instance"),
+               "<instance_name> tag...", "Add tags to the given instance"),
   'remove-tags': (RemoveTags, ARGS_ATLEAST(1), [DEBUG_OPT, TAG_SRC_OPT],
   'remove-tags': (RemoveTags, ARGS_ATLEAST(1), [DEBUG_OPT, TAG_SRC_OPT],
-                  "<node_name> tag...", "Remove tags from given instance"),
+                  "<instance_name> tag...", "Remove tags from given instance"),
+  }
+
+#: dictionary with aliases for commands
+aliases = {
+  'activate_block_devs': 'activate-disks',
+  'replace_disks': 'replace-disks',
+  'start': 'startup',
+  'stop': 'shutdown',
   }
 
 if __name__ == '__main__':
   }
 
 if __name__ == '__main__':
-  sys.exit(GenericMain(commands,
+  sys.exit(GenericMain(commands, aliases=aliases,
                        override={"tag_type": constants.TAG_INSTANCE}))
                        override={"tag_type": constants.TAG_INSTANCE}))