Statistics
| Branch: | Tag: | Revision:

root / lib / cmdlib.py @ 2dad1652

History | View | Annotate | Download (439.2 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 LUClusterVerifyConfig.
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 (LUClusterVerifyConfig.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 (LUClusterVerifyConfig.ETYPE_WARNING, fnamemsg)
1283
  elif errcode == utils.CERT_ERROR:
1284
    return (LUClusterVerifyConfig.ETYPE_ERROR, fnamemsg)
1285

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

    
1288

    
1289
def _GetAllHypervisorParameters(cluster, instances):
1290
  """Compute the set of all hypervisor parameters.
1291

1292
  @type cluster: L{objects.Cluster}
1293
  @param cluster: the cluster object
1294
  @param instances: list of L{objects.Instance}
1295
  @param instances: additional instances from which to obtain parameters
1296
  @rtype: list of (origin, hypervisor, parameters)
1297
  @return: a list with all parameters found, indicating the hypervisor they
1298
       apply to, and the origin (can be "cluster", "os X", or "instance Y")
1299

1300
  """
1301
  hvp_data = []
1302

    
1303
  for hv_name in cluster.enabled_hypervisors:
1304
    hvp_data.append(("cluster", hv_name, cluster.GetHVDefaults(hv_name)))
1305

    
1306
  for os_name, os_hvp in cluster.os_hvp.items():
1307
    for hv_name, hv_params in os_hvp.items():
1308
      if hv_params:
1309
        full_params = cluster.GetHVDefaults(hv_name, os_name=os_name)
1310
        hvp_data.append(("os %s" % os_name, hv_name, full_params))
1311

    
1312
  # TODO: collapse identical parameter values in a single one
1313
  for instance in instances:
1314
    if instance.hvparams:
1315
      hvp_data.append(("instance %s" % instance.name, instance.hypervisor,
1316
                       cluster.FillHV(instance)))
1317

    
1318
  return hvp_data
1319

    
1320

    
1321
class _VerifyErrors(object):
1322
  """Mix-in for cluster/group verify LUs.
1323

1324
  It provides _Error and _ErrorIf, and updates the self.bad boolean. (Expects
1325
  self.op and self._feedback_fn to be available.)
1326

1327
  """
1328
  TCLUSTER = "cluster"
1329
  TNODE = "node"
1330
  TINSTANCE = "instance"
1331

    
1332
  ECLUSTERCFG = (TCLUSTER, "ECLUSTERCFG")
1333
  ECLUSTERCERT = (TCLUSTER, "ECLUSTERCERT")
1334
  ECLUSTERFILECHECK = (TCLUSTER, "ECLUSTERFILECHECK")
1335
  EINSTANCEBADNODE = (TINSTANCE, "EINSTANCEBADNODE")
1336
  EINSTANCEDOWN = (TINSTANCE, "EINSTANCEDOWN")
1337
  EINSTANCELAYOUT = (TINSTANCE, "EINSTANCELAYOUT")
1338
  EINSTANCEMISSINGDISK = (TINSTANCE, "EINSTANCEMISSINGDISK")
1339
  EINSTANCEFAULTYDISK = (TINSTANCE, "EINSTANCEFAULTYDISK")
1340
  EINSTANCEWRONGNODE = (TINSTANCE, "EINSTANCEWRONGNODE")
1341
  EINSTANCESPLITGROUPS = (TINSTANCE, "EINSTANCESPLITGROUPS")
1342
  ENODEDRBD = (TNODE, "ENODEDRBD")
1343
  ENODEDRBDHELPER = (TNODE, "ENODEDRBDHELPER")
1344
  ENODEFILECHECK = (TNODE, "ENODEFILECHECK")
1345
  ENODEHOOKS = (TNODE, "ENODEHOOKS")
1346
  ENODEHV = (TNODE, "ENODEHV")
1347
  ENODELVM = (TNODE, "ENODELVM")
1348
  ENODEN1 = (TNODE, "ENODEN1")
1349
  ENODENET = (TNODE, "ENODENET")
1350
  ENODEOS = (TNODE, "ENODEOS")
1351
  ENODEORPHANINSTANCE = (TNODE, "ENODEORPHANINSTANCE")
1352
  ENODEORPHANLV = (TNODE, "ENODEORPHANLV")
1353
  ENODERPC = (TNODE, "ENODERPC")
1354
  ENODESSH = (TNODE, "ENODESSH")
1355
  ENODEVERSION = (TNODE, "ENODEVERSION")
1356
  ENODESETUP = (TNODE, "ENODESETUP")
1357
  ENODETIME = (TNODE, "ENODETIME")
1358
  ENODEOOBPATH = (TNODE, "ENODEOOBPATH")
1359

    
1360
  ETYPE_FIELD = "code"
1361
  ETYPE_ERROR = "ERROR"
1362
  ETYPE_WARNING = "WARNING"
1363

    
1364
  def _Error(self, ecode, item, msg, *args, **kwargs):
1365
    """Format an error message.
1366

1367
    Based on the opcode's error_codes parameter, either format a
1368
    parseable error code, or a simpler error string.
1369

1370
    This must be called only from Exec and functions called from Exec.
1371

1372
    """
1373
    ltype = kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR)
1374
    itype, etxt = ecode
1375
    # first complete the msg
1376
    if args:
1377
      msg = msg % args
1378
    # then format the whole message
1379
    if self.op.error_codes: # This is a mix-in. pylint: disable-msg=E1101
1380
      msg = "%s:%s:%s:%s:%s" % (ltype, etxt, itype, item, msg)
1381
    else:
1382
      if item:
1383
        item = " " + item
1384
      else:
1385
        item = ""
1386
      msg = "%s: %s%s: %s" % (ltype, itype, item, msg)
1387
    # and finally report it via the feedback_fn
1388
    self._feedback_fn("  - %s" % msg) # Mix-in. pylint: disable-msg=E1101
1389

    
1390
  def _ErrorIf(self, cond, *args, **kwargs):
1391
    """Log an error message if the passed condition is True.
1392

1393
    """
1394
    cond = (bool(cond)
1395
            or self.op.debug_simulate_errors) # pylint: disable-msg=E1101
1396
    if cond:
1397
      self._Error(*args, **kwargs)
1398
    # do not mark the operation as failed for WARN cases only
1399
    if kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR) == self.ETYPE_ERROR:
1400
      self.bad = self.bad or cond
1401

    
1402

    
1403
class LUClusterVerifyConfig(NoHooksLU, _VerifyErrors):
1404
  """Verifies the cluster config.
1405

1406
  """
1407

    
1408
  REQ_BGL = False
1409

    
1410
  def _VerifyHVP(self, hvp_data):
1411
    """Verifies locally the syntax of the hypervisor parameters.
1412

1413
    """
1414
    for item, hv_name, hv_params in hvp_data:
1415
      msg = ("hypervisor %s parameters syntax check (source %s): %%s" %
1416
             (item, hv_name))
1417
      try:
1418
        hv_class = hypervisor.GetHypervisor(hv_name)
1419
        utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
1420
        hv_class.CheckParameterSyntax(hv_params)
1421
      except errors.GenericError, err:
1422
        self._ErrorIf(True, self.ECLUSTERCFG, None, msg % str(err))
1423

    
1424
  def ExpandNames(self):
1425
    self.all_group_info = self.cfg.GetAllNodeGroupsInfo()
1426
    self.all_inst_info = self.cfg.GetAllInstancesInfo()
1427
    self.needed_locks = {}
1428

    
1429
  def Exec(self, feedback_fn):
1430
    """Verify integrity of cluster, performing various test on nodes.
1431

1432
    """
1433
    self.bad = False
1434
    self._feedback_fn = feedback_fn
1435

    
1436
    feedback_fn("* Verifying cluster config")
1437

    
1438
    for msg in self.cfg.VerifyConfig():
1439
      self._ErrorIf(True, self.ECLUSTERCFG, None, msg)
1440

    
1441
    feedback_fn("* Verifying cluster certificate files")
1442

    
1443
    for cert_filename in constants.ALL_CERT_FILES:
1444
      (errcode, msg) = _VerifyCertificate(cert_filename)
1445
      self._ErrorIf(errcode, self.ECLUSTERCERT, None, msg, code=errcode)
1446

    
1447
    feedback_fn("* Verifying hypervisor parameters")
1448

    
1449
    self._VerifyHVP(_GetAllHypervisorParameters(self.cfg.GetClusterInfo(),
1450
                                                self.all_inst_info.values()))
1451

    
1452
    return (not self.bad, [g.name for g in self.all_group_info.values()])
1453

    
1454

    
1455
class LUClusterVerifyGroup(LogicalUnit, _VerifyErrors):
1456
  """Verifies the status of a node group.
1457

1458
  """
1459

    
1460
  HPATH = "cluster-verify"
1461
  HTYPE = constants.HTYPE_CLUSTER
1462
  REQ_BGL = False
1463

    
1464
  _HOOKS_INDENT_RE = re.compile("^", re.M)
1465

    
1466
  class NodeImage(object):
1467
    """A class representing the logical and physical status of a node.
1468

1469
    @type name: string
1470
    @ivar name: the node name to which this object refers
1471
    @ivar volumes: a structure as returned from
1472
        L{ganeti.backend.GetVolumeList} (runtime)
1473
    @ivar instances: a list of running instances (runtime)
1474
    @ivar pinst: list of configured primary instances (config)
1475
    @ivar sinst: list of configured secondary instances (config)
1476
    @ivar sbp: dictionary of {primary-node: list of instances} for all
1477
        instances for which this node is secondary (config)
1478
    @ivar mfree: free memory, as reported by hypervisor (runtime)
1479
    @ivar dfree: free disk, as reported by the node (runtime)
1480
    @ivar offline: the offline status (config)
1481
    @type rpc_fail: boolean
1482
    @ivar rpc_fail: whether the RPC verify call was successfull (overall,
1483
        not whether the individual keys were correct) (runtime)
1484
    @type lvm_fail: boolean
1485
    @ivar lvm_fail: whether the RPC call didn't return valid LVM data
1486
    @type hyp_fail: boolean
1487
    @ivar hyp_fail: whether the RPC call didn't return the instance list
1488
    @type ghost: boolean
1489
    @ivar ghost: whether this is a known node or not (config)
1490
    @type os_fail: boolean
1491
    @ivar os_fail: whether the RPC call didn't return valid OS data
1492
    @type oslist: list
1493
    @ivar oslist: list of OSes as diagnosed by DiagnoseOS
1494
    @type vm_capable: boolean
1495
    @ivar vm_capable: whether the node can host instances
1496

1497
    """
1498
    def __init__(self, offline=False, name=None, vm_capable=True):
1499
      self.name = name
1500
      self.volumes = {}
1501
      self.instances = []
1502
      self.pinst = []
1503
      self.sinst = []
1504
      self.sbp = {}
1505
      self.mfree = 0
1506
      self.dfree = 0
1507
      self.offline = offline
1508
      self.vm_capable = vm_capable
1509
      self.rpc_fail = False
1510
      self.lvm_fail = False
1511
      self.hyp_fail = False
1512
      self.ghost = False
1513
      self.os_fail = False
1514
      self.oslist = {}
1515

    
1516
  def ExpandNames(self):
1517
    # This raises errors.OpPrereqError on its own:
1518
    self.group_uuid = self.cfg.LookupNodeGroup(self.op.group_name)
1519

    
1520
    all_node_info = self.cfg.GetAllNodesInfo()
1521
    all_inst_info = self.cfg.GetAllInstancesInfo()
1522

    
1523
    node_names = set(node.name
1524
                     for node in all_node_info.values()
1525
                     if node.group == self.group_uuid)
1526

    
1527
    inst_names = [inst.name
1528
                  for inst in all_inst_info.values()
1529
                  if inst.primary_node in node_names]
1530

    
1531
    self.needed_locks = {
1532
      locking.LEVEL_NODEGROUP: [self.group_uuid],
1533
      locking.LEVEL_NODE: list(node_names),
1534
      locking.LEVEL_INSTANCE: inst_names,
1535
    }
1536

    
1537
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
1538

    
1539
  def CheckPrereq(self):
1540
    self.all_node_info = self.cfg.GetAllNodesInfo()
1541
    self.all_inst_info = self.cfg.GetAllInstancesInfo()
1542

    
1543
    group_nodes = set(node.name
1544
                      for node in self.all_node_info.values()
1545
                      if node.group == self.group_uuid)
1546

    
1547
    group_instances = set(inst.name
1548
                          for inst in self.all_inst_info.values()
1549
                          if inst.primary_node in group_nodes)
1550

    
1551
    unlocked_nodes = \
1552
        group_nodes.difference(self.glm.list_owned(locking.LEVEL_NODE))
1553

    
1554
    unlocked_instances = \
1555
        group_instances.difference(self.glm.list_owned(locking.LEVEL_INSTANCE))
1556

    
1557
    if unlocked_nodes:
1558
      raise errors.OpPrereqError("missing lock for nodes: %s" %
1559
                                 utils.CommaJoin(unlocked_nodes))
1560

    
1561
    if unlocked_instances:
1562
      raise errors.OpPrereqError("missing lock for instances: %s" %
1563
                                 utils.CommaJoin(unlocked_instances))
1564

    
1565
    self.my_node_names = utils.NiceSort(group_nodes)
1566
    self.my_inst_names = utils.NiceSort(group_instances)
1567

    
1568
    self.my_node_info = dict((name, self.all_node_info[name])
1569
                             for name in self.my_node_names)
1570

    
1571
    self.my_inst_info = dict((name, self.all_inst_info[name])
1572
                             for name in self.my_inst_names)
1573

    
1574
  def _VerifyNode(self, ninfo, nresult):
1575
    """Perform some basic validation on data returned from a node.
1576

1577
      - check the result data structure is well formed and has all the
1578
        mandatory fields
1579
      - check ganeti version
1580

1581
    @type ninfo: L{objects.Node}
1582
    @param ninfo: the node to check
1583
    @param nresult: the results from the node
1584
    @rtype: boolean
1585
    @return: whether overall this call was successful (and we can expect
1586
         reasonable values in the respose)
1587

1588
    """
1589
    node = ninfo.name
1590
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1591

    
1592
    # main result, nresult should be a non-empty dict
1593
    test = not nresult or not isinstance(nresult, dict)
1594
    _ErrorIf(test, self.ENODERPC, node,
1595
                  "unable to verify node: no data returned")
1596
    if test:
1597
      return False
1598

    
1599
    # compares ganeti version
1600
    local_version = constants.PROTOCOL_VERSION
1601
    remote_version = nresult.get("version", None)
1602
    test = not (remote_version and
1603
                isinstance(remote_version, (list, tuple)) and
1604
                len(remote_version) == 2)
1605
    _ErrorIf(test, self.ENODERPC, node,
1606
             "connection to node returned invalid data")
1607
    if test:
1608
      return False
1609

    
1610
    test = local_version != remote_version[0]
1611
    _ErrorIf(test, self.ENODEVERSION, node,
1612
             "incompatible protocol versions: master %s,"
1613
             " node %s", local_version, remote_version[0])
1614
    if test:
1615
      return False
1616

    
1617
    # node seems compatible, we can actually try to look into its results
1618

    
1619
    # full package version
1620
    self._ErrorIf(constants.RELEASE_VERSION != remote_version[1],
1621
                  self.ENODEVERSION, node,
1622
                  "software version mismatch: master %s, node %s",
1623
                  constants.RELEASE_VERSION, remote_version[1],
1624
                  code=self.ETYPE_WARNING)
1625

    
1626
    hyp_result = nresult.get(constants.NV_HYPERVISOR, None)
1627
    if ninfo.vm_capable and isinstance(hyp_result, dict):
1628
      for hv_name, hv_result in hyp_result.iteritems():
1629
        test = hv_result is not None
1630
        _ErrorIf(test, self.ENODEHV, node,
1631
                 "hypervisor %s verify failure: '%s'", hv_name, hv_result)
1632

    
1633
    hvp_result = nresult.get(constants.NV_HVPARAMS, None)
1634
    if ninfo.vm_capable and isinstance(hvp_result, list):
1635
      for item, hv_name, hv_result in hvp_result:
1636
        _ErrorIf(True, self.ENODEHV, node,
1637
                 "hypervisor %s parameter verify failure (source %s): %s",
1638
                 hv_name, item, hv_result)
1639

    
1640
    test = nresult.get(constants.NV_NODESETUP,
1641
                       ["Missing NODESETUP results"])
1642
    _ErrorIf(test, self.ENODESETUP, node, "node setup error: %s",
1643
             "; ".join(test))
1644

    
1645
    return True
1646

    
1647
  def _VerifyNodeTime(self, ninfo, nresult,
1648
                      nvinfo_starttime, nvinfo_endtime):
1649
    """Check the node time.
1650

1651
    @type ninfo: L{objects.Node}
1652
    @param ninfo: the node to check
1653
    @param nresult: the remote results for the node
1654
    @param nvinfo_starttime: the start time of the RPC call
1655
    @param nvinfo_endtime: the end time of the RPC call
1656

1657
    """
1658
    node = ninfo.name
1659
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1660

    
1661
    ntime = nresult.get(constants.NV_TIME, None)
1662
    try:
1663
      ntime_merged = utils.MergeTime(ntime)
1664
    except (ValueError, TypeError):
1665
      _ErrorIf(True, self.ENODETIME, node, "Node returned invalid time")
1666
      return
1667

    
1668
    if ntime_merged < (nvinfo_starttime - constants.NODE_MAX_CLOCK_SKEW):
1669
      ntime_diff = "%.01fs" % abs(nvinfo_starttime - ntime_merged)
1670
    elif ntime_merged > (nvinfo_endtime + constants.NODE_MAX_CLOCK_SKEW):
1671
      ntime_diff = "%.01fs" % abs(ntime_merged - nvinfo_endtime)
1672
    else:
1673
      ntime_diff = None
1674

    
1675
    _ErrorIf(ntime_diff is not None, self.ENODETIME, node,
1676
             "Node time diverges by at least %s from master node time",
1677
             ntime_diff)
1678

    
1679
  def _VerifyNodeLVM(self, ninfo, nresult, vg_name):
1680
    """Check the node LVM results.
1681

1682
    @type ninfo: L{objects.Node}
1683
    @param ninfo: the node to check
1684
    @param nresult: the remote results for the node
1685
    @param vg_name: the configured VG name
1686

1687
    """
1688
    if vg_name is None:
1689
      return
1690

    
1691
    node = ninfo.name
1692
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1693

    
1694
    # checks vg existence and size > 20G
1695
    vglist = nresult.get(constants.NV_VGLIST, None)
1696
    test = not vglist
1697
    _ErrorIf(test, self.ENODELVM, node, "unable to check volume groups")
1698
    if not test:
1699
      vgstatus = utils.CheckVolumeGroupSize(vglist, vg_name,
1700
                                            constants.MIN_VG_SIZE)
1701
      _ErrorIf(vgstatus, self.ENODELVM, node, vgstatus)
1702

    
1703
    # check pv names
1704
    pvlist = nresult.get(constants.NV_PVLIST, None)
1705
    test = pvlist is None
1706
    _ErrorIf(test, self.ENODELVM, node, "Can't get PV list from node")
1707
    if not test:
1708
      # check that ':' is not present in PV names, since it's a
1709
      # special character for lvcreate (denotes the range of PEs to
1710
      # use on the PV)
1711
      for _, pvname, owner_vg in pvlist:
1712
        test = ":" in pvname
1713
        _ErrorIf(test, self.ENODELVM, node, "Invalid character ':' in PV"
1714
                 " '%s' of VG '%s'", pvname, owner_vg)
1715

    
1716
  def _VerifyNodeBridges(self, ninfo, nresult, bridges):
1717
    """Check the node bridges.
1718

1719
    @type ninfo: L{objects.Node}
1720
    @param ninfo: the node to check
1721
    @param nresult: the remote results for the node
1722
    @param bridges: the expected list of bridges
1723

1724
    """
1725
    if not bridges:
1726
      return
1727

    
1728
    node = ninfo.name
1729
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1730

    
1731
    missing = nresult.get(constants.NV_BRIDGES, None)
1732
    test = not isinstance(missing, list)
1733
    _ErrorIf(test, self.ENODENET, node,
1734
             "did not return valid bridge information")
1735
    if not test:
1736
      _ErrorIf(bool(missing), self.ENODENET, node, "missing bridges: %s" %
1737
               utils.CommaJoin(sorted(missing)))
1738

    
1739
  def _VerifyNodeNetwork(self, ninfo, nresult):
1740
    """Check the node network connectivity results.
1741

1742
    @type ninfo: L{objects.Node}
1743
    @param ninfo: the node to check
1744
    @param nresult: the remote results for the node
1745

1746
    """
1747
    node = ninfo.name
1748
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1749

    
1750
    test = constants.NV_NODELIST not in nresult
1751
    _ErrorIf(test, self.ENODESSH, node,
1752
             "node hasn't returned node ssh connectivity data")
1753
    if not test:
1754
      if nresult[constants.NV_NODELIST]:
1755
        for a_node, a_msg in nresult[constants.NV_NODELIST].items():
1756
          _ErrorIf(True, self.ENODESSH, node,
1757
                   "ssh communication with node '%s': %s", a_node, a_msg)
1758

    
1759
    test = constants.NV_NODENETTEST not in nresult
1760
    _ErrorIf(test, self.ENODENET, node,
1761
             "node hasn't returned node tcp connectivity data")
1762
    if not test:
1763
      if nresult[constants.NV_NODENETTEST]:
1764
        nlist = utils.NiceSort(nresult[constants.NV_NODENETTEST].keys())
1765
        for anode in nlist:
1766
          _ErrorIf(True, self.ENODENET, node,
1767
                   "tcp communication with node '%s': %s",
1768
                   anode, nresult[constants.NV_NODENETTEST][anode])
1769

    
1770
    test = constants.NV_MASTERIP not in nresult
1771
    _ErrorIf(test, self.ENODENET, node,
1772
             "node hasn't returned node master IP reachability data")
1773
    if not test:
1774
      if not nresult[constants.NV_MASTERIP]:
1775
        if node == self.master_node:
1776
          msg = "the master node cannot reach the master IP (not configured?)"
1777
        else:
1778
          msg = "cannot reach the master IP"
1779
        _ErrorIf(True, self.ENODENET, node, msg)
1780

    
1781
  def _VerifyInstance(self, instance, instanceconfig, node_image,
1782
                      diskstatus):
1783
    """Verify an instance.
1784

1785
    This function checks to see if the required block devices are
1786
    available on the instance's node.
1787

1788
    """
1789
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1790
    node_current = instanceconfig.primary_node
1791

    
1792
    node_vol_should = {}
1793
    instanceconfig.MapLVsByNode(node_vol_should)
1794

    
1795
    for node in node_vol_should:
1796
      n_img = node_image[node]
1797
      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
1798
        # ignore missing volumes on offline or broken nodes
1799
        continue
1800
      for volume in node_vol_should[node]:
1801
        test = volume not in n_img.volumes
1802
        _ErrorIf(test, self.EINSTANCEMISSINGDISK, instance,
1803
                 "volume %s missing on node %s", volume, node)
1804

    
1805
    if instanceconfig.admin_up:
1806
      pri_img = node_image[node_current]
1807
      test = instance not in pri_img.instances and not pri_img.offline
1808
      _ErrorIf(test, self.EINSTANCEDOWN, instance,
1809
               "instance not running on its primary node %s",
1810
               node_current)
1811

    
1812
    diskdata = [(nname, success, status, idx)
1813
                for (nname, disks) in diskstatus.items()
1814
                for idx, (success, status) in enumerate(disks)]
1815

    
1816
    for nname, success, bdev_status, idx in diskdata:
1817
      # the 'ghost node' construction in Exec() ensures that we have a
1818
      # node here
1819
      snode = node_image[nname]
1820
      bad_snode = snode.ghost or snode.offline
1821
      _ErrorIf(instanceconfig.admin_up and not success and not bad_snode,
1822
               self.EINSTANCEFAULTYDISK, instance,
1823
               "couldn't retrieve status for disk/%s on %s: %s",
1824
               idx, nname, bdev_status)
1825
      _ErrorIf((instanceconfig.admin_up and success and
1826
                bdev_status.ldisk_status == constants.LDS_FAULTY),
1827
               self.EINSTANCEFAULTYDISK, instance,
1828
               "disk/%s on %s is faulty", idx, nname)
1829

    
1830
  def _VerifyOrphanVolumes(self, node_vol_should, node_image, reserved):
1831
    """Verify if there are any unknown volumes in the cluster.
1832

1833
    The .os, .swap and backup volumes are ignored. All other volumes are
1834
    reported as unknown.
1835

1836
    @type reserved: L{ganeti.utils.FieldSet}
1837
    @param reserved: a FieldSet of reserved volume names
1838

1839
    """
1840
    for node, n_img in node_image.items():
1841
      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
1842
        # skip non-healthy nodes
1843
        continue
1844
      for volume in n_img.volumes:
1845
        test = ((node not in node_vol_should or
1846
                volume not in node_vol_should[node]) and
1847
                not reserved.Matches(volume))
1848
        self._ErrorIf(test, self.ENODEORPHANLV, node,
1849
                      "volume %s is unknown", volume)
1850

    
1851
  def _VerifyNPlusOneMemory(self, node_image, instance_cfg):
1852
    """Verify N+1 Memory Resilience.
1853

1854
    Check that if one single node dies we can still start all the
1855
    instances it was primary for.
1856

1857
    """
1858
    cluster_info = self.cfg.GetClusterInfo()
1859
    for node, n_img in node_image.items():
1860
      # This code checks that every node which is now listed as
1861
      # secondary has enough memory to host all instances it is
1862
      # supposed to should a single other node in the cluster fail.
1863
      # FIXME: not ready for failover to an arbitrary node
1864
      # FIXME: does not support file-backed instances
1865
      # WARNING: we currently take into account down instances as well
1866
      # as up ones, considering that even if they're down someone
1867
      # might want to start them even in the event of a node failure.
1868
      if n_img.offline:
1869
        # we're skipping offline nodes from the N+1 warning, since
1870
        # most likely we don't have good memory infromation from them;
1871
        # we already list instances living on such nodes, and that's
1872
        # enough warning
1873
        continue
1874
      for prinode, instances in n_img.sbp.items():
1875
        needed_mem = 0
1876
        for instance in instances:
1877
          bep = cluster_info.FillBE(instance_cfg[instance])
1878
          if bep[constants.BE_AUTO_BALANCE]:
1879
            needed_mem += bep[constants.BE_MEMORY]
1880
        test = n_img.mfree < needed_mem
1881
        self._ErrorIf(test, self.ENODEN1, node,
1882
                      "not enough memory to accomodate instance failovers"
1883
                      " should node %s fail (%dMiB needed, %dMiB available)",
1884
                      prinode, needed_mem, n_img.mfree)
1885

    
1886
  @classmethod
1887
  def _VerifyFiles(cls, errorif, nodeinfo, master_node, all_nvinfo,
1888
                   (files_all, files_all_opt, files_mc, files_vm)):
1889
    """Verifies file checksums collected from all nodes.
1890

1891
    @param errorif: Callback for reporting errors
1892
    @param nodeinfo: List of L{objects.Node} objects
1893
    @param master_node: Name of master node
1894
    @param all_nvinfo: RPC results
1895

1896
    """
1897
    node_names = frozenset(node.name for node in nodeinfo)
1898

    
1899
    assert master_node in node_names
1900
    assert (len(files_all | files_all_opt | files_mc | files_vm) ==
1901
            sum(map(len, [files_all, files_all_opt, files_mc, files_vm]))), \
1902
           "Found file listed in more than one file list"
1903

    
1904
    # Define functions determining which nodes to consider for a file
1905
    file2nodefn = dict([(filename, fn)
1906
      for (files, fn) in [(files_all, None),
1907
                          (files_all_opt, None),
1908
                          (files_mc, lambda node: (node.master_candidate or
1909
                                                   node.name == master_node)),
1910
                          (files_vm, lambda node: node.vm_capable)]
1911
      for filename in files])
1912

    
1913
    fileinfo = dict((filename, {}) for filename in file2nodefn.keys())
1914

    
1915
    for node in nodeinfo:
1916
      nresult = all_nvinfo[node.name]
1917

    
1918
      if nresult.fail_msg or not nresult.payload:
1919
        node_files = None
1920
      else:
1921
        node_files = nresult.payload.get(constants.NV_FILELIST, None)
1922

    
1923
      test = not (node_files and isinstance(node_files, dict))
1924
      errorif(test, cls.ENODEFILECHECK, node.name,
1925
              "Node did not return file checksum data")
1926
      if test:
1927
        continue
1928

    
1929
      for (filename, checksum) in node_files.items():
1930
        # Check if the file should be considered for a node
1931
        fn = file2nodefn[filename]
1932
        if fn is None or fn(node):
1933
          fileinfo[filename].setdefault(checksum, set()).add(node.name)
1934

    
1935
    for (filename, checksums) in fileinfo.items():
1936
      assert compat.all(len(i) > 10 for i in checksums), "Invalid checksum"
1937

    
1938
      # Nodes having the file
1939
      with_file = frozenset(node_name
1940
                            for nodes in fileinfo[filename].values()
1941
                            for node_name in nodes)
1942

    
1943
      # Nodes missing file
1944
      missing_file = node_names - with_file
1945

    
1946
      if filename in files_all_opt:
1947
        # All or no nodes
1948
        errorif(missing_file and missing_file != node_names,
1949
                cls.ECLUSTERFILECHECK, None,
1950
                "File %s is optional, but it must exist on all or no nodes (not"
1951
                " found on %s)",
1952
                filename, utils.CommaJoin(utils.NiceSort(missing_file)))
1953
      else:
1954
        errorif(missing_file, cls.ECLUSTERFILECHECK, None,
1955
                "File %s is missing from node(s) %s", filename,
1956
                utils.CommaJoin(utils.NiceSort(missing_file)))
1957

    
1958
      # See if there are multiple versions of the file
1959
      test = len(checksums) > 1
1960
      if test:
1961
        variants = ["variant %s on %s" %
1962
                    (idx + 1, utils.CommaJoin(utils.NiceSort(nodes)))
1963
                    for (idx, (checksum, nodes)) in
1964
                      enumerate(sorted(checksums.items()))]
1965
      else:
1966
        variants = []
1967

    
1968
      errorif(test, cls.ECLUSTERFILECHECK, None,
1969
              "File %s found with %s different checksums (%s)",
1970
              filename, len(checksums), "; ".join(variants))
1971

    
1972
  def _VerifyNodeDrbd(self, ninfo, nresult, instanceinfo, drbd_helper,
1973
                      drbd_map):
1974
    """Verifies and the node DRBD status.
1975

1976
    @type ninfo: L{objects.Node}
1977
    @param ninfo: the node to check
1978
    @param nresult: the remote results for the node
1979
    @param instanceinfo: the dict of instances
1980
    @param drbd_helper: the configured DRBD usermode helper
1981
    @param drbd_map: the DRBD map as returned by
1982
        L{ganeti.config.ConfigWriter.ComputeDRBDMap}
1983

1984
    """
1985
    node = ninfo.name
1986
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1987

    
1988
    if drbd_helper:
1989
      helper_result = nresult.get(constants.NV_DRBDHELPER, None)
1990
      test = (helper_result == None)
1991
      _ErrorIf(test, self.ENODEDRBDHELPER, node,
1992
               "no drbd usermode helper returned")
1993
      if helper_result:
1994
        status, payload = helper_result
1995
        test = not status
1996
        _ErrorIf(test, self.ENODEDRBDHELPER, node,
1997
                 "drbd usermode helper check unsuccessful: %s", payload)
1998
        test = status and (payload != drbd_helper)
1999
        _ErrorIf(test, self.ENODEDRBDHELPER, node,
2000
                 "wrong drbd usermode helper: %s", payload)
2001

    
2002
    # compute the DRBD minors
2003
    node_drbd = {}
2004
    for minor, instance in drbd_map[node].items():
2005
      test = instance not in instanceinfo
2006
      _ErrorIf(test, self.ECLUSTERCFG, None,
2007
               "ghost instance '%s' in temporary DRBD map", instance)
2008
        # ghost instance should not be running, but otherwise we
2009
        # don't give double warnings (both ghost instance and
2010
        # unallocated minor in use)
2011
      if test:
2012
        node_drbd[minor] = (instance, False)
2013
      else:
2014
        instance = instanceinfo[instance]
2015
        node_drbd[minor] = (instance.name, instance.admin_up)
2016

    
2017
    # and now check them
2018
    used_minors = nresult.get(constants.NV_DRBDLIST, [])
2019
    test = not isinstance(used_minors, (tuple, list))
2020
    _ErrorIf(test, self.ENODEDRBD, node,
2021
             "cannot parse drbd status file: %s", str(used_minors))
2022
    if test:
2023
      # we cannot check drbd status
2024
      return
2025

    
2026
    for minor, (iname, must_exist) in node_drbd.items():
2027
      test = minor not in used_minors and must_exist
2028
      _ErrorIf(test, self.ENODEDRBD, node,
2029
               "drbd minor %d of instance %s is not active", minor, iname)
2030
    for minor in used_minors:
2031
      test = minor not in node_drbd
2032
      _ErrorIf(test, self.ENODEDRBD, node,
2033
               "unallocated drbd minor %d is in use", minor)
2034

    
2035
  def _UpdateNodeOS(self, ninfo, nresult, nimg):
2036
    """Builds the node OS structures.
2037

2038
    @type ninfo: L{objects.Node}
2039
    @param ninfo: the node to check
2040
    @param nresult: the remote results for the node
2041
    @param nimg: the node image object
2042

2043
    """
2044
    node = ninfo.name
2045
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2046

    
2047
    remote_os = nresult.get(constants.NV_OSLIST, None)
2048
    test = (not isinstance(remote_os, list) or
2049
            not compat.all(isinstance(v, list) and len(v) == 7
2050
                           for v in remote_os))
2051

    
2052
    _ErrorIf(test, self.ENODEOS, node,
2053
             "node hasn't returned valid OS data")
2054

    
2055
    nimg.os_fail = test
2056

    
2057
    if test:
2058
      return
2059

    
2060
    os_dict = {}
2061

    
2062
    for (name, os_path, status, diagnose,
2063
         variants, parameters, api_ver) in nresult[constants.NV_OSLIST]:
2064

    
2065
      if name not in os_dict:
2066
        os_dict[name] = []
2067

    
2068
      # parameters is a list of lists instead of list of tuples due to
2069
      # JSON lacking a real tuple type, fix it:
2070
      parameters = [tuple(v) for v in parameters]
2071
      os_dict[name].append((os_path, status, diagnose,
2072
                            set(variants), set(parameters), set(api_ver)))
2073

    
2074
    nimg.oslist = os_dict
2075

    
2076
  def _VerifyNodeOS(self, ninfo, nimg, base):
2077
    """Verifies the node OS list.
2078

2079
    @type ninfo: L{objects.Node}
2080
    @param ninfo: the node to check
2081
    @param nimg: the node image object
2082
    @param base: the 'template' node we match against (e.g. from the master)
2083

2084
    """
2085
    node = ninfo.name
2086
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2087

    
2088
    assert not nimg.os_fail, "Entered _VerifyNodeOS with failed OS rpc?"
2089

    
2090
    beautify_params = lambda l: ["%s: %s" % (k, v) for (k, v) in l]
2091
    for os_name, os_data in nimg.oslist.items():
2092
      assert os_data, "Empty OS status for OS %s?!" % os_name
2093
      f_path, f_status, f_diag, f_var, f_param, f_api = os_data[0]
2094
      _ErrorIf(not f_status, self.ENODEOS, node,
2095
               "Invalid OS %s (located at %s): %s", os_name, f_path, f_diag)
2096
      _ErrorIf(len(os_data) > 1, self.ENODEOS, node,
2097
               "OS '%s' has multiple entries (first one shadows the rest): %s",
2098
               os_name, utils.CommaJoin([v[0] for v in os_data]))
2099
      # this will catched in backend too
2100
      _ErrorIf(compat.any(v >= constants.OS_API_V15 for v in f_api)
2101
               and not f_var, self.ENODEOS, node,
2102
               "OS %s with API at least %d does not declare any variant",
2103
               os_name, constants.OS_API_V15)
2104
      # comparisons with the 'base' image
2105
      test = os_name not in base.oslist
2106
      _ErrorIf(test, self.ENODEOS, node,
2107
               "Extra OS %s not present on reference node (%s)",
2108
               os_name, base.name)
2109
      if test:
2110
        continue
2111
      assert base.oslist[os_name], "Base node has empty OS status?"
2112
      _, b_status, _, b_var, b_param, b_api = base.oslist[os_name][0]
2113
      if not b_status:
2114
        # base OS is invalid, skipping
2115
        continue
2116
      for kind, a, b in [("API version", f_api, b_api),
2117
                         ("variants list", f_var, b_var),
2118
                         ("parameters", beautify_params(f_param),
2119
                          beautify_params(b_param))]:
2120
        _ErrorIf(a != b, self.ENODEOS, node,
2121
                 "OS %s for %s differs from reference node %s: [%s] vs. [%s]",
2122
                 kind, os_name, base.name,
2123
                 utils.CommaJoin(sorted(a)), utils.CommaJoin(sorted(b)))
2124

    
2125
    # check any missing OSes
2126
    missing = set(base.oslist.keys()).difference(nimg.oslist.keys())
2127
    _ErrorIf(missing, self.ENODEOS, node,
2128
             "OSes present on reference node %s but missing on this node: %s",
2129
             base.name, utils.CommaJoin(missing))
2130

    
2131
  def _VerifyOob(self, ninfo, nresult):
2132
    """Verifies out of band functionality of a node.
2133

2134
    @type ninfo: L{objects.Node}
2135
    @param ninfo: the node to check
2136
    @param nresult: the remote results for the node
2137

2138
    """
2139
    node = ninfo.name
2140
    # We just have to verify the paths on master and/or master candidates
2141
    # as the oob helper is invoked on the master
2142
    if ((ninfo.master_candidate or ninfo.master_capable) and
2143
        constants.NV_OOB_PATHS in nresult):
2144
      for path_result in nresult[constants.NV_OOB_PATHS]:
2145
        self._ErrorIf(path_result, self.ENODEOOBPATH, node, path_result)
2146

    
2147
  def _UpdateNodeVolumes(self, ninfo, nresult, nimg, vg_name):
2148
    """Verifies and updates the node volume data.
2149

2150
    This function will update a L{NodeImage}'s internal structures
2151
    with data from the remote call.
2152

2153
    @type ninfo: L{objects.Node}
2154
    @param ninfo: the node to check
2155
    @param nresult: the remote results for the node
2156
    @param nimg: the node image object
2157
    @param vg_name: the configured VG name
2158

2159
    """
2160
    node = ninfo.name
2161
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2162

    
2163
    nimg.lvm_fail = True
2164
    lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")
2165
    if vg_name is None:
2166
      pass
2167
    elif isinstance(lvdata, basestring):
2168
      _ErrorIf(True, self.ENODELVM, node, "LVM problem on node: %s",
2169
               utils.SafeEncode(lvdata))
2170
    elif not isinstance(lvdata, dict):
2171
      _ErrorIf(True, self.ENODELVM, node, "rpc call to node failed (lvlist)")
2172
    else:
2173
      nimg.volumes = lvdata
2174
      nimg.lvm_fail = False
2175

    
2176
  def _UpdateNodeInstances(self, ninfo, nresult, nimg):
2177
    """Verifies and updates the node instance list.
2178

2179
    If the listing was successful, then updates this node's instance
2180
    list. Otherwise, it marks the RPC call as failed for the instance
2181
    list key.
2182

2183
    @type ninfo: L{objects.Node}
2184
    @param ninfo: the node to check
2185
    @param nresult: the remote results for the node
2186
    @param nimg: the node image object
2187

2188
    """
2189
    idata = nresult.get(constants.NV_INSTANCELIST, None)
2190
    test = not isinstance(idata, list)
2191
    self._ErrorIf(test, self.ENODEHV, ninfo.name, "rpc call to node failed"
2192
                  " (instancelist): %s", utils.SafeEncode(str(idata)))
2193
    if test:
2194
      nimg.hyp_fail = True
2195
    else:
2196
      nimg.instances = idata
2197

    
2198
  def _UpdateNodeInfo(self, ninfo, nresult, nimg, vg_name):
2199
    """Verifies and computes a node information map
2200

2201
    @type ninfo: L{objects.Node}
2202
    @param ninfo: the node to check
2203
    @param nresult: the remote results for the node
2204
    @param nimg: the node image object
2205
    @param vg_name: the configured VG name
2206

2207
    """
2208
    node = ninfo.name
2209
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2210

    
2211
    # try to read free memory (from the hypervisor)
2212
    hv_info = nresult.get(constants.NV_HVINFO, None)
2213
    test = not isinstance(hv_info, dict) or "memory_free" not in hv_info
2214
    _ErrorIf(test, self.ENODEHV, node, "rpc call to node failed (hvinfo)")
2215
    if not test:
2216
      try:
2217
        nimg.mfree = int(hv_info["memory_free"])
2218
      except (ValueError, TypeError):
2219
        _ErrorIf(True, self.ENODERPC, node,
2220
                 "node returned invalid nodeinfo, check hypervisor")
2221

    
2222
    # FIXME: devise a free space model for file based instances as well
2223
    if vg_name is not None:
2224
      test = (constants.NV_VGLIST not in nresult or
2225
              vg_name not in nresult[constants.NV_VGLIST])
2226
      _ErrorIf(test, self.ENODELVM, node,
2227
               "node didn't return data for the volume group '%s'"
2228
               " - it is either missing or broken", vg_name)
2229
      if not test:
2230
        try:
2231
          nimg.dfree = int(nresult[constants.NV_VGLIST][vg_name])
2232
        except (ValueError, TypeError):
2233
          _ErrorIf(True, self.ENODERPC, node,
2234
                   "node returned invalid LVM info, check LVM status")
2235

    
2236
  def _CollectDiskInfo(self, nodelist, node_image, instanceinfo):
2237
    """Gets per-disk status information for all instances.
2238

2239
    @type nodelist: list of strings
2240
    @param nodelist: Node names
2241
    @type node_image: dict of (name, L{objects.Node})
2242
    @param node_image: Node objects
2243
    @type instanceinfo: dict of (name, L{objects.Instance})
2244
    @param instanceinfo: Instance objects
2245
    @rtype: {instance: {node: [(succes, payload)]}}
2246
    @return: a dictionary of per-instance dictionaries with nodes as
2247
        keys and disk information as values; the disk information is a
2248
        list of tuples (success, payload)
2249

2250
    """
2251
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2252

    
2253
    node_disks = {}
2254
    node_disks_devonly = {}
2255
    diskless_instances = set()
2256
    diskless = constants.DT_DISKLESS
2257

    
2258
    for nname in nodelist:
2259
      node_instances = list(itertools.chain(node_image[nname].pinst,
2260
                                            node_image[nname].sinst))
2261
      diskless_instances.update(inst for inst in node_instances
2262
                                if instanceinfo[inst].disk_template == diskless)
2263
      disks = [(inst, disk)
2264
               for inst in node_instances
2265
               for disk in instanceinfo[inst].disks]
2266

    
2267
      if not disks:
2268
        # No need to collect data
2269
        continue
2270

    
2271
      node_disks[nname] = disks
2272

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

    
2277
      for dev in devonly:
2278
        self.cfg.SetDiskID(dev, nname)
2279

    
2280
      node_disks_devonly[nname] = devonly
2281

    
2282
    assert len(node_disks) == len(node_disks_devonly)
2283

    
2284
    # Collect data from all nodes with disks
2285
    result = self.rpc.call_blockdev_getmirrorstatus_multi(node_disks.keys(),
2286
                                                          node_disks_devonly)
2287

    
2288
    assert len(result) == len(node_disks)
2289

    
2290
    instdisk = {}
2291

    
2292
    for (nname, nres) in result.items():
2293
      disks = node_disks[nname]
2294

    
2295
      if nres.offline:
2296
        # No data from this node
2297
        data = len(disks) * [(False, "node offline")]
2298
      else:
2299
        msg = nres.fail_msg
2300
        _ErrorIf(msg, self.ENODERPC, nname,
2301
                 "while getting disk information: %s", msg)
2302
        if msg:
2303
          # No data from this node
2304
          data = len(disks) * [(False, msg)]
2305
        else:
2306
          data = []
2307
          for idx, i in enumerate(nres.payload):
2308
            if isinstance(i, (tuple, list)) and len(i) == 2:
2309
              data.append(i)
2310
            else:
2311
              logging.warning("Invalid result from node %s, entry %d: %s",
2312
                              nname, idx, i)
2313
              data.append((False, "Invalid result from the remote node"))
2314

    
2315
      for ((inst, _), status) in zip(disks, data):
2316
        instdisk.setdefault(inst, {}).setdefault(nname, []).append(status)
2317

    
2318
    # Add empty entries for diskless instances.
2319
    for inst in diskless_instances:
2320
      assert inst not in instdisk
2321
      instdisk[inst] = {}
2322

    
2323
    assert compat.all(len(statuses) == len(instanceinfo[inst].disks) and
2324
                      len(nnames) <= len(instanceinfo[inst].all_nodes) and
2325
                      compat.all(isinstance(s, (tuple, list)) and
2326
                                 len(s) == 2 for s in statuses)
2327
                      for inst, nnames in instdisk.items()
2328
                      for nname, statuses in nnames.items())
2329
    assert set(instdisk) == set(instanceinfo), "instdisk consistency failure"
2330

    
2331
    return instdisk
2332

    
2333
  def BuildHooksEnv(self):
2334
    """Build hooks env.
2335

2336
    Cluster-Verify hooks just ran in the post phase and their failure makes
2337
    the output be logged in the verify output and the verification to fail.
2338

2339
    """
2340
    env = {
2341
      "CLUSTER_TAGS": " ".join(self.cfg.GetClusterInfo().GetTags())
2342
      }
2343

    
2344
    env.update(("NODE_TAGS_%s" % node.name, " ".join(node.GetTags()))
2345
               for node in self.my_node_info.values())
2346

    
2347
    return env
2348

    
2349
  def BuildHooksNodes(self):
2350
    """Build hooks nodes.
2351

2352
    """
2353
    assert self.my_node_names, ("Node list not gathered,"
2354
      " has CheckPrereq been executed?")
2355
    return ([], self.my_node_names)
2356

    
2357
  def Exec(self, feedback_fn):
2358
    """Verify integrity of the node group, performing various test on nodes.
2359

2360
    """
2361
    # This method has too many local variables. pylint: disable-msg=R0914
2362
    self.bad = False
2363
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2364
    verbose = self.op.verbose
2365
    self._feedback_fn = feedback_fn
2366

    
2367
    vg_name = self.cfg.GetVGName()
2368
    drbd_helper = self.cfg.GetDRBDHelper()
2369
    cluster = self.cfg.GetClusterInfo()
2370
    groupinfo = self.cfg.GetAllNodeGroupsInfo()
2371
    hypervisors = cluster.enabled_hypervisors
2372
    node_data_list = [self.my_node_info[name] for name in self.my_node_names]
2373

    
2374
    i_non_redundant = [] # Non redundant instances
2375
    i_non_a_balanced = [] # Non auto-balanced instances
2376
    n_offline = 0 # Count of offline nodes
2377
    n_drained = 0 # Count of nodes being drained
2378
    node_vol_should = {}
2379

    
2380
    # FIXME: verify OS list
2381

    
2382
    # File verification
2383
    filemap = _ComputeAncillaryFiles(cluster, False)
2384

    
2385
    # do local checksums
2386
    master_node = self.master_node = self.cfg.GetMasterNode()
2387
    master_ip = self.cfg.GetMasterIP()
2388

    
2389
    feedback_fn("* Gathering data (%d nodes)" % len(self.my_node_names))
2390

    
2391
    # We will make nodes contact all nodes in their group, and one node from
2392
    # every other group.
2393
    # TODO: should it be a *random* node, different every time?
2394
    online_nodes = [node.name for node in node_data_list if not node.offline]
2395
    other_group_nodes = {}
2396

    
2397
    for name in sorted(self.all_node_info):
2398
      node = self.all_node_info[name]
2399
      if (node.group not in other_group_nodes
2400
          and node.group != self.group_uuid
2401
          and not node.offline):
2402
        other_group_nodes[node.group] = node.name
2403

    
2404
    node_verify_param = {
2405
      constants.NV_FILELIST:
2406
        utils.UniqueSequence(filename
2407
                             for files in filemap
2408
                             for filename in files),
2409
      constants.NV_NODELIST: online_nodes + other_group_nodes.values(),
2410
      constants.NV_HYPERVISOR: hypervisors,
2411
      constants.NV_HVPARAMS:
2412
        _GetAllHypervisorParameters(cluster, self.all_inst_info.values()),
2413
      constants.NV_NODENETTEST: [(node.name, node.primary_ip, node.secondary_ip)
2414
                                 for node in node_data_list
2415
                                 if not node.offline],
2416
      constants.NV_INSTANCELIST: hypervisors,
2417
      constants.NV_VERSION: None,
2418
      constants.NV_HVINFO: self.cfg.GetHypervisorType(),
2419
      constants.NV_NODESETUP: None,
2420
      constants.NV_TIME: None,
2421
      constants.NV_MASTERIP: (master_node, master_ip),
2422
      constants.NV_OSLIST: None,
2423
      constants.NV_VMNODES: self.cfg.GetNonVmCapableNodeList(),
2424
      }
2425

    
2426
    if vg_name is not None:
2427
      node_verify_param[constants.NV_VGLIST] = None
2428
      node_verify_param[constants.NV_LVLIST] = vg_name
2429
      node_verify_param[constants.NV_PVLIST] = [vg_name]
2430
      node_verify_param[constants.NV_DRBDLIST] = None
2431

    
2432
    if drbd_helper:
2433
      node_verify_param[constants.NV_DRBDHELPER] = drbd_helper
2434

    
2435
    # bridge checks
2436
    # FIXME: this needs to be changed per node-group, not cluster-wide
2437
    bridges = set()
2438
    default_nicpp = cluster.nicparams[constants.PP_DEFAULT]
2439
    if default_nicpp[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
2440
      bridges.add(default_nicpp[constants.NIC_LINK])
2441
    for instance in self.my_inst_info.values():
2442
      for nic in instance.nics:
2443
        full_nic = cluster.SimpleFillNIC(nic.nicparams)
2444
        if full_nic[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
2445
          bridges.add(full_nic[constants.NIC_LINK])
2446

    
2447
    if bridges:
2448
      node_verify_param[constants.NV_BRIDGES] = list(bridges)
2449

    
2450
    # Build our expected cluster state
2451
    node_image = dict((node.name, self.NodeImage(offline=node.offline,
2452
                                                 name=node.name,
2453
                                                 vm_capable=node.vm_capable))
2454
                      for node in node_data_list)
2455

    
2456
    # Gather OOB paths
2457
    oob_paths = []
2458
    for node in self.all_node_info.values():
2459
      path = _SupportsOob(self.cfg, node)
2460
      if path and path not in oob_paths:
2461
        oob_paths.append(path)
2462

    
2463
    if oob_paths:
2464
      node_verify_param[constants.NV_OOB_PATHS] = oob_paths
2465

    
2466
    for instance in self.my_inst_names:
2467
      inst_config = self.my_inst_info[instance]
2468

    
2469
      for nname in inst_config.all_nodes:
2470
        if nname not in node_image:
2471
          # ghost node
2472
          gnode = self.NodeImage(name=nname)
2473
          gnode.ghost = True
2474
          node_image[nname] = gnode
2475

    
2476
      inst_config.MapLVsByNode(node_vol_should)
2477

    
2478
      pnode = inst_config.primary_node
2479
      node_image[pnode].pinst.append(instance)
2480

    
2481
      for snode in inst_config.secondary_nodes:
2482
        nimg = node_image[snode]
2483
        nimg.sinst.append(instance)
2484
        if pnode not in nimg.sbp:
2485
          nimg.sbp[pnode] = []
2486
        nimg.sbp[pnode].append(instance)
2487

    
2488
    # At this point, we have the in-memory data structures complete,
2489
    # except for the runtime information, which we'll gather next
2490

    
2491
    # Due to the way our RPC system works, exact response times cannot be
2492
    # guaranteed (e.g. a broken node could run into a timeout). By keeping the
2493
    # time before and after executing the request, we can at least have a time
2494
    # window.
2495
    nvinfo_starttime = time.time()
2496
    all_nvinfo = self.rpc.call_node_verify(self.my_node_names,
2497
                                           node_verify_param,
2498
                                           self.cfg.GetClusterName())
2499
    nvinfo_endtime = time.time()
2500

    
2501
    all_drbd_map = self.cfg.ComputeDRBDMap()
2502

    
2503
    feedback_fn("* Gathering disk information (%s nodes)" %
2504
                len(self.my_node_names))
2505
    instdisk = self._CollectDiskInfo(self.my_node_names, node_image,
2506
                                     self.my_inst_info)
2507

    
2508
    feedback_fn("* Verifying configuration file consistency")
2509

    
2510
    # If not all nodes are being checked, we need to make sure the master node
2511
    # and a non-checked vm_capable node are in the list.
2512
    absent_nodes = set(self.all_node_info).difference(self.my_node_info)
2513
    if absent_nodes:
2514
      vf_nvinfo = all_nvinfo.copy()
2515
      vf_node_info = list(self.my_node_info.values())
2516
      additional_nodes = []
2517
      if master_node not in self.my_node_info:
2518
        additional_nodes.append(master_node)
2519
        vf_node_info.append(self.all_node_info[master_node])
2520
      # Add the first vm_capable node we find which is not included
2521
      for node in absent_nodes:
2522
        nodeinfo = self.all_node_info[node]
2523
        if nodeinfo.vm_capable and not nodeinfo.offline:
2524
          additional_nodes.append(node)
2525
          vf_node_info.append(self.all_node_info[node])
2526
          break
2527
      key = constants.NV_FILELIST
2528
      vf_nvinfo.update(self.rpc.call_node_verify(additional_nodes,
2529
                                                 {key: node_verify_param[key]},
2530
                                                 self.cfg.GetClusterName()))
2531
    else:
2532
      vf_nvinfo = all_nvinfo
2533
      vf_node_info = self.my_node_info.values()
2534

    
2535
    self._VerifyFiles(_ErrorIf, vf_node_info, master_node, vf_nvinfo, filemap)
2536

    
2537
    feedback_fn("* Verifying node status")
2538

    
2539
    refos_img = None
2540

    
2541
    for node_i in node_data_list:
2542
      node = node_i.name
2543
      nimg = node_image[node]
2544

    
2545
      if node_i.offline:
2546
        if verbose:
2547
          feedback_fn("* Skipping offline node %s" % (node,))
2548
        n_offline += 1
2549
        continue
2550

    
2551
      if node == master_node:
2552
        ntype = "master"
2553
      elif node_i.master_candidate:
2554
        ntype = "master candidate"
2555
      elif node_i.drained:
2556
        ntype = "drained"
2557
        n_drained += 1
2558
      else:
2559
        ntype = "regular"
2560
      if verbose:
2561
        feedback_fn("* Verifying node %s (%s)" % (node, ntype))
2562

    
2563
      msg = all_nvinfo[node].fail_msg
2564
      _ErrorIf(msg, self.ENODERPC, node, "while contacting node: %s", msg)
2565
      if msg:
2566
        nimg.rpc_fail = True
2567
        continue
2568

    
2569
      nresult = all_nvinfo[node].payload
2570

    
2571
      nimg.call_ok = self._VerifyNode(node_i, nresult)
2572
      self._VerifyNodeTime(node_i, nresult, nvinfo_starttime, nvinfo_endtime)
2573
      self._VerifyNodeNetwork(node_i, nresult)
2574
      self._VerifyOob(node_i, nresult)
2575

    
2576
      if nimg.vm_capable:
2577
        self._VerifyNodeLVM(node_i, nresult, vg_name)
2578
        self._VerifyNodeDrbd(node_i, nresult, self.all_inst_info, drbd_helper,
2579
                             all_drbd_map)
2580

    
2581
        self._UpdateNodeVolumes(node_i, nresult, nimg, vg_name)
2582
        self._UpdateNodeInstances(node_i, nresult, nimg)
2583
        self._UpdateNodeInfo(node_i, nresult, nimg, vg_name)
2584
        self._UpdateNodeOS(node_i, nresult, nimg)
2585

    
2586
        if not nimg.os_fail:
2587
          if refos_img is None:
2588
            refos_img = nimg
2589
          self._VerifyNodeOS(node_i, nimg, refos_img)
2590
        self._VerifyNodeBridges(node_i, nresult, bridges)
2591

    
2592
        # Check whether all running instancies are primary for the node. (This
2593
        # can no longer be done from _VerifyInstance below, since some of the
2594
        # wrong instances could be from other node groups.)
2595
        non_primary_inst = set(nimg.instances).difference(nimg.pinst)
2596

    
2597
        for inst in non_primary_inst:
2598
          test = inst in self.all_inst_info
2599
          _ErrorIf(test, self.EINSTANCEWRONGNODE, inst,
2600
                   "instance should not run on node %s", node_i.name)
2601
          _ErrorIf(not test, self.ENODEORPHANINSTANCE, node_i.name,
2602
                   "node is running unknown instance %s", inst)
2603

    
2604
    feedback_fn("* Verifying instance status")
2605
    for instance in self.my_inst_names:
2606
      if verbose:
2607
        feedback_fn("* Verifying instance %s" % instance)
2608
      inst_config = self.my_inst_info[instance]
2609
      self._VerifyInstance(instance, inst_config, node_image,
2610
                           instdisk[instance])
2611
      inst_nodes_offline = []
2612

    
2613
      pnode = inst_config.primary_node
2614
      pnode_img = node_image[pnode]
2615
      _ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,
2616
               self.ENODERPC, pnode, "instance %s, connection to"
2617
               " primary node failed", instance)
2618

    
2619
      _ErrorIf(inst_config.admin_up and pnode_img.offline,
2620
               self.EINSTANCEBADNODE, instance,
2621
               "instance is marked as running and lives on offline node %s",
2622
               inst_config.primary_node)
2623

    
2624
      # If the instance is non-redundant we cannot survive losing its primary
2625
      # node, so we are not N+1 compliant. On the other hand we have no disk
2626
      # templates with more than one secondary so that situation is not well
2627
      # supported either.
2628
      # FIXME: does not support file-backed instances
2629
      if not inst_config.secondary_nodes:
2630
        i_non_redundant.append(instance)
2631

    
2632
      _ErrorIf(len(inst_config.secondary_nodes) > 1, self.EINSTANCELAYOUT,
2633
               instance, "instance has multiple secondary nodes: %s",
2634
               utils.CommaJoin(inst_config.secondary_nodes),
2635
               code=self.ETYPE_WARNING)
2636

    
2637
      if inst_config.disk_template in constants.DTS_INT_MIRROR:
2638
        pnode = inst_config.primary_node
2639
        instance_nodes = utils.NiceSort(inst_config.all_nodes)
2640
        instance_groups = {}
2641

    
2642
        for node in instance_nodes:
2643
          instance_groups.setdefault(self.all_node_info[node].group,
2644
                                     []).append(node)
2645

    
2646
        pretty_list = [
2647
          "%s (group %s)" % (utils.CommaJoin(nodes), groupinfo[group].name)
2648
          # Sort so that we always list the primary node first.
2649
          for group, nodes in sorted(instance_groups.items(),
2650
                                     key=lambda (_, nodes): pnode in nodes,
2651
                                     reverse=True)]
2652

    
2653
        self._ErrorIf(len(instance_groups) > 1, self.EINSTANCESPLITGROUPS,
2654
                      instance, "instance has primary and secondary nodes in"
2655
                      " different groups: %s", utils.CommaJoin(pretty_list),
2656
                      code=self.ETYPE_WARNING)
2657

    
2658
      if not cluster.FillBE(inst_config)[constants.BE_AUTO_BALANCE]:
2659
        i_non_a_balanced.append(instance)
2660

    
2661
      for snode in inst_config.secondary_nodes:
2662
        s_img = node_image[snode]
2663
        _ErrorIf(s_img.rpc_fail and not s_img.offline, self.ENODERPC, snode,
2664
                 "instance %s, connection to secondary node failed", instance)
2665

    
2666
        if s_img.offline:
2667
          inst_nodes_offline.append(snode)
2668

    
2669
      # warn that the instance lives on offline nodes
2670
      _ErrorIf(inst_nodes_offline, self.EINSTANCEBADNODE, instance,
2671
               "instance has offline secondary node(s) %s",
2672
               utils.CommaJoin(inst_nodes_offline))
2673
      # ... or ghost/non-vm_capable nodes
2674
      for node in inst_config.all_nodes:
2675
        _ErrorIf(node_image[node].ghost, self.EINSTANCEBADNODE, instance,
2676
                 "instance lives on ghost node %s", node)
2677
        _ErrorIf(not node_image[node].vm_capable, self.EINSTANCEBADNODE,
2678
                 instance, "instance lives on non-vm_capable node %s", node)
2679

    
2680
    feedback_fn("* Verifying orphan volumes")
2681
    reserved = utils.FieldSet(*cluster.reserved_lvs)
2682
    self._VerifyOrphanVolumes(node_vol_should, node_image, reserved)
2683

    
2684
    if constants.VERIFY_NPLUSONE_MEM not in self.op.skip_checks:
2685
      feedback_fn("* Verifying N+1 Memory redundancy")
2686
      self._VerifyNPlusOneMemory(node_image, self.my_inst_info)
2687

    
2688
    feedback_fn("* Other Notes")
2689
    if i_non_redundant:
2690
      feedback_fn("  - NOTICE: %d non-redundant instance(s) found."
2691
                  % len(i_non_redundant))
2692

    
2693
    if i_non_a_balanced:
2694
      feedback_fn("  - NOTICE: %d non-auto-balanced instance(s) found."
2695
                  % len(i_non_a_balanced))
2696

    
2697
    if n_offline:
2698
      feedback_fn("  - NOTICE: %d offline node(s) found." % n_offline)
2699

    
2700
    if n_drained:
2701
      feedback_fn("  - NOTICE: %d drained node(s) found." % n_drained)
2702

    
2703
    return not self.bad
2704

    
2705
  def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):
2706
    """Analyze the post-hooks' result
2707

2708
    This method analyses the hook result, handles it, and sends some
2709
    nicely-formatted feedback back to the user.
2710

2711
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
2712
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
2713
    @param hooks_results: the results of the multi-node hooks rpc call
2714
    @param feedback_fn: function used send feedback back to the caller
2715
    @param lu_result: previous Exec result
2716
    @return: the new Exec result, based on the previous result
2717
        and hook results
2718

2719
    """
2720
    # We only really run POST phase hooks, and are only interested in
2721
    # their results
2722
    if phase == constants.HOOKS_PHASE_POST:
2723
      # Used to change hooks' output to proper indentation
2724
      feedback_fn("* Hooks Results")
2725
      assert hooks_results, "invalid result from hooks"
2726

    
2727
      for node_name in hooks_results:
2728
        res = hooks_results[node_name]
2729
        msg = res.fail_msg
2730
        test = msg and not res.offline
2731
        self._ErrorIf(test, self.ENODEHOOKS, node_name,
2732
                      "Communication failure in hooks execution: %s", msg)
2733
        if res.offline or msg:
2734
          # No need to investigate payload if node is offline or gave an error.
2735
          # override manually lu_result here as _ErrorIf only
2736
          # overrides self.bad
2737
          lu_result = 1
2738
          continue
2739
        for script, hkr, output in res.payload:
2740
          test = hkr == constants.HKR_FAIL
2741
          self._ErrorIf(test, self.ENODEHOOKS, node_name,
2742
                        "Script %s failed, output:", script)
2743
          if test:
2744
            output = self._HOOKS_INDENT_RE.sub('      ', output)
2745
            feedback_fn("%s" % output)
2746
            lu_result = 0
2747

    
2748
      return lu_result
2749

    
2750

    
2751
class LUClusterVerifyDisks(NoHooksLU):
2752
  """Verifies the cluster disks status.
2753

2754
  """
2755
  REQ_BGL = False
2756

    
2757
  def ExpandNames(self):
2758
    self.needed_locks = {
2759
      locking.LEVEL_NODE: locking.ALL_SET,
2760
      locking.LEVEL_INSTANCE: locking.ALL_SET,
2761
    }
2762
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
2763

    
2764
  def Exec(self, feedback_fn):
2765
    """Verify integrity of cluster disks.
2766

2767
    @rtype: tuple of three items
2768
    @return: a tuple of (dict of node-to-node_error, list of instances
2769
        which need activate-disks, dict of instance: (node, volume) for
2770
        missing volumes
2771

2772
    """
2773
    result = res_nodes, res_instances, res_missing = {}, [], {}
2774

    
2775
    nodes = utils.NiceSort(self.cfg.GetVmCapableNodeList())
2776
    instances = self.cfg.GetAllInstancesInfo().values()
2777

    
2778
    nv_dict = {}
2779
    for inst in instances:
2780
      inst_lvs = {}
2781
      if not inst.admin_up:
2782
        continue
2783
      inst.MapLVsByNode(inst_lvs)
2784
      # transform { iname: {node: [vol,],},} to {(node, vol): iname}
2785
      for node, vol_list in inst_lvs.iteritems():
2786
        for vol in vol_list:
2787
          nv_dict[(node, vol)] = inst
2788

    
2789
    if not nv_dict:
2790
      return result
2791

    
2792
    node_lvs = self.rpc.call_lv_list(nodes, [])
2793
    for node, node_res in node_lvs.items():
2794
      if node_res.offline:
2795
        continue
2796
      msg = node_res.fail_msg
2797
      if msg:
2798
        logging.warning("Error enumerating LVs on node %s: %s", node, msg)
2799
        res_nodes[node] = msg
2800
        continue
2801

    
2802
      lvs = node_res.payload
2803
      for lv_name, (_, _, lv_online) in lvs.items():
2804
        inst = nv_dict.pop((node, lv_name), None)
2805
        if (not lv_online and inst is not None
2806
            and inst.name not in res_instances):
2807
          res_instances.append(inst.name)
2808

    
2809
    # any leftover items in nv_dict are missing LVs, let's arrange the
2810
    # data better
2811
    for key, inst in nv_dict.iteritems():
2812
      if inst.name not in res_missing:
2813
        res_missing[inst.name] = []
2814
      res_missing[inst.name].append(key)
2815

    
2816
    return result
2817

    
2818

    
2819
class LUClusterRepairDiskSizes(NoHooksLU):
2820
  """Verifies the cluster disks sizes.
2821

2822
  """
2823
  REQ_BGL = False
2824

    
2825
  def ExpandNames(self):
2826
    if self.op.instances:
2827
      self.wanted_names = _GetWantedInstances(self, self.op.instances)
2828
      self.needed_locks = {
2829
        locking.LEVEL_NODE: [],
2830
        locking.LEVEL_INSTANCE: self.wanted_names,
2831
        }
2832
      self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
2833
    else:
2834
      self.wanted_names = None
2835
      self.needed_locks = {
2836
        locking.LEVEL_NODE: locking.ALL_SET,
2837
        locking.LEVEL_INSTANCE: locking.ALL_SET,
2838
        }
2839
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
2840

    
2841
  def DeclareLocks(self, level):
2842
    if level == locking.LEVEL_NODE and self.wanted_names is not None:
2843
      self._LockInstancesNodes(primary_only=True)
2844

    
2845
  def CheckPrereq(self):
2846
    """Check prerequisites.
2847

2848
    This only checks the optional instance list against the existing names.
2849

2850
    """
2851
    if self.wanted_names is None:
2852
      self.wanted_names = self.glm.list_owned(locking.LEVEL_INSTANCE)
2853

    
2854
    self.wanted_instances = [self.cfg.GetInstanceInfo(name) for name
2855
                             in self.wanted_names]
2856

    
2857
  def _EnsureChildSizes(self, disk):
2858
    """Ensure children of the disk have the needed disk size.
2859

2860
    This is valid mainly for DRBD8 and fixes an issue where the
2861
    children have smaller disk size.
2862

2863
    @param disk: an L{ganeti.objects.Disk} object
2864

2865
    """
2866
    if disk.dev_type == constants.LD_DRBD8:
2867
      assert disk.children, "Empty children for DRBD8?"
2868
      fchild = disk.children[0]
2869
      mismatch = fchild.size < disk.size
2870
      if mismatch:
2871
        self.LogInfo("Child disk has size %d, parent %d, fixing",
2872
                     fchild.size, disk.size)
2873
        fchild.size = disk.size
2874

    
2875
      # and we recurse on this child only, not on the metadev
2876
      return self._EnsureChildSizes(fchild) or mismatch
2877
    else:
2878
      return False
2879

    
2880
  def Exec(self, feedback_fn):
2881
    """Verify the size of cluster disks.
2882

2883
    """
2884
    # TODO: check child disks too
2885
    # TODO: check differences in size between primary/secondary nodes
2886
    per_node_disks = {}
2887
    for instance in self.wanted_instances:
2888
      pnode = instance.primary_node
2889
      if pnode not in per_node_disks:
2890
        per_node_disks[pnode] = []
2891
      for idx, disk in enumerate(instance.disks):
2892
        per_node_disks[pnode].append((instance, idx, disk))
2893

    
2894
    changed = []
2895
    for node, dskl in per_node_disks.items():
2896
      newl = [v[2].Copy() for v in dskl]
2897
      for dsk in newl:
2898
        self.cfg.SetDiskID(dsk, node)
2899
      result = self.rpc.call_blockdev_getsize(node, newl)
2900
      if result.fail_msg:
2901
        self.LogWarning("Failure in blockdev_getsize call to node"
2902
                        " %s, ignoring", node)
2903
        continue
2904
      if len(result.payload) != len(dskl):
2905
        logging.warning("Invalid result from node %s: len(dksl)=%d,"
2906
                        " result.payload=%s", node, len(dskl), result.payload)
2907
        self.LogWarning("Invalid result from node %s, ignoring node results",
2908
                        node)
2909
        continue
2910
      for ((instance, idx, disk), size) in zip(dskl, result.payload):
2911
        if size is None:
2912
          self.LogWarning("Disk %d of instance %s did not return size"
2913
                          " information, ignoring", idx, instance.name)
2914
          continue
2915
        if not isinstance(size, (int, long)):
2916
          self.LogWarning("Disk %d of instance %s did not return valid"
2917
                          " size information, ignoring", idx, instance.name)
2918
          continue
2919
        size = size >> 20
2920
        if size != disk.size:
2921
          self.LogInfo("Disk %d of instance %s has mismatched size,"
2922
                       " correcting: recorded %d, actual %d", idx,
2923
                       instance.name, disk.size, size)
2924
          disk.size = size
2925
          self.cfg.Update(instance, feedback_fn)
2926
          changed.append((instance.name, idx, size))
2927
        if self._EnsureChildSizes(disk):
2928
          self.cfg.Update(instance, feedback_fn)
2929
          changed.append((instance.name, idx, disk.size))
2930
    return changed
2931

    
2932

    
2933
class LUClusterRename(LogicalUnit):
2934
  """Rename the cluster.
2935

2936
  """
2937
  HPATH = "cluster-rename"
2938
  HTYPE = constants.HTYPE_CLUSTER
2939

    
2940
  def BuildHooksEnv(self):
2941
    """Build hooks env.
2942

2943
    """
2944
    return {
2945
      "OP_TARGET": self.cfg.GetClusterName(),
2946
      "NEW_NAME": self.op.name,
2947
      }
2948

    
2949
  def BuildHooksNodes(self):
2950
    """Build hooks nodes.
2951

2952
    """
2953
    return ([self.cfg.GetMasterNode()], self.cfg.GetNodeList())
2954

    
2955
  def CheckPrereq(self):
2956
    """Verify that the passed name is a valid one.
2957

2958
    """
2959
    hostname = netutils.GetHostname(name=self.op.name,
2960
                                    family=self.cfg.GetPrimaryIPFamily())
2961

    
2962
    new_name = hostname.name
2963
    self.ip = new_ip = hostname.ip
2964
    old_name = self.cfg.GetClusterName()
2965
    old_ip = self.cfg.GetMasterIP()
2966
    if new_name == old_name and new_ip == old_ip:
2967
      raise errors.OpPrereqError("Neither the name nor the IP address of the"
2968
                                 " cluster has changed",
2969
                                 errors.ECODE_INVAL)
2970
    if new_ip != old_ip:
2971
      if netutils.TcpPing(new_ip, constants.DEFAULT_NODED_PORT):
2972
        raise errors.OpPrereqError("The given cluster IP address (%s) is"
2973
                                   " reachable on the network" %
2974
                                   new_ip, errors.ECODE_NOTUNIQUE)
2975

    
2976
    self.op.name = new_name
2977

    
2978
  def Exec(self, feedback_fn):
2979
    """Rename the cluster.
2980

2981
    """
2982
    clustername = self.op.name
2983
    ip = self.ip
2984

    
2985
    # shutdown the master IP
2986
    master = self.cfg.GetMasterNode()
2987
    result = self.rpc.call_node_stop_master(master, False)
2988
    result.Raise("Could not disable the master role")
2989

    
2990
    try:
2991
      cluster = self.cfg.GetClusterInfo()
2992
      cluster.cluster_name = clustername
2993
      cluster.master_ip = ip
2994
      self.cfg.Update(cluster, feedback_fn)
2995

    
2996
      # update the known hosts file
2997
      ssh.WriteKnownHostsFile(self.cfg, constants.SSH_KNOWN_HOSTS_FILE)
2998
      node_list = self.cfg.GetOnlineNodeList()
2999
      try:
3000
        node_list.remove(master)
3001
      except ValueError:
3002
        pass
3003
      _UploadHelper(self, node_list, constants.SSH_KNOWN_HOSTS_FILE)
3004
    finally:
3005
      result = self.rpc.call_node_start_master(master, False, False)
3006
      msg = result.fail_msg
3007
      if msg:
3008
        self.LogWarning("Could not re-enable the master role on"
3009
                        " the master, please restart manually: %s", msg)
3010

    
3011
    return clustername
3012

    
3013

    
3014
class LUClusterSetParams(LogicalUnit):
3015
  """Change the parameters of the cluster.
3016

3017
  """
3018
  HPATH = "cluster-modify"
3019
  HTYPE = constants.HTYPE_CLUSTER
3020
  REQ_BGL = False
3021

    
3022
  def CheckArguments(self):
3023
    """Check parameters
3024

3025
    """
3026
    if self.op.uid_pool:
3027
      uidpool.CheckUidPool(self.op.uid_pool)
3028

    
3029
    if self.op.add_uids:
3030
      uidpool.CheckUidPool(self.op.add_uids)
3031

    
3032
    if self.op.remove_uids:
3033
      uidpool.CheckUidPool(self.op.remove_uids)
3034

    
3035
  def ExpandNames(self):
3036
    # FIXME: in the future maybe other cluster params won't require checking on
3037
    # all nodes to be modified.
3038
    self.needed_locks = {
3039
      locking.LEVEL_NODE: locking.ALL_SET,
3040
    }
3041
    self.share_locks[locking.LEVEL_NODE] = 1
3042

    
3043
  def BuildHooksEnv(self):
3044
    """Build hooks env.
3045

3046
    """
3047
    return {
3048
      "OP_TARGET": self.cfg.GetClusterName(),
3049
      "NEW_VG_NAME": self.op.vg_name,
3050
      }
3051

    
3052
  def BuildHooksNodes(self):
3053
    """Build hooks nodes.
3054

3055
    """
3056
    mn = self.cfg.GetMasterNode()
3057
    return ([mn], [mn])
3058

    
3059
  def CheckPrereq(self):
3060
    """Check prerequisites.
3061

3062
    This checks whether the given params don't conflict and
3063
    if the given volume group is valid.
3064

3065
    """
3066
    if self.op.vg_name is not None and not self.op.vg_name:
3067
      if self.cfg.HasAnyDiskOfType(constants.LD_LV):
3068
        raise errors.OpPrereqError("Cannot disable lvm storage while lvm-based"
3069
                                   " instances exist", errors.ECODE_INVAL)
3070

    
3071
    if self.op.drbd_helper is not None and not self.op.drbd_helper:
3072
      if self.cfg.HasAnyDiskOfType(constants.LD_DRBD8):
3073
        raise errors.OpPrereqError("Cannot disable drbd helper while"
3074
                                   " drbd-based instances exist",
3075
                                   errors.ECODE_INVAL)
3076

    
3077
    node_list = self.glm.list_owned(locking.LEVEL_NODE)
3078

    
3079
    # if vg_name not None, checks given volume group on all nodes
3080
    if self.op.vg_name:
3081
      vglist = self.rpc.call_vg_list(node_list)
3082
      for node in node_list:
3083
        msg = vglist[node].fail_msg
3084
        if msg:
3085
          # ignoring down node
3086
          self.LogWarning("Error while gathering data on node %s"
3087
                          " (ignoring node): %s", node, msg)
3088
          continue
3089
        vgstatus = utils.CheckVolumeGroupSize(vglist[node].payload,
3090
                                              self.op.vg_name,
3091
                                              constants.MIN_VG_SIZE)
3092
        if vgstatus:
3093
          raise errors.OpPrereqError("Error on node '%s': %s" %
3094
                                     (node, vgstatus), errors.ECODE_ENVIRON)
3095

    
3096
    if self.op.drbd_helper:
3097
      # checks given drbd helper on all nodes
3098
      helpers = self.rpc.call_drbd_helper(node_list)
3099
      for node in node_list:
3100
        ninfo = self.cfg.GetNodeInfo(node)
3101
        if ninfo.offline:
3102
          self.LogInfo("Not checking drbd helper on offline node %s", node)
3103
          continue
3104
        msg = helpers[node].fail_msg
3105
        if msg:
3106
          raise errors.OpPrereqError("Error checking drbd helper on node"
3107
                                     " '%s': %s" % (node, msg),
3108
                                     errors.ECODE_ENVIRON)
3109
        node_helper = helpers[node].payload
3110
        if node_helper != self.op.drbd_helper:
3111
          raise errors.OpPrereqError("Error on node '%s': drbd helper is %s" %
3112
                                     (node, node_helper), errors.ECODE_ENVIRON)
3113

    
3114
    self.cluster = cluster = self.cfg.GetClusterInfo()
3115
    # validate params changes
3116
    if self.op.beparams:
3117
      utils.ForceDictType(self.op.beparams, constants.BES_PARAMETER_TYPES)
3118
      self.new_beparams = cluster.SimpleFillBE(self.op.beparams)
3119

    
3120
    if self.op.ndparams:
3121
      utils.ForceDictType(self.op.ndparams, constants.NDS_PARAMETER_TYPES)
3122
      self.new_ndparams = cluster.SimpleFillND(self.op.ndparams)
3123

    
3124
      # TODO: we need a more general way to handle resetting
3125
      # cluster-level parameters to default values
3126
      if self.new_ndparams["oob_program"] == "":
3127
        self.new_ndparams["oob_program"] = \
3128
            constants.NDC_DEFAULTS[constants.ND_OOB_PROGRAM]
3129

    
3130
    if self.op.nicparams:
3131
      utils.ForceDictType(self.op.nicparams, constants.NICS_PARAMETER_TYPES)
3132
      self.new_nicparams = cluster.SimpleFillNIC(self.op.nicparams)
3133
      objects.NIC.CheckParameterSyntax(self.new_nicparams)
3134
      nic_errors = []
3135

    
3136
      # check all instances for consistency
3137
      for instance in self.cfg.GetAllInstancesInfo().values():
3138
        for nic_idx, nic in enumerate(instance.nics):
3139
          params_copy = copy.deepcopy(nic.nicparams)
3140
          params_filled = objects.FillDict(self.new_nicparams, params_copy)
3141

    
3142
          # check parameter syntax
3143
          try:
3144
            objects.NIC.CheckParameterSyntax(params_filled)
3145
          except errors.ConfigurationError, err:
3146
            nic_errors.append("Instance %s, nic/%d: %s" %
3147
                              (instance.name, nic_idx, err))
3148

    
3149
          # if we're moving instances to routed, check that they have an ip
3150
          target_mode = params_filled[constants.NIC_MODE]
3151
          if target_mode == constants.NIC_MODE_ROUTED and not nic.ip:
3152
            nic_errors.append("Instance %s, nic/%d: routed NIC with no ip"
3153
                              " address" % (instance.name, nic_idx))
3154
      if nic_errors:
3155
        raise errors.OpPrereqError("Cannot apply the change, errors:\n%s" %
3156
                                   "\n".join(nic_errors))
3157

    
3158
    # hypervisor list/parameters
3159
    self.new_hvparams = new_hvp = objects.FillDict(cluster.hvparams, {})
3160
    if self.op.hvparams:
3161
      for hv_name, hv_dict in self.op.hvparams.items():
3162
        if hv_name not in self.new_hvparams:
3163
          self.new_hvparams[hv_name] = hv_dict
3164
        else:
3165
          self.new_hvparams[hv_name].update(hv_dict)
3166

    
3167
    # os hypervisor parameters
3168
    self.new_os_hvp = objects.FillDict(cluster.os_hvp, {})
3169
    if self.op.os_hvp:
3170
      for os_name, hvs in self.op.os_hvp.items():
3171
        if os_name not in self.new_os_hvp:
3172
          self.new_os_hvp[os_name] = hvs
3173
        else:
3174
          for hv_name, hv_dict in hvs.items():
3175
            if hv_name not in self.new_os_hvp[os_name]:
3176
              self.new_os_hvp[os_name][hv_name] = hv_dict
3177
            else:
3178
              self.new_os_hvp[os_name][hv_name].update(hv_dict)
3179

    
3180
    # os parameters
3181
    self.new_osp = objects.FillDict(cluster.osparams, {})
3182
    if self.op.osparams:
3183
      for os_name, osp in self.op.osparams.items():
3184
        if os_name not in self.new_osp:
3185
          self.new_osp[os_name] = {}
3186

    
3187
        self.new_osp[os_name] = _GetUpdatedParams(self.new_osp[os_name], osp,
3188
                                                  use_none=True)
3189

    
3190
        if not self.new_osp[os_name]:
3191
          # we removed all parameters
3192
          del self.new_osp[os_name]
3193
        else:
3194
          # check the parameter validity (remote check)
3195
          _CheckOSParams(self, False, [self.cfg.GetMasterNode()],
3196
                         os_name, self.new_osp[os_name])
3197

    
3198
    # changes to the hypervisor list
3199
    if self.op.enabled_hypervisors is not None:
3200
      self.hv_list = self.op.enabled_hypervisors
3201
      for hv in self.hv_list:
3202
        # if the hypervisor doesn't already exist in the cluster
3203
        # hvparams, we initialize it to empty, and then (in both
3204
        # cases) we make sure to fill the defaults, as we might not
3205
        # have a complete defaults list if the hypervisor wasn't
3206
        # enabled before
3207
        if hv not in new_hvp:
3208
          new_hvp[hv] = {}
3209
        new_hvp[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], new_hvp[hv])
3210
        utils.ForceDictType(new_hvp[hv], constants.HVS_PARAMETER_TYPES)
3211
    else:
3212
      self.hv_list = cluster.enabled_hypervisors
3213

    
3214
    if self.op.hvparams or self.op.enabled_hypervisors is not None:
3215
      # either the enabled list has changed, or the parameters have, validate
3216
      for hv_name, hv_params in self.new_hvparams.items():
3217
        if ((self.op.hvparams and hv_name in self.op.hvparams) or
3218
            (self.op.enabled_hypervisors and
3219
             hv_name in self.op.enabled_hypervisors)):
3220
          # either this is a new hypervisor, or its parameters have changed
3221
          hv_class = hypervisor.GetHypervisor(hv_name)
3222
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
3223
          hv_class.CheckParameterSyntax(hv_params)
3224
          _CheckHVParams(self, node_list, hv_name, hv_params)
3225

    
3226
    if self.op.os_hvp:
3227
      # no need to check any newly-enabled hypervisors, since the
3228
      # defaults have already been checked in the above code-block
3229
      for os_name, os_hvp in self.new_os_hvp.items():
3230
        for hv_name, hv_params in os_hvp.items():
3231
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
3232
          # we need to fill in the new os_hvp on top of the actual hv_p
3233
          cluster_defaults = self.new_hvparams.get(hv_name, {})
3234
          new_osp = objects.FillDict(cluster_defaults, hv_params)
3235
          hv_class = hypervisor.GetHypervisor(hv_name)
3236
          hv_class.CheckParameterSyntax(new_osp)
3237
          _CheckHVParams(self, node_list, hv_name, new_osp)
3238

    
3239
    if self.op.default_iallocator:
3240
      alloc_script = utils.FindFile(self.op.default_iallocator,
3241
                                    constants.IALLOCATOR_SEARCH_PATH,
3242
                                    os.path.isfile)
3243
      if alloc_script is None:
3244
        raise errors.OpPrereqError("Invalid default iallocator script '%s'"
3245
                                   " specified" % self.op.default_iallocator,
3246
                                   errors.ECODE_INVAL)
3247

    
3248
  def Exec(self, feedback_fn):
3249
    """Change the parameters of the cluster.
3250

3251
    """
3252
    if self.op.vg_name is not None:
3253
      new_volume = self.op.vg_name
3254
      if not new_volume:
3255
        new_volume = None
3256
      if new_volume != self.cfg.GetVGName():
3257
        self.cfg.SetVGName(new_volume)
3258
      else:
3259
        feedback_fn("Cluster LVM configuration already in desired"
3260
                    " state, not changing")
3261
    if self.op.drbd_helper is not None:
3262
      new_helper = self.op.drbd_helper
3263
      if not new_helper:
3264
        new_helper = None
3265
      if new_helper != self.cfg.GetDRBDHelper():
3266
        self.cfg.SetDRBDHelper(new_helper)
3267
      else:
3268
        feedback_fn("Cluster DRBD helper already in desired state,"
3269
                    " not changing")
3270
    if self.op.hvparams:
3271
      self.cluster.hvparams = self.new_hvparams
3272
    if self.op.os_hvp:
3273
      self.cluster.os_hvp = self.new_os_hvp
3274
    if self.op.enabled_hypervisors is not None:
3275
      self.cluster.hvparams = self.new_hvparams
3276
      self.cluster.enabled_hypervisors = self.op.enabled_hypervisors
3277
    if self.op.beparams:
3278
      self.cluster.beparams[constants.PP_DEFAULT] = self.new_beparams
3279
    if self.op.nicparams:
3280
      self.cluster.nicparams[constants.PP_DEFAULT] = self.new_nicparams
3281
    if self.op.osparams:
3282
      self.cluster.osparams = self.new_osp
3283
    if self.op.ndparams:
3284
      self.cluster.ndparams = self.new_ndparams
3285

    
3286
    if self.op.candidate_pool_size is not None:
3287
      self.cluster.candidate_pool_size = self.op.candidate_pool_size
3288
      # we need to update the pool size here, otherwise the save will fail
3289
      _AdjustCandidatePool(self, [])
3290

    
3291
    if self.op.maintain_node_health is not None:
3292
      self.cluster.maintain_node_health = self.op.maintain_node_health
3293

    
3294
    if self.op.prealloc_wipe_disks is not None:
3295
      self.cluster.prealloc_wipe_disks = self.op.prealloc_wipe_disks
3296

    
3297
    if self.op.add_uids is not None:
3298
      uidpool.AddToUidPool(self.cluster.uid_pool, self.op.add_uids)
3299

    
3300
    if self.op.remove_uids is not None:
3301
      uidpool.RemoveFromUidPool(self.cluster.uid_pool, self.op.remove_uids)
3302

    
3303
    if self.op.uid_pool is not None:
3304
      self.cluster.uid_pool = self.op.uid_pool
3305

    
3306
    if self.op.default_iallocator is not None:
3307
      self.cluster.default_iallocator = self.op.default_iallocator
3308

    
3309
    if self.op.reserved_lvs is not None:
3310
      self.cluster.reserved_lvs = self.op.reserved_lvs
3311

    
3312
    def helper_os(aname, mods, desc):
3313
      desc += " OS list"
3314
      lst = getattr(self.cluster, aname)
3315
      for key, val in mods:
3316
        if key == constants.DDM_ADD:
3317
          if val in lst:
3318
            feedback_fn("OS %s already in %s, ignoring" % (val, desc))
3319
          else:
3320
            lst.append(val)
3321
        elif key == constants.DDM_REMOVE:
3322
          if val in lst:
3323
            lst.remove(val)
3324
          else:
3325
            feedback_fn("OS %s not found in %s, ignoring" % (val, desc))
3326
        else:
3327
          raise errors.ProgrammerError("Invalid modification '%s'" % key)
3328

    
3329
    if self.op.hidden_os:
3330
      helper_os("hidden_os", self.op.hidden_os, "hidden")
3331

    
3332
    if self.op.blacklisted_os:
3333
      helper_os("blacklisted_os", self.op.blacklisted_os, "blacklisted")
3334

    
3335
    if self.op.master_netdev:
3336
      master = self.cfg.GetMasterNode()
3337
      feedback_fn("Shutting down master ip on the current netdev (%s)" %
3338
                  self.cluster.master_netdev)
3339
      result = self.rpc.call_node_stop_master(master, False)
3340
      result.Raise("Could not disable the master ip")
3341
      feedback_fn("Changing master_netdev from %s to %s" %
3342
                  (self.cluster.master_netdev, self.op.master_netdev))
3343
      self.cluster.master_netdev = self.op.master_netdev
3344

    
3345
    self.cfg.Update(self.cluster, feedback_fn)
3346

    
3347
    if self.op.master_netdev:
3348
      feedback_fn("Starting the master ip on the new master netdev (%s)" %
3349
                  self.op.master_netdev)
3350
      result = self.rpc.call_node_start_master(master, False, False)
3351
      if result.fail_msg:
3352
        self.LogWarning("Could not re-enable the master ip on"
3353
                        " the master, please restart manually: %s",
3354
                        result.fail_msg)
3355

    
3356

    
3357
def _UploadHelper(lu, nodes, fname):
3358
  """Helper for uploading a file and showing warnings.
3359

3360
  """
3361
  if os.path.exists(fname):
3362
    result = lu.rpc.call_upload_file(nodes, fname)
3363
    for to_node, to_result in result.items():
3364
      msg = to_result.fail_msg
3365
      if msg:
3366
        msg = ("Copy of file %s to node %s failed: %s" %
3367
               (fname, to_node, msg))
3368
        lu.proc.LogWarning(msg)
3369

    
3370

    
3371
def _ComputeAncillaryFiles(cluster, redist):
3372
  """Compute files external to Ganeti which need to be consistent.
3373

3374
  @type redist: boolean
3375
  @param redist: Whether to include files which need to be redistributed
3376

3377
  """
3378
  # Compute files for all nodes
3379
  files_all = set([
3380
    constants.SSH_KNOWN_HOSTS_FILE,
3381
    constants.CONFD_HMAC_KEY,
3382
    constants.CLUSTER_DOMAIN_SECRET_FILE,
3383
    ])
3384

    
3385
  if not redist:
3386
    files_all.update(constants.ALL_CERT_FILES)
3387
    files_all.update(ssconf.SimpleStore().GetFileList())
3388

    
3389
  if cluster.modify_etc_hosts:
3390
    files_all.add(constants.ETC_HOSTS)
3391

    
3392
  # Files which must either exist on all nodes or on none
3393
  files_all_opt = set([
3394
    constants.RAPI_USERS_FILE,
3395
    ])
3396

    
3397
  # Files which should only be on master candidates
3398
  files_mc = set()
3399
  if not redist:
3400
    files_mc.add(constants.CLUSTER_CONF_FILE)
3401

    
3402
  # Files which should only be on VM-capable nodes
3403
  files_vm = set(filename
3404
    for hv_name in cluster.enabled_hypervisors
3405
    for filename in hypervisor.GetHypervisor(hv_name).GetAncillaryFiles())
3406

    
3407
  # Filenames must be unique
3408
  assert (len(files_all | files_all_opt | files_mc | files_vm) ==
3409
          sum(map(len, [files_all, files_all_opt, files_mc, files_vm]))), \
3410
         "Found file listed in more than one file list"
3411

    
3412
  return (files_all, files_all_opt, files_mc, files_vm)
3413

    
3414

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

3418
  ConfigWriter takes care of distributing the config and ssconf files, but
3419
  there are more files which should be distributed to all nodes. This function
3420
  makes sure those are copied.
3421

3422
  @param lu: calling logical unit
3423
  @param additional_nodes: list of nodes not in the config to distribute to
3424
  @type additional_vm: boolean
3425
  @param additional_vm: whether the additional nodes are vm-capable or not
3426

3427
  """
3428
  # Gather target nodes
3429
  cluster = lu.cfg.GetClusterInfo()
3430
  master_info = lu.cfg.GetNodeInfo(lu.cfg.GetMasterNode())
3431

    
3432
  online_nodes = lu.cfg.GetOnlineNodeList()
3433
  vm_nodes = lu.cfg.GetVmCapableNodeList()
3434

    
3435
  if additional_nodes is not None:
3436
    online_nodes.extend(additional_nodes)
3437
    if additional_vm:
3438
      vm_nodes.extend(additional_nodes)
3439

    
3440
  # Never distribute to master node
3441
  for nodelist in [online_nodes, vm_nodes]:
3442
    if master_info.name in nodelist:
3443
      nodelist.remove(master_info.name)
3444

    
3445
  # Gather file lists
3446
  (files_all, files_all_opt, files_mc, files_vm) = \
3447
    _ComputeAncillaryFiles(cluster, True)
3448

    
3449
  # Never re-distribute configuration file from here
3450
  assert not (constants.CLUSTER_CONF_FILE in files_all or
3451
              constants.CLUSTER_CONF_FILE in files_vm)
3452
  assert not files_mc, "Master candidates not handled in this function"
3453

    
3454
  filemap = [
3455
    (online_nodes, files_all),
3456
    (online_nodes, files_all_opt),
3457
    (vm_nodes, files_vm),
3458
    ]
3459

    
3460
  # Upload the files
3461
  for (node_list, files) in filemap:
3462
    for fname in files:
3463
      _UploadHelper(lu, node_list, fname)
3464

    
3465

    
3466
class LUClusterRedistConf(NoHooksLU):
3467
  """Force the redistribution of cluster configuration.
3468

3469
  This is a very simple LU.
3470

3471
  """
3472
  REQ_BGL = False
3473

    
3474
  def ExpandNames(self):
3475
    self.needed_locks = {
3476
      locking.LEVEL_NODE: locking.ALL_SET,
3477
    }
3478
    self.share_locks[locking.LEVEL_NODE] = 1
3479

    
3480
  def Exec(self, feedback_fn):
3481
    """Redistribute the configuration.
3482

3483
    """
3484
    self.cfg.Update(self.cfg.GetClusterInfo(), feedback_fn)
3485
    _RedistributeAncillaryFiles(self)
3486

    
3487

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

3491
  """
3492
  if not instance.disks or disks is not None and not disks:
3493
    return True
3494

    
3495
  disks = _ExpandCheckDisks(instance, disks)
3496

    
3497
  if not oneshot:
3498
    lu.proc.LogInfo("Waiting for instance %s to sync disks." % instance.name)
3499

    
3500
  node = instance.primary_node
3501

    
3502
  for dev in disks:
3503
    lu.cfg.SetDiskID(dev, node)
3504

    
3505
  # TODO: Convert to utils.Retry
3506

    
3507
  retries = 0
3508
  degr_retries = 10 # in seconds, as we sleep 1 second each time
3509
  while True:
3510
    max_time = 0
3511
    done = True
3512
    cumul_degraded = False
3513
    rstats = lu.rpc.call_blockdev_getmirrorstatus(node, disks)
3514
    msg = rstats.fail_msg
3515
    if msg:
3516
      lu.LogWarning("Can't get any data from node %s: %s", node, msg)
3517
      retries += 1
3518
      if retries >= 10:
3519
        raise errors.RemoteError("Can't contact node %s for mirror data,"
3520
                                 " aborting." % node)
3521
      time.sleep(6)
3522
      continue
3523
    rstats = rstats.payload
3524
    retries = 0
3525
    for i, mstat in enumerate(rstats):
3526
      if mstat is None:
3527
        lu.LogWarning("Can't compute data for node %s/%s",
3528
                           node, disks[i].iv_name)
3529
        continue
3530

    
3531
      cumul_degraded = (cumul_degraded or
3532
                        (mstat.is_degraded and mstat.sync_percent is None))
3533
      if mstat.sync_percent is not None:
3534
        done = False
3535
        if mstat.estimated_time is not None:
3536
          rem_time = ("%s remaining (estimated)" %
3537
                      utils.FormatSeconds(mstat.estimated_time))
3538
          max_time = mstat.estimated_time
3539
        else:
3540
          rem_time = "no time estimate"
3541
        lu.proc.LogInfo("- device %s: %5.2f%% done, %s" %
3542
                        (disks[i].iv_name, mstat.sync_percent, rem_time))
3543

    
3544
    # if we're done but degraded, let's do a few small retries, to
3545
    # make sure we see a stable and not transient situation; therefore
3546
    # we force restart of the loop
3547
    if (done or oneshot) and cumul_degraded and degr_retries > 0:
3548
      logging.info("Degraded disks found, %d retries left", degr_retries)
3549
      degr_retries -= 1
3550
      time.sleep(1)
3551
      continue
3552

    
3553
    if done or oneshot:
3554
      break
3555

    
3556
    time.sleep(min(60, max_time))
3557

    
3558
  if done:
3559
    lu.proc.LogInfo("Instance %s's disks are in sync." % instance.name)
3560
  return not cumul_degraded
3561

    
3562

    
3563
def _CheckDiskConsistency(lu, dev, node, on_primary, ldisk=False):
3564
  """Check that mirrors are not degraded.
3565

3566
  The ldisk parameter, if True, will change the test from the
3567
  is_degraded attribute (which represents overall non-ok status for
3568
  the device(s)) to the ldisk (representing the local storage status).
3569

3570
  """
3571
  lu.cfg.SetDiskID(dev, node)
3572

    
3573
  result = True
3574

    
3575
  if on_primary or dev.AssembleOnSecondary():
3576
    rstats = lu.rpc.call_blockdev_find(node, dev)
3577
    msg = rstats.fail_msg
3578
    if msg:
3579
      lu.LogWarning("Can't find disk on node %s: %s", node, msg)
3580
      result = False
3581
    elif not rstats.payload:
3582
      lu.LogWarning("Can't find disk on node %s", node)
3583
      result = False
3584
    else:
3585
      if ldisk:
3586
        result = result and rstats.payload.ldisk_status == constants.LDS_OKAY
3587
      else:
3588
        result = result and not rstats.payload.is_degraded
3589

    
3590
  if dev.children:
3591
    for child in dev.children:
3592
      result = result and _CheckDiskConsistency(lu, child, node, on_primary)
3593

    
3594
  return result
3595

    
3596

    
3597
class LUOobCommand(NoHooksLU):
3598
  """Logical unit for OOB handling.
3599

3600
  """
3601
  REG_BGL = False
3602
  _SKIP_MASTER = (constants.OOB_POWER_OFF, constants.OOB_POWER_CYCLE)
3603

    
3604
  def ExpandNames(self):
3605
    """Gather locks we need.
3606

3607
    """
3608
    if self.op.node_names:
3609
      self.op.node_names = _GetWantedNodes(self, self.op.node_names)
3610
      lock_names = self.op.node_names
3611
    else:
3612
      lock_names = locking.ALL_SET
3613

    
3614
    self.needed_locks = {
3615
      locking.LEVEL_NODE: lock_names,
3616
      }
3617

    
3618
  def CheckPrereq(self):
3619
    """Check prerequisites.
3620

3621
    This checks:
3622
     - the node exists in the configuration
3623
     - OOB is supported
3624

3625
    Any errors are signaled by raising errors.OpPrereqError.
3626

3627
    """
3628
    self.nodes = []
3629
    self.master_node = self.cfg.GetMasterNode()
3630

    
3631
    assert self.op.power_delay >= 0.0
3632

    
3633
    if self.op.node_names:
3634
      if (self.op.command in self._SKIP_MASTER and
3635
          self.master_node in self.op.node_names):
3636
        master_node_obj = self.cfg.GetNodeInfo(self.master_node)
3637
        master_oob_handler = _SupportsOob(self.cfg, master_node_obj)
3638

    
3639
        if master_oob_handler:
3640
          additional_text = ("run '%s %s %s' if you want to operate on the"
3641
                             " master regardless") % (master_oob_handler,
3642
                                                      self.op.command,
3643
                                                      self.master_node)
3644
        else:
3645
          additional_text = "it does not support out-of-band operations"
3646

    
3647
        raise errors.OpPrereqError(("Operating on the master node %s is not"
3648
                                    " allowed for %s; %s") %
3649
                                   (self.master_node, self.op.command,
3650
                                    additional_text), errors.ECODE_INVAL)
3651
    else:
3652
      self.op.node_names = self.cfg.GetNodeList()
3653
      if self.op.command in self._SKIP_MASTER:
3654
        self.op.node_names.remove(self.master_node)
3655

    
3656
    if self.op.command in self._SKIP_MASTER:
3657
      assert self.master_node not in self.op.node_names
3658

    
3659
    for node_name in self.op.node_names:
3660
      node = self.cfg.GetNodeInfo(node_name)
3661

    
3662
      if node is None:
3663
        raise errors.OpPrereqError("Node %s not found" % node_name,
3664
                                   errors.ECODE_NOENT)
3665
      else:
3666
        self.nodes.append(node)
3667

    
3668
      if (not self.op.ignore_status and
3669
          (self.op.command == constants.OOB_POWER_OFF and not node.offline)):
3670
        raise errors.OpPrereqError(("Cannot power off node %s because it is"
3671
                                    " not marked offline") % node_name,
3672
                                   errors.ECODE_STATE)
3673

    
3674
  def Exec(self, feedback_fn):
3675
    """Execute OOB and return result if we expect any.
3676

3677
    """
3678
    master_node = self.master_node
3679
    ret = []
3680

    
3681
    for idx, node in enumerate(utils.NiceSort(self.nodes,
3682
                                              key=lambda node: node.name)):
3683
      node_entry = [(constants.RS_NORMAL, node.name)]
3684
      ret.append(node_entry)
3685

    
3686
      oob_program = _SupportsOob(self.cfg, node)
3687

    
3688
      if not oob_program:
3689
        node_entry.append((constants.RS_UNAVAIL, None))
3690
        continue
3691

    
3692
      logging.info("Executing out-of-band command '%s' using '%s' on %s",
3693
                   self.op.command, oob_program, node.name)
3694
      result = self.rpc.call_run_oob(master_node, oob_program,
3695
                                     self.op.command, node.name,
3696
                                     self.op.timeout)
3697

    
3698
      if result.fail_msg:
3699
        self.LogWarning("Out-of-band RPC failed on node '%s': %s",
3700
                        node.name, result.fail_msg)
3701
        node_entry.append((constants.RS_NODATA, None))
3702
      else:
3703
        try:
3704
          self._CheckPayload(result)
3705
        except errors.OpExecError, err:
3706
          self.LogWarning("Payload returned by node '%s' is not valid: %s",
3707
                          node.name, err)
3708
          node_entry.append((constants.RS_NODATA, None))
3709
        else:
3710
          if self.op.command == constants.OOB_HEALTH:
3711
            # For health we should log important events
3712
            for item, status in result.payload:
3713
              if status in [constants.OOB_STATUS_WARNING,
3714
                            constants.OOB_STATUS_CRITICAL]:
3715
                self.LogWarning("Item '%s' on node '%s' has status '%s'",
3716
                                item, node.name, status)
3717

    
3718
          if self.op.command == constants.OOB_POWER_ON:
3719
            node.powered = True
3720
          elif self.op.command == constants.OOB_POWER_OFF:
3721
            node.powered = False
3722
          elif self.op.command == constants.OOB_POWER_STATUS:
3723
            powered = result.payload[constants.OOB_POWER_STATUS_POWERED]
3724
            if powered != node.powered:
3725
              logging.warning(("Recorded power state (%s) of node '%s' does not"
3726
                               " match actual power state (%s)"), node.powered,
3727
                              node.name, powered)
3728

    
3729
          # For configuration changing commands we should update the node
3730
          if self.op.command in (constants.OOB_POWER_ON,
3731
                                 constants.OOB_POWER_OFF):
3732
            self.cfg.Update(node, feedback_fn)
3733

    
3734
          node_entry.append((constants.RS_NORMAL, result.payload))
3735

    
3736
          if (self.op.command == constants.OOB_POWER_ON and
3737
              idx < len(self.nodes) - 1):
3738
            time.sleep(self.op.power_delay)
3739

    
3740
    return ret
3741

    
3742
  def _CheckPayload(self, result):
3743
    """Checks if the payload is valid.
3744

3745
    @param result: RPC result
3746
    @raises errors.OpExecError: If payload is not valid
3747

3748
    """
3749
    errs = []
3750
    if self.op.command == constants.OOB_HEALTH:
3751
      if not isinstance(result.payload, list):
3752
        errs.append("command 'health' is expected to return a list but got %s" %
3753
                    type(result.payload))
3754
      else:
3755
        for item, status in result.payload:
3756
          if status not in constants.OOB_STATUSES:
3757
            errs.append("health item '%s' has invalid status '%s'" %
3758
                        (item, status))
3759

    
3760
    if self.op.command == constants.OOB_POWER_STATUS:
3761
      if not isinstance(result.payload, dict):
3762
        errs.append("power-status is expected to return a dict but got %s" %
3763
                    type(result.payload))
3764

    
3765
    if self.op.command in [
3766
        constants.OOB_POWER_ON,
3767
        constants.OOB_POWER_OFF,
3768
        constants.OOB_POWER_CYCLE,
3769
        ]:
3770
      if result.payload is not None:
3771
        errs.append("%s is expected to not return payload but got '%s'" %
3772
                    (self.op.command, result.payload))
3773

    
3774
    if errs:
3775
      raise errors.OpExecError("Check of out-of-band payload failed due to %s" %
3776
                               utils.CommaJoin(errs))
3777

    
3778
class _OsQuery(_QueryBase):
3779
  FIELDS = query.OS_FIELDS
3780

    
3781
  def ExpandNames(self, lu):
3782
    # Lock all nodes in shared mode
3783
    # Temporary removal of locks, should be reverted later
3784
    # TODO: reintroduce locks when they are lighter-weight
3785
    lu.needed_locks = {}
3786
    #self.share_locks[locking.LEVEL_NODE] = 1
3787
    #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3788

    
3789
    # The following variables interact with _QueryBase._GetNames
3790
    if self.names:
3791
      self.wanted = self.names
3792
    else:
3793
      self.wanted = locking.ALL_SET
3794

    
3795
    self.do_locking = self.use_locking
3796

    
3797
  def DeclareLocks(self, lu, level):
3798
    pass
3799

    
3800
  @staticmethod
3801
  def _DiagnoseByOS(rlist):
3802
    """Remaps a per-node return list into an a per-os per-node dictionary
3803

3804
    @param rlist: a map with node names as keys and OS objects as values
3805

3806
    @rtype: dict
3807
    @return: a dictionary with osnames as keys and as value another
3808
        map, with nodes as keys and tuples of (path, status, diagnose,
3809
        variants, parameters, api_versions) as values, eg::
3810

3811
          {"debian-etch": {"node1": [(/usr/lib/..., True, "", [], []),
3812
                                     (/srv/..., False, "invalid api")],
3813
                           "node2": [(/srv/..., True, "", [], [])]}
3814
          }
3815

3816
    """
3817
    all_os = {}
3818
    # we build here the list of nodes that didn't fail the RPC (at RPC
3819
    # level), so that nodes with a non-responding node daemon don't
3820
    # make all OSes invalid
3821
    good_nodes = [node_name for node_name in rlist
3822
                  if not rlist[node_name].fail_msg]
3823
    for node_name, nr in rlist.items():
3824
      if nr.fail_msg or not nr.payload:
3825
        continue
3826
      for (name, path, status, diagnose, variants,
3827
           params, api_versions) in nr.payload:
3828
        if name not in all_os:
3829
          # build a list of nodes for this os containing empty lists
3830
          # for each node in node_list
3831
          all_os[name] = {}
3832
          for nname in good_nodes:
3833
            all_os[name][nname] = []
3834
        # convert params from [name, help] to (name, help)
3835
        params = [tuple(v) for v in params]
3836
        all_os[name][node_name].append((path, status, diagnose,
3837
                                        variants, params, api_versions))
3838
    return all_os
3839

    
3840
  def _GetQueryData(self, lu):
3841
    """Computes the list of nodes and their attributes.
3842

3843
    """
3844
    # Locking is not used
3845
    assert not (compat.any(lu.glm.is_owned(level)
3846
                           for level in locking.LEVELS
3847
                           if level != locking.LEVEL_CLUSTER) or
3848
                self.do_locking or self.use_locking)
3849

    
3850
    valid_nodes = [node.name
3851
                   for node in lu.cfg.GetAllNodesInfo().values()
3852
                   if not node.offline and node.vm_capable]
3853
    pol = self._DiagnoseByOS(lu.rpc.call_os_diagnose(valid_nodes))
3854
    cluster = lu.cfg.GetClusterInfo()
3855

    
3856
    data = {}
3857

    
3858
    for (os_name, os_data) in pol.items():
3859
      info = query.OsInfo(name=os_name, valid=True, node_status=os_data,
3860
                          hidden=(os_name in cluster.hidden_os),
3861
                          blacklisted=(os_name in cluster.blacklisted_os))
3862

    
3863
      variants = set()
3864
      parameters = set()
3865
      api_versions = set()
3866

    
3867
      for idx, osl in enumerate(os_data.values()):
3868
        info.valid = bool(info.valid and osl and osl[0][1])
3869
        if not info.valid:
3870
          break
3871

    
3872
        (node_variants, node_params, node_api) = osl[0][3:6]
3873
        if idx == 0:
3874
          # First entry
3875
          variants.update(node_variants)
3876
          parameters.update(node_params)
3877
          api_versions.update(node_api)
3878
        else:
3879
          # Filter out inconsistent values
3880
          variants.intersection_update(node_variants)
3881
          parameters.intersection_update(node_params)
3882
          api_versions.intersection_update(node_api)
3883

    
3884
      info.variants = list(variants)
3885
      info.parameters = list(parameters)
3886
      info.api_versions = list(api_versions)
3887

    
3888
      data[os_name] = info
3889

    
3890
    # Prepare data in requested order
3891
    return [data[name] for name in self._GetNames(lu, pol.keys(), None)
3892
            if name in data]
3893

    
3894

    
3895
class LUOsDiagnose(NoHooksLU):
3896
  """Logical unit for OS diagnose/query.
3897

3898
  """
3899
  REQ_BGL = False
3900

    
3901
  @staticmethod
3902
  def _BuildFilter(fields, names):
3903
    """Builds a filter for querying OSes.
3904

3905
    """
3906
    name_filter = qlang.MakeSimpleFilter("name", names)
3907

    
3908
    # Legacy behaviour: Hide hidden, blacklisted or invalid OSes if the
3909
    # respective field is not requested
3910
    status_filter = [[qlang.OP_NOT, [qlang.OP_TRUE, fname]]
3911
                     for fname in ["hidden", "blacklisted"]
3912
                     if fname not in fields]
3913
    if "valid" not in fields:
3914
      status_filter.append([qlang.OP_TRUE, "valid"])
3915

    
3916
    if status_filter:
3917
      status_filter.insert(0, qlang.OP_AND)
3918
    else:
3919
      status_filter = None
3920

    
3921
    if name_filter and status_filter:
3922
      return [qlang.OP_AND, name_filter, status_filter]
3923
    elif name_filter:
3924
      return name_filter
3925
    else:
3926
      return status_filter
3927

    
3928
  def CheckArguments(self):
3929
    self.oq = _OsQuery(self._BuildFilter(self.op.output_fields, self.op.names),
3930
                       self.op.output_fields, False)
3931

    
3932
  def ExpandNames(self):
3933
    self.oq.ExpandNames(self)
3934

    
3935
  def Exec(self, feedback_fn):
3936
    return self.oq.OldStyleQuery(self)
3937

    
3938

    
3939
class LUNodeRemove(LogicalUnit):
3940
  """Logical unit for removing a node.
3941

3942
  """
3943
  HPATH = "node-remove"
3944
  HTYPE = constants.HTYPE_NODE
3945

    
3946
  def BuildHooksEnv(self):
3947
    """Build hooks env.
3948

3949
    This doesn't run on the target node in the pre phase as a failed
3950
    node would then be impossible to remove.
3951

3952
    """
3953
    return {
3954
      "OP_TARGET": self.op.node_name,
3955
      "NODE_NAME": self.op.node_name,
3956
      }
3957

    
3958
  def BuildHooksNodes(self):
3959
    """Build hooks nodes.
3960

3961
    """
3962
    all_nodes = self.cfg.GetNodeList()
3963
    try:
3964
      all_nodes.remove(self.op.node_name)
3965
    except ValueError:
3966
      logging.warning("Node '%s', which is about to be removed, was not found"
3967
                      " in the list of all nodes", self.op.node_name)
3968
    return (all_nodes, all_nodes)
3969

    
3970
  def CheckPrereq(self):
3971
    """Check prerequisites.
3972

3973
    This checks:
3974
     - the node exists in the configuration
3975
     - it does not have primary or secondary instances
3976
     - it's not the master
3977

3978
    Any errors are signaled by raising errors.OpPrereqError.
3979

3980
    """
3981
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3982
    node = self.cfg.GetNodeInfo(self.op.node_name)
3983
    assert node is not None
3984

    
3985
    instance_list = self.cfg.GetInstanceList()
3986

    
3987
    masternode = self.cfg.GetMasterNode()
3988
    if node.name == masternode:
3989
      raise errors.OpPrereqError("Node is the master node, failover to another"
3990
                                 " node is required", errors.ECODE_INVAL)
3991

    
3992
    for instance_name in instance_list:
3993
      instance = self.cfg.GetInstanceInfo(instance_name)
3994
      if node.name in instance.all_nodes:
3995
        raise errors.OpPrereqError("Instance %s is still running on the node,"
3996
                                   " please remove first" % instance_name,
3997
                                   errors.ECODE_INVAL)
3998
    self.op.node_name = node.name
3999
    self.node = node
4000

    
4001
  def Exec(self, feedback_fn):
4002
    """Removes the node from the cluster.
4003

4004
    """
4005
    node = self.node
4006
    logging.info("Stopping the node daemon and removing configs from node %s",
4007
                 node.name)
4008

    
4009
    modify_ssh_setup = self.cfg.GetClusterInfo().modify_ssh_setup
4010

    
4011
    # Promote nodes to master candidate as needed
4012
    _AdjustCandidatePool(self, exceptions=[node.name])
4013
    self.context.RemoveNode(node.name)
4014

    
4015
    # Run post hooks on the node before it's removed
4016
    _RunPostHook(self, node.name)
4017

    
4018
    result = self.rpc.call_node_leave_cluster(node.name, modify_ssh_setup)
4019
    msg = result.fail_msg
4020
    if msg:
4021
      self.LogWarning("Errors encountered on the remote node while leaving"
4022
                      " the cluster: %s", msg)
4023

    
4024
    # Remove node from our /etc/hosts
4025
    if self.cfg.GetClusterInfo().modify_etc_hosts:
4026
      master_node = self.cfg.GetMasterNode()
4027
      result = self.rpc.call_etc_hosts_modify(master_node,
4028
                                              constants.ETC_HOSTS_REMOVE,
4029
                                              node.name, None)
4030
      result.Raise("Can't update hosts file with new host data")
4031
      _RedistributeAncillaryFiles(self)
4032

    
4033

    
4034
class _NodeQuery(_QueryBase):
4035
  FIELDS = query.NODE_FIELDS
4036

    
4037
  def ExpandNames(self, lu):
4038
    lu.needed_locks = {}
4039
    lu.share_locks[locking.LEVEL_NODE] = 1
4040

    
4041
    if self.names:
4042
      self.wanted = _GetWantedNodes(lu, self.names)
4043
    else:
4044
      self.wanted = locking.ALL_SET
4045

    
4046
    self.do_locking = (self.use_locking and
4047
                       query.NQ_LIVE in self.requested_data)
4048

    
4049
    if self.do_locking:
4050
      # if we don't request only static fields, we need to lock the nodes
4051
      lu.needed_locks[locking.LEVEL_NODE] = self.wanted
4052

    
4053
  def DeclareLocks(self, lu, level):
4054
    pass
4055

    
4056
  def _GetQueryData(self, lu):
4057
    """Computes the list of nodes and their attributes.
4058

4059
    """
4060
    all_info = lu.cfg.GetAllNodesInfo()
4061

    
4062
    nodenames = self._GetNames(lu, all_info.keys(), locking.LEVEL_NODE)
4063

    
4064
    # Gather data as requested
4065
    if query.NQ_LIVE in self.requested_data:
4066
      # filter out non-vm_capable nodes
4067
      toquery_nodes = [name for name in nodenames if all_info[name].vm_capable]
4068

    
4069
      node_data = lu.rpc.call_node_info(toquery_nodes, lu.cfg.GetVGName(),
4070
                                        lu.cfg.GetHypervisorType())
4071
      live_data = dict((name, nresult.payload)
4072
                       for (name, nresult) in node_data.items()
4073
                       if not nresult.fail_msg and nresult.payload)
4074
    else:
4075
      live_data = None
4076

    
4077
    if query.NQ_INST in self.requested_data:
4078
      node_to_primary = dict([(name, set()) for name in nodenames])
4079
      node_to_secondary = dict([(name, set()) for name in nodenames])
4080

    
4081
      inst_data = lu.cfg.GetAllInstancesInfo()
4082

    
4083
      for inst in inst_data.values():
4084
        if inst.primary_node in node_to_primary:
4085
          node_to_primary[inst.primary_node].add(inst.name)
4086
        for secnode in inst.secondary_nodes:
4087
          if secnode in node_to_secondary:
4088
            node_to_secondary[secnode].add(inst.name)
4089
    else:
4090
      node_to_primary = None
4091
      node_to_secondary = None
4092

    
4093
    if query.NQ_OOB in self.requested_data:
4094
      oob_support = dict((name, bool(_SupportsOob(lu.cfg, node)))
4095
                         for name, node in all_info.iteritems())
4096
    else:
4097
      oob_support = None