Statistics
| Branch: | Tag: | Revision:

root / lib / cmdlib.py @ a01225a6

History | View | Annotate | Download (433.9 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Google Inc.
5
#
6
# This program is free software; you can redistribute it and/or modify
7
# it under the terms of the GNU General Public License as published by
8
# the Free Software Foundation; either version 2 of the License, or
9
# (at your option) any later version.
10
#
11
# This program is distributed in the hope that it will be useful, but
12
# WITHOUT ANY WARRANTY; without even the implied warranty of
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
# General Public License for more details.
15
#
16
# You should have received a copy of the GNU General Public License
17
# along with this program; if not, write to the Free Software
18
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19
# 02110-1301, USA.
20

    
21

    
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
from ganeti import ht
61

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

    
64

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

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

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

    
77

    
78
class ResultWithJobs:
79
  """Data container for LU results with jobs.
80

81
  Instances of this class returned from L{LogicalUnit.Exec} will be recognized
82
  by L{mcpu.Processor._ProcessResult}. The latter will then submit the jobs
83
  contained in the C{jobs} attribute and include the job IDs in the opcode
84
  result.
85

86
  """
87
  def __init__(self, jobs, **kwargs):
88
    """Initializes this class.
89

90
    Additional return values can be specified as keyword arguments.
91

92
    @type jobs: list of lists of L{opcode.OpCode}
93
    @param jobs: A list of lists of opcode objects
94

95
    """
96
    self.jobs = jobs
97
    self.other = kwargs
98

    
99

    
100
class LogicalUnit(object):
101
  """Logical Unit base class.
102

103
  Subclasses must follow these rules:
104
    - implement ExpandNames
105
    - implement CheckPrereq (except when tasklets are used)
106
    - implement Exec (except when tasklets are used)
107
    - implement BuildHooksEnv
108
    - implement BuildHooksNodes
109
    - redefine HPATH and HTYPE
110
    - optionally redefine their run requirements:
111
        REQ_BGL: the LU needs to hold the Big Ganeti Lock exclusively
112

113
  Note that all commands require root permissions.
114

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

118
  """
119
  HPATH = None
120
  HTYPE = None
121
  REQ_BGL = True
122

    
123
  def __init__(self, processor, op, context, rpc):
124
    """Constructor for LogicalUnit.
125

126
    This needs to be overridden in derived classes in order to check op
127
    validity.
128

129
    """
130
    self.proc = processor
131
    self.op = op
132
    self.cfg = context.cfg
133
    self.glm = context.glm
134
    self.context = context
135
    self.rpc = rpc
136
    # Dicts used to declare locking needs to mcpu
137
    self.needed_locks = None
138
    self.share_locks = dict.fromkeys(locking.LEVELS, 0)
139
    self.add_locks = {}
140
    self.remove_locks = {}
141
    # Used to force good behavior when calling helper functions
142
    self.recalculate_locks = {}
143
    # logging
144
    self.Log = processor.Log # pylint: disable-msg=C0103
145
    self.LogWarning = processor.LogWarning # pylint: disable-msg=C0103
146
    self.LogInfo = processor.LogInfo # pylint: disable-msg=C0103
147
    self.LogStep = processor.LogStep # pylint: disable-msg=C0103
148
    # support for dry-run
149
    self.dry_run_result = None
150
    # support for generic debug attribute
151
    if (not hasattr(self.op, "debug_level") or
152
        not isinstance(self.op.debug_level, int)):
153
      self.op.debug_level = 0
154

    
155
    # Tasklets
156
    self.tasklets = None
157

    
158
    # Validate opcode parameters and set defaults
159
    self.op.Validate(True)
160

    
161
    self.CheckArguments()
162

    
163
  def CheckArguments(self):
164
    """Check syntactic validity for the opcode arguments.
165

166
    This method is for doing a simple syntactic check and ensure
167
    validity of opcode parameters, without any cluster-related
168
    checks. While the same can be accomplished in ExpandNames and/or
169
    CheckPrereq, doing these separate is better because:
170

171
      - ExpandNames is left as as purely a lock-related function
172
      - CheckPrereq is run after we have acquired locks (and possible
173
        waited for them)
174

175
    The function is allowed to change the self.op attribute so that
176
    later methods can no longer worry about missing parameters.
177

178
    """
179
    pass
180

    
181
  def ExpandNames(self):
182
    """Expand names for this LU.
183

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

189
    LUs which implement this method must also populate the self.needed_locks
190
    member, as a dict with lock levels as keys, and a list of needed lock names
191
    as values. Rules:
192

193
      - use an empty dict if you don't need any lock
194
      - if you don't need any lock at a particular level omit that level
195
      - don't put anything for the BGL level
196
      - if you want all locks at a level use locking.ALL_SET as a value
197

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

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

206
    Examples::
207

208
      # Acquire all nodes and one instance
209
      self.needed_locks = {
210
        locking.LEVEL_NODE: locking.ALL_SET,
211
        locking.LEVEL_INSTANCE: ['instance1.example.com'],
212
      }
213
      # Acquire just two nodes
214
      self.needed_locks = {
215
        locking.LEVEL_NODE: ['node1.example.com', 'node2.example.com'],
216
      }
217
      # Acquire no locks
218
      self.needed_locks = {} # No, you can't leave it to the default value None
219

220
    """
221
    # The implementation of this method is mandatory only if the new LU is
222
    # concurrent, so that old LUs don't need to be changed all at the same
223
    # time.
224
    if self.REQ_BGL:
225
      self.needed_locks = {} # Exclusive LUs don't need locks.
226
    else:
227
      raise NotImplementedError
228

    
229
  def DeclareLocks(self, level):
230
    """Declare LU locking needs for a level
231

232
    While most LUs can just declare their locking needs at ExpandNames time,
233
    sometimes there's the need to calculate some locks after having acquired
234
    the ones before. This function is called just before acquiring locks at a
235
    particular level, but after acquiring the ones at lower levels, and permits
236
    such calculations. It can be used to modify self.needed_locks, and by
237
    default it does nothing.
238

239
    This function is only called if you have something already set in
240
    self.needed_locks for the level.
241

242
    @param level: Locking level which is going to be locked
243
    @type level: member of ganeti.locking.LEVELS
244

245
    """
246

    
247
  def CheckPrereq(self):
248
    """Check prerequisites for this LU.
249

250
    This method should check that the prerequisites for the execution
251
    of this LU are fulfilled. It can do internode communication, but
252
    it should be idempotent - no cluster or system changes are
253
    allowed.
254

255
    The method should raise errors.OpPrereqError in case something is
256
    not fulfilled. Its return value is ignored.
257

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

261
    """
262
    if self.tasklets is not None:
263
      for (idx, tl) in enumerate(self.tasklets):
264
        logging.debug("Checking prerequisites for tasklet %s/%s",
265
                      idx + 1, len(self.tasklets))
266
        tl.CheckPrereq()
267
    else:
268
      pass
269

    
270
  def Exec(self, feedback_fn):
271
    """Execute the LU.
272

273
    This method should implement the actual work. It should raise
274
    errors.OpExecError for failures that are somewhat dealt with in
275
    code, or expected.
276

277
    """
278
    if self.tasklets is not None:
279
      for (idx, tl) in enumerate(self.tasklets):
280
        logging.debug("Executing tasklet %s/%s", idx + 1, len(self.tasklets))
281
        tl.Exec(feedback_fn)
282
    else:
283
      raise NotImplementedError
284

    
285
  def BuildHooksEnv(self):
286
    """Build hooks environment for this LU.
287

288
    @rtype: dict
289
    @return: Dictionary containing the environment that will be used for
290
      running the hooks for this LU. The keys of the dict must not be prefixed
291
      with "GANETI_"--that'll be added by the hooks runner. The hooks runner
292
      will extend the environment with additional variables. If no environment
293
      should be defined, an empty dictionary should be returned (not C{None}).
294
    @note: If the C{HPATH} attribute of the LU class is C{None}, this function
295
      will not be called.
296

297
    """
298
    raise NotImplementedError
299

    
300
  def BuildHooksNodes(self):
301
    """Build list of nodes to run LU's hooks.
302

303
    @rtype: tuple; (list, list)
304
    @return: Tuple containing a list of node names on which the hook
305
      should run before the execution and a list of node names on which the
306
      hook should run after the execution. No nodes should be returned as an
307
      empty list (and not None).
308
    @note: If the C{HPATH} attribute of the LU class is C{None}, this function
309
      will not be called.
310

311
    """
312
    raise NotImplementedError
313

    
314
  def HooksCallBack(self, phase, hook_results, feedback_fn, lu_result):
315
    """Notify the LU about the results of its hooks.
316

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

323
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
324
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
325
    @param hook_results: the results of the multi-node hooks rpc call
326
    @param feedback_fn: function used send feedback back to the caller
327
    @param lu_result: the previous Exec result this LU had, or None
328
        in the PRE phase
329
    @return: the new Exec result, based on the previous result
330
        and hook results
331

332
    """
333
    # API must be kept, thus we ignore the unused argument and could
334
    # be a function warnings
335
    # pylint: disable-msg=W0613,R0201
336
    return lu_result
337

    
338
  def _ExpandAndLockInstance(self):
339
    """Helper function to expand and lock an instance.
340

341
    Many LUs that work on an instance take its name in self.op.instance_name
342
    and need to expand it and then declare the expanded name for locking. This
343
    function does it, and then updates self.op.instance_name to the expanded
344
    name. It also initializes needed_locks as a dict, if this hasn't been done
345
    before.
346

347
    """
348
    if self.needed_locks is None:
349
      self.needed_locks = {}
350
    else:
351
      assert locking.LEVEL_INSTANCE not in self.needed_locks, \
352
        "_ExpandAndLockInstance called with instance-level locks set"
353
    self.op.instance_name = _ExpandInstanceName(self.cfg,
354
                                                self.op.instance_name)
355
    self.needed_locks[locking.LEVEL_INSTANCE] = self.op.instance_name
356

    
357
  def _LockInstancesNodes(self, primary_only=False):
358
    """Helper function to declare instances' nodes for locking.
359

360
    This function should be called after locking one or more instances to lock
361
    their nodes. Its effect is populating self.needed_locks[locking.LEVEL_NODE]
362
    with all primary or secondary nodes for instances already locked and
363
    present in self.needed_locks[locking.LEVEL_INSTANCE].
364

365
    It should be called from DeclareLocks, and for safety only works if
366
    self.recalculate_locks[locking.LEVEL_NODE] is set.
367

368
    In the future it may grow parameters to just lock some instance's nodes, or
369
    to just lock primaries or secondary nodes, if needed.
370

371
    If should be called in DeclareLocks in a way similar to::
372

373
      if level == locking.LEVEL_NODE:
374
        self._LockInstancesNodes()
375

376
    @type primary_only: boolean
377
    @param primary_only: only lock primary nodes of locked instances
378

379
    """
380
    assert locking.LEVEL_NODE in self.recalculate_locks, \
381
      "_LockInstancesNodes helper function called with no nodes to recalculate"
382

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

    
385
    # For now we'll replace self.needed_locks[locking.LEVEL_NODE], but in the
386
    # future we might want to have different behaviors depending on the value
387
    # of self.recalculate_locks[locking.LEVEL_NODE]
388
    wanted_nodes = []
389
    for instance_name in self.glm.list_owned(locking.LEVEL_INSTANCE):
390
      instance = self.context.cfg.GetInstanceInfo(instance_name)
391
      wanted_nodes.append(instance.primary_node)
392
      if not primary_only:
393
        wanted_nodes.extend(instance.secondary_nodes)
394

    
395
    if self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_REPLACE:
396
      self.needed_locks[locking.LEVEL_NODE] = wanted_nodes
397
    elif self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_APPEND:
398
      self.needed_locks[locking.LEVEL_NODE].extend(wanted_nodes)
399

    
400
    del self.recalculate_locks[locking.LEVEL_NODE]
401

    
402

    
403
class NoHooksLU(LogicalUnit): # pylint: disable-msg=W0223
404
  """Simple LU which runs no hooks.
405

406
  This LU is intended as a parent for other LogicalUnits which will
407
  run no hooks, in order to reduce duplicate code.
408

409
  """
410
  HPATH = None
411
  HTYPE = None
412

    
413
  def BuildHooksEnv(self):
414
    """Empty BuildHooksEnv for NoHooksLu.
415

416
    This just raises an error.
417

418
    """
419
    raise AssertionError("BuildHooksEnv called for NoHooksLUs")
420

    
421
  def BuildHooksNodes(self):
422
    """Empty BuildHooksNodes for NoHooksLU.
423

424
    """
425
    raise AssertionError("BuildHooksNodes called for NoHooksLU")
426

    
427

    
428
class Tasklet:
429
  """Tasklet base class.
430

431
  Tasklets are subcomponents for LUs. LUs can consist entirely of tasklets or
432
  they can mix legacy code with tasklets. Locking needs to be done in the LU,
433
  tasklets know nothing about locks.
434

435
  Subclasses must follow these rules:
436
    - Implement CheckPrereq
437
    - Implement Exec
438

439
  """
440
  def __init__(self, lu):
441
    self.lu = lu
442

    
443
    # Shortcuts
444
    self.cfg = lu.cfg
445
    self.rpc = lu.rpc
446

    
447
  def CheckPrereq(self):
448
    """Check prerequisites for this tasklets.
449

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

454
    The method should raise errors.OpPrereqError in case something is not
455
    fulfilled. Its return value is ignored.
456

457
    This method should also update all parameters to their canonical form if it
458
    hasn't been done before.
459

460
    """
461
    pass
462

    
463
  def Exec(self, feedback_fn):
464
    """Execute the tasklet.
465

466
    This method should implement the actual work. It should raise
467
    errors.OpExecError for failures that are somewhat dealt with in code, or
468
    expected.
469

470
    """
471
    raise NotImplementedError
472

    
473

    
474
class _QueryBase:
475
  """Base for query utility classes.
476

477
  """
478
  #: Attribute holding field definitions
479
  FIELDS = None
480

    
481
  def __init__(self, filter_, fields, use_locking):
482
    """Initializes this class.
483

484
    """
485
    self.use_locking = use_locking
486

    
487
    self.query = query.Query(self.FIELDS, fields, filter_=filter_,
488
                             namefield="name")
489
    self.requested_data = self.query.RequestedData()
490
    self.names = self.query.RequestedNames()
491

    
492
    # Sort only if no names were requested
493
    self.sort_by_name = not self.names
494

    
495
    self.do_locking = None
496
    self.wanted = None
497

    
498
  def _GetNames(self, lu, all_names, lock_level):
499
    """Helper function to determine names asked for in the query.
500

501
    """
502
    if self.do_locking:
503
      names = lu.glm.list_owned(lock_level)
504
    else:
505
      names = all_names
506

    
507
    if self.wanted == locking.ALL_SET:
508
      assert not self.names
509
      # caller didn't specify names, so ordering is not important
510
      return utils.NiceSort(names)
511

    
512
    # caller specified names and we must keep the same order
513
    assert self.names
514
    assert not self.do_locking or lu.glm.is_owned(lock_level)
515

    
516
    missing = set(self.wanted).difference(names)
517
    if missing:
518
      raise errors.OpExecError("Some items were removed before retrieving"
519
                               " their data: %s" % missing)
520

    
521
    # Return expanded names
522
    return self.wanted
523

    
524
  def ExpandNames(self, lu):
525
    """Expand names for this query.
526

527
    See L{LogicalUnit.ExpandNames}.
528

529
    """
530
    raise NotImplementedError()
531

    
532
  def DeclareLocks(self, lu, level):
533
    """Declare locks for this query.
534

535
    See L{LogicalUnit.DeclareLocks}.
536

537
    """
538
    raise NotImplementedError()
539

    
540
  def _GetQueryData(self, lu):
541
    """Collects all data for this query.
542

543
    @return: Query data object
544

545
    """
546
    raise NotImplementedError()
547

    
548
  def NewStyleQuery(self, lu):
549
    """Collect data and execute query.
550

551
    """
552
    return query.GetQueryResponse(self.query, self._GetQueryData(lu),
553
                                  sort_by_name=self.sort_by_name)
554

    
555
  def OldStyleQuery(self, lu):
556
    """Collect data and execute query.
557

558
    """
559
    return self.query.OldStyleQuery(self._GetQueryData(lu),
560
                                    sort_by_name=self.sort_by_name)
561

    
562

    
563
def _GetWantedNodes(lu, nodes):
564
  """Returns list of checked and expanded node names.
565

566
  @type lu: L{LogicalUnit}
567
  @param lu: the logical unit on whose behalf we execute
568
  @type nodes: list
569
  @param nodes: list of node names or None for all nodes
570
  @rtype: list
571
  @return: the list of nodes, sorted
572
  @raise errors.ProgrammerError: if the nodes parameter is wrong type
573

574
  """
575
  if nodes:
576
    return [_ExpandNodeName(lu.cfg, name) for name in nodes]
577

    
578
  return utils.NiceSort(lu.cfg.GetNodeList())
579

    
580

    
581
def _GetWantedInstances(lu, instances):
582
  """Returns list of checked and expanded instance names.
583

584
  @type lu: L{LogicalUnit}
585
  @param lu: the logical unit on whose behalf we execute
586
  @type instances: list
587
  @param instances: list of instance names or None for all instances
588
  @rtype: list
589
  @return: the list of instances, sorted
590
  @raise errors.OpPrereqError: if the instances parameter is wrong type
591
  @raise errors.OpPrereqError: if any of the passed instances is not found
592

593
  """
594
  if instances:
595
    wanted = [_ExpandInstanceName(lu.cfg, name) for name in instances]
596
  else:
597
    wanted = utils.NiceSort(lu.cfg.GetInstanceList())
598
  return wanted
599

    
600

    
601
def _GetUpdatedParams(old_params, update_dict,
602
                      use_default=True, use_none=False):
603
  """Return the new version of a parameter dictionary.
604

605
  @type old_params: dict
606
  @param old_params: old parameters
607
  @type update_dict: dict
608
  @param update_dict: dict containing new parameter values, or
609
      constants.VALUE_DEFAULT to reset the parameter to its default
610
      value
611
  @param use_default: boolean
612
  @type use_default: whether to recognise L{constants.VALUE_DEFAULT}
613
      values as 'to be deleted' values
614
  @param use_none: boolean
615
  @type use_none: whether to recognise C{None} values as 'to be
616
      deleted' values
617
  @rtype: dict
618
  @return: the new parameter dictionary
619

620
  """
621
  params_copy = copy.deepcopy(old_params)
622
  for key, val in update_dict.iteritems():
623
    if ((use_default and val == constants.VALUE_DEFAULT) or
624
        (use_none and val is None)):
625
      try:
626
        del params_copy[key]
627
      except KeyError:
628
        pass
629
    else:
630
      params_copy[key] = val
631
  return params_copy
632

    
633

    
634
def _ReleaseLocks(lu, level, names=None, keep=None):
635
  """Releases locks owned by an LU.
636

637
  @type lu: L{LogicalUnit}
638
  @param level: Lock level
639
  @type names: list or None
640
  @param names: Names of locks to release
641
  @type keep: list or None
642
  @param keep: Names of locks to retain
643

644
  """
645
  assert not (keep is not None and names is not None), \
646
         "Only one of the 'names' and the 'keep' parameters can be given"
647

    
648
  if names is not None:
649
    should_release = names.__contains__
650
  elif keep:
651
    should_release = lambda name: name not in keep
652
  else:
653
    should_release = None
654

    
655
  if should_release:
656
    retain = []
657
    release = []
658

    
659
    # Determine which locks to release
660
    for name in lu.glm.list_owned(level):
661
      if should_release(name):
662
        release.append(name)
663
      else:
664
        retain.append(name)
665

    
666
    assert len(lu.glm.list_owned(level)) == (len(retain) + len(release))
667

    
668
    # Release just some locks
669
    lu.glm.release(level, names=release)
670

    
671
    assert frozenset(lu.glm.list_owned(level)) == frozenset(retain)
672
  else:
673
    # Release everything
674
    lu.glm.release(level)
675

    
676
    assert not lu.glm.is_owned(level), "No locks should be owned"
677

    
678

    
679
def _RunPostHook(lu, node_name):
680
  """Runs the post-hook for an opcode on a single node.
681

682
  """
683
  hm = lu.proc.hmclass(lu.rpc.call_hooks_runner, lu)
684
  try:
685
    hm.RunPhase(constants.HOOKS_PHASE_POST, nodes=[node_name])
686
  except:
687
    # pylint: disable-msg=W0702
688
    lu.LogWarning("Errors occurred running hooks on %s" % node_name)
689

    
690

    
691
def _CheckOutputFields(static, dynamic, selected):
692
  """Checks whether all selected fields are valid.
693

694
  @type static: L{utils.FieldSet}
695
  @param static: static fields set
696
  @type dynamic: L{utils.FieldSet}
697
  @param dynamic: dynamic fields set
698

699
  """
700
  f = utils.FieldSet()
701
  f.Extend(static)
702
  f.Extend(dynamic)
703

    
704
  delta = f.NonMatching(selected)
705
  if delta:
706
    raise errors.OpPrereqError("Unknown output fields selected: %s"
707
                               % ",".join(delta), errors.ECODE_INVAL)
708

    
709

    
710
def _CheckGlobalHvParams(params):
711
  """Validates that given hypervisor params are not global ones.
712

713
  This will ensure that instances don't get customised versions of
714
  global params.
715

716
  """
717
  used_globals = constants.HVC_GLOBALS.intersection(params)
718
  if used_globals:
719
    msg = ("The following hypervisor parameters are global and cannot"
720
           " be customized at instance level, please modify them at"
721
           " cluster level: %s" % utils.CommaJoin(used_globals))
722
    raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
723

    
724

    
725
def _CheckNodeOnline(lu, node, msg=None):
726
  """Ensure that a given node is online.
727

728
  @param lu: the LU on behalf of which we make the check
729
  @param node: the node to check
730
  @param msg: if passed, should be a message to replace the default one
731
  @raise errors.OpPrereqError: if the node is offline
732

733
  """
734
  if msg is None:
735
    msg = "Can't use offline node"
736
  if lu.cfg.GetNodeInfo(node).offline:
737
    raise errors.OpPrereqError("%s: %s" % (msg, node), errors.ECODE_STATE)
738

    
739

    
740
def _CheckNodeNotDrained(lu, node):
741
  """Ensure that a given node is not drained.
742

743
  @param lu: the LU on behalf of which we make the check
744
  @param node: the node to check
745
  @raise errors.OpPrereqError: if the node is drained
746

747
  """
748
  if lu.cfg.GetNodeInfo(node).drained:
749
    raise errors.OpPrereqError("Can't use drained node %s" % node,
750
                               errors.ECODE_STATE)
751

    
752

    
753
def _CheckNodeVmCapable(lu, node):
754
  """Ensure that a given node is vm capable.
755

756
  @param lu: the LU on behalf of which we make the check
757
  @param node: the node to check
758
  @raise errors.OpPrereqError: if the node is not vm capable
759

760
  """
761
  if not lu.cfg.GetNodeInfo(node).vm_capable:
762
    raise errors.OpPrereqError("Can't use non-vm_capable node %s" % node,
763
                               errors.ECODE_STATE)
764

    
765

    
766
def _CheckNodeHasOS(lu, node, os_name, force_variant):
767
  """Ensure that a node supports a given OS.
768

769
  @param lu: the LU on behalf of which we make the check
770
  @param node: the node to check
771
  @param os_name: the OS to query about
772
  @param force_variant: whether to ignore variant errors
773
  @raise errors.OpPrereqError: if the node is not supporting the OS
774

775
  """
776
  result = lu.rpc.call_os_get(node, os_name)
777
  result.Raise("OS '%s' not in supported OS list for node %s" %
778
               (os_name, node),
779
               prereq=True, ecode=errors.ECODE_INVAL)
780
  if not force_variant:
781
    _CheckOSVariant(result.payload, os_name)
782

    
783

    
784
def _CheckNodeHasSecondaryIP(lu, node, secondary_ip, prereq):
785
  """Ensure that a node has the given secondary ip.
786

787
  @type lu: L{LogicalUnit}
788
  @param lu: the LU on behalf of which we make the check
789
  @type node: string
790
  @param node: the node to check
791
  @type secondary_ip: string
792
  @param secondary_ip: the ip to check
793
  @type prereq: boolean
794
  @param prereq: whether to throw a prerequisite or an execute error
795
  @raise errors.OpPrereqError: if the node doesn't have the ip, and prereq=True
796
  @raise errors.OpExecError: if the node doesn't have the ip, and prereq=False
797

798
  """
799
  result = lu.rpc.call_node_has_ip_address(node, secondary_ip)
800
  result.Raise("Failure checking secondary ip on node %s" % node,
801
               prereq=prereq, ecode=errors.ECODE_ENVIRON)
802
  if not result.payload:
803
    msg = ("Node claims it doesn't have the secondary ip you gave (%s),"
804
           " please fix and re-run this command" % secondary_ip)
805
    if prereq:
806
      raise errors.OpPrereqError(msg, errors.ECODE_ENVIRON)
807
    else:
808
      raise errors.OpExecError(msg)
809

    
810

    
811
def _GetClusterDomainSecret():
812
  """Reads the cluster domain secret.
813

814
  """
815
  return utils.ReadOneLineFile(constants.CLUSTER_DOMAIN_SECRET_FILE,
816
                               strict=True)
817

    
818

    
819
def _CheckInstanceDown(lu, instance, reason):
820
  """Ensure that an instance is not running."""
821
  if instance.admin_up:
822
    raise errors.OpPrereqError("Instance %s is marked to be up, %s" %
823
                               (instance.name, reason), errors.ECODE_STATE)
824

    
825
  pnode = instance.primary_node
826
  ins_l = lu.rpc.call_instance_list([pnode], [instance.hypervisor])[pnode]
827
  ins_l.Raise("Can't contact node %s for instance information" % pnode,
828
              prereq=True, ecode=errors.ECODE_ENVIRON)
829

    
830
  if instance.name in ins_l.payload:
831
    raise errors.OpPrereqError("Instance %s is running, %s" %
832
                               (instance.name, reason), errors.ECODE_STATE)
833

    
834

    
835
def _ExpandItemName(fn, name, kind):
836
  """Expand an item name.
837

838
  @param fn: the function to use for expansion
839
  @param name: requested item name
840
  @param kind: text description ('Node' or 'Instance')
841
  @return: the resolved (full) name
842
  @raise errors.OpPrereqError: if the item is not found
843

844
  """
845
  full_name = fn(name)
846
  if full_name is None:
847
    raise errors.OpPrereqError("%s '%s' not known" % (kind, name),
848
                               errors.ECODE_NOENT)
849
  return full_name
850

    
851

    
852
def _ExpandNodeName(cfg, name):
853
  """Wrapper over L{_ExpandItemName} for nodes."""
854
  return _ExpandItemName(cfg.ExpandNodeName, name, "Node")
855

    
856

    
857
def _ExpandInstanceName(cfg, name):
858
  """Wrapper over L{_ExpandItemName} for instance."""
859
  return _ExpandItemName(cfg.ExpandInstanceName, name, "Instance")
860

    
861

    
862
def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,
863
                          memory, vcpus, nics, disk_template, disks,
864
                          bep, hvp, hypervisor_name):
865
  """Builds instance related env variables for hooks
866

867
  This builds the hook environment from individual variables.
868

869
  @type name: string
870
  @param name: the name of the instance
871
  @type primary_node: string
872
  @param primary_node: the name of the instance's primary node
873
  @type secondary_nodes: list
874
  @param secondary_nodes: list of secondary nodes as strings
875
  @type os_type: string
876
  @param os_type: the name of the instance's OS
877
  @type status: boolean
878
  @param status: the should_run status of the instance
879
  @type memory: string
880
  @param memory: the memory size of the instance
881
  @type vcpus: string
882
  @param vcpus: the count of VCPUs the instance has
883
  @type nics: list
884
  @param nics: list of tuples (ip, mac, mode, link) representing
885
      the NICs the instance has
886
  @type disk_template: string
887
  @param disk_template: the disk template of the instance
888
  @type disks: list
889
  @param disks: the list of (size, mode) pairs
890
  @type bep: dict
891
  @param bep: the backend parameters for the instance
892
  @type hvp: dict
893
  @param hvp: the hypervisor parameters for the instance
894
  @type hypervisor_name: string
895
  @param hypervisor_name: the hypervisor for the instance
896
  @rtype: dict
897
  @return: the hook environment for this instance
898

899
  """
900
  if status:
901
    str_status = "up"
902
  else:
903
    str_status = "down"
904
  env = {
905
    "OP_TARGET": name,
906
    "INSTANCE_NAME": name,
907
    "INSTANCE_PRIMARY": primary_node,
908
    "INSTANCE_SECONDARIES": " ".join(secondary_nodes),
909
    "INSTANCE_OS_TYPE": os_type,
910
    "INSTANCE_STATUS": str_status,
911
    "INSTANCE_MEMORY": memory,
912
    "INSTANCE_VCPUS": vcpus,
913
    "INSTANCE_DISK_TEMPLATE": disk_template,
914
    "INSTANCE_HYPERVISOR": hypervisor_name,
915
  }
916

    
917
  if nics:
918
    nic_count = len(nics)
919
    for idx, (ip, mac, mode, link) in enumerate(nics):
920
      if ip is None:
921
        ip = ""
922
      env["INSTANCE_NIC%d_IP" % idx] = ip
923
      env["INSTANCE_NIC%d_MAC" % idx] = mac
924
      env["INSTANCE_NIC%d_MODE" % idx] = mode
925
      env["INSTANCE_NIC%d_LINK" % idx] = link
926
      if mode == constants.NIC_MODE_BRIDGED:
927
        env["INSTANCE_NIC%d_BRIDGE" % idx] = link
928
  else:
929
    nic_count = 0
930

    
931
  env["INSTANCE_NIC_COUNT"] = nic_count
932

    
933
  if disks:
934
    disk_count = len(disks)
935
    for idx, (size, mode) in enumerate(disks):
936
      env["INSTANCE_DISK%d_SIZE" % idx] = size
937
      env["INSTANCE_DISK%d_MODE" % idx] = mode
938
  else:
939
    disk_count = 0
940

    
941
  env["INSTANCE_DISK_COUNT"] = disk_count
942

    
943
  for source, kind in [(bep, "BE"), (hvp, "HV")]:
944
    for key, value in source.items():
945
      env["INSTANCE_%s_%s" % (kind, key)] = value
946

    
947
  return env
948

    
949

    
950
def _NICListToTuple(lu, nics):
951
  """Build a list of nic information tuples.
952

953
  This list is suitable to be passed to _BuildInstanceHookEnv or as a return
954
  value in LUInstanceQueryData.
955

956
  @type lu:  L{LogicalUnit}
957
  @param lu: the logical unit on whose behalf we execute
958
  @type nics: list of L{objects.NIC}
959
  @param nics: list of nics to convert to hooks tuples
960

961
  """
962
  hooks_nics = []
963
  cluster = lu.cfg.GetClusterInfo()
964
  for nic in nics:
965
    ip = nic.ip
966
    mac = nic.mac
967
    filled_params = cluster.SimpleFillNIC(nic.nicparams)
968
    mode = filled_params[constants.NIC_MODE]
969
    link = filled_params[constants.NIC_LINK]
970
    hooks_nics.append((ip, mac, mode, link))
971
  return hooks_nics
972

    
973

    
974
def _BuildInstanceHookEnvByObject(lu, instance, override=None):
975
  """Builds instance related env variables for hooks from an object.
976

977
  @type lu: L{LogicalUnit}
978
  @param lu: the logical unit on whose behalf we execute
979
  @type instance: L{objects.Instance}
980
  @param instance: the instance for which we should build the
981
      environment
982
  @type override: dict
983
  @param override: dictionary with key/values that will override
984
      our values
985
  @rtype: dict
986
  @return: the hook environment dictionary
987

988
  """
989
  cluster = lu.cfg.GetClusterInfo()
990
  bep = cluster.FillBE(instance)
991
  hvp = cluster.FillHV(instance)
992
  args = {
993
    'name': instance.name,
994
    'primary_node': instance.primary_node,
995
    'secondary_nodes': instance.secondary_nodes,
996
    'os_type': instance.os,
997
    'status': instance.admin_up,
998
    'memory': bep[constants.BE_MEMORY],
999
    'vcpus': bep[constants.BE_VCPUS],
1000
    'nics': _NICListToTuple(lu, instance.nics),
1001
    'disk_template': instance.disk_template,
1002
    'disks': [(disk.size, disk.mode) for disk in instance.disks],
1003
    'bep': bep,
1004
    'hvp': hvp,
1005
    'hypervisor_name': instance.hypervisor,
1006
  }
1007
  if override:
1008
    args.update(override)
1009
  return _BuildInstanceHookEnv(**args) # pylint: disable-msg=W0142
1010

    
1011

    
1012
def _AdjustCandidatePool(lu, exceptions):
1013
  """Adjust the candidate pool after node operations.
1014

1015
  """
1016
  mod_list = lu.cfg.MaintainCandidatePool(exceptions)
1017
  if mod_list:
1018
    lu.LogInfo("Promoted nodes to master candidate role: %s",
1019
               utils.CommaJoin(node.name for node in mod_list))
1020
    for name in mod_list:
1021
      lu.context.ReaddNode(name)
1022
  mc_now, mc_max, _ = lu.cfg.GetMasterCandidateStats(exceptions)
1023
  if mc_now > mc_max:
1024
    lu.LogInfo("Note: more nodes are candidates (%d) than desired (%d)" %
1025
               (mc_now, mc_max))
1026

    
1027

    
1028
def _DecideSelfPromotion(lu, exceptions=None):
1029
  """Decide whether I should promote myself as a master candidate.
1030

1031
  """
1032
  cp_size = lu.cfg.GetClusterInfo().candidate_pool_size
1033
  mc_now, mc_should, _ = lu.cfg.GetMasterCandidateStats(exceptions)
1034
  # the new node will increase mc_max with one, so:
1035
  mc_should = min(mc_should + 1, cp_size)
1036
  return mc_now < mc_should
1037

    
1038

    
1039
def _CheckNicsBridgesExist(lu, target_nics, target_node):
1040
  """Check that the brigdes needed by a list of nics exist.
1041

1042
  """
1043
  cluster = lu.cfg.GetClusterInfo()
1044
  paramslist = [cluster.SimpleFillNIC(nic.nicparams) for nic in target_nics]
1045
  brlist = [params[constants.NIC_LINK] for params in paramslist
1046
            if params[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED]
1047
  if brlist:
1048
    result = lu.rpc.call_bridges_exist(target_node, brlist)
1049
    result.Raise("Error checking bridges on destination node '%s'" %
1050
                 target_node, prereq=True, ecode=errors.ECODE_ENVIRON)
1051

    
1052

    
1053
def _CheckInstanceBridgesExist(lu, instance, node=None):
1054
  """Check that the brigdes needed by an instance exist.
1055

1056
  """
1057
  if node is None:
1058
    node = instance.primary_node
1059
  _CheckNicsBridgesExist(lu, instance.nics, node)
1060

    
1061

    
1062
def _CheckOSVariant(os_obj, name):
1063
  """Check whether an OS name conforms to the os variants specification.
1064

1065
  @type os_obj: L{objects.OS}
1066
  @param os_obj: OS object to check
1067
  @type name: string
1068
  @param name: OS name passed by the user, to check for validity
1069

1070
  """
1071
  if not os_obj.supported_variants:
1072
    return
1073
  variant = objects.OS.GetVariant(name)
1074
  if not variant:
1075
    raise errors.OpPrereqError("OS name must include a variant",
1076
                               errors.ECODE_INVAL)
1077

    
1078
  if variant not in os_obj.supported_variants:
1079
    raise errors.OpPrereqError("Unsupported OS variant", errors.ECODE_INVAL)
1080

    
1081

    
1082
def _GetNodeInstancesInner(cfg, fn):
1083
  return [i for i in cfg.GetAllInstancesInfo().values() if fn(i)]
1084

    
1085

    
1086
def _GetNodeInstances(cfg, node_name):
1087
  """Returns a list of all primary and secondary instances on a node.
1088

1089
  """
1090

    
1091
  return _GetNodeInstancesInner(cfg, lambda inst: node_name in inst.all_nodes)
1092

    
1093

    
1094
def _GetNodePrimaryInstances(cfg, node_name):
1095
  """Returns primary instances on a node.
1096

1097
  """
1098
  return _GetNodeInstancesInner(cfg,
1099
                                lambda inst: node_name == inst.primary_node)
1100

    
1101

    
1102
def _GetNodeSecondaryInstances(cfg, node_name):
1103
  """Returns secondary instances on a node.
1104

1105
  """
1106
  return _GetNodeInstancesInner(cfg,
1107
                                lambda inst: node_name in inst.secondary_nodes)
1108

    
1109

    
1110
def _GetStorageTypeArgs(cfg, storage_type):
1111
  """Returns the arguments for a storage type.
1112

1113
  """
1114
  # Special case for file storage
1115
  if storage_type == constants.ST_FILE:
1116
    # storage.FileStorage wants a list of storage directories
1117
    return [[cfg.GetFileStorageDir(), cfg.GetSharedFileStorageDir()]]
1118

    
1119
  return []
1120

    
1121

    
1122
def _FindFaultyInstanceDisks(cfg, rpc, instance, node_name, prereq):
1123
  faulty = []
1124

    
1125
  for dev in instance.disks:
1126
    cfg.SetDiskID(dev, node_name)
1127

    
1128
  result = rpc.call_blockdev_getmirrorstatus(node_name, instance.disks)
1129
  result.Raise("Failed to get disk status from node %s" % node_name,
1130
               prereq=prereq, ecode=errors.ECODE_ENVIRON)
1131

    
1132
  for idx, bdev_status in enumerate(result.payload):
1133
    if bdev_status and bdev_status.ldisk_status == constants.LDS_FAULTY:
1134
      faulty.append(idx)
1135

    
1136
  return faulty
1137

    
1138

    
1139
def _CheckIAllocatorOrNode(lu, iallocator_slot, node_slot):
1140
  """Check the sanity of iallocator and node arguments and use the
1141
  cluster-wide iallocator if appropriate.
1142

1143
  Check that at most one of (iallocator, node) is specified. If none is
1144
  specified, then the LU's opcode's iallocator slot is filled with the
1145
  cluster-wide default iallocator.
1146

1147
  @type iallocator_slot: string
1148
  @param iallocator_slot: the name of the opcode iallocator slot
1149
  @type node_slot: string
1150
  @param node_slot: the name of the opcode target node slot
1151

1152
  """
1153
  node = getattr(lu.op, node_slot, None)
1154
  iallocator = getattr(lu.op, iallocator_slot, None)
1155

    
1156
  if node is not None and iallocator is not None:
1157
    raise errors.OpPrereqError("Do not specify both, iallocator and node",
1158
                               errors.ECODE_INVAL)
1159
  elif node is None and iallocator is None:
1160
    default_iallocator = lu.cfg.GetDefaultIAllocator()
1161
    if default_iallocator:
1162
      setattr(lu.op, iallocator_slot, default_iallocator)
1163
    else:
1164
      raise errors.OpPrereqError("No iallocator or node given and no"
1165
                                 " cluster-wide default iallocator found;"
1166
                                 " please specify either an iallocator or a"
1167
                                 " node, or set a cluster-wide default"
1168
                                 " iallocator")
1169

    
1170

    
1171
class LUClusterPostInit(LogicalUnit):
1172
  """Logical unit for running hooks after cluster initialization.
1173

1174
  """
1175
  HPATH = "cluster-init"
1176
  HTYPE = constants.HTYPE_CLUSTER
1177

    
1178
  def BuildHooksEnv(self):
1179
    """Build hooks env.
1180

1181
    """
1182
    return {
1183
      "OP_TARGET": self.cfg.GetClusterName(),
1184
      }
1185

    
1186
  def BuildHooksNodes(self):
1187
    """Build hooks nodes.
1188

1189
    """
1190
    return ([], [self.cfg.GetMasterNode()])
1191

    
1192
  def Exec(self, feedback_fn):
1193
    """Nothing to do.
1194

1195
    """
1196
    return True
1197

    
1198

    
1199
class LUClusterDestroy(LogicalUnit):
1200
  """Logical unit for destroying the cluster.
1201

1202
  """
1203
  HPATH = "cluster-destroy"
1204
  HTYPE = constants.HTYPE_CLUSTER
1205

    
1206
  def BuildHooksEnv(self):
1207
    """Build hooks env.
1208

1209
    """
1210
    return {
1211
      "OP_TARGET": self.cfg.GetClusterName(),
1212
      }
1213

    
1214
  def BuildHooksNodes(self):
1215
    """Build hooks nodes.
1216

1217
    """
1218
    return ([], [])
1219

    
1220
  def CheckPrereq(self):
1221
    """Check prerequisites.
1222

1223
    This checks whether the cluster is empty.
1224

1225
    Any errors are signaled by raising errors.OpPrereqError.
1226

1227
    """
1228
    master = self.cfg.GetMasterNode()
1229

    
1230
    nodelist = self.cfg.GetNodeList()
1231
    if len(nodelist) != 1 or nodelist[0] != master:
1232
      raise errors.OpPrereqError("There are still %d node(s) in"
1233
                                 " this cluster." % (len(nodelist) - 1),
1234
                                 errors.ECODE_INVAL)
1235
    instancelist = self.cfg.GetInstanceList()
1236
    if instancelist:
1237
      raise errors.OpPrereqError("There are still %d instance(s) in"
1238
                                 " this cluster." % len(instancelist),
1239
                                 errors.ECODE_INVAL)
1240

    
1241
  def Exec(self, feedback_fn):
1242
    """Destroys the cluster.
1243

1244
    """
1245
    master = self.cfg.GetMasterNode()
1246

    
1247
    # Run post hooks on master node before it's removed
1248
    _RunPostHook(self, master)
1249

    
1250
    result = self.rpc.call_node_stop_master(master, False)
1251
    result.Raise("Could not disable the master role")
1252

    
1253
    return master
1254

    
1255

    
1256
def _VerifyCertificate(filename):
1257
  """Verifies a certificate for LUClusterVerify.
1258

1259
  @type filename: string
1260
  @param filename: Path to PEM file
1261

1262
  """
1263
  try:
1264
    cert = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,
1265
                                           utils.ReadFile(filename))
1266
  except Exception, err: # pylint: disable-msg=W0703
1267
    return (LUClusterVerify.ETYPE_ERROR,
1268
            "Failed to load X509 certificate %s: %s" % (filename, err))
1269

    
1270
  (errcode, msg) = \
1271
    utils.VerifyX509Certificate(cert, constants.SSL_CERT_EXPIRATION_WARN,
1272
                                constants.SSL_CERT_EXPIRATION_ERROR)
1273

    
1274
  if msg:
1275
    fnamemsg = "While verifying %s: %s" % (filename, msg)
1276
  else:
1277
    fnamemsg = None
1278

    
1279
  if errcode is None:
1280
    return (None, fnamemsg)
1281
  elif errcode == utils.CERT_WARNING:
1282
    return (LUClusterVerify.ETYPE_WARNING, fnamemsg)
1283
  elif errcode == utils.CERT_ERROR:
1284
    return (LUClusterVerify.ETYPE_ERROR, fnamemsg)
1285

    
1286
  raise errors.ProgrammerError("Unhandled certificate error code %r" % errcode)
1287

    
1288

    
1289
class LUClusterVerify(LogicalUnit):
1290
  """Verifies the cluster status.
1291

1292
  """
1293
  HPATH = "cluster-verify"
1294
  HTYPE = constants.HTYPE_CLUSTER
1295
  REQ_BGL = False
1296

    
1297
  TCLUSTER = "cluster"
1298
  TNODE = "node"
1299
  TINSTANCE = "instance"
1300

    
1301
  ECLUSTERCFG = (TCLUSTER, "ECLUSTERCFG")
1302
  ECLUSTERCERT = (TCLUSTER, "ECLUSTERCERT")
1303
  ECLUSTERFILECHECK = (TCLUSTER, "ECLUSTERFILECHECK")
1304
  EINSTANCEBADNODE = (TINSTANCE, "EINSTANCEBADNODE")
1305
  EINSTANCEDOWN = (TINSTANCE, "EINSTANCEDOWN")
1306
  EINSTANCELAYOUT = (TINSTANCE, "EINSTANCELAYOUT")
1307
  EINSTANCEMISSINGDISK = (TINSTANCE, "EINSTANCEMISSINGDISK")
1308
  EINSTANCEFAULTYDISK = (TINSTANCE, "EINSTANCEFAULTYDISK")
1309
  EINSTANCEWRONGNODE = (TINSTANCE, "EINSTANCEWRONGNODE")
1310
  EINSTANCESPLITGROUPS = (TINSTANCE, "EINSTANCESPLITGROUPS")
1311
  ENODEDRBD = (TNODE, "ENODEDRBD")
1312
  ENODEDRBDHELPER = (TNODE, "ENODEDRBDHELPER")
1313
  ENODEFILECHECK = (TNODE, "ENODEFILECHECK")
1314
  ENODEHOOKS = (TNODE, "ENODEHOOKS")
1315
  ENODEHV = (TNODE, "ENODEHV")
1316
  ENODELVM = (TNODE, "ENODELVM")
1317
  ENODEN1 = (TNODE, "ENODEN1")
1318
  ENODENET = (TNODE, "ENODENET")
1319
  ENODEOS = (TNODE, "ENODEOS")
1320
  ENODEORPHANINSTANCE = (TNODE, "ENODEORPHANINSTANCE")
1321
  ENODEORPHANLV = (TNODE, "ENODEORPHANLV")
1322
  ENODERPC = (TNODE, "ENODERPC")
1323
  ENODESSH = (TNODE, "ENODESSH")
1324
  ENODEVERSION = (TNODE, "ENODEVERSION")
1325
  ENODESETUP = (TNODE, "ENODESETUP")
1326
  ENODETIME = (TNODE, "ENODETIME")
1327
  ENODEOOBPATH = (TNODE, "ENODEOOBPATH")
1328

    
1329
  ETYPE_FIELD = "code"
1330
  ETYPE_ERROR = "ERROR"
1331
  ETYPE_WARNING = "WARNING"
1332

    
1333
  _HOOKS_INDENT_RE = re.compile("^", re.M)
1334

    
1335
  class NodeImage(object):
1336
    """A class representing the logical and physical status of a node.
1337

1338
    @type name: string
1339
    @ivar name: the node name to which this object refers
1340
    @ivar volumes: a structure as returned from
1341
        L{ganeti.backend.GetVolumeList} (runtime)
1342
    @ivar instances: a list of running instances (runtime)
1343
    @ivar pinst: list of configured primary instances (config)
1344
    @ivar sinst: list of configured secondary instances (config)
1345
    @ivar sbp: dictionary of {primary-node: list of instances} for all
1346
        instances for which this node is secondary (config)
1347
    @ivar mfree: free memory, as reported by hypervisor (runtime)
1348
    @ivar dfree: free disk, as reported by the node (runtime)
1349
    @ivar offline: the offline status (config)
1350
    @type rpc_fail: boolean
1351
    @ivar rpc_fail: whether the RPC verify call was successfull (overall,
1352
        not whether the individual keys were correct) (runtime)
1353
    @type lvm_fail: boolean
1354
    @ivar lvm_fail: whether the RPC call didn't return valid LVM data
1355
    @type hyp_fail: boolean
1356
    @ivar hyp_fail: whether the RPC call didn't return the instance list
1357
    @type ghost: boolean
1358
    @ivar ghost: whether this is a known node or not (config)
1359
    @type os_fail: boolean
1360
    @ivar os_fail: whether the RPC call didn't return valid OS data
1361
    @type oslist: list
1362
    @ivar oslist: list of OSes as diagnosed by DiagnoseOS
1363
    @type vm_capable: boolean
1364
    @ivar vm_capable: whether the node can host instances
1365

1366
    """
1367
    def __init__(self, offline=False, name=None, vm_capable=True):
1368
      self.name = name
1369
      self.volumes = {}
1370
      self.instances = []
1371
      self.pinst = []
1372
      self.sinst = []
1373
      self.sbp = {}
1374
      self.mfree = 0
1375
      self.dfree = 0
1376
      self.offline = offline
1377
      self.vm_capable = vm_capable
1378
      self.rpc_fail = False
1379
      self.lvm_fail = False
1380
      self.hyp_fail = False
1381
      self.ghost = False
1382
      self.os_fail = False
1383
      self.oslist = {}
1384

    
1385
  def ExpandNames(self):
1386
    self.needed_locks = {
1387
      locking.LEVEL_NODE: locking.ALL_SET,
1388
      locking.LEVEL_INSTANCE: locking.ALL_SET,
1389
    }
1390
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
1391

    
1392
  def _Error(self, ecode, item, msg, *args, **kwargs):
1393
    """Format an error message.
1394

1395
    Based on the opcode's error_codes parameter, either format a
1396
    parseable error code, or a simpler error string.
1397

1398
    This must be called only from Exec and functions called from Exec.
1399

1400
    """
1401
    ltype = kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR)
1402
    itype, etxt = ecode
1403
    # first complete the msg
1404
    if args:
1405
      msg = msg % args
1406
    # then format the whole message
1407
    if self.op.error_codes:
1408
      msg = "%s:%s:%s:%s:%s" % (ltype, etxt, itype, item, msg)
1409
    else:
1410
      if item:
1411
        item = " " + item
1412
      else:
1413
        item = ""
1414
      msg = "%s: %s%s: %s" % (ltype, itype, item, msg)
1415
    # and finally report it via the feedback_fn
1416
    self._feedback_fn("  - %s" % msg)
1417

    
1418
  def _ErrorIf(self, cond, *args, **kwargs):
1419
    """Log an error message if the passed condition is True.
1420

1421
    """
1422
    cond = bool(cond) or self.op.debug_simulate_errors
1423
    if cond:
1424
      self._Error(*args, **kwargs)
1425
    # do not mark the operation as failed for WARN cases only
1426
    if kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR) == self.ETYPE_ERROR:
1427
      self.bad = self.bad or cond
1428

    
1429
  def _VerifyNode(self, ninfo, nresult):
1430
    """Perform some basic validation on data returned from a node.
1431

1432
      - check the result data structure is well formed and has all the
1433
        mandatory fields
1434
      - check ganeti version
1435

1436
    @type ninfo: L{objects.Node}
1437
    @param ninfo: the node to check
1438
    @param nresult: the results from the node
1439
    @rtype: boolean
1440
    @return: whether overall this call was successful (and we can expect
1441
         reasonable values in the respose)
1442

1443
    """
1444
    node = ninfo.name
1445
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1446

    
1447
    # main result, nresult should be a non-empty dict
1448
    test = not nresult or not isinstance(nresult, dict)
1449
    _ErrorIf(test, self.ENODERPC, node,
1450
                  "unable to verify node: no data returned")
1451
    if test:
1452
      return False
1453

    
1454
    # compares ganeti version
1455
    local_version = constants.PROTOCOL_VERSION
1456
    remote_version = nresult.get("version", None)
1457
    test = not (remote_version and
1458
                isinstance(remote_version, (list, tuple)) and
1459
                len(remote_version) == 2)
1460
    _ErrorIf(test, self.ENODERPC, node,
1461
             "connection to node returned invalid data")
1462
    if test:
1463
      return False
1464

    
1465
    test = local_version != remote_version[0]
1466
    _ErrorIf(test, self.ENODEVERSION, node,
1467
             "incompatible protocol versions: master %s,"
1468
             " node %s", local_version, remote_version[0])
1469
    if test:
1470
      return False
1471

    
1472
    # node seems compatible, we can actually try to look into its results
1473

    
1474
    # full package version
1475
    self._ErrorIf(constants.RELEASE_VERSION != remote_version[1],
1476
                  self.ENODEVERSION, node,
1477
                  "software version mismatch: master %s, node %s",
1478
                  constants.RELEASE_VERSION, remote_version[1],
1479
                  code=self.ETYPE_WARNING)
1480

    
1481
    hyp_result = nresult.get(constants.NV_HYPERVISOR, None)
1482
    if ninfo.vm_capable and isinstance(hyp_result, dict):
1483
      for hv_name, hv_result in hyp_result.iteritems():
1484
        test = hv_result is not None
1485
        _ErrorIf(test, self.ENODEHV, node,
1486
                 "hypervisor %s verify failure: '%s'", hv_name, hv_result)
1487

    
1488
    hvp_result = nresult.get(constants.NV_HVPARAMS, None)
1489
    if ninfo.vm_capable and isinstance(hvp_result, list):
1490
      for item, hv_name, hv_result in hvp_result:
1491
        _ErrorIf(True, self.ENODEHV, node,
1492
                 "hypervisor %s parameter verify failure (source %s): %s",
1493
                 hv_name, item, hv_result)
1494

    
1495
    test = nresult.get(constants.NV_NODESETUP,
1496
                       ["Missing NODESETUP results"])
1497
    _ErrorIf(test, self.ENODESETUP, node, "node setup error: %s",
1498
             "; ".join(test))
1499

    
1500
    return True
1501

    
1502
  def _VerifyNodeTime(self, ninfo, nresult,
1503
                      nvinfo_starttime, nvinfo_endtime):
1504
    """Check the node time.
1505

1506
    @type ninfo: L{objects.Node}
1507
    @param ninfo: the node to check
1508
    @param nresult: the remote results for the node
1509
    @param nvinfo_starttime: the start time of the RPC call
1510
    @param nvinfo_endtime: the end time of the RPC call
1511

1512
    """
1513
    node = ninfo.name
1514
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1515

    
1516
    ntime = nresult.get(constants.NV_TIME, None)
1517
    try:
1518
      ntime_merged = utils.MergeTime(ntime)
1519
    except (ValueError, TypeError):
1520
      _ErrorIf(True, self.ENODETIME, node, "Node returned invalid time")
1521
      return
1522

    
1523
    if ntime_merged < (nvinfo_starttime - constants.NODE_MAX_CLOCK_SKEW):
1524
      ntime_diff = "%.01fs" % abs(nvinfo_starttime - ntime_merged)
1525
    elif ntime_merged > (nvinfo_endtime + constants.NODE_MAX_CLOCK_SKEW):
1526
      ntime_diff = "%.01fs" % abs(ntime_merged - nvinfo_endtime)
1527
    else:
1528
      ntime_diff = None
1529

    
1530
    _ErrorIf(ntime_diff is not None, self.ENODETIME, node,
1531
             "Node time diverges by at least %s from master node time",
1532
             ntime_diff)
1533

    
1534
  def _VerifyNodeLVM(self, ninfo, nresult, vg_name):
1535
    """Check the node LVM results.
1536

1537
    @type ninfo: L{objects.Node}
1538
    @param ninfo: the node to check
1539
    @param nresult: the remote results for the node
1540
    @param vg_name: the configured VG name
1541

1542
    """
1543
    if vg_name is None:
1544
      return
1545

    
1546
    node = ninfo.name
1547
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1548

    
1549
    # checks vg existence and size > 20G
1550
    vglist = nresult.get(constants.NV_VGLIST, None)
1551
    test = not vglist
1552
    _ErrorIf(test, self.ENODELVM, node, "unable to check volume groups")
1553
    if not test:
1554
      vgstatus = utils.CheckVolumeGroupSize(vglist, vg_name,
1555
                                            constants.MIN_VG_SIZE)
1556
      _ErrorIf(vgstatus, self.ENODELVM, node, vgstatus)
1557

    
1558
    # check pv names
1559
    pvlist = nresult.get(constants.NV_PVLIST, None)
1560
    test = pvlist is None
1561
    _ErrorIf(test, self.ENODELVM, node, "Can't get PV list from node")
1562
    if not test:
1563
      # check that ':' is not present in PV names, since it's a
1564
      # special character for lvcreate (denotes the range of PEs to
1565
      # use on the PV)
1566
      for _, pvname, owner_vg in pvlist:
1567
        test = ":" in pvname
1568
        _ErrorIf(test, self.ENODELVM, node, "Invalid character ':' in PV"
1569
                 " '%s' of VG '%s'", pvname, owner_vg)
1570

    
1571
  def _VerifyNodeBridges(self, ninfo, nresult, bridges):
1572
    """Check the node bridges.
1573

1574
    @type ninfo: L{objects.Node}
1575
    @param ninfo: the node to check
1576
    @param nresult: the remote results for the node
1577
    @param bridges: the expected list of bridges
1578

1579
    """
1580
    if not bridges:
1581
      return
1582

    
1583
    node = ninfo.name
1584
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1585

    
1586
    missing = nresult.get(constants.NV_BRIDGES, None)
1587
    test = not isinstance(missing, list)
1588
    _ErrorIf(test, self.ENODENET, node,
1589
             "did not return valid bridge information")
1590
    if not test:
1591
      _ErrorIf(bool(missing), self.ENODENET, node, "missing bridges: %s" %
1592
               utils.CommaJoin(sorted(missing)))
1593

    
1594
  def _VerifyNodeNetwork(self, ninfo, nresult):
1595
    """Check the node network connectivity results.
1596

1597
    @type ninfo: L{objects.Node}
1598
    @param ninfo: the node to check
1599
    @param nresult: the remote results for the node
1600

1601
    """
1602
    node = ninfo.name
1603
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1604

    
1605
    test = constants.NV_NODELIST not in nresult
1606
    _ErrorIf(test, self.ENODESSH, node,
1607
             "node hasn't returned node ssh connectivity data")
1608
    if not test:
1609
      if nresult[constants.NV_NODELIST]:
1610
        for a_node, a_msg in nresult[constants.NV_NODELIST].items():
1611
          _ErrorIf(True, self.ENODESSH, node,
1612
                   "ssh communication with node '%s': %s", a_node, a_msg)
1613

    
1614
    test = constants.NV_NODENETTEST not in nresult
1615
    _ErrorIf(test, self.ENODENET, node,
1616
             "node hasn't returned node tcp connectivity data")
1617
    if not test:
1618
      if nresult[constants.NV_NODENETTEST]:
1619
        nlist = utils.NiceSort(nresult[constants.NV_NODENETTEST].keys())
1620
        for anode in nlist:
1621
          _ErrorIf(True, self.ENODENET, node,
1622
                   "tcp communication with node '%s': %s",
1623
                   anode, nresult[constants.NV_NODENETTEST][anode])
1624

    
1625
    test = constants.NV_MASTERIP not in nresult
1626
    _ErrorIf(test, self.ENODENET, node,
1627
             "node hasn't returned node master IP reachability data")
1628
    if not test:
1629
      if not nresult[constants.NV_MASTERIP]:
1630
        if node == self.master_node:
1631
          msg = "the master node cannot reach the master IP (not configured?)"
1632
        else:
1633
          msg = "cannot reach the master IP"
1634
        _ErrorIf(True, self.ENODENET, node, msg)
1635

    
1636
  def _VerifyInstance(self, instance, instanceconfig, node_image,
1637
                      diskstatus):
1638
    """Verify an instance.
1639

1640
    This function checks to see if the required block devices are
1641
    available on the instance's node.
1642

1643
    """
1644
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1645
    node_current = instanceconfig.primary_node
1646

    
1647
    node_vol_should = {}
1648
    instanceconfig.MapLVsByNode(node_vol_should)
1649

    
1650
    for node in node_vol_should:
1651
      n_img = node_image[node]
1652
      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
1653
        # ignore missing volumes on offline or broken nodes
1654
        continue
1655
      for volume in node_vol_should[node]:
1656
        test = volume not in n_img.volumes
1657
        _ErrorIf(test, self.EINSTANCEMISSINGDISK, instance,
1658
                 "volume %s missing on node %s", volume, node)
1659

    
1660
    if instanceconfig.admin_up:
1661
      pri_img = node_image[node_current]
1662
      test = instance not in pri_img.instances and not pri_img.offline
1663
      _ErrorIf(test, self.EINSTANCEDOWN, instance,
1664
               "instance not running on its primary node %s",
1665
               node_current)
1666

    
1667
    for node, n_img in node_image.items():
1668
      if node != node_current:
1669
        test = instance in n_img.instances
1670
        _ErrorIf(test, self.EINSTANCEWRONGNODE, instance,
1671
                 "instance should not run on node %s", node)
1672

    
1673
    diskdata = [(nname, success, status, idx)
1674
                for (nname, disks) in diskstatus.items()
1675
                for idx, (success, status) in enumerate(disks)]
1676

    
1677
    for nname, success, bdev_status, idx in diskdata:
1678
      # the 'ghost node' construction in Exec() ensures that we have a
1679
      # node here
1680
      snode = node_image[nname]
1681
      bad_snode = snode.ghost or snode.offline
1682
      _ErrorIf(instanceconfig.admin_up and not success and not bad_snode,
1683
               self.EINSTANCEFAULTYDISK, instance,
1684
               "couldn't retrieve status for disk/%s on %s: %s",
1685
               idx, nname, bdev_status)
1686
      _ErrorIf((instanceconfig.admin_up and success and
1687
                bdev_status.ldisk_status == constants.LDS_FAULTY),
1688
               self.EINSTANCEFAULTYDISK, instance,
1689
               "disk/%s on %s is faulty", idx, nname)
1690

    
1691
  def _VerifyOrphanVolumes(self, node_vol_should, node_image, reserved):
1692
    """Verify if there are any unknown volumes in the cluster.
1693

1694
    The .os, .swap and backup volumes are ignored. All other volumes are
1695
    reported as unknown.
1696

1697
    @type reserved: L{ganeti.utils.FieldSet}
1698
    @param reserved: a FieldSet of reserved volume names
1699

1700
    """
1701
    for node, n_img in node_image.items():
1702
      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
1703
        # skip non-healthy nodes
1704
        continue
1705
      for volume in n_img.volumes:
1706
        test = ((node not in node_vol_should or
1707
                volume not in node_vol_should[node]) and
1708
                not reserved.Matches(volume))
1709
        self._ErrorIf(test, self.ENODEORPHANLV, node,
1710
                      "volume %s is unknown", volume)
1711

    
1712
  def _VerifyOrphanInstances(self, instancelist, node_image):
1713
    """Verify the list of running instances.
1714

1715
    This checks what instances are running but unknown to the cluster.
1716

1717
    """
1718
    for node, n_img in node_image.items():
1719
      for o_inst in n_img.instances:
1720
        test = o_inst not in instancelist
1721
        self._ErrorIf(test, self.ENODEORPHANINSTANCE, node,
1722
                      "instance %s on node %s should not exist", o_inst, node)
1723

    
1724
  def _VerifyNPlusOneMemory(self, node_image, instance_cfg):
1725
    """Verify N+1 Memory Resilience.
1726

1727
    Check that if one single node dies we can still start all the
1728
    instances it was primary for.
1729

1730
    """
1731
    cluster_info = self.cfg.GetClusterInfo()
1732
    for node, n_img in node_image.items():
1733
      # This code checks that every node which is now listed as
1734
      # secondary has enough memory to host all instances it is
1735
      # supposed to should a single other node in the cluster fail.
1736
      # FIXME: not ready for failover to an arbitrary node
1737
      # FIXME: does not support file-backed instances
1738
      # WARNING: we currently take into account down instances as well
1739
      # as up ones, considering that even if they're down someone
1740
      # might want to start them even in the event of a node failure.
1741
      if n_img.offline:
1742
        # we're skipping offline nodes from the N+1 warning, since
1743
        # most likely we don't have good memory infromation from them;
1744
        # we already list instances living on such nodes, and that's
1745
        # enough warning
1746
        continue
1747
      for prinode, instances in n_img.sbp.items():
1748
        needed_mem = 0
1749
        for instance in instances:
1750
          bep = cluster_info.FillBE(instance_cfg[instance])
1751
          if bep[constants.BE_AUTO_BALANCE]:
1752
            needed_mem += bep[constants.BE_MEMORY]
1753
        test = n_img.mfree < needed_mem
1754
        self._ErrorIf(test, self.ENODEN1, node,
1755
                      "not enough memory to accomodate instance failovers"
1756
                      " should node %s fail (%dMiB needed, %dMiB available)",
1757
                      prinode, needed_mem, n_img.mfree)
1758

    
1759
  @classmethod
1760
  def _VerifyFiles(cls, errorif, nodeinfo, master_node, all_nvinfo,
1761
                   (files_all, files_all_opt, files_mc, files_vm)):
1762
    """Verifies file checksums collected from all nodes.
1763

1764
    @param errorif: Callback for reporting errors
1765
    @param nodeinfo: List of L{objects.Node} objects
1766
    @param master_node: Name of master node
1767
    @param all_nvinfo: RPC results
1768

1769
    """
1770
    node_names = frozenset(node.name for node in nodeinfo)
1771

    
1772
    assert master_node in node_names
1773
    assert (len(files_all | files_all_opt | files_mc | files_vm) ==
1774
            sum(map(len, [files_all, files_all_opt, files_mc, files_vm]))), \
1775
           "Found file listed in more than one file list"
1776

    
1777
    # Define functions determining which nodes to consider for a file
1778
    file2nodefn = dict([(filename, fn)
1779
      for (files, fn) in [(files_all, None),
1780
                          (files_all_opt, None),
1781
                          (files_mc, lambda node: (node.master_candidate or
1782
                                                   node.name == master_node)),
1783
                          (files_vm, lambda node: node.vm_capable)]
1784
      for filename in files])
1785

    
1786
    fileinfo = dict((filename, {}) for filename in file2nodefn.keys())
1787

    
1788
    for node in nodeinfo:
1789
      nresult = all_nvinfo[node.name]
1790

    
1791
      if nresult.fail_msg or not nresult.payload:
1792
        node_files = None
1793
      else:
1794
        node_files = nresult.payload.get(constants.NV_FILELIST, None)
1795

    
1796
      test = not (node_files and isinstance(node_files, dict))
1797
      errorif(test, cls.ENODEFILECHECK, node.name,
1798
              "Node did not return file checksum data")
1799
      if test:
1800
        continue
1801

    
1802
      for (filename, checksum) in node_files.items():
1803
        # Check if the file should be considered for a node
1804
        fn = file2nodefn[filename]
1805
        if fn is None or fn(node):
1806
          fileinfo[filename].setdefault(checksum, set()).add(node.name)
1807

    
1808
    for (filename, checksums) in fileinfo.items():
1809
      assert compat.all(len(i) > 10 for i in checksums), "Invalid checksum"
1810

    
1811
      # Nodes having the file
1812
      with_file = frozenset(node_name
1813
                            for nodes in fileinfo[filename].values()
1814
                            for node_name in nodes)
1815

    
1816
      # Nodes missing file
1817
      missing_file = node_names - with_file
1818

    
1819
      if filename in files_all_opt:
1820
        # All or no nodes
1821
        errorif(missing_file and missing_file != node_names,
1822
                cls.ECLUSTERFILECHECK, None,
1823
                "File %s is optional, but it must exist on all or no nodes (not"
1824
                " found on %s)",
1825
                filename, utils.CommaJoin(utils.NiceSort(missing_file)))
1826
      else:
1827
        errorif(missing_file, cls.ECLUSTERFILECHECK, None,
1828
                "File %s is missing from node(s) %s", filename,
1829
                utils.CommaJoin(utils.NiceSort(missing_file)))
1830

    
1831
      # See if there are multiple versions of the file
1832
      test = len(checksums) > 1
1833
      if test:
1834
        variants = ["variant %s on %s" %
1835
                    (idx + 1, utils.CommaJoin(utils.NiceSort(nodes)))
1836
                    for (idx, (checksum, nodes)) in
1837
                      enumerate(sorted(checksums.items()))]
1838
      else:
1839
        variants = []
1840

    
1841
      errorif(test, cls.ECLUSTERFILECHECK, None,
1842
              "File %s found with %s different checksums (%s)",
1843
              filename, len(checksums), "; ".join(variants))
1844

    
1845
  def _VerifyNodeDrbd(self, ninfo, nresult, instanceinfo, drbd_helper,
1846
                      drbd_map):
1847
    """Verifies and the node DRBD status.
1848

1849
    @type ninfo: L{objects.Node}
1850
    @param ninfo: the node to check
1851
    @param nresult: the remote results for the node
1852
    @param instanceinfo: the dict of instances
1853
    @param drbd_helper: the configured DRBD usermode helper
1854
    @param drbd_map: the DRBD map as returned by
1855
        L{ganeti.config.ConfigWriter.ComputeDRBDMap}
1856

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

    
1861
    if drbd_helper:
1862
      helper_result = nresult.get(constants.NV_DRBDHELPER, None)
1863
      test = (helper_result == None)
1864
      _ErrorIf(test, self.ENODEDRBDHELPER, node,
1865
               "no drbd usermode helper returned")
1866
      if helper_result:
1867
        status, payload = helper_result
1868
        test = not status
1869
        _ErrorIf(test, self.ENODEDRBDHELPER, node,
1870
                 "drbd usermode helper check unsuccessful: %s", payload)
1871
        test = status and (payload != drbd_helper)
1872
        _ErrorIf(test, self.ENODEDRBDHELPER, node,
1873
                 "wrong drbd usermode helper: %s", payload)
1874

    
1875
    # compute the DRBD minors
1876
    node_drbd = {}
1877
    for minor, instance in drbd_map[node].items():
1878
      test = instance not in instanceinfo
1879
      _ErrorIf(test, self.ECLUSTERCFG, None,
1880
               "ghost instance '%s' in temporary DRBD map", instance)
1881
        # ghost instance should not be running, but otherwise we
1882
        # don't give double warnings (both ghost instance and
1883
        # unallocated minor in use)
1884
      if test:
1885
        node_drbd[minor] = (instance, False)
1886
      else:
1887
        instance = instanceinfo[instance]
1888
        node_drbd[minor] = (instance.name, instance.admin_up)
1889

    
1890
    # and now check them
1891
    used_minors = nresult.get(constants.NV_DRBDLIST, [])
1892
    test = not isinstance(used_minors, (tuple, list))
1893
    _ErrorIf(test, self.ENODEDRBD, node,
1894
             "cannot parse drbd status file: %s", str(used_minors))
1895
    if test:
1896
      # we cannot check drbd status
1897
      return
1898

    
1899
    for minor, (iname, must_exist) in node_drbd.items():
1900
      test = minor not in used_minors and must_exist
1901
      _ErrorIf(test, self.ENODEDRBD, node,
1902
               "drbd minor %d of instance %s is not active", minor, iname)
1903
    for minor in used_minors:
1904
      test = minor not in node_drbd
1905
      _ErrorIf(test, self.ENODEDRBD, node,
1906
               "unallocated drbd minor %d is in use", minor)
1907

    
1908
  def _UpdateNodeOS(self, ninfo, nresult, nimg):
1909
    """Builds the node OS structures.
1910

1911
    @type ninfo: L{objects.Node}
1912
    @param ninfo: the node to check
1913
    @param nresult: the remote results for the node
1914
    @param nimg: the node image object
1915

1916
    """
1917
    node = ninfo.name
1918
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1919

    
1920
    remote_os = nresult.get(constants.NV_OSLIST, None)
1921
    test = (not isinstance(remote_os, list) or
1922
            not compat.all(isinstance(v, list) and len(v) == 7
1923
                           for v in remote_os))
1924

    
1925
    _ErrorIf(test, self.ENODEOS, node,
1926
             "node hasn't returned valid OS data")
1927

    
1928
    nimg.os_fail = test
1929

    
1930
    if test:
1931
      return
1932

    
1933
    os_dict = {}
1934

    
1935
    for (name, os_path, status, diagnose,
1936
         variants, parameters, api_ver) in nresult[constants.NV_OSLIST]:
1937

    
1938
      if name not in os_dict:
1939
        os_dict[name] = []
1940

    
1941
      # parameters is a list of lists instead of list of tuples due to
1942
      # JSON lacking a real tuple type, fix it:
1943
      parameters = [tuple(v) for v in parameters]
1944
      os_dict[name].append((os_path, status, diagnose,
1945
                            set(variants), set(parameters), set(api_ver)))
1946

    
1947
    nimg.oslist = os_dict
1948

    
1949
  def _VerifyNodeOS(self, ninfo, nimg, base):
1950
    """Verifies the node OS list.
1951

1952
    @type ninfo: L{objects.Node}
1953
    @param ninfo: the node to check
1954
    @param nimg: the node image object
1955
    @param base: the 'template' node we match against (e.g. from the master)
1956

1957
    """
1958
    node = ninfo.name
1959
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1960

    
1961
    assert not nimg.os_fail, "Entered _VerifyNodeOS with failed OS rpc?"
1962

    
1963
    beautify_params = lambda l: ["%s: %s" % (k, v) for (k, v) in l]
1964
    for os_name, os_data in nimg.oslist.items():
1965
      assert os_data, "Empty OS status for OS %s?!" % os_name
1966
      f_path, f_status, f_diag, f_var, f_param, f_api = os_data[0]
1967
      _ErrorIf(not f_status, self.ENODEOS, node,
1968
               "Invalid OS %s (located at %s): %s", os_name, f_path, f_diag)
1969
      _ErrorIf(len(os_data) > 1, self.ENODEOS, node,
1970
               "OS '%s' has multiple entries (first one shadows the rest): %s",
1971
               os_name, utils.CommaJoin([v[0] for v in os_data]))
1972
      # this will catched in backend too
1973
      _ErrorIf(compat.any(v >= constants.OS_API_V15 for v in f_api)
1974
               and not f_var, self.ENODEOS, node,
1975
               "OS %s with API at least %d does not declare any variant",
1976
               os_name, constants.OS_API_V15)
1977
      # comparisons with the 'base' image
1978
      test = os_name not in base.oslist
1979
      _ErrorIf(test, self.ENODEOS, node,
1980
               "Extra OS %s not present on reference node (%s)",
1981
               os_name, base.name)
1982
      if test:
1983
        continue
1984
      assert base.oslist[os_name], "Base node has empty OS status?"
1985
      _, b_status, _, b_var, b_param, b_api = base.oslist[os_name][0]
1986
      if not b_status:
1987
        # base OS is invalid, skipping
1988
        continue
1989
      for kind, a, b in [("API version", f_api, b_api),
1990
                         ("variants list", f_var, b_var),
1991
                         ("parameters", beautify_params(f_param),
1992
                          beautify_params(b_param))]:
1993
        _ErrorIf(a != b, self.ENODEOS, node,
1994
                 "OS %s for %s differs from reference node %s: [%s] vs. [%s]",
1995
                 kind, os_name, base.name,
1996
                 utils.CommaJoin(sorted(a)), utils.CommaJoin(sorted(b)))
1997

    
1998
    # check any missing OSes
1999
    missing = set(base.oslist.keys()).difference(nimg.oslist.keys())
2000
    _ErrorIf(missing, self.ENODEOS, node,
2001
             "OSes present on reference node %s but missing on this node: %s",
2002
             base.name, utils.CommaJoin(missing))
2003

    
2004
  def _VerifyOob(self, ninfo, nresult):
2005
    """Verifies out of band functionality of a node.
2006

2007
    @type ninfo: L{objects.Node}
2008
    @param ninfo: the node to check
2009
    @param nresult: the remote results for the node
2010

2011
    """
2012
    node = ninfo.name
2013
    # We just have to verify the paths on master and/or master candidates
2014
    # as the oob helper is invoked on the master
2015
    if ((ninfo.master_candidate or ninfo.master_capable) and
2016
        constants.NV_OOB_PATHS in nresult):
2017
      for path_result in nresult[constants.NV_OOB_PATHS]:
2018
        self._ErrorIf(path_result, self.ENODEOOBPATH, node, path_result)
2019

    
2020
  def _UpdateNodeVolumes(self, ninfo, nresult, nimg, vg_name):
2021
    """Verifies and updates the node volume data.
2022

2023
    This function will update a L{NodeImage}'s internal structures
2024
    with data from the remote call.
2025

2026
    @type ninfo: L{objects.Node}
2027
    @param ninfo: the node to check
2028
    @param nresult: the remote results for the node
2029
    @param nimg: the node image object
2030
    @param vg_name: the configured VG name
2031

2032
    """
2033
    node = ninfo.name
2034
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2035

    
2036
    nimg.lvm_fail = True
2037
    lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")
2038
    if vg_name is None:
2039
      pass
2040
    elif isinstance(lvdata, basestring):
2041
      _ErrorIf(True, self.ENODELVM, node, "LVM problem on node: %s",
2042
               utils.SafeEncode(lvdata))
2043
    elif not isinstance(lvdata, dict):
2044
      _ErrorIf(True, self.ENODELVM, node, "rpc call to node failed (lvlist)")
2045
    else:
2046
      nimg.volumes = lvdata
2047
      nimg.lvm_fail = False
2048

    
2049
  def _UpdateNodeInstances(self, ninfo, nresult, nimg):
2050
    """Verifies and updates the node instance list.
2051

2052
    If the listing was successful, then updates this node's instance
2053
    list. Otherwise, it marks the RPC call as failed for the instance
2054
    list key.
2055

2056
    @type ninfo: L{objects.Node}
2057
    @param ninfo: the node to check
2058
    @param nresult: the remote results for the node
2059
    @param nimg: the node image object
2060

2061
    """
2062
    idata = nresult.get(constants.NV_INSTANCELIST, None)
2063
    test = not isinstance(idata, list)
2064
    self._ErrorIf(test, self.ENODEHV, ninfo.name, "rpc call to node failed"
2065
                  " (instancelist): %s", utils.SafeEncode(str(idata)))
2066
    if test:
2067
      nimg.hyp_fail = True
2068
    else:
2069
      nimg.instances = idata
2070

    
2071
  def _UpdateNodeInfo(self, ninfo, nresult, nimg, vg_name):
2072
    """Verifies and computes a node information map
2073

2074
    @type ninfo: L{objects.Node}
2075
    @param ninfo: the node to check
2076
    @param nresult: the remote results for the node
2077
    @param nimg: the node image object
2078
    @param vg_name: the configured VG name
2079

2080
    """
2081
    node = ninfo.name
2082
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2083

    
2084
    # try to read free memory (from the hypervisor)
2085
    hv_info = nresult.get(constants.NV_HVINFO, None)
2086
    test = not isinstance(hv_info, dict) or "memory_free" not in hv_info
2087
    _ErrorIf(test, self.ENODEHV, node, "rpc call to node failed (hvinfo)")
2088
    if not test:
2089
      try:
2090
        nimg.mfree = int(hv_info["memory_free"])
2091
      except (ValueError, TypeError):
2092
        _ErrorIf(True, self.ENODERPC, node,
2093
                 "node returned invalid nodeinfo, check hypervisor")
2094

    
2095
    # FIXME: devise a free space model for file based instances as well
2096
    if vg_name is not None:
2097
      test = (constants.NV_VGLIST not in nresult or
2098
              vg_name not in nresult[constants.NV_VGLIST])
2099
      _ErrorIf(test, self.ENODELVM, node,
2100
               "node didn't return data for the volume group '%s'"
2101
               " - it is either missing or broken", vg_name)
2102
      if not test:
2103
        try:
2104
          nimg.dfree = int(nresult[constants.NV_VGLIST][vg_name])
2105
        except (ValueError, TypeError):
2106
          _ErrorIf(True, self.ENODERPC, node,
2107
                   "node returned invalid LVM info, check LVM status")
2108

    
2109
  def _CollectDiskInfo(self, nodelist, node_image, instanceinfo):
2110
    """Gets per-disk status information for all instances.
2111

2112
    @type nodelist: list of strings
2113
    @param nodelist: Node names
2114
    @type node_image: dict of (name, L{objects.Node})
2115
    @param node_image: Node objects
2116
    @type instanceinfo: dict of (name, L{objects.Instance})
2117
    @param instanceinfo: Instance objects
2118
    @rtype: {instance: {node: [(succes, payload)]}}
2119
    @return: a dictionary of per-instance dictionaries with nodes as
2120
        keys and disk information as values; the disk information is a
2121
        list of tuples (success, payload)
2122

2123
    """
2124
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2125

    
2126
    node_disks = {}
2127
    node_disks_devonly = {}
2128
    diskless_instances = set()
2129
    diskless = constants.DT_DISKLESS
2130

    
2131
    for nname in nodelist:
2132
      node_instances = list(itertools.chain(node_image[nname].pinst,
2133
                                            node_image[nname].sinst))
2134
      diskless_instances.update(inst for inst in node_instances
2135
                                if instanceinfo[inst].disk_template == diskless)
2136
      disks = [(inst, disk)
2137
               for inst in node_instances
2138
               for disk in instanceinfo[inst].disks]
2139

    
2140
      if not disks:
2141
        # No need to collect data
2142
        continue
2143

    
2144
      node_disks[nname] = disks
2145

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

    
2150
      for dev in devonly:
2151
        self.cfg.SetDiskID(dev, nname)
2152

    
2153
      node_disks_devonly[nname] = devonly
2154

    
2155
    assert len(node_disks) == len(node_disks_devonly)
2156

    
2157
    # Collect data from all nodes with disks
2158
    result = self.rpc.call_blockdev_getmirrorstatus_multi(node_disks.keys(),
2159
                                                          node_disks_devonly)
2160

    
2161
    assert len(result) == len(node_disks)
2162

    
2163
    instdisk = {}
2164

    
2165
    for (nname, nres) in result.items():
2166
      disks = node_disks[nname]
2167

    
2168
      if nres.offline:
2169
        # No data from this node
2170
        data = len(disks) * [(False, "node offline")]
2171
      else:
2172
        msg = nres.fail_msg
2173
        _ErrorIf(msg, self.ENODERPC, nname,
2174
                 "while getting disk information: %s", msg)
2175
        if msg:
2176
          # No data from this node
2177
          data = len(disks) * [(False, msg)]
2178
        else:
2179
          data = []
2180
          for idx, i in enumerate(nres.payload):
2181
            if isinstance(i, (tuple, list)) and len(i) == 2:
2182
              data.append(i)
2183
            else:
2184
              logging.warning("Invalid result from node %s, entry %d: %s",
2185
                              nname, idx, i)
2186
              data.append((False, "Invalid result from the remote node"))
2187

    
2188
      for ((inst, _), status) in zip(disks, data):
2189
        instdisk.setdefault(inst, {}).setdefault(nname, []).append(status)
2190

    
2191
    # Add empty entries for diskless instances.
2192
    for inst in diskless_instances:
2193
      assert inst not in instdisk
2194
      instdisk[inst] = {}
2195

    
2196
    assert compat.all(len(statuses) == len(instanceinfo[inst].disks) and
2197
                      len(nnames) <= len(instanceinfo[inst].all_nodes) and
2198
                      compat.all(isinstance(s, (tuple, list)) and
2199
                                 len(s) == 2 for s in statuses)
2200
                      for inst, nnames in instdisk.items()
2201
                      for nname, statuses in nnames.items())
2202
    assert set(instdisk) == set(instanceinfo), "instdisk consistency failure"
2203

    
2204
    return instdisk
2205

    
2206
  def _VerifyHVP(self, hvp_data):
2207
    """Verifies locally the syntax of the hypervisor parameters.
2208

2209
    """
2210
    for item, hv_name, hv_params in hvp_data:
2211
      msg = ("hypervisor %s parameters syntax check (source %s): %%s" %
2212
             (item, hv_name))
2213
      try:
2214
        hv_class = hypervisor.GetHypervisor(hv_name)
2215
        utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
2216
        hv_class.CheckParameterSyntax(hv_params)
2217
      except errors.GenericError, err:
2218
        self._ErrorIf(True, self.ECLUSTERCFG, None, msg % str(err))
2219

    
2220
  def BuildHooksEnv(self):
2221
    """Build hooks env.
2222

2223
    Cluster-Verify hooks just ran in the post phase and their failure makes
2224
    the output be logged in the verify output and the verification to fail.
2225

2226
    """
2227
    cfg = self.cfg
2228

    
2229
    env = {
2230
      "CLUSTER_TAGS": " ".join(cfg.GetClusterInfo().GetTags())
2231
      }
2232

    
2233
    env.update(("NODE_TAGS_%s" % node.name, " ".join(node.GetTags()))
2234
               for node in cfg.GetAllNodesInfo().values())
2235

    
2236
    return env
2237

    
2238
  def BuildHooksNodes(self):
2239
    """Build hooks nodes.
2240

2241
    """
2242
    return ([], self.cfg.GetNodeList())
2243

    
2244
  def Exec(self, feedback_fn):
2245
    """Verify integrity of cluster, performing various test on nodes.
2246

2247
    """
2248
    # This method has too many local variables. pylint: disable-msg=R0914
2249
    self.bad = False
2250
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2251
    verbose = self.op.verbose
2252
    self._feedback_fn = feedback_fn
2253
    feedback_fn("* Verifying global settings")
2254
    for msg in self.cfg.VerifyConfig():
2255
      _ErrorIf(True, self.ECLUSTERCFG, None, msg)
2256

    
2257
    # Check the cluster certificates
2258
    for cert_filename in constants.ALL_CERT_FILES:
2259
      (errcode, msg) = _VerifyCertificate(cert_filename)
2260
      _ErrorIf(errcode, self.ECLUSTERCERT, None, msg, code=errcode)
2261

    
2262
    vg_name = self.cfg.GetVGName()
2263
    drbd_helper = self.cfg.GetDRBDHelper()
2264
    hypervisors = self.cfg.GetClusterInfo().enabled_hypervisors
2265
    cluster = self.cfg.GetClusterInfo()
2266
    nodeinfo_byname = self.cfg.GetAllNodesInfo()
2267
    nodelist = utils.NiceSort(nodeinfo_byname.keys())
2268
    nodeinfo = [nodeinfo_byname[nname] for nname in nodelist]
2269
    instanceinfo = self.cfg.GetAllInstancesInfo()
2270
    instancelist = utils.NiceSort(instanceinfo.keys())
2271
    groupinfo = self.cfg.GetAllNodeGroupsInfo()
2272
    i_non_redundant = [] # Non redundant instances
2273
    i_non_a_balanced = [] # Non auto-balanced instances
2274
    n_offline = 0 # Count of offline nodes
2275
    n_drained = 0 # Count of nodes being drained
2276
    node_vol_should = {}
2277

    
2278
    # FIXME: verify OS list
2279

    
2280
    # File verification
2281
    filemap = _ComputeAncillaryFiles(cluster, False)
2282

    
2283
    # do local checksums
2284
    master_node = self.master_node = self.cfg.GetMasterNode()
2285
    master_ip = self.cfg.GetMasterIP()
2286

    
2287
    # Compute the set of hypervisor parameters
2288
    hvp_data = []
2289
    for hv_name in hypervisors:
2290
      hvp_data.append(("cluster", hv_name, cluster.GetHVDefaults(hv_name)))
2291
    for os_name, os_hvp in cluster.os_hvp.items():
2292
      for hv_name, hv_params in os_hvp.items():
2293
        if not hv_params:
2294
          continue
2295
        full_params = cluster.GetHVDefaults(hv_name, os_name=os_name)
2296
        hvp_data.append(("os %s" % os_name, hv_name, full_params))
2297
    # TODO: collapse identical parameter values in a single one
2298
    for instance in instanceinfo.values():
2299
      if not instance.hvparams:
2300
        continue
2301
      hvp_data.append(("instance %s" % instance.name, instance.hypervisor,
2302
                       cluster.FillHV(instance)))
2303
    # and verify them locally
2304
    self._VerifyHVP(hvp_data)
2305

    
2306
    feedback_fn("* Gathering data (%d nodes)" % len(nodelist))
2307
    node_verify_param = {
2308
      constants.NV_FILELIST:
2309
        utils.UniqueSequence(filename
2310
                             for files in filemap
2311
                             for filename in files),
2312
      constants.NV_NODELIST: [node.name for node in nodeinfo
2313
                              if not node.offline],
2314
      constants.NV_HYPERVISOR: hypervisors,
2315
      constants.NV_HVPARAMS: hvp_data,
2316
      constants.NV_NODENETTEST: [(node.name, node.primary_ip,
2317
                                  node.secondary_ip) for node in nodeinfo
2318
                                 if not node.offline],
2319
      constants.NV_INSTANCELIST: hypervisors,
2320
      constants.NV_VERSION: None,
2321
      constants.NV_HVINFO: self.cfg.GetHypervisorType(),
2322
      constants.NV_NODESETUP: None,
2323
      constants.NV_TIME: None,
2324
      constants.NV_MASTERIP: (master_node, master_ip),
2325
      constants.NV_OSLIST: None,
2326
      constants.NV_VMNODES: self.cfg.GetNonVmCapableNodeList(),
2327
      }
2328

    
2329
    if vg_name is not None:
2330
      node_verify_param[constants.NV_VGLIST] = None
2331
      node_verify_param[constants.NV_LVLIST] = vg_name
2332
      node_verify_param[constants.NV_PVLIST] = [vg_name]
2333
      node_verify_param[constants.NV_DRBDLIST] = None
2334

    
2335
    if drbd_helper:
2336
      node_verify_param[constants.NV_DRBDHELPER] = drbd_helper
2337

    
2338
    # bridge checks
2339
    # FIXME: this needs to be changed per node-group, not cluster-wide
2340
    bridges = set()
2341
    default_nicpp = cluster.nicparams[constants.PP_DEFAULT]
2342
    if default_nicpp[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
2343
      bridges.add(default_nicpp[constants.NIC_LINK])
2344
    for instance in instanceinfo.values():
2345
      for nic in instance.nics:
2346
        full_nic = cluster.SimpleFillNIC(nic.nicparams)
2347
        if full_nic[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
2348
          bridges.add(full_nic[constants.NIC_LINK])
2349

    
2350
    if bridges:
2351
      node_verify_param[constants.NV_BRIDGES] = list(bridges)
2352

    
2353
    # Build our expected cluster state
2354
    node_image = dict((node.name, self.NodeImage(offline=node.offline,
2355
                                                 name=node.name,
2356
                                                 vm_capable=node.vm_capable))
2357
                      for node in nodeinfo)
2358

    
2359
    # Gather OOB paths
2360
    oob_paths = []
2361
    for node in nodeinfo:
2362
      path = _SupportsOob(self.cfg, node)
2363
      if path and path not in oob_paths:
2364
        oob_paths.append(path)
2365

    
2366
    if oob_paths:
2367
      node_verify_param[constants.NV_OOB_PATHS] = oob_paths
2368

    
2369
    for instance in instancelist:
2370
      inst_config = instanceinfo[instance]
2371

    
2372
      for nname in inst_config.all_nodes:
2373
        if nname not in node_image:
2374
          # ghost node
2375
          gnode = self.NodeImage(name=nname)
2376
          gnode.ghost = True
2377
          node_image[nname] = gnode
2378

    
2379
      inst_config.MapLVsByNode(node_vol_should)
2380

    
2381
      pnode = inst_config.primary_node
2382
      node_image[pnode].pinst.append(instance)
2383

    
2384
      for snode in inst_config.secondary_nodes:
2385
        nimg = node_image[snode]
2386
        nimg.sinst.append(instance)
2387
        if pnode not in nimg.sbp:
2388
          nimg.sbp[pnode] = []
2389
        nimg.sbp[pnode].append(instance)
2390

    
2391
    # At this point, we have the in-memory data structures complete,
2392
    # except for the runtime information, which we'll gather next
2393

    
2394
    # Due to the way our RPC system works, exact response times cannot be
2395
    # guaranteed (e.g. a broken node could run into a timeout). By keeping the
2396
    # time before and after executing the request, we can at least have a time
2397
    # window.
2398
    nvinfo_starttime = time.time()
2399
    all_nvinfo = self.rpc.call_node_verify(nodelist, node_verify_param,
2400
                                           self.cfg.GetClusterName())
2401
    nvinfo_endtime = time.time()
2402

    
2403
    all_drbd_map = self.cfg.ComputeDRBDMap()
2404

    
2405
    feedback_fn("* Gathering disk information (%s nodes)" % len(nodelist))
2406
    instdisk = self._CollectDiskInfo(nodelist, node_image, instanceinfo)
2407

    
2408
    feedback_fn("* Verifying configuration file consistency")
2409
    self._VerifyFiles(_ErrorIf, nodeinfo, master_node, all_nvinfo, filemap)
2410

    
2411
    feedback_fn("* Verifying node status")
2412

    
2413
    refos_img = None
2414

    
2415
    for node_i in nodeinfo:
2416
      node = node_i.name
2417
      nimg = node_image[node]
2418

    
2419
      if node_i.offline:
2420
        if verbose:
2421
          feedback_fn("* Skipping offline node %s" % (node,))
2422
        n_offline += 1
2423
        continue
2424

    
2425
      if node == master_node:
2426
        ntype = "master"
2427
      elif node_i.master_candidate:
2428
        ntype = "master candidate"
2429
      elif node_i.drained:
2430
        ntype = "drained"
2431
        n_drained += 1
2432
      else:
2433
        ntype = "regular"
2434
      if verbose:
2435
        feedback_fn("* Verifying node %s (%s)" % (node, ntype))
2436

    
2437
      msg = all_nvinfo[node].fail_msg
2438
      _ErrorIf(msg, self.ENODERPC, node, "while contacting node: %s", msg)
2439
      if msg:
2440
        nimg.rpc_fail = True
2441
        continue
2442

    
2443
      nresult = all_nvinfo[node].payload
2444

    
2445
      nimg.call_ok = self._VerifyNode(node_i, nresult)
2446
      self._VerifyNodeTime(node_i, nresult, nvinfo_starttime, nvinfo_endtime)
2447
      self._VerifyNodeNetwork(node_i, nresult)
2448
      self._VerifyOob(node_i, nresult)
2449

    
2450
      if nimg.vm_capable:
2451
        self._VerifyNodeLVM(node_i, nresult, vg_name)
2452
        self._VerifyNodeDrbd(node_i, nresult, instanceinfo, drbd_helper,
2453
                             all_drbd_map)
2454

    
2455
        self._UpdateNodeVolumes(node_i, nresult, nimg, vg_name)
2456
        self._UpdateNodeInstances(node_i, nresult, nimg)
2457
        self._UpdateNodeInfo(node_i, nresult, nimg, vg_name)
2458
        self._UpdateNodeOS(node_i, nresult, nimg)
2459
        if not nimg.os_fail:
2460
          if refos_img is None:
2461
            refos_img = nimg
2462
          self._VerifyNodeOS(node_i, nimg, refos_img)
2463
        self._VerifyNodeBridges(node_i, nresult, bridges)
2464

    
2465
    feedback_fn("* Verifying instance status")
2466
    for instance in instancelist:
2467
      if verbose:
2468
        feedback_fn("* Verifying instance %s" % instance)
2469
      inst_config = instanceinfo[instance]
2470
      self._VerifyInstance(instance, inst_config, node_image,
2471
                           instdisk[instance])
2472
      inst_nodes_offline = []
2473

    
2474
      pnode = inst_config.primary_node
2475
      pnode_img = node_image[pnode]
2476
      _ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,
2477
               self.ENODERPC, pnode, "instance %s, connection to"
2478
               " primary node failed", instance)
2479

    
2480
      _ErrorIf(inst_config.admin_up and pnode_img.offline,
2481
               self.EINSTANCEBADNODE, instance,
2482
               "instance is marked as running and lives on offline node %s",
2483
               inst_config.primary_node)
2484

    
2485
      # If the instance is non-redundant we cannot survive losing its primary
2486
      # node, so we are not N+1 compliant. On the other hand we have no disk
2487
      # templates with more than one secondary so that situation is not well
2488
      # supported either.
2489
      # FIXME: does not support file-backed instances
2490
      if not inst_config.secondary_nodes:
2491
        i_non_redundant.append(instance)
2492

    
2493
      _ErrorIf(len(inst_config.secondary_nodes) > 1, self.EINSTANCELAYOUT,
2494
               instance, "instance has multiple secondary nodes: %s",
2495
               utils.CommaJoin(inst_config.secondary_nodes),
2496
               code=self.ETYPE_WARNING)
2497

    
2498
      if inst_config.disk_template in constants.DTS_INT_MIRROR:
2499
        pnode = inst_config.primary_node
2500
        instance_nodes = utils.NiceSort(inst_config.all_nodes)
2501
        instance_groups = {}
2502

    
2503
        for node in instance_nodes:
2504
          instance_groups.setdefault(nodeinfo_byname[node].group,
2505
                                     []).append(node)
2506

    
2507
        pretty_list = [
2508
          "%s (group %s)" % (utils.CommaJoin(nodes), groupinfo[group].name)
2509
          # Sort so that we always list the primary node first.
2510
          for group, nodes in sorted(instance_groups.items(),
2511
                                     key=lambda (_, nodes): pnode in nodes,
2512
                                     reverse=True)]
2513

    
2514
        self._ErrorIf(len(instance_groups) > 1, self.EINSTANCESPLITGROUPS,
2515
                      instance, "instance has primary and secondary nodes in"
2516
                      " different groups: %s", utils.CommaJoin(pretty_list),
2517
                      code=self.ETYPE_WARNING)
2518

    
2519
      if not cluster.FillBE(inst_config)[constants.BE_AUTO_BALANCE]:
2520
        i_non_a_balanced.append(instance)
2521

    
2522
      for snode in inst_config.secondary_nodes:
2523
        s_img = node_image[snode]
2524
        _ErrorIf(s_img.rpc_fail and not s_img.offline, self.ENODERPC, snode,
2525
                 "instance %s, connection to secondary node failed", instance)
2526

    
2527
        if s_img.offline:
2528
          inst_nodes_offline.append(snode)
2529

    
2530
      # warn that the instance lives on offline nodes
2531
      _ErrorIf(inst_nodes_offline, self.EINSTANCEBADNODE, instance,
2532
               "instance has offline secondary node(s) %s",
2533
               utils.CommaJoin(inst_nodes_offline))
2534
      # ... or ghost/non-vm_capable nodes
2535
      for node in inst_config.all_nodes:
2536
        _ErrorIf(node_image[node].ghost, self.EINSTANCEBADNODE, instance,
2537
                 "instance lives on ghost node %s", node)
2538
        _ErrorIf(not node_image[node].vm_capable, self.EINSTANCEBADNODE,
2539
                 instance, "instance lives on non-vm_capable node %s", node)
2540

    
2541
    feedback_fn("* Verifying orphan volumes")
2542
    reserved = utils.FieldSet(*cluster.reserved_lvs)
2543
    self._VerifyOrphanVolumes(node_vol_should, node_image, reserved)
2544

    
2545
    feedback_fn("* Verifying orphan instances")
2546
    self._VerifyOrphanInstances(instancelist, node_image)
2547

    
2548
    if constants.VERIFY_NPLUSONE_MEM not in self.op.skip_checks:
2549
      feedback_fn("* Verifying N+1 Memory redundancy")
2550
      self._VerifyNPlusOneMemory(node_image, instanceinfo)
2551

    
2552
    feedback_fn("* Other Notes")
2553
    if i_non_redundant:
2554
      feedback_fn("  - NOTICE: %d non-redundant instance(s) found."
2555
                  % len(i_non_redundant))
2556

    
2557
    if i_non_a_balanced:
2558
      feedback_fn("  - NOTICE: %d non-auto-balanced instance(s) found."
2559
                  % len(i_non_a_balanced))
2560

    
2561
    if n_offline:
2562
      feedback_fn("  - NOTICE: %d offline node(s) found." % n_offline)
2563

    
2564
    if n_drained:
2565
      feedback_fn("  - NOTICE: %d drained node(s) found." % n_drained)
2566

    
2567
    return not self.bad
2568

    
2569
  def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):
2570
    """Analyze the post-hooks' result
2571

2572
    This method analyses the hook result, handles it, and sends some
2573
    nicely-formatted feedback back to the user.
2574

2575
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
2576
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
2577
    @param hooks_results: the results of the multi-node hooks rpc call
2578
    @param feedback_fn: function used send feedback back to the caller
2579
    @param lu_result: previous Exec result
2580
    @return: the new Exec result, based on the previous result
2581
        and hook results
2582

2583
    """
2584
    # We only really run POST phase hooks, and are only interested in
2585
    # their results
2586
    if phase == constants.HOOKS_PHASE_POST:
2587
      # Used to change hooks' output to proper indentation
2588
      feedback_fn("* Hooks Results")
2589
      assert hooks_results, "invalid result from hooks"
2590

    
2591
      for node_name in hooks_results:
2592
        res = hooks_results[node_name]
2593
        msg = res.fail_msg
2594
        test = msg and not res.offline
2595
        self._ErrorIf(test, self.ENODEHOOKS, node_name,
2596
                      "Communication failure in hooks execution: %s", msg)
2597
        if res.offline or msg:
2598
          # No need to investigate payload if node is offline or gave an error.
2599
          # override manually lu_result here as _ErrorIf only
2600
          # overrides self.bad
2601
          lu_result = 1
2602
          continue
2603
        for script, hkr, output in res.payload:
2604
          test = hkr == constants.HKR_FAIL
2605
          self._ErrorIf(test, self.ENODEHOOKS, node_name,
2606
                        "Script %s failed, output:", script)
2607
          if test:
2608
            output = self._HOOKS_INDENT_RE.sub('      ', output)
2609
            feedback_fn("%s" % output)
2610
            lu_result = 0
2611

    
2612
      return lu_result
2613

    
2614

    
2615
class LUClusterVerifyDisks(NoHooksLU):
2616
  """Verifies the cluster disks status.
2617

2618
  """
2619
  REQ_BGL = False
2620

    
2621
  def ExpandNames(self):
2622
    self.needed_locks = {
2623
      locking.LEVEL_NODE: locking.ALL_SET,
2624
      locking.LEVEL_INSTANCE: locking.ALL_SET,
2625
    }
2626
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
2627

    
2628
  def Exec(self, feedback_fn):
2629
    """Verify integrity of cluster disks.
2630

2631
    @rtype: tuple of three items
2632
    @return: a tuple of (dict of node-to-node_error, list of instances
2633
        which need activate-disks, dict of instance: (node, volume) for
2634
        missing volumes
2635

2636
    """
2637
    result = res_nodes, res_instances, res_missing = {}, [], {}
2638

    
2639
    nodes = utils.NiceSort(self.cfg.GetVmCapableNodeList())
2640
    instances = self.cfg.GetAllInstancesInfo().values()
2641

    
2642
    nv_dict = {}
2643
    for inst in instances:
2644
      inst_lvs = {}
2645
      if not inst.admin_up:
2646
        continue
2647
      inst.MapLVsByNode(inst_lvs)
2648
      # transform { iname: {node: [vol,],},} to {(node, vol): iname}
2649
      for node, vol_list in inst_lvs.iteritems():
2650
        for vol in vol_list:
2651
          nv_dict[(node, vol)] = inst
2652

    
2653
    if not nv_dict:
2654
      return result
2655

    
2656
    node_lvs = self.rpc.call_lv_list(nodes, [])
2657
    for node, node_res in node_lvs.items():
2658
      if node_res.offline:
2659
        continue
2660
      msg = node_res.fail_msg
2661
      if msg:
2662
        logging.warning("Error enumerating LVs on node %s: %s", node, msg)
2663
        res_nodes[node] = msg
2664
        continue
2665

    
2666
      lvs = node_res.payload
2667
      for lv_name, (_, _, lv_online) in lvs.items():
2668
        inst = nv_dict.pop((node, lv_name), None)
2669
        if (not lv_online and inst is not None
2670
            and inst.name not in res_instances):
2671
          res_instances.append(inst.name)
2672

    
2673
    # any leftover items in nv_dict are missing LVs, let's arrange the
2674
    # data better
2675
    for key, inst in nv_dict.iteritems():
2676
      if inst.name not in res_missing:
2677
        res_missing[inst.name] = []
2678
      res_missing[inst.name].append(key)
2679

    
2680
    return result
2681

    
2682

    
2683
class LUClusterRepairDiskSizes(NoHooksLU):
2684
  """Verifies the cluster disks sizes.
2685

2686
  """
2687
  REQ_BGL = False
2688

    
2689
  def ExpandNames(self):
2690
    if self.op.instances:
2691
      self.wanted_names = _GetWantedInstances(self, self.op.instances)
2692
      self.needed_locks = {
2693
        locking.LEVEL_NODE: [],
2694
        locking.LEVEL_INSTANCE: self.wanted_names,
2695
        }
2696
      self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
2697
    else:
2698
      self.wanted_names = None
2699
      self.needed_locks = {
2700
        locking.LEVEL_NODE: locking.ALL_SET,
2701
        locking.LEVEL_INSTANCE: locking.ALL_SET,
2702
        }
2703
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
2704

    
2705
  def DeclareLocks(self, level):
2706
    if level == locking.LEVEL_NODE and self.wanted_names is not None:
2707
      self._LockInstancesNodes(primary_only=True)
2708

    
2709
  def CheckPrereq(self):
2710
    """Check prerequisites.
2711

2712
    This only checks the optional instance list against the existing names.
2713

2714
    """
2715
    if self.wanted_names is None:
2716
      self.wanted_names = self.glm.list_owned(locking.LEVEL_INSTANCE)
2717

    
2718
    self.wanted_instances = [self.cfg.GetInstanceInfo(name) for name
2719
                             in self.wanted_names]
2720

    
2721
  def _EnsureChildSizes(self, disk):
2722
    """Ensure children of the disk have the needed disk size.
2723

2724
    This is valid mainly for DRBD8 and fixes an issue where the
2725
    children have smaller disk size.
2726

2727
    @param disk: an L{ganeti.objects.Disk} object
2728

2729
    """
2730
    if disk.dev_type == constants.LD_DRBD8:
2731
      assert disk.children, "Empty children for DRBD8?"
2732
      fchild = disk.children[0]
2733
      mismatch = fchild.size < disk.size
2734
      if mismatch:
2735
        self.LogInfo("Child disk has size %d, parent %d, fixing",
2736
                     fchild.size, disk.size)
2737
        fchild.size = disk.size
2738

    
2739
      # and we recurse on this child only, not on the metadev
2740
      return self._EnsureChildSizes(fchild) or mismatch
2741
    else:
2742
      return False
2743

    
2744
  def Exec(self, feedback_fn):
2745
    """Verify the size of cluster disks.
2746

2747
    """
2748
    # TODO: check child disks too
2749
    # TODO: check differences in size between primary/secondary nodes
2750
    per_node_disks = {}
2751
    for instance in self.wanted_instances:
2752
      pnode = instance.primary_node
2753
      if pnode not in per_node_disks:
2754
        per_node_disks[pnode] = []
2755
      for idx, disk in enumerate(instance.disks):
2756
        per_node_disks[pnode].append((instance, idx, disk))
2757

    
2758
    changed = []
2759
    for node, dskl in per_node_disks.items():
2760
      newl = [v[2].Copy() for v in dskl]
2761
      for dsk in newl:
2762
        self.cfg.SetDiskID(dsk, node)
2763
      result = self.rpc.call_blockdev_getsize(node, newl)
2764
      if result.fail_msg:
2765
        self.LogWarning("Failure in blockdev_getsize call to node"
2766
                        " %s, ignoring", node)
2767
        continue
2768
      if len(result.payload) != len(dskl):
2769
        logging.warning("Invalid result from node %s: len(dksl)=%d,"
2770
                        " result.payload=%s", node, len(dskl), result.payload)
2771
        self.LogWarning("Invalid result from node %s, ignoring node results",
2772
                        node)
2773
        continue
2774
      for ((instance, idx, disk), size) in zip(dskl, result.payload):
2775
        if size is None:
2776
          self.LogWarning("Disk %d of instance %s did not return size"
2777
                          " information, ignoring", idx, instance.name)
2778
          continue
2779
        if not isinstance(size, (int, long)):
2780
          self.LogWarning("Disk %d of instance %s did not return valid"
2781
                          " size information, ignoring", idx, instance.name)
2782
          continue
2783
        size = size >> 20
2784
        if size != disk.size:
2785
          self.LogInfo("Disk %d of instance %s has mismatched size,"
2786
                       " correcting: recorded %d, actual %d", idx,
2787
                       instance.name, disk.size, size)
2788
          disk.size = size
2789
          self.cfg.Update(instance, feedback_fn)
2790
          changed.append((instance.name, idx, size))
2791
        if self._EnsureChildSizes(disk):
2792
          self.cfg.Update(instance, feedback_fn)
2793
          changed.append((instance.name, idx, disk.size))
2794
    return changed
2795

    
2796

    
2797
class LUClusterRename(LogicalUnit):
2798
  """Rename the cluster.
2799

2800
  """
2801
  HPATH = "cluster-rename"
2802
  HTYPE = constants.HTYPE_CLUSTER
2803

    
2804
  def BuildHooksEnv(self):
2805
    """Build hooks env.
2806

2807
    """
2808
    return {
2809
      "OP_TARGET": self.cfg.GetClusterName(),
2810
      "NEW_NAME": self.op.name,
2811
      }
2812

    
2813
  def BuildHooksNodes(self):
2814
    """Build hooks nodes.
2815

2816
    """
2817
    return ([self.cfg.GetMasterNode()], self.cfg.GetNodeList())
2818

    
2819
  def CheckPrereq(self):
2820
    """Verify that the passed name is a valid one.
2821

2822
    """
2823
    hostname = netutils.GetHostname(name=self.op.name,
2824
                                    family=self.cfg.GetPrimaryIPFamily())
2825

    
2826
    new_name = hostname.name
2827
    self.ip = new_ip = hostname.ip
2828
    old_name = self.cfg.GetClusterName()
2829
    old_ip = self.cfg.GetMasterIP()
2830
    if new_name == old_name and new_ip == old_ip:
2831
      raise errors.OpPrereqError("Neither the name nor the IP address of the"
2832
                                 " cluster has changed",
2833
                                 errors.ECODE_INVAL)
2834
    if new_ip != old_ip:
2835
      if netutils.TcpPing(new_ip, constants.DEFAULT_NODED_PORT):
2836
        raise errors.OpPrereqError("The given cluster IP address (%s) is"
2837
                                   " reachable on the network" %
2838
                                   new_ip, errors.ECODE_NOTUNIQUE)
2839

    
2840
    self.op.name = new_name
2841

    
2842
  def Exec(self, feedback_fn):
2843
    """Rename the cluster.
2844

2845
    """
2846
    clustername = self.op.name
2847
    ip = self.ip
2848

    
2849
    # shutdown the master IP
2850
    master = self.cfg.GetMasterNode()
2851
    result = self.rpc.call_node_stop_master(master, False)
2852
    result.Raise("Could not disable the master role")
2853

    
2854
    try:
2855
      cluster = self.cfg.GetClusterInfo()
2856
      cluster.cluster_name = clustername
2857
      cluster.master_ip = ip
2858
      self.cfg.Update(cluster, feedback_fn)
2859

    
2860
      # update the known hosts file
2861
      ssh.WriteKnownHostsFile(self.cfg, constants.SSH_KNOWN_HOSTS_FILE)
2862
      node_list = self.cfg.GetOnlineNodeList()
2863
      try:
2864
        node_list.remove(master)
2865
      except ValueError:
2866
        pass
2867
      _UploadHelper(self, node_list, constants.SSH_KNOWN_HOSTS_FILE)
2868
    finally:
2869
      result = self.rpc.call_node_start_master(master, False, False)
2870
      msg = result.fail_msg
2871
      if msg:
2872
        self.LogWarning("Could not re-enable the master role on"
2873
                        " the master, please restart manually: %s", msg)
2874

    
2875
    return clustername
2876

    
2877

    
2878
class LUClusterSetParams(LogicalUnit):
2879
  """Change the parameters of the cluster.
2880

2881
  """
2882
  HPATH = "cluster-modify"
2883
  HTYPE = constants.HTYPE_CLUSTER
2884
  REQ_BGL = False
2885

    
2886
  def CheckArguments(self):
2887
    """Check parameters
2888

2889
    """
2890
    if self.op.uid_pool:
2891
      uidpool.CheckUidPool(self.op.uid_pool)
2892

    
2893
    if self.op.add_uids:
2894
      uidpool.CheckUidPool(self.op.add_uids)
2895

    
2896
    if self.op.remove_uids:
2897
      uidpool.CheckUidPool(self.op.remove_uids)
2898

    
2899
  def ExpandNames(self):
2900
    # FIXME: in the future maybe other cluster params won't require checking on
2901
    # all nodes to be modified.
2902
    self.needed_locks = {
2903
      locking.LEVEL_NODE: locking.ALL_SET,
2904
    }
2905
    self.share_locks[locking.LEVEL_NODE] = 1
2906

    
2907
  def BuildHooksEnv(self):
2908
    """Build hooks env.
2909

2910
    """
2911
    return {
2912
      "OP_TARGET": self.cfg.GetClusterName(),
2913
      "NEW_VG_NAME": self.op.vg_name,
2914
      }
2915

    
2916
  def BuildHooksNodes(self):
2917
    """Build hooks nodes.
2918

2919
    """
2920
    mn = self.cfg.GetMasterNode()
2921
    return ([mn], [mn])
2922

    
2923
  def CheckPrereq(self):
2924
    """Check prerequisites.
2925

2926
    This checks whether the given params don't conflict and
2927
    if the given volume group is valid.
2928

2929
    """
2930
    if self.op.vg_name is not None and not self.op.vg_name:
2931
      if self.cfg.HasAnyDiskOfType(constants.LD_LV):
2932
        raise errors.OpPrereqError("Cannot disable lvm storage while lvm-based"
2933
                                   " instances exist", errors.ECODE_INVAL)
2934

    
2935
    if self.op.drbd_helper is not None and not self.op.drbd_helper:
2936
      if self.cfg.HasAnyDiskOfType(constants.LD_DRBD8):
2937
        raise errors.OpPrereqError("Cannot disable drbd helper while"
2938
                                   " drbd-based instances exist",
2939
                                   errors.ECODE_INVAL)
2940

    
2941
    node_list = self.glm.list_owned(locking.LEVEL_NODE)
2942

    
2943
    # if vg_name not None, checks given volume group on all nodes
2944
    if self.op.vg_name:
2945
      vglist = self.rpc.call_vg_list(node_list)
2946
      for node in node_list:
2947
        msg = vglist[node].fail_msg
2948
        if msg:
2949
          # ignoring down node
2950
          self.LogWarning("Error while gathering data on node %s"
2951
                          " (ignoring node): %s", node, msg)
2952
          continue
2953
        vgstatus = utils.CheckVolumeGroupSize(vglist[node].payload,
2954
                                              self.op.vg_name,
2955
                                              constants.MIN_VG_SIZE)
2956
        if vgstatus:
2957
          raise errors.OpPrereqError("Error on node '%s': %s" %
2958
                                     (node, vgstatus), errors.ECODE_ENVIRON)
2959

    
2960
    if self.op.drbd_helper:
2961
      # checks given drbd helper on all nodes
2962
      helpers = self.rpc.call_drbd_helper(node_list)
2963
      for node in node_list:
2964
        ninfo = self.cfg.GetNodeInfo(node)
2965
        if ninfo.offline:
2966
          self.LogInfo("Not checking drbd helper on offline node %s", node)
2967
          continue
2968
        msg = helpers[node].fail_msg
2969
        if msg:
2970
          raise errors.OpPrereqError("Error checking drbd helper on node"
2971
                                     " '%s': %s" % (node, msg),
2972
                                     errors.ECODE_ENVIRON)
2973
        node_helper = helpers[node].payload
2974
        if node_helper != self.op.drbd_helper:
2975
          raise errors.OpPrereqError("Error on node '%s': drbd helper is %s" %
2976
                                     (node, node_helper), errors.ECODE_ENVIRON)
2977

    
2978
    self.cluster = cluster = self.cfg.GetClusterInfo()
2979
    # validate params changes
2980
    if self.op.beparams:
2981
      utils.ForceDictType(self.op.beparams, constants.BES_PARAMETER_TYPES)
2982
      self.new_beparams = cluster.SimpleFillBE(self.op.beparams)
2983

    
2984
    if self.op.ndparams:
2985
      utils.ForceDictType(self.op.ndparams, constants.NDS_PARAMETER_TYPES)
2986
      self.new_ndparams = cluster.SimpleFillND(self.op.ndparams)
2987

    
2988
      # TODO: we need a more general way to handle resetting
2989
      # cluster-level parameters to default values
2990
      if self.new_ndparams["oob_program"] == "":
2991
        self.new_ndparams["oob_program"] = \
2992
            constants.NDC_DEFAULTS[constants.ND_OOB_PROGRAM]
2993

    
2994
    if self.op.nicparams:
2995
      utils.ForceDictType(self.op.nicparams, constants.NICS_PARAMETER_TYPES)
2996
      self.new_nicparams = cluster.SimpleFillNIC(self.op.nicparams)
2997
      objects.NIC.CheckParameterSyntax(self.new_nicparams)
2998
      nic_errors = []
2999

    
3000
      # check all instances for consistency
3001
      for instance in self.cfg.GetAllInstancesInfo().values():
3002
        for nic_idx, nic in enumerate(instance.nics):
3003
          params_copy = copy.deepcopy(nic.nicparams)
3004
          params_filled = objects.FillDict(self.new_nicparams, params_copy)
3005

    
3006
          # check parameter syntax
3007
          try:
3008
            objects.NIC.CheckParameterSyntax(params_filled)
3009
          except errors.ConfigurationError, err:
3010
            nic_errors.append("Instance %s, nic/%d: %s" %
3011
                              (instance.name, nic_idx, err))
3012

    
3013
          # if we're moving instances to routed, check that they have an ip
3014
          target_mode = params_filled[constants.NIC_MODE]
3015
          if target_mode == constants.NIC_MODE_ROUTED and not nic.ip:
3016
            nic_errors.append("Instance %s, nic/%d: routed NIC with no ip"
3017
                              " address" % (instance.name, nic_idx))
3018
      if nic_errors:
3019
        raise errors.OpPrereqError("Cannot apply the change, errors:\n%s" %
3020
                                   "\n".join(nic_errors))
3021

    
3022
    # hypervisor list/parameters
3023
    self.new_hvparams = new_hvp = objects.FillDict(cluster.hvparams, {})
3024
    if self.op.hvparams:
3025
      for hv_name, hv_dict in self.op.hvparams.items():
3026
        if hv_name not in self.new_hvparams:
3027
          self.new_hvparams[hv_name] = hv_dict
3028
        else:
3029
          self.new_hvparams[hv_name].update(hv_dict)
3030

    
3031
    # os hypervisor parameters
3032
    self.new_os_hvp = objects.FillDict(cluster.os_hvp, {})
3033
    if self.op.os_hvp:
3034
      for os_name, hvs in self.op.os_hvp.items():
3035
        if os_name not in self.new_os_hvp:
3036
          self.new_os_hvp[os_name] = hvs
3037
        else:
3038
          for hv_name, hv_dict in hvs.items():
3039
            if hv_name not in self.new_os_hvp[os_name]:
3040
              self.new_os_hvp[os_name][hv_name] = hv_dict
3041
            else:
3042
              self.new_os_hvp[os_name][hv_name].update(hv_dict)
3043

    
3044
    # os parameters
3045
    self.new_osp = objects.FillDict(cluster.osparams, {})
3046
    if self.op.osparams:
3047
      for os_name, osp in self.op.osparams.items():
3048
        if os_name not in self.new_osp:
3049
          self.new_osp[os_name] = {}
3050

    
3051
        self.new_osp[os_name] = _GetUpdatedParams(self.new_osp[os_name], osp,
3052
                                                  use_none=True)
3053

    
3054
        if not self.new_osp[os_name]:
3055
          # we removed all parameters
3056
          del self.new_osp[os_name]
3057
        else:
3058
          # check the parameter validity (remote check)
3059
          _CheckOSParams(self, False, [self.cfg.GetMasterNode()],
3060
                         os_name, self.new_osp[os_name])
3061

    
3062
    # changes to the hypervisor list
3063
    if self.op.enabled_hypervisors is not None:
3064
      self.hv_list = self.op.enabled_hypervisors
3065
      for hv in self.hv_list:
3066
        # if the hypervisor doesn't already exist in the cluster
3067
        # hvparams, we initialize it to empty, and then (in both
3068
        # cases) we make sure to fill the defaults, as we might not
3069
        # have a complete defaults list if the hypervisor wasn't
3070
        # enabled before
3071
        if hv not in new_hvp:
3072
          new_hvp[hv] = {}
3073
        new_hvp[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], new_hvp[hv])
3074
        utils.ForceDictType(new_hvp[hv], constants.HVS_PARAMETER_TYPES)
3075
    else:
3076
      self.hv_list = cluster.enabled_hypervisors
3077

    
3078
    if self.op.hvparams or self.op.enabled_hypervisors is not None:
3079
      # either the enabled list has changed, or the parameters have, validate
3080
      for hv_name, hv_params in self.new_hvparams.items():
3081
        if ((self.op.hvparams and hv_name in self.op.hvparams) or
3082
            (self.op.enabled_hypervisors and
3083
             hv_name in self.op.enabled_hypervisors)):
3084
          # either this is a new hypervisor, or its parameters have changed
3085
          hv_class = hypervisor.GetHypervisor(hv_name)
3086
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
3087
          hv_class.CheckParameterSyntax(hv_params)
3088
          _CheckHVParams(self, node_list, hv_name, hv_params)
3089

    
3090
    if self.op.os_hvp:
3091
      # no need to check any newly-enabled hypervisors, since the
3092
      # defaults have already been checked in the above code-block
3093
      for os_name, os_hvp in self.new_os_hvp.items():
3094
        for hv_name, hv_params in os_hvp.items():
3095
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
3096
          # we need to fill in the new os_hvp on top of the actual hv_p
3097
          cluster_defaults = self.new_hvparams.get(hv_name, {})
3098
          new_osp = objects.FillDict(cluster_defaults, hv_params)
3099
          hv_class = hypervisor.GetHypervisor(hv_name)
3100
          hv_class.CheckParameterSyntax(new_osp)
3101
          _CheckHVParams(self, node_list, hv_name, new_osp)
3102

    
3103
    if self.op.default_iallocator:
3104
      alloc_script = utils.FindFile(self.op.default_iallocator,
3105
                                    constants.IALLOCATOR_SEARCH_PATH,
3106
                                    os.path.isfile)
3107
      if alloc_script is None:
3108
        raise errors.OpPrereqError("Invalid default iallocator script '%s'"
3109
                                   " specified" % self.op.default_iallocator,
3110
                                   errors.ECODE_INVAL)
3111

    
3112
  def Exec(self, feedback_fn):
3113
    """Change the parameters of the cluster.
3114

3115
    """
3116
    if self.op.vg_name is not None:
3117
      new_volume = self.op.vg_name
3118
      if not new_volume:
3119
        new_volume = None
3120
      if new_volume != self.cfg.GetVGName():
3121
        self.cfg.SetVGName(new_volume)
3122
      else:
3123
        feedback_fn("Cluster LVM configuration already in desired"
3124
                    " state, not changing")
3125
    if self.op.drbd_helper is not None:
3126
      new_helper = self.op.drbd_helper
3127
      if not new_helper:
3128
        new_helper = None
3129
      if new_helper != self.cfg.GetDRBDHelper():
3130
        self.cfg.SetDRBDHelper(new_helper)
3131
      else:
3132
        feedback_fn("Cluster DRBD helper already in desired state,"
3133
                    " not changing")
3134
    if self.op.hvparams:
3135
      self.cluster.hvparams = self.new_hvparams
3136
    if self.op.os_hvp:
3137
      self.cluster.os_hvp = self.new_os_hvp
3138
    if self.op.enabled_hypervisors is not None:
3139
      self.cluster.hvparams = self.new_hvparams
3140
      self.cluster.enabled_hypervisors = self.op.enabled_hypervisors
3141
    if self.op.beparams:
3142
      self.cluster.beparams[constants.PP_DEFAULT] = self.new_beparams
3143
    if self.op.nicparams:
3144
      self.cluster.nicparams[constants.PP_DEFAULT] = self.new_nicparams
3145
    if self.op.osparams:
3146
      self.cluster.osparams = self.new_osp
3147
    if self.op.ndparams:
3148
      self.cluster.ndparams = self.new_ndparams
3149

    
3150
    if self.op.candidate_pool_size is not None:
3151
      self.cluster.candidate_pool_size = self.op.candidate_pool_size
3152
      # we need to update the pool size here, otherwise the save will fail
3153
      _AdjustCandidatePool(self, [])
3154

    
3155
    if self.op.maintain_node_health is not None:
3156
      self.cluster.maintain_node_health = self.op.maintain_node_health
3157

    
3158
    if self.op.prealloc_wipe_disks is not None:
3159
      self.cluster.prealloc_wipe_disks = self.op.prealloc_wipe_disks
3160

    
3161
    if self.op.add_uids is not None:
3162
      uidpool.AddToUidPool(self.cluster.uid_pool, self.op.add_uids)
3163

    
3164
    if self.op.remove_uids is not None:
3165
      uidpool.RemoveFromUidPool(self.cluster.uid_pool, self.op.remove_uids)
3166

    
3167
    if self.op.uid_pool is not None:
3168
      self.cluster.uid_pool = self.op.uid_pool
3169

    
3170
    if self.op.default_iallocator is not None:
3171
      self.cluster.default_iallocator = self.op.default_iallocator
3172

    
3173
    if self.op.reserved_lvs is not None:
3174
      self.cluster.reserved_lvs = self.op.reserved_lvs
3175

    
3176
    def helper_os(aname, mods, desc):
3177
      desc += " OS list"
3178
      lst = getattr(self.cluster, aname)
3179
      for key, val in mods:
3180
        if key == constants.DDM_ADD:
3181
          if val in lst:
3182
            feedback_fn("OS %s already in %s, ignoring" % (val, desc))
3183
          else:
3184
            lst.append(val)
3185
        elif key == constants.DDM_REMOVE:
3186
          if val in lst:
3187
            lst.remove(val)
3188
          else:
3189
            feedback_fn("OS %s not found in %s, ignoring" % (val, desc))
3190
        else:
3191
          raise errors.ProgrammerError("Invalid modification '%s'" % key)
3192

    
3193
    if self.op.hidden_os:
3194
      helper_os("hidden_os", self.op.hidden_os, "hidden")
3195

    
3196
    if self.op.blacklisted_os:
3197
      helper_os("blacklisted_os", self.op.blacklisted_os, "blacklisted")
3198

    
3199
    if self.op.master_netdev:
3200
      master = self.cfg.GetMasterNode()
3201
      feedback_fn("Shutting down master ip on the current netdev (%s)" %
3202
                  self.cluster.master_netdev)
3203
      result = self.rpc.call_node_stop_master(master, False)
3204
      result.Raise("Could not disable the master ip")
3205
      feedback_fn("Changing master_netdev from %s to %s" %
3206
                  (self.cluster.master_netdev, self.op.master_netdev))
3207
      self.cluster.master_netdev = self.op.master_netdev
3208

    
3209
    self.cfg.Update(self.cluster, feedback_fn)
3210

    
3211
    if self.op.master_netdev:
3212
      feedback_fn("Starting the master ip on the new master netdev (%s)" %
3213
                  self.op.master_netdev)
3214
      result = self.rpc.call_node_start_master(master, False, False)
3215
      if result.fail_msg:
3216
        self.LogWarning("Could not re-enable the master ip on"
3217
                        " the master, please restart manually: %s",
3218
                        result.fail_msg)
3219

    
3220

    
3221
def _UploadHelper(lu, nodes, fname):
3222
  """Helper for uploading a file and showing warnings.
3223

3224
  """
3225
  if os.path.exists(fname):
3226
    result = lu.rpc.call_upload_file(nodes, fname)
3227
    for to_node, to_result in result.items():
3228
      msg = to_result.fail_msg
3229
      if msg:
3230
        msg = ("Copy of file %s to node %s failed: %s" %
3231
               (fname, to_node, msg))
3232
        lu.proc.LogWarning(msg)
3233

    
3234

    
3235
def _ComputeAncillaryFiles(cluster, redist):
3236
  """Compute files external to Ganeti which need to be consistent.
3237

3238
  @type redist: boolean
3239
  @param redist: Whether to include files which need to be redistributed
3240

3241
  """
3242
  # Compute files for all nodes
3243
  files_all = set([
3244
    constants.SSH_KNOWN_HOSTS_FILE,
3245
    constants.CONFD_HMAC_KEY,
3246
    constants.CLUSTER_DOMAIN_SECRET_FILE,
3247
    ])
3248

    
3249
  if not redist:
3250
    files_all.update(constants.ALL_CERT_FILES)
3251
    files_all.update(ssconf.SimpleStore().GetFileList())
3252

    
3253
  if cluster.modify_etc_hosts:
3254
    files_all.add(constants.ETC_HOSTS)
3255

    
3256
  # Files which must either exist on all nodes or on none
3257
  files_all_opt = set([
3258
    constants.RAPI_USERS_FILE,
3259
    ])
3260

    
3261
  # Files which should only be on master candidates
3262
  files_mc = set()
3263
  if not redist:
3264
    files_mc.add(constants.CLUSTER_CONF_FILE)
3265

    
3266
  # Files which should only be on VM-capable nodes
3267
  files_vm = set(filename
3268
    for hv_name in cluster.enabled_hypervisors
3269
    for filename in hypervisor.GetHypervisor(hv_name).GetAncillaryFiles())
3270

    
3271
  # Filenames must be unique
3272
  assert (len(files_all | files_all_opt | files_mc | files_vm) ==
3273
          sum(map(len, [files_all, files_all_opt, files_mc, files_vm]))), \
3274
         "Found file listed in more than one file list"
3275

    
3276
  return (files_all, files_all_opt, files_mc, files_vm)
3277

    
3278

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

3282
  ConfigWriter takes care of distributing the config and ssconf files, but
3283
  there are more files which should be distributed to all nodes. This function
3284
  makes sure those are copied.
3285

3286
  @param lu: calling logical unit
3287
  @param additional_nodes: list of nodes not in the config to distribute to
3288
  @type additional_vm: boolean
3289
  @param additional_vm: whether the additional nodes are vm-capable or not
3290

3291
  """
3292
  # Gather target nodes
3293
  cluster = lu.cfg.GetClusterInfo()
3294
  master_info = lu.cfg.GetNodeInfo(lu.cfg.GetMasterNode())
3295

    
3296
  online_nodes = lu.cfg.GetOnlineNodeList()
3297
  vm_nodes = lu.cfg.GetVmCapableNodeList()
3298

    
3299
  if additional_nodes is not None:
3300
    online_nodes.extend(additional_nodes)
3301
    if additional_vm:
3302
      vm_nodes.extend(additional_nodes)
3303

    
3304
  # Never distribute to master node
3305
  for nodelist in [online_nodes, vm_nodes]:
3306
    if master_info.name in nodelist:
3307
      nodelist.remove(master_info.name)
3308

    
3309
  # Gather file lists
3310
  (files_all, files_all_opt, files_mc, files_vm) = \
3311
    _ComputeAncillaryFiles(cluster, True)
3312

    
3313
  # Never re-distribute configuration file from here
3314
  assert not (constants.CLUSTER_CONF_FILE in files_all or
3315
              constants.CLUSTER_CONF_FILE in files_vm)
3316
  assert not files_mc, "Master candidates not handled in this function"
3317

    
3318
  filemap = [
3319
    (online_nodes, files_all),
3320
    (online_nodes, files_all_opt),
3321
    (vm_nodes, files_vm),
3322
    ]
3323

    
3324
  # Upload the files
3325
  for (node_list, files) in filemap:
3326
    for fname in files:
3327
      _UploadHelper(lu, node_list, fname)
3328

    
3329

    
3330
class LUClusterRedistConf(NoHooksLU):
3331
  """Force the redistribution of cluster configuration.
3332

3333
  This is a very simple LU.
3334

3335
  """
3336
  REQ_BGL = False
3337

    
3338
  def ExpandNames(self):
3339
    self.needed_locks = {
3340
      locking.LEVEL_NODE: locking.ALL_SET,
3341
    }
3342
    self.share_locks[locking.LEVEL_NODE] = 1
3343

    
3344
  def Exec(self, feedback_fn):
3345
    """Redistribute the configuration.
3346

3347
    """
3348
    self.cfg.Update(self.cfg.GetClusterInfo(), feedback_fn)
3349
    _RedistributeAncillaryFiles(self)
3350

    
3351

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

3355
  """
3356
  if not instance.disks or disks is not None and not disks:
3357
    return True
3358

    
3359
  disks = _ExpandCheckDisks(instance, disks)
3360

    
3361
  if not oneshot:
3362
    lu.proc.LogInfo("Waiting for instance %s to sync disks." % instance.name)
3363

    
3364
  node = instance.primary_node
3365

    
3366
  for dev in disks:
3367
    lu.cfg.SetDiskID(dev, node)
3368

    
3369
  # TODO: Convert to utils.Retry
3370

    
3371
  retries = 0
3372
  degr_retries = 10 # in seconds, as we sleep 1 second each time
3373
  while True:
3374
    max_time = 0
3375
    done = True
3376
    cumul_degraded = False
3377
    rstats = lu.rpc.call_blockdev_getmirrorstatus(node, disks)
3378
    msg = rstats.fail_msg
3379
    if msg:
3380
      lu.LogWarning("Can't get any data from node %s: %s", node, msg)
3381
      retries += 1
3382
      if retries >= 10:
3383
        raise errors.RemoteError("Can't contact node %s for mirror data,"
3384
                                 " aborting." % node)
3385
      time.sleep(6)
3386
      continue
3387
    rstats = rstats.payload
3388
    retries = 0
3389
    for i, mstat in enumerate(rstats):
3390
      if mstat is None:
3391
        lu.LogWarning("Can't compute data for node %s/%s",
3392
                           node, disks[i].iv_name)
3393
        continue
3394

    
3395
      cumul_degraded = (cumul_degraded or
3396
                        (mstat.is_degraded and mstat.sync_percent is None))
3397
      if mstat.sync_percent is not None:
3398
        done = False
3399
        if mstat.estimated_time is not None:
3400
          rem_time = ("%s remaining (estimated)" %
3401
                      utils.FormatSeconds(mstat.estimated_time))
3402
          max_time = mstat.estimated_time
3403
        else:
3404
          rem_time = "no time estimate"
3405
        lu.proc.LogInfo("- device %s: %5.2f%% done, %s" %
3406
                        (disks[i].iv_name, mstat.sync_percent, rem_time))
3407

    
3408
    # if we're done but degraded, let's do a few small retries, to
3409
    # make sure we see a stable and not transient situation; therefore
3410
    # we force restart of the loop
3411
    if (done or oneshot) and cumul_degraded and degr_retries > 0:
3412
      logging.info("Degraded disks found, %d retries left", degr_retries)
3413
      degr_retries -= 1
3414
      time.sleep(1)
3415
      continue
3416

    
3417
    if done or oneshot:
3418
      break
3419

    
3420
    time.sleep(min(60, max_time))
3421

    
3422
  if done:
3423
    lu.proc.LogInfo("Instance %s's disks are in sync." % instance.name)
3424
  return not cumul_degraded
3425

    
3426

    
3427
def _CheckDiskConsistency(lu, dev, node, on_primary, ldisk=False):
3428
  """Check that mirrors are not degraded.
3429

3430
  The ldisk parameter, if True, will change the test from the
3431
  is_degraded attribute (which represents overall non-ok status for
3432
  the device(s)) to the ldisk (representing the local storage status).
3433

3434
  """
3435
  lu.cfg.SetDiskID(dev, node)
3436

    
3437
  result = True
3438

    
3439
  if on_primary or dev.AssembleOnSecondary():
3440
    rstats = lu.rpc.call_blockdev_find(node, dev)
3441
    msg = rstats.fail_msg
3442
    if msg:
3443
      lu.LogWarning("Can't find disk on node %s: %s", node, msg)
3444
      result = False
3445
    elif not rstats.payload:
3446
      lu.LogWarning("Can't find disk on node %s", node)
3447
      result = False
3448
    else:
3449
      if ldisk:
3450
        result = result and rstats.payload.ldisk_status == constants.LDS_OKAY
3451
      else:
3452
        result = result and not rstats.payload.is_degraded
3453

    
3454
  if dev.children:
3455
    for child in dev.children:
3456
      result = result and _CheckDiskConsistency(lu, child, node, on_primary)
3457

    
3458
  return result
3459

    
3460

    
3461
class LUOobCommand(NoHooksLU):
3462
  """Logical unit for OOB handling.
3463

3464
  """
3465
  REG_BGL = False
3466
  _SKIP_MASTER = (constants.OOB_POWER_OFF, constants.OOB_POWER_CYCLE)
3467

    
3468
  def ExpandNames(self):
3469
    """Gather locks we need.
3470

3471
    """
3472
    if self.op.node_names:
3473
      self.op.node_names = _GetWantedNodes(self, self.op.node_names)
3474
      lock_names = self.op.node_names
3475
    else:
3476
      lock_names = locking.ALL_SET
3477

    
3478
    self.needed_locks = {
3479
      locking.LEVEL_NODE: lock_names,
3480
      }
3481

    
3482
  def CheckPrereq(self):
3483
    """Check prerequisites.
3484

3485
    This checks:
3486
     - the node exists in the configuration
3487
     - OOB is supported
3488

3489
    Any errors are signaled by raising errors.OpPrereqError.
3490

3491
    """
3492
    self.nodes = []
3493
    self.master_node = self.cfg.GetMasterNode()
3494

    
3495
    assert self.op.power_delay >= 0.0
3496

    
3497
    if self.op.node_names:
3498
      if (self.op.command in self._SKIP_MASTER and
3499
          self.master_node in self.op.node_names):
3500
        master_node_obj = self.cfg.GetNodeInfo(self.master_node)
3501
        master_oob_handler = _SupportsOob(self.cfg, master_node_obj)
3502

    
3503
        if master_oob_handler:
3504
          additional_text = ("run '%s %s %s' if you want to operate on the"
3505
                             " master regardless") % (master_oob_handler,
3506
                                                      self.op.command,
3507
                                                      self.master_node)
3508
        else:
3509
          additional_text = "it does not support out-of-band operations"
3510

    
3511
        raise errors.OpPrereqError(("Operating on the master node %s is not"
3512
                                    " allowed for %s; %s") %
3513
                                   (self.master_node, self.op.command,
3514
                                    additional_text), errors.ECODE_INVAL)
3515
    else:
3516
      self.op.node_names = self.cfg.GetNodeList()
3517
      if self.op.command in self._SKIP_MASTER:
3518
        self.op.node_names.remove(self.master_node)
3519

    
3520
    if self.op.command in self._SKIP_MASTER:
3521
      assert self.master_node not in self.op.node_names
3522

    
3523
    for node_name in self.op.node_names:
3524
      node = self.cfg.GetNodeInfo(node_name)
3525

    
3526
      if node is None:
3527
        raise errors.OpPrereqError("Node %s not found" % node_name,
3528
                                   errors.ECODE_NOENT)
3529
      else:
3530
        self.nodes.append(node)
3531

    
3532
      if (not self.op.ignore_status and
3533
          (self.op.command == constants.OOB_POWER_OFF and not node.offline)):
3534
        raise errors.OpPrereqError(("Cannot power off node %s because it is"
3535
                                    " not marked offline") % node_name,
3536
                                   errors.ECODE_STATE)
3537

    
3538
  def Exec(self, feedback_fn):
3539
    """Execute OOB and return result if we expect any.
3540

3541
    """
3542
    master_node = self.master_node
3543
    ret = []
3544

    
3545
    for idx, node in enumerate(utils.NiceSort(self.nodes,
3546
                                              key=lambda node: node.name)):
3547
      node_entry = [(constants.RS_NORMAL, node.name)]
3548
      ret.append(node_entry)
3549

    
3550
      oob_program = _SupportsOob(self.cfg, node)
3551

    
3552
      if not oob_program:
3553
        node_entry.append((constants.RS_UNAVAIL, None))
3554
        continue
3555

    
3556
      logging.info("Executing out-of-band command '%s' using '%s' on %s",
3557
                   self.op.command, oob_program, node.name)
3558
      result = self.rpc.call_run_oob(master_node, oob_program,
3559
                                     self.op.command, node.name,
3560
                                     self.op.timeout)
3561

    
3562
      if result.fail_msg:
3563
        self.LogWarning("Out-of-band RPC failed on node '%s': %s",
3564
                        node.name, result.fail_msg)
3565
        node_entry.append((constants.RS_NODATA, None))
3566
      else:
3567
        try:
3568
          self._CheckPayload(result)
3569
        except errors.OpExecError, err:
3570
          self.LogWarning("Payload returned by node '%s' is not valid: %s",
3571
                          node.name, err)
3572
          node_entry.append((constants.RS_NODATA, None))
3573
        else:
3574
          if self.op.command == constants.OOB_HEALTH:
3575
            # For health we should log important events
3576
            for item, status in result.payload:
3577
              if status in [constants.OOB_STATUS_WARNING,
3578
                            constants.OOB_STATUS_CRITICAL]:
3579
                self.LogWarning("Item '%s' on node '%s' has status '%s'",
3580
                                item, node.name, status)
3581

    
3582
          if self.op.command == constants.OOB_POWER_ON:
3583
            node.powered = True
3584
          elif self.op.command == constants.OOB_POWER_OFF:
3585
            node.powered = False
3586
          elif self.op.command == constants.OOB_POWER_STATUS:
3587
            powered = result.payload[constants.OOB_POWER_STATUS_POWERED]
3588
            if powered != node.powered:
3589
              logging.warning(("Recorded power state (%s) of node '%s' does not"
3590
                               " match actual power state (%s)"), node.powered,
3591
                              node.name, powered)
3592

    
3593
          # For configuration changing commands we should update the node
3594
          if self.op.command in (constants.OOB_POWER_ON,
3595
                                 constants.OOB_POWER_OFF):
3596
            self.cfg.Update(node, feedback_fn)
3597

    
3598
          node_entry.append((constants.RS_NORMAL, result.payload))
3599

    
3600
          if (self.op.command == constants.OOB_POWER_ON and
3601
              idx < len(self.nodes) - 1):
3602
            time.sleep(self.op.power_delay)
3603

    
3604
    return ret
3605

    
3606
  def _CheckPayload(self, result):
3607
    """Checks if the payload is valid.
3608

3609
    @param result: RPC result
3610
    @raises errors.OpExecError: If payload is not valid
3611

3612
    """
3613
    errs = []
3614
    if self.op.command == constants.OOB_HEALTH:
3615
      if not isinstance(result.payload, list):
3616
        errs.append("command 'health' is expected to return a list but got %s" %
3617
                    type(result.payload))
3618
      else:
3619
        for item, status in result.payload:
3620
          if status not in constants.OOB_STATUSES:
3621
            errs.append("health item '%s' has invalid status '%s'" %
3622
                        (item, status))
3623

    
3624
    if self.op.command == constants.OOB_POWER_STATUS:
3625
      if not isinstance(result.payload, dict):
3626
        errs.append("power-status is expected to return a dict but got %s" %
3627
                    type(result.payload))
3628

    
3629
    if self.op.command in [
3630
        constants.OOB_POWER_ON,
3631
        constants.OOB_POWER_OFF,
3632
        constants.OOB_POWER_CYCLE,
3633
        ]:
3634
      if result.payload is not None:
3635
        errs.append("%s is expected to not return payload but got '%s'" %
3636
                    (self.op.command, result.payload))
3637

    
3638
    if errs:
3639
      raise errors.OpExecError("Check of out-of-band payload failed due to %s" %
3640
                               utils.CommaJoin(errs))
3641

    
3642
class _OsQuery(_QueryBase):
3643
  FIELDS = query.OS_FIELDS
3644

    
3645
  def ExpandNames(self, lu):
3646
    # Lock all nodes in shared mode
3647
    # Temporary removal of locks, should be reverted later
3648
    # TODO: reintroduce locks when they are lighter-weight
3649
    lu.needed_locks = {}
3650
    #self.share_locks[locking.LEVEL_NODE] = 1
3651
    #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3652

    
3653
    # The following variables interact with _QueryBase._GetNames
3654
    if self.names:
3655
      self.wanted = self.names
3656
    else:
3657
      self.wanted = locking.ALL_SET
3658

    
3659
    self.do_locking = self.use_locking
3660

    
3661
  def DeclareLocks(self, lu, level):
3662
    pass
3663

    
3664
  @staticmethod
3665
  def _DiagnoseByOS(rlist):
3666
    """Remaps a per-node return list into an a per-os per-node dictionary
3667

3668
    @param rlist: a map with node names as keys and OS objects as values
3669

3670
    @rtype: dict
3671
    @return: a dictionary with osnames as keys and as value another
3672
        map, with nodes as keys and tuples of (path, status, diagnose,
3673
        variants, parameters, api_versions) as values, eg::
3674

3675
          {"debian-etch": {"node1": [(/usr/lib/..., True, "", [], []),
3676
                                     (/srv/..., False, "invalid api")],
3677
                           "node2": [(/srv/..., True, "", [], [])]}
3678
          }
3679

3680
    """
3681
    all_os = {}
3682
    # we build here the list of nodes that didn't fail the RPC (at RPC
3683
    # level), so that nodes with a non-responding node daemon don't
3684
    # make all OSes invalid
3685
    good_nodes = [node_name for node_name in rlist
3686
                  if not rlist[node_name].fail_msg]
3687
    for node_name, nr in rlist.items():
3688
      if nr.fail_msg or not nr.payload:
3689
        continue
3690
      for (name, path, status, diagnose, variants,
3691
           params, api_versions) in nr.payload:
3692
        if name not in all_os:
3693
          # build a list of nodes for this os containing empty lists
3694
          # for each node in node_list
3695
          all_os[name] = {}
3696
          for nname in good_nodes:
3697
            all_os[name][nname] = []
3698
        # convert params from [name, help] to (name, help)
3699
        params = [tuple(v) for v in params]
3700
        all_os[name][node_name].append((path, status, diagnose,
3701
                                        variants, params, api_versions))
3702
    return all_os
3703

    
3704
  def _GetQueryData(self, lu):
3705
    """Computes the list of nodes and their attributes.
3706

3707
    """
3708
    # Locking is not used
3709
    assert not (compat.any(lu.glm.is_owned(level)
3710
                           for level in locking.LEVELS
3711
                           if level != locking.LEVEL_CLUSTER) or
3712
                self.do_locking or self.use_locking)
3713

    
3714
    valid_nodes = [node.name
3715
                   for node in lu.cfg.GetAllNodesInfo().values()
3716
                   if not node.offline and node.vm_capable]
3717
    pol = self._DiagnoseByOS(lu.rpc.call_os_diagnose(valid_nodes))
3718
    cluster = lu.cfg.GetClusterInfo()
3719

    
3720
    data = {}
3721

    
3722
    for (os_name, os_data) in pol.items():
3723
      info = query.OsInfo(name=os_name, valid=True, node_status=os_data,
3724
                          hidden=(os_name in cluster.hidden_os),
3725
                          blacklisted=(os_name in cluster.blacklisted_os))
3726

    
3727
      variants = set()
3728
      parameters = set()
3729
      api_versions = set()
3730

    
3731
      for idx, osl in enumerate(os_data.values()):
3732
        info.valid = bool(info.valid and osl and osl[0][1])
3733
        if not info.valid:
3734
          break
3735

    
3736
        (node_variants, node_params, node_api) = osl[0][3:6]
3737
        if idx == 0:
3738
          # First entry
3739
          variants.update(node_variants)
3740
          parameters.update(node_params)
3741
          api_versions.update(node_api)
3742
        else:
3743
          # Filter out inconsistent values
3744
          variants.intersection_update(node_variants)
3745
          parameters.intersection_update(node_params)
3746
          api_versions.intersection_update(node_api)
3747

    
3748
      info.variants = list(variants)
3749
      info.parameters = list(parameters)
3750
      info.api_versions = list(api_versions)
3751

    
3752
      data[os_name] = info
3753

    
3754
    # Prepare data in requested order
3755
    return [data[name] for name in self._GetNames(lu, pol.keys(), None)
3756
            if name in data]
3757

    
3758

    
3759
class LUOsDiagnose(NoHooksLU):
3760
  """Logical unit for OS diagnose/query.
3761

3762
  """
3763
  REQ_BGL = False
3764

    
3765
  @staticmethod
3766
  def _BuildFilter(fields, names):
3767
    """Builds a filter for querying OSes.
3768

3769
    """
3770
    name_filter = qlang.MakeSimpleFilter("name", names)
3771

    
3772
    # Legacy behaviour: Hide hidden, blacklisted or invalid OSes if the
3773
    # respective field is not requested
3774
    status_filter = [[qlang.OP_NOT, [qlang.OP_TRUE, fname]]
3775
                     for fname in ["hidden", "blacklisted"]
3776
                     if fname not in fields]
3777
    if "valid" not in fields:
3778
      status_filter.append([qlang.OP_TRUE, "valid"])
3779

    
3780
    if status_filter:
3781
      status_filter.insert(0, qlang.OP_AND)
3782
    else:
3783
      status_filter = None
3784

    
3785
    if name_filter and status_filter:
3786
      return [qlang.OP_AND, name_filter, status_filter]
3787
    elif name_filter:
3788
      return name_filter
3789
    else:
3790
      return status_filter
3791

    
3792
  def CheckArguments(self):
3793
    self.oq = _OsQuery(self._BuildFilter(self.op.output_fields, self.op.names),
3794
                       self.op.output_fields, False)
3795

    
3796
  def ExpandNames(self):
3797
    self.oq.ExpandNames(self)
3798

    
3799
  def Exec(self, feedback_fn):
3800
    return self.oq.OldStyleQuery(self)
3801

    
3802

    
3803
class LUNodeRemove(LogicalUnit):
3804
  """Logical unit for removing a node.
3805

3806
  """
3807
  HPATH = "node-remove"
3808
  HTYPE = constants.HTYPE_NODE
3809

    
3810
  def BuildHooksEnv(self):
3811
    """Build hooks env.
3812

3813
    This doesn't run on the target node in the pre phase as a failed
3814
    node would then be impossible to remove.
3815

3816
    """
3817
    return {
3818
      "OP_TARGET": self.op.node_name,
3819
      "NODE_NAME": self.op.node_name,
3820
      }
3821

    
3822
  def BuildHooksNodes(self):
3823
    """Build hooks nodes.
3824

3825
    """
3826
    all_nodes = self.cfg.GetNodeList()
3827
    try:
3828
      all_nodes.remove(self.op.node_name)
3829
    except ValueError:
3830
      logging.warning("Node '%s', which is about to be removed, was not found"
3831
                      " in the list of all nodes", self.op.node_name)
3832
    return (all_nodes, all_nodes)
3833

    
3834
  def CheckPrereq(self):
3835
    """Check prerequisites.
3836

3837
    This checks:
3838
     - the node exists in the configuration
3839
     - it does not have primary or secondary instances
3840
     - it's not the master
3841

3842
    Any errors are signaled by raising errors.OpPrereqError.
3843

3844
    """
3845
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3846
    node = self.cfg.GetNodeInfo(self.op.node_name)
3847
    assert node is not None
3848

    
3849
    instance_list = self.cfg.GetInstanceList()
3850

    
3851
    masternode = self.cfg.GetMasterNode()
3852
    if node.name == masternode:
3853
      raise errors.OpPrereqError("Node is the master node, failover to another"
3854
                                 " node is required", errors.ECODE_INVAL)
3855

    
3856
    for instance_name in instance_list:
3857
      instance = self.cfg.GetInstanceInfo(instance_name)
3858
      if node.name in instance.all_nodes:
3859
        raise errors.OpPrereqError("Instance %s is still running on the node,"
3860
                                   " please remove first" % instance_name,
3861
                                   errors.ECODE_INVAL)
3862
    self.op.node_name = node.name
3863
    self.node = node
3864

    
3865
  def Exec(self, feedback_fn):
3866
    """Removes the node from the cluster.
3867

3868
    """
3869
    node = self.node
3870
    logging.info("Stopping the node daemon and removing configs from node %s",
3871
                 node.name)
3872

    
3873
    modify_ssh_setup = self.cfg.GetClusterInfo().modify_ssh_setup
3874

    
3875
    # Promote nodes to master candidate as needed
3876
    _AdjustCandidatePool(self, exceptions=[node.name])
3877
    self.context.RemoveNode(node.name)
3878

    
3879
    # Run post hooks on the node before it's removed
3880
    _RunPostHook(self, node.name)
3881

    
3882
    result = self.rpc.call_node_leave_cluster(node.name, modify_ssh_setup)
3883
    msg = result.fail_msg
3884
    if msg:
3885
      self.LogWarning("Errors encountered on the remote node while leaving"
3886
                      " the cluster: %s", msg)
3887

    
3888
    # Remove node from our /etc/hosts
3889
    if self.cfg.GetClusterInfo().modify_etc_hosts:
3890
      master_node = self.cfg.GetMasterNode()
3891
      result = self.rpc.call_etc_hosts_modify(master_node,
3892
                                              constants.ETC_HOSTS_REMOVE,
3893
                                              node.name, None)
3894
      result.Raise("Can't update hosts file with new host data")
3895
      _RedistributeAncillaryFiles(self)
3896

    
3897

    
3898
class _NodeQuery(_QueryBase):
3899
  FIELDS = query.NODE_FIELDS
3900

    
3901
  def ExpandNames(self, lu):
3902
    lu.needed_locks = {}
3903
    lu.share_locks[locking.LEVEL_NODE] = 1
3904

    
3905
    if self.names:
3906
      self.wanted = _GetWantedNodes(lu, self.names)
3907
    else:
3908
      self.wanted = locking.ALL_SET
3909

    
3910
    self.do_locking = (self.use_locking and
3911
                       query.NQ_LIVE in self.requested_data)
3912

    
3913
    if self.do_locking:
3914
      # if we don't request only static fields, we need to lock the nodes
3915
      lu.needed_locks[locking.LEVEL_NODE] = self.wanted
3916

    
3917
  def DeclareLocks(self, lu, level):
3918
    pass
3919

    
3920
  def _GetQueryData(self, lu):
3921
    """Computes the list of nodes and their attributes.
3922

3923
    """
3924
    all_info = lu.cfg.GetAllNodesInfo()
3925

    
3926
    nodenames = self._GetNames(lu, all_info.keys(), locking.LEVEL_NODE)
3927

    
3928
    # Gather data as requested
3929
    if query.NQ_LIVE in self.requested_data:
3930
      # filter out non-vm_capable nodes
3931
      toquery_nodes = [name for name in nodenames if all_info[name].vm_capable]
3932

    
3933
      node_data = lu.rpc.call_node_info(toquery_nodes, lu.cfg.GetVGName(),
3934
                                        lu.cfg.GetHypervisorType())
3935
      live_data = dict((name, nresult.payload)
3936
                       for (name, nresult) in node_data.items()
3937
                       if not nresult.fail_msg and nresult.payload)
3938
    else:
3939
      live_data = None
3940

    
3941
    if query.NQ_INST in self.requested_data:
3942
      node_to_primary = dict([(name, set()) for name in nodenames])
3943
      node_to_secondary = dict([(name, set()) for name in nodenames])
3944

    
3945
      inst_data = lu.cfg.GetAllInstancesInfo()
3946

    
3947
      for inst in inst_data.values():
3948
        if inst.primary_node in node_to_primary:
3949
          node_to_primary[inst.primary_node].add(inst.name)
3950
        for secnode in inst.secondary_nodes:
3951
          if secnode in node_to_secondary:
3952
            node_to_secondary[secnode].add(inst.name)
3953
    else:
3954
      node_to_primary = None
3955
      node_to_secondary = None
3956

    
3957
    if query.NQ_OOB in self.requested_data:
3958
      oob_support = dict((name, bool(_SupportsOob(lu.cfg, node)))
3959
                         for name, node in all_info.iteritems())
3960
    else:
3961
      oob_support = None
3962

    
3963
    if query.NQ_GROUP in self.requested_data:
3964
      groups = lu.cfg.GetAllNodeGroupsInfo()
3965
    else:
3966
      groups = {}
3967

    
3968
    return query.NodeQueryData([all_info[name] for name in nodenames],
3969
                               live_data, lu.cfg.GetMasterNode(),
3970
                               node_to_primary, node_to_secondary, groups,
3971
                               oob_support, lu.cfg.GetClusterInfo())
3972

    
3973

    
3974
class LUNodeQuery(NoHooksLU):
3975
  """Logical unit for querying nodes.
3976

3977
  """
3978
  # pylint: disable-msg=W0142
3979
  REQ_BGL = False
3980

    
3981
  def CheckArguments(self):
3982
    self.nq = _NodeQuery(qlang.MakeSimpleFilter("name", self.op.names),
3983
                         self.op.output_fields, self.op.use_locking)
3984

    
3985
  def ExpandNames(self):
3986
    self.nq.ExpandNames(self)
3987

    
3988
  def Exec(self, feedback_fn):
3989
    return self.nq.OldStyleQuery(self)
3990

    
3991

    
3992
class LUNodeQueryvols(NoHooksLU):
3993
  """Logical unit for getting volumes on node(s).
3994

3995
  """
3996
  REQ_BGL = False
3997
  _FIELDS_DYNAMIC = utils.FieldSet("phys", "vg", "name", "size", "instance")
3998
  _FIELDS_STATIC = utils.FieldSet("node")
3999

    
4000
  def CheckArguments(self):
4001
    _CheckOutputFields(static=self._FIELDS_STATIC,
4002
                       dynamic=self._FIELDS_DYNAMIC,
4003
                       selected=self.op.output_fields)
4004

    
4005
  def ExpandNames(self):
4006
    self.needed_locks = {}
4007
    self.share_locks[locking.LEVEL_NODE] = 1
4008
    if not self.op.nodes:
4009
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
4010
    else:
4011
      self.needed_locks[locking.LEVEL_NODE] = \
4012
        _GetWantedNodes(self, self.op.nodes)
4013

    
4014
  def Exec(self, feedback_fn):
4015
    """Computes the list of nodes and their attributes.
4016

4017
    """
4018
    nodenames = self.glm.list_owned(locking.LEVEL_NODE)
4019
    volumes = self.rpc.call_node_volumes(nodenames)
4020

    
4021
    ilist = [self.cfg.GetInstanceInfo(iname) for iname
4022
             in self.cfg.GetInstanceList()]
4023

    
4024
    lv_by_node = dict([(inst, inst.MapLVsByNode()) for inst in ilist])
4025

    
4026
    output = []
4027
    for node in nodenames:
4028
      nresult = volumes[node]
4029
      if nresult.offline:
4030
        continue
4031
      msg = nresult.fail_msg
4032
      if msg:
4033
        self.LogWarning("Can't compute volume data on node %s: %s", node, msg)
4034
        continue
4035

    
4036
      node_vols = nresult.payload[:]
4037
      node_vols.sort(key=lambda vol: vol['dev'])
4038

    
4039
      for vol in node_vols:
4040
        node_output = []
4041
        for field in self.op.output_fields:
4042
          if field == "node":
4043
            val = node
4044
          elif field == "phys":
4045
            val = vol['dev']
4046
          elif field == "vg":
4047
            val = vol['vg']
4048
          elif field == "name":
4049
            val = vol['name']
4050
          elif field == "size":
4051
            val = int(float(vol['size']))
4052
          elif field == "instance":
4053
            for inst in ilist:
4054
              if node not in lv_by_node[inst]:
4055
                continue
4056
              if vol['name'] in lv_by_node[inst][node]:
4057
                val = inst.name
4058
                break
4059
            else:
4060
              val = '-'
4061
          else:
4062
            raise errors.ParameterError(field)
4063
          node_output.append(str(val))
4064

    
4065
        output.append(node_output)
4066

    
4067
    return output
4068

    
4069

    
4070
class LUNodeQueryStorage(NoHooksLU):
4071
  """Logical unit for getting information on storage units on node(s).
4072

4073
  """
4074
  _FIELDS_STATIC = utils.FieldSet(constants.SF_NODE)
4075
  REQ_BGL = False
4076

    
4077
  def CheckArguments(self):
4078
    _CheckOutputFields(static=self._FIELDS_STATIC,
4079
                       dynamic=utils.FieldSet(*constants.VALID_STORAGE_FIELDS),
4080
                       selected=self.op.output_fields)
4081

    
4082
  def ExpandNames(self):
4083
    self.needed_locks = {}
4084
    self.share_locks[locking.LEVEL_NODE] = 1
4085

    
4086
    if self.op.nodes:
4087
      self.needed_locks[locking.LEVEL_NODE] = \
4088
        _GetWantedNodes(self, self.op.nodes)
4089
    else:
4090
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
4091

    
4092
  def Exec(self, feedback_fn):
4093
    """Computes the list of nodes and their attributes.
4094

4095
    """
4096
    self.nodes = self.glm.list_owned(locking.LEVEL_NODE)
4097

    
4098