Statistics
| Branch: | Tag: | Revision:

root / lib / cmdlib.py @ 35c0c8da

History | View | Annotate | Download (251.2 kB)

1
#
2
#
3

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

    
22
"""Module implementing the master-side code."""
23

    
24
# pylint: disable-msg=W0613,W0201
25

    
26
import os
27
import os.path
28
import time
29
import tempfile
30
import re
31
import platform
32
import logging
33
import copy
34
import random
35

    
36
from ganeti import ssh
37
from ganeti import utils
38
from ganeti import errors
39
from ganeti import hypervisor
40
from ganeti import locking
41
from ganeti import constants
42
from ganeti import objects
43
from ganeti import opcodes
44
from ganeti import serializer
45
from ganeti import ssconf
46

    
47

    
48
class LogicalUnit(object):
49
  """Logical Unit base class.
50

51
  Subclasses must follow these rules:
52
    - implement ExpandNames
53
    - implement CheckPrereq
54
    - implement Exec
55
    - implement BuildHooksEnv
56
    - redefine HPATH and HTYPE
57
    - optionally redefine their run requirements:
58
        REQ_BGL: the LU needs to hold the Big Ganeti Lock exclusively
59

60
  Note that all commands require root permissions.
61

62
  """
63
  HPATH = None
64
  HTYPE = None
65
  _OP_REQP = []
66
  REQ_BGL = True
67

    
68
  def __init__(self, processor, op, context, rpc):
69
    """Constructor for LogicalUnit.
70

71
    This needs to be overriden in derived classes in order to check op
72
    validity.
73

74
    """
75
    self.proc = processor
76
    self.op = op
77
    self.cfg = context.cfg
78
    self.context = context
79
    self.rpc = rpc
80
    # Dicts used to declare locking needs to mcpu
81
    self.needed_locks = None
82
    self.acquired_locks = {}
83
    self.share_locks = dict(((i, 0) for i in locking.LEVELS))
84
    self.add_locks = {}
85
    self.remove_locks = {}
86
    # Used to force good behavior when calling helper functions
87
    self.recalculate_locks = {}
88
    self.__ssh = None
89
    # logging
90
    self.LogWarning = processor.LogWarning
91
    self.LogInfo = processor.LogInfo
92

    
93
    for attr_name in self._OP_REQP:
94
      attr_val = getattr(op, attr_name, None)
95
      if attr_val is None:
96
        raise errors.OpPrereqError("Required parameter '%s' missing" %
97
                                   attr_name)
98
    self.CheckArguments()
99

    
100
  def __GetSSH(self):
101
    """Returns the SshRunner object
102

103
    """
104
    if not self.__ssh:
105
      self.__ssh = ssh.SshRunner(self.cfg.GetClusterName())
106
    return self.__ssh
107

    
108
  ssh = property(fget=__GetSSH)
109

    
110
  def CheckArguments(self):
111
    """Check syntactic validity for the opcode arguments.
112

113
    This method is for doing a simple syntactic check and ensure
114
    validity of opcode parameters, without any cluster-related
115
    checks. While the same can be accomplished in ExpandNames and/or
116
    CheckPrereq, doing these separate is better because:
117

118
      - ExpandNames is left as as purely a lock-related function
119
      - CheckPrereq is run after we have aquired locks (and possible
120
        waited for them)
121

122
    The function is allowed to change the self.op attribute so that
123
    later methods can no longer worry about missing parameters.
124

125
    """
126
    pass
127

    
128
  def ExpandNames(self):
129
    """Expand names for this LU.
130

131
    This method is called before starting to execute the opcode, and it should
132
    update all the parameters of the opcode to their canonical form (e.g. a
133
    short node name must be fully expanded after this method has successfully
134
    completed). This way locking, hooks, logging, ecc. can work correctly.
135

136
    LUs which implement this method must also populate the self.needed_locks
137
    member, as a dict with lock levels as keys, and a list of needed lock names
138
    as values. Rules:
139

140
      - use an empty dict if you don't need any lock
141
      - if you don't need any lock at a particular level omit that level
142
      - don't put anything for the BGL level
143
      - if you want all locks at a level use locking.ALL_SET as a value
144

145
    If you need to share locks (rather than acquire them exclusively) at one
146
    level you can modify self.share_locks, setting a true value (usually 1) for
147
    that level. By default locks are not shared.
148

149
    Examples::
150

151
      # Acquire all nodes and one instance
152
      self.needed_locks = {
153
        locking.LEVEL_NODE: locking.ALL_SET,
154
        locking.LEVEL_INSTANCE: ['instance1.example.tld'],
155
      }
156
      # Acquire just two nodes
157
      self.needed_locks = {
158
        locking.LEVEL_NODE: ['node1.example.tld', 'node2.example.tld'],
159
      }
160
      # Acquire no locks
161
      self.needed_locks = {} # No, you can't leave it to the default value None
162

163
    """
164
    # The implementation of this method is mandatory only if the new LU is
165
    # concurrent, so that old LUs don't need to be changed all at the same
166
    # time.
167
    if self.REQ_BGL:
168
      self.needed_locks = {} # Exclusive LUs don't need locks.
169
    else:
170
      raise NotImplementedError
171

    
172
  def DeclareLocks(self, level):
173
    """Declare LU locking needs for a level
174

175
    While most LUs can just declare their locking needs at ExpandNames time,
176
    sometimes there's the need to calculate some locks after having acquired
177
    the ones before. This function is called just before acquiring locks at a
178
    particular level, but after acquiring the ones at lower levels, and permits
179
    such calculations. It can be used to modify self.needed_locks, and by
180
    default it does nothing.
181

182
    This function is only called if you have something already set in
183
    self.needed_locks for the level.
184

185
    @param level: Locking level which is going to be locked
186
    @type level: member of ganeti.locking.LEVELS
187

188
    """
189

    
190
  def CheckPrereq(self):
191
    """Check prerequisites for this LU.
192

193
    This method should check that the prerequisites for the execution
194
    of this LU are fulfilled. It can do internode communication, but
195
    it should be idempotent - no cluster or system changes are
196
    allowed.
197

198
    The method should raise errors.OpPrereqError in case something is
199
    not fulfilled. Its return value is ignored.
200

201
    This method should also update all the parameters of the opcode to
202
    their canonical form if it hasn't been done by ExpandNames before.
203

204
    """
205
    raise NotImplementedError
206

    
207
  def Exec(self, feedback_fn):
208
    """Execute the LU.
209

210
    This method should implement the actual work. It should raise
211
    errors.OpExecError for failures that are somewhat dealt with in
212
    code, or expected.
213

214
    """
215
    raise NotImplementedError
216

    
217
  def BuildHooksEnv(self):
218
    """Build hooks environment for this LU.
219

220
    This method should return a three-node tuple consisting of: a dict
221
    containing the environment that will be used for running the
222
    specific hook for this LU, a list of node names on which the hook
223
    should run before the execution, and a list of node names on which
224
    the hook should run after the execution.
225

226
    The keys of the dict must not have 'GANETI_' prefixed as this will
227
    be handled in the hooks runner. Also note additional keys will be
228
    added by the hooks runner. If the LU doesn't define any
229
    environment, an empty dict (and not None) should be returned.
230

231
    No nodes should be returned as an empty list (and not None).
232

233
    Note that if the HPATH for a LU class is None, this function will
234
    not be called.
235

236
    """
237
    raise NotImplementedError
238

    
239
  def HooksCallBack(self, phase, hook_results, feedback_fn, lu_result):
240
    """Notify the LU about the results of its hooks.
241

242
    This method is called every time a hooks phase is executed, and notifies
243
    the Logical Unit about the hooks' result. The LU can then use it to alter
244
    its result based on the hooks.  By default the method does nothing and the
245
    previous result is passed back unchanged but any LU can define it if it
246
    wants to use the local cluster hook-scripts somehow.
247

248
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
249
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
250
    @param hook_results: the results of the multi-node hooks rpc call
251
    @param feedback_fn: function used send feedback back to the caller
252
    @param lu_result: the previous Exec result this LU had, or None
253
        in the PRE phase
254
    @return: the new Exec result, based on the previous result
255
        and hook results
256

257
    """
258
    return lu_result
259

    
260
  def _ExpandAndLockInstance(self):
261
    """Helper function to expand and lock an instance.
262

263
    Many LUs that work on an instance take its name in self.op.instance_name
264
    and need to expand it and then declare the expanded name for locking. This
265
    function does it, and then updates self.op.instance_name to the expanded
266
    name. It also initializes needed_locks as a dict, if this hasn't been done
267
    before.
268

269
    """
270
    if self.needed_locks is None:
271
      self.needed_locks = {}
272
    else:
273
      assert locking.LEVEL_INSTANCE not in self.needed_locks, \
274
        "_ExpandAndLockInstance called with instance-level locks set"
275
    expanded_name = self.cfg.ExpandInstanceName(self.op.instance_name)
276
    if expanded_name is None:
277
      raise errors.OpPrereqError("Instance '%s' not known" %
278
                                  self.op.instance_name)
279
    self.needed_locks[locking.LEVEL_INSTANCE] = expanded_name
280
    self.op.instance_name = expanded_name
281

    
282
  def _LockInstancesNodes(self, primary_only=False):
283
    """Helper function to declare instances' nodes for locking.
284

285
    This function should be called after locking one or more instances to lock
286
    their nodes. Its effect is populating self.needed_locks[locking.LEVEL_NODE]
287
    with all primary or secondary nodes for instances already locked and
288
    present in self.needed_locks[locking.LEVEL_INSTANCE].
289

290
    It should be called from DeclareLocks, and for safety only works if
291
    self.recalculate_locks[locking.LEVEL_NODE] is set.
292

293
    In the future it may grow parameters to just lock some instance's nodes, or
294
    to just lock primaries or secondary nodes, if needed.
295

296
    If should be called in DeclareLocks in a way similar to::
297

298
      if level == locking.LEVEL_NODE:
299
        self._LockInstancesNodes()
300

301
    @type primary_only: boolean
302
    @param primary_only: only lock primary nodes of locked instances
303

304
    """
305
    assert locking.LEVEL_NODE in self.recalculate_locks, \
306
      "_LockInstancesNodes helper function called with no nodes to recalculate"
307

    
308
    # TODO: check if we're really been called with the instance locks held
309

    
310
    # For now we'll replace self.needed_locks[locking.LEVEL_NODE], but in the
311
    # future we might want to have different behaviors depending on the value
312
    # of self.recalculate_locks[locking.LEVEL_NODE]
313
    wanted_nodes = []
314
    for instance_name in self.acquired_locks[locking.LEVEL_INSTANCE]:
315
      instance = self.context.cfg.GetInstanceInfo(instance_name)
316
      wanted_nodes.append(instance.primary_node)
317
      if not primary_only:
318
        wanted_nodes.extend(instance.secondary_nodes)
319

    
320
    if self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_REPLACE:
321
      self.needed_locks[locking.LEVEL_NODE] = wanted_nodes
322
    elif self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_APPEND:
323
      self.needed_locks[locking.LEVEL_NODE].extend(wanted_nodes)
324

    
325
    del self.recalculate_locks[locking.LEVEL_NODE]
326

    
327

    
328
class NoHooksLU(LogicalUnit):
329
  """Simple LU which runs no hooks.
330

331
  This LU is intended as a parent for other LogicalUnits which will
332
  run no hooks, in order to reduce duplicate code.
333

334
  """
335
  HPATH = None
336
  HTYPE = None
337

    
338

    
339
def _GetWantedNodes(lu, nodes):
340
  """Returns list of checked and expanded node names.
341

342
  @type lu: L{LogicalUnit}
343
  @param lu: the logical unit on whose behalf we execute
344
  @type nodes: list
345
  @param nodes: list of node names or None for all nodes
346
  @rtype: list
347
  @return: the list of nodes, sorted
348
  @raise errors.OpProgrammerError: if the nodes parameter is wrong type
349

350
  """
351
  if not isinstance(nodes, list):
352
    raise errors.OpPrereqError("Invalid argument type 'nodes'")
353

    
354
  if not nodes:
355
    raise errors.ProgrammerError("_GetWantedNodes should only be called with a"
356
      " non-empty list of nodes whose name is to be expanded.")
357

    
358
  wanted = []
359
  for name in nodes:
360
    node = lu.cfg.ExpandNodeName(name)
361
    if node is None:
362
      raise errors.OpPrereqError("No such node name '%s'" % name)
363
    wanted.append(node)
364

    
365
  return utils.NiceSort(wanted)
366

    
367

    
368
def _GetWantedInstances(lu, instances):
369
  """Returns list of checked and expanded instance names.
370

371
  @type lu: L{LogicalUnit}
372
  @param lu: the logical unit on whose behalf we execute
373
  @type instances: list
374
  @param instances: list of instance names or None for all instances
375
  @rtype: list
376
  @return: the list of instances, sorted
377
  @raise errors.OpPrereqError: if the instances parameter is wrong type
378
  @raise errors.OpPrereqError: if any of the passed instances is not found
379

380
  """
381
  if not isinstance(instances, list):
382
    raise errors.OpPrereqError("Invalid argument type 'instances'")
383

    
384
  if instances:
385
    wanted = []
386

    
387
    for name in instances:
388
      instance = lu.cfg.ExpandInstanceName(name)
389
      if instance is None:
390
        raise errors.OpPrereqError("No such instance name '%s'" % name)
391
      wanted.append(instance)
392

    
393
  else:
394
    wanted = utils.NiceSort(lu.cfg.GetInstanceList())
395
  return wanted
396

    
397

    
398
def _CheckOutputFields(static, dynamic, selected):
399
  """Checks whether all selected fields are valid.
400

401
  @type static: L{utils.FieldSet}
402
  @param static: static fields set
403
  @type dynamic: L{utils.FieldSet}
404
  @param dynamic: dynamic fields set
405

406
  """
407
  f = utils.FieldSet()
408
  f.Extend(static)
409
  f.Extend(dynamic)
410

    
411
  delta = f.NonMatching(selected)
412
  if delta:
413
    raise errors.OpPrereqError("Unknown output fields selected: %s"
414
                               % ",".join(delta))
415

    
416

    
417
def _CheckBooleanOpField(op, name):
418
  """Validates boolean opcode parameters.
419

420
  This will ensure that an opcode parameter is either a boolean value,
421
  or None (but that it always exists).
422

423
  """
424
  val = getattr(op, name, None)
425
  if not (val is None or isinstance(val, bool)):
426
    raise errors.OpPrereqError("Invalid boolean parameter '%s' (%s)" %
427
                               (name, str(val)))
428
  setattr(op, name, val)
429

    
430

    
431
def _CheckNodeOnline(lu, node):
432
  """Ensure that a given node is online.
433

434
  @param lu: the LU on behalf of which we make the check
435
  @param node: the node to check
436
  @raise errors.OpPrereqError: if the node is offline
437

438
  """
439
  if lu.cfg.GetNodeInfo(node).offline:
440
    raise errors.OpPrereqError("Can't use offline node %s" % node)
441

    
442

    
443
def _CheckNodeNotDrained(lu, node):
444
  """Ensure that a given node is not drained.
445

446
  @param lu: the LU on behalf of which we make the check
447
  @param node: the node to check
448
  @raise errors.OpPrereqError: if the node is drained
449

450
  """
451
  if lu.cfg.GetNodeInfo(node).drained:
452
    raise errors.OpPrereqError("Can't use drained node %s" % node)
453

    
454

    
455
def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,
456
                          memory, vcpus, nics, disk_template, disks):
457
  """Builds instance related env variables for hooks
458

459
  This builds the hook environment from individual variables.
460

461
  @type name: string
462
  @param name: the name of the instance
463
  @type primary_node: string
464
  @param primary_node: the name of the instance's primary node
465
  @type secondary_nodes: list
466
  @param secondary_nodes: list of secondary nodes as strings
467
  @type os_type: string
468
  @param os_type: the name of the instance's OS
469
  @type status: boolean
470
  @param status: the should_run status of the instance
471
  @type memory: string
472
  @param memory: the memory size of the instance
473
  @type vcpus: string
474
  @param vcpus: the count of VCPUs the instance has
475
  @type nics: list
476
  @param nics: list of tuples (ip, bridge, mac) representing
477
      the NICs the instance  has
478
  @type disk_template: string
479
  @param disk_template: the distk template of the instance
480
  @type disks: list
481
  @param disks: the list of (size, mode) pairs
482
  @rtype: dict
483
  @return: the hook environment for this instance
484

485
  """
486
  if status:
487
    str_status = "up"
488
  else:
489
    str_status = "down"
490
  env = {
491
    "OP_TARGET": name,
492
    "INSTANCE_NAME": name,
493
    "INSTANCE_PRIMARY": primary_node,
494
    "INSTANCE_SECONDARIES": " ".join(secondary_nodes),
495
    "INSTANCE_OS_TYPE": os_type,
496
    "INSTANCE_STATUS": str_status,
497
    "INSTANCE_MEMORY": memory,
498
    "INSTANCE_VCPUS": vcpus,
499
    "INSTANCE_DISK_TEMPLATE": disk_template,
500
  }
501

    
502
  if nics:
503
    nic_count = len(nics)
504
    for idx, (ip, mac, mode, link) in enumerate(nics):
505
      if ip is None:
506
        ip = ""
507
      env["INSTANCE_NIC%d_IP" % idx] = ip
508
      env["INSTANCE_NIC%d_MAC" % idx] = mac
509
      env["INSTANCE_NIC%d_MODE" % idx] = mode
510
      env["INSTANCE_NIC%d_LINK" % idx] = link
511
      if mode == constants.NIC_MODE_BRIDGED:
512
        env["INSTANCE_NIC%d_BRIDGE" % idx] = link
513
  else:
514
    nic_count = 0
515

    
516
  env["INSTANCE_NIC_COUNT"] = nic_count
517

    
518
  if disks:
519
    disk_count = len(disks)
520
    for idx, (size, mode) in enumerate(disks):
521
      env["INSTANCE_DISK%d_SIZE" % idx] = size
522
      env["INSTANCE_DISK%d_MODE" % idx] = mode
523
  else:
524
    disk_count = 0
525

    
526
  env["INSTANCE_DISK_COUNT"] = disk_count
527

    
528
  return env
529

    
530
def _PreBuildNICHooksList(lu, nics):
531
  """Build a list of nic information tuples.
532

533
  This list is suitable to be passed to _BuildInstanceHookEnv.
534

535
  @type lu:  L{LogicalUnit}
536
  @param lu: the logical unit on whose behalf we execute
537
  @type nics: list of L{objects.NIC}
538
  @param nics: list of nics to convert to hooks tuples
539

540
  """
541
  hooks_nics = []
542
  c_nicparams = lu.cfg.GetClusterInfo().nicparams[constants.PP_DEFAULT]
543
  for nic in nics:
544
    ip = nic.ip
545
    mac = nic.mac
546
    filled_params = objects.FillDict(c_nicparams, nic.nicparams)
547
    mode = filled_params[constants.NIC_MODE]
548
    link = filled_params[constants.NIC_LINK]
549
    hooks_nics.append((ip, mac, mode, link))
550
  return hooks_nics
551

    
552
def _BuildInstanceHookEnvByObject(lu, instance, override=None):
553
  """Builds instance related env variables for hooks from an object.
554

555
  @type lu: L{LogicalUnit}
556
  @param lu: the logical unit on whose behalf we execute
557
  @type instance: L{objects.Instance}
558
  @param instance: the instance for which we should build the
559
      environment
560
  @type override: dict
561
  @param override: dictionary with key/values that will override
562
      our values
563
  @rtype: dict
564
  @return: the hook environment dictionary
565

566
  """
567
  bep = lu.cfg.GetClusterInfo().FillBE(instance)
568
  args = {
569
    'name': instance.name,
570
    'primary_node': instance.primary_node,
571
    'secondary_nodes': instance.secondary_nodes,
572
    'os_type': instance.os,
573
    'status': instance.admin_up,
574
    'memory': bep[constants.BE_MEMORY],
575
    'vcpus': bep[constants.BE_VCPUS],
576
    'nics': _PreBuildNICHooksList(lu, instance.nics),
577
    'disk_template': instance.disk_template,
578
    'disks': [(disk.size, disk.mode) for disk in instance.disks],
579
  }
580
  if override:
581
    args.update(override)
582
  return _BuildInstanceHookEnv(**args)
583

    
584

    
585
def _AdjustCandidatePool(lu):
586
  """Adjust the candidate pool after node operations.
587

588
  """
589
  mod_list = lu.cfg.MaintainCandidatePool()
590
  if mod_list:
591
    lu.LogInfo("Promoted nodes to master candidate role: %s",
592
               ", ".join(node.name for node in mod_list))
593
    for name in mod_list:
594
      lu.context.ReaddNode(name)
595
  mc_now, mc_max = lu.cfg.GetMasterCandidateStats()
596
  if mc_now > mc_max:
597
    lu.LogInfo("Note: more nodes are candidates (%d) than desired (%d)" %
598
               (mc_now, mc_max))
599

    
600

    
601
def _CheckNicsBridgesExist(lu, target_nics, target_node,
602
                               profile=constants.PP_DEFAULT):
603
  """Check that the brigdes needed by a list of nics exist.
604

605
  """
606
  c_nicparams = lu.cfg.GetClusterInfo().nicparams[profile]
607
  paramslist = [objects.FillDict(c_nicparams, nic.nicparams)
608
                for nic in target_nics]
609
  brlist = [params[constants.NIC_LINK] for params in paramslist
610
            if params[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED]
611
  if brlist:
612
    result = lu.rpc.call_bridges_exist(target_node, brlist)
613
    msg = result.RemoteFailMsg()
614
    if msg:
615
      raise errors.OpPrereqError("Error checking bridges on destination node"
616
                                 " '%s': %s" % (target_node, msg))
617

    
618

    
619
def _CheckInstanceBridgesExist(lu, instance, node=None):
620
  """Check that the brigdes needed by an instance exist.
621

622
  """
623
  if node is None:
624
    node=instance.primary_node
625
  _CheckNicsBridgesExist(lu, instance.nics, node)
626

    
627

    
628
class LUDestroyCluster(NoHooksLU):
629
  """Logical unit for destroying the cluster.
630

631
  """
632
  _OP_REQP = []
633

    
634
  def CheckPrereq(self):
635
    """Check prerequisites.
636

637
    This checks whether the cluster is empty.
638

639
    Any errors are signalled by raising errors.OpPrereqError.
640

641
    """
642
    master = self.cfg.GetMasterNode()
643

    
644
    nodelist = self.cfg.GetNodeList()
645
    if len(nodelist) != 1 or nodelist[0] != master:
646
      raise errors.OpPrereqError("There are still %d node(s) in"
647
                                 " this cluster." % (len(nodelist) - 1))
648
    instancelist = self.cfg.GetInstanceList()
649
    if instancelist:
650
      raise errors.OpPrereqError("There are still %d instance(s) in"
651
                                 " this cluster." % len(instancelist))
652

    
653
  def Exec(self, feedback_fn):
654
    """Destroys the cluster.
655

656
    """
657
    master = self.cfg.GetMasterNode()
658
    result = self.rpc.call_node_stop_master(master, False)
659
    result.Raise()
660
    if not result.data:
661
      raise errors.OpExecError("Could not disable the master role")
662
    priv_key, pub_key, _ = ssh.GetUserFiles(constants.GANETI_RUNAS)
663
    utils.CreateBackup(priv_key)
664
    utils.CreateBackup(pub_key)
665
    return master
666

    
667

    
668
class LUVerifyCluster(LogicalUnit):
669
  """Verifies the cluster status.
670

671
  """
672
  HPATH = "cluster-verify"
673
  HTYPE = constants.HTYPE_CLUSTER
674
  _OP_REQP = ["skip_checks"]
675
  REQ_BGL = False
676

    
677
  def ExpandNames(self):
678
    self.needed_locks = {
679
      locking.LEVEL_NODE: locking.ALL_SET,
680
      locking.LEVEL_INSTANCE: locking.ALL_SET,
681
    }
682
    self.share_locks = dict(((i, 1) for i in locking.LEVELS))
683

    
684
  def _VerifyNode(self, nodeinfo, file_list, local_cksum,
685
                  node_result, feedback_fn, master_files,
686
                  drbd_map, vg_name):
687
    """Run multiple tests against a node.
688

689
    Test list:
690

691
      - compares ganeti version
692
      - checks vg existance and size > 20G
693
      - checks config file checksum
694
      - checks ssh to other nodes
695

696
    @type nodeinfo: L{objects.Node}
697
    @param nodeinfo: the node to check
698
    @param file_list: required list of files
699
    @param local_cksum: dictionary of local files and their checksums
700
    @param node_result: the results from the node
701
    @param feedback_fn: function used to accumulate results
702
    @param master_files: list of files that only masters should have
703
    @param drbd_map: the useddrbd minors for this node, in
704
        form of minor: (instance, must_exist) which correspond to instances
705
        and their running status
706
    @param vg_name: Ganeti Volume Group (result of self.cfg.GetVGName())
707

708
    """
709
    node = nodeinfo.name
710

    
711
    # main result, node_result should be a non-empty dict
712
    if not node_result or not isinstance(node_result, dict):
713
      feedback_fn("  - ERROR: unable to verify node %s." % (node,))
714
      return True
715

    
716
    # compares ganeti version
717
    local_version = constants.PROTOCOL_VERSION
718
    remote_version = node_result.get('version', None)
719
    if not (remote_version and isinstance(remote_version, (list, tuple)) and
720
            len(remote_version) == 2):
721
      feedback_fn("  - ERROR: connection to %s failed" % (node))
722
      return True
723

    
724
    if local_version != remote_version[0]:
725
      feedback_fn("  - ERROR: incompatible protocol versions: master %s,"
726
                  " node %s %s" % (local_version, node, remote_version[0]))
727
      return True
728

    
729
    # node seems compatible, we can actually try to look into its results
730

    
731
    bad = False
732

    
733
    # full package version
734
    if constants.RELEASE_VERSION != remote_version[1]:
735
      feedback_fn("  - WARNING: software version mismatch: master %s,"
736
                  " node %s %s" %
737
                  (constants.RELEASE_VERSION, node, remote_version[1]))
738

    
739
    # checks vg existence and size > 20G
740
    if vg_name is not None:
741
      vglist = node_result.get(constants.NV_VGLIST, None)
742
      if not vglist:
743
        feedback_fn("  - ERROR: unable to check volume groups on node %s." %
744
                        (node,))
745
        bad = True
746
      else:
747
        vgstatus = utils.CheckVolumeGroupSize(vglist, vg_name,
748
                                              constants.MIN_VG_SIZE)
749
        if vgstatus:
750
          feedback_fn("  - ERROR: %s on node %s" % (vgstatus, node))
751
          bad = True
752

    
753
    # checks config file checksum
754

    
755
    remote_cksum = node_result.get(constants.NV_FILELIST, None)
756
    if not isinstance(remote_cksum, dict):
757
      bad = True
758
      feedback_fn("  - ERROR: node hasn't returned file checksum data")
759
    else:
760
      for file_name in file_list:
761
        node_is_mc = nodeinfo.master_candidate
762
        must_have_file = file_name not in master_files
763
        if file_name not in remote_cksum:
764
          if node_is_mc or must_have_file:
765
            bad = True
766
            feedback_fn("  - ERROR: file '%s' missing" % file_name)
767
        elif remote_cksum[file_name] != local_cksum[file_name]:
768
          if node_is_mc or must_have_file:
769
            bad = True
770
            feedback_fn("  - ERROR: file '%s' has wrong checksum" % file_name)
771
          else:
772
            # not candidate and this is not a must-have file
773
            bad = True
774
            feedback_fn("  - ERROR: non master-candidate has old/wrong file"
775
                        " '%s'" % file_name)
776
        else:
777
          # all good, except non-master/non-must have combination
778
          if not node_is_mc and not must_have_file:
779
            feedback_fn("  - ERROR: file '%s' should not exist on non master"
780
                        " candidates" % file_name)
781

    
782
    # checks ssh to any
783

    
784
    if constants.NV_NODELIST not in node_result:
785
      bad = True
786
      feedback_fn("  - ERROR: node hasn't returned node ssh connectivity data")
787
    else:
788
      if node_result[constants.NV_NODELIST]:
789
        bad = True
790
        for node in node_result[constants.NV_NODELIST]:
791
          feedback_fn("  - ERROR: ssh communication with node '%s': %s" %
792
                          (node, node_result[constants.NV_NODELIST][node]))
793

    
794
    if constants.NV_NODENETTEST not in node_result:
795
      bad = True
796
      feedback_fn("  - ERROR: node hasn't returned node tcp connectivity data")
797
    else:
798
      if node_result[constants.NV_NODENETTEST]:
799
        bad = True
800
        nlist = utils.NiceSort(node_result[constants.NV_NODENETTEST].keys())
801
        for node in nlist:
802
          feedback_fn("  - ERROR: tcp communication with node '%s': %s" %
803
                          (node, node_result[constants.NV_NODENETTEST][node]))
804

    
805
    hyp_result = node_result.get(constants.NV_HYPERVISOR, None)
806
    if isinstance(hyp_result, dict):
807
      for hv_name, hv_result in hyp_result.iteritems():
808
        if hv_result is not None:
809
          feedback_fn("  - ERROR: hypervisor %s verify failure: '%s'" %
810
                      (hv_name, hv_result))
811

    
812
    # check used drbd list
813
    if vg_name is not None:
814
      used_minors = node_result.get(constants.NV_DRBDLIST, [])
815
      if not isinstance(used_minors, (tuple, list)):
816
        feedback_fn("  - ERROR: cannot parse drbd status file: %s" %
817
                    str(used_minors))
818
      else:
819
        for minor, (iname, must_exist) in drbd_map.items():
820
          if minor not in used_minors and must_exist:
821
            feedback_fn("  - ERROR: drbd minor %d of instance %s is"
822
                        " not active" % (minor, iname))
823
            bad = True
824
        for minor in used_minors:
825
          if minor not in drbd_map:
826
            feedback_fn("  - ERROR: unallocated drbd minor %d is in use" %
827
                        minor)
828
            bad = True
829

    
830
    return bad
831

    
832
  def _VerifyInstance(self, instance, instanceconfig, node_vol_is,
833
                      node_instance, feedback_fn, n_offline):
834
    """Verify an instance.
835

836
    This function checks to see if the required block devices are
837
    available on the instance's node.
838

839
    """
840
    bad = False
841

    
842
    node_current = instanceconfig.primary_node
843

    
844
    node_vol_should = {}
845
    instanceconfig.MapLVsByNode(node_vol_should)
846

    
847
    for node in node_vol_should:
848
      if node in n_offline:
849
        # ignore missing volumes on offline nodes
850
        continue
851
      for volume in node_vol_should[node]:
852
        if node not in node_vol_is or volume not in node_vol_is[node]:
853
          feedback_fn("  - ERROR: volume %s missing on node %s" %
854
                          (volume, node))
855
          bad = True
856

    
857
    if instanceconfig.admin_up:
858
      if ((node_current not in node_instance or
859
          not instance in node_instance[node_current]) and
860
          node_current not in n_offline):
861
        feedback_fn("  - ERROR: instance %s not running on node %s" %
862
                        (instance, node_current))
863
        bad = True
864

    
865
    for node in node_instance:
866
      if (not node == node_current):
867
        if instance in node_instance[node]:
868
          feedback_fn("  - ERROR: instance %s should not run on node %s" %
869
                          (instance, node))
870
          bad = True
871

    
872
    return bad
873

    
874
  def _VerifyOrphanVolumes(self, node_vol_should, node_vol_is, feedback_fn):
875
    """Verify if there are any unknown volumes in the cluster.
876

877
    The .os, .swap and backup volumes are ignored. All other volumes are
878
    reported as unknown.
879

880
    """
881
    bad = False
882

    
883
    for node in node_vol_is:
884
      for volume in node_vol_is[node]:
885
        if node not in node_vol_should or volume not in node_vol_should[node]:
886
          feedback_fn("  - ERROR: volume %s on node %s should not exist" %
887
                      (volume, node))
888
          bad = True
889
    return bad
890

    
891
  def _VerifyOrphanInstances(self, instancelist, node_instance, feedback_fn):
892
    """Verify the list of running instances.
893

894
    This checks what instances are running but unknown to the cluster.
895

896
    """
897
    bad = False
898
    for node in node_instance:
899
      for runninginstance in node_instance[node]:
900
        if runninginstance not in instancelist:
901
          feedback_fn("  - ERROR: instance %s on node %s should not exist" %
902
                          (runninginstance, node))
903
          bad = True
904
    return bad
905

    
906
  def _VerifyNPlusOneMemory(self, node_info, instance_cfg, feedback_fn):
907
    """Verify N+1 Memory Resilience.
908

909
    Check that if one single node dies we can still start all the instances it
910
    was primary for.
911

912
    """
913
    bad = False
914

    
915
    for node, nodeinfo in node_info.iteritems():
916
      # This code checks that every node which is now listed as secondary has
917
      # enough memory to host all instances it is supposed to should a single
918
      # other node in the cluster fail.
919
      # FIXME: not ready for failover to an arbitrary node
920
      # FIXME: does not support file-backed instances
921
      # WARNING: we currently take into account down instances as well as up
922
      # ones, considering that even if they're down someone might want to start
923
      # them even in the event of a node failure.
924
      for prinode, instances in nodeinfo['sinst-by-pnode'].iteritems():
925
        needed_mem = 0
926
        for instance in instances:
927
          bep = self.cfg.GetClusterInfo().FillBE(instance_cfg[instance])
928
          if bep[constants.BE_AUTO_BALANCE]:
929
            needed_mem += bep[constants.BE_MEMORY]
930
        if nodeinfo['mfree'] < needed_mem:
931
          feedback_fn("  - ERROR: not enough memory on node %s to accomodate"
932
                      " failovers should node %s fail" % (node, prinode))
933
          bad = True
934
    return bad
935

    
936
  def CheckPrereq(self):
937
    """Check prerequisites.
938

939
    Transform the list of checks we're going to skip into a set and check that
940
    all its members are valid.
941

942
    """
943
    self.skip_set = frozenset(self.op.skip_checks)
944
    if not constants.VERIFY_OPTIONAL_CHECKS.issuperset(self.skip_set):
945
      raise errors.OpPrereqError("Invalid checks to be skipped specified")
946

    
947
  def BuildHooksEnv(self):
948
    """Build hooks env.
949

950
    Cluster-Verify hooks just rone in the post phase and their failure makes
951
    the output be logged in the verify output and the verification to fail.
952

953
    """
954
    all_nodes = self.cfg.GetNodeList()
955
    env = {
956
      "CLUSTER_TAGS": " ".join(self.cfg.GetClusterInfo().GetTags())
957
      }
958
    for node in self.cfg.GetAllNodesInfo().values():
959
      env["NODE_TAGS_%s" % node.name] = " ".join(node.GetTags())
960

    
961
    return env, [], all_nodes
962

    
963
  def Exec(self, feedback_fn):
964
    """Verify integrity of cluster, performing various test on nodes.
965

966
    """
967
    bad = False
968
    feedback_fn("* Verifying global settings")
969
    for msg in self.cfg.VerifyConfig():
970
      feedback_fn("  - ERROR: %s" % msg)
971

    
972
    vg_name = self.cfg.GetVGName()
973
    hypervisors = self.cfg.GetClusterInfo().enabled_hypervisors
974
    nodelist = utils.NiceSort(self.cfg.GetNodeList())
975
    nodeinfo = [self.cfg.GetNodeInfo(nname) for nname in nodelist]
976
    instancelist = utils.NiceSort(self.cfg.GetInstanceList())
977
    instanceinfo = dict((iname, self.cfg.GetInstanceInfo(iname))
978
                        for iname in instancelist)
979
    i_non_redundant = [] # Non redundant instances
980
    i_non_a_balanced = [] # Non auto-balanced instances
981
    n_offline = [] # List of offline nodes
982
    n_drained = [] # List of nodes being drained
983
    node_volume = {}
984
    node_instance = {}
985
    node_info = {}
986
    instance_cfg = {}
987

    
988
    # FIXME: verify OS list
989
    # do local checksums
990
    master_files = [constants.CLUSTER_CONF_FILE]
991

    
992
    file_names = ssconf.SimpleStore().GetFileList()
993
    file_names.append(constants.SSL_CERT_FILE)
994
    file_names.append(constants.RAPI_CERT_FILE)
995
    file_names.extend(master_files)
996

    
997
    local_checksums = utils.FingerprintFiles(file_names)
998

    
999
    feedback_fn("* Gathering data (%d nodes)" % len(nodelist))
1000
    node_verify_param = {
1001
      constants.NV_FILELIST: file_names,
1002
      constants.NV_NODELIST: [node.name for node in nodeinfo
1003
                              if not node.offline],
1004
      constants.NV_HYPERVISOR: hypervisors,
1005
      constants.NV_NODENETTEST: [(node.name, node.primary_ip,
1006
                                  node.secondary_ip) for node in nodeinfo
1007
                                 if not node.offline],
1008
      constants.NV_INSTANCELIST: hypervisors,
1009
      constants.NV_VERSION: None,
1010
      constants.NV_HVINFO: self.cfg.GetHypervisorType(),
1011
      }
1012
    if vg_name is not None:
1013
      node_verify_param[constants.NV_VGLIST] = None
1014
      node_verify_param[constants.NV_LVLIST] = vg_name
1015
      node_verify_param[constants.NV_DRBDLIST] = None
1016
    all_nvinfo = self.rpc.call_node_verify(nodelist, node_verify_param,
1017
                                           self.cfg.GetClusterName())
1018

    
1019
    cluster = self.cfg.GetClusterInfo()
1020
    master_node = self.cfg.GetMasterNode()
1021
    all_drbd_map = self.cfg.ComputeDRBDMap()
1022

    
1023
    for node_i in nodeinfo:
1024
      node = node_i.name
1025
      nresult = all_nvinfo[node].data
1026

    
1027
      if node_i.offline:
1028
        feedback_fn("* Skipping offline node %s" % (node,))
1029
        n_offline.append(node)
1030
        continue
1031

    
1032
      if node == master_node:
1033
        ntype = "master"
1034
      elif node_i.master_candidate:
1035
        ntype = "master candidate"
1036
      elif node_i.drained:
1037
        ntype = "drained"
1038
        n_drained.append(node)
1039
      else:
1040
        ntype = "regular"
1041
      feedback_fn("* Verifying node %s (%s)" % (node, ntype))
1042

    
1043
      if all_nvinfo[node].failed or not isinstance(nresult, dict):
1044
        feedback_fn("  - ERROR: connection to %s failed" % (node,))
1045
        bad = True
1046
        continue
1047

    
1048
      node_drbd = {}
1049
      for minor, instance in all_drbd_map[node].items():
1050
        if instance not in instanceinfo:
1051
          feedback_fn("  - ERROR: ghost instance '%s' in temporary DRBD map" %
1052
                      instance)
1053
          # ghost instance should not be running, but otherwise we
1054
          # don't give double warnings (both ghost instance and
1055
          # unallocated minor in use)
1056
          node_drbd[minor] = (instance, False)
1057
        else:
1058
          instance = instanceinfo[instance]
1059
          node_drbd[minor] = (instance.name, instance.admin_up)
1060
      result = self._VerifyNode(node_i, file_names, local_checksums,
1061
                                nresult, feedback_fn, master_files,
1062
                                node_drbd, vg_name)
1063
      bad = bad or result
1064

    
1065
      lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")
1066
      if vg_name is None:
1067
        node_volume[node] = {}
1068
      elif isinstance(lvdata, basestring):
1069
        feedback_fn("  - ERROR: LVM problem on node %s: %s" %
1070
                    (node, utils.SafeEncode(lvdata)))
1071
        bad = True
1072
        node_volume[node] = {}
1073
      elif not isinstance(lvdata, dict):
1074
        feedback_fn("  - ERROR: connection to %s failed (lvlist)" % (node,))
1075
        bad = True
1076
        continue
1077
      else:
1078
        node_volume[node] = lvdata
1079

    
1080
      # node_instance
1081
      idata = nresult.get(constants.NV_INSTANCELIST, None)
1082
      if not isinstance(idata, list):
1083
        feedback_fn("  - ERROR: connection to %s failed (instancelist)" %
1084
                    (node,))
1085
        bad = True
1086
        continue
1087

    
1088
      node_instance[node] = idata
1089

    
1090
      # node_info
1091
      nodeinfo = nresult.get(constants.NV_HVINFO, None)
1092
      if not isinstance(nodeinfo, dict):
1093
        feedback_fn("  - ERROR: connection to %s failed (hvinfo)" % (node,))
1094
        bad = True
1095
        continue
1096

    
1097
      try:
1098
        node_info[node] = {
1099
          "mfree": int(nodeinfo['memory_free']),
1100
          "pinst": [],
1101
          "sinst": [],
1102
          # dictionary holding all instances this node is secondary for,
1103
          # grouped by their primary node. Each key is a cluster node, and each
1104
          # value is a list of instances which have the key as primary and the
1105
          # current node as secondary.  this is handy to calculate N+1 memory
1106
          # availability if you can only failover from a primary to its
1107
          # secondary.
1108
          "sinst-by-pnode": {},
1109
        }
1110
        # FIXME: devise a free space model for file based instances as well
1111
        if vg_name is not None:
1112
          if (constants.NV_VGLIST not in nresult or
1113
              vg_name not in nresult[constants.NV_VGLIST]):
1114
            feedback_fn("  - ERROR: node %s didn't return data for the"
1115
                        " volume group '%s' - it is either missing or broken" %
1116
                        (node, vg_name))
1117
            bad = True
1118
            continue
1119
          node_info[node]["dfree"] = int(nresult[constants.NV_VGLIST][vg_name])
1120
      except (ValueError, KeyError):
1121
        feedback_fn("  - ERROR: invalid nodeinfo value returned"
1122
                    " from node %s" % (node,))
1123
        bad = True
1124
        continue
1125

    
1126
    node_vol_should = {}
1127

    
1128
    for instance in instancelist:
1129
      feedback_fn("* Verifying instance %s" % instance)
1130
      inst_config = instanceinfo[instance]
1131
      result =  self._VerifyInstance(instance, inst_config, node_volume,
1132
                                     node_instance, feedback_fn, n_offline)
1133
      bad = bad or result
1134
      inst_nodes_offline = []
1135

    
1136
      inst_config.MapLVsByNode(node_vol_should)
1137

    
1138
      instance_cfg[instance] = inst_config
1139

    
1140
      pnode = inst_config.primary_node
1141
      if pnode in node_info:
1142
        node_info[pnode]['pinst'].append(instance)
1143
      elif pnode not in n_offline:
1144
        feedback_fn("  - ERROR: instance %s, connection to primary node"
1145
                    " %s failed" % (instance, pnode))
1146
        bad = True
1147

    
1148
      if pnode in n_offline:
1149
        inst_nodes_offline.append(pnode)
1150

    
1151
      # If the instance is non-redundant we cannot survive losing its primary
1152
      # node, so we are not N+1 compliant. On the other hand we have no disk
1153
      # templates with more than one secondary so that situation is not well
1154
      # supported either.
1155
      # FIXME: does not support file-backed instances
1156
      if len(inst_config.secondary_nodes) == 0:
1157
        i_non_redundant.append(instance)
1158
      elif len(inst_config.secondary_nodes) > 1:
1159
        feedback_fn("  - WARNING: multiple secondaries for instance %s"
1160
                    % instance)
1161

    
1162
      if not cluster.FillBE(inst_config)[constants.BE_AUTO_BALANCE]:
1163
        i_non_a_balanced.append(instance)
1164

    
1165
      for snode in inst_config.secondary_nodes:
1166
        if snode in node_info:
1167
          node_info[snode]['sinst'].append(instance)
1168
          if pnode not in node_info[snode]['sinst-by-pnode']:
1169
            node_info[snode]['sinst-by-pnode'][pnode] = []
1170
          node_info[snode]['sinst-by-pnode'][pnode].append(instance)
1171
        elif snode not in n_offline:
1172
          feedback_fn("  - ERROR: instance %s, connection to secondary node"
1173
                      " %s failed" % (instance, snode))
1174
          bad = True
1175
        if snode in n_offline:
1176
          inst_nodes_offline.append(snode)
1177

    
1178
      if inst_nodes_offline:
1179
        # warn that the instance lives on offline nodes, and set bad=True
1180
        feedback_fn("  - ERROR: instance lives on offline node(s) %s" %
1181
                    ", ".join(inst_nodes_offline))
1182
        bad = True
1183

    
1184
    feedback_fn("* Verifying orphan volumes")
1185
    result = self._VerifyOrphanVolumes(node_vol_should, node_volume,
1186
                                       feedback_fn)
1187
    bad = bad or result
1188

    
1189
    feedback_fn("* Verifying remaining instances")
1190
    result = self._VerifyOrphanInstances(instancelist, node_instance,
1191
                                         feedback_fn)
1192
    bad = bad or result
1193

    
1194
    if constants.VERIFY_NPLUSONE_MEM not in self.skip_set:
1195
      feedback_fn("* Verifying N+1 Memory redundancy")
1196
      result = self._VerifyNPlusOneMemory(node_info, instance_cfg, feedback_fn)
1197
      bad = bad or result
1198

    
1199
    feedback_fn("* Other Notes")
1200
    if i_non_redundant:
1201
      feedback_fn("  - NOTICE: %d non-redundant instance(s) found."
1202
                  % len(i_non_redundant))
1203

    
1204
    if i_non_a_balanced:
1205
      feedback_fn("  - NOTICE: %d non-auto-balanced instance(s) found."
1206
                  % len(i_non_a_balanced))
1207

    
1208
    if n_offline:
1209
      feedback_fn("  - NOTICE: %d offline node(s) found." % len(n_offline))
1210

    
1211
    if n_drained:
1212
      feedback_fn("  - NOTICE: %d drained node(s) found." % len(n_drained))
1213

    
1214
    return not bad
1215

    
1216
  def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):
1217
    """Analize the post-hooks' result
1218

1219
    This method analyses the hook result, handles it, and sends some
1220
    nicely-formatted feedback back to the user.
1221

1222
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
1223
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
1224
    @param hooks_results: the results of the multi-node hooks rpc call
1225
    @param feedback_fn: function used send feedback back to the caller
1226
    @param lu_result: previous Exec result
1227
    @return: the new Exec result, based on the previous result
1228
        and hook results
1229

1230
    """
1231
    # We only really run POST phase hooks, and are only interested in
1232
    # their results
1233
    if phase == constants.HOOKS_PHASE_POST:
1234
      # Used to change hooks' output to proper indentation
1235
      indent_re = re.compile('^', re.M)
1236
      feedback_fn("* Hooks Results")
1237
      if not hooks_results:
1238
        feedback_fn("  - ERROR: general communication failure")
1239
        lu_result = 1
1240
      else:
1241
        for node_name in hooks_results:
1242
          show_node_header = True
1243
          res = hooks_results[node_name]
1244
          if res.failed or res.data is False or not isinstance(res.data, list):
1245
            if res.offline:
1246
              # no need to warn or set fail return value
1247
              continue
1248
            feedback_fn("    Communication failure in hooks execution")
1249
            lu_result = 1
1250
            continue
1251
          for script, hkr, output in res.data:
1252
            if hkr == constants.HKR_FAIL:
1253
              # The node header is only shown once, if there are
1254
              # failing hooks on that node
1255
              if show_node_header:
1256
                feedback_fn("  Node %s:" % node_name)
1257
                show_node_header = False
1258
              feedback_fn("    ERROR: Script %s failed, output:" % script)
1259
              output = indent_re.sub('      ', output)
1260
              feedback_fn("%s" % output)
1261
              lu_result = 1
1262

    
1263
      return lu_result
1264

    
1265

    
1266
class LUVerifyDisks(NoHooksLU):
1267
  """Verifies the cluster disks status.
1268

1269
  """
1270
  _OP_REQP = []
1271
  REQ_BGL = False
1272

    
1273
  def ExpandNames(self):
1274
    self.needed_locks = {
1275
      locking.LEVEL_NODE: locking.ALL_SET,
1276
      locking.LEVEL_INSTANCE: locking.ALL_SET,
1277
    }
1278
    self.share_locks = dict(((i, 1) for i in locking.LEVELS))
1279

    
1280
  def CheckPrereq(self):
1281
    """Check prerequisites.
1282

1283
    This has no prerequisites.
1284

1285
    """
1286
    pass
1287

    
1288
  def Exec(self, feedback_fn):
1289
    """Verify integrity of cluster disks.
1290

1291
    @rtype: tuple of three items
1292
    @return: a tuple of (dict of node-to-node_error, list of instances
1293
        which need activate-disks, dict of instance: (node, volume) for
1294
        missing volumes
1295

1296
    """
1297
    result = res_nodes, res_instances, res_missing = {}, [], {}
1298

    
1299
    vg_name = self.cfg.GetVGName()
1300
    nodes = utils.NiceSort(self.cfg.GetNodeList())
1301
    instances = [self.cfg.GetInstanceInfo(name)
1302
                 for name in self.cfg.GetInstanceList()]
1303

    
1304
    nv_dict = {}
1305
    for inst in instances:
1306
      inst_lvs = {}
1307
      if (not inst.admin_up or
1308
          inst.disk_template not in constants.DTS_NET_MIRROR):
1309
        continue
1310
      inst.MapLVsByNode(inst_lvs)
1311
      # transform { iname: {node: [vol,],},} to {(node, vol): iname}
1312
      for node, vol_list in inst_lvs.iteritems():
1313
        for vol in vol_list:
1314
          nv_dict[(node, vol)] = inst
1315

    
1316
    if not nv_dict:
1317
      return result
1318

    
1319
    node_lvs = self.rpc.call_volume_list(nodes, vg_name)
1320

    
1321
    to_act = set()
1322
    for node in nodes:
1323
      # node_volume
1324
      node_res = node_lvs[node]
1325
      if node_res.offline:
1326
        continue
1327
      msg = node_res.RemoteFailMsg()
1328
      if msg:
1329
        logging.warning("Error enumerating LVs on node %s: %s", node, msg)
1330
        res_nodes[node] = msg
1331
        continue
1332

    
1333
      lvs = node_res.payload
1334
      for lv_name, (_, lv_inactive, lv_online) in lvs.items():
1335
        inst = nv_dict.pop((node, lv_name), None)
1336
        if (not lv_online and inst is not None
1337
            and inst.name not in res_instances):
1338
          res_instances.append(inst.name)
1339

    
1340
    # any leftover items in nv_dict are missing LVs, let's arrange the
1341
    # data better
1342
    for key, inst in nv_dict.iteritems():
1343
      if inst.name not in res_missing:
1344
        res_missing[inst.name] = []
1345
      res_missing[inst.name].append(key)
1346

    
1347
    return result
1348

    
1349

    
1350
class LURenameCluster(LogicalUnit):
1351
  """Rename the cluster.
1352

1353
  """
1354
  HPATH = "cluster-rename"
1355
  HTYPE = constants.HTYPE_CLUSTER
1356
  _OP_REQP = ["name"]
1357

    
1358
  def BuildHooksEnv(self):
1359
    """Build hooks env.
1360

1361
    """
1362
    env = {
1363
      "OP_TARGET": self.cfg.GetClusterName(),
1364
      "NEW_NAME": self.op.name,
1365
      }
1366
    mn = self.cfg.GetMasterNode()
1367
    return env, [mn], [mn]
1368

    
1369
  def CheckPrereq(self):
1370
    """Verify that the passed name is a valid one.
1371

1372
    """
1373
    hostname = utils.HostInfo(self.op.name)
1374

    
1375
    new_name = hostname.name
1376
    self.ip = new_ip = hostname.ip
1377
    old_name = self.cfg.GetClusterName()
1378
    old_ip = self.cfg.GetMasterIP()
1379
    if new_name == old_name and new_ip == old_ip:
1380
      raise errors.OpPrereqError("Neither the name nor the IP address of the"
1381
                                 " cluster has changed")
1382
    if new_ip != old_ip:
1383
      if utils.TcpPing(new_ip, constants.DEFAULT_NODED_PORT):
1384
        raise errors.OpPrereqError("The given cluster IP address (%s) is"
1385
                                   " reachable on the network. Aborting." %
1386
                                   new_ip)
1387

    
1388
    self.op.name = new_name
1389

    
1390
  def Exec(self, feedback_fn):
1391
    """Rename the cluster.
1392

1393
    """
1394
    clustername = self.op.name
1395
    ip = self.ip
1396

    
1397
    # shutdown the master IP
1398
    master = self.cfg.GetMasterNode()
1399
    result = self.rpc.call_node_stop_master(master, False)
1400
    if result.failed or not result.data:
1401
      raise errors.OpExecError("Could not disable the master role")
1402

    
1403
    try:
1404
      cluster = self.cfg.GetClusterInfo()
1405
      cluster.cluster_name = clustername
1406
      cluster.master_ip = ip
1407
      self.cfg.Update(cluster)
1408

    
1409
      # update the known hosts file
1410
      ssh.WriteKnownHostsFile(self.cfg, constants.SSH_KNOWN_HOSTS_FILE)
1411
      node_list = self.cfg.GetNodeList()
1412
      try:
1413
        node_list.remove(master)
1414
      except ValueError:
1415
        pass
1416
      result = self.rpc.call_upload_file(node_list,
1417
                                         constants.SSH_KNOWN_HOSTS_FILE)
1418
      for to_node, to_result in result.iteritems():
1419
         msg = to_result.RemoteFailMsg()
1420
         if msg:
1421
           msg = ("Copy of file %s to node %s failed: %s" %
1422
                   (constants.SSH_KNOWN_HOSTS_FILE, to_node, msg))
1423
           self.proc.LogWarning(msg)
1424

    
1425
    finally:
1426
      result = self.rpc.call_node_start_master(master, False)
1427
      if result.failed or not result.data:
1428
        self.LogWarning("Could not re-enable the master role on"
1429
                        " the master, please restart manually.")
1430

    
1431

    
1432
def _RecursiveCheckIfLVMBased(disk):
1433
  """Check if the given disk or its children are lvm-based.
1434

1435
  @type disk: L{objects.Disk}
1436
  @param disk: the disk to check
1437
  @rtype: booleean
1438
  @return: boolean indicating whether a LD_LV dev_type was found or not
1439

1440
  """
1441
  if disk.children:
1442
    for chdisk in disk.children:
1443
      if _RecursiveCheckIfLVMBased(chdisk):
1444
        return True
1445
  return disk.dev_type == constants.LD_LV
1446

    
1447

    
1448
class LUSetClusterParams(LogicalUnit):
1449
  """Change the parameters of the cluster.
1450

1451
  """
1452
  HPATH = "cluster-modify"
1453
  HTYPE = constants.HTYPE_CLUSTER
1454
  _OP_REQP = []
1455
  REQ_BGL = False
1456

    
1457
  def CheckArguments(self):
1458
    """Check parameters
1459

1460
    """
1461
    if not hasattr(self.op, "candidate_pool_size"):
1462
      self.op.candidate_pool_size = None
1463
    if self.op.candidate_pool_size is not None:
1464
      try:
1465
        self.op.candidate_pool_size = int(self.op.candidate_pool_size)
1466
      except (ValueError, TypeError), err:
1467
        raise errors.OpPrereqError("Invalid candidate_pool_size value: %s" %
1468
                                   str(err))
1469
      if self.op.candidate_pool_size < 1:
1470
        raise errors.OpPrereqError("At least one master candidate needed")
1471

    
1472
  def ExpandNames(self):
1473
    # FIXME: in the future maybe other cluster params won't require checking on
1474
    # all nodes to be modified.
1475
    self.needed_locks = {
1476
      locking.LEVEL_NODE: locking.ALL_SET,
1477
    }
1478
    self.share_locks[locking.LEVEL_NODE] = 1
1479

    
1480
  def BuildHooksEnv(self):
1481
    """Build hooks env.
1482

1483
    """
1484
    env = {
1485
      "OP_TARGET": self.cfg.GetClusterName(),
1486
      "NEW_VG_NAME": self.op.vg_name,
1487
      }
1488
    mn = self.cfg.GetMasterNode()
1489
    return env, [mn], [mn]
1490

    
1491
  def CheckPrereq(self):
1492
    """Check prerequisites.
1493

1494
    This checks whether the given params don't conflict and
1495
    if the given volume group is valid.
1496

1497
    """
1498
    if self.op.vg_name is not None and not self.op.vg_name:
1499
      instances = self.cfg.GetAllInstancesInfo().values()
1500
      for inst in instances:
1501
        for disk in inst.disks:
1502
          if _RecursiveCheckIfLVMBased(disk):
1503
            raise errors.OpPrereqError("Cannot disable lvm storage while"
1504
                                       " lvm-based instances exist")
1505

    
1506
    node_list = self.acquired_locks[locking.LEVEL_NODE]
1507

    
1508
    # if vg_name not None, checks given volume group on all nodes
1509
    if self.op.vg_name:
1510
      vglist = self.rpc.call_vg_list(node_list)
1511
      for node in node_list:
1512
        msg = vglist[node].RemoteFailMsg()
1513
        if msg:
1514
          # ignoring down node
1515
          self.LogWarning("Error while gathering data on node %s"
1516
                          " (ignoring node): %s", node, msg)
1517
          continue
1518
        vgstatus = utils.CheckVolumeGroupSize(vglist[node].payload,
1519
                                              self.op.vg_name,
1520
                                              constants.MIN_VG_SIZE)
1521
        if vgstatus:
1522
          raise errors.OpPrereqError("Error on node '%s': %s" %
1523
                                     (node, vgstatus))
1524

    
1525
    self.cluster = cluster = self.cfg.GetClusterInfo()
1526
    # validate params changes
1527
    if self.op.beparams:
1528
      utils.ForceDictType(self.op.beparams, constants.BES_PARAMETER_TYPES)
1529
      self.new_beparams = objects.FillDict(
1530
        cluster.beparams[constants.PP_DEFAULT], self.op.beparams)
1531

    
1532
    if self.op.nicparams:
1533
      utils.ForceDictType(self.op.nicparams, constants.NICS_PARAMETER_TYPES)
1534
      self.new_nicparams = objects.FillDict(
1535
        cluster.nicparams[constants.PP_DEFAULT], self.op.nicparams)
1536
      objects.NIC.CheckParameterSyntax(self.new_nicparams)
1537

    
1538
    # hypervisor list/parameters
1539
    self.new_hvparams = objects.FillDict(cluster.hvparams, {})
1540
    if self.op.hvparams:
1541
      if not isinstance(self.op.hvparams, dict):
1542
        raise errors.OpPrereqError("Invalid 'hvparams' parameter on input")
1543
      for hv_name, hv_dict in self.op.hvparams.items():
1544
        if hv_name not in self.new_hvparams:
1545
          self.new_hvparams[hv_name] = hv_dict
1546
        else:
1547
          self.new_hvparams[hv_name].update(hv_dict)
1548

    
1549
    if self.op.enabled_hypervisors is not None:
1550
      self.hv_list = self.op.enabled_hypervisors
1551
    else:
1552
      self.hv_list = cluster.enabled_hypervisors
1553

    
1554
    if self.op.hvparams or self.op.enabled_hypervisors is not None:
1555
      # either the enabled list has changed, or the parameters have, validate
1556
      for hv_name, hv_params in self.new_hvparams.items():
1557
        if ((self.op.hvparams and hv_name in self.op.hvparams) or
1558
            (self.op.enabled_hypervisors and
1559
             hv_name in self.op.enabled_hypervisors)):
1560
          # either this is a new hypervisor, or its parameters have changed
1561
          hv_class = hypervisor.GetHypervisor(hv_name)
1562
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
1563
          hv_class.CheckParameterSyntax(hv_params)
1564
          _CheckHVParams(self, node_list, hv_name, hv_params)
1565

    
1566
  def Exec(self, feedback_fn):
1567
    """Change the parameters of the cluster.
1568

1569
    """
1570
    if self.op.vg_name is not None:
1571
      new_volume = self.op.vg_name
1572
      if not new_volume:
1573
        new_volume = None
1574
      if new_volume != self.cfg.GetVGName():
1575
        self.cfg.SetVGName(new_volume)
1576
      else:
1577
        feedback_fn("Cluster LVM configuration already in desired"
1578
                    " state, not changing")
1579
    if self.op.hvparams:
1580
      self.cluster.hvparams = self.new_hvparams
1581
    if self.op.enabled_hypervisors is not None:
1582
      self.cluster.enabled_hypervisors = self.op.enabled_hypervisors
1583
    if self.op.beparams:
1584
      self.cluster.beparams[constants.PP_DEFAULT] = self.new_beparams
1585
    if self.op.nicparams:
1586
      self.cluster.nicparams[constants.PP_DEFAULT] = self.new_nicparams
1587

    
1588
    if self.op.candidate_pool_size is not None:
1589
      self.cluster.candidate_pool_size = self.op.candidate_pool_size
1590

    
1591
    self.cfg.Update(self.cluster)
1592

    
1593
    # we want to update nodes after the cluster so that if any errors
1594
    # happen, we have recorded and saved the cluster info
1595
    if self.op.candidate_pool_size is not None:
1596
      _AdjustCandidatePool(self)
1597

    
1598

    
1599
def _RedistributeAncillaryFiles(lu, additional_nodes=None):
1600
  """Distribute additional files which are part of the cluster configuration.
1601

1602
  ConfigWriter takes care of distributing the config and ssconf files, but
1603
  there are more files which should be distributed to all nodes. This function
1604
  makes sure those are copied.
1605

1606
  @param lu: calling logical unit
1607
  @param additional_nodes: list of nodes not in the config to distribute to
1608

1609
  """
1610
  # 1. Gather target nodes
1611
  myself = lu.cfg.GetNodeInfo(lu.cfg.GetMasterNode())
1612
  dist_nodes = lu.cfg.GetNodeList()
1613
  if additional_nodes is not None:
1614
    dist_nodes.extend(additional_nodes)
1615
  if myself.name in dist_nodes:
1616
    dist_nodes.remove(myself.name)
1617
  # 2. Gather files to distribute
1618
  dist_files = set([constants.ETC_HOSTS,
1619
                    constants.SSH_KNOWN_HOSTS_FILE,
1620
                    constants.RAPI_CERT_FILE,
1621
                    constants.RAPI_USERS_FILE,
1622
                   ])
1623

    
1624
  enabled_hypervisors = lu.cfg.GetClusterInfo().enabled_hypervisors
1625
  for hv_name in enabled_hypervisors:
1626
    hv_class = hypervisor.GetHypervisor(hv_name)
1627
    dist_files.update(hv_class.GetAncillaryFiles())
1628

    
1629
  # 3. Perform the files upload
1630
  for fname in dist_files:
1631
    if os.path.exists(fname):
1632
      result = lu.rpc.call_upload_file(dist_nodes, fname)
1633
      for to_node, to_result in result.items():
1634
         msg = to_result.RemoteFailMsg()
1635
         if msg:
1636
           msg = ("Copy of file %s to node %s failed: %s" %
1637
                   (fname, to_node, msg))
1638
           lu.proc.LogWarning(msg)
1639

    
1640

    
1641
class LURedistributeConfig(NoHooksLU):
1642
  """Force the redistribution of cluster configuration.
1643

1644
  This is a very simple LU.
1645

1646
  """
1647
  _OP_REQP = []
1648
  REQ_BGL = False
1649

    
1650
  def ExpandNames(self):
1651
    self.needed_locks = {
1652
      locking.LEVEL_NODE: locking.ALL_SET,
1653
    }
1654
    self.share_locks[locking.LEVEL_NODE] = 1
1655

    
1656
  def CheckPrereq(self):
1657
    """Check prerequisites.
1658

1659
    """
1660

    
1661
  def Exec(self, feedback_fn):
1662
    """Redistribute the configuration.
1663

1664
    """
1665
    self.cfg.Update(self.cfg.GetClusterInfo())
1666
    _RedistributeAncillaryFiles(self)
1667

    
1668

    
1669
def _WaitForSync(lu, instance, oneshot=False, unlock=False):
1670
  """Sleep and poll for an instance's disk to sync.
1671

1672
  """
1673
  if not instance.disks:
1674
    return True
1675

    
1676
  if not oneshot:
1677
    lu.proc.LogInfo("Waiting for instance %s to sync disks." % instance.name)
1678

    
1679
  node = instance.primary_node
1680

    
1681
  for dev in instance.disks:
1682
    lu.cfg.SetDiskID(dev, node)
1683

    
1684
  retries = 0
1685
  while True:
1686
    max_time = 0
1687
    done = True
1688
    cumul_degraded = False
1689
    rstats = lu.rpc.call_blockdev_getmirrorstatus(node, instance.disks)
1690
    msg = rstats.RemoteFailMsg()
1691
    if msg:
1692
      lu.LogWarning("Can't get any data from node %s: %s", node, msg)
1693
      retries += 1
1694
      if retries >= 10:
1695
        raise errors.RemoteError("Can't contact node %s for mirror data,"
1696
                                 " aborting." % node)
1697
      time.sleep(6)
1698
      continue
1699
    rstats = rstats.payload
1700
    retries = 0
1701
    for i, mstat in enumerate(rstats):
1702
      if mstat is None:
1703
        lu.LogWarning("Can't compute data for node %s/%s",
1704
                           node, instance.disks[i].iv_name)
1705
        continue
1706
      # we ignore the ldisk parameter
1707
      perc_done, est_time, is_degraded, _ = mstat
1708
      cumul_degraded = cumul_degraded or (is_degraded and perc_done is None)
1709
      if perc_done is not None:
1710
        done = False
1711
        if est_time is not None:
1712
          rem_time = "%d estimated seconds remaining" % est_time
1713
          max_time = est_time
1714
        else:
1715
          rem_time = "no time estimate"
1716
        lu.proc.LogInfo("- device %s: %5.2f%% done, %s" %
1717
                        (instance.disks[i].iv_name, perc_done, rem_time))
1718
    if done or oneshot:
1719
      break
1720

    
1721
    time.sleep(min(60, max_time))
1722

    
1723
  if done:
1724
    lu.proc.LogInfo("Instance %s's disks are in sync." % instance.name)
1725
  return not cumul_degraded
1726

    
1727

    
1728
def _CheckDiskConsistency(lu, dev, node, on_primary, ldisk=False):
1729
  """Check that mirrors are not degraded.
1730

1731
  The ldisk parameter, if True, will change the test from the
1732
  is_degraded attribute (which represents overall non-ok status for
1733
  the device(s)) to the ldisk (representing the local storage status).
1734

1735
  """
1736
  lu.cfg.SetDiskID(dev, node)
1737
  if ldisk:
1738
    idx = 6
1739
  else:
1740
    idx = 5
1741

    
1742
  result = True
1743
  if on_primary or dev.AssembleOnSecondary():
1744
    rstats = lu.rpc.call_blockdev_find(node, dev)
1745
    msg = rstats.RemoteFailMsg()
1746
    if msg:
1747
      lu.LogWarning("Can't find disk on node %s: %s", node, msg)
1748
      result = False
1749
    elif not rstats.payload:
1750
      lu.LogWarning("Can't find disk on node %s", node)
1751
      result = False
1752
    else:
1753
      result = result and (not rstats.payload[idx])
1754
  if dev.children:
1755
    for child in dev.children:
1756
      result = result and _CheckDiskConsistency(lu, child, node, on_primary)
1757

    
1758
  return result
1759

    
1760

    
1761
class LUDiagnoseOS(NoHooksLU):
1762
  """Logical unit for OS diagnose/query.
1763

1764
  """
1765
  _OP_REQP = ["output_fields", "names"]
1766
  REQ_BGL = False
1767
  _FIELDS_STATIC = utils.FieldSet()
1768
  _FIELDS_DYNAMIC = utils.FieldSet("name", "valid", "node_status")
1769

    
1770
  def ExpandNames(self):
1771
    if self.op.names:
1772
      raise errors.OpPrereqError("Selective OS query not supported")
1773

    
1774
    _CheckOutputFields(static=self._FIELDS_STATIC,
1775
                       dynamic=self._FIELDS_DYNAMIC,
1776
                       selected=self.op.output_fields)
1777

    
1778
    # Lock all nodes, in shared mode
1779
    # Temporary removal of locks, should be reverted later
1780
    # TODO: reintroduce locks when they are lighter-weight
1781
    self.needed_locks = {}
1782
    #self.share_locks[locking.LEVEL_NODE] = 1
1783
    #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
1784

    
1785
  def CheckPrereq(self):
1786
    """Check prerequisites.
1787

1788
    """
1789

    
1790
  @staticmethod
1791
  def _DiagnoseByOS(node_list, rlist):
1792
    """Remaps a per-node return list into an a per-os per-node dictionary
1793

1794
    @param node_list: a list with the names of all nodes
1795
    @param rlist: a map with node names as keys and OS objects as values
1796

1797
    @rtype: dict
1798
    @return: a dictionary with osnames as keys and as value another map, with
1799
        nodes as keys and list of OS objects as values, eg::
1800

1801
          {"debian-etch": {"node1": [<object>,...],
1802
                           "node2": [<object>,]}
1803
          }
1804

1805
    """
1806
    all_os = {}
1807
    # we build here the list of nodes that didn't fail the RPC (at RPC
1808
    # level), so that nodes with a non-responding node daemon don't
1809
    # make all OSes invalid
1810
    good_nodes = [node_name for node_name in rlist
1811
                  if not rlist[node_name].failed]
1812
    for node_name, nr in rlist.iteritems():
1813
      if nr.failed or not nr.data:
1814
        continue
1815
      for os_obj in nr.data:
1816
        if os_obj.name not in all_os:
1817
          # build a list of nodes for this os containing empty lists
1818
          # for each node in node_list
1819
          all_os[os_obj.name] = {}
1820
          for nname in good_nodes:
1821
            all_os[os_obj.name][nname] = []
1822
        all_os[os_obj.name][node_name].append(os_obj)
1823
    return all_os
1824

    
1825
  def Exec(self, feedback_fn):
1826
    """Compute the list of OSes.
1827

1828
    """
1829
    valid_nodes = [node for node in self.cfg.GetOnlineNodeList()]
1830
    node_data = self.rpc.call_os_diagnose(valid_nodes)
1831
    if node_data == False:
1832
      raise errors.OpExecError("Can't gather the list of OSes")
1833
    pol = self._DiagnoseByOS(valid_nodes, node_data)
1834
    output = []
1835
    for os_name, os_data in pol.iteritems():
1836
      row = []
1837
      for field in self.op.output_fields:
1838
        if field == "name":
1839
          val = os_name
1840
        elif field == "valid":
1841
          val = utils.all([osl and osl[0] for osl in os_data.values()])
1842
        elif field == "node_status":
1843
          val = {}
1844
          for node_name, nos_list in os_data.iteritems():
1845
            val[node_name] = [(v.status, v.path) for v in nos_list]
1846
        else:
1847
          raise errors.ParameterError(field)
1848
        row.append(val)
1849
      output.append(row)
1850

    
1851
    return output
1852

    
1853

    
1854
class LURemoveNode(LogicalUnit):
1855
  """Logical unit for removing a node.
1856

1857
  """
1858
  HPATH = "node-remove"
1859
  HTYPE = constants.HTYPE_NODE
1860
  _OP_REQP = ["node_name"]
1861

    
1862
  def BuildHooksEnv(self):
1863
    """Build hooks env.
1864

1865
    This doesn't run on the target node in the pre phase as a failed
1866
    node would then be impossible to remove.
1867

1868
    """
1869
    env = {
1870
      "OP_TARGET": self.op.node_name,
1871
      "NODE_NAME": self.op.node_name,
1872
      }
1873
    all_nodes = self.cfg.GetNodeList()
1874
    all_nodes.remove(self.op.node_name)
1875
    return env, all_nodes, all_nodes
1876

    
1877
  def CheckPrereq(self):
1878
    """Check prerequisites.
1879

1880
    This checks:
1881
     - the node exists in the configuration
1882
     - it does not have primary or secondary instances
1883
     - it's not the master
1884

1885
    Any errors are signalled by raising errors.OpPrereqError.
1886

1887
    """
1888
    node = self.cfg.GetNodeInfo(self.cfg.ExpandNodeName(self.op.node_name))
1889
    if node is None:
1890
      raise errors.OpPrereqError, ("Node '%s' is unknown." % self.op.node_name)
1891

    
1892
    instance_list = self.cfg.GetInstanceList()
1893

    
1894
    masternode = self.cfg.GetMasterNode()
1895
    if node.name == masternode:
1896
      raise errors.OpPrereqError("Node is the master node,"
1897
                                 " you need to failover first.")
1898

    
1899
    for instance_name in instance_list:
1900
      instance = self.cfg.GetInstanceInfo(instance_name)
1901
      if node.name in instance.all_nodes:
1902
        raise errors.OpPrereqError("Instance %s is still running on the node,"
1903
                                   " please remove first." % instance_name)
1904
    self.op.node_name = node.name
1905
    self.node = node
1906

    
1907
  def Exec(self, feedback_fn):
1908
    """Removes the node from the cluster.
1909

1910
    """
1911
    node = self.node
1912
    logging.info("Stopping the node daemon and removing configs from node %s",
1913
                 node.name)
1914

    
1915
    self.context.RemoveNode(node.name)
1916

    
1917
    self.rpc.call_node_leave_cluster(node.name)
1918

    
1919
    # Promote nodes to master candidate as needed
1920
    _AdjustCandidatePool(self)
1921

    
1922

    
1923
class LUQueryNodes(NoHooksLU):
1924
  """Logical unit for querying nodes.
1925

1926
  """
1927
  _OP_REQP = ["output_fields", "names", "use_locking"]
1928
  REQ_BGL = False
1929
  _FIELDS_DYNAMIC = utils.FieldSet(
1930
    "dtotal", "dfree",
1931
    "mtotal", "mnode", "mfree",
1932
    "bootid",
1933
    "ctotal", "cnodes", "csockets",
1934
    )
1935

    
1936
  _FIELDS_STATIC = utils.FieldSet(
1937
    "name", "pinst_cnt", "sinst_cnt",
1938
    "pinst_list", "sinst_list",
1939
    "pip", "sip", "tags",
1940
    "serial_no",
1941
    "master_candidate",
1942
    "master",
1943
    "offline",
1944
    "drained",
1945
    )
1946

    
1947
  def ExpandNames(self):
1948
    _CheckOutputFields(static=self._FIELDS_STATIC,
1949
                       dynamic=self._FIELDS_DYNAMIC,
1950
                       selected=self.op.output_fields)
1951

    
1952
    self.needed_locks = {}
1953
    self.share_locks[locking.LEVEL_NODE] = 1
1954

    
1955
    if self.op.names:
1956
      self.wanted = _GetWantedNodes(self, self.op.names)
1957
    else:
1958
      self.wanted = locking.ALL_SET
1959

    
1960
    self.do_node_query = self._FIELDS_STATIC.NonMatching(self.op.output_fields)
1961
    self.do_locking = self.do_node_query and self.op.use_locking
1962
    if self.do_locking:
1963
      # if we don't request only static fields, we need to lock the nodes
1964
      self.needed_locks[locking.LEVEL_NODE] = self.wanted
1965

    
1966

    
1967
  def CheckPrereq(self):
1968
    """Check prerequisites.
1969

1970
    """
1971
    # The validation of the node list is done in the _GetWantedNodes,
1972
    # if non empty, and if empty, there's no validation to do
1973
    pass
1974

    
1975
  def Exec(self, feedback_fn):
1976
    """Computes the list of nodes and their attributes.
1977

1978
    """
1979
    all_info = self.cfg.GetAllNodesInfo()
1980
    if self.do_locking:
1981
      nodenames = self.acquired_locks[locking.LEVEL_NODE]
1982
    elif self.wanted != locking.ALL_SET:
1983
      nodenames = self.wanted
1984
      missing = set(nodenames).difference(all_info.keys())
1985
      if missing:
1986
        raise errors.OpExecError(
1987
          "Some nodes were removed before retrieving their data: %s" % missing)
1988
    else:
1989
      nodenames = all_info.keys()
1990

    
1991
    nodenames = utils.NiceSort(nodenames)
1992
    nodelist = [all_info[name] for name in nodenames]
1993

    
1994
    # begin data gathering
1995

    
1996
    if self.do_node_query:
1997
      live_data = {}
1998
      node_data = self.rpc.call_node_info(nodenames, self.cfg.GetVGName(),
1999
                                          self.cfg.GetHypervisorType())
2000
      for name in nodenames:
2001
        nodeinfo = node_data[name]
2002
        if not nodeinfo.failed and nodeinfo.data:
2003
          nodeinfo = nodeinfo.data
2004
          fn = utils.TryConvert
2005
          live_data[name] = {
2006
            "mtotal": fn(int, nodeinfo.get('memory_total', None)),
2007
            "mnode": fn(int, nodeinfo.get('memory_dom0', None)),
2008
            "mfree": fn(int, nodeinfo.get('memory_free', None)),
2009
            "dtotal": fn(int, nodeinfo.get('vg_size', None)),
2010
            "dfree": fn(int, nodeinfo.get('vg_free', None)),
2011
            "ctotal": fn(int, nodeinfo.get('cpu_total', None)),
2012
            "bootid": nodeinfo.get('bootid', None),
2013
            "cnodes": fn(int, nodeinfo.get('cpu_nodes', None)),
2014
            "csockets": fn(int, nodeinfo.get('cpu_sockets', None)),
2015
            }
2016
        else:
2017
          live_data[name] = {}
2018
    else:
2019
      live_data = dict.fromkeys(nodenames, {})
2020

    
2021
    node_to_primary = dict([(name, set()) for name in nodenames])
2022
    node_to_secondary = dict([(name, set()) for name in nodenames])
2023

    
2024
    inst_fields = frozenset(("pinst_cnt", "pinst_list",
2025
                             "sinst_cnt", "sinst_list"))
2026
    if inst_fields & frozenset(self.op.output_fields):
2027
      instancelist = self.cfg.GetInstanceList()
2028

    
2029
      for instance_name in instancelist:
2030
        inst = self.cfg.GetInstanceInfo(instance_name)
2031
        if inst.primary_node in node_to_primary:
2032
          node_to_primary[inst.primary_node].add(inst.name)
2033
        for secnode in inst.secondary_nodes:
2034
          if secnode in node_to_secondary:
2035
            node_to_secondary[secnode].add(inst.name)
2036

    
2037
    master_node = self.cfg.GetMasterNode()
2038

    
2039
    # end data gathering
2040

    
2041
    output = []
2042
    for node in nodelist:
2043
      node_output = []
2044
      for field in self.op.output_fields:
2045
        if field == "name":
2046
          val = node.name
2047
        elif field == "pinst_list":
2048
          val = list(node_to_primary[node.name])
2049
        elif field == "sinst_list":
2050
          val = list(node_to_secondary[node.name])
2051
        elif field == "pinst_cnt":
2052
          val = len(node_to_primary[node.name])
2053
        elif field == "sinst_cnt":
2054
          val = len(node_to_secondary[node.name])
2055
        elif field == "pip":
2056
          val = node.primary_ip
2057
        elif field == "sip":
2058
          val = node.secondary_ip
2059
        elif field == "tags":
2060
          val = list(node.GetTags())
2061
        elif field == "serial_no":
2062
          val = node.serial_no
2063
        elif field == "master_candidate":
2064
          val = node.master_candidate
2065
        elif field == "master":
2066
          val = node.name == master_node
2067
        elif field == "offline":
2068
          val = node.offline
2069
        elif field == "drained":
2070
          val = node.drained
2071
        elif self._FIELDS_DYNAMIC.Matches(field):
2072
          val = live_data[node.name].get(field, None)
2073
        else:
2074
          raise errors.ParameterError(field)
2075
        node_output.append(val)
2076
      output.append(node_output)
2077

    
2078
    return output
2079

    
2080

    
2081
class LUQueryNodeVolumes(NoHooksLU):
2082
  """Logical unit for getting volumes on node(s).
2083

2084
  """
2085
  _OP_REQP = ["nodes", "output_fields"]
2086
  REQ_BGL = False
2087
  _FIELDS_DYNAMIC = utils.FieldSet("phys", "vg", "name", "size", "instance")
2088
  _FIELDS_STATIC = utils.FieldSet("node")
2089

    
2090
  def ExpandNames(self):
2091
    _CheckOutputFields(static=self._FIELDS_STATIC,
2092
                       dynamic=self._FIELDS_DYNAMIC,
2093
                       selected=self.op.output_fields)
2094

    
2095
    self.needed_locks = {}
2096
    self.share_locks[locking.LEVEL_NODE] = 1
2097
    if not self.op.nodes:
2098
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
2099
    else:
2100
      self.needed_locks[locking.LEVEL_NODE] = \
2101
        _GetWantedNodes(self, self.op.nodes)
2102

    
2103
  def CheckPrereq(self):
2104
    """Check prerequisites.
2105

2106
    This checks that the fields required are valid output fields.
2107

2108
    """
2109
    self.nodes = self.acquired_locks[locking.LEVEL_NODE]
2110

    
2111
  def Exec(self, feedback_fn):
2112
    """Computes the list of nodes and their attributes.
2113

2114
    """
2115
    nodenames = self.nodes
2116
    volumes = self.rpc.call_node_volumes(nodenames)
2117

    
2118
    ilist = [self.cfg.GetInstanceInfo(iname) for iname
2119
             in self.cfg.GetInstanceList()]
2120

    
2121
    lv_by_node = dict([(inst, inst.MapLVsByNode()) for inst in ilist])
2122

    
2123
    output = []
2124
    for node in nodenames:
2125
      if node not in volumes or volumes[node].failed or not volumes[node].data:
2126
        continue
2127

    
2128
      node_vols = volumes[node].data[:]
2129
      node_vols.sort(key=lambda vol: vol['dev'])
2130

    
2131
      for vol in node_vols:
2132
        node_output = []
2133
        for field in self.op.output_fields:
2134
          if field == "node":
2135
            val = node
2136
          elif field == "phys":
2137
            val = vol['dev']
2138
          elif field == "vg":
2139
            val = vol['vg']
2140
          elif field == "name":
2141
            val = vol['name']
2142
          elif field == "size":
2143
            val = int(float(vol['size']))
2144
          elif field == "instance":
2145
            for inst in ilist:
2146
              if node not in lv_by_node[inst]:
2147
                continue
2148
              if vol['name'] in lv_by_node[inst][node]:
2149
                val = inst.name
2150
                break
2151
            else:
2152
              val = '-'
2153
          else:
2154
            raise errors.ParameterError(field)
2155
          node_output.append(str(val))
2156

    
2157
        output.append(node_output)
2158

    
2159
    return output
2160

    
2161

    
2162
class LUAddNode(LogicalUnit):
2163
  """Logical unit for adding node to the cluster.
2164

2165
  """
2166
  HPATH = "node-add"
2167
  HTYPE = constants.HTYPE_NODE
2168
  _OP_REQP = ["node_name"]
2169

    
2170
  def BuildHooksEnv(self):
2171
    """Build hooks env.
2172

2173
    This will run on all nodes before, and on all nodes + the new node after.
2174

2175
    """
2176
    env = {
2177
      "OP_TARGET": self.op.node_name,
2178
      "NODE_NAME": self.op.node_name,
2179
      "NODE_PIP": self.op.primary_ip,
2180
      "NODE_SIP": self.op.secondary_ip,
2181
      }
2182
    nodes_0 = self.cfg.GetNodeList()
2183
    nodes_1 = nodes_0 + [self.op.node_name, ]
2184
    return env, nodes_0, nodes_1
2185

    
2186
  def CheckPrereq(self):
2187
    """Check prerequisites.
2188

2189
    This checks:
2190
     - the new node is not already in the config
2191
     - it is resolvable
2192
     - its parameters (single/dual homed) matches the cluster
2193

2194
    Any errors are signalled by raising errors.OpPrereqError.
2195

2196
    """
2197
    node_name = self.op.node_name
2198
    cfg = self.cfg
2199

    
2200
    dns_data = utils.HostInfo(node_name)
2201

    
2202
    node = dns_data.name
2203
    primary_ip = self.op.primary_ip = dns_data.ip
2204
    secondary_ip = getattr(self.op, "secondary_ip", None)
2205
    if secondary_ip is None:
2206
      secondary_ip = primary_ip
2207
    if not utils.IsValidIP(secondary_ip):
2208
      raise errors.OpPrereqError("Invalid secondary IP given")
2209
    self.op.secondary_ip = secondary_ip
2210

    
2211
    node_list = cfg.GetNodeList()
2212
    if not self.op.readd and node in node_list:
2213
      raise errors.OpPrereqError("Node %s is already in the configuration" %
2214
                                 node)
2215
    elif self.op.readd and node not in node_list:
2216
      raise errors.OpPrereqError("Node %s is not in the configuration" % node)
2217

    
2218
    for existing_node_name in node_list:
2219
      existing_node = cfg.GetNodeInfo(existing_node_name)
2220

    
2221
      if self.op.readd and node == existing_node_name:
2222
        if (existing_node.primary_ip != primary_ip or
2223
            existing_node.secondary_ip != secondary_ip):
2224
          raise errors.OpPrereqError("Readded node doesn't have the same IP"
2225
                                     " address configuration as before")
2226
        continue
2227

    
2228
      if (existing_node.primary_ip == primary_ip or
2229
          existing_node.secondary_ip == primary_ip or
2230
          existing_node.primary_ip == secondary_ip or
2231
          existing_node.secondary_ip == secondary_ip):
2232
        raise errors.OpPrereqError("New node ip address(es) conflict with"
2233
                                   " existing node %s" % existing_node.name)
2234

    
2235
    # check that the type of the node (single versus dual homed) is the
2236
    # same as for the master
2237
    myself = cfg.GetNodeInfo(self.cfg.GetMasterNode())
2238
    master_singlehomed = myself.secondary_ip == myself.primary_ip
2239
    newbie_singlehomed = secondary_ip == primary_ip
2240
    if master_singlehomed != newbie_singlehomed:
2241
      if master_singlehomed:
2242
        raise errors.OpPrereqError("The master has no private ip but the"
2243
                                   " new node has one")
2244
      else:
2245
        raise errors.OpPrereqError("The master has a private ip but the"
2246
                                   " new node doesn't have one")
2247

    
2248
    # checks reachablity
2249
    if not utils.TcpPing(primary_ip, constants.DEFAULT_NODED_PORT):
2250
      raise errors.OpPrereqError("Node not reachable by ping")
2251

    
2252
    if not newbie_singlehomed:
2253
      # check reachability from my secondary ip to newbie's secondary ip
2254
      if not utils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,
2255
                           source=myself.secondary_ip):
2256
        raise errors.OpPrereqError("Node secondary ip not reachable by TCP"
2257
                                   " based ping to noded port")
2258

    
2259
    cp_size = self.cfg.GetClusterInfo().candidate_pool_size
2260
    mc_now, _ = self.cfg.GetMasterCandidateStats()
2261
    master_candidate = mc_now < cp_size
2262

    
2263
    self.new_node = objects.Node(name=node,
2264
                                 primary_ip=primary_ip,
2265
                                 secondary_ip=secondary_ip,
2266
                                 master_candidate=master_candidate,
2267
                                 offline=False, drained=False)
2268

    
2269
  def Exec(self, feedback_fn):
2270
    """Adds the new node to the cluster.
2271

2272
    """
2273
    new_node = self.new_node
2274
    node = new_node.name
2275

    
2276
    # check connectivity
2277
    result = self.rpc.call_version([node])[node]
2278
    result.Raise()
2279
    if result.data:
2280
      if constants.PROTOCOL_VERSION == result.data:
2281
        logging.info("Communication to node %s fine, sw version %s match",
2282
                     node, result.data)
2283
      else:
2284
        raise errors.OpExecError("Version mismatch master version %s,"
2285
                                 " node version %s" %
2286
                                 (constants.PROTOCOL_VERSION, result.data))
2287
    else:
2288
      raise errors.OpExecError("Cannot get version from the new node")
2289

    
2290
    # setup ssh on node
2291
    logging.info("Copy ssh key to node %s", node)
2292
    priv_key, pub_key, _ = ssh.GetUserFiles(constants.GANETI_RUNAS)
2293
    keyarray = []
2294
    keyfiles = [constants.SSH_HOST_DSA_PRIV, constants.SSH_HOST_DSA_PUB,
2295
                constants.SSH_HOST_RSA_PRIV, constants.SSH_HOST_RSA_PUB,
2296
                priv_key, pub_key]
2297

    
2298
    for i in keyfiles:
2299
      f = open(i, 'r')
2300
      try:
2301
        keyarray.append(f.read())
2302
      finally:
2303
        f.close()
2304

    
2305
    result = self.rpc.call_node_add(node, keyarray[0], keyarray[1],
2306
                                    keyarray[2],
2307
                                    keyarray[3], keyarray[4], keyarray[5])
2308

    
2309
    msg = result.RemoteFailMsg()
2310
    if msg:
2311
      raise errors.OpExecError("Cannot transfer ssh keys to the"
2312
                               " new node: %s" % msg)
2313

    
2314
    # Add node to our /etc/hosts, and add key to known_hosts
2315
    if self.cfg.GetClusterInfo().modify_etc_hosts:
2316
      utils.AddHostToEtcHosts(new_node.name)
2317

    
2318
    if new_node.secondary_ip != new_node.primary_ip:
2319
      result = self.rpc.call_node_has_ip_address(new_node.name,
2320
                                                 new_node.secondary_ip)
2321
      if result.failed or not result.data:
2322
        raise errors.OpExecError("Node claims it doesn't have the secondary ip"
2323
                                 " you gave (%s). Please fix and re-run this"
2324
                                 " command." % new_node.secondary_ip)
2325

    
2326
    node_verify_list = [self.cfg.GetMasterNode()]
2327
    node_verify_param = {
2328
      'nodelist': [node],
2329
      # TODO: do a node-net-test as well?
2330
    }
2331

    
2332
    result = self.rpc.call_node_verify(node_verify_list, node_verify_param,
2333
                                       self.cfg.GetClusterName())
2334
    for verifier in node_verify_list:
2335
      if result[verifier].failed or not result[verifier].data:
2336
        raise errors.OpExecError("Cannot communicate with %s's node daemon"
2337
                                 " for remote verification" % verifier)
2338
      if result[verifier].data['nodelist']:
2339
        for failed in result[verifier].data['nodelist']:
2340
          feedback_fn("ssh/hostname verification failed %s -> %s" %
2341
                      (verifier, result[verifier].data['nodelist'][failed]))
2342
        raise errors.OpExecError("ssh/hostname verification failed.")
2343

    
2344
    if self.op.readd:
2345
      _RedistributeAncillaryFiles(self)
2346
      self.context.ReaddNode(new_node)
2347
    else:
2348
      _RedistributeAncillaryFiles(self, additional_nodes=[node])
2349
      self.context.AddNode(new_node)
2350

    
2351

    
2352
class LUSetNodeParams(LogicalUnit):
2353
  """Modifies the parameters of a node.
2354

2355
  """
2356
  HPATH = "node-modify"
2357
  HTYPE = constants.HTYPE_NODE
2358
  _OP_REQP = ["node_name"]
2359
  REQ_BGL = False
2360

    
2361
  def CheckArguments(self):
2362
    node_name = self.cfg.ExpandNodeName(self.op.node_name)
2363
    if node_name is None:
2364
      raise errors.OpPrereqError("Invalid node name '%s'" % self.op.node_name)
2365
    self.op.node_name = node_name
2366
    _CheckBooleanOpField(self.op, 'master_candidate')
2367
    _CheckBooleanOpField(self.op, 'offline')
2368
    _CheckBooleanOpField(self.op, 'drained')
2369
    all_mods = [self.op.offline, self.op.master_candidate, self.op.drained]
2370
    if all_mods.count(None) == 3:
2371
      raise errors.OpPrereqError("Please pass at least one modification")
2372
    if all_mods.count(True) > 1:
2373
      raise errors.OpPrereqError("Can't set the node into more than one"
2374
                                 " state at the same time")
2375

    
2376
  def ExpandNames(self):
2377
    self.needed_locks = {locking.LEVEL_NODE: self.op.node_name}
2378

    
2379
  def BuildHooksEnv(self):
2380
    """Build hooks env.
2381

2382
    This runs on the master node.
2383

2384
    """
2385
    env = {
2386
      "OP_TARGET": self.op.node_name,
2387
      "MASTER_CANDIDATE": str(self.op.master_candidate),
2388
      "OFFLINE": str(self.op.offline),
2389
      "DRAINED": str(self.op.drained),
2390
      }
2391
    nl = [self.cfg.GetMasterNode(),
2392
          self.op.node_name]
2393
    return env, nl, nl
2394

    
2395
  def CheckPrereq(self):
2396
    """Check prerequisites.
2397

2398
    This only checks the instance list against the existing names.
2399

2400
    """
2401
    node = self.node = self.cfg.GetNodeInfo(self.op.node_name)
2402

    
2403
    if ((self.op.master_candidate == False or self.op.offline == True or
2404
         self.op.drained == True) and node.master_candidate):
2405
      # we will demote the node from master_candidate
2406
      if self.op.node_name == self.cfg.GetMasterNode():
2407
        raise errors.OpPrereqError("The master node has to be a"
2408
                                   " master candidate, online and not drained")
2409
      cp_size = self.cfg.GetClusterInfo().candidate_pool_size
2410
      num_candidates, _ = self.cfg.GetMasterCandidateStats()
2411
      if num_candidates <= cp_size:
2412
        msg = ("Not enough master candidates (desired"
2413
               " %d, new value will be %d)" % (cp_size, num_candidates-1))
2414
        if self.op.force:
2415
          self.LogWarning(msg)
2416
        else:
2417
          raise errors.OpPrereqError(msg)
2418

    
2419
    if (self.op.master_candidate == True and
2420
        ((node.offline and not self.op.offline == False) or
2421
         (node.drained and not self.op.drained == False))):
2422
      raise errors.OpPrereqError("Node '%s' is offline or drained, can't set"
2423
                                 " to master_candidate" % node.name)
2424

    
2425
    return
2426

    
2427
  def Exec(self, feedback_fn):
2428
    """Modifies a node.
2429

2430
    """
2431
    node = self.node
2432

    
2433
    result = []
2434
    changed_mc = False
2435

    
2436
    if self.op.offline is not None:
2437
      node.offline = self.op.offline
2438
      result.append(("offline", str(self.op.offline)))
2439
      if self.op.offline == True:
2440
        if node.master_candidate:
2441
          node.master_candidate = False
2442
          changed_mc = True
2443
          result.append(("master_candidate", "auto-demotion due to offline"))
2444
        if node.drained:
2445
          node.drained = False
2446
          result.append(("drained", "clear drained status due to offline"))
2447

    
2448
    if self.op.master_candidate is not None:
2449
      node.master_candidate = self.op.master_candidate
2450
      changed_mc = True
2451
      result.append(("master_candidate", str(self.op.master_candidate)))
2452
      if self.op.master_candidate == False:
2453
        rrc = self.rpc.call_node_demote_from_mc(node.name)
2454
        msg = rrc.RemoteFailMsg()
2455
        if msg:
2456
          self.LogWarning("Node failed to demote itself: %s" % msg)
2457

    
2458
    if self.op.drained is not None:
2459
      node.drained = self.op.drained
2460
      result.append(("drained", str(self.op.drained)))
2461
      if self.op.drained == True:
2462
        if node.master_candidate:
2463
          node.master_candidate = False
2464
          changed_mc = True
2465
          result.append(("master_candidate", "auto-demotion due to drain"))
2466
        if node.offline:
2467
          node.offline = False
2468
          result.append(("offline", "clear offline status due to drain"))
2469

    
2470
    # this will trigger configuration file update, if needed
2471
    self.cfg.Update(node)
2472
    # this will trigger job queue propagation or cleanup
2473
    if changed_mc:
2474
      self.context.ReaddNode(node)
2475

    
2476
    return result
2477

    
2478

    
2479
class LUPowercycleNode(NoHooksLU):
2480
  """Powercycles a node.
2481

2482
  """
2483
  _OP_REQP = ["node_name", "force"]
2484
  REQ_BGL = False
2485

    
2486
  def CheckArguments(self):
2487
    node_name = self.cfg.ExpandNodeName(self.op.node_name)
2488
    if node_name is None:
2489
      raise errors.OpPrereqError("Invalid node name '%s'" % self.op.node_name)
2490
    self.op.node_name = node_name
2491
    if node_name == self.cfg.GetMasterNode() and not self.op.force:
2492
      raise errors.OpPrereqError("The node is the master and the force"
2493
                                 " parameter was not set")
2494

    
2495
  def ExpandNames(self):
2496
    """Locking for PowercycleNode.
2497

2498
    This is a last-resource option and shouldn't block on other
2499
    jobs. Therefore, we grab no locks.
2500

2501
    """
2502
    self.needed_locks = {}
2503

    
2504
  def CheckPrereq(self):
2505
    """Check prerequisites.
2506

2507
    This LU has no prereqs.
2508

2509
    """
2510
    pass
2511

    
2512
  def Exec(self, feedback_fn):
2513
    """Reboots a node.
2514

2515
    """
2516
    result = self.rpc.call_node_powercycle(self.op.node_name,
2517
                                           self.cfg.GetHypervisorType())
2518
    msg = result.RemoteFailMsg()
2519
    if msg:
2520
      raise errors.OpExecError("Failed to schedule the reboot: %s" % msg)
2521
    return result.payload
2522

    
2523

    
2524
class LUQueryClusterInfo(NoHooksLU):
2525
  """Query cluster configuration.
2526

2527
  """
2528
  _OP_REQP = []
2529
  REQ_BGL = False
2530

    
2531
  def ExpandNames(self):
2532
    self.needed_locks = {}
2533

    
2534
  def CheckPrereq(self):
2535
    """No prerequsites needed for this LU.
2536

2537
    """
2538
    pass
2539

    
2540
  def Exec(self, feedback_fn):
2541
    """Return cluster config.
2542

2543
    """
2544
    cluster = self.cfg.GetClusterInfo()
2545
    result = {
2546
      "software_version": constants.RELEASE_VERSION,
2547
      "protocol_version": constants.PROTOCOL_VERSION,
2548
      "config_version": constants.CONFIG_VERSION,
2549
      "os_api_version": constants.OS_API_VERSION,
2550
      "export_version": constants.EXPORT_VERSION,
2551
      "architecture": (platform.architecture()[0], platform.machine()),
2552
      "name": cluster.cluster_name,
2553
      "master": cluster.master_node,
2554
      "default_hypervisor": cluster.default_hypervisor,
2555
      "enabled_hypervisors": cluster.enabled_hypervisors,
2556
      "hvparams": dict([(hypervisor, cluster.hvparams[hypervisor])
2557
                        for hypervisor in cluster.enabled_hypervisors]),
2558
      "beparams": cluster.beparams,
2559
      "nicparams": cluster.nicparams,
2560
      "candidate_pool_size": cluster.candidate_pool_size,
2561
      "master_netdev": cluster.master_netdev,
2562
      "volume_group_name": cluster.volume_group_name,
2563
      "file_storage_dir": cluster.file_storage_dir,
2564
      }
2565

    
2566
    return result
2567

    
2568

    
2569
class LUQueryConfigValues(NoHooksLU):
2570
  """Return configuration values.
2571

2572
  """
2573
  _OP_REQP = []
2574
  REQ_BGL = False
2575
  _FIELDS_DYNAMIC = utils.FieldSet()
2576
  _FIELDS_STATIC = utils.FieldSet("cluster_name", "master_node", "drain_flag")
2577

    
2578
  def ExpandNames(self):
2579
    self.needed_locks = {}
2580

    
2581
    _CheckOutputFields(static=self._FIELDS_STATIC,
2582
                       dynamic=self._FIELDS_DYNAMIC,
2583
                       selected=self.op.output_fields)
2584

    
2585
  def CheckPrereq(self):
2586
    """No prerequisites.
2587

2588
    """
2589
    pass
2590

    
2591
  def Exec(self, feedback_fn):
2592
    """Dump a representation of the cluster config to the standard output.
2593

2594
    """
2595
    values = []
2596
    for field in self.op.output_fields:
2597
      if field == "cluster_name":
2598
        entry = self.cfg.GetClusterName()
2599
      elif field == "master_node":
2600
        entry = self.cfg.GetMasterNode()
2601
      elif field == "drain_flag":
2602
        entry = os.path.exists(constants.JOB_QUEUE_DRAIN_FILE)
2603
      else:
2604
        raise errors.ParameterError(field)
2605
      values.append(entry)
2606
    return values
2607

    
2608

    
2609
class LUActivateInstanceDisks(NoHooksLU):
2610
  """Bring up an instance's disks.
2611

2612
  """
2613
  _OP_REQP = ["instance_name"]
2614
  REQ_BGL = False
2615

    
2616
  def ExpandNames(self):
2617
    self._ExpandAndLockInstance()
2618
    self.needed_locks[locking.LEVEL_NODE] = []
2619
    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
2620

    
2621
  def DeclareLocks(self, level):
2622
    if level == locking.LEVEL_NODE:
2623
      self._LockInstancesNodes()
2624

    
2625
  def CheckPrereq(self):
2626
    """Check prerequisites.
2627

2628
    This checks that the instance is in the cluster.
2629

2630
    """
2631
    self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
2632
    assert self.instance is not None, \
2633
      "Cannot retrieve locked instance %s" % self.op.instance_name
2634
    _CheckNodeOnline(self, self.instance.primary_node)
2635

    
2636
  def Exec(self, feedback_fn):
2637
    """Activate the disks.
2638

2639
    """
2640
    disks_ok, disks_info = _AssembleInstanceDisks(self, self.instance)
2641
    if not disks_ok:
2642
      raise errors.OpExecError("Cannot activate block devices")
2643

    
2644
    return disks_info
2645

    
2646

    
2647
def _AssembleInstanceDisks(lu, instance, ignore_secondaries=False):
2648
  """Prepare the block devices for an instance.
2649

2650
  This sets up the block devices on all nodes.
2651

2652
  @type lu: L{LogicalUnit}
2653
  @param lu: the logical unit on whose behalf we execute
2654
  @type instance: L{objects.Instance}
2655
  @param instance: the instance for whose disks we assemble
2656
  @type ignore_secondaries: boolean
2657
  @param ignore_secondaries: if true, errors on secondary nodes
2658
      won't result in an error return from the function
2659
  @return: False if the operation failed, otherwise a list of
2660
      (host, instance_visible_name, node_visible_name)
2661
      with the mapping from node devices to instance devices
2662

2663
  """
2664
  device_info = []
2665
  disks_ok = True
2666
  iname = instance.name
2667
  # With the two passes mechanism we try to reduce the window of
2668
  # opportunity for the race condition of switching DRBD to primary
2669
  # before handshaking occured, but we do not eliminate it
2670

    
2671
  # The proper fix would be to wait (with some limits) until the
2672
  # connection has been made and drbd transitions from WFConnection
2673
  # into any other network-connected state (Connected, SyncTarget,
2674
  # SyncSource, etc.)
2675

    
2676
  # 1st pass, assemble on all nodes in secondary mode
2677
  for inst_disk in instance.disks:
2678
    for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):
2679
      lu.cfg.SetDiskID(node_disk, node)
2680
      result = lu.rpc.call_blockdev_assemble(node, node_disk, iname, False)
2681
      msg = result.RemoteFailMsg()
2682
      if msg:
2683
        lu.proc.LogWarning("Could not prepare block device %s on node %s"
2684
                           " (is_primary=False, pass=1): %s",
2685
                           inst_disk.iv_name, node, msg)
2686
        if not ignore_secondaries:
2687
          disks_ok = False
2688

    
2689
  # FIXME: race condition on drbd migration to primary
2690

    
2691
  # 2nd pass, do only the primary node
2692
  for inst_disk in instance.disks:
2693
    for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):
2694
      if node != instance.primary_node:
2695
        continue
2696
      lu.cfg.SetDiskID(node_disk, node)
2697
      result = lu.rpc.call_blockdev_assemble(node, node_disk, iname, True)
2698
      msg = result.RemoteFailMsg()
2699
      if msg:
2700
        lu.proc.LogWarning("Could not prepare block device %s on node %s"
2701
                           " (is_primary=True, pass=2): %s",
2702
                           inst_disk.iv_name, node, msg)
2703
        disks_ok = False
2704
    device_info.append((instance.primary_node, inst_disk.iv_name,
2705
                        result.payload))
2706

    
2707
  # leave the disks configured for the primary node
2708
  # this is a workaround that would be fixed better by
2709
  # improving the logical/physical id handling
2710
  for disk in instance.disks:
2711
    lu.cfg.SetDiskID(disk, instance.primary_node)
2712

    
2713
  return disks_ok, device_info
2714

    
2715

    
2716
def _StartInstanceDisks(lu, instance, force):
2717
  """Start the disks of an instance.
2718

2719
  """
2720
  disks_ok, dummy = _AssembleInstanceDisks(lu, instance,
2721
                                           ignore_secondaries=force)
2722
  if not disks_ok:
2723
    _ShutdownInstanceDisks(lu, instance)
2724
    if force is not None and not force:
2725
      lu.proc.LogWarning("", hint="If the message above refers to a"
2726
                         " secondary node,"
2727
                         " you can retry the operation using '--force'.")
2728
    raise errors.OpExecError("Disk consistency error")
2729

    
2730

    
2731
class LUDeactivateInstanceDisks(NoHooksLU):
2732
  """Shutdown an instance's disks.
2733

2734
  """
2735
  _OP_REQP = ["instance_name"]
2736
  REQ_BGL = False
2737

    
2738
  def ExpandNames(self):
2739
    self._ExpandAndLockInstance()
2740
    self.needed_locks[locking.LEVEL_NODE] = []
2741
    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
2742

    
2743
  def DeclareLocks(self, level):
2744
    if level == locking.LEVEL_NODE:
2745
      self._LockInstancesNodes()
2746

    
2747
  def CheckPrereq(self):
2748
    """Check prerequisites.
2749

2750
    This checks that the instance is in the cluster.
2751

2752
    """
2753
    self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
2754
    assert self.instance is not None, \
2755
      "Cannot retrieve locked instance %s" % self.op.instance_name
2756

    
2757
  def Exec(self, feedback_fn):
2758
    """Deactivate the disks
2759

2760
    """
2761
    instance = self.instance
2762
    _SafeShutdownInstanceDisks(self, instance)
2763

    
2764

    
2765
def _SafeShutdownInstanceDisks(lu, instance):
2766
  """Shutdown block devices of an instance.
2767

2768
  This function checks if an instance is running, before calling
2769
  _ShutdownInstanceDisks.
2770

2771
  """
2772
  ins_l = lu.rpc.call_instance_list([instance.primary_node],
2773
                                      [instance.hypervisor])
2774
  ins_l = ins_l[instance.primary_node]
2775
  if ins_l.failed or not isinstance(ins_l.data, list):
2776
    raise errors.OpExecError("Can't contact node '%s'" %
2777
                             instance.primary_node)
2778

    
2779
  if instance.name in ins_l.data:
2780
    raise errors.OpExecError("Instance is running, can't shutdown"
2781
                             " block devices.")
2782

    
2783
  _ShutdownInstanceDisks(lu, instance)
2784

    
2785

    
2786
def _ShutdownInstanceDisks(lu, instance, ignore_primary=False):
2787
  """Shutdown block devices of an instance.
2788

2789
  This does the shutdown on all nodes of the instance.
2790

2791
  If the ignore_primary is false, errors on the primary node are
2792
  ignored.
2793

2794
  """
2795
  all_result = True
2796
  for disk in instance.disks:
2797
    for node, top_disk in disk.ComputeNodeTree(instance.primary_node):
2798
      lu.cfg.SetDiskID(top_disk, node)
2799
      result = lu.rpc.call_blockdev_shutdown(node, top_disk)
2800
      msg = result.RemoteFailMsg()
2801
      if msg:
2802
        lu.LogWarning("Could not shutdown block device %s on node %s: %s",
2803
                      disk.iv_name, node, msg)
2804
        if not ignore_primary or node != instance.primary_node:
2805
          all_result = False
2806
  return all_result
2807

    
2808

    
2809
def _CheckNodeFreeMemory(lu, node, reason, requested, hypervisor_name):
2810
  """Checks if a node has enough free memory.
2811

2812
  This function check if a given node has the needed amount of free
2813
  memory. In case the node has less memory or we cannot get the
2814
  information from the node, this function raise an OpPrereqError
2815
  exception.
2816

2817
  @type lu: C{LogicalUnit}
2818
  @param lu: a logical unit from which we get configuration data
2819
  @type node: C{str}
2820
  @param node: the node to check
2821
  @type reason: C{str}
2822
  @param reason: string to use in the error message
2823
  @type requested: C{int}
2824
  @param requested: the amount of memory in MiB to check for
2825
  @type hypervisor_name: C{str}
2826
  @param hypervisor_name: the hypervisor to ask for memory stats
2827
  @raise errors.OpPrereqError: if the node doesn't have enough memory, or
2828
      we cannot check the node
2829

2830
  """
2831
  nodeinfo = lu.rpc.call_node_info([node], lu.cfg.GetVGName(), hypervisor_name)
2832
  nodeinfo[node].Raise()
2833
  free_mem = nodeinfo[node].data.get('memory_free')
2834
  if not isinstance(free_mem, int):
2835
    raise errors.OpPrereqError("Can't compute free memory on node %s, result"
2836
                             " was '%s'" % (node, free_mem))
2837
  if requested > free_mem:
2838
    raise errors.OpPrereqError("Not enough memory on node %s for %s:"
2839
                             " needed %s MiB, available %s MiB" %
2840
                             (node, reason, requested, free_mem))
2841

    
2842

    
2843
class LUStartupInstance(LogicalUnit):
2844
  """Starts an instance.
2845

2846
  """
2847
  HPATH = "instance-start"
2848
  HTYPE = constants.HTYPE_INSTANCE
2849
  _OP_REQP = ["instance_name", "force"]
2850
  REQ_BGL = False
2851

    
2852
  def ExpandNames(self):
2853
    self._ExpandAndLockInstance()
2854

    
2855
  def BuildHooksEnv(self):
2856
    """Build hooks env.
2857

2858
    This runs on master, primary and secondary nodes of the instance.
2859

2860
    """
2861
    env = {
2862
      "FORCE": self.op.force,
2863
      }
2864
    env.update(_BuildInstanceHookEnvByObject(self, self.instance))
2865
    nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
2866
    return env, nl, nl
2867

    
2868
  def CheckPrereq(self):
2869
    """Check prerequisites.
2870

2871
    This checks that the instance is in the cluster.
2872

2873
    """
2874
    self.instance = instance = self.cfg.GetInstanceInfo(self.op.instance_name)
2875
    assert self.instance is not None, \
2876
      "Cannot retrieve locked instance %s" % self.op.instance_name
2877

    
2878
    # extra beparams
2879
    self.beparams = getattr(self.op, "beparams", {})
2880
    if self.beparams:
2881
      if not isinstance(self.beparams, dict):
2882
        raise errors.OpPrereqError("Invalid beparams passed: %s, expected"
2883
                                   " dict" % (type(self.beparams), ))
2884
      # fill the beparams dict
2885
      utils.ForceDictType(self.beparams, constants.BES_PARAMETER_TYPES)
2886
      self.op.beparams = self.beparams
2887

    
2888
    # extra hvparams
2889
    self.hvparams = getattr(self.op, "hvparams", {})
2890
    if self.hvparams:
2891
      if not isinstance(self.hvparams, dict):
2892
        raise errors.OpPrereqError("Invalid hvparams passed: %s, expected"
2893
                                   " dict" % (type(self.hvparams), ))
2894

    
2895
      # check hypervisor parameter syntax (locally)
2896
      cluster = self.cfg.GetClusterInfo()
2897
      utils.ForceDictType(self.hvparams, constants.HVS_PARAMETER_TYPES)
2898
      filled_hvp = objects.FillDict(cluster.hvparams[instance.hypervisor],
2899
                                    instance.hvparams)
2900
      filled_hvp.update(self.hvparams)
2901
      hv_type = hypervisor.GetHypervisor(instance.hypervisor)
2902
      hv_type.CheckParameterSyntax(filled_hvp)
2903
      _CheckHVParams(self, instance.all_nodes, instance.hypervisor, filled_hvp)
2904
      self.op.hvparams = self.hvparams
2905

    
2906
    _CheckNodeOnline(self, instance.primary_node)
2907

    
2908
    bep = self.cfg.GetClusterInfo().FillBE(instance)
2909
    # check bridges existance
2910
    _CheckInstanceBridgesExist(self, instance)
2911

    
2912
    remote_info = self.rpc.call_instance_info(instance.primary_node,
2913
                                              instance.name,
2914
                                              instance.hypervisor)
2915
    remote_info.Raise()
2916
    if not remote_info.data:
2917
      _CheckNodeFreeMemory(self, instance.primary_node,
2918
                           "starting instance %s" % instance.name,
2919
                           bep[constants.BE_MEMORY], instance.hypervisor)
2920

    
2921
  def Exec(self, feedback_fn):
2922
    """Start the instance.
2923

2924
    """
2925
    instance = self.instance
2926
    force = self.op.force
2927

    
2928
    self.cfg.MarkInstanceUp(instance.name)
2929

    
2930
    node_current = instance.primary_node
2931

    
2932
    _StartInstanceDisks(self, instance, force)
2933

    
2934
    result = self.rpc.call_instance_start(node_current, instance,
2935
                                          self.hvparams, self.beparams)
2936
    msg = result.RemoteFailMsg()
2937
    if msg:
2938
      _ShutdownInstanceDisks(self, instance)
2939
      raise errors.OpExecError("Could not start instance: %s" % msg)
2940

    
2941

    
2942
class LURebootInstance(LogicalUnit):
2943
  """Reboot an instance.
2944

2945
  """
2946
  HPATH = "instance-reboot"
2947
  HTYPE = constants.HTYPE_INSTANCE
2948
  _OP_REQP = ["instance_name", "ignore_secondaries", "reboot_type"]
2949
  REQ_BGL = False
2950

    
2951
  def ExpandNames(self):
2952
    if self.op.reboot_type not in [constants.INSTANCE_REBOOT_SOFT,
2953
                                   constants.INSTANCE_REBOOT_HARD,
2954
                                   constants.INSTANCE_REBOOT_FULL]:
2955
      raise errors.ParameterError("reboot type not in [%s, %s, %s]" %
2956
                                  (constants.INSTANCE_REBOOT_SOFT,
2957
                                   constants.INSTANCE_REBOOT_HARD,
2958
                                   constants.INSTANCE_REBOOT_FULL))
2959
    self._ExpandAndLockInstance()
2960

    
2961
  def BuildHooksEnv(self):
2962
    """Build hooks env.
2963

2964
    This runs on master, primary and secondary nodes of the instance.
2965

2966
    """
2967
    env = {
2968
      "IGNORE_SECONDARIES": self.op.ignore_secondaries,
2969
      "REBOOT_TYPE": self.op.reboot_type,
2970
      }
2971
    env.update(_BuildInstanceHookEnvByObject(self, self.instance))
2972
    nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
2973
    return env, nl, nl
2974

    
2975
  def CheckPrereq(self):
2976
    """Check prerequisites.
2977

2978
    This checks that the instance is in the cluster.
2979

2980
    """
2981
    self.instance = instance = self.cfg.GetInstanceInfo(self.op.instance_name)
2982
    assert self.instance is not None, \
2983
      "Cannot retrieve locked instance %s" % self.op.instance_name
2984

    
2985
    _CheckNodeOnline(self, instance.primary_node)
2986

    
2987
    # check bridges existance
2988
    _CheckInstanceBridgesExist(self, instance)
2989

    
2990
  def Exec(self, feedback_fn):
2991
    """Reboot the instance.
2992

2993
    """
2994
    instance = self.instance
2995
    ignore_secondaries = self.op.ignore_secondaries
2996
    reboot_type = self.op.reboot_type
2997

    
2998
    node_current = instance.primary_node
2999

    
3000
    if reboot_type in [constants.INSTANCE_REBOOT_SOFT,
3001
                       constants.INSTANCE_REBOOT_HARD]:
3002
      for disk in instance.disks:
3003
        self.cfg.SetDiskID(disk, node_current)
3004
      result = self.rpc.call_instance_reboot(node_current, instance,
3005
                                             reboot_type)
3006
      msg = result.RemoteFailMsg()
3007
      if msg:
3008
        raise errors.OpExecError("Could not reboot instance: %s" % msg)
3009
    else:
3010
      result = self.rpc.call_instance_shutdown(node_current, instance)
3011
      msg = result.RemoteFailMsg()
3012
      if msg:
3013
        raise errors.OpExecError("Could not shutdown instance for"
3014
                                 " full reboot: %s" % msg)
3015
      _ShutdownInstanceDisks(self, instance)
3016
      _StartInstanceDisks(self, instance, ignore_secondaries)
3017
      result = self.rpc.call_instance_start(node_current, instance, None, None)
3018
      msg = result.RemoteFailMsg()
3019
      if msg:
3020
        _ShutdownInstanceDisks(self, instance)
3021
        raise errors.OpExecError("Could not start instance for"
3022
                                 " full reboot: %s" % msg)
3023

    
3024
    self.cfg.MarkInstanceUp(instance.name)
3025

    
3026

    
3027
class LUShutdownInstance(LogicalUnit):
3028
  """Shutdown an instance.
3029

3030
  """
3031
  HPATH = "instance-stop"
3032
  HTYPE = constants.HTYPE_INSTANCE
3033
  _OP_REQP = ["instance_name"]
3034
  REQ_BGL = False
3035

    
3036
  def ExpandNames(self):
3037
    self._ExpandAndLockInstance()
3038

    
3039
  def BuildHooksEnv(self):
3040
    """Build hooks env.
3041

3042
    This runs on master, primary and secondary nodes of the instance.
3043

3044
    """
3045
    env = _BuildInstanceHookEnvByObject(self, self.instance)
3046
    nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
3047
    return env, nl, nl
3048

    
3049
  def CheckPrereq(self):
3050
    """Check prerequisites.
3051

3052
    This checks that the instance is in the cluster.
3053

3054
    """
3055
    self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
3056
    assert self.instance is not None, \
3057
      "Cannot retrieve locked instance %s" % self.op.instance_name
3058
    _CheckNodeOnline(self, self.instance.primary_node)
3059

    
3060
  def Exec(self, feedback_fn):
3061
    """Shutdown the instance.
3062

3063
    """
3064
    instance = self.instance
3065
    node_current = instance.primary_node
3066
    self.cfg.MarkInstanceDown(instance.name)
3067
    result = self.rpc.call_instance_shutdown(node_current, instance)
3068
    msg = result.RemoteFailMsg()
3069
    if msg:
3070
      self.proc.LogWarning("Could not shutdown instance: %s" % msg)
3071

    
3072
    _ShutdownInstanceDisks(self, instance)
3073

    
3074

    
3075
class LUReinstallInstance(LogicalUnit):
3076
  """Reinstall an instance.
3077

3078
  """
3079
  HPATH = "instance-reinstall"
3080
  HTYPE = constants.HTYPE_INSTANCE
3081
  _OP_REQP = ["instance_name"]
3082
  REQ_BGL = False
3083

    
3084
  def ExpandNames(self):
3085
    self._ExpandAndLockInstance()
3086

    
3087
  def BuildHooksEnv(self):
3088
    """Build hooks env.
3089

3090
    This runs on master, primary and secondary nodes of the instance.
3091

3092
    """
3093
    env = _BuildInstanceHookEnvByObject(self, self.instance)
3094
    nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
3095
    return env, nl, nl
3096

    
3097
  def CheckPrereq(self):
3098
    """Check prerequisites.
3099

3100
    This checks that the instance is in the cluster and is not running.
3101

3102
    """
3103
    instance = self.cfg.GetInstanceInfo(self.op.instance_name)
3104
    assert instance is not None, \
3105
      "Cannot retrieve locked instance %s" % self.op.instance_name
3106
    _CheckNodeOnline(self, instance.primary_node)
3107

    
3108
    if instance.disk_template == constants.DT_DISKLESS:
3109
      raise errors.OpPrereqError("Instance '%s' has no disks" %
3110
                                 self.op.instance_name)
3111
    if instance.admin_up:
3112
      raise errors.OpPrereqError("Instance '%s' is marked to be up" %
3113
                                 self.op.instance_name)
3114
    remote_info = self.rpc.call_instance_info(instance.primary_node,
3115
                                              instance.name,
3116
                                              instance.hypervisor)
3117
    remote_info.Raise()
3118
    if remote_info.data:
3119
      raise errors.OpPrereqError("Instance '%s' is running on the node %s" %
3120
                                 (self.op.instance_name,
3121
                                  instance.primary_node))
3122

    
3123
    self.op.os_type = getattr(self.op, "os_type", None)
3124
    if self.op.os_type is not None:
3125
      # OS verification
3126
      pnode = self.cfg.GetNodeInfo(
3127
        self.cfg.ExpandNodeName(instance.primary_node))
3128
      if pnode is None:
3129
        raise errors.OpPrereqError("Primary node '%s' is unknown" %
3130
                                   self.op.pnode)
3131
      result = self.rpc.call_os_get(pnode.name, self.op.os_type)
3132
      result.Raise()
3133
      if not isinstance(result.data, objects.OS):
3134
        raise errors.OpPrereqError("OS '%s' not in supported OS list for"
3135
                                   " primary node"  % self.op.os_type)
3136

    
3137
    self.instance = instance
3138

    
3139
  def Exec(self, feedback_fn):
3140
    """Reinstall the instance.
3141

3142
    """
3143
    inst = self.instance
3144

    
3145
    if self.op.os_type is not None:
3146
      feedback_fn("Changing OS to '%s'..." % self.op.os_type)
3147
      inst.os = self.op.os_type
3148
      self.cfg.Update(inst)
3149

    
3150
    _StartInstanceDisks(self, inst, None)
3151
    try:
3152
      feedback_fn("Running the instance OS create scripts...")
3153
      result = self.rpc.call_instance_os_add(inst.primary_node, inst, True)
3154
      msg = result.RemoteFailMsg()
3155
      if msg:
3156
        raise errors.OpExecError("Could not install OS for instance %s"
3157
                                 " on node %s: %s" %
3158
                                 (inst.name, inst.primary_node, msg))
3159
    finally:
3160
      _ShutdownInstanceDisks(self, inst)
3161

    
3162

    
3163
class LURenameInstance(LogicalUnit):
3164
  """Rename an instance.
3165

3166
  """
3167
  HPATH = "instance-rename"
3168
  HTYPE = constants.HTYPE_INSTANCE
3169
  _OP_REQP = ["instance_name", "new_name"]
3170

    
3171
  def BuildHooksEnv(self):
3172
    """Build hooks env.
3173

3174
    This runs on master, primary and secondary nodes of the instance.
3175

3176
    """
3177
    env = _BuildInstanceHookEnvByObject(self, self.instance)
3178
    env["INSTANCE_NEW_NAME"] = self.op.new_name
3179
    nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
3180
    return env, nl, nl
3181

    
3182
  def CheckPrereq(self):
3183
    """Check prerequisites.
3184

3185
    This checks that the instance is in the cluster and is not running.
3186

3187
    """
3188
    instance = self.cfg.GetInstanceInfo(
3189
      self.cfg.ExpandInstanceName(self.op.instance_name))
3190
    if instance is None:
3191
      raise errors.OpPrereqError("Instance '%s' not known" %
3192
                                 self.op.instance_name)
3193
    _CheckNodeOnline(self, instance.primary_node)
3194

    
3195
    if instance.admin_up:
3196
      raise errors.OpPrereqError("Instance '%s' is marked to be up" %
3197
                                 self.op.instance_name)
3198
    remote_info = self.rpc.call_instance_info(instance.primary_node,
3199
                                              instance.name,
3200
                                              instance.hypervisor)
3201
    remote_info.Raise()
3202
    if remote_info.data:
3203
      raise errors.OpPrereqError("Instance '%s' is running on the node %s" %
3204
                                 (self.op.instance_name,
3205
                                  instance.primary_node))
3206
    self.instance = instance
3207

    
3208
    # new name verification
3209
    name_info = utils.HostInfo(self.op.new_name)
3210

    
3211
    self.op.new_name = new_name = name_info.name
3212
    instance_list = self.cfg.GetInstanceList()
3213
    if new_name in instance_list:
3214
      raise errors.OpPrereqError("Instance '%s' is already in the cluster" %
3215
                                 new_name)
3216

    
3217
    if not getattr(self.op, "ignore_ip", False):
3218
      if utils.TcpPing(name_info.ip, constants.DEFAULT_NODED_PORT):
3219
        raise errors.OpPrereqError("IP %s of instance %s already in use" %
3220
                                   (name_info.ip, new_name))
3221

    
3222

    
3223
  def Exec(self, feedback_fn):
3224
    """Reinstall the instance.
3225

3226
    """
3227
    inst = self.instance
3228
    old_name = inst.name
3229

    
3230
    if inst.disk_template == constants.DT_FILE:
3231
      old_file_storage_dir = os.path.dirname(inst.disks[0].logical_id[1])
3232

    
3233
    self.cfg.RenameInstance(inst.name, self.op.new_name)
3234
    # Change the instance lock. This is definitely safe while we hold the BGL
3235
    self.context.glm.remove(locking.LEVEL_INSTANCE, old_name)
3236
    self.context.glm.add(locking.LEVEL_INSTANCE, self.op.new_name)
3237

    
3238
    # re-read the instance from the configuration after rename
3239
    inst = self.cfg.GetInstanceInfo(self.op.new_name)
3240

    
3241
    if inst.disk_template == constants.DT_FILE:
3242
      new_file_storage_dir = os.path.dirname(inst.disks[0].logical_id[1])
3243
      result = self.rpc.call_file_storage_dir_rename(inst.primary_node,
3244
                                                     old_file_storage_dir,
3245
                                                     new_file_storage_dir)
3246
      result.Raise()
3247
      if not result.data:
3248
        raise errors.OpExecError("Could not connect to node '%s' to rename"
3249
                                 " directory '%s' to '%s' (but the instance"
3250
                                 " has been renamed in Ganeti)" % (
3251
                                 inst.primary_node, old_file_storage_dir,
3252
                                 new_file_storage_dir))
3253

    
3254
      if not result.data[0]:
3255
        raise errors.OpExecError("Could not rename directory '%s' to '%s'"
3256
                                 " (but the instance has been renamed in"
3257
                                 " Ganeti)" % (old_file_storage_dir,
3258
                                               new_file_storage_dir))
3259

    
3260
    _StartInstanceDisks(self, inst, None)
3261
    try:
3262
      result = self.rpc.call_instance_run_rename(inst.primary_node, inst,
3263
                                                 old_name)
3264
      msg = result.RemoteFailMsg()
3265
      if msg:
3266
        msg = ("Could not run OS rename script for instance %s on node %s"
3267
               " (but the instance has been renamed in Ganeti): %s" %
3268
               (inst.name, inst.primary_node, msg))
3269
        self.proc.LogWarning(msg)
3270
    finally:
3271
      _ShutdownInstanceDisks(self, inst)
3272

    
3273

    
3274
class LURemoveInstance(LogicalUnit):
3275
  """Remove an instance.
3276

3277
  """
3278
  HPATH = "instance-remove"
3279
  HTYPE = constants.HTYPE_INSTANCE
3280
  _OP_REQP = ["instance_name", "ignore_failures"]
3281
  REQ_BGL = False
3282

    
3283
  def ExpandNames(self):
3284
    self._ExpandAndLockInstance()
3285
    self.needed_locks[locking.LEVEL_NODE] = []
3286
    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
3287

    
3288
  def DeclareLocks(self, level):
3289
    if level == locking.LEVEL_NODE:
3290
      self._LockInstancesNodes()
3291

    
3292
  def BuildHooksEnv(self):
3293
    """Build hooks env.
3294

3295
    This runs on master, primary and secondary nodes of the instance.
3296

3297
    """
3298
    env = _BuildInstanceHookEnvByObject(self, self.instance)
3299
    nl = [self.cfg.GetMasterNode()]
3300
    return env, nl, nl
3301

    
3302
  def CheckPrereq(self):
3303
    """Check prerequisites.
3304

3305
    This checks that the instance is in the cluster.
3306

3307
    """
3308
    self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
3309
    assert self.instance is not None, \
3310
      "Cannot retrieve locked instance %s" % self.op.instance_name
3311

    
3312
  def Exec(self, feedback_fn):
3313
    """Remove the instance.
3314

3315
    """
3316
    instance = self.instance
3317
    logging.info("Shutting down instance %s on node %s",
3318
                 instance.name, instance.primary_node)
3319

    
3320
    result = self.rpc.call_instance_shutdown(instance.primary_node, instance)
3321
    msg = result.RemoteFailMsg()
3322
    if msg:
3323
      if self.op.ignore_failures:
3324
        feedback_fn("Warning: can't shutdown instance: %s" % msg)
3325
      else:
3326
        raise errors.OpExecError("Could not shutdown instance %s on"
3327
                                 " node %s: %s" %
3328
                                 (instance.name, instance.primary_node, msg))
3329

    
3330
    logging.info("Removing block devices for instance %s", instance.name)
3331

    
3332
    if not _RemoveDisks(self, instance):
3333
      if self.op.ignore_failures:
3334
        feedback_fn("Warning: can't remove instance's disks")
3335
      else:
3336
        raise errors.OpExecError("Can't remove instance's disks")
3337

    
3338
    logging.info("Removing instance %s out of cluster config", instance.name)
3339

    
3340
    self.cfg.RemoveInstance(instance.name)
3341
    self.remove_locks[locking.LEVEL_INSTANCE] = instance.name
3342

    
3343

    
3344
class LUQueryInstances(NoHooksLU):
3345
  """Logical unit for querying instances.
3346

3347
  """
3348
  _OP_REQP = ["output_fields", "names", "use_locking"]
3349
  REQ_BGL = False
3350
  _FIELDS_STATIC = utils.FieldSet(*["name", "os", "pnode", "snodes",
3351
                                    "admin_state",
3352
                                    "disk_template", "ip", "mac", "bridge",
3353
                                    "sda_size", "sdb_size", "vcpus", "tags",
3354
                                    "network_port", "beparams",
3355
                                    r"(disk)\.(size)/([0-9]+)",
3356
                                    r"(disk)\.(sizes)", "disk_usage",
3357
                                    r"(nic)\.(mac|ip|bridge)/([0-9]+)",
3358
                                    r"(nic)\.(macs|ips|bridges)",
3359
                                    r"(disk|nic)\.(count)",
3360
                                    "serial_no", "hypervisor", "hvparams",] +
3361
                                  ["hv/%s" % name
3362
                                   for name in constants.HVS_PARAMETERS] +
3363
                                  ["be/%s" % name
3364
                                   for name in constants.BES_PARAMETERS])
3365
  _FIELDS_DYNAMIC = utils.FieldSet("oper_state", "oper_ram", "status")
3366

    
3367

    
3368
  def ExpandNames(self):
3369
    _CheckOutputFields(static=self._FIELDS_STATIC,
3370
                       dynamic=self._FIELDS_DYNAMIC,
3371
                       selected=self.op.output_fields)
3372

    
3373
    self.needed_locks = {}
3374
    self.share_locks[locking.LEVEL_INSTANCE] = 1
3375
    self.share_locks[locking.LEVEL_NODE] = 1
3376

    
3377
    if self.op.names:
3378
      self.wanted = _GetWantedInstances(self, self.op.names)
3379
    else:
3380
      self.wanted = locking.ALL_SET
3381

    
3382
    self.do_node_query = self._FIELDS_STATIC.NonMatching(self.op.output_fields)
3383
    self.do_locking = self.do_node_query and self.op.use_locking
3384
    if self.do_locking:
3385
      self.needed_locks[locking.LEVEL_INSTANCE] = self.wanted
3386
      self.needed_locks[locking.LEVEL_NODE] = []
3387
      self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
3388

    
3389
  def DeclareLocks(self, level):
3390
    if level == locking.LEVEL_NODE and self.do_locking:
3391
      self._LockInstancesNodes()
3392

    
3393
  def CheckPrereq(self):
3394
    """Check prerequisites.
3395

3396
    """
3397
    pass
3398

    
3399
  def Exec(self, feedback_fn):
3400
    """Computes the list of nodes and their attributes.
3401

3402
    """
3403
    all_info = self.cfg.GetAllInstancesInfo()
3404
    if self.wanted == locking.ALL_SET:
3405
      # caller didn't specify instance names, so ordering is not important
3406
      if self.do_locking:
3407
        instance_names = self.acquired_locks[locking.LEVEL_INSTANCE]
3408
      else:
3409
        instance_names = all_info.keys()
3410
      instance_names = utils.NiceSort(instance_names)
3411
    else:
3412
      # caller did specify names, so we must keep the ordering
3413
      if self.do_locking:
3414
        tgt_set = self.acquired_locks[locking.LEVEL_INSTANCE]
3415
      else:
3416
        tgt_set = all_info.keys()
3417
      missing = set(self.wanted).difference(tgt_set)
3418
      if missing:
3419
        raise errors.OpExecError("Some instances were removed before"
3420
                                 " retrieving their data: %s" % missing)
3421
      instance_names = self.wanted
3422

    
3423
    instance_list = [all_info[iname] for iname in instance_names]
3424

    
3425
    # begin data gathering
3426

    
3427
    nodes = frozenset([inst.primary_node for inst in instance_list])
3428
    hv_list = list(set([inst.hypervisor for inst in instance_list]))
3429

    
3430
    bad_nodes = []
3431
    off_nodes = []
3432
    if self.do_node_query:
3433
      live_data = {}
3434
      node_data = self.rpc.call_all_instances_info(nodes, hv_list)
3435
      for name in nodes:
3436
        result = node_data[name]
3437
        if result.offline:
3438
          # offline nodes will be in both lists
3439
          off_nodes.append(name)
3440
        if result.failed:
3441
          bad_nodes.append(name)
3442
        else:
3443
          if result.data:
3444
            live_data.update(result.data)
3445
            # else no instance is alive
3446
    else:
3447
      live_data = dict([(name, {}) for name in instance_names])
3448

    
3449
    # end data gathering
3450

    
3451
    HVPREFIX = "hv/"
3452
    BEPREFIX = "be/"
3453
    output = []
3454
    for instance in instance_list:
3455
      iout = []
3456
      i_hv = self.cfg.GetClusterInfo().FillHV(instance)
3457
      i_be = self.cfg.GetClusterInfo().FillBE(instance)
3458
      for field in self.op.output_fields:
3459
        st_match = self._FIELDS_STATIC.Matches(field)
3460
        if field == "name":
3461
          val = instance.name
3462
        elif field == "os":
3463
          val = instance.os
3464
        elif field == "pnode":
3465
          val = instance.primary_node
3466
        elif field == "snodes":
3467
          val = list(instance.secondary_nodes)
3468
        elif field == "admin_state":
3469
          val = instance.admin_up
3470
        elif field == "oper_state":
3471
          if instance.primary_node in bad_nodes:
3472
            val = None
3473
          else:
3474
            val = bool(live_data.get(instance.name))
3475
        elif field == "status":
3476
          if instance.primary_node in off_nodes:
3477
            val = "ERROR_nodeoffline"
3478
          elif instance.primary_node in bad_nodes:
3479
            val = "ERROR_nodedown"
3480
          else:
3481
            running = bool(live_data.get(instance.name))
3482
            if running:
3483
              if instance.admin_up:
3484
                val = "running"
3485
              else:
3486
                val = "ERROR_up"
3487
            else:
3488
              if instance.admin_up:
3489
                val = "ERROR_down"
3490
              else:
3491
                val = "ADMIN_down"
3492
        elif field == "oper_ram":
3493
          if instance.primary_node in bad_nodes:
3494
            val = None
3495
          elif instance.name in live_data:
3496
            val = live_data[instance.name].get("memory", "?")
3497
          else:
3498
            val = "-"
3499
        elif field == "disk_template":
3500
          val = instance.disk_template
3501
        elif field == "ip":
3502
          val = instance.nics[0].ip
3503
        elif field == "bridge":
3504
          val = instance.nics[0].bridge
3505
        elif field == "mac":
3506
          val = instance.nics[0].mac
3507
        elif field == "sda_size" or field == "sdb_size":
3508
          idx = ord(field[2]) - ord('a')
3509
          try:
3510
            val = instance.FindDisk(idx).size
3511
          except errors.OpPrereqError:
3512
            val = None
3513
        elif field == "disk_usage": # total disk usage per node
3514
          disk_sizes = [{'size': disk.size} for disk in instance.disks]
3515
          val = _ComputeDiskSize(instance.disk_template, disk_sizes)
3516
        elif field == "tags":
3517
          val = list(instance.GetTags())
3518
        elif field == "serial_no":
3519
          val = instance.serial_no
3520
        elif field == "network_port":
3521
          val = instance.network_port
3522
        elif field == "hypervisor":
3523
          val = instance.hypervisor
3524
        elif field == "hvparams":
3525
          val = i_hv
3526
        elif (field.startswith(HVPREFIX) and
3527
              field[len(HVPREFIX):] in constants.HVS_PARAMETERS):
3528
          val = i_hv.get(field[len(HVPREFIX):], None)
3529
        elif field == "beparams":
3530
          val = i_be
3531
        elif (field.startswith(BEPREFIX) and
3532
              field[len(BEPREFIX):] in constants.BES_PARAMETERS):
3533
          val = i_be.get(field[len(BEPREFIX):], None)
3534
        elif st_match and st_match.groups():
3535
          # matches a variable list
3536
          st_groups = st_match.groups()
3537
          if st_groups and st_groups[0] == "disk":
3538
            if st_groups[1] == "count":
3539
              val = len(instance.disks)
3540
            elif st_groups[1] == "sizes":
3541
              val = [disk.size for disk in instance.disks]
3542
            elif st_groups[1] == "size":
3543
              try:
3544
                val = instance.FindDisk(st_groups[2]).size
3545
              except errors.OpPrereqError:
3546
                val = None
3547
            else:
3548
              assert False, "Unhandled disk parameter"
3549
          elif st_groups[0] == "nic":
3550
            if st_groups[1] == "count":
3551
              val = len(instance.nics)
3552
            elif st_groups[1] == "macs":
3553
              val = [nic.mac for nic in instance.nics]
3554
            elif st_groups[1] == "ips":
3555
              val = [nic.ip for nic in instance.nics]
3556
            elif st_groups[1] == "bridges":
3557
              val = [nic.bridge for nic in instance.nics]
3558
            else:
3559
              # index-based item
3560
              nic_idx = int(st_groups[2])
3561
              if nic_idx >= len(instance.nics):
3562
                val = None
3563
              else:
3564
                if st_groups[1] == "mac":
3565
                  val = instance.nics[nic_idx].mac
3566
                elif st_groups[1] == "ip":
3567
                  val = instance.nics[nic_idx].ip
3568
                elif st_groups[1] == "bridge":
3569
                  val = instance.nics[nic_idx].bridge
3570
                else:
3571
                  assert False, "Unhandled NIC parameter"
3572
          else:
3573
            assert False, "Unhandled variable parameter"
3574
        else:
3575
          raise errors.ParameterError(field)
3576
        iout.append(val)
3577
      output.append(iout)
3578

    
3579
    return output
3580

    
3581

    
3582
class LUFailoverInstance(LogicalUnit):
3583
  """Failover an instance.
3584

3585
  """
3586
  HPATH = "instance-failover"
3587
  HTYPE = constants.HTYPE_INSTANCE
3588
  _OP_REQP = ["instance_name", "ignore_consistency"]
3589
  REQ_BGL = False
3590

    
3591
  def ExpandNames(self):
3592
    self._ExpandAndLockInstance()
3593
    self.needed_locks[locking.LEVEL_NODE] = []
3594
    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
3595

    
3596
  def DeclareLocks(self, level):
3597
    if level == locking.LEVEL_NODE:
3598
      self._LockInstancesNodes()
3599

    
3600
  def BuildHooksEnv(self):
3601
    """Build hooks env.
3602

3603
    This runs on master, primary and secondary nodes of the instance.
3604

3605
    """
3606
    env = {
3607
      "IGNORE_CONSISTENCY": self.op.ignore_consistency,
3608
      }
3609
    env.update(_BuildInstanceHookEnvByObject(self, self.instance))
3610
    nl = [self.cfg.GetMasterNode()] + list(self.instance.secondary_nodes)
3611
    return env, nl, nl
3612

    
3613
  def CheckPrereq(self):
3614
    """Check prerequisites.
3615

3616
    This checks that the instance is in the cluster.
3617

3618
    """
3619
    self.instance = instance = self.cfg.GetInstanceInfo(self.op.instance_name)
3620
    assert self.instance is not None, \
3621
      "Cannot retrieve locked instance %s" % self.op.instance_name
3622

    
3623
    bep = self.cfg.GetClusterInfo().FillBE(instance)
3624
    if instance.disk_template not in constants.DTS_NET_MIRROR:
3625
      raise errors.OpPrereqError("Instance's disk layout is not"
3626
                                 " network mirrored, cannot failover.")
3627

    
3628
    secondary_nodes = instance.secondary_nodes
3629
    if not secondary_nodes:
3630
      raise errors.ProgrammerError("no secondary node but using "
3631
                                   "a mirrored disk template")
3632

    
3633
    target_node = secondary_nodes[0]
3634
    _CheckNodeOnline(self, target_node)
3635
    _CheckNodeNotDrained(self, target_node)
3636
    # check memory requirements on the secondary node
3637
    _CheckNodeFreeMemory(self, target_node, "failing over instance %s" %
3638
                         instance.name, bep[constants.BE_MEMORY],
3639
                         instance.hypervisor)
3640
    # check bridge existance
3641
    _CheckInstanceBridgesExist(self, instance, node=target_node)
3642

    
3643
  def Exec(self, feedback_fn):
3644
    """Failover an instance.
3645

3646
    The failover is done by shutting it down on its present node and
3647
    starting it on the secondary.
3648

3649
    """
3650
    instance = self.instance
3651

    
3652
    source_node = instance.primary_node
3653
    target_node = instance.secondary_nodes[0]
3654

    
3655
    feedback_fn("* checking disk consistency between source and target")
3656
    for dev in instance.disks:
3657
      # for drbd, these are drbd over lvm
3658
      if not _CheckDiskConsistency(self, dev, target_node, False):
3659
        if instance.admin_up and not self.op.ignore_consistency:
3660
          raise errors.OpExecError("Disk %s is degraded on target node,"
3661
                                   " aborting failover." % dev.iv_name)
3662

    
3663
    feedback_fn("* shutting down instance on source node")
3664
    logging.info("Shutting down instance %s on node %s",
3665
                 instance.name, source_node)
3666

    
3667
    result = self.rpc.call_instance_shutdown(source_node, instance)
3668
    msg = result.RemoteFailMsg()
3669
    if msg:
3670
      if self.op.ignore_consistency:
3671
        self.proc.LogWarning("Could not shutdown instance %s on node %s."
3672
                             " Proceeding anyway. Please make sure node"
3673
                             " %s is down. Error details: %s",
3674
                             instance.name, source_node, source_node, msg)
3675
      else:
3676
        raise errors.OpExecError("Could not shutdown instance %s on"
3677
                                 " node %s: %s" %
3678
                                 (instance.name, source_node, msg))
3679

    
3680
    feedback_fn("* deactivating the instance's disks on source node")
3681
    if not _ShutdownInstanceDisks(self, instance, ignore_primary=True):
3682
      raise errors.OpExecError("Can't shut down the instance's disks.")
3683

    
3684
    instance.primary_node = target_node
3685
    # distribute new instance config to the other nodes
3686
    self.cfg.Update(instance)
3687

    
3688
    # Only start the instance if it's marked as up
3689
    if instance.admin_up:
3690
      feedback_fn("* activating the instance's disks on target node")
3691
      logging.info("Starting instance %s on node %s",
3692
                   instance.name, target_node)
3693

    
3694
      disks_ok, dummy = _AssembleInstanceDisks(self, instance,
3695
                                               ignore_secondaries=True)
3696
      if not disks_ok:
3697
        _ShutdownInstanceDisks(self, instance)
3698
        raise errors.OpExecError("Can't activate the instance's disks")
3699

    
3700
      feedback_fn("* starting the instance on the target node")
3701
      result = self.rpc.call_instance_start(target_node, instance, None, None)
3702
      msg = result.RemoteFailMsg()
3703
      if msg:
3704
        _ShutdownInstanceDisks(self, instance)
3705
        raise errors.OpExecError("Could not start instance %s on node %s: %s" %
3706
                                 (instance.name, target_node, msg))
3707

    
3708

    
3709
class LUMigrateInstance(LogicalUnit):
3710
  """Migrate an instance.
3711

3712
  This is migration without shutting down, compared to the failover,
3713
  which is done with shutdown.
3714

3715
  """
3716
  HPATH = "instance-migrate"
3717
  HTYPE = constants.HTYPE_INSTANCE
3718
  _OP_REQP = ["instance_name", "live", "cleanup"]
3719

    
3720
  REQ_BGL = False
3721

    
3722
  def ExpandNames(self):
3723
    self._ExpandAndLockInstance()
3724
    self.needed_locks[locking.LEVEL_NODE] = []
3725
    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
3726

    
3727
  def DeclareLocks(self, level):
3728
    if level == locking.LEVEL_NODE:
3729
      self._LockInstancesNodes()
3730

    
3731
  def BuildHooksEnv(self):
3732
    """Build hooks env.
3733

3734
    This runs on master, primary and secondary nodes of the instance.
3735

3736
    """
3737
    env = _BuildInstanceHookEnvByObject(self, self.instance)
3738
    env["MIGRATE_LIVE"] = self.op.live
3739
    env["MIGRATE_CLEANUP"] = self.op.cleanup
3740
    nl = [self.cfg.GetMasterNode()] + list(self.instance.secondary_nodes)
3741
    return env, nl, nl
3742

    
3743
  def CheckPrereq(self):
3744
    """Check prerequisites.
3745

3746
    This checks that the instance is in the cluster.
3747

3748
    """
3749
    instance = self.cfg.GetInstanceInfo(
3750
      self.cfg.ExpandInstanceName(self.op.instance_name))
3751
    if instance is None:
3752
      raise errors.OpPrereqError("Instance '%s' not known" %
3753
                                 self.op.instance_name)
3754

    
3755
    if instance.disk_template != constants.DT_DRBD8:
3756
      raise errors.OpPrereqError("Instance's disk layout is not"
3757
                                 " drbd8, cannot migrate.")
3758

    
3759
    secondary_nodes = instance.secondary_nodes
3760
    if not secondary_nodes:
3761
      raise errors.ConfigurationError("No secondary node but using"
3762
                                      " drbd8 disk template")
3763

    
3764
    i_be = self.cfg.GetClusterInfo().FillBE(instance)
3765

    
3766
    target_node = secondary_nodes[0]
3767
    # check memory requirements on the secondary node
3768
    _CheckNodeFreeMemory(self, target_node, "migrating instance %s" %
3769
                         instance.name, i_be[constants.BE_MEMORY],
3770
                         instance.hypervisor)
3771

    
3772
    # check bridge existance
3773
    _CheckInstanceBridgesExist(self, instance, node=target_node)
3774

    
3775
    if not self.op.cleanup:
3776
      _CheckNodeNotDrained(self, target_node)
3777
      result = self.rpc.call_instance_migratable(instance.primary_node,
3778
                                                 instance)
3779
      msg = result.RemoteFailMsg()
3780
      if msg:
3781
        raise errors.OpPrereqError("Can't migrate: %s - please use failover" %
3782
                                   msg)
3783

    
3784
    self.instance = instance
3785

    
3786
  def _WaitUntilSync(self):
3787
    """Poll with custom rpc for disk sync.
3788

3789
    This uses our own step-based rpc call.
3790

3791
    """
3792
    self.feedback_fn("* wait until resync is done")
3793
    all_done = False
3794
    while not all_done:
3795
      all_done = True
3796
      result = self.rpc.call_drbd_wait_sync(self.all_nodes,
3797
                                            self.nodes_ip,
3798
                                            self.instance.disks)
3799
      min_percent = 100
3800
      for node, nres in result.items():
3801
        msg = nres.RemoteFailMsg()
3802
        if msg:
3803
          raise errors.OpExecError("Cannot resync disks on node %s: %s" %
3804
                                   (node, msg))
3805
        node_done, node_percent = nres.payload
3806
        all_done = all_done and node_done
3807
        if node_percent is not None:
3808
          min_percent = min(min_percent, node_percent)
3809
      if not all_done:
3810
        if min_percent < 100:
3811
          self.feedback_fn("   - progress: %.1f%%" % min_percent)
3812
        time.sleep(2)
3813

    
3814
  def _EnsureSecondary(self, node):
3815
    """Demote a node to secondary.
3816

3817
    """
3818
    self.feedback_fn("* switching node %s to secondary mode" % node)
3819

    
3820
    for dev in self.instance.disks:
3821
      self.cfg.SetDiskID(dev, node)
3822

    
3823
    result = self.rpc.call_blockdev_close(node, self.instance.name,
3824
                                          self.instance.disks)
3825
    msg = result.RemoteFailMsg()
3826
    if msg:
3827
      raise errors.OpExecError("Cannot change disk to secondary on node %s,"
3828
                               " error %s" % (node, msg))
3829

    
3830
  def _GoStandalone(self):
3831
    """Disconnect from the network.
3832

3833
    """
3834
    self.feedback_fn("* changing into standalone mode")
3835
    result = self.rpc.call_drbd_disconnect_net(self.all_nodes, self.nodes_ip,
3836
                                               self.instance.disks)
3837
    for node, nres in result.items():
3838
      msg = nres.RemoteFailMsg()
3839
      if msg:
3840
        raise errors.OpExecError("Cannot disconnect disks node %s,"
3841
                                 " error %s" % (node, msg))
3842

    
3843
  def _GoReconnect(self, multimaster):
3844
    """Reconnect to the network.
3845

3846
    """
3847
    if multimaster:
3848
      msg = "dual-master"
3849
    else:
3850
      msg = "single-master"
3851
    self.feedback_fn("* changing disks into %s mode" % msg)
3852
    result = self.rpc.call_drbd_attach_net(self.all_nodes, self.nodes_ip,
3853
                                           self.instance.disks,
3854
                                           self.instance.name, multimaster)
3855
    for node, nres in result.items():
3856
      msg = nres.RemoteFailMsg()
3857
      if msg:
3858
        raise errors.OpExecError("Cannot change disks config on node %s,"
3859
                                 " error: %s" % (node, msg))
3860

    
3861
  def _ExecCleanup(self):
3862
    """Try to cleanup after a failed migration.
3863

3864
    The cleanup is done by:
3865
      - check that the instance is running only on one node
3866
        (and update the config if needed)
3867
      - change disks on its secondary node to secondary
3868
      - wait until disks are fully synchronized
3869
      - disconnect from the network
3870
      - change disks into single-master mode
3871
      - wait again until disks are fully synchronized
3872

3873
    """
3874
    instance = self.instance
3875
    target_node = self.target_node
3876
    source_node = self.source_node
3877

    
3878
    # check running on only one node
3879
    self.feedback_fn("* checking where the instance actually runs"
3880
                     " (if this hangs, the hypervisor might be in"
3881
                     " a bad state)")
3882
    ins_l = self.rpc.call_instance_list(self.all_nodes, [instance.hypervisor])
3883
    for node, result in ins_l.items():
3884
      result.Raise()
3885
      if not isinstance(result.data, list):
3886
        raise errors.OpExecError("Can't contact node '%s'" % node)
3887

    
3888
    runningon_source = instance.name in ins_l[source_node].data
3889
    runningon_target = instance.name in ins_l[target_node].data
3890

    
3891
    if runningon_source and runningon_target:
3892
      raise errors.OpExecError("Instance seems to be running on two nodes,"
3893
                               " or the hypervisor is confused. You will have"
3894
                               " to ensure manually that it runs only on one"
3895
                               " and restart this operation.")
3896

    
3897
    if not (runningon_source or runningon_target):
3898
      raise errors.OpExecError("Instance does not seem to be running at all."
3899
                               " In this case, it's safer to repair by"
3900
                               " running 'gnt-instance stop' to ensure disk"
3901
                               " shutdown, and then restarting it.")
3902

    
3903
    if runningon_target:
3904
      # the migration has actually succeeded, we need to update the config
3905
      self.feedback_fn("* instance running on secondary node (%s),"
3906
                       " updating config" % target_node)
3907
      instance.primary_node = target_node
3908
      self.cfg.Update(instance)
3909
      demoted_node = source_node
3910
    else:
3911
      self.feedback_fn("* instance confirmed to be running on its"
3912
                       " primary node (%s)" % source_node)
3913
      demoted_node = target_node
3914

    
3915
    self._EnsureSecondary(demoted_node)
3916
    try:
3917
      self._WaitUntilSync()
3918
    except errors.OpExecError:
3919
      # we ignore here errors, since if the device is standalone, it
3920
      # won't be able to sync
3921
      pass
3922
    self._GoStandalone()
3923
    self._GoReconnect(False)
3924
    self._WaitUntilSync()
3925

    
3926
    self.feedback_fn("* done")
3927

    
3928
  def _RevertDiskStatus(self):
3929
    """Try to revert the disk status after a failed migration.
3930

3931
    """
3932
    target_node = self.target_node
3933
    try:
3934
      self._EnsureSecondary(target_node)
3935
      self._GoStandalone()
3936
      self._GoReconnect(False)
3937
      self._WaitUntilSync()
3938
    except errors.OpExecError, err:
3939
      self.LogWarning("Migration failed and I can't reconnect the"
3940
                      " drives: error '%s'\n"
3941
                      "Please look and recover the instance status" %
3942
                      str(err))
3943

    
3944
  def _AbortMigration(self):
3945
    """Call the hypervisor code to abort a started migration.
3946

3947
    """
3948
    instance = self.instance
3949
    target_node = self.target_node
3950
    migration_info = self.migration_info
3951

    
3952
    abort_result = self.rpc.call_finalize_migration(target_node,
3953
                                                    instance,
3954
                                                    migration_info,
3955
                                                    False)
3956
    abort_msg = abort_result.RemoteFailMsg()
3957
    if abort_msg:
3958
      logging.error("Aborting migration failed on target node %s: %s" %
3959
                    (target_node, abort_msg))
3960
      # Don't raise an exception here, as we stil have to try to revert the
3961
      # disk status, even if this step failed.
3962

    
3963
  def _ExecMigration(self):
3964
    """Migrate an instance.
3965

3966
    The migrate is done by:
3967
      - change the disks into dual-master mode
3968
      - wait until disks are fully synchronized again
3969
      - migrate the instance
3970
      - change disks on the new secondary node (the old primary) to secondary
3971
      - wait until disks are fully synchronized
3972
      - change disks into single-master mode
3973

3974
    """
3975
    instance = self.instance
3976
    target_node = self.target_node
3977
    source_node = self.source_node
3978

    
3979
    self.feedback_fn("* checking disk consistency between source and target")
3980
    for dev in instance.disks:
3981
      if not _CheckDiskConsistency(self, dev, target_node, False):
3982
        raise errors.OpExecError("Disk %s is degraded or not fully"
3983
                                 " synchronized on target node,"
3984
                                 " aborting migrate." % dev.iv_name)
3985

    
3986
    # First get the migration information from the remote node
3987
    result = self.rpc.call_migration_info(source_node, instance)
3988
    msg = result.RemoteFailMsg()
3989
    if msg:
3990
      log_err = ("Failed fetching source migration information from %s: %s" %
3991
                 (source_node, msg))
3992
      logging.error(log_err)
3993
      raise errors.OpExecError(log_err)
3994

    
3995
    self.migration_info = migration_info = result.payload
3996

    
3997
    # Then switch the disks to master/master mode
3998
    self._EnsureSecondary(target_node)
3999
    self._GoStandalone()
4000
    self._GoReconnect(True)
4001
    self._WaitUntilSync()
4002

    
4003
    self.feedback_fn("* preparing %s to accept the instance" % target_node)
4004
    result = self.rpc.call_accept_instance(target_node,
4005
                                           instance,
4006
                                           migration_info,
4007
                                           self.nodes_ip[target_node])
4008

    
4009
    msg = result.RemoteFailMsg()
4010
    if msg:
4011