Statistics
| Branch: | Tag: | Revision:

root / scripts / gnt-instance @ cb573a31

History | View | Annotate | Download (49.5 kB)

1
#!/usr/bin/python
2
#
3

    
4
# Copyright (C) 2006, 2007 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-msg=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 sys
29
import os
30
import itertools
31
import simplejson
32
from cStringIO import StringIO
33

    
34
from ganeti.cli import *
35
from ganeti import opcodes
36
from ganeti import constants
37
from ganeti import utils
38
from ganeti import errors
39

    
40

    
41
_SHUTDOWN_CLUSTER = "cluster"
42
_SHUTDOWN_NODES_BOTH = "nodes"
43
_SHUTDOWN_NODES_PRI = "nodes-pri"
44
_SHUTDOWN_NODES_SEC = "nodes-sec"
45
_SHUTDOWN_NODES_BOTH_BY_TAGS = "nodes-by-tags"
46
_SHUTDOWN_NODES_PRI_BY_TAGS = "nodes-pri-by-tags"
47
_SHUTDOWN_NODES_SEC_BY_TAGS = "nodes-sec-by-tags"
48
_SHUTDOWN_INSTANCES = "instances"
49
_SHUTDOWN_INSTANCES_BY_TAGS = "instances-by-tags"
50

    
51
_SHUTDOWN_NODES_TAGS_MODES = (
52
    _SHUTDOWN_NODES_BOTH_BY_TAGS,
53
    _SHUTDOWN_NODES_PRI_BY_TAGS,
54
    _SHUTDOWN_NODES_SEC_BY_TAGS)
55

    
56

    
57
_VALUE_TRUE = "true"
58

    
59
#: default list of options for L{ListInstances}
60
_LIST_DEF_FIELDS = [
61
  "name", "hypervisor", "os", "pnode", "status", "oper_ram",
62
  ]
63

    
64

    
65
def _ExpandMultiNames(mode, names, client=None):
66
  """Expand the given names using the passed mode.
67

    
68
  For _SHUTDOWN_CLUSTER, all instances will be returned. For
69
  _SHUTDOWN_NODES_PRI/SEC, all instances having those nodes as
70
  primary/secondary will be returned. For _SHUTDOWN_NODES_BOTH, all
71
  instances having those nodes as either primary or secondary will be
72
  returned. For _SHUTDOWN_INSTANCES, the given instances will be
73
  returned.
74

    
75
  @param mode: one of L{_SHUTDOWN_CLUSTER}, L{_SHUTDOWN_NODES_BOTH},
76
      L{_SHUTDOWN_NODES_PRI}, L{_SHUTDOWN_NODES_SEC} or
77
      L{_SHUTDOWN_INSTANCES}
78
  @param names: a list of names; for cluster, it must be empty,
79
      and for node and instance it must be a list of valid item
80
      names (short names are valid as usual, e.g. node1 instead of
81
      node1.example.com)
82
  @rtype: list
83
  @return: the list of names after the expansion
84
  @raise errors.ProgrammerError: for unknown selection type
85
  @raise errors.OpPrereqError: for invalid input parameters
86

    
87
  """
88
  # pylint: disable-msg=W0142
89

    
90
  if client is None:
91
    client = GetClient()
92
  if mode == _SHUTDOWN_CLUSTER:
93
    if names:
94
      raise errors.OpPrereqError("Cluster filter mode takes no arguments",
95
                                 errors.ECODE_INVAL)
96
    idata = client.QueryInstances([], ["name"], False)
97
    inames = [row[0] for row in idata]
98

    
99
  elif mode in (_SHUTDOWN_NODES_BOTH,
100
                _SHUTDOWN_NODES_PRI,
101
                _SHUTDOWN_NODES_SEC) + _SHUTDOWN_NODES_TAGS_MODES:
102
    if mode in _SHUTDOWN_NODES_TAGS_MODES:
103
      if not names:
104
        raise errors.OpPrereqError("No node tags passed", errors.ECODE_INVAL)
105
      ndata = client.QueryNodes([], ["name", "pinst_list",
106
                                     "sinst_list", "tags"], False)
107
      ndata = [row for row in ndata if set(row[3]).intersection(names)]
108
    else:
109
      if not names:
110
        raise errors.OpPrereqError("No node names passed", errors.ECODE_INVAL)
111
      ndata = client.QueryNodes(names, ["name", "pinst_list", "sinst_list"],
112
                              False)
113

    
114
    ipri = [row[1] for row in ndata]
115
    pri_names = list(itertools.chain(*ipri))
116
    isec = [row[2] for row in ndata]
117
    sec_names = list(itertools.chain(*isec))
118
    if mode in (_SHUTDOWN_NODES_BOTH, _SHUTDOWN_NODES_BOTH_BY_TAGS):
119
      inames = pri_names + sec_names
120
    elif mode in (_SHUTDOWN_NODES_PRI, _SHUTDOWN_NODES_PRI_BY_TAGS):
121
      inames = pri_names
122
    elif mode in (_SHUTDOWN_NODES_SEC, _SHUTDOWN_NODES_SEC_BY_TAGS):
123
      inames = sec_names
124
    else:
125
      raise errors.ProgrammerError("Unhandled shutdown type")
126
  elif mode == _SHUTDOWN_INSTANCES:
127
    if not names:
128
      raise errors.OpPrereqError("No instance names passed",
129
                                 errors.ECODE_INVAL)
130
    idata = client.QueryInstances(names, ["name"], False)
131
    inames = [row[0] for row in idata]
132
  elif mode == _SHUTDOWN_INSTANCES_BY_TAGS:
133
    if not names:
134
      raise errors.OpPrereqError("No instance tags passed",
135
                                 errors.ECODE_INVAL)
136
    idata = client.QueryInstances([], ["name", "tags"], False)
137
    inames = [row[0] for row in idata if set(row[1]).intersection(names)]
138
  else:
139
    raise errors.OpPrereqError("Unknown mode '%s'" % mode, errors.ECODE_INVAL)
140

    
141
  return inames
142

    
143

    
144
def _ConfirmOperation(inames, text, extra=""):
145
  """Ask the user to confirm an operation on a list of instances.
146

    
147
  This function is used to request confirmation for doing an operation
148
  on a given list of instances.
149

    
150
  @type inames: list
151
  @param inames: the list of names that we display when
152
      we ask for confirmation
153
  @type text: str
154
  @param text: the operation that the user should confirm
155
      (e.g. I{shutdown} or I{startup})
156
  @rtype: boolean
157
  @return: True or False depending on user's confirmation.
158

    
159
  """
160
  count = len(inames)
161
  msg = ("The %s will operate on %d instances.\n%s"
162
         "Do you want to continue?" % (text, count, extra))
163
  affected = ("\nAffected instances:\n" +
164
              "\n".join(["  %s" % name for name in inames]))
165

    
166
  choices = [('y', True, 'Yes, execute the %s' % text),
167
             ('n', False, 'No, abort the %s' % text)]
168

    
169
  if count > 20:
170
    choices.insert(1, ('v', 'v', 'View the list of affected instances'))
171
    ask = msg
172
  else:
173
    ask = msg + affected
174

    
175
  choice = AskUser(ask, choices)
176
  if choice == 'v':
177
    choices.pop(1)
178
    choice = AskUser(msg + affected, choices)
179
  return choice
180

    
181

    
182
def _EnsureInstancesExist(client, names):
183
  """Check for and ensure the given instance names exist.
184

    
185
  This function will raise an OpPrereqError in case they don't
186
  exist. Otherwise it will exit cleanly.
187

    
188
  @type client: L{ganeti.luxi.Client}
189
  @param client: the client to use for the query
190
  @type names: list
191
  @param names: the list of instance names to query
192
  @raise errors.OpPrereqError: in case any instance is missing
193

    
194
  """
195
  # TODO: change LUQueryInstances to that it actually returns None
196
  # instead of raising an exception, or devise a better mechanism
197
  result = client.QueryInstances(names, ["name"], False)
198
  for orig_name, row in zip(names, result):
199
    if row[0] is None:
200
      raise errors.OpPrereqError("Instance '%s' does not exist" % orig_name,
201
                                 errors.ECODE_NOENT)
202

    
203

    
204
def GenericManyOps(operation, fn):
205
  """Generic multi-instance operations.
206

    
207
  The will return a wrapper that processes the options and arguments
208
  given, and uses the passed function to build the opcode needed for
209
  the specific operation. Thus all the generic loop/confirmation code
210
  is abstracted into this function.
211

    
212
  """
213
  def realfn(opts, args):
214
    if opts.multi_mode is None:
215
      opts.multi_mode = _SHUTDOWN_INSTANCES
216
    cl = GetClient()
217
    inames = _ExpandMultiNames(opts.multi_mode, args, client=cl)
218
    if not inames:
219
      raise errors.OpPrereqError("Selection filter does not match"
220
                                 " any instances", errors.ECODE_INVAL)
221
    multi_on = opts.multi_mode != _SHUTDOWN_INSTANCES or len(inames) > 1
222
    if not (opts.force_multi or not multi_on
223
            or _ConfirmOperation(inames, operation)):
224
      return 1
225
    jex = JobExecutor(verbose=multi_on, cl=cl, opts=opts)
226
    for name in inames:
227
      op = fn(name, opts)
228
      jex.QueueJob(name, op)
229
    jex.WaitOrShow(not opts.submit_only)
230
    return 0
231
  return realfn
232

    
233

    
234
def ListInstances(opts, args):
235
  """List instances and their properties.
236

    
237
  @param opts: the command line options selected by the user
238
  @type args: list
239
  @param args: should be an empty list
240
  @rtype: int
241
  @return: the desired exit code
242

    
243
  """
244
  if opts.output is None:
245
    selected_fields = _LIST_DEF_FIELDS
246
  elif opts.output.startswith("+"):
247
    selected_fields = _LIST_DEF_FIELDS + opts.output[1:].split(",")
248
  else:
249
    selected_fields = opts.output.split(",")
250

    
251
  output = GetClient().QueryInstances(args, selected_fields, opts.do_locking)
252

    
253
  if not opts.no_headers:
254
    headers = {
255
      "name": "Instance", "os": "OS", "pnode": "Primary_node",
256
      "snodes": "Secondary_Nodes", "admin_state": "Autostart",
257
      "oper_state": "Running",
258
      "oper_ram": "Memory", "disk_template": "Disk_template",
259
      "ip": "IP_address", "mac": "MAC_address",
260
      "nic_mode": "NIC_Mode", "nic_link": "NIC_Link",
261
      "bridge": "Bridge",
262
      "sda_size": "Disk/0", "sdb_size": "Disk/1",
263
      "disk_usage": "DiskUsage",
264
      "status": "Status", "tags": "Tags",
265
      "network_port": "Network_port",
266
      "hv/kernel_path": "Kernel_path",
267
      "hv/initrd_path": "Initrd_path",
268
      "hv/boot_order": "Boot_order",
269
      "hv/acpi": "ACPI",
270
      "hv/pae": "PAE",
271
      "hv/cdrom_image_path": "CDROM_image_path",
272
      "hv/nic_type": "NIC_type",
273
      "hv/disk_type": "Disk_type",
274
      "hv/vnc_bind_address": "VNC_bind_address",
275
      "serial_no": "SerialNo", "hypervisor": "Hypervisor",
276
      "hvparams": "Hypervisor_parameters",
277
      "be/memory": "Configured_memory",
278
      "be/vcpus": "VCPUs",
279
      "vcpus": "VCPUs",
280
      "be/auto_balance": "Auto_balance",
281
      "disk.count": "Disks", "disk.sizes": "Disk_sizes",
282
      "nic.count": "NICs", "nic.ips": "NIC_IPs",
283
      "nic.modes": "NIC_modes", "nic.links": "NIC_links",
284
      "nic.bridges": "NIC_bridges", "nic.macs": "NIC_MACs",
285
      "ctime": "CTime", "mtime": "MTime", "uuid": "UUID",
286
      }
287
  else:
288
    headers = None
289

    
290
  unitfields = ["be/memory", "oper_ram", "sd(a|b)_size", "disk\.size/.*"]
291
  numfields = ["be/memory", "oper_ram", "sd(a|b)_size", "be/vcpus",
292
               "serial_no", "(disk|nic)\.count", "disk\.size/.*"]
293

    
294
  list_type_fields = ("tags", "disk.sizes", "nic.macs", "nic.ips",
295
                      "nic.modes", "nic.links", "nic.bridges")
296
  # change raw values to nicer strings
297
  for row in output:
298
    for idx, field in enumerate(selected_fields):
299
      val = row[idx]
300
      if field == "snodes":
301
        val = ",".join(val) or "-"
302
      elif field == "admin_state":
303
        if val:
304
          val = "yes"
305
        else:
306
          val = "no"
307
      elif field == "oper_state":
308
        if val is None:
309
          val = "(node down)"
310
        elif val: # True
311
          val = "running"
312
        else:
313
          val = "stopped"
314
      elif field == "oper_ram":
315
        if val is None:
316
          val = "(node down)"
317
      elif field == "sda_size" or field == "sdb_size":
318
        if val is None:
319
          val = "N/A"
320
      elif field == "ctime" or field == "mtime":
321
        val = utils.FormatTime(val)
322
      elif field in list_type_fields:
323
        val = ",".join(str(item) for item in val)
324
      elif val is None:
325
        val = "-"
326
      row[idx] = str(val)
327

    
328
  data = GenerateTable(separator=opts.separator, headers=headers,
329
                       fields=selected_fields, unitfields=unitfields,
330
                       numfields=numfields, data=output, units=opts.units)
331

    
332
  for line in data:
333
    ToStdout(line)
334

    
335
  return 0
336

    
337

    
338
def AddInstance(opts, args):
339
  """Add an instance to the cluster.
340

    
341
  This is just a wrapper over GenericInstanceCreate.
342

    
343
  """
344
  return GenericInstanceCreate(constants.INSTANCE_CREATE, opts, args)
345

    
346

    
347
def BatchCreate(opts, args):
348
  """Create instances using a definition file.
349

    
350
  This function reads a json file with instances defined
351
  in the form::
352

    
353
    {"instance-name":{
354
      "disk_size": [20480],
355
      "template": "drbd",
356
      "backend": {
357
        "memory": 512,
358
        "vcpus": 1 },
359
      "os": "debootstrap",
360
      "primary_node": "firstnode",
361
      "secondary_node": "secondnode",
362
      "iallocator": "dumb"}
363
    }
364

    
365
  Note that I{primary_node} and I{secondary_node} have precedence over
366
  I{iallocator}.
367

    
368
  @param opts: the command line options selected by the user
369
  @type args: list
370
  @param args: should contain one element, the json filename
371
  @rtype: int
372
  @return: the desired exit code
373

    
374
  """
375
  _DEFAULT_SPECS = {"disk_size": [20 * 1024],
376
                    "backend": {},
377
                    "iallocator": None,
378
                    "primary_node": None,
379
                    "secondary_node": None,
380
                    "nics": None,
381
                    "start": True,
382
                    "ip_check": True,
383
                    "name_check": True,
384
                    "hypervisor": None,
385
                    "hvparams": {},
386
                    "file_storage_dir": None,
387
                    "file_driver": 'loop'}
388

    
389
  def _PopulateWithDefaults(spec):
390
    """Returns a new hash combined with default values."""
391
    mydict = _DEFAULT_SPECS.copy()
392
    mydict.update(spec)
393
    return mydict
394

    
395
  def _Validate(spec):
396
    """Validate the instance specs."""
397
    # Validate fields required under any circumstances
398
    for required_field in ('os', 'template'):
399
      if required_field not in spec:
400
        raise errors.OpPrereqError('Required field "%s" is missing.' %
401
                                   required_field, errors.ECODE_INVAL)
402
    # Validate special fields
403
    if spec['primary_node'] is not None:
404
      if (spec['template'] in constants.DTS_NET_MIRROR and
405
          spec['secondary_node'] is None):
406
        raise errors.OpPrereqError('Template requires secondary node, but'
407
                                   ' there was no secondary provided.',
408
                                   errors.ECODE_INVAL)
409
    elif spec['iallocator'] is None:
410
      raise errors.OpPrereqError('You have to provide at least a primary_node'
411
                                 ' or an iallocator.',
412
                                 errors.ECODE_INVAL)
413

    
414
    if (spec['hvparams'] and
415
        not isinstance(spec['hvparams'], dict)):
416
      raise errors.OpPrereqError('Hypervisor parameters must be a dict.',
417
                                 errors.ECODE_INVAL)
418

    
419
  json_filename = args[0]
420
  try:
421
    instance_data = simplejson.loads(utils.ReadFile(json_filename))
422
  except Exception, err: # pylint: disable-msg=W0703
423
    ToStderr("Can't parse the instance definition file: %s" % str(err))
424
    return 1
425

    
426
  jex = JobExecutor(opts=opts)
427

    
428
  # Iterate over the instances and do:
429
  #  * Populate the specs with default value
430
  #  * Validate the instance specs
431
  i_names = utils.NiceSort(instance_data.keys())
432
  for name in i_names:
433
    specs = instance_data[name]
434
    specs = _PopulateWithDefaults(specs)
435
    _Validate(specs)
436

    
437
    hypervisor = specs['hypervisor']
438
    hvparams = specs['hvparams']
439

    
440
    disks = []
441
    for elem in specs['disk_size']:
442
      try:
443
        size = utils.ParseUnit(elem)
444
      except (TypeError, ValueError), err:
445
        raise errors.OpPrereqError("Invalid disk size '%s' for"
446
                                   " instance %s: %s" %
447
                                   (elem, name, err), errors.ECODE_INVAL)
448
      disks.append({"size": size})
449

    
450
    utils.ForceDictType(specs['backend'], constants.BES_PARAMETER_TYPES)
451
    utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES)
452

    
453
    tmp_nics = []
454
    for field in ('ip', 'mac', 'mode', 'link', 'bridge'):
455
      if field in specs:
456
        if not tmp_nics:
457
          tmp_nics.append({})
458
        tmp_nics[0][field] = specs[field]
459

    
460
    if specs['nics'] is not None and tmp_nics:
461
      raise errors.OpPrereqError("'nics' list incompatible with using"
462
                                 " individual nic fields as well",
463
                                 errors.ECODE_INVAL)
464
    elif specs['nics'] is not None:
465
      tmp_nics = specs['nics']
466
    elif not tmp_nics:
467
      tmp_nics = [{}]
468

    
469
    op = opcodes.OpCreateInstance(instance_name=name,
470
                                  disks=disks,
471
                                  disk_template=specs['template'],
472
                                  mode=constants.INSTANCE_CREATE,
473
                                  os_type=specs['os'],
474
                                  force_variant=opts.force_variant,
475
                                  pnode=specs['primary_node'],
476
                                  snode=specs['secondary_node'],
477
                                  nics=tmp_nics,
478
                                  start=specs['start'],
479
                                  ip_check=specs['ip_check'],
480
                                  name_check=specs['name_check'],
481
                                  wait_for_sync=True,
482
                                  iallocator=specs['iallocator'],
483
                                  hypervisor=hypervisor,
484
                                  hvparams=hvparams,
485
                                  beparams=specs['backend'],
486
                                  file_storage_dir=specs['file_storage_dir'],
487
                                  file_driver=specs['file_driver'])
488

    
489
    jex.QueueJob(name, op)
490
  # we never want to wait, just show the submitted job IDs
491
  jex.WaitOrShow(False)
492

    
493
  return 0
494

    
495

    
496
def ReinstallInstance(opts, args):
497
  """Reinstall an instance.
498

    
499
  @param opts: the command line options selected by the user
500
  @type args: list
501
  @param args: should contain only one element, the name of the
502
      instance to be reinstalled
503
  @rtype: int
504
  @return: the desired exit code
505

    
506
  """
507
  # first, compute the desired name list
508
  if opts.multi_mode is None:
509
    opts.multi_mode = _SHUTDOWN_INSTANCES
510

    
511
  inames = _ExpandMultiNames(opts.multi_mode, args)
512
  if not inames:
513
    raise errors.OpPrereqError("Selection filter does not match any instances",
514
                               errors.ECODE_INVAL)
515

    
516
  # second, if requested, ask for an OS
517
  if opts.select_os is True:
518
    op = opcodes.OpDiagnoseOS(output_fields=["name", "valid", "variants"],
519
                              names=[])
520
    result = SubmitOpCode(op, opts=opts)
521

    
522
    if not result:
523
      ToStdout("Can't get the OS list")
524
      return 1
525

    
526
    ToStdout("Available OS templates:")
527
    number = 0
528
    choices = []
529
    for (name, valid, variants) in result:
530
      if valid:
531
        for entry in CalculateOSNames(name, variants):
532
          ToStdout("%3s: %s", number, entry)
533
          choices.append(("%s" % number, entry, entry))
534
          number += 1
535

    
536
    choices.append(('x', 'exit', 'Exit gnt-instance reinstall'))
537
    selected = AskUser("Enter OS template number (or x to abort):",
538
                       choices)
539

    
540
    if selected == 'exit':
541
      ToStderr("User aborted reinstall, exiting")
542
      return 1
543

    
544
    os_name = selected
545
  else:
546
    os_name = opts.os
547

    
548
  # third, get confirmation: multi-reinstall requires --force-multi
549
  # *and* --force, single-reinstall just --force
550
  multi_on = opts.multi_mode != _SHUTDOWN_INSTANCES or len(inames) > 1
551
  if multi_on:
552
    warn_msg = "Note: this will remove *all* data for the below instances!\n"
553
    if not ((opts.force_multi and opts.force) or
554
            _ConfirmOperation(inames, "reinstall", extra=warn_msg)):
555
      return 1
556
  else:
557
    if not opts.force:
558
      usertext = ("This will reinstall the instance %s and remove"
559
                  " all data. Continue?") % inames[0]
560
      if not AskUser(usertext):
561
        return 1
562

    
563
  jex = JobExecutor(verbose=multi_on, opts=opts)
564
  for instance_name in inames:
565
    op = opcodes.OpReinstallInstance(instance_name=instance_name,
566
                                     os_type=os_name,
567
                                     force_variant=opts.force_variant)
568
    jex.QueueJob(instance_name, op)
569

    
570
  jex.WaitOrShow(not opts.submit_only)
571
  return 0
572

    
573

    
574
def RemoveInstance(opts, args):
575
  """Remove an instance.
576

    
577
  @param opts: the command line options selected by the user
578
  @type args: list
579
  @param args: should contain only one element, the name of
580
      the instance to be removed
581
  @rtype: int
582
  @return: the desired exit code
583

    
584
  """
585
  instance_name = args[0]
586
  force = opts.force
587
  cl = GetClient()
588

    
589
  if not force:
590
    _EnsureInstancesExist(cl, [instance_name])
591

    
592
    usertext = ("This will remove the volumes of the instance %s"
593
                " (including mirrors), thus removing all the data"
594
                " of the instance. Continue?") % instance_name
595
    if not AskUser(usertext):
596
      return 1
597

    
598
  op = opcodes.OpRemoveInstance(instance_name=instance_name,
599
                                ignore_failures=opts.ignore_failures,
600
                                shutdown_timeout=opts.shutdown_timeout)
601
  SubmitOrSend(op, opts, cl=cl)
602
  return 0
603

    
604

    
605
def RenameInstance(opts, args):
606
  """Rename an instance.
607

    
608
  @param opts: the command line options selected by the user
609
  @type args: list
610
  @param args: should contain two elements, the old and the
611
      new instance names
612
  @rtype: int
613
  @return: the desired exit code
614

    
615
  """
616
  op = opcodes.OpRenameInstance(instance_name=args[0],
617
                                new_name=args[1],
618
                                ignore_ip=opts.ignore_ip)
619
  SubmitOrSend(op, opts)
620
  return 0
621

    
622

    
623
def ActivateDisks(opts, args):
624
  """Activate an instance's disks.
625

    
626
  This serves two purposes:
627
    - it allows (as long as the instance is not running)
628
      mounting the disks and modifying them from the node
629
    - it repairs inactive secondary drbds
630

    
631
  @param opts: the command line options selected by the user
632
  @type args: list
633
  @param args: should contain only one element, the instance name
634
  @rtype: int
635
  @return: the desired exit code
636

    
637
  """
638
  instance_name = args[0]
639
  op = opcodes.OpActivateInstanceDisks(instance_name=instance_name,
640
                                       ignore_size=opts.ignore_size)
641
  disks_info = SubmitOrSend(op, opts)
642
  for host, iname, nname in disks_info:
643
    ToStdout("%s:%s:%s", host, iname, nname)
644
  return 0
645

    
646

    
647
def DeactivateDisks(opts, args):
648
  """Deactivate an instance's disks.
649

    
650
  This function takes the instance name, looks for its primary node
651
  and the tries to shutdown its block devices on that node.
652

    
653
  @param opts: the command line options selected by the user
654
  @type args: list
655
  @param args: should contain only one element, the instance name
656
  @rtype: int
657
  @return: the desired exit code
658

    
659
  """
660
  instance_name = args[0]
661
  op = opcodes.OpDeactivateInstanceDisks(instance_name=instance_name)
662
  SubmitOrSend(op, opts)
663
  return 0
664

    
665

    
666
def RecreateDisks(opts, args):
667
  """Recreate an instance's disks.
668

    
669
  @param opts: the command line options selected by the user
670
  @type args: list
671
  @param args: should contain only one element, the instance name
672
  @rtype: int
673
  @return: the desired exit code
674

    
675
  """
676
  instance_name = args[0]
677
  if opts.disks:
678
    try:
679
      opts.disks = [int(v) for v in opts.disks.split(",")]
680
    except (ValueError, TypeError), err:
681
      ToStderr("Invalid disks value: %s" % str(err))
682
      return 1
683
  else:
684
    opts.disks = []
685

    
686
  op = opcodes.OpRecreateInstanceDisks(instance_name=instance_name,
687
                                       disks=opts.disks)
688
  SubmitOrSend(op, opts)
689
  return 0
690

    
691

    
692
def GrowDisk(opts, args):
693
  """Grow an instance's disks.
694

    
695
  @param opts: the command line options selected by the user
696
  @type args: list
697
  @param args: should contain two elements, the instance name
698
      whose disks we grow and the disk name, e.g. I{sda}
699
  @rtype: int
700
  @return: the desired exit code
701

    
702
  """
703
  instance = args[0]
704
  disk = args[1]
705
  try:
706
    disk = int(disk)
707
  except (TypeError, ValueError), err:
708
    raise errors.OpPrereqError("Invalid disk index: %s" % str(err),
709
                               errors.ECODE_INVAL)
710
  amount = utils.ParseUnit(args[2])
711
  op = opcodes.OpGrowDisk(instance_name=instance, disk=disk, amount=amount,
712
                          wait_for_sync=opts.wait_for_sync)
713
  SubmitOrSend(op, opts)
714
  return 0
715

    
716

    
717
def _StartupInstance(name, opts):
718
  """Startup instances.
719

    
720
  This returns the opcode to start an instance, and its decorator will
721
  wrap this into a loop starting all desired instances.
722

    
723
  @param name: the name of the instance to act on
724
  @param opts: the command line options selected by the user
725
  @return: the opcode needed for the operation
726

    
727
  """
728
  op = opcodes.OpStartupInstance(instance_name=name,
729
                                 force=opts.force)
730
  # do not add these parameters to the opcode unless they're defined
731
  if opts.hvparams:
732
    op.hvparams = opts.hvparams
733
  if opts.beparams:
734
    op.beparams = opts.beparams
735
  return op
736

    
737

    
738
def _RebootInstance(name, opts):
739
  """Reboot instance(s).
740

    
741
  This returns the opcode to reboot an instance, and its decorator
742
  will wrap this into a loop rebooting all desired instances.
743

    
744
  @param name: the name of the instance to act on
745
  @param opts: the command line options selected by the user
746
  @return: the opcode needed for the operation
747

    
748
  """
749
  return opcodes.OpRebootInstance(instance_name=name,
750
                                  reboot_type=opts.reboot_type,
751
                                  ignore_secondaries=opts.ignore_secondaries,
752
                                  shutdown_timeout=opts.shutdown_timeout)
753

    
754

    
755
def _ShutdownInstance(name, opts):
756
  """Shutdown an instance.
757

    
758
  This returns the opcode to shutdown an instance, and its decorator
759
  will wrap this into a loop shutting down all desired instances.
760

    
761
  @param name: the name of the instance to act on
762
  @param opts: the command line options selected by the user
763
  @return: the opcode needed for the operation
764

    
765
  """
766
  return opcodes.OpShutdownInstance(instance_name=name,
767
                                    timeout=opts.timeout)
768

    
769

    
770
def ReplaceDisks(opts, args):
771
  """Replace the disks of an instance
772

    
773
  @param opts: the command line options selected by the user
774
  @type args: list
775
  @param args: should contain only one element, the instance name
776
  @rtype: int
777
  @return: the desired exit code
778

    
779
  """
780
  new_2ndary = opts.dst_node
781
  iallocator = opts.iallocator
782
  if opts.disks is None:
783
    disks = []
784
  else:
785
    try:
786
      disks = [int(i) for i in opts.disks.split(",")]
787
    except (TypeError, ValueError), err:
788
      raise errors.OpPrereqError("Invalid disk index passed: %s" % str(err),
789
                                 errors.ECODE_INVAL)
790
  cnt = [opts.on_primary, opts.on_secondary, opts.auto,
791
         new_2ndary is not None, iallocator is not None].count(True)
792
  if cnt != 1:
793
    raise errors.OpPrereqError("One and only one of the -p, -s, -a, -n and -i"
794
                               " options must be passed", errors.ECODE_INVAL)
795
  elif opts.on_primary:
796
    mode = constants.REPLACE_DISK_PRI
797
  elif opts.on_secondary:
798
    mode = constants.REPLACE_DISK_SEC
799
  elif opts.auto:
800
    mode = constants.REPLACE_DISK_AUTO
801
    if disks:
802
      raise errors.OpPrereqError("Cannot specify disks when using automatic"
803
                                 " mode", errors.ECODE_INVAL)
804
  elif new_2ndary is not None or iallocator is not None:
805
    # replace secondary
806
    mode = constants.REPLACE_DISK_CHG
807

    
808
  op = opcodes.OpReplaceDisks(instance_name=args[0], disks=disks,
809
                              remote_node=new_2ndary, mode=mode,
810
                              iallocator=iallocator,
811
                              early_release=opts.early_release)
812
  SubmitOrSend(op, opts)
813
  return 0
814

    
815

    
816
def FailoverInstance(opts, args):
817
  """Failover an instance.
818

    
819
  The failover is done by shutting it down on its present node and
820
  starting it on the secondary.
821

    
822
  @param opts: the command line options selected by the user
823
  @type args: list
824
  @param args: should contain only one element, the instance name
825
  @rtype: int
826
  @return: the desired exit code
827

    
828
  """
829
  cl = GetClient()
830
  instance_name = args[0]
831
  force = opts.force
832

    
833
  if not force:
834
    _EnsureInstancesExist(cl, [instance_name])
835

    
836
    usertext = ("Failover will happen to image %s."
837
                " This requires a shutdown of the instance. Continue?" %
838
                (instance_name,))
839
    if not AskUser(usertext):
840
      return 1
841

    
842
  op = opcodes.OpFailoverInstance(instance_name=instance_name,
843
                                  ignore_consistency=opts.ignore_consistency,
844
                                  shutdown_timeout=opts.shutdown_timeout)
845
  SubmitOrSend(op, opts, cl=cl)
846
  return 0
847

    
848

    
849
def MigrateInstance(opts, args):
850
  """Migrate an instance.
851

    
852
  The migrate is done without shutdown.
853

    
854
  @param opts: the command line options selected by the user
855
  @type args: list
856
  @param args: should contain only one element, the instance name
857
  @rtype: int
858
  @return: the desired exit code
859

    
860
  """
861
  cl = GetClient()
862
  instance_name = args[0]
863
  force = opts.force
864

    
865
  if not force:
866
    _EnsureInstancesExist(cl, [instance_name])
867

    
868
    if opts.cleanup:
869
      usertext = ("Instance %s will be recovered from a failed migration."
870
                  " Note that the migration procedure (including cleanup)" %
871
                  (instance_name,))
872
    else:
873
      usertext = ("Instance %s will be migrated. Note that migration" %
874
                  (instance_name,))
875
    usertext += (" is **experimental** in this version."
876
                " This might impact the instance if anything goes wrong."
877
                " Continue?")
878
    if not AskUser(usertext):
879
      return 1
880

    
881
  op = opcodes.OpMigrateInstance(instance_name=instance_name, live=opts.live,
882
                                 cleanup=opts.cleanup)
883
  SubmitOpCode(op, cl=cl, opts=opts)
884
  return 0
885

    
886

    
887
def MoveInstance(opts, args):
888
  """Move an instance.
889

    
890
  @param opts: the command line options selected by the user
891
  @type args: list
892
  @param args: should contain only one element, the instance name
893
  @rtype: int
894
  @return: the desired exit code
895

    
896
  """
897
  cl = GetClient()
898
  instance_name = args[0]
899
  force = opts.force
900

    
901
  if not force:
902
    usertext = ("Instance %s will be moved."
903
                " This requires a shutdown of the instance. Continue?" %
904
                (instance_name,))
905
    if not AskUser(usertext):
906
      return 1
907

    
908
  op = opcodes.OpMoveInstance(instance_name=instance_name,
909
                              target_node=opts.node,
910
                              shutdown_timeout=opts.shutdown_timeout)
911
  SubmitOrSend(op, opts, cl=cl)
912
  return 0
913

    
914

    
915
def ConnectToInstanceConsole(opts, args):
916
  """Connect to the console of an instance.
917

    
918
  @param opts: the command line options selected by the user
919
  @type args: list
920
  @param args: should contain only one element, the instance name
921
  @rtype: int
922
  @return: the desired exit code
923

    
924
  """
925
  instance_name = args[0]
926

    
927
  op = opcodes.OpConnectConsole(instance_name=instance_name)
928
  cmd = SubmitOpCode(op, opts=opts)
929

    
930
  if opts.show_command:
931
    ToStdout("%s", utils.ShellQuoteArgs(cmd))
932
  else:
933
    try:
934
      os.execvp(cmd[0], cmd)
935
    finally:
936
      ToStderr("Can't run console command %s with arguments:\n'%s'",
937
               cmd[0], " ".join(cmd))
938
      os._exit(1) # pylint: disable-msg=W0212
939

    
940

    
941
def _FormatLogicalID(dev_type, logical_id):
942
  """Formats the logical_id of a disk.
943

    
944
  """
945
  if dev_type == constants.LD_DRBD8:
946
    node_a, node_b, port, minor_a, minor_b, key = logical_id
947
    data = [
948
      ("nodeA", "%s, minor=%s" % (node_a, minor_a)),
949
      ("nodeB", "%s, minor=%s" % (node_b, minor_b)),
950
      ("port", port),
951
      ("auth key", key),
952
      ]
953
  elif dev_type == constants.LD_LV:
954
    vg_name, lv_name = logical_id
955
    data = ["%s/%s" % (vg_name, lv_name)]
956
  else:
957
    data = [str(logical_id)]
958

    
959
  return data
960

    
961

    
962
def _FormatBlockDevInfo(idx, top_level, dev, static):
963
  """Show block device information.
964

    
965
  This is only used by L{ShowInstanceConfig}, but it's too big to be
966
  left for an inline definition.
967

    
968
  @type idx: int
969
  @param idx: the index of the current disk
970
  @type top_level: boolean
971
  @param top_level: if this a top-level disk?
972
  @type dev: dict
973
  @param dev: dictionary with disk information
974
  @type static: boolean
975
  @param static: wheter the device information doesn't contain
976
      runtime information but only static data
977
  @return: a list of either strings, tuples or lists
978
      (which should be formatted at a higher indent level)
979

    
980
  """
981
  def helper(dtype, status):
982
    """Format one line for physical device status.
983

    
984
    @type dtype: str
985
    @param dtype: a constant from the L{constants.LDS_BLOCK} set
986
    @type status: tuple
987
    @param status: a tuple as returned from L{backend.FindBlockDevice}
988
    @return: the string representing the status
989

    
990
    """
991
    if not status:
992
      return "not active"
993
    txt = ""
994
    (path, major, minor, syncp, estt, degr, ldisk_status) = status
995
    if major is None:
996
      major_string = "N/A"
997
    else:
998
      major_string = str(major)
999

    
1000
    if minor is None:
1001
      minor_string = "N/A"
1002
    else:
1003
      minor_string = str(minor)
1004

    
1005
    txt += ("%s (%s:%s)" % (path, major_string, minor_string))
1006
    if dtype in (constants.LD_DRBD8, ):
1007
      if syncp is not None:
1008
        sync_text = "*RECOVERING* %5.2f%%," % syncp
1009
        if estt:
1010
          sync_text += " ETA %ds" % estt
1011
        else:
1012
          sync_text += " ETA unknown"
1013
      else:
1014
        sync_text = "in sync"
1015
      if degr:
1016
        degr_text = "*DEGRADED*"
1017
      else:
1018
        degr_text = "ok"
1019
      if ldisk_status == constants.LDS_FAULTY:
1020
        ldisk_text = " *MISSING DISK*"
1021
      elif ldisk_status == constants.LDS_UNKNOWN:
1022
        ldisk_text = " *UNCERTAIN STATE*"
1023
      else:
1024
        ldisk_text = ""
1025
      txt += (" %s, status %s%s" % (sync_text, degr_text, ldisk_text))
1026
    elif dtype == constants.LD_LV:
1027
      if ldisk_status == constants.LDS_FAULTY:
1028
        ldisk_text = " *FAILED* (failed drive?)"
1029
      else:
1030
        ldisk_text = ""
1031
      txt += ldisk_text
1032
    return txt
1033

    
1034
  # the header
1035
  if top_level:
1036
    if dev["iv_name"] is not None:
1037
      txt = dev["iv_name"]
1038
    else:
1039
      txt = "disk %d" % idx
1040
  else:
1041
    txt = "child %d" % idx
1042
  if isinstance(dev["size"], int):
1043
    nice_size = utils.FormatUnit(dev["size"], "h")
1044
  else:
1045
    nice_size = dev["size"]
1046
  d1 = ["- %s: %s, size %s" % (txt, dev["dev_type"], nice_size)]
1047
  data = []
1048
  if top_level:
1049
    data.append(("access mode", dev["mode"]))
1050
  if dev["logical_id"] is not None:
1051
    try:
1052
      l_id = _FormatLogicalID(dev["dev_type"], dev["logical_id"])
1053
    except ValueError:
1054
      l_id = [str(dev["logical_id"])]
1055
    if len(l_id) == 1:
1056
      data.append(("logical_id", l_id[0]))
1057
    else:
1058
      data.extend(l_id)
1059
  elif dev["physical_id"] is not None:
1060
    data.append("physical_id:")
1061
    data.append([dev["physical_id"]])
1062
  if not static:
1063
    data.append(("on primary", helper(dev["dev_type"], dev["pstatus"])))
1064
  if dev["sstatus"] and not static:
1065
    data.append(("on secondary", helper(dev["dev_type"], dev["sstatus"])))
1066

    
1067
  if dev["children"]:
1068
    data.append("child devices:")
1069
    for c_idx, child in enumerate(dev["children"]):
1070
      data.append(_FormatBlockDevInfo(c_idx, False, child, static))
1071
  d1.append(data)
1072
  return d1
1073

    
1074

    
1075
def _FormatList(buf, data, indent_level):
1076
  """Formats a list of data at a given indent level.
1077

    
1078
  If the element of the list is:
1079
    - a string, it is simply formatted as is
1080
    - a tuple, it will be split into key, value and the all the
1081
      values in a list will be aligned all at the same start column
1082
    - a list, will be recursively formatted
1083

    
1084
  @type buf: StringIO
1085
  @param buf: the buffer into which we write the output
1086
  @param data: the list to format
1087
  @type indent_level: int
1088
  @param indent_level: the indent level to format at
1089

    
1090
  """
1091
  max_tlen = max([len(elem[0]) for elem in data
1092
                 if isinstance(elem, tuple)] or [0])
1093
  for elem in data:
1094
    if isinstance(elem, basestring):
1095
      buf.write("%*s%s\n" % (2*indent_level, "", elem))
1096
    elif isinstance(elem, tuple):
1097
      key, value = elem
1098
      spacer = "%*s" % (max_tlen - len(key), "")
1099
      buf.write("%*s%s:%s %s\n" % (2*indent_level, "", key, spacer, value))
1100
    elif isinstance(elem, list):
1101
      _FormatList(buf, elem, indent_level+1)
1102

    
1103

    
1104
def ShowInstanceConfig(opts, args):
1105
  """Compute instance run-time status.
1106

    
1107
  @param opts: the command line options selected by the user
1108
  @type args: list
1109
  @param args: either an empty list, and then we query all
1110
      instances, or should contain a list of instance names
1111
  @rtype: int
1112
  @return: the desired exit code
1113

    
1114
  """
1115
  if not args and not opts.show_all:
1116
    ToStderr("No instance selected."
1117
             " Please pass in --all if you want to query all instances.\n"
1118
             "Note that this can take a long time on a big cluster.")
1119
    return 1
1120
  elif args and opts.show_all:
1121
    ToStderr("Cannot use --all if you specify instance names.")
1122
    return 1
1123

    
1124
  retcode = 0
1125
  op = opcodes.OpQueryInstanceData(instances=args, static=opts.static)
1126
  result = SubmitOpCode(op, opts=opts)
1127
  if not result:
1128
    ToStdout("No instances.")
1129
    return 1
1130

    
1131
  buf = StringIO()
1132
  retcode = 0
1133
  for instance_name in result:
1134
    instance = result[instance_name]
1135
    buf.write("Instance name: %s\n" % instance["name"])
1136
    buf.write("UUID: %s\n" % instance["uuid"])
1137
    buf.write("Serial number: %s\n" % instance["serial_no"])
1138
    buf.write("Creation time: %s\n" % utils.FormatTime(instance["ctime"]))
1139
    buf.write("Modification time: %s\n" % utils.FormatTime(instance["mtime"]))
1140
    buf.write("State: configured to be %s" % instance["config_state"])
1141
    if not opts.static:
1142
      buf.write(", actual state is %s" % instance["run_state"])
1143
    buf.write("\n")
1144
    ##buf.write("Considered for memory checks in cluster verify: %s\n" %
1145
    ##          instance["auto_balance"])
1146
    buf.write("  Nodes:\n")
1147
    buf.write("    - primary: %s\n" % instance["pnode"])
1148
    buf.write("    - secondaries: %s\n" % utils.CommaJoin(instance["snodes"]))
1149
    buf.write("  Operating system: %s\n" % instance["os"])
1150
    if instance.has_key("network_port"):
1151
      buf.write("  Allocated network port: %s\n" % instance["network_port"])
1152
    buf.write("  Hypervisor: %s\n" % instance["hypervisor"])
1153

    
1154
    # custom VNC console information
1155
    vnc_bind_address = instance["hv_actual"].get(constants.HV_VNC_BIND_ADDRESS,
1156
                                                 None)
1157
    if vnc_bind_address:
1158
      port = instance["network_port"]
1159
      display = int(port) - constants.VNC_BASE_PORT
1160
      if display > 0 and vnc_bind_address == constants.BIND_ADDRESS_GLOBAL:
1161
        vnc_console_port = "%s:%s (display %s)" % (instance["pnode"],
1162
                                                   port,
1163
                                                   display)
1164
      elif display > 0 and utils.IsValidIP(vnc_bind_address):
1165
        vnc_console_port = ("%s:%s (node %s) (display %s)" %
1166
                             (vnc_bind_address, port,
1167
                              instance["pnode"], display))
1168
      else:
1169
        # vnc bind address is a file
1170
        vnc_console_port = "%s:%s" % (instance["pnode"],
1171
                                      vnc_bind_address)
1172
      buf.write("    - console connection: vnc to %s\n" % vnc_console_port)
1173

    
1174
    for key in instance["hv_actual"]:
1175
      if key in instance["hv_instance"]:
1176
        val = instance["hv_instance"][key]
1177
      else:
1178
        val = "default (%s)" % instance["hv_actual"][key]
1179
      buf.write("    - %s: %s\n" % (key, val))
1180
    buf.write("  Hardware:\n")
1181
    buf.write("    - VCPUs: %d\n" %
1182
              instance["be_actual"][constants.BE_VCPUS])
1183
    buf.write("    - memory: %dMiB\n" %
1184
              instance["be_actual"][constants.BE_MEMORY])
1185
    buf.write("    - NICs:\n")
1186
    for idx, (ip, mac, mode, link) in enumerate(instance["nics"]):
1187
      buf.write("      - nic/%d: MAC: %s, IP: %s, mode: %s, link: %s\n" %
1188
                (idx, mac, ip, mode, link))
1189
    buf.write("  Disks:\n")
1190

    
1191
    for idx, device in enumerate(instance["disks"]):
1192
      _FormatList(buf, _FormatBlockDevInfo(idx, True, device, opts.static), 2)
1193

    
1194
  ToStdout(buf.getvalue().rstrip('\n'))
1195
  return retcode
1196

    
1197

    
1198
def SetInstanceParams(opts, args):
1199
  """Modifies an instance.
1200

    
1201
  All parameters take effect only at the next restart of the instance.
1202

    
1203
  @param opts: the command line options selected by the user
1204
  @type args: list
1205
  @param args: should contain only one element, the instance name
1206
  @rtype: int
1207
  @return: the desired exit code
1208

    
1209
  """
1210
  if not (opts.nics or opts.disks or
1211
          opts.hvparams or opts.beparams):
1212
    ToStderr("Please give at least one of the parameters.")
1213
    return 1
1214

    
1215
  for param in opts.beparams:
1216
    if isinstance(opts.beparams[param], basestring):
1217
      if opts.beparams[param].lower() == "default":
1218
        opts.beparams[param] = constants.VALUE_DEFAULT
1219

    
1220
  utils.ForceDictType(opts.beparams, constants.BES_PARAMETER_TYPES,
1221
                      allowed_values=[constants.VALUE_DEFAULT])
1222

    
1223
  for param in opts.hvparams:
1224
    if isinstance(opts.hvparams[param], basestring):
1225
      if opts.hvparams[param].lower() == "default":
1226
        opts.hvparams[param] = constants.VALUE_DEFAULT
1227

    
1228
  utils.ForceDictType(opts.hvparams, constants.HVS_PARAMETER_TYPES,
1229
                      allowed_values=[constants.VALUE_DEFAULT])
1230

    
1231
  for idx, (nic_op, nic_dict) in enumerate(opts.nics):
1232
    try:
1233
      nic_op = int(nic_op)
1234
      opts.nics[idx] = (nic_op, nic_dict)
1235
    except (TypeError, ValueError):
1236
      pass
1237

    
1238
  for idx, (disk_op, disk_dict) in enumerate(opts.disks):
1239
    try:
1240
      disk_op = int(disk_op)
1241
      opts.disks[idx] = (disk_op, disk_dict)
1242
    except (TypeError, ValueError):
1243
      pass
1244
    if disk_op == constants.DDM_ADD:
1245
      if 'size' not in disk_dict:
1246
        raise errors.OpPrereqError("Missing required parameter 'size'",
1247
                                   errors.ECODE_INVAL)
1248
      disk_dict['size'] = utils.ParseUnit(disk_dict['size'])
1249

    
1250
  op = opcodes.OpSetInstanceParams(instance_name=args[0],
1251
                                   nics=opts.nics,
1252
                                   disks=opts.disks,
1253
                                   hvparams=opts.hvparams,
1254
                                   beparams=opts.beparams,
1255
                                   force=opts.force)
1256

    
1257
  # even if here we process the result, we allow submit only
1258
  result = SubmitOrSend(op, opts)
1259

    
1260
  if result:
1261
    ToStdout("Modified instance %s", args[0])
1262
    for param, data in result:
1263
      ToStdout(" - %-5s -> %s", param, data)
1264
    ToStdout("Please don't forget that these parameters take effect"
1265
             " only at the next start of the instance.")
1266
  return 0
1267

    
1268

    
1269
# multi-instance selection options
1270
m_force_multi = cli_option("--force-multiple", dest="force_multi",
1271
                           help="Do not ask for confirmation when more than"
1272
                           " one instance is affected",
1273
                           action="store_true", default=False)
1274

    
1275
m_pri_node_opt = cli_option("--primary", dest="multi_mode",
1276
                            help="Filter by nodes (primary only)",
1277
                            const=_SHUTDOWN_NODES_PRI, action="store_const")
1278

    
1279
m_sec_node_opt = cli_option("--secondary", dest="multi_mode",
1280
                            help="Filter by nodes (secondary only)",
1281
                            const=_SHUTDOWN_NODES_SEC, action="store_const")
1282

    
1283
m_node_opt = cli_option("--node", dest="multi_mode",
1284
                        help="Filter by nodes (primary and secondary)",
1285
                        const=_SHUTDOWN_NODES_BOTH, action="store_const")
1286

    
1287
m_clust_opt = cli_option("--all", dest="multi_mode",
1288
                         help="Select all instances in the cluster",
1289
                         const=_SHUTDOWN_CLUSTER, action="store_const")
1290

    
1291
m_inst_opt = cli_option("--instance", dest="multi_mode",
1292
                        help="Filter by instance name [default]",
1293
                        const=_SHUTDOWN_INSTANCES, action="store_const")
1294

    
1295
m_node_tags_opt = cli_option("--node-tags", dest="multi_mode",
1296
                             help="Filter by node tag",
1297
                             const=_SHUTDOWN_NODES_BOTH_BY_TAGS,
1298
                             action="store_const")
1299

    
1300
m_pri_node_tags_opt = cli_option("--pri-node-tags", dest="multi_mode",
1301
                                 help="Filter by primary node tag",
1302
                                 const=_SHUTDOWN_NODES_PRI_BY_TAGS,
1303
                                 action="store_const")
1304

    
1305
m_sec_node_tags_opt = cli_option("--sec-node-tags", dest="multi_mode",
1306
                                 help="Filter by secondary node tag",
1307
                                 const=_SHUTDOWN_NODES_SEC_BY_TAGS,
1308
                                 action="store_const")
1309

    
1310
m_inst_tags_opt = cli_option("--tags", dest="multi_mode",
1311
                             help="Filter by instance tag",
1312
                             const=_SHUTDOWN_INSTANCES_BY_TAGS,
1313
                             action="store_const")
1314

    
1315
# this is defined separately due to readability only
1316
add_opts = [
1317
  BACKEND_OPT,
1318
  DISK_OPT,
1319
  DISK_TEMPLATE_OPT,
1320
  FILESTORE_DIR_OPT,
1321
  FILESTORE_DRIVER_OPT,
1322
  HYPERVISOR_OPT,
1323
  IALLOCATOR_OPT,
1324
  NET_OPT,
1325
  NODE_PLACEMENT_OPT,
1326
  NOIPCHECK_OPT,
1327
  NONAMECHECK_OPT,
1328
  NONICS_OPT,
1329
  NOSTART_OPT,
1330
  NWSYNC_OPT,
1331
  OS_OPT,
1332
  FORCE_VARIANT_OPT,
1333
  OS_SIZE_OPT,
1334
  SUBMIT_OPT,
1335
  ]
1336

    
1337
commands = {
1338
  'add': (
1339
    AddInstance, [ArgHost(min=1, max=1)], add_opts,
1340
    "[...] -t disk-type -n node[:secondary-node] -o os-type <name>",
1341
    "Creates and adds a new instance to the cluster"),
1342
  'batch-create': (
1343
    BatchCreate, [ArgFile(min=1, max=1)], [],
1344
    "<instances.json>",
1345
    "Create a bunch of instances based on specs in the file."),
1346
  'console': (
1347
    ConnectToInstanceConsole, ARGS_ONE_INSTANCE,
1348
    [SHOWCMD_OPT],
1349
    "[--show-cmd] <instance>", "Opens a console on the specified instance"),
1350
  'failover': (
1351
    FailoverInstance, ARGS_ONE_INSTANCE,
1352
    [FORCE_OPT, IGNORE_CONSIST_OPT, SUBMIT_OPT, SHUTDOWN_TIMEOUT_OPT],
1353
    "[-f] <instance>", "Stops the instance and starts it on the backup node,"
1354
    " using the remote mirror (only for instances of type drbd)"),
1355
  'migrate': (
1356
    MigrateInstance, ARGS_ONE_INSTANCE,
1357
    [FORCE_OPT, NONLIVE_OPT, CLEANUP_OPT],
1358
    "[-f] <instance>", "Migrate instance to its secondary node"
1359
    " (only for instances of type drbd)"),
1360
  'move': (
1361
    MoveInstance, ARGS_ONE_INSTANCE,
1362
    [FORCE_OPT, SUBMIT_OPT, SINGLE_NODE_OPT, SHUTDOWN_TIMEOUT_OPT],
1363
    "[-f] <instance>", "Move instance to an arbitrary node"
1364
    " (only for instances of type file and lv)"),
1365
  'info': (
1366
    ShowInstanceConfig, ARGS_MANY_INSTANCES,
1367
    [STATIC_OPT, ALL_OPT],
1368
    "[-s] {--all | <instance>...}",
1369
    "Show information on the specified instance(s)"),
1370
  'list': (
1371
    ListInstances, ARGS_MANY_INSTANCES,
1372
    [NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT, SYNC_OPT],
1373
    "[<instance>...]",
1374
    "Lists the instances and their status. The available fields are"
1375
    " (see the man page for details): status, oper_state, oper_ram,"
1376
    " name, os, pnode, snodes, admin_state, admin_ram, disk_template,"
1377
    " ip, mac, nic_mode, nic_link, sda_size, sdb_size, vcpus, serial_no,"
1378
    " nic.count, nic.mac/N, nic.ip/N, nic.mode/N, nic.link/N,"
1379
    " nic.macs, nic.ips, nic.modes, nic.links,"
1380
    " disk.count, disk.size/N, disk.sizes,"
1381
    " hv/NAME, be/memory, be/vcpus, be/auto_balance,"
1382
    " hypervisor."
1383
    " The default field"
1384
    " list is (in order): %s." % utils.CommaJoin(_LIST_DEF_FIELDS),
1385
    ),
1386
  'reinstall': (
1387
    ReinstallInstance, [ArgInstance()],
1388
    [FORCE_OPT, OS_OPT, FORCE_VARIANT_OPT, m_force_multi, m_node_opt,
1389
     m_pri_node_opt, m_sec_node_opt, m_clust_opt, m_inst_opt, m_node_tags_opt,
1390
     m_pri_node_tags_opt, m_sec_node_tags_opt, m_inst_tags_opt, SELECT_OS_OPT,
1391
     SUBMIT_OPT],
1392
    "[-f] <instance>", "Reinstall a stopped instance"),
1393
  'remove': (
1394
    RemoveInstance, ARGS_ONE_INSTANCE,
1395
    [FORCE_OPT, SHUTDOWN_TIMEOUT_OPT, IGNORE_FAILURES_OPT, SUBMIT_OPT],
1396
    "[-f] <instance>", "Shuts down the instance and removes it"),
1397
  'rename': (
1398
    RenameInstance,
1399
    [ArgInstance(min=1, max=1), ArgHost(min=1, max=1)],
1400
    [NOIPCHECK_OPT, SUBMIT_OPT],
1401
    "<instance> <new_name>", "Rename the instance"),
1402
  'replace-disks': (
1403
    ReplaceDisks, ARGS_ONE_INSTANCE,
1404
    [AUTO_REPLACE_OPT, DISKIDX_OPT, IALLOCATOR_OPT, EARLY_RELEASE_OPT,
1405
     NEW_SECONDARY_OPT, ON_PRIMARY_OPT, ON_SECONDARY_OPT, SUBMIT_OPT],
1406
    "[-s|-p|-n NODE|-I NAME] <instance>",
1407
    "Replaces all disks for the instance"),
1408
  'modify': (
1409
    SetInstanceParams, ARGS_ONE_INSTANCE,
1410
    [BACKEND_OPT, DISK_OPT, FORCE_OPT, HVOPTS_OPT, NET_OPT, SUBMIT_OPT],
1411
    "<instance>", "Alters the parameters of an instance"),
1412
  'shutdown': (
1413
    GenericManyOps("shutdown", _ShutdownInstance), [ArgInstance()],
1414
    [m_node_opt, m_pri_node_opt, m_sec_node_opt, m_clust_opt,
1415
     m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt,
1416
     m_inst_tags_opt, m_inst_opt, m_force_multi, TIMEOUT_OPT, SUBMIT_OPT],
1417
    "<instance>", "Stops an instance"),
1418
  'startup': (
1419
    GenericManyOps("startup", _StartupInstance), [ArgInstance()],
1420
    [FORCE_OPT, m_force_multi, m_node_opt, m_pri_node_opt, m_sec_node_opt,
1421
     m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt,
1422
     m_inst_tags_opt, m_clust_opt, m_inst_opt, SUBMIT_OPT, HVOPTS_OPT,
1423
     BACKEND_OPT],
1424
    "<instance>", "Starts an instance"),
1425
  'reboot': (
1426
    GenericManyOps("reboot", _RebootInstance), [ArgInstance()],
1427
    [m_force_multi, REBOOT_TYPE_OPT, IGNORE_SECONDARIES_OPT, m_node_opt,
1428
     m_pri_node_opt, m_sec_node_opt, m_clust_opt, m_inst_opt, SUBMIT_OPT,
1429
     m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt,
1430
     m_inst_tags_opt, SHUTDOWN_TIMEOUT_OPT],
1431
    "<instance>", "Reboots an instance"),
1432
  'activate-disks': (
1433
    ActivateDisks, ARGS_ONE_INSTANCE, [SUBMIT_OPT, IGNORE_SIZE_OPT],
1434
    "<instance>", "Activate an instance's disks"),
1435
  'deactivate-disks': (
1436
    DeactivateDisks, ARGS_ONE_INSTANCE, [SUBMIT_OPT],
1437
    "<instance>", "Deactivate an instance's disks"),
1438
  'recreate-disks': (
1439
    RecreateDisks, ARGS_ONE_INSTANCE, [SUBMIT_OPT, DISKIDX_OPT],
1440
    "<instance>", "Recreate an instance's disks"),
1441
  'grow-disk': (
1442
    GrowDisk,
1443
    [ArgInstance(min=1, max=1), ArgUnknown(min=1, max=1),
1444
     ArgUnknown(min=1, max=1)],
1445
    [SUBMIT_OPT, NWSYNC_OPT],
1446
    "<instance> <disk> <size>", "Grow an instance's disk"),
1447
  'list-tags': (
1448
    ListTags, ARGS_ONE_INSTANCE, [],
1449
    "<instance_name>", "List the tags of the given instance"),
1450
  'add-tags': (
1451
    AddTags, [ArgInstance(min=1, max=1), ArgUnknown()],
1452
    [TAG_SRC_OPT],
1453
    "<instance_name> tag...", "Add tags to the given instance"),
1454
  'remove-tags': (
1455
    RemoveTags, [ArgInstance(min=1, max=1), ArgUnknown()],
1456
    [TAG_SRC_OPT],
1457
    "<instance_name> tag...", "Remove tags from given instance"),
1458
  }
1459

    
1460
#: dictionary with aliases for commands
1461
aliases = {
1462
  'activate_block_devs': 'activate-disks',
1463
  'replace_disks': 'replace-disks',
1464
  'start': 'startup',
1465
  'stop': 'shutdown',
1466
  }
1467

    
1468

    
1469
if __name__ == '__main__':
1470
  sys.exit(GenericMain(commands, aliases=aliases,
1471
                       override={"tag_type": constants.TAG_INSTANCE}))