/lib/cmdlib.py - snf-ganeti - Greek Research and Technology Network's projects

| Branch: | Tag: | Revision:

root / lib / cmdlib.py @ 9b64e486

History | View | Annotate | Download (405.7 kB)

+      #
+      #
       # Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Google Inc.
+      #
       # This program is free software; you can redistribute it and/or modify
       # it under the terms of the GNU General Public License as published by
       # the Free Software Foundation; either version 2 of the License, or
       # (at your option) any later version.
+      #
       # This program is distributed in the hope that it will be useful, but
       # WITHOUT ANY WARRANTY; without even the implied warranty of
       # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
       # General Public License for more details.
+      #
       # You should have received a copy of the GNU General Public License
       # along with this program; if not, write to the Free Software
       # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
       # 02110-1301, USA.
       """Module implementing the master-side code."""
       # pylint: disable-msg=W0201,C0302
       # W0201 since most LU attributes are defined in CheckPrereq or similar
       # functions
       # C0302: since we have waaaay to many lines in this module
       import os
       import os.path
       import time
       import re
       import platform
       import logging
       import copy
       import OpenSSL
       import socket
       import tempfile
       import shutil
       import itertools
       from ganeti import ssh
       from ganeti import utils
       from ganeti import errors
       from ganeti import hypervisor
       from ganeti import locking
       from ganeti import constants
       from ganeti import objects
       from ganeti import serializer
       from ganeti import ssconf
       from ganeti import uidpool
       from ganeti import compat
       from ganeti import masterd
       from ganeti import netutils
       from ganeti import query
       from ganeti import qlang
       from ganeti import opcodes
       import ganeti.masterd.instance # pylint: disable-msg=W0611
       def _SupportsOob(cfg, node):
         """Tells if node supports OOB.
         @type cfg: L{config.ConfigWriter}
         @param cfg: The cluster configuration
         @type node: L{objects.Node}
         @param node: The node
         @return: The OOB script if supported or an empty string otherwise
         """
         return cfg.GetNdParams(node)[constants.ND_OOB_PROGRAM]
       # End types
       class LogicalUnit(object):
         """Logical Unit base class.
         Subclasses must follow these rules:
           - implement ExpandNames
           - implement CheckPrereq (except when tasklets are used)
           - implement Exec (except when tasklets are used)
           - implement BuildHooksEnv
           - redefine HPATH and HTYPE
           - optionally redefine their run requirements:
               REQ_BGL: the LU needs to hold the Big Ganeti Lock exclusively
         Note that all commands require root permissions.
         @ivar dry_run_result: the value (if any) that will be returned to the caller
             in dry-run mode (signalled by opcode dry_run parameter)
         """
         HPATH = None
         HTYPE = None
         REQ_BGL = True
         def __init__(self, processor, op, context, rpc):
           """Constructor for LogicalUnit.
           This needs to be overridden in derived classes in order to check op
           validity.
           """
           self.proc = processor
           self.op = op
           self.cfg = context.cfg
           self.context = context
           self.rpc = rpc
           # Dicts used to declare locking needs to mcpu
           self.needed_locks = None
           self.acquired_locks = {}
           self.share_locks = dict.fromkeys(locking.LEVELS, 0)
           self.add_locks = {}
           self.remove_locks = {}
           # Used to force good behavior when calling helper functions
           self.recalculate_locks = {}
           self.__ssh = None
           # logging
           self.Log = processor.Log # pylint: disable-msg=C0103
           self.LogWarning = processor.LogWarning # pylint: disable-msg=C0103
           self.LogInfo = processor.LogInfo # pylint: disable-msg=C0103
           self.LogStep = processor.LogStep # pylint: disable-msg=C0103
           # support for dry-run
           self.dry_run_result = None
           # support for generic debug attribute
           if (not hasattr(self.op, "debug_level") or
               not isinstance(self.op.debug_level, int)):
             self.op.debug_level = 0
           # Tasklets
           self.tasklets = None
           # Validate opcode parameters and set defaults
           self.op.Validate(True)
           self.CheckArguments()
         def __GetSSH(self):
           """Returns the SshRunner object
           """
           if not self.__ssh:
             self.__ssh = ssh.SshRunner(self.cfg.GetClusterName())
           return self.__ssh
         ssh = property(fget=__GetSSH)
         def CheckArguments(self):
           """Check syntactic validity for the opcode arguments.
           This method is for doing a simple syntactic check and ensure
           validity of opcode parameters, without any cluster-related
           checks. While the same can be accomplished in ExpandNames and/or
           CheckPrereq, doing these separate is better because:
             - ExpandNames is left as as purely a lock-related function
             - CheckPrereq is run after we have acquired locks (and possible
               waited for them)
           The function is allowed to change the self.op attribute so that
           later methods can no longer worry about missing parameters.
           """
           pass
         def ExpandNames(self):
           """Expand names for this LU.
           This method is called before starting to execute the opcode, and it should
           update all the parameters of the opcode to their canonical form (e.g. a
           short node name must be fully expanded after this method has successfully
           completed). This way locking, hooks, logging, etc. can work correctly.
           LUs which implement this method must also populate the self.needed_locks
           member, as a dict with lock levels as keys, and a list of needed lock names
           as values. Rules:
             - use an empty dict if you don't need any lock
             - if you don't need any lock at a particular level omit that level
             - don't put anything for the BGL level
             - if you want all locks at a level use locking.ALL_SET as a value
           If you need to share locks (rather than acquire them exclusively) at one
           level you can modify self.share_locks, setting a true value (usually 1) for
           that level. By default locks are not shared.
           This function can also define a list of tasklets, which then will be
           executed in order instead of the usual LU-level CheckPrereq and Exec
           functions, if those are not defined by the LU.
           Examples::
             # Acquire all nodes and one instance
             self.needed_locks = {
               locking.LEVEL_NODE: locking.ALL_SET,
               locking.LEVEL_INSTANCE: ['instance1.example.com'],
+            }
             # Acquire just two nodes
             self.needed_locks = {
               locking.LEVEL_NODE: ['node1.example.com', 'node2.example.com'],
+            }
             # Acquire no locks
             self.needed_locks = {} # No, you can't leave it to the default value None
           """
           # The implementation of this method is mandatory only if the new LU is
           # concurrent, so that old LUs don't need to be changed all at the same
           # time.
           if self.REQ_BGL:
             self.needed_locks = {} # Exclusive LUs don't need locks.
           else:
             raise NotImplementedError
         def DeclareLocks(self, level):
           """Declare LU locking needs for a level
           While most LUs can just declare their locking needs at ExpandNames time,
           sometimes there's the need to calculate some locks after having acquired
           the ones before. This function is called just before acquiring locks at a
           particular level, but after acquiring the ones at lower levels, and permits
           such calculations. It can be used to modify self.needed_locks, and by
           default it does nothing.
           This function is only called if you have something already set in
           self.needed_locks for the level.
           @param level: Locking level which is going to be locked
           @type level: member of ganeti.locking.LEVELS
           """
         def CheckPrereq(self):
           """Check prerequisites for this LU.
           This method should check that the prerequisites for the execution
           of this LU are fulfilled. It can do internode communication, but
           it should be idempotent - no cluster or system changes are
           allowed.
           The method should raise errors.OpPrereqError in case something is
           not fulfilled. Its return value is ignored.
           This method should also update all the parameters of the opcode to
           their canonical form if it hasn't been done by ExpandNames before.
           """
           if self.tasklets is not None:
             for (idx, tl) in enumerate(self.tasklets):
               logging.debug("Checking prerequisites for tasklet %s/%s",
                             idx + 1, len(self.tasklets))
               tl.CheckPrereq()
           else:
             pass
         def Exec(self, feedback_fn):
           """Execute the LU.
           This method should implement the actual work. It should raise
           errors.OpExecError for failures that are somewhat dealt with in
           code, or expected.
           """
           if self.tasklets is not None:
             for (idx, tl) in enumerate(self.tasklets):
               logging.debug("Executing tasklet %s/%s", idx + 1, len(self.tasklets))
               tl.Exec(feedback_fn)
           else:
             raise NotImplementedError
         def BuildHooksEnv(self):
           """Build hooks environment for this LU.
           This method should return a three-node tuple consisting of: a dict
           containing the environment that will be used for running the
           specific hook for this LU, a list of node names on which the hook
           should run before the execution, and a list of node names on which
           the hook should run after the execution.
           The keys of the dict must not have 'GANETI_' prefixed as this will
           be handled in the hooks runner. Also note additional keys will be
           added by the hooks runner. If the LU doesn't define any
           environment, an empty dict (and not None) should be returned.
           No nodes should be returned as an empty list (and not None).
           Note that if the HPATH for a LU class is None, this function will
           not be called.
           """
           raise NotImplementedError
         def HooksCallBack(self, phase, hook_results, feedback_fn, lu_result):
           """Notify the LU about the results of its hooks.
           This method is called every time a hooks phase is executed, and notifies
           the Logical Unit about the hooks' result. The LU can then use it to alter
           its result based on the hooks.  By default the method does nothing and the
           previous result is passed back unchanged but any LU can define it if it
           wants to use the local cluster hook-scripts somehow.
           @param phase: one of L{constants.HOOKS_PHASE_POST} or
               L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
           @param hook_results: the results of the multi-node hooks rpc call
           @param feedback_fn: function used send feedback back to the caller
           @param lu_result: the previous Exec result this LU had, or None
               in the PRE phase
           @return: the new Exec result, based on the previous result
               and hook results
           """
           # API must be kept, thus we ignore the unused argument and could
           # be a function warnings
           # pylint: disable-msg=W0613,R0201
           return lu_result
         def _ExpandAndLockInstance(self):
           """Helper function to expand and lock an instance.
           Many LUs that work on an instance take its name in self.op.instance_name
           and need to expand it and then declare the expanded name for locking. This
           function does it, and then updates self.op.instance_name to the expanded
           name. It also initializes needed_locks as a dict, if this hasn't been done
           before.
           """
           if self.needed_locks is None:
             self.needed_locks = {}
           else:
             assert locking.LEVEL_INSTANCE not in self.needed_locks, \
               "_ExpandAndLockInstance called with instance-level locks set"
           self.op.instance_name = _ExpandInstanceName(self.cfg,
                                                       self.op.instance_name)
           self.needed_locks[locking.LEVEL_INSTANCE] = self.op.instance_name
         def _LockInstancesNodes(self, primary_only=False):
           """Helper function to declare instances' nodes for locking.
           This function should be called after locking one or more instances to lock
           their nodes. Its effect is populating self.needed_locks[locking.LEVEL_NODE]
           with all primary or secondary nodes for instances already locked and
           present in self.needed_locks[locking.LEVEL_INSTANCE].
           It should be called from DeclareLocks, and for safety only works if
           self.recalculate_locks[locking.LEVEL_NODE] is set.
           In the future it may grow parameters to just lock some instance's nodes, or
           to just lock primaries or secondary nodes, if needed.
           If should be called in DeclareLocks in a way similar to::
             if level == locking.LEVEL_NODE:
               self._LockInstancesNodes()
           @type primary_only: boolean
           @param primary_only: only lock primary nodes of locked instances
           """
           assert locking.LEVEL_NODE in self.recalculate_locks, \
             "_LockInstancesNodes helper function called with no nodes to recalculate"
           # TODO: check if we're really been called with the instance locks held
           # For now we'll replace self.needed_locks[locking.LEVEL_NODE], but in the
           # future we might want to have different behaviors depending on the value
           # of self.recalculate_locks[locking.LEVEL_NODE]
           wanted_nodes = []
           for instance_name in self.acquired_locks[locking.LEVEL_INSTANCE]:
             instance = self.context.cfg.GetInstanceInfo(instance_name)
             wanted_nodes.append(instance.primary_node)
             if not primary_only:
               wanted_nodes.extend(instance.secondary_nodes)
           if self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_REPLACE:
             self.needed_locks[locking.LEVEL_NODE] = wanted_nodes
           elif self.recalculate_locks[locking.LEVEL_NODE] == constants.LOCKS_APPEND:
             self.needed_locks[locking.LEVEL_NODE].extend(wanted_nodes)
           del self.recalculate_locks[locking.LEVEL_NODE]
       class NoHooksLU(LogicalUnit): # pylint: disable-msg=W0223
         """Simple LU which runs no hooks.
         This LU is intended as a parent for other LogicalUnits which will
         run no hooks, in order to reduce duplicate code.
         """
         HPATH = None
         HTYPE = None
         def BuildHooksEnv(self):
           """Empty BuildHooksEnv for NoHooksLu.
           This just raises an error.
           """
           assert False, "BuildHooksEnv called for NoHooksLUs"
       class Tasklet:
         """Tasklet base class.
         Tasklets are subcomponents for LUs. LUs can consist entirely of tasklets or
         they can mix legacy code with tasklets. Locking needs to be done in the LU,
         tasklets know nothing about locks.
         Subclasses must follow these rules:
           - Implement CheckPrereq
           - Implement Exec
         """
         def __init__(self, lu):
           self.lu = lu
           # Shortcuts
           self.cfg = lu.cfg
           self.rpc = lu.rpc
         def CheckPrereq(self):
           """Check prerequisites for this tasklets.
           This method should check whether the prerequisites for the execution of
           this tasklet are fulfilled. It can do internode communication, but it
           should be idempotent - no cluster or system changes are allowed.
           The method should raise errors.OpPrereqError in case something is not
           fulfilled. Its return value is ignored.
           This method should also update all parameters to their canonical form if it
           hasn't been done before.
           """
           pass
         def Exec(self, feedback_fn):
           """Execute the tasklet.
           This method should implement the actual work. It should raise
           errors.OpExecError for failures that are somewhat dealt with in code, or
           expected.
           """
           raise NotImplementedError
       class _QueryBase:
         """Base for query utility classes.
         """
         #: Attribute holding field definitions
         FIELDS = None
         def __init__(self, names, fields, use_locking):
           """Initializes this class.
           """
           self.names = names
           self.use_locking = use_locking
           self.query = query.Query(self.FIELDS, fields)
           self.requested_data = self.query.RequestedData()
           self.do_locking = None
           self.wanted = None
         def _GetNames(self, lu, all_names, lock_level):
           """Helper function to determine names asked for in the query.
           """
           if self.do_locking:
             names = lu.acquired_locks[lock_level]
           else:
             names = all_names
           if self.wanted == locking.ALL_SET:
             assert not self.names
             # caller didn't specify names, so ordering is not important
             return utils.NiceSort(names)
           # caller specified names and we must keep the same order
           assert self.names
           assert not self.do_locking or lu.acquired_locks[lock_level]
           missing = set(self.wanted).difference(names)
           if missing:
             raise errors.OpExecError("Some items were removed before retrieving"
                                      " their data: %s" % missing)
           # Return expanded names
           return self.wanted
         @classmethod
         def FieldsQuery(cls, fields):
           """Returns list of available fields.
           @return: List of L{objects.QueryFieldDefinition}
           """
           return query.QueryFields(cls.FIELDS, fields)
         def ExpandNames(self, lu):
           """Expand names for this query.
           See L{LogicalUnit.ExpandNames}.
           """
           raise NotImplementedError()
         def DeclareLocks(self, lu, level):
           """Declare locks for this query.
           See L{LogicalUnit.DeclareLocks}.
           """
           raise NotImplementedError()
         def _GetQueryData(self, lu):
           """Collects all data for this query.
           @return: Query data object
           """
           raise NotImplementedError()
         def NewStyleQuery(self, lu):
           """Collect data and execute query.
           """
           return query.GetQueryResponse(self.query, self._GetQueryData(lu))
         def OldStyleQuery(self, lu):
           """Collect data and execute query.
           """
           return self.query.OldStyleQuery(self._GetQueryData(lu))
       def _GetWantedNodes(lu, nodes):
         """Returns list of checked and expanded node names.
         @type lu: L{LogicalUnit}
         @param lu: the logical unit on whose behalf we execute
         @type nodes: list
         @param nodes: list of node names or None for all nodes
         @rtype: list
         @return: the list of nodes, sorted
         @raise errors.ProgrammerError: if the nodes parameter is wrong type
         """
         if nodes:
           return [_ExpandNodeName(lu.cfg, name) for name in nodes]
         return utils.NiceSort(lu.cfg.GetNodeList())
       def _GetWantedInstances(lu, instances):
         """Returns list of checked and expanded instance names.
         @type lu: L{LogicalUnit}
         @param lu: the logical unit on whose behalf we execute
         @type instances: list
         @param instances: list of instance names or None for all instances
         @rtype: list
         @return: the list of instances, sorted
         @raise errors.OpPrereqError: if the instances parameter is wrong type
         @raise errors.OpPrereqError: if any of the passed instances is not found
         """
         if instances:
           wanted = [_ExpandInstanceName(lu.cfg, name) for name in instances]
         else:
           wanted = utils.NiceSort(lu.cfg.GetInstanceList())
         return wanted
       def _GetUpdatedParams(old_params, update_dict,
                             use_default=True, use_none=False):
         """Return the new version of a parameter dictionary.
         @type old_params: dict
         @param old_params: old parameters
         @type update_dict: dict
         @param update_dict: dict containing new parameter values, or
             constants.VALUE_DEFAULT to reset the parameter to its default
             value
         @param use_default: boolean
         @type use_default: whether to recognise L{constants.VALUE_DEFAULT}
             values as 'to be deleted' values
         @param use_none: boolean
         @type use_none: whether to recognise C{None} values as 'to be
             deleted' values
         @rtype: dict
         @return: the new parameter dictionary
         """
         params_copy = copy.deepcopy(old_params)
         for key, val in update_dict.iteritems():
           if ((use_default and val == constants.VALUE_DEFAULT) or
               (use_none and val is None)):
             try:
               del params_copy[key]
             except KeyError:
               pass
           else:
             params_copy[key] = val
         return params_copy
       def _CheckOutputFields(static, dynamic, selected):
         """Checks whether all selected fields are valid.
         @type static: L{utils.FieldSet}
         @param static: static fields set
         @type dynamic: L{utils.FieldSet}
         @param dynamic: dynamic fields set
         """
         f = utils.FieldSet()
         f.Extend(static)
         f.Extend(dynamic)
         delta = f.NonMatching(selected)
         if delta:
           raise errors.OpPrereqError("Unknown output fields selected: %s"
                                      % ",".join(delta), errors.ECODE_INVAL)
       def _CheckGlobalHvParams(params):
         """Validates that given hypervisor params are not global ones.
         This will ensure that instances don't get customised versions of
         global params.
         """
         used_globals = constants.HVC_GLOBALS.intersection(params)
         if used_globals:
           msg = ("The following hypervisor parameters are global and cannot"
                  " be customized at instance level, please modify them at"
                  " cluster level: %s" % utils.CommaJoin(used_globals))
           raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
       def _CheckNodeOnline(lu, node, msg=None):
         """Ensure that a given node is online.
         @param lu: the LU on behalf of which we make the check
         @param node: the node to check
         @param msg: if passed, should be a message to replace the default one
         @raise errors.OpPrereqError: if the node is offline
         """
         if msg is None:
           msg = "Can't use offline node"
         if lu.cfg.GetNodeInfo(node).offline:
           raise errors.OpPrereqError("%s: %s" % (msg, node), errors.ECODE_STATE)
       def _CheckNodeNotDrained(lu, node):
         """Ensure that a given node is not drained.
         @param lu: the LU on behalf of which we make the check
         @param node: the node to check
         @raise errors.OpPrereqError: if the node is drained
         """
         if lu.cfg.GetNodeInfo(node).drained:
           raise errors.OpPrereqError("Can't use drained node %s" % node,
                                      errors.ECODE_STATE)
       def _CheckNodeVmCapable(lu, node):
         """Ensure that a given node is vm capable.
         @param lu: the LU on behalf of which we make the check
         @param node: the node to check
         @raise errors.OpPrereqError: if the node is not vm capable
         """
         if not lu.cfg.GetNodeInfo(node).vm_capable:
           raise errors.OpPrereqError("Can't use non-vm_capable node %s" % node,
                                      errors.ECODE_STATE)
       def _CheckNodeHasOS(lu, node, os_name, force_variant):
         """Ensure that a node supports a given OS.
         @param lu: the LU on behalf of which we make the check
         @param node: the node to check
         @param os_name: the OS to query about
         @param force_variant: whether to ignore variant errors
         @raise errors.OpPrereqError: if the node is not supporting the OS
         """
         result = lu.rpc.call_os_get(node, os_name)
         result.Raise("OS '%s' not in supported OS list for node %s" %
                      (os_name, node),
                      prereq=True, ecode=errors.ECODE_INVAL)
         if not force_variant:
           _CheckOSVariant(result.payload, os_name)
       def _CheckNodeHasSecondaryIP(lu, node, secondary_ip, prereq):
         """Ensure that a node has the given secondary ip.
         @type lu: L{LogicalUnit}
         @param lu: the LU on behalf of which we make the check
         @type node: string
         @param node: the node to check
         @type secondary_ip: string
         @param secondary_ip: the ip to check
         @type prereq: boolean
         @param prereq: whether to throw a prerequisite or an execute error
         @raise errors.OpPrereqError: if the node doesn't have the ip, and prereq=True
         @raise errors.OpExecError: if the node doesn't have the ip, and prereq=False
         """
         result = lu.rpc.call_node_has_ip_address(node, secondary_ip)
         result.Raise("Failure checking secondary ip on node %s" % node,
                      prereq=prereq, ecode=errors.ECODE_ENVIRON)
         if not result.payload:
           msg = ("Node claims it doesn't have the secondary ip you gave (%s),"
                  " please fix and re-run this command" % secondary_ip)
           if prereq:
             raise errors.OpPrereqError(msg, errors.ECODE_ENVIRON)
           else:
             raise errors.OpExecError(msg)
       def _GetClusterDomainSecret():
         """Reads the cluster domain secret.
         """
         return utils.ReadOneLineFile(constants.CLUSTER_DOMAIN_SECRET_FILE,
                                      strict=True)
       def _CheckInstanceDown(lu, instance, reason):
         """Ensure that an instance is not running."""
         if instance.admin_up:
           raise errors.OpPrereqError("Instance %s is marked to be up, %s" %
                                      (instance.name, reason), errors.ECODE_STATE)
         pnode = instance.primary_node
         ins_l = lu.rpc.call_instance_list([pnode], [instance.hypervisor])[pnode]
         ins_l.Raise("Can't contact node %s for instance information" % pnode,
                     prereq=True, ecode=errors.ECODE_ENVIRON)
         if instance.name in ins_l.payload:
           raise errors.OpPrereqError("Instance %s is running, %s" %
                                      (instance.name, reason), errors.ECODE_STATE)
       def _ExpandItemName(fn, name, kind):
         """Expand an item name.
         @param fn: the function to use for expansion
         @param name: requested item name
         @param kind: text description ('Node' or 'Instance')
         @return: the resolved (full) name
         @raise errors.OpPrereqError: if the item is not found
         """
         full_name = fn(name)
         if full_name is None:
           raise errors.OpPrereqError("%s '%s' not known" % (kind, name),
                                      errors.ECODE_NOENT)
         return full_name
       def _ExpandNodeName(cfg, name):
         """Wrapper over L{_ExpandItemName} for nodes."""
         return _ExpandItemName(cfg.ExpandNodeName, name, "Node")
       def _ExpandInstanceName(cfg, name):
         """Wrapper over L{_ExpandItemName} for instance."""
         return _ExpandItemName(cfg.ExpandInstanceName, name, "Instance")
       def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,
                                 memory, vcpus, nics, disk_template, disks,
                                 bep, hvp, hypervisor_name):
         """Builds instance related env variables for hooks
         This builds the hook environment from individual variables.
         @type name: string
         @param name: the name of the instance
         @type primary_node: string
         @param primary_node: the name of the instance's primary node
         @type secondary_nodes: list
         @param secondary_nodes: list of secondary nodes as strings
         @type os_type: string
         @param os_type: the name of the instance's OS
         @type status: boolean
         @param status: the should_run status of the instance
         @type memory: string
         @param memory: the memory size of the instance
         @type vcpus: string
         @param vcpus: the count of VCPUs the instance has
         @type nics: list
         @param nics: list of tuples (ip, mac, mode, link) representing
             the NICs the instance has
         @type disk_template: string
         @param disk_template: the disk template of the instance
         @type disks: list
         @param disks: the list of (size, mode) pairs
         @type bep: dict
         @param bep: the backend parameters for the instance
         @type hvp: dict
         @param hvp: the hypervisor parameters for the instance
         @type hypervisor_name: string
         @param hypervisor_name: the hypervisor for the instance
         @rtype: dict
         @return: the hook environment for this instance
         """
         if status:
           str_status = "up"
         else:
           str_status = "down"
         env = {
           "OP_TARGET": name,
           "INSTANCE_NAME": name,
           "INSTANCE_PRIMARY": primary_node,
           "INSTANCE_SECONDARIES": " ".join(secondary_nodes),
           "INSTANCE_OS_TYPE": os_type,
           "INSTANCE_STATUS": str_status,
           "INSTANCE_MEMORY": memory,
           "INSTANCE_VCPUS": vcpus,
           "INSTANCE_DISK_TEMPLATE": disk_template,
           "INSTANCE_HYPERVISOR": hypervisor_name,
+        }
         if nics:
           nic_count = len(nics)
           for idx, (ip, mac, mode, link) in enumerate(nics):
             if ip is None:
               ip = ""
             env["INSTANCE_NIC%d_IP" % idx] = ip
             env["INSTANCE_NIC%d_MAC" % idx] = mac
             env["INSTANCE_NIC%d_MODE" % idx] = mode
             env["INSTANCE_NIC%d_LINK" % idx] = link
             if mode == constants.NIC_MODE_BRIDGED:
               env["INSTANCE_NIC%d_BRIDGE" % idx] = link
         else:
           nic_count = 0
         env["INSTANCE_NIC_COUNT"] = nic_count
         if disks:
           disk_count = len(disks)
           for idx, (size, mode) in enumerate(disks):
             env["INSTANCE_DISK%d_SIZE" % idx] = size
             env["INSTANCE_DISK%d_MODE" % idx] = mode
         else:
           disk_count = 0
         env["INSTANCE_DISK_COUNT"] = disk_count
         for source, kind in [(bep, "BE"), (hvp, "HV")]:
           for key, value in source.items():
             env["INSTANCE_%s_%s" % (kind, key)] = value
         return env
       def _NICListToTuple(lu, nics):
         """Build a list of nic information tuples.
         This list is suitable to be passed to _BuildInstanceHookEnv or as a return
         value in LUInstanceQueryData.
         @type lu:  L{LogicalUnit}
         @param lu: the logical unit on whose behalf we execute
         @type nics: list of L{objects.NIC}
         @param nics: list of nics to convert to hooks tuples
         """
         hooks_nics = []
         cluster = lu.cfg.GetClusterInfo()
         for nic in nics:
           ip = nic.ip
           mac = nic.mac
           filled_params = cluster.SimpleFillNIC(nic.nicparams)
           mode = filled_params[constants.NIC_MODE]
           link = filled_params[constants.NIC_LINK]
           hooks_nics.append((ip, mac, mode, link))
         return hooks_nics
       def _BuildInstanceHookEnvByObject(lu, instance, override=None):
         """Builds instance related env variables for hooks from an object.
         @type lu: L{LogicalUnit}
         @param lu: the logical unit on whose behalf we execute
         @type instance: L{objects.Instance}
         @param instance: the instance for which we should build the
             environment
         @type override: dict
         @param override: dictionary with key/values that will override
             our values
         @rtype: dict
         @return: the hook environment dictionary
         """
         cluster = lu.cfg.GetClusterInfo()
         bep = cluster.FillBE(instance)
         hvp = cluster.FillHV(instance)
         args = {
           'name': instance.name,
           'primary_node': instance.primary_node,
           'secondary_nodes': instance.secondary_nodes,
           'os_type': instance.os,
           'status': instance.admin_up,
           'memory': bep[constants.BE_MEMORY],
           'vcpus': bep[constants.BE_VCPUS],
           'nics': _NICListToTuple(lu, instance.nics),
           'disk_template': instance.disk_template,
           'disks': [(disk.size, disk.mode) for disk in instance.disks],
           'bep': bep,
           'hvp': hvp,
           'hypervisor_name': instance.hypervisor,
+        }
         if override:
           args.update(override)
         return _BuildInstanceHookEnv(**args) # pylint: disable-msg=W0142
       def _AdjustCandidatePool(lu, exceptions):
         """Adjust the candidate pool after node operations.
         """
         mod_list = lu.cfg.MaintainCandidatePool(exceptions)
         if mod_list:
           lu.LogInfo("Promoted nodes to master candidate role: %s",
                      utils.CommaJoin(node.name for node in mod_list))
           for name in mod_list:
             lu.context.ReaddNode(name)
         mc_now, mc_max, _ = lu.cfg.GetMasterCandidateStats(exceptions)
         if mc_now > mc_max:
           lu.LogInfo("Note: more nodes are candidates (%d) than desired (%d)" %
                      (mc_now, mc_max))
       def _DecideSelfPromotion(lu, exceptions=None):
         """Decide whether I should promote myself as a master candidate.
         """
         cp_size = lu.cfg.GetClusterInfo().candidate_pool_size
         mc_now, mc_should, _ = lu.cfg.GetMasterCandidateStats(exceptions)
         # the new node will increase mc_max with one, so:
         mc_should = min(mc_should + 1, cp_size)
         return mc_now < mc_should
       def _CheckNicsBridgesExist(lu, target_nics, target_node):
         """Check that the brigdes needed by a list of nics exist.
         """
         cluster = lu.cfg.GetClusterInfo()
         paramslist = [cluster.SimpleFillNIC(nic.nicparams) for nic in target_nics]
         brlist = [params[constants.NIC_LINK] for params in paramslist
                   if params[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED]
         if brlist:
           result = lu.rpc.call_bridges_exist(target_node, brlist)
           result.Raise("Error checking bridges on destination node '%s'" %
                        target_node, prereq=True, ecode=errors.ECODE_ENVIRON)
       def _CheckInstanceBridgesExist(lu, instance, node=None):
         """Check that the brigdes needed by an instance exist.
         """
         if node is None:
           node = instance.primary_node
         _CheckNicsBridgesExist(lu, instance.nics, node)
       def _CheckOSVariant(os_obj, name):
         """Check whether an OS name conforms to the os variants specification.
         @type os_obj: L{objects.OS}
         @param os_obj: OS object to check
         @type name: string
         @param name: OS name passed by the user, to check for validity
         """
         if not os_obj.supported_variants:
           return
         variant = objects.OS.GetVariant(name)
         if not variant:
           raise errors.OpPrereqError("OS name must include a variant",
                                      errors.ECODE_INVAL)
         if variant not in os_obj.supported_variants:
           raise errors.OpPrereqError("Unsupported OS variant", errors.ECODE_INVAL)
       def _GetNodeInstancesInner(cfg, fn):
         return [i for i in cfg.GetAllInstancesInfo().values() if fn(i)]
       def _GetNodeInstances(cfg, node_name):
         """Returns a list of all primary and secondary instances on a node.
         """
         return _GetNodeInstancesInner(cfg, lambda inst: node_name in inst.all_nodes)
       def _GetNodePrimaryInstances(cfg, node_name):
         """Returns primary instances on a node.
         """
         return _GetNodeInstancesInner(cfg,
                                       lambda inst: node_name == inst.primary_node)
       def _GetNodeSecondaryInstances(cfg, node_name):
         """Returns secondary instances on a node.
         """
         return _GetNodeInstancesInner(cfg,
                                       lambda inst: node_name in inst.secondary_nodes)
       def _GetStorageTypeArgs(cfg, storage_type):
         """Returns the arguments for a storage type.
         """
         # Special case for file storage
         if storage_type == constants.ST_FILE:
           # storage.FileStorage wants a list of storage directories
           return [[cfg.GetFileStorageDir()]]
         return []
       def _FindFaultyInstanceDisks(cfg, rpc, instance, node_name, prereq):
         faulty = []
         for dev in instance.disks:
           cfg.SetDiskID(dev, node_name)
         result = rpc.call_blockdev_getmirrorstatus(node_name, instance.disks)
         result.Raise("Failed to get disk status from node %s" % node_name,
                      prereq=prereq, ecode=errors.ECODE_ENVIRON)
         for idx, bdev_status in enumerate(result.payload):
           if bdev_status and bdev_status.ldisk_status == constants.LDS_FAULTY:
             faulty.append(idx)
         return faulty
       def _CheckIAllocatorOrNode(lu, iallocator_slot, node_slot):
         """Check the sanity of iallocator and node arguments and use the
         cluster-wide iallocator if appropriate.
         Check that at most one of (iallocator, node) is specified. If none is
         specified, then the LU's opcode's iallocator slot is filled with the
         cluster-wide default iallocator.
         @type iallocator_slot: string
         @param iallocator_slot: the name of the opcode iallocator slot
         @type node_slot: string
         @param node_slot: the name of the opcode target node slot
         """
         node = getattr(lu.op, node_slot, None)
         iallocator = getattr(lu.op, iallocator_slot, None)
         if node is not None and iallocator is not None:
           raise errors.OpPrereqError("Do not specify both, iallocator and node.",
                                      errors.ECODE_INVAL)
         elif node is None and iallocator is None:
           default_iallocator = lu.cfg.GetDefaultIAllocator()
           if default_iallocator:
             setattr(lu.op, iallocator_slot, default_iallocator)
           else:
             raise errors.OpPrereqError("No iallocator or node given and no"
                                        " cluster-wide default iallocator found."
                                        " Please specify either an iallocator or a"
                                        " node, or set a cluster-wide default"
                                        " iallocator.")
       class LUClusterPostInit(LogicalUnit):
         """Logical unit for running hooks after cluster initialization.
         """
         HPATH = "cluster-init"
         HTYPE = constants.HTYPE_CLUSTER
         def BuildHooksEnv(self):
           """Build hooks env.
           """
           env = {"OP_TARGET": self.cfg.GetClusterName()}
           mn = self.cfg.GetMasterNode()
           return env, [], [mn]
         def Exec(self, feedback_fn):
           """Nothing to do.
           """
           return True
       class LUClusterDestroy(LogicalUnit):
         """Logical unit for destroying the cluster.
         """
         HPATH = "cluster-destroy"
         HTYPE = constants.HTYPE_CLUSTER
         def BuildHooksEnv(self):
           """Build hooks env.
           """
           env = {"OP_TARGET": self.cfg.GetClusterName()}
           return env, [], []
         def CheckPrereq(self):
           """Check prerequisites.
           This checks whether the cluster is empty.
           Any errors are signaled by raising errors.OpPrereqError.
           """
           master = self.cfg.GetMasterNode()
           nodelist = self.cfg.GetNodeList()
           if len(nodelist) != 1 or nodelist[0] != master:
             raise errors.OpPrereqError("There are still %d node(s) in"
                                        " this cluster." % (len(nodelist) - 1),
                                        errors.ECODE_INVAL)
           instancelist = self.cfg.GetInstanceList()
           if instancelist:
             raise errors.OpPrereqError("There are still %d instance(s) in"
                                        " this cluster." % len(instancelist),
                                        errors.ECODE_INVAL)
         def Exec(self, feedback_fn):
           """Destroys the cluster.
           """
           master = self.cfg.GetMasterNode()
           # Run post hooks on master node before it's removed
           hm = self.proc.hmclass(self.rpc.call_hooks_runner, self)
           try:
             hm.RunPhase(constants.HOOKS_PHASE_POST, [master])
           except:
             # pylint: disable-msg=W0702
             self.LogWarning("Errors occurred running hooks on %s" % master)
           result = self.rpc.call_node_stop_master(master, False)
           result.Raise("Could not disable the master role")
           return master
       def _VerifyCertificate(filename):
         """Verifies a certificate for LUClusterVerify.
         @type filename: string
         @param filename: Path to PEM file
         """
         try:
           cert = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,
                                                  utils.ReadFile(filename))
         except Exception, err: # pylint: disable-msg=W0703
           return (LUClusterVerify.ETYPE_ERROR,
                   "Failed to load X509 certificate %s: %s" % (filename, err))
         (errcode, msg) = \
           utils.VerifyX509Certificate(cert, constants.SSL_CERT_EXPIRATION_WARN,
                                       constants.SSL_CERT_EXPIRATION_ERROR)
         if msg:
           fnamemsg = "While verifying %s: %s" % (filename, msg)
         else:
           fnamemsg = None
         if errcode is None:
           return (None, fnamemsg)
         elif errcode == utils.CERT_WARNING:
           return (LUClusterVerify.ETYPE_WARNING, fnamemsg)
         elif errcode == utils.CERT_ERROR:
           return (LUClusterVerify.ETYPE_ERROR, fnamemsg)
         raise errors.ProgrammerError("Unhandled certificate error code %r" % errcode)
       class LUClusterVerify(LogicalUnit):
         """Verifies the cluster status.
         """
         HPATH = "cluster-verify"
         HTYPE = constants.HTYPE_CLUSTER
         REQ_BGL = False
         TCLUSTER = "cluster"
         TNODE = "node"
         TINSTANCE = "instance"
         ECLUSTERCFG = (TCLUSTER, "ECLUSTERCFG")
         ECLUSTERCERT = (TCLUSTER, "ECLUSTERCERT")
         EINSTANCEBADNODE = (TINSTANCE, "EINSTANCEBADNODE")
         EINSTANCEDOWN = (TINSTANCE, "EINSTANCEDOWN")
         EINSTANCELAYOUT = (TINSTANCE, "EINSTANCELAYOUT")
         EINSTANCEMISSINGDISK = (TINSTANCE, "EINSTANCEMISSINGDISK")
         EINSTANCEFAULTYDISK = (TINSTANCE, "EINSTANCEFAULTYDISK")
         EINSTANCEWRONGNODE = (TINSTANCE, "EINSTANCEWRONGNODE")
         EINSTANCESPLITGROUPS = (TINSTANCE, "EINSTANCESPLITGROUPS")
         ENODEDRBD = (TNODE, "ENODEDRBD")
         ENODEDRBDHELPER = (TNODE, "ENODEDRBDHELPER")
         ENODEFILECHECK = (TNODE, "ENODEFILECHECK")
         ENODEHOOKS = (TNODE, "ENODEHOOKS")
         ENODEHV = (TNODE, "ENODEHV")
         ENODELVM = (TNODE, "ENODELVM")
         ENODEN1 = (TNODE, "ENODEN1")
         ENODENET = (TNODE, "ENODENET")
         ENODEOS = (TNODE, "ENODEOS")
         ENODEORPHANINSTANCE = (TNODE, "ENODEORPHANINSTANCE")
         ENODEORPHANLV = (TNODE, "ENODEORPHANLV")
         ENODERPC = (TNODE, "ENODERPC")
         ENODESSH = (TNODE, "ENODESSH")
         ENODEVERSION = (TNODE, "ENODEVERSION")
         ENODESETUP = (TNODE, "ENODESETUP")
         ENODETIME = (TNODE, "ENODETIME")
         ENODEOOBPATH = (TNODE, "ENODEOOBPATH")
         ETYPE_FIELD = "code"
         ETYPE_ERROR = "ERROR"
         ETYPE_WARNING = "WARNING"
         _HOOKS_INDENT_RE = re.compile("^", re.M)
         class NodeImage(object):
           """A class representing the logical and physical status of a node.
           @type name: string
           @ivar name: the node name to which this object refers
           @ivar volumes: a structure as returned from
               L{ganeti.backend.GetVolumeList} (runtime)
           @ivar instances: a list of running instances (runtime)
           @ivar pinst: list of configured primary instances (config)
           @ivar sinst: list of configured secondary instances (config)
           @ivar sbp: diction of {secondary-node: list of instances} of all peers
               of this node (config)
           @ivar mfree: free memory, as reported by hypervisor (runtime)
           @ivar dfree: free disk, as reported by the node (runtime)
           @ivar offline: the offline status (config)
           @type rpc_fail: boolean
           @ivar rpc_fail: whether the RPC verify call was successfull (overall,
               not whether the individual keys were correct) (runtime)
           @type lvm_fail: boolean
           @ivar lvm_fail: whether the RPC call didn't return valid LVM data
           @type hyp_fail: boolean
           @ivar hyp_fail: whether the RPC call didn't return the instance list
           @type ghost: boolean
           @ivar ghost: whether this is a known node or not (config)
           @type os_fail: boolean
           @ivar os_fail: whether the RPC call didn't return valid OS data
           @type oslist: list
           @ivar oslist: list of OSes as diagnosed by DiagnoseOS
           @type vm_capable: boolean
           @ivar vm_capable: whether the node can host instances
           """
           def __init__(self, offline=False, name=None, vm_capable=True):
             self.name = name
             self.volumes = {}
             self.instances = []
             self.pinst = []
             self.sinst = []
             self.sbp = {}
             self.mfree = 0
             self.dfree = 0
             self.offline = offline
             self.vm_capable = vm_capable
             self.rpc_fail = False
             self.lvm_fail = False
             self.hyp_fail = False
             self.ghost = False
             self.os_fail = False
             self.oslist = {}
         def ExpandNames(self):
           self.needed_locks = {
             locking.LEVEL_NODE: locking.ALL_SET,
             locking.LEVEL_INSTANCE: locking.ALL_SET,
+          }
           self.share_locks = dict.fromkeys(locking.LEVELS, 1)
         def _Error(self, ecode, item, msg, *args, **kwargs):
           """Format an error message.
           Based on the opcode's error_codes parameter, either format a
           parseable error code, or a simpler error string.
           This must be called only from Exec and functions called from Exec.
           """
           ltype = kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR)
           itype, etxt = ecode
           # first complete the msg
           if args:
             msg = msg % args
           # then format the whole message
           if self.op.error_codes:
             msg = "%s:%s:%s:%s:%s" % (ltype, etxt, itype, item, msg)
           else:
             if item:
               item = " " + item
             else:
               item = ""
             msg = "%s: %s%s: %s" % (ltype, itype, item, msg)
           # and finally report it via the feedback_fn
           self._feedback_fn("  - %s" % msg)
         def _ErrorIf(self, cond, *args, **kwargs):
           """Log an error message if the passed condition is True.
           """
           cond = bool(cond) or self.op.debug_simulate_errors
           if cond:
             self._Error(*args, **kwargs)
           # do not mark the operation as failed for WARN cases only
           if kwargs.get(self.ETYPE_FIELD, self.ETYPE_ERROR) == self.ETYPE_ERROR:
             self.bad = self.bad or cond
         def _VerifyNode(self, ninfo, nresult):
           """Perform some basic validation on data returned from a node.
             - check the result data structure is well formed and has all the
               mandatory fields
             - check ganeti version
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the results from the node
           @rtype: boolean
           @return: whether overall this call was successful (and we can expect
                reasonable values in the respose)
           """
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           # main result, nresult should be a non-empty dict
           test = not nresult or not isinstance(nresult, dict)
           _ErrorIf(test, self.ENODERPC, node,
                         "unable to verify node: no data returned")
           if test:
             return False
           # compares ganeti version
           local_version = constants.PROTOCOL_VERSION
           remote_version = nresult.get("version", None)
           test = not (remote_version and
                       isinstance(remote_version, (list, tuple)) and
                       len(remote_version) == 2)
           _ErrorIf(test, self.ENODERPC, node,
                    "connection to node returned invalid data")
           if test:
             return False
           test = local_version != remote_version[0]
           _ErrorIf(test, self.ENODEVERSION, node,
                    "incompatible protocol versions: master %s,"
                    " node %s", local_version, remote_version[0])
           if test:
             return False
           # node seems compatible, we can actually try to look into its results
           # full package version
           self._ErrorIf(constants.RELEASE_VERSION != remote_version[1],
                         self.ENODEVERSION, node,
                         "software version mismatch: master %s, node %s",
                         constants.RELEASE_VERSION, remote_version[1],
                         code=self.ETYPE_WARNING)
           hyp_result = nresult.get(constants.NV_HYPERVISOR, None)
           if ninfo.vm_capable and isinstance(hyp_result, dict):
             for hv_name, hv_result in hyp_result.iteritems():
               test = hv_result is not None
               _ErrorIf(test, self.ENODEHV, node,
                        "hypervisor %s verify failure: '%s'", hv_name, hv_result)
           hvp_result = nresult.get(constants.NV_HVPARAMS, None)
           if ninfo.vm_capable and isinstance(hvp_result, list):
             for item, hv_name, hv_result in hvp_result:
               _ErrorIf(True, self.ENODEHV, node,
                        "hypervisor %s parameter verify failure (source %s): %s",
                        hv_name, item, hv_result)
           test = nresult.get(constants.NV_NODESETUP,
                                  ["Missing NODESETUP results"])
           _ErrorIf(test, self.ENODESETUP, node, "node setup error: %s",
                    "; ".join(test))
           return True
         def _VerifyNodeTime(self, ninfo, nresult,
                             nvinfo_starttime, nvinfo_endtime):
           """Check the node time.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           @param nvinfo_starttime: the start time of the RPC call
           @param nvinfo_endtime: the end time of the RPC call
           """
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           ntime = nresult.get(constants.NV_TIME, None)
           try:
             ntime_merged = utils.MergeTime(ntime)
           except (ValueError, TypeError):
             _ErrorIf(True, self.ENODETIME, node, "Node returned invalid time")
             return
           if ntime_merged < (nvinfo_starttime - constants.NODE_MAX_CLOCK_SKEW):
             ntime_diff = "%.01fs" % abs(nvinfo_starttime - ntime_merged)
           elif ntime_merged > (nvinfo_endtime + constants.NODE_MAX_CLOCK_SKEW):
             ntime_diff = "%.01fs" % abs(ntime_merged - nvinfo_endtime)
           else:
             ntime_diff = None
           _ErrorIf(ntime_diff is not None, self.ENODETIME, node,
                    "Node time diverges by at least %s from master node time",
                    ntime_diff)
         def _VerifyNodeLVM(self, ninfo, nresult, vg_name):
           """Check the node LVM results.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           @param vg_name: the configured VG name
           """
           if vg_name is None:
             return
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           # checks vg existence and size > 20G
           vglist = nresult.get(constants.NV_VGLIST, None)
           test = not vglist
           _ErrorIf(test, self.ENODELVM, node, "unable to check volume groups")
           if not test:
             vgstatus = utils.CheckVolumeGroupSize(vglist, vg_name,
                                                   constants.MIN_VG_SIZE)
             _ErrorIf(vgstatus, self.ENODELVM, node, vgstatus)
           # check pv names
           pvlist = nresult.get(constants.NV_PVLIST, None)
           test = pvlist is None
           _ErrorIf(test, self.ENODELVM, node, "Can't get PV list from node")
           if not test:
             # check that ':' is not present in PV names, since it's a
             # special character for lvcreate (denotes the range of PEs to
             # use on the PV)
             for _, pvname, owner_vg in pvlist:
               test = ":" in pvname
               _ErrorIf(test, self.ENODELVM, node, "Invalid character ':' in PV"
                        " '%s' of VG '%s'", pvname, owner_vg)
         def _VerifyNodeBridges(self, ninfo, nresult, bridges):
           """Check the node bridges.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           @param bridges: the expected list of bridges
           """
           if not bridges:
             return
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           missing = nresult.get(constants.NV_BRIDGES, None)
           test = not isinstance(missing, list)
           _ErrorIf(test, self.ENODENET, node,
                    "did not return valid bridge information")
           if not test:
             _ErrorIf(bool(missing), self.ENODENET, node, "missing bridges: %s" %
                      utils.CommaJoin(sorted(missing)))
         def _VerifyNodeNetwork(self, ninfo, nresult):
           """Check the node network connectivity results.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           """
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           test = constants.NV_NODELIST not in nresult
           _ErrorIf(test, self.ENODESSH, node,
                    "node hasn't returned node ssh connectivity data")
           if not test:
             if nresult[constants.NV_NODELIST]:
               for a_node, a_msg in nresult[constants.NV_NODELIST].items():
                 _ErrorIf(True, self.ENODESSH, node,
                          "ssh communication with node '%s': %s", a_node, a_msg)
           test = constants.NV_NODENETTEST not in nresult
           _ErrorIf(test, self.ENODENET, node,
                    "node hasn't returned node tcp connectivity data")
           if not test:
             if nresult[constants.NV_NODENETTEST]:
               nlist = utils.NiceSort(nresult[constants.NV_NODENETTEST].keys())
               for anode in nlist:
                 _ErrorIf(True, self.ENODENET, node,
                          "tcp communication with node '%s': %s",
                          anode, nresult[constants.NV_NODENETTEST][anode])
           test = constants.NV_MASTERIP not in nresult
           _ErrorIf(test, self.ENODENET, node,
                    "node hasn't returned node master IP reachability data")
           if not test:
             if not nresult[constants.NV_MASTERIP]:
               if node == self.master_node:
                 msg = "the master node cannot reach the master IP (not configured?)"
               else:
                 msg = "cannot reach the master IP"
               _ErrorIf(True, self.ENODENET, node, msg)
         def _VerifyInstance(self, instance, instanceconfig, node_image,
                             diskstatus):
           """Verify an instance.
           This function checks to see if the required block devices are
           available on the instance's node.
           """
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           node_current = instanceconfig.primary_node
           node_vol_should = {}
           instanceconfig.MapLVsByNode(node_vol_should)
           for node in node_vol_should:
             n_img = node_image[node]
             if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
               # ignore missing volumes on offline or broken nodes
               continue
             for volume in node_vol_should[node]:
               test = volume not in n_img.volumes
               _ErrorIf(test, self.EINSTANCEMISSINGDISK, instance,
                        "volume %s missing on node %s", volume, node)
           if instanceconfig.admin_up:
             pri_img = node_image[node_current]
             test = instance not in pri_img.instances and not pri_img.offline
             _ErrorIf(test, self.EINSTANCEDOWN, instance,
                      "instance not running on its primary node %s",
                      node_current)
           for node, n_img in node_image.items():
             if node != node_current:
               test = instance in n_img.instances
               _ErrorIf(test, self.EINSTANCEWRONGNODE, instance,
                        "instance should not run on node %s", node)
           diskdata = [(nname, success, status, idx)
                       for (nname, disks) in diskstatus.items()
                       for idx, (success, status) in enumerate(disks)]
           for nname, success, bdev_status, idx in diskdata:
             # the 'ghost node' construction in Exec() ensures that we have a
             # node here
             snode = node_image[nname]
             bad_snode = snode.ghost or snode.offline
             _ErrorIf(instanceconfig.admin_up and not success and not bad_snode,
                      self.EINSTANCEFAULTYDISK, instance,
                      "couldn't retrieve status for disk/%s on %s: %s",
                      idx, nname, bdev_status)
             _ErrorIf((instanceconfig.admin_up and success and
                       bdev_status.ldisk_status == constants.LDS_FAULTY),
                      self.EINSTANCEFAULTYDISK, instance,
                      "disk/%s on %s is faulty", idx, nname)
         def _VerifyOrphanVolumes(self, node_vol_should, node_image, reserved):
           """Verify if there are any unknown volumes in the cluster.
           The .os, .swap and backup volumes are ignored. All other volumes are
           reported as unknown.
           @type reserved: L{ganeti.utils.FieldSet}
           @param reserved: a FieldSet of reserved volume names
           """
           for node, n_img in node_image.items():
             if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:
               # skip non-healthy nodes
               continue
             for volume in n_img.volumes:
               test = ((node not in node_vol_should or
                       volume not in node_vol_should[node]) and
                       not reserved.Matches(volume))
               self._ErrorIf(test, self.ENODEORPHANLV, node,
                             "volume %s is unknown", volume)
         def _VerifyOrphanInstances(self, instancelist, node_image):
           """Verify the list of running instances.
           This checks what instances are running but unknown to the cluster.
           """
           for node, n_img in node_image.items():
             for o_inst in n_img.instances:
               test = o_inst not in instancelist
               self._ErrorIf(test, self.ENODEORPHANINSTANCE, node,
                             "instance %s on node %s should not exist", o_inst, node)
         def _VerifyNPlusOneMemory(self, node_image, instance_cfg):
           """Verify N+1 Memory Resilience.
           Check that if one single node dies we can still start all the
           instances it was primary for.
           """
           for node, n_img in node_image.items():
             # This code checks that every node which is now listed as
             # secondary has enough memory to host all instances it is
             # supposed to should a single other node in the cluster fail.
             # FIXME: not ready for failover to an arbitrary node
             # FIXME: does not support file-backed instances
             # WARNING: we currently take into account down instances as well
             # as up ones, considering that even if they're down someone
             # might want to start them even in the event of a node failure.
             if n_img.offline:
               # we're skipping offline nodes from the N+1 warning, since
               # most likely we don't have good memory infromation from them;
               # we already list instances living on such nodes, and that's
               # enough warning
               continue
             for prinode, instances in n_img.sbp.items():
               needed_mem = 0
               for instance in instances:
                 bep = self.cfg.GetClusterInfo().FillBE(instance_cfg[instance])
                 if bep[constants.BE_AUTO_BALANCE]:
                   needed_mem += bep[constants.BE_MEMORY]
               test = n_img.mfree < needed_mem
               self._ErrorIf(test, self.ENODEN1, node,
                             "not enough memory to accomodate instance failovers"
                             " should node %s fail (%dMiB needed, %dMiB available)",
                             prinode, needed_mem, n_img.mfree)
         def _VerifyNodeFiles(self, ninfo, nresult, file_list, local_cksum,
                              master_files):
           """Verifies and computes the node required file checksums.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           @param file_list: required list of files
           @param local_cksum: dictionary of local files and their checksums
           @param master_files: list of files that only masters should have
           """
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           remote_cksum = nresult.get(constants.NV_FILELIST, None)
           test = not isinstance(remote_cksum, dict)
           _ErrorIf(test, self.ENODEFILECHECK, node,
                    "node hasn't returned file checksum data")
           if test:
             return
           for file_name in file_list:
             node_is_mc = ninfo.master_candidate
             must_have = (file_name not in master_files) or node_is_mc
             # missing
             test1 = file_name not in remote_cksum
             # invalid checksum
             test2 = not test1 and remote_cksum[file_name] != local_cksum[file_name]
             # existing and good
             test3 = not test1 and remote_cksum[file_name] == local_cksum[file_name]
             _ErrorIf(test1 and must_have, self.ENODEFILECHECK, node,
                      "file '%s' missing", file_name)
             _ErrorIf(test2 and must_have, self.ENODEFILECHECK, node,
                      "file '%s' has wrong checksum", file_name)
             # not candidate and this is not a must-have file
             _ErrorIf(test2 and not must_have, self.ENODEFILECHECK, node,
                      "file '%s' should not exist on non master"
                      " candidates (and the file is outdated)", file_name)
             # all good, except non-master/non-must have combination
             _ErrorIf(test3 and not must_have, self.ENODEFILECHECK, node,
                      "file '%s' should not exist"
                      " on non master candidates", file_name)
         def _VerifyNodeDrbd(self, ninfo, nresult, instanceinfo, drbd_helper,
                             drbd_map):
           """Verifies and the node DRBD status.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           @param instanceinfo: the dict of instances
           @param drbd_helper: the configured DRBD usermode helper
           @param drbd_map: the DRBD map as returned by
               L{ganeti.config.ConfigWriter.ComputeDRBDMap}
           """
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           if drbd_helper:
             helper_result = nresult.get(constants.NV_DRBDHELPER, None)
             test = (helper_result == None)
             _ErrorIf(test, self.ENODEDRBDHELPER, node,
                      "no drbd usermode helper returned")
             if helper_result:
               status, payload = helper_result
               test = not status
               _ErrorIf(test, self.ENODEDRBDHELPER, node,
                        "drbd usermode helper check unsuccessful: %s", payload)
               test = status and (payload != drbd_helper)
               _ErrorIf(test, self.ENODEDRBDHELPER, node,
                        "wrong drbd usermode helper: %s", payload)
           # compute the DRBD minors
           node_drbd = {}
           for minor, instance in drbd_map[node].items():
             test = instance not in instanceinfo
             _ErrorIf(test, self.ECLUSTERCFG, None,
                      "ghost instance '%s' in temporary DRBD map", instance)
               # ghost instance should not be running, but otherwise we
               # don't give double warnings (both ghost instance and
               # unallocated minor in use)
             if test:
               node_drbd[minor] = (instance, False)
             else:
               instance = instanceinfo[instance]
               node_drbd[minor] = (instance.name, instance.admin_up)
           # and now check them
           used_minors = nresult.get(constants.NV_DRBDLIST, [])
           test = not isinstance(used_minors, (tuple, list))
           _ErrorIf(test, self.ENODEDRBD, node,
                    "cannot parse drbd status file: %s", str(used_minors))
           if test:
             # we cannot check drbd status
             return
           for minor, (iname, must_exist) in node_drbd.items():
             test = minor not in used_minors and must_exist
             _ErrorIf(test, self.ENODEDRBD, node,
                      "drbd minor %d of instance %s is not active", minor, iname)
           for minor in used_minors:
             test = minor not in node_drbd
             _ErrorIf(test, self.ENODEDRBD, node,
                      "unallocated drbd minor %d is in use", minor)
         def _UpdateNodeOS(self, ninfo, nresult, nimg):
           """Builds the node OS structures.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           @param nimg: the node image object
           """
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           remote_os = nresult.get(constants.NV_OSLIST, None)
           test = (not isinstance(remote_os, list) or
                   not compat.all(isinstance(v, list) and len(v) == 7
                                  for v in remote_os))
           _ErrorIf(test, self.ENODEOS, node,
                    "node hasn't returned valid OS data")
           nimg.os_fail = test
           if test:
             return
           os_dict = {}
           for (name, os_path, status, diagnose,
                variants, parameters, api_ver) in nresult[constants.NV_OSLIST]:
             if name not in os_dict:
               os_dict[name] = []
             # parameters is a list of lists instead of list of tuples due to
             # JSON lacking a real tuple type, fix it:
             parameters = [tuple(v) for v in parameters]
             os_dict[name].append((os_path, status, diagnose,
                                   set(variants), set(parameters), set(api_ver)))
           nimg.oslist = os_dict
         def _VerifyNodeOS(self, ninfo, nimg, base):
           """Verifies the node OS list.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nimg: the node image object
           @param base: the 'template' node we match against (e.g. from the master)
           """
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           assert not nimg.os_fail, "Entered _VerifyNodeOS with failed OS rpc?"
           beautify_params = lambda l: ["%s: %s" % (k, v) for (k, v) in l]
           for os_name, os_data in nimg.oslist.items():
             assert os_data, "Empty OS status for OS %s?!" % os_name
             f_path, f_status, f_diag, f_var, f_param, f_api = os_data[0]
             _ErrorIf(not f_status, self.ENODEOS, node,
                      "Invalid OS %s (located at %s): %s", os_name, f_path, f_diag)
             _ErrorIf(len(os_data) > 1, self.ENODEOS, node,
                      "OS '%s' has multiple entries (first one shadows the rest): %s",
                      os_name, utils.CommaJoin([v[0] for v in os_data]))
             # this will catched in backend too
             _ErrorIf(compat.any(v >= constants.OS_API_V15 for v in f_api)
                      and not f_var, self.ENODEOS, node,
                      "OS %s with API at least %d does not declare any variant",
                      os_name, constants.OS_API_V15)
             # comparisons with the 'base' image
             test = os_name not in base.oslist
             _ErrorIf(test, self.ENODEOS, node,
                      "Extra OS %s not present on reference node (%s)",
                      os_name, base.name)
             if test:
               continue
             assert base.oslist[os_name], "Base node has empty OS status?"
             _, b_status, _, b_var, b_param, b_api = base.oslist[os_name][0]
             if not b_status:
               # base OS is invalid, skipping
               continue
             for kind, a, b in [("API version", f_api, b_api),
                                ("variants list", f_var, b_var),
                                ("parameters", beautify_params(f_param),
                                 beautify_params(b_param))]:
               _ErrorIf(a != b, self.ENODEOS, node,
                        "OS %s for %s differs from reference node %s: [%s] vs. [%s]",
                        kind, os_name, base.name,
                        utils.CommaJoin(sorted(a)), utils.CommaJoin(sorted(b)))
           # check any missing OSes
           missing = set(base.oslist.keys()).difference(nimg.oslist.keys())
           _ErrorIf(missing, self.ENODEOS, node,
                    "OSes present on reference node %s but missing on this node: %s",
                    base.name, utils.CommaJoin(missing))
         def _VerifyOob(self, ninfo, nresult):
           """Verifies out of band functionality of a node.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           """
           node = ninfo.name
           # We just have to verify the paths on master and/or master candidates
           # as the oob helper is invoked on the master
           if ((ninfo.master_candidate or ninfo.master_capable) and
               constants.NV_OOB_PATHS in nresult):
             for path_result in nresult[constants.NV_OOB_PATHS]:
               self._ErrorIf(path_result, self.ENODEOOBPATH, node, path_result)
         def _UpdateNodeVolumes(self, ninfo, nresult, nimg, vg_name):
           """Verifies and updates the node volume data.
           This function will update a L{NodeImage}'s internal structures
           with data from the remote call.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           @param nimg: the node image object
           @param vg_name: the configured VG name
           """
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           nimg.lvm_fail = True
           lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")
           if vg_name is None:
             pass
           elif isinstance(lvdata, basestring):
             _ErrorIf(True, self.ENODELVM, node, "LVM problem on node: %s",
                      utils.SafeEncode(lvdata))
           elif not isinstance(lvdata, dict):
             _ErrorIf(True, self.ENODELVM, node, "rpc call to node failed (lvlist)")
           else:
             nimg.volumes = lvdata
             nimg.lvm_fail = False
         def _UpdateNodeInstances(self, ninfo, nresult, nimg):
           """Verifies and updates the node instance list.
           If the listing was successful, then updates this node's instance
           list. Otherwise, it marks the RPC call as failed for the instance
           list key.
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           @param nimg: the node image object
           """
           idata = nresult.get(constants.NV_INSTANCELIST, None)
           test = not isinstance(idata, list)
           self._ErrorIf(test, self.ENODEHV, ninfo.name, "rpc call to node failed"
                         " (instancelist): %s", utils.SafeEncode(str(idata)))
           if test:
             nimg.hyp_fail = True
           else:
             nimg.instances = idata
         def _UpdateNodeInfo(self, ninfo, nresult, nimg, vg_name):
           """Verifies and computes a node information map
           @type ninfo: L{objects.Node}
           @param ninfo: the node to check
           @param nresult: the remote results for the node
           @param nimg: the node image object
           @param vg_name: the configured VG name
           """
           node = ninfo.name
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           # try to read free memory (from the hypervisor)
           hv_info = nresult.get(constants.NV_HVINFO, None)
           test = not isinstance(hv_info, dict) or "memory_free" not in hv_info
           _ErrorIf(test, self.ENODEHV, node, "rpc call to node failed (hvinfo)")
           if not test:
             try:
               nimg.mfree = int(hv_info["memory_free"])
             except (ValueError, TypeError):
               _ErrorIf(True, self.ENODERPC, node,
                        "node returned invalid nodeinfo, check hypervisor")
           # FIXME: devise a free space model for file based instances as well
           if vg_name is not None:
             test = (constants.NV_VGLIST not in nresult or
                     vg_name not in nresult[constants.NV_VGLIST])
             _ErrorIf(test, self.ENODELVM, node,
                      "node didn't return data for the volume group '%s'"
                      " - it is either missing or broken", vg_name)
             if not test:
               try:
                 nimg.dfree = int(nresult[constants.NV_VGLIST][vg_name])
               except (ValueError, TypeError):
                 _ErrorIf(True, self.ENODERPC, node,
                          "node returned invalid LVM info, check LVM status")
         def _CollectDiskInfo(self, nodelist, node_image, instanceinfo):
           """Gets per-disk status information for all instances.
           @type nodelist: list of strings
           @param nodelist: Node names
           @type node_image: dict of (name, L{objects.Node})
           @param node_image: Node objects
           @type instanceinfo: dict of (name, L{objects.Instance})
           @param instanceinfo: Instance objects
           @rtype: {instance: {node: [(succes, payload)]}}
           @return: a dictionary of per-instance dictionaries with nodes as
               keys and disk information as values; the disk information is a
               list of tuples (success, payload)
           """
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           node_disks = {}
           node_disks_devonly = {}
           diskless_instances = set()
           diskless = constants.DT_DISKLESS
           for nname in nodelist:
             node_instances = list(itertools.chain(node_image[nname].pinst,
                                                   node_image[nname].sinst))
             diskless_instances.update(inst for inst in node_instances
                                       if instanceinfo[inst].disk_template == diskless)
             disks = [(inst, disk)
                      for inst in node_instances
                      for disk in instanceinfo[inst].disks]
             if not disks:
               # No need to collect data
               continue
             node_disks[nname] = disks
             # Creating copies as SetDiskID below will modify the objects and that can
             # lead to incorrect data returned from nodes
             devonly = [dev.Copy() for (_, dev) in disks]
             for dev in devonly:
               self.cfg.SetDiskID(dev, nname)
             node_disks_devonly[nname] = devonly
           assert len(node_disks) == len(node_disks_devonly)
           # Collect data from all nodes with disks
           result = self.rpc.call_blockdev_getmirrorstatus_multi(node_disks.keys(),
                                                                 node_disks_devonly)
           assert len(result) == len(node_disks)
           instdisk = {}
           for (nname, nres) in result.items():
             disks = node_disks[nname]
             if nres.offline:
               # No data from this node
               data = len(disks) * [(False, "node offline")]
             else:
               msg = nres.fail_msg
               _ErrorIf(msg, self.ENODERPC, nname,
                        "while getting disk information: %s", msg)
               if msg:
                 # No data from this node
                 data = len(disks) * [(False, msg)]
               else:
                 data = []
                 for idx, i in enumerate(nres.payload):
                   if isinstance(i, (tuple, list)) and len(i) == 2:
                     data.append(i)
                   else:
                     logging.warning("Invalid result from node %s, entry %d: %s",
                                     nname, idx, i)
                     data.append((False, "Invalid result from the remote node"))
             for ((inst, _), status) in zip(disks, data):
               instdisk.setdefault(inst, {}).setdefault(nname, []).append(status)
           # Add empty entries for diskless instances.
           for inst in diskless_instances:
             assert inst not in instdisk
             instdisk[inst] = {}
           assert compat.all(len(statuses) == len(instanceinfo[inst].disks) and
                             len(nnames) <= len(instanceinfo[inst].all_nodes) and
                             compat.all(isinstance(s, (tuple, list)) and
                                        len(s) == 2 for s in statuses)
                             for inst, nnames in instdisk.items()
                             for nname, statuses in nnames.items())
           assert set(instdisk) == set(instanceinfo), "instdisk consistency failure"
           return instdisk
         def _VerifyHVP(self, hvp_data):
           """Verifies locally the syntax of the hypervisor parameters.
           """
           for item, hv_name, hv_params in hvp_data:
             msg = ("hypervisor %s parameters syntax check (source %s): %%s" %
                    (item, hv_name))
             try:
               hv_class = hypervisor.GetHypervisor(hv_name)
               utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
               hv_class.CheckParameterSyntax(hv_params)
             except errors.GenericError, err:
               self._ErrorIf(True, self.ECLUSTERCFG, None, msg % str(err))
         def BuildHooksEnv(self):
           """Build hooks env.
           Cluster-Verify hooks just ran in the post phase and their failure makes
           the output be logged in the verify output and the verification to fail.
           """
           all_nodes = self.cfg.GetNodeList()
           env = {
             "CLUSTER_TAGS": " ".join(self.cfg.GetClusterInfo().GetTags())
+            }
           for node in self.cfg.GetAllNodesInfo().values():
             env["NODE_TAGS_%s" % node.name] = " ".join(node.GetTags())
           return env, [], all_nodes
         def Exec(self, feedback_fn):
           """Verify integrity of cluster, performing various test on nodes.
           """
           # This method has too many local variables. pylint: disable-msg=R0914
           self.bad = False
           _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103
           verbose = self.op.verbose
           self._feedback_fn = feedback_fn
           feedback_fn("* Verifying global settings")
           for msg in self.cfg.VerifyConfig():
             _ErrorIf(True, self.ECLUSTERCFG, None, msg)
           # Check the cluster certificates
           for cert_filename in constants.ALL_CERT_FILES:
             (errcode, msg) = _VerifyCertificate(cert_filename)
             _ErrorIf(errcode, self.ECLUSTERCERT, None, msg, code=errcode)
           vg_name = self.cfg.GetVGName()
           drbd_helper = self.cfg.GetDRBDHelper()
           hypervisors = self.cfg.GetClusterInfo().enabled_hypervisors
           cluster = self.cfg.GetClusterInfo()
           nodeinfo_byname = self.cfg.GetAllNodesInfo()
           nodelist = utils.NiceSort(nodeinfo_byname.keys())
           nodeinfo = [nodeinfo_byname[nname] for nname in nodelist]
           instanceinfo = self.cfg.GetAllInstancesInfo()
           instancelist = utils.NiceSort(instanceinfo.keys())
           groupinfo = self.cfg.GetAllNodeGroupsInfo()
           i_non_redundant = [] # Non redundant instances
           i_non_a_balanced = [] # Non auto-balanced instances
           n_offline = 0 # Count of offline nodes
           n_drained = 0 # Count of nodes being drained
           node_vol_should = {}
           # FIXME: verify OS list
           # do local checksums
           master_files = [constants.CLUSTER_CONF_FILE]
           master_node = self.master_node = self.cfg.GetMasterNode()
           master_ip = self.cfg.GetMasterIP()
           file_names = ssconf.SimpleStore().GetFileList()
           file_names.extend(constants.ALL_CERT_FILES)
           file_names.extend(master_files)
           if cluster.modify_etc_hosts:
             file_names.append(constants.ETC_HOSTS)
           local_checksums = utils.FingerprintFiles(file_names)
           # Compute the set of hypervisor parameters
           hvp_data = []
           for hv_name in hypervisors:
             hvp_data.append(("cluster", hv_name, cluster.GetHVDefaults(hv_name)))
           for os_name, os_hvp in cluster.os_hvp.items():
             for hv_name, hv_params in os_hvp.items():
               if not hv_params:
                 continue
               full_params = cluster.GetHVDefaults(hv_name, os_name=os_name)
               hvp_data.append(("os %s" % os_name, hv_name, full_params))
           # TODO: collapse identical parameter values in a single one
           for instance in instanceinfo.values():
             if not instance.hvparams:
               continue
             hvp_data.append(("instance %s" % instance.name, instance.hypervisor,
                              cluster.FillHV(instance)))
           # and verify them locally
           self._VerifyHVP(hvp_data)
           feedback_fn("* Gathering data (%d nodes)" % len(nodelist))
           node_verify_param = {
             constants.NV_FILELIST: file_names,
             constants.NV_NODELIST: [node.name for node in nodeinfo
                                     if not node.offline],
             constants.NV_HYPERVISOR: hypervisors,
             constants.NV_HVPARAMS: hvp_data,
             constants.NV_NODENETTEST: [(node.name, node.primary_ip,
                                         node.secondary_ip) for node in nodeinfo
                                        if not node.offline],
             constants.NV_INSTANCELIST: hypervisors,
             constants.NV_VERSION: None,
             constants.NV_HVINFO: self.cfg.GetHypervisorType(),
             constants.NV_NODESETUP: None,
             constants.NV_TIME: None,
             constants.NV_MASTERIP: (master_node, master_ip),
             constants.NV_OSLIST: None,
             constants.NV_VMNODES: self.cfg.GetNonVmCapableNodeList(),
+            }
           if vg_name is not None:
             node_verify_param[constants.NV_VGLIST] = None
             node_verify_param[constants.NV_LVLIST] = vg_name
             node_verify_param[constants.NV_PVLIST] = [vg_name]
             node_verify_param[constants.NV_DRBDLIST] = None
           if drbd_helper:
             node_verify_param[constants.NV_DRBDHELPER] = drbd_helper
           # bridge checks
           # FIXME: this needs to be changed per node-group, not cluster-wide
           bridges = set()
           default_nicpp = cluster.nicparams[constants.PP_DEFAULT]
           if default_nicpp[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
             bridges.add(default_nicpp[constants.NIC_LINK])
           for instance in instanceinfo.values():
             for nic in instance.nics:
               full_nic = cluster.SimpleFillNIC(nic.nicparams)
               if full_nic[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
                 bridges.add(full_nic[constants.NIC_LINK])
           if bridges:
             node_verify_param[constants.NV_BRIDGES] = list(bridges)
           # Build our expected cluster state
           node_image = dict((node.name, self.NodeImage(offline=node.offline,
                                                        name=node.name,
                                                        vm_capable=node.vm_capable))
                             for node in nodeinfo)
           # Gather OOB paths
           oob_paths = []
           for node in nodeinfo:
             path = _SupportsOob(self.cfg, node)
             if path and path not in oob_paths:
               oob_paths.append(path)
           if oob_paths:
             node_verify_param[constants.NV_OOB_PATHS] = oob_paths
           for instance in instancelist:
             inst_config = instanceinfo[instance]
             for nname in inst_config.all_nodes:
               if nname not in node_image:
                 # ghost node
                 gnode = self.NodeImage(name=nname)
                 gnode.ghost = True
                 node_image[nname] = gnode
             inst_config.MapLVsByNode(node_vol_should)
             pnode = inst_config.primary_node
             node_image[pnode].pinst.append(instance)
             for snode in inst_config.secondary_nodes:
               nimg = node_image[snode]
               nimg.sinst.append(instance)
               if pnode not in nimg.sbp:
                 nimg.sbp[pnode] = []
               nimg.sbp[pnode].append(instance)
           # At this point, we have the in-memory data structures complete,
           # except for the runtime information, which we'll gather next
           # Due to the way our RPC system works, exact response times cannot be
           # guaranteed (e.g. a broken node could run into a timeout). By keeping the
           # time before and after executing the request, we can at least have a time
           # window.
           nvinfo_starttime = time.time()
           all_nvinfo = self.rpc.call_node_verify(nodelist, node_verify_param,
                                                  self.cfg.GetClusterName())
           nvinfo_endtime = time.time()
           all_drbd_map = self.cfg.ComputeDRBDMap()
           feedback_fn("* Gathering disk information (%s nodes)" % len(nodelist))
           instdisk = self._CollectDiskInfo(nodelist, node_image, instanceinfo)
           feedback_fn("* Verifying node status")
           refos_img = None
           for node_i in nodeinfo:
             node = node_i.name
             nimg = node_image[node]
             if node_i.offline:
               if verbose:
                 feedback_fn("* Skipping offline node %s" % (node,))
               n_offline += 1
               continue
             if node == master_node:
               ntype = "master"
             elif node_i.master_candidate:
               ntype = "master candidate"
             elif node_i.drained:
               ntype = "drained"
               n_drained += 1
             else:
               ntype = "regular"
             if verbose:
               feedback_fn("* Verifying node %s (%s)" % (node, ntype))
             msg = all_nvinfo[node].fail_msg
             _ErrorIf(msg, self.ENODERPC, node, "while contacting node: %s", msg)
             if msg:
               nimg.rpc_fail = True
               continue
             nresult = all_nvinfo[node].payload
             nimg.call_ok = self._VerifyNode(node_i, nresult)
             self._VerifyNodeTime(node_i, nresult, nvinfo_starttime, nvinfo_endtime)
             self._VerifyNodeNetwork(node_i, nresult)
             self._VerifyNodeFiles(node_i, nresult, file_names, local_checksums,
                                   master_files)
             self._VerifyOob(node_i, nresult)
             if nimg.vm_capable:
               self._VerifyNodeLVM(node_i, nresult, vg_name)
               self._VerifyNodeDrbd(node_i, nresult, instanceinfo, drbd_helper,
                                    all_drbd_map)
               self._UpdateNodeVolumes(node_i, nresult, nimg, vg_name)
               self._UpdateNodeInstances(node_i, nresult, nimg)
               self._UpdateNodeInfo(node_i, nresult, nimg, vg_name)
               self._UpdateNodeOS(node_i, nresult, nimg)
               if not nimg.os_fail:
                 if refos_img is None:
                   refos_img = nimg
                 self._VerifyNodeOS(node_i, nimg, refos_img)
               self._VerifyNodeBridges(node_i, nresult, bridges)
           feedback_fn("* Verifying instance status")
           for instance in instancelist:
             if verbose:
               feedback_fn("* Verifying instance %s" % instance)
             inst_config = instanceinfo[instance]
             self._VerifyInstance(instance, inst_config, node_image,
                                  instdisk[instance])
             inst_nodes_offline = []
             pnode = inst_config.primary_node
             pnode_img = node_image[pnode]
             _ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,
                      self.ENODERPC, pnode, "instance %s, connection to"
                      " primary node failed", instance)
             _ErrorIf(pnode_img.offline, self.EINSTANCEBADNODE, instance,
                      "instance lives on offline node %s", inst_config.primary_node)
             # If the instance is non-redundant we cannot survive losing its primary
             # node, so we are not N+1 compliant. On the other hand we have no disk
             # templates with more than one secondary so that situation is not well
             # supported either.
             # FIXME: does not support file-backed instances
             if not inst_config.secondary_nodes:
               i_non_redundant.append(instance)
             _ErrorIf(len(inst_config.secondary_nodes) > 1, self.EINSTANCELAYOUT,
                      instance, "instance has multiple secondary nodes: %s",
                      utils.CommaJoin(inst_config.secondary_nodes),
                      code=self.ETYPE_WARNING)
             if inst_config.disk_template in constants.DTS_NET_MIRROR:
               pnode = inst_config.primary_node
               instance_nodes = utils.NiceSort(inst_config.all_nodes)
               instance_groups = {}
               for node in instance_nodes:
                 instance_groups.setdefault(nodeinfo_byname[node].group,
                                            []).append(node)
               pretty_list = [
                 "%s (group %s)" % (utils.CommaJoin(nodes), groupinfo[group].name)
                 # Sort so that we always list the primary node first.
                 for group, nodes in sorted(instance_groups.items(),
                                            key=lambda (_, nodes): pnode in nodes,
                                            reverse=True)]
               self._ErrorIf(len(instance_groups) > 1, self.EINSTANCESPLITGROUPS,
                             instance, "instance has primary and secondary nodes in"
                             " different groups: %s", utils.CommaJoin(pretty_list),
                             code=self.ETYPE_WARNING)
             if not cluster.FillBE(inst_config)[constants.BE_AUTO_BALANCE]:
               i_non_a_balanced.append(instance)
             for snode in inst_config.secondary_nodes:
               s_img = node_image[snode]
               _ErrorIf(s_img.rpc_fail and not s_img.offline, self.ENODERPC, snode,
                        "instance %s, connection to secondary node failed", instance)
               if s_img.offline:
                 inst_nodes_offline.append(snode)
             # warn that the instance lives on offline nodes
             _ErrorIf(inst_nodes_offline, self.EINSTANCEBADNODE, instance,
                      "instance has offline secondary node(s) %s",
                      utils.CommaJoin(inst_nodes_offline))
             # ... or ghost/non-vm_capable nodes
             for node in inst_config.all_nodes:
               _ErrorIf(node_image[node].ghost, self.EINSTANCEBADNODE, instance,
                        "instance lives on ghost node %s", node)
               _ErrorIf(not node_image[node].vm_capable, self.EINSTANCEBADNODE,
                        instance, "instance lives on non-vm_capable node %s", node)
           feedback_fn("* Verifying orphan volumes")
           reserved = utils.FieldSet(*cluster.reserved_lvs)
           self._VerifyOrphanVolumes(node_vol_should, node_image, reserved)
           feedback_fn("* Verifying orphan instances")
           self._VerifyOrphanInstances(instancelist, node_image)
           if constants.VERIFY_NPLUSONE_MEM not in self.op.skip_checks:
             feedback_fn("* Verifying N+1 Memory redundancy")
             self._VerifyNPlusOneMemory(node_image, instanceinfo)
           feedback_fn("* Other Notes")
           if i_non_redundant:
             feedback_fn("  - NOTICE: %d non-redundant instance(s) found."
                         % len(i_non_redundant))
           if i_non_a_balanced:
             feedback_fn("  - NOTICE: %d non-auto-balanced instance(s) found."
                         % len(i_non_a_balanced))
           if n_offline:
             feedback_fn("  - NOTICE: %d offline node(s) found." % n_offline)
           if n_drained:
             feedback_fn("  - NOTICE: %d drained node(s) found." % n_drained)
           return not self.bad
         def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):
           """Analyze the post-hooks' result
           This method analyses the hook result, handles it, and sends some
           nicely-formatted feedback back to the user.
           @param phase: one of L{constants.HOOKS_PHASE_POST} or
               L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
           @param hooks_results: the results of the multi-node hooks rpc call
           @param feedback_fn: function used send feedback back to the caller
           @param lu_result: previous Exec result
           @return: the new Exec result, based on the previous result
               and hook results
           """
           # We only really run POST phase hooks, and are only interested in
           # their results
           if phase == constants.HOOKS_PHASE_POST:
             # Used to change hooks' output to proper indentation
             feedback_fn("* Hooks Results")
             assert hooks_results, "invalid result from hooks"
             for node_name in hooks_results:
               res = hooks_results[node_name]
               msg = res.fail_msg
               test = msg and not res.offline
               self._ErrorIf(test, self.ENODEHOOKS, node_name,
                             "Communication failure in hooks execution: %s", msg)
               if res.offline or msg:
                 # No need to investigate payload if node is offline or gave an error.
                 # override manually lu_result here as _ErrorIf only
                 # overrides self.bad
                 lu_result = 1
                 continue
               for script, hkr, output in res.payload:
                 test = hkr == constants.HKR_FAIL
                 self._ErrorIf(test, self.ENODEHOOKS, node_name,
                               "Script %s failed, output:", script)
                 if test:
                   output = self._HOOKS_INDENT_RE.sub('      ', output)
                   feedback_fn("%s" % output)
                   lu_result = 0
             return lu_result
       class LUClusterVerifyDisks(NoHooksLU):
         """Verifies the cluster disks status.
         """
         REQ_BGL = False
         def ExpandNames(self):
           self.needed_locks = {
             locking.LEVEL_NODE: locking.ALL_SET,
             locking.LEVEL_INSTANCE: locking.ALL_SET,
+          }
           self.share_locks = dict.fromkeys(locking.LEVELS, 1)
         def Exec(self, feedback_fn):
           """Verify integrity of cluster disks.
           @rtype: tuple of three items
           @return: a tuple of (dict of node-to-node_error, list of instances
               which need activate-disks, dict of instance: (node, volume) for
               missing volumes
           """
           result = res_nodes, res_instances, res_missing = {}, [], {}
           nodes = utils.NiceSort(self.cfg.GetVmCapableNodeList())
           instances = self.cfg.GetAllInstancesInfo().values()
           nv_dict = {}
           for inst in instances:
             inst_lvs = {}
             if not inst.admin_up:
               continue
             inst.MapLVsByNode(inst_lvs)
             # transform { iname: {node: [vol,],},} to {(node, vol): iname}
             for node, vol_list in inst_lvs.iteritems():
               for vol in vol_list:
                 nv_dict[(node, vol)] = inst
           if not nv_dict:
             return result
           node_lvs = self.rpc.call_lv_list(nodes, [])
           for node, node_res in node_lvs.items():
             if node_res.offline:
               continue
             msg = node_res.fail_msg
             if msg:
               logging.warning("Error enumerating LVs on node %s: %s", node, msg)
               res_nodes[node] = msg
               continue
             lvs = node_res.payload
             for lv_name, (_, _, lv_online) in lvs.items():
               inst = nv_dict.pop((node, lv_name), None)
               if (not lv_online and inst is not None
                   and inst.name not in res_instances):
                 res_instances.append(inst.name)
           # any leftover items in nv_dict are missing LVs, let's arrange the
           # data better
           for key, inst in nv_dict.iteritems():
             if inst.name not in res_missing:
               res_missing[inst.name] = []
             res_missing[inst.name].append(key)
           return result
       class LUClusterRepairDiskSizes(NoHooksLU):
         """Verifies the cluster disks sizes.
         """
         REQ_BGL = False
         def ExpandNames(self):
           if self.op.instances:
             self.wanted_names = []
             for name in self.op.instances:
               full_name = _ExpandInstanceName(self.cfg, name)
               self.wanted_names.append(full_name)
             self.needed_locks = {
               locking.LEVEL_NODE: [],
               locking.LEVEL_INSTANCE: self.wanted_names,
+              }
             self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
           else:
             self.wanted_names = None
             self.needed_locks = {
               locking.LEVEL_NODE: locking.ALL_SET,
               locking.LEVEL_INSTANCE: locking.ALL_SET,
+              }
           self.share_locks = dict(((i, 1) for i in locking.LEVELS))
         def DeclareLocks(self, level):
           if level == locking.LEVEL_NODE and self.wanted_names is not None:
             self._LockInstancesNodes(primary_only=True)
         def CheckPrereq(self):
           """Check prerequisites.
           This only checks the optional instance list against the existing names.
           """
           if self.wanted_names is None:
             self.wanted_names = self.acquired_locks[locking.LEVEL_INSTANCE]
           self.wanted_instances = [self.cfg.GetInstanceInfo(name) for name
                                    in self.wanted_names]
         def _EnsureChildSizes(self, disk):
           """Ensure children of the disk have the needed disk size.
           This is valid mainly for DRBD8 and fixes an issue where the
           children have smaller disk size.
           @param disk: an L{ganeti.objects.Disk} object
           """
           if disk.dev_type == constants.LD_DRBD8:
             assert disk.children, "Empty children for DRBD8?"
             fchild = disk.children[0]
             mismatch = fchild.size < disk.size
             if mismatch:
               self.LogInfo("Child disk has size %d, parent %d, fixing",
                            fchild.size, disk.size)
               fchild.size = disk.size
             # and we recurse on this child only, not on the metadev
             return self._EnsureChildSizes(fchild) or mismatch
           else:
             return False
         def Exec(self, feedback_fn):
           """Verify the size of cluster disks.
           """
           # TODO: check child disks too
           # TODO: check differences in size between primary/secondary nodes
           per_node_disks = {}
           for instance in self.wanted_instances:
             pnode = instance.primary_node
             if pnode not in per_node_disks:
               per_node_disks[pnode] = []
             for idx, disk in enumerate(instance.disks):
               per_node_disks[pnode].append((instance, idx, disk))
           changed = []
           for node, dskl in per_node_disks.items():
             newl = [v[2].Copy() for v in dskl]
             for dsk in newl:
               self.cfg.SetDiskID(dsk, node)
             result = self.rpc.call_blockdev_getsize(node, newl)
             if result.fail_msg:
               self.LogWarning("Failure in blockdev_getsize call to node"
                               " %s, ignoring", node)
               continue
             if len(result.payload) != len(dskl):
               logging.warning("Invalid result from node %s: len(dksl)=%d,"
                               " result.payload=%s", node, len(dskl), result.payload)
               self.LogWarning("Invalid result from node %s, ignoring node results",
                               node)
               continue
             for ((instance, idx, disk), size) in zip(dskl, result.payload):
               if size is None:
                 self.LogWarning("Disk %d of instance %s did not return size"
                                 " information, ignoring", idx, instance.name)
                 continue
               if not isinstance(size, (int, long)):
                 self.LogWarning("Disk %d of instance %s did not return valid"
                                 " size information, ignoring", idx, instance.name)
                 continue
               size = size >> 20
               if size != disk.size:
                 self.LogInfo("Disk %d of instance %s has mismatched size,"
                              " correcting: recorded %d, actual %d", idx,
                              instance.name, disk.size, size)
                 disk.size = size
                 self.cfg.Update(instance, feedback_fn)
                 changed.append((instance.name, idx, size))
               if self._EnsureChildSizes(disk):
                 self.cfg.Update(instance, feedback_fn)
                 changed.append((instance.name, idx, disk.size))
           return changed
       class LUClusterRename(LogicalUnit):
         """Rename the cluster.
         """
         HPATH = "cluster-rename"
         HTYPE = constants.HTYPE_CLUSTER
         def BuildHooksEnv(self):
           """Build hooks env.
           """
           env = {
             "OP_TARGET": self.cfg.GetClusterName(),
             "NEW_NAME": self.op.name,
+            }
           mn = self.cfg.GetMasterNode()
           all_nodes = self.cfg.GetNodeList()
           return env, [mn], all_nodes
         def CheckPrereq(self):
           """Verify that the passed name is a valid one.
           """
           hostname = netutils.GetHostname(name=self.op.name,
                                           family=self.cfg.GetPrimaryIPFamily())
           new_name = hostname.name
           self.ip = new_ip = hostname.ip
           old_name = self.cfg.GetClusterName()
           old_ip = self.cfg.GetMasterIP()
           if new_name == old_name and new_ip == old_ip:
             raise errors.OpPrereqError("Neither the name nor the IP address of the"
                                        " cluster has changed",
                                        errors.ECODE_INVAL)
           if new_ip != old_ip:
             if netutils.TcpPing(new_ip, constants.DEFAULT_NODED_PORT):
               raise errors.OpPrereqError("The given cluster IP address (%s) is"
                                          " reachable on the network" %
                                          new_ip, errors.ECODE_NOTUNIQUE)
           self.op.name = new_name
         def Exec(self, feedback_fn):
           """Rename the cluster.
           """
           clustername = self.op.name
           ip = self.ip
           # shutdown the master IP
           master = self.cfg.GetMasterNode()
           result = self.rpc.call_node_stop_master(master, False)
           result.Raise("Could not disable the master role")
           try:
             cluster = self.cfg.GetClusterInfo()
             cluster.cluster_name = clustername
             cluster.master_ip = ip
             self.cfg.Update(cluster, feedback_fn)
             # update the known hosts file
             ssh.WriteKnownHostsFile(self.cfg, constants.SSH_KNOWN_HOSTS_FILE)
             node_list = self.cfg.GetOnlineNodeList()
             try:
               node_list.remove(master)
             except ValueError:
               pass
             _UploadHelper(self, node_list, constants.SSH_KNOWN_HOSTS_FILE)
           finally:
             result = self.rpc.call_node_start_master(master, False, False)
             msg = result.fail_msg
             if msg:
               self.LogWarning("Could not re-enable the master role on"
                               " the master, please restart manually: %s", msg)
           return clustername
       class LUClusterSetParams(LogicalUnit):
         """Change the parameters of the cluster.
         """
         HPATH = "cluster-modify"
         HTYPE = constants.HTYPE_CLUSTER
         REQ_BGL = False
         def CheckArguments(self):
           """Check parameters
           """
           if self.op.uid_pool:
             uidpool.CheckUidPool(self.op.uid_pool)
           if self.op.add_uids:
             uidpool.CheckUidPool(self.op.add_uids)
           if self.op.remove_uids:
             uidpool.CheckUidPool(self.op.remove_uids)
         def ExpandNames(self):
           # FIXME: in the future maybe other cluster params won't require checking on
           # all nodes to be modified.
           self.needed_locks = {
             locking.LEVEL_NODE: locking.ALL_SET,
+          }
           self.share_locks[locking.LEVEL_NODE] = 1
         def BuildHooksEnv(self):
           """Build hooks env.
           """
           env = {
             "OP_TARGET": self.cfg.GetClusterName(),
             "NEW_VG_NAME": self.op.vg_name,
+            }
           mn = self.cfg.GetMasterNode()
           return env, [mn], [mn]
         def CheckPrereq(self):
           """Check prerequisites.
           This checks whether the given params don't conflict and
           if the given volume group is valid.
           """
           if self.op.vg_name is not None and not self.op.vg_name:
             if self.cfg.HasAnyDiskOfType(constants.LD_LV):
               raise errors.OpPrereqError("Cannot disable lvm storage while lvm-based"
                                          " instances exist", errors.ECODE_INVAL)
           if self.op.drbd_helper is not None and not self.op.drbd_helper:
             if self.cfg.HasAnyDiskOfType(constants.LD_DRBD8):
               raise errors.OpPrereqError("Cannot disable drbd helper while"
                                          " drbd-based instances exist",
                                          errors.ECODE_INVAL)
           node_list = self.acquired_locks[locking.LEVEL_NODE]
           # if vg_name not None, checks given volume group on all nodes
           if self.op.vg_name:
             vglist = self.rpc.call_vg_list(node_list)
             for node in node_list:
               msg = vglist[node].fail_msg
               if msg:
                 # ignoring down node
                 self.LogWarning("Error while gathering data on node %s"
                                 " (ignoring node): %s", node, msg)
                 continue
               vgstatus = utils.CheckVolumeGroupSize(vglist[node].payload,
                                                     self.op.vg_name,
                                                     constants.MIN_VG_SIZE)
               if vgstatus:
                 raise errors.OpPrereqError("Error on node '%s': %s" %
                                            (node, vgstatus), errors.ECODE_ENVIRON)
           if self.op.drbd_helper:
             # checks given drbd helper on all nodes
             helpers = self.rpc.call_drbd_helper(node_list)
             for node in node_list:
               ninfo = self.cfg.GetNodeInfo(node)
               if ninfo.offline:
                 self.LogInfo("Not checking drbd helper on offline node %s", node)
                 continue
               msg = helpers[node].fail_msg
               if msg:
                 raise errors.OpPrereqError("Error checking drbd helper on node"
                                            " '%s': %s" % (node, msg),
                                            errors.ECODE_ENVIRON)
               node_helper = helpers[node].payload
               if node_helper != self.op.drbd_helper:
                 raise errors.OpPrereqError("Error on node '%s': drbd helper is %s" %
                                            (node, node_helper), errors.ECODE_ENVIRON)
           self.cluster = cluster = self.cfg.GetClusterInfo()
           # validate params changes
           if self.op.beparams:
             utils.ForceDictType(self.op.beparams, constants.BES_PARAMETER_TYPES)
             self.new_beparams = cluster.SimpleFillBE(self.op.beparams)
           if self.op.ndparams:
             utils.ForceDictType(self.op.ndparams, constants.NDS_PARAMETER_TYPES)
             self.new_ndparams = cluster.SimpleFillND(self.op.ndparams)
             # TODO: we need a more general way to handle resetting
             # cluster-level parameters to default values
             if self.new_ndparams["oob_program"] == "":
               self.new_ndparams["oob_program"] = \
                   constants.NDC_DEFAULTS[constants.ND_OOB_PROGRAM]
           if self.op.nicparams:
             utils.ForceDictType(self.op.nicparams, constants.NICS_PARAMETER_TYPES)
             self.new_nicparams = cluster.SimpleFillNIC(self.op.nicparams)
             objects.NIC.CheckParameterSyntax(self.new_nicparams)
             nic_errors = []
             # check all instances for consistency
             for instance in self.cfg.GetAllInstancesInfo().values():
               for nic_idx, nic in enumerate(instance.nics):
                 params_copy = copy.deepcopy(nic.nicparams)
                 params_filled = objects.FillDict(self.new_nicparams, params_copy)
                 # check parameter syntax
                 try:
                   objects.NIC.CheckParameterSyntax(params_filled)
                 except errors.ConfigurationError, err:
                   nic_errors.append("Instance %s, nic/%d: %s" %
                                     (instance.name, nic_idx, err))
                 # if we're moving instances to routed, check that they have an ip
                 target_mode = params_filled[constants.NIC_MODE]
                 if target_mode == constants.NIC_MODE_ROUTED and not nic.ip:
                   nic_errors.append("Instance %s, nic/%d: routed NIC with no ip"
                                     " address" % (instance.name, nic_idx))
             if nic_errors:
               raise errors.OpPrereqError("Cannot apply the change, errors:\n%s" %
                                          "\n".join(nic_errors))
           # hypervisor list/parameters
           self.new_hvparams = new_hvp = objects.FillDict(cluster.hvparams, {})
           if self.op.hvparams:
             for hv_name, hv_dict in self.op.hvparams.items():
               if hv_name not in self.new_hvparams:
                 self.new_hvparams[hv_name] = hv_dict
               else:
                 self.new_hvparams[hv_name].update(hv_dict)
           # os hypervisor parameters
           self.new_os_hvp = objects.FillDict(cluster.os_hvp, {})
           if self.op.os_hvp:
             for os_name, hvs in self.op.os_hvp.items():
               if os_name not in self.new_os_hvp:
                 self.new_os_hvp[os_name] = hvs
               else:
                 for hv_name, hv_dict in hvs.items():
                   if hv_name not in self.new_os_hvp[os_name]:
                     self.new_os_hvp[os_name][hv_name] = hv_dict
                   else:
                     self.new_os_hvp[os_name][hv_name].update(hv_dict)
           # os parameters
           self.new_osp = objects.FillDict(cluster.osparams, {})
           if self.op.osparams:
             for os_name, osp in self.op.osparams.items():
               if os_name not in self.new_osp:
                 self.new_osp[os_name] = {}
               self.new_osp[os_name] = _GetUpdatedParams(self.new_osp[os_name], osp,
                                                         use_none=True)
               if not self.new_osp[os_name]:
                 # we removed all parameters
                 del self.new_osp[os_name]
               else:
                 # check the parameter validity (remote check)
                 _CheckOSParams(self, False, [self.cfg.GetMasterNode()],
                                os_name, self.new_osp[os_name])
           # changes to the hypervisor list
           if self.op.enabled_hypervisors is not None:
             self.hv_list = self.op.enabled_hypervisors
             for hv in self.hv_list:
               # if the hypervisor doesn't already exist in the cluster
               # hvparams, we initialize it to empty, and then (in both
               # cases) we make sure to fill the defaults, as we might not
               # have a complete defaults list if the hypervisor wasn't
               # enabled before
               if hv not in new_hvp:
                 new_hvp[hv] = {}
               new_hvp[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], new_hvp[hv])
               utils.ForceDictType(new_hvp[hv], constants.HVS_PARAMETER_TYPES)
           else:
             self.hv_list = cluster.enabled_hypervisors
           if self.op.hvparams or self.op.enabled_hypervisors is not None:
             # either the enabled list has changed, or the parameters have, validate
             for hv_name, hv_params in self.new_hvparams.items():
               if ((self.op.hvparams and hv_name in self.op.hvparams) or
                   (self.op.enabled_hypervisors and
                    hv_name in self.op.enabled_hypervisors)):
                 # either this is a new hypervisor, or its parameters have changed
                 hv_class = hypervisor.GetHypervisor(hv_name)
                 utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
                 hv_class.CheckParameterSyntax(hv_params)
                 _CheckHVParams(self, node_list, hv_name, hv_params)
           if self.op.os_hvp:
             # no need to check any newly-enabled hypervisors, since the
             # defaults have already been checked in the above code-block
             for os_name, os_hvp in self.new_os_hvp.items():
               for hv_name, hv_params in os_hvp.items():
                 utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)
                 # we need to fill in the new os_hvp on top of the actual hv_p
                 cluster_defaults = self.new_hvparams.get(hv_name, {})
                 new_osp = objects.FillDict(cluster_defaults, hv_params)
                 hv_class = hypervisor.GetHypervisor(hv_name)
                 hv_class.CheckParameterSyntax(new_osp)
                 _CheckHVParams(self, node_list, hv_name, new_osp)
           if self.op.default_iallocator:
             alloc_script = utils.FindFile(self.op.default_iallocator,
                                           constants.IALLOCATOR_SEARCH_PATH,
                                           os.path.isfile)
             if alloc_script is None:
               raise errors.OpPrereqError("Invalid default iallocator script '%s'"
                                          " specified" % self.op.default_iallocator,
                                          errors.ECODE_INVAL)
         def Exec(self, feedback_fn):
           """Change the parameters of the cluster.
           """
           if self.op.vg_name is not None:
             new_volume = self.op.vg_name
             if not new_volume:
               new_volume = None
             if new_volume != self.cfg.GetVGName():
               self.cfg.SetVGName(new_volume)
             else:
               feedback_fn("Cluster LVM configuration already in desired"
                           " state, not changing")
           if self.op.drbd_helper is not None:
             new_helper = self.op.drbd_helper
             if not new_helper:
               new_helper = None
             if new_helper != self.cfg.GetDRBDHelper():
               self.cfg.SetDRBDHelper(new_helper)
             else:
               feedback_fn("Cluster DRBD helper already in desired state,"
                           " not changing")
           if self.op.hvparams:
             self.cluster.hvparams = self.new_hvparams
           if self.op.os_hvp:
             self.cluster.os_hvp = self.new_os_hvp
           if self.op.enabled_hypervisors is not None:
             self.cluster.hvparams = self.new_hvparams
             self.cluster.enabled_hypervisors = self.op.enabled_hypervisors
           if self.op.beparams:
             self.cluster.beparams[constants.PP_DEFAULT] = self.new_beparams
           if self.op.nicparams:
             self.cluster.nicparams[constants.PP_DEFAULT] = self.new_nicparams
           if self.op.osparams:
             self.cluster.osparams = self.new_osp
           if self.op.ndparams:
             self.cluster.ndparams = self.new_ndparams
           if self.op.candidate_pool_size is not None:
             self.cluster.candidate_pool_size = self.op.candidate_pool_size
             # we need to update the pool size here, otherwise the save will fail
             _AdjustCandidatePool(self, [])
           if self.op.maintain_node_health is not None:
             self.cluster.maintain_node_health = self.op.maintain_node_health
           if self.op.prealloc_wipe_disks is not None:
             self.cluster.prealloc_wipe_disks = self.op.prealloc_wipe_disks
           if self.op.add_uids is not None:
             uidpool.AddToUidPool(self.cluster.uid_pool, self.op.add_uids)
           if self.op.remove_uids is not None:
             uidpool.RemoveFromUidPool(self.cluster.uid_pool, self.op.remove_uids)
           if self.op.uid_pool is not None:
             self.cluster.uid_pool = self.op.uid_pool
           if self.op.default_iallocator is not None:
             self.cluster.default_iallocator = self.op.default_iallocator
           if self.op.reserved_lvs is not None:
             self.cluster.reserved_lvs = self.op.reserved_lvs
           def helper_os(aname, mods, desc):
             desc += " OS list"
             lst = getattr(self.cluster, aname)
             for key, val in mods:
               if key == constants.DDM_ADD:
                 if val in lst:
                   feedback_fn("OS %s already in %s, ignoring" % (val, desc))
                 else:
                   lst.append(val)
               elif key == constants.DDM_REMOVE:
                 if val in lst:
                   lst.remove(val)
                 else:
                   feedback_fn("OS %s not found in %s, ignoring" % (val, desc))
               else:
                 raise errors.ProgrammerError("Invalid modification '%s'" % key)
           if self.op.hidden_os:
             helper_os("hidden_os", self.op.hidden_os, "hidden")
           if self.op.blacklisted_os:
             helper_os("blacklisted_os", self.op.blacklisted_os, "blacklisted")
           if self.op.master_netdev:
             master = self.cfg.GetMasterNode()
             feedback_fn("Shutting down master ip on the current netdev (%s)" %
                         self.cluster.master_netdev)
             result = self.rpc.call_node_stop_master(master, False)
             result.Raise("Could not disable the master ip")
             feedback_fn("Changing master_netdev from %s to %s" %
                         (self.cluster.master_netdev, self.op.master_netdev))
             self.cluster.master_netdev = self.op.master_netdev
           self.cfg.Update(self.cluster, feedback_fn)
           if self.op.master_netdev:
             feedback_fn("Starting the master ip on the new master netdev (%s)" %
                         self.op.master_netdev)
             result = self.rpc.call_node_start_master(master, False, False)
             if result.fail_msg:
               self.LogWarning("Could not re-enable the master ip on"
                               " the master, please restart manually: %s",
                               result.fail_msg)
       def _UploadHelper(lu, nodes, fname):
         """Helper for uploading a file and showing warnings.
         """
         if os.path.exists(fname):
           result = lu.rpc.call_upload_file(nodes, fname)
           for to_node, to_result in result.items():
             msg = to_result.fail_msg
             if msg:
               msg = ("Copy of file %s to node %s failed: %s" %
                      (fname, to_node, msg))
               lu.proc.LogWarning(msg)
       def _RedistributeAncillaryFiles(lu, additional_nodes=None, additional_vm=True):
         """Distribute additional files which are part of the cluster configuration.
         ConfigWriter takes care of distributing the config and ssconf files, but
         there are more files which should be distributed to all nodes. This function
         makes sure those are copied.
         @param lu: calling logical unit
         @param additional_nodes: list of nodes not in the config to distribute to
         @type additional_vm: boolean
         @param additional_vm: whether the additional nodes are vm-capable or not
         """
         # 1. Gather target nodes
         myself = lu.cfg.GetNodeInfo(lu.cfg.GetMasterNode())
         dist_nodes = lu.cfg.GetOnlineNodeList()
         nvm_nodes = lu.cfg.GetNonVmCapableNodeList()
         vm_nodes = [name for name in dist_nodes if name not in nvm_nodes]
         if additional_nodes is not None:
           dist_nodes.extend(additional_nodes)
           if additional_vm:
             vm_nodes.extend(additional_nodes)
         if myself.name in dist_nodes:
           dist_nodes.remove(myself.name)
         if myself.name in vm_nodes:
           vm_nodes.remove(myself.name)
         # 2. Gather files to distribute
         dist_files = set([constants.ETC_HOSTS,
                           constants.SSH_KNOWN_HOSTS_FILE,
                           constants.RAPI_CERT_FILE,
                           constants.RAPI_USERS_FILE,
                           constants.CONFD_HMAC_KEY,
                           constants.CLUSTER_DOMAIN_SECRET_FILE,
                          ])
         vm_files = set()
         enabled_hypervisors = lu.cfg.GetClusterInfo().enabled_hypervisors
         for hv_name in enabled_hypervisors:
           hv_class = hypervisor.GetHypervisor(hv_name)
           vm_files.update(hv_class.GetAncillaryFiles())
         # 3. Perform the files upload
         for fname in dist_files:
           _UploadHelper(lu, dist_nodes, fname)
         for fname in vm_files:
           _UploadHelper(lu, vm_nodes, fname)
       class LUClusterRedistConf(NoHooksLU):
         """Force the redistribution of cluster configuration.
         This is a very simple LU.
         """
         REQ_BGL = False
         def ExpandNames(self):
           self.needed_locks = {
             locking.LEVEL_NODE: locking.ALL_SET,
+          }
           self.share_locks[locking.LEVEL_NODE] = 1
         def Exec(self, feedback_fn):
           """Redistribute the configuration.
           """
           self.cfg.Update(self.cfg.GetClusterInfo(), feedback_fn)
           _RedistributeAncillaryFiles(self)
       def _WaitForSync(lu, instance, disks=None, oneshot=False):
         """Sleep and poll for an instance's disk to sync.
         """
         if not instance.disks or disks is not None and not disks:
           return True
         disks = _ExpandCheckDisks(instance, disks)
         if not oneshot:
           lu.proc.LogInfo("Waiting for instance %s to sync disks." % instance.name)
         node = instance.primary_node
         for dev in disks:
           lu.cfg.SetDiskID(dev, node)
         # TODO: Convert to utils.Retry
         retries = 0
         degr_retries = 10 # in seconds, as we sleep 1 second each time
         while True:
           max_time = 0
           done = True
           cumul_degraded = False
           rstats = lu.rpc.call_blockdev_getmirrorstatus(node, disks)
           msg = rstats.fail_msg
           if msg:
             lu.LogWarning("Can't get any data from node %s: %s", node, msg)
             retries += 1
             if retries >= 10:
               raise errors.RemoteError("Can't contact node %s for mirror data,"
                                        " aborting." % node)
             time.sleep(6)
             continue
           rstats = rstats.payload
           retries = 0
           for i, mstat in enumerate(rstats):
             if mstat is None:
               lu.LogWarning("Can't compute data for node %s/%s",
                                  node, disks[i].iv_name)
               continue
             cumul_degraded = (cumul_degraded or
                               (mstat.is_degraded and mstat.sync_percent is None))
             if mstat.sync_percent is not None:
               done = False
               if mstat.estimated_time is not None:
                 rem_time = ("%s remaining (estimated)" %
                             utils.FormatSeconds(mstat.estimated_time))
                 max_time = mstat.estimated_time
               else:
                 rem_time = "no time estimate"
               lu.proc.LogInfo("- device %s: %5.2f%% done, %s" %
                               (disks[i].iv_name, mstat.sync_percent, rem_time))
           # if we're done but degraded, let's do a few small retries, to
           # make sure we see a stable and not transient situation; therefore
           # we force restart of the loop
           if (done or oneshot) and cumul_degraded and degr_retries > 0:
             logging.info("Degraded disks found, %d retries left", degr_retries)
             degr_retries -= 1
             time.sleep(1)
             continue
           if done or oneshot:
             break
           time.sleep(min(60, max_time))
         if done:
           lu.proc.LogInfo("Instance %s's disks are in sync." % instance.name)
         return not cumul_degraded
       def _CheckDiskConsistency(lu, dev, node, on_primary, ldisk=False):
         """Check that mirrors are not degraded.
         The ldisk parameter, if True, will change the test from the
         is_degraded attribute (which represents overall non-ok status for
         the device(s)) to the ldisk (representing the local storage status).
         """
         lu.cfg.SetDiskID(dev, node)
         result = True
         if on_primary or dev.AssembleOnSecondary():
           rstats = lu.rpc.call_blockdev_find(node, dev)
           msg = rstats.fail_msg
           if msg:
             lu.LogWarning("Can't find disk on node %s: %s", node, msg)
             result = False
           elif not rstats.payload:
             lu.LogWarning("Can't find disk on node %s", node)
             result = False
           else:
             if ldisk:
               result = result and rstats.payload.ldisk_status == constants.LDS_OKAY
             else:
               result = result and not rstats.payload.is_degraded
         if dev.children:
           for child in dev.children:
             result = result and _CheckDiskConsistency(lu, child, node, on_primary)
         return result
       class LUOobCommand(NoHooksLU):
         """Logical unit for OOB handling.
         """
         REG_BGL = False
         def CheckPrereq(self):
           """Check prerequisites.
           This checks:
            - the node exists in the configuration
            - OOB is supported
           Any errors are signaled by raising errors.OpPrereqError.
           """
           self.nodes = []
           for node_name in self.op.node_names:
             node = self.cfg.GetNodeInfo(node_name)
             if node is None:
               raise errors.OpPrereqError("Node %s not found" % node_name,
                                          errors.ECODE_NOENT)
             else:
               self.nodes.append(node)
             if (self.op.command == constants.OOB_POWER_OFF and not node.offline):
               raise errors.OpPrereqError(("Cannot power off node %s because it is"
                                           " not marked offline") % node_name,
                                          errors.ECODE_STATE)
         def ExpandNames(self):
           """Gather locks we need.
           """
           if self.op.node_names:
             self.op.node_names = [_ExpandNodeName(self.cfg, name)
                                   for name in self.op.node_names]
           else:
             self.op.node_names = self.cfg.GetNodeList()
           self.needed_locks = {
             locking.LEVEL_NODE: self.op.node_names,
+            }
         def Exec(self, feedback_fn):
           """Execute OOB and return result if we expect any.
           """
           master_node = self.cfg.GetMasterNode()
           ret = []
           for node in self.nodes:
             node_entry = [(constants.RS_NORMAL, node.name)]
             ret.append(node_entry)
             oob_program = _SupportsOob(self.cfg, node)
             if not oob_program:
               node_entry.append((constants.RS_UNAVAIL, None))
               continue
             logging.info("Executing out-of-band command '%s' using '%s' on %s",
                          self.op.command, oob_program, node.name)
             result = self.rpc.call_run_oob(master_node, oob_program,
                                            self.op.command, node.name,
                                            self.op.timeout)
             if result.fail_msg:
               self.LogWarning("On node '%s' out-of-band RPC failed with: %s",
                               node.name, result.fail_msg)
               node_entry.append((constants.RS_NODATA, None))
             else:
               try:
                 self._CheckPayload(result)
               except errors.OpExecError, err:
                 self.LogWarning("The payload returned by '%s' is not valid: %s",
                                 node.name, err)
                 node_entry.append((constants.RS_NODATA, None))
               else:
                 if self.op.command == constants.OOB_HEALTH:
                   # For health we should log important events
                   for item, status in result.payload:
                     if status in [constants.OOB_STATUS_WARNING,
                                   constants.OOB_STATUS_CRITICAL]:
                       self.LogWarning("On node '%s' item '%s' has status '%s'",
                                       node.name, item, status)
                 if self.op.command == constants.OOB_POWER_ON:
                   node.powered = True
                 elif self.op.command == constants.OOB_POWER_OFF:
                   node.powered = False
                 elif self.op.command == constants.OOB_POWER_STATUS:
                   powered = result.payload[constants.OOB_POWER_STATUS_POWERED]
                   if powered != node.powered:
                     logging.warning(("Recorded power state (%s) of node '%s' does not"
                                      " match actual power state (%s)"), node.powered,
                                     node.name, powered)
                 # For configuration changing commands we should update the node
                 if self.op.command in (constants.OOB_POWER_ON,
                                        constants.OOB_POWER_OFF):
                   self.cfg.Update(node, feedback_fn)
                 node_entry.append((constants.RS_NORMAL, result.payload))
           return ret
         def _CheckPayload(self, result):
           """Checks if the payload is valid.
           @param result: RPC result
           @raises errors.OpExecError: If payload is not valid
           """
           errs = []
           if self.op.command == constants.OOB_HEALTH:
             if not isinstance(result.payload, list):
               errs.append("command 'health' is expected to return a list but got %s" %
                           type(result.payload))
             else:
               for item, status in result.payload:
                 if status not in constants.OOB_STATUSES:
                   errs.append("health item '%s' has invalid status '%s'" %
                               (item, status))
           if self.op.command == constants.OOB_POWER_STATUS:
             if not isinstance(result.payload, dict):
               errs.append("power-status is expected to return a dict but got %s" %
                           type(result.payload))
           if self.op.command in [
               constants.OOB_POWER_ON,
               constants.OOB_POWER_OFF,
               constants.OOB_POWER_CYCLE,
               ]:
             if result.payload is not None:
               errs.append("%s is expected to not return payload but got '%s'" %
                           (self.op.command, result.payload))
           if errs:
             raise errors.OpExecError("Check of out-of-band payload failed due to %s" %
                                      utils.CommaJoin(errs))
       class LUOsDiagnose(NoHooksLU):
         """Logical unit for OS diagnose/query.
         """
         REQ_BGL = False
         _HID = "hidden"
         _BLK = "blacklisted"
         _VLD = "valid"
         _FIELDS_STATIC = utils.FieldSet()
         _FIELDS_DYNAMIC = utils.FieldSet("name", _VLD, "node_status", "variants",
                                          "parameters", "api_versions", _HID, _BLK)
         def CheckArguments(self):
           if self.op.names:
             raise errors.OpPrereqError("Selective OS query not supported",
                                        errors.ECODE_INVAL)
           _CheckOutputFields(static=self._FIELDS_STATIC,
                              dynamic=self._FIELDS_DYNAMIC,
                              selected=self.op.output_fields)
         def ExpandNames(self):
           # Lock all nodes, in shared mode
           # Temporary removal of locks, should be reverted later
           # TODO: reintroduce locks when they are lighter-weight
           self.needed_locks = {}
           #self.share_locks[locking.LEVEL_NODE] = 1
           #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
         @staticmethod
         def _DiagnoseByOS(rlist):
           """Remaps a per-node return list into an a per-os per-node dictionary
           @param rlist: a map with node names as keys and OS objects as values
           @rtype: dict
           @return: a dictionary with osnames as keys and as value another
               map, with nodes as keys and tuples of (path, status, diagnose,
               variants, parameters, api_versions) as values, eg::
                 {"debian-etch": {"node1": [(/usr/lib/..., True, "", [], []),
                                            (/srv/..., False, "invalid api")],
                                  "node2": [(/srv/..., True, "", [], [])]}
+                }
           """
           all_os = {}
           # we build here the list of nodes that didn't fail the RPC (at RPC
           # level), so that nodes with a non-responding node daemon don't
           # make all OSes invalid
           good_nodes = [node_name for node_name in rlist
                         if not rlist[node_name].fail_msg]
           for node_name, nr in rlist.items():
             if nr.fail_msg or not nr.payload:
               continue
             for (name, path, status, diagnose, variants,
                  params, api_versions) in nr.payload:
               if name not in all_os:
                 # build a list of nodes for this os containing empty lists
                 # for each node in node_list
                 all_os[name] = {}
                 for nname in good_nodes:
                   all_os[name][nname] = []
               # convert params from [name, help] to (name, help)
               params = [tuple(v) for v in params]
               all_os[name][node_name].append((path, status, diagnose,
                                               variants, params, api_versions))
           return all_os
         def Exec(self, feedback_fn):
           """Compute the list of OSes.
           """
           valid_nodes = [node.name
                          for node in self.cfg.GetAllNodesInfo().values()
                          if not node.offline and node.vm_capable]
           node_data = self.rpc.call_os_diagnose(valid_nodes)
           pol = self._DiagnoseByOS(node_data)
           output = []
           cluster = self.cfg.GetClusterInfo()
           for os_name in utils.NiceSort(pol.keys()):
             os_data = pol[os_name]
             row = []
             valid = True
             (variants, params, api_versions) = null_state = (set(), set(), set())
             for idx, osl in enumerate(os_data.values()):
               valid = bool(valid and osl and osl[0][1])
               if not valid:
                 (variants, params, api_versions) = null_state
                 break
               node_variants, node_params, node_api = osl[0][3:6]
               if idx == 0: # first entry
                 variants = set(node_variants)
                 params = set(node_params)
                 api_versions = set(node_api)
               else: # keep consistency
                 variants.intersection_update(node_variants)
                 params.intersection_update(node_params)
                 api_versions.intersection_update(node_api)
             is_hid = os_name in cluster.hidden_os
             is_blk = os_name in cluster.blacklisted_os
             if ((self._HID not in self.op.output_fields and is_hid) or
                 (self._BLK not in self.op.output_fields and is_blk) or
                 (self._VLD not in self.op.output_fields and not valid)):
               continue
             for field in self.op.output_fields:
               if field == "name":
                 val = os_name
               elif field == self._VLD:
                 val = valid
               elif field == "node_status":
                 # this is just a copy of the dict
                 val = {}
                 for node_name, nos_list in os_data.items():
                   val[node_name] = nos_list
               elif field == "variants":
                 val = utils.NiceSort(list(variants))
               elif field == "parameters":
                 val = list(params)
               elif field == "api_versions":
                 val = list(api_versions)
               elif field == self._HID:
                 val = is_hid
               elif field == self._BLK:
                 val = is_blk
               else:
                 raise errors.ParameterError(field)
               row.append(val)
             output.append(row)
           return output
       class LUNodeRemove(LogicalUnit):
         """Logical unit for removing a node.
         """
         HPATH = "node-remove"
         HTYPE = constants.HTYPE_NODE
         def BuildHooksEnv(self):
           """Build hooks env.
           This doesn't run on the target node in the pre phase as a failed
           node would then be impossible to remove.
           """
           env = {
             "OP_TARGET": self.op.node_name,
             "NODE_NAME": self.op.node_name,
+            }
           all_nodes = self.cfg.GetNodeList()
           try:
             all_nodes.remove(self.op.node_name)
           except ValueError:
             logging.warning("Node %s which is about to be removed not found"
                             " in the all nodes list", self.op.node_name)
           return env, all_nodes, all_nodes
         def CheckPrereq(self):
           """Check prerequisites.
           This checks:
            - the node exists in the configuration
            - it does not have primary or secondary instances
            - it's not the master
           Any errors are signaled by raising errors.OpPrereqError.
           """
           self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
           node = self.cfg.GetNodeInfo(self.op.node_name)
           assert node is not None
           instance_list = self.cfg.GetInstanceList()
           masternode = self.cfg.GetMasterNode()
           if node.name == masternode:
             raise errors.OpPrereqError("Node is the master node,"
                                        " you need to failover first.",
                                        errors.ECODE_INVAL)
           for instance_name in instance_list:
             instance = self.cfg.GetInstanceInfo(instance_name)
             if node.name in instance.all_nodes:
               raise errors.OpPrereqError("Instance %s is still running on the node,"
                                          " please remove first." % instance_name,
                                          errors.ECODE_INVAL)
           self.op.node_name = node.name
           self.node = node
         def Exec(self, feedback_fn):
           """Removes the node from the cluster.
           """
           node = self.node
           logging.info("Stopping the node daemon and removing configs from node %s",
                        node.name)
           modify_ssh_setup = self.cfg.GetClusterInfo().modify_ssh_setup
           # Promote nodes to master candidate as needed
           _AdjustCandidatePool(self, exceptions=[node.name])
           self.context.RemoveNode(node.name)
           # Run post hooks on the node before it's removed
           hm = self.proc.hmclass(self.rpc.call_hooks_runner, self)
           try:
             hm.RunPhase(constants.HOOKS_PHASE_POST, [node.name])
           except:
             # pylint: disable-msg=W0702
             self.LogWarning("Errors occurred running hooks on %s" % node.name)
           result = self.rpc.call_node_leave_cluster(node.name, modify_ssh_setup)
           msg = result.fail_msg
           if msg:
             self.LogWarning("Errors encountered on the remote node while leaving"
                             " the cluster: %s", msg)
           # Remove node from our /etc/hosts
           if self.cfg.GetClusterInfo().modify_etc_hosts:
             master_node = self.cfg.GetMasterNode()
             result = self.rpc.call_etc_hosts_modify(master_node,
                                                     constants.ETC_HOSTS_REMOVE,
                                                     node.name, None)
             result.Raise("Can't update hosts file with new host data")
             _RedistributeAncillaryFiles(self)
       class _NodeQuery(_QueryBase):
         FIELDS = query.NODE_FIELDS
         def ExpandNames(self, lu):
           lu.needed_locks = {}
           lu.share_locks[locking.LEVEL_NODE] = 1
           if self.names:
             self.wanted = _GetWantedNodes(lu, self.names)
           else:
             self.wanted = locking.ALL_SET
           self.do_locking = (self.use_locking and
                              query.NQ_LIVE in self.requested_data)
           if self.do_locking:
             # if we don't request only static fields, we need to lock the nodes
             lu.needed_locks[locking.LEVEL_NODE] = self.wanted
         def DeclareLocks(self, lu, level):
           pass
         def _GetQueryData(self, lu):
           """Computes the list of nodes and their attributes.
           """
           all_info = lu.cfg.GetAllNodesInfo()
           nodenames = self._GetNames(lu, all_info.keys(), locking.LEVEL_NODE)
           # Gather data as requested
           if query.NQ_LIVE in self.requested_data:
             # filter out non-vm_capable nodes
             toquery_nodes = [name for name in nodenames if all_info[name].vm_capable]
             node_data = lu.rpc.call_node_info(toquery_nodes, lu.cfg.GetVGName(),
                                               lu.cfg.GetHypervisorType())
             live_data = dict((name, nresult.payload)
                              for (name, nresult) in node_data.items()
                              if not nresult.fail_msg and nresult.payload)
           else:
             live_data = None
           if query.NQ_INST in self.requested_data:
             node_to_primary = dict([(name, set()) for name in nodenames])
             node_to_secondary = dict([(name, set()) for name in nodenames])
             inst_data = lu.cfg.GetAllInstancesInfo()
             for inst in inst_data.values():
               if inst.primary_node in node_to_primary:
                 node_to_primary[inst.primary_node].add(inst.name)
               for secnode in inst.secondary_nodes:
                 if secnode in node_to_secondary:
                   node_to_secondary[secnode].add(inst.name)
           else:
             node_to_primary = None
             node_to_secondary = None
           if query.NQ_OOB in self.requested_data:
             oob_support = dict((name, bool(_SupportsOob(lu.cfg, node)))
                                for name, node in all_info.iteritems())
           else:
             oob_support = None
           if query.NQ_GROUP in self.requested_data:
             groups = lu.cfg.GetAllNodeGroupsInfo()
           else:
             groups = {}
           return query.NodeQueryData([all_info[name] for name in nodenames],
                                      live_data, lu.cfg.GetMasterNode(),
                                      node_to_primary, node_to_secondary, groups,
                                      oob_support, lu.cfg.GetClusterInfo())
       class LUNodeQuery(NoHooksLU):
         """Logical unit for querying nodes.
         """
         # pylint: disable-msg=W0142
         REQ_BGL = False
         def CheckArguments(self):
           self.nq = _NodeQuery(self.op.names, self.op.output_fields,
                                self.op.use_locking)
         def ExpandNames(self):
           self.nq.ExpandNames(self)
         def Exec(self, feedback_fn):
           return self.nq.OldStyleQuery(self)
       class LUNodeQueryvols(NoHooksLU):
         """Logical unit for getting volumes on node(s).
         """
         REQ_BGL = False
         _FIELDS_DYNAMIC = utils.FieldSet("phys", "vg", "name", "size", "instance")
         _FIELDS_STATIC = utils.FieldSet("node")
         def CheckArguments(self):
           _CheckOutputFields(static=self._FIELDS_STATIC,
                              dynamic=self._FIELDS_DYNAMIC,
                              selected=self.op.output_fields)
         def ExpandNames(self):
           self.needed_locks = {}
           self.share_locks[locking.LEVEL_NODE] = 1
           if not self.op.nodes:
             self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
           else:
             self.needed_locks[locking.LEVEL_NODE] = \
               _GetWantedNodes(self, self.op.nodes)
         def Exec(self, feedback_fn):
           """Computes the list of nodes and their attributes.
           """
           nodenames = self.acquired_locks[locking.LEVEL_NODE]
           volumes = self.rpc.call_node_volumes(nodenames)
           ilist = [self.cfg.GetInstanceInfo(iname) for iname
                    in self.cfg.GetInstanceList()]
           lv_by_node = dict([(inst, inst.MapLVsByNode()) for inst in ilist])
           output = []
           for node in nodenames:
             nresult = volumes[node]
             if nresult.offline:
               continue
             msg = nresult.fail_msg
             if msg:
               self.LogWarning("Can't compute volume data on node %s: %s", node, msg)
               continue
             node_vols = nresult.payload[:]
             node_vols.sort(key=lambda vol: vol['dev'])
             for vol in node_vols:
               node_output = []
               for field in self.op.output_fields:
                 if field == "node":
                   val = node
                 elif field == "phys":
                   val = vol['dev']
                 elif field == "vg":
                   val = vol['vg']
                 elif field == "name":
                   val = vol['name']
                 elif field == "size":
                   val = int(float(vol['size']))
                 elif field == "instance":
                   for inst in ilist:
                     if node not in lv_by_node[inst]:
                       continue
                     if vol['name'] in lv_by_node[inst][node]:
                       val = inst.name
                       break
                   else:
                     val = '-'
                 else:
                   raise errors.ParameterError(field)
                 node_output.append(str(val))
               output.append(node_output)
           return output
       class LUNodeQueryStorage(NoHooksLU):
         """Logical unit for getting information on storage units on node(s).
         """
         _FIELDS_STATIC = utils.FieldSet(constants.SF_NODE)
         REQ_BGL = False
         def CheckArguments(self):
           _CheckOutputFields(static=self._FIELDS_STATIC,
                              dynamic=utils.FieldSet(*constants.VALID_STORAGE_FIELDS),
                              selected=self.op.output_fields)
         def ExpandNames(self):
           self.needed_locks = {}
           self.share_locks[locking.LEVEL_NODE] = 1
           if self.op.nodes:
             self.needed_locks[locking.LEVEL_NODE] = \
               _GetWantedNodes(self, self.op.nodes)
           else:
             self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
         def Exec(self, feedback_fn):
           """Computes the list of nodes and their attributes.
           """
           self.nodes = self.acquired_locks[locking.LEVEL_NODE]
           # Always get name to sort by
           if constants.SF_NAME in self.op.output_fields:
             fields = self.op.output_fields[:]
           else:
             fields = [constants.SF_NAME] + self.op.output_fields
           # Never ask for node or type as it's only known to the LU
           for extra in [constants.SF_NODE, constants.SF_TYPE]:
             while extra in fields:
               fields.remove(extra)
           field_idx = dict([(name, idx) for (idx, name) in enumerate(fields)])
           name_idx = field_idx[constants.SF_NAME]
           st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
           data = self.rpc.call_storage_list(self.nodes,
                                             self.op.storage_type, st_args,
                                             self.op.name, fields)
           result = []
           for node in utils.NiceSort(self.nodes):
             nresult = data[node]
             if nresult.offline:
               continue
             msg = nresult.fail_msg
             if msg:
               self.LogWarning("Can't get storage data from node %s: %s", node, msg)
               continue
             rows = dict([(row[name_idx], row) for row in nresult.payload])
             for name in utils.NiceSort(rows.keys()):
               row = rows[name]
               out = []
               for field in self.op.output_fields:
                 if field == constants.SF_NODE:
                   val = node
                 elif field == constants.SF_TYPE:
                   val = self.op.storage_type
                 elif field in field_idx:
                   val = row[field_idx[field]]
                 else:
                   raise errors.ParameterError(field)
                 out.append(val)
               result.append(out)
           return result
       class _InstanceQuery(_QueryBase):
         FIELDS = query.INSTANCE_FIELDS
         def ExpandNames(self, lu):
           lu.needed_locks = {}
           lu.share_locks[locking.LEVEL_INSTANCE] = 1
           lu.share_locks[locking.LEVEL_NODE] = 1
           if self.names:
             self.wanted = _GetWantedInstances(lu, self.names)
           else:
             self.wanted = locking.ALL_SET
           self.do_locking = (self.use_locking and
                              query.IQ_LIVE in self.requested_data)
           if self.do_locking:
             lu.needed_locks[locking.LEVEL_INSTANCE] = self.wanted
             lu.needed_locks[locking.LEVEL_NODE] = []
             lu.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
         def DeclareLocks(self, lu, level):
           if level == locking.LEVEL_NODE and self.do_locking:
             lu._LockInstancesNodes() # pylint: disable-msg=W0212
         def _GetQueryData(self, lu):
           """Computes the list of instances and their attributes.
           """
           cluster = lu.cfg.GetClusterInfo()
           all_info = lu.cfg.GetAllInstancesInfo()
           instance_names = self._GetNames(lu, all_info.keys(), locking.LEVEL_INSTANCE)
           instance_list = [all_info[name] for name in instance_names]
           nodes = frozenset(itertools.chain(*(inst.all_nodes
                                               for inst in instance_list)))
           hv_list = list(set([inst.hypervisor for inst in instance_list]))
           bad_nodes = []
           offline_nodes = []
           wrongnode_inst = set()
           # Gather data as requested
           if self.requested_data & set([query.IQ_LIVE, query.IQ_CONSOLE]):
             live_data = {}
             node_data = lu.rpc.call_all_instances_info(nodes, hv_list)
             for name in nodes:
               result = node_data[name]
               if result.offline:
                 # offline nodes will be in both lists
                 assert result.fail_msg
                 offline_nodes.append(name)
               if result.fail_msg:
                 bad_nodes.append(name)
               elif result.payload:
                 for inst in result.payload:
                   if inst in all_info:
                     if all_info[inst].primary_node == name:
                       live_data.update(result.payload)
                     else:
                       wrongnode_inst.add(inst)
                   else:
                     # orphan instance; we don't list it here as we don't
                     # handle this case yet in the output of instance listing
                     logging.warning("Orphan instance '%s' found on node %s",
                                     inst, name)
               # else no instance is alive
           else:
             live_data = {}
           if query.IQ_DISKUSAGE in self.requested_data:
             disk_usage = dict((inst.name,
                                _ComputeDiskSize(inst.disk_template,
                                                 [{"size": disk.size}
                                                  for disk in inst.disks]))
                               for inst in instance_list)
           else:
             disk_usage = None
           if query.IQ_CONSOLE in self.requested_data:
             consinfo = {}
             for inst in instance_list:
               if inst.name in live_data:
                 # Instance is running
                 consinfo[inst.name] = _GetInstanceConsole(cluster, inst)
               else:
                 consinfo[inst.name] = None
             assert set(consinfo.keys()) == set(instance_names)
           else:
             consinfo = None
           return query.InstanceQueryData(instance_list, lu.cfg.GetClusterInfo(),
                                          disk_usage, offline_nodes, bad_nodes,
                                          live_data, wrongnode_inst, consinfo)
       class LUQuery(NoHooksLU):
         """Query for resources/items of a certain kind.
         """
         # pylint: disable-msg=W0142
         REQ_BGL = False
         def CheckArguments(self):
           qcls = _GetQueryImplementation(self.op.what)
           names = qlang.ReadSimpleFilter("name", self.op.filter)
           self.impl = qcls(names, self.op.fields, False)
         def ExpandNames(self):
           self.impl.ExpandNames(self)
         def DeclareLocks(self, level):
           self.impl.DeclareLocks(self, level)
         def Exec(self, feedback_fn):
           return self.impl.NewStyleQuery(self)
       class LUQueryFields(NoHooksLU):
         """Query for resources/items of a certain kind.
         """
         # pylint: disable-msg=W0142
         REQ_BGL = False
         def CheckArguments(self):
           self.qcls = _GetQueryImplementation(self.op.what)
         def ExpandNames(self):
           self.needed_locks = {}
         def Exec(self, feedback_fn):
           return self.qcls.FieldsQuery(self.op.fields)
       class LUNodeModifyStorage(NoHooksLU):
         """Logical unit for modifying a storage volume on a node.
         """
         REQ_BGL = False
         def CheckArguments(self):
           self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
           storage_type = self.op.storage_type
           try:
             modifiable = constants.MODIFIABLE_STORAGE_FIELDS[storage_type]
           except KeyError:
             raise errors.OpPrereqError("Storage units of type '%s' can not be"
                                        " modified" % storage_type,
                                        errors.ECODE_INVAL)
           diff = set(self.op.changes.keys()) - modifiable
           if diff:
             raise errors.OpPrereqError("The following fields can not be modified for"
                                        " storage units of type '%s': %r" %
                                        (storage_type, list(diff)),
                                        errors.ECODE_INVAL)
         def ExpandNames(self):
           self.needed_locks = {
             locking.LEVEL_NODE: self.op.node_name,
+            }
         def Exec(self, feedback_fn):
           """Computes the list of nodes and their attributes.
           """
           st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
           result = self.rpc.call_storage_modify(self.op.node_name,
                                                 self.op.storage_type, st_args,
                                                 self.op.name, self.op.changes)
           result.Raise("Failed to modify storage unit '%s' on %s" %
                        (self.op.name, self.op.node_name))
       class LUNodeAdd(LogicalUnit):

Synnefo » snf-ganeti

root / lib / cmdlib.py @ 9b64e486