Statistics
| Branch: | Tag: | Revision:

root / lib / cmdlib.py @ 3a488770

History | View | Annotate | Download (332.3 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007, 2008 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
25

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

    
29
import os
30
import os.path
31
import time
32
import re
33
import platform
34
import logging
35
import copy
36
import OpenSSL
37

    
38
from ganeti import ssh
39
from ganeti import utils
40
from ganeti import errors
41
from ganeti import hypervisor
42
from ganeti import locking
43
from ganeti import constants
44
from ganeti import objects
45
from ganeti import serializer
46
from ganeti import ssconf
47

    
48

    
49
class LogicalUnit(object):
50
  """Logical Unit base class.
51

52
  Subclasses must follow these rules:
53
    - implement ExpandNames
54
    - implement CheckPrereq (except when tasklets are used)
55
    - implement Exec (except when tasklets are used)
56
    - implement BuildHooksEnv
57
    - redefine HPATH and HTYPE
58
    - optionally redefine their run requirements:
59
        REQ_BGL: the LU needs to hold the Big Ganeti Lock exclusively
60

61
  Note that all commands require root permissions.
62

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

66
  """
67
  HPATH = None
68
  HTYPE = None
69
  _OP_REQP = []
70
  REQ_BGL = True
71

    
72
  def __init__(self, processor, op, context, rpc):
73
    """Constructor for LogicalUnit.
74

75
    This needs to be overridden in derived classes in order to check op
76
    validity.
77

78
    """
79
    self.proc = processor
80
    self.op = op
81
    self.cfg = context.cfg
82
    self.context = context
83
    self.rpc = rpc
84
    # Dicts used to declare locking needs to mcpu
85
    self.needed_locks = None
86
    self.acquired_locks = {}
87
    self.share_locks = dict.fromkeys(locking.LEVELS, 0)
88
    self.add_locks = {}
89
    self.remove_locks = {}
90
    # Used to force good behavior when calling helper functions
91
    self.recalculate_locks = {}
92
    self.__ssh = None
93
    # logging
94
    self.LogWarning = processor.LogWarning # pylint: disable-msg=C0103
95
    self.LogInfo = processor.LogInfo # pylint: disable-msg=C0103
96
    self.LogStep = processor.LogStep # pylint: disable-msg=C0103
97
    # support for dry-run
98
    self.dry_run_result = None
99
    # support for generic debug attribute
100
    if (not hasattr(self.op, "debug_level") or
101
        not isinstance(self.op.debug_level, int)):
102
      self.op.debug_level = 0
103

    
104
    # Tasklets
105
    self.tasklets = None
106

    
107
    for attr_name in self._OP_REQP:
108
      attr_val = getattr(op, attr_name, None)
109
      if attr_val is None:
110
        raise errors.OpPrereqError("Required parameter '%s' missing" %
111
                                   attr_name, errors.ECODE_INVAL)
112

    
113
    self.CheckArguments()
114

    
115
  def __GetSSH(self):
116
    """Returns the SshRunner object
117

118
    """
119
    if not self.__ssh:
120
      self.__ssh = ssh.SshRunner(self.cfg.GetClusterName())
121
    return self.__ssh
122

    
123
  ssh = property(fget=__GetSSH)
124

    
125
  def CheckArguments(self):
126
    """Check syntactic validity for the opcode arguments.
127

128
    This method is for doing a simple syntactic check and ensure
129
    validity of opcode parameters, without any cluster-related
130
    checks. While the same can be accomplished in ExpandNames and/or
131
    CheckPrereq, doing these separate is better because:
132

133
      - ExpandNames is left as as purely a lock-related function
134
      - CheckPrereq is run after we have acquired locks (and possible
135
        waited for them)
136

137
    The function is allowed to change the self.op attribute so that
138
    later methods can no longer worry about missing parameters.
139

140
    """
141
    pass
142

    
143
  def ExpandNames(self):
144
    """Expand names for this LU.
145

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

151
    LUs which implement this method must also populate the self.needed_locks
152
    member, as a dict with lock levels as keys, and a list of needed lock names
153
    as values. Rules:
154

155
      - use an empty dict if you don't need any lock
156
      - if you don't need any lock at a particular level omit that level
157
      - don't put anything for the BGL level
158
      - if you want all locks at a level use locking.ALL_SET as a value
159

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

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

168
    Examples::
169

170
      # Acquire all nodes and one instance
171
      self.needed_locks = {
172
        locking.LEVEL_NODE: locking.ALL_SET,
173
        locking.LEVEL_INSTANCE: ['instance1.example.tld'],
174
      }
175
      # Acquire just two nodes
176
      self.needed_locks = {
177
        locking.LEVEL_NODE: ['node1.example.tld', 'node2.example.tld'],
178
      }
179
      # Acquire no locks
180
      self.needed_locks = {} # No, you can't leave it to the default value None
181

182
    """
183
    # The implementation of this method is mandatory only if the new LU is
184
    # concurrent, so that old LUs don't need to be changed all at the same
185
    # time.
186
    if self.REQ_BGL:
187
      self.needed_locks = {} # Exclusive LUs don't need locks.
188
    else:
189
      raise NotImplementedError
190

    
191
  def DeclareLocks(self, level):
192
    """Declare LU locking needs for a level
193

194
    While most LUs can just declare their locking needs at ExpandNames time,
195
    sometimes there's the need to calculate some locks after having acquired
196
    the ones before. This function is called just before acquiring locks at a
197
    particular level, but after acquiring the ones at lower levels, and permits
198
    such calculations. It can be used to modify self.needed_locks, and by
199
    default it does nothing.
200

201
    This function is only called if you have something already set in
202
    self.needed_locks for the level.
203

204
    @param level: Locking level which is going to be locked
205
    @type level: member of ganeti.locking.LEVELS
206

207
    """
208

    
209
  def CheckPrereq(self):
210
    """Check prerequisites for this LU.
211

212
    This method should check that the prerequisites for the execution
213
    of this LU are fulfilled. It can do internode communication, but
214
    it should be idempotent - no cluster or system changes are
215
    allowed.
216

217
    The method should raise errors.OpPrereqError in case something is
218
    not fulfilled. Its return value is ignored.
219

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

223
    """
224
    if self.tasklets is not None:
225
      for (idx, tl) in enumerate(self.tasklets):
226
        logging.debug("Checking prerequisites for tasklet %s/%s",
227
                      idx + 1, len(self.tasklets))
228
        tl.CheckPrereq()
229
    else:
230
      raise NotImplementedError
231

    
232
  def Exec(self, feedback_fn):
233
    """Execute the LU.
234

235
    This method should implement the actual work. It should raise
236
    errors.OpExecError for failures that are somewhat dealt with in
237
    code, or expected.
238

239
    """
240
    if self.tasklets is not None:
241
      for (idx, tl) in enumerate(self.tasklets):
242
        logging.debug("Executing tasklet %s/%s", idx + 1, len(self.tasklets))
243
        tl.Exec(feedback_fn)
244
    else:
245
      raise NotImplementedError
246

    
247
  def BuildHooksEnv(self):
248
    """Build hooks environment for this LU.
249

250
    This method should return a three-node tuple consisting of: a dict
251
    containing the environment that will be used for running the
252
    specific hook for this LU, a list of node names on which the hook
253
    should run before the execution, and a list of node names on which
254
    the hook should run after the execution.
255

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

261
    No nodes should be returned as an empty list (and not None).
262

263
    Note that if the HPATH for a LU class is None, this function will
264
    not be called.
265

266
    """
267
    raise NotImplementedError
268

    
269
  def HooksCallBack(self, phase, hook_results, feedback_fn, lu_result):
270
    """Notify the LU about the results of its hooks.
271

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

278
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
279
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
280
    @param hook_results: the results of the multi-node hooks rpc call
281
    @param feedback_fn: function used send feedback back to the caller
282
    @param lu_result: the previous Exec result this LU had, or None
283
        in the PRE phase
284
    @return: the new Exec result, based on the previous result
285
        and hook results
286

287
    """
288
    # API must be kept, thus we ignore the unused argument and could
289
    # be a function warnings
290
    # pylint: disable-msg=W0613,R0201
291
    return lu_result
292

    
293
  def _ExpandAndLockInstance(self):
294
    """Helper function to expand and lock an instance.
295

296
    Many LUs that work on an instance take its name in self.op.instance_name
297
    and need to expand it and then declare the expanded name for locking. This
298
    function does it, and then updates self.op.instance_name to the expanded
299
    name. It also initializes needed_locks as a dict, if this hasn't been done
300
    before.
301

302
    """
303
    if self.needed_locks is None:
304
      self.needed_locks = {}
305
    else:
306
      assert locking.LEVEL_INSTANCE not in self.needed_locks, \
307
        "_ExpandAndLockInstance called with instance-level locks set"
308
    self.op.instance_name = _ExpandInstanceName(self.cfg,
309
                                                self.op.instance_name)
310
    self.needed_locks[locking.LEVEL_INSTANCE] = self.op.instance_name
311

    
312
  def _LockInstancesNodes(self, primary_only=False):
313
    """Helper function to declare instances' nodes for locking.
314

315
    This function should be called after locking one or more instances to lock
316
    their nodes. Its effect is populating self.needed_locks[locking.LEVEL_NODE]
317
    with all primary or secondary nodes for instances already locked and
318
    present in self.needed_locks[locking.LEVEL_INSTANCE].
319

320
    It should be called from DeclareLocks, and for safety only works if
321
    self.recalculate_locks[locking.LEVEL_NODE] is set.
322

323
    In the future it may grow parameters to just lock some instance's nodes, or
324
    to just lock primaries or secondary nodes, if needed.
325

326
    If should be called in DeclareLocks in a way similar to::
327

328
      if level == locking.LEVEL_NODE:
329
        self._LockInstancesNodes()
330

331
    @type primary_only: boolean
332
    @param primary_only: only lock primary nodes of locked instances
333

334
    """
335
    assert locking.LEVEL_NODE in self.recalculate_locks, \
336
      "_LockInstancesNodes helper function called with no nodes to recalculate"
337

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

    
340
    # For now we'll replace self.needed_locks[locking.LEVEL_NODE], but in the
341
    # future we might want to have different behaviors depending on the value
342
    # of self.recalculate_locks[locking.LEVEL_NODE]
343
    wanted_nodes = []
344
    for instance_name in self.acquired_locks[locking.LEVEL_INSTANCE]:
345
      instance = self.context.cfg.GetInstanceInfo(instance_name)
346
      wanted_nodes.append(instance.primary_node)
347
      if not primary_only:
348
        wanted_nodes.extend(instance.secondary_nodes)
349

    
350
    if self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_REPLACE:
351
      self.needed_locks[locking.LEVEL_NODE] = wanted_nodes
352
    elif self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_APPEND:
353
      self.needed_locks[locking.LEVEL_NODE].extend(wanted_nodes)
354

    
355
    del self.recalculate_locks[locking.LEVEL_NODE]
356

    
357

    
358
class NoHooksLU(LogicalUnit): # pylint: disable-msg=W0223
359
  """Simple LU which runs no hooks.
360

361
  This LU is intended as a parent for other LogicalUnits which will
362
  run no hooks, in order to reduce duplicate code.
363

364
  """
365
  HPATH = None
366
  HTYPE = None
367

    
368
  def BuildHooksEnv(self):
369
    """Empty BuildHooksEnv for NoHooksLu.
370

371
    This just raises an error.
372

373
    """
374
    assert False, "BuildHooksEnv called for NoHooksLUs"
375

    
376

    
377
class Tasklet:
378
  """Tasklet base class.
379

380
  Tasklets are subcomponents for LUs. LUs can consist entirely of tasklets or
381
  they can mix legacy code with tasklets. Locking needs to be done in the LU,
382
  tasklets know nothing about locks.
383

384
  Subclasses must follow these rules:
385
    - Implement CheckPrereq
386
    - Implement Exec
387

388
  """
389
  def __init__(self, lu):
390
    self.lu = lu
391

    
392
    # Shortcuts
393
    self.cfg = lu.cfg
394
    self.rpc = lu.rpc
395

    
396
  def CheckPrereq(self):
397
    """Check prerequisites for this tasklets.
398

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

403
    The method should raise errors.OpPrereqError in case something is not
404
    fulfilled. Its return value is ignored.
405

406
    This method should also update all parameters to their canonical form if it
407
    hasn't been done before.
408

409
    """
410
    raise NotImplementedError
411

    
412
  def Exec(self, feedback_fn):
413
    """Execute the tasklet.
414

415
    This method should implement the actual work. It should raise
416
    errors.OpExecError for failures that are somewhat dealt with in code, or
417
    expected.
418

419
    """
420
    raise NotImplementedError
421

    
422

    
423
def _GetWantedNodes(lu, nodes):
424
  """Returns list of checked and expanded node names.
425

426
  @type lu: L{LogicalUnit}
427
  @param lu: the logical unit on whose behalf we execute
428
  @type nodes: list
429
  @param nodes: list of node names or None for all nodes
430
  @rtype: list
431
  @return: the list of nodes, sorted
432
  @raise errors.ProgrammerError: if the nodes parameter is wrong type
433

434
  """
435
  if not isinstance(nodes, list):
436
    raise errors.OpPrereqError("Invalid argument type 'nodes'",
437
                               errors.ECODE_INVAL)
438

    
439
  if not nodes:
440
    raise errors.ProgrammerError("_GetWantedNodes should only be called with a"
441
      " non-empty list of nodes whose name is to be expanded.")
442

    
443
  wanted = [_ExpandNodeName(lu.cfg, name) for name in nodes]
444
  return utils.NiceSort(wanted)
445

    
446

    
447
def _GetWantedInstances(lu, instances):
448
  """Returns list of checked and expanded instance names.
449

450
  @type lu: L{LogicalUnit}
451
  @param lu: the logical unit on whose behalf we execute
452
  @type instances: list
453
  @param instances: list of instance names or None for all instances
454
  @rtype: list
455
  @return: the list of instances, sorted
456
  @raise errors.OpPrereqError: if the instances parameter is wrong type
457
  @raise errors.OpPrereqError: if any of the passed instances is not found
458

459
  """
460
  if not isinstance(instances, list):
461
    raise errors.OpPrereqError("Invalid argument type 'instances'",
462
                               errors.ECODE_INVAL)
463

    
464
  if instances:
465
    wanted = [_ExpandInstanceName(lu.cfg, name) for name in instances]
466
  else:
467
    wanted = utils.NiceSort(lu.cfg.GetInstanceList())
468
  return wanted
469

    
470

    
471
def _CheckOutputFields(static, dynamic, selected):
472
  """Checks whether all selected fields are valid.
473

474
  @type static: L{utils.FieldSet}
475
  @param static: static fields set
476
  @type dynamic: L{utils.FieldSet}
477
  @param dynamic: dynamic fields set
478

479
  """
480
  f = utils.FieldSet()
481
  f.Extend(static)
482
  f.Extend(dynamic)
483

    
484
  delta = f.NonMatching(selected)
485
  if delta:
486
    raise errors.OpPrereqError("Unknown output fields selected: %s"
487
                               % ",".join(delta), errors.ECODE_INVAL)
488

    
489

    
490
def _CheckBooleanOpField(op, name):
491
  """Validates boolean opcode parameters.
492

493
  This will ensure that an opcode parameter is either a boolean value,
494
  or None (but that it always exists).
495

496
  """
497
  val = getattr(op, name, None)
498
  if not (val is None or isinstance(val, bool)):
499
    raise errors.OpPrereqError("Invalid boolean parameter '%s' (%s)" %
500
                               (name, str(val)), errors.ECODE_INVAL)
501
  setattr(op, name, val)
502

    
503

    
504
def _CheckGlobalHvParams(params):
505
  """Validates that given hypervisor params are not global ones.
506

507
  This will ensure that instances don't get customised versions of
508
  global params.
509

510
  """
511
  used_globals = constants.HVC_GLOBALS.intersection(params)
512
  if used_globals:
513
    msg = ("The following hypervisor parameters are global and cannot"
514
           " be customized at instance level, please modify them at"
515
           " cluster level: %s" % utils.CommaJoin(used_globals))
516
    raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
517

    
518

    
519
def _CheckNodeOnline(lu, node):
520
  """Ensure that a given node is online.
521

522
  @param lu: the LU on behalf of which we make the check
523
  @param node: the node to check
524
  @raise errors.OpPrereqError: if the node is offline
525

526
  """
527
  if lu.cfg.GetNodeInfo(node).offline:
528
    raise errors.OpPrereqError("Can't use offline node %s" % node,
529
                               errors.ECODE_INVAL)
530

    
531

    
532
def _CheckNodeNotDrained(lu, node):
533
  """Ensure that a given node is not drained.
534

535
  @param lu: the LU on behalf of which we make the check
536
  @param node: the node to check
537
  @raise errors.OpPrereqError: if the node is drained
538

539
  """
540
  if lu.cfg.GetNodeInfo(node).drained:
541
    raise errors.OpPrereqError("Can't use drained node %s" % node,
542
                               errors.ECODE_INVAL)
543

    
544

    
545
def _CheckNodeHasOS(lu, node, os_name, force_variant):
546
  """Ensure that a node supports a given OS.
547

548
  @param lu: the LU on behalf of which we make the check
549
  @param node: the node to check
550
  @param os_name: the OS to query about
551
  @param force_variant: whether to ignore variant errors
552
  @raise errors.OpPrereqError: if the node is not supporting the OS
553

554
  """
555
  result = lu.rpc.call_os_get(node, os_name)
556
  result.Raise("OS '%s' not in supported OS list for node %s" %
557
               (os_name, node),
558
               prereq=True, ecode=errors.ECODE_INVAL)
559
  if not force_variant:
560
    _CheckOSVariant(result.payload, os_name)
561

    
562

    
563
def _CheckDiskTemplate(template):
564
  """Ensure a given disk template is valid.
565

566
  """
567
  if template not in constants.DISK_TEMPLATES:
568
    msg = ("Invalid disk template name '%s', valid templates are: %s" %
569
           (template, utils.CommaJoin(constants.DISK_TEMPLATES)))
570
    raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
571

    
572

    
573
def _CheckInstanceDown(lu, instance, reason):
574
  """Ensure that an instance is not running."""
575
  if instance.admin_up:
576
    raise errors.OpPrereqError("Instance %s is marked to be up, %s" %
577
                               (instance.name, reason), errors.ECODE_STATE)
578

    
579
  pnode = instance.primary_node
580
  ins_l = lu.rpc.call_instance_list([pnode], [instance.hypervisor])[pnode]
581
  ins_l.Raise("Can't contact node %s for instance information" % pnode,
582
              prereq=True, ecode=errors.ECODE_ENVIRON)
583

    
584
  if instance.name in ins_l.payload:
585
    raise errors.OpPrereqError("Instance %s is running, %s" %
586
                               (instance.name, reason), errors.ECODE_STATE)
587

    
588

    
589
def _ExpandItemName(fn, name, kind):
590
  """Expand an item name.
591

592
  @param fn: the function to use for expansion
593
  @param name: requested item name
594
  @param kind: text description ('Node' or 'Instance')
595
  @return: the resolved (full) name
596
  @raise errors.OpPrereqError: if the item is not found
597

598
  """
599
  full_name = fn(name)
600
  if full_name is None:
601
    raise errors.OpPrereqError("%s '%s' not known" % (kind, name),
602
                               errors.ECODE_NOENT)
603
  return full_name
604

    
605

    
606
def _ExpandNodeName(cfg, name):
607
  """Wrapper over L{_ExpandItemName} for nodes."""
608
  return _ExpandItemName(cfg.ExpandNodeName, name, "Node")
609

    
610

    
611
def _ExpandInstanceName(cfg, name):
612
  """Wrapper over L{_ExpandItemName} for instance."""
613
  return _ExpandItemName(cfg.ExpandInstanceName, name, "Instance")
614

    
615

    
616
def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,
617
                          memory, vcpus, nics, disk_template, disks,
618
                          bep, hvp, hypervisor_name):
619
  """Builds instance related env variables for hooks
620

621
  This builds the hook environment from individual variables.
622

623
  @type name: string
624
  @param name: the name of the instance
625
  @type primary_node: string
626
  @param primary_node: the name of the instance's primary node
627
  @type secondary_nodes: list
628
  @param secondary_nodes: list of secondary nodes as strings
629
  @type os_type: string
630
  @param os_type: the name of the instance's OS
631
  @type status: boolean
632
  @param status: the should_run status of the instance
633
  @type memory: string
634
  @param memory: the memory size of the instance
635
  @type vcpus: string
636
  @param vcpus: the count of VCPUs the instance has
637
  @type nics: list
638
  @param nics: list of tuples (ip, mac, mode, link) representing
639
      the NICs the instance has
640
  @type disk_template: string
641
  @param disk_template: the disk template of the instance
642
  @type disks: list
643
  @param disks: the list of (size, mode) pairs
644
  @type bep: dict
645
  @param bep: the backend parameters for the instance
646
  @type hvp: dict
647
  @param hvp: the hypervisor parameters for the instance
648
  @type hypervisor_name: string
649
  @param hypervisor_name: the hypervisor for the instance
650
  @rtype: dict
651
  @return: the hook environment for this instance
652

653
  """
654
  if status:
655
    str_status = "up"
656
  else:
657
    str_status = "down"
658
  env = {
659
    "OP_TARGET": name,
660
    "INSTANCE_NAME": name,
661
    "INSTANCE_PRIMARY": primary_node,
662
    "INSTANCE_SECONDARIES": " ".join(secondary_nodes),
663
    "INSTANCE_OS_TYPE": os_type,
664
    "INSTANCE_STATUS": str_status,
665
    "INSTANCE_MEMORY": memory,
666
    "INSTANCE_VCPUS": vcpus,
667
    "INSTANCE_DISK_TEMPLATE": disk_template,
668
    "INSTANCE_HYPERVISOR": hypervisor_name,
669
  }
670

    
671
  if nics:
672
    nic_count = len(nics)
673
    for idx, (ip, mac, mode, link) in enumerate(nics):
674
      if ip is None:
675
        ip = ""
676
      env["INSTANCE_NIC%d_IP" % idx] = ip
677
      env["INSTANCE_NIC%d_MAC" % idx] = mac
678
      env["INSTANCE_NIC%d_MODE" % idx] = mode
679
      env["INSTANCE_NIC%d_LINK" % idx] = link
680
      if mode == constants.NIC_MODE_BRIDGED:
681
        env["INSTANCE_NIC%d_BRIDGE" % idx] = link
682
  else:
683
    nic_count = 0
684

    
685
  env["INSTANCE_NIC_COUNT"] = nic_count
686

    
687
  if disks:
688
    disk_count = len(disks)
689
    for idx, (size, mode) in enumerate(disks):
690
      env["INSTANCE_DISK%d_SIZE" % idx] = size
691
      env["INSTANCE_DISK%d_MODE" % idx] = mode
692
  else:
693
    disk_count = 0
694

    
695
  env["INSTANCE_DISK_COUNT"] = disk_count
696

    
697
  for source, kind in [(bep, "BE"), (hvp, "HV")]:
698
    for key, value in source.items():
699
      env["INSTANCE_%s_%s" % (kind, key)] = value
700

    
701
  return env
702

    
703

    
704
def _NICListToTuple(lu, nics):
705
  """Build a list of nic information tuples.
706

707
  This list is suitable to be passed to _BuildInstanceHookEnv or as a return
708
  value in LUQueryInstanceData.
709

710
  @type lu:  L{LogicalUnit}
711
  @param lu: the logical unit on whose behalf we execute
712
  @type nics: list of L{objects.NIC}
713
  @param nics: list of nics to convert to hooks tuples
714

715
  """
716
  hooks_nics = []
717
  c_nicparams = lu.cfg.GetClusterInfo().nicparams[constants.PP_DEFAULT]
718
  for nic in nics:
719
    ip = nic.ip
720
    mac = nic.mac
721
    filled_params = objects.FillDict(c_nicparams, nic.nicparams)
722
    mode = filled_params[constants.NIC_MODE]
723
    link = filled_params[constants.NIC_LINK]
724
    hooks_nics.append((ip, mac, mode, link))
725
  return hooks_nics
726

    
727

    
728
def _BuildInstanceHookEnvByObject(lu, instance, override=None):
729
  """Builds instance related env variables for hooks from an object.
730

731
  @type lu: L{LogicalUnit}
732
  @param lu: the logical unit on whose behalf we execute
733
  @type instance: L{objects.Instance}
734
  @param instance: the instance for which we should build the
735
      environment
736
  @type override: dict
737
  @param override: dictionary with key/values that will override
738
      our values
739
  @rtype: dict
740
  @return: the hook environment dictionary
741

742
  """
743
  cluster = lu.cfg.GetClusterInfo()
744
  bep = cluster.FillBE(instance)
745
  hvp = cluster.FillHV(instance)
746
  args = {
747
    'name': instance.name,
748
    'primary_node': instance.primary_node,
749
    'secondary_nodes': instance.secondary_nodes,
750
    'os_type': instance.os,
751
    'status': instance.admin_up,
752
    'memory': bep[constants.BE_MEMORY],
753
    'vcpus': bep[constants.BE_VCPUS],
754
    'nics': _NICListToTuple(lu, instance.nics),
755
    'disk_template': instance.disk_template,
756
    'disks': [(disk.size, disk.mode) for disk in instance.disks],
757
    'bep': bep,
758
    'hvp': hvp,
759
    'hypervisor_name': instance.hypervisor,
760
  }
761
  if override:
762
    args.update(override)
763
  return _BuildInstanceHookEnv(**args) # pylint: disable-msg=W0142
764

    
765

    
766
def _AdjustCandidatePool(lu, exceptions):
767
  """Adjust the candidate pool after node operations.
768

769
  """
770
  mod_list = lu.cfg.MaintainCandidatePool(exceptions)
771
  if mod_list:
772
    lu.LogInfo("Promoted nodes to master candidate role: %s",
773
               utils.CommaJoin(node.name for node in mod_list))
774
    for name in mod_list:
775
      lu.context.ReaddNode(name)
776
  mc_now, mc_max, _ = lu.cfg.GetMasterCandidateStats(exceptions)
777
  if mc_now > mc_max:
778
    lu.LogInfo("Note: more nodes are candidates (%d) than desired (%d)" %
779
               (mc_now, mc_max))
780

    
781

    
782
def _DecideSelfPromotion(lu, exceptions=None):
783
  """Decide whether I should promote myself as a master candidate.
784

785
  """
786
  cp_size = lu.cfg.GetClusterInfo().candidate_pool_size
787
  mc_now, mc_should, _ = lu.cfg.GetMasterCandidateStats(exceptions)
788
  # the new node will increase mc_max with one, so:
789
  mc_should = min(mc_should + 1, cp_size)
790
  return mc_now < mc_should
791

    
792

    
793
def _CheckNicsBridgesExist(lu, target_nics, target_node,
794
                               profile=constants.PP_DEFAULT):
795
  """Check that the brigdes needed by a list of nics exist.
796

797
  """
798
  c_nicparams = lu.cfg.GetClusterInfo().nicparams[profile]
799
  paramslist = [objects.FillDict(c_nicparams, nic.nicparams)
800
                for nic in target_nics]
801
  brlist = [params[constants.NIC_LINK] for params in paramslist
802
            if params[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED]
803
  if brlist:
804
    result = lu.rpc.call_bridges_exist(target_node, brlist)
805
    result.Raise("Error checking bridges on destination node '%s'" %
806
                 target_node, prereq=True, ecode=errors.ECODE_ENVIRON)
807

    
808

    
809
def _CheckInstanceBridgesExist(lu, instance, node=None):
810
  """Check that the brigdes needed by an instance exist.
811

812
  """
813
  if node is None:
814
    node = instance.primary_node
815
  _CheckNicsBridgesExist(lu, instance.nics, node)
816

    
817

    
818
def _CheckOSVariant(os_obj, name):
819
  """Check whether an OS name conforms to the os variants specification.
820

821
  @type os_obj: L{objects.OS}
822
  @param os_obj: OS object to check
823
  @type name: string
824
  @param name: OS name passed by the user, to check for validity
825

826
  """
827
  if not os_obj.supported_variants:
828
    return
829
  try:
830
    variant = name.split("+", 1)[1]
831
  except IndexError:
832
    raise errors.OpPrereqError("OS name must include a variant",
833
                               errors.ECODE_INVAL)
834

    
835
  if variant not in os_obj.supported_variants:
836
    raise errors.OpPrereqError("Unsupported OS variant", errors.ECODE_INVAL)
837

    
838

    
839
def _GetNodeInstancesInner(cfg, fn):
840
  return [i for i in cfg.GetAllInstancesInfo().values() if fn(i)]
841

    
842

    
843
def _GetNodeInstances(cfg, node_name):
844
  """Returns a list of all primary and secondary instances on a node.
845

846
  """
847

    
848
  return _GetNodeInstancesInner(cfg, lambda inst: node_name in inst.all_nodes)
849

    
850

    
851
def _GetNodePrimaryInstances(cfg, node_name):
852
  """Returns primary instances on a node.
853

854
  """
855
  return _GetNodeInstancesInner(cfg,
856
                                lambda inst: node_name == inst.primary_node)
857

    
858

    
859
def _GetNodeSecondaryInstances(cfg, node_name):
860
  """Returns secondary instances on a node.
861

862
  """
863
  return _GetNodeInstancesInner(cfg,
864
                                lambda inst: node_name in inst.secondary_nodes)
865

    
866

    
867
def _GetStorageTypeArgs(cfg, storage_type):
868
  """Returns the arguments for a storage type.
869

870
  """
871
  # Special case for file storage
872
  if storage_type == constants.ST_FILE:
873
    # storage.FileStorage wants a list of storage directories
874
    return [[cfg.GetFileStorageDir()]]
875

    
876
  return []
877

    
878

    
879
def _FindFaultyInstanceDisks(cfg, rpc, instance, node_name, prereq):
880
  faulty = []
881

    
882
  for dev in instance.disks:
883
    cfg.SetDiskID(dev, node_name)
884

    
885
  result = rpc.call_blockdev_getmirrorstatus(node_name, instance.disks)
886
  result.Raise("Failed to get disk status from node %s" % node_name,
887
               prereq=prereq, ecode=errors.ECODE_ENVIRON)
888

    
889
  for idx, bdev_status in enumerate(result.payload):
890
    if bdev_status and bdev_status.ldisk_status == constants.LDS_FAULTY:
891
      faulty.append(idx)
892

    
893
  return faulty
894

    
895

    
896
def _FormatTimestamp(secs):
897
  """Formats a Unix timestamp with the local timezone.
898

899
  """
900
  return time.strftime("%F %T %Z", time.gmtime(secs))
901

    
902

    
903
class LUPostInitCluster(LogicalUnit):
904
  """Logical unit for running hooks after cluster initialization.
905

906
  """
907
  HPATH = "cluster-init"
908
  HTYPE = constants.HTYPE_CLUSTER
909
  _OP_REQP = []
910

    
911
  def BuildHooksEnv(self):
912
    """Build hooks env.
913

914
    """
915
    env = {"OP_TARGET": self.cfg.GetClusterName()}
916
    mn = self.cfg.GetMasterNode()
917
    return env, [], [mn]
918

    
919
  def CheckPrereq(self):
920
    """No prerequisites to check.
921

922
    """
923
    return True
924

    
925
  def Exec(self, feedback_fn):
926
    """Nothing to do.
927

928
    """
929
    return True
930

    
931

    
932
class LUDestroyCluster(LogicalUnit):
933
  """Logical unit for destroying the cluster.
934

935
  """
936
  HPATH = "cluster-destroy"
937
  HTYPE = constants.HTYPE_CLUSTER
938
  _OP_REQP = []
939

    
940
  def BuildHooksEnv(self):
941
    """Build hooks env.
942

943
    """
944
    env = {"OP_TARGET": self.cfg.GetClusterName()}
945
    return env, [], []
946

    
947
  def CheckPrereq(self):
948
    """Check prerequisites.
949

950
    This checks whether the cluster is empty.
951

952
    Any errors are signaled by raising errors.OpPrereqError.
953

954
    """
955
    master = self.cfg.GetMasterNode()
956

    
957
    nodelist = self.cfg.GetNodeList()
958
    if len(nodelist) != 1 or nodelist[0] != master:
959
      raise errors.OpPrereqError("There are still %d node(s) in"
960
                                 " this cluster." % (len(nodelist) - 1),
961
                                 errors.ECODE_INVAL)
962
    instancelist = self.cfg.GetInstanceList()
963
    if instancelist:
964
      raise errors.OpPrereqError("There are still %d instance(s) in"
965
                                 " this cluster." % len(instancelist),
966
                                 errors.ECODE_INVAL)
967

    
968
  def Exec(self, feedback_fn):
969
    """Destroys the cluster.
970

971
    """
972
    master = self.cfg.GetMasterNode()
973
    modify_ssh_setup = self.cfg.GetClusterInfo().modify_ssh_setup
974

    
975
    # Run post hooks on master node before it's removed
976
    hm = self.proc.hmclass(self.rpc.call_hooks_runner, self)
977
    try:
978
      hm.RunPhase(constants.HOOKS_PHASE_POST, [master])
979
    except:
980
      # pylint: disable-msg=W0702
981
      self.LogWarning("Errors occurred running hooks on %s" % master)
982

    
983
    result = self.rpc.call_node_stop_master(master, False)
984
    result.Raise("Could not disable the master role")
985

    
986
    if modify_ssh_setup:
987
      priv_key, pub_key, _ = ssh.GetUserFiles(constants.GANETI_RUNAS)
988
      utils.CreateBackup(priv_key)
989
      utils.CreateBackup(pub_key)
990

    
991
    return master
992

    
993

    
994
def _VerifyCertificateInner(filename, expired, not_before, not_after, now,
995
                            warn_days=constants.SSL_CERT_EXPIRATION_WARN,
996
                            error_days=constants.SSL_CERT_EXPIRATION_ERROR):
997
  """Verifies certificate details for LUVerifyCluster.
998

999
  """
1000
  if expired:
1001
    msg = "Certificate %s is expired" % filename
1002

    
1003
    if not_before is not None and not_after is not None:
1004
      msg += (" (valid from %s to %s)" %
1005
              (_FormatTimestamp(not_before),
1006
               _FormatTimestamp(not_after)))
1007
    elif not_before is not None:
1008
      msg += " (valid from %s)" % _FormatTimestamp(not_before)
1009
    elif not_after is not None:
1010
      msg += " (valid until %s)" % _FormatTimestamp(not_after)
1011

    
1012
    return (LUVerifyCluster.ETYPE_ERROR, msg)
1013

    
1014
  elif not_before is not None and not_before > now:
1015
    return (LUVerifyCluster.ETYPE_WARNING,
1016
            "Certificate %s not yet valid (valid from %s)" %
1017
            (filename, _FormatTimestamp(not_before)))
1018

    
1019
  elif not_after is not None:
1020
    remaining_days = int((not_after - now) / (24 * 3600))
1021

    
1022
    msg = ("Certificate %s expires in %d days" % (filename, remaining_days))
1023

    
1024
    if remaining_days <= error_days:
1025
      return (LUVerifyCluster.ETYPE_ERROR, msg)
1026

    
1027
    if remaining_days <= warn_days:
1028
      return (LUVerifyCluster.ETYPE_WARNING, msg)
1029

    
1030
  return (None, None)
1031

    
1032

    
1033
def _VerifyCertificate(filename):
1034
  """Verifies a certificate for LUVerifyCluster.
1035

1036
  @type filename: string
1037
  @param filename: Path to PEM file
1038

1039
  """
1040
  try:
1041
    cert = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,
1042
                                           utils.ReadFile(filename))
1043
  except Exception, err: # pylint: disable-msg=W0703
1044
    return (LUVerifyCluster.ETYPE_ERROR,
1045
            "Failed to load X509 certificate %s: %s" % (filename, err))
1046

    
1047
  # Depending on the pyOpenSSL version, this can just return (None, None)
1048
  (not_before, not_after) = utils.GetX509CertValidity(cert)
1049

    
1050
  return _VerifyCertificateInner(filename, cert.has_expired(),
1051
                                 not_before, not_after, time.time())
1052

    
1053

    
1054
class LUVerifyCluster(LogicalUnit):
1055
  """Verifies the cluster status.
1056

1057
  """
1058
  HPATH = "cluster-verify"
1059
  HTYPE = constants.HTYPE_CLUSTER
1060
  _OP_REQP = ["skip_checks", "verbose", "error_codes", "debug_simulate_errors"]
1061
  REQ_BGL = False
1062

    
1063
  TCLUSTER = "cluster"
1064
  TNODE = "node"
1065
  TINSTANCE = "instance"
1066

    
1067
  ECLUSTERCFG = (TCLUSTER, "ECLUSTERCFG")
1068
  ECLUSTERCERT = (TCLUSTER, "ECLUSTERCERT")
1069
  EINSTANCEBADNODE = (TINSTANCE, "EINSTANCEBADNODE")
1070
  EINSTANCEDOWN = (TINSTANCE, "EINSTANCEDOWN")
1071
  EINSTANCELAYOUT = (TINSTANCE, "EINSTANCELAYOUT")
1072
  EINSTANCEMISSINGDISK = (TINSTANCE, "EINSTANCEMISSINGDISK")
1073
  EINSTANCEMISSINGDISK = (TINSTANCE, "EINSTANCEMISSINGDISK")
1074
  EINSTANCEWRONGNODE = (TINSTANCE, "EINSTANCEWRONGNODE")
1075
  ENODEDRBD = (TNODE, "ENODEDRBD")
1076
  ENODEFILECHECK = (TNODE, "ENODEFILECHECK")
1077
  ENODEHOOKS = (TNODE, "ENODEHOOKS")
1078
  ENODEHV = (TNODE, "ENODEHV")
1079
  ENODELVM = (TNODE, "ENODELVM")
1080
  ENODEN1 = (TNODE, "ENODEN1")
1081
  ENODENET = (TNODE, "ENODENET")
1082
  ENODEORPHANINSTANCE = (TNODE, "ENODEORPHANINSTANCE")
1083
  ENODEORPHANLV = (TNODE, "ENODEORPHANLV")
1084
  ENODERPC = (TNODE, "ENODERPC")
1085
  ENODESSH = (TNODE, "ENODESSH")
1086
  ENODEVERSION = (TNODE, "ENODEVERSION")
1087
  ENODESETUP = (TNODE, "ENODESETUP")
1088
  ENODETIME = (TNODE, "ENODETIME")
1089

    
1090
  ETYPE_FIELD = "code"
1091
  ETYPE_ERROR = "ERROR"
1092
  ETYPE_WARNING = "WARNING"
1093

    
1094
  class NodeImage(object):
1095
    """A class representing the logical and physical status of a node.
1096

1097
    @ivar volumes: a structure as returned from
1098
        L{ganeti.backend.GetVolumeList} (runtime)
1099
    @ivar instances: a list of running instances (runtime)
1100
    @ivar pinst: list of configured primary instances (config)
1101
    @ivar sinst: list of configured secondary instances (config)
1102
    @ivar sbp: diction of {secondary-node: list of instances} of all peers
1103
        of this node (config)
1104
    @ivar mfree: free memory, as reported by hypervisor (runtime)
1105
    @ivar dfree: free disk, as reported by the node (runtime)
1106
    @ivar offline: the offline status (config)
1107
    @type rpc_fail: boolean
1108
    @ivar rpc_fail: whether the RPC verify call was successfull (overall,
1109
        not whether the individual keys were correct) (runtime)
1110
    @type lvm_fail: boolean
1111
    @ivar lvm_fail: whether the RPC call didn't return valid LVM data
1112
    @type hyp_fail: boolean
1113
    @ivar hyp_fail: whether the RPC call didn't return the instance list
1114
    @type ghost: boolean
1115
    @ivar ghost: whether this is a known node or not (config)
1116

1117
    """
1118
    def __init__(self, offline=False):
1119
      self.volumes = {}
1120
      self.instances = []
1121
      self.pinst = []
1122
      self.sinst = []
1123
      self.sbp = {}
1124
      self.mfree = 0
1125
      self.dfree = 0
1126
      self.offline = offline
1127
      self.rpc_fail = False
1128
      self.lvm_fail = False
1129
      self.hyp_fail = False
1130
      self.ghost = False
1131

    
1132
  def ExpandNames(self):
1133
    self.needed_locks = {
1134
      locking.LEVEL_NODE: locking.ALL_SET,
1135
      locking.LEVEL_INSTANCE: locking.ALL_SET,
1136
    }
1137
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
1138

    
1139
  def _Error(self, ecode, item, msg, *args, **kwargs):
1140
    """Format an error message.
1141

1142
    Based on the opcode's error_codes parameter, either format a
1143
    parseable error code, or a simpler error string.
1144

1145
    This must be called only from Exec and functions called from Exec.
1146

1147
    """
1148
    ltype = kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR)
1149
    itype, etxt = ecode
1150
    # first complete the msg
1151
    if args:
1152
      msg = msg % args
1153
    # then format the whole message
1154
    if self.op.error_codes:
1155
      msg = "%s:%s:%s:%s:%s" % (ltype, etxt, itype, item, msg)
1156
    else:
1157
      if item:
1158
        item = " " + item
1159
      else:
1160
        item = ""
1161
      msg = "%s: %s%s: %s" % (ltype, itype, item, msg)
1162
    # and finally report it via the feedback_fn
1163
    self._feedback_fn("  - %s" % msg)
1164

    
1165
  def _ErrorIf(self, cond, *args, **kwargs):
1166
    """Log an error message if the passed condition is True.
1167

1168
    """
1169
    cond = bool(cond) or self.op.debug_simulate_errors
1170
    if cond:
1171
      self._Error(*args, **kwargs)
1172
    # do not mark the operation as failed for WARN cases only
1173
    if kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR) == self.ETYPE_ERROR:
1174
      self.bad = self.bad or cond
1175

    
1176
  def _VerifyNode(self, ninfo, nresult):
1177
    """Run multiple tests against a node.
1178

1179
    Test list:
1180

1181
      - compares ganeti version
1182
      - checks vg existence and size > 20G
1183
      - checks config file checksum
1184
      - checks ssh to other nodes
1185

1186
    @type ninfo: L{objects.Node}
1187
    @param ninfo: the node to check
1188
    @param nresult: the results from the node
1189
    @rtype: boolean
1190
    @return: whether overall this call was successful (and we can expect
1191
         reasonable values in the respose)
1192

1193
    """
1194
    node = ninfo.name
1195
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1196

    
1197
    # main result, nresult should be a non-empty dict
1198
    test = not nresult or not isinstance(nresult, dict)
1199
    _ErrorIf(test, self.ENODERPC, node,
1200
                  "unable to verify node: no data returned")
1201
    if test:
1202
      return False
1203

    
1204
    # compares ganeti version
1205
    local_version = constants.PROTOCOL_VERSION
1206
    remote_version = nresult.get("version", None)
1207
    test = not (remote_version and
1208
                isinstance(remote_version, (list, tuple)) and
1209
                len(remote_version) == 2)
1210
    _ErrorIf(test, self.ENODERPC, node,
1211
             "connection to node returned invalid data")
1212
    if test:
1213
      return False
1214

    
1215
    test = local_version != remote_version[0]
1216
    _ErrorIf(test, self.ENODEVERSION, node,
1217
             "incompatible protocol versions: master %s,"
1218
             " node %s", local_version, remote_version[0])
1219
    if test:
1220
      return False
1221

    
1222
    # node seems compatible, we can actually try to look into its results
1223

    
1224
    # full package version
1225
    self._ErrorIf(constants.RELEASE_VERSION != remote_version[1],
1226
                  self.ENODEVERSION, node,
1227
                  "software version mismatch: master %s, node %s",
1228
                  constants.RELEASE_VERSION, remote_version[1],
1229
                  code=self.ETYPE_WARNING)
1230

    
1231
    hyp_result = nresult.get(constants.NV_HYPERVISOR, None)
1232
    if isinstance(hyp_result, dict):
1233
      for hv_name, hv_result in hyp_result.iteritems():
1234
        test = hv_result is not None
1235
        _ErrorIf(test, self.ENODEHV, node,
1236
                 "hypervisor %s verify failure: '%s'", hv_name, hv_result)
1237

    
1238

    
1239
    test = nresult.get(constants.NV_NODESETUP,
1240
                           ["Missing NODESETUP results"])
1241
    _ErrorIf(test, self.ENODESETUP, node, "node setup error: %s",
1242
             "; ".join(test))
1243

    
1244
    return True
1245

    
1246
  def _VerifyNodeTime(self, ninfo, nresult,
1247
                      nvinfo_starttime, nvinfo_endtime):
1248
    """Check the node time.
1249

1250
    @type ninfo: L{objects.Node}
1251
    @param ninfo: the node to check
1252
    @param nresult: the remote results for the node
1253
    @param nvinfo_starttime: the start time of the RPC call
1254
    @param nvinfo_endtime: the end time of the RPC call
1255

1256
    """
1257
    node = ninfo.name
1258
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1259

    
1260
    ntime = nresult.get(constants.NV_TIME, None)
1261
    try:
1262
      ntime_merged = utils.MergeTime(ntime)
1263
    except (ValueError, TypeError):
1264
      _ErrorIf(True, self.ENODETIME, node, "Node returned invalid time")
1265
      return
1266

    
1267
    if ntime_merged < (nvinfo_starttime - constants.NODE_MAX_CLOCK_SKEW):
1268
      ntime_diff = "%.01fs" % abs(nvinfo_starttime - ntime_merged)
1269
    elif ntime_merged > (nvinfo_endtime + constants.NODE_MAX_CLOCK_SKEW):
1270
      ntime_diff = "%.01fs" % abs(ntime_merged - nvinfo_endtime)
1271
    else:
1272
      ntime_diff = None
1273

    
1274
    _ErrorIf(ntime_diff is not None, self.ENODETIME, node,
1275
             "Node time diverges by at least %s from master node time",
1276
             ntime_diff)
1277

    
1278
  def _VerifyNodeLVM(self, ninfo, nresult, vg_name):
1279
    """Check the node time.
1280

1281
    @type ninfo: L{objects.Node}
1282
    @param ninfo: the node to check
1283
    @param nresult: the remote results for the node
1284
    @param vg_name: the configured VG name
1285

1286
    """
1287
    if vg_name is None:
1288
      return
1289

    
1290
    node = ninfo.name
1291
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1292

    
1293
    # checks vg existence and size > 20G
1294
    vglist = nresult.get(constants.NV_VGLIST, None)
1295
    test = not vglist
1296
    _ErrorIf(test, self.ENODELVM, node, "unable to check volume groups")
1297
    if not test:
1298
      vgstatus = utils.CheckVolumeGroupSize(vglist, vg_name,
1299
                                            constants.MIN_VG_SIZE)
1300
      _ErrorIf(vgstatus, self.ENODELVM, node, vgstatus)
1301

    
1302
    # check pv names
1303
    pvlist = nresult.get(constants.NV_PVLIST, None)
1304
    test = pvlist is None
1305
    _ErrorIf(test, self.ENODELVM, node, "Can't get PV list from node")
1306
    if not test:
1307
      # check that ':' is not present in PV names, since it's a
1308
      # special character for lvcreate (denotes the range of PEs to
1309
      # use on the PV)
1310
      for _, pvname, owner_vg in pvlist:
1311
        test = ":" in pvname
1312
        _ErrorIf(test, self.ENODELVM, node, "Invalid character ':' in PV"
1313
                 " '%s' of VG '%s'", pvname, owner_vg)
1314

    
1315
  def _VerifyNodeNetwork(self, ninfo, nresult):
1316
    """Check the node time.
1317

1318
    @type ninfo: L{objects.Node}
1319
    @param ninfo: the node to check
1320
    @param nresult: the remote results for the node
1321

1322
    """
1323
    node = ninfo.name
1324
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1325

    
1326
    test = constants.NV_NODELIST not in nresult
1327
    _ErrorIf(test, self.ENODESSH, node,
1328
             "node hasn't returned node ssh connectivity data")
1329
    if not test:
1330
      if nresult[constants.NV_NODELIST]:
1331
        for a_node, a_msg in nresult[constants.NV_NODELIST].items():
1332
          _ErrorIf(True, self.ENODESSH, node,
1333
                   "ssh communication with node '%s': %s", a_node, a_msg)
1334

    
1335
    test = constants.NV_NODENETTEST not in nresult
1336
    _ErrorIf(test, self.ENODENET, node,
1337
             "node hasn't returned node tcp connectivity data")
1338
    if not test:
1339
      if nresult[constants.NV_NODENETTEST]:
1340
        nlist = utils.NiceSort(nresult[constants.NV_NODENETTEST].keys())
1341
        for anode in nlist:
1342
          _ErrorIf(True, self.ENODENET, node,
1343
                   "tcp communication with node '%s': %s",
1344
                   anode, nresult[constants.NV_NODENETTEST][anode])
1345

    
1346
  def _VerifyInstance(self, instance, instanceconfig, node_image):
1347
    """Verify an instance.
1348

1349
    This function checks to see if the required block devices are
1350
    available on the instance's node.
1351

1352
    """
1353
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1354
    node_current = instanceconfig.primary_node
1355

    
1356
    node_vol_should = {}
1357
    instanceconfig.MapLVsByNode(node_vol_should)
1358

    
1359
    for node in node_vol_should:
1360
      n_img = node_image[node]
1361
      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
1362
        # ignore missing volumes on offline or broken nodes
1363
        continue
1364
      for volume in node_vol_should[node]:
1365
        test = volume not in n_img.volumes
1366
        _ErrorIf(test, self.EINSTANCEMISSINGDISK, instance,
1367
                 "volume %s missing on node %s", volume, node)
1368

    
1369
    if instanceconfig.admin_up:
1370
      pri_img = node_image[node_current]
1371
      test = instance not in pri_img.instances and not pri_img.offline
1372
      _ErrorIf(test, self.EINSTANCEDOWN, instance,
1373
               "instance not running on its primary node %s",
1374
               node_current)
1375

    
1376
    for node, n_img in node_image.items():
1377
      if (not node == node_current):
1378
        test = instance in n_img.instances
1379
        _ErrorIf(test, self.EINSTANCEWRONGNODE, instance,
1380
                 "instance should not run on node %s", node)
1381

    
1382
  def _VerifyOrphanVolumes(self, node_vol_should, node_image):
1383
    """Verify if there are any unknown volumes in the cluster.
1384

1385
    The .os, .swap and backup volumes are ignored. All other volumes are
1386
    reported as unknown.
1387

1388
    """
1389
    for node, n_img in node_image.items():
1390
      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
1391
        # skip non-healthy nodes
1392
        continue
1393
      for volume in n_img.volumes:
1394
        test = (node not in node_vol_should or
1395
                volume not in node_vol_should[node])
1396
        self._ErrorIf(test, self.ENODEORPHANLV, node,
1397
                      "volume %s is unknown", volume)
1398

    
1399
  def _VerifyOrphanInstances(self, instancelist, node_image):
1400
    """Verify the list of running instances.
1401

1402
    This checks what instances are running but unknown to the cluster.
1403

1404
    """
1405
    for node, n_img in node_image.items():
1406
      for o_inst in n_img.instances:
1407
        test = o_inst not in instancelist
1408
        self._ErrorIf(test, self.ENODEORPHANINSTANCE, node,
1409
                      "instance %s on node %s should not exist", o_inst, node)
1410

    
1411
  def _VerifyNPlusOneMemory(self, node_image, instance_cfg):
1412
    """Verify N+1 Memory Resilience.
1413

1414
    Check that if one single node dies we can still start all the
1415
    instances it was primary for.
1416

1417
    """
1418
    for node, n_img in node_image.items():
1419
      # This code checks that every node which is now listed as
1420
      # secondary has enough memory to host all instances it is
1421
      # supposed to should a single other node in the cluster fail.
1422
      # FIXME: not ready for failover to an arbitrary node
1423
      # FIXME: does not support file-backed instances
1424
      # WARNING: we currently take into account down instances as well
1425
      # as up ones, considering that even if they're down someone
1426
      # might want to start them even in the event of a node failure.
1427
      for prinode, instances in n_img.sbp.items():
1428
        needed_mem = 0
1429
        for instance in instances:
1430
          bep = self.cfg.GetClusterInfo().FillBE(instance_cfg[instance])
1431
          if bep[constants.BE_AUTO_BALANCE]:
1432
            needed_mem += bep[constants.BE_MEMORY]
1433
        test = n_img.mfree < needed_mem
1434
        self._ErrorIf(test, self.ENODEN1, node,
1435
                      "not enough memory on to accommodate"
1436
                      " failovers should peer node %s fail", prinode)
1437

    
1438
  def _VerifyNodeFiles(self, ninfo, nresult, file_list, local_cksum,
1439
                       master_files):
1440
    """Verifies and computes the node required file checksums.
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 file_list: required list of files
1446
    @param local_cksum: dictionary of local files and their checksums
1447
    @param master_files: list of files that only masters should have
1448

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

    
1453
    remote_cksum = nresult.get(constants.NV_FILELIST, None)
1454
    test = not isinstance(remote_cksum, dict)
1455
    _ErrorIf(test, self.ENODEFILECHECK, node,
1456
             "node hasn't returned file checksum data")
1457
    if test:
1458
      return
1459

    
1460
    for file_name in file_list:
1461
      node_is_mc = ninfo.master_candidate
1462
      must_have = (file_name not in master_files) or node_is_mc
1463
      # missing
1464
      test1 = file_name not in remote_cksum
1465
      # invalid checksum
1466
      test2 = not test1 and remote_cksum[file_name] != local_cksum[file_name]
1467
      # existing and good
1468
      test3 = not test1 and remote_cksum[file_name] == local_cksum[file_name]
1469
      _ErrorIf(test1 and must_have, self.ENODEFILECHECK, node,
1470
               "file '%s' missing", file_name)
1471
      _ErrorIf(test2 and must_have, self.ENODEFILECHECK, node,
1472
               "file '%s' has wrong checksum", file_name)
1473
      # not candidate and this is not a must-have file
1474
      _ErrorIf(test2 and not must_have, self.ENODEFILECHECK, node,
1475
               "file '%s' should not exist on non master"
1476
               " candidates (and the file is outdated)", file_name)
1477
      # all good, except non-master/non-must have combination
1478
      _ErrorIf(test3 and not must_have, self.ENODEFILECHECK, node,
1479
               "file '%s' should not exist"
1480
               " on non master candidates", file_name)
1481

    
1482
  def _VerifyNodeDrbd(self, ninfo, nresult, instanceinfo, drbd_map):
1483
    """Verifies and the node DRBD status.
1484

1485
    @type ninfo: L{objects.Node}
1486
    @param ninfo: the node to check
1487
    @param nresult: the remote results for the node
1488
    @param instanceinfo: the dict of instances
1489
    @param drbd_map: the DRBD map as returned by
1490
        L{ganeti.config.ConfigWriter.ComputeDRBDMap}
1491

1492
    """
1493
    node = ninfo.name
1494
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1495

    
1496
    # compute the DRBD minors
1497
    node_drbd = {}
1498
    for minor, instance in drbd_map[node].items():
1499
      test = instance not in instanceinfo
1500
      _ErrorIf(test, self.ECLUSTERCFG, None,
1501
               "ghost instance '%s' in temporary DRBD map", instance)
1502
        # ghost instance should not be running, but otherwise we
1503
        # don't give double warnings (both ghost instance and
1504
        # unallocated minor in use)
1505
      if test:
1506
        node_drbd[minor] = (instance, False)
1507
      else:
1508
        instance = instanceinfo[instance]
1509
        node_drbd[minor] = (instance.name, instance.admin_up)
1510

    
1511
    # and now check them
1512
    used_minors = nresult.get(constants.NV_DRBDLIST, [])
1513
    test = not isinstance(used_minors, (tuple, list))
1514
    _ErrorIf(test, self.ENODEDRBD, node,
1515
             "cannot parse drbd status file: %s", str(used_minors))
1516
    if test:
1517
      # we cannot check drbd status
1518
      return
1519

    
1520
    for minor, (iname, must_exist) in node_drbd.items():
1521
      test = minor not in used_minors and must_exist
1522
      _ErrorIf(test, self.ENODEDRBD, node,
1523
               "drbd minor %d of instance %s is not active", minor, iname)
1524
    for minor in used_minors:
1525
      test = minor not in node_drbd
1526
      _ErrorIf(test, self.ENODEDRBD, node,
1527
               "unallocated drbd minor %d is in use", minor)
1528

    
1529
  def _UpdateNodeVolumes(self, ninfo, nresult, nimg, vg_name):
1530
    """Verifies and updates the node volume data.
1531

1532
    This function will update a L{NodeImage}'s internal structures
1533
    with data from the remote call.
1534

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

1541
    """
1542
    node = ninfo.name
1543
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1544

    
1545
    nimg.lvm_fail = True
1546
    lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")
1547
    if vg_name is None:
1548
      pass
1549
    elif isinstance(lvdata, basestring):
1550
      _ErrorIf(True, self.ENODELVM, node, "LVM problem on node: %s",
1551
               utils.SafeEncode(lvdata))
1552
    elif not isinstance(lvdata, dict):
1553
      _ErrorIf(True, self.ENODELVM, node, "rpc call to node failed (lvlist)")
1554
    else:
1555
      nimg.volumes = lvdata
1556
      nimg.lvm_fail = False
1557

    
1558
  def _UpdateNodeInstances(self, ninfo, nresult, nimg):
1559
    """Verifies and updates the node instance list.
1560

1561
    If the listing was successful, then updates this node's instance
1562
    list. Otherwise, it marks the RPC call as failed for the instance
1563
    list key.
1564

1565
    @type ninfo: L{objects.Node}
1566
    @param ninfo: the node to check
1567
    @param nresult: the remote results for the node
1568
    @param nimg: the node image object
1569

1570
    """
1571
    idata = nresult.get(constants.NV_INSTANCELIST, None)
1572
    test = not isinstance(idata, list)
1573
    self._ErrorIf(test, self.ENODEHV, ninfo.name, "rpc call to node failed"
1574
                  " (instancelist): %s", utils.SafeEncode(str(idata)))
1575
    if test:
1576
      nimg.hyp_fail = True
1577
    else:
1578
      nimg.instances = idata
1579

    
1580
  def _UpdateNodeInfo(self, ninfo, nresult, nimg, vg_name):
1581
    """Verifies and computes a node information map
1582

1583
    @type ninfo: L{objects.Node}
1584
    @param ninfo: the node to check
1585
    @param nresult: the remote results for the node
1586
    @param nimg: the node image object
1587
    @param vg_name: the configured VG name
1588

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

    
1593
    # try to read free memory (from the hypervisor)
1594
    hv_info = nresult.get(constants.NV_HVINFO, None)
1595
    test = not isinstance(hv_info, dict) or "memory_free" not in hv_info
1596
    _ErrorIf(test, self.ENODEHV, node, "rpc call to node failed (hvinfo)")
1597
    if not test:
1598
      try:
1599
        nimg.mfree = int(hv_info["memory_free"])
1600
      except (ValueError, TypeError):
1601
        _ErrorIf(True, self.ENODERPC, node,
1602
                 "node returned invalid nodeinfo, check hypervisor")
1603

    
1604
    # FIXME: devise a free space model for file based instances as well
1605
    if vg_name is not None:
1606
      test = (constants.NV_VGLIST not in nresult or
1607
              vg_name not in nresult[constants.NV_VGLIST])
1608
      _ErrorIf(test, self.ENODELVM, node,
1609
               "node didn't return data for the volume group '%s'"
1610
               " - it is either missing or broken", vg_name)
1611
      if not test:
1612
        try:
1613
          nimg.dfree = int(nresult[constants.NV_VGLIST][vg_name])
1614
        except (ValueError, TypeError):
1615
          _ErrorIf(True, self.ENODERPC, node,
1616
                   "node returned invalid LVM info, check LVM status")
1617

    
1618
  def CheckPrereq(self):
1619
    """Check prerequisites.
1620

1621
    Transform the list of checks we're going to skip into a set and check that
1622
    all its members are valid.
1623

1624
    """
1625
    self.skip_set = frozenset(self.op.skip_checks)
1626
    if not constants.VERIFY_OPTIONAL_CHECKS.issuperset(self.skip_set):
1627
      raise errors.OpPrereqError("Invalid checks to be skipped specified",
1628
                                 errors.ECODE_INVAL)
1629

    
1630
  def BuildHooksEnv(self):
1631
    """Build hooks env.
1632

1633
    Cluster-Verify hooks just ran in the post phase and their failure makes
1634
    the output be logged in the verify output and the verification to fail.
1635

1636
    """
1637
    all_nodes = self.cfg.GetNodeList()
1638
    env = {
1639
      "CLUSTER_TAGS": " ".join(self.cfg.GetClusterInfo().GetTags())
1640
      }
1641
    for node in self.cfg.GetAllNodesInfo().values():
1642
      env["NODE_TAGS_%s" % node.name] = " ".join(node.GetTags())
1643

    
1644
    return env, [], all_nodes
1645

    
1646
  def Exec(self, feedback_fn):
1647
    """Verify integrity of cluster, performing various test on nodes.
1648

1649
    """
1650
    self.bad = False
1651
    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
1652
    verbose = self.op.verbose
1653
    self._feedback_fn = feedback_fn
1654
    feedback_fn("* Verifying global settings")
1655
    for msg in self.cfg.VerifyConfig():
1656
      _ErrorIf(True, self.ECLUSTERCFG, None, msg)
1657

    
1658
    # Check the cluster certificates
1659
    for cert_filename in constants.ALL_CERT_FILES:
1660
      (errcode, msg) = _VerifyCertificate(cert_filename)
1661
      _ErrorIf(errcode, self.ECLUSTERCERT, None, msg, code=errcode)
1662

    
1663
    vg_name = self.cfg.GetVGName()
1664
    hypervisors = self.cfg.GetClusterInfo().enabled_hypervisors
1665
    nodelist = utils.NiceSort(self.cfg.GetNodeList())
1666
    nodeinfo = [self.cfg.GetNodeInfo(nname) for nname in nodelist]
1667
    instancelist = utils.NiceSort(self.cfg.GetInstanceList())
1668
    instanceinfo = dict((iname, self.cfg.GetInstanceInfo(iname))
1669
                        for iname in instancelist)
1670
    i_non_redundant = [] # Non redundant instances
1671
    i_non_a_balanced = [] # Non auto-balanced instances
1672
    n_offline = 0 # Count of offline nodes
1673
    n_drained = 0 # Count of nodes being drained
1674
    node_vol_should = {}
1675

    
1676
    # FIXME: verify OS list
1677
    # do local checksums
1678
    master_files = [constants.CLUSTER_CONF_FILE]
1679

    
1680
    file_names = ssconf.SimpleStore().GetFileList()
1681
    file_names.extend(constants.ALL_CERT_FILES)
1682
    file_names.extend(master_files)
1683

    
1684
    local_checksums = utils.FingerprintFiles(file_names)
1685

    
1686
    feedback_fn("* Gathering data (%d nodes)" % len(nodelist))
1687
    node_verify_param = {
1688
      constants.NV_FILELIST: file_names,
1689
      constants.NV_NODELIST: [node.name for node in nodeinfo
1690
                              if not node.offline],
1691
      constants.NV_HYPERVISOR: hypervisors,
1692
      constants.NV_NODENETTEST: [(node.name, node.primary_ip,
1693
                                  node.secondary_ip) for node in nodeinfo
1694
                                 if not node.offline],
1695
      constants.NV_INSTANCELIST: hypervisors,
1696
      constants.NV_VERSION: None,
1697
      constants.NV_HVINFO: self.cfg.GetHypervisorType(),
1698
      constants.NV_NODESETUP: None,
1699
      constants.NV_TIME: None,
1700
      }
1701

    
1702
    if vg_name is not None:
1703
      node_verify_param[constants.NV_VGLIST] = None
1704
      node_verify_param[constants.NV_LVLIST] = vg_name
1705
      node_verify_param[constants.NV_PVLIST] = [vg_name]
1706
      node_verify_param[constants.NV_DRBDLIST] = None
1707

    
1708
    # Build our expected cluster state
1709
    node_image = dict((node.name, self.NodeImage(offline=node.offline))
1710
                      for node in nodeinfo)
1711

    
1712
    for instance in instancelist:
1713
      inst_config = instanceinfo[instance]
1714

    
1715
      for nname in inst_config.all_nodes:
1716
        if nname not in node_image:
1717
          # ghost node
1718
          gnode = self.NodeImage()
1719
          gnode.ghost = True
1720
          node_image[nname] = gnode
1721

    
1722
      inst_config.MapLVsByNode(node_vol_should)
1723

    
1724
      pnode = inst_config.primary_node
1725
      node_image[pnode].pinst.append(instance)
1726

    
1727
      for snode in inst_config.secondary_nodes:
1728
        nimg = node_image[snode]
1729
        nimg.sinst.append(instance)
1730
        if pnode not in nimg.sbp:
1731
          nimg.sbp[pnode] = []
1732
        nimg.sbp[pnode].append(instance)
1733

    
1734
    # At this point, we have the in-memory data structures complete,
1735
    # except for the runtime information, which we'll gather next
1736

    
1737
    # Due to the way our RPC system works, exact response times cannot be
1738
    # guaranteed (e.g. a broken node could run into a timeout). By keeping the
1739
    # time before and after executing the request, we can at least have a time
1740
    # window.
1741
    nvinfo_starttime = time.time()
1742
    all_nvinfo = self.rpc.call_node_verify(nodelist, node_verify_param,
1743
                                           self.cfg.GetClusterName())
1744
    nvinfo_endtime = time.time()
1745

    
1746
    cluster = self.cfg.GetClusterInfo()
1747
    master_node = self.cfg.GetMasterNode()
1748
    all_drbd_map = self.cfg.ComputeDRBDMap()
1749

    
1750
    feedback_fn("* Verifying node status")
1751
    for node_i in nodeinfo:
1752
      node = node_i.name
1753
      nimg = node_image[node]
1754

    
1755
      if node_i.offline:
1756
        if verbose:
1757
          feedback_fn("* Skipping offline node %s" % (node,))
1758
        n_offline += 1
1759
        continue
1760

    
1761
      if node == master_node:
1762
        ntype = "master"
1763
      elif node_i.master_candidate:
1764
        ntype = "master candidate"
1765
      elif node_i.drained:
1766
        ntype = "drained"
1767
        n_drained += 1
1768
      else:
1769
        ntype = "regular"
1770
      if verbose:
1771
        feedback_fn("* Verifying node %s (%s)" % (node, ntype))
1772

    
1773
      msg = all_nvinfo[node].fail_msg
1774
      _ErrorIf(msg, self.ENODERPC, node, "while contacting node: %s", msg)
1775
      if msg:
1776
        nimg.rpc_fail = True
1777
        continue
1778

    
1779
      nresult = all_nvinfo[node].payload
1780

    
1781
      nimg.call_ok = self._VerifyNode(node_i, nresult)
1782
      self._VerifyNodeNetwork(node_i, nresult)
1783
      self._VerifyNodeLVM(node_i, nresult, vg_name)
1784
      self._VerifyNodeFiles(node_i, nresult, file_names, local_checksums,
1785
                            master_files)
1786
      self._VerifyNodeDrbd(node_i, nresult, instanceinfo, all_drbd_map)
1787
      self._VerifyNodeTime(node_i, nresult, nvinfo_starttime, nvinfo_endtime)
1788

    
1789
      self._UpdateNodeVolumes(node_i, nresult, nimg, vg_name)
1790
      self._UpdateNodeInstances(node_i, nresult, nimg)
1791
      self._UpdateNodeInfo(node_i, nresult, nimg, vg_name)
1792

    
1793
    feedback_fn("* Verifying instance status")
1794
    for instance in instancelist:
1795
      if verbose:
1796
        feedback_fn("* Verifying instance %s" % instance)
1797
      inst_config = instanceinfo[instance]
1798
      self._VerifyInstance(instance, inst_config, node_image)
1799
      inst_nodes_offline = []
1800

    
1801
      pnode = inst_config.primary_node
1802
      pnode_img = node_image[pnode]
1803
      _ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,
1804
               self.ENODERPC, pnode, "instance %s, connection to"
1805
               " primary node failed", instance)
1806

    
1807
      if pnode_img.offline:
1808
        inst_nodes_offline.append(pnode)
1809

    
1810
      # If the instance is non-redundant we cannot survive losing its primary
1811
      # node, so we are not N+1 compliant. On the other hand we have no disk
1812
      # templates with more than one secondary so that situation is not well
1813
      # supported either.
1814
      # FIXME: does not support file-backed instances
1815
      if not inst_config.secondary_nodes:
1816
        i_non_redundant.append(instance)
1817
      _ErrorIf(len(inst_config.secondary_nodes) > 1, self.EINSTANCELAYOUT,
1818
               instance, "instance has multiple secondary nodes: %s",
1819
               utils.CommaJoin(inst_config.secondary_nodes),
1820
               code=self.ETYPE_WARNING)
1821

    
1822
      if not cluster.FillBE(inst_config)[constants.BE_AUTO_BALANCE]:
1823
        i_non_a_balanced.append(instance)
1824

    
1825
      for snode in inst_config.secondary_nodes:
1826
        s_img = node_image[snode]
1827
        _ErrorIf(s_img.rpc_fail and not s_img.offline, self.ENODERPC, snode,
1828
                 "instance %s, connection to secondary node failed", instance)
1829

    
1830
        if s_img.offline:
1831
          inst_nodes_offline.append(snode)
1832

    
1833
      # warn that the instance lives on offline nodes
1834
      _ErrorIf(inst_nodes_offline, self.EINSTANCEBADNODE, instance,
1835
               "instance lives on offline node(s) %s",
1836
               utils.CommaJoin(inst_nodes_offline))
1837
      # ... or ghost nodes
1838
      for node in inst_config.all_nodes:
1839
        _ErrorIf(node_image[node].ghost, self.EINSTANCEBADNODE, instance,
1840
                 "instance lives on ghost node %s", node)
1841

    
1842
    feedback_fn("* Verifying orphan volumes")
1843
    self._VerifyOrphanVolumes(node_vol_should, node_image)
1844

    
1845
    feedback_fn("* Verifying oprhan instances")
1846
    self._VerifyOrphanInstances(instancelist, node_image)
1847

    
1848
    if constants.VERIFY_NPLUSONE_MEM not in self.skip_set:
1849
      feedback_fn("* Verifying N+1 Memory redundancy")
1850
      self._VerifyNPlusOneMemory(node_image, instanceinfo)
1851

    
1852
    feedback_fn("* Other Notes")
1853
    if i_non_redundant:
1854
      feedback_fn("  - NOTICE: %d non-redundant instance(s) found."
1855
                  % len(i_non_redundant))
1856

    
1857
    if i_non_a_balanced:
1858
      feedback_fn("  - NOTICE: %d non-auto-balanced instance(s) found."
1859
                  % len(i_non_a_balanced))
1860

    
1861
    if n_offline:
1862
      feedback_fn("  - NOTICE: %d offline node(s) found." % n_offline)
1863

    
1864
    if n_drained:
1865
      feedback_fn("  - NOTICE: %d drained node(s) found." % n_drained)
1866

    
1867
    return not self.bad
1868

    
1869
  def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):
1870
    """Analyze the post-hooks' result
1871

1872
    This method analyses the hook result, handles it, and sends some
1873
    nicely-formatted feedback back to the user.
1874

1875
    @param phase: one of L{constants.HOOKS_PHASE_POST} or
1876
        L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
1877
    @param hooks_results: the results of the multi-node hooks rpc call
1878
    @param feedback_fn: function used send feedback back to the caller
1879
    @param lu_result: previous Exec result
1880
    @return: the new Exec result, based on the previous result
1881
        and hook results
1882

1883
    """
1884
    # We only really run POST phase hooks, and are only interested in
1885
    # their results
1886
    if phase == constants.HOOKS_PHASE_POST:
1887
      # Used to change hooks' output to proper indentation
1888
      indent_re = re.compile('^', re.M)
1889
      feedback_fn("* Hooks Results")
1890
      assert hooks_results, "invalid result from hooks"
1891

    
1892
      for node_name in hooks_results:
1893
        res = hooks_results[node_name]
1894
        msg = res.fail_msg
1895
        test = msg and not res.offline
1896
        self._ErrorIf(test, self.ENODEHOOKS, node_name,
1897
                      "Communication failure in hooks execution: %s", msg)
1898
        if res.offline or msg:
1899
          # No need to investigate payload if node is offline or gave an error.
1900
          # override manually lu_result here as _ErrorIf only
1901
          # overrides self.bad
1902
          lu_result = 1
1903
          continue
1904
        for script, hkr, output in res.payload:
1905
          test = hkr == constants.HKR_FAIL
1906
          self._ErrorIf(test, self.ENODEHOOKS, node_name,
1907
                        "Script %s failed, output:", script)
1908
          if test:
1909
            output = indent_re.sub('      ', output)
1910
            feedback_fn("%s" % output)
1911
            lu_result = 0
1912

    
1913
      return lu_result
1914

    
1915

    
1916
class LUVerifyDisks(NoHooksLU):
1917
  """Verifies the cluster disks status.
1918

1919
  """
1920
  _OP_REQP = []
1921
  REQ_BGL = False
1922

    
1923
  def ExpandNames(self):
1924
    self.needed_locks = {
1925
      locking.LEVEL_NODE: locking.ALL_SET,
1926
      locking.LEVEL_INSTANCE: locking.ALL_SET,
1927
    }
1928
    self.share_locks = dict.fromkeys(locking.LEVELS, 1)
1929

    
1930
  def CheckPrereq(self):
1931
    """Check prerequisites.
1932

1933
    This has no prerequisites.
1934

1935
    """
1936
    pass
1937

    
1938
  def Exec(self, feedback_fn):
1939
    """Verify integrity of cluster disks.
1940

1941
    @rtype: tuple of three items
1942
    @return: a tuple of (dict of node-to-node_error, list of instances
1943
        which need activate-disks, dict of instance: (node, volume) for
1944
        missing volumes
1945

1946
    """
1947
    result = res_nodes, res_instances, res_missing = {}, [], {}
1948

    
1949
    vg_name = self.cfg.GetVGName()
1950
    nodes = utils.NiceSort(self.cfg.GetNodeList())
1951
    instances = [self.cfg.GetInstanceInfo(name)
1952
                 for name in self.cfg.GetInstanceList()]
1953

    
1954
    nv_dict = {}
1955
    for inst in instances:
1956
      inst_lvs = {}
1957
      if (not inst.admin_up or
1958
          inst.disk_template not in constants.DTS_NET_MIRROR):
1959
        continue
1960
      inst.MapLVsByNode(inst_lvs)
1961
      # transform { iname: {node: [vol,],},} to {(node, vol): iname}
1962
      for node, vol_list in inst_lvs.iteritems():
1963
        for vol in vol_list:
1964
          nv_dict[(node, vol)] = inst
1965

    
1966
    if not nv_dict:
1967
      return result
1968

    
1969
    node_lvs = self.rpc.call_lv_list(nodes, vg_name)
1970

    
1971
    for node in nodes:
1972
      # node_volume
1973
      node_res = node_lvs[node]
1974
      if node_res.offline:
1975
        continue
1976
      msg = node_res.fail_msg
1977
      if msg:
1978
        logging.warning("Error enumerating LVs on node %s: %s", node, msg)
1979
        res_nodes[node] = msg
1980
        continue
1981

    
1982
      lvs = node_res.payload
1983
      for lv_name, (_, _, lv_online) in lvs.items():
1984
        inst = nv_dict.pop((node, lv_name), None)
1985
        if (not lv_online and inst is not None
1986
            and inst.name not in res_instances):
1987
          res_instances.append(inst.name)
1988

    
1989
    # any leftover items in nv_dict are missing LVs, let's arrange the
1990
    # data better
1991
    for key, inst in nv_dict.iteritems():
1992
      if inst.name not in res_missing:
1993
        res_missing[inst.name] = []
1994
      res_missing[inst.name].append(key)
1995

    
1996
    return result
1997

    
1998

    
1999
class LURepairDiskSizes(NoHooksLU):
2000
  """Verifies the cluster disks sizes.
2001

2002
  """
2003
  _OP_REQP = ["instances"]
2004
  REQ_BGL = False
2005

    
2006
  def ExpandNames(self):
2007
    if not isinstance(self.op.instances, list):
2008
      raise errors.OpPrereqError("Invalid argument type 'instances'",
2009
                                 errors.ECODE_INVAL)
2010

    
2011
    if self.op.instances:
2012
      self.wanted_names = []
2013
      for name in self.op.instances:
2014
        full_name = _ExpandInstanceName(self.cfg, name)
2015
        self.wanted_names.append(full_name)
2016
      self.needed_locks = {
2017
        locking.LEVEL_NODE: [],
2018
        locking.LEVEL_INSTANCE: self.wanted_names,
2019
        }
2020
      self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
2021
    else:
2022
      self.wanted_names = None
2023
      self.needed_locks = {
2024
        locking.LEVEL_NODE: locking.ALL_SET,
2025
        locking.LEVEL_INSTANCE: locking.ALL_SET,
2026
        }
2027
    self.share_locks = dict(((i, 1) for i in locking.LEVELS))
2028

    
2029
  def DeclareLocks(self, level):
2030
    if level == locking.LEVEL_NODE and self.wanted_names is not None:
2031
      self._LockInstancesNodes(primary_only=True)
2032

    
2033
  def CheckPrereq(self):
2034
    """Check prerequisites.
2035

2036
    This only checks the optional instance list against the existing names.
2037

2038
    """
2039
    if self.wanted_names is None:
2040
      self.wanted_names = self.acquired_locks[locking.LEVEL_INSTANCE]
2041

    
2042
    self.wanted_instances = [self.cfg.GetInstanceInfo(name) for name
2043
                             in self.wanted_names]
2044

    
2045
  def _EnsureChildSizes(self, disk):
2046
    """Ensure children of the disk have the needed disk size.
2047

2048
    This is valid mainly for DRBD8 and fixes an issue where the
2049
    children have smaller disk size.
2050

2051
    @param disk: an L{ganeti.objects.Disk} object
2052

2053
    """
2054
    if disk.dev_type == constants.LD_DRBD8:
2055
      assert disk.children, "Empty children for DRBD8?"
2056
      fchild = disk.children[0]
2057
      mismatch = fchild.size < disk.size
2058
      if mismatch:
2059
        self.LogInfo("Child disk has size %d, parent %d, fixing",
2060
                     fchild.size, disk.size)
2061
        fchild.size = disk.size
2062

    
2063
      # and we recurse on this child only, not on the metadev
2064
      return self._EnsureChildSizes(fchild) or mismatch
2065
    else:
2066
      return False
2067

    
2068
  def Exec(self, feedback_fn):
2069
    """Verify the size of cluster disks.
2070

2071
    """
2072
    # TODO: check child disks too
2073
    # TODO: check differences in size between primary/secondary nodes
2074
    per_node_disks = {}
2075
    for instance in self.wanted_instances:
2076
      pnode = instance.primary_node
2077
      if pnode not in per_node_disks:
2078
        per_node_disks[pnode] = []
2079
      for idx, disk in enumerate(instance.disks):
2080
        per_node_disks[pnode].append((instance, idx, disk))
2081

    
2082
    changed = []
2083
    for node, dskl in per_node_disks.items():
2084
      newl = [v[2].Copy() for v in dskl]
2085
      for dsk in newl:
2086
        self.cfg.SetDiskID(dsk, node)
2087
      result = self.rpc.call_blockdev_getsizes(node, newl)
2088
      if result.fail_msg:
2089
        self.LogWarning("Failure in blockdev_getsizes call to node"
2090
                        " %s, ignoring", node)
2091
        continue
2092
      if len(result.data) != len(dskl):
2093
        self.LogWarning("Invalid result from node %s, ignoring node results",
2094
                        node)
2095
        continue
2096
      for ((instance, idx, disk), size) in zip(dskl, result.data):
2097
        if size is None:
2098
          self.LogWarning("Disk %d of instance %s did not return size"
2099
                          " information, ignoring", idx, instance.name)
2100
          continue
2101
        if not isinstance(size, (int, long)):
2102
          self.LogWarning("Disk %d of instance %s did not return valid"
2103
                          " size information, ignoring", idx, instance.name)
2104
          continue
2105
        size = size >> 20
2106
        if size != disk.size:
2107
          self.LogInfo("Disk %d of instance %s has mismatched size,"
2108
                       " correcting: recorded %d, actual %d", idx,
2109
                       instance.name, disk.size, size)
2110
          disk.size = size
2111
          self.cfg.Update(instance, feedback_fn)
2112
          changed.append((instance.name, idx, size))
2113
        if self._EnsureChildSizes(disk):
2114
          self.cfg.Update(instance, feedback_fn)
2115
          changed.append((instance.name, idx, disk.size))
2116
    return changed
2117

    
2118

    
2119
class LURenameCluster(LogicalUnit):
2120
  """Rename the cluster.
2121

2122
  """
2123
  HPATH = "cluster-rename"
2124
  HTYPE = constants.HTYPE_CLUSTER
2125
  _OP_REQP = ["name"]
2126

    
2127
  def BuildHooksEnv(self):
2128
    """Build hooks env.
2129

2130
    """
2131
    env = {
2132
      "OP_TARGET": self.cfg.GetClusterName(),
2133
      "NEW_NAME": self.op.name,
2134
      }
2135
    mn = self.cfg.GetMasterNode()
2136
    all_nodes = self.cfg.GetNodeList()
2137
    return env, [mn], all_nodes
2138

    
2139
  def CheckPrereq(self):
2140
    """Verify that the passed name is a valid one.
2141

2142
    """
2143
    hostname = utils.GetHostInfo(self.op.name)
2144

    
2145
    new_name = hostname.name
2146
    self.ip = new_ip = hostname.ip
2147
    old_name = self.cfg.GetClusterName()
2148
    old_ip = self.cfg.GetMasterIP()
2149
    if new_name == old_name and new_ip == old_ip:
2150
      raise errors.OpPrereqError("Neither the name nor the IP address of the"
2151
                                 " cluster has changed",
2152
                                 errors.ECODE_INVAL)
2153
    if new_ip != old_ip:
2154
      if utils.TcpPing(new_ip, constants.DEFAULT_NODED_PORT):
2155
        raise errors.OpPrereqError("The given cluster IP address (%s) is"
2156
                                   " reachable on the network. Aborting." %
2157
                                   new_ip, errors.ECODE_NOTUNIQUE)
2158

    
2159
    self.op.name = new_name
2160

    
2161
  def Exec(self, feedback_fn):
2162
    """Rename the cluster.
2163

2164
    """
2165
    clustername = self.op.name
2166
    ip = self.ip
2167

    
2168
    # shutdown the master IP
2169
    master = self.cfg.GetMasterNode()
2170
    result = self.rpc.call_node_stop_master(master, False)
2171
    result.Raise("Could not disable the master role")
2172

    
2173
    try:
2174
      cluster = self.cfg.GetClusterInfo()
2175
      cluster.cluster_name = clustername
2176
      cluster.master_ip = ip
2177
      self.cfg.Update(cluster, feedback_fn)
2178

    
2179
      # update the known hosts file
2180
      ssh.WriteKnownHostsFile(self.cfg, constants.SSH_KNOWN_HOSTS_FILE)
2181
      node_list = self.cfg.GetNodeList()
2182
      try:
2183
        node_list.remove(master)
2184
      except ValueError:
2185
        pass
2186
      result = self.rpc.call_upload_file(node_list,
2187
                                         constants.SSH_KNOWN_HOSTS_FILE)
2188
      for to_node, to_result in result.iteritems():
2189
        msg = to_result.fail_msg
2190
        if msg:
2191
          msg = ("Copy of file %s to node %s failed: %s" %
2192
                 (constants.SSH_KNOWN_HOSTS_FILE, to_node, msg))
2193
          self.proc.LogWarning(msg)
2194

    
2195
    finally:
2196
      result = self.rpc.call_node_start_master(master, False, False)
2197
      msg = result.fail_msg
2198
      if msg:
2199
        self.LogWarning("Could not re-enable the master role on"
2200
                        " the master, please restart manually: %s", msg)
2201

    
2202

    
2203
def _RecursiveCheckIfLVMBased(disk):
2204
  """Check if the given disk or its children are lvm-based.
2205

2206
  @type disk: L{objects.Disk}
2207
  @param disk: the disk to check
2208
  @rtype: boolean
2209
  @return: boolean indicating whether a LD_LV dev_type was found or not
2210

2211
  """
2212
  if disk.children:
2213
    for chdisk in disk.children:
2214
      if _RecursiveCheckIfLVMBased(chdisk):
2215
        return True
2216
  return disk.dev_type == constants.LD_LV
2217

    
2218

    
2219
class LUSetClusterParams(LogicalUnit):
2220
  """Change the parameters of the cluster.
2221

2222
  """
2223
  HPATH = "cluster-modify"
2224
  HTYPE = constants.HTYPE_CLUSTER
2225
  _OP_REQP = []
2226
  REQ_BGL = False
2227

    
2228
  def CheckArguments(self):
2229
    """Check parameters
2230

2231
    """
2232
    if not hasattr(self.op, "candidate_pool_size"):
2233
      self.op.candidate_pool_size = None
2234
    if self.op.candidate_pool_size is not None:
2235
      try:
2236
        self.op.candidate_pool_size = int(self.op.candidate_pool_size)
2237
      except (ValueError, TypeError), err:
2238
        raise errors.OpPrereqError("Invalid candidate_pool_size value: %s" %
2239
                                   str(err), errors.ECODE_INVAL)
2240
      if self.op.candidate_pool_size < 1:
2241
        raise errors.OpPrereqError("At least one master candidate needed",
2242
                                   errors.ECODE_INVAL)
2243

    
2244
  def ExpandNames(self):
2245
    # FIXME: in the future maybe other cluster params won't require checking on
2246
    # all nodes to be modified.
2247
    self.needed_locks = {
2248
      locking.LEVEL_NODE: locking.ALL_SET,
2249
    }
2250
    self.share_locks[locking.LEVEL_NODE] = 1
2251

    
2252
  def BuildHooksEnv(self):
2253
    """Build hooks env.
2254

2255
    """
2256
    env = {
2257
      "OP_TARGET": self.cfg.GetClusterName(),
2258
      "NEW_VG_NAME": self.op.vg_name,
2259
      }
2260
    mn = self.cfg.GetMasterNode()
2261
    return env, [mn], [mn]
2262

    
2263
  def CheckPrereq(self):
2264
    """Check prerequisites.
2265

2266
    This checks whether the given params don't conflict and
2267
    if the given volume group is valid.
2268

2269
    """
2270
    if self.op.vg_name is not None and not self.op.vg_name:
2271
      instances = self.cfg.GetAllInstancesInfo().values()
2272
      for inst in instances:
2273
        for disk in inst.disks:
2274
          if _RecursiveCheckIfLVMBased(disk):
2275
            raise errors.OpPrereqError("Cannot disable lvm storage while"
2276
                                       " lvm-based instances exist",
2277
                                       errors.ECODE_INVAL)
2278

    
2279
    node_list = self.acquired_locks[locking.LEVEL_NODE]
2280

    
2281
    # if vg_name not None, checks given volume group on all nodes
2282
    if self.op.vg_name:
2283
      vglist = self.rpc.call_vg_list(node_list)
2284
      for node in node_list:
2285
        msg = vglist[node].fail_msg
2286
        if msg:
2287
          # ignoring down node
2288
          self.LogWarning("Error while gathering data on node %s"
2289
                          " (ignoring node): %s", node, msg)
2290
          continue
2291
        vgstatus = utils.CheckVolumeGroupSize(vglist[node].payload,
2292
                                              self.op.vg_name,
2293
                                              constants.MIN_VG_SIZE)
2294
        if vgstatus:
2295
          raise errors.OpPrereqError("Error on node '%s': %s" %
2296
                                     (node, vgstatus), errors.ECODE_ENVIRON)
2297

    
2298
    self.cluster = cluster = self.cfg.GetClusterInfo()
2299
    # validate params changes
2300
    if self.op.beparams:
2301
      utils.ForceDictType(self.op.beparams, constants.BES_PARAMETER_TYPES)
2302
      self.new_beparams = objects.FillDict(
2303
        cluster.beparams[constants.PP_DEFAULT], self.op.beparams)
2304

    
2305
    if self.op.nicparams:
2306
      utils.ForceDictType(self.op.nicparams, constants.NICS_PARAMETER_TYPES)
2307
      self.new_nicparams = objects.FillDict(
2308
        cluster.nicparams[constants.PP_DEFAULT], self.op.nicparams)
2309
      objects.NIC.CheckParameterSyntax(self.new_nicparams)
2310
      nic_errors = []
2311

    
2312
      # check all instances for consistency
2313
      for instance in self.cfg.GetAllInstancesInfo().values():
2314
        for nic_idx, nic in enumerate(instance.nics):
2315
          params_copy = copy.deepcopy(nic.nicparams)
2316
          params_filled = objects.FillDict(self.new_nicparams, params_copy)
2317

    
2318
          # check parameter syntax
2319
          try:
2320
            objects.NIC.CheckParameterSyntax(params_filled)
2321
          except errors.ConfigurationError, err:
2322
            nic_errors.append("Instance %s, nic/%d: %s" %
2323
                              (instance.name, nic_idx, err))
2324

    
2325
          # if we're moving instances to routed, check that they have an ip
2326
          target_mode = params_filled[constants.NIC_MODE]
2327
          if target_mode == constants.NIC_MODE_ROUTED and not nic.ip:
2328
            nic_errors.append("Instance %s, nic/%d: routed nick with no ip" %
2329
                              (instance.name, nic_idx))
2330
      if nic_errors:
2331
        raise errors.OpPrereqError("Cannot apply the change, errors:\n%s" %
2332
                                   "\n".join(nic_errors))
2333

    
2334
    # hypervisor list/parameters
2335
    self.new_hvparams = objects.FillDict(cluster.hvparams, {})
2336
    if self.op.hvparams:
2337
      if not isinstance(self.op.hvparams, dict):
2338
        raise errors.OpPrereqError("Invalid 'hvparams' parameter on input",
2339
                                   errors.ECODE_INVAL)
2340
      for hv_name, hv_dict in self.op.hvparams.items():
2341
        if hv_name not in self.new_hvparams:
2342
          self.new_hvparams[hv_name] = hv_dict
2343
        else:
2344
          self.new_hvparams[hv_name].update(hv_dict)
2345

    
2346
    # os hypervisor parameters
2347
    self.new_os_hvp = objects.FillDict(cluster.os_hvp, {})
2348
    if self.op.os_hvp:
2349
      if not isinstance(self.op.os_hvp, dict):
2350
        raise errors.OpPrereqError("Invalid 'os_hvp' parameter on input",
2351
                                   errors.ECODE_INVAL)
2352
      for os_name, hvs in self.op.os_hvp.items():
2353
        if not isinstance(hvs, dict):
2354
          raise errors.OpPrereqError(("Invalid 'os_hvp' parameter on"
2355
                                      " input"), errors.ECODE_INVAL)
2356
        if os_name not in self.new_os_hvp:
2357
          self.new_os_hvp[os_name] = hvs
2358
        else:
2359
          for hv_name, hv_dict in hvs.items():
2360
            if hv_name not in self.new_os_hvp[os_name]:
2361
              self.new_os_hvp[os_name][hv_name] = hv_dict
2362
            else:
2363
              self.new_os_hvp[os_name][hv_name].update(hv_dict)
2364

    
2365
    if self.op.enabled_hypervisors is not None:
2366
      self.hv_list = self.op.enabled_hypervisors
2367
      if not self.hv_list:
2368
        raise errors.OpPrereqError("Enabled hypervisors list must contain at"
2369
                                   " least one member",
2370
                                   errors.ECODE_INVAL)
2371
      invalid_hvs = set(self.hv_list) - constants.HYPER_TYPES
2372
      if invalid_hvs:
2373
        raise errors.OpPrereqError("Enabled hypervisors contains invalid"
2374
                                   " entries: %s" %
2375
                                   utils.CommaJoin(invalid_hvs),
2376
                                   errors.ECODE_INVAL)
2377
    else:
2378
      self.hv_list = cluster.enabled_hypervisors
2379

    
2380
    if self.op.hvparams or self.op.enabled_hypervisors is not None:
2381
      # either the enabled list has changed, or the parameters have, validate
2382
      for hv_name, hv_params in self.new_hvparams.items():
2383
        if ((self.op.hvparams and hv_name in self.op.hvparams) or
2384
            (self.op.enabled_hypervisors and
2385
             hv_name in self.op.enabled_hypervisors)):
2386
          # either this is a new hypervisor, or its parameters have changed
2387
          hv_class = hypervisor.GetHypervisor(hv_name)
2388
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
2389
          hv_class.CheckParameterSyntax(hv_params)
2390
          _CheckHVParams(self, node_list, hv_name, hv_params)
2391

    
2392
    if self.op.os_hvp:
2393
      # no need to check any newly-enabled hypervisors, since the
2394
      # defaults have already been checked in the above code-block
2395
      for os_name, os_hvp in self.new_os_hvp.items():
2396
        for hv_name, hv_params in os_hvp.items():
2397
          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
2398
          # we need to fill in the new os_hvp on top of the actual hv_p
2399
          cluster_defaults = self.new_hvparams.get(hv_name, {})
2400
          new_osp = objects.FillDict(cluster_defaults, hv_params)
2401
          hv_class = hypervisor.GetHypervisor(hv_name)
2402
          hv_class.CheckParameterSyntax(new_osp)
2403
          _CheckHVParams(self, node_list, hv_name, new_osp)
2404

    
2405

    
2406
  def Exec(self, feedback_fn):
2407
    """Change the parameters of the cluster.
2408

2409
    """
2410
    if self.op.vg_name is not None:
2411
      new_volume = self.op.vg_name
2412
      if not new_volume:
2413
        new_volume = None
2414
      if new_volume != self.cfg.GetVGName():
2415
        self.cfg.SetVGName(new_volume)
2416
      else:
2417
        feedback_fn("Cluster LVM configuration already in desired"
2418
                    " state, not changing")
2419
    if self.op.hvparams:
2420
      self.cluster.hvparams = self.new_hvparams
2421
    if self.op.os_hvp:
2422
      self.cluster.os_hvp = self.new_os_hvp
2423
    if self.op.enabled_hypervisors is not None:
2424
      self.cluster.enabled_hypervisors = self.op.enabled_hypervisors
2425
    if self.op.beparams:
2426
      self.cluster.beparams[constants.PP_DEFAULT] = self.new_beparams
2427
    if self.op.nicparams:
2428
      self.cluster.nicparams[constants.PP_DEFAULT] = self.new_nicparams
2429

    
2430
    if self.op.candidate_pool_size is not None:
2431
      self.cluster.candidate_pool_size = self.op.candidate_pool_size
2432
      # we need to update the pool size here, otherwise the save will fail
2433
      _AdjustCandidatePool(self, [])
2434

    
2435
    self.cfg.Update(self.cluster, feedback_fn)
2436

    
2437

    
2438
def _RedistributeAncillaryFiles(lu, additional_nodes=None):
2439
  """Distribute additional files which are part of the cluster configuration.
2440

2441
  ConfigWriter takes care of distributing the config and ssconf files, but
2442
  there are more files which should be distributed to all nodes. This function
2443
  makes sure those are copied.
2444

2445
  @param lu: calling logical unit
2446
  @param additional_nodes: list of nodes not in the config to distribute to
2447

2448
  """
2449
  # 1. Gather target nodes
2450
  myself = lu.cfg.GetNodeInfo(lu.cfg.GetMasterNode())
2451
  dist_nodes = lu.cfg.GetOnlineNodeList()
2452
  if additional_nodes is not None:
2453
    dist_nodes.extend(additional_nodes)
2454
  if myself.name in dist_nodes:
2455
    dist_nodes.remove(myself.name)
2456

    
2457
  # 2. Gather files to distribute
2458
  dist_files = set([constants.ETC_HOSTS,
2459
                    constants.SSH_KNOWN_HOSTS_FILE,
2460
                    constants.RAPI_CERT_FILE,
2461
                    constants.RAPI_USERS_FILE,
2462
                    constants.CONFD_HMAC_KEY,
2463
                   ])
2464

    
2465
  enabled_hypervisors = lu.cfg.GetClusterInfo().enabled_hypervisors
2466
  for hv_name in enabled_hypervisors:
2467
    hv_class = hypervisor.GetHypervisor(hv_name)
2468
    dist_files.update(hv_class.GetAncillaryFiles())
2469

    
2470
  # 3. Perform the files upload
2471
  for fname in dist_files:
2472
    if os.path.exists(fname):
2473
      result = lu.rpc.call_upload_file(dist_nodes, fname)
2474
      for to_node, to_result in result.items():
2475
        msg = to_result.fail_msg
2476
        if msg:
2477
          msg = ("Copy of file %s to node %s failed: %s" %
2478
                 (fname, to_node, msg))
2479
          lu.proc.LogWarning(msg)
2480

    
2481

    
2482
class LURedistributeConfig(NoHooksLU):
2483
  """Force the redistribution of cluster configuration.
2484

2485
  This is a very simple LU.
2486

2487
  """
2488
  _OP_REQP = []
2489
  REQ_BGL = False
2490

    
2491
  def ExpandNames(self):
2492
    self.needed_locks = {
2493
      locking.LEVEL_NODE: locking.ALL_SET,
2494
    }
2495
    self.share_locks[locking.LEVEL_NODE] = 1
2496

    
2497
  def CheckPrereq(self):
2498
    """Check prerequisites.
2499

2500
    """
2501

    
2502
  def Exec(self, feedback_fn):
2503
    """Redistribute the configuration.
2504

2505
    """
2506
    self.cfg.Update(self.cfg.GetClusterInfo(), feedback_fn)
2507
    _RedistributeAncillaryFiles(self)
2508

    
2509

    
2510
def _WaitForSync(lu, instance, oneshot=False):
2511
  """Sleep and poll for an instance's disk to sync.
2512

2513
  """
2514
  if not instance.disks:
2515
    return True
2516

    
2517
  if not oneshot:
2518
    lu.proc.LogInfo("Waiting for instance %s to sync disks." % instance.name)
2519

    
2520
  node = instance.primary_node
2521

    
2522
  for dev in instance.disks:
2523
    lu.cfg.SetDiskID(dev, node)
2524

    
2525
  # TODO: Convert to utils.Retry
2526

    
2527
  retries = 0
2528
  degr_retries = 10 # in seconds, as we sleep 1 second each time
2529
  while True:
2530
    max_time = 0
2531
    done = True
2532
    cumul_degraded = False
2533
    rstats = lu.rpc.call_blockdev_getmirrorstatus(node, instance.disks)
2534
    msg = rstats.fail_msg
2535
    if msg:
2536
      lu.LogWarning("Can't get any data from node %s: %s", node, msg)
2537
      retries += 1
2538
      if retries >= 10:
2539
        raise errors.RemoteError("Can't contact node %s for mirror data,"
2540
                                 " aborting." % node)
2541
      time.sleep(6)
2542
      continue
2543
    rstats = rstats.payload
2544
    retries = 0
2545
    for i, mstat in enumerate(rstats):
2546
      if mstat is None:
2547
        lu.LogWarning("Can't compute data for node %s/%s",
2548
                           node, instance.disks[i].iv_name)
2549
        continue
2550

    
2551
      cumul_degraded = (cumul_degraded or
2552
                        (mstat.is_degraded and mstat.sync_percent is None))
2553
      if mstat.sync_percent is not None:
2554
        done = False
2555
        if mstat.estimated_time is not None:
2556
          rem_time = "%d estimated seconds remaining" % mstat.estimated_time
2557
          max_time = mstat.estimated_time
2558
        else:
2559
          rem_time = "no time estimate"
2560
        lu.proc.LogInfo("- device %s: %5.2f%% done, %s" %
2561
                        (instance.disks[i].iv_name, mstat.sync_percent,
2562
                         rem_time))
2563

    
2564
    # if we're done but degraded, let's do a few small retries, to
2565
    # make sure we see a stable and not transient situation; therefore
2566
    # we force restart of the loop
2567
    if (done or oneshot) and cumul_degraded and degr_retries > 0:
2568
      logging.info("Degraded disks found, %d retries left", degr_retries)
2569
      degr_retries -= 1
2570
      time.sleep(1)
2571
      continue
2572

    
2573
    if done or oneshot:
2574
      break
2575

    
2576
    time.sleep(min(60, max_time))
2577

    
2578
  if done:
2579
    lu.proc.LogInfo("Instance %s's disks are in sync." % instance.name)
2580
  return not cumul_degraded
2581

    
2582

    
2583
def _CheckDiskConsistency(lu, dev, node, on_primary, ldisk=False):
2584
  """Check that mirrors are not degraded.
2585

2586
  The ldisk parameter, if True, will change the test from the
2587
  is_degraded attribute (which represents overall non-ok status for
2588
  the device(s)) to the ldisk (representing the local storage status).
2589

2590
  """
2591
  lu.cfg.SetDiskID(dev, node)
2592

    
2593
  result = True
2594

    
2595
  if on_primary or dev.AssembleOnSecondary():
2596
    rstats = lu.rpc.call_blockdev_find(node, dev)
2597
    msg = rstats.fail_msg
2598
    if msg:
2599
      lu.LogWarning("Can't find disk on node %s: %s", node, msg)
2600
      result = False
2601
    elif not rstats.payload:
2602
      lu.LogWarning("Can't find disk on node %s", node)
2603
      result = False
2604
    else:
2605
      if ldisk:
2606
        result = result and rstats.payload.ldisk_status == constants.LDS_OKAY
2607
      else:
2608
        result = result and not rstats.payload.is_degraded
2609

    
2610
  if dev.children:
2611
    for child in dev.children:
2612
      result = result and _CheckDiskConsistency(lu, child, node, on_primary)
2613

    
2614
  return result
2615

    
2616

    
2617
class LUDiagnoseOS(NoHooksLU):
2618
  """Logical unit for OS diagnose/query.
2619

2620
  """
2621
  _OP_REQP = ["output_fields", "names"]
2622
  REQ_BGL = False
2623
  _FIELDS_STATIC = utils.FieldSet()
2624
  _FIELDS_DYNAMIC = utils.FieldSet("name", "valid", "node_status", "variants")
2625
  # Fields that need calculation of global os validity
2626
  _FIELDS_NEEDVALID = frozenset(["valid", "variants"])
2627

    
2628
  def ExpandNames(self):
2629
    if self.op.names:
2630
      raise errors.OpPrereqError("Selective OS query not supported",
2631
                                 errors.ECODE_INVAL)
2632

    
2633
    _CheckOutputFields(static=self._FIELDS_STATIC,
2634
                       dynamic=self._FIELDS_DYNAMIC,
2635
                       selected=self.op.output_fields)
2636

    
2637
    # Lock all nodes, in shared mode
2638
    # Temporary removal of locks, should be reverted later
2639
    # TODO: reintroduce locks when they are lighter-weight
2640
    self.needed_locks = {}
2641
    #self.share_locks[locking.LEVEL_NODE] = 1
2642
    #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
2643

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

2647
    """
2648

    
2649
  @staticmethod
2650
  def _DiagnoseByOS(rlist):
2651
    """Remaps a per-node return list into an a per-os per-node dictionary
2652

2653
    @param rlist: a map with node names as keys and OS objects as values
2654

2655
    @rtype: dict
2656
    @return: a dictionary with osnames as keys and as value another map, with
2657
        nodes as keys and tuples of (path, status, diagnose) as values, eg::
2658

2659
          {"debian-etch": {"node1": [(/usr/lib/..., True, ""),
2660
                                     (/srv/..., False, "invalid api")],
2661
                           "node2": [(/srv/..., True, "")]}
2662
          }
2663

2664
    """
2665
    all_os = {}
2666
    # we build here the list of nodes that didn't fail the RPC (at RPC
2667
    # level), so that nodes with a non-responding node daemon don't
2668
    # make all OSes invalid
2669
    good_nodes = [node_name for node_name in rlist
2670
                  if not rlist[node_name].fail_msg]
2671
    for node_name, nr in rlist.items():
2672
      if nr.fail_msg or not nr.payload:
2673
        continue
2674
      for name, path, status, diagnose, variants in nr.payload:
2675
        if name not in all_os:
2676
          # build a list of nodes for this os containing empty lists
2677
          # for each node in node_list
2678
          all_os[name] = {}
2679
          for nname in good_nodes:
2680
            all_os[name][nname] = []
2681
        all_os[name][node_name].append((path, status, diagnose, variants))
2682
    return all_os
2683

    
2684
  def Exec(self, feedback_fn):
2685
    """Compute the list of OSes.
2686

2687
    """
2688
    valid_nodes = [node for node in self.cfg.GetOnlineNodeList()]
2689
    node_data = self.rpc.call_os_diagnose(valid_nodes)
2690
    pol = self._DiagnoseByOS(node_data)
2691
    output = []
2692
    calc_valid = self._FIELDS_NEEDVALID.intersection(self.op.output_fields)
2693
    calc_variants = "variants" in self.op.output_fields
2694

    
2695
    for os_name, os_data in pol.items():
2696
      row = []
2697
      if calc_valid:
2698
        valid = True
2699
        variants = None
2700
        for osl in os_data.values():
2701
          valid = valid and osl and osl[0][1]
2702
          if not valid:
2703
            variants = None
2704
            break
2705
          if calc_variants:
2706
            node_variants = osl[0][3]
2707
            if variants is None:
2708
              variants = node_variants
2709
            else:
2710
              variants = [v for v in variants if v in node_variants]
2711

    
2712
      for field in self.op.output_fields:
2713
        if field == "name":
2714
          val = os_name
2715
        elif field == "valid":
2716
          val = valid
2717
        elif field == "node_status":
2718
          # this is just a copy of the dict
2719
          val = {}
2720
          for node_name, nos_list in os_data.items():
2721
            val[node_name] = nos_list
2722
        elif field == "variants":
2723
          val =  variants
2724
        else:
2725
          raise errors.ParameterError(field)
2726
        row.append(val)
2727
      output.append(row)
2728

    
2729
    return output
2730

    
2731

    
2732
class LURemoveNode(LogicalUnit):
2733
  """Logical unit for removing a node.
2734

2735
  """
2736
  HPATH = "node-remove"
2737
  HTYPE = constants.HTYPE_NODE
2738
  _OP_REQP = ["node_name"]
2739

    
2740
  def BuildHooksEnv(self):
2741
    """Build hooks env.
2742

2743
    This doesn't run on the target node in the pre phase as a failed
2744
    node would then be impossible to remove.
2745

2746
    """
2747
    env = {
2748
      "OP_TARGET": self.op.node_name,
2749
      "NODE_NAME": self.op.node_name,
2750
      }
2751
    all_nodes = self.cfg.GetNodeList()
2752
    try:
2753
      all_nodes.remove(self.op.node_name)
2754
    except ValueError:
2755
      logging.warning("Node %s which is about to be removed not found"
2756
                      " in the all nodes list", self.op.node_name)
2757
    return env, all_nodes, all_nodes
2758

    
2759
  def CheckPrereq(self):
2760
    """Check prerequisites.
2761

2762
    This checks:
2763
     - the node exists in the configuration
2764
     - it does not have primary or secondary instances
2765
     - it's not the master
2766

2767
    Any errors are signaled by raising errors.OpPrereqError.
2768

2769
    """
2770
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
2771
    node = self.cfg.GetNodeInfo(self.op.node_name)
2772
    assert node is not None
2773

    
2774
    instance_list = self.cfg.GetInstanceList()
2775

    
2776
    masternode = self.cfg.GetMasterNode()
2777
    if node.name == masternode:
2778
      raise errors.OpPrereqError("Node is the master node,"
2779
                                 " you need to failover first.",
2780
                                 errors.ECODE_INVAL)
2781

    
2782
    for instance_name in instance_list:
2783
      instance = self.cfg.GetInstanceInfo(instance_name)
2784
      if node.name in instance.all_nodes:
2785
        raise errors.OpPrereqError("Instance %s is still running on the node,"
2786
                                   " please remove first." % instance_name,
2787
                                   errors.ECODE_INVAL)
2788
    self.op.node_name = node.name
2789
    self.node = node
2790

    
2791
  def Exec(self, feedback_fn):
2792
    """Removes the node from the cluster.
2793

2794
    """
2795
    node = self.node
2796
    logging.info("Stopping the node daemon and removing configs from node %s",
2797
                 node.name)
2798

    
2799
    modify_ssh_setup = self.cfg.GetClusterInfo().modify_ssh_setup
2800

    
2801
    # Promote nodes to master candidate as needed
2802
    _AdjustCandidatePool(self, exceptions=[node.name])
2803
    self.context.RemoveNode(node.name)
2804

    
2805
    # Run post hooks on the node before it's removed
2806
    hm = self.proc.hmclass(self.rpc.call_hooks_runner, self)
2807
    try:
2808
      hm.RunPhase(constants.HOOKS_PHASE_POST, [node.name])
2809
    except:
2810
      # pylint: disable-msg=W0702
2811
      self.LogWarning("Errors occurred running hooks on %s" % node.name)
2812

    
2813
    result = self.rpc.call_node_leave_cluster(node.name, modify_ssh_setup)
2814
    msg = result.fail_msg
2815
    if msg:
2816
      self.LogWarning("Errors encountered on the remote node while leaving"
2817
                      " the cluster: %s", msg)
2818

    
2819

    
2820
class LUQueryNodes(NoHooksLU):
2821
  """Logical unit for querying nodes.
2822

2823
  """
2824
  # pylint: disable-msg=W0142
2825
  _OP_REQP = ["output_fields", "names", "use_locking"]
2826
  REQ_BGL = False
2827

    
2828
  _SIMPLE_FIELDS = ["name", "serial_no", "ctime", "mtime", "uuid",
2829
                    "master_candidate", "offline", "drained"]
2830

    
2831
  _FIELDS_DYNAMIC = utils.FieldSet(
2832
    "dtotal", "dfree",
2833
    "mtotal", "mnode", "mfree",
2834
    "bootid",
2835
    "ctotal", "cnodes", "csockets",
2836
    )
2837

    
2838
  _FIELDS_STATIC = utils.FieldSet(*[
2839
    "pinst_cnt", "sinst_cnt",
2840
    "pinst_list", "sinst_list",
2841
    "pip", "sip", "tags",
2842
    "master",
2843
    "role"] + _SIMPLE_FIELDS
2844
    )
2845

    
2846
  def ExpandNames(self):
2847
    _CheckOutputFields(static=self._FIELDS_STATIC,
2848
                       dynamic=self._FIELDS_DYNAMIC,
2849
                       selected=self.op.output_fields)
2850

    
2851
    self.needed_locks = {}
2852
    self.share_locks[locking.LEVEL_NODE] = 1
2853

    
2854
    if self.op.names:
2855
      self.wanted = _GetWantedNodes(self, self.op.names)
2856
    else:
2857
      self.wanted = locking.ALL_SET
2858

    
2859
    self.do_node_query = self._FIELDS_STATIC.NonMatching(self.op.output_fields)
2860
    self.do_locking = self.do_node_query and self.op.use_locking
2861
    if self.do_locking:
2862
      # if we don't request only static fields, we need to lock the nodes
2863
      self.needed_locks[locking.LEVEL_NODE] = self.wanted
2864

    
2865
  def CheckPrereq(self):
2866
    """Check prerequisites.
2867

2868
    """
2869
    # The validation of the node list is done in the _GetWantedNodes,
2870
    # if non empty, and if empty, there's no validation to do
2871
    pass
2872

    
2873
  def Exec(self, feedback_fn):
2874
    """Computes the list of nodes and their attributes.
2875

2876
    """
2877
    all_info = self.cfg.GetAllNodesInfo()
2878
    if self.do_locking:
2879
      nodenames = self.acquired_locks[locking.LEVEL_NODE]
2880
    elif self.wanted != locking.ALL_SET:
2881
      nodenames = self.wanted
2882
      missing = set(nodenames).difference(all_info.keys())
2883
      if missing:
2884
        raise errors.OpExecError(
2885
          "Some nodes were removed before retrieving their data: %s" % missing)
2886
    else:
2887
      nodenames = all_info.keys()
2888

    
2889
    nodenames = utils.NiceSort(nodenames)
2890
    nodelist = [all_info[name] for name in nodenames]
2891

    
2892
    # begin data gathering
2893

    
2894
    if self.do_node_query:
2895
      live_data = {}
2896
      node_data = self.rpc.call_node_info(nodenames, self.cfg.GetVGName(),
2897
                                          self.cfg.GetHypervisorType())
2898
      for name in nodenames:
2899
        nodeinfo = node_data[name]
2900
        if not nodeinfo.fail_msg and nodeinfo.payload:
2901
          nodeinfo = nodeinfo.payload
2902
          fn = utils.TryConvert
2903
          live_data[name] = {
2904
            "mtotal": fn(int, nodeinfo.get('memory_total', None)),
2905
            "mnode": fn(int, nodeinfo.get('memory_dom0', None)),
2906
            "mfree": fn(int, nodeinfo.get('memory_free', None)),
2907
            "dtotal": fn(int, nodeinfo.get('vg_size', None)),
2908
            "dfree": fn(int, nodeinfo.get('vg_free', None)),
2909
            "ctotal": fn(int, nodeinfo.get('cpu_total', None)),
2910
            "bootid": nodeinfo.get('bootid', None),
2911
            "cnodes": fn(int, nodeinfo.get('cpu_nodes', None)),
2912
            "csockets": fn(int, nodeinfo.get('cpu_sockets', None)),
2913
            }
2914
        else:
2915
          live_data[name] = {}
2916
    else:
2917
      live_data = dict.fromkeys(nodenames, {})
2918

    
2919
    node_to_primary = dict([(name, set()) for name in nodenames])
2920
    node_to_secondary = dict([(name, set()) for name in nodenames])
2921

    
2922
    inst_fields = frozenset(("pinst_cnt", "pinst_list",
2923
                             "sinst_cnt", "sinst_list"))
2924
    if inst_fields & frozenset(self.op.output_fields):
2925
      inst_data = self.cfg.GetAllInstancesInfo()
2926

    
2927
      for inst in inst_data.values():
2928
        if inst.primary_node in node_to_primary:
2929
          node_to_primary[inst.primary_node].add(inst.name)
2930
        for secnode in inst.secondary_nodes:
2931
          if secnode in node_to_secondary:
2932
            node_to_secondary[secnode].add(inst.name)
2933

    
2934
    master_node = self.cfg.GetMasterNode()
2935

    
2936
    # end data gathering
2937

    
2938
    output = []
2939
    for node in nodelist:
2940
      node_output = []
2941
      for field in self.op.output_fields:
2942
        if field in self._SIMPLE_FIELDS:
2943
          val = getattr(node, field)
2944
        elif field == "pinst_list":
2945
          val = list(node_to_primary[node.name])
2946
        elif field == "sinst_list":
2947
          val = list(node_to_secondary[node.name])
2948
        elif field == "pinst_cnt":
2949
          val = len(node_to_primary[node.name])
2950
        elif field == "sinst_cnt":
2951
          val = len(node_to_secondary[node.name])
2952
        elif field == "pip":
2953
          val = node.primary_ip
2954
        elif field == "sip":
2955
          val = node.secondary_ip
2956
        elif field == "tags":
2957
          val = list(node.GetTags())
2958
        elif field == "master":
2959
          val = node.name == master_node
2960
        elif self._FIELDS_DYNAMIC.Matches(field):
2961
          val = live_data[node.name].get(field, None)
2962
        elif field == "role":
2963
          if node.name == master_node:
2964
            val = "M"
2965
          elif node.master_candidate:
2966
            val = "C"
2967
          elif node.drained:
2968
            val = "D"
2969
          elif node.offline:
2970
            val = "O"
2971
          else:
2972
            val = "R"
2973
        else:
2974
          raise errors.ParameterError(field)
2975
        node_output.append(val)
2976
      output.append(node_output)
2977

    
2978
    return output
2979

    
2980

    
2981
class LUQueryNodeVolumes(NoHooksLU):
2982
  """Logical unit for getting volumes on node(s).
2983

2984
  """
2985
  _OP_REQP = ["nodes", "output_fields"]
2986
  REQ_BGL = False
2987
  _FIELDS_DYNAMIC = utils.FieldSet("phys", "vg", "name", "size", "instance")
2988
  _FIELDS_STATIC = utils.FieldSet("node")
2989

    
2990
  def ExpandNames(self):
2991
    _CheckOutputFields(static=self._FIELDS_STATIC,
2992
                       dynamic=self._FIELDS_DYNAMIC,
2993
                       selected=self.op.output_fields)
2994

    
2995
    self.needed_locks = {}
2996
    self.share_locks[locking.LEVEL_NODE] = 1
2997
    if not self.op.nodes:
2998
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
2999
    else:
3000
      self.needed_locks[locking.LEVEL_NODE] = \
3001
        _GetWantedNodes(self, self.op.nodes)
3002

    
3003
  def CheckPrereq(self):
3004
    """Check prerequisites.
3005

3006
    This checks that the fields required are valid output fields.
3007

3008
    """
3009
    self.nodes = self.acquired_locks[locking.LEVEL_NODE]
3010

    
3011
  def Exec(self, feedback_fn):
3012
    """Computes the list of nodes and their attributes.
3013

3014
    """
3015
    nodenames = self.nodes
3016
    volumes = self.rpc.call_node_volumes(nodenames)
3017

    
3018
    ilist = [self.cfg.GetInstanceInfo(iname) for iname
3019
             in self.cfg.GetInstanceList()]
3020

    
3021
    lv_by_node = dict([(inst, inst.MapLVsByNode()) for inst in ilist])
3022

    
3023
    output = []
3024
    for node in nodenames:
3025
      nresult = volumes[node]
3026
      if nresult.offline:
3027
        continue
3028
      msg = nresult.fail_msg
3029
      if msg:
3030
        self.LogWarning("Can't compute volume data on node %s: %s", node, msg)
3031
        continue
3032

    
3033
      node_vols = nresult.payload[:]
3034
      node_vols.sort(key=lambda vol: vol['dev'])
3035

    
3036
      for vol in node_vols:
3037
        node_output = []
3038
        for field in self.op.output_fields:
3039
          if field == "node":
3040
            val = node
3041
          elif field == "phys":
3042
            val = vol['dev']
3043
          elif field == "vg":
3044
            val = vol['vg']
3045
          elif field == "name":
3046
            val = vol['name']
3047
          elif field == "size":
3048
            val = int(float(vol['size']))
3049
          elif field == "instance":
3050
            for inst in ilist:
3051
              if node not in lv_by_node[inst]:
3052
                continue
3053
              if vol['name'] in lv_by_node[inst][node]:
3054
                val = inst.name
3055
                break
3056
            else:
3057
              val = '-'
3058
          else:
3059
            raise errors.ParameterError(field)
3060
          node_output.append(str(val))
3061

    
3062
        output.append(node_output)
3063

    
3064
    return output
3065

    
3066

    
3067
class LUQueryNodeStorage(NoHooksLU):
3068
  """Logical unit for getting information on storage units on node(s).
3069

3070
  """
3071
  _OP_REQP = ["nodes", "storage_type", "output_fields"]
3072
  REQ_BGL = False
3073
  _FIELDS_STATIC = utils.FieldSet(constants.SF_NODE)
3074

    
3075
  def ExpandNames(self):
3076
    storage_type = self.op.storage_type
3077

    
3078
    if storage_type not in constants.VALID_STORAGE_TYPES:
3079
      raise errors.OpPrereqError("Unknown storage type: %s" % storage_type,
3080
                                 errors.ECODE_INVAL)
3081

    
3082
    _CheckOutputFields(static=self._FIELDS_STATIC,
3083
                       dynamic=utils.FieldSet(*constants.VALID_STORAGE_FIELDS),
3084
                       selected=self.op.output_fields)
3085

    
3086
    self.needed_locks = {}
3087
    self.share_locks[locking.LEVEL_NODE] = 1
3088

    
3089
    if self.op.nodes:
3090
      self.needed_locks[locking.LEVEL_NODE] = \
3091
        _GetWantedNodes(self, self.op.nodes)
3092
    else:
3093
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3094

    
3095
  def CheckPrereq(self):
3096
    """Check prerequisites.
3097

3098
    This checks that the fields required are valid output fields.
3099

3100
    """
3101
    self.op.name = getattr(self.op, "name", None)
3102

    
3103
    self.nodes = self.acquired_locks[locking.LEVEL_NODE]
3104

    
3105
  def Exec(self, feedback_fn):
3106
    """Computes the list of nodes and their attributes.
3107

3108
    """
3109
    # Always get name to sort by
3110
    if constants.SF_NAME in self.op.output_fields:
3111
      fields = self.op.output_fields[:]
3112
    else:
3113
      fields = [constants.SF_NAME] + self.op.output_fields
3114

    
3115
    # Never ask for node or type as it's only known to the LU
3116
    for extra in [constants.SF_NODE, constants.SF_TYPE]:
3117
      while extra in fields:
3118
        fields.remove(extra)
3119

    
3120
    field_idx = dict([(name, idx) for (idx, name) in enumerate(fields)])
3121
    name_idx = field_idx[constants.SF_NAME]
3122

    
3123
    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
3124
    data = self.rpc.call_storage_list(self.nodes,
3125
                                      self.op.storage_type, st_args,
3126
                                      self.op.name, fields)
3127

    
3128
    result = []
3129

    
3130
    for node in utils.NiceSort(self.nodes):
3131
      nresult = data[node]
3132
      if nresult.offline:
3133
        continue
3134

    
3135
      msg = nresult.fail_msg
3136
      if msg:
3137
        self.LogWarning("Can't get storage data from node %s: %s", node, msg)
3138
        continue
3139

    
3140
      rows = dict([(row[name_idx], row) for row in nresult.payload])
3141

    
3142
      for name in utils.NiceSort(rows.keys()):
3143
        row = rows[name]
3144

    
3145
        out = []
3146

    
3147
        for field in self.op.output_fields:
3148
          if field == constants.SF_NODE:
3149
            val = node
3150
          elif field == constants.SF_TYPE:
3151
            val = self.op.storage_type
3152
          elif field in field_idx:
3153
            val = row[field_idx[field]]
3154
          else:
3155
            raise errors.ParameterError(field)
3156

    
3157
          out.append(val)
3158

    
3159
        result.append(out)
3160

    
3161
    return result
3162

    
3163

    
3164
class LUModifyNodeStorage(NoHooksLU):
3165
  """Logical unit for modifying a storage volume on a node.
3166

3167
  """
3168
  _OP_REQP = ["node_name", "storage_type", "name", "changes"]
3169
  REQ_BGL = False
3170

    
3171
  def CheckArguments(self):
3172
    self.opnode_name = _ExpandNodeName(self.cfg, self.op.node_name)
3173

    
3174
    storage_type = self.op.storage_type
3175
    if storage_type not in constants.VALID_STORAGE_TYPES:
3176
      raise errors.OpPrereqError("Unknown storage type: %s" % storage_type,
3177
                                 errors.ECODE_INVAL)
3178

    
3179
  def ExpandNames(self):
3180
    self.needed_locks = {
3181
      locking.LEVEL_NODE: self.op.node_name,
3182
      }
3183

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

3187
    """
3188
    storage_type = self.op.storage_type
3189

    
3190
    try:
3191
      modifiable = constants.MODIFIABLE_STORAGE_FIELDS[storage_type]
3192
    except KeyError:
3193
      raise errors.OpPrereqError("Storage units of type '%s' can not be"
3194
                                 " modified" % storage_type,
3195
                                 errors.ECODE_INVAL)
3196

    
3197
    diff = set(self.op.changes.keys()) - modifiable
3198
    if diff:
3199
      raise errors.OpPrereqError("The following fields can not be modified for"
3200
                                 " storage units of type '%s': %r" %
3201
                                 (storage_type, list(diff)),
3202
                                 errors.ECODE_INVAL)
3203

    
3204
  def Exec(self, feedback_fn):
3205
    """Computes the list of nodes and their attributes.
3206

3207
    """
3208
    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
3209
    result = self.rpc.call_storage_modify(self.op.node_name,
3210
                                          self.op.storage_type, st_args,
3211
                                          self.op.name, self.op.changes)
3212
    result.Raise("Failed to modify storage unit '%s' on %s" %
3213
                 (self.op.name, self.op.node_name))
3214

    
3215

    
3216
class LUAddNode(LogicalUnit):
3217
  """Logical unit for adding node to the cluster.
3218

3219
  """
3220
  HPATH = "node-add"
3221
  HTYPE = constants.HTYPE_NODE
3222
  _OP_REQP = ["node_name"]
3223

    
3224
  def CheckArguments(self):
3225
    # validate/normalize the node name
3226
    self.op.node_name = utils.HostInfo.NormalizeName(self.op.node_name)
3227

    
3228
  def BuildHooksEnv(self):
3229
    """Build hooks env.
3230

3231
    This will run on all nodes before, and on all nodes + the new node after.
3232

3233
    """
3234
    env = {
3235
      "OP_TARGET": self.op.node_name,
3236
      "NODE_NAME": self.op.node_name,
3237
      "NODE_PIP": self.op.primary_ip,
3238
      "NODE_SIP": self.op.secondary_ip,
3239
      }
3240
    nodes_0 = self.cfg.GetNodeList()
3241
    nodes_1 = nodes_0 + [self.op.node_name, ]
3242
    return env, nodes_0, nodes_1
3243

    
3244
  def CheckPrereq(self):
3245
    """Check prerequisites.
3246

3247
    This checks:
3248
     - the new node is not already in the config
3249
     - it is resolvable
3250
     - its parameters (single/dual homed) matches the cluster
3251

3252
    Any errors are signaled by raising errors.OpPrereqError.
3253

3254
    """
3255
    node_name = self.op.node_name
3256
    cfg = self.cfg
3257

    
3258
    dns_data = utils.GetHostInfo(node_name)
3259

    
3260
    node = dns_data.name
3261
    primary_ip = self.op.primary_ip = dns_data.ip
3262
    secondary_ip = getattr(self.op, "secondary_ip", None)
3263
    if secondary_ip is None:
3264
      secondary_ip = primary_ip
3265
    if not utils.IsValidIP(secondary_ip):
3266
      raise errors.OpPrereqError("Invalid secondary IP given",
3267
                                 errors.ECODE_INVAL)
3268
    self.op.secondary_ip = secondary_ip
3269

    
3270
    node_list = cfg.GetNodeList()
3271
    if not self.op.readd and node in node_list:
3272
      raise errors.OpPrereqError("Node %s is already in the configuration" %
3273
                                 node, errors.ECODE_EXISTS)
3274
    elif self.op.readd and node not in node_list:
3275
      raise errors.OpPrereqError("Node %s is not in the configuration" % node,
3276
                                 errors.ECODE_NOENT)
3277

    
3278
    for existing_node_name in node_list:
3279
      existing_node = cfg.GetNodeInfo(existing_node_name)
3280

    
3281
      if self.op.readd and node == existing_node_name:
3282
        if (existing_node.primary_ip != primary_ip or
3283
            existing_node.secondary_ip != secondary_ip):
3284
          raise errors.OpPrereqError("Readded node doesn't have the same IP"
3285
                                     " address configuration as before",
3286
                                     errors.ECODE_INVAL)
3287
        continue
3288

    
3289
      if (existing_node.primary_ip == primary_ip or
3290
          existing_node.secondary_ip == primary_ip or
3291
          existing_node.primary_ip == secondary_ip or
3292
          existing_node.secondary_ip == secondary_ip):
3293
        raise errors.OpPrereqError("New node ip address(es) conflict with"
3294
                                   " existing node %s" % existing_node.name,
3295
                                   errors.ECODE_NOTUNIQUE)
3296

    
3297
    # check that the type of the node (single versus dual homed) is the
3298
    # same as for the master
3299
    myself = cfg.GetNodeInfo(self.cfg.GetMasterNode())
3300
    master_singlehomed = myself.secondary_ip == myself.primary_ip
3301
    newbie_singlehomed = secondary_ip == primary_ip
3302
    if master_singlehomed != newbie_singlehomed:
3303
      if master_singlehomed:
3304
        raise errors.OpPrereqError("The master has no private ip but the"
3305
                                   " new node has one",
3306
                                   errors.ECODE_INVAL)
3307
      else:
3308
        raise errors.OpPrereqError("The master has a private ip but the"
3309
                                   " new node doesn't have one",
3310
                                   errors.ECODE_INVAL)
3311

    
3312
    # checks reachability
3313
    if not utils.TcpPing(primary_ip, constants.DEFAULT_NODED_PORT):
3314
      raise errors.OpPrereqError("Node not reachable by ping",
3315
                                 errors.ECODE_ENVIRON)
3316

    
3317
    if not newbie_singlehomed:
3318
      # check reachability from my secondary ip to newbie's secondary ip
3319
      if not utils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,
3320
                           source=myself.secondary_ip):
3321
        raise errors.OpPrereqError("Node secondary ip not reachable by TCP"
3322
                                   " based ping to noded port",
3323
                                   errors.ECODE_ENVIRON)
3324

    
3325
    if self.op.readd:
3326
      exceptions = [node]
3327
    else:
3328
      exceptions = []
3329

    
3330
    self.master_candidate = _DecideSelfPromotion(self, exceptions=exceptions)
3331

    
3332
    if self.op.readd:
3333
      self.new_node = self.cfg.GetNodeInfo(node)
3334
      assert self.new_node is not None, "Can't retrieve locked node %s" % node
3335
    else:
3336
      self.new_node = objects.Node(name=node,
3337
                                   primary_ip=primary_ip,
3338
                                   secondary_ip=secondary_ip,
3339
                                   master_candidate=self.master_candidate,
3340
                                   offline=False, drained=False)
3341

    
3342
  def Exec(self, feedback_fn):
3343
    """Adds the new node to the cluster.
3344

3345
    """
3346
    new_node = self.new_node
3347
    node = new_node.name
3348

    
3349
    # for re-adds, reset the offline/drained/master-candidate flags;
3350
    # we need to reset here, otherwise offline would prevent RPC calls
3351
    # later in the procedure; this also means that if the re-add
3352
    # fails, we are left with a non-offlined, broken node
3353
    if self.op.readd:
3354
      new_node.drained = new_node.offline = False # pylint: disable-msg=W0201
3355
      self.LogInfo("Readding a node, the offline/drained flags were reset")
3356
      # if we demote the node, we do cleanup later in the procedure
3357
      new_node.master_candidate = self.master_candidate
3358

    
3359
    # notify the user about any possible mc promotion
3360
    if new_node.master_candidate:
3361
      self.LogInfo("Node will be a master candidate")
3362

    
3363
    # check connectivity
3364
    result = self.rpc.call_version([node])[node]
3365
    result.Raise("Can't get version information from node %s" % node)
3366
    if constants.PROTOCOL_VERSION == result.payload:
3367
      logging.info("Communication to node %s fine, sw version %s match",
3368
                   node, result.payload)
3369
    else:
3370
      raise errors.OpExecError("Version mismatch master version %s,"
3371
                               " node version %s" %
3372
                               (constants.PROTOCOL_VERSION, result.payload))
3373

    
3374
    # setup ssh on node
3375
    if self.cfg.GetClusterInfo().modify_ssh_setup:
3376
      logging.info("Copy ssh key to node %s", node)
3377
      priv_key, pub_key, _ = ssh.GetUserFiles(constants.GANETI_RUNAS)
3378
      keyarray = []
3379
      keyfiles = [constants.SSH_HOST_DSA_PRIV, constants.SSH_HOST_DSA_PUB,
3380
                  constants.SSH_HOST_RSA_PRIV, constants.SSH_HOST_RSA_PUB,
3381
                  priv_key, pub_key]
3382

    
3383
      for i in keyfiles:
3384
        keyarray.append(utils.ReadFile(i))
3385

    
3386
      result = self.rpc.call_node_add(node, keyarray[0], keyarray[1],
3387
                                      keyarray[2], keyarray[3], keyarray[4],
3388
                                      keyarray[5])
3389
      result.Raise("Cannot transfer ssh keys to the new node")
3390

    
3391
    # Add node to our /etc/hosts, and add key to known_hosts
3392
    if self.cfg.GetClusterInfo().modify_etc_hosts:
3393
      utils.AddHostToEtcHosts(new_node.name)
3394

    
3395
    if new_node.secondary_ip != new_node.primary_ip:
3396
      result = self.rpc.call_node_has_ip_address(new_node.name,
3397
                                                 new_node.secondary_ip)
3398
      result.Raise("Failure checking secondary ip on node %s" % new_node.name,
3399
                   prereq=True, ecode=errors.ECODE_ENVIRON)
3400
      if not result.payload:
3401
        raise errors.OpExecError("Node claims it doesn't have the secondary ip"
3402
                                 " you gave (%s). Please fix and re-run this"
3403
                                 " command." % new_node.secondary_ip)
3404

    
3405
    node_verify_list = [self.cfg.GetMasterNode()]
3406
    node_verify_param = {
3407
      constants.NV_NODELIST: [node],
3408
      # TODO: do a node-net-test as well?
3409
    }
3410

    
3411
    result = self.rpc.call_node_verify(node_verify_list, node_verify_param,
3412
                                       self.cfg.GetClusterName())
3413
    for verifier in node_verify_list:
3414
      result[verifier].Raise("Cannot communicate with node %s" % verifier)
3415
      nl_payload = result[verifier].payload[constants.NV_NODELIST]
3416
      if nl_payload:
3417
        for failed in nl_payload:
3418
          feedback_fn("ssh/hostname verification failed"
3419
                      " (checking from %s): %s" %
3420
                      (verifier, nl_payload[failed]))
3421
        raise errors.OpExecError("ssh/hostname verification failed.")
3422

    
3423
    if self.op.readd:
3424
      _RedistributeAncillaryFiles(self)
3425
      self.context.ReaddNode(new_node)
3426
      # make sure we redistribute the config
3427
      self.cfg.Update(new_node, feedback_fn)
3428
      # and make sure the new node will not have old files around
3429
      if not new_node.master_candidate:
3430
        result = self.rpc.call_node_demote_from_mc(new_node.name)
3431
        msg = result.fail_msg
3432
        if msg:
3433
          self.LogWarning("Node failed to demote itself from master"
3434
                          " candidate status: %s" % msg)
3435
    else:
3436
      _RedistributeAncillaryFiles(self, additional_nodes=[node])
3437
      self.context.AddNode(new_node, self.proc.GetECId())
3438

    
3439

    
3440
class LUSetNodeParams(LogicalUnit):
3441
  """Modifies the parameters of a node.
3442

3443
  """
3444
  HPATH = "node-modify"
3445
  HTYPE = constants.HTYPE_NODE
3446
  _OP_REQP = ["node_name"]
3447
  REQ_BGL = False
3448

    
3449
  def CheckArguments(self):
3450
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3451
    _CheckBooleanOpField(self.op, 'master_candidate')
3452
    _CheckBooleanOpField(self.op, 'offline')
3453
    _CheckBooleanOpField(self.op, 'drained')
3454
    _CheckBooleanOpField(self.op, 'auto_promote')
3455
    all_mods = [self.op.offline, self.op.master_candidate, self.op.drained]
3456
    if all_mods.count(None) == 3:
3457
      raise errors.OpPrereqError("Please pass at least one modification",
3458
                                 errors.ECODE_INVAL)
3459
    if all_mods.count(True) > 1:
3460
      raise errors.OpPrereqError("Can't set the node into more than one"
3461
                                 " state at the same time",
3462
                                 errors.ECODE_INVAL)
3463

    
3464
    # Boolean value that tells us whether we're offlining or draining the node
3465
    self.offline_or_drain = (self.op.offline == True or
3466
                             self.op.drained == True)
3467
    self.deoffline_or_drain = (self.op.offline == False or
3468
                               self.op.drained == False)
3469
    self.might_demote = (self.op.master_candidate == False or
3470
                         self.offline_or_drain)
3471

    
3472
    self.lock_all = self.op.auto_promote and self.might_demote
3473

    
3474

    
3475
  def ExpandNames(self):
3476
    if self.lock_all:
3477
      self.needed_locks = {locking.LEVEL_NODE: locking.ALL_SET}
3478
    else:
3479
      self.needed_locks = {locking.LEVEL_NODE: self.op.node_name}
3480

    
3481
  def BuildHooksEnv(self):
3482
    """Build hooks env.
3483

3484
    This runs on the master node.
3485

3486
    """
3487
    env = {
3488
      "OP_TARGET": self.op.node_name,
3489
      "MASTER_CANDIDATE": str(self.op.master_candidate),
3490
      "OFFLINE": str(self.op.offline),
3491
      "DRAINED": str(self.op.drained),
3492
      }
3493
    nl = [self.cfg.GetMasterNode(),
3494
          self.op.node_name]
3495
    return env, nl, nl
3496

    
3497
  def CheckPrereq(self):
3498
    """Check prerequisites.
3499

3500
    This only checks the instance list against the existing names.
3501

3502
    """
3503
    node = self.node = self.cfg.GetNodeInfo(self.op.node_name)
3504

    
3505
    if (self.op.master_candidate is not None or
3506
        self.op.drained is not None or
3507
        self.op.offline is not None):
3508
      # we can't change the master's node flags
3509
      if self.op.node_name == self.cfg.GetMasterNode():
3510
        raise errors.OpPrereqError("The master role can be changed"
3511
                                   " only via masterfailover",
3512
                                   errors.ECODE_INVAL)
3513

    
3514

    
3515
    if node.master_candidate and self.might_demote and not self.lock_all:
3516
      assert not self.op.auto_promote, "auto-promote set but lock_all not"
3517
      # check if after removing the current node, we're missing master
3518
      # candidates
3519
      (mc_remaining, mc_should, _) = \
3520
          self.cfg.GetMasterCandidateStats(exceptions=[node.name])
3521
      if mc_remaining < mc_should:
3522
        raise errors.OpPrereqError("Not enough master candidates, please"
3523
                                   " pass auto_promote to allow promotion",
3524
                                   errors.ECODE_INVAL)
3525

    
3526
    if (self.op.master_candidate == True and
3527
        ((node.offline and not self.op.offline == False) or
3528
         (node.drained and not self.op.drained == False))):
3529
      raise errors.OpPrereqError("Node '%s' is offline or drained, can't set"
3530
                                 " to master_candidate" % node.name,
3531
                                 errors.ECODE_INVAL)
3532

    
3533
    # If we're being deofflined/drained, we'll MC ourself if needed
3534
    if (self.deoffline_or_drain and not self.offline_or_drain and not
3535
        self.op.master_candidate == True and not node.master_candidate):
3536
      self.op.master_candidate = _DecideSelfPromotion(self)
3537
      if self.op.master_candidate:
3538
        self.LogInfo("Autopromoting node to master candidate")
3539

    
3540
    return
3541

    
3542
  def Exec(self, feedback_fn):
3543
    """Modifies a node.
3544

3545
    """
3546
    node = self.node
3547

    
3548
    result = []
3549
    changed_mc = False
3550

    
3551
    if self.op.offline is not None:
3552
      node.offline = self.op.offline
3553
      result.append(("offline", str(self.op.offline)))
3554
      if self.op.offline == True:
3555
        if node.master_candidate:
3556
          node.master_candidate = False
3557
          changed_mc = True
3558
          result.append(("master_candidate", "auto-demotion due to offline"))
3559
        if node.drained:
3560
          node.drained = False
3561
          result.append(("drained", "clear drained status due to offline"))
3562

    
3563
    if self.op.master_candidate is not None:
3564
      node.master_candidate = self.op.master_candidate
3565
      changed_mc = True
3566
      result.append(("master_candidate", str(self.op.master_candidate)))
3567
      if self.op.master_candidate == False:
3568
        rrc = self.rpc.call_node_demote_from_mc(node.name)
3569
        msg = rrc.fail_msg
3570
        if msg:
3571
          self.LogWarning("Node failed to demote itself: %s" % msg)
3572

    
3573
    if self.op.drained is not None:
3574
      node.drained = self.op.drained
3575
      result.append(("drained", str(self.op.drained)))
3576
      if self.op.drained == True:
3577
        if node.master_candidate:
3578
          node.master_candidate = False
3579
          changed_mc = True
3580
          result.append(("master_candidate", "auto-demotion due to drain"))
3581
          rrc = self.rpc.call_node_demote_from_mc(node.name)
3582
          msg = rrc.fail_msg
3583
          if msg:
3584
            self.LogWarning("Node failed to demote itself: %s" % msg)
3585
        if node.offline:
3586
          node.offline = False
3587
          result.append(("offline", "clear offline status due to drain"))
3588

    
3589
    # we locked all nodes, we adjust the CP before updating this node
3590
    if self.lock_all:
3591
      _AdjustCandidatePool(self, [node.name])
3592

    
3593
    # this will trigger configuration file update, if needed
3594
    self.cfg.Update(node, feedback_fn)
3595

    
3596
    # this will trigger job queue propagation or cleanup
3597
    if changed_mc:
3598
      self.context.ReaddNode(node)
3599

    
3600
    return result
3601

    
3602

    
3603
class LUPowercycleNode(NoHooksLU):
3604
  """Powercycles a node.
3605

3606
  """
3607
  _OP_REQP = ["node_name", "force"]
3608
  REQ_BGL = False
3609

    
3610
  def CheckArguments(self):
3611
    self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
3612
    if self.op.node_name == self.cfg.GetMasterNode() and not self.op.force:
3613
      raise errors.OpPrereqError("The node is the master and the force"
3614
                                 " parameter was not set",
3615
                                 errors.ECODE_INVAL)
3616

    
3617
  def ExpandNames(self):
3618
    """Locking for PowercycleNode.
3619

3620
    This is a last-resort option and shouldn't block on other
3621
    jobs. Therefore, we grab no locks.
3622

3623
    """
3624
    self.needed_locks = {}
3625

    
3626
  def CheckPrereq(self):
3627
    """Check prerequisites.
3628

3629
    This LU has no prereqs.
3630

3631
    """
3632
    pass
3633

    
3634
  def Exec(self, feedback_fn):
3635
    """Reboots a node.
3636

3637
    """
3638
    result = self.rpc.call_node_powercycle(self.op.node_name,
3639
                                           self.cfg.GetHypervisorType())
3640
    result.Raise("Failed to schedule the reboot")
3641
    return result.payload
3642

    
3643

    
3644
class LUQueryClusterInfo(NoHooksLU):
3645
  """Query cluster configuration.
3646

3647
  """
3648
  _OP_REQP = []
3649
  REQ_BGL = False
3650

    
3651
  def ExpandNames(self):
3652
    self.needed_locks = {}
3653

    
3654
  def CheckPrereq(self):
3655
    """No prerequsites needed for this LU.
3656

3657
    """
3658
    pass
3659

    
3660
  def Exec(self, feedback_fn):
3661
    """Return cluster config.
3662

3663
    """
3664
    cluster = self.cfg.GetClusterInfo()
3665
    os_hvp = {}
3666

    
3667
    # Filter just for enabled hypervisors
3668
    for os_name, hv_dict in cluster.os_hvp.items():
3669
      os_hvp[os_name] = {}
3670
      for hv_name, hv_params in hv_dict.items():
3671
        if hv_name in cluster.enabled_hypervisors:
3672
          os_hvp[os_name][hv_name] = hv_params
3673

    
3674
    result = {
3675
      "software_version": constants.RELEASE_VERSION,
3676
      "protocol_version": constants.PROTOCOL_VERSION,
3677
      "config_version": constants.CONFIG_VERSION,
3678
      "os_api_version": max(constants.OS_API_VERSIONS),
3679
      "export_version": constants.EXPORT_VERSION,
3680
      "architecture": (platform.architecture()[0], platform.machine()),
3681
      "name": cluster.cluster_name,
3682
      "master": cluster.master_node,
3683
      "default_hypervisor": cluster.enabled_hypervisors[0],
3684
      "enabled_hypervisors": cluster.enabled_hypervisors,
3685
      "hvparams": dict([(hypervisor_name, cluster.hvparams[hypervisor_name])
3686
                        for hypervisor_name in cluster.enabled_hypervisors]),
3687
      "os_hvp": os_hvp,
3688
      "beparams": cluster.beparams,
3689
      "nicparams": cluster.nicparams,
3690
      "candidate_pool_size": cluster.candidate_pool_size,
3691
      "master_netdev": cluster.master_netdev,
3692
      "volume_group_name": cluster.volume_group_name,
3693
      "file_storage_dir": cluster.file_storage_dir,
3694
      "ctime": cluster.ctime,
3695
      "mtime": cluster.mtime,
3696
      "uuid": cluster.uuid,
3697
      "tags": list(cluster.GetTags()),
3698
      }
3699

    
3700
    return result
3701

    
3702

    
3703
class LUQueryConfigValues(NoHooksLU):
3704
  """Return configuration values.
3705

3706
  """
3707
  _OP_REQP = []
3708
  REQ_BGL = False
3709
  _FIELDS_DYNAMIC = utils.FieldSet()
3710
  _FIELDS_STATIC = utils.FieldSet("cluster_name", "master_node", "drain_flag",
3711
                                  "watcher_pause")
3712

    
3713
  def ExpandNames(self):
3714
    self.needed_locks = {}
3715

    
3716
    _CheckOutputFields(static=self._FIELDS_STATIC,
3717
                       dynamic=self._FIELDS_DYNAMIC,
3718
                       selected=self.op.output_fields)
3719

    
3720
  def CheckPrereq(self):
3721
    """No prerequisites.
3722

3723
    """
3724
    pass
3725

    
3726
  def Exec(self, feedback_fn):
3727
    """Dump a representation of the cluster config to the standard output.
3728

3729
    """
3730
    values = []
3731
    for field in self.op.output_fields:
3732
      if field == "cluster_name":
3733
        entry = self.cfg.GetClusterName()
3734
      elif field == "master_node":
3735
        entry = self.cfg.GetMasterNode()
3736
      elif field == "drain_flag":
3737
        entry = os.path.exists(constants.JOB_QUEUE_DRAIN_FILE)
3738
      elif field == "watcher_pause":
3739
        entry = utils.ReadWatcherPauseFile(constants.WATCHER_PAUSEFILE)
3740
      else:
3741
        raise errors.ParameterError(field)
3742
      values.append(entry)
3743
    return values
3744

    
3745

    
3746
class LUActivateInstanceDisks(NoHooksLU):
3747
  """Bring up an instance's disks.
3748

3749
  """
3750
  _OP_REQP = ["instance_name"]
3751
  REQ_BGL = False
3752

    
3753
  def ExpandNames(self):
3754
    self._ExpandAndLockInstance()
3755
    self.needed_locks[locking.LEVEL_NODE] = []
3756
    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
3757

    
3758
  def DeclareLocks(self, level):
3759
    if level == locking.LEVEL_NODE:
3760
      self._LockInstancesNodes()
3761

    
3762
  def CheckPrereq(self):
3763
    """Check prerequisites.
3764

3765
    This checks that the instance is in the cluster.
3766

3767
    """
3768
    self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
3769
    assert self.instance is not None, \
3770
      "Cannot retrieve locked instance %s" % self.op.instance_name
3771
    _CheckNodeOnline(self, self.instance.primary_node)
3772
    if not hasattr(self.op, "ignore_size"):
3773
      self.op.ignore_size = False
3774

    
3775
  def Exec(self, feedback_fn):
3776
    """Activate the disks.
3777

3778
    """
3779
    disks_ok, disks_info = \
3780
              _AssembleInstanceDisks(self, self.instance,
3781
                                     ignore_size=self.op.ignore_size)
3782
    if not disks_ok:
3783
      raise errors.OpExecError("Cannot activate block devices")
3784

    
3785
    return disks_info
3786

    
3787

    
3788
def _AssembleInstanceDisks(lu, instance, ignore_secondaries=False,
3789
                           ignore_size=False):
3790
  """Prepare the block devices for an instance.
3791

3792
  This sets up the block devices on all nodes.
3793

3794
  @type lu: L{LogicalUnit}
3795
  @param lu: the logical unit on whose behalf we execute
3796
  @type instance: L{objects.Instance}
3797
  @param instance: the instance for whose disks we assemble
3798
  @type ignore_secondaries: boolean
3799
  @param ignore_secondaries: if true, errors on secondary nodes
3800
      won't result in an error return from the function
3801
  @type ignore_size: boolean
3802
  @param ignore_size: if true, the current known size of the disk
3803
      will not be used during the disk activation, useful for cases
3804
      when the size is wrong
3805
  @return: False if the operation failed, otherwise a list of
3806
      (host, instance_visible_name, node_visible_name)
3807
      with the mapping from node devices to instance devices
3808

3809
  """
3810
  device_info = []
3811
  disks_ok = True
3812
  iname = instance.name
3813
  # With the two passes mechanism we try to reduce the window of
3814
  # opportunity for the race condition of switching DRBD to primary
3815
  # before handshaking occured, but we do not eliminate it
3816

    
3817
  # The proper fix would be to wait (with some limits) until the
3818
  # connection has been made and drbd transitions from WFConnection
3819
  # into any other network-connected state (Connected, SyncTarget,
3820
  # SyncSource, etc.)
3821

    
3822
  # 1st pass, assemble on all nodes in secondary mode
3823
  for inst_disk in instance.disks:
3824
    for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):
3825
      if ignore_size:
3826
        node_disk = node_disk.Copy()
3827
        node_disk.UnsetSize()
3828
      lu.cfg.SetDiskID(node_disk, node)
3829
      result = lu.rpc.call_blockdev_assemble(node, node_disk, iname, False)
3830
      msg = result.fail_msg
3831
      if msg:
3832
        lu.proc.LogWarning("Could not prepare block device %s on node %s"
3833
                           " (is_primary=False, pass=1): %s",
3834
                           inst_disk.iv_name, node, msg)
3835
        if not ignore_secondaries:
3836
          disks_ok = False
3837

    
3838
  # FIXME: race condition on drbd migration to primary
3839

    
3840
  # 2nd pass, do only the primary node
3841
  for inst_disk in instance.disks:
3842
    dev_path = None
3843

    
3844
    for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):
3845
      if node != instance.primary_node:
3846
        continue
3847
      if ignore_size:
3848
        node_disk = node_disk.Copy()
3849
        node_disk.UnsetSize()
3850
      lu.cfg.SetDiskID(node_disk, node)
3851
      result = lu.rpc.call_blockdev_assemble(node, node_disk, iname, True)
3852
      msg = result.fail_msg
3853
      if msg:
3854
        lu.proc.LogWarning("Could not prepare block device %s on node %s"
3855
                           " (is_primary=True, pass=2): %s",
3856
                           inst_disk.iv_name, node, msg)
3857
        disks_ok = False
3858
      else:
3859
        dev_path = result.payload
3860

    
3861
    device_info.append((instance.primary_node, inst_disk.iv_name, dev_path))
3862

    
3863
  # leave the disks configured for the primary node
3864
  # this is a workaround that would be fixed better by
3865
  # improving the logical/physical id handling
3866
  for disk in instance.disks:
3867
    lu.cfg.SetDiskID(disk, instance.primary_node)
3868

    
3869
  return disks_ok, device_info
3870

    
3871

    
3872
def _StartInstanceDisks(lu, instance, force):
3873
  """Start the disks of an instance.
3874

3875
  """
3876
  disks_ok, _ = _AssembleInstanceDisks(lu, instance,
3877
                                           ignore_secondaries=force)
3878
  if not disks_ok:
3879
    _ShutdownInstanceDisks(lu, instance)
3880
    if force is not None and not force:
3881
      lu.proc.LogWarning("", hint="If the message above refers to a"
3882
                         " secondary node,"
3883
                         " you can retry the operation using '--force'.")
3884
    raise errors.OpExecError("Disk consistency error")
3885

    
3886

    
3887
class LUDeactivateInstanceDisks(NoHooksLU):
3888
  """Shutdown an instance's disks.
3889

3890
  """
3891
  _OP_REQP = ["instance_name"]
3892
  REQ_BGL = False
3893

    
3894
  def ExpandNames(self):
3895
    self._ExpandAndLockInstance()
3896
    self.needed_locks[locking.LEVEL_NODE] = []
3897
    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
3898

    
3899
  def DeclareLocks(self, level):
3900
    if level == locking.LEVEL_NODE:
3901
      self._LockInstancesNodes()
3902

    
3903
  def CheckPrereq(self):
3904
    """Check prerequisites.
3905

3906
    This checks that the instance is in the cluster.
3907

3908
    """
3909
    self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
3910
    assert self.instance is not None, \
3911
      "Cannot retrieve locked instance %s" % self.op.instance_name
3912

    
3913
  def Exec(self, feedback_fn):
3914
    """Deactivate the disks
3915

3916
    """
3917
    instance = self.instance
3918
    _SafeShutdownInstanceDisks(self, instance)
3919

    
3920

    
3921
def _SafeShutdownInstanceDisks(lu, instance):
3922
  """Shutdown block devices of an instance.
3923

3924
  This function checks if an instance is running, before calling
3925
  _ShutdownInstanceDisks.
3926

3927
  """
3928
  _CheckInstanceDown(lu, instance, "cannot shutdown disks")
3929
  _ShutdownInstanceDisks(lu, instance)
3930

    
3931

    
3932
def _ShutdownInstanceDisks(lu, instance, ignore_primary=False):
3933
  """Shutdown block devices of an instance.
3934

3935
  This does the shutdown on all nodes of the instance.
3936

3937
  If the ignore_primary is false, errors on the primary node are
3938
  ignored.
3939

3940
  """
3941
  all_result = True
3942
  for disk in instance.disks:
3943
    for node, top_disk in disk.ComputeNodeTree(instance.primary_node):
3944
      lu.cfg.SetDiskID(top_disk, node)
3945
      result = lu.rpc.call_blockdev_shutdown(node, top_disk)
3946
      msg = result.fail_msg
3947
      if msg:
3948
        lu.LogWarning("Could not shutdown block device %s on node %s: %s",
3949
                      disk.iv_name, node, msg)
3950
        if not ignore_primary or node != instance.primary_node:
3951
          all_result = False
3952
  return all_result
3953

    
3954

    
3955
def _CheckNodeFreeMemory(lu, node, reason, requested, hypervisor_name):
3956
  """Checks if a node has enough free memory.
3957

3958
  This function check if a given node has the needed amount of free
3959
  memory. In case the node has less memory or we cannot get the
3960
  information from the node, this function raise an OpPrereqError
3961
  exception.
3962

3963
  @type lu: C{LogicalUnit}
3964
  @param lu: a logical unit from which we get configuration data
3965
  @type node: C{str}
3966
  @param node: the node to check
3967
  @type reason: C{str}
3968
  @param reason: string to use in the error message
3969
  @type requested: C{int}
3970
  @param requested: the amount of memory in MiB to check for
3971
  @type hypervisor_name: C{str}
3972
  @param hypervisor_name: the hypervisor to ask for memory stats
3973
  @raise errors.OpPrereqError: if the node doesn't have enough memory, or
3974
      we cannot check the node
3975

3976
  """
3977
  nodeinfo = lu.rpc.call_node_info([node], lu.cfg.GetVGName(), hypervisor_name)
3978
  nodeinfo[node].Raise("Can't get data from node %s" % node,
3979
                       prereq=True, ecode=errors.ECODE_ENVIRON)
3980
  free_mem = nodeinfo[node].payload.get('memory_free', None)
3981
  if not isinstance(free_mem, int):
3982
    raise errors.OpPrereqError("Can't compute free memory on node %s, result"
3983
                               " was '%s'" % (node, free_mem),
3984
                               errors.ECODE_ENVIRON)
3985
  if requested > free_mem:
3986
    raise errors.OpPrereqError("Not enough memory on node %s for %s:"
3987
                               " needed %s MiB, available %s MiB" %
3988
                               (node, reason, requested, free_mem),
3989
                               errors.ECODE_NORES)
3990

    
3991

    
3992
def _CheckNodesFreeDisk(lu, nodenames, requested):
3993
  """Checks if nodes have enough free disk space in the default VG.
3994

3995
  This function check if all given nodes have the needed amount of
3996
  free disk. In case any node has less disk or we cannot get the
3997
  information from the node, this function raise an OpPrereqError
3998
  exception.
3999

4000
  @type lu: C{LogicalUnit}
4001
  @param lu: a logical unit from which we get configuration data
4002
  @type nodenames: C{list}
4003
  @param nodenames: the list of node names to check
4004
  @type requested: C{int}
4005
  @param requested: the amount of disk in MiB to check for
4006
  @raise errors.OpPrereqError: if the node doesn't have enough disk, or
4007
      we cannot check the node
4008

4009
  """
4010
  nodeinfo = lu.rpc.call_node_info(nodenames, lu.cfg.GetVGName(),
4011
                                   lu.cfg.GetHypervisorType())
4012
  for node in nodenames:
4013
    info = nodeinfo[node]
4014
    info.Raise("Cannot get current information from node %s" % node,
4015
               prereq=True, ecode=errors.ECODE_ENVIRON)
4016
    vg_free = info.payload.get("vg_free", None)
4017
    if not isinstance(vg_free, int):
4018
      raise errors.OpPrereqError("Can't compute free disk space on node %s,"
4019
                                 " result was '%s'" % (node, vg_free),
4020
                                 errors.ECODE_ENVIRON)
4021
    if requested > vg_free:
4022
      raise errors.OpPrereqError("Not enough disk space on target node %s:"
4023
                                 " required %d MiB, available %d MiB" %
4024
                                 (node, requested, vg_free),
4025
                                 errors.ECODE_NORES)
4026

    
4027

    
4028
class LUStartupInstance(LogicalUnit):
4029
  """Starts an instance.
4030