code.grnet.gr Git - ganeti-local/blob - lib/client/gnt_instance.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21 """Instance related commands"""
  22
  23 # pylint: disable=W0401,W0614,C0103
  24 # W0401: Wildcard import ganeti.cli
  25 # W0614: Unused import %s from wildcard import (since we need cli)
  26 # C0103: Invalid name gnt-instance
  27
  28 import itertools
  29 import simplejson
  30 import logging
  31 from cStringIO import StringIO
  32
  33 from ganeti.cli import *
  34 from ganeti import opcodes
  35 from ganeti import constants
  36 from ganeti import compat
  37 from ganeti import utils
  38 from ganeti import errors
  39 from ganeti import netutils
  40 from ganeti import ssh
  41 from ganeti import objects
  42
  43
  44 _EXPAND_CLUSTER = "cluster"
  45 _EXPAND_NODES_BOTH = "nodes"
  46 _EXPAND_NODES_PRI = "nodes-pri"
  47 _EXPAND_NODES_SEC = "nodes-sec"
  48 _EXPAND_NODES_BOTH_BY_TAGS = "nodes-by-tags"
  49 _EXPAND_NODES_PRI_BY_TAGS = "nodes-pri-by-tags"
  50 _EXPAND_NODES_SEC_BY_TAGS = "nodes-sec-by-tags"
  51 _EXPAND_INSTANCES = "instances"
  52 _EXPAND_INSTANCES_BY_TAGS = "instances-by-tags"
  53
  54 _EXPAND_NODES_TAGS_MODES = frozenset([
  55   _EXPAND_NODES_BOTH_BY_TAGS,
  56   _EXPAND_NODES_PRI_BY_TAGS,
  57   _EXPAND_NODES_SEC_BY_TAGS,
  58   ])
  59
  60
  61 #: default list of options for L{ListInstances}
  62 _LIST_DEF_FIELDS = [
  63   "name", "hypervisor", "os", "pnode", "status", "oper_ram",
  64   ]
  65
  66
  67 _ENV_OVERRIDE = frozenset(["list"])
  68
  69
  70 def _ExpandMultiNames(mode, names, client=None):
  71   """Expand the given names using the passed mode.
  72
  73   For _EXPAND_CLUSTER, all instances will be returned. For
  74   _EXPAND_NODES_PRI/SEC, all instances having those nodes as
  75   primary/secondary will be returned. For _EXPAND_NODES_BOTH, all
  76   instances having those nodes as either primary or secondary will be
  77   returned. For _EXPAND_INSTANCES, the given instances will be
  78   returned.
  79
  80   @param mode: one of L{_EXPAND_CLUSTER}, L{_EXPAND_NODES_BOTH},
  81       L{_EXPAND_NODES_PRI}, L{_EXPAND_NODES_SEC} or
  82       L{_EXPAND_INSTANCES}
  83   @param names: a list of names; for cluster, it must be empty,
  84       and for node and instance it must be a list of valid item
  85       names (short names are valid as usual, e.g. node1 instead of
  86       node1.example.com)
  87   @rtype: list
  88   @return: the list of names after the expansion
  89   @raise errors.ProgrammerError: for unknown selection type
  90   @raise errors.OpPrereqError: for invalid input parameters
  91
  92   """
  93   # pylint: disable=W0142
  94
  95   if client is None:
  96     client = GetClient()
  97   if mode == _EXPAND_CLUSTER:
  98     if names:
  99       raise errors.OpPrereqError("Cluster filter mode takes no arguments",
 100                                  errors.ECODE_INVAL)
 101     idata = client.QueryInstances([], ["name"], False)
 102     inames = [row[0] for row in idata]
 103
 104   elif (mode in _EXPAND_NODES_TAGS_MODES or
 105         mode in (_EXPAND_NODES_BOTH, _EXPAND_NODES_PRI, _EXPAND_NODES_SEC)):
 106     if mode in _EXPAND_NODES_TAGS_MODES:
 107       if not names:
 108         raise errors.OpPrereqError("No node tags passed", errors.ECODE_INVAL)
 109       ndata = client.QueryNodes([], ["name", "pinst_list",
 110                                      "sinst_list", "tags"], False)
 111       ndata = [row for row in ndata if set(row[3]).intersection(names)]
 112     else:
 113       if not names:
 114         raise errors.OpPrereqError("No node names passed", errors.ECODE_INVAL)
 115       ndata = client.QueryNodes(names, ["name", "pinst_list", "sinst_list"],
 116                               False)
 117
 118     ipri = [row[1] for row in ndata]
 119     pri_names = list(itertools.chain(*ipri))
 120     isec = [row[2] for row in ndata]
 121     sec_names = list(itertools.chain(*isec))
 122     if mode in (_EXPAND_NODES_BOTH, _EXPAND_NODES_BOTH_BY_TAGS):
 123       inames = pri_names + sec_names
 124     elif mode in (_EXPAND_NODES_PRI, _EXPAND_NODES_PRI_BY_TAGS):
 125       inames = pri_names
 126     elif mode in (_EXPAND_NODES_SEC, _EXPAND_NODES_SEC_BY_TAGS):
 127       inames = sec_names
 128     else:
 129       raise errors.ProgrammerError("Unhandled shutdown type")
 130   elif mode == _EXPAND_INSTANCES:
 131     if not names:
 132       raise errors.OpPrereqError("No instance names passed",
 133                                  errors.ECODE_INVAL)
 134     idata = client.QueryInstances(names, ["name"], False)
 135     inames = [row[0] for row in idata]
 136   elif mode == _EXPAND_INSTANCES_BY_TAGS:
 137     if not names:
 138       raise errors.OpPrereqError("No instance tags passed",
 139                                  errors.ECODE_INVAL)
 140     idata = client.QueryInstances([], ["name", "tags"], False)
 141     inames = [row[0] for row in idata if set(row[1]).intersection(names)]
 142   else:
 143     raise errors.OpPrereqError("Unknown mode '%s'" % mode, errors.ECODE_INVAL)
 144
 145   return inames
 146
 147
 148 def _EnsureInstancesExist(client, names):
 149   """Check for and ensure the given instance names exist.
 150
 151   This function will raise an OpPrereqError in case they don't
 152   exist. Otherwise it will exit cleanly.
 153
 154   @type client: L{ganeti.luxi.Client}
 155   @param client: the client to use for the query
 156   @type names: list
 157   @param names: the list of instance names to query
 158   @raise errors.OpPrereqError: in case any instance is missing
 159
 160   """
 161   # TODO: change LUInstanceQuery to that it actually returns None
 162   # instead of raising an exception, or devise a better mechanism
 163   result = client.QueryInstances(names, ["name"], False)
 164   for orig_name, row in zip(names, result):
 165     if row[0] is None:
 166       raise errors.OpPrereqError("Instance '%s' does not exist" % orig_name,
 167                                  errors.ECODE_NOENT)
 168
 169
 170 def GenericManyOps(operation, fn):
 171   """Generic multi-instance operations.
 172
 173   The will return a wrapper that processes the options and arguments
 174   given, and uses the passed function to build the opcode needed for
 175   the specific operation. Thus all the generic loop/confirmation code
 176   is abstracted into this function.
 177
 178   """
 179   def realfn(opts, args):
 180     if opts.multi_mode is None:
 181       opts.multi_mode = _EXPAND_INSTANCES
 182     cl = GetClient()
 183     inames = _ExpandMultiNames(opts.multi_mode, args, client=cl)
 184     if not inames:
 185       if opts.multi_mode == _EXPAND_CLUSTER:
 186         ToStdout("Cluster is empty, no instances to shutdown")
 187         return 0
 188       raise errors.OpPrereqError("Selection filter does not match"
 189                                  " any instances", errors.ECODE_INVAL)
 190     multi_on = opts.multi_mode != _EXPAND_INSTANCES or len(inames) > 1
 191     if not (opts.force_multi or not multi_on
 192             or ConfirmOperation(inames, "instances", operation)):
 193       return 1
 194     jex = JobExecutor(verbose=multi_on, cl=cl, opts=opts)
 195     for name in inames:
 196       op = fn(name, opts)
 197       jex.QueueJob(name, op)
 198     results = jex.WaitOrShow(not opts.submit_only)
 199     rcode = compat.all(row[0] for row in results)
 200     return int(not rcode)
 201   return realfn
 202
 203
 204 def ListInstances(opts, args):
 205   """List instances and their properties.
 206
 207   @param opts: the command line options selected by the user
 208   @type args: list
 209   @param args: should be an empty list
 210   @rtype: int
 211   @return: the desired exit code
 212
 213   """
 214   selected_fields = ParseFields(opts.output, _LIST_DEF_FIELDS)
 215
 216   fmtoverride = dict.fromkeys(["tags", "disk.sizes", "nic.macs", "nic.ips",
 217                                "nic.modes", "nic.links", "nic.bridges",
 218                                "snodes", "snodes.group", "snodes.group.uuid"],
 219                               (lambda value: ",".join(str(item)
 220                                                       for item in value),
 221                                False))
 222
 223   return GenericList(constants.QR_INSTANCE, selected_fields, args, opts.units,
 224                      opts.separator, not opts.no_headers,
 225                      format_override=fmtoverride, verbose=opts.verbose,
 226                      force_filter=opts.force_filter)
 227
 228
 229 def ListInstanceFields(opts, args):
 230   """List instance fields.
 231
 232   @param opts: the command line options selected by the user
 233   @type args: list
 234   @param args: fields to list, or empty for all
 235   @rtype: int
 236   @return: the desired exit code
 237
 238   """
 239   return GenericListFields(constants.QR_INSTANCE, args, opts.separator,
 240                            not opts.no_headers)
 241
 242
 243 def AddInstance(opts, args):
 244   """Add an instance to the cluster.
 245
 246   This is just a wrapper over GenericInstanceCreate.
 247
 248   """
 249   return GenericInstanceCreate(constants.INSTANCE_CREATE, opts, args)
 250
 251
 252 def BatchCreate(opts, args):
 253   """Create instances using a definition file.
 254
 255   This function reads a json file with instances defined
 256   in the form::
 257
 258     {"instance-name":{
 259       "disk_size": [20480],
 260       "template": "drbd",
 261       "backend": {
 262         "memory": 512,
 263         "vcpus": 1 },
 264       "os": "debootstrap",
 265       "primary_node": "firstnode",
 266       "secondary_node": "secondnode",
 267       "iallocator": "dumb"}
 268     }
 269
 270   Note that I{primary_node} and I{secondary_node} have precedence over
 271   I{iallocator}.
 272
 273   @param opts: the command line options selected by the user
 274   @type args: list
 275   @param args: should contain one element, the json filename
 276   @rtype: int
 277   @return: the desired exit code
 278
 279   """
 280   _DEFAULT_SPECS = {"disk_size": [20 * 1024],
 281                     "backend": {},
 282                     "iallocator": None,
 283                     "primary_node": None,
 284                     "secondary_node": None,
 285                     "nics": None,
 286                     "start": True,
 287                     "ip_check": True,
 288                     "name_check": True,
 289                     "hypervisor": None,
 290                     "hvparams": {},
 291                     "file_storage_dir": None,
 292                     "force_variant": False,
 293                     "file_driver": "loop"}
 294
 295   def _PopulateWithDefaults(spec):
 296     """Returns a new hash combined with default values."""
 297     mydict = _DEFAULT_SPECS.copy()
 298     mydict.update(spec)
 299     return mydict
 300
 301   def _Validate(spec):
 302     """Validate the instance specs."""
 303     # Validate fields required under any circumstances
 304     for required_field in ("os", "template"):
 305       if required_field not in spec:
 306         raise errors.OpPrereqError('Required field "%s" is missing.' %
 307                                    required_field, errors.ECODE_INVAL)
 308     # Validate special fields
 309     if spec["primary_node"] is not None:
 310       if (spec["template"] in constants.DTS_INT_MIRROR and
 311           spec["secondary_node"] is None):
 312         raise errors.OpPrereqError("Template requires secondary node, but"
 313                                    " there was no secondary provided.",
 314                                    errors.ECODE_INVAL)
 315     elif spec["iallocator"] is None:
 316       raise errors.OpPrereqError("You have to provide at least a primary_node"
 317                                  " or an iallocator.",
 318                                  errors.ECODE_INVAL)
 319
 320     if (spec["hvparams"] and
 321         not isinstance(spec["hvparams"], dict)):
 322       raise errors.OpPrereqError("Hypervisor parameters must be a dict.",
 323                                  errors.ECODE_INVAL)
 324
 325   json_filename = args[0]
 326   try:
 327     instance_data = simplejson.loads(utils.ReadFile(json_filename))
 328   except Exception, err: # pylint: disable=W0703
 329     ToStderr("Can't parse the instance definition file: %s" % str(err))
 330     return 1
 331
 332   if not isinstance(instance_data, dict):
 333     ToStderr("The instance definition file is not in dict format.")
 334     return 1
 335
 336   jex = JobExecutor(opts=opts)
 337
 338   # Iterate over the instances and do:
 339   #  * Populate the specs with default value
 340   #  * Validate the instance specs
 341   i_names = utils.NiceSort(instance_data.keys()) # pylint: disable=E1103
 342   for name in i_names:
 343     specs = instance_data[name]
 344     specs = _PopulateWithDefaults(specs)
 345     _Validate(specs)
 346
 347     hypervisor = specs["hypervisor"]
 348     hvparams = specs["hvparams"]
 349
 350     disks = []
 351     for elem in specs["disk_size"]:
 352       try:
 353         size = utils.ParseUnit(elem)
 354       except (TypeError, ValueError), err:
 355         raise errors.OpPrereqError("Invalid disk size '%s' for"
 356                                    " instance %s: %s" %
 357                                    (elem, name, err), errors.ECODE_INVAL)
 358       disks.append({"size": size})
 359
 360     utils.ForceDictType(specs["backend"], constants.BES_PARAMETER_TYPES)
 361     utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES)
 362
 363     tmp_nics = []
 364     for field in constants.INIC_PARAMS:
 365       if field in specs:
 366         if not tmp_nics:
 367           tmp_nics.append({})
 368         tmp_nics[0][field] = specs[field]
 369
 370     if specs["nics"] is not None and tmp_nics:
 371       raise errors.OpPrereqError("'nics' list incompatible with using"
 372                                  " individual nic fields as well",
 373                                  errors.ECODE_INVAL)
 374     elif specs["nics"] is not None:
 375       tmp_nics = specs["nics"]
 376     elif not tmp_nics:
 377       tmp_nics = [{}]
 378
 379     op = opcodes.OpInstanceCreate(instance_name=name,
 380                                   disks=disks,
 381                                   disk_template=specs["template"],
 382                                   mode=constants.INSTANCE_CREATE,
 383                                   os_type=specs["os"],
 384                                   force_variant=specs["force_variant"],
 385                                   pnode=specs["primary_node"],
 386                                   snode=specs["secondary_node"],
 387                                   nics=tmp_nics,
 388                                   start=specs["start"],
 389                                   ip_check=specs["ip_check"],
 390                                   name_check=specs["name_check"],
 391                                   wait_for_sync=True,
 392                                   iallocator=specs["iallocator"],
 393                                   hypervisor=hypervisor,
 394                                   hvparams=hvparams,
 395                                   beparams=specs["backend"],
 396                                   file_storage_dir=specs["file_storage_dir"],
 397                                   file_driver=specs["file_driver"])
 398
 399     jex.QueueJob(name, op)
 400   # we never want to wait, just show the submitted job IDs
 401   jex.WaitOrShow(False)
 402
 403   return 0
 404
 405
 406 def ReinstallInstance(opts, args):
 407   """Reinstall an instance.
 408
 409   @param opts: the command line options selected by the user
 410   @type args: list
 411   @param args: should contain only one element, the name of the
 412       instance to be reinstalled
 413   @rtype: int
 414   @return: the desired exit code
 415
 416   """
 417   # first, compute the desired name list
 418   if opts.multi_mode is None:
 419     opts.multi_mode = _EXPAND_INSTANCES
 420
 421   inames = _ExpandMultiNames(opts.multi_mode, args)
 422   if not inames:
 423     raise errors.OpPrereqError("Selection filter does not match any instances",
 424                                errors.ECODE_INVAL)
 425
 426   # second, if requested, ask for an OS
 427   if opts.select_os is True:
 428     op = opcodes.OpOsDiagnose(output_fields=["name", "variants"], names=[])
 429     result = SubmitOpCode(op, opts=opts)
 430
 431     if not result:
 432       ToStdout("Can't get the OS list")
 433       return 1
 434
 435     ToStdout("Available OS templates:")
 436     number = 0
 437     choices = []
 438     for (name, variants) in result:
 439       for entry in CalculateOSNames(name, variants):
 440         ToStdout("%3s: %s", number, entry)
 441         choices.append(("%s" % number, entry, entry))
 442         number += 1
 443
 444     choices.append(("x", "exit", "Exit gnt-instance reinstall"))
 445     selected = AskUser("Enter OS template number (or x to abort):",
 446                        choices)
 447
 448     if selected == "exit":
 449       ToStderr("User aborted reinstall, exiting")
 450       return 1
 451
 452     os_name = selected
 453     os_msg = "change the OS to '%s'" % selected
 454   else:
 455     os_name = opts.os
 456     if opts.os is not None:
 457       os_msg = "change the OS to '%s'" % os_name
 458     else:
 459       os_msg = "keep the same OS"
 460
 461   # third, get confirmation: multi-reinstall requires --force-multi,
 462   # single-reinstall either --force or --force-multi (--force-multi is
 463   # a stronger --force)
 464   multi_on = opts.multi_mode != _EXPAND_INSTANCES or len(inames) > 1
 465   if multi_on:
 466     warn_msg = ("Note: this will remove *all* data for the"
 467                 " below instances! It will %s.\n" % os_msg)
 468     if not (opts.force_multi or
 469             ConfirmOperation(inames, "instances", "reinstall", extra=warn_msg)):
 470       return 1
 471   else:
 472     if not (opts.force or opts.force_multi):
 473       usertext = ("This will reinstall the instance '%s' (and %s) which"
 474                   " removes all data. Continue?") % (inames[0], os_msg)
 475       if not AskUser(usertext):
 476         return 1
 477
 478   jex = JobExecutor(verbose=multi_on, opts=opts)
 479   for instance_name in inames:
 480     op = opcodes.OpInstanceReinstall(instance_name=instance_name,
 481                                      os_type=os_name,
 482                                      force_variant=opts.force_variant,
 483                                      osparams=opts.osparams)
 484     jex.QueueJob(instance_name, op)
 485
 486   jex.WaitOrShow(not opts.submit_only)
 487   return 0
 488
 489
 490 def RemoveInstance(opts, args):
 491   """Remove an instance.
 492
 493   @param opts: the command line options selected by the user
 494   @type args: list
 495   @param args: should contain only one element, the name of
 496       the instance to be removed
 497   @rtype: int
 498   @return: the desired exit code
 499
 500   """
 501   instance_name = args[0]
 502   force = opts.force
 503   cl = GetClient()
 504
 505   if not force:
 506     _EnsureInstancesExist(cl, [instance_name])
 507
 508     usertext = ("This will remove the volumes of the instance %s"
 509                 " (including mirrors), thus removing all the data"
 510                 " of the instance. Continue?") % instance_name
 511     if not AskUser(usertext):
 512       return 1
 513
 514   op = opcodes.OpInstanceRemove(instance_name=instance_name,
 515                                 ignore_failures=opts.ignore_failures,
 516                                 shutdown_timeout=opts.shutdown_timeout)
 517   SubmitOrSend(op, opts, cl=cl)
 518   return 0
 519
 520
 521 def RenameInstance(opts, args):
 522   """Rename an instance.
 523
 524   @param opts: the command line options selected by the user
 525   @type args: list
 526   @param args: should contain two elements, the old and the
 527       new instance names
 528   @rtype: int
 529   @return: the desired exit code
 530
 531   """
 532   if not opts.name_check:
 533     if not AskUser("As you disabled the check of the DNS entry, please verify"
 534                    " that '%s' is a FQDN. Continue?" % args[1]):
 535       return 1
 536
 537   op = opcodes.OpInstanceRename(instance_name=args[0],
 538                                 new_name=args[1],
 539                                 ip_check=opts.ip_check,
 540                                 name_check=opts.name_check)
 541   result = SubmitOrSend(op, opts)
 542
 543   if result:
 544     ToStdout("Instance '%s' renamed to '%s'", args[0], result)
 545
 546   return 0
 547
 548
 549 def ActivateDisks(opts, args):
 550   """Activate an instance's disks.
 551
 552   This serves two purposes:
 553     - it allows (as long as the instance is not running)
 554       mounting the disks and modifying them from the node
 555     - it repairs inactive secondary drbds
 556
 557   @param opts: the command line options selected by the user
 558   @type args: list
 559   @param args: should contain only one element, the instance name
 560   @rtype: int
 561   @return: the desired exit code
 562
 563   """
 564   instance_name = args[0]
 565   op = opcodes.OpInstanceActivateDisks(instance_name=instance_name,
 566                                        ignore_size=opts.ignore_size)
 567   disks_info = SubmitOrSend(op, opts)
 568   for host, iname, nname in disks_info:
 569     ToStdout("%s:%s:%s", host, iname, nname)
 570   return 0
 571
 572
 573 def DeactivateDisks(opts, args):
 574   """Deactivate an instance's disks.
 575
 576   This function takes the instance name, looks for its primary node
 577   and the tries to shutdown its block devices on that node.
 578
 579   @param opts: the command line options selected by the user
 580   @type args: list
 581   @param args: should contain only one element, the instance name
 582   @rtype: int
 583   @return: the desired exit code
 584
 585   """
 586   instance_name = args[0]
 587   op = opcodes.OpInstanceDeactivateDisks(instance_name=instance_name,
 588                                          force=opts.force)
 589   SubmitOrSend(op, opts)
 590   return 0
 591
 592
 593 def RecreateDisks(opts, args):
 594   """Recreate an instance's disks.
 595
 596   @param opts: the command line options selected by the user
 597   @type args: list
 598   @param args: should contain only one element, the instance name
 599   @rtype: int
 600   @return: the desired exit code
 601
 602   """
 603   instance_name = args[0]
 604   if opts.disks:
 605     try:
 606       opts.disks = [int(v) for v in opts.disks.split(",")]
 607     except (ValueError, TypeError), err:
 608       ToStderr("Invalid disks value: %s" % str(err))
 609       return 1
 610   else:
 611     opts.disks = []
 612
 613   if opts.node:
 614     pnode, snode = SplitNodeOption(opts.node)
 615     nodes = [pnode]
 616     if snode is not None:
 617       nodes.append(snode)
 618   else:
 619     nodes = []
 620
 621   op = opcodes.OpInstanceRecreateDisks(instance_name=instance_name,
 622                                        disks=opts.disks,
 623                                        nodes=nodes)
 624   SubmitOrSend(op, opts)
 625   return 0
 626
 627
 628 def GrowDisk(opts, args):
 629   """Grow an instance's disks.
 630
 631   @param opts: the command line options selected by the user
 632   @type args: list
 633   @param args: should contain two elements, the instance name
 634       whose disks we grow and the disk name, e.g. I{sda}
 635   @rtype: int
 636   @return: the desired exit code
 637
 638   """
 639   instance = args[0]
 640   disk = args[1]
 641   try:
 642     disk = int(disk)
 643   except (TypeError, ValueError), err:
 644     raise errors.OpPrereqError("Invalid disk index: %s" % str(err),
 645                                errors.ECODE_INVAL)
 646   amount = utils.ParseUnit(args[2])
 647   op = opcodes.OpInstanceGrowDisk(instance_name=instance,
 648                                   disk=disk, amount=amount,
 649                                   wait_for_sync=opts.wait_for_sync)
 650   SubmitOrSend(op, opts)
 651   return 0
 652
 653
 654 def _StartupInstance(name, opts):
 655   """Startup instances.
 656
 657   This returns the opcode to start an instance, and its decorator will
 658   wrap this into a loop starting all desired instances.
 659
 660   @param name: the name of the instance to act on
 661   @param opts: the command line options selected by the user
 662   @return: the opcode needed for the operation
 663
 664   """
 665   op = opcodes.OpInstanceStartup(instance_name=name,
 666                                  force=opts.force,
 667                                  ignore_offline_nodes=opts.ignore_offline,
 668                                  no_remember=opts.no_remember,
 669                                  startup_paused=opts.startup_paused)
 670   # do not add these parameters to the opcode unless they're defined
 671   if opts.hvparams:
 672     op.hvparams = opts.hvparams
 673   if opts.beparams:
 674     op.beparams = opts.beparams
 675   return op
 676
 677
 678 def _RebootInstance(name, opts):
 679   """Reboot instance(s).
 680
 681   This returns the opcode to reboot an instance, and its decorator
 682   will wrap this into a loop rebooting all desired instances.
 683
 684   @param name: the name of the instance to act on
 685   @param opts: the command line options selected by the user
 686   @return: the opcode needed for the operation
 687
 688   """
 689   return opcodes.OpInstanceReboot(instance_name=name,
 690                                   reboot_type=opts.reboot_type,
 691                                   ignore_secondaries=opts.ignore_secondaries,
 692                                   shutdown_timeout=opts.shutdown_timeout)
 693
 694
 695 def _ShutdownInstance(name, opts):
 696   """Shutdown an instance.
 697
 698   This returns the opcode to shutdown an instance, and its decorator
 699   will wrap this into a loop shutting down all desired instances.
 700
 701   @param name: the name of the instance to act on
 702   @param opts: the command line options selected by the user
 703   @return: the opcode needed for the operation
 704
 705   """
 706   return opcodes.OpInstanceShutdown(instance_name=name,
 707                                     timeout=opts.timeout,
 708                                     ignore_offline_nodes=opts.ignore_offline,
 709                                     no_remember=opts.no_remember)
 710
 711
 712 def ReplaceDisks(opts, args):
 713   """Replace the disks of an instance
 714
 715   @param opts: the command line options selected by the user
 716   @type args: list
 717   @param args: should contain only one element, the instance name
 718   @rtype: int
 719   @return: the desired exit code
 720
 721   """
 722   new_2ndary = opts.dst_node
 723   iallocator = opts.iallocator
 724   if opts.disks is None:
 725     disks = []
 726   else:
 727     try:
 728       disks = [int(i) for i in opts.disks.split(",")]
 729     except (TypeError, ValueError), err:
 730       raise errors.OpPrereqError("Invalid disk index passed: %s" % str(err),
 731                                  errors.ECODE_INVAL)
 732   cnt = [opts.on_primary, opts.on_secondary, opts.auto,
 733          new_2ndary is not None, iallocator is not None].count(True)
 734   if cnt != 1:
 735     raise errors.OpPrereqError("One and only one of the -p, -s, -a, -n and -I"
 736                                " options must be passed", errors.ECODE_INVAL)
 737   elif opts.on_primary:
 738     mode = constants.REPLACE_DISK_PRI
 739   elif opts.on_secondary:
 740     mode = constants.REPLACE_DISK_SEC
 741   elif opts.auto:
 742     mode = constants.REPLACE_DISK_AUTO
 743     if disks:
 744       raise errors.OpPrereqError("Cannot specify disks when using automatic"
 745                                  " mode", errors.ECODE_INVAL)
 746   elif new_2ndary is not None or iallocator is not None:
 747     # replace secondary
 748     mode = constants.REPLACE_DISK_CHG
 749
 750   op = opcodes.OpInstanceReplaceDisks(instance_name=args[0], disks=disks,
 751                                       remote_node=new_2ndary, mode=mode,
 752                                       iallocator=iallocator,
 753                                       early_release=opts.early_release)
 754   SubmitOrSend(op, opts)
 755   return 0
 756
 757
 758 def FailoverInstance(opts, args):
 759   """Failover an instance.
 760
 761   The failover is done by shutting it down on its present node and
 762   starting it on the secondary.
 763
 764   @param opts: the command line options selected by the user
 765   @type args: list
 766   @param args: should contain only one element, the instance name
 767   @rtype: int
 768   @return: the desired exit code
 769
 770   """
 771   cl = GetClient()
 772   instance_name = args[0]
 773   force = opts.force
 774   iallocator = opts.iallocator
 775   target_node = opts.dst_node
 776
 777   if iallocator and target_node:
 778     raise errors.OpPrereqError("Specify either an iallocator (-I), or a target"
 779                                " node (-n) but not both", errors.ECODE_INVAL)
 780
 781   if not force:
 782     _EnsureInstancesExist(cl, [instance_name])
 783
 784     usertext = ("Failover will happen to image %s."
 785                 " This requires a shutdown of the instance. Continue?" %
 786                 (instance_name,))
 787     if not AskUser(usertext):
 788       return 1
 789
 790   op = opcodes.OpInstanceFailover(instance_name=instance_name,
 791                                   ignore_consistency=opts.ignore_consistency,
 792                                   shutdown_timeout=opts.shutdown_timeout,
 793                                   iallocator=iallocator,
 794                                   target_node=target_node)
 795   SubmitOrSend(op, opts, cl=cl)
 796   return 0
 797
 798
 799 def MigrateInstance(opts, args):
 800   """Migrate an instance.
 801
 802   The migrate is done without shutdown.
 803
 804   @param opts: the command line options selected by the user
 805   @type args: list
 806   @param args: should contain only one element, the instance name
 807   @rtype: int
 808   @return: the desired exit code
 809
 810   """
 811   cl = GetClient()
 812   instance_name = args[0]
 813   force = opts.force
 814   iallocator = opts.iallocator
 815   target_node = opts.dst_node
 816
 817   if iallocator and target_node:
 818     raise errors.OpPrereqError("Specify either an iallocator (-I), or a target"
 819                                " node (-n) but not both", errors.ECODE_INVAL)
 820
 821   if not force:
 822     _EnsureInstancesExist(cl, [instance_name])
 823
 824     if opts.cleanup:
 825       usertext = ("Instance %s will be recovered from a failed migration."
 826                   " Note that the migration procedure (including cleanup)" %
 827                   (instance_name,))
 828     else:
 829       usertext = ("Instance %s will be migrated. Note that migration" %
 830                   (instance_name,))
 831     usertext += (" might impact the instance if anything goes wrong"
 832                  " (e.g. due to bugs in the hypervisor). Continue?")
 833     if not AskUser(usertext):
 834       return 1
 835
 836   # this should be removed once --non-live is deprecated
 837   if not opts.live and opts.migration_mode is not None:
 838     raise errors.OpPrereqError("Only one of the --non-live and "
 839                                "--migration-mode options can be passed",
 840                                errors.ECODE_INVAL)
 841   if not opts.live: # --non-live passed
 842     mode = constants.HT_MIGRATION_NONLIVE
 843   else:
 844     mode = opts.migration_mode
 845
 846   op = opcodes.OpInstanceMigrate(instance_name=instance_name, mode=mode,
 847                                  cleanup=opts.cleanup, iallocator=iallocator,
 848                                  target_node=target_node,
 849                                  allow_failover=opts.allow_failover)
 850   SubmitOpCode(op, cl=cl, opts=opts)
 851   return 0
 852
 853
 854 def MoveInstance(opts, args):
 855   """Move an instance.
 856
 857   @param opts: the command line options selected by the user
 858   @type args: list
 859   @param args: should contain only one element, the instance name
 860   @rtype: int
 861   @return: the desired exit code
 862
 863   """
 864   cl = GetClient()
 865   instance_name = args[0]
 866   force = opts.force
 867
 868   if not force:
 869     usertext = ("Instance %s will be moved."
 870                 " This requires a shutdown of the instance. Continue?" %
 871                 (instance_name,))
 872     if not AskUser(usertext):
 873       return 1
 874
 875   op = opcodes.OpInstanceMove(instance_name=instance_name,
 876                               target_node=opts.node,
 877                               shutdown_timeout=opts.shutdown_timeout,
 878                               ignore_consistency=opts.ignore_consistency)
 879   SubmitOrSend(op, opts, cl=cl)
 880   return 0
 881
 882
 883 def ConnectToInstanceConsole(opts, args):
 884   """Connect to the console of an instance.
 885
 886   @param opts: the command line options selected by the user
 887   @type args: list
 888   @param args: should contain only one element, the instance name
 889   @rtype: int
 890   @return: the desired exit code
 891
 892   """
 893   instance_name = args[0]
 894
 895   cl = GetClient()
 896   try:
 897     cluster_name = cl.QueryConfigValues(["cluster_name"])[0]
 898     ((console_data, oper_state), ) = \
 899       cl.QueryInstances([instance_name], ["console", "oper_state"], False)
 900   finally:
 901     # Ensure client connection is closed while external commands are run
 902     cl.Close()
 903
 904   del cl
 905
 906   if not console_data:
 907     if oper_state:
 908       # Instance is running
 909       raise errors.OpExecError("Console information for instance %s is"
 910                                " unavailable" % instance_name)
 911     else:
 912       raise errors.OpExecError("Instance %s is not running, can't get console" %
 913                                instance_name)
 914
 915   return _DoConsole(objects.InstanceConsole.FromDict(console_data),
 916                     opts.show_command, cluster_name)
 917
 918
 919 def _DoConsole(console, show_command, cluster_name, feedback_fn=ToStdout,
 920                _runcmd_fn=utils.RunCmd):
 921   """Acts based on the result of L{opcodes.OpInstanceConsole}.
 922
 923   @type console: L{objects.InstanceConsole}
 924   @param console: Console object
 925   @type show_command: bool
 926   @param show_command: Whether to just display commands
 927   @type cluster_name: string
 928   @param cluster_name: Cluster name as retrieved from master daemon
 929
 930   """
 931   assert console.Validate()
 932
 933   if console.kind == constants.CONS_MESSAGE:
 934     feedback_fn(console.message)
 935   elif console.kind == constants.CONS_VNC:
 936     feedback_fn("Instance %s has VNC listening on %s:%s (display %s),"
 937                 " URL <vnc://%s:%s/>",
 938                 console.instance, console.host, console.port,
 939                 console.display, console.host, console.port)
 940   elif console.kind == constants.CONS_SPICE:
 941     feedback_fn("Instance %s has SPICE listening on %s:%s", console.instance,
 942                 console.host, console.port)
 943   elif console.kind == constants.CONS_SSH:
 944     # Convert to string if not already one
 945     if isinstance(console.command, basestring):
 946       cmd = console.command
 947     else:
 948       cmd = utils.ShellQuoteArgs(console.command)
 949
 950     srun = ssh.SshRunner(cluster_name=cluster_name)
 951     ssh_cmd = srun.BuildCmd(console.host, console.user, cmd,
 952                             batch=True, quiet=False, tty=True)
 953
 954     if show_command:
 955       feedback_fn(utils.ShellQuoteArgs(ssh_cmd))
 956     else:
 957       result = _runcmd_fn(ssh_cmd, interactive=True)
 958       if result.failed:
 959         logging.error("Console command \"%s\" failed with reason '%s' and"
 960                       " output %r", result.cmd, result.fail_reason,
 961                       result.output)
 962         raise errors.OpExecError("Connection to console of instance %s failed,"
 963                                  " please check cluster configuration" %
 964                                  console.instance)
 965   else:
 966     raise errors.GenericError("Unknown console type '%s'" % console.kind)
 967
 968   return constants.EXIT_SUCCESS
 969
 970
 971 def _FormatLogicalID(dev_type, logical_id, roman):
 972   """Formats the logical_id of a disk.
 973
 974   """
 975   if dev_type == constants.LD_DRBD8:
 976     node_a, node_b, port, minor_a, minor_b, key = logical_id
 977     data = [
 978       ("nodeA", "%s, minor=%s" % (node_a, compat.TryToRoman(minor_a,
 979                                                             convert=roman))),
 980       ("nodeB", "%s, minor=%s" % (node_b, compat.TryToRoman(minor_b,
 981                                                             convert=roman))),
 982       ("port", compat.TryToRoman(port, convert=roman)),
 983       ("auth key", key),
 984       ]
 985   elif dev_type == constants.LD_LV:
 986     vg_name, lv_name = logical_id
 987     data = ["%s/%s" % (vg_name, lv_name)]
 988   else:
 989     data = [str(logical_id)]
 990
 991   return data
 992
 993
 994 def _FormatBlockDevInfo(idx, top_level, dev, roman):
 995   """Show block device information.
 996
 997   This is only used by L{ShowInstanceConfig}, but it's too big to be
 998   left for an inline definition.
 999
1000   @type idx: int
1001   @param idx: the index of the current disk
1002   @type top_level: boolean
1003   @param top_level: if this a top-level disk?
1004   @type dev: dict
1005   @param dev: dictionary with disk information
1006   @type roman: boolean
1007   @param roman: whether to try to use roman integers
1008   @return: a list of either strings, tuples or lists
1009       (which should be formatted at a higher indent level)
1010
1011   """
1012   def helper(dtype, status):
1013     """Format one line for physical device status.
1014
1015     @type dtype: str
1016     @param dtype: a constant from the L{constants.LDS_BLOCK} set
1017     @type status: tuple
1018     @param status: a tuple as returned from L{backend.FindBlockDevice}
1019     @return: the string representing the status
1020
1021     """
1022     if not status:
1023       return "not active"
1024     txt = ""
1025     (path, major, minor, syncp, estt, degr, ldisk_status) = status
1026     if major is None:
1027       major_string = "N/A"
1028     else:
1029       major_string = str(compat.TryToRoman(major, convert=roman))
1030
1031     if minor is None:
1032       minor_string = "N/A"
1033     else:
1034       minor_string = str(compat.TryToRoman(minor, convert=roman))
1035
1036     txt += ("%s (%s:%s)" % (path, major_string, minor_string))
1037     if dtype in (constants.LD_DRBD8, ):
1038       if syncp is not None:
1039         sync_text = "*RECOVERING* %5.2f%%," % syncp
1040         if estt:
1041           sync_text += " ETA %ss" % compat.TryToRoman(estt, convert=roman)
1042         else:
1043           sync_text += " ETA unknown"
1044       else:
1045         sync_text = "in sync"
1046       if degr:
1047         degr_text = "*DEGRADED*"
1048       else:
1049         degr_text = "ok"
1050       if ldisk_status == constants.LDS_FAULTY:
1051         ldisk_text = " *MISSING DISK*"
1052       elif ldisk_status == constants.LDS_UNKNOWN:
1053         ldisk_text = " *UNCERTAIN STATE*"
1054       else:
1055         ldisk_text = ""
1056       txt += (" %s, status %s%s" % (sync_text, degr_text, ldisk_text))
1057     elif dtype == constants.LD_LV:
1058       if ldisk_status == constants.LDS_FAULTY:
1059         ldisk_text = " *FAILED* (failed drive?)"
1060       else:
1061         ldisk_text = ""
1062       txt += ldisk_text
1063     return txt
1064
1065   # the header
1066   if top_level:
1067     if dev["iv_name"] is not None:
1068       txt = dev["iv_name"]
1069     else:
1070       txt = "disk %s" % compat.TryToRoman(idx, convert=roman)
1071   else:
1072     txt = "child %s" % compat.TryToRoman(idx, convert=roman)
1073   if isinstance(dev["size"], int):
1074     nice_size = utils.FormatUnit(dev["size"], "h")
1075   else:
1076     nice_size = dev["size"]
1077   d1 = ["- %s: %s, size %s" % (txt, dev["dev_type"], nice_size)]
1078   data = []
1079   if top_level:
1080     data.append(("access mode", dev["mode"]))
1081   if dev["logical_id"] is not None:
1082     try:
1083       l_id = _FormatLogicalID(dev["dev_type"], dev["logical_id"], roman)
1084     except ValueError:
1085       l_id = [str(dev["logical_id"])]
1086     if len(l_id) == 1:
1087       data.append(("logical_id", l_id[0]))
1088     else:
1089       data.extend(l_id)
1090   elif dev["physical_id"] is not None:
1091     data.append("physical_id:")
1092     data.append([dev["physical_id"]])
1093
1094   if dev["pstatus"]:
1095     data.append(("on primary", helper(dev["dev_type"], dev["pstatus"])))
1096
1097   if dev["sstatus"]:
1098     data.append(("on secondary", helper(dev["dev_type"], dev["sstatus"])))
1099
1100   if dev["children"]:
1101     data.append("child devices:")
1102     for c_idx, child in enumerate(dev["children"]):
1103       data.append(_FormatBlockDevInfo(c_idx, False, child, roman))
1104   d1.append(data)
1105   return d1
1106
1107
1108 def _FormatList(buf, data, indent_level):
1109   """Formats a list of data at a given indent level.
1110
1111   If the element of the list is:
1112     - a string, it is simply formatted as is
1113     - a tuple, it will be split into key, value and the all the
1114       values in a list will be aligned all at the same start column
1115     - a list, will be recursively formatted
1116
1117   @type buf: StringIO
1118   @param buf: the buffer into which we write the output
1119   @param data: the list to format
1120   @type indent_level: int
1121   @param indent_level: the indent level to format at
1122
1123   """
1124   max_tlen = max([len(elem[0]) for elem in data
1125                  if isinstance(elem, tuple)] or [0])
1126   for elem in data:
1127     if isinstance(elem, basestring):
1128       buf.write("%*s%s\n" % (2 * indent_level, "", elem))
1129     elif isinstance(elem, tuple):
1130       key, value = elem
1131       spacer = "%*s" % (max_tlen - len(key), "")
1132       buf.write("%*s%s:%s %s\n" % (2 * indent_level, "", key, spacer, value))
1133     elif isinstance(elem, list):
1134       _FormatList(buf, elem, indent_level + 1)
1135
1136
1137 def ShowInstanceConfig(opts, args):
1138   """Compute instance run-time status.
1139
1140   @param opts: the command line options selected by the user
1141   @type args: list
1142   @param args: either an empty list, and then we query all
1143       instances, or should contain a list of instance names
1144   @rtype: int
1145   @return: the desired exit code
1146
1147   """
1148   if not args and not opts.show_all:
1149     ToStderr("No instance selected."
1150              " Please pass in --all if you want to query all instances.\n"
1151              "Note that this can take a long time on a big cluster.")
1152     return 1
1153   elif args and opts.show_all:
1154     ToStderr("Cannot use --all if you specify instance names.")
1155     return 1
1156
1157   retcode = 0
1158   op = opcodes.OpInstanceQueryData(instances=args, static=opts.static,
1159                                    use_locking=not opts.static)
1160   result = SubmitOpCode(op, opts=opts)
1161   if not result:
1162     ToStdout("No instances.")
1163     return 1
1164
1165   buf = StringIO()
1166   retcode = 0
1167   for instance_name in result:
1168     instance = result[instance_name]
1169     buf.write("Instance name: %s\n" % instance["name"])
1170     buf.write("UUID: %s\n" % instance["uuid"])
1171     buf.write("Serial number: %s\n" %
1172               compat.TryToRoman(instance["serial_no"],
1173                                 convert=opts.roman_integers))
1174     buf.write("Creation time: %s\n" % utils.FormatTime(instance["ctime"]))
1175     buf.write("Modification time: %s\n" % utils.FormatTime(instance["mtime"]))
1176     buf.write("State: configured to be %s" % instance["config_state"])
1177     if instance["run_state"]:
1178       buf.write(", actual state is %s" % instance["run_state"])
1179     buf.write("\n")
1180     ##buf.write("Considered for memory checks in cluster verify: %s\n" %
1181     ##          instance["auto_balance"])
1182     buf.write("  Nodes:\n")
1183     buf.write("    - primary: %s\n" % instance["pnode"])
1184     buf.write("    - secondaries: %s\n" % utils.CommaJoin(instance["snodes"]))
1185     buf.write("  Operating system: %s\n" % instance["os"])
1186     FormatParameterDict(buf, instance["os_instance"], instance["os_actual"],
1187                         level=2)
1188     if "network_port" in instance:
1189       buf.write("  Allocated network port: %s\n" %
1190                 compat.TryToRoman(instance["network_port"],
1191                                   convert=opts.roman_integers))
1192     buf.write("  Hypervisor: %s\n" % instance["hypervisor"])
1193
1194     # custom VNC console information
1195     vnc_bind_address = instance["hv_actual"].get(constants.HV_VNC_BIND_ADDRESS,
1196                                                  None)
1197     if vnc_bind_address:
1198       port = instance["network_port"]
1199       display = int(port) - constants.VNC_BASE_PORT
1200       if display > 0 and vnc_bind_address == constants.IP4_ADDRESS_ANY:
1201         vnc_console_port = "%s:%s (display %s)" % (instance["pnode"],
1202                                                    port,
1203                                                    display)
1204       elif display > 0 and netutils.IP4Address.IsValid(vnc_bind_address):
1205         vnc_console_port = ("%s:%s (node %s) (display %s)" %
1206                              (vnc_bind_address, port,
1207                               instance["pnode"], display))
1208       else:
1209         # vnc bind address is a file
1210         vnc_console_port = "%s:%s" % (instance["pnode"],
1211                                       vnc_bind_address)
1212       buf.write("    - console connection: vnc to %s\n" % vnc_console_port)
1213
1214     FormatParameterDict(buf, instance["hv_instance"], instance["hv_actual"],
1215                         level=2)
1216     buf.write("  Hardware:\n")
1217     buf.write("    - VCPUs: %s\n" %
1218               compat.TryToRoman(instance["be_actual"][constants.BE_VCPUS],
1219                                 convert=opts.roman_integers))
1220     buf.write("    - memory: %sMiB\n" %
1221               compat.TryToRoman(instance["be_actual"][constants.BE_MEMORY],
1222                                 convert=opts.roman_integers))
1223     buf.write("    - NICs:\n")
1224     for idx, (ip, mac, mode, link) in enumerate(instance["nics"]):
1225       buf.write("      - nic/%d: MAC: %s, IP: %s, mode: %s, link: %s\n" %
1226                 (idx, mac, ip, mode, link))
1227     buf.write("  Disk template: %s\n" % instance["disk_template"])
1228     buf.write("  Disks:\n")
1229
1230     for idx, device in enumerate(instance["disks"]):
1231       _FormatList(buf, _FormatBlockDevInfo(idx, True, device,
1232                   opts.roman_integers), 2)
1233
1234   ToStdout(buf.getvalue().rstrip("\n"))
1235   return retcode
1236
1237
1238 def SetInstanceParams(opts, args):
1239   """Modifies an instance.
1240
1241   All parameters take effect only at the next restart of the instance.
1242
1243   @param opts: the command line options selected by the user
1244   @type args: list
1245   @param args: should contain only one element, the instance name
1246   @rtype: int
1247   @return: the desired exit code
1248
1249   """
1250   if not (opts.nics or opts.disks or opts.disk_template or
1251           opts.hvparams or opts.beparams or opts.os or opts.osparams or
1252           opts.offline_inst or opts.online_inst):
1253     ToStderr("Please give at least one of the parameters.")
1254     return 1
1255
1256   for param in opts.beparams:
1257     if isinstance(opts.beparams[param], basestring):
1258       if opts.beparams[param].lower() == "default":
1259         opts.beparams[param] = constants.VALUE_DEFAULT
1260
1261   utils.ForceDictType(opts.beparams, constants.BES_PARAMETER_TYPES,
1262                       allowed_values=[constants.VALUE_DEFAULT])
1263
1264   for param in opts.hvparams:
1265     if isinstance(opts.hvparams[param], basestring):
1266       if opts.hvparams[param].lower() == "default":
1267         opts.hvparams[param] = constants.VALUE_DEFAULT
1268
1269   utils.ForceDictType(opts.hvparams, constants.HVS_PARAMETER_TYPES,
1270                       allowed_values=[constants.VALUE_DEFAULT])
1271
1272   for idx, (nic_op, nic_dict) in enumerate(opts.nics):
1273     try:
1274       nic_op = int(nic_op)
1275       opts.nics[idx] = (nic_op, nic_dict)
1276     except (TypeError, ValueError):
1277       pass
1278
1279   for idx, (disk_op, disk_dict) in enumerate(opts.disks):
1280     try:
1281       disk_op = int(disk_op)
1282       opts.disks[idx] = (disk_op, disk_dict)
1283     except (TypeError, ValueError):
1284       pass
1285     if disk_op == constants.DDM_ADD:
1286       if "size" not in disk_dict:
1287         raise errors.OpPrereqError("Missing required parameter 'size'",
1288                                    errors.ECODE_INVAL)
1289       disk_dict["size"] = utils.ParseUnit(disk_dict["size"])
1290
1291   if (opts.disk_template and
1292       opts.disk_template in constants.DTS_INT_MIRROR and
1293       not opts.node):
1294     ToStderr("Changing the disk template to a mirrored one requires"
1295              " specifying a secondary node")
1296     return 1
1297
1298   op = opcodes.OpInstanceSetParams(instance_name=args[0],
1299                                    nics=opts.nics,
1300                                    disks=opts.disks,
1301                                    disk_template=opts.disk_template,
1302                                    remote_node=opts.node,
1303                                    hvparams=opts.hvparams,
1304                                    beparams=opts.beparams,
1305                                    os_name=opts.os,
1306                                    osparams=opts.osparams,
1307                                    force_variant=opts.force_variant,
1308                                    force=opts.force,
1309                                    wait_for_sync=opts.wait_for_sync,
1310                                    offline_inst=opts.offline_inst,
1311                                    online_inst=opts.online_inst)
1312
1313   # even if here we process the result, we allow submit only
1314   result = SubmitOrSend(op, opts)
1315
1316   if result:
1317     ToStdout("Modified instance %s", args[0])
1318     for param, data in result:
1319       ToStdout(" - %-5s -> %s", param, data)
1320     ToStdout("Please don't forget that most parameters take effect"
1321              " only at the next start of the instance.")
1322   return 0
1323
1324
1325 def ChangeGroup(opts, args):
1326   """Moves an instance to another group.
1327
1328   """
1329   (instance_name, ) = args
1330
1331   cl = GetClient()
1332
1333   op = opcodes.OpInstanceChangeGroup(instance_name=instance_name,
1334                                      iallocator=opts.iallocator,
1335                                      target_groups=opts.to,
1336                                      early_release=opts.early_release)
1337   result = SubmitOpCode(op, cl=cl, opts=opts)
1338
1339   # Keep track of submitted jobs
1340   jex = JobExecutor(cl=cl, opts=opts)
1341
1342   for (status, job_id) in result[constants.JOB_IDS_KEY]:
1343     jex.AddJobId(None, status, job_id)
1344
1345   results = jex.GetResults()
1346   bad_cnt = len([row for row in results if not row[0]])
1347   if bad_cnt == 0:
1348     ToStdout("Instance '%s' changed group successfully.", instance_name)
1349     rcode = constants.EXIT_SUCCESS
1350   else:
1351     ToStdout("There were %s errors while changing group of instance '%s'.",
1352              bad_cnt, instance_name)
1353     rcode = constants.EXIT_FAILURE
1354
1355   return rcode
1356
1357
1358 # multi-instance selection options
1359 m_force_multi = cli_option("--force-multiple", dest="force_multi",
1360                            help="Do not ask for confirmation when more than"
1361                            " one instance is affected",
1362                            action="store_true", default=False)
1363
1364 m_pri_node_opt = cli_option("--primary", dest="multi_mode",
1365                             help="Filter by nodes (primary only)",
1366                             const=_EXPAND_NODES_PRI, action="store_const")
1367
1368 m_sec_node_opt = cli_option("--secondary", dest="multi_mode",
1369                             help="Filter by nodes (secondary only)",
1370                             const=_EXPAND_NODES_SEC, action="store_const")
1371
1372 m_node_opt = cli_option("--node", dest="multi_mode",
1373                         help="Filter by nodes (primary and secondary)",
1374                         const=_EXPAND_NODES_BOTH, action="store_const")
1375
1376 m_clust_opt = cli_option("--all", dest="multi_mode",
1377                          help="Select all instances in the cluster",
1378                          const=_EXPAND_CLUSTER, action="store_const")
1379
1380 m_inst_opt = cli_option("--instance", dest="multi_mode",
1381                         help="Filter by instance name [default]",
1382                         const=_EXPAND_INSTANCES, action="store_const")
1383
1384 m_node_tags_opt = cli_option("--node-tags", dest="multi_mode",
1385                              help="Filter by node tag",
1386                              const=_EXPAND_NODES_BOTH_BY_TAGS,
1387                              action="store_const")
1388
1389 m_pri_node_tags_opt = cli_option("--pri-node-tags", dest="multi_mode",
1390                                  help="Filter by primary node tag",
1391                                  const=_EXPAND_NODES_PRI_BY_TAGS,
1392                                  action="store_const")
1393
1394 m_sec_node_tags_opt = cli_option("--sec-node-tags", dest="multi_mode",
1395                                  help="Filter by secondary node tag",
1396                                  const=_EXPAND_NODES_SEC_BY_TAGS,
1397                                  action="store_const")
1398
1399 m_inst_tags_opt = cli_option("--tags", dest="multi_mode",
1400                              help="Filter by instance tag",
1401                              const=_EXPAND_INSTANCES_BY_TAGS,
1402                              action="store_const")
1403
1404 # this is defined separately due to readability only
1405 add_opts = [
1406   NOSTART_OPT,
1407   OS_OPT,
1408   FORCE_VARIANT_OPT,
1409   NO_INSTALL_OPT,
1410   ]
1411
1412 commands = {
1413   "add": (
1414     AddInstance, [ArgHost(min=1, max=1)], COMMON_CREATE_OPTS + add_opts,
1415     "[...] -t disk-type -n node[:secondary-node] -o os-type <name>",
1416     "Creates and adds a new instance to the cluster"),
1417   "batch-create": (
1418     BatchCreate, [ArgFile(min=1, max=1)], [DRY_RUN_OPT, PRIORITY_OPT],
1419     "<instances.json>",
1420     "Create a bunch of instances based on specs in the file."),
1421   "console": (
1422     ConnectToInstanceConsole, ARGS_ONE_INSTANCE,
1423     [SHOWCMD_OPT, PRIORITY_OPT],
1424     "[--show-cmd] <instance>", "Opens a console on the specified instance"),
1425   "failover": (
1426     FailoverInstance, ARGS_ONE_INSTANCE,
1427     [FORCE_OPT, IGNORE_CONSIST_OPT, SUBMIT_OPT, SHUTDOWN_TIMEOUT_OPT,
1428      DRY_RUN_OPT, PRIORITY_OPT, DST_NODE_OPT, IALLOCATOR_OPT],
1429     "[-f] <instance>", "Stops the instance, changes its primary node and"
1430     " (if it was originally running) starts it on the new node"
1431     " (the secondary for mirrored instances or any node"
1432     " for shared storage)."),
1433   "migrate": (
1434     MigrateInstance, ARGS_ONE_INSTANCE,
1435     [FORCE_OPT, NONLIVE_OPT, MIGRATION_MODE_OPT, CLEANUP_OPT, DRY_RUN_OPT,
1436      PRIORITY_OPT, DST_NODE_OPT, IALLOCATOR_OPT, ALLOW_FAILOVER_OPT],
1437     "[-f] <instance>", "Migrate instance to its secondary node"
1438     " (only for mirrored instances)"),
1439   "move": (
1440     MoveInstance, ARGS_ONE_INSTANCE,
1441     [FORCE_OPT, SUBMIT_OPT, SINGLE_NODE_OPT, SHUTDOWN_TIMEOUT_OPT,
1442      DRY_RUN_OPT, PRIORITY_OPT, IGNORE_CONSIST_OPT],
1443     "[-f] <instance>", "Move instance to an arbitrary node"
1444     " (only for instances of type file and lv)"),
1445   "info": (
1446     ShowInstanceConfig, ARGS_MANY_INSTANCES,
1447     [STATIC_OPT, ALL_OPT, ROMAN_OPT, PRIORITY_OPT],
1448     "[-s] {--all | <instance>...}",
1449     "Show information on the specified instance(s)"),
1450   "list": (
1451     ListInstances, ARGS_MANY_INSTANCES,
1452     [NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT, VERBOSE_OPT,
1453      FORCE_FILTER_OPT],
1454     "[<instance>...]",
1455     "Lists the instances and their status. The available fields can be shown"
1456     " using the \"list-fields\" command (see the man page for details)."
1457     " The default field list is (in order): %s." %
1458     utils.CommaJoin(_LIST_DEF_FIELDS),
1459     ),
1460   "list-fields": (
1461     ListInstanceFields, [ArgUnknown()],
1462     [NOHDR_OPT, SEP_OPT],
1463     "[fields...]",
1464     "Lists all available fields for instances"),
1465   "reinstall": (
1466     ReinstallInstance, [ArgInstance()],
1467     [FORCE_OPT, OS_OPT, FORCE_VARIANT_OPT, m_force_multi, m_node_opt,
1468      m_pri_node_opt, m_sec_node_opt, m_clust_opt, m_inst_opt, m_node_tags_opt,
1469      m_pri_node_tags_opt, m_sec_node_tags_opt, m_inst_tags_opt, SELECT_OS_OPT,
1470      SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT, OSPARAMS_OPT],
1471     "[-f] <instance>", "Reinstall a stopped instance"),
1472   "remove": (
1473     RemoveInstance, ARGS_ONE_INSTANCE,
1474     [FORCE_OPT, SHUTDOWN_TIMEOUT_OPT, IGNORE_FAILURES_OPT, SUBMIT_OPT,
1475      DRY_RUN_OPT, PRIORITY_OPT],
1476     "[-f] <instance>", "Shuts down the instance and removes it"),
1477   "rename": (
1478     RenameInstance,
1479     [ArgInstance(min=1, max=1), ArgHost(min=1, max=1)],
1480     [NOIPCHECK_OPT, NONAMECHECK_OPT, SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT],
1481     "<instance> <new_name>", "Rename the instance"),
1482   "replace-disks": (
1483     ReplaceDisks, ARGS_ONE_INSTANCE,
1484     [AUTO_REPLACE_OPT, DISKIDX_OPT, IALLOCATOR_OPT, EARLY_RELEASE_OPT,
1485      NEW_SECONDARY_OPT, ON_PRIMARY_OPT, ON_SECONDARY_OPT, SUBMIT_OPT,
1486      DRY_RUN_OPT, PRIORITY_OPT],
1487     "[-s|-p|-n NODE|-I NAME] <instance>",
1488     "Replaces all disks for the instance"),
1489   "modify": (
1490     SetInstanceParams, ARGS_ONE_INSTANCE,
1491     [BACKEND_OPT, DISK_OPT, FORCE_OPT, HVOPTS_OPT, NET_OPT, SUBMIT_OPT,
1492      DISK_TEMPLATE_OPT, SINGLE_NODE_OPT, OS_OPT, FORCE_VARIANT_OPT,
1493      OSPARAMS_OPT, DRY_RUN_OPT, PRIORITY_OPT, NWSYNC_OPT, OFFLINE_INST_OPT,
1494      ONLINE_INST_OPT],
1495     "<instance>", "Alters the parameters of an instance"),
1496   "shutdown": (
1497     GenericManyOps("shutdown", _ShutdownInstance), [ArgInstance()],
1498     [m_node_opt, m_pri_node_opt, m_sec_node_opt, m_clust_opt,
1499      m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt,
1500      m_inst_tags_opt, m_inst_opt, m_force_multi, TIMEOUT_OPT, SUBMIT_OPT,
1501      DRY_RUN_OPT, PRIORITY_OPT, IGNORE_OFFLINE_OPT, NO_REMEMBER_OPT],
1502     "<instance>", "Stops an instance"),
1503   "startup": (
1504     GenericManyOps("startup", _StartupInstance), [ArgInstance()],
1505     [FORCE_OPT, m_force_multi, m_node_opt, m_pri_node_opt, m_sec_node_opt,
1506      m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt,
1507      m_inst_tags_opt, m_clust_opt, m_inst_opt, SUBMIT_OPT, HVOPTS_OPT,
1508      BACKEND_OPT, DRY_RUN_OPT, PRIORITY_OPT, IGNORE_OFFLINE_OPT,
1509      NO_REMEMBER_OPT, STARTUP_PAUSED_OPT],
1510     "<instance>", "Starts an instance"),
1511   "reboot": (
1512     GenericManyOps("reboot", _RebootInstance), [ArgInstance()],
1513     [m_force_multi, REBOOT_TYPE_OPT, IGNORE_SECONDARIES_OPT, m_node_opt,
1514      m_pri_node_opt, m_sec_node_opt, m_clust_opt, m_inst_opt, SUBMIT_OPT,
1515      m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt,
1516      m_inst_tags_opt, SHUTDOWN_TIMEOUT_OPT, DRY_RUN_OPT, PRIORITY_OPT],
1517     "<instance>", "Reboots an instance"),
1518   "activate-disks": (
1519     ActivateDisks, ARGS_ONE_INSTANCE,
1520     [SUBMIT_OPT, IGNORE_SIZE_OPT, PRIORITY_OPT],
1521     "<instance>", "Activate an instance's disks"),
1522   "deactivate-disks": (
1523     DeactivateDisks, ARGS_ONE_INSTANCE,
1524     [FORCE_OPT, SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT],
1525     "[-f] <instance>", "Deactivate an instance's disks"),
1526   "recreate-disks": (
1527     RecreateDisks, ARGS_ONE_INSTANCE,
1528     [SUBMIT_OPT, DISKIDX_OPT, NODE_PLACEMENT_OPT, DRY_RUN_OPT, PRIORITY_OPT],
1529     "<instance>", "Recreate an instance's disks"),
1530   "grow-disk": (
1531     GrowDisk,
1532     [ArgInstance(min=1, max=1), ArgUnknown(min=1, max=1),
1533      ArgUnknown(min=1, max=1)],
1534     [SUBMIT_OPT, NWSYNC_OPT, DRY_RUN_OPT, PRIORITY_OPT],
1535     "<instance> <disk> <size>", "Grow an instance's disk"),
1536   "change-group": (
1537     ChangeGroup, ARGS_ONE_INSTANCE,
1538     [TO_GROUP_OPT, IALLOCATOR_OPT, EARLY_RELEASE_OPT],
1539     "[-I <iallocator>] [--to <group>]", "Change group of instance"),
1540   "list-tags": (
1541     ListTags, ARGS_ONE_INSTANCE, [PRIORITY_OPT],
1542     "<instance_name>", "List the tags of the given instance"),
1543   "add-tags": (
1544     AddTags, [ArgInstance(min=1, max=1), ArgUnknown()],
1545     [TAG_SRC_OPT, PRIORITY_OPT],
1546     "<instance_name> tag...", "Add tags to the given instance"),
1547   "remove-tags": (
1548     RemoveTags, [ArgInstance(min=1, max=1), ArgUnknown()],
1549     [TAG_SRC_OPT, PRIORITY_OPT],
1550     "<instance_name> tag...", "Remove tags from given instance"),
1551   }
1552
1553 #: dictionary with aliases for commands
1554 aliases = {
1555   "start": "startup",
1556   "stop": "shutdown",
1557   }
1558
1559
1560 def Main():
1561   return GenericMain(commands, aliases=aliases,
1562                      override={"tag_type": constants.TAG_INSTANCE},
1563                      env_override=_ENV_OVERRIDE)