Statistics
| Branch: | Tag: | Revision:

root / lib / cmdlib.py @ 55cc0a44

History | View | Annotate | Download (385.1 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007, 2008, 2009, 2010 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=W0201,C0302
25

    
26
# W0201 since most LU attributes are defined in CheckPrereq or similar
27
# functions
28

    
29
# C0302: since we have waaaay to many lines in this module
30

    
31
import os
32
import os.path
33
import time
34
import re
35
import platform
36
import logging
37
import copy
38
import OpenSSL
39
import socket
40
import tempfile
41
import shutil
42
import itertools
43

    
44
from ganeti import ssh
45
from ganeti import utils
46
from ganeti import errors
47
from ganeti import hypervisor
48
from ganeti import locking
49
from ganeti import constants
50
from ganeti import objects
51
from ganeti import serializer
52
from ganeti import ssconf
53
from ganeti import uidpool
54
from ganeti import compat
55
from ganeti import masterd
56
from ganeti import netutils
57
from ganeti import query
58
from ganeti import qlang
59
from ganeti import opcodes
60

    
61
import ganeti.masterd.instance # pylint: disable-msg=W0611
62

    
63

    
64
def _SupportsOob(cfg, node):
65
  """Tells if node supports OOB.
66

67
  @type cfg: L{config.ConfigWriter}
68
  @param cfg: The cluster configuration
69
  @type node: L{objects.Node}
70
  @param node: The node
71
  @return: The OOB script if supported or an empty string otherwise
72

73
  """
74
  return cfg.GetNdParams(node)[constants.ND_OOB_PROGRAM]
75

    
76

    
77
# End types
78
class LogicalUnit(object):
79
  """Logical Unit base class.
80

81
  Subclasses must follow these rules:
82
    - implement ExpandNames
83
    - implement CheckPrereq (except when tasklets are used)
84
    - implement Exec (except when tasklets are used)
85
    - implement BuildHooksEnv
86
    - redefine HPATH and HTYPE
87
    - optionally redefine their run requirements:
88
        REQ_BGL: the LU needs to hold the Big Ganeti Lock exclusively
89

90
  Note that all commands require root permissions.
91

92
  @ivar dry_run_result: the value (if any) that will be returned to the caller
93
      in dry-run mode (signalled by opcode dry_run parameter)
94

95
  """
96
  HPATH = None
97
  HTYPE = None
98
  REQ_BGL = True
99

    
100
  def __init__(self, processor, op, context, rpc):
101
    """Constructor for LogicalUnit.
102

103
    This needs to be overridden in derived classes in order to check op
104
    validity.
105

106
    """
107
    self.proc = processor
108
    self.op = op
109
    self.cfg = context.cfg
110
    self.context = context
111
    self.rpc = rpc
112
    # Dicts used to declare locking needs to mcpu
113
    self.needed_locks = None
114
    self.acquired_locks = {}
115
    self.share_locks = dict.fromkeys(locking.LEVELS, 0)
116
    self.add_locks = {}
117
    self.remove_locks = {}
118
    # Used to force good behavior when calling helper functions
119
    self.recalculate_locks = {}
120
    self.__ssh = None
121
    # logging
122
    self.Log = processor.Log # pylint: disable-msg=C0103
123
    self.LogWarning = processor.LogWarning # pylint: disable-msg=C0103
124
    self.LogInfo = processor.LogInfo # pylint: disable-msg=C0103
125
    self.LogStep = processor.LogStep # pylint: disable-msg=C0103
126
    # support for dry-run
127
    self.dry_run_result = None
128
    # support for generic debug attribute
129
    if (not hasattr(self.op, "debug_level") or
130
        not isinstance(self.op.debug_level, int)):
131
      self.op.debug_level = 0
132

    
133
    # Tasklets
134
    self.tasklets = None
135

    
136
    # Validate opcode parameters and set defaults
137
    self.op.Validate(True)
138

    
139
    self.CheckArguments()
140

    
141
  def __GetSSH(self):
142
    """Returns the SshRunner object
143

144
    """
145
    if not self.__ssh:
146
      self.__ssh = ssh.SshRunner(self.cfg.GetClusterName())
147
    return self.__ssh
148

    
149
  ssh = property(fget=__GetSSH)
150

    
151
  def CheckArguments(self):
152
    """Check syntactic validity for the opcode arguments.
153

154
    This method is for doing a simple syntactic check and ensure
155
    validity of opcode parameters, without any cluster-related
156
    checks. While the same can be accomplished in ExpandNames and/or
157
    CheckPrereq, doing these separate is better because:
158

159
      - ExpandNames is left as as purely a lock-related function
160
      - CheckPrereq is run after we have acquired locks (and possible
161
        waited for them)
162

163
    The function is allowed to change the self.op attribute so that
164
    later methods can no longer worry about missing parameters.
165

166
    """
167
    pass
168

    
169
  def ExpandNames(self):
170
    """Expand names for this LU.
171

172
    This method is called before starting to execute the opcode, and it should
173
    update all the parameters of the opcode to their canonical form (e.g. a
174
    short node name must be fully expanded after this method has successfully
175
    completed). This way locking, hooks, logging, etc. can work correctly.
176

177
    LUs which implement this method must also populate the self.needed_locks
178
    member, as a dict with lock levels as keys, and a list of needed lock names
179
    as values. Rules:
180

181
      - use an empty dict if you don't need any lock
182
      - if you don't need any lock at a particular level omit that level
183
      - don't put anything for the BGL level
184
      - if you want all locks at a level use locking.ALL_SET as a value
185

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

190
    This function can also define a list of tasklets, which then will be
191
    executed in order instead of the usual LU-level CheckPrereq and Exec
192
    functions, if those are not defined by the LU.
193

194
    Examples::
195

196
      # Acquire all nodes and one instance
197
      self.needed_locks = {
198
        locking.LEVEL_NODE: locking.ALL_SET,
199
        locking.LEVEL_INSTANCE: ['instance1.example.com'],
200
      }
201
      # Acquire just two nodes
202
      self.needed_locks = {
203
        locking.LEVEL_NODE: ['node1.example.com', 'node2.example.com'],
204
      }
205
      # Acquire no locks
206
      self.needed_locks = {} # No, you can't leave it to the default value None
207

208
    """
209
    # The implementation of this method is mandatory only if the new LU is
210
    # concurrent, so that old LUs don't need to be changed all at the same
211
    # time.
212
    if self.REQ_BGL:
213
      self.needed_locks = {} # Exclusive LUs don't need locks.
214
    else:
215
      raise NotImplementedError
216

    
217
  def DeclareLocks(self, level):
218
    """Declare LU locking needs for a level
219

220
    While most LUs can just declare their locking needs at ExpandNames time,
221
    sometimes there's the need to calculate some locks after having acquired
222
    the ones before. This function is called just before acquiring locks at a
223
    particular level, but after acquiring the ones at lower levels, and permits
224
    such calculations. It can be used to modify self.needed_locks, and by
225
    default it does nothing.
226

227
    This function is only called if you have something already set in
228
    self.needed_locks for the level.
229

230
    @param level: Locking level which is going to be locked
231
    @type level: member of ganeti.locking.LEVELS
232

233
    """
234

    
235
  def CheckPrereq(self):
236
    """Check prerequisites for this LU.
237

238
    This method should check that the prerequisites for the execution
239
    of this LU are fulfilled. It can do internode communication, but
240
    it should be idempotent - no cluster or system changes are
241
    allowed.
242

243
    The method should raise errors.OpPrereqError in case something is
244
    not fulfilled. Its return value is ignored.
245

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

249
    """
250
    if self.tasklets is not None:
251
      for (idx, tl) in enumerate(self.tasklets):
252
        logging.debug("Checking prerequisites for tasklet %s/%s",
253
                      idx + 1, len(self.tasklets))
254
        tl.CheckPrereq()
255
    else:
256
      pass
257

    
258
  def Exec(self, feedback_fn):
259
    """Execute the LU.
260

261
    This method should implement the actual work. It should raise
262
    errors.OpExecError for failures that are somewhat dealt with in
263
    code, or expected.
264

265
    """
266
    if self.tasklets is not None:
267
      for (idx, tl) in enumerate(self.tasklets):
268
        logging.debug("Executing tasklet %s/%s", idx + 1, len(self.tasklets))
269
        tl.Exec(feedback_fn)
270
    else:
271
      raise NotImplementedError
272

    
273
  def BuildHooksEnv(self):
274
    """Build hooks environment for this LU.
275

276
    This method should return a three-node tuple consisting of: a dict
277
    containing the environment that will be used for running the
278
    specific hook for this LU, a list of node names on which the hook
279
    should run before the execution, and a list of node names on which
280
    the hook should run after the execution.
281

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

287
    No nodes should be returned as an empty list (and not None).
288

289
    Note that if the HPATH for a LU class is None, this function will
290
    not be called.
291

292
    """
293
    raise NotImplementedError
294

    
295
  def HooksCallBack(self, phase, hook_results, feedback_fn, lu_result):
296
    """Notify the LU about the results of its hooks.
297

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

304
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
305
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
306
    @param hook_results: the results of the multi-node hooks rpc call
307
    @param feedback_fn: function used send feedback back to the caller
308
    @param lu_result: the previous Exec result this LU had, or None
309
        in the PRE phase
310
    @return: the new Exec result, based on the previous result
311
        and hook results
312

313
    """
314
    # API must be kept, thus we ignore the unused argument and could
315
    # be a function warnings
316
    # pylint: disable-msg=W0613,R0201
317
    return lu_result
318

    
319
  def _ExpandAndLockInstance(self):
320
    """Helper function to expand and lock an instance.
321

322
    Many LUs that work on an instance take its name in self.op.instance_name
323
    and need to expand it and then declare the expanded name for locking. This
324
    function does it, and then updates self.op.instance_name to the expanded
325
    name. It also initializes needed_locks as a dict, if this hasn't been done
326
    before.
327

328
    """
329
    if self.needed_locks is None:
330
      self.needed_locks = {}
331
    else:
332
      assert locking.LEVEL_INSTANCE not in self.needed_locks, \
333
        "_ExpandAndLockInstance called with instance-level locks set"
334
    self.op.instance_name = _ExpandInstanceName(self.cfg,
335
                                                self.op.instance_name)
336
    self.needed_locks[locking.LEVEL_INSTANCE] = self.op.instance_name
337

    
338
  def _LockInstancesNodes(self, primary_only=False):
339
    """Helper function to declare instances' nodes for locking.
340

341
    This function should be called after locking one or more instances to lock
342
    their nodes. Its effect is populating self.needed_locks[locking.LEVEL_NODE]
343
    with all primary or secondary nodes for instances already locked and
344
    present in self.needed_locks[locking.LEVEL_INSTANCE].
345

346
    It should be called from DeclareLocks, and for safety only works if
347
    self.recalculate_locks[locking.LEVEL_NODE] is set.
348

349
    In the future it may grow parameters to just lock some instance's nodes, or
350
    to just lock primaries or secondary nodes, if needed.
351

352
    If should be called in DeclareLocks in a way similar to::
353

354
      if level == locking.LEVEL_NODE:
355
        self._LockInstancesNodes()
356

357
    @type primary_only: boolean
358
    @param primary_only: only lock primary nodes of locked instances
359

360
    """
361
    assert locking.LEVEL_NODE in self.recalculate_locks, \
362
      "_LockInstancesNodes helper function called with no nodes to recalculate"
363

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

    
366
    # For now we'll replace self.needed_locks[locking.LEVEL_NODE], but in the
367
    # future we might want to have different behaviors depending on the value
368
    # of self.recalculate_locks[locking.LEVEL_NODE]
369
    wanted_nodes = []
370
    for instance_name in self.acquired_locks[locking.LEVEL_INSTANCE]:
371
      instance = self.context.cfg.GetInstanceInfo(instance_name)
372
      wanted_nodes.append(instance.primary_node)
373
      if not primary_only:
374
        wanted_nodes.extend(instance.secondary_nodes)
375

    
376
    if self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_REPLACE:
377
      self.needed_locks[locking.LEVEL_NODE] = wanted_nodes
378
    elif self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_APPEND:
379
      self.needed_locks[locking.LEVEL_NODE].extend(wanted_nodes)
380

    
381
    del self.recalculate_locks[locking.LEVEL_NODE]
382

    
383

    
384
class NoHooksLU(LogicalUnit): # pylint: disable-msg=W0223
385
  """Simple LU which runs no hooks.
386

387
  This LU is intended as a parent for other LogicalUnits which will
388
  run no hooks, in order to reduce duplicate code.
389

390
  """
391
  HPATH = None
392
  HTYPE = None
393

    
394
  def BuildHooksEnv(self):
395
    """Empty BuildHooksEnv for NoHooksLu.
396

397
    This just raises an error.
398

399
    """
400
    assert False, "BuildHooksEnv called for NoHooksLUs"
401

    
402

    
403
class Tasklet:
404
  """Tasklet base class.
405

406
  Tasklets are subcomponents for LUs. LUs can consist entirely of tasklets or
407
  they can mix legacy code with tasklets. Locking needs to be done in the LU,
408
  tasklets know nothing about locks.
409

410
  Subclasses must follow these rules:
411
    - Implement CheckPrereq
412
    - Implement Exec
413

414
  """
415
  def __init__(self, lu):
416
    self.lu = lu
417

    
418
    # Shortcuts
419
    self.cfg = lu.cfg
420
    self.rpc = lu.rpc
421

    
422
  def CheckPrereq(self):
423
    """Check prerequisites for this tasklets.
424

425
    This method should check whether the prerequisites for the execution of
426
    this tasklet are fulfilled. It can do internode communication, but it
427
    should be idempotent - no cluster or system changes are allowed.
428

429
    The method should raise errors.OpPrereqError in case something is not
430
    fulfilled. Its return value is ignored.
431

432
    This method should also update all parameters to their canonical form if it
433
    hasn't been done before.
434

435
    """
436
    pass
437

    
438
  def Exec(self, feedback_fn):
439
    """Execute the tasklet.
440

441
    This method should implement the actual work. It should raise
442
    errors.OpExecError for failures that are somewhat dealt with in code, or
443
    expected.
444

445
    """
446
    raise NotImplementedError
447

    
448

    
449
class _QueryBase:
450
  """Base for query utility classes.
451

452
  """
453
  #: Attribute holding field definitions
454
  FIELDS = None
455

    
456
  def __init__(self, names, fields, use_locking):
457
    """Initializes this class.
458

459
    """
460
    self.names = names
461
    self.use_locking = use_locking
462

    
463
    self.query = query.Query(self.FIELDS, fields)
464
    self.requested_data = self.query.RequestedData()
465

    
466
    self.do_locking = None
467
    self.wanted = None
468

    
469
  def _GetNames(self, lu, all_names, lock_level):
470
    """Helper function to determine names asked for in the query.
471

472
    """
473
    if self.do_locking:
474
      names = lu.acquired_locks[lock_level]
475
    else:
476
      names = all_names
477

    
478
    if self.wanted == locking.ALL_SET:
479
      assert not self.names
480
      # caller didn't specify names, so ordering is not important
481
      return utils.NiceSort(names)
482

    
483
    # caller specified names and we must keep the same order
484
    assert self.names
485
    assert not self.do_locking or lu.acquired_locks[lock_level]
486

    
487
    missing = set(self.wanted).difference(names)
488
    if missing:
489
      raise errors.OpExecError("Some items were removed before retrieving"
490
                               " their data: %s" % missing)
491

    
492
    # Return expanded names
493
    return self.wanted
494

    
495
  @classmethod
496
  def FieldsQuery(cls, fields):
497
    """Returns list of available fields.
498

499
    @return: List of L{objects.QueryFieldDefinition}
500

501
    """
502
    return query.QueryFields(cls.FIELDS, fields)
503

    
504
  def ExpandNames(self, lu):
505
    """Expand names for this query.
506

507
    See L{LogicalUnit.ExpandNames}.
508

509
    """
510
    raise NotImplementedError()
511

    
512
  def DeclareLocks(self, lu, level):
513
    """Declare locks for this query.
514

515
    See L{LogicalUnit.DeclareLocks}.
516

517
    """
518
    raise NotImplementedError()
519

    
520
  def _GetQueryData(self, lu):
521
    """Collects all data for this query.
522

523
    @return: Query data object
524

525
    """
526
    raise NotImplementedError()
527

    
528
  def NewStyleQuery(self, lu):
529
    """Collect data and execute query.
530

531
    """
532
    return query.GetQueryResponse(self.query, self._GetQueryData(lu))
533

    
534
  def OldStyleQuery(self, lu):
535
    """Collect data and execute query.
536

537
    """
538
    return self.query.OldStyleQuery(self._GetQueryData(lu))
539

    
540

    
541
def _GetWantedNodes(lu, nodes):
542
  """Returns list of checked and expanded node names.
543

544
  @type lu: L{LogicalUnit}
545
  @param lu: the logical unit on whose behalf we execute
546
  @type nodes: list
547
  @param nodes: list of node names or None for all nodes
548
  @rtype: list
549
  @return: the list of nodes, sorted
550
  @raise errors.ProgrammerError: if the nodes parameter is wrong type
551

552
  """
553
  if nodes:
554
    return [_ExpandNodeName(lu.cfg, name) for name in nodes]
555

    
556
  return utils.NiceSort(lu.cfg.GetNodeList())
557

    
558

    
559
def _GetWantedInstances(lu, instances):
560
  """Returns list of checked and expanded instance names.
561

562
  @type lu: L{LogicalUnit}
563
  @param lu: the logical unit on whose behalf we execute
564
  @type instances: list
565
  @param instances: list of instance names or None for all instances
566
  @rtype: list
567
  @return: the list of instances, sorted
568
  @raise errors.OpPrereqError: if the instances parameter is wrong type
569
  @raise errors.OpPrereqError: if any of the passed instances is not found
570

571
  """
572
  if instances:
573
    wanted = [_ExpandInstanceName(lu.cfg, name) for name in instances]
574
  else:
575
    wanted = utils.NiceSort(lu.cfg.GetInstanceList())
576
  return wanted
577

    
578

    
579
def _GetUpdatedParams(old_params, update_dict,
580
                      use_default=True, use_none=False):
581
  """Return the new version of a parameter dictionary.
582

583
  @type old_params: dict
584
  @param old_params: old parameters
585
  @type update_dict: dict
586
  @param update_dict: dict containing new parameter values, or
587
      constants.VALUE_DEFAULT to reset the parameter to its default
588
      value
589
  @param use_default: boolean
590
  @type use_default: whether to recognise L{constants.VALUE_DEFAULT}
591
      values as 'to be deleted' values
592
  @param use_none: boolean
593
  @type use_none: whether to recognise C{None} values as 'to be
594
      deleted' values
595
  @rtype: dict
596
  @return: the new parameter dictionary
597

598
  """
599
  params_copy = copy.deepcopy(old_params)
600
  for key, val in update_dict.iteritems():
601
    if ((use_default and val == constants.VALUE_DEFAULT) or
602
        (use_none and val is None)):
603
      try:
604
        del params_copy[key]
605
      except KeyError:
606
        pass
607
    else:
608
      params_copy[key] = val
609
  return params_copy
610

    
611

    
612
def _CheckOutputFields(static, dynamic, selected):
613
  """Checks whether all selected fields are valid.
614

615
  @type static: L{utils.FieldSet}
616
  @param static: static fields set
617
  @type dynamic: L{utils.FieldSet}
618
  @param dynamic: dynamic fields set
619

620
  """
621
  f = utils.FieldSet()
622
  f.Extend(static)
623
  f.Extend(dynamic)
624

    
625
  delta = f.NonMatching(selected)
626
  if delta:
627
    raise errors.OpPrereqError("Unknown output fields selected: %s"
628
                               % ",".join(delta), errors.ECODE_INVAL)
629

    
630

    
631
def _CheckGlobalHvParams(params):
632
  """Validates that given hypervisor params are not global ones.
633

634
  This will ensure that instances don't get customised versions of
635
  global params.
636

637
  """
638
  used_globals = constants.HVC_GLOBALS.intersection(params)
639
  if used_globals:
640
    msg = ("The following hypervisor parameters are global and cannot"
641
           " be customized at instance level, please modify them at"
642
           " cluster level: %s" % utils.CommaJoin(used_globals))
643
    raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
644

    
645

    
646
def _CheckNodeOnline(lu, node, msg=None):
647
  """Ensure that a given node is online.
648

649
  @param lu: the LU on behalf of which we make the check
650
  @param node: the node to check
651
  @param msg: if passed, should be a message to replace the default one
652
  @raise errors.OpPrereqError: if the node is offline
653

654
  """
655
  if msg is None:
656
    msg = "Can't use offline node"
657
  if lu.cfg.GetNodeInfo(node).offline:
658
    raise errors.OpPrereqError("%s: %s" % (msg, node), errors.ECODE_STATE)
659

    
660

    
661
def _CheckNodeNotDrained(lu, node):
662
  """Ensure that a given node is not drained.
663

664
  @param lu: the LU on behalf of which we make the check
665
  @param node: the node to check
666
  @raise errors.OpPrereqError: if the node is drained
667

668
  """
669
  if lu.cfg.GetNodeInfo(node).drained:
670
    raise errors.OpPrereqError("Can't use drained node %s" % node,
671
                               errors.ECODE_STATE)
672

    
673

    
674
def _CheckNodeVmCapable(lu, node):
675
  """Ensure that a given node is vm capable.
676

677
  @param lu: the LU on behalf of which we make the check
678
  @param node: the node to check
679
  @raise errors.OpPrereqError: if the node is not vm capable
680

681
  """
682
  if not lu.cfg.GetNodeInfo(node).vm_capable:
683
    raise errors.OpPrereqError("Can't use non-vm_capable node %s" % node,
684
                               errors.ECODE_STATE)
685

    
686

    
687
def _CheckNodeHasOS(lu, node, os_name, force_variant):
688
  """Ensure that a node supports a given OS.
689

690
  @param lu: the LU on behalf of which we make the check
691
  @param node: the node to check
692
  @param os_name: the OS to query about
693
  @param force_variant: whether to ignore variant errors
694
  @raise errors.OpPrereqError: if the node is not supporting the OS
695

696
  """
697
  result = lu.rpc.call_os_get(node, os_name)
698
  result.Raise("OS '%s' not in supported OS list for node %s" %
699
               (os_name, node),
700
               prereq=True, ecode=errors.ECODE_INVAL)
701
  if not force_variant:
702
    _CheckOSVariant(result.payload, os_name)
703

    
704

    
705
def _CheckNodeHasSecondaryIP(lu, node, secondary_ip, prereq):
706
  """Ensure that a node has the given secondary ip.
707

708
  @type lu: L{LogicalUnit}
709
  @param lu: the LU on behalf of which we make the check
710
  @type node: string
711
  @param node: the node to check
712
  @type secondary_ip: string
713
  @param secondary_ip: the ip to check
714
  @type prereq: boolean
715
  @param prereq: whether to throw a prerequisite or an execute error
716
  @raise errors.OpPrereqError: if the node doesn't have the ip, and prereq=True
717
  @raise errors.OpExecError: if the node doesn't have the ip, and prereq=False
718

719
  """
720
  result = lu.rpc.call_node_has_ip_address(node, secondary_ip)
721
  result.Raise("Failure checking secondary ip on node %s" % node,
722
               prereq=prereq, ecode=errors.ECODE_ENVIRON)
723
  if not result.payload:
724
    msg = ("Node claims it doesn't have the secondary ip you gave (%s),"
725
           " please fix and re-run this command" % secondary_ip)
726
    if prereq:
727
      raise errors.OpPrereqError(msg, errors.ECODE_ENVIRON)
728
    else:
729
      raise errors.OpExecError(msg)
730

    
731

    
732
def _GetClusterDomainSecret():
733
  """Reads the cluster domain secret.
734

735
  """
736
  return utils.ReadOneLineFile(constants.CLUSTER_DOMAIN_SECRET_FILE,
737
                               strict=True)
738

    
739

    
740
def _CheckInstanceDown(lu, instance, reason):
741
  """Ensure that an instance is not running."""
742
  if instance.admin_up:
743
    raise errors.OpPrereqError("Instance %s is marked to be up, %s" %
744
                               (instance.name, reason), errors.ECODE_STATE)
745

    
746
  pnode = instance.primary_node
747
  ins_l = lu.rpc.call_instance_list([pnode], [instance.hypervisor])[pnode]
748
  ins_l.Raise("Can't contact node %s for instance information" % pnode,
749
              prereq=True, ecode=errors.ECODE_ENVIRON)
750

    
751
  if instance.name in ins_l.payload:
752
    raise errors.OpPrereqError("Instance %s is running, %s" %
753
                               (instance.name, reason), errors.ECODE_STATE)
754

    
755

    
756
def _ExpandItemName(fn, name, kind):
757
  """Expand an item name.
758

759
  @param fn: the function to use for expansion
760
  @param name: requested item name
761
  @param kind: text description ('Node' or 'Instance')
762
  @return: the resolved (full) name
763
  @raise errors.OpPrereqError: if the item is not found
764

765
  """
766
  full_name = fn(name)
767
  if full_name is None:
768
    raise errors.OpPrereqError("%s '%s' not known" % (kind, name),
769
                               errors.ECODE_NOENT)
770
  return full_name
771

    
772

    
773
def _ExpandNodeName(cfg, name):
774
  """Wrapper over L{_ExpandItemName} for nodes."""
775
  return _ExpandItemName(cfg.ExpandNodeName, name, "Node")
776

    
777

    
778
def _ExpandInstanceName(cfg, name):
779
  """Wrapper over L{_ExpandItemName} for instance."""
780
  return _ExpandItemName(cfg.ExpandInstanceName, name, "Instance")
781

    
782

    
783
def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,
784
                          memory, vcpus, nics, disk_template, disks,
785
                          bep, hvp, hypervisor_name):
786
  """Builds instance related env variables for hooks
787

788
  This builds the hook environment from individual variables.
789

790
  @type name: string
791
  @param name: the name of the instance
792
  @type primary_node: string
793
  @param primary_node: the name of the instance's primary node
794
  @type secondary_nodes: list
795
  @param secondary_nodes: list of secondary nodes as strings
796
  @type os_type: string
797
  @param os_type: the name of the instance's OS
798
  @type status: boolean
799
  @param status: the should_run status of the instance
800
  @type memory: string
801
  @param memory: the memory size of the instance
802
  @type vcpus: string
803
  @param vcpus: the count of VCPUs the instance has
804
  @type nics: list
805
  @param nics: list of tuples (ip, mac, mode, link) representing
806
      the NICs the instance has
807
  @type disk_template: string
808
  @param disk_template: the disk template of the instance
809
  @type disks: list
810
  @param disks: the list of (size, mode) pairs
811
  @type bep: dict
812
  @param bep: the backend parameters for the instance
813
  @type hvp: dict
814
  @param hvp: the hypervisor parameters for the instance
815
  @type hypervisor_name: string
816
  @param hypervisor_name: the hypervisor for the instance
817
  @rtype: dict
818
  @return: the hook environment for this instance
819

820
  """
821
  if status:
822
    str_status = "up"
823
  else:
824
    str_status = "down"
825
  env = {
826
    "OP_TARGET": name,
827
    "INSTANCE_NAME": name,
828
    "INSTANCE_PRIMARY": primary_node,
829
    "INSTANCE_SECONDARIES": " ".join(secondary_nodes),
830
    "INSTANCE_OS_TYPE": os_type,
831
    "INSTANCE_STATUS": str_status,
832
    "INSTANCE_MEMORY": memory,
833
    "INSTANCE_VCPUS": vcpus,
834
    "INSTANCE_DISK_TEMPLATE": disk_template,
835
    "INSTANCE_HYPERVISOR": hypervisor_name,
836
  }
837

    
838
  if nics:
839
    nic_count = len(nics)
840
    for idx, (ip, mac, mode, link) in enumerate(nics):
841
      if ip is None:
842
        ip = ""
843
      env["INSTANCE_NIC%d_IP" % idx] = ip
844
      env["INSTANCE_NIC%d_MAC" % idx] = mac
845
      env["INSTANCE_NIC%d_MODE" % idx] = mode
846
      env["INSTANCE_NIC%d_LINK" % idx] = link
847
      if mode == constants.NIC_MODE_BRIDGED:
848
        env["INSTANCE_NIC%d_BRIDGE" % idx] = link
849
  else:
850
    nic_count = 0
851

    
852
  env["INSTANCE_NIC_COUNT"] = nic_count
853

    
854
  if disks:
855
    disk_count = len(disks)
856
    for idx, (size, mode) in enumerate(disks):
857
      env["INSTANCE_DISK%d_SIZE" % idx] = size
858
      env["INSTANCE_DISK%d_MODE" % idx] = mode
859
  else:
860
    disk_count = 0
861

    
862
  env["INSTANCE_DISK_COUNT"] = disk_count
863

    
864
  for source, kind in [(bep, "BE"), (hvp, "HV")]:
865
    for key, value in source.items():
866
      env["INSTANCE_%s_%s" % (kind, key)] = value
867

    
868
  return env
869

    
870

    
871
def _NICListToTuple(lu, nics):
872
  """Build a list of nic information tuples.
873

874
  This list is suitable to be passed to _BuildInstanceHookEnv or as a return
875
  value in LUQueryInstanceData.
876

877
  @type lu:  L{LogicalUnit}
878
  @param lu: the logical unit on whose behalf we execute
879
  @type nics: list of L{objects.NIC}
880
  @param nics: list of nics to convert to hooks tuples
881

882
  """
883
  hooks_nics = []
884
  cluster = lu.cfg.GetClusterInfo()
885
  for nic in nics:
886
    ip = nic.ip
887
    mac = nic.mac
888
    filled_params = cluster.SimpleFillNIC(nic.nicparams)
889
    mode = filled_params[constants.NIC_MODE]
890
    link = filled_params[constants.NIC_LINK]
891
    hooks_nics.append((ip, mac, mode, link))
892
  return hooks_nics
893

    
894

    
895
def _BuildInstanceHookEnvByObject(lu, instance, override=None):
896
  """Builds instance related env variables for hooks from an object.
897

898
  @type lu: L{LogicalUnit}
899
  @param lu: the logical unit on whose behalf we execute
900
  @type instance: L{objects.Instance}
901
  @param instance: the instance for which we should build the
902
      environment
903
  @type override: dict
904
  @param override: dictionary with key/values that will override
905
      our values
906
  @rtype: dict
907
  @return: the hook environment dictionary
908

909
  """
910
  cluster = lu.cfg.GetClusterInfo()
911
  bep = cluster.FillBE(instance)
912
  hvp = cluster.FillHV(instance)
913
  args = {
914
    'name': instance.name,
915
    'primary_node': instance.primary_node,
916
    'secondary_nodes': instance.secondary_nodes,
917
    'os_type': instance.os,
918
    'status': instance.admin_up,
919
    'memory': bep[constants.BE_MEMORY],
920
    'vcpus': bep[constants.BE_VCPUS],
921
    'nics': _NICListToTuple(lu, instance.nics),
922
    'disk_template': instance.disk_template,
923
    'disks': [(disk.size, disk.mode) for disk in instance.disks],
924
    'bep': bep,
925
    'hvp': hvp,
926
    'hypervisor_name': instance.hypervisor,
927
  }
928
  if override:
929
    args.update(override)
930
  return _BuildInstanceHookEnv(**args) # pylint: disable-msg=W0142
931

    
932

    
933
def _AdjustCandidatePool(lu, exceptions):
934
  """Adjust the candidate pool after node operations.
935

936
  """
937
  mod_list = lu.cfg.MaintainCandidatePool(exceptions)
938
  if mod_list:
939
    lu.LogInfo("Promoted nodes to master candidate role: %s",
940
               utils.CommaJoin(node.name for node in mod_list))
941
    for name in mod_list:
942
      lu.context.ReaddNode(name)
943
  mc_now, mc_max, _ = lu.cfg.GetMasterCandidateStats(exceptions)
944
  if mc_now > mc_max:
945
    lu.LogInfo("Note: more nodes are candidates (%d) than desired (%d)" %
946
               (mc_now, mc_max))
947

    
948

    
949
def _DecideSelfPromotion(lu, exceptions=None):
950
  """Decide whether I should promote myself as a master candidate.
951

952
  """
953
  cp_size = lu.cfg.GetClusterInfo().candidate_pool_size
954
  mc_now, mc_should, _ = lu.cfg.GetMasterCandidateStats(exceptions)
955
  # the new node will increase mc_max with one, so:
956
  mc_should = min(mc_should + 1, cp_size)
957
  return mc_now < mc_should
958

    
959

    
960
def _CheckNicsBridgesExist(lu, target_nics, target_node):
961
  """Check that the brigdes needed by a list of nics exist.
962

963
  """
964
  cluster = lu.cfg.GetClusterInfo()
965
  paramslist = [cluster.SimpleFillNIC(nic.nicparams) for nic in target_nics]
966
  brlist = [params[constants.NIC_LINK] for params in paramslist
967
            if params[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED]
968
  if brlist:
969
    result = lu.rpc.call_bridges_exist(target_node, brlist)
970
    result.Raise("Error checking bridges on destination node '%s'" %
971
                 target_node, prereq=True, ecode=errors.ECODE_ENVIRON)
972

    
973

    
974
def _CheckInstanceBridgesExist(lu, instance, node=None):
975
  """Check that the brigdes needed by an instance exist.
976

977
  """
978
  if node is None:
979
    node = instance.primary_node
980
  _CheckNicsBridgesExist(lu, instance.nics, node)
981

    
982

    
983
def _CheckOSVariant(os_obj, name):
984
  """Check whether an OS name conforms to the os variants specification.
985

986
  @type os_obj: L{objects.OS}
987
  @param os_obj: OS object to check
988
  @type name: string
989
  @param name: OS name passed by the user, to check for validity
990

991
  """
992
  if not os_obj.supported_variants:
993
    return
994
  variant = objects.OS.GetVariant(name)
995
  if not variant:
996
    raise errors.OpPrereqError("OS name must include a variant",
997
                               errors.ECODE_INVAL)
998

    
999
  if variant not in os_obj.supported_variants:
1000
    raise errors.OpPrereqError("Unsupported OS variant", errors.ECODE_INVAL)
1001

    
1002

    
1003
def _GetNodeInstancesInner(cfg, fn):
1004
  return [i for i in cfg.GetAllInstancesInfo().values() if fn(i)]
1005

    
1006

    
1007
def _GetNodeInstances(cfg, node_name):
1008
  """Returns a list of all primary and secondary instances on a node.
1009

1010
  """
1011

    
1012
  return _GetNodeInstancesInner(cfg, lambda inst: node_name in inst.all_nodes)
1013

    
1014

    
1015
def _GetNodePrimaryInstances(cfg, node_name):
1016
  """Returns primary instances on a node.
1017

1018
  """
1019
  return _GetNodeInstancesInner(cfg,
1020
                                lambda inst: node_name == inst.primary_node)
1021

    
1022

    
1023
def _GetNodeSecondaryInstances(cfg, node_name):
1024
  """Returns secondary instances on a node.
1025

1026
  """
1027
  return _GetNodeInstancesInner(cfg,
1028
                                lambda inst: node_name in inst.secondary_nodes)
1029

    
1030

    
1031
def _GetStorageTypeArgs(cfg, storage_type):
1032
  """Returns the arguments for a storage type.
1033

1034
  """
1035
  # Special case for file storage
1036
  if storage_type == constants.ST_FILE:
1037
    # storage.FileStorage wants a list of storage directories
1038
    return [[cfg.GetFileStorageDir()]]
1039

    
1040
  return []
1041

    
1042

    
1043
def _FindFaultyInstanceDisks(cfg, rpc, instance, node_name, prereq):
1044
  faulty = []
1045

    
1046
  for dev in instance.disks:
1047
    cfg.SetDiskID(dev, node_name)
1048

    
1049
  result = rpc.call_blockdev_getmirrorstatus(node_name, instance.disks)
1050
  result.Raise("Failed to get disk status from node %s" % node_name,
1051
               prereq=prereq, ecode=errors.ECODE_ENVIRON)
1052

    
1053
  for idx, bdev_status in enumerate(result.payload):
1054
    if bdev_status and bdev_status.ldisk_status == constants.LDS_FAULTY:
1055
      faulty.append(idx)
1056

    
1057
  return faulty
1058

    
1059

    
1060
def _CheckIAllocatorOrNode(lu, iallocator_slot, node_slot):
1061
  """Check the sanity of iallocator and node arguments and use the
1062
  cluster-wide iallocator if appropriate.
1063

1064
  Check that at most one of (iallocator, node) is specified. If none is
1065
  specified, then the LU's opcode's iallocator slot is filled with the
1066
  cluster-wide default iallocator.
1067

1068
  @type iallocator_slot: string
1069
  @param iallocator_slot: the name of the opcode iallocator slot
1070
  @type node_slot: string
1071
  @param node_slot: the name of the opcode target node slot
1072

1073
  """
1074
  node = getattr(lu.op, node_slot, None)
1075
  iallocator = getattr(lu.op, iallocator_slot, None)
1076

    
1077
  if node is not None and iallocator is not None:
1078
    raise errors.OpPrereqError("Do not specify both, iallocator and node.",
1079
                               errors.ECODE_INVAL)
1080
  elif node is None and iallocator is None:
1081
    default_iallocator = lu.cfg.GetDefaultIAllocator()
1082
    if default_iallocator:
1083
      setattr(lu.op, iallocator_slot, default_iallocator)
1084
    else:
1085
      raise errors.OpPrereqError("No iallocator or node given and no"
1086
                                 " cluster-wide default iallocator found."
1087
                                 " Please specify either an iallocator or a"
1088
                                 " node, or set a cluster-wide default"
1089
                                 " iallocator.")
1090

    
1091

    
1092
class LUPostInitCluster(LogicalUnit):
1093
  """Logical unit for running hooks after cluster initialization.
1094

1095
  """
1096
  HPATH = "cluster-init"
1097
  HTYPE = constants.HTYPE_CLUSTER
1098

    
1099
  def BuildHooksEnv(self):
1100
    """Build hooks env.
1101

1102
    """
1103
    env = {"OP_TARGET": self.cfg.GetClusterName()}
1104
    mn = self.cfg.GetMasterNode()
1105
    return env, [], [mn]
1106

    
1107
  def Exec(self, feedback_fn):
1108
    """Nothing to do.
1109

1110
    """
1111
    return True
1112

    
1113

    
1114
class LUDestroyCluster(LogicalUnit):
1115
  """Logical unit for destroying the cluster.
1116

1117
  """
1118
  HPATH = "cluster-destroy"
1119
  HTYPE = constants.HTYPE_CLUSTER
1120

    
1121
  def BuildHooksEnv(self):
1122
    """Build hooks env.
1123

1124
    """
1125
    env = {"OP_TARGET": self.cfg.GetClusterName()}
1126
    return env, [], []
1127

    
1128
  def CheckPrereq(self):
1129
    """Check prerequisites.
1130

1131
    This checks whether the cluster is empty.
1132

1133
    Any errors are signaled by raising errors.OpPrereqError.
1134

1135
    """
1136
    master = self.cfg.GetMasterNode()
1137

    
1138
    nodelist = self.cfg.GetNodeList()
1139
    if len(nodelist) != 1 or nodelist[0] != master:
1140
      raise errors.OpPrereqError("There are still %d node(s) in"
1141
                                 " this cluster." % (len(nodelist) - 1),
1142
                                 errors.ECODE_INVAL)
1143
    instancelist = self.cfg.GetInstanceList()
1144
    if instancelist:
1145
      raise errors.OpPrereqError("There are still %d instance(s) in"
1146
                                 " this cluster." % len(instancelist),
1147
                                 errors.ECODE_INVAL)
1148

    
1149
  def Exec(self, feedback_fn):
1150
    """Destroys the cluster.
1151

1152
    """
1153
    master = self.cfg.GetMasterNode()
1154

    
1155
    # Run post hooks on master node before it's removed
1156
    hm = self.proc.hmclass(self.rpc.call_hooks_runner, self)
1157
    try:
1158
      hm.RunPhase(constants.HOOKS_PHASE_POST, [master])
1159
    except:
1160
      # pylint: disable-msg=W0702
1161
      self.LogWarning("Errors occurred running hooks on %s" % master)
1162

    
1163
    result = self.rpc.call_node_stop_master(master, False)
1164
    result.Raise("Could not disable the master role")
1165

    
1166
    return master
1167

    
1168

    
1169
def _VerifyCertificate(filename):
1170
  """Verifies a certificate for LUVerifyCluster.
1171

1172
  @type filename: string
1173
  @param filename: Path to PEM file
1174

1175
  """
1176
  try:
1177
    cert = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,
1178
                                           utils.ReadFile(filename))
1179
  except Exception, err: # pylint: disable-msg=W0703
1180
    return (LUVerifyCluster.ETYPE_ERROR,
1181
            "Failed to load X509 certificate %s: %s" % (filename, err))
1182

    
1183
  (errcode, msg) = \
1184
    utils.VerifyX509Certificate(cert, constants.SSL_CERT_EXPIRATION_WARN,
1185
                                constants.SSL_CERT_EXPIRATION_ERROR)
1186

    
1187
  if msg:
1188
    fnamemsg = "While verifying %s: %s" % (filename, msg)
1189
  else:
1190
    fnamemsg = None
1191

    
1192
  if errcode is None:
1193
    return (None, fnamemsg)
1194
  elif errcode == utils.CERT_WARNING:
1195
    return (LUVerifyCluster.ETYPE_WARNING, fnamemsg)
1196
  elif errcode == utils.CERT_ERROR:
1197
    return (LUVerifyCluster.ETYPE_ERROR, fnamemsg)
1198

    
1199
  raise errors.ProgrammerError("Unhandled certificate error code %r" % errcode)
1200

    
1201

    
1202
class LUVerifyCluster(LogicalUnit):
1203
  """Verifies the cluster status.
1204

1205
  """
1206
  HPATH = "cluster-verify"
1207
  HTYPE = constants.HTYPE_CLUSTER
1208
  REQ_BGL = False
1209

    
1210
  TCLUSTER = "cluster"
1211
  TNODE = "node"
1212
  TINSTANCE = "instance"
1213

    
1214
  ECLUSTERCFG = (TCLUSTER, "ECLUSTERCFG")
1215
  ECLUSTERCERT = (TCLUSTER, "ECLUSTERCERT")
1216
  EINSTANCEBADNODE = (TINSTANCE, "EINSTANCEBADNODE")
1217
  EINSTANCEDOWN = (TINSTANCE, "EINSTANCEDOWN")
1218
  EINSTANCELAYOUT = (TINSTANCE, "EINSTANCELAYOUT")
1219
  EINSTANCEMISSINGDISK = (TINSTANCE, "EINSTANCEMISSINGDISK")
1220
  EINSTANCEFAULTYDISK = (TINSTANCE, "EINSTANCEFAULTYDISK")
1221
  EINSTANCEWRONGNODE = (TINSTANCE, "EINSTANCEWRONGNODE")
1222
  ENODEDRBD = (TNODE, "ENODEDRBD")
1223
  ENODEDRBDHELPER = (TNODE, "ENODEDRBDHELPER")
1224
  ENODEFILECHECK = (TNODE, "ENODEFILECHECK")
1225
  ENODEHOOKS = (TNODE, "ENODEHOOKS")
1226
  ENODEHV = (TNODE, "ENODEHV")
1227
  ENODELVM = (TNODE, "ENODELVM")
1228
  ENODEN1 = (TNODE, "ENODEN1")
1229
  ENODENET = (TNODE, "ENODENET")
1230
  ENODEOS = (TNODE, "ENODEOS")
1231
  ENODEORPHANINSTANCE = (TNODE, "ENODEORPHANINSTANCE")
1232
  ENODEORPHANLV = (TNODE, "ENODEORPHANLV")
1233
  ENODERPC = (TNODE, "ENODERPC")
1234
  ENODESSH = (TNODE, "ENODESSH")
1235
  ENODEVERSION = (TNODE, "ENODEVERSION")
1236
  ENODESETUP = (TNODE, "ENODESETUP")
1237
  ENODETIME = (TNODE, "ENODETIME")
1238
  ENODEOOBPATH = (TNODE, "ENODEOOBPATH")
1239

    
1240
  ETYPE_FIELD = "code"
1241
  ETYPE_ERROR = "ERROR"
1242
  ETYPE_WARNING = "WARNING"
1243

    
1244
  _HOOKS_INDENT_RE = re.compile("^", re.M)
1245

    
1246
  class NodeImage(object):
1247
    """A class representing the logical and physical status of a node.
1248

1249
    @type name: string
1250
    @ivar name: the node name to which this object refers
1251
    @ivar volumes: a structure as returned from
1252
        L{ganeti.backend.GetVolumeList} (runtime)
1253
    @ivar instances: a list of running instances (runtime)
1254
    @ivar pinst: list of configured primary instances (config)
1255
    @ivar sinst: list of configured secondary instances (config)
1256
    @ivar sbp: diction of {secondary-node: list of instances} of all peers
1257
        of this node (config)
1258
    @ivar mfree: free memory, as reported by hypervisor (runtime)
1259
    @ivar dfree: free disk, as reported by the node (runtime)
1260
    @ivar offline: the offline status (config)
1261
    @type rpc_fail: boolean
1262
    @ivar rpc_fail: whether the RPC verify call was successfull (overall,
1263
        not whether the individual keys were correct) (runtime)
1264
    @type lvm_fail: boolean
1265
    @ivar lvm_fail: whether the RPC call didn't return valid LVM data
1266
    @type hyp_fail: boolean
1267
    @ivar hyp_fail: whether the RPC call didn't return the instance list
1268
    @type ghost: boolean
1269
    @ivar ghost: whether this is a known node or not (config)
1270
    @type os_fail: boolean
1271
    @ivar os_fail: whether the RPC call didn't return valid OS data
1272
    @type oslist: list
1273
    @ivar oslist: list of OSes as diagnosed by DiagnoseOS
1274
    @type vm_capable: boolean
1275
    @ivar vm_capable: whether the node can host instances
1276

1277
    """
1278
    def __init__(self, offline=False, name=None, vm_capable=True):
1279
      self.name = name
1280
      self.volumes = {}
1281
      self.instances = []
1282
      self.pinst = []
1283
      self.sinst = []
1284
      self.sbp = {}
1285
      self.mfree = 0
1286
      self.dfree = 0
1287
      self.offline = offline
1288
      self.vm_capable = vm_capable
1289
      self.rpc_fail = False
1290
      self.lvm_fail = False
1291
      self.hyp_fail = False
1292
      self.ghost = False
1293
      self.os_fail = False
1294
      self.oslist = {}
1295

    
1296
  def ExpandNames(self):
1297
    self.needed_locks = {
1298
      locking.LEVEL_NODE: locking.ALL_SET,
1299
      locking.LEVEL_INSTANCE: locking.ALL_SET,
1300
    }
1301
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
1302

    
1303
  def _Error(self, ecode, item, msg, *args, **kwargs):
1304
    """Format an error message.
1305

1306
    Based on the opcode's error_codes parameter, either format a
1307
    parseable error code, or a simpler error string.
1308

1309
    This must be called only from Exec and functions called from Exec.
1310

1311
    """
1312
    ltype = kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR)
1313
    itype, etxt = ecode
1314
    # first complete the msg
1315
    if args:
1316
      msg = msg % args
1317
    # then format the whole message
1318
    if self.op.error_codes:
1319
      msg = "%s:%s:%s:%s:%s" % (ltype, etxt, itype, item, msg)
1320
    else:
1321
      if item:
1322
        item = " " + item
1323
      else:
1324
        item = ""
1325
      msg = "%s: %s%s: %s" % (ltype, itype, item, msg)
1326
    # and finally report it via the feedback_fn
1327
    self._feedback_fn("  - %s" % msg)
1328

    
1329
  def _ErrorIf(self, cond, *args, **kwargs):
1330
    """Log an error message if the passed condition is True.
1331

1332
    """
1333
    cond = bool(cond) or self.op.debug_simulate_errors
1334
    if cond:
1335
      self._Error(*args, **kwargs)
1336
    # do not mark the operation as failed for WARN cases only
1337
    if kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR) == self.ETYPE_ERROR:
1338
      self.bad = self.bad or cond
1339

    
1340
  def _VerifyNode(self, ninfo, nresult):
1341
    """Perform some basic validation on data returned from a node.
1342

1343
      - check the result data structure is well formed and has all the
1344
        mandatory fields
1345
      - check ganeti version
1346

1347
    @type ninfo: L{objects.Node}
1348
    @param ninfo: the node to check
1349
    @param nresult: the results from the node
1350
    @rtype: boolean
1351
    @return: whether overall this call was successful (and we can expect
1352
         reasonable values in the respose)
1353

1354
    """
1355
    node = ninfo.name
1356
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1357

    
1358
    # main result, nresult should be a non-empty dict
1359
    test = not nresult or not isinstance(nresult, dict)
1360
    _ErrorIf(test, self.ENODERPC, node,
1361
                  "unable to verify node: no data returned")
1362
    if test:
1363
      return False
1364

    
1365
    # compares ganeti version
1366
    local_version = constants.PROTOCOL_VERSION
1367
    remote_version = nresult.get("version", None)
1368
    test = not (remote_version and
1369
                isinstance(remote_version, (list, tuple)) and
1370
                len(remote_version) == 2)
1371
    _ErrorIf(test, self.ENODERPC, node,
1372
             "connection to node returned invalid data")
1373
    if test:
1374
      return False
1375

    
1376
    test = local_version != remote_version[0]
1377
    _ErrorIf(test, self.ENODEVERSION, node,
1378
             "incompatible protocol versions: master %s,"
1379
             " node %s", local_version, remote_version[0])
1380
    if test:
1381
      return False
1382

    
1383
    # node seems compatible, we can actually try to look into its results
1384

    
1385
    # full package version
1386
    self._ErrorIf(constants.RELEASE_VERSION != remote_version[1],
1387
                  self.ENODEVERSION, node,
1388
                  "software version mismatch: master %s, node %s",
1389
                  constants.RELEASE_VERSION, remote_version[1],
1390
                  code=self.ETYPE_WARNING)
1391

    
1392
    hyp_result = nresult.get(constants.NV_HYPERVISOR, None)
1393
    if ninfo.vm_capable and isinstance(hyp_result, dict):
1394
      for hv_name, hv_result in hyp_result.iteritems():
1395
        test = hv_result is not None
1396
        _ErrorIf(test, self.ENODEHV, node,
1397
                 "hypervisor %s verify failure: '%s'", hv_name, hv_result)
1398

    
1399
    test = nresult.get(constants.NV_NODESETUP,
1400
                           ["Missing NODESETUP results"])
1401
    _ErrorIf(test, self.ENODESETUP, node, "node setup error: %s",
1402
             "; ".join(test))
1403

    
1404
    return True
1405

    
1406
  def _VerifyNodeTime(self, ninfo, nresult,
1407
                      nvinfo_starttime, nvinfo_endtime):
1408
    """Check the node time.
1409

1410
    @type ninfo: L{objects.Node}
1411
    @param ninfo: the node to check
1412
    @param nresult: the remote results for the node
1413
    @param nvinfo_starttime: the start time of the RPC call
1414
    @param nvinfo_endtime: the end time of the RPC call
1415

1416
    """
1417
    node = ninfo.name
1418
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1419

    
1420
    ntime = nresult.get(constants.NV_TIME, None)
1421
    try:
1422
      ntime_merged = utils.MergeTime(ntime)
1423
    except (ValueError, TypeError):
1424
      _ErrorIf(True, self.ENODETIME, node, "Node returned invalid time")
1425
      return
1426

    
1427
    if ntime_merged < (nvinfo_starttime - constants.NODE_MAX_CLOCK_SKEW):
1428
      ntime_diff = "%.01fs" % abs(nvinfo_starttime - ntime_merged)
1429
    elif ntime_merged > (nvinfo_endtime + constants.NODE_MAX_CLOCK_SKEW):
1430
      ntime_diff = "%.01fs" % abs(ntime_merged - nvinfo_endtime)
1431
    else:
1432
      ntime_diff = None
1433

    
1434
    _ErrorIf(ntime_diff is not None, self.ENODETIME, node,
1435
             "Node time diverges by at least %s from master node time",
1436
             ntime_diff)
1437

    
1438
  def _VerifyNodeLVM(self, ninfo, nresult, vg_name):
1439
    """Check the node time.
1440

1441
    @type ninfo: L{objects.Node}
1442
    @param ninfo: the node to check
1443
    @param nresult: the remote results for the node
1444
    @param vg_name: the configured VG name
1445

1446
    """
1447
    if vg_name is None:
1448
      return
1449

    
1450
    node = ninfo.name
1451
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1452

    
1453
    # checks vg existence and size > 20G
1454
    vglist = nresult.get(constants.NV_VGLIST, None)
1455
    test = not vglist
1456
    _ErrorIf(test, self.ENODELVM, node, "unable to check volume groups")
1457
    if not test:
1458
      vgstatus = utils.CheckVolumeGroupSize(vglist, vg_name,
1459
                                            constants.MIN_VG_SIZE)
1460
      _ErrorIf(vgstatus, self.ENODELVM, node, vgstatus)
1461

    
1462
    # check pv names
1463
    pvlist = nresult.get(constants.NV_PVLIST, None)
1464
    test = pvlist is None
1465
    _ErrorIf(test, self.ENODELVM, node, "Can't get PV list from node")
1466
    if not test:
1467
      # check that ':' is not present in PV names, since it's a
1468
      # special character for lvcreate (denotes the range of PEs to
1469
      # use on the PV)
1470
      for _, pvname, owner_vg in pvlist:
1471
        test = ":" in pvname
1472
        _ErrorIf(test, self.ENODELVM, node, "Invalid character ':' in PV"
1473
                 " '%s' of VG '%s'", pvname, owner_vg)
1474

    
1475
  def _VerifyNodeNetwork(self, ninfo, nresult):
1476
    """Check the node time.
1477

1478
    @type ninfo: L{objects.Node}
1479
    @param ninfo: the node to check
1480
    @param nresult: the remote results for the node
1481

1482
    """
1483
    node = ninfo.name
1484
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1485

    
1486
    test = constants.NV_NODELIST not in nresult
1487
    _ErrorIf(test, self.ENODESSH, node,
1488
             "node hasn't returned node ssh connectivity data")
1489
    if not test:
1490
      if nresult[constants.NV_NODELIST]:
1491
        for a_node, a_msg in nresult[constants.NV_NODELIST].items():
1492
          _ErrorIf(True, self.ENODESSH, node,
1493
                   "ssh communication with node '%s': %s", a_node, a_msg)
1494

    
1495
    test = constants.NV_NODENETTEST not in nresult
1496
    _ErrorIf(test, self.ENODENET, node,
1497
             "node hasn't returned node tcp connectivity data")
1498
    if not test:
1499
      if nresult[constants.NV_NODENETTEST]:
1500
        nlist = utils.NiceSort(nresult[constants.NV_NODENETTEST].keys())
1501
        for anode in nlist:
1502
          _ErrorIf(True, self.ENODENET, node,
1503
                   "tcp communication with node '%s': %s",
1504
                   anode, nresult[constants.NV_NODENETTEST][anode])
1505

    
1506
    test = constants.NV_MASTERIP not in nresult
1507
    _ErrorIf(test, self.ENODENET, node,
1508
             "node hasn't returned node master IP reachability data")
1509
    if not test:
1510
      if not nresult[constants.NV_MASTERIP]:
1511
        if node == self.master_node:
1512
          msg = "the master node cannot reach the master IP (not configured?)"
1513
        else:
1514
          msg = "cannot reach the master IP"
1515
        _ErrorIf(True, self.ENODENET, node, msg)
1516

    
1517
  def _VerifyInstance(self, instance, instanceconfig, node_image,
1518
                      diskstatus):
1519
    """Verify an instance.
1520

1521
    This function checks to see if the required block devices are
1522
    available on the instance's node.
1523

1524
    """
1525
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1526
    node_current = instanceconfig.primary_node
1527

    
1528
    node_vol_should = {}
1529
    instanceconfig.MapLVsByNode(node_vol_should)
1530

    
1531
    for node in node_vol_should:
1532
      n_img = node_image[node]
1533
      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
1534
        # ignore missing volumes on offline or broken nodes
1535
        continue
1536
      for volume in node_vol_should[node]:
1537
        test = volume not in n_img.volumes
1538
        _ErrorIf(test, self.EINSTANCEMISSINGDISK, instance,
1539
                 "volume %s missing on node %s", volume, node)
1540

    
1541
    if instanceconfig.admin_up:
1542
      pri_img = node_image[node_current]
1543
      test = instance not in pri_img.instances and not pri_img.offline
1544
      _ErrorIf(test, self.EINSTANCEDOWN, instance,
1545
               "instance not running on its primary node %s",
1546
               node_current)
1547

    
1548
    for node, n_img in node_image.items():
1549
      if (not node == node_current):
1550
        test = instance in n_img.instances
1551
        _ErrorIf(test, self.EINSTANCEWRONGNODE, instance,
1552
                 "instance should not run on node %s", node)
1553

    
1554
    diskdata = [(nname, success, status, idx)
1555
                for (nname, disks) in diskstatus.items()
1556
                for idx, (success, status) in enumerate(disks)]
1557

    
1558
    for nname, success, bdev_status, idx in diskdata:
1559
      _ErrorIf(instanceconfig.admin_up and not success,
1560
               self.EINSTANCEFAULTYDISK, instance,
1561
               "couldn't retrieve status for disk/%s on %s: %s",
1562
               idx, nname, bdev_status)
1563
      _ErrorIf((instanceconfig.admin_up and success and
1564
                bdev_status.ldisk_status == constants.LDS_FAULTY),
1565
               self.EINSTANCEFAULTYDISK, instance,
1566
               "disk/%s on %s is faulty", idx, nname)
1567

    
1568
  def _VerifyOrphanVolumes(self, node_vol_should, node_image, reserved):
1569
    """Verify if there are any unknown volumes in the cluster.
1570

1571
    The .os, .swap and backup volumes are ignored. All other volumes are
1572
    reported as unknown.
1573

1574
    @type reserved: L{ganeti.utils.FieldSet}
1575
    @param reserved: a FieldSet of reserved volume names
1576

1577
    """
1578
    for node, n_img in node_image.items():
1579
      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
1580
        # skip non-healthy nodes
1581
        continue
1582
      for volume in n_img.volumes:
1583
        test = ((node not in node_vol_should or
1584
                volume not in node_vol_should[node]) and
1585
                not reserved.Matches(volume))
1586
        self._ErrorIf(test, self.ENODEORPHANLV, node,
1587
                      "volume %s is unknown", volume)
1588

    
1589
  def _VerifyOrphanInstances(self, instancelist, node_image):
1590
    """Verify the list of running instances.
1591

1592
    This checks what instances are running but unknown to the cluster.
1593

1594
    """
1595
    for node, n_img in node_image.items():
1596
      for o_inst in n_img.instances:
1597
        test = o_inst not in instancelist
1598
        self._ErrorIf(test, self.ENODEORPHANINSTANCE, node,
1599
                      "instance %s on node %s should not exist", o_inst, node)
1600

    
1601
  def _VerifyNPlusOneMemory(self, node_image, instance_cfg):
1602
    """Verify N+1 Memory Resilience.
1603

1604
    Check that if one single node dies we can still start all the
1605
    instances it was primary for.
1606

1607
    """
1608
    for node, n_img in node_image.items():
1609
      # This code checks that every node which is now listed as
1610
      # secondary has enough memory to host all instances it is
1611
      # supposed to should a single other node in the cluster fail.
1612
      # FIXME: not ready for failover to an arbitrary node
1613
      # FIXME: does not support file-backed instances
1614
      # WARNING: we currently take into account down instances as well
1615
      # as up ones, considering that even if they're down someone
1616
      # might want to start them even in the event of a node failure.
1617
      for prinode, instances in n_img.sbp.items():
1618
        needed_mem = 0
1619
        for instance in instances:
1620
          bep = self.cfg.GetClusterInfo().FillBE(instance_cfg[instance])
1621
          if bep[constants.BE_AUTO_BALANCE]:
1622
            needed_mem += bep[constants.BE_MEMORY]
1623
        test = n_img.mfree < needed_mem
1624
        self._ErrorIf(test, self.ENODEN1, node,
1625
                      "not enough memory to accomodate instance failovers"
1626
                      " should node %s fail", prinode)
1627

    
1628
  def _VerifyNodeFiles(self, ninfo, nresult, file_list, local_cksum,
1629
                       master_files):
1630
    """Verifies and computes the node required file checksums.
1631

1632
    @type ninfo: L{objects.Node}
1633
    @param ninfo: the node to check
1634
    @param nresult: the remote results for the node
1635
    @param file_list: required list of files
1636
    @param local_cksum: dictionary of local files and their checksums
1637
    @param master_files: list of files that only masters should have
1638

1639
    """
1640
    node = ninfo.name
1641
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1642

    
1643
    remote_cksum = nresult.get(constants.NV_FILELIST, None)
1644
    test = not isinstance(remote_cksum, dict)
1645
    _ErrorIf(test, self.ENODEFILECHECK, node,
1646
             "node hasn't returned file checksum data")
1647
    if test:
1648
      return
1649

    
1650
    for file_name in file_list:
1651
      node_is_mc = ninfo.master_candidate
1652
      must_have = (file_name not in master_files) or node_is_mc
1653
      # missing
1654
      test1 = file_name not in remote_cksum
1655
      # invalid checksum
1656
      test2 = not test1 and remote_cksum[file_name] != local_cksum[file_name]
1657
      # existing and good
1658
      test3 = not test1 and remote_cksum[file_name] == local_cksum[file_name]
1659
      _ErrorIf(test1 and must_have, self.ENODEFILECHECK, node,
1660
               "file '%s' missing", file_name)
1661
      _ErrorIf(test2 and must_have, self.ENODEFILECHECK, node,
1662
               "file '%s' has wrong checksum", file_name)
1663
      # not candidate and this is not a must-have file
1664
      _ErrorIf(test2 and not must_have, self.ENODEFILECHECK, node,
1665
               "file '%s' should not exist on non master"
1666
               " candidates (and the file is outdated)", file_name)
1667
      # all good, except non-master/non-must have combination
1668
      _ErrorIf(test3 and not must_have, self.ENODEFILECHECK, node,
1669
               "file '%s' should not exist"
1670
               " on non master candidates", file_name)
1671

    
1672
  def _VerifyNodeDrbd(self, ninfo, nresult, instanceinfo, drbd_helper,
1673
                      drbd_map):
1674
    """Verifies and the node DRBD status.
1675

1676
    @type ninfo: L{objects.Node}
1677
    @param ninfo: the node to check
1678
    @param nresult: the remote results for the node
1679
    @param instanceinfo: the dict of instances
1680
    @param drbd_helper: the configured DRBD usermode helper
1681
    @param drbd_map: the DRBD map as returned by
1682
        L{ganeti.config.ConfigWriter.ComputeDRBDMap}
1683

1684
    """
1685
    node = ninfo.name
1686
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1687

    
1688
    if drbd_helper:
1689
      helper_result = nresult.get(constants.NV_DRBDHELPER, None)
1690
      test = (helper_result == None)
1691
      _ErrorIf(test, self.ENODEDRBDHELPER, node,
1692
               "no drbd usermode helper returned")
1693
      if helper_result:
1694
        status, payload = helper_result
1695
        test = not status
1696
        _ErrorIf(test, self.ENODEDRBDHELPER, node,
1697
                 "drbd usermode helper check unsuccessful: %s", payload)
1698
        test = status and (payload != drbd_helper)
1699
        _ErrorIf(test, self.ENODEDRBDHELPER, node,
1700
                 "wrong drbd usermode helper: %s", payload)
1701

    
1702
    # compute the DRBD minors
1703
    node_drbd = {}
1704
    for minor, instance in drbd_map[node].items():
1705
      test = instance not in instanceinfo
1706
      _ErrorIf(test, self.ECLUSTERCFG, None,
1707
               "ghost instance '%s' in temporary DRBD map", instance)
1708
        # ghost instance should not be running, but otherwise we
1709
        # don't give double warnings (both ghost instance and
1710
        # unallocated minor in use)
1711
      if test:
1712
        node_drbd[minor] = (instance, False)
1713
      else:
1714
        instance = instanceinfo[instance]
1715
        node_drbd[minor] = (instance.name, instance.admin_up)
1716

    
1717
    # and now check them
1718
    used_minors = nresult.get(constants.NV_DRBDLIST, [])
1719
    test = not isinstance(used_minors, (tuple, list))
1720
    _ErrorIf(test, self.ENODEDRBD, node,
1721
             "cannot parse drbd status file: %s", str(used_minors))
1722
    if test:
1723
      # we cannot check drbd status
1724
      return
1725

    
1726
    for minor, (iname, must_exist) in node_drbd.items():
1727
      test = minor not in used_minors and must_exist
1728
      _ErrorIf(test, self.ENODEDRBD, node,
1729
               "drbd minor %d of instance %s is not active", minor, iname)
1730
    for minor in used_minors:
1731
      test = minor not in node_drbd
1732
      _ErrorIf(test, self.ENODEDRBD, node,
1733
               "unallocated drbd minor %d is in use", minor)
1734

    
1735
  def _UpdateNodeOS(self, ninfo, nresult, nimg):
1736
    """Builds the node OS structures.
1737

1738
    @type ninfo: L{objects.Node}
1739
    @param ninfo: the node to check
1740
    @param nresult: the remote results for the node
1741
    @param nimg: the node image object
1742

1743
    """
1744
    node = ninfo.name
1745
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1746

    
1747
    remote_os = nresult.get(constants.NV_OSLIST, None)
1748
    test = (not isinstance(remote_os, list) or
1749
            not compat.all(isinstance(v, list) and len(v) == 7
1750
                           for v in remote_os))
1751

    
1752
    _ErrorIf(test, self.ENODEOS, node,
1753
             "node hasn't returned valid OS data")
1754

    
1755
    nimg.os_fail = test
1756

    
1757
    if test:
1758
      return
1759

    
1760
    os_dict = {}
1761

    
1762
    for (name, os_path, status, diagnose,
1763
         variants, parameters, api_ver) in nresult[constants.NV_OSLIST]:
1764

    
1765
      if name not in os_dict:
1766
        os_dict[name] = []
1767

    
1768
      # parameters is a list of lists instead of list of tuples due to
1769
      # JSON lacking a real tuple type, fix it:
1770
      parameters = [tuple(v) for v in parameters]
1771
      os_dict[name].append((os_path, status, diagnose,
1772
                            set(variants), set(parameters), set(api_ver)))
1773

    
1774
    nimg.oslist = os_dict
1775

    
1776
  def _VerifyNodeOS(self, ninfo, nimg, base):
1777
    """Verifies the node OS list.
1778

1779
    @type ninfo: L{objects.Node}
1780
    @param ninfo: the node to check
1781
    @param nimg: the node image object
1782
    @param base: the 'template' node we match against (e.g. from the master)
1783

1784
    """
1785
    node = ninfo.name
1786
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1787

    
1788
    assert not nimg.os_fail, "Entered _VerifyNodeOS with failed OS rpc?"
1789

    
1790
    for os_name, os_data in nimg.oslist.items():
1791
      assert os_data, "Empty OS status for OS %s?!" % os_name
1792
      f_path, f_status, f_diag, f_var, f_param, f_api = os_data[0]
1793
      _ErrorIf(not f_status, self.ENODEOS, node,
1794
               "Invalid OS %s (located at %s): %s", os_name, f_path, f_diag)
1795
      _ErrorIf(len(os_data) > 1, self.ENODEOS, node,
1796
               "OS '%s' has multiple entries (first one shadows the rest): %s",
1797
               os_name, utils.CommaJoin([v[0] for v in os_data]))
1798
      # this will catched in backend too
1799
      _ErrorIf(compat.any(v >= constants.OS_API_V15 for v in f_api)
1800
               and not f_var, self.ENODEOS, node,
1801
               "OS %s with API at least %d does not declare any variant",
1802
               os_name, constants.OS_API_V15)
1803
      # comparisons with the 'base' image
1804
      test = os_name not in base.oslist
1805
      _ErrorIf(test, self.ENODEOS, node,
1806
               "Extra OS %s not present on reference node (%s)",
1807
               os_name, base.name)
1808
      if test:
1809
        continue
1810
      assert base.oslist[os_name], "Base node has empty OS status?"
1811
      _, b_status, _, b_var, b_param, b_api = base.oslist[os_name][0]
1812
      if not b_status:
1813
        # base OS is invalid, skipping
1814
        continue
1815
      for kind, a, b in [("API version", f_api, b_api),
1816
                         ("variants list", f_var, b_var),
1817
                         ("parameters", f_param, b_param)]:
1818
        _ErrorIf(a != b, self.ENODEOS, node,
1819
                 "OS %s %s differs from reference node %s: %s vs. %s",
1820
                 kind, os_name, base.name,
1821
                 utils.CommaJoin(a), utils.CommaJoin(b))
1822

    
1823
    # check any missing OSes
1824
    missing = set(base.oslist.keys()).difference(nimg.oslist.keys())
1825
    _ErrorIf(missing, self.ENODEOS, node,
1826
             "OSes present on reference node %s but missing on this node: %s",
1827
             base.name, utils.CommaJoin(missing))
1828

    
1829
  def _VerifyOob(self, ninfo, nresult):
1830
    """Verifies out of band functionality of a node.
1831

1832
    @type ninfo: L{objects.Node}
1833
    @param ninfo: the node to check
1834
    @param nresult: the remote results for the node
1835

1836
    """
1837
    node = ninfo.name
1838
    # We just have to verify the paths on master and/or master candidates
1839
    # as the oob helper is invoked on the master
1840
    if ((ninfo.master_candidate or ninfo.master) and
1841
        constants.NV_OOB_PATHS in nresult):
1842
      for path_result in nresult[constants.NV_OOB_PATHS]:
1843
        self._ErrorIf(path_result, self.ENODEOOBPATH, node, path_result)
1844

    
1845
  def _UpdateNodeVolumes(self, ninfo, nresult, nimg, vg_name):
1846
    """Verifies and updates the node volume data.
1847

1848
    This function will update a L{NodeImage}'s internal structures
1849
    with data from the remote call.
1850

1851
    @type ninfo: L{objects.Node}
1852
    @param ninfo: the node to check
1853
    @param nresult: the remote results for the node
1854
    @param nimg: the node image object
1855
    @param vg_name: the configured VG name
1856

1857
    """
1858
    node = ninfo.name
1859
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1860

    
1861
    nimg.lvm_fail = True
1862
    lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")
1863
    if vg_name is None:
1864
      pass
1865
    elif isinstance(lvdata, basestring):
1866
      _ErrorIf(True, self.ENODELVM, node, "LVM problem on node: %s",
1867
               utils.SafeEncode(lvdata))
1868
    elif not isinstance(lvdata, dict):
1869
      _ErrorIf(True, self.ENODELVM, node, "rpc call to node failed (lvlist)")
1870
    else:
1871
      nimg.volumes = lvdata
1872
      nimg.lvm_fail = False
1873

    
1874
  def _UpdateNodeInstances(self, ninfo, nresult, nimg):
1875
    """Verifies and updates the node instance list.
1876

1877
    If the listing was successful, then updates this node's instance
1878
    list. Otherwise, it marks the RPC call as failed for the instance
1879
    list key.
1880

1881
    @type ninfo: L{objects.Node}
1882
    @param ninfo: the node to check
1883
    @param nresult: the remote results for the node
1884
    @param nimg: the node image object
1885

1886
    """
1887
    idata = nresult.get(constants.NV_INSTANCELIST, None)
1888
    test = not isinstance(idata, list)
1889
    self._ErrorIf(test, self.ENODEHV, ninfo.name, "rpc call to node failed"
1890
                  " (instancelist): %s", utils.SafeEncode(str(idata)))
1891
    if test:
1892
      nimg.hyp_fail = True
1893
    else:
1894
      nimg.instances = idata
1895

    
1896
  def _UpdateNodeInfo(self, ninfo, nresult, nimg, vg_name):
1897
    """Verifies and computes a node information map
1898

1899
    @type ninfo: L{objects.Node}
1900
    @param ninfo: the node to check
1901
    @param nresult: the remote results for the node
1902
    @param nimg: the node image object
1903
    @param vg_name: the configured VG name
1904

1905
    """
1906
    node = ninfo.name
1907
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1908

    
1909
    # try to read free memory (from the hypervisor)
1910
    hv_info = nresult.get(constants.NV_HVINFO, None)
1911
    test = not isinstance(hv_info, dict) or "memory_free" not in hv_info
1912
    _ErrorIf(test, self.ENODEHV, node, "rpc call to node failed (hvinfo)")
1913
    if not test:
1914
      try:
1915
        nimg.mfree = int(hv_info["memory_free"])
1916
      except (ValueError, TypeError):
1917
        _ErrorIf(True, self.ENODERPC, node,
1918
                 "node returned invalid nodeinfo, check hypervisor")
1919

    
1920
    # FIXME: devise a free space model for file based instances as well
1921
    if vg_name is not None:
1922
      test = (constants.NV_VGLIST not in nresult or
1923
              vg_name not in nresult[constants.NV_VGLIST])
1924
      _ErrorIf(test, self.ENODELVM, node,
1925
               "node didn't return data for the volume group '%s'"
1926
               " - it is either missing or broken", vg_name)
1927
      if not test:
1928
        try:
1929
          nimg.dfree = int(nresult[constants.NV_VGLIST][vg_name])
1930
        except (ValueError, TypeError):
1931
          _ErrorIf(True, self.ENODERPC, node,
1932
                   "node returned invalid LVM info, check LVM status")
1933

    
1934
  def _CollectDiskInfo(self, nodelist, node_image, instanceinfo):
1935
    """Gets per-disk status information for all instances.
1936

1937
    @type nodelist: list of strings
1938
    @param nodelist: Node names
1939
    @type node_image: dict of (name, L{objects.Node})
1940
    @param node_image: Node objects
1941
    @type instanceinfo: dict of (name, L{objects.Instance})
1942
    @param instanceinfo: Instance objects
1943
    @rtype: {instance: {node: [(succes, payload)]}}
1944
    @return: a dictionary of per-instance dictionaries with nodes as
1945
        keys and disk information as values; the disk information is a
1946
        list of tuples (success, payload)
1947

1948
    """
1949
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1950

    
1951
    node_disks = {}
1952
    node_disks_devonly = {}
1953
    diskless_instances = set()
1954
    diskless = constants.DT_DISKLESS
1955

    
1956
    for nname in nodelist:
1957
      node_instances = list(itertools.chain(node_image[nname].pinst,
1958
                                            node_image[nname].sinst))
1959
      diskless_instances.update(inst for inst in node_instances
1960
                                if instanceinfo[inst].disk_template == diskless)
1961
      disks = [(inst, disk)
1962
               for inst in node_instances
1963
               for disk in instanceinfo[inst].disks]
1964

    
1965
      if not disks:
1966
        # No need to collect data
1967
        continue
1968

    
1969
      node_disks[nname] = disks
1970

    
1971
      # Creating copies as SetDiskID below will modify the objects and that can
1972
      # lead to incorrect data returned from nodes
1973
      devonly = [dev.Copy() for (_, dev) in disks]
1974

    
1975
      for dev in devonly:
1976
        self.cfg.SetDiskID(dev, nname)
1977

    
1978
      node_disks_devonly[nname] = devonly
1979

    
1980
    assert len(node_disks) == len(node_disks_devonly)
1981

    
1982
    # Collect data from all nodes with disks
1983
    result = self.rpc.call_blockdev_getmirrorstatus_multi(node_disks.keys(),
1984
                                                          node_disks_devonly)
1985

    
1986
    assert len(result) == len(node_disks)
1987

    
1988
    instdisk = {}
1989

    
1990
    for (nname, nres) in result.items():
1991
      disks = node_disks[nname]
1992

    
1993
      if nres.offline:
1994
        # No data from this node
1995
        data = len(disks) * [(False, "node offline")]
1996
      else:
1997
        msg = nres.fail_msg
1998
        _ErrorIf(msg, self.ENODERPC, nname,
1999
                 "while getting disk information: %s", msg)
2000
        if msg:
2001
          # No data from this node
2002
          data = len(disks) * [(False, msg)]
2003
        else:
2004
          data = []
2005
          for idx, i in enumerate(nres.payload):
2006
            if isinstance(i, (tuple, list)) and len(i) == 2:
2007
              data.append(i)
2008
            else:
2009
              logging.warning("Invalid result from node %s, entry %d: %s",
2010
                              nname, idx, i)
2011
              data.append((False, "Invalid result from the remote node"))
2012

    
2013
      for ((inst, _), status) in zip(disks, data):
2014
        instdisk.setdefault(inst, {}).setdefault(nname, []).append(status)
2015

    
2016
    # Add empty entries for diskless instances.
2017
    for inst in diskless_instances:
2018
      assert inst not in instdisk
2019
      instdisk[inst] = {}
2020

    
2021
    assert compat.all(len(statuses) == len(instanceinfo[inst].disks) and
2022
                      len(nnames) <= len(instanceinfo[inst].all_nodes) and
2023
                      compat.all(isinstance(s, (tuple, list)) and
2024
                                 len(s) == 2 for s in statuses)
2025
                      for inst, nnames in instdisk.items()
2026
                      for nname, statuses in nnames.items())
2027
    assert set(instdisk) == set(instanceinfo), "instdisk consistency failure"
2028

    
2029
    return instdisk
2030

    
2031
  def BuildHooksEnv(self):
2032
    """Build hooks env.
2033

2034
    Cluster-Verify hooks just ran in the post phase and their failure makes
2035
    the output be logged in the verify output and the verification to fail.
2036

2037
    """
2038
    all_nodes = self.cfg.GetNodeList()
2039
    env = {
2040
      "CLUSTER_TAGS": " ".join(self.cfg.GetClusterInfo().GetTags())
2041
      }
2042
    for node in self.cfg.GetAllNodesInfo().values():
2043
      env["NODE_TAGS_%s" % node.name] = " ".join(node.GetTags())
2044

    
2045
    return env, [], all_nodes
2046

    
2047
  def Exec(self, feedback_fn):
2048
    """Verify integrity of cluster, performing various test on nodes.
2049

2050
    """
2051
    self.bad = False
2052
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2053
    verbose = self.op.verbose
2054
    self._feedback_fn = feedback_fn
2055
    feedback_fn("* Verifying global settings")
2056
    for msg in self.cfg.VerifyConfig():
2057
      _ErrorIf(True, self.ECLUSTERCFG, None, msg)
2058

    
2059
    # Check the cluster certificates
2060
    for cert_filename in constants.ALL_CERT_FILES:
2061
      (errcode, msg) = _VerifyCertificate(cert_filename)
2062
      _ErrorIf(errcode, self.ECLUSTERCERT, None, msg, code=errcode)
2063

    
2064
    vg_name = self.cfg.GetVGName()
2065
    drbd_helper = self.cfg.GetDRBDHelper()
2066
    hypervisors = self.cfg.GetClusterInfo().enabled_hypervisors
2067
    cluster = self.cfg.GetClusterInfo()
2068
    nodelist = utils.NiceSort(self.cfg.GetNodeList())
2069
    nodeinfo = [self.cfg.GetNodeInfo(nname) for nname in nodelist]
2070
    instancelist = utils.NiceSort(self.cfg.GetInstanceList())
2071
    instanceinfo = dict((iname, self.cfg.GetInstanceInfo(iname))
2072
                        for iname in instancelist)
2073
    i_non_redundant = [] # Non redundant instances
2074
    i_non_a_balanced = [] # Non auto-balanced instances
2075
    n_offline = 0 # Count of offline nodes
2076
    n_drained = 0 # Count of nodes being drained
2077
    node_vol_should = {}
2078

    
2079
    # FIXME: verify OS list
2080
    # do local checksums
2081
    master_files = [constants.CLUSTER_CONF_FILE]
2082
    master_node = self.master_node = self.cfg.GetMasterNode()
2083
    master_ip = self.cfg.GetMasterIP()
2084

    
2085
    file_names = ssconf.SimpleStore().GetFileList()
2086
    file_names.extend(constants.ALL_CERT_FILES)
2087
    file_names.extend(master_files)
2088
    if cluster.modify_etc_hosts:
2089
      file_names.append(constants.ETC_HOSTS)
2090

    
2091
    local_checksums = utils.FingerprintFiles(file_names)
2092

    
2093
    feedback_fn("* Gathering data (%d nodes)" % len(nodelist))
2094
    node_verify_param = {
2095
      constants.NV_FILELIST: file_names,
2096
      constants.NV_NODELIST: [node.name for node in nodeinfo
2097
                              if not node.offline],
2098
      constants.NV_HYPERVISOR: hypervisors,
2099
      constants.NV_NODENETTEST: [(node.name, node.primary_ip,
2100
                                  node.secondary_ip) for node in nodeinfo
2101
                                 if not node.offline],
2102
      constants.NV_INSTANCELIST: hypervisors,
2103
      constants.NV_VERSION: None,
2104
      constants.NV_HVINFO: self.cfg.GetHypervisorType(),
2105
      constants.NV_NODESETUP: None,
2106
      constants.NV_TIME: None,
2107
      constants.NV_MASTERIP: (master_node, master_ip),
2108
      constants.NV_OSLIST: None,
2109
      constants.NV_VMNODES: self.cfg.GetNonVmCapableNodeList(),
2110
      }
2111

    
2112
    if vg_name is not None:
2113
      node_verify_param[constants.NV_VGLIST] = None
2114
      node_verify_param[constants.NV_LVLIST] = vg_name
2115
      node_verify_param[constants.NV_PVLIST] = [vg_name]
2116
      node_verify_param[constants.NV_DRBDLIST] = None
2117

    
2118
    if drbd_helper:
2119
      node_verify_param[constants.NV_DRBDHELPER] = drbd_helper
2120

    
2121
    # Build our expected cluster state
2122
    node_image = dict((node.name, self.NodeImage(offline=node.offline,
2123
                                                 name=node.name,
2124
                                                 vm_capable=node.vm_capable))
2125
                      for node in nodeinfo)
2126

    
2127
    # Gather OOB paths
2128
    oob_paths = []
2129
    for node in nodeinfo:
2130
      path = _SupportsOob(self.cfg, node)
2131
      if path and path not in oob_paths:
2132
        oob_paths.append(path)
2133

    
2134
    if oob_paths:
2135
      node_verify_param[constants.NV_OOB_PATHS] = oob_paths
2136

    
2137
    for instance in instancelist:
2138
      inst_config = instanceinfo[instance]
2139

    
2140
      for nname in inst_config.all_nodes:
2141
        if nname not in node_image:
2142
          # ghost node
2143
          gnode = self.NodeImage(name=nname)
2144
          gnode.ghost = True
2145
          node_image[nname] = gnode
2146

    
2147
      inst_config.MapLVsByNode(node_vol_should)
2148

    
2149
      pnode = inst_config.primary_node
2150
      node_image[pnode].pinst.append(instance)
2151

    
2152
      for snode in inst_config.secondary_nodes:
2153
        nimg = node_image[snode]
2154
        nimg.sinst.append(instance)
2155
        if pnode not in nimg.sbp:
2156
          nimg.sbp[pnode] = []
2157
        nimg.sbp[pnode].append(instance)
2158

    
2159
    # At this point, we have the in-memory data structures complete,
2160
    # except for the runtime information, which we'll gather next
2161

    
2162
    # Due to the way our RPC system works, exact response times cannot be
2163
    # guaranteed (e.g. a broken node could run into a timeout). By keeping the
2164
    # time before and after executing the request, we can at least have a time
2165
    # window.
2166
    nvinfo_starttime = time.time()
2167
    all_nvinfo = self.rpc.call_node_verify(nodelist, node_verify_param,
2168
                                           self.cfg.GetClusterName())
2169
    nvinfo_endtime = time.time()
2170

    
2171
    all_drbd_map = self.cfg.ComputeDRBDMap()
2172

    
2173
    feedback_fn("* Gathering disk information (%s nodes)" % len(nodelist))
2174
    instdisk = self._CollectDiskInfo(nodelist, node_image, instanceinfo)
2175

    
2176
    feedback_fn("* Verifying node status")
2177

    
2178
    refos_img = None
2179

    
2180
    for node_i in nodeinfo:
2181
      node = node_i.name
2182
      nimg = node_image[node]
2183

    
2184
      if node_i.offline:
2185
        if verbose:
2186
          feedback_fn("* Skipping offline node %s" % (node,))
2187
        n_offline += 1
2188
        continue
2189

    
2190
      if node == master_node:
2191
        ntype = "master"
2192
      elif node_i.master_candidate:
2193
        ntype = "master candidate"
2194
      elif node_i.drained:
2195
        ntype = "drained"
2196
        n_drained += 1
2197
      else:
2198
        ntype = "regular"
2199
      if verbose:
2200
        feedback_fn("* Verifying node %s (%s)" % (node, ntype))
2201

    
2202
      msg = all_nvinfo[node].fail_msg
2203
      _ErrorIf(msg, self.ENODERPC, node, "while contacting node: %s", msg)
2204
      if msg:
2205
        nimg.rpc_fail = True
2206
        continue
2207

    
2208
      nresult = all_nvinfo[node].payload
2209

    
2210
      nimg.call_ok = self._VerifyNode(node_i, nresult)
2211
      self._VerifyNodeTime(node_i, nresult, nvinfo_starttime, nvinfo_endtime)
2212
      self._VerifyNodeNetwork(node_i, nresult)
2213
      self._VerifyNodeFiles(node_i, nresult, file_names, local_checksums,
2214
                            master_files)
2215

    
2216
      self._VerifyOob(node_i, nresult)
2217

    
2218
      if nimg.vm_capable:
2219
        self._VerifyNodeLVM(node_i, nresult, vg_name)
2220
        self._VerifyNodeDrbd(node_i, nresult, instanceinfo, drbd_helper,
2221
                             all_drbd_map)
2222

    
2223
        self._UpdateNodeVolumes(node_i, nresult, nimg, vg_name)
2224
        self._UpdateNodeInstances(node_i, nresult, nimg)
2225
        self._UpdateNodeInfo(node_i, nresult, nimg, vg_name)
2226
        self._UpdateNodeOS(node_i, nresult, nimg)
2227
        if not nimg.os_fail:
2228
          if refos_img is None:
2229
            refos_img = nimg
2230
          self._VerifyNodeOS(node_i, nimg, refos_img)
2231

    
2232
    feedback_fn("* Verifying instance status")
2233
    for instance in instancelist:
2234
      if verbose:
2235
        feedback_fn("* Verifying instance %s" % instance)
2236
      inst_config = instanceinfo[instance]
2237
      self._VerifyInstance(instance, inst_config, node_image,
2238
                           instdisk[instance])
2239
      inst_nodes_offline = []
2240

    
2241
      pnode = inst_config.primary_node
2242
      pnode_img = node_image[pnode]
2243
      _ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,
2244
               self.ENODERPC, pnode, "instance %s, connection to"
2245
               " primary node failed", instance)
2246

    
2247
      if pnode_img.offline:
2248
        inst_nodes_offline.append(pnode)
2249

    
2250
      # If the instance is non-redundant we cannot survive losing its primary
2251
      # node, so we are not N+1 compliant. On the other hand we have no disk
2252
      # templates with more than one secondary so that situation is not well
2253
      # supported either.
2254
      # FIXME: does not support file-backed instances
2255
      if not inst_config.secondary_nodes:
2256
        i_non_redundant.append(instance)
2257
      _ErrorIf(len(inst_config.secondary_nodes) > 1, self.EINSTANCELAYOUT,
2258
               instance, "instance has multiple secondary nodes: %s",
2259
               utils.CommaJoin(inst_config.secondary_nodes),
2260
               code=self.ETYPE_WARNING)
2261

    
2262
      if not cluster.FillBE(inst_config)[constants.BE_AUTO_BALANCE]:
2263
        i_non_a_balanced.append(instance)
2264

    
2265
      for snode in inst_config.secondary_nodes:
2266
        s_img = node_image[snode]
2267
        _ErrorIf(s_img.rpc_fail and not s_img.offline, self.ENODERPC, snode,
2268
                 "instance %s, connection to secondary node failed", instance)
2269

    
2270
        if s_img.offline:
2271
          inst_nodes_offline.append(snode)
2272

    
2273
      # warn that the instance lives on offline nodes
2274
      _ErrorIf(inst_nodes_offline, self.EINSTANCEBADNODE, instance,
2275
               "instance lives on offline node(s) %s",
2276
               utils.CommaJoin(inst_nodes_offline))
2277
      # ... or ghost/non-vm_capable nodes
2278
      for node in inst_config.all_nodes:
2279
        _ErrorIf(node_image[node].ghost, self.EINSTANCEBADNODE, instance,
2280
                 "instance lives on ghost node %s", node)
2281
        _ErrorIf(not node_image[node].vm_capable, self.EINSTANCEBADNODE,
2282
                 instance, "instance lives on non-vm_capable node %s", node)
2283

    
2284
    feedback_fn("* Verifying orphan volumes")
2285
    reserved = utils.FieldSet(*cluster.reserved_lvs)
2286
    self._VerifyOrphanVolumes(node_vol_should, node_image, reserved)
2287

    
2288
    feedback_fn("* Verifying orphan instances")
2289
    self._VerifyOrphanInstances(instancelist, node_image)
2290

    
2291
    if constants.VERIFY_NPLUSONE_MEM not in self.op.skip_checks:
2292
      feedback_fn("* Verifying N+1 Memory redundancy")
2293
      self._VerifyNPlusOneMemory(node_image, instanceinfo)
2294

    
2295
    feedback_fn("* Other Notes")
2296
    if i_non_redundant:
2297
      feedback_fn("  - NOTICE: %d non-redundant instance(s) found."
2298
                  % len(i_non_redundant))
2299

    
2300
    if i_non_a_balanced:
2301
      feedback_fn("  - NOTICE: %d non-auto-balanced instance(s) found."
2302
                  % len(i_non_a_balanced))
2303

    
2304
    if n_offline:
2305
      feedback_fn("  - NOTICE: %d offline node(s) found." % n_offline)
2306

    
2307
    if n_drained:
2308
      feedback_fn("  - NOTICE: %d drained node(s) found." % n_drained)
2309

    
2310
    return not self.bad
2311

    
2312
  def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):
2313
    """Analyze the post-hooks' result
2314

2315
    This method analyses the hook result, handles it, and sends some
2316
    nicely-formatted feedback back to the user.
2317

2318
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
2319
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
2320
    @param hooks_results: the results of the multi-node hooks rpc call
2321
    @param feedback_fn: function used send feedback back to the caller
2322
    @param lu_result: previous Exec result
2323
    @return: the new Exec result, based on the previous result
2324
        and hook results
2325

2326
    """
2327
    # We only really run POST phase hooks, and are only interested in
2328
    # their results
2329
    if phase == constants.HOOKS_PHASE_POST:
2330
      # Used to change hooks' output to proper indentation
2331
      feedback_fn("* Hooks Results")
2332
      assert hooks_results, "invalid result from hooks"
2333

    
2334
      for node_name in hooks_results:
2335
        res = hooks_results[node_name]
2336
        msg = res.fail_msg
2337
        test = msg and not res.offline
2338
        self._ErrorIf(test, self.ENODEHOOKS, node_name,
2339
                      "Communication failure in hooks execution: %s", msg)
2340
        if res.offline or msg:
2341
          # No need to investigate payload if node is offline or gave an error.
2342
          # override manually lu_result here as _ErrorIf only
2343
          # overrides self.bad
2344
          lu_result = 1
2345
          continue
2346
        for script, hkr, output in res.payload:
2347
          test = hkr == constants.HKR_FAIL
2348
          self._ErrorIf(test, self.ENODEHOOKS, node_name,
2349
                        "Script %s failed, output:", script)
2350
          if test:
2351
            output = self._HOOKS_INDENT_RE.sub('      ', output)
2352
            feedback_fn("%s" % output)
2353
            lu_result = 0
2354

    
2355
      return lu_result
2356

    
2357

    
2358
class LUVerifyDisks(NoHooksLU):
2359
  """Verifies the cluster disks status.
2360

2361
  """
2362
  REQ_BGL = False
2363

    
2364
  def ExpandNames(self):
2365
    self.needed_locks = {
2366
      locking.LEVEL_NODE: locking.ALL_SET,
2367
      locking.LEVEL_INSTANCE: locking.ALL_SET,
2368
    }
2369
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
2370

    
2371
  def Exec(self, feedback_fn):
2372
    """Verify integrity of cluster disks.
2373

2374
    @rtype: tuple of three items
2375
    @return: a tuple of (dict of node-to-node_error, list of instances
2376
        which need activate-disks, dict of instance: (node, volume) for
2377
        missing volumes
2378

2379
    """
2380
    result = res_nodes, res_instances, res_missing = {}, [], {}
2381

    
2382
    nodes = utils.NiceSort(self.cfg.GetNodeList())
2383
    instances = [self.cfg.GetInstanceInfo(name)
2384
                 for name in self.cfg.GetInstanceList()]
2385

    
2386
    nv_dict = {}
2387
    for inst in instances:
2388
      inst_lvs = {}
2389
      if (not inst.admin_up or
2390
          inst.disk_template not in constants.DTS_NET_MIRROR):
2391
        continue
2392
      inst.MapLVsByNode(inst_lvs)
2393
      # transform { iname: {node: [vol,],},} to {(node, vol): iname}
2394
      for node, vol_list in inst_lvs.iteritems():
2395
        for vol in vol_list:
2396
          nv_dict[(node, vol)] = inst
2397

    
2398
    if not nv_dict:
2399
      return result
2400

    
2401
    vg_names = self.rpc.call_vg_list(nodes)
2402
    vg_names.Raise("Cannot get list of VGs")
2403

    
2404
    for node in nodes:
2405
      # node_volume
2406
      node_res = self.rpc.call_lv_list([node],
2407
                                       vg_names[node].payload.keys())[node]
2408
      if node_res.offline:
2409
        continue
2410
      msg = node_res.fail_msg
2411
      if msg:
2412
        logging.warning("Error enumerating LVs on node %s: %s", node, msg)
2413
        res_nodes[node] = msg
2414
        continue
2415

    
2416
      lvs = node_res.payload
2417
      for lv_name, (_, _, lv_online) in lvs.items():
2418
        inst = nv_dict.pop((node, lv_name), None)
2419
        if (not lv_online and inst is not None
2420
            and inst.name not in res_instances):
2421
          res_instances.append(inst.name)
2422

    
2423
    # any leftover items in nv_dict are missing LVs, let's arrange the
2424
    # data better
2425
    for key, inst in nv_dict.iteritems():
2426
      if inst.name not in res_missing:
2427
        res_missing[inst.name] = []
2428
      res_missing[inst.name].append(key)
2429

    
2430
    return result
2431

    
2432

    
2433
class LURepairDiskSizes(NoHooksLU):
2434
  """Verifies the cluster disks sizes.
2435

2436
  """
2437
  REQ_BGL = False
2438

    
2439
  def ExpandNames(self):
2440
    if self.op.instances:
2441
      self.wanted_names = []
2442
      for name in self.op.instances:
2443
        full_name = _ExpandInstanceName(self.cfg, name)
2444
        self.wanted_names.append(full_name)
2445
      self.needed_locks = {
2446
        locking.LEVEL_NODE: [],
2447
        locking.LEVEL_INSTANCE: self.wanted_names,
2448
        }
2449
      self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
2450
    else:
2451
      self.wanted_names = None
2452
      self.needed_locks = {
2453
        locking.LEVEL_NODE: locking.ALL_SET,
2454
        locking.LEVEL_INSTANCE: locking.ALL_SET,
2455
        }
2456
    self.share_locks = dict(((i, 1) for i in locking.LEVELS))
2457

    
2458
  def DeclareLocks(self, level):
2459
    if level == locking.LEVEL_NODE and self.wanted_names is not None:
2460
      self._LockInstancesNodes(primary_only=True)
2461

    
2462
  def CheckPrereq(self):
2463
    """Check prerequisites.
2464

2465
    This only checks the optional instance list against the existing names.
2466

2467
    """
2468
    if self.wanted_names is None:
2469
      self.wanted_names = self.acquired_locks[locking.LEVEL_INSTANCE]
2470

    
2471
    self.wanted_instances = [self.cfg.GetInstanceInfo(name) for name
2472
                             in self.wanted_names]
2473

    
2474
  def _EnsureChildSizes(self, disk):
2475
    """Ensure children of the disk have the needed disk size.
2476

2477
    This is valid mainly for DRBD8 and fixes an issue where the
2478
    children have smaller disk size.
2479

2480
    @param disk: an L{ganeti.objects.Disk} object
2481

2482
    """
2483
    if disk.dev_type == constants.LD_DRBD8:
2484
      assert disk.children, "Empty children for DRBD8?"
2485
      fchild = disk.children[0]
2486
      mismatch = fchild.size < disk.size
2487
      if mismatch:
2488
        self.LogInfo("Child disk has size %d, parent %d, fixing",
2489
                     fchild.size, disk.size)
2490
        fchild.size = disk.size
2491

    
2492
      # and we recurse on this child only, not on the metadev
2493
      return self._EnsureChildSizes(fchild) or mismatch
2494
    else:
2495
      return False
2496

    
2497
  def Exec(self, feedback_fn):
2498
    """Verify the size of cluster disks.
2499

2500
    """
2501
    # TODO: check child disks too
2502
    # TODO: check differences in size between primary/secondary nodes
2503
    per_node_disks = {}
2504
    for instance in self.wanted_instances:
2505
      pnode = instance.primary_node
2506
      if pnode not in per_node_disks:
2507
        per_node_disks[pnode] = []
2508
      for idx, disk in enumerate(instance.disks):
2509
        per_node_disks[pnode].append((instance, idx, disk))
2510

    
2511
    changed = []
2512
    for node, dskl in per_node_disks.items():
2513
      newl = [v[2].Copy() for v in dskl]
2514
      for dsk in newl:
2515
        self.cfg.SetDiskID(dsk, node)
2516
      result = self.rpc.call_blockdev_getsizes(node, newl)
2517
      if result.fail_msg:
2518
        self.LogWarning("Failure in blockdev_getsizes call to node"
2519
                        " %s, ignoring", node)
2520
        continue
2521
      if len(result.data) != len(dskl):
2522
        self.LogWarning("Invalid result from node %s, ignoring node results",
2523
                        node)
2524
        continue
2525
      for ((instance, idx, disk), size) in zip(dskl, result.data):
2526
        if size is None:
2527
          self.LogWarning("Disk %d of instance %s did not return size"
2528
                          " information, ignoring", idx, instance.name)
2529
          continue
2530
        if not isinstance(size, (int, long)):
2531
          self.LogWarning("Disk %d of instance %s did not return valid"
2532
                          " size information, ignoring", idx, instance.name)
2533
          continue
2534
        size = size >> 20
2535
        if size != disk.size:
2536
          self.LogInfo("Disk %d of instance %s has mismatched size,"
2537
                       " correcting: recorded %d, actual %d", idx,
2538
                       instance.name, disk.size, size)
2539
          disk.size = size
2540
          self.cfg.Update(instance, feedback_fn)
2541
          changed.append((instance.name, idx, size))
2542
        if self._EnsureChildSizes(disk):
2543
          self.cfg.Update(instance, feedback_fn)
2544
          changed.append((instance.name, idx, disk.size))
2545
    return changed
2546

    
2547

    
2548
class LURenameCluster(LogicalUnit):
2549
  """Rename the cluster.
2550

2551
  """
2552
  HPATH = "cluster-rename"
2553
  HTYPE = constants.HTYPE_CLUSTER
2554

    
2555
  def BuildHooksEnv(self):
2556
    """Build hooks env.
2557

2558
    """
2559
    env = {
2560
      "OP_TARGET": self.cfg.GetClusterName(),
2561
      "NEW_NAME": self.op.name,
2562
      }
2563
    mn = self.cfg.GetMasterNode()
2564
    all_nodes = self.cfg.GetNodeList()
2565
    return env, [mn], all_nodes
2566

    
2567
  def CheckPrereq(self):
2568
    """Verify that the passed name is a valid one.
2569

2570
    """
2571
    hostname = netutils.GetHostname(name=self.op.name,
2572
                                    family=self.cfg.GetPrimaryIPFamily())
2573

    
2574
    new_name = hostname.name
2575
    self.ip = new_ip = hostname.ip
2576
    old_name = self.cfg.GetClusterName()
2577
    old_ip = self.cfg.GetMasterIP()
2578
    if new_name == old_name and new_ip == old_ip:
2579
      raise errors.OpPrereqError("Neither the name nor the IP address of the"
2580
                                 " cluster has changed",
2581
                                 errors.ECODE_INVAL)
2582
    if new_ip != old_ip:
2583
      if netutils.TcpPing(new_ip, constants.DEFAULT_NODED_PORT):
2584
        raise errors.OpPrereqError("The given cluster IP address (%s) is"
2585
                                   " reachable on the network" %
2586
                                   new_ip, errors.ECODE_NOTUNIQUE)
2587

    
2588
    self.op.name = new_name
2589

    
2590
  def Exec(self, feedback_fn):
2591
    """Rename the cluster.
2592

2593
    """
2594
    clustername = self.op.name
2595
    ip = self.ip
2596

    
2597
    # shutdown the master IP
2598
    master = self.cfg.GetMasterNode()
2599
    result = self.rpc.call_node_stop_master(master, False)
2600
    result.Raise("Could not disable the master role")
2601

    
2602
    try:
2603
      cluster = self.cfg.GetClusterInfo()
2604
      cluster.cluster_name = clustername
2605
      cluster.master_ip = ip
2606
      self.cfg.Update(cluster, feedback_fn)
2607

    
2608
      # update the known hosts file
2609
      ssh.WriteKnownHostsFile(self.cfg, constants.SSH_KNOWN_HOSTS_FILE)
2610
      node_list = self.cfg.GetOnlineNodeList()
2611
      try:
2612
        node_list.remove(master)
2613
      except ValueError:
2614
        pass
2615
      _UploadHelper(self, node_list, constants.SSH_KNOWN_HOSTS_FILE)
2616
    finally:
2617
      result = self.rpc.call_node_start_master(master, False, False)
2618
      msg = result.fail_msg
2619
      if msg:
2620
        self.LogWarning("Could not re-enable the master role on"
2621
                        " the master, please restart manually: %s", msg)
2622

    
2623
    return clustername
2624

    
2625

    
2626
class LUSetClusterParams(LogicalUnit):
2627
  """Change the parameters of the cluster.
2628

2629
  """
2630
  HPATH = "cluster-modify"
2631
  HTYPE = constants.HTYPE_CLUSTER
2632
  REQ_BGL = False
2633

    
2634
  def CheckArguments(self):
2635
    """Check parameters
2636

2637
    """
2638
    if self.op.uid_pool:
2639
      uidpool.CheckUidPool(self.op.uid_pool)
2640

    
2641
    if self.op.add_uids:
2642
      uidpool.CheckUidPool(self.op.add_uids)
2643

    
2644
    if self.op.remove_uids:
2645
      uidpool.CheckUidPool(self.op.remove_uids)
2646

    
2647
  def ExpandNames(self):
2648
    # FIXME: in the future maybe other cluster params won't require checking on
2649
    # all nodes to be modified.
2650
    self.needed_locks = {
2651
      locking.LEVEL_NODE: locking.ALL_SET,
2652
    }
2653
    self.share_locks[locking.LEVEL_NODE] = 1
2654

    
2655
  def BuildHooksEnv(self):
2656
    """Build hooks env.
2657

2658
    """
2659
    env = {
2660
      "OP_TARGET": self.cfg.GetClusterName(),
2661
      "NEW_VG_NAME": self.op.vg_name,
2662
      }
2663
    mn = self.cfg.GetMasterNode()
2664
    return env, [mn], [mn]
2665

    
2666
  def CheckPrereq(self):
2667
    """Check prerequisites.
2668

2669
    This checks whether the given params don't conflict and
2670
    if the given volume group is valid.
2671

2672
    """
2673
    if self.op.vg_name is not None and not self.op.vg_name:
2674
      if self.cfg.HasAnyDiskOfType(constants.LD_LV):
2675
        raise errors.OpPrereqError("Cannot disable lvm storage while lvm-based"
2676
                                   " instances exist", errors.ECODE_INVAL)
2677

    
2678
    if self.op.drbd_helper is not None and not self.op.drbd_helper:
2679
      if self.cfg.HasAnyDiskOfType(constants.LD_DRBD8):
2680
        raise errors.OpPrereqError("Cannot disable drbd helper while"
2681
                                   " drbd-based instances exist",
2682
                                   errors.ECODE_INVAL)
2683

    
2684
    node_list = self.acquired_locks[locking.LEVEL_NODE]
2685

    
2686
    # if vg_name not None, checks given volume group on all nodes
2687
    if self.op.vg_name:
2688
      vglist = self.rpc.call_vg_list(node_list)
2689
      for node in node_list:
2690
        msg = vglist[node].fail_msg
2691
        if msg:
2692
          # ignoring down node
2693
          self.LogWarning("Error while gathering data on node %s"
2694
                          " (ignoring node): %s", node, msg)
2695
          continue
2696
        vgstatus = utils.CheckVolumeGroupSize(vglist[node].payload,
2697
                                              self.op.vg_name,
2698
                                              constants.MIN_VG_SIZE)
2699
        if vgstatus:
2700
          raise errors.OpPrereqError("Error on node '%s': %s" %
2701
                                     (node, vgstatus), errors.ECODE_ENVIRON)
2702

    
2703
    if self.op.drbd_helper:
2704
      # checks given drbd helper on all nodes
2705
      helpers = self.rpc.call_drbd_helper(node_list)
2706
      for node in node_list:
2707
        ninfo = self.cfg.GetNodeInfo(node)
2708
        if ninfo.offline:
2709
          self.LogInfo("Not checking drbd helper on offline node %s", node)
2710
          continue
2711
        msg = helpers[node].fail_msg
2712
        if msg:
2713
          raise errors.OpPrereqError("Error checking drbd helper on node"
2714
                                     " '%s': %s" % (node, msg),
2715
                                     errors.ECODE_ENVIRON)
2716
        node_helper = helpers[node].payload
2717
        if node_helper != self.op.drbd_helper:
2718
          raise errors.OpPrereqError("Error on node '%s': drbd helper is %s" %
2719
                                     (node, node_helper), errors.ECODE_ENVIRON)
2720

    
2721
    self.cluster = cluster = self.cfg.GetClusterInfo()
2722
    # validate params changes
2723
    if self.op.beparams:
2724
      utils.ForceDictType(self.op.beparams, constants.BES_PARAMETER_TYPES)
2725
      self.new_beparams = cluster.SimpleFillBE(self.op.beparams)
2726

    
2727
    if self.op.ndparams:
2728
      utils.ForceDictType(self.op.ndparams, constants.NDS_PARAMETER_TYPES)
2729
      self.new_ndparams = cluster.SimpleFillND(self.op.ndparams)
2730

    
2731
    if self.op.nicparams:
2732
      utils.ForceDictType(self.op.nicparams, constants.NICS_PARAMETER_TYPES)
2733
      self.new_nicparams = cluster.SimpleFillNIC(self.op.nicparams)
2734
      objects.NIC.CheckParameterSyntax(self.new_nicparams)
2735
      nic_errors = []
2736

    
2737
      # check all instances for consistency
2738
      for instance in self.cfg.GetAllInstancesInfo().values():
2739
        for nic_idx, nic in enumerate(instance.nics):
2740
          params_copy = copy.deepcopy(nic.nicparams)
2741
          params_filled = objects.FillDict(self.new_nicparams, params_copy)
2742

    
2743
          # check parameter syntax
2744
          try:
2745
            objects.NIC.CheckParameterSyntax(params_filled)
2746
          except errors.ConfigurationError, err:
2747
            nic_errors.append("Instance %s, nic/%d: %s" %
2748
                              (instance.name, nic_idx, err))
2749

    
2750
          # if we're moving instances to routed, check that they have an ip
2751
          target_mode = params_filled[constants.NIC_MODE]
2752
          if target_mode == constants.NIC_MODE_ROUTED and not nic.ip:
2753
            nic_errors.append("Instance %s, nic/%d: routed nick with no ip" %
2754
                              (instance.name, nic_idx))
2755
      if nic_errors:
2756
        raise errors.OpPrereqError("Cannot apply the change, errors:\n%s" %
2757
                                   "\n".join(nic_errors))
2758

    
2759
    # hypervisor list/parameters
2760
    self.new_hvparams = new_hvp = objects.FillDict(cluster.hvparams, {})
2761
    if self.op.hvparams:
2762
      for hv_name, hv_dict in self.op.hvparams.items():
2763
        if hv_name not in self.new_hvparams:
2764
          self.new_hvparams[hv_name] = hv_dict
2765
        else:
2766
          self.new_hvparams[hv_name].update(hv_dict)
2767

    
2768
    # os hypervisor parameters
2769
    self.new_os_hvp = objects.FillDict(cluster.os_hvp, {})
2770
    if self.op.os_hvp:
2771
      for os_name, hvs in self.op.os_hvp.items():
2772
        if os_name not in self.new_os_hvp:
2773
          self.new_os_hvp[os_name] = hvs
2774
        else:
2775
          for hv_name, hv_dict in hvs.items():
2776
            if hv_name not in self.new_os_hvp[os_name]:
2777
              self.new_os_hvp[os_name][hv_name] = hv_dict
2778
            else:
2779
              self.new_os_hvp[os_name][hv_name].update(hv_dict)
2780

    
2781
    # os parameters
2782
    self.new_osp = objects.FillDict(cluster.osparams, {})
2783
    if self.op.osparams:
2784
      for os_name, osp in self.op.osparams.items():
2785
        if os_name not in self.new_osp:
2786
          self.new_osp[os_name] = {}
2787

    
2788
        self.new_osp[os_name] = _GetUpdatedParams(self.new_osp[os_name], osp,
2789
                                                  use_none=True)
2790

    
2791
        if not self.new_osp[os_name]:
2792
          # we removed all parameters
2793
          del self.new_osp[os_name]
2794
        else:
2795
          # check the parameter validity (remote check)
2796
          _CheckOSParams(self, False, [self.cfg.GetMasterNode()],
2797
                         os_name, self.new_osp[os_name])
2798

    
2799
    # changes to the hypervisor list
2800
    if self.op.enabled_hypervisors is not None:
2801
      self.hv_list = self.op.enabled_hypervisors
2802
      for hv in self.hv_list:
2803
        # if the hypervisor doesn't already exist in the cluster
2804
        # hvparams, we initialize it to empty, and then (in both
2805
        # cases) we make sure to fill the defaults, as we might not
2806
        # have a complete defaults list if the hypervisor wasn't
2807
        # enabled before
2808
        if hv not in new_hvp:
2809
          new_hvp[hv] = {}
2810
        new_hvp[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], new_hvp[hv])
2811
        utils.ForceDictType(new_hvp[hv], constants.HVS_PARAMETER_TYPES)
2812
    else:
2813
      self.hv_list = cluster.enabled_hypervisors
2814

    
2815
    if self.op.hvparams or self.op.enabled_hypervisors is not None:
2816
      # either the enabled list has changed, or the parameters have, validate
2817
      for hv_name, hv_params in self.new_hvparams.items():
2818
        if ((self.op.hvparams and hv_name in self.op.hvparams) or
2819
            (self.op.enabled_hypervisors and
2820
             hv_name in self.op.enabled_hypervisors)):
2821
          # either this is a new hypervisor, or its parameters have changed
2822
          hv_class = hypervisor.GetHypervisor(hv_name)
2823
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
2824
          hv_class.CheckParameterSyntax(hv_params)
2825
          _CheckHVParams(self, node_list, hv_name, hv_params)
2826

    
2827
    if self.op.os_hvp:
2828
      # no need to check any newly-enabled hypervisors, since the
2829
      # defaults have already been checked in the above code-block
2830
      for os_name, os_hvp in self.new_os_hvp.items():
2831
        for hv_name, hv_params in os_hvp.items():
2832
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
2833
          # we need to fill in the new os_hvp on top of the actual hv_p
2834
          cluster_defaults = self.new_hvparams.get(hv_name, {})
2835
          new_osp = objects.FillDict(cluster_defaults, hv_params)
2836
          hv_class = hypervisor.GetHypervisor(hv_name)
2837
          hv_class.CheckParameterSyntax(new_osp)
2838
          _CheckHVParams(self, node_list, hv_name, new_osp)
2839

    
2840
    if self.op.default_iallocator:
2841
      alloc_script = utils.FindFile(self.op.default_iallocator,
2842
                                    constants.IALLOCATOR_SEARCH_PATH,
2843
                                    os.path.isfile)
2844
      if alloc_script is None:
2845
        raise errors.OpPrereqError("Invalid default iallocator script '%s'"
2846
                                   " specified" % self.op.default_iallocator,
2847
                                   errors.ECODE_INVAL)
2848

    
2849
  def Exec(self, feedback_fn):
2850
    """Change the parameters of the cluster.
2851

2852
    """
2853
    if self.op.vg_name is not None:
2854
      new_volume = self.op.vg_name
2855
      if not new_volume:
2856
        new_volume = None
2857
      if new_volume != self.cfg.GetVGName():
2858
        self.cfg.SetVGName(new_volume)
2859
      else:
2860
        feedback_fn("Cluster LVM configuration already in desired"
2861
                    " state, not changing")
2862
    if self.op.drbd_helper is not None:
2863
      new_helper = self.op.drbd_helper
2864
      if not new_helper:
2865
        new_helper = None
2866
      if new_helper != self.cfg.GetDRBDHelper():
2867
        self.cfg.SetDRBDHelper(new_helper)
2868
      else:
2869
        feedback_fn("Cluster DRBD helper already in desired state,"
2870
                    " not changing")
2871
    if self.op.hvparams:
2872
      self.cluster.hvparams = self.new_hvparams
2873
    if self.op.os_hvp:
2874
      self.cluster.os_hvp = self.new_os_hvp
2875
    if self.op.enabled_hypervisors is not None:
2876
      self.cluster.hvparams = self.new_hvparams
2877
      self.cluster.enabled_hypervisors = self.op.enabled_hypervisors
2878
    if self.op.beparams:
2879
      self.cluster.beparams[constants.PP_DEFAULT] = self.new_beparams
2880
    if self.op.nicparams:
2881
      self.cluster.nicparams[constants.PP_DEFAULT] = self.new_nicparams
2882
    if self.op.osparams:
2883
      self.cluster.osparams = self.new_osp
2884
    if self.op.ndparams:
2885
      self.cluster.ndparams = self.new_ndparams
2886

    
2887
    if self.op.candidate_pool_size is not None:
2888
      self.cluster.candidate_pool_size = self.op.candidate_pool_size
2889
      # we need to update the pool size here, otherwise the save will fail
2890
      _AdjustCandidatePool(self, [])
2891

    
2892
    if self.op.maintain_node_health is not None:
2893
      self.cluster.maintain_node_health = self.op.maintain_node_health
2894

    
2895
    if self.op.prealloc_wipe_disks is not None:
2896
      self.cluster.prealloc_wipe_disks = self.op.prealloc_wipe_disks
2897

    
2898
    if self.op.add_uids is not None:
2899
      uidpool.AddToUidPool(self.cluster.uid_pool, self.op.add_uids)
2900

    
2901
    if self.op.remove_uids is not None:
2902
      uidpool.RemoveFromUidPool(self.cluster.uid_pool, self.op.remove_uids)
2903

    
2904
    if self.op.uid_pool is not None:
2905
      self.cluster.uid_pool = self.op.uid_pool
2906

    
2907
    if self.op.default_iallocator is not None:
2908
      self.cluster.default_iallocator = self.op.default_iallocator
2909

    
2910
    if self.op.reserved_lvs is not None:
2911
      self.cluster.reserved_lvs = self.op.reserved_lvs
2912

    
2913
    def helper_os(aname, mods, desc):
2914
      desc += " OS list"
2915
      lst = getattr(self.cluster, aname)
2916
      for key, val in mods:
2917
        if key == constants.DDM_ADD:
2918
          if val in lst:
2919
            feedback_fn("OS %s already in %s, ignoring" % (val, desc))
2920
          else:
2921
            lst.append(val)
2922
        elif key == constants.DDM_REMOVE:
2923
          if val in lst:
2924
            lst.remove(val)
2925
          else:
2926
            feedback_fn("OS %s not found in %s, ignoring" % (val, desc))
2927
        else:
2928
          raise errors.ProgrammerError("Invalid modification '%s'" % key)
2929

    
2930
    if self.op.hidden_os:
2931
      helper_os("hidden_os", self.op.hidden_os, "hidden")
2932

    
2933
    if self.op.blacklisted_os:
2934
      helper_os("blacklisted_os", self.op.blacklisted_os, "blacklisted")
2935

    
2936
    if self.op.master_netdev:
2937
      master = self.cfg.GetMasterNode()
2938
      feedback_fn("Shutting down master ip on the current netdev (%s)" %
2939
                  self.cluster.master_netdev)
2940
      result = self.rpc.call_node_stop_master(master, False)
2941
      result.Raise("Could not disable the master ip")
2942
      feedback_fn("Changing master_netdev from %s to %s" %
2943
                  (self.cluster.master_netdev, self.op.master_netdev))
2944
      self.cluster.master_netdev = self.op.master_netdev
2945

    
2946
    self.cfg.Update(self.cluster, feedback_fn)
2947

    
2948
    if self.op.master_netdev:
2949
      feedback_fn("Starting the master ip on the new master netdev (%s)" %
2950
                  self.op.master_netdev)
2951
      result = self.rpc.call_node_start_master(master, False, False)
2952
      if result.fail_msg:
2953
        self.LogWarning("Could not re-enable the master ip on"
2954
                        " the master, please restart manually: %s",
2955
                        result.fail_msg)
2956

    
2957

    
2958
def _UploadHelper(lu, nodes, fname):
2959
  """Helper for uploading a file and showing warnings.
2960

2961
  """
2962
  if os.path.exists(fname):
2963
    result = lu.rpc.call_upload_file(nodes, fname)
2964
    for to_node, to_result in result.items():
2965
      msg = to_result.fail_msg
2966
      if msg:
2967
        msg = ("Copy of file %s to node %s failed: %s" %
2968
               (fname, to_node, msg))
2969
        lu.proc.LogWarning(msg)
2970

    
2971

    
2972
def _RedistributeAncillaryFiles(lu, additional_nodes=None, additional_vm=True):
2973
  """Distribute additional files which are part of the cluster configuration.
2974

2975
  ConfigWriter takes care of distributing the config and ssconf files, but
2976
  there are more files which should be distributed to all nodes. This function
2977
  makes sure those are copied.
2978

2979
  @param lu: calling logical unit
2980
  @param additional_nodes: list of nodes not in the config to distribute to
2981
  @type additional_vm: boolean
2982
  @param additional_vm: whether the additional nodes are vm-capable or not
2983

2984
  """
2985
  # 1. Gather target nodes
2986
  myself = lu.cfg.GetNodeInfo(lu.cfg.GetMasterNode())
2987
  dist_nodes = lu.cfg.GetOnlineNodeList()
2988
  nvm_nodes = lu.cfg.GetNonVmCapableNodeList()
2989
  vm_nodes = [name for name in dist_nodes if name not in nvm_nodes]
2990
  if additional_nodes is not None:
2991
    dist_nodes.extend(additional_nodes)
2992
    if additional_vm:
2993
      vm_nodes.extend(additional_nodes)
2994
  if myself.name in dist_nodes:
2995
    dist_nodes.remove(myself.name)
2996
  if myself.name in vm_nodes:
2997
    vm_nodes.remove(myself.name)
2998

    
2999
  # 2. Gather files to distribute
3000
  dist_files = set([constants.ETC_HOSTS,
3001
                    constants.SSH_KNOWN_HOSTS_FILE,
3002
                    constants.RAPI_CERT_FILE,
3003
                    constants.RAPI_USERS_FILE,
3004
                    constants.CONFD_HMAC_KEY,
3005
                    constants.CLUSTER_DOMAIN_SECRET_FILE,
3006
                   ])
3007

    
3008
  vm_files = set()
3009
  enabled_hypervisors = lu.cfg.GetClusterInfo().enabled_hypervisors
3010
  for hv_name in enabled_hypervisors:
3011
    hv_class = hypervisor.GetHypervisor(hv_name)
3012
    vm_files.update(hv_class.GetAncillaryFiles())
3013

    
3014
  # 3. Perform the files upload
3015
  for fname in dist_files:
3016
    _UploadHelper(lu, dist_nodes, fname)
3017
  for fname in vm_files:
3018
    _UploadHelper(lu, vm_nodes, fname)
3019

    
3020

    
3021
class LURedistributeConfig(NoHooksLU):
3022
  """Force the redistribution of cluster configuration.
3023

3024
  This is a very simple LU.
3025

3026
  """
3027
  REQ_BGL = False
3028

    
3029
  def ExpandNames(self):
3030
    self.needed_locks = {
3031
      locking.LEVEL_NODE: locking.ALL_SET,
3032
    }
3033
    self.share_locks[locking.LEVEL_NODE] = 1
3034

    
3035
  def Exec(self, feedback_fn):
3036
    """Redistribute the configuration.
3037

3038
    """
3039
    self.cfg.Update(self.cfg.GetClusterInfo(), feedback_fn)
3040
    _RedistributeAncillaryFiles(self)
3041

    
3042

    
3043
def _WaitForSync(lu, instance, disks=None, oneshot=False):
3044
  """Sleep and poll for an instance's disk to sync.
3045

3046
  """
3047
  if not instance.disks or disks is not None and not disks:
3048
    return True
3049

    
3050
  disks = _ExpandCheckDisks(instance, disks)
3051

    
3052
  if not oneshot:
3053
    lu.proc.LogInfo("Waiting for instance %s to sync disks." % instance.name)
3054

    
3055
  node = instance.primary_node
3056

    
3057
  for dev in disks:
3058
    lu.cfg.SetDiskID(dev, node)
3059

    
3060
  # TODO: Convert to utils.Retry
3061

    
3062
  retries = 0
3063
  degr_retries = 10 # in seconds, as we sleep 1 second each time
3064
  while True:
3065
    max_time = 0
3066
    done = True
3067
    cumul_degraded = False
3068
    rstats = lu.rpc.call_blockdev_getmirrorstatus(node, disks)
3069
    msg = rstats.fail_msg
3070
    if msg:
3071
      lu.LogWarning("Can't get any data from node %s: %s", node, msg)
3072
      retries += 1
3073
      if retries >= 10:
3074
        raise errors.RemoteError("Can't contact node %s for mirror data,"
3075
                                 " aborting." % node)
3076
      time.sleep(6)
3077
      continue
3078
    rstats = rstats.payload
3079
    retries = 0
3080
    for i, mstat in enumerate(rstats):
3081
      if mstat is None:
3082
        lu.LogWarning("Can't compute data for node %s/%s",
3083
                           node, disks[i].iv_name)
3084
        continue
3085

    
3086
      cumul_degraded = (cumul_degraded or
3087
                        (mstat.is_degraded and mstat.sync_percent is None))
3088
      if mstat.sync_percent is not None:
3089
        done = False
3090
        if mstat.estimated_time is not None:
3091
          rem_time = ("%s remaining (estimated)" %
3092
                      utils.FormatSeconds(mstat.estimated_time))
3093
          max_time = mstat.estimated_time
3094
        else:
3095
          rem_time = "no time estimate"
3096
        lu.proc.LogInfo("- device %s: %5.2f%% done, %s" %
3097
                        (disks[i].iv_name, mstat.sync_percent, rem_time))
3098

    
3099
    # if we're done but degraded, let's do a few small retries, to
3100
    # make sure we see a stable and not transient situation; therefore
3101
    # we force restart of the loop
3102
    if (done or oneshot) and cumul_degraded and degr_retries > 0:
3103
      logging.info("Degraded disks found, %d retries left", degr_retries)
3104
      degr_retries -= 1
3105
      time.sleep(1)
3106
      continue
3107

    
3108
    if done or oneshot:
3109
      break
3110

    
3111
    time.sleep(min(60, max_time))
3112

    
3113
  if done:
3114
    lu.proc.LogInfo("Instance %s's disks are in sync." % instance.name)
3115
  return not cumul_degraded
3116

    
3117

    
3118
def _CheckDiskConsistency(lu, dev, node, on_primary, ldisk=False):
3119
  """Check that mirrors are not degraded.
3120

3121
  The ldisk parameter, if True, will change the test from the
3122
  is_degraded attribute (which represents overall non-ok status for
3123
  the device(s)) to the ldisk (representing the local storage status).
3124

3125
  """
3126
  lu.cfg.SetDiskID(dev, node)
3127

    
3128
  result = True
3129

    
3130
  if on_primary or dev.AssembleOnSecondary():
3131
    rstats = lu.rpc.call_blockdev_find(node, dev)
3132
    msg = rstats.fail_msg
3133
    if msg:
3134
      lu.LogWarning("Can't find disk on node %s: %s", node, msg)
3135
      result = False
3136
    elif not rstats.payload:
3137
      lu.LogWarning("Can't find disk on node %s", node)
3138
      result = False
3139
    else:
3140
      if ldisk:
3141
        result = result and rstats.payload.ldisk_status == constants.LDS_OKAY
3142
      else:
3143
        result = result and not rstats.payload.is_degraded
3144

    
3145
  if dev.children:
3146
    for child in dev.children:
3147
      result = result and _CheckDiskConsistency(lu, child, node, on_primary)
3148

    
3149
  return result
3150

    
3151

    
3152
class LUOobCommand(NoHooksLU):
3153
  """Logical unit for OOB handling.
3154

3155
  """
3156
  REG_BGL = False
3157

    
3158
  def CheckPrereq(self):
3159
    """Check prerequisites.
3160

3161
    This checks:
3162
     - the node exists in the configuration
3163
     - OOB is supported
3164

3165
    Any errors are signaled by raising errors.OpPrereqError.
3166

3167
    """
3168
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3169
    node = self.cfg.GetNodeInfo(self.op.node_name)
3170

    
3171
    if node is None:
3172
      raise errors.OpPrereqError("Node %s not found" % self.op.node_name)
3173

    
3174
    self.oob_program = _SupportsOob(self.cfg, node)
3175

    
3176
    if not self.oob_program:
3177
      raise errors.OpPrereqError("OOB is not supported for node %s" %
3178
                                 self.op.node_name)
3179

    
3180
    if self.op.command == constants.OOB_POWER_OFF and not node.offline:
3181
      raise errors.OpPrereqError(("Cannot power off node %s because it is"
3182
                                  " not marked offline") % self.op.node_name)
3183

    
3184
    self.node = node
3185

    
3186
  def ExpandNames(self):
3187
    """Gather locks we need.
3188

3189
    """
3190
    node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3191
    self.needed_locks = {
3192
      locking.LEVEL_NODE: [node_name],
3193
      }
3194

    
3195
  def Exec(self, feedback_fn):
3196
    """Execute OOB and return result if we expect any.
3197

3198
    """
3199
    master_node = self.cfg.GetMasterNode()
3200
    node = self.node
3201

    
3202
    logging.info("Executing out-of-band command '%s' using '%s' on %s",
3203
                 self.op.command, self.oob_program, self.op.node_name)
3204
    result = self.rpc.call_run_oob(master_node, self.oob_program,
3205
                                   self.op.command, self.op.node_name,
3206
                                   self.op.timeout)
3207

    
3208
    result.Raise("An error occurred on execution of OOB helper")
3209

    
3210
    self._CheckPayload(result)
3211

    
3212
    if self.op.command == constants.OOB_HEALTH:
3213
      # For health we should log important events
3214
      for item, status in result.payload:
3215
        if status in [constants.OOB_STATUS_WARNING,
3216
                      constants.OOB_STATUS_CRITICAL]:
3217
          logging.warning("On node '%s' item '%s' has status '%s'",
3218
                          self.op.node_name, item, status)
3219

    
3220
    if self.op.command == constants.OOB_POWER_ON:
3221
      node.powered = True
3222
    elif self.op.command == constants.OOB_POWER_OFF:
3223
      node.powered = False
3224
    elif self.op.command == constants.OOB_POWER_STATUS:
3225
      powered = result.payload[constants.OOB_POWER_STATUS_POWERED]
3226
      if powered != self.node.powered:
3227
        logging.warning(("Recorded power state (%s) of node '%s' does not match"
3228
                         " actual power state (%s)"), node.powered,
3229
                        self.op.node_name, powered)
3230

    
3231
    self.cfg.Update(node, feedback_fn)
3232

    
3233
    return result.payload
3234

    
3235
  def _CheckPayload(self, result):
3236
    """Checks if the payload is valid.
3237

3238
    @param result: RPC result
3239
    @raises errors.OpExecError: If payload is not valid
3240

3241
    """
3242
    errs = []
3243
    if self.op.command == constants.OOB_HEALTH:
3244
      if not isinstance(result.payload, list):
3245
        errs.append("command 'health' is expected to return a list but got %s" %
3246
                    type(result.payload))
3247
      for item, status in result.payload:
3248
        if status not in constants.OOB_STATUSES:
3249
          errs.append("health item '%s' has invalid status '%s'" %
3250
                      (item, status))
3251

    
3252
    if self.op.command == constants.OOB_POWER_STATUS:
3253
      if not isinstance(result.payload, dict):
3254
        errs.append("power-status is expected to return a dict but got %s" %
3255
                    type(result.payload))
3256

    
3257
    if self.op.command in [
3258
        constants.OOB_POWER_ON,
3259
        constants.OOB_POWER_OFF,
3260
        constants.OOB_POWER_CYCLE,
3261
        ]:
3262
      if result.payload is not None:
3263
        errs.append("%s is expected to not return payload but got '%s'" %
3264
                    (self.op.command, result.payload))
3265

    
3266
    if errs:
3267
      raise errors.OpExecError("Check of out-of-band payload failed due to %s" %
3268
                               utils.CommaJoin(errs))
3269

    
3270

    
3271

    
3272
class LUDiagnoseOS(NoHooksLU):
3273
  """Logical unit for OS diagnose/query.
3274

3275
  """
3276
  REQ_BGL = False
3277
  _HID = "hidden"
3278
  _BLK = "blacklisted"
3279
  _VLD = "valid"
3280
  _FIELDS_STATIC = utils.FieldSet()
3281
  _FIELDS_DYNAMIC = utils.FieldSet("name", _VLD, "node_status", "variants",
3282
                                   "parameters", "api_versions", _HID, _BLK)
3283

    
3284
  def CheckArguments(self):
3285
    if self.op.names:
3286
      raise errors.OpPrereqError("Selective OS query not supported",
3287
                                 errors.ECODE_INVAL)
3288

    
3289
    _CheckOutputFields(static=self._FIELDS_STATIC,
3290
                       dynamic=self._FIELDS_DYNAMIC,
3291
                       selected=self.op.output_fields)
3292

    
3293
  def ExpandNames(self):
3294
    # Lock all nodes, in shared mode
3295
    # Temporary removal of locks, should be reverted later
3296
    # TODO: reintroduce locks when they are lighter-weight
3297
    self.needed_locks = {}
3298
    #self.share_locks[locking.LEVEL_NODE] = 1
3299
    #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3300

    
3301
  @staticmethod
3302
  def _DiagnoseByOS(rlist):
3303
    """Remaps a per-node return list into an a per-os per-node dictionary
3304

3305
    @param rlist: a map with node names as keys and OS objects as values
3306

3307
    @rtype: dict
3308
    @return: a dictionary with osnames as keys and as value another
3309
        map, with nodes as keys and tuples of (path, status, diagnose,
3310
        variants, parameters, api_versions) as values, eg::
3311

3312
          {"debian-etch": {"node1": [(/usr/lib/..., True, "", [], []),
3313
                                     (/srv/..., False, "invalid api")],
3314
                           "node2": [(/srv/..., True, "", [], [])]}
3315
          }
3316

3317
    """
3318
    all_os = {}
3319
    # we build here the list of nodes that didn't fail the RPC (at RPC
3320
    # level), so that nodes with a non-responding node daemon don't
3321
    # make all OSes invalid
3322
    good_nodes = [node_name for node_name in rlist
3323
                  if not rlist[node_name].fail_msg]
3324
    for node_name, nr in rlist.items():
3325
      if nr.fail_msg or not nr.payload:
3326
        continue
3327
      for (name, path, status, diagnose, variants,
3328
           params, api_versions) in nr.payload:
3329
        if name not in all_os:
3330
          # build a list of nodes for this os containing empty lists
3331
          # for each node in node_list
3332
          all_os[name] = {}
3333
          for nname in good_nodes:
3334
            all_os[name][nname] = []
3335
        # convert params from [name, help] to (name, help)
3336
        params = [tuple(v) for v in params]
3337
        all_os[name][node_name].append((path, status, diagnose,
3338
                                        variants, params, api_versions))
3339
    return all_os
3340

    
3341
  def Exec(self, feedback_fn):
3342
    """Compute the list of OSes.
3343

3344
    """
3345
    valid_nodes = [node for node in self.cfg.GetOnlineNodeList()]
3346
    node_data = self.rpc.call_os_diagnose(valid_nodes)
3347
    pol = self._DiagnoseByOS(node_data)
3348
    output = []
3349
    cluster = self.cfg.GetClusterInfo()
3350

    
3351
    for os_name in utils.NiceSort(pol.keys()):
3352
      os_data = pol[os_name]
3353
      row = []
3354
      valid = True
3355
      (variants, params, api_versions) = null_state = (set(), set(), set())
3356
      for idx, osl in enumerate(os_data.values()):
3357
        valid = bool(valid and osl and osl[0][1])
3358
        if not valid:
3359
          (variants, params, api_versions) = null_state
3360
          break
3361
        node_variants, node_params, node_api = osl[0][3:6]
3362
        if idx == 0: # first entry
3363
          variants = set(node_variants)
3364
          params = set(node_params)
3365
          api_versions = set(node_api)
3366
        else: # keep consistency
3367
          variants.intersection_update(node_variants)
3368
          params.intersection_update(node_params)
3369
          api_versions.intersection_update(node_api)
3370

    
3371
      is_hid = os_name in cluster.hidden_os
3372
      is_blk = os_name in cluster.blacklisted_os
3373
      if ((self._HID not in self.op.output_fields and is_hid) or
3374
          (self._BLK not in self.op.output_fields and is_blk) or
3375
          (self._VLD not in self.op.output_fields and not valid)):
3376
        continue
3377

    
3378
      for field in self.op.output_fields:
3379
        if field == "name":
3380
          val = os_name
3381
        elif field == self._VLD:
3382
          val = valid
3383
        elif field == "node_status":
3384
          # this is just a copy of the dict
3385
          val = {}
3386
          for node_name, nos_list in os_data.items():
3387
            val[node_name] = nos_list
3388
        elif field == "variants":
3389
          val = utils.NiceSort(list(variants))
3390
        elif field == "parameters":
3391
          val = list(params)
3392
        elif field == "api_versions":
3393
          val = list(api_versions)
3394
        elif field == self._HID:
3395
          val = is_hid
3396
        elif field == self._BLK:
3397
          val = is_blk
3398
        else:
3399
          raise errors.ParameterError(field)
3400
        row.append(val)
3401
      output.append(row)
3402

    
3403
    return output
3404

    
3405

    
3406
class LURemoveNode(LogicalUnit):
3407
  """Logical unit for removing a node.
3408

3409
  """
3410
  HPATH = "node-remove"
3411
  HTYPE = constants.HTYPE_NODE
3412

    
3413
  def BuildHooksEnv(self):
3414
    """Build hooks env.
3415

3416
    This doesn't run on the target node in the pre phase as a failed
3417
    node would then be impossible to remove.
3418

3419
    """
3420
    env = {
3421
      "OP_TARGET": self.op.node_name,
3422
      "NODE_NAME": self.op.node_name,
3423
      }
3424
    all_nodes = self.cfg.GetNodeList()
3425
    try:
3426
      all_nodes.remove(self.op.node_name)
3427
    except ValueError:
3428
      logging.warning("Node %s which is about to be removed not found"
3429
                      " in the all nodes list", self.op.node_name)
3430
    return env, all_nodes, all_nodes
3431

    
3432
  def CheckPrereq(self):
3433
    """Check prerequisites.
3434

3435
    This checks:
3436
     - the node exists in the configuration
3437
     - it does not have primary or secondary instances
3438
     - it's not the master
3439

3440
    Any errors are signaled by raising errors.OpPrereqError.
3441

3442
    """
3443
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3444
    node = self.cfg.GetNodeInfo(self.op.node_name)
3445
    assert node is not None
3446

    
3447
    instance_list = self.cfg.GetInstanceList()
3448

    
3449
    masternode = self.cfg.GetMasterNode()
3450
    if node.name == masternode:
3451
      raise errors.OpPrereqError("Node is the master node,"
3452
                                 " you need to failover first.",
3453
                                 errors.ECODE_INVAL)
3454

    
3455
    for instance_name in instance_list:
3456
      instance = self.cfg.GetInstanceInfo(instance_name)
3457
      if node.name in instance.all_nodes:
3458
        raise errors.OpPrereqError("Instance %s is still running on the node,"
3459
                                   " please remove first." % instance_name,
3460
                                   errors.ECODE_INVAL)
3461
    self.op.node_name = node.name
3462
    self.node = node
3463

    
3464
  def Exec(self, feedback_fn):
3465
    """Removes the node from the cluster.
3466

3467
    """
3468
    node = self.node
3469
    logging.info("Stopping the node daemon and removing configs from node %s",
3470
                 node.name)
3471

    
3472
    modify_ssh_setup = self.cfg.GetClusterInfo().modify_ssh_setup
3473

    
3474
    # Promote nodes to master candidate as needed
3475
    _AdjustCandidatePool(self, exceptions=[node.name])
3476
    self.context.RemoveNode(node.name)
3477

    
3478
    # Run post hooks on the node before it's removed
3479
    hm = self.proc.hmclass(self.rpc.call_hooks_runner, self)
3480
    try:
3481
      hm.RunPhase(constants.HOOKS_PHASE_POST, [node.name])
3482
    except:
3483
      # pylint: disable-msg=W0702
3484
      self.LogWarning("Errors occurred running hooks on %s" % node.name)
3485

    
3486
    result = self.rpc.call_node_leave_cluster(node.name, modify_ssh_setup)
3487
    msg = result.fail_msg
3488
    if msg:
3489
      self.LogWarning("Errors encountered on the remote node while leaving"
3490
                      " the cluster: %s", msg)
3491

    
3492
    # Remove node from our /etc/hosts
3493
    if self.cfg.GetClusterInfo().modify_etc_hosts:
3494
      master_node = self.cfg.GetMasterNode()
3495
      result = self.rpc.call_etc_hosts_modify(master_node,
3496
                                              constants.ETC_HOSTS_REMOVE,
3497
                                              node.name, None)
3498
      result.Raise("Can't update hosts file with new host data")
3499
      _RedistributeAncillaryFiles(self)
3500

    
3501

    
3502
class _NodeQuery(_QueryBase):
3503
  FIELDS = query.NODE_FIELDS
3504

    
3505
  def ExpandNames(self, lu):
3506
    lu.needed_locks = {}
3507
    lu.share_locks[locking.LEVEL_NODE] = 1
3508

    
3509
    if self.names:
3510
      self.wanted = _GetWantedNodes(lu, self.names)
3511
    else:
3512
      self.wanted = locking.ALL_SET
3513

    
3514
    self.do_locking = (self.use_locking and
3515
                       query.NQ_LIVE in self.requested_data)
3516

    
3517
    if self.do_locking:
3518
      # if we don't request only static fields, we need to lock the nodes
3519
      lu.needed_locks[locking.LEVEL_NODE] = self.wanted
3520

    
3521
  def DeclareLocks(self, lu, level):
3522
    pass
3523

    
3524
  def _GetQueryData(self, lu):
3525
    """Computes the list of nodes and their attributes.
3526

3527
    """
3528
    all_info = lu.cfg.GetAllNodesInfo()
3529

    
3530
    nodenames = self._GetNames(lu, all_info.keys(), locking.LEVEL_NODE)
3531

    
3532
    # Gather data as requested
3533
    if query.NQ_LIVE in self.requested_data:
3534
      node_data = lu.rpc.call_node_info(nodenames, lu.cfg.GetVGName(),
3535
                                        lu.cfg.GetHypervisorType())
3536
      live_data = dict((name, nresult.payload)
3537
                       for (name, nresult) in node_data.items()
3538
                       if not nresult.fail_msg and nresult.payload)
3539
    else:
3540
      live_data = None
3541

    
3542
    if query.NQ_INST in self.requested_data:
3543
      node_to_primary = dict([(name, set()) for name in nodenames])
3544
      node_to_secondary = dict([(name, set()) for name in nodenames])
3545

    
3546
      inst_data = lu.cfg.GetAllInstancesInfo()
3547

    
3548
      for inst in inst_data.values():
3549
        if inst.primary_node in node_to_primary:
3550
          node_to_primary[inst.primary_node].add(inst.name)
3551
        for secnode in inst.secondary_nodes:
3552
          if secnode in node_to_secondary:
3553
            node_to_secondary[secnode].add(inst.name)
3554
    else:
3555
      node_to_primary = None
3556
      node_to_secondary = None
3557

    
3558
    if query.NQ_OOB in self.requested_data:
3559
      oob_support = dict((name, bool(_SupportsOob(lu.cfg, node)))
3560
                         for name, node in all_info.iteritems())
3561
    else:
3562
      oob_support = None
3563

    
3564
    if query.NQ_GROUP in self.requested_data:
3565
      groups = lu.cfg.GetAllNodeGroupsInfo()
3566
    else:
3567
      groups = {}
3568

    
3569
    return query.NodeQueryData([all_info[name] for name in nodenames],
3570
                               live_data, lu.cfg.GetMasterNode(),
3571
                               node_to_primary, node_to_secondary, groups,
3572
                               oob_support)
3573

    
3574

    
3575
class LUQueryNodes(NoHooksLU):
3576
  """Logical unit for querying nodes.
3577

3578
  """
3579
  # pylint: disable-msg=W0142
3580
  REQ_BGL = False
3581

    
3582
  def CheckArguments(self):
3583
    self.nq = _NodeQuery(self.op.names, self.op.output_fields,
3584
                         self.op.use_locking)
3585

    
3586
  def ExpandNames(self):
3587
    self.nq.ExpandNames(self)
3588

    
3589
  def Exec(self, feedback_fn):
3590
    return self.nq.OldStyleQuery(self)
3591

    
3592

    
3593
class LUQueryNodeVolumes(NoHooksLU):
3594
  """Logical unit for getting volumes on node(s).
3595

3596
  """
3597
  REQ_BGL = False
3598
  _FIELDS_DYNAMIC = utils.FieldSet("phys", "vg", "name", "size", "instance")
3599
  _FIELDS_STATIC = utils.FieldSet("node")
3600

    
3601
  def CheckArguments(self):
3602
    _CheckOutputFields(static=self._FIELDS_STATIC,
3603
                       dynamic=self._FIELDS_DYNAMIC,
3604
                       selected=self.op.output_fields)
3605

    
3606
  def ExpandNames(self):
3607
    self.needed_locks = {}
3608
    self.share_locks[locking.LEVEL_NODE] = 1
3609
    if not self.op.nodes:
3610
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3611
    else:
3612
      self.needed_locks[locking.LEVEL_NODE] = \
3613
        _GetWantedNodes(self, self.op.nodes)
3614

    
3615
  def Exec(self, feedback_fn):
3616
    """Computes the list of nodes and their attributes.
3617

3618
    """
3619
    nodenames = self.acquired_locks[locking.LEVEL_NODE]
3620
    volumes = self.rpc.call_node_volumes(nodenames)
3621

    
3622
    ilist = [self.cfg.GetInstanceInfo(iname) for iname
3623
             in self.cfg.GetInstanceList()]
3624

    
3625
    lv_by_node = dict([(inst, inst.MapLVsByNode()) for inst in ilist])
3626

    
3627
    output = []
3628
    for node in nodenames:
3629
      nresult = volumes[node]
3630
      if nresult.offline:
3631
        continue
3632
      msg = nresult.fail_msg
3633
      if msg:
3634
        self.LogWarning("Can't compute volume data on node %s: %s", node, msg)
3635
        continue
3636

    
3637
      node_vols = nresult.payload[:]
3638
      node_vols.sort(key=lambda vol: vol['dev'])
3639

    
3640
      for vol in node_vols:
3641
        node_output = []
3642
        for field in self.op.output_fields:
3643
          if field == "node":
3644
            val = node
3645
          elif field == "phys":
3646
            val = vol['dev']
3647
          elif field == "vg":
3648
            val = vol['vg']
3649
          elif field == "name":
3650
            val = vol['name']
3651
          elif field == "size":
3652
            val = int(float(vol['size']))
3653
          elif field == "instance":
3654
            for inst in ilist:
3655
              if node not in lv_by_node[inst]:
3656
                continue
3657
              if vol['name'] in lv_by_node[inst][node]:
3658
                val = inst.name
3659
                break
3660
            else:
3661
              val = '-'
3662
          else:
3663
            raise errors.ParameterError(field)
3664
          node_output.append(str(val))
3665

    
3666
        output.append(node_output)
3667

    
3668
    return output
3669

    
3670

    
3671
class LUQueryNodeStorage(NoHooksLU):
3672
  """Logical unit for getting information on storage units on node(s).
3673

3674
  """
3675
  _FIELDS_STATIC = utils.FieldSet(constants.SF_NODE)
3676
  REQ_BGL = False
3677

    
3678
  def CheckArguments(self):
3679
    _CheckOutputFields(static=self._FIELDS_STATIC,
3680
                       dynamic=utils.FieldSet(*constants.VALID_STORAGE_FIELDS),
3681
                       selected=self.op.output_fields)
3682

    
3683
  def ExpandNames(self):
3684
    self.needed_locks = {}
3685
    self.share_locks[locking.LEVEL_NODE] = 1
3686

    
3687
    if self.op.nodes:
3688
      self.needed_locks[locking.LEVEL_NODE] = \
3689
        _GetWantedNodes(self, self.op.nodes)
3690
    else:
3691
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3692

    
3693
  def Exec(self, feedback_fn):
3694
    """Computes the list of nodes and their attributes.
3695

3696
    """
3697
    self.nodes = self.acquired_locks[locking.LEVEL_NODE]
3698

    
3699
    # Always get name to sort by
3700
    if constants.SF_NAME in self.op.output_fields:
3701
      fields = self.op.output_fields[:]
3702
    else:
3703
      fields = [constants.SF_NAME] + self.op.output_fields
3704

    
3705
    # Never ask for node or type as it's only known to the LU
3706
    for extra in [constants.SF_NODE, constants.SF_TYPE]:
3707
      while extra in fields:
3708
        fields.remove(extra)
3709

    
3710
    field_idx = dict([(name, idx) for (idx, name) in enumerate(fields)])
3711
    name_idx = field_idx[constants.SF_NAME]
3712

    
3713
    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
3714
    data = self.rpc.call_storage_list(self.nodes,
3715
                                      self.op.storage_type, st_args,
3716
                                      self.op.name, fields)
3717

    
3718
    result = []
3719

    
3720
    for node in utils.NiceSort(self.nodes):
3721
      nresult = data[node]
3722
      if nresult.offline:
3723
        continue
3724

    
3725
      msg = nresult.fail_msg
3726
      if msg:
3727
        self.LogWarning("Can't get storage data from node %s: %s", node, msg)
3728
        continue
3729

    
3730
      rows = dict([(row[name_idx], row) for row in nresult.payload])
3731

    
3732
      for name in utils.NiceSort(rows.keys()):
3733
        row = rows[name]
3734

    
3735
        out = []
3736

    
3737
        for field in self.op.output_fields:
3738
          if field == constants.SF_NODE:
3739
            val = node
3740
          elif field == constants.SF_TYPE:
3741
            val = self.op.storage_type
3742
          elif field in field_idx:
3743
            val = row[field_idx[field]]
3744
          else:
3745
            raise errors.ParameterError(field)
3746

    
3747
          out.append(val)
3748

    
3749
        result.append(out)
3750

    
3751
    return result
3752

    
3753

    
3754
class _InstanceQuery(_QueryBase):
3755
  FIELDS = query.INSTANCE_FIELDS
3756

    
3757
  def ExpandNames(self, lu):
3758
    lu.needed_locks = {}
3759
    lu.share_locks[locking.LEVEL_INSTANCE] = 1
3760
    lu.share_locks[locking.LEVEL_NODE] = 1
3761

    
3762
    if self.names:
3763
      self.wanted = _GetWantedInstances(lu, self.names)
3764
    else:
3765
      self.wanted = locking.ALL_SET
3766

    
3767
    self.do_locking = (self.use_locking and
3768
                       query.IQ_LIVE in self.requested_data)
3769
    if self.do_locking:
3770
      lu.needed_locks[locking.LEVEL_INSTANCE] = self.wanted
3771
      lu.needed_locks[locking.LEVEL_NODE] = []
3772
      lu.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
3773

    
3774
  def DeclareLocks(self, lu, level):
3775
    if level == locking.LEVEL_NODE and self.do_locking:
3776
      lu._LockInstancesNodes() # pylint: disable-msg=W0212
3777

    
3778
  def _GetQueryData(self, lu):
3779
    """Computes the list of instances and their attributes.
3780

3781
    """
3782
    all_info = lu.cfg.GetAllInstancesInfo()
3783

    
3784
    instance_names = self._GetNames(lu, all_info.keys(), locking.LEVEL_INSTANCE)
3785

    
3786
    instance_list = [all_info[name] for name in instance_names]
3787
    nodes = frozenset([inst.primary_node for inst in instance_list])
3788
    hv_list = list(set([inst.hypervisor for inst in instance_list]))
3789
    bad_nodes = []
3790
    offline_nodes = []
3791

    
3792
    # Gather data as requested
3793
    if query.IQ_LIVE in self.requested_data:
3794
      live_data = {}
3795
      node_data = lu.rpc.call_all_instances_info(nodes, hv_list)
3796
      for name in nodes:
3797
        result = node_data[name]
3798
        if result.offline:
3799
          # offline nodes will be in both lists
3800
          assert result.fail_msg
3801
          offline_nodes.append(name)
3802
        if result.fail_msg:
3803
          bad_nodes.append(name)
3804
        elif result.payload:
3805
          live_data.update(result.payload)
3806
        # else no instance is alive
3807
    else:
3808
      live_data = {}
3809

    
3810
    if query.IQ_DISKUSAGE in self.requested_data:
3811
      disk_usage = dict((inst.name,
3812
                         _ComputeDiskSize(inst.disk_template,
3813
                                          [{"size": disk.size}
3814
                                           for disk in inst.disks]))
3815
                        for inst in instance_list)
3816
    else:
3817
      disk_usage = None
3818

    
3819
    return query.InstanceQueryData(instance_list, lu.cfg.GetClusterInfo(),
3820
                                   disk_usage, offline_nodes, bad_nodes,
3821
                                   live_data)
3822

    
3823

    
3824
class LUQuery(NoHooksLU):
3825
  """Query for resources/items of a certain kind.
3826

3827
  """
3828
  # pylint: disable-msg=W0142
3829
  REQ_BGL = False
3830

    
3831
  def CheckArguments(self):
3832
    qcls = _GetQueryImplementation(self.op.what)
3833
    names = qlang.ReadSimpleFilter("name", self.op.filter)
3834

    
3835
    self.impl = qcls(names, self.op.fields, False)
3836

    
3837
  def ExpandNames(self):
3838
    self.impl.ExpandNames(self)
3839

    
3840
  def DeclareLocks(self, level):
3841
    self.impl.DeclareLocks(self, level)
3842

    
3843
  def Exec(self, feedback_fn):
3844
    return self.impl.NewStyleQuery(self)
3845

    
3846

    
3847
class LUQueryFields(NoHooksLU):
3848
  """Query for resources/items of a certain kind.
3849

3850
  """
3851
  # pylint: disable-msg=W0142
3852
  REQ_BGL = False
3853

    
3854
  def CheckArguments(self):
3855
    self.qcls = _GetQueryImplementation(self.op.what)
3856

    
3857
  def ExpandNames(self):
3858
    self.needed_locks = {}
3859

    
3860
  def Exec(self, feedback_fn):
3861
    return self.qcls.FieldsQuery(self.op.fields)
3862

    
3863

    
3864
class LUModifyNodeStorage(NoHooksLU):
3865
  """Logical unit for modifying a storage volume on a node.
3866

3867
  """
3868
  REQ_BGL = False
3869

    
3870
  def CheckArguments(self):
3871
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3872

    
3873
    storage_type = self.op.storage_type
3874

    
3875
    try:
3876
      modifiable = constants.MODIFIABLE_STORAGE_FIELDS[storage_type]
3877
    except KeyError:
3878
      raise errors.OpPrereqError("Storage units of type '%s' can not be"
3879
                                 " modified" % storage_type,
3880
                                 errors.ECODE_INVAL)
3881

    
3882
    diff = set(self.op.changes.keys()) - modifiable
3883
    if diff:
3884
      raise errors.OpPrereqError("The following fields can not be modified for"
3885
                                 " storage units of type '%s': %r" %
3886
                                 (storage_type, list(diff)),
3887
                                 errors.ECODE_INVAL)
3888

    
3889
  def ExpandNames(self):
3890
    self.needed_locks = {
3891
      locking.LEVEL_NODE: self.op.node_name,
3892
      }
3893

    
3894
  def Exec(self, feedback_fn):
3895
    """Computes the list of nodes and their attributes.
3896

3897
    """
3898
    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
3899
    result = self.rpc.call_storage_modify(self.op.node_name,
3900
                                          self.op.storage_type, st_args,
3901
                                          self.op.name, self.op.changes)
3902
    result.Raise("Failed to modify storage unit '%s' on %s" %
3903
                 (self.op.name, self.op.node_name))
3904

    
3905

    
3906
class LUAddNode(LogicalUnit):
3907
  """Logical unit for adding node to the cluster.
3908

3909
  """
3910
  HPATH = "node-add"
3911
  HTYPE = constants.HTYPE_NODE
3912
  _NFLAGS = ["master_capable", "vm_capable"]
3913

    
3914
  def CheckArguments(self):
3915
    self.primary_ip_family = self.cfg.GetPrimaryIPFamily()
3916
    # validate/normalize the node name
3917
    self.hostname = netutils.GetHostname(name=self.op.node_name,
3918
                                         family=self.primary_ip_family)
3919
    self.op.node_name = self.hostname.name
3920
    if self.op.readd and self.op.group:
3921
      raise errors.OpPrereqError("Cannot pass a node group when a node is"
3922
                                 " being readded", errors.ECODE_INVAL)
3923

    
3924
  def BuildHooksEnv(self):
3925
    """Build hooks env.
3926

3927
    This will run on all nodes before, and on all nodes + the new node after.
3928

3929
    """
3930
    env = {
3931
      "OP_TARGET": self.op.node_name,
3932
      "NODE_NAME": self.op.node_name,
3933
      "NODE_PIP": self.op.primary_ip,
3934
      "NODE_SIP": self.op.secondary_ip,
3935
      "MASTER_CAPABLE": str(self.op.master_capable),
3936
      "VM_CAPABLE": str(self.op.vm_capable),
3937
      }
3938
    nodes_0 = self.cfg.GetNodeList()
3939
    nodes_1 = nodes_0 + [self.op.node_name, ]
3940
    return env, nodes_0, nodes_1
3941

    
3942
  def CheckPrereq(self):
3943
    """Check prerequisites.
3944

3945
    This checks:
3946
     - the new node is not already in the config
3947
     - it is resolvable
3948
     - its parameters (single/dual homed) matches the cluster
3949

3950
    Any errors are signaled by raising errors.OpPrereqError.
3951

3952
    """
3953
    cfg = self.cfg
3954
    hostname = self.hostname
3955
    node = hostname.name
3956
    primary_ip = self.op.primary_ip = hostname.ip
3957
    if self.op.secondary_ip is None:
3958
      if self.primary_ip_family == netutils.IP6Address.family:
3959
        raise errors.OpPrereqError("When using a IPv6 primary address, a valid"
3960
                                   " IPv4 address must be given as secondary",
3961
                                   errors.ECODE_INVAL)
3962
      self.op.secondary_ip = primary_ip
3963

    
3964
    secondary_ip = self.op.secondary_ip
3965
    if not netutils.IP4Address.IsValid(secondary_ip):
3966
      raise errors.OpPrereqError("Secondary IP (%s) needs to be a valid IPv4"
3967
                                 " address" % secondary_ip, errors.ECODE_INVAL)
3968

    
3969
    node_list = cfg.GetNodeList()
3970
    if not self.op.readd and node in node_list:
3971
      raise errors.OpPrereqError("Node %s is already in the configuration" %
3972
                                 node, errors.ECODE_EXISTS)
3973
    elif self.op.readd and node not in node_list:
3974
      raise errors.OpPrereqError("Node %s is not in the configuration" % node,
3975
                                 errors.ECODE_NOENT)
3976

    
3977
    self.changed_primary_ip = False
3978

    
3979
    for existing_node_name in node_list:
3980
      existing_node = cfg.GetNodeInfo(existing_node_name)
3981

    
3982
      if self.op.readd and node == existing_node_name:
3983
        if existing_node.secondary_ip != secondary_ip:
3984
          raise errors.OpPrereqError("Readded node doesn't have the same IP"
3985
                                     " address configuration as before",
3986
                                     errors.ECODE_INVAL)
3987
        if existing_node.primary_ip != primary_ip:
3988
          self.changed_primary_ip = True
3989

    
3990
        continue
3991

    
3992
      if (existing_node.primary_ip == primary_ip or
3993
          existing_node.secondary_ip == primary_ip or
3994
          existing_node.primary_ip == secondary_ip or
3995
          existing_node.secondary_ip == secondary_ip):
3996
        raise errors.OpPrereqError("New node ip address(es) conflict with"
3997
                                   " existing node %s" % existing_node.name,
3998
                                   errors.ECODE_NOTUNIQUE)
3999

    
4000
    # After this 'if' block, None is no longer a valid value for the
4001
    # _capable op attributes
4002
    if self.op.readd:
4003
      old_node = self.cfg.GetNodeInfo(node)
4004
      assert old_node is not None, "Can't retrieve locked node %s" % node
4005
      for attr in self._NFLAGS:
4006
        if getattr(self.op, attr) is None:
4007
          setattr(self.op, attr, getattr(old_node, attr))
4008
    else:
4009
      for attr in self._NFLAGS:
4010
        if getattr(self.op, attr) is None:
4011
          setattr(self.op, attr, True)
4012

    
4013
    if self.op.readd and not self.op.vm_capable:
4014
      pri, sec = cfg.GetNodeInstances(node)
4015
      if pri or sec:
4016
        raise errors.OpPrereqError("Node %s being re-added with vm_capable"
4017
                                   " flag set to false, but it already holds"
4018
                                   " instances" % node,
4019
                                   errors.ECODE_STATE)
4020

    
4021
    # check that the type of the node (single versus dual homed) is the
4022
    # same as for the master
4023
    myself = cfg.GetNodeInfo(self.cfg.GetMasterNode())
4024
    master_singlehomed = myself.secondary_ip == myself.primary_ip
4025
    newbie_singlehomed = secondary_ip == primary_ip
4026
    if master_singlehomed != newbie_singlehomed:
4027
      if master_singlehomed:
4028
        raise errors.OpPrereqError("The master has no secondary ip but the"
4029
                                   " new node has one",
4030
                                   errors.ECODE_INVAL)
4031
      else:
4032
        raise errors.OpPrereqError("The master has a secondary ip but the"
4033
                                   " new node doesn't have one",
4034
                                   errors.ECODE_INVAL)
4035

    
4036
    # checks reachability
4037
    if not netutils.TcpPing(primary_ip, constants.DEFAULT_NODED_PORT):
4038
      raise errors.OpPrereqError("Node not reachable by ping",
4039
                                 errors.ECODE_ENVIRON)
4040

    
4041
    if not newbie_singlehomed:
4042
      # check reachability from my secondary ip to newbie's secondary ip
4043
      if not netutils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,
4044
                           source=myself.secondary_ip):
4045
        raise errors.OpPrereqError("Node secondary ip not reachable by TCP"
4046
                                   " based ping to node daemon port",
4047
                                   errors.ECODE_ENVIRON)
4048

    
4049
    if self.op.readd:
4050
      exceptions = [node]
4051
    else:
4052
      exceptions = []
4053

    
4054
    if self.op.master_capable:
4055
      self.master_candidate = _DecideSelfPromotion(self, exceptions=exceptions)
4056
    else:
4057
      self.master_candidate = False
4058

    
4059
    if self.op.readd:
4060
      self.new_node = old_node
4061
    else:
4062
      node_group = cfg.LookupNodeGroup(self.op.group)
4063
      self.new_node = objects.Node(name=node,
4064
                                   primary_ip=primary_ip,
4065
                                   secondary_ip=secondary_ip,
4066
                                   master_candidate=self.master_candidate,
4067
                                   offline=False, drained=False,
4068
                                   group=node_group)
4069

    
4070
    if self.op.ndparams:
4071
      utils.ForceDictType(self.op.ndparams, constants.NDS_PARAMETER_TYPES)
4072

    
4073
  def Exec(self, feedback_fn):
4074
    """Adds the new node to the cluster.
4075

4076
    """
4077
    new_node = self.new_node
4078
    node = new_node.name
4079

    
4080
    # We adding a new node so we assume it's powered
4081
    new_node.powered = True
4082

    
4083
    # for re-adds, reset the offline/drained/master-candidate flags;
4084
    # we need to reset here, otherwise offline would prevent RPC calls
4085
    # later in the procedure; this also means that if the re-add
4086
    # fails, we are left with a non-offlined, broken node
4087
    if self.op.readd:
4088
      new_node.drained = new_node.offline = False # pylint: disable-msg=W0201
4089
      self.LogInfo("Readding a node, the offline/drained flags were reset")
4090
      # if we demote the node, we do cleanup later in the procedure
4091