Statistics
| Branch: | Tag: | Revision:

root / lib / cmdlib.py @ f7c94c17

History | View | Annotate | Download (392.2 kB)

1
#
2
#
3

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

    
21

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

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

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

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

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

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

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

    
63

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

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

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

    
76

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

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

90
  Note that all commands require root permissions.
91

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

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

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

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

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

    
133
    # Tasklets
134
    self.tasklets = None
135

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

    
139
    self.CheckArguments()
140

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

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

    
149
  ssh = property(fget=__GetSSH)
150

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

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

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

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

166
    """
167
    pass
168

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

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

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

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

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

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

194
    Examples::
195

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

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

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

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

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

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

233
    """
234

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

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

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

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

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

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

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

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

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

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

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

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

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

292
    """
293
    raise NotImplementedError
294

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
381
    del self.recalculate_locks[locking.LEVEL_NODE]
382

    
383

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

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

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

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

397
    This just raises an error.
398

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

    
402

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

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

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

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

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

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

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

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

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

435
    """
436
    pass
437

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

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

445
    """
446
    raise NotImplementedError
447

    
448

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

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

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

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

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

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

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

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

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

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

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

    
492
    # Return expanded names
493
    return self.wanted
494

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

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

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

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

507
    See L{LogicalUnit.ExpandNames}.
508

509
    """
510
    raise NotImplementedError()
511

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

515
    See L{LogicalUnit.DeclareLocks}.
516

517
    """
518
    raise NotImplementedError()
519

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

523
    @return: Query data object
524

525
    """
526
    raise NotImplementedError()
527

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

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

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

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

    
540

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

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

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

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

    
558

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

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

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

    
578

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

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

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

    
611

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

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

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

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

    
630

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

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

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

    
645

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

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

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

    
660

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

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

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

    
673

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

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

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

    
686

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

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

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

    
704

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

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

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

    
731

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

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

    
739

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

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

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

    
755

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

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

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

    
772

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

    
777

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

    
782

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

788
  This builds the hook environment from individual variables.
789

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

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

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

    
852
  env["INSTANCE_NIC_COUNT"] = nic_count
853

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

    
862
  env["INSTANCE_DISK_COUNT"] = disk_count
863

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

    
868
  return env
869

    
870

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

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

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

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

    
894

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

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

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

    
932

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

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

    
948

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

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

    
959

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

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

    
973

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

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

    
982

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

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

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

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

    
1002

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

    
1006

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

1010
  """
1011

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

    
1014

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

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

    
1022

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

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

    
1030

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

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

    
1040
  return []
1041

    
1042

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

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

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

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

    
1057
  return faulty
1058

    
1059

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

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

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

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

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

    
1091

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

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

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

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

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

1110
    """
1111
    return True
1112

    
1113

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

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

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

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

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

1131
    This checks whether the cluster is empty.
1132

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

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

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

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

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

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

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

    
1166
    return master
1167

    
1168

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

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

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

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

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

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

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

    
1201

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1405
    return True
1406

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1756
    nimg.os_fail = test
1757

    
1758
    if test:
1759
      return
1760

    
1761
    os_dict = {}
1762

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

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

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

    
1775
    nimg.oslist = os_dict
1776

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1970
      node_disks[nname] = disks
1971

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

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

    
1979
      node_disks_devonly[nname] = devonly
1980

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

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

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

    
1989
    instdisk = {}
1990

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

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

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

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

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

    
2030
    return instdisk
2031

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

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

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

    
2046
    return env, [], all_nodes
2047

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

2051
    """
2052
    # This method has too many local variables. pylint: disable-msg=R0914
2053
    self.bad = False
2054
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
2055
    verbose = self.op.verbose
2056
    self._feedback_fn = feedback_fn
2057
    feedback_fn("* Verifying global settings")
2058
    for msg in self.cfg.VerifyConfig():
2059
      _ErrorIf(True, self.ECLUSTERCFG, None, msg)
2060

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

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

    
2083
    # FIXME: verify OS list
2084
    # do local checksums
2085
    master_files = [constants.CLUSTER_CONF_FILE]
2086
    master_node = self.master_node = self.cfg.GetMasterNode()
2087
    master_ip = self.cfg.GetMasterIP()
2088

    
2089
    file_names = ssconf.SimpleStore().GetFileList()
2090
    file_names.extend(constants.ALL_CERT_FILES)
2091
    file_names.extend(master_files)
2092
    if cluster.modify_etc_hosts:
2093
      file_names.append(constants.ETC_HOSTS)
2094

    
2095
    local_checksums = utils.FingerprintFiles(file_names)
2096

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

    
2116
    if vg_name is not None:
2117
      node_verify_param[constants.NV_VGLIST] = None
2118
      node_verify_param[constants.NV_LVLIST] = vg_name
2119
      node_verify_param[constants.NV_PVLIST] = [vg_name]
2120
      node_verify_param[constants.NV_DRBDLIST] = None
2121

    
2122
    if drbd_helper:
2123
      node_verify_param[constants.NV_DRBDHELPER] = drbd_helper
2124

    
2125
    # Build our expected cluster state
2126
    node_image = dict((node.name, self.NodeImage(offline=node.offline,
2127
                                                 name=node.name,
2128
                                                 vm_capable=node.vm_capable))
2129
                      for node in nodeinfo)
2130

    
2131
    # Gather OOB paths
2132
    oob_paths = []
2133
    for node in nodeinfo:
2134
      path = _SupportsOob(self.cfg, node)
2135
      if path and path not in oob_paths:
2136
        oob_paths.append(path)
2137

    
2138
    if oob_paths:
2139
      node_verify_param[constants.NV_OOB_PATHS] = oob_paths
2140

    
2141
    for instance in instancelist:
2142
      inst_config = instanceinfo[instance]
2143

    
2144
      for nname in inst_config.all_nodes:
2145
        if nname not in node_image:
2146
          # ghost node
2147
          gnode = self.NodeImage(name=nname)
2148
          gnode.ghost = True
2149
          node_image[nname] = gnode
2150

    
2151
      inst_config.MapLVsByNode(node_vol_should)
2152

    
2153
      pnode = inst_config.primary_node
2154
      node_image[pnode].pinst.append(instance)
2155

    
2156
      for snode in inst_config.secondary_nodes:
2157
        nimg = node_image[snode]
2158
        nimg.sinst.append(instance)
2159
        if pnode not in nimg.sbp:
2160
          nimg.sbp[pnode] = []
2161
        nimg.sbp[pnode].append(instance)
2162

    
2163
    # At this point, we have the in-memory data structures complete,
2164
    # except for the runtime information, which we'll gather next
2165

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

    
2175
    all_drbd_map = self.cfg.ComputeDRBDMap()
2176

    
2177
    feedback_fn("* Gathering disk information (%s nodes)" % len(nodelist))
2178
    instdisk = self._CollectDiskInfo(nodelist, node_image, instanceinfo)
2179

    
2180
    feedback_fn("* Verifying node status")
2181

    
2182
    refos_img = None
2183

    
2184
    for node_i in nodeinfo:
2185
      node = node_i.name
2186
      nimg = node_image[node]
2187

    
2188
      if node_i.offline:
2189
        if verbose:
2190
          feedback_fn("* Skipping offline node %s" % (node,))
2191
        n_offline += 1
2192
        continue
2193

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

    
2206
      msg = all_nvinfo[node].fail_msg
2207
      _ErrorIf(msg, self.ENODERPC, node, "while contacting node: %s", msg)
2208
      if msg:
2209
        nimg.rpc_fail = True
2210
        continue
2211

    
2212
      nresult = all_nvinfo[node].payload
2213

    
2214
      nimg.call_ok = self._VerifyNode(node_i, nresult)
2215
      self._VerifyNodeTime(node_i, nresult, nvinfo_starttime, nvinfo_endtime)
2216
      self._VerifyNodeNetwork(node_i, nresult)
2217
      self._VerifyNodeFiles(node_i, nresult, file_names, local_checksums,
2218
                            master_files)
2219

    
2220
      self._VerifyOob(node_i, nresult)
2221

    
2222
      if nimg.vm_capable:
2223
        self._VerifyNodeLVM(node_i, nresult, vg_name)
2224
        self._VerifyNodeDrbd(node_i, nresult, instanceinfo, drbd_helper,
2225
                             all_drbd_map)
2226

    
2227
        self._UpdateNodeVolumes(node_i, nresult, nimg, vg_name)
2228
        self._UpdateNodeInstances(node_i, nresult, nimg)
2229
        self._UpdateNodeInfo(node_i, nresult, nimg, vg_name)
2230
        self._UpdateNodeOS(node_i, nresult, nimg)
2231
        if not nimg.os_fail:
2232
          if refos_img is None:
2233
            refos_img = nimg
2234
          self._VerifyNodeOS(node_i, nimg, refos_img)
2235

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

    
2245
      pnode = inst_config.primary_node
2246
      pnode_img = node_image[pnode]
2247
      _ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,
2248
               self.ENODERPC, pnode, "instance %s, connection to"
2249
               " primary node failed", instance)
2250

    
2251
      if pnode_img.offline:
2252
        inst_nodes_offline.append(pnode)
2253

    
2254
      # If the instance is non-redundant we cannot survive losing its primary
2255
      # node, so we are not N+1 compliant. On the other hand we have no disk
2256
      # templates with more than one secondary so that situation is not well
2257
      # supported either.
2258
      # FIXME: does not support file-backed instances
2259
      if not inst_config.secondary_nodes:
2260
        i_non_redundant.append(instance)
2261

    
2262
      _ErrorIf(len(inst_config.secondary_nodes) > 1, self.EINSTANCELAYOUT,
2263
               instance, "instance has multiple secondary nodes: %s",
2264
               utils.CommaJoin(inst_config.secondary_nodes),
2265
               code=self.ETYPE_WARNING)
2266

    
2267
      if inst_config.disk_template in constants.DTS_NET_MIRROR:
2268
        pnode = inst_config.primary_node
2269
        instance_nodes = utils.NiceSort(inst_config.all_nodes)
2270
        instance_groups = {}
2271

    
2272
        for node in instance_nodes:
2273
          instance_groups.setdefault(nodeinfo_byname[node].group,
2274
                                     []).append(node)
2275

    
2276
        pretty_list = [
2277
          "%s (group %s)" % (utils.CommaJoin(nodes), groupinfo[group].name)
2278
          # Sort so that we always list the primary node first.
2279
          for group, nodes in sorted(instance_groups.items(),
2280
                                     key=lambda (_, nodes): pnode in nodes,
2281
                                     reverse=True)]
2282

    
2283
        self._ErrorIf(len(instance_groups) > 1, self.EINSTANCESPLITGROUPS,
2284
                      instance, "instance has primary and secondary nodes in"
2285
                      " different groups: %s", utils.CommaJoin(pretty_list),
2286
                      code=self.ETYPE_WARNING)
2287

    
2288
      if not cluster.FillBE(inst_config)[constants.BE_AUTO_BALANCE]:
2289
        i_non_a_balanced.append(instance)
2290

    
2291
      for snode in inst_config.secondary_nodes:
2292
        s_img = node_image[snode]
2293
        _ErrorIf(s_img.rpc_fail and not s_img.offline, self.ENODERPC, snode,
2294
                 "instance %s, connection to secondary node failed", instance)
2295

    
2296
        if s_img.offline:
2297
          inst_nodes_offline.append(snode)
2298

    
2299
      # warn that the instance lives on offline nodes
2300
      _ErrorIf(inst_nodes_offline, self.EINSTANCEBADNODE, instance,
2301
               "instance lives on offline node(s) %s",
2302
               utils.CommaJoin(inst_nodes_offline))
2303
      # ... or ghost/non-vm_capable nodes
2304
      for node in inst_config.all_nodes:
2305
        _ErrorIf(node_image[node].ghost, self.EINSTANCEBADNODE, instance,
2306
                 "instance lives on ghost node %s", node)
2307
        _ErrorIf(not node_image[node].vm_capable, self.EINSTANCEBADNODE,
2308
                 instance, "instance lives on non-vm_capable node %s", node)
2309

    
2310
    feedback_fn("* Verifying orphan volumes")
2311
    reserved = utils.FieldSet(*cluster.reserved_lvs)
2312
    self._VerifyOrphanVolumes(node_vol_should, node_image, reserved)
2313

    
2314
    feedback_fn("* Verifying orphan instances")
2315
    self._VerifyOrphanInstances(instancelist, node_image)
2316

    
2317
    if constants.VERIFY_NPLUSONE_MEM not in self.op.skip_checks:
2318
      feedback_fn("* Verifying N+1 Memory redundancy")
2319
      self._VerifyNPlusOneMemory(node_image, instanceinfo)
2320

    
2321
    feedback_fn("* Other Notes")
2322
    if i_non_redundant:
2323
      feedback_fn("  - NOTICE: %d non-redundant instance(s) found."
2324
                  % len(i_non_redundant))
2325

    
2326
    if i_non_a_balanced:
2327
      feedback_fn("  - NOTICE: %d non-auto-balanced instance(s) found."
2328
                  % len(i_non_a_balanced))
2329

    
2330
    if n_offline:
2331
      feedback_fn("  - NOTICE: %d offline node(s) found." % n_offline)
2332

    
2333
    if n_drained:
2334
      feedback_fn("  - NOTICE: %d drained node(s) found." % n_drained)
2335

    
2336
    return not self.bad
2337

    
2338
  def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):
2339
    """Analyze the post-hooks' result
2340

2341
    This method analyses the hook result, handles it, and sends some
2342
    nicely-formatted feedback back to the user.
2343

2344
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
2345
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
2346
    @param hooks_results: the results of the multi-node hooks rpc call
2347
    @param feedback_fn: function used send feedback back to the caller
2348
    @param lu_result: previous Exec result
2349
    @return: the new Exec result, based on the previous result
2350
        and hook results
2351

2352
    """
2353
    # We only really run POST phase hooks, and are only interested in
2354
    # their results
2355
    if phase == constants.HOOKS_PHASE_POST:
2356
      # Used to change hooks' output to proper indentation
2357
      feedback_fn("* Hooks Results")
2358
      assert hooks_results, "invalid result from hooks"
2359

    
2360
      for node_name in hooks_results:
2361
        res = hooks_results[node_name]
2362
        msg = res.fail_msg
2363
        test = msg and not res.offline
2364
        self._ErrorIf(test, self.ENODEHOOKS, node_name,
2365
                      "Communication failure in hooks execution: %s", msg)
2366
        if res.offline or msg:
2367
          # No need to investigate payload if node is offline or gave an error.
2368
          # override manually lu_result here as _ErrorIf only
2369
          # overrides self.bad
2370
          lu_result = 1
2371
          continue
2372
        for script, hkr, output in res.payload:
2373
          test = hkr == constants.HKR_FAIL
2374
          self._ErrorIf(test, self.ENODEHOOKS, node_name,
2375
                        "Script %s failed, output:", script)
2376
          if test:
2377
            output = self._HOOKS_INDENT_RE.sub('      ', output)
2378
            feedback_fn("%s" % output)
2379
            lu_result = 0
2380

    
2381
      return lu_result
2382

    
2383

    
2384
class LUClusterVerifyDisks(NoHooksLU):
2385
  """Verifies the cluster disks status.
2386

2387
  """
2388
  REQ_BGL = False
2389

    
2390
  def ExpandNames(self):
2391
    self.needed_locks = {
2392
      locking.LEVEL_NODE: locking.ALL_SET,
2393
      locking.LEVEL_INSTANCE: locking.ALL_SET,
2394
    }
2395
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
2396

    
2397
  def Exec(self, feedback_fn):
2398
    """Verify integrity of cluster disks.
2399

2400
    @rtype: tuple of three items
2401
    @return: a tuple of (dict of node-to-node_error, list of instances
2402
        which need activate-disks, dict of instance: (node, volume) for
2403
        missing volumes
2404

2405
    """
2406
    result = res_nodes, res_instances, res_missing = {}, [], {}
2407

    
2408
    nodes = utils.NiceSort(self.cfg.GetNodeList())
2409
    instances = [self.cfg.GetInstanceInfo(name)
2410
                 for name in self.cfg.GetInstanceList()]
2411

    
2412
    nv_dict = {}
2413
    for inst in instances:
2414
      inst_lvs = {}
2415
      if (not inst.admin_up or
2416
          inst.disk_template not in constants.DTS_NET_MIRROR):
2417
        continue
2418
      inst.MapLVsByNode(inst_lvs)
2419
      # transform { iname: {node: [vol,],},} to {(node, vol): iname}
2420
      for node, vol_list in inst_lvs.iteritems():
2421
        for vol in vol_list:
2422
          nv_dict[(node, vol)] = inst
2423

    
2424
    if not nv_dict:
2425
      return result
2426

    
2427
    vg_names = self.rpc.call_vg_list(nodes)
2428
    for node in nodes:
2429
      vg_names[node].Raise("Cannot get list of VGs")
2430

    
2431
    for node in nodes:
2432
      # node_volume
2433
      node_res = self.rpc.call_lv_list([node],
2434
                                       vg_names[node].payload.keys())[node]
2435
      if node_res.offline:
2436
        continue
2437
      msg = node_res.fail_msg
2438
      if msg:
2439
        logging.warning("Error enumerating LVs on node %s: %s", node, msg)
2440
        res_nodes[node] = msg
2441
        continue
2442

    
2443
      lvs = node_res.payload
2444
      for lv_name, (_, _, lv_online) in lvs.items():
2445
        inst = nv_dict.pop((node, lv_name), None)
2446
        if (not lv_online and inst is not None
2447
            and inst.name not in res_instances):
2448
          res_instances.append(inst.name)
2449

    
2450
    # any leftover items in nv_dict are missing LVs, let's arrange the
2451
    # data better
2452
    for key, inst in nv_dict.iteritems():
2453
      if inst.name not in res_missing:
2454
        res_missing[inst.name] = []
2455
      res_missing[inst.name].append(key)
2456

    
2457
    return result
2458

    
2459

    
2460
class LUClusterRepairDiskSizes(NoHooksLU):
2461
  """Verifies the cluster disks sizes.
2462

2463
  """
2464
  REQ_BGL = False
2465

    
2466
  def ExpandNames(self):
2467
    if self.op.instances:
2468
      self.wanted_names = []
2469
      for name in self.op.instances:
2470
        full_name = _ExpandInstanceName(self.cfg, name)
2471
        self.wanted_names.append(full_name)
2472
      self.needed_locks = {
2473
        locking.LEVEL_NODE: [],
2474
        locking.LEVEL_INSTANCE: self.wanted_names,
2475
        }
2476
      self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
2477
    else:
2478
      self.wanted_names = None
2479
      self.needed_locks = {
2480
        locking.LEVEL_NODE: locking.ALL_SET,
2481
        locking.LEVEL_INSTANCE: locking.ALL_SET,
2482
        }
2483
    self.share_locks = dict(((i, 1) for i in locking.LEVELS))
2484

    
2485
  def DeclareLocks(self, level):
2486
    if level == locking.LEVEL_NODE and self.wanted_names is not None:
2487
      self._LockInstancesNodes(primary_only=True)
2488

    
2489
  def CheckPrereq(self):
2490
    """Check prerequisites.
2491

2492
    This only checks the optional instance list against the existing names.
2493

2494
    """
2495
    if self.wanted_names is None:
2496
      self.wanted_names = self.acquired_locks[locking.LEVEL_INSTANCE]
2497

    
2498
    self.wanted_instances = [self.cfg.GetInstanceInfo(name) for name
2499
                             in self.wanted_names]
2500

    
2501
  def _EnsureChildSizes(self, disk):
2502
    """Ensure children of the disk have the needed disk size.
2503

2504
    This is valid mainly for DRBD8 and fixes an issue where the
2505
    children have smaller disk size.
2506

2507
    @param disk: an L{ganeti.objects.Disk} object
2508

2509
    """
2510
    if disk.dev_type == constants.LD_DRBD8:
2511
      assert disk.children, "Empty children for DRBD8?"
2512
      fchild = disk.children[0]
2513
      mismatch = fchild.size < disk.size
2514
      if mismatch:
2515
        self.LogInfo("Child disk has size %d, parent %d, fixing",
2516
                     fchild.size, disk.size)
2517
        fchild.size = disk.size
2518

    
2519
      # and we recurse on this child only, not on the metadev
2520
      return self._EnsureChildSizes(fchild) or mismatch
2521
    else:
2522
      return False
2523

    
2524
  def Exec(self, feedback_fn):
2525
    """Verify the size of cluster disks.
2526

2527
    """
2528
    # TODO: check child disks too
2529
    # TODO: check differences in size between primary/secondary nodes
2530
    per_node_disks = {}
2531
    for instance in self.wanted_instances:
2532
      pnode = instance.primary_node
2533
      if pnode not in per_node_disks:
2534
        per_node_disks[pnode] = []
2535
      for idx, disk in enumerate(instance.disks):
2536
        per_node_disks[pnode].append((instance, idx, disk))
2537

    
2538
    changed = []
2539
    for node, dskl in per_node_disks.items():
2540
      newl = [v[2].Copy() for v in dskl]
2541
      for dsk in newl:
2542
        self.cfg.SetDiskID(dsk, node)
2543
      result = self.rpc.call_blockdev_getsizes(node, newl)
2544
      if result.fail_msg:
2545
        self.LogWarning("Failure in blockdev_getsizes call to node"
2546
                        " %s, ignoring", node)
2547
        continue
2548
      if len(result.data) != len(dskl):
2549
        self.LogWarning("Invalid result from node %s, ignoring node results",
2550
                        node)
2551
        continue
2552
      for ((instance, idx, disk), size) in zip(dskl, result.data):
2553
        if size is None:
2554
          self.LogWarning("Disk %d of instance %s did not return size"
2555
                          " information, ignoring", idx, instance.name)
2556
          continue
2557
        if not isinstance(size, (int, long)):
2558
          self.LogWarning("Disk %d of instance %s did not return valid"
2559
                          " size information, ignoring", idx, instance.name)
2560
          continue
2561
        size = size >> 20
2562
        if size != disk.size:
2563
          self.LogInfo("Disk %d of instance %s has mismatched size,"
2564
                       " correcting: recorded %d, actual %d", idx,
2565
                       instance.name, disk.size, size)
2566
          disk.size = size
2567
          self.cfg.Update(instance, feedback_fn)
2568
          changed.append((instance.name, idx, size))
2569
        if self._EnsureChildSizes(disk):
2570
          self.cfg.Update(instance, feedback_fn)
2571
          changed.append((instance.name, idx, disk.size))
2572
    return changed
2573

    
2574

    
2575
class LUClusterRename(LogicalUnit):
2576
  """Rename the cluster.
2577

2578
  """
2579
  HPATH = "cluster-rename"
2580
  HTYPE = constants.HTYPE_CLUSTER
2581

    
2582
  def BuildHooksEnv(self):
2583
    """Build hooks env.
2584

2585
    """
2586
    env = {
2587
      "OP_TARGET": self.cfg.GetClusterName(),
2588
      "NEW_NAME": self.op.name,
2589
      }
2590
    mn = self.cfg.GetMasterNode()
2591
    all_nodes = self.cfg.GetNodeList()
2592
    return env, [mn], all_nodes
2593

    
2594
  def CheckPrereq(self):
2595
    """Verify that the passed name is a valid one.
2596

2597
    """
2598
    hostname = netutils.GetHostname(name=self.op.name,
2599
                                    family=self.cfg.GetPrimaryIPFamily())
2600

    
2601
    new_name = hostname.name
2602
    self.ip = new_ip = hostname.ip
2603
    old_name = self.cfg.GetClusterName()
2604
    old_ip = self.cfg.GetMasterIP()
2605
    if new_name == old_name and new_ip == old_ip:
2606
      raise errors.OpPrereqError("Neither the name nor the IP address of the"
2607
                                 " cluster has changed",
2608
                                 errors.ECODE_INVAL)
2609
    if new_ip != old_ip:
2610
      if netutils.TcpPing(new_ip, constants.DEFAULT_NODED_PORT):
2611
        raise errors.OpPrereqError("The given cluster IP address (%s) is"
2612
                                   " reachable on the network" %
2613
                                   new_ip, errors.ECODE_NOTUNIQUE)
2614

    
2615
    self.op.name = new_name
2616

    
2617
  def Exec(self, feedback_fn):
2618
    """Rename the cluster.
2619

2620
    """
2621
    clustername = self.op.name
2622
    ip = self.ip
2623

    
2624
    # shutdown the master IP
2625
    master = self.cfg.GetMasterNode()
2626
    result = self.rpc.call_node_stop_master(master, False)
2627
    result.Raise("Could not disable the master role")
2628

    
2629
    try:
2630
      cluster = self.cfg.GetClusterInfo()
2631
      cluster.cluster_name = clustername
2632
      cluster.master_ip = ip
2633
      self.cfg.Update(cluster, feedback_fn)
2634

    
2635
      # update the known hosts file
2636
      ssh.WriteKnownHostsFile(self.cfg, constants.SSH_KNOWN_HOSTS_FILE)
2637
      node_list = self.cfg.GetOnlineNodeList()
2638
      try:
2639
        node_list.remove(master)
2640
      except ValueError:
2641
        pass
2642
      _UploadHelper(self, node_list, constants.SSH_KNOWN_HOSTS_FILE)
2643
    finally:
2644
      result = self.rpc.call_node_start_master(master, False, False)
2645
      msg = result.fail_msg
2646
      if msg:
2647
        self.LogWarning("Could not re-enable the master role on"
2648
                        " the master, please restart manually: %s", msg)
2649

    
2650
    return clustername
2651

    
2652

    
2653
class LUClusterSetParams(LogicalUnit):
2654
  """Change the parameters of the cluster.
2655

2656
  """
2657
  HPATH = "cluster-modify"
2658
  HTYPE = constants.HTYPE_CLUSTER
2659
  REQ_BGL = False
2660

    
2661
  def CheckArguments(self):
2662
    """Check parameters
2663

2664
    """
2665
    if self.op.uid_pool:
2666
      uidpool.CheckUidPool(self.op.uid_pool)
2667

    
2668
    if self.op.add_uids:
2669
      uidpool.CheckUidPool(self.op.add_uids)
2670

    
2671
    if self.op.remove_uids:
2672
      uidpool.CheckUidPool(self.op.remove_uids)
2673

    
2674
  def ExpandNames(self):
2675
    # FIXME: in the future maybe other cluster params won't require checking on
2676
    # all nodes to be modified.
2677
    self.needed_locks = {
2678
      locking.LEVEL_NODE: locking.ALL_SET,
2679
    }
2680
    self.share_locks[locking.LEVEL_NODE] = 1
2681

    
2682
  def BuildHooksEnv(self):
2683
    """Build hooks env.
2684

2685
    """
2686
    env = {
2687
      "OP_TARGET": self.cfg.GetClusterName(),
2688
      "NEW_VG_NAME": self.op.vg_name,
2689
      }
2690
    mn = self.cfg.GetMasterNode()
2691
    return env, [mn], [mn]
2692

    
2693
  def CheckPrereq(self):
2694
    """Check prerequisites.
2695

2696
    This checks whether the given params don't conflict and
2697
    if the given volume group is valid.
2698

2699
    """
2700
    if self.op.vg_name is not None and not self.op.vg_name:
2701
      if self.cfg.HasAnyDiskOfType(constants.LD_LV):
2702
        raise errors.OpPrereqError("Cannot disable lvm storage while lvm-based"
2703
                                   " instances exist", errors.ECODE_INVAL)
2704

    
2705
    if self.op.drbd_helper is not None and not self.op.drbd_helper:
2706
      if self.cfg.HasAnyDiskOfType(constants.LD_DRBD8):
2707
        raise errors.OpPrereqError("Cannot disable drbd helper while"
2708
                                   " drbd-based instances exist",
2709
                                   errors.ECODE_INVAL)
2710

    
2711
    node_list = self.acquired_locks[locking.LEVEL_NODE]
2712

    
2713
    # if vg_name not None, checks given volume group on all nodes
2714
    if self.op.vg_name:
2715
      vglist = self.rpc.call_vg_list(node_list)
2716
      for node in node_list:
2717
        msg = vglist[node].fail_msg
2718
        if msg:
2719
          # ignoring down node
2720
          self.LogWarning("Error while gathering data on node %s"
2721
                          " (ignoring node): %s", node, msg)
2722
          continue
2723
        vgstatus = utils.CheckVolumeGroupSize(vglist[node].payload,
2724
                                              self.op.vg_name,
2725
                                              constants.MIN_VG_SIZE)
2726
        if vgstatus:
2727
          raise errors.OpPrereqError("Error on node '%s': %s" %
2728
                                     (node, vgstatus), errors.ECODE_ENVIRON)
2729

    
2730
    if self.op.drbd_helper:
2731
      # checks given drbd helper on all nodes
2732
      helpers = self.rpc.call_drbd_helper(node_list)
2733
      for node in node_list:
2734
        ninfo = self.cfg.GetNodeInfo(node)
2735
        if ninfo.offline:
2736
          self.LogInfo("Not checking drbd helper on offline node %s", node)
2737
          continue
2738
        msg = helpers[node].fail_msg
2739
        if msg:
2740
          raise errors.OpPrereqError("Error checking drbd helper on node"
2741
                                     " '%s': %s" % (node, msg),
2742
                                     errors.ECODE_ENVIRON)
2743
        node_helper = helpers[node].payload
2744
        if node_helper != self.op.drbd_helper:
2745
          raise errors.OpPrereqError("Error on node '%s': drbd helper is %s" %
2746
                                     (node, node_helper), errors.ECODE_ENVIRON)
2747

    
2748
    self.cluster = cluster = self.cfg.GetClusterInfo()
2749
    # validate params changes
2750
    if self.op.beparams:
2751
      utils.ForceDictType(self.op.beparams, constants.BES_PARAMETER_TYPES)
2752
      self.new_beparams = cluster.SimpleFillBE(self.op.beparams)
2753

    
2754
    if self.op.ndparams:
2755
      utils.ForceDictType(self.op.ndparams, constants.NDS_PARAMETER_TYPES)
2756
      self.new_ndparams = cluster.SimpleFillND(self.op.ndparams)
2757

    
2758
    if self.op.nicparams:
2759
      utils.ForceDictType(self.op.nicparams, constants.NICS_PARAMETER_TYPES)
2760
      self.new_nicparams = cluster.SimpleFillNIC(self.op.nicparams)
2761
      objects.NIC.CheckParameterSyntax(self.new_nicparams)
2762
      nic_errors = []
2763

    
2764
      # check all instances for consistency
2765
      for instance in self.cfg.GetAllInstancesInfo().values():
2766
        for nic_idx, nic in enumerate(instance.nics):
2767
          params_copy = copy.deepcopy(nic.nicparams)
2768
          params_filled = objects.FillDict(self.new_nicparams, params_copy)
2769

    
2770
          # check parameter syntax
2771
          try:
2772
            objects.NIC.CheckParameterSyntax(params_filled)
2773
          except errors.ConfigurationError, err:
2774
            nic_errors.append("Instance %s, nic/%d: %s" %
2775
                              (instance.name, nic_idx, err))
2776

    
2777
          # if we're moving instances to routed, check that they have an ip
2778
          target_mode = params_filled[constants.NIC_MODE]
2779
          if target_mode == constants.NIC_MODE_ROUTED and not nic.ip:
2780
            nic_errors.append("Instance %s, nic/%d: routed nick with no ip" %
2781
                              (instance.name, nic_idx))
2782
      if nic_errors:
2783
        raise errors.OpPrereqError("Cannot apply the change, errors:\n%s" %
2784
                                   "\n".join(nic_errors))
2785

    
2786
    # hypervisor list/parameters
2787
    self.new_hvparams = new_hvp = objects.FillDict(cluster.hvparams, {})
2788
    if self.op.hvparams:
2789
      for hv_name, hv_dict in self.op.hvparams.items():
2790
        if hv_name not in self.new_hvparams:
2791
          self.new_hvparams[hv_name] = hv_dict
2792
        else:
2793
          self.new_hvparams[hv_name].update(hv_dict)
2794

    
2795
    # os hypervisor parameters
2796
    self.new_os_hvp = objects.FillDict(cluster.os_hvp, {})
2797
    if self.op.os_hvp:
2798
      for os_name, hvs in self.op.os_hvp.items():
2799
        if os_name not in self.new_os_hvp:
2800
          self.new_os_hvp[os_name] = hvs
2801
        else:
2802
          for hv_name, hv_dict in hvs.items():
2803
            if hv_name not in self.new_os_hvp[os_name]:
2804
              self.new_os_hvp[os_name][hv_name] = hv_dict
2805
            else:
2806
              self.new_os_hvp[os_name][hv_name].update(hv_dict)
2807

    
2808
    # os parameters
2809
    self.new_osp = objects.FillDict(cluster.osparams, {})
2810
    if self.op.osparams:
2811
      for os_name, osp in self.op.osparams.items():
2812
        if os_name not in self.new_osp:
2813
          self.new_osp[os_name] = {}
2814

    
2815
        self.new_osp[os_name] = _GetUpdatedParams(self.new_osp[os_name], osp,
2816
                                                  use_none=True)
2817

    
2818
        if not self.new_osp[os_name]:
2819
          # we removed all parameters
2820
          del self.new_osp[os_name]
2821
        else:
2822
          # check the parameter validity (remote check)
2823
          _CheckOSParams(self, False, [self.cfg.GetMasterNode()],
2824
                         os_name, self.new_osp[os_name])
2825

    
2826
    # changes to the hypervisor list
2827
    if self.op.enabled_hypervisors is not None:
2828
      self.hv_list = self.op.enabled_hypervisors
2829
      for hv in self.hv_list:
2830
        # if the hypervisor doesn't already exist in the cluster
2831
        # hvparams, we initialize it to empty, and then (in both
2832
        # cases) we make sure to fill the defaults, as we might not
2833
        # have a complete defaults list if the hypervisor wasn't
2834
        # enabled before
2835
        if hv not in new_hvp:
2836
          new_hvp[hv] = {}
2837
        new_hvp[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], new_hvp[hv])
2838
        utils.ForceDictType(new_hvp[hv], constants.HVS_PARAMETER_TYPES)
2839
    else:
2840
      self.hv_list = cluster.enabled_hypervisors
2841

    
2842
    if self.op.hvparams or self.op.enabled_hypervisors is not None:
2843
      # either the enabled list has changed, or the parameters have, validate
2844
      for hv_name, hv_params in self.new_hvparams.items():
2845
        if ((self.op.hvparams and hv_name in self.op.hvparams) or
2846
            (self.op.enabled_hypervisors and
2847
             hv_name in self.op.enabled_hypervisors)):
2848
          # either this is a new hypervisor, or its parameters have changed
2849
          hv_class = hypervisor.GetHypervisor(hv_name)
2850
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
2851
          hv_class.CheckParameterSyntax(hv_params)
2852
          _CheckHVParams(self, node_list, hv_name, hv_params)
2853

    
2854
    if self.op.os_hvp:
2855
      # no need to check any newly-enabled hypervisors, since the
2856
      # defaults have already been checked in the above code-block
2857
      for os_name, os_hvp in self.new_os_hvp.items():
2858
        for hv_name, hv_params in os_hvp.items():
2859
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
2860
          # we need to fill in the new os_hvp on top of the actual hv_p
2861
          cluster_defaults = self.new_hvparams.get(hv_name, {})
2862
          new_osp = objects.FillDict(cluster_defaults, hv_params)
2863
          hv_class = hypervisor.GetHypervisor(hv_name)
2864
          hv_class.CheckParameterSyntax(new_osp)
2865
          _CheckHVParams(self, node_list, hv_name, new_osp)
2866

    
2867
    if self.op.default_iallocator:
2868
      alloc_script = utils.FindFile(self.op.default_iallocator,
2869
                                    constants.IALLOCATOR_SEARCH_PATH,
2870
                                    os.path.isfile)
2871
      if alloc_script is None:
2872
        raise errors.OpPrereqError("Invalid default iallocator script '%s'"
2873
                                   " specified" % self.op.default_iallocator,
2874
                                   errors.ECODE_INVAL)
2875

    
2876
  def Exec(self, feedback_fn):
2877
    """Change the parameters of the cluster.
2878

2879
    """
2880
    if self.op.vg_name is not None:
2881
      new_volume = self.op.vg_name
2882
      if not new_volume:
2883
        new_volume = None
2884
      if new_volume != self.cfg.GetVGName():
2885
        self.cfg.SetVGName(new_volume)
2886
      else:
2887
        feedback_fn("Cluster LVM configuration already in desired"
2888
                    " state, not changing")
2889
    if self.op.drbd_helper is not None:
2890
      new_helper = self.op.drbd_helper
2891
      if not new_helper:
2892
        new_helper = None
2893
      if new_helper != self.cfg.GetDRBDHelper():
2894
        self.cfg.SetDRBDHelper(new_helper)
2895
      else:
2896
        feedback_fn("Cluster DRBD helper already in desired state,"
2897
                    " not changing")
2898
    if self.op.hvparams:
2899
      self.cluster.hvparams = self.new_hvparams
2900
    if self.op.os_hvp:
2901
      self.cluster.os_hvp = self.new_os_hvp
2902
    if self.op.enabled_hypervisors is not None:
2903
      self.cluster.hvparams = self.new_hvparams
2904
      self.cluster.enabled_hypervisors = self.op.enabled_hypervisors
2905
    if self.op.beparams:
2906
      self.cluster.beparams[constants.PP_DEFAULT] = self.new_beparams
2907
    if self.op.nicparams:
2908
      self.cluster.nicparams[constants.PP_DEFAULT] = self.new_nicparams
2909
    if self.op.osparams:
2910
      self.cluster.osparams = self.new_osp
2911
    if self.op.ndparams:
2912
      self.cluster.ndparams = self.new_ndparams
2913

    
2914
    if self.op.candidate_pool_size is not None:
2915
      self.cluster.candidate_pool_size = self.op.candidate_pool_size
2916
      # we need to update the pool size here, otherwise the save will fail
2917
      _AdjustCandidatePool(self, [])
2918

    
2919
    if self.op.maintain_node_health is not None:
2920
      self.cluster.maintain_node_health = self.op.maintain_node_health
2921

    
2922
    if self.op.prealloc_wipe_disks is not None:
2923
      self.cluster.prealloc_wipe_disks = self.op.prealloc_wipe_disks
2924

    
2925
    if self.op.add_uids is not None:
2926
      uidpool.AddToUidPool(self.cluster.uid_pool, self.op.add_uids)
2927

    
2928
    if self.op.remove_uids is not None:
2929
      uidpool.RemoveFromUidPool(self.cluster.uid_pool, self.op.remove_uids)
2930

    
2931
    if self.op.uid_pool is not None:
2932
      self.cluster.uid_pool = self.op.uid_pool
2933

    
2934
    if self.op.default_iallocator is not None:
2935
      self.cluster.default_iallocator = self.op.default_iallocator
2936

    
2937
    if self.op.reserved_lvs is not None:
2938
      self.cluster.reserved_lvs = self.op.reserved_lvs
2939

    
2940
    def helper_os(aname, mods, desc):
2941
      desc += " OS list"
2942
      lst = getattr(self.cluster, aname)
2943
      for key, val in mods:
2944
        if key == constants.DDM_ADD:
2945
          if val in lst:
2946
            feedback_fn("OS %s already in %s, ignoring" % (val, desc))
2947
          else:
2948
            lst.append(val)
2949
        elif key == constants.DDM_REMOVE:
2950
          if val in lst:
2951
            lst.remove(val)
2952
          else:
2953
            feedback_fn("OS %s not found in %s, ignoring" % (val, desc))
2954
        else:
2955
          raise errors.ProgrammerError("Invalid modification '%s'" % key)
2956

    
2957
    if self.op.hidden_os:
2958
      helper_os("hidden_os", self.op.hidden_os, "hidden")
2959

    
2960
    if self.op.blacklisted_os:
2961
      helper_os("blacklisted_os", self.op.blacklisted_os, "blacklisted")
2962

    
2963
    if self.op.master_netdev:
2964
      master = self.cfg.GetMasterNode()
2965
      feedback_fn("Shutting down master ip on the current netdev (%s)" %
2966
                  self.cluster.master_netdev)
2967
      result = self.rpc.call_node_stop_master(master, False)
2968
      result.Raise("Could not disable the master ip")
2969
      feedback_fn("Changing master_netdev from %s to %s" %
2970
                  (self.cluster.master_netdev, self.op.master_netdev))
2971
      self.cluster.master_netdev = self.op.master_netdev
2972

    
2973
    self.cfg.Update(self.cluster, feedback_fn)
2974

    
2975
    if self.op.master_netdev:
2976
      feedback_fn("Starting the master ip on the new master netdev (%s)" %
2977
                  self.op.master_netdev)
2978
      result = self.rpc.call_node_start_master(master, False, False)
2979
      if result.fail_msg:
2980
        self.LogWarning("Could not re-enable the master ip on"
2981
                        " the master, please restart manually: %s",
2982
                        result.fail_msg)
2983

    
2984

    
2985
def _UploadHelper(lu, nodes, fname):
2986
  """Helper for uploading a file and showing warnings.
2987

2988
  """
2989
  if os.path.exists(fname):
2990
    result = lu.rpc.call_upload_file(nodes, fname)
2991
    for to_node, to_result in result.items():
2992
      msg = to_result.fail_msg
2993
      if msg:
2994
        msg = ("Copy of file %s to node %s failed: %s" %
2995
               (fname, to_node, msg))
2996
        lu.proc.LogWarning(msg)
2997

    
2998

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

3002
  ConfigWriter takes care of distributing the config and ssconf files, but
3003
  there are more files which should be distributed to all nodes. This function
3004
  makes sure those are copied.
3005

3006
  @param lu: calling logical unit
3007
  @param additional_nodes: list of nodes not in the config to distribute to
3008
  @type additional_vm: boolean
3009
  @param additional_vm: whether the additional nodes are vm-capable or not
3010

3011
  """
3012
  # 1. Gather target nodes
3013
  myself = lu.cfg.GetNodeInfo(lu.cfg.GetMasterNode())
3014
  dist_nodes = lu.cfg.GetOnlineNodeList()
3015
  nvm_nodes = lu.cfg.GetNonVmCapableNodeList()
3016
  vm_nodes = [name for name in dist_nodes if name not in nvm_nodes]
3017
  if additional_nodes is not None:
3018
    dist_nodes.extend(additional_nodes)
3019
    if additional_vm:
3020
      vm_nodes.extend(additional_nodes)
3021
  if myself.name in dist_nodes:
3022
    dist_nodes.remove(myself.name)
3023
  if myself.name in vm_nodes:
3024
    vm_nodes.remove(myself.name)
3025

    
3026
  # 2. Gather files to distribute
3027
  dist_files = set([constants.ETC_HOSTS,
3028
                    constants.SSH_KNOWN_HOSTS_FILE,
3029
                    constants.RAPI_CERT_FILE,
3030
                    constants.RAPI_USERS_FILE,
3031
                    constants.CONFD_HMAC_KEY,
3032
                    constants.CLUSTER_DOMAIN_SECRET_FILE,
3033
                   ])
3034

    
3035
  vm_files = set()
3036
  enabled_hypervisors = lu.cfg.GetClusterInfo().enabled_hypervisors
3037
  for hv_name in enabled_hypervisors:
3038
    hv_class = hypervisor.GetHypervisor(hv_name)
3039
    vm_files.update(hv_class.GetAncillaryFiles())
3040

    
3041
  # 3. Perform the files upload
3042
  for fname in dist_files:
3043
    _UploadHelper(lu, dist_nodes, fname)
3044
  for fname in vm_files:
3045
    _UploadHelper(lu, vm_nodes, fname)
3046

    
3047

    
3048
class LUClusterRedistConf(NoHooksLU):
3049
  """Force the redistribution of cluster configuration.
3050

3051
  This is a very simple LU.
3052

3053
  """
3054
  REQ_BGL = False
3055

    
3056
  def ExpandNames(self):
3057
    self.needed_locks = {
3058
      locking.LEVEL_NODE: locking.ALL_SET,
3059
    }
3060
    self.share_locks[locking.LEVEL_NODE] = 1
3061

    
3062
  def Exec(self, feedback_fn):
3063
    """Redistribute the configuration.
3064

3065
    """
3066
    self.cfg.Update(self.cfg.GetClusterInfo(), feedback_fn)
3067
    _RedistributeAncillaryFiles(self)
3068

    
3069

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

3073
  """
3074
  if not instance.disks or disks is not None and not disks:
3075
    return True
3076

    
3077
  disks = _ExpandCheckDisks(instance, disks)
3078

    
3079
  if not oneshot:
3080
    lu.proc.LogInfo("Waiting for instance %s to sync disks." % instance.name)
3081

    
3082
  node = instance.primary_node
3083

    
3084
  for dev in disks:
3085
    lu.cfg.SetDiskID(dev, node)
3086

    
3087
  # TODO: Convert to utils.Retry
3088

    
3089
  retries = 0
3090
  degr_retries = 10 # in seconds, as we sleep 1 second each time
3091
  while True:
3092
    max_time = 0
3093
    done = True
3094
    cumul_degraded = False
3095
    rstats = lu.rpc.call_blockdev_getmirrorstatus(node, disks)
3096
    msg = rstats.fail_msg
3097
    if msg:
3098
      lu.LogWarning("Can't get any data from node %s: %s", node, msg)
3099
      retries += 1
3100
      if retries >= 10:
3101
        raise errors.RemoteError("Can't contact node %s for mirror data,"
3102
                                 " aborting." % node)
3103
      time.sleep(6)
3104
      continue
3105
    rstats = rstats.payload
3106
    retries = 0
3107
    for i, mstat in enumerate(rstats):
3108
      if mstat is None:
3109
        lu.LogWarning("Can't compute data for node %s/%s",
3110
                           node, disks[i].iv_name)
3111
        continue
3112

    
3113
      cumul_degraded = (cumul_degraded or
3114
                        (mstat.is_degraded and mstat.sync_percent is None))
3115
      if mstat.sync_percent is not None:
3116
        done = False
3117
        if mstat.estimated_time is not None:
3118
          rem_time = ("%s remaining (estimated)" %
3119
                      utils.FormatSeconds(mstat.estimated_time))
3120
          max_time = mstat.estimated_time
3121
        else:
3122
          rem_time = "no time estimate"
3123
        lu.proc.LogInfo("- device %s: %5.2f%% done, %s" %
3124
                        (disks[i].iv_name, mstat.sync_percent, rem_time))
3125

    
3126
    # if we're done but degraded, let's do a few small retries, to
3127
    # make sure we see a stable and not transient situation; therefore
3128
    # we force restart of the loop
3129
    if (done or oneshot) and cumul_degraded and degr_retries > 0:
3130
      logging.info("Degraded disks found, %d retries left", degr_retries)
3131
      degr_retries -= 1
3132
      time.sleep(1)
3133
      continue
3134

    
3135
    if done or oneshot:
3136
      break
3137

    
3138
    time.sleep(min(60, max_time))
3139

    
3140
  if done:
3141
    lu.proc.LogInfo("Instance %s's disks are in sync." % instance.name)
3142
  return not cumul_degraded
3143

    
3144

    
3145
def _CheckDiskConsistency(lu, dev, node, on_primary, ldisk=False):
3146
  """Check that mirrors are not degraded.
3147

3148
  The ldisk parameter, if True, will change the test from the
3149
  is_degraded attribute (which represents overall non-ok status for
3150
  the device(s)) to the ldisk (representing the local storage status).
3151

3152
  """
3153
  lu.cfg.SetDiskID(dev, node)
3154

    
3155
  result = True
3156

    
3157
  if on_primary or dev.AssembleOnSecondary():
3158
    rstats = lu.rpc.call_blockdev_find(node, dev)
3159
    msg = rstats.fail_msg
3160
    if msg:
3161
      lu.LogWarning("Can't find disk on node %s: %s", node, msg)
3162
      result = False
3163
    elif not rstats.payload:
3164
      lu.LogWarning("Can't find disk on node %s", node)
3165
      result = False
3166
    else:
3167
      if ldisk:
3168
        result = result and rstats.payload.ldisk_status == constants.LDS_OKAY
3169
      else:
3170
        result = result and not rstats.payload.is_degraded
3171

    
3172
  if dev.children:
3173
    for child in dev.children:
3174
      result = result and _CheckDiskConsistency(lu, child, node, on_primary)
3175

    
3176
  return result
3177

    
3178

    
3179
class LUOobCommand(NoHooksLU):
3180
  """Logical unit for OOB handling.
3181

3182
  """
3183
  REG_BGL = False
3184

    
3185
  def CheckPrereq(self):
3186
    """Check prerequisites.
3187

3188
    This checks:
3189
     - the node exists in the configuration
3190
     - OOB is supported
3191

3192
    Any errors are signaled by raising errors.OpPrereqError.
3193

3194
    """
3195
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3196
    node = self.cfg.GetNodeInfo(self.op.node_name)
3197

    
3198
    if node is None:
3199
      raise errors.OpPrereqError("Node %s not found" % self.op.node_name)
3200

    
3201
    self.oob_program = _SupportsOob(self.cfg, node)
3202

    
3203
    if not self.oob_program:
3204
      raise errors.OpPrereqError("OOB is not supported for node %s" %
3205
                                 self.op.node_name)
3206

    
3207
    if self.op.command == constants.OOB_POWER_OFF and not node.offline:
3208
      raise errors.OpPrereqError(("Cannot power off node %s because it is"
3209
                                  " not marked offline") % self.op.node_name)
3210

    
3211
    self.node = node
3212

    
3213
  def ExpandNames(self):
3214
    """Gather locks we need.
3215

3216
    """
3217
    node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3218
    self.needed_locks = {
3219
      locking.LEVEL_NODE: [node_name],
3220
      }
3221

    
3222
  def Exec(self, feedback_fn):
3223
    """Execute OOB and return result if we expect any.
3224

3225
    """
3226
    master_node = self.cfg.GetMasterNode()
3227
    node = self.node
3228

    
3229
    logging.info("Executing out-of-band command '%s' using '%s' on %s",
3230
                 self.op.command, self.oob_program, self.op.node_name)
3231
    result = self.rpc.call_run_oob(master_node, self.oob_program,
3232
                                   self.op.command, self.op.node_name,
3233
                                   self.op.timeout)
3234

    
3235
    result.Raise("An error occurred on execution of OOB helper")
3236

    
3237
    self._CheckPayload(result)
3238

    
3239
    if self.op.command == constants.OOB_HEALTH:
3240
      # For health we should log important events
3241
      for item, status in result.payload:
3242
        if status in [constants.OOB_STATUS_WARNING,
3243
                      constants.OOB_STATUS_CRITICAL]:
3244
          logging.warning("On node '%s' item '%s' has status '%s'",
3245
                          self.op.node_name, item, status)
3246

    
3247
    if self.op.command == constants.OOB_POWER_ON:
3248
      node.powered = True
3249
    elif self.op.command == constants.OOB_POWER_OFF:
3250
      node.powered = False
3251
    elif self.op.command == constants.OOB_POWER_STATUS:
3252
      powered = result.payload[constants.OOB_POWER_STATUS_POWERED]
3253
      if powered != self.node.powered:
3254
        logging.warning(("Recorded power state (%s) of node '%s' does not match"
3255
                         " actual power state (%s)"), node.powered,
3256
                        self.op.node_name, powered)
3257

    
3258
    self.cfg.Update(node, feedback_fn)
3259

    
3260
    return result.payload
3261

    
3262
  def _CheckPayload(self, result):
3263
    """Checks if the payload is valid.
3264

3265
    @param result: RPC result
3266
    @raises errors.OpExecError: If payload is not valid
3267

3268
    """
3269
    errs = []
3270
    if self.op.command == constants.OOB_HEALTH:
3271
      if not isinstance(result.payload, list):
3272
        errs.append("command 'health' is expected to return a list but got %s" %
3273
                    type(result.payload))
3274
      for item, status in result.payload:
3275
        if status not in constants.OOB_STATUSES:
3276
          errs.append("health item '%s' has invalid status '%s'" %
3277
                      (item, status))
3278

    
3279
    if self.op.command == constants.OOB_POWER_STATUS:
3280
      if not isinstance(result.payload, dict):
3281
        errs.append("power-status is expected to return a dict but got %s" %
3282
                    type(result.payload))
3283

    
3284
    if self.op.command in [
3285
        constants.OOB_POWER_ON,
3286
        constants.OOB_POWER_OFF,
3287
        constants.OOB_POWER_CYCLE,
3288
        ]:
3289
      if result.payload is not None:
3290
        errs.append("%s is expected to not return payload but got '%s'" %
3291
                    (self.op.command, result.payload))
3292

    
3293
    if errs:
3294
      raise errors.OpExecError("Check of out-of-band payload failed due to %s" %
3295
                               utils.CommaJoin(errs))
3296

    
3297

    
3298

    
3299
class LUOsDiagnose(NoHooksLU):
3300
  """Logical unit for OS diagnose/query.
3301

3302
  """
3303
  REQ_BGL = False
3304
  _HID = "hidden"
3305
  _BLK = "blacklisted"
3306
  _VLD = "valid"
3307
  _FIELDS_STATIC = utils.FieldSet()
3308
  _FIELDS_DYNAMIC = utils.FieldSet("name", _VLD, "node_status", "variants",
3309
                                   "parameters", "api_versions", _HID, _BLK)
3310

    
3311
  def CheckArguments(self):
3312
    if self.op.names:
3313
      raise errors.OpPrereqError("Selective OS query not supported",
3314
                                 errors.ECODE_INVAL)
3315

    
3316
    _CheckOutputFields(static=self._FIELDS_STATIC,
3317
                       dynamic=self._FIELDS_DYNAMIC,
3318
                       selected=self.op.output_fields)
3319

    
3320
  def ExpandNames(self):
3321
    # Lock all nodes, in shared mode
3322
    # Temporary removal of locks, should be reverted later
3323
    # TODO: reintroduce locks when they are lighter-weight
3324
    self.needed_locks = {}
3325
    #self.share_locks[locking.LEVEL_NODE] = 1
3326
    #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3327

    
3328
  @staticmethod
3329
  def _DiagnoseByOS(rlist):
3330
    """Remaps a per-node return list into an a per-os per-node dictionary
3331

3332
    @param rlist: a map with node names as keys and OS objects as values
3333

3334
    @rtype: dict
3335
    @return: a dictionary with osnames as keys and as value another
3336
        map, with nodes as keys and tuples of (path, status, diagnose,
3337
        variants, parameters, api_versions) as values, eg::
3338

3339
          {"debian-etch": {"node1": [(/usr/lib/..., True, "", [], []),
3340
                                     (/srv/..., False, "invalid api")],
3341
                           "node2": [(/srv/..., True, "", [], [])]}
3342
          }
3343

3344
    """
3345
    all_os = {}
3346
    # we build here the list of nodes that didn't fail the RPC (at RPC
3347
    # level), so that nodes with a non-responding node daemon don't
3348
    # make all OSes invalid
3349
    good_nodes = [node_name for node_name in rlist
3350
                  if not rlist[node_name].fail_msg]
3351
    for node_name, nr in rlist.items():
3352
      if nr.fail_msg or not nr.payload:
3353
        continue
3354
      for (name, path, status, diagnose, variants,
3355
           params, api_versions) in nr.payload:
3356
        if name not in all_os:
3357
          # build a list of nodes for this os containing empty lists
3358
          # for each node in node_list
3359
          all_os[name] = {}
3360
          for nname in good_nodes:
3361
            all_os[name][nname] = []
3362
        # convert params from [name, help] to (name, help)
3363
        params = [tuple(v) for v in params]
3364
        all_os[name][node_name].append((path, status, diagnose,
3365
                                        variants, params, api_versions))
3366
    return all_os
3367

    
3368
  def Exec(self, feedback_fn):
3369
    """Compute the list of OSes.
3370

3371
    """
3372
    valid_nodes = [node for node in self.cfg.GetOnlineNodeList()]
3373
    node_data = self.rpc.call_os_diagnose(valid_nodes)
3374
    pol = self._DiagnoseByOS(node_data)
3375
    output = []
3376
    cluster = self.cfg.GetClusterInfo()
3377

    
3378
    for os_name in utils.NiceSort(pol.keys()):
3379
      os_data = pol[os_name]
3380
      row = []
3381
      valid = True
3382
      (variants, params, api_versions) = null_state = (set(), set(), set())
3383
      for idx, osl in enumerate(os_data.values()):
3384
        valid = bool(valid and osl and osl[0][1])
3385
        if not valid:
3386
          (variants, params, api_versions) = null_state
3387
          break
3388
        node_variants, node_params, node_api = osl[0][3:6]
3389
        if idx == 0: # first entry
3390
          variants = set(node_variants)
3391
          params = set(node_params)
3392
          api_versions = set(node_api)
3393
        else: # keep consistency
3394
          variants.intersection_update(node_variants)
3395
          params.intersection_update(node_params)
3396
          api_versions.intersection_update(node_api)
3397

    
3398
      is_hid = os_name in cluster.hidden_os
3399
      is_blk = os_name in cluster.blacklisted_os
3400
      if ((self._HID not in self.op.output_fields and is_hid) or
3401
          (self._BLK not in self.op.output_fields and is_blk) or
3402
          (self._VLD not in self.op.output_fields and not valid)):
3403
        continue
3404

    
3405
      for field in self.op.output_fields:
3406
        if field == "name":
3407
          val = os_name
3408
        elif field == self._VLD:
3409
          val = valid
3410
        elif field == "node_status":
3411
          # this is just a copy of the dict
3412
          val = {}
3413
          for node_name, nos_list in os_data.items():
3414
            val[node_name] = nos_list
3415
        elif field == "variants":
3416
          val = utils.NiceSort(list(variants))
3417
        elif field == "parameters":
3418
          val = list(params)
3419
        elif field == "api_versions":
3420
          val = list(api_versions)
3421
        elif field == self._HID:
3422
          val = is_hid
3423
        elif field == self._BLK:
3424
          val = is_blk
3425
        else:
3426
          raise errors.ParameterError(field)
3427
        row.append(val)
3428
      output.append(row)
3429

    
3430
    return output
3431

    
3432

    
3433
class LUNodeRemove(LogicalUnit):
3434
  """Logical unit for removing a node.
3435

3436
  """
3437
  HPATH = "node-remove"
3438
  HTYPE = constants.HTYPE_NODE
3439

    
3440
  def BuildHooksEnv(self):
3441
    """Build hooks env.
3442

3443
    This doesn't run on the target node in the pre phase as a failed
3444
    node would then be impossible to remove.
3445

3446
    """
3447
    env = {
3448
      "OP_TARGET": self.op.node_name,
3449
      "NODE_NAME": self.op.node_name,
3450
      }
3451
    all_nodes = self.cfg.GetNodeList()
3452
    try:
3453
      all_nodes.remove(self.op.node_name)
3454
    except ValueError:
3455
      logging.warning("Node %s which is about to be removed not found"
3456
                      " in the all nodes list", self.op.node_name)
3457
    return env, all_nodes, all_nodes
3458

    
3459
  def CheckPrereq(self):
3460
    """Check prerequisites.
3461

3462
    This checks:
3463
     - the node exists in the configuration
3464
     - it does not have primary or secondary instances
3465
     - it's not the master
3466

3467
    Any errors are signaled by raising errors.OpPrereqError.
3468

3469
    """
3470
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3471
    node = self.cfg.GetNodeInfo(self.op.node_name)
3472
    assert node is not None
3473

    
3474
    instance_list = self.cfg.GetInstanceList()
3475

    
3476
    masternode = self.cfg.GetMasterNode()
3477
    if node.name == masternode:
3478
      raise errors.OpPrereqError("Node is the master node,"
3479
                                 " you need to failover first.",
3480
                                 errors.ECODE_INVAL)
3481

    
3482
    for instance_name in instance_list:
3483
      instance = self.cfg.GetInstanceInfo(instance_name)
3484
      if node.name in instance.all_nodes:
3485
        raise errors.OpPrereqError("Instance %s is still running on the node,"
3486
                                   " please remove first." % instance_name,
3487
                                   errors.ECODE_INVAL)
3488
    self.op.node_name = node.name
3489
    self.node = node
3490

    
3491
  def Exec(self, feedback_fn):
3492
    """Removes the node from the cluster.
3493

3494
    """
3495
    node = self.node
3496
    logging.info("Stopping the node daemon and removing configs from node %s",
3497
                 node.name)
3498

    
3499
    modify_ssh_setup = self.cfg.GetClusterInfo().modify_ssh_setup
3500

    
3501
    # Promote nodes to master candidate as needed
3502
    _AdjustCandidatePool(self, exceptions=[node.name])
3503
    self.context.RemoveNode(node.name)
3504

    
3505
    # Run post hooks on the node before it's removed
3506
    hm = self.proc.hmclass(self.rpc.call_hooks_runner, self)
3507
    try:
3508
      hm.RunPhase(constants.HOOKS_PHASE_POST, [node.name])
3509
    except:
3510
      # pylint: disable-msg=W0702
3511
      self.LogWarning("Errors occurred running hooks on %s" % node.name)
3512

    
3513
    result = self.rpc.call_node_leave_cluster(node.name, modify_ssh_setup)
3514
    msg = result.fail_msg
3515
    if msg:
3516
      self.LogWarning("Errors encountered on the remote node while leaving"
3517
                      " the cluster: %s", msg)
3518

    
3519
    # Remove node from our /etc/hosts
3520
    if self.cfg.GetClusterInfo().modify_etc_hosts:
3521
      master_node = self.cfg.GetMasterNode()
3522
      result = self.rpc.call_etc_hosts_modify(master_node,
3523
                                              constants.ETC_HOSTS_REMOVE,
3524
                                              node.name, None)
3525
      result.Raise("Can't update hosts file with new host data")
3526
      _RedistributeAncillaryFiles(self)
3527

    
3528

    
3529
class _NodeQuery(_QueryBase):
3530
  FIELDS = query.NODE_FIELDS
3531

    
3532
  def ExpandNames(self, lu):
3533
    lu.needed_locks = {}
3534
    lu.share_locks[locking.LEVEL_NODE] = 1
3535

    
3536
    if self.names:
3537
      self.wanted = _GetWantedNodes(lu, self.names)
3538
    else:
3539
      self.wanted = locking.ALL_SET
3540

    
3541
    self.do_locking = (self.use_locking and
3542
                       query.NQ_LIVE in self.requested_data)
3543

    
3544
    if self.do_locking:
3545
      # if we don't request only static fields, we need to lock the nodes
3546
      lu.needed_locks[locking.LEVEL_NODE] = self.wanted
3547

    
3548
  def DeclareLocks(self, lu, level):
3549
    pass
3550

    
3551
  def _GetQueryData(self, lu):
3552
    """Computes the list of nodes and their attributes.
3553

3554
    """
3555
    all_info = lu.cfg.GetAllNodesInfo()
3556

    
3557
    nodenames = self._GetNames(lu, all_info.keys(), locking.LEVEL_NODE)
3558

    
3559
    # Gather data as requested
3560
    if query.NQ_LIVE in self.requested_data:
3561
      node_data = lu.rpc.call_node_info(nodenames, lu.cfg.GetVGName(),
3562
                                        lu.cfg.GetHypervisorType())
3563
      live_data = dict((name, nresult.payload)
3564
                       for (name, nresult) in node_data.items()
3565
                       if not nresult.fail_msg and nresult.payload)
3566
    else:
3567
      live_data = None
3568

    
3569
    if query.NQ_INST in self.requested_data:
3570
      node_to_primary = dict([(name, set()) for name in nodenames])
3571
      node_to_secondary = dict([(name, set()) for name in nodenames])
3572

    
3573
      inst_data = lu.cfg.GetAllInstancesInfo()
3574

    
3575
      for inst in inst_data.values():
3576
        if inst.primary_node in node_to_primary:
3577
          node_to_primary[inst.primary_node].add(inst.name)
3578
        for secnode in inst.secondary_nodes:
3579
          if secnode in node_to_secondary:
3580
            node_to_secondary[secnode].add(inst.name)
3581
    else:
3582
      node_to_primary = None
3583
      node_to_secondary = None
3584

    
3585
    if query.NQ_OOB in self.requested_data:
3586
      oob_support = dict((name, bool(_SupportsOob(lu.cfg, node)))
3587
                         for name, node in all_info.iteritems())
3588
    else:
3589
      oob_support = None
3590

    
3591
    if query.NQ_GROUP in self.requested_data:
3592
      groups = lu.cfg.GetAllNodeGroupsInfo()
3593
    else:
3594
      groups = {}
3595

    
3596
    return query.NodeQueryData([all_info[name] for name in nodenames],
3597
                               live_data, lu.cfg.GetMasterNode(),
3598
                               node_to_primary, node_to_secondary, groups,
3599
                               oob_support, lu.cfg.GetClusterInfo())
3600

    
3601

    
3602
class LUNodeQuery(NoHooksLU):
3603
  """Logical unit for querying nodes.
3604

3605
  """
3606
  # pylint: disable-msg=W0142
3607
  REQ_BGL = False
3608

    
3609
  def CheckArguments(self):
3610
    self.nq = _NodeQuery(self.op.names, self.op.output_fields,
3611
                         self.op.use_locking)
3612

    
3613
  def ExpandNames(self):
3614
    self.nq.ExpandNames(self)
3615

    
3616
  def Exec(self, feedback_fn):
3617
    return self.nq.OldStyleQuery(self)
3618

    
3619

    
3620
class LUNodeQueryvols(NoHooksLU):
3621
  """Logical unit for getting volumes on node(s).
3622

3623
  """
3624
  REQ_BGL = False
3625
  _FIELDS_DYNAMIC = utils.FieldSet("phys", "vg", "name", "size", "instance")
3626
  _FIELDS_STATIC = utils.FieldSet("node")
3627

    
3628
  def CheckArguments(self):
3629
    _CheckOutputFields(static=self._FIELDS_STATIC,
3630
                       dynamic=self._FIELDS_DYNAMIC,
3631
                       selected=self.op.output_fields)
3632

    
3633
  def ExpandNames(self):
3634
    self.needed_locks = {}
3635
    self.share_locks[locking.LEVEL_NODE] = 1
3636
    if not self.op.nodes:
3637
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3638
    else:
3639
      self.needed_locks[locking.LEVEL_NODE] = \
3640
        _GetWantedNodes(self, self.op.nodes)
3641

    
3642
  def Exec(self, feedback_fn):
3643
    """Computes the list of nodes and their attributes.
3644

3645
    """
3646
    nodenames = self.acquired_locks[locking.LEVEL_NODE]
3647
    volumes = self.rpc.call_node_volumes(nodenames)
3648

    
3649
    ilist = [self.cfg.GetInstanceInfo(iname) for iname
3650
             in self.cfg.GetInstanceList()]
3651

    
3652
    lv_by_node = dict([(inst, inst.MapLVsByNode()) for inst in ilist])
3653

    
3654
    output = []
3655
    for node in nodenames:
3656
      nresult = volumes[node]
3657
      if nresult.offline:
3658
        continue
3659
      msg = nresult.fail_msg
3660
      if msg:
3661
        self.LogWarning("Can't compute volume data on node %s: %s", node, msg)
3662
        continue
3663

    
3664
      node_vols = nresult.payload[:]
3665
      node_vols.sort(key=lambda vol: vol['dev'])
3666

    
3667
      for vol in node_vols:
3668
        node_output = []
3669
        for field in self.op.output_fields:
3670
          if field == "node":
3671
            val = node
3672
          elif field == "phys":
3673
            val = vol['dev']
3674
          elif field == "vg":
3675
            val = vol['vg']
3676
          elif field == "name":
3677
            val = vol['name']
3678
          elif field == "size":
3679
            val = int(float(vol['size']))
3680
          elif field == "instance":
3681
            for inst in ilist:
3682
              if node not in lv_by_node[inst]:
3683
                continue
3684
              if vol['name'] in lv_by_node[inst][node]:
3685
                val = inst.name
3686
                break
3687
            else:
3688
              val = '-'
3689
          else:
3690
            raise errors.ParameterError(field)
3691
          node_output.append(str(val))
3692

    
3693
        output.append(node_output)
3694

    
3695
    return output
3696

    
3697

    
3698
class LUNodeQueryStorage(NoHooksLU):
3699
  """Logical unit for getting information on storage units on node(s).
3700

3701
  """
3702
  _FIELDS_STATIC = utils.FieldSet(constants.SF_NODE)
3703
  REQ_BGL = False
3704

    
3705
  def CheckArguments(self):
3706
    _CheckOutputFields(static=self._FIELDS_STATIC,
3707
                       dynamic=utils.FieldSet(*constants.VALID_STORAGE_FIELDS),
3708
                       selected=self.op.output_fields)
3709

    
3710
  def ExpandNames(self):
3711
    self.needed_locks = {}
3712
    self.share_locks[locking.LEVEL_NODE] = 1
3713

    
3714
    if self.op.nodes:
3715
      self.needed_locks[locking.LEVEL_NODE] = \
3716
        _GetWantedNodes(self, self.op.nodes)
3717
    else:
3718
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3719

    
3720
  def Exec(self, feedback_fn):
3721
    """Computes the list of nodes and their attributes.
3722

3723
    """
3724
    self.nodes = self.acquired_locks[locking.LEVEL_NODE]
3725

    
3726
    # Always get name to sort by
3727
    if constants.SF_NAME in self.op.output_fields:
3728
      fields = self.op.output_fields[:]
3729
    else:
3730
      fields = [constants.SF_NAME] + self.op.output_fields
3731

    
3732
    # Never ask for node or type as it's only known to the LU
3733
    for extra in [constants.SF_NODE, constants.SF_TYPE]:
3734
      while extra in fields:
3735
        fields.remove(extra)
3736

    
3737
    field_idx = dict([(name, idx) for (idx, name) in enumerate(fields)])
3738
    name_idx = field_idx[constants.SF_NAME]
3739

    
3740
    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
3741
    data = self.rpc.call_storage_list(self.nodes,
3742
                                      self.op.storage_type, st_args,
3743
                                      self.op.name, fields)
3744

    
3745
    result = []
3746

    
3747
    for node in utils.NiceSort(self.nodes):
3748
      nresult = data[node]
3749
      if nresult.offline:
3750
        continue
3751

    
3752
      msg = nresult.fail_msg
3753
      if msg:
3754
        self.LogWarning("Can't get storage data from node %s: %s", node, msg)
3755
        continue
3756

    
3757
      rows = dict([(row[name_idx], row) for row in nresult.payload])
3758

    
3759
      for name in utils.NiceSort(rows.keys()):
3760
        row = rows[name]
3761

    
3762
        out = []
3763

    
3764
        for field in self.op.output_fields:
3765
          if field == constants.SF_NODE:
3766
            val = node
3767
          elif field == constants.SF_TYPE:
3768
            val = self.op.storage_type
3769
          elif field in field_idx:
3770
            val = row[field_idx[field]]
3771
          else:
3772
            raise errors.ParameterError(field)
3773

    
3774
          out.append(val)
3775

    
3776
        result.append(out)
3777

    
3778
    return result
3779

    
3780

    
3781
class _InstanceQuery(_QueryBase):
3782
  FIELDS = query.INSTANCE_FIELDS
3783

    
3784
  def ExpandNames(self, lu):
3785
    lu.needed_locks = {}
3786
    lu.share_locks[locking.LEVEL_INSTANCE] = 1
3787
    lu.share_locks[locking.LEVEL_NODE] = 1
3788

    
3789
    if self.names:
3790
      self.wanted = _GetWantedInstances(lu, self.names)
3791
    else:
3792
      self.wanted = locking.ALL_SET
3793

    
3794
    self.do_locking = (self.use_locking and
3795
                       query.IQ_LIVE in self.requested_data)
3796
    if self.do_locking:
3797
      lu.needed_locks[locking.LEVEL_INSTANCE] = self.wanted
3798
      lu.needed_locks[locking.LEVEL_NODE] = []
3799
      lu.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
3800

    
3801
  def DeclareLocks(self, lu, level):
3802
    if level == locking.LEVEL_NODE and self.do_locking:
3803
      lu._LockInstancesNodes() # pylint: disable-msg=W0212
3804

    
3805
  def _GetQueryData(self, lu):
3806
    """Computes the list of instances and their attributes.
3807

3808
    """
3809
    all_info = lu.cfg.GetAllInstancesInfo()
3810

    
3811
    instance_names = self._GetNames(lu, all_info.keys(), locking.LEVEL_INSTANCE)
3812

    
3813
    instance_list = [all_info[name] for name in instance_names]
3814
    nodes = frozenset([inst.primary_node for inst in instance_list])
3815
    hv_list = list(set([inst.hypervisor for inst in instance_list]))
3816
    bad_nodes = []
3817
    offline_nodes = []
3818

    
3819
    # Gather data as requested
3820
    if query.IQ_LIVE in self.requested_data:
3821
      live_data = {}
3822
      node_data = lu.rpc.call_all_instances_info(nodes, hv_list)
3823
      for name in nodes:
3824
        result = node_data[name]
3825
        if result.offline:
3826
          # offline nodes will be in both lists
3827
          assert result.fail_msg
3828
          offline_nodes.append(name)
3829
        if result.fail_msg:
3830
          bad_nodes.append(name)
3831
        elif result.payload:
3832
          live_data.update(result.payload)
3833
        # else no instance is alive
3834
    else:
3835
      live_data = {}
3836

    
3837
    if query.IQ_DISKUSAGE in self.requested_data:
3838
      disk_usage = dict((inst.name,
3839
                         _ComputeDiskSize(inst.disk_template,
3840
                                          [{"size": disk.size}
3841
                                           for disk in inst.disks]))
3842
                        for inst in instance_list)
3843
    else:
3844
      disk_usage = None
3845

    
3846
    return query.InstanceQueryData(instance_list, lu.cfg.GetClusterInfo(),
3847
                                   disk_usage, offline_nodes, bad_nodes,
3848
                                   live_data)
3849

    
3850

    
3851
class LUQuery(NoHooksLU):
3852
  """Query for resources/items of a certain kind.
3853

3854
  """
3855
  # pylint: disable-msg=W0142
3856
  REQ_BGL = False
3857

    
3858
  def CheckArguments(self):
3859
    qcls = _GetQueryImplementation(self.op.what)
3860
    names = qlang.ReadSimpleFilter("name", self.op.filter)
3861

    
3862
    self.impl = qcls(names, self.op.fields, False)
3863

    
3864
  def ExpandNames(self):
3865
    self.impl.ExpandNames(self)
3866

    
3867
  def DeclareLocks(self, level):
3868
    self.impl.DeclareLocks(self, level)
3869

    
3870
  def Exec(self, feedback_fn):
3871
    return self.impl.NewStyleQuery(self)
3872

    
3873

    
3874
class LUQueryFields(NoHooksLU):
3875
  """Query for resources/items of a certain kind.
3876

3877
  """
3878
  # pylint: disable-msg=W0142
3879
  REQ_BGL = False
3880

    
3881
  def CheckArguments(self):
3882
    self.qcls = _GetQueryImplementation(self.op.what)
3883

    
3884
  def ExpandNames(self):
3885
    self.needed_locks = {}
3886

    
3887
  def Exec(self, feedback_fn):
3888
    return self.qcls.FieldsQuery(self.op.fields)
3889

    
3890

    
3891
class LUNodeModifyStorage(NoHooksLU):
3892
  """Logical unit for modifying a storage volume on a node.
3893

3894
  """
3895
  REQ_BGL = False
3896

    
3897
  def CheckArguments(self):
3898
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3899

    
3900
    storage_type = self.op.storage_type
3901

    
3902
    try:
3903
      modifiable = constants.MODIFIABLE_STORAGE_FIELDS[storage_type]
3904
    except KeyError:
3905
      raise errors.OpPrereqError("Storage units of type '%s' can not be"
3906
                                 " modified" % storage_type,
3907
                                 errors.ECODE_INVAL)
3908

    
3909
    diff = set(self.op.changes.keys()) - modifiable
3910
    if diff:
3911
      raise errors.OpPrereqError("The following fields can not be modified for"
3912
                                 " storage units of type '%s': %r" %
3913
                                 (storage_type, list(diff)),
3914
                                 errors.ECODE_INVAL)
3915

    
3916
  def ExpandNames(self):
3917
    self.needed_locks = {
3918
      locking.LEVEL_NODE: self.op.node_name,
3919
      }
3920

    
3921
  def Exec(self, feedback_fn):
3922
    """Computes the list of nodes and their attributes.
3923

3924
    """
3925
    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
3926
    result = self.rpc.call_storage_modify(self.op.node_name,
3927
                                          self.op.storage_type, st_args,
3928
                                          self.op.name, self.op.changes)
3929
    result.Raise("Failed to modify storage unit '%s' on %s" %
3930
                 (self.op.name, self.op.node_name))
3931

    
3932

    
3933
class LUNodeAdd(LogicalUnit):
3934
  """Logical unit for adding node to the cluster.
3935

3936
  """
3937
  HPATH = "node-add"
3938
  HTYPE = constants.HTYPE_NODE
3939
  _NFLAGS = ["master_capable", "vm_capable"]
3940

    
3941
  def CheckArguments(self):
3942
    self.primary_ip_family = self.cfg.GetPrimaryIPFamily()
3943
    # validate/normalize the node name
3944
    self.hostname = netutils.GetHostname(name=self.op.node_name,
3945
                                         family=self.primary_ip_family)
3946
    self.op.node_name = self.hostname.name
3947
    if self.op.readd and self.op.group:
3948
      raise errors.OpPrereqError("Cannot pass a node group when a node is"
3949
                                 " being readded", errors.ECODE_INVAL)
3950

    
3951
  def BuildHooksEnv(self):
3952
    """Build hooks env.
3953

3954
    This will run on all nodes before, and on all nodes + the new node after.
3955

3956
    """
3957
    env = {
3958
      "OP_TARGET": self.op.node_name,
3959
      "NODE_NAME": self.op.node_name,
3960
      "NODE_PIP": self.op.primary_ip,
3961
      "NODE_SIP": self.op.secondary_ip,
3962
      "MASTER_CAPABLE": str(self.op.master_capable),
3963
      "VM_CAPABLE": str(self.op.vm_capable),
3964
      }
3965
    nodes_0 = self.cfg.GetNodeList()
3966
    nodes_1 = nodes_0 + [self.op.node_name, ]
3967
    return env, nodes_0, nodes_1
3968

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

3972
    This checks:
3973
     - the new node is not already in the config
3974
     - it is resolvable
3975
     - its parameters (single/dual homed) matches the cluster
3976

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

3979
    """
3980
    cfg = self.cfg
3981
    hostname = self.hostname
3982
    node = hostname.name
3983
    primary_ip = self.op.primary_ip = hostname.ip
3984
    if self.op.secondary_ip is None:
3985
      if self.primary_ip_family == netutils.IP6Address.family:
3986
        raise errors.OpPrereqError("When using a IPv6 primary address, a valid"
3987
                                   " IPv4 address must be given as secondary",
3988
                                   errors.ECODE_INVAL)
3989
      self.op.secondary_ip = primary_ip
3990

    
3991
    secondary_ip = self.op.secondary_ip
3992
    if not netutils.IP4Address.IsValid(secondary_ip):
3993
      raise errors.OpPrereqError("Secondary IP (%s) needs to be a valid IPv4"
3994
                                 " address" % secondary_ip, errors.ECODE_INVAL)
3995

    
3996
    node_list = cfg.GetNodeList()
3997
    if not self.op.readd and node in node_list:
3998
      raise errors.OpPrereqError("Node %s is already in the configuration" %
3999
                                 node, errors.ECODE_EXISTS)
4000
    elif self.op.readd and node not in node_list:
4001
      raise errors.OpPrereqError("Node %s is not in the configuration" % node,
4002
                                 errors.ECODE_NOENT)
4003

    
4004
    self.changed_primary_ip = False
4005

    
4006
    for existing_node_name in node_list:
4007
      existing_node = cfg.GetNodeInfo(existing_node_name)
4008

    
4009
      if self.op.readd and node == existing_node_name:
4010
        if existing_node.secondary_ip != secondary_ip:
4011
          raise errors.OpPrereqError("Readded node doesn't have the same IP"
4012
                                     " address configuration as before",
4013
                                     errors.ECODE_INVAL)
4014
        if existing_node.primary_ip != primary_ip:
4015
          self.changed_primary_ip = True
4016

    
4017
        continue
4018

    
4019
      if (existing_node.primary_ip == primary_ip or
4020
          existing_node.secondary_ip == primary_ip or
4021
          existing_node.primary_ip == secondary_ip or
4022
          existing_node.secondary_ip == secondary_ip):
4023
        raise errors.OpPrereqError("New node ip address(es) conflict with"
4024
                                   " existing node %s" % existing_node.name,
4025
                                   errors.ECODE_NOTUNIQUE)
4026

    
4027
    # After this 'if' block, None is no longer a valid value for the
4028
    # _capable op attributes
4029
    if self.op.readd:
4030
      old_node = self.cfg.GetNodeInfo(node)
4031
      assert old_node is not None, "Can't retrieve locked node %s" % node
4032
      for attr in self._NFLAGS:
4033
        if getattr(self.op, attr) is None:
4034
          setattr(self.op, attr, getattr(old_node, attr))
4035
    else:
4036
      for attr in self._NFLAGS:
4037
        if getattr(self.op, attr) is None:
4038
          setattr(self.op, attr, True)
4039

    
4040
    if self.op.readd and not self.op.vm_capable:
4041
      pri, sec = cfg.GetNodeInstances(node)
4042
      if pri or sec:
4043
        raise errors.OpPrereqError("Node %s being re-added with vm_capable"
4044
                                   " flag set to false, but it already holds"
4045
                                   " instances" % node,
4046
                                   errors.ECODE_STATE)
4047

    
4048
    # check that the type of the node (single versus dual homed) is the
4049
    # same as for the master
4050
    myself = cfg.GetNodeInfo(self.cfg.GetMasterNode())
4051
    master_singlehomed = myself.secondary_ip == myself.primary_ip
4052
    newbie_singlehomed = secondary_ip == primary_ip
4053
    if master_singlehomed != newbie_singlehomed:
4054
      if master_singlehomed:
4055
        raise errors.OpPrereqError("The master has no secondary ip but the"
4056
                                   " new node has one",
4057
                                   errors.ECODE_INVAL)
4058
      else:
4059
        raise errors.OpPrereqError("The master has a secondary ip but the"
4060
                                   " new node doesn't have one",
4061
                                   errors.ECODE_INVAL)
4062

    
4063
    # checks reachability
4064
    if not netutils.TcpPing(primary_ip, constants.DEFAULT_NODED_PORT):
4065
      raise errors.OpPrereqError("Node not reachable by ping",
4066
                                 errors.ECODE_ENVIRON)
4067

    
4068
    if not newbie_singlehomed:
4069
      # check reachability from my secondary ip to newbie's secondary ip
4070
      if not netutils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,
4071
                           source=myself.secondary_ip):
4072
        raise errors.OpPrereqError("Node secondary ip not reachable by TCP"
4073
                                   " based ping to node daemon port",
4074
                                   errors.ECODE_ENVIRON)
4075

    
4076
    if self.op.readd:
4077
      exceptions = [node]
4078
    else:
4079
      exceptions = []
4080

    
4081
    if self.op.master_capable:
4082
      self.master_candidate = _DecideSelfPromotion(self, exceptions=exceptions)
4083
    else:
4084
      self.master_candidate = False
4085

    
4086
    if self.op.readd:
4087
      self.new_node = old_node
4088
    else:
4089
      node_group = cfg.LookupNodeGroup(self.op.group)
4090
      self