Statistics
| Branch: | Tag: | Revision:

root / lib / cmdlib.py @ 7c4c22f5

History | View | Annotate | Download (365.2 kB)

1
#
2
#
3

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

    
21

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

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

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

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

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

    
43
from ganeti import ssh
44
from ganeti import utils
45
from ganeti import errors
46
from ganeti import hypervisor
47
from ganeti import locking
48
from ganeti import constants
49
from ganeti import objects
50
from ganeti import serializer
51
from ganeti import ssconf
52
from ganeti import uidpool
53
from ganeti import compat
54
from ganeti import masterd
55
from ganeti import netutils
56

    
57
import ganeti.masterd.instance # pylint: disable-msg=W0611
58

    
59

    
60
# Modifiable default values; need to define these here before the
61
# actual LUs
62

    
63
def _EmptyList():
64
  """Returns an empty list.
65

66
  """
67
  return []
68

    
69

    
70
def _EmptyDict():
71
  """Returns an empty dict.
72

73
  """
74
  return {}
75

    
76

    
77
#: The without-default default value
78
_NoDefault = object()
79

    
80

    
81
#: The no-type (value to complex to check it in the type system)
82
_NoType = object()
83

    
84

    
85
# Some basic types
86
def _TNotNone(val):
87
  """Checks if the given value is not None.
88

89
  """
90
  return val is not None
91

    
92

    
93
def _TNone(val):
94
  """Checks if the given value is None.
95

96
  """
97
  return val is None
98

    
99

    
100
def _TBool(val):
101
  """Checks if the given value is a boolean.
102

103
  """
104
  return isinstance(val, bool)
105

    
106

    
107
def _TInt(val):
108
  """Checks if the given value is an integer.
109

110
  """
111
  return isinstance(val, int)
112

    
113

    
114
def _TFloat(val):
115
  """Checks if the given value is a float.
116

117
  """
118
  return isinstance(val, float)
119

    
120

    
121
def _TString(val):
122
  """Checks if the given value is a string.
123

124
  """
125
  return isinstance(val, basestring)
126

    
127

    
128
def _TTrue(val):
129
  """Checks if a given value evaluates to a boolean True value.
130

131
  """
132
  return bool(val)
133

    
134

    
135
def _TElemOf(target_list):
136
  """Builds a function that checks if a given value is a member of a list.
137

138
  """
139
  return lambda val: val in target_list
140

    
141

    
142
# Container types
143
def _TList(val):
144
  """Checks if the given value is a list.
145

146
  """
147
  return isinstance(val, list)
148

    
149

    
150
def _TDict(val):
151
  """Checks if the given value is a dictionary.
152

153
  """
154
  return isinstance(val, dict)
155

    
156

    
157
# Combinator types
158
def _TAnd(*args):
159
  """Combine multiple functions using an AND operation.
160

161
  """
162
  def fn(val):
163
    return compat.all(t(val) for t in args)
164
  return fn
165

    
166

    
167
def _TOr(*args):
168
  """Combine multiple functions using an AND operation.
169

170
  """
171
  def fn(val):
172
    return compat.any(t(val) for t in args)
173
  return fn
174

    
175

    
176
# Type aliases
177

    
178
#: a non-empty string
179
_TNonEmptyString = _TAnd(_TString, _TTrue)
180

    
181

    
182
#: a maybe non-empty string
183
_TMaybeString = _TOr(_TNonEmptyString, _TNone)
184

    
185

    
186
#: a maybe boolean (bool or none)
187
_TMaybeBool = _TOr(_TBool, _TNone)
188

    
189

    
190
#: a positive integer
191
_TPositiveInt = _TAnd(_TInt, lambda v: v >= 0)
192

    
193
#: a strictly positive integer
194
_TStrictPositiveInt = _TAnd(_TInt, lambda v: v > 0)
195

    
196

    
197
def _TListOf(my_type):
198
  """Checks if a given value is a list with all elements of the same type.
199

200
  """
201
  return _TAnd(_TList,
202
               lambda lst: compat.all(my_type(v) for v in lst))
203

    
204

    
205
def _TDictOf(key_type, val_type):
206
  """Checks a dict type for the type of its key/values.
207

208
  """
209
  return _TAnd(_TDict,
210
               lambda my_dict: (compat.all(key_type(v) for v in my_dict.keys())
211
                                and compat.all(val_type(v)
212
                                               for v in my_dict.values())))
213

    
214

    
215
# Common opcode attributes
216

    
217
#: output fields for a query operation
218
_POutputFields = ("output_fields", _NoDefault, _TListOf(_TNonEmptyString))
219

    
220

    
221
#: the shutdown timeout
222
_PShutdownTimeout = ("shutdown_timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT,
223
                     _TPositiveInt)
224

    
225
#: the force parameter
226
_PForce = ("force", False, _TBool)
227

    
228
#: a required instance name (for single-instance LUs)
229
_PInstanceName = ("instance_name", _NoDefault, _TNonEmptyString)
230

    
231

    
232
#: a required node name (for single-node LUs)
233
_PNodeName = ("node_name", _NoDefault, _TNonEmptyString)
234

    
235
#: the migration type (live/non-live)
236
_PMigrationMode = ("mode", None, _TOr(_TNone,
237
                                      _TElemOf(constants.HT_MIGRATION_MODES)))
238

    
239
#: the obsolete 'live' mode (boolean)
240
_PMigrationLive = ("live", None, _TMaybeBool)
241

    
242

    
243
# End types
244
class LogicalUnit(object):
245
  """Logical Unit base class.
246

247
  Subclasses must follow these rules:
248
    - implement ExpandNames
249
    - implement CheckPrereq (except when tasklets are used)
250
    - implement Exec (except when tasklets are used)
251
    - implement BuildHooksEnv
252
    - redefine HPATH and HTYPE
253
    - optionally redefine their run requirements:
254
        REQ_BGL: the LU needs to hold the Big Ganeti Lock exclusively
255

256
  Note that all commands require root permissions.
257

258
  @ivar dry_run_result: the value (if any) that will be returned to the caller
259
      in dry-run mode (signalled by opcode dry_run parameter)
260
  @cvar _OP_PARAMS: a list of opcode attributes, their defaults values
261
      they should get if not already defined, and types they must match
262

263
  """
264
  HPATH = None
265
  HTYPE = None
266
  _OP_PARAMS = []
267
  REQ_BGL = True
268

    
269
  def __init__(self, processor, op, context, rpc):
270
    """Constructor for LogicalUnit.
271

272
    This needs to be overridden in derived classes in order to check op
273
    validity.
274

275
    """
276
    self.proc = processor
277
    self.op = op
278
    self.cfg = context.cfg
279
    self.context = context
280
    self.rpc = rpc
281
    # Dicts used to declare locking needs to mcpu
282
    self.needed_locks = None
283
    self.acquired_locks = {}
284
    self.share_locks = dict.fromkeys(locking.LEVELS, 0)
285
    self.add_locks = {}
286
    self.remove_locks = {}
287
    # Used to force good behavior when calling helper functions
288
    self.recalculate_locks = {}
289
    self.__ssh = None
290
    # logging
291
    self.Log = processor.Log # pylint: disable-msg=C0103
292
    self.LogWarning = processor.LogWarning # pylint: disable-msg=C0103
293
    self.LogInfo = processor.LogInfo # pylint: disable-msg=C0103
294
    self.LogStep = processor.LogStep # pylint: disable-msg=C0103
295
    # support for dry-run
296
    self.dry_run_result = None
297
    # support for generic debug attribute
298
    if (not hasattr(self.op, "debug_level") or
299
        not isinstance(self.op.debug_level, int)):
300
      self.op.debug_level = 0
301

    
302
    # Tasklets
303
    self.tasklets = None
304

    
305
    # The new kind-of-type-system
306
    op_id = self.op.OP_ID
307
    for attr_name, aval, test in self._OP_PARAMS:
308
      if not hasattr(op, attr_name):
309
        if aval == _NoDefault:
310
          raise errors.OpPrereqError("Required parameter '%s.%s' missing" %
311
                                     (op_id, attr_name), errors.ECODE_INVAL)
312
        else:
313
          if callable(aval):
314
            dval = aval()
315
          else:
316
            dval = aval
317
          setattr(self.op, attr_name, dval)
318
      attr_val = getattr(op, attr_name)
319
      if test == _NoType:
320
        # no tests here
321
        continue
322
      if not callable(test):
323
        raise errors.ProgrammerError("Validation for parameter '%s.%s' failed,"
324
                                     " given type is not a proper type (%s)" %
325
                                     (op_id, attr_name, test))
326
      if not test(attr_val):
327
        logging.error("OpCode %s, parameter %s, has invalid type %s/value %s",
328
                      self.op.OP_ID, attr_name, type(attr_val), attr_val)
329
        raise errors.OpPrereqError("Parameter '%s.%s' fails validation" %
330
                                   (op_id, attr_name), errors.ECODE_INVAL)
331

    
332
    self.CheckArguments()
333

    
334
  def __GetSSH(self):
335
    """Returns the SshRunner object
336

337
    """
338
    if not self.__ssh:
339
      self.__ssh = ssh.SshRunner(self.cfg.GetClusterName())
340
    return self.__ssh
341

    
342
  ssh = property(fget=__GetSSH)
343

    
344
  def CheckArguments(self):
345
    """Check syntactic validity for the opcode arguments.
346

347
    This method is for doing a simple syntactic check and ensure
348
    validity of opcode parameters, without any cluster-related
349
    checks. While the same can be accomplished in ExpandNames and/or
350
    CheckPrereq, doing these separate is better because:
351

352
      - ExpandNames is left as as purely a lock-related function
353
      - CheckPrereq is run after we have acquired locks (and possible
354
        waited for them)
355

356
    The function is allowed to change the self.op attribute so that
357
    later methods can no longer worry about missing parameters.
358

359
    """
360
    pass
361

    
362
  def ExpandNames(self):
363
    """Expand names for this LU.
364

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

370
    LUs which implement this method must also populate the self.needed_locks
371
    member, as a dict with lock levels as keys, and a list of needed lock names
372
    as values. Rules:
373

374
      - use an empty dict if you don't need any lock
375
      - if you don't need any lock at a particular level omit that level
376
      - don't put anything for the BGL level
377
      - if you want all locks at a level use locking.ALL_SET as a value
378

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

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

387
    Examples::
388

389
      # Acquire all nodes and one instance
390
      self.needed_locks = {
391
        locking.LEVEL_NODE: locking.ALL_SET,
392
        locking.LEVEL_INSTANCE: ['instance1.example.com'],
393
      }
394
      # Acquire just two nodes
395
      self.needed_locks = {
396
        locking.LEVEL_NODE: ['node1.example.com', 'node2.example.com'],
397
      }
398
      # Acquire no locks
399
      self.needed_locks = {} # No, you can't leave it to the default value None
400

401
    """
402
    # The implementation of this method is mandatory only if the new LU is
403
    # concurrent, so that old LUs don't need to be changed all at the same
404
    # time.
405
    if self.REQ_BGL:
406
      self.needed_locks = {} # Exclusive LUs don't need locks.
407
    else:
408
      raise NotImplementedError
409

    
410
  def DeclareLocks(self, level):
411
    """Declare LU locking needs for a level
412

413
    While most LUs can just declare their locking needs at ExpandNames time,
414
    sometimes there's the need to calculate some locks after having acquired
415
    the ones before. This function is called just before acquiring locks at a
416
    particular level, but after acquiring the ones at lower levels, and permits
417
    such calculations. It can be used to modify self.needed_locks, and by
418
    default it does nothing.
419

420
    This function is only called if you have something already set in
421
    self.needed_locks for the level.
422

423
    @param level: Locking level which is going to be locked
424
    @type level: member of ganeti.locking.LEVELS
425

426
    """
427

    
428
  def CheckPrereq(self):
429
    """Check prerequisites for this LU.
430

431
    This method should check that the prerequisites for the execution
432
    of this LU are fulfilled. It can do internode communication, but
433
    it should be idempotent - no cluster or system changes are
434
    allowed.
435

436
    The method should raise errors.OpPrereqError in case something is
437
    not fulfilled. Its return value is ignored.
438

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

442
    """
443
    if self.tasklets is not None:
444
      for (idx, tl) in enumerate(self.tasklets):
445
        logging.debug("Checking prerequisites for tasklet %s/%s",
446
                      idx + 1, len(self.tasklets))
447
        tl.CheckPrereq()
448
    else:
449
      pass
450

    
451
  def Exec(self, feedback_fn):
452
    """Execute the LU.
453

454
    This method should implement the actual work. It should raise
455
    errors.OpExecError for failures that are somewhat dealt with in
456
    code, or expected.
457

458
    """
459
    if self.tasklets is not None:
460
      for (idx, tl) in enumerate(self.tasklets):
461
        logging.debug("Executing tasklet %s/%s", idx + 1, len(self.tasklets))
462
        tl.Exec(feedback_fn)
463
    else:
464
      raise NotImplementedError
465

    
466
  def BuildHooksEnv(self):
467
    """Build hooks environment for this LU.
468

469
    This method should return a three-node tuple consisting of: a dict
470
    containing the environment that will be used for running the
471
    specific hook for this LU, a list of node names on which the hook
472
    should run before the execution, and a list of node names on which
473
    the hook should run after the execution.
474

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

480
    No nodes should be returned as an empty list (and not None).
481

482
    Note that if the HPATH for a LU class is None, this function will
483
    not be called.
484

485
    """
486
    raise NotImplementedError
487

    
488
  def HooksCallBack(self, phase, hook_results, feedback_fn, lu_result):
489
    """Notify the LU about the results of its hooks.
490

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

497
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
498
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
499
    @param hook_results: the results of the multi-node hooks rpc call
500
    @param feedback_fn: function used send feedback back to the caller
501
    @param lu_result: the previous Exec result this LU had, or None
502
        in the PRE phase
503
    @return: the new Exec result, based on the previous result
504
        and hook results
505

506
    """
507
    # API must be kept, thus we ignore the unused argument and could
508
    # be a function warnings
509
    # pylint: disable-msg=W0613,R0201
510
    return lu_result
511

    
512
  def _ExpandAndLockInstance(self):
513
    """Helper function to expand and lock an instance.
514

515
    Many LUs that work on an instance take its name in self.op.instance_name
516
    and need to expand it and then declare the expanded name for locking. This
517
    function does it, and then updates self.op.instance_name to the expanded
518
    name. It also initializes needed_locks as a dict, if this hasn't been done
519
    before.
520

521
    """
522
    if self.needed_locks is None:
523
      self.needed_locks = {}
524
    else:
525
      assert locking.LEVEL_INSTANCE not in self.needed_locks, \
526
        "_ExpandAndLockInstance called with instance-level locks set"
527
    self.op.instance_name = _ExpandInstanceName(self.cfg,
528
                                                self.op.instance_name)
529
    self.needed_locks[locking.LEVEL_INSTANCE] = self.op.instance_name
530

    
531
  def _LockInstancesNodes(self, primary_only=False):
532
    """Helper function to declare instances' nodes for locking.
533

534
    This function should be called after locking one or more instances to lock
535
    their nodes. Its effect is populating self.needed_locks[locking.LEVEL_NODE]
536
    with all primary or secondary nodes for instances already locked and
537
    present in self.needed_locks[locking.LEVEL_INSTANCE].
538

539
    It should be called from DeclareLocks, and for safety only works if
540
    self.recalculate_locks[locking.LEVEL_NODE] is set.
541

542
    In the future it may grow parameters to just lock some instance's nodes, or
543
    to just lock primaries or secondary nodes, if needed.
544

545
    If should be called in DeclareLocks in a way similar to::
546

547
      if level == locking.LEVEL_NODE:
548
        self._LockInstancesNodes()
549

550
    @type primary_only: boolean
551
    @param primary_only: only lock primary nodes of locked instances
552

553
    """
554
    assert locking.LEVEL_NODE in self.recalculate_locks, \
555
      "_LockInstancesNodes helper function called with no nodes to recalculate"
556

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

    
559
    # For now we'll replace self.needed_locks[locking.LEVEL_NODE], but in the
560
    # future we might want to have different behaviors depending on the value
561
    # of self.recalculate_locks[locking.LEVEL_NODE]
562
    wanted_nodes = []
563
    for instance_name in self.acquired_locks[locking.LEVEL_INSTANCE]:
564
      instance = self.context.cfg.GetInstanceInfo(instance_name)
565
      wanted_nodes.append(instance.primary_node)
566
      if not primary_only:
567
        wanted_nodes.extend(instance.secondary_nodes)
568

    
569
    if self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_REPLACE:
570
      self.needed_locks[locking.LEVEL_NODE] = wanted_nodes
571
    elif self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_APPEND:
572
      self.needed_locks[locking.LEVEL_NODE].extend(wanted_nodes)
573

    
574
    del self.recalculate_locks[locking.LEVEL_NODE]
575

    
576

    
577
class NoHooksLU(LogicalUnit): # pylint: disable-msg=W0223
578
  """Simple LU which runs no hooks.
579

580
  This LU is intended as a parent for other LogicalUnits which will
581
  run no hooks, in order to reduce duplicate code.
582

583
  """
584
  HPATH = None
585
  HTYPE = None
586

    
587
  def BuildHooksEnv(self):
588
    """Empty BuildHooksEnv for NoHooksLu.
589

590
    This just raises an error.
591

592
    """
593
    assert False, "BuildHooksEnv called for NoHooksLUs"
594

    
595

    
596
class Tasklet:
597
  """Tasklet base class.
598

599
  Tasklets are subcomponents for LUs. LUs can consist entirely of tasklets or
600
  they can mix legacy code with tasklets. Locking needs to be done in the LU,
601
  tasklets know nothing about locks.
602

603
  Subclasses must follow these rules:
604
    - Implement CheckPrereq
605
    - Implement Exec
606

607
  """
608
  def __init__(self, lu):
609
    self.lu = lu
610

    
611
    # Shortcuts
612
    self.cfg = lu.cfg
613
    self.rpc = lu.rpc
614

    
615
  def CheckPrereq(self):
616
    """Check prerequisites for this tasklets.
617

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

622
    The method should raise errors.OpPrereqError in case something is not
623
    fulfilled. Its return value is ignored.
624

625
    This method should also update all parameters to their canonical form if it
626
    hasn't been done before.
627

628
    """
629
    pass
630

    
631
  def Exec(self, feedback_fn):
632
    """Execute the tasklet.
633

634
    This method should implement the actual work. It should raise
635
    errors.OpExecError for failures that are somewhat dealt with in code, or
636
    expected.
637

638
    """
639
    raise NotImplementedError
640

    
641

    
642
def _GetWantedNodes(lu, nodes):
643
  """Returns list of checked and expanded node names.
644

645
  @type lu: L{LogicalUnit}
646
  @param lu: the logical unit on whose behalf we execute
647
  @type nodes: list
648
  @param nodes: list of node names or None for all nodes
649
  @rtype: list
650
  @return: the list of nodes, sorted
651
  @raise errors.ProgrammerError: if the nodes parameter is wrong type
652

653
  """
654
  if not nodes:
655
    raise errors.ProgrammerError("_GetWantedNodes should only be called with a"
656
      " non-empty list of nodes whose name is to be expanded.")
657

    
658
  wanted = [_ExpandNodeName(lu.cfg, name) for name in nodes]
659
  return utils.NiceSort(wanted)
660

    
661

    
662
def _GetWantedInstances(lu, instances):
663
  """Returns list of checked and expanded instance names.
664

665
  @type lu: L{LogicalUnit}
666
  @param lu: the logical unit on whose behalf we execute
667
  @type instances: list
668
  @param instances: list of instance names or None for all instances
669
  @rtype: list
670
  @return: the list of instances, sorted
671
  @raise errors.OpPrereqError: if the instances parameter is wrong type
672
  @raise errors.OpPrereqError: if any of the passed instances is not found
673

674
  """
675
  if instances:
676
    wanted = [_ExpandInstanceName(lu.cfg, name) for name in instances]
677
  else:
678
    wanted = utils.NiceSort(lu.cfg.GetInstanceList())
679
  return wanted
680

    
681

    
682
def _GetUpdatedParams(old_params, update_dict,
683
                      use_default=True, use_none=False):
684
  """Return the new version of a parameter dictionary.
685

686
  @type old_params: dict
687
  @param old_params: old parameters
688
  @type update_dict: dict
689
  @param update_dict: dict containing new parameter values, or
690
      constants.VALUE_DEFAULT to reset the parameter to its default
691
      value
692
  @param use_default: boolean
693
  @type use_default: whether to recognise L{constants.VALUE_DEFAULT}
694
      values as 'to be deleted' values
695
  @param use_none: boolean
696
  @type use_none: whether to recognise C{None} values as 'to be
697
      deleted' values
698
  @rtype: dict
699
  @return: the new parameter dictionary
700

701
  """
702
  params_copy = copy.deepcopy(old_params)
703
  for key, val in update_dict.iteritems():
704
    if ((use_default and val == constants.VALUE_DEFAULT) or
705
        (use_none and val is None)):
706
      try:
707
        del params_copy[key]
708
      except KeyError:
709
        pass
710
    else:
711
      params_copy[key] = val
712
  return params_copy
713

    
714

    
715
def _CheckOutputFields(static, dynamic, selected):
716
  """Checks whether all selected fields are valid.
717

718
  @type static: L{utils.FieldSet}
719
  @param static: static fields set
720
  @type dynamic: L{utils.FieldSet}
721
  @param dynamic: dynamic fields set
722

723
  """
724
  f = utils.FieldSet()
725
  f.Extend(static)
726
  f.Extend(dynamic)
727

    
728
  delta = f.NonMatching(selected)
729
  if delta:
730
    raise errors.OpPrereqError("Unknown output fields selected: %s"
731
                               % ",".join(delta), errors.ECODE_INVAL)
732

    
733

    
734
def _CheckGlobalHvParams(params):
735
  """Validates that given hypervisor params are not global ones.
736

737
  This will ensure that instances don't get customised versions of
738
  global params.
739

740
  """
741
  used_globals = constants.HVC_GLOBALS.intersection(params)
742
  if used_globals:
743
    msg = ("The following hypervisor parameters are global and cannot"
744
           " be customized at instance level, please modify them at"
745
           " cluster level: %s" % utils.CommaJoin(used_globals))
746
    raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
747

    
748

    
749
def _CheckNodeOnline(lu, node):
750
  """Ensure that a given node is online.
751

752
  @param lu: the LU on behalf of which we make the check
753
  @param node: the node to check
754
  @raise errors.OpPrereqError: if the node is offline
755

756
  """
757
  if lu.cfg.GetNodeInfo(node).offline:
758
    raise errors.OpPrereqError("Can't use offline node %s" % node,
759
                               errors.ECODE_INVAL)
760

    
761

    
762
def _CheckNodeNotDrained(lu, node):
763
  """Ensure that a given node is not drained.
764

765
  @param lu: the LU on behalf of which we make the check
766
  @param node: the node to check
767
  @raise errors.OpPrereqError: if the node is drained
768

769
  """
770
  if lu.cfg.GetNodeInfo(node).drained:
771
    raise errors.OpPrereqError("Can't use drained node %s" % node,
772
                               errors.ECODE_INVAL)
773

    
774

    
775
def _CheckNodeHasOS(lu, node, os_name, force_variant):
776
  """Ensure that a node supports a given OS.
777

778
  @param lu: the LU on behalf of which we make the check
779
  @param node: the node to check
780
  @param os_name: the OS to query about
781
  @param force_variant: whether to ignore variant errors
782
  @raise errors.OpPrereqError: if the node is not supporting the OS
783

784
  """
785
  result = lu.rpc.call_os_get(node, os_name)
786
  result.Raise("OS '%s' not in supported OS list for node %s" %
787
               (os_name, node),
788
               prereq=True, ecode=errors.ECODE_INVAL)
789
  if not force_variant:
790
    _CheckOSVariant(result.payload, os_name)
791

    
792

    
793
def _RequireFileStorage():
794
  """Checks that file storage is enabled.
795

796
  @raise errors.OpPrereqError: when file storage is disabled
797

798
  """
799
  if not constants.ENABLE_FILE_STORAGE:
800
    raise errors.OpPrereqError("File storage disabled at configure time",
801
                               errors.ECODE_INVAL)
802

    
803

    
804
def _CheckDiskTemplate(template):
805
  """Ensure a given disk template is valid.
806

807
  """
808
  if template not in constants.DISK_TEMPLATES:
809
    msg = ("Invalid disk template name '%s', valid templates are: %s" %
810
           (template, utils.CommaJoin(constants.DISK_TEMPLATES)))
811
    raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
812
  if template == constants.DT_FILE:
813
    _RequireFileStorage()
814
  return True
815

    
816

    
817
def _CheckStorageType(storage_type):
818
  """Ensure a given storage type is valid.
819

820
  """
821
  if storage_type not in constants.VALID_STORAGE_TYPES:
822
    raise errors.OpPrereqError("Unknown storage type: %s" % storage_type,
823
                               errors.ECODE_INVAL)
824
  if storage_type == constants.ST_FILE:
825
    _RequireFileStorage()
826
  return True
827

    
828

    
829
def _GetClusterDomainSecret():
830
  """Reads the cluster domain secret.
831

832
  """
833
  return utils.ReadOneLineFile(constants.CLUSTER_DOMAIN_SECRET_FILE,
834
                               strict=True)
835

    
836

    
837
def _CheckInstanceDown(lu, instance, reason):
838
  """Ensure that an instance is not running."""
839
  if instance.admin_up:
840
    raise errors.OpPrereqError("Instance %s is marked to be up, %s" %
841
                               (instance.name, reason), errors.ECODE_STATE)
842

    
843
  pnode = instance.primary_node
844
  ins_l = lu.rpc.call_instance_list([pnode], [instance.hypervisor])[pnode]
845
  ins_l.Raise("Can't contact node %s for instance information" % pnode,
846
              prereq=True, ecode=errors.ECODE_ENVIRON)
847

    
848
  if instance.name in ins_l.payload:
849
    raise errors.OpPrereqError("Instance %s is running, %s" %
850
                               (instance.name, reason), errors.ECODE_STATE)
851

    
852

    
853
def _ExpandItemName(fn, name, kind):
854
  """Expand an item name.
855

856
  @param fn: the function to use for expansion
857
  @param name: requested item name
858
  @param kind: text description ('Node' or 'Instance')
859
  @return: the resolved (full) name
860
  @raise errors.OpPrereqError: if the item is not found
861

862
  """
863
  full_name = fn(name)
864
  if full_name is None:
865
    raise errors.OpPrereqError("%s '%s' not known" % (kind, name),
866
                               errors.ECODE_NOENT)
867
  return full_name
868

    
869

    
870
def _ExpandNodeName(cfg, name):
871
  """Wrapper over L{_ExpandItemName} for nodes."""
872
  return _ExpandItemName(cfg.ExpandNodeName, name, "Node")
873

    
874

    
875
def _ExpandInstanceName(cfg, name):
876
  """Wrapper over L{_ExpandItemName} for instance."""
877
  return _ExpandItemName(cfg.ExpandInstanceName, name, "Instance")
878

    
879

    
880
def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,
881
                          memory, vcpus, nics, disk_template, disks,
882
                          bep, hvp, hypervisor_name):
883
  """Builds instance related env variables for hooks
884

885
  This builds the hook environment from individual variables.
886

887
  @type name: string
888
  @param name: the name of the instance
889
  @type primary_node: string
890
  @param primary_node: the name of the instance's primary node
891
  @type secondary_nodes: list
892
  @param secondary_nodes: list of secondary nodes as strings
893
  @type os_type: string
894
  @param os_type: the name of the instance's OS
895
  @type status: boolean
896
  @param status: the should_run status of the instance
897
  @type memory: string
898
  @param memory: the memory size of the instance
899
  @type vcpus: string
900
  @param vcpus: the count of VCPUs the instance has
901
  @type nics: list
902
  @param nics: list of tuples (ip, mac, mode, link) representing
903
      the NICs the instance has
904
  @type disk_template: string
905
  @param disk_template: the disk template of the instance
906
  @type disks: list
907
  @param disks: the list of (size, mode) pairs
908
  @type bep: dict
909
  @param bep: the backend parameters for the instance
910
  @type hvp: dict
911
  @param hvp: the hypervisor parameters for the instance
912
  @type hypervisor_name: string
913
  @param hypervisor_name: the hypervisor for the instance
914
  @rtype: dict
915
  @return: the hook environment for this instance
916

917
  """
918
  if status:
919
    str_status = "up"
920
  else:
921
    str_status = "down"
922
  env = {
923
    "OP_TARGET": name,
924
    "INSTANCE_NAME": name,
925
    "INSTANCE_PRIMARY": primary_node,
926
    "INSTANCE_SECONDARIES": " ".join(secondary_nodes),
927
    "INSTANCE_OS_TYPE": os_type,
928
    "INSTANCE_STATUS": str_status,
929
    "INSTANCE_MEMORY": memory,
930
    "INSTANCE_VCPUS": vcpus,
931
    "INSTANCE_DISK_TEMPLATE": disk_template,
932
    "INSTANCE_HYPERVISOR": hypervisor_name,
933
  }
934

    
935
  if nics:
936
    nic_count = len(nics)
937
    for idx, (ip, mac, mode, link) in enumerate(nics):
938
      if ip is None:
939
        ip = ""
940
      env["INSTANCE_NIC%d_IP" % idx] = ip
941
      env["INSTANCE_NIC%d_MAC" % idx] = mac
942
      env["INSTANCE_NIC%d_MODE" % idx] = mode
943
      env["INSTANCE_NIC%d_LINK" % idx] = link
944
      if mode == constants.NIC_MODE_BRIDGED:
945
        env["INSTANCE_NIC%d_BRIDGE" % idx] = link
946
  else:
947
    nic_count = 0
948

    
949
  env["INSTANCE_NIC_COUNT"] = nic_count
950

    
951
  if disks:
952
    disk_count = len(disks)
953
    for idx, (size, mode) in enumerate(disks):
954
      env["INSTANCE_DISK%d_SIZE" % idx] = size
955
      env["INSTANCE_DISK%d_MODE" % idx] = mode
956
  else:
957
    disk_count = 0
958

    
959
  env["INSTANCE_DISK_COUNT"] = disk_count
960

    
961
  for source, kind in [(bep, "BE"), (hvp, "HV")]:
962
    for key, value in source.items():
963
      env["INSTANCE_%s_%s" % (kind, key)] = value
964

    
965
  return env
966

    
967

    
968
def _NICListToTuple(lu, nics):
969
  """Build a list of nic information tuples.
970

971
  This list is suitable to be passed to _BuildInstanceHookEnv or as a return
972
  value in LUQueryInstanceData.
973

974
  @type lu:  L{LogicalUnit}
975
  @param lu: the logical unit on whose behalf we execute
976
  @type nics: list of L{objects.NIC}
977
  @param nics: list of nics to convert to hooks tuples
978

979
  """
980
  hooks_nics = []
981
  cluster = lu.cfg.GetClusterInfo()
982
  for nic in nics:
983
    ip = nic.ip
984
    mac = nic.mac
985
    filled_params = cluster.SimpleFillNIC(nic.nicparams)
986
    mode = filled_params[constants.NIC_MODE]
987
    link = filled_params[constants.NIC_LINK]
988
    hooks_nics.append((ip, mac, mode, link))
989
  return hooks_nics
990

    
991

    
992
def _BuildInstanceHookEnvByObject(lu, instance, override=None):
993
  """Builds instance related env variables for hooks from an object.
994

995
  @type lu: L{LogicalUnit}
996
  @param lu: the logical unit on whose behalf we execute
997
  @type instance: L{objects.Instance}
998
  @param instance: the instance for which we should build the
999
      environment
1000
  @type override: dict
1001
  @param override: dictionary with key/values that will override
1002
      our values
1003
  @rtype: dict
1004
  @return: the hook environment dictionary
1005

1006
  """
1007
  cluster = lu.cfg.GetClusterInfo()
1008
  bep = cluster.FillBE(instance)
1009
  hvp = cluster.FillHV(instance)
1010
  args = {
1011
    'name': instance.name,
1012
    'primary_node': instance.primary_node,
1013
    'secondary_nodes': instance.secondary_nodes,
1014
    'os_type': instance.os,
1015
    'status': instance.admin_up,
1016
    'memory': bep[constants.BE_MEMORY],
1017
    'vcpus': bep[constants.BE_VCPUS],
1018
    'nics': _NICListToTuple(lu, instance.nics),
1019
    'disk_template': instance.disk_template,
1020
    'disks': [(disk.size, disk.mode) for disk in instance.disks],
1021
    'bep': bep,
1022
    'hvp': hvp,
1023
    'hypervisor_name': instance.hypervisor,
1024
  }
1025
  if override:
1026
    args.update(override)
1027
  return _BuildInstanceHookEnv(**args) # pylint: disable-msg=W0142
1028

    
1029

    
1030
def _AdjustCandidatePool(lu, exceptions):
1031
  """Adjust the candidate pool after node operations.
1032

1033
  """
1034
  mod_list = lu.cfg.MaintainCandidatePool(exceptions)
1035
  if mod_list:
1036
    lu.LogInfo("Promoted nodes to master candidate role: %s",
1037
               utils.CommaJoin(node.name for node in mod_list))
1038
    for name in mod_list:
1039
      lu.context.ReaddNode(name)
1040
  mc_now, mc_max, _ = lu.cfg.GetMasterCandidateStats(exceptions)
1041
  if mc_now > mc_max:
1042
    lu.LogInfo("Note: more nodes are candidates (%d) than desired (%d)" %
1043
               (mc_now, mc_max))
1044

    
1045

    
1046
def _DecideSelfPromotion(lu, exceptions=None):
1047
  """Decide whether I should promote myself as a master candidate.
1048

1049
  """
1050
  cp_size = lu.cfg.GetClusterInfo().candidate_pool_size
1051
  mc_now, mc_should, _ = lu.cfg.GetMasterCandidateStats(exceptions)
1052
  # the new node will increase mc_max with one, so:
1053
  mc_should = min(mc_should + 1, cp_size)
1054
  return mc_now < mc_should
1055

    
1056

    
1057
def _CheckNicsBridgesExist(lu, target_nics, target_node):
1058
  """Check that the brigdes needed by a list of nics exist.
1059

1060
  """
1061
  cluster = lu.cfg.GetClusterInfo()
1062
  paramslist = [cluster.SimpleFillNIC(nic.nicparams) for nic in target_nics]
1063
  brlist = [params[constants.NIC_LINK] for params in paramslist
1064
            if params[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED]
1065
  if brlist:
1066
    result = lu.rpc.call_bridges_exist(target_node, brlist)
1067
    result.Raise("Error checking bridges on destination node '%s'" %
1068
                 target_node, prereq=True, ecode=errors.ECODE_ENVIRON)
1069

    
1070

    
1071
def _CheckInstanceBridgesExist(lu, instance, node=None):
1072
  """Check that the brigdes needed by an instance exist.
1073

1074
  """
1075
  if node is None:
1076
    node = instance.primary_node
1077
  _CheckNicsBridgesExist(lu, instance.nics, node)
1078

    
1079

    
1080
def _CheckOSVariant(os_obj, name):
1081
  """Check whether an OS name conforms to the os variants specification.
1082

1083
  @type os_obj: L{objects.OS}
1084
  @param os_obj: OS object to check
1085
  @type name: string
1086
  @param name: OS name passed by the user, to check for validity
1087

1088
  """
1089
  if not os_obj.supported_variants:
1090
    return
1091
  try:
1092
    variant = name.split("+", 1)[1]
1093
  except IndexError:
1094
    raise errors.OpPrereqError("OS name must include a variant",
1095
                               errors.ECODE_INVAL)
1096

    
1097
  if variant not in os_obj.supported_variants:
1098
    raise errors.OpPrereqError("Unsupported OS variant", errors.ECODE_INVAL)
1099

    
1100

    
1101
def _GetNodeInstancesInner(cfg, fn):
1102
  return [i for i in cfg.GetAllInstancesInfo().values() if fn(i)]
1103

    
1104

    
1105
def _GetNodeInstances(cfg, node_name):
1106
  """Returns a list of all primary and secondary instances on a node.
1107

1108
  """
1109

    
1110
  return _GetNodeInstancesInner(cfg, lambda inst: node_name in inst.all_nodes)
1111

    
1112

    
1113
def _GetNodePrimaryInstances(cfg, node_name):
1114
  """Returns primary instances on a node.
1115

1116
  """
1117
  return _GetNodeInstancesInner(cfg,
1118
                                lambda inst: node_name == inst.primary_node)
1119

    
1120

    
1121
def _GetNodeSecondaryInstances(cfg, node_name):
1122
  """Returns secondary instances on a node.
1123

1124
  """
1125
  return _GetNodeInstancesInner(cfg,
1126
                                lambda inst: node_name in inst.secondary_nodes)
1127

    
1128

    
1129
def _GetStorageTypeArgs(cfg, storage_type):
1130
  """Returns the arguments for a storage type.
1131

1132
  """
1133
  # Special case for file storage
1134
  if storage_type == constants.ST_FILE:
1135
    # storage.FileStorage wants a list of storage directories
1136
    return [[cfg.GetFileStorageDir()]]
1137

    
1138
  return []
1139

    
1140

    
1141
def _FindFaultyInstanceDisks(cfg, rpc, instance, node_name, prereq):
1142
  faulty = []
1143

    
1144
  for dev in instance.disks:
1145
    cfg.SetDiskID(dev, node_name)
1146

    
1147
  result = rpc.call_blockdev_getmirrorstatus(node_name, instance.disks)
1148
  result.Raise("Failed to get disk status from node %s" % node_name,
1149
               prereq=prereq, ecode=errors.ECODE_ENVIRON)
1150

    
1151
  for idx, bdev_status in enumerate(result.payload):
1152
    if bdev_status and bdev_status.ldisk_status == constants.LDS_FAULTY:
1153
      faulty.append(idx)
1154

    
1155
  return faulty
1156

    
1157

    
1158
def _CheckIAllocatorOrNode(lu, iallocator_slot, node_slot):
1159
  """Check the sanity of iallocator and node arguments and use the
1160
  cluster-wide iallocator if appropriate.
1161

1162
  Check that at most one of (iallocator, node) is specified. If none is
1163
  specified, then the LU's opcode's iallocator slot is filled with the
1164
  cluster-wide default iallocator.
1165

1166
  @type iallocator_slot: string
1167
  @param iallocator_slot: the name of the opcode iallocator slot
1168
  @type node_slot: string
1169
  @param node_slot: the name of the opcode target node slot
1170

1171
  """
1172
  node = getattr(lu.op, node_slot, None)
1173
  iallocator = getattr(lu.op, iallocator_slot, None)
1174

    
1175
  if node is not None and iallocator is not None:
1176
    raise errors.OpPrereqError("Do not specify both, iallocator and node.",
1177
                               errors.ECODE_INVAL)
1178
  elif node is None and iallocator is None:
1179
    default_iallocator = lu.cfg.GetDefaultIAllocator()
1180
    if default_iallocator:
1181
      setattr(lu.op, iallocator_slot, default_iallocator)
1182
    else:
1183
      raise errors.OpPrereqError("No iallocator or node given and no"
1184
                                 " cluster-wide default iallocator found."
1185
                                 " Please specify either an iallocator or a"
1186
                                 " node, or set a cluster-wide default"
1187
                                 " iallocator.")
1188

    
1189

    
1190
class LUPostInitCluster(LogicalUnit):
1191
  """Logical unit for running hooks after cluster initialization.
1192

1193
  """
1194
  HPATH = "cluster-init"
1195
  HTYPE = constants.HTYPE_CLUSTER
1196

    
1197
  def BuildHooksEnv(self):
1198
    """Build hooks env.
1199

1200
    """
1201
    env = {"OP_TARGET": self.cfg.GetClusterName()}
1202
    mn = self.cfg.GetMasterNode()
1203
    return env, [], [mn]
1204

    
1205
  def Exec(self, feedback_fn):
1206
    """Nothing to do.
1207

1208
    """
1209
    return True
1210

    
1211

    
1212
class LUDestroyCluster(LogicalUnit):
1213
  """Logical unit for destroying the cluster.
1214

1215
  """
1216
  HPATH = "cluster-destroy"
1217
  HTYPE = constants.HTYPE_CLUSTER
1218

    
1219
  def BuildHooksEnv(self):
1220
    """Build hooks env.
1221

1222
    """
1223
    env = {"OP_TARGET": self.cfg.GetClusterName()}
1224
    return env, [], []
1225

    
1226
  def CheckPrereq(self):
1227
    """Check prerequisites.
1228

1229
    This checks whether the cluster is empty.
1230

1231
    Any errors are signaled by raising errors.OpPrereqError.
1232

1233
    """
1234
    master = self.cfg.GetMasterNode()
1235

    
1236
    nodelist = self.cfg.GetNodeList()
1237
    if len(nodelist) != 1 or nodelist[0] != master:
1238
      raise errors.OpPrereqError("There are still %d node(s) in"
1239
                                 " this cluster." % (len(nodelist) - 1),
1240
                                 errors.ECODE_INVAL)
1241
    instancelist = self.cfg.GetInstanceList()
1242
    if instancelist:
1243
      raise errors.OpPrereqError("There are still %d instance(s) in"
1244
                                 " this cluster." % len(instancelist),
1245
                                 errors.ECODE_INVAL)
1246

    
1247
  def Exec(self, feedback_fn):
1248
    """Destroys the cluster.
1249

1250
    """
1251
    master = self.cfg.GetMasterNode()
1252

    
1253
    # Run post hooks on master node before it's removed
1254
    hm = self.proc.hmclass(self.rpc.call_hooks_runner, self)
1255
    try:
1256
      hm.RunPhase(constants.HOOKS_PHASE_POST, [master])
1257
    except:
1258
      # pylint: disable-msg=W0702
1259
      self.LogWarning("Errors occurred running hooks on %s" % master)
1260

    
1261
    result = self.rpc.call_node_stop_master(master, False)
1262
    result.Raise("Could not disable the master role")
1263

    
1264
    return master
1265

    
1266

    
1267
def _VerifyCertificate(filename):
1268
  """Verifies a certificate for LUVerifyCluster.
1269

1270
  @type filename: string
1271
  @param filename: Path to PEM file
1272

1273
  """
1274
  try:
1275
    cert = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,
1276
                                           utils.ReadFile(filename))
1277
  except Exception, err: # pylint: disable-msg=W0703
1278
    return (LUVerifyCluster.ETYPE_ERROR,
1279
            "Failed to load X509 certificate %s: %s" % (filename, err))
1280

    
1281
  (errcode, msg) = \
1282
    utils.VerifyX509Certificate(cert, constants.SSL_CERT_EXPIRATION_WARN,
1283
                                constants.SSL_CERT_EXPIRATION_ERROR)
1284

    
1285
  if msg:
1286
    fnamemsg = "While verifying %s: %s" % (filename, msg)
1287
  else:
1288
    fnamemsg = None
1289

    
1290
  if errcode is None:
1291
    return (None, fnamemsg)
1292
  elif errcode == utils.CERT_WARNING:
1293
    return (LUVerifyCluster.ETYPE_WARNING, fnamemsg)
1294
  elif errcode == utils.CERT_ERROR:
1295
    return (LUVerifyCluster.ETYPE_ERROR, fnamemsg)
1296

    
1297
  raise errors.ProgrammerError("Unhandled certificate error code %r" % errcode)
1298

    
1299

    
1300
class LUVerifyCluster(LogicalUnit):
1301
  """Verifies the cluster status.
1302

1303
  """
1304
  HPATH = "cluster-verify"
1305
  HTYPE = constants.HTYPE_CLUSTER
1306
  _OP_PARAMS = [
1307
    ("skip_checks", _EmptyList,
1308
     _TListOf(_TElemOf(constants.VERIFY_OPTIONAL_CHECKS))),
1309
    ("verbose", False, _TBool),
1310
    ("error_codes", False, _TBool),
1311
    ("debug_simulate_errors", False, _TBool),
1312
    ]
1313
  REQ_BGL = False
1314

    
1315
  TCLUSTER = "cluster"
1316
  TNODE = "node"
1317
  TINSTANCE = "instance"
1318

    
1319
  ECLUSTERCFG = (TCLUSTER, "ECLUSTERCFG")
1320
  ECLUSTERCERT = (TCLUSTER, "ECLUSTERCERT")
1321
  EINSTANCEBADNODE = (TINSTANCE, "EINSTANCEBADNODE")
1322
  EINSTANCEDOWN = (TINSTANCE, "EINSTANCEDOWN")
1323
  EINSTANCELAYOUT = (TINSTANCE, "EINSTANCELAYOUT")
1324
  EINSTANCEMISSINGDISK = (TINSTANCE, "EINSTANCEMISSINGDISK")
1325
  EINSTANCEMISSINGDISK = (TINSTANCE, "EINSTANCEMISSINGDISK")
1326
  EINSTANCEWRONGNODE = (TINSTANCE, "EINSTANCEWRONGNODE")
1327
  ENODEDRBD = (TNODE, "ENODEDRBD")
1328
  ENODEDRBDHELPER = (TNODE, "ENODEDRBDHELPER")
1329
  ENODEFILECHECK = (TNODE, "ENODEFILECHECK")
1330
  ENODEHOOKS = (TNODE, "ENODEHOOKS")
1331
  ENODEHV = (TNODE, "ENODEHV")
1332
  ENODELVM = (TNODE, "ENODELVM")
1333
  ENODEN1 = (TNODE, "ENODEN1")
1334
  ENODENET = (TNODE, "ENODENET")
1335
  ENODEOS = (TNODE, "ENODEOS")
1336
  ENODEORPHANINSTANCE = (TNODE, "ENODEORPHANINSTANCE")
1337
  ENODEORPHANLV = (TNODE, "ENODEORPHANLV")
1338
  ENODERPC = (TNODE, "ENODERPC")
1339
  ENODESSH = (TNODE, "ENODESSH")
1340
  ENODEVERSION = (TNODE, "ENODEVERSION")
1341
  ENODESETUP = (TNODE, "ENODESETUP")
1342
  ENODETIME = (TNODE, "ENODETIME")
1343

    
1344
  ETYPE_FIELD = "code"
1345
  ETYPE_ERROR = "ERROR"
1346
  ETYPE_WARNING = "WARNING"
1347

    
1348
  class NodeImage(object):
1349
    """A class representing the logical and physical status of a node.
1350

1351
    @type name: string
1352
    @ivar name: the node name to which this object refers
1353
    @ivar volumes: a structure as returned from
1354
        L{ganeti.backend.GetVolumeList} (runtime)
1355
    @ivar instances: a list of running instances (runtime)
1356
    @ivar pinst: list of configured primary instances (config)
1357
    @ivar sinst: list of configured secondary instances (config)
1358
    @ivar sbp: diction of {secondary-node: list of instances} of all peers
1359
        of this node (config)
1360
    @ivar mfree: free memory, as reported by hypervisor (runtime)
1361
    @ivar dfree: free disk, as reported by the node (runtime)
1362
    @ivar offline: the offline status (config)
1363
    @type rpc_fail: boolean
1364
    @ivar rpc_fail: whether the RPC verify call was successfull (overall,
1365
        not whether the individual keys were correct) (runtime)
1366
    @type lvm_fail: boolean
1367
    @ivar lvm_fail: whether the RPC call didn't return valid LVM data
1368
    @type hyp_fail: boolean
1369
    @ivar hyp_fail: whether the RPC call didn't return the instance list
1370
    @type ghost: boolean
1371
    @ivar ghost: whether this is a known node or not (config)
1372
    @type os_fail: boolean
1373
    @ivar os_fail: whether the RPC call didn't return valid OS data
1374
    @type oslist: list
1375
    @ivar oslist: list of OSes as diagnosed by DiagnoseOS
1376

1377
    """
1378
    def __init__(self, offline=False, name=None):
1379
      self.name = name
1380
      self.volumes = {}
1381
      self.instances = []
1382
      self.pinst = []
1383
      self.sinst = []
1384
      self.sbp = {}
1385
      self.mfree = 0
1386
      self.dfree = 0
1387
      self.offline = offline
1388
      self.rpc_fail = False
1389
      self.lvm_fail = False
1390
      self.hyp_fail = False
1391
      self.ghost = False
1392
      self.os_fail = False
1393
      self.oslist = {}
1394

    
1395
  def ExpandNames(self):
1396
    self.needed_locks = {
1397
      locking.LEVEL_NODE: locking.ALL_SET,
1398
      locking.LEVEL_INSTANCE: locking.ALL_SET,
1399
    }
1400
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
1401

    
1402
  def _Error(self, ecode, item, msg, *args, **kwargs):
1403
    """Format an error message.
1404

1405
    Based on the opcode's error_codes parameter, either format a
1406
    parseable error code, or a simpler error string.
1407

1408
    This must be called only from Exec and functions called from Exec.
1409

1410
    """
1411
    ltype = kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR)
1412
    itype, etxt = ecode
1413
    # first complete the msg
1414
    if args:
1415
      msg = msg % args
1416
    # then format the whole message
1417
    if self.op.error_codes:
1418
      msg = "%s:%s:%s:%s:%s" % (ltype, etxt, itype, item, msg)
1419
    else:
1420
      if item:
1421
        item = " " + item
1422
      else:
1423
        item = ""
1424
      msg = "%s: %s%s: %s" % (ltype, itype, item, msg)
1425
    # and finally report it via the feedback_fn
1426
    self._feedback_fn("  - %s" % msg)
1427

    
1428
  def _ErrorIf(self, cond, *args, **kwargs):
1429
    """Log an error message if the passed condition is True.
1430

1431
    """
1432
    cond = bool(cond) or self.op.debug_simulate_errors
1433
    if cond:
1434
      self._Error(*args, **kwargs)
1435
    # do not mark the operation as failed for WARN cases only
1436
    if kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR) == self.ETYPE_ERROR:
1437
      self.bad = self.bad or cond
1438

    
1439
  def _VerifyNode(self, ninfo, nresult):
1440
    """Perform some basic validation on data returned from a node.
1441

1442
      - check the result data structure is well formed and has all the
1443
        mandatory fields
1444
      - check ganeti version
1445

1446
    @type ninfo: L{objects.Node}
1447
    @param ninfo: the node to check
1448
    @param nresult: the results from the node
1449
    @rtype: boolean
1450
    @return: whether overall this call was successful (and we can expect
1451
         reasonable values in the respose)
1452

1453
    """
1454
    node = ninfo.name
1455
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1456

    
1457
    # main result, nresult should be a non-empty dict
1458
    test = not nresult or not isinstance(nresult, dict)
1459
    _ErrorIf(test, self.ENODERPC, node,
1460
                  "unable to verify node: no data returned")
1461
    if test:
1462
      return False
1463

    
1464
    # compares ganeti version
1465
    local_version = constants.PROTOCOL_VERSION
1466
    remote_version = nresult.get("version", None)
1467
    test = not (remote_version and
1468
                isinstance(remote_version, (list, tuple)) and
1469
                len(remote_version) == 2)
1470
    _ErrorIf(test, self.ENODERPC, node,
1471
             "connection to node returned invalid data")
1472
    if test:
1473
      return False
1474

    
1475
    test = local_version != remote_version[0]
1476
    _ErrorIf(test, self.ENODEVERSION, node,
1477
             "incompatible protocol versions: master %s,"
1478
             " node %s", local_version, remote_version[0])
1479
    if test:
1480
      return False
1481

    
1482
    # node seems compatible, we can actually try to look into its results
1483

    
1484
    # full package version
1485
    self._ErrorIf(constants.RELEASE_VERSION != remote_version[1],
1486
                  self.ENODEVERSION, node,
1487
                  "software version mismatch: master %s, node %s",
1488
                  constants.RELEASE_VERSION, remote_version[1],
1489
                  code=self.ETYPE_WARNING)
1490

    
1491
    hyp_result = nresult.get(constants.NV_HYPERVISOR, None)
1492
    if isinstance(hyp_result, dict):
1493
      for hv_name, hv_result in hyp_result.iteritems():
1494
        test = hv_result is not None
1495
        _ErrorIf(test, self.ENODEHV, node,
1496
                 "hypervisor %s verify failure: '%s'", hv_name, hv_result)
1497

    
1498

    
1499
    test = nresult.get(constants.NV_NODESETUP,
1500
                           ["Missing NODESETUP results"])
1501
    _ErrorIf(test, self.ENODESETUP, node, "node setup error: %s",
1502
             "; ".join(test))
1503

    
1504
    return True
1505

    
1506
  def _VerifyNodeTime(self, ninfo, nresult,
1507
                      nvinfo_starttime, nvinfo_endtime):
1508
    """Check the node time.
1509

1510
    @type ninfo: L{objects.Node}
1511
    @param ninfo: the node to check
1512
    @param nresult: the remote results for the node
1513
    @param nvinfo_starttime: the start time of the RPC call
1514
    @param nvinfo_endtime: the end time of the RPC call
1515

1516
    """
1517
    node = ninfo.name
1518
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1519

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

    
1527
    if ntime_merged < (nvinfo_starttime - constants.NODE_MAX_CLOCK_SKEW):
1528
      ntime_diff = "%.01fs" % abs(nvinfo_starttime - ntime_merged)
1529
    elif ntime_merged > (nvinfo_endtime + constants.NODE_MAX_CLOCK_SKEW):
1530
      ntime_diff = "%.01fs" % abs(ntime_merged - nvinfo_endtime)
1531
    else:
1532
      ntime_diff = None
1533

    
1534
    _ErrorIf(ntime_diff is not None, self.ENODETIME, node,
1535
             "Node time diverges by at least %s from master node time",
1536
             ntime_diff)
1537

    
1538
  def _VerifyNodeLVM(self, ninfo, nresult, vg_name):
1539
    """Check the node time.
1540

1541
    @type ninfo: L{objects.Node}
1542
    @param ninfo: the node to check
1543
    @param nresult: the remote results for the node
1544
    @param vg_name: the configured VG name
1545

1546
    """
1547
    if vg_name is None:
1548
      return
1549

    
1550
    node = ninfo.name
1551
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1552

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

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

    
1575
  def _VerifyNodeNetwork(self, ninfo, nresult):
1576
    """Check the node time.
1577

1578
    @type ninfo: L{objects.Node}
1579
    @param ninfo: the node to check
1580
    @param nresult: the remote results for the node
1581

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

    
1586
    test = constants.NV_NODELIST not in nresult
1587
    _ErrorIf(test, self.ENODESSH, node,
1588
             "node hasn't returned node ssh connectivity data")
1589
    if not test:
1590
      if nresult[constants.NV_NODELIST]:
1591
        for a_node, a_msg in nresult[constants.NV_NODELIST].items():
1592
          _ErrorIf(True, self.ENODESSH, node,
1593
                   "ssh communication with node '%s': %s", a_node, a_msg)
1594

    
1595
    test = constants.NV_NODENETTEST not in nresult
1596
    _ErrorIf(test, self.ENODENET, node,
1597
             "node hasn't returned node tcp connectivity data")
1598
    if not test:
1599
      if nresult[constants.NV_NODENETTEST]:
1600
        nlist = utils.NiceSort(nresult[constants.NV_NODENETTEST].keys())
1601
        for anode in nlist:
1602
          _ErrorIf(True, self.ENODENET, node,
1603
                   "tcp communication with node '%s': %s",
1604
                   anode, nresult[constants.NV_NODENETTEST][anode])
1605

    
1606
    test = constants.NV_MASTERIP not in nresult
1607
    _ErrorIf(test, self.ENODENET, node,
1608
             "node hasn't returned node master IP reachability data")
1609
    if not test:
1610
      if not nresult[constants.NV_MASTERIP]:
1611
        if node == self.master_node:
1612
          msg = "the master node cannot reach the master IP (not configured?)"
1613
        else:
1614
          msg = "cannot reach the master IP"
1615
        _ErrorIf(True, self.ENODENET, node, msg)
1616

    
1617

    
1618
  def _VerifyInstance(self, instance, instanceconfig, node_image):
1619
    """Verify an instance.
1620

1621
    This function checks to see if the required block devices are
1622
    available on the instance's node.
1623

1624
    """
1625
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1626
    node_current = instanceconfig.primary_node
1627

    
1628
    node_vol_should = {}
1629
    instanceconfig.MapLVsByNode(node_vol_should)
1630

    
1631
    for node in node_vol_should:
1632
      n_img = node_image[node]
1633
      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
1634
        # ignore missing volumes on offline or broken nodes
1635
        continue
1636
      for volume in node_vol_should[node]:
1637
        test = volume not in n_img.volumes
1638
        _ErrorIf(test, self.EINSTANCEMISSINGDISK, instance,
1639
                 "volume %s missing on node %s", volume, node)
1640

    
1641
    if instanceconfig.admin_up:
1642
      pri_img = node_image[node_current]
1643
      test = instance not in pri_img.instances and not pri_img.offline
1644
      _ErrorIf(test, self.EINSTANCEDOWN, instance,
1645
               "instance not running on its primary node %s",
1646
               node_current)
1647

    
1648
    for node, n_img in node_image.items():
1649
      if (not node == node_current):
1650
        test = instance in n_img.instances
1651
        _ErrorIf(test, self.EINSTANCEWRONGNODE, instance,
1652
                 "instance should not run on node %s", node)
1653

    
1654
  def _VerifyOrphanVolumes(self, node_vol_should, node_image, reserved):
1655
    """Verify if there are any unknown volumes in the cluster.
1656

1657
    The .os, .swap and backup volumes are ignored. All other volumes are
1658
    reported as unknown.
1659

1660
    @type reserved: L{ganeti.utils.FieldSet}
1661
    @param reserved: a FieldSet of reserved volume names
1662

1663
    """
1664
    for node, n_img in node_image.items():
1665
      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
1666
        # skip non-healthy nodes
1667
        continue
1668
      for volume in n_img.volumes:
1669
        test = ((node not in node_vol_should or
1670
                volume not in node_vol_should[node]) and
1671
                not reserved.Matches(volume))
1672
        self._ErrorIf(test, self.ENODEORPHANLV, node,
1673
                      "volume %s is unknown", volume)
1674

    
1675
  def _VerifyOrphanInstances(self, instancelist, node_image):
1676
    """Verify the list of running instances.
1677

1678
    This checks what instances are running but unknown to the cluster.
1679

1680
    """
1681
    for node, n_img in node_image.items():
1682
      for o_inst in n_img.instances:
1683
        test = o_inst not in instancelist
1684
        self._ErrorIf(test, self.ENODEORPHANINSTANCE, node,
1685
                      "instance %s on node %s should not exist", o_inst, node)
1686

    
1687
  def _VerifyNPlusOneMemory(self, node_image, instance_cfg):
1688
    """Verify N+1 Memory Resilience.
1689

1690
    Check that if one single node dies we can still start all the
1691
    instances it was primary for.
1692

1693
    """
1694
    for node, n_img in node_image.items():
1695
      # This code checks that every node which is now listed as
1696
      # secondary has enough memory to host all instances it is
1697
      # supposed to should a single other node in the cluster fail.
1698
      # FIXME: not ready for failover to an arbitrary node
1699
      # FIXME: does not support file-backed instances
1700
      # WARNING: we currently take into account down instances as well
1701
      # as up ones, considering that even if they're down someone
1702
      # might want to start them even in the event of a node failure.
1703
      for prinode, instances in n_img.sbp.items():
1704
        needed_mem = 0
1705
        for instance in instances:
1706
          bep = self.cfg.GetClusterInfo().FillBE(instance_cfg[instance])
1707
          if bep[constants.BE_AUTO_BALANCE]:
1708
            needed_mem += bep[constants.BE_MEMORY]
1709
        test = n_img.mfree < needed_mem
1710
        self._ErrorIf(test, self.ENODEN1, node,
1711
                      "not enough memory on to accommodate"
1712
                      " failovers should peer node %s fail", prinode)
1713

    
1714
  def _VerifyNodeFiles(self, ninfo, nresult, file_list, local_cksum,
1715
                       master_files):
1716
    """Verifies and computes the node required file checksums.
1717

1718
    @type ninfo: L{objects.Node}
1719
    @param ninfo: the node to check
1720
    @param nresult: the remote results for the node
1721
    @param file_list: required list of files
1722
    @param local_cksum: dictionary of local files and their checksums
1723
    @param master_files: list of files that only masters should have
1724

1725
    """
1726
    node = ninfo.name
1727
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1728

    
1729
    remote_cksum = nresult.get(constants.NV_FILELIST, None)
1730
    test = not isinstance(remote_cksum, dict)
1731
    _ErrorIf(test, self.ENODEFILECHECK, node,
1732
             "node hasn't returned file checksum data")
1733
    if test:
1734
      return
1735

    
1736
    for file_name in file_list:
1737
      node_is_mc = ninfo.master_candidate
1738
      must_have = (file_name not in master_files) or node_is_mc
1739
      # missing
1740
      test1 = file_name not in remote_cksum
1741
      # invalid checksum
1742
      test2 = not test1 and remote_cksum[file_name] != local_cksum[file_name]
1743
      # existing and good
1744
      test3 = not test1 and remote_cksum[file_name] == local_cksum[file_name]
1745
      _ErrorIf(test1 and must_have, self.ENODEFILECHECK, node,
1746
               "file '%s' missing", file_name)
1747
      _ErrorIf(test2 and must_have, self.ENODEFILECHECK, node,
1748
               "file '%s' has wrong checksum", file_name)
1749
      # not candidate and this is not a must-have file
1750
      _ErrorIf(test2 and not must_have, self.ENODEFILECHECK, node,
1751
               "file '%s' should not exist on non master"
1752
               " candidates (and the file is outdated)", file_name)
1753
      # all good, except non-master/non-must have combination
1754
      _ErrorIf(test3 and not must_have, self.ENODEFILECHECK, node,
1755
               "file '%s' should not exist"
1756
               " on non master candidates", file_name)
1757

    
1758
  def _VerifyNodeDrbd(self, ninfo, nresult, instanceinfo, drbd_helper,
1759
                      drbd_map):
1760
    """Verifies and the node DRBD status.
1761

1762
    @type ninfo: L{objects.Node}
1763
    @param ninfo: the node to check
1764
    @param nresult: the remote results for the node
1765
    @param instanceinfo: the dict of instances
1766
    @param drbd_helper: the configured DRBD usermode helper
1767
    @param drbd_map: the DRBD map as returned by
1768
        L{ganeti.config.ConfigWriter.ComputeDRBDMap}
1769

1770
    """
1771
    node = ninfo.name
1772
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1773

    
1774
    if drbd_helper:
1775
      helper_result = nresult.get(constants.NV_DRBDHELPER, None)
1776
      test = (helper_result == None)
1777
      _ErrorIf(test, self.ENODEDRBDHELPER, node,
1778
               "no drbd usermode helper returned")
1779
      if helper_result:
1780
        status, payload = helper_result
1781
        test = not status
1782
        _ErrorIf(test, self.ENODEDRBDHELPER, node,
1783
                 "drbd usermode helper check unsuccessful: %s", payload)
1784
        test = status and (payload != drbd_helper)
1785
        _ErrorIf(test, self.ENODEDRBDHELPER, node,
1786
                 "wrong drbd usermode helper: %s", payload)
1787

    
1788
    # compute the DRBD minors
1789
    node_drbd = {}
1790
    for minor, instance in drbd_map[node].items():
1791
      test = instance not in instanceinfo
1792
      _ErrorIf(test, self.ECLUSTERCFG, None,
1793
               "ghost instance '%s' in temporary DRBD map", instance)
1794
        # ghost instance should not be running, but otherwise we
1795
        # don't give double warnings (both ghost instance and
1796
        # unallocated minor in use)
1797
      if test:
1798
        node_drbd[minor] = (instance, False)
1799
      else:
1800
        instance = instanceinfo[instance]
1801
        node_drbd[minor] = (instance.name, instance.admin_up)
1802

    
1803
    # and now check them
1804
    used_minors = nresult.get(constants.NV_DRBDLIST, [])
1805
    test = not isinstance(used_minors, (tuple, list))
1806
    _ErrorIf(test, self.ENODEDRBD, node,
1807
             "cannot parse drbd status file: %s", str(used_minors))
1808
    if test:
1809
      # we cannot check drbd status
1810
      return
1811

    
1812
    for minor, (iname, must_exist) in node_drbd.items():
1813
      test = minor not in used_minors and must_exist
1814
      _ErrorIf(test, self.ENODEDRBD, node,
1815
               "drbd minor %d of instance %s is not active", minor, iname)
1816
    for minor in used_minors:
1817
      test = minor not in node_drbd
1818
      _ErrorIf(test, self.ENODEDRBD, node,
1819
               "unallocated drbd minor %d is in use", minor)
1820

    
1821
  def _UpdateNodeOS(self, ninfo, nresult, nimg):
1822
    """Builds the node OS structures.
1823

1824
    @type ninfo: L{objects.Node}
1825
    @param ninfo: the node to check
1826
    @param nresult: the remote results for the node
1827
    @param nimg: the node image object
1828

1829
    """
1830
    node = ninfo.name
1831
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1832

    
1833
    remote_os = nresult.get(constants.NV_OSLIST, None)
1834
    test = (not isinstance(remote_os, list) or
1835
            not compat.all(isinstance(v, list) and len(v) == 7
1836
                           for v in remote_os))
1837

    
1838
    _ErrorIf(test, self.ENODEOS, node,
1839
             "node hasn't returned valid OS data")
1840

    
1841
    nimg.os_fail = test
1842

    
1843
    if test:
1844
      return
1845

    
1846
    os_dict = {}
1847

    
1848
    for (name, os_path, status, diagnose,
1849
         variants, parameters, api_ver) in nresult[constants.NV_OSLIST]:
1850

    
1851
      if name not in os_dict:
1852
        os_dict[name] = []
1853

    
1854
      # parameters is a list of lists instead of list of tuples due to
1855
      # JSON lacking a real tuple type, fix it:
1856
      parameters = [tuple(v) for v in parameters]
1857
      os_dict[name].append((os_path, status, diagnose,
1858
                            set(variants), set(parameters), set(api_ver)))
1859

    
1860
    nimg.oslist = os_dict
1861

    
1862
  def _VerifyNodeOS(self, ninfo, nimg, base):
1863
    """Verifies the node OS list.
1864

1865
    @type ninfo: L{objects.Node}
1866
    @param ninfo: the node to check
1867
    @param nimg: the node image object
1868
    @param base: the 'template' node we match against (e.g. from the master)
1869

1870
    """
1871
    node = ninfo.name
1872
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1873

    
1874
    assert not nimg.os_fail, "Entered _VerifyNodeOS with failed OS rpc?"
1875

    
1876
    for os_name, os_data in nimg.oslist.items():
1877
      assert os_data, "Empty OS status for OS %s?!" % os_name
1878
      f_path, f_status, f_diag, f_var, f_param, f_api = os_data[0]
1879
      _ErrorIf(not f_status, self.ENODEOS, node,
1880
               "Invalid OS %s (located at %s): %s", os_name, f_path, f_diag)
1881
      _ErrorIf(len(os_data) > 1, self.ENODEOS, node,
1882
               "OS '%s' has multiple entries (first one shadows the rest): %s",
1883
               os_name, utils.CommaJoin([v[0] for v in os_data]))
1884
      # this will catched in backend too
1885
      _ErrorIf(compat.any(v >= constants.OS_API_V15 for v in f_api)
1886
               and not f_var, self.ENODEOS, node,
1887
               "OS %s with API at least %d does not declare any variant",
1888
               os_name, constants.OS_API_V15)
1889
      # comparisons with the 'base' image
1890
      test = os_name not in base.oslist
1891
      _ErrorIf(test, self.ENODEOS, node,
1892
               "Extra OS %s not present on reference node (%s)",
1893
               os_name, base.name)
1894
      if test:
1895
        continue
1896
      assert base.oslist[os_name], "Base node has empty OS status?"
1897
      _, b_status, _, b_var, b_param, b_api = base.oslist[os_name][0]
1898
      if not b_status:
1899
        # base OS is invalid, skipping
1900
        continue
1901
      for kind, a, b in [("API version", f_api, b_api),
1902
                         ("variants list", f_var, b_var),
1903
                         ("parameters", f_param, b_param)]:
1904
        _ErrorIf(a != b, self.ENODEOS, node,
1905
                 "OS %s %s differs from reference node %s: %s vs. %s",
1906
                 kind, os_name, base.name,
1907
                 utils.CommaJoin(a), utils.CommaJoin(b))
1908

    
1909
    # check any missing OSes
1910
    missing = set(base.oslist.keys()).difference(nimg.oslist.keys())
1911
    _ErrorIf(missing, self.ENODEOS, node,
1912
             "OSes present on reference node %s but missing on this node: %s",
1913
             base.name, utils.CommaJoin(missing))
1914

    
1915
  def _UpdateNodeVolumes(self, ninfo, nresult, nimg, vg_name):
1916
    """Verifies and updates the node volume data.
1917

1918
    This function will update a L{NodeImage}'s internal structures
1919
    with data from the remote call.
1920

1921
    @type ninfo: L{objects.Node}
1922
    @param ninfo: the node to check
1923
    @param nresult: the remote results for the node
1924
    @param nimg: the node image object
1925
    @param vg_name: the configured VG name
1926

1927
    """
1928
    node = ninfo.name
1929
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1930

    
1931
    nimg.lvm_fail = True
1932
    lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")
1933
    if vg_name is None:
1934
      pass
1935
    elif isinstance(lvdata, basestring):
1936
      _ErrorIf(True, self.ENODELVM, node, "LVM problem on node: %s",
1937
               utils.SafeEncode(lvdata))
1938
    elif not isinstance(lvdata, dict):
1939
      _ErrorIf(True, self.ENODELVM, node, "rpc call to node failed (lvlist)")
1940
    else:
1941
      nimg.volumes = lvdata
1942
      nimg.lvm_fail = False
1943

    
1944
  def _UpdateNodeInstances(self, ninfo, nresult, nimg):
1945
    """Verifies and updates the node instance list.
1946

1947
    If the listing was successful, then updates this node's instance
1948
    list. Otherwise, it marks the RPC call as failed for the instance
1949
    list key.
1950

1951
    @type ninfo: L{objects.Node}
1952
    @param ninfo: the node to check
1953
    @param nresult: the remote results for the node
1954
    @param nimg: the node image object
1955

1956
    """
1957
    idata = nresult.get(constants.NV_INSTANCELIST, None)
1958
    test = not isinstance(idata, list)
1959
    self._ErrorIf(test, self.ENODEHV, ninfo.name, "rpc call to node failed"
1960
                  " (instancelist): %s", utils.SafeEncode(str(idata)))
1961
    if test:
1962
      nimg.hyp_fail = True
1963
    else:
1964
      nimg.instances = idata
1965

    
1966
  def _UpdateNodeInfo(self, ninfo, nresult, nimg, vg_name):
1967
    """Verifies and computes a node information map
1968

1969
    @type ninfo: L{objects.Node}
1970
    @param ninfo: the node to check
1971
    @param nresult: the remote results for the node
1972
    @param nimg: the node image object
1973
    @param vg_name: the configured VG name
1974

1975
    """
1976
    node = ninfo.name
1977
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1978

    
1979
    # try to read free memory (from the hypervisor)
1980
    hv_info = nresult.get(constants.NV_HVINFO, None)
1981
    test = not isinstance(hv_info, dict) or "memory_free" not in hv_info
1982
    _ErrorIf(test, self.ENODEHV, node, "rpc call to node failed (hvinfo)")
1983
    if not test:
1984
      try:
1985
        nimg.mfree = int(hv_info["memory_free"])
1986
      except (ValueError, TypeError):
1987
        _ErrorIf(True, self.ENODERPC, node,
1988
                 "node returned invalid nodeinfo, check hypervisor")
1989

    
1990
    # FIXME: devise a free space model for file based instances as well
1991
    if vg_name is not None:
1992
      test = (constants.NV_VGLIST not in nresult or
1993
              vg_name not in nresult[constants.NV_VGLIST])
1994
      _ErrorIf(test, self.ENODELVM, node,
1995
               "node didn't return data for the volume group '%s'"
1996
               " - it is either missing or broken", vg_name)
1997
      if not test:
1998
        try:
1999
          nimg.dfree = int(nresult[constants.NV_VGLIST][vg_name])
2000
        except (ValueError, TypeError):
2001
          _ErrorIf(True, self.ENODERPC, node,
2002
                   "node returned invalid LVM info, check LVM status")
2003

    
2004
  def BuildHooksEnv(self):
2005
    """Build hooks env.
2006

2007
    Cluster-Verify hooks just ran in the post phase and their failure makes
2008
    the output be logged in the verify output and the verification to fail.
2009

2010
    """
2011
    all_nodes = self.cfg.GetNodeList()
2012
    env = {
2013
      "CLUSTER_TAGS": " ".join(self.cfg.GetClusterInfo().GetTags())
2014
      }
2015
    for node in self.cfg.GetAllNodesInfo().values():
2016
      env["NODE_TAGS_%s" % node.name] = " ".join(node.GetTags())
2017

    
2018
    return env, [], all_nodes
2019

    
2020
  def Exec(self, feedback_fn):
2021
    """Verify integrity of cluster, performing various test on nodes.
2022

2023
    """
2024
    self.bad = False
2025
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2026
    verbose = self.op.verbose
2027
    self._feedback_fn = feedback_fn
2028
    feedback_fn("* Verifying global settings")
2029
    for msg in self.cfg.VerifyConfig():
2030
      _ErrorIf(True, self.ECLUSTERCFG, None, msg)
2031

    
2032
    # Check the cluster certificates
2033
    for cert_filename in constants.ALL_CERT_FILES:
2034
      (errcode, msg) = _VerifyCertificate(cert_filename)
2035
      _ErrorIf(errcode, self.ECLUSTERCERT, None, msg, code=errcode)
2036

    
2037
    vg_name = self.cfg.GetVGName()
2038
    drbd_helper = self.cfg.GetDRBDHelper()
2039
    hypervisors = self.cfg.GetClusterInfo().enabled_hypervisors
2040
    cluster = self.cfg.GetClusterInfo()
2041
    nodelist = utils.NiceSort(self.cfg.GetNodeList())
2042
    nodeinfo = [self.cfg.GetNodeInfo(nname) for nname in nodelist]
2043
    instancelist = utils.NiceSort(self.cfg.GetInstanceList())
2044
    instanceinfo = dict((iname, self.cfg.GetInstanceInfo(iname))
2045
                        for iname in instancelist)
2046
    i_non_redundant = [] # Non redundant instances
2047
    i_non_a_balanced = [] # Non auto-balanced instances
2048
    n_offline = 0 # Count of offline nodes
2049
    n_drained = 0 # Count of nodes being drained
2050
    node_vol_should = {}
2051

    
2052
    # FIXME: verify OS list
2053
    # do local checksums
2054
    master_files = [constants.CLUSTER_CONF_FILE]
2055
    master_node = self.master_node = self.cfg.GetMasterNode()
2056
    master_ip = self.cfg.GetMasterIP()
2057

    
2058
    file_names = ssconf.SimpleStore().GetFileList()
2059
    file_names.extend(constants.ALL_CERT_FILES)
2060
    file_names.extend(master_files)
2061
    if cluster.modify_etc_hosts:
2062
      file_names.append(constants.ETC_HOSTS)
2063

    
2064
    local_checksums = utils.FingerprintFiles(file_names)
2065

    
2066
    feedback_fn("* Gathering data (%d nodes)" % len(nodelist))
2067
    node_verify_param = {
2068
      constants.NV_FILELIST: file_names,
2069
      constants.NV_NODELIST: [node.name for node in nodeinfo
2070
                              if not node.offline],
2071
      constants.NV_HYPERVISOR: hypervisors,
2072
      constants.NV_NODENETTEST: [(node.name, node.primary_ip,
2073
                                  node.secondary_ip) for node in nodeinfo
2074
                                 if not node.offline],
2075
      constants.NV_INSTANCELIST: hypervisors,
2076
      constants.NV_VERSION: None,
2077
      constants.NV_HVINFO: self.cfg.GetHypervisorType(),
2078
      constants.NV_NODESETUP: None,
2079
      constants.NV_TIME: None,
2080
      constants.NV_MASTERIP: (master_node, master_ip),
2081
      constants.NV_OSLIST: None,
2082
      }
2083

    
2084
    if vg_name is not None:
2085
      node_verify_param[constants.NV_VGLIST] = None
2086
      node_verify_param[constants.NV_LVLIST] = vg_name
2087
      node_verify_param[constants.NV_PVLIST] = [vg_name]
2088
      node_verify_param[constants.NV_DRBDLIST] = None
2089

    
2090
    if drbd_helper:
2091
      node_verify_param[constants.NV_DRBDHELPER] = drbd_helper
2092

    
2093
    # Build our expected cluster state
2094
    node_image = dict((node.name, self.NodeImage(offline=node.offline,
2095
                                                 name=node.name))
2096
                      for node in nodeinfo)
2097

    
2098
    for instance in instancelist:
2099
      inst_config = instanceinfo[instance]
2100

    
2101
      for nname in inst_config.all_nodes:
2102
        if nname not in node_image:
2103
          # ghost node
2104
          gnode = self.NodeImage(name=nname)
2105
          gnode.ghost = True
2106
          node_image[nname] = gnode
2107

    
2108
      inst_config.MapLVsByNode(node_vol_should)
2109

    
2110
      pnode = inst_config.primary_node
2111
      node_image[pnode].pinst.append(instance)
2112

    
2113
      for snode in inst_config.secondary_nodes:
2114
        nimg = node_image[snode]
2115
        nimg.sinst.append(instance)
2116
        if pnode not in nimg.sbp:
2117
          nimg.sbp[pnode] = []
2118
        nimg.sbp[pnode].append(instance)
2119

    
2120
    # At this point, we have the in-memory data structures complete,
2121
    # except for the runtime information, which we'll gather next
2122

    
2123
    # Due to the way our RPC system works, exact response times cannot be
2124
    # guaranteed (e.g. a broken node could run into a timeout). By keeping the
2125
    # time before and after executing the request, we can at least have a time
2126
    # window.
2127
    nvinfo_starttime = time.time()
2128
    all_nvinfo = self.rpc.call_node_verify(nodelist, node_verify_param,
2129
                                           self.cfg.GetClusterName())
2130
    nvinfo_endtime = time.time()
2131

    
2132
    all_drbd_map = self.cfg.ComputeDRBDMap()
2133

    
2134
    feedback_fn("* Verifying node status")
2135

    
2136
    refos_img = None
2137

    
2138
    for node_i in nodeinfo:
2139
      node = node_i.name
2140
      nimg = node_image[node]
2141

    
2142
      if node_i.offline:
2143
        if verbose:
2144
          feedback_fn("* Skipping offline node %s" % (node,))
2145
        n_offline += 1
2146
        continue
2147

    
2148
      if node == master_node:
2149
        ntype = "master"
2150
      elif node_i.master_candidate:
2151
        ntype = "master candidate"
2152
      elif node_i.drained:
2153
        ntype = "drained"
2154
        n_drained += 1
2155
      else:
2156
        ntype = "regular"
2157
      if verbose:
2158
        feedback_fn("* Verifying node %s (%s)" % (node, ntype))
2159

    
2160
      msg = all_nvinfo[node].fail_msg
2161
      _ErrorIf(msg, self.ENODERPC, node, "while contacting node: %s", msg)
2162
      if msg:
2163
        nimg.rpc_fail = True
2164
        continue
2165

    
2166
      nresult = all_nvinfo[node].payload
2167

    
2168
      nimg.call_ok = self._VerifyNode(node_i, nresult)
2169
      self._VerifyNodeNetwork(node_i, nresult)
2170
      self._VerifyNodeLVM(node_i, nresult, vg_name)
2171
      self._VerifyNodeFiles(node_i, nresult, file_names, local_checksums,
2172
                            master_files)
2173
      self._VerifyNodeDrbd(node_i, nresult, instanceinfo, drbd_helper,
2174
                           all_drbd_map)
2175
      self._VerifyNodeTime(node_i, nresult, nvinfo_starttime, nvinfo_endtime)
2176

    
2177
      self._UpdateNodeVolumes(node_i, nresult, nimg, vg_name)
2178
      self._UpdateNodeInstances(node_i, nresult, nimg)
2179
      self._UpdateNodeInfo(node_i, nresult, nimg, vg_name)
2180
      self._UpdateNodeOS(node_i, nresult, nimg)
2181
      if not nimg.os_fail:
2182
        if refos_img is None:
2183
          refos_img = nimg
2184
        self._VerifyNodeOS(node_i, nimg, refos_img)
2185

    
2186
    feedback_fn("* Verifying instance status")
2187
    for instance in instancelist:
2188
      if verbose:
2189
        feedback_fn("* Verifying instance %s" % instance)
2190
      inst_config = instanceinfo[instance]
2191
      self._VerifyInstance(instance, inst_config, node_image)
2192
      inst_nodes_offline = []
2193

    
2194
      pnode = inst_config.primary_node
2195
      pnode_img = node_image[pnode]
2196
      _ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,
2197
               self.ENODERPC, pnode, "instance %s, connection to"
2198
               " primary node failed", instance)
2199

    
2200
      if pnode_img.offline:
2201
        inst_nodes_offline.append(pnode)
2202

    
2203
      # If the instance is non-redundant we cannot survive losing its primary
2204
      # node, so we are not N+1 compliant. On the other hand we have no disk
2205
      # templates with more than one secondary so that situation is not well
2206
      # supported either.
2207
      # FIXME: does not support file-backed instances
2208
      if not inst_config.secondary_nodes:
2209
        i_non_redundant.append(instance)
2210
      _ErrorIf(len(inst_config.secondary_nodes) > 1, self.EINSTANCELAYOUT,
2211
               instance, "instance has multiple secondary nodes: %s",
2212
               utils.CommaJoin(inst_config.secondary_nodes),
2213
               code=self.ETYPE_WARNING)
2214

    
2215
      if not cluster.FillBE(inst_config)[constants.BE_AUTO_BALANCE]:
2216
        i_non_a_balanced.append(instance)
2217

    
2218
      for snode in inst_config.secondary_nodes:
2219
        s_img = node_image[snode]
2220
        _ErrorIf(s_img.rpc_fail and not s_img.offline, self.ENODERPC, snode,
2221
                 "instance %s, connection to secondary node failed", instance)
2222

    
2223
        if s_img.offline:
2224
          inst_nodes_offline.append(snode)
2225

    
2226
      # warn that the instance lives on offline nodes
2227
      _ErrorIf(inst_nodes_offline, self.EINSTANCEBADNODE, instance,
2228
               "instance lives on offline node(s) %s",
2229
               utils.CommaJoin(inst_nodes_offline))
2230
      # ... or ghost nodes
2231
      for node in inst_config.all_nodes:
2232
        _ErrorIf(node_image[node].ghost, self.EINSTANCEBADNODE, instance,
2233
                 "instance lives on ghost node %s", node)
2234

    
2235
    feedback_fn("* Verifying orphan volumes")
2236
    reserved = utils.FieldSet(*cluster.reserved_lvs)
2237
    self._VerifyOrphanVolumes(node_vol_should, node_image, reserved)
2238

    
2239
    feedback_fn("* Verifying orphan instances")
2240
    self._VerifyOrphanInstances(instancelist, node_image)
2241

    
2242
    if constants.VERIFY_NPLUSONE_MEM not in self.op.skip_checks:
2243
      feedback_fn("* Verifying N+1 Memory redundancy")
2244
      self._VerifyNPlusOneMemory(node_image, instanceinfo)
2245

    
2246
    feedback_fn("* Other Notes")
2247
    if i_non_redundant:
2248
      feedback_fn("  - NOTICE: %d non-redundant instance(s) found."
2249
                  % len(i_non_redundant))
2250

    
2251
    if i_non_a_balanced:
2252
      feedback_fn("  - NOTICE: %d non-auto-balanced instance(s) found."
2253
                  % len(i_non_a_balanced))
2254

    
2255
    if n_offline:
2256
      feedback_fn("  - NOTICE: %d offline node(s) found." % n_offline)
2257

    
2258
    if n_drained:
2259
      feedback_fn("  - NOTICE: %d drained node(s) found." % n_drained)
2260

    
2261
    return not self.bad
2262

    
2263
  def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):
2264
    """Analyze the post-hooks' result
2265

2266
    This method analyses the hook result, handles it, and sends some
2267
    nicely-formatted feedback back to the user.
2268

2269
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
2270
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
2271
    @param hooks_results: the results of the multi-node hooks rpc call
2272
    @param feedback_fn: function used send feedback back to the caller
2273
    @param lu_result: previous Exec result
2274
    @return: the new Exec result, based on the previous result
2275
        and hook results
2276

2277
    """
2278
    # We only really run POST phase hooks, and are only interested in
2279
    # their results
2280
    if phase == constants.HOOKS_PHASE_POST:
2281
      # Used to change hooks' output to proper indentation
2282
      indent_re = re.compile('^', re.M)
2283
      feedback_fn("* Hooks Results")
2284
      assert hooks_results, "invalid result from hooks"
2285

    
2286
      for node_name in hooks_results:
2287
        res = hooks_results[node_name]
2288
        msg = res.fail_msg
2289
        test = msg and not res.offline
2290
        self._ErrorIf(test, self.ENODEHOOKS, node_name,
2291
                      "Communication failure in hooks execution: %s", msg)
2292
        if res.offline or msg:
2293
          # No need to investigate payload if node is offline or gave an error.
2294
          # override manually lu_result here as _ErrorIf only
2295
          # overrides self.bad
2296
          lu_result = 1
2297
          continue
2298
        for script, hkr, output in res.payload:
2299
          test = hkr == constants.HKR_FAIL
2300
          self._ErrorIf(test, self.ENODEHOOKS, node_name,
2301
                        "Script %s failed, output:", script)
2302
          if test:
2303
            output = indent_re.sub('      ', output)
2304
            feedback_fn("%s" % output)
2305
            lu_result = 0
2306

    
2307
      return lu_result
2308

    
2309

    
2310
class LUVerifyDisks(NoHooksLU):
2311
  """Verifies the cluster disks status.
2312

2313
  """
2314
  REQ_BGL = False
2315

    
2316
  def ExpandNames(self):
2317
    self.needed_locks = {
2318
      locking.LEVEL_NODE: locking.ALL_SET,
2319
      locking.LEVEL_INSTANCE: locking.ALL_SET,
2320
    }
2321
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
2322

    
2323
  def Exec(self, feedback_fn):
2324
    """Verify integrity of cluster disks.
2325

2326
    @rtype: tuple of three items
2327
    @return: a tuple of (dict of node-to-node_error, list of instances
2328
        which need activate-disks, dict of instance: (node, volume) for
2329
        missing volumes
2330

2331
    """
2332
    result = res_nodes, res_instances, res_missing = {}, [], {}
2333

    
2334
    vg_name = self.cfg.GetVGName()
2335
    nodes = utils.NiceSort(self.cfg.GetNodeList())
2336
    instances = [self.cfg.GetInstanceInfo(name)
2337
                 for name in self.cfg.GetInstanceList()]
2338

    
2339
    nv_dict = {}
2340
    for inst in instances:
2341
      inst_lvs = {}
2342
      if (not inst.admin_up or
2343
          inst.disk_template not in constants.DTS_NET_MIRROR):
2344
        continue
2345
      inst.MapLVsByNode(inst_lvs)
2346
      # transform { iname: {node: [vol,],},} to {(node, vol): iname}
2347
      for node, vol_list in inst_lvs.iteritems():
2348
        for vol in vol_list:
2349
          nv_dict[(node, vol)] = inst
2350

    
2351
    if not nv_dict:
2352
      return result
2353

    
2354
    node_lvs = self.rpc.call_lv_list(nodes, vg_name)
2355

    
2356
    for node in nodes:
2357
      # node_volume
2358
      node_res = node_lvs[node]
2359
      if node_res.offline:
2360
        continue
2361
      msg = node_res.fail_msg
2362
      if msg:
2363
        logging.warning("Error enumerating LVs on node %s: %s", node, msg)
2364
        res_nodes[node] = msg
2365
        continue
2366

    
2367
      lvs = node_res.payload
2368
      for lv_name, (_, _, lv_online) in lvs.items():
2369
        inst = nv_dict.pop((node, lv_name), None)
2370
        if (not lv_online and inst is not None
2371
            and inst.name not in res_instances):
2372
          res_instances.append(inst.name)
2373

    
2374
    # any leftover items in nv_dict are missing LVs, let's arrange the
2375
    # data better
2376
    for key, inst in nv_dict.iteritems():
2377
      if inst.name not in res_missing:
2378
        res_missing[inst.name] = []
2379
      res_missing[inst.name].append(key)
2380

    
2381
    return result
2382

    
2383

    
2384
class LURepairDiskSizes(NoHooksLU):
2385
  """Verifies the cluster disks sizes.
2386

2387
  """
2388
  _OP_PARAMS = [("instances", _EmptyList, _TListOf(_TNonEmptyString))]
2389
  REQ_BGL = False
2390

    
2391
  def ExpandNames(self):
2392
    if self.op.instances:
2393
      self.wanted_names = []
2394
      for name in self.op.instances:
2395
        full_name = _ExpandInstanceName(self.cfg, name)
2396
        self.wanted_names.append(full_name)
2397
      self.needed_locks = {
2398
        locking.LEVEL_NODE: [],
2399
        locking.LEVEL_INSTANCE: self.wanted_names,
2400
        }
2401
      self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
2402
    else:
2403
      self.wanted_names = None
2404
      self.needed_locks = {
2405
        locking.LEVEL_NODE: locking.ALL_SET,
2406
        locking.LEVEL_INSTANCE: locking.ALL_SET,
2407
        }
2408
    self.share_locks = dict(((i, 1) for i in locking.LEVELS))
2409

    
2410
  def DeclareLocks(self, level):
2411
    if level == locking.LEVEL_NODE and self.wanted_names is not None:
2412
      self._LockInstancesNodes(primary_only=True)
2413

    
2414
  def CheckPrereq(self):
2415
    """Check prerequisites.
2416

2417
    This only checks the optional instance list against the existing names.
2418

2419
    """
2420
    if self.wanted_names is None:
2421
      self.wanted_names = self.acquired_locks[locking.LEVEL_INSTANCE]
2422

    
2423
    self.wanted_instances = [self.cfg.GetInstanceInfo(name) for name
2424
                             in self.wanted_names]
2425

    
2426
  def _EnsureChildSizes(self, disk):
2427
    """Ensure children of the disk have the needed disk size.
2428

2429
    This is valid mainly for DRBD8 and fixes an issue where the
2430
    children have smaller disk size.
2431

2432
    @param disk: an L{ganeti.objects.Disk} object
2433

2434
    """
2435
    if disk.dev_type == constants.LD_DRBD8:
2436
      assert disk.children, "Empty children for DRBD8?"
2437
      fchild = disk.children[0]
2438
      mismatch = fchild.size < disk.size
2439
      if mismatch:
2440
        self.LogInfo("Child disk has size %d, parent %d, fixing",
2441
                     fchild.size, disk.size)
2442
        fchild.size = disk.size
2443

    
2444
      # and we recurse on this child only, not on the metadev
2445
      return self._EnsureChildSizes(fchild) or mismatch
2446
    else:
2447
      return False
2448

    
2449
  def Exec(self, feedback_fn):
2450
    """Verify the size of cluster disks.
2451

2452
    """
2453
    # TODO: check child disks too
2454
    # TODO: check differences in size between primary/secondary nodes
2455
    per_node_disks = {}
2456
    for instance in self.wanted_instances:
2457
      pnode = instance.primary_node
2458
      if pnode not in per_node_disks:
2459
        per_node_disks[pnode] = []
2460
      for idx, disk in enumerate(instance.disks):
2461
        per_node_disks[pnode].append((instance, idx, disk))
2462

    
2463
    changed = []
2464
    for node, dskl in per_node_disks.items():
2465
      newl = [v[2].Copy() for v in dskl]
2466
      for dsk in newl:
2467
        self.cfg.SetDiskID(dsk, node)
2468
      result = self.rpc.call_blockdev_getsizes(node, newl)
2469
      if result.fail_msg:
2470
        self.LogWarning("Failure in blockdev_getsizes call to node"
2471
                        " %s, ignoring", node)
2472
        continue
2473
      if len(result.data) != len(dskl):
2474
        self.LogWarning("Invalid result from node %s, ignoring node results",
2475
                        node)
2476
        continue
2477
      for ((instance, idx, disk), size) in zip(dskl, result.data):
2478
        if size is None:
2479
          self.LogWarning("Disk %d of instance %s did not return size"
2480
                          " information, ignoring", idx, instance.name)
2481
          continue
2482
        if not isinstance(size, (int, long)):
2483
          self.LogWarning("Disk %d of instance %s did not return valid"
2484
                          " size information, ignoring", idx, instance.name)
2485
          continue
2486
        size = size >> 20
2487
        if size != disk.size:
2488
          self.LogInfo("Disk %d of instance %s has mismatched size,"
2489
                       " correcting: recorded %d, actual %d", idx,
2490
                       instance.name, disk.size, size)
2491
          disk.size = size
2492
          self.cfg.Update(instance, feedback_fn)
2493
          changed.append((instance.name, idx, size))
2494
        if self._EnsureChildSizes(disk):
2495
          self.cfg.Update(instance, feedback_fn)
2496
          changed.append((instance.name, idx, disk.size))
2497
    return changed
2498

    
2499

    
2500
class LURenameCluster(LogicalUnit):
2501
  """Rename the cluster.
2502

2503
  """
2504
  HPATH = "cluster-rename"
2505
  HTYPE = constants.HTYPE_CLUSTER
2506
  _OP_PARAMS = [("name", _NoDefault, _TNonEmptyString)]
2507

    
2508
  def BuildHooksEnv(self):
2509
    """Build hooks env.
2510

2511
    """
2512
    env = {
2513
      "OP_TARGET": self.cfg.GetClusterName(),
2514
      "NEW_NAME": self.op.name,
2515
      }
2516
    mn = self.cfg.GetMasterNode()
2517
    all_nodes = self.cfg.GetNodeList()
2518
    return env, [mn], all_nodes
2519

    
2520
  def CheckPrereq(self):
2521
    """Verify that the passed name is a valid one.
2522

2523
    """
2524
    hostname = netutils.GetHostname(name=self.op.name,
2525
                                    family=self.cfg.GetPrimaryIPFamily())
2526

    
2527
    new_name = hostname.name
2528
    self.ip = new_ip = hostname.ip
2529
    old_name = self.cfg.GetClusterName()
2530
    old_ip = self.cfg.GetMasterIP()
2531
    if new_name == old_name and new_ip == old_ip:
2532
      raise errors.OpPrereqError("Neither the name nor the IP address of the"
2533
                                 " cluster has changed",
2534
                                 errors.ECODE_INVAL)
2535
    if new_ip != old_ip:
2536
      if netutils.TcpPing(new_ip, constants.DEFAULT_NODED_PORT):
2537
        raise errors.OpPrereqError("The given cluster IP address (%s) is"
2538
                                   " reachable on the network" %
2539
                                   new_ip, errors.ECODE_NOTUNIQUE)
2540

    
2541
    self.op.name = new_name
2542

    
2543
  def Exec(self, feedback_fn):
2544
    """Rename the cluster.
2545

2546
    """
2547
    clustername = self.op.name
2548
    ip = self.ip
2549

    
2550
    # shutdown the master IP
2551
    master = self.cfg.GetMasterNode()
2552
    result = self.rpc.call_node_stop_master(master, False)
2553
    result.Raise("Could not disable the master role")
2554

    
2555
    try:
2556
      cluster = self.cfg.GetClusterInfo()
2557
      cluster.cluster_name = clustername
2558
      cluster.master_ip = ip
2559
      self.cfg.Update(cluster, feedback_fn)
2560

    
2561
      # update the known hosts file
2562
      ssh.WriteKnownHostsFile(self.cfg, constants.SSH_KNOWN_HOSTS_FILE)
2563
      node_list = self.cfg.GetNodeList()
2564
      try:
2565
        node_list.remove(master)
2566
      except ValueError:
2567
        pass
2568
      result = self.rpc.call_upload_file(node_list,
2569
                                         constants.SSH_KNOWN_HOSTS_FILE)
2570
      for to_node, to_result in result.iteritems():
2571
        msg = to_result.fail_msg
2572
        if msg:
2573
          msg = ("Copy of file %s to node %s failed: %s" %
2574
                 (constants.SSH_KNOWN_HOSTS_FILE, to_node, msg))
2575
          self.proc.LogWarning(msg)
2576

    
2577
    finally:
2578
      result = self.rpc.call_node_start_master(master, False, False)
2579
      msg = result.fail_msg
2580
      if msg:
2581
        self.LogWarning("Could not re-enable the master role on"
2582
                        " the master, please restart manually: %s", msg)
2583

    
2584
    return clustername
2585

    
2586

    
2587
class LUSetClusterParams(LogicalUnit):
2588
  """Change the parameters of the cluster.
2589

2590
  """
2591
  HPATH = "cluster-modify"
2592
  HTYPE = constants.HTYPE_CLUSTER
2593
  _OP_PARAMS = [
2594
    ("vg_name", None, _TMaybeString),
2595
    ("enabled_hypervisors", None,
2596
     _TOr(_TAnd(_TListOf(_TElemOf(constants.HYPER_TYPES)), _TTrue), _TNone)),
2597
    ("hvparams", None, _TOr(_TDictOf(_TNonEmptyString, _TDict), _TNone)),
2598
    ("beparams", None, _TOr(_TDictOf(_TNonEmptyString, _TDict), _TNone)),
2599
    ("os_hvp", None, _TOr(_TDictOf(_TNonEmptyString, _TDict), _TNone)),
2600
    ("osparams", None, _TOr(_TDictOf(_TNonEmptyString, _TDict), _TNone)),
2601
    ("candidate_pool_size", None, _TOr(_TStrictPositiveInt, _TNone)),
2602
    ("uid_pool", None, _NoType),
2603
    ("add_uids", None, _NoType),
2604
    ("remove_uids", None, _NoType),
2605
    ("maintain_node_health", None, _TMaybeBool),
2606
    ("nicparams", None, _TOr(_TDict, _TNone)),
2607
    ("drbd_helper", None, _TOr(_TString, _TNone)),
2608
    ("default_iallocator", None, _TMaybeString),
2609
    ("reserved_lvs", None, _TOr(_TListOf(_TNonEmptyString), _TNone)),
2610
    ]
2611
  REQ_BGL = False
2612

    
2613
  def CheckArguments(self):
2614
    """Check parameters
2615

2616
    """
2617
    if self.op.uid_pool:
2618
      uidpool.CheckUidPool(self.op.uid_pool)
2619

    
2620
    if self.op.add_uids:
2621
      uidpool.CheckUidPool(self.op.add_uids)
2622

    
2623
    if self.op.remove_uids:
2624
      uidpool.CheckUidPool(self.op.remove_uids)
2625

    
2626
  def ExpandNames(self):
2627
    # FIXME: in the future maybe other cluster params won't require checking on
2628
    # all nodes to be modified.
2629
    self.needed_locks = {
2630
      locking.LEVEL_NODE: locking.ALL_SET,
2631
    }
2632
    self.share_locks[locking.LEVEL_NODE] = 1
2633

    
2634
  def BuildHooksEnv(self):
2635
    """Build hooks env.
2636

2637
    """
2638
    env = {
2639
      "OP_TARGET": self.cfg.GetClusterName(),
2640
      "NEW_VG_NAME": self.op.vg_name,
2641
      }
2642
    mn = self.cfg.GetMasterNode()
2643
    return env, [mn], [mn]
2644

    
2645
  def CheckPrereq(self):
2646
    """Check prerequisites.
2647

2648
    This checks whether the given params don't conflict and
2649
    if the given volume group is valid.
2650

2651
    """
2652
    if self.op.vg_name is not None and not self.op.vg_name:
2653
      if self.cfg.HasAnyDiskOfType(constants.LD_LV):
2654
        raise errors.OpPrereqError("Cannot disable lvm storage while lvm-based"
2655
                                   " instances exist", errors.ECODE_INVAL)
2656

    
2657
    if self.op.drbd_helper is not None and not self.op.drbd_helper:
2658
      if self.cfg.HasAnyDiskOfType(constants.LD_DRBD8):
2659
        raise errors.OpPrereqError("Cannot disable drbd helper while"
2660
                                   " drbd-based instances exist",
2661
                                   errors.ECODE_INVAL)
2662

    
2663
    node_list = self.acquired_locks[locking.LEVEL_NODE]
2664

    
2665
    # if vg_name not None, checks given volume group on all nodes
2666
    if self.op.vg_name:
2667
      vglist = self.rpc.call_vg_list(node_list)
2668
      for node in node_list:
2669
        msg = vglist[node].fail_msg
2670
        if msg:
2671
          # ignoring down node
2672
          self.LogWarning("Error while gathering data on node %s"
2673
                          " (ignoring node): %s", node, msg)
2674
          continue
2675
        vgstatus = utils.CheckVolumeGroupSize(vglist[node].payload,
2676
                                              self.op.vg_name,
2677
                                              constants.MIN_VG_SIZE)
2678
        if vgstatus:
2679
          raise errors.OpPrereqError("Error on node '%s': %s" %
2680
                                     (node, vgstatus), errors.ECODE_ENVIRON)
2681

    
2682
    if self.op.drbd_helper:
2683
      # checks given drbd helper on all nodes
2684
      helpers = self.rpc.call_drbd_helper(node_list)
2685
      for node in node_list:
2686
        ninfo = self.cfg.GetNodeInfo(node)
2687
        if ninfo.offline:
2688
          self.LogInfo("Not checking drbd helper on offline node %s", node)
2689
          continue
2690
        msg = helpers[node].fail_msg
2691
        if msg:
2692
          raise errors.OpPrereqError("Error checking drbd helper on node"
2693
                                     " '%s': %s" % (node, msg),
2694
                                     errors.ECODE_ENVIRON)
2695
        node_helper = helpers[node].payload
2696
        if node_helper != self.op.drbd_helper:
2697
          raise errors.OpPrereqError("Error on node '%s': drbd helper is %s" %
2698
                                     (node, node_helper), errors.ECODE_ENVIRON)
2699

    
2700
    self.cluster = cluster = self.cfg.GetClusterInfo()
2701
    # validate params changes
2702
    if self.op.beparams:
2703
      utils.ForceDictType(self.op.beparams, constants.BES_PARAMETER_TYPES)
2704
      self.new_beparams = cluster.SimpleFillBE(self.op.beparams)
2705

    
2706
    if self.op.nicparams:
2707
      utils.ForceDictType(self.op.nicparams, constants.NICS_PARAMETER_TYPES)
2708
      self.new_nicparams = cluster.SimpleFillNIC(self.op.nicparams)
2709
      objects.NIC.CheckParameterSyntax(self.new_nicparams)
2710
      nic_errors = []
2711

    
2712
      # check all instances for consistency
2713
      for instance in self.cfg.GetAllInstancesInfo().values():
2714
        for nic_idx, nic in enumerate(instance.nics):
2715
          params_copy = copy.deepcopy(nic.nicparams)
2716
          params_filled = objects.FillDict(self.new_nicparams, params_copy)
2717

    
2718
          # check parameter syntax
2719
          try:
2720
            objects.NIC.CheckParameterSyntax(params_filled)
2721
          except errors.ConfigurationError, err:
2722
            nic_errors.append("Instance %s, nic/%d: %s" %
2723
                              (instance.name, nic_idx, err))
2724

    
2725
          # if we're moving instances to routed, check that they have an ip
2726
          target_mode = params_filled[constants.NIC_MODE]
2727
          if target_mode == constants.NIC_MODE_ROUTED and not nic.ip:
2728
            nic_errors.append("Instance %s, nic/%d: routed nick with no ip" %
2729
                              (instance.name, nic_idx))
2730
      if nic_errors:
2731
        raise errors.OpPrereqError("Cannot apply the change, errors:\n%s" %
2732
                                   "\n".join(nic_errors))
2733

    
2734
    # hypervisor list/parameters
2735
    self.new_hvparams = new_hvp = objects.FillDict(cluster.hvparams, {})
2736
    if self.op.hvparams:
2737
      for hv_name, hv_dict in self.op.hvparams.items():
2738
        if hv_name not in self.new_hvparams:
2739
          self.new_hvparams[hv_name] = hv_dict
2740
        else:
2741
          self.new_hvparams[hv_name].update(hv_dict)
2742

    
2743
    # os hypervisor parameters
2744
    self.new_os_hvp = objects.FillDict(cluster.os_hvp, {})
2745
    if self.op.os_hvp:
2746
      for os_name, hvs in self.op.os_hvp.items():
2747
        if os_name not in self.new_os_hvp:
2748
          self.new_os_hvp[os_name] = hvs
2749
        else:
2750
          for hv_name, hv_dict in hvs.items():
2751
            if hv_name not in self.new_os_hvp[os_name]:
2752
              self.new_os_hvp[os_name][hv_name] = hv_dict
2753
            else:
2754
              self.new_os_hvp[os_name][hv_name].update(hv_dict)
2755

    
2756
    # os parameters
2757
    self.new_osp = objects.FillDict(cluster.osparams, {})
2758
    if self.op.osparams:
2759
      for os_name, osp in self.op.osparams.items():
2760
        if os_name not in self.new_osp:
2761
          self.new_osp[os_name] = {}
2762

    
2763
        self.new_osp[os_name] = _GetUpdatedParams(self.new_osp[os_name], osp,
2764
                                                  use_none=True)
2765

    
2766
        if not self.new_osp[os_name]:
2767
          # we removed all parameters
2768
          del self.new_osp[os_name]
2769
        else:
2770
          # check the parameter validity (remote check)
2771
          _CheckOSParams(self, False, [self.cfg.GetMasterNode()],
2772
                         os_name, self.new_osp[os_name])
2773

    
2774
    # changes to the hypervisor list
2775
    if self.op.enabled_hypervisors is not None:
2776
      self.hv_list = self.op.enabled_hypervisors
2777
      for hv in self.hv_list:
2778
        # if the hypervisor doesn't already exist in the cluster
2779
        # hvparams, we initialize it to empty, and then (in both
2780
        # cases) we make sure to fill the defaults, as we might not
2781
        # have a complete defaults list if the hypervisor wasn't
2782
        # enabled before
2783
        if hv not in new_hvp:
2784
          new_hvp[hv] = {}
2785
        new_hvp[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], new_hvp[hv])
2786
        utils.ForceDictType(new_hvp[hv], constants.HVS_PARAMETER_TYPES)
2787
    else:
2788
      self.hv_list = cluster.enabled_hypervisors
2789

    
2790
    if self.op.hvparams or self.op.enabled_hypervisors is not None:
2791
      # either the enabled list has changed, or the parameters have, validate
2792
      for hv_name, hv_params in self.new_hvparams.items():
2793
        if ((self.op.hvparams and hv_name in self.op.hvparams) or
2794
            (self.op.enabled_hypervisors and
2795
             hv_name in self.op.enabled_hypervisors)):
2796
          # either this is a new hypervisor, or its parameters have changed
2797
          hv_class = hypervisor.GetHypervisor(hv_name)
2798
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
2799
          hv_class.CheckParameterSyntax(hv_params)
2800
          _CheckHVParams(self, node_list, hv_name, hv_params)
2801

    
2802
    if self.op.os_hvp:
2803
      # no need to check any newly-enabled hypervisors, since the
2804
      # defaults have already been checked in the above code-block
2805
      for os_name, os_hvp in self.new_os_hvp.items():
2806
        for hv_name, hv_params in os_hvp.items():
2807
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
2808
          # we need to fill in the new os_hvp on top of the actual hv_p
2809
          cluster_defaults = self.new_hvparams.get(hv_name, {})
2810
          new_osp = objects.FillDict(cluster_defaults, hv_params)
2811
          hv_class = hypervisor.GetHypervisor(hv_name)
2812
          hv_class.CheckParameterSyntax(new_osp)
2813
          _CheckHVParams(self, node_list, hv_name, new_osp)
2814

    
2815
    if self.op.default_iallocator:
2816
      alloc_script = utils.FindFile(self.op.default_iallocator,
2817
                                    constants.IALLOCATOR_SEARCH_PATH,
2818
                                    os.path.isfile)
2819
      if alloc_script is None:
2820
        raise errors.OpPrereqError("Invalid default iallocator script '%s'"
2821
                                   " specified" % self.op.default_iallocator,
2822
                                   errors.ECODE_INVAL)
2823

    
2824
  def Exec(self, feedback_fn):
2825
    """Change the parameters of the cluster.
2826

2827
    """
2828
    if self.op.vg_name is not None:
2829
      new_volume = self.op.vg_name
2830
      if not new_volume:
2831
        new_volume = None
2832
      if new_volume != self.cfg.GetVGName():
2833
        self.cfg.SetVGName(new_volume)
2834
      else:
2835
        feedback_fn("Cluster LVM configuration already in desired"
2836
                    " state, not changing")
2837
    if self.op.drbd_helper is not None:
2838
      new_helper = self.op.drbd_helper
2839
      if not new_helper:
2840
        new_helper = None
2841
      if new_helper != self.cfg.GetDRBDHelper():
2842
        self.cfg.SetDRBDHelper(new_helper)
2843
      else:
2844
        feedback_fn("Cluster DRBD helper already in desired state,"
2845
                    " not changing")
2846
    if self.op.hvparams:
2847
      self.cluster.hvparams = self.new_hvparams
2848
    if self.op.os_hvp:
2849
      self.cluster.os_hvp = self.new_os_hvp
2850
    if self.op.enabled_hypervisors is not None:
2851
      self.cluster.hvparams = self.new_hvparams
2852
      self.cluster.enabled_hypervisors = self.op.enabled_hypervisors
2853
    if self.op.beparams:
2854
      self.cluster.beparams[constants.PP_DEFAULT] = self.new_beparams
2855
    if self.op.nicparams:
2856
      self.cluster.nicparams[constants.PP_DEFAULT] = self.new_nicparams
2857
    if self.op.osparams:
2858
      self.cluster.osparams = self.new_osp
2859

    
2860
    if self.op.candidate_pool_size is not None:
2861
      self.cluster.candidate_pool_size = self.op.candidate_pool_size
2862
      # we need to update the pool size here, otherwise the save will fail
2863
      _AdjustCandidatePool(self, [])
2864

    
2865
    if self.op.maintain_node_health is not None:
2866
      self.cluster.maintain_node_health = self.op.maintain_node_health
2867

    
2868
    if self.op.add_uids is not None:
2869
      uidpool.AddToUidPool(self.cluster.uid_pool, self.op.add_uids)
2870

    
2871
    if self.op.remove_uids is not None:
2872
      uidpool.RemoveFromUidPool(self.cluster.uid_pool, self.op.remove_uids)
2873

    
2874
    if self.op.uid_pool is not None:
2875
      self.cluster.uid_pool = self.op.uid_pool
2876

    
2877
    if self.op.default_iallocator is not None:
2878
      self.cluster.default_iallocator = self.op.default_iallocator
2879

    
2880
    if self.op.reserved_lvs is not None:
2881
      self.cluster.reserved_lvs = self.op.reserved_lvs
2882

    
2883
    self.cfg.Update(self.cluster, feedback_fn)
2884

    
2885

    
2886
def _RedistributeAncillaryFiles(lu, additional_nodes=None):
2887
  """Distribute additional files which are part of the cluster configuration.
2888

2889
  ConfigWriter takes care of distributing the config and ssconf files, but
2890
  there are more files which should be distributed to all nodes. This function
2891
  makes sure those are copied.
2892

2893
  @param lu: calling logical unit
2894
  @param additional_nodes: list of nodes not in the config to distribute to
2895

2896
  """
2897
  # 1. Gather target nodes
2898
  myself = lu.cfg.GetNodeInfo(lu.cfg.GetMasterNode())
2899
  dist_nodes = lu.cfg.GetOnlineNodeList()
2900
  if additional_nodes is not None:
2901
    dist_nodes.extend(additional_nodes)
2902
  if myself.name in dist_nodes:
2903
    dist_nodes.remove(myself.name)
2904

    
2905
  # 2. Gather files to distribute
2906
  dist_files = set([constants.ETC_HOSTS,
2907
                    constants.SSH_KNOWN_HOSTS_FILE,
2908
                    constants.RAPI_CERT_FILE,
2909
                    constants.RAPI_USERS_FILE,
2910
                    constants.CONFD_HMAC_KEY,
2911
                    constants.CLUSTER_DOMAIN_SECRET_FILE,
2912
                   ])
2913

    
2914
  enabled_hypervisors = lu.cfg.GetClusterInfo().enabled_hypervisors
2915
  for hv_name in enabled_hypervisors:
2916
    hv_class = hypervisor.GetHypervisor(hv_name)
2917
    dist_files.update(hv_class.GetAncillaryFiles())
2918

    
2919
  # 3. Perform the files upload
2920
  for fname in dist_files:
2921
    if os.path.exists(fname):
2922
      result = lu.rpc.call_upload_file(dist_nodes, fname)
2923
      for to_node, to_result in result.items():
2924
        msg = to_result.fail_msg
2925
        if msg:
2926
          msg = ("Copy of file %s to node %s failed: %s" %
2927
                 (fname, to_node, msg))
2928
          lu.proc.LogWarning(msg)
2929

    
2930

    
2931
class LURedistributeConfig(NoHooksLU):
2932
  """Force the redistribution of cluster configuration.
2933

2934
  This is a very simple LU.
2935

2936
  """
2937
  REQ_BGL = False
2938

    
2939
  def ExpandNames(self):
2940
    self.needed_locks = {
2941
      locking.LEVEL_NODE: locking.ALL_SET,
2942
    }
2943
    self.share_locks[locking.LEVEL_NODE] = 1
2944

    
2945
  def Exec(self, feedback_fn):
2946
    """Redistribute the configuration.
2947

2948
    """
2949
    self.cfg.Update(self.cfg.GetClusterInfo(), feedback_fn)
2950
    _RedistributeAncillaryFiles(self)
2951

    
2952

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

2956
  """
2957
  if not instance.disks or disks is not None and not disks:
2958
    return True
2959

    
2960
  disks = _ExpandCheckDisks(instance, disks)
2961

    
2962
  if not oneshot:
2963
    lu.proc.LogInfo("Waiting for instance %s to sync disks." % instance.name)
2964

    
2965
  node = instance.primary_node
2966

    
2967
  for dev in disks:
2968
    lu.cfg.SetDiskID(dev, node)
2969

    
2970
  # TODO: Convert to utils.Retry
2971

    
2972
  retries = 0
2973
  degr_retries = 10 # in seconds, as we sleep 1 second each time
2974
  while True:
2975
    max_time = 0
2976
    done = True
2977
    cumul_degraded = False
2978
    rstats = lu.rpc.call_blockdev_getmirrorstatus(node, disks)
2979
    msg = rstats.fail_msg
2980
    if msg:
2981
      lu.LogWarning("Can't get any data from node %s: %s", node, msg)
2982
      retries += 1
2983
      if retries >= 10:
2984
        raise errors.RemoteError("Can't contact node %s for mirror data,"
2985
                                 " aborting." % node)
2986
      time.sleep(6)
2987
      continue
2988
    rstats = rstats.payload
2989
    retries = 0
2990
    for i, mstat in enumerate(rstats):
2991
      if mstat is None:
2992
        lu.LogWarning("Can't compute data for node %s/%s",
2993
                           node, disks[i].iv_name)
2994
        continue
2995

    
2996
      cumul_degraded = (cumul_degraded or
2997
                        (mstat.is_degraded and mstat.sync_percent is None))
2998
      if mstat.sync_percent is not None:
2999
        done = False
3000
        if mstat.estimated_time is not None:
3001
          rem_time = ("%s remaining (estimated)" %
3002
                      utils.FormatSeconds(mstat.estimated_time))
3003
          max_time = mstat.estimated_time
3004
        else:
3005
          rem_time = "no time estimate"
3006
        lu.proc.LogInfo("- device %s: %5.2f%% done, %s" %
3007
                        (disks[i].iv_name, mstat.sync_percent, rem_time))
3008

    
3009
    # if we're done but degraded, let's do a few small retries, to
3010
    # make sure we see a stable and not transient situation; therefore
3011
    # we force restart of the loop
3012
    if (done or oneshot) and cumul_degraded and degr_retries > 0:
3013
      logging.info("Degraded disks found, %d retries left", degr_retries)
3014
      degr_retries -= 1
3015
      time.sleep(1)
3016
      continue
3017

    
3018
    if done or oneshot:
3019
      break
3020

    
3021
    time.sleep(min(60, max_time))
3022

    
3023
  if done:
3024
    lu.proc.LogInfo("Instance %s's disks are in sync." % instance.name)
3025
  return not cumul_degraded
3026

    
3027

    
3028
def _CheckDiskConsistency(lu, dev, node, on_primary, ldisk=False):
3029
  """Check that mirrors are not degraded.
3030

3031
  The ldisk parameter, if True, will change the test from the
3032
  is_degraded attribute (which represents overall non-ok status for
3033
  the device(s)) to the ldisk (representing the local storage status).
3034

3035
  """
3036
  lu.cfg.SetDiskID(dev, node)
3037

    
3038
  result = True
3039

    
3040
  if on_primary or dev.AssembleOnSecondary():
3041
    rstats = lu.rpc.call_blockdev_find(node, dev)
3042
    msg = rstats.fail_msg
3043
    if msg:
3044
      lu.LogWarning("Can't find disk on node %s: %s", node, msg)
3045
      result = False
3046
    elif not rstats.payload:
3047
      lu.LogWarning("Can't find disk on node %s", node)
3048
      result = False
3049
    else:
3050
      if ldisk:
3051
        result = result and rstats.payload.ldisk_status == constants.LDS_OKAY
3052
      else:
3053
        result = result and not rstats.payload.is_degraded
3054

    
3055
  if dev.children:
3056
    for child in dev.children:
3057
      result = result and _CheckDiskConsistency(lu, child, node, on_primary)
3058

    
3059
  return result
3060

    
3061

    
3062
class LUDiagnoseOS(NoHooksLU):
3063
  """Logical unit for OS diagnose/query.
3064

3065
  """
3066
  _OP_PARAMS = [
3067
    _POutputFields,
3068
    ("names", _EmptyList, _TListOf(_TNonEmptyString)),
3069
    ]
3070
  REQ_BGL = False
3071
  _FIELDS_STATIC = utils.FieldSet()
3072
  _FIELDS_DYNAMIC = utils.FieldSet("name", "valid", "node_status", "variants",
3073
                                   "parameters", "api_versions")
3074

    
3075
  def CheckArguments(self):
3076
    if self.op.names:
3077
      raise errors.OpPrereqError("Selective OS query not supported",
3078
                                 errors.ECODE_INVAL)
3079

    
3080
    _CheckOutputFields(static=self._FIELDS_STATIC,
3081
                       dynamic=self._FIELDS_DYNAMIC,
3082
                       selected=self.op.output_fields)
3083

    
3084
  def ExpandNames(self):
3085
    # Lock all nodes, in shared mode
3086
    # Temporary removal of locks, should be reverted later
3087
    # TODO: reintroduce locks when they are lighter-weight
3088
    self.needed_locks = {}
3089
    #self.share_locks[locking.LEVEL_NODE] = 1
3090
    #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3091

    
3092
  @staticmethod
3093
  def _DiagnoseByOS(rlist):
3094
    """Remaps a per-node return list into an a per-os per-node dictionary
3095

3096
    @param rlist: a map with node names as keys and OS objects as values
3097

3098
    @rtype: dict
3099
    @return: a dictionary with osnames as keys and as value another
3100
        map, with nodes as keys and tuples of (path, status, diagnose,
3101
        variants, parameters, api_versions) as values, eg::
3102

3103
          {"debian-etch": {"node1": [(/usr/lib/..., True, "", [], []),
3104
                                     (/srv/..., False, "invalid api")],
3105
                           "node2": [(/srv/..., True, "", [], [])]}
3106
          }
3107

3108
    """
3109
    all_os = {}
3110
    # we build here the list of nodes that didn't fail the RPC (at RPC
3111
    # level), so that nodes with a non-responding node daemon don't
3112
    # make all OSes invalid
3113
    good_nodes = [node_name for node_name in rlist
3114
                  if not rlist[node_name].fail_msg]
3115
    for node_name, nr in rlist.items():
3116
      if nr.fail_msg or not nr.payload:
3117
        continue
3118
      for (name, path, status, diagnose, variants,
3119
           params, api_versions) in nr.payload:
3120
        if name not in all_os:
3121
          # build a list of nodes for this os containing empty lists
3122
          # for each node in node_list
3123
          all_os[name] = {}
3124
          for nname in good_nodes:
3125
            all_os[name][nname] = []
3126
        # convert params from [name, help] to (name, help)
3127
        params = [tuple(v) for v in params]
3128
        all_os[name][node_name].append((path, status, diagnose,
3129
                                        variants, params, api_versions))
3130
    return all_os
3131

    
3132
  def Exec(self, feedback_fn):
3133
    """Compute the list of OSes.
3134

3135
    """
3136
    valid_nodes = [node for node in self.cfg.GetOnlineNodeList()]
3137
    node_data = self.rpc.call_os_diagnose(valid_nodes)
3138
    pol = self._DiagnoseByOS(node_data)
3139
    output = []
3140

    
3141
    for os_name, os_data in pol.items():
3142
      row = []
3143
      valid = True
3144
      (variants, params, api_versions) = null_state = (set(), set(), set())
3145
      for idx, osl in enumerate(os_data.values()):
3146
        valid = bool(valid and osl and osl[0][1])
3147
        if not valid:
3148
          (variants, params, api_versions) = null_state
3149
          break
3150
        node_variants, node_params, node_api = osl[0][3:6]
3151
        if idx == 0: # first entry
3152
          variants = set(node_variants)
3153
          params = set(node_params)
3154
          api_versions = set(node_api)
3155
        else: # keep consistency
3156
          variants.intersection_update(node_variants)
3157
          params.intersection_update(node_params)
3158
          api_versions.intersection_update(node_api)
3159

    
3160
      for field in self.op.output_fields:
3161
        if field == "name":
3162
          val = os_name
3163
        elif field == "valid":
3164
          val = valid
3165
        elif field == "node_status":
3166
          # this is just a copy of the dict
3167
          val = {}
3168
          for node_name, nos_list in os_data.items():
3169
            val[node_name] = nos_list
3170
        elif field == "variants":
3171
          val = list(variants)
3172
        elif field == "parameters":
3173
          val = list(params)
3174
        elif field == "api_versions":
3175
          val = list(api_versions)
3176
        else:
3177
          raise errors.ParameterError(field)
3178
        row.append(val)
3179
      output.append(row)
3180

    
3181
    return output
3182

    
3183

    
3184
class LURemoveNode(LogicalUnit):
3185
  """Logical unit for removing a node.
3186

3187
  """
3188
  HPATH = "node-remove"
3189
  HTYPE = constants.HTYPE_NODE
3190
  _OP_PARAMS = [
3191
    _PNodeName,
3192
    ]
3193

    
3194
  def BuildHooksEnv(self):
3195
    """Build hooks env.
3196

3197
    This doesn't run on the target node in the pre phase as a failed
3198
    node would then be impossible to remove.
3199

3200
    """
3201
    env = {
3202
      "OP_TARGET": self.op.node_name,
3203
      "NODE_NAME": self.op.node_name,
3204
      }
3205
    all_nodes = self.cfg.GetNodeList()
3206
    try:
3207
      all_nodes.remove(self.op.node_name)
3208
    except ValueError:
3209
      logging.warning("Node %s which is about to be removed not found"
3210
                      " in the all nodes list", self.op.node_name)
3211
    return env, all_nodes, all_nodes
3212

    
3213
  def CheckPrereq(self):
3214
    """Check prerequisites.
3215

3216
    This checks:
3217
     - the node exists in the configuration
3218
     - it does not have primary or secondary instances
3219
     - it's not the master
3220

3221
    Any errors are signaled by raising errors.OpPrereqError.
3222

3223
    """
3224
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3225
    node = self.cfg.GetNodeInfo(self.op.node_name)
3226
    assert node is not None
3227

    
3228
    instance_list = self.cfg.GetInstanceList()
3229

    
3230
    masternode = self.cfg.GetMasterNode()
3231
    if node.name == masternode:
3232
      raise errors.OpPrereqError("Node is the master node,"
3233
                                 " you need to failover first.",
3234
                                 errors.ECODE_INVAL)
3235

    
3236
    for instance_name in instance_list:
3237
      instance = self.cfg.GetInstanceInfo(instance_name)
3238
      if node.name in instance.all_nodes:
3239
        raise errors.OpPrereqError("Instance %s is still running on the node,"
3240
                                   " please remove first." % instance_name,
3241
                                   errors.ECODE_INVAL)
3242
    self.op.node_name = node.name
3243
    self.node = node
3244

    
3245
  def Exec(self, feedback_fn):
3246
    """Removes the node from the cluster.
3247

3248
    """
3249
    node = self.node
3250
    logging.info("Stopping the node daemon and removing configs from node %s",
3251
                 node.name)
3252

    
3253
    modify_ssh_setup = self.cfg.GetClusterInfo().modify_ssh_setup
3254

    
3255
    # Promote nodes to master candidate as needed
3256
    _AdjustCandidatePool(self, exceptions=[node.name])
3257
    self.context.RemoveNode(node.name)
3258

    
3259
    # Run post hooks on the node before it's removed
3260
    hm = self.proc.hmclass(self.rpc.call_hooks_runner, self)
3261
    try:
3262
      hm.RunPhase(constants.HOOKS_PHASE_POST, [node.name])
3263
    except:
3264
      # pylint: disable-msg=W0702
3265
      self.LogWarning("Errors occurred running hooks on %s" % node.name)
3266

    
3267
    result = self.rpc.call_node_leave_cluster(node.name, modify_ssh_setup)
3268
    msg = result.fail_msg
3269
    if msg:
3270
      self.LogWarning("Errors encountered on the remote node while leaving"
3271
                      " the cluster: %s", msg)
3272

    
3273
    # Remove node from our /etc/hosts
3274
    if self.cfg.GetClusterInfo().modify_etc_hosts:
3275
      # FIXME: this should be done via an rpc call to node daemon
3276
      utils.RemoveHostFromEtcHosts(node.name)
3277
      _RedistributeAncillaryFiles(self)
3278

    
3279

    
3280
class LUQueryNodes(NoHooksLU):
3281
  """Logical unit for querying nodes.
3282

3283
  """
3284
  # pylint: disable-msg=W0142
3285
  _OP_PARAMS = [
3286
    _POutputFields,
3287
    ("names", _EmptyList, _TListOf(_TNonEmptyString)),
3288
    ("use_locking", False, _TBool),
3289
    ]
3290
  REQ_BGL = False
3291

    
3292
  _SIMPLE_FIELDS = ["name", "serial_no", "ctime", "mtime", "uuid",
3293
                    "master_candidate", "offline", "drained"]
3294

    
3295
  _FIELDS_DYNAMIC = utils.FieldSet(
3296
    "dtotal", "dfree",
3297
    "mtotal", "mnode", "mfree",
3298
    "bootid",
3299
    "ctotal", "cnodes", "csockets",
3300
    )
3301

    
3302
  _FIELDS_STATIC = utils.FieldSet(*[
3303
    "pinst_cnt", "sinst_cnt",
3304
    "pinst_list", "sinst_list",
3305
    "pip", "sip", "tags",
3306
    "master",
3307
    "role"] + _SIMPLE_FIELDS
3308
    )
3309

    
3310
  def CheckArguments(self):
3311
    _CheckOutputFields(static=self._FIELDS_STATIC,
3312
                       dynamic=self._FIELDS_DYNAMIC,
3313
                       selected=self.op.output_fields)
3314

    
3315
  def ExpandNames(self):
3316
    self.needed_locks = {}
3317
    self.share_locks[locking.LEVEL_NODE] = 1
3318

    
3319
    if self.op.names:
3320
      self.wanted = _GetWantedNodes(self, self.op.names)
3321
    else:
3322
      self.wanted = locking.ALL_SET
3323

    
3324
    self.do_node_query = self._FIELDS_STATIC.NonMatching(self.op.output_fields)
3325
    self.do_locking = self.do_node_query and self.op.use_locking
3326
    if self.do_locking:
3327
      # if we don't request only static fields, we need to lock the nodes
3328
      self.needed_locks[locking.LEVEL_NODE] = self.wanted
3329

    
3330
  def Exec(self, feedback_fn):
3331
    """Computes the list of nodes and their attributes.
3332

3333
    """
3334
    all_info = self.cfg.GetAllNodesInfo()
3335
    if self.do_locking:
3336
      nodenames = self.acquired_locks[locking.LEVEL_NODE]
3337
    elif self.wanted != locking.ALL_SET:
3338
      nodenames = self.wanted
3339
      missing = set(nodenames).difference(all_info.keys())
3340
      if missing:
3341
        raise errors.OpExecError(
3342
          "Some nodes were removed before retrieving their data: %s" % missing)
3343
    else:
3344
      nodenames = all_info.keys()
3345

    
3346
    nodenames = utils.NiceSort(nodenames)
3347
    nodelist = [all_info[name] for name in nodenames]
3348

    
3349
    # begin data gathering
3350

    
3351
    if self.do_node_query:
3352
      live_data = {}
3353
      node_data = self.rpc.call_node_info(nodenames, self.cfg.GetVGName(),
3354
                                          self.cfg.GetHypervisorType())
3355
      for name in nodenames:
3356
        nodeinfo = node_data[name]
3357
        if not nodeinfo.fail_msg and nodeinfo.payload:
3358
          nodeinfo = nodeinfo.payload
3359
          fn = utils.TryConvert
3360
          live_data[name] = {
3361
            "mtotal": fn(int, nodeinfo.get('memory_total', None)),
3362
            "mnode": fn(int, nodeinfo.get('memory_dom0', None)),
3363
            "mfree": fn(int, nodeinfo.get('memory_free', None)),
3364
            "dtotal": fn(int, nodeinfo.get('vg_size', None)),
3365
            "dfree": fn(int, nodeinfo.get('vg_free', None)),
3366
            "ctotal": fn(int, nodeinfo.get('cpu_total', None)),
3367
            "bootid": nodeinfo.get('bootid', None),
3368
            "cnodes": fn(int, nodeinfo.get('cpu_nodes', None)),
3369
            "csockets": fn(int, nodeinfo.get('cpu_sockets', None)),
3370
            }
3371
        else:
3372
          live_data[name] = {}
3373
    else:
3374
      live_data = dict.fromkeys(nodenames, {})
3375

    
3376
    node_to_primary = dict([(name, set()) for name in nodenames])
3377
    node_to_secondary = dict([(name, set()) for name in nodenames])
3378

    
3379
    inst_fields = frozenset(("pinst_cnt", "pinst_list",
3380
                             "sinst_cnt", "sinst_list"))
3381
    if inst_fields & frozenset(self.op.output_fields):
3382
      inst_data = self.cfg.GetAllInstancesInfo()
3383

    
3384
      for inst in inst_data.values():
3385
        if inst.primary_node in node_to_primary:
3386
          node_to_primary[inst.primary_node].add(inst.name)
3387
        for secnode in inst.secondary_nodes:
3388
          if secnode in node_to_secondary:
3389
            node_to_secondary[secnode].add(inst.name)
3390

    
3391
    master_node = self.cfg.GetMasterNode()
3392

    
3393
    # end data gathering
3394

    
3395
    output = []
3396
    for node in nodelist:
3397
      node_output = []
3398
      for field in self.op.output_fields:
3399
        if field in self._SIMPLE_FIELDS:
3400
          val = getattr(node, field)
3401
        elif field == "pinst_list":
3402
          val = list(node_to_primary[node.name])
3403
        elif field == "sinst_list":
3404
          val = list(node_to_secondary[node.name])
3405
        elif field == "pinst_cnt":
3406
          val = len(node_to_primary[node.name])
3407
        elif field == "sinst_cnt":
3408
          val = len(node_to_secondary[node.name])
3409
        elif field == "pip":
3410
          val = node.primary_ip
3411
        elif field == "sip":
3412
          val = node.secondary_ip
3413
        elif field == "tags":
3414
          val = list(node.GetTags())
3415
        elif field == "master":
3416
          val = node.name == master_node
3417
        elif self._FIELDS_DYNAMIC.Matches(field):
3418
          val = live_data[node.name].get(field, None)
3419
        elif field == "role":
3420
          if node.name == master_node:
3421
            val = "M"
3422
          elif node.master_candidate:
3423
            val = "C"
3424
          elif node.drained:
3425
            val = "D"
3426
          elif node.offline:
3427
            val = "O"
3428
          else:
3429
            val = "R"
3430
        else:
3431
          raise errors.ParameterError(field)
3432
        node_output.append(val)
3433
      output.append(node_output)
3434

    
3435
    return output
3436

    
3437

    
3438
class LUQueryNodeVolumes(NoHooksLU):
3439
  """Logical unit for getting volumes on node(s).
3440

3441
  """
3442
  _OP_PARAMS = [
3443
    ("nodes", _EmptyList, _TListOf(_TNonEmptyString)),
3444
    ("output_fields", _NoDefault, _TListOf(_TNonEmptyString)),
3445
    ]
3446
  REQ_BGL = False
3447
  _FIELDS_DYNAMIC = utils.FieldSet("phys", "vg", "name", "size", "instance")
3448
  _FIELDS_STATIC = utils.FieldSet("node")
3449

    
3450
  def CheckArguments(self):
3451
    _CheckOutputFields(static=self._FIELDS_STATIC,
3452
                       dynamic=self._FIELDS_DYNAMIC,
3453
                       selected=self.op.output_fields)
3454

    
3455
  def ExpandNames(self):
3456
    self.needed_locks = {}
3457
    self.share_locks[locking.LEVEL_NODE] = 1
3458
    if not self.op.nodes:
3459
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3460
    else:
3461
      self.needed_locks[locking.LEVEL_NODE] = \
3462
        _GetWantedNodes(self, self.op.nodes)
3463

    
3464
  def Exec(self, feedback_fn):
3465
    """Computes the list of nodes and their attributes.
3466

3467
    """
3468
    nodenames = self.acquired_locks[locking.LEVEL_NODE]
3469
    volumes = self.rpc.call_node_volumes(nodenames)
3470

    
3471
    ilist = [self.cfg.GetInstanceInfo(iname) for iname
3472
             in self.cfg.GetInstanceList()]
3473

    
3474
    lv_by_node = dict([(inst, inst.MapLVsByNode()) for inst in ilist])
3475

    
3476
    output = []
3477
    for node in nodenames:
3478
      nresult = volumes[node]
3479
      if nresult.offline:
3480
        continue
3481
      msg = nresult.fail_msg
3482
      if msg:
3483
        self.LogWarning("Can't compute volume data on node %s: %s", node, msg)
3484
        continue
3485

    
3486
      node_vols = nresult.payload[:]
3487
      node_vols.sort(key=lambda vol: vol['dev'])
3488

    
3489
      for vol in node_vols:
3490
        node_output = []
3491
        for field in self.op.output_fields:
3492
          if field == "node":
3493
            val = node
3494
          elif field == "phys":
3495
            val = vol['dev']
3496
          elif field == "vg":
3497
            val = vol['vg']
3498
          elif field == "name":
3499
            val = vol['name']
3500
          elif field == "size":
3501
            val = int(float(vol['size']))
3502
          elif field == "instance":
3503
            for inst in ilist:
3504
              if node not in lv_by_node[inst]:
3505
                continue
3506
              if vol['name'] in lv_by_node[inst][node]:
3507
                val = inst.name
3508
                break
3509
            else:
3510
              val = '-'
3511
          else:
3512
            raise errors.ParameterError(field)
3513
          node_output.append(str(val))
3514

    
3515
        output.append(node_output)
3516

    
3517
    return output
3518

    
3519

    
3520
class LUQueryNodeStorage(NoHooksLU):
3521
  """Logical unit for getting information on storage units on node(s).
3522

3523
  """
3524
  _FIELDS_STATIC = utils.FieldSet(constants.SF_NODE)
3525
  _OP_PARAMS = [
3526
    ("nodes", _EmptyList, _TListOf(_TNonEmptyString)),
3527
    ("storage_type", _NoDefault, _CheckStorageType),
3528
    ("output_fields", _NoDefault, _TListOf(_TNonEmptyString)),
3529
    ("name", None, _TMaybeString),
3530
    ]
3531
  REQ_BGL = False
3532

    
3533
  def CheckArguments(self):
3534
    _CheckOutputFields(static=self._FIELDS_STATIC,
3535
                       dynamic=utils.FieldSet(*constants.VALID_STORAGE_FIELDS),
3536
                       selected=self.op.output_fields)
3537

    
3538
  def ExpandNames(self):
3539
    self.needed_locks = {}
3540
    self.share_locks[locking.LEVEL_NODE] = 1
3541

    
3542
    if self.op.nodes:
3543
      self.needed_locks[locking.LEVEL_NODE] = \
3544
        _GetWantedNodes(self, self.op.nodes)
3545
    else:
3546
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3547

    
3548
  def Exec(self, feedback_fn):
3549
    """Computes the list of nodes and their attributes.
3550

3551
    """
3552
    self.nodes = self.acquired_locks[locking.LEVEL_NODE]
3553

    
3554
    # Always get name to sort by
3555
    if constants.SF_NAME in self.op.output_fields:
3556
      fields = self.op.output_fields[:]
3557
    else:
3558
      fields = [constants.SF_NAME] + self.op.output_fields
3559

    
3560
    # Never ask for node or type as it's only known to the LU
3561
    for extra in [constants.SF_NODE, constants.SF_TYPE]:
3562
      while extra in fields:
3563
        fields.remove(extra)
3564

    
3565
    field_idx = dict([(name, idx) for (idx, name) in enumerate(fields)])
3566
    name_idx = field_idx[constants.SF_NAME]
3567

    
3568
    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
3569
    data = self.rpc.call_storage_list(self.nodes,
3570
                                      self.op.storage_type, st_args,
3571
                                      self.op.name, fields)
3572

    
3573
    result = []
3574

    
3575
    for node in utils.NiceSort(self.nodes):
3576
      nresult = data[node]
3577
      if nresult.offline:
3578
        continue
3579

    
3580
      msg = nresult.fail_msg
3581
      if msg:
3582
        self.LogWarning("Can't get storage data from node %s: %s", node, msg)
3583
        continue
3584

    
3585
      rows = dict([(row[name_idx], row) for row in nresult.payload])
3586

    
3587
      for name in utils.NiceSort(rows.keys()):
3588
        row = rows[name]
3589

    
3590
        out = []
3591

    
3592
        for field in self.op.output_fields:
3593
          if field == constants.SF_NODE:
3594
            val = node
3595
          elif field == constants.SF_TYPE:
3596
            val = self.op.storage_type
3597
          elif field in field_idx:
3598
            val = row[field_idx[field]]
3599
          else:
3600
            raise errors.ParameterError(field)
3601

    
3602
          out.append(val)
3603

    
3604
        result.append(out)
3605

    
3606
    return result
3607

    
3608

    
3609
class LUModifyNodeStorage(NoHooksLU):
3610
  """Logical unit for modifying a storage volume on a node.
3611

3612
  """
3613
  _OP_PARAMS = [
3614
    _PNodeName,
3615
    ("storage_type", _NoDefault, _CheckStorageType),
3616
    ("name", _NoDefault, _TNonEmptyString),
3617
    ("changes", _NoDefault, _TDict),
3618
    ]
3619
  REQ_BGL = False
3620

    
3621
  def CheckArguments(self):
3622
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3623

    
3624
    storage_type = self.op.storage_type
3625

    
3626
    try:
3627
      modifiable = constants.MODIFIABLE_STORAGE_FIELDS[storage_type]
3628
    except KeyError:
3629
      raise errors.OpPrereqError("Storage units of type '%s' can not be"
3630
                                 " modified" % storage_type,
3631
                                 errors.ECODE_INVAL)
3632

    
3633
    diff = set(self.op.changes.keys()) - modifiable
3634
    if diff:
3635
      raise errors.OpPrereqError("The following fields can not be modified for"
3636
                                 " storage units of type '%s': %r" %
3637
                                 (storage_type, list(diff)),
3638
                                 errors.ECODE_INVAL)
3639

    
3640
  def ExpandNames(self):
3641
    self.needed_locks = {
3642
      locking.LEVEL_NODE: self.op.node_name,
3643
      }
3644

    
3645
  def Exec(self, feedback_fn):
3646
    """Computes the list of nodes and their attributes.
3647

3648
    """
3649
    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
3650
    result = self.rpc.call_storage_modify(self.op.node_name,
3651
                                          self.op.storage_type, st_args,
3652
                                          self.op.name, self.op.changes)
3653
    result.Raise("Failed to modify storage unit '%s' on %s" %
3654
                 (self.op.name, self.op.node_name))
3655

    
3656

    
3657
class LUAddNode(LogicalUnit):
3658
  """Logical unit for adding node to the cluster.
3659

3660
  """
3661
  HPATH = "node-add"
3662
  HTYPE = constants.HTYPE_NODE
3663
  _OP_PARAMS = [
3664
    _PNodeName,
3665
    ("primary_ip", None, _NoType),
3666
    ("secondary_ip", None, _TMaybeString),
3667
    ("readd", False, _TBool),
3668
    ]
3669

    
3670
  def CheckArguments(self):
3671
    self.primary_ip_family = self.cfg.GetPrimaryIPFamily()
3672
    # validate/normalize the node name
3673
    self.hostname = netutils.GetHostname(name=self.op.node_name,
3674
                                         family=self.primary_ip_family)
3675
    self.op.node_name = self.hostname.name
3676

    
3677
  def BuildHooksEnv(self):
3678
    """Build hooks env.
3679

3680
    This will run on all nodes before, and on all nodes + the new node after.
3681

3682
    """
3683
    env = {
3684
      "OP_TARGET": self.op.node_name,
3685
      "NODE_NAME": self.op.node_name,
3686
      "NODE_PIP": self.op.primary_ip,
3687
      "NODE_SIP": self.op.secondary_ip,
3688
      }
3689
    nodes_0 = self.cfg.GetNodeList()
3690
    nodes_1 = nodes_0 + [self.op.node_name, ]
3691
    return env, nodes_0, nodes_1
3692

    
3693
  def CheckPrereq(self):
3694
    """Check prerequisites.
3695

3696
    This checks:
3697
     - the new node is not already in the config
3698
     - it is resolvable
3699
     - its parameters (single/dual homed) matches the cluster
3700

3701
    Any errors are signaled by raising errors.OpPrereqError.
3702

3703
    """
3704
    cfg = self.cfg
3705
    hostname = self.hostname
3706
    node = hostname.name
3707
    primary_ip = self.op.primary_ip = hostname.ip
3708
    if self.op.secondary_ip is None:
3709
      if self.primary_ip_family == netutils.IP6Address.family:
3710
        raise errors.OpPrereqError("When using a IPv6 primary address, a valid"
3711
                                   " IPv4 address must be given as secondary",
3712
                                   errors.ECODE_INVAL)
3713
      self.op.secondary_ip = primary_ip
3714

    
3715
    secondary_ip = self.op.secondary_ip
3716
    if not netutils.IP4Address.IsValid(secondary_ip):
3717
      raise errors.OpPrereqError("Secondary IP (%s) needs to be a valid IPv4"
3718
                                 " address" % secondary_ip, errors.ECODE_INVAL)
3719

    
3720
    node_list = cfg.GetNodeList()
3721
    if not self.op.readd and node in node_list:
3722
      raise errors.OpPrereqError("Node %s is already in the configuration" %
3723
                                 node, errors.ECODE_EXISTS)
3724
    elif self.op.readd and node not in node_list:
3725
      raise errors.OpPrereqError("Node %s is not in the configuration" % node,
3726
                                 errors.ECODE_NOENT)
3727

    
3728
    self.changed_primary_ip = False
3729

    
3730
    for existing_node_name in node_list:
3731
      existing_node = cfg.GetNodeInfo(existing_node_name)
3732

    
3733
      if self.op.readd and node == existing_node_name:
3734
        if existing_node.secondary_ip != secondary_ip:
3735
          raise errors.OpPrereqError("Readded node doesn't have the same IP"
3736
                                     " address configuration as before",
3737
                                     errors.ECODE_INVAL)
3738
        if existing_node.primary_ip != primary_ip:
3739
          self.changed_primary_ip = True
3740

    
3741
        continue
3742

    
3743
      if (existing_node.primary_ip == primary_ip or
3744
          existing_node.secondary_ip == primary_ip or
3745
          existing_node.primary_ip == secondary_ip or
3746
          existing_node.secondary_ip == secondary_ip):
3747
        raise errors.OpPrereqError("New node ip address(es) conflict with"
3748
                                   " existing node %s" % existing_node.name,
3749
                                   errors.ECODE_NOTUNIQUE)
3750

    
3751
    # check that the type of the node (single versus dual homed) is the
3752
    # same as for the master
3753
    myself = cfg.GetNodeInfo(self.cfg.GetMasterNode())
3754
    master_singlehomed = myself.secondary_ip == myself.primary_ip
3755
    newbie_singlehomed = secondary_ip == primary_ip
3756
    if master_singlehomed != newbie_singlehomed:
3757
      if master_singlehomed:
3758
        raise errors.OpPrereqError("The master has no private ip but the"
3759
                                   " new node has one",
3760
                                   errors.ECODE_INVAL)
3761
      else:
3762
        raise errors.OpPrereqError("The master has a private ip but the"
3763
                                   " new node doesn't have one",
3764
                                   errors.ECODE_INVAL)
3765

    
3766
    # checks reachability
3767
    if not netutils.TcpPing(primary_ip, constants.DEFAULT_NODED_PORT):
3768
      raise errors.OpPrereqError("Node not reachable by ping",
3769
                                 errors.ECODE_ENVIRON)
3770

    
3771
    if not newbie_singlehomed:
3772
      # check reachability from my secondary ip to newbie's secondary ip
3773
      if not netutils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,
3774
                           source=myself.secondary_ip):
3775
        raise errors.OpPrereqError("Node secondary ip not reachable by TCP"
3776
                                   " based ping to noded port",
3777
                                   errors.ECODE_ENVIRON)
3778

    
3779
    if self.op.readd:
3780
      exceptions = [node]
3781
    else:
3782
      exceptions = []
3783

    
3784
    self.master_candidate = _DecideSelfPromotion(self, exceptions=exceptions)
3785

    
3786
    if self.op.readd:
3787
      self.new_node = self.cfg.GetNodeInfo(node)
3788
      assert self.new_node is not None, "Can't retrieve locked node %s" % node
3789
    else:
3790
      self.new_node = objects.Node(name=node,
3791
                                   primary_ip=primary_ip,
3792
                                   secondary_ip=secondary_ip,
3793
                                   master_candidate=self.master_candidate,
3794
                                   offline=False, drained=False)
3795

    
3796
  def Exec(self, feedback_fn):
3797
    """Adds the new node to the cluster.
3798

3799
    """
3800
    new_node = self.new_node
3801
    node = new_node.name
3802

    
3803
    # for re-adds, reset the offline/drained/master-candidate flags;
3804
    # we need to reset here, otherwise offline would prevent RPC calls
3805
    # later in the procedure; this also means that if the re-add
3806
    # fails, we are left with a non-offlined, broken node
3807
    if self.op.readd:
3808
      new_node.drained = new_node.offline = False # pylint: disable-msg=W0201
3809
      self.LogInfo("Readding a node, the offline/drained flags were reset")
3810
      # if we demote the node, we do cleanup later in the procedure
3811
      new_node.master_candidate = self.master_candidate
3812
      if self.changed_primary_ip:
3813
        new_node.primary_ip = self.op.primary_ip
3814

    
3815
    # notify the user about any possible mc promotion
3816
    if new_node.master_candidate:
3817
      self.LogInfo("Node will be a master candidate")
3818

    
3819
    # check connectivity
3820
    result = self.rpc.call_version([node])[node]
3821
    result.Raise("Can't get version information from node %s" % node)
3822
    if constants.PROTOCOL_VERSION == result.payload:
3823
      logging.info("Communication to node %s fine, sw version %s match",
3824
                   node, result.payload)
3825
    else:
3826
      raise errors.OpExecError("Version mismatch master version %s,"
3827
                               " node version %s" %
3828
                               (constants.PROTOCOL_VERSION, result.payload))
3829

    
3830
    # Add node to our /etc/hosts, and add key to known_hosts
3831
    if self.cfg.GetClusterInfo().modify_etc_hosts:
3832
      # FIXME: this should be done via an rpc call to node daemon
3833
      utils.AddHostToEtcHosts(self.hostname)
3834

    
3835
    if new_node.secondary_ip != new_node.primary_ip:
3836
      result = self.rpc.call_node_has_ip_address(new_node.name,
3837
                                                 new_node.secondary_ip)
3838
      result.Raise("Failure checking secondary ip on node %s" % new_node.name,
3839
                   prereq=True, ecode=errors.ECODE_ENVIRON)
3840
      if not result.payload:
3841
        raise errors.OpExecError("Node claims it doesn't have the secondary ip"
3842
                                 " you gave (%s). Please fix and re-run this"
3843
                                 " command." % new_node.secondary_ip)
3844

    
3845
    node_verify_list = [self.cfg.GetMasterNode()]
3846
    node_verify_param = {
3847
      constants.NV_NODELIST: [node],
3848
      # TODO: do a node-net-test as well?
3849
    }
3850

    
3851
    result = self.rpc.call_node_verify(node_verify_list, node_verify_param,
3852
                                       self.cfg.GetClusterName())
3853
    for verifier in node_verify_list:
3854
      result[verifier].Raise("Cannot communicate with node %s" % verifier)
3855
      nl_payload = result[verifier].payload[constants.NV_NODELIST]
3856
      if nl_payload:
3857
        for failed in nl_payload:
3858
          feedback_fn("ssh/hostname verification failed"
3859
                      " (checking from %s): %s" %
3860
                      (verifier, nl_payload[failed]))
3861
        raise errors.OpExecError("ssh/hostname verification failed.")
3862

    
3863
    if self.op.readd:
3864
      _RedistributeAncillaryFiles(self)
3865
      self.context.ReaddNode(new_node)
3866
      # make sure we redistribute the config
3867
      self.cfg.Update(new_node, feedback_fn)
3868
      # and make sure the new node will not have old files around
3869
      if not new_node.master_candidate:
3870
        result = self.rpc.call_node_demote_from_mc(new_node.name)
3871
        msg = result.fail_msg
3872
        if msg:
3873
          self.LogWarning("Node failed to demote itself from master"
3874
                          " candidate status: %s" % msg)
3875
    else:
3876
      _RedistributeAncillaryFiles(self, additional_nodes=[node])
3877
      self.context.AddNode(new_node, self.proc.GetECId())
3878

    
3879

    
3880
class LUSetNodeParams(LogicalUnit):
3881
  """Modifies the parameters of a node.
3882

3883
  """
3884
  HPATH = "node-modify"
3885
  HTYPE = constants.HTYPE_NODE
3886
  _OP_PARAMS = [
3887
    _PNodeName,
3888
    ("master_candidate", None, _TMaybeBool),
3889
    ("offline", None, _TMaybeBool),
3890
    ("drained", None, _TMaybeBool),
3891
    ("auto_promote", False, _TBool),
3892
    _PForce,
3893
    ]
3894
  REQ_BGL = False
3895

    
3896
  def CheckArguments(self):
3897
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3898
    all_mods = [self.op.offline, self.op.master_candidate, self.op.drained]
3899
    if all_mods.count(None) == 3:
3900
      raise errors.OpPrereqError("Please pass at least one modification",
3901
                                 errors.ECODE_INVAL)
3902
    if all_mods.count(True) > 1:
3903
      raise errors.OpPrereqError("Can't set the node into more than one"
3904
                                 " state at the same time",
3905
                                 errors.ECODE_INVAL)
3906

    
3907
    # Boolean value that tells us whether we're offlining or draining the node
3908
    self.offline_or_drain = (self.op.offline == True or
3909
                             self.op.drained == True)
3910
    self.deoffline_or_drain = (self.op.offline == False or
3911
                               self.op.drained == False)
3912
    self.might_demote = (self.op.master_candidate == False or
3913
                         self.offline_or_drain)
3914

    
3915
    self.lock_all = self.op.auto_promote and self.might_demote
3916

    
3917

    
3918
  def ExpandNames(self):
3919
    if self.lock_all:
3920
      self.needed_locks = {locking.LEVEL_NODE: locking.ALL_SET}
3921
    else:
3922
      self.needed_locks = {locking.LEVEL_NODE: self.op.node_name}
3923

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

3927
    This runs on the master node.
3928

3929
    """
3930
    env = {
3931
      "OP_TARGET": self.op.node_name,
3932
      "MASTER_CANDIDATE": str(self.op.master_candidate),
3933
      "OFFLINE": str(self.op.offline),
3934
      "DRAINED": str(self.op.drained),
3935
      }
3936
    nl = [self.cfg.GetMasterNode(),
3937
          self.op.node_name]
3938
    return env, nl, nl
3939

    
3940
  def CheckPrereq(self):
3941
    """Check prerequisites.
3942

3943
    This only checks the instance list against the existing names.
3944

3945
    """
3946
    node = self.node = self.cfg.GetNodeInfo(self.op.node_name)
3947

    
3948
    if (self.op.master_candidate is not None or
3949
        self.op.drained is not None or
3950
        self.op.offline is not None):
3951
      # we can't change the master's node flags
3952
      if self.op.node_name == self.cfg.GetMasterNode():
3953
        raise errors.OpPrereqError("The master role can be changed"
3954
                                   " only via master-failover",
3955
                                   errors.ECODE_INVAL)
3956

    
3957

    
3958
    if node.master_candidate and self.might_demote and not self.lock_all:
3959
      assert not self.op.auto_promote, "auto-promote set but lock_all not"
3960
      # check if after removing the current node, we're missing master
3961
      # candidates
3962
      (mc_remaining, mc_should, _) = \
3963
          self.cfg.GetMasterCandidateStats(exceptions=[node.name])
3964
      if mc_remaining < mc_should:
3965
        raise errors.OpPrereqError("Not enough master candidates, please"
3966
                                   " pass auto_promote to allow promotion",
3967
                                   errors.ECODE_INVAL)
3968

    
3969
    if (self.op.master_candidate == True and
3970
        ((node.offline and not self.op.offline == False) or
3971
         (node.drained and not self.op.drained == False))):
3972
      raise errors.OpPrereqError("Node '%s' is offline or drained, can't set"
3973
                                 " to master_candidate" % node.name,
3974
                                 errors.ECODE_INVAL)
3975

    
3976
    # If we're being deofflined/drained, we'll MC ourself if needed
3977
    if (self.deoffline_or_drain and not self.offline_or_drain and not
3978
        self.op.master_candidate == True and not node.master_candidate):
3979
      self.op.master_candidate = _DecideSelfPromotion(self)
3980
      if self.op.master_candidate:
3981
        self.LogInfo("Autopromoting node to master candidate")
3982

    
3983
    return
3984

    
3985
  def Exec(self, feedback_fn):
3986
    """Modifies a node.
3987

3988
    """
3989
    node = self.node
3990

    
3991
    result = []
3992
    changed_mc = False
3993

    
3994
    if self.op.offline is not None:
3995
      node.offline = self.op.offline
3996
      result.append(("offline", str(self.op.offline)))
3997
      if self.op.offline == True:
3998
        if node.master_candidate:
3999
          node.master_candidate = False
4000
          changed_mc = True
4001
          result.append(("master_candidate", "auto-demotion due to offline"))
4002
        if node.drained:
4003
          node.drained = False
4004
          result.append(("drained", "clear drained status due to offline"))
4005

    
4006
    if self.op.master_candidate is not None:
4007
      node.master_candidate = self.op.master_candidate
4008
      changed_mc = True
4009
      result.append(("master_candidate", str(self.op.master_candidate)))
4010
      if self.op.master_candidate == False:
4011
        rrc = self.rpc.call_node_demote_from_mc(node.name)
4012
        msg = rrc.fail_msg
4013
        if msg:
4014
          self.LogWarning("Node failed to demote itself: %s" % msg)
4015

    
4016
    if self.op.drained is not None:
4017
      node.drained = self.op.drained
4018
      result.append(("drained", str(self.op.drained)))
4019
      if self.op.drained == True:
4020
        if node.master_candidate:
4021
          node.master_candidate = False
4022
          changed_mc = True
4023
          result.append(("master_candidate", "auto-demotion due to drain"))
4024
          rrc = self.rpc.call_node_demote_from_mc(node.name)
4025
          msg = rrc.fail_msg
4026
          if msg:
4027
            self.LogWarning("Node failed to demote itself: %s" % msg)
4028
        if node.offline:
4029
          node.offline = False
4030
          result.append(("offline", "clear offline status due to drain"))
4031

    
4032
    # we locked all nodes, we adjust the CP before updating this node
4033
    if self.lock_all:
4034
      _AdjustCandidatePool(self, [node.name])
4035

    
4036
    # this will trigger configuration file update, if needed
4037
    self.cfg.Update(node, feedback_fn)
4038

    
4039
    # this will trigger job queue propagation or cleanup
4040
    if changed_mc:
4041
      self.context.ReaddNode(node)
4042

    
4043
    return result
4044