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

| Branch: | Tag: | Revision:

root / lib / cmdlib.py @ b726aff0

History | View | Annotate | Download (253 kB)

+      #
+      #
       # Copyright (C) 2006, 2007, 2008 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=W0613,W0201
       import os
       import os.path
       import time
       import tempfile
       import re
       import platform
       import logging
       import copy
       import random
       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 opcodes
       from ganeti import serializer
       from ganeti import ssconf
       class LogicalUnit(object):
         """Logical Unit base class.
         Subclasses must follow these rules:
           - implement ExpandNames
           - implement CheckPrereq
           - implement Exec
           - 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.
         """
         HPATH = None
         HTYPE = None
         _OP_REQP = []
         REQ_BGL = True
         def __init__(self, processor, op, context, rpc):
           """Constructor for LogicalUnit.
           This needs to be overriden 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(((i, 0) for i in locking.LEVELS))
           self.add_locks = {}
           self.remove_locks = {}
           # Used to force good behavior when calling helper functions
           self.recalculate_locks = {}
           self.__ssh = None
           # logging
           self.LogWarning = processor.LogWarning
           self.LogInfo = processor.LogInfo
           for attr_name in self._OP_REQP:
             attr_val = getattr(op, attr_name, None)
             if attr_val is None:
               raise errors.OpPrereqError("Required parameter '%s' missing" %
                                          attr_name)
           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 aquired 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, ecc. 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.
           Examples::
             # Acquire all nodes and one instance
             self.needed_locks = {
               locking.LEVEL_NODE: locking.ALL_SET,
               locking.LEVEL_INSTANCE: ['instance1.example.tld'],
+            }
             # Acquire just two nodes
             self.needed_locks = {
               locking.LEVEL_NODE: ['node1.example.tld', 'node2.example.tld'],
+            }
             # 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.
           """
           raise NotImplementedError
         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.
           """
           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
           """
           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"
           expanded_name = self.cfg.ExpandInstanceName(self.op.instance_name)
           if expanded_name is None:
             raise errors.OpPrereqError("Instance '%s' not known" %
                                         self.op.instance_name)
           self.needed_locks[locking.LEVEL_INSTANCE] = expanded_name
           self.op.instance_name = expanded_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):
         """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 _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.OpProgrammerError: if the nodes parameter is wrong type
         """
         if not isinstance(nodes, list):
           raise errors.OpPrereqError("Invalid argument type 'nodes'")
         if not nodes:
           raise errors.ProgrammerError("_GetWantedNodes should only be called with a"
             " non-empty list of nodes whose name is to be expanded.")
         wanted = []
         for name in nodes:
           node = lu.cfg.ExpandNodeName(name)
           if node is None:
             raise errors.OpPrereqError("No such node name '%s'" % name)
           wanted.append(node)
         return utils.NiceSort(wanted)
       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 not isinstance(instances, list):
           raise errors.OpPrereqError("Invalid argument type 'instances'")
         if instances:
           wanted = []
           for name in instances:
             instance = lu.cfg.ExpandInstanceName(name)
             if instance is None:
               raise errors.OpPrereqError("No such instance name '%s'" % name)
             wanted.append(instance)
         else:
           wanted = utils.NiceSort(lu.cfg.GetInstanceList())
         return wanted
       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))
       def _CheckBooleanOpField(op, name):
         """Validates boolean opcode parameters.
         This will ensure that an opcode parameter is either a boolean value,
         or None (but that it always exists).
         """
         val = getattr(op, name, None)
         if not (val is None or isinstance(val, bool)):
           raise errors.OpPrereqError("Invalid boolean parameter '%s' (%s)" %
                                      (name, str(val)))
         setattr(op, name, val)
       def _CheckNodeOnline(lu, node):
         """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
         @raise errors.OpPrereqError: if the node is offline
         """
         if lu.cfg.GetNodeInfo(node).offline:
           raise errors.OpPrereqError("Can't use offline node %s" % node)
       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)
       def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,
                                 memory, vcpus, nics, disk_template, disks):
         """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, bridge, mac) representing
             the NICs the instance  has
         @type disk_template: string
         @param disk_template: the distk template of the instance
         @type disks: list
         @param disks: the list of (size, mode) pairs
         @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,
+        }
         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
         return env
       def _PreBuildNICHooksList(lu, nics):
         """Build a list of nic information tuples.
         This list is suitable to be passed to _BuildInstanceHookEnv.
         @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 = []
         c_nicparams = lu.cfg.GetClusterInfo().nicparams[constants.PP_DEFAULT]
         for nic in nics:
           ip = nic.ip
           mac = nic.mac
           filled_params = objects.FillDict(c_nicparams, 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
         """
         bep = lu.cfg.GetClusterInfo().FillBE(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': _PreBuildNICHooksList(lu, instance.nics),
           'disk_template': instance.disk_template,
           'disks': [(disk.size, disk.mode) for disk in instance.disks],
+        }
         if override:
           args.update(override)
         return _BuildInstanceHookEnv(**args)
       def _AdjustCandidatePool(lu):
         """Adjust the candidate pool after node operations.
         """
         mod_list = lu.cfg.MaintainCandidatePool()
         if mod_list:
           lu.LogInfo("Promoted nodes to master candidate role: %s",
                      ", ".join(node.name for node in mod_list))
           for name in mod_list:
             lu.context.ReaddNode(name)
         mc_now, mc_max = lu.cfg.GetMasterCandidateStats()
         if mc_now > mc_max:
           lu.LogInfo("Note: more nodes are candidates (%d) than desired (%d)" %
                      (mc_now, mc_max))
       def _CheckNicsBridgesExist(lu, target_nics, target_node,
                                      profile=constants.PP_DEFAULT):
         """Check that the brigdes needed by a list of nics exist.
         """
         c_nicparams = lu.cfg.GetClusterInfo().nicparams[profile]
         paramslist = [objects.FillDict(c_nicparams, 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)
           msg = result.RemoteFailMsg()
           if msg:
             raise errors.OpPrereqError("Error checking bridges on destination node"
                                        " '%s': %s" % (target_node, msg))
       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)
       class LUDestroyCluster(NoHooksLU):
         """Logical unit for destroying the cluster.
         """
         _OP_REQP = []
         def CheckPrereq(self):
           """Check prerequisites.
           This checks whether the cluster is empty.
           Any errors are signalled 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))
           instancelist = self.cfg.GetInstanceList()
           if instancelist:
             raise errors.OpPrereqError("There are still %d instance(s) in"
                                        " this cluster." % len(instancelist))
         def Exec(self, feedback_fn):
           """Destroys the cluster.
           """
           master = self.cfg.GetMasterNode()
           result = self.rpc.call_node_stop_master(master, False)
           result.Raise()
           if not result.data:
             raise errors.OpExecError("Could not disable the master role")
           priv_key, pub_key, _ = ssh.GetUserFiles(constants.GANETI_RUNAS)
           utils.CreateBackup(priv_key)
           utils.CreateBackup(pub_key)
           return master
       class LUVerifyCluster(LogicalUnit):
         """Verifies the cluster status.
         """
         HPATH = "cluster-verify"
         HTYPE = constants.HTYPE_CLUSTER
         _OP_REQP = ["skip_checks"]
         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(((i, 1) for i in locking.LEVELS))
         def _VerifyNode(self, nodeinfo, file_list, local_cksum,
                         node_result, feedback_fn, master_files,
                         drbd_map, vg_name):
           """Run multiple tests against a node.
           Test list:
             - compares ganeti version
             - checks vg existance and size > 20G
             - checks config file checksum
             - checks ssh to other nodes
           @type nodeinfo: L{objects.Node}
           @param nodeinfo: the node to check
           @param file_list: required list of files
           @param local_cksum: dictionary of local files and their checksums
           @param node_result: the results from the node
           @param feedback_fn: function used to accumulate results
           @param master_files: list of files that only masters should have
           @param drbd_map: the useddrbd minors for this node, in
               form of minor: (instance, must_exist) which correspond to instances
               and their running status
           @param vg_name: Ganeti Volume Group (result of self.cfg.GetVGName())
           """
           node = nodeinfo.name
           # main result, node_result should be a non-empty dict
           if not node_result or not isinstance(node_result, dict):
             feedback_fn("  - ERROR: unable to verify node %s." % (node,))
             return True
           # compares ganeti version
           local_version = constants.PROTOCOL_VERSION
           remote_version = node_result.get('version', None)
           if not (remote_version and isinstance(remote_version, (list, tuple)) and
                   len(remote_version) == 2):
             feedback_fn("  - ERROR: connection to %s failed" % (node))
             return True
           if local_version != remote_version[0]:
             feedback_fn("  - ERROR: incompatible protocol versions: master %s,"
                         " node %s %s" % (local_version, node, remote_version[0]))
             return True
           # node seems compatible, we can actually try to look into its results
           bad = False
           # full package version
           if constants.RELEASE_VERSION != remote_version[1]:
             feedback_fn("  - WARNING: software version mismatch: master %s,"
                         " node %s %s" %
                         (constants.RELEASE_VERSION, node, remote_version[1]))
           # checks vg existence and size > 20G
           if vg_name is not None:
             vglist = node_result.get(constants.NV_VGLIST, None)
             if not vglist:
               feedback_fn("  - ERROR: unable to check volume groups on node %s." %
                               (node,))
               bad = True
             else:
               vgstatus = utils.CheckVolumeGroupSize(vglist, vg_name,
                                                     constants.MIN_VG_SIZE)
               if vgstatus:
                 feedback_fn("  - ERROR: %s on node %s" % (vgstatus, node))
                 bad = True
           # checks config file checksum
           remote_cksum = node_result.get(constants.NV_FILELIST, None)
           if not isinstance(remote_cksum, dict):
             bad = True
             feedback_fn("  - ERROR: node hasn't returned file checksum data")
           else:
             for file_name in file_list:
               node_is_mc = nodeinfo.master_candidate
               must_have_file = file_name not in master_files
               if file_name not in remote_cksum:
                 if node_is_mc or must_have_file:
                   bad = True
                   feedback_fn("  - ERROR: file '%s' missing" % file_name)
               elif remote_cksum[file_name] != local_cksum[file_name]:
                 if node_is_mc or must_have_file:
                   bad = True
                   feedback_fn("  - ERROR: file '%s' has wrong checksum" % file_name)
                 else:
                   # not candidate and this is not a must-have file
                   bad = True
                   feedback_fn("  - ERROR: non master-candidate has old/wrong file"
                               " '%s'" % file_name)
               else:
                 # all good, except non-master/non-must have combination
                 if not node_is_mc and not must_have_file:
                   feedback_fn("  - ERROR: file '%s' should not exist on non master"
                               " candidates" % file_name)
           # checks ssh to any
           if constants.NV_NODELIST not in node_result:
             bad = True
             feedback_fn("  - ERROR: node hasn't returned node ssh connectivity data")
           else:
             if node_result[constants.NV_NODELIST]:
               bad = True
               for node in node_result[constants.NV_NODELIST]:
                 feedback_fn("  - ERROR: ssh communication with node '%s': %s" %
                                 (node, node_result[constants.NV_NODELIST][node]))
           if constants.NV_NODENETTEST not in node_result:
             bad = True
             feedback_fn("  - ERROR: node hasn't returned node tcp connectivity data")
           else:
             if node_result[constants.NV_NODENETTEST]:
               bad = True
               nlist = utils.NiceSort(node_result[constants.NV_NODENETTEST].keys())
               for node in nlist:
                 feedback_fn("  - ERROR: tcp communication with node '%s': %s" %
                                 (node, node_result[constants.NV_NODENETTEST][node]))
           hyp_result = node_result.get(constants.NV_HYPERVISOR, None)
           if isinstance(hyp_result, dict):
             for hv_name, hv_result in hyp_result.iteritems():
               if hv_result is not None:
                 feedback_fn("  - ERROR: hypervisor %s verify failure: '%s'" %
                             (hv_name, hv_result))
           # check used drbd list
           if vg_name is not None:
             used_minors = node_result.get(constants.NV_DRBDLIST, [])
             if not isinstance(used_minors, (tuple, list)):
               feedback_fn("  - ERROR: cannot parse drbd status file: %s" %
                           str(used_minors))
             else:
               for minor, (iname, must_exist) in drbd_map.items():
                 if minor not in used_minors and must_exist:
                   feedback_fn("  - ERROR: drbd minor %d of instance %s is"
                               " not active" % (minor, iname))
                   bad = True
               for minor in used_minors:
                 if minor not in drbd_map:
                   feedback_fn("  - ERROR: unallocated drbd minor %d is in use" %
                               minor)
                   bad = True
           return bad
         def _VerifyInstance(self, instance, instanceconfig, node_vol_is,
                             node_instance, feedback_fn, n_offline):
           """Verify an instance.
           This function checks to see if the required block devices are
           available on the instance's node.
           """
           bad = False
           node_current = instanceconfig.primary_node
           node_vol_should = {}
           instanceconfig.MapLVsByNode(node_vol_should)
           for node in node_vol_should:
             if node in n_offline:
               # ignore missing volumes on offline nodes
               continue
             for volume in node_vol_should[node]:
               if node not in node_vol_is or volume not in node_vol_is[node]:
                 feedback_fn("  - ERROR: volume %s missing on node %s" %
                                 (volume, node))
                 bad = True
           if instanceconfig.admin_up:
             if ((node_current not in node_instance or
                 not instance in node_instance[node_current]) and
                 node_current not in n_offline):
               feedback_fn("  - ERROR: instance %s not running on node %s" %
                               (instance, node_current))
               bad = True
           for node in node_instance:
             if (not node == node_current):
               if instance in node_instance[node]:
                 feedback_fn("  - ERROR: instance %s should not run on node %s" %
                                 (instance, node))
                 bad = True
           return bad
         def _VerifyOrphanVolumes(self, node_vol_should, node_vol_is, feedback_fn):
           """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.
           """
           bad = False
           for node in node_vol_is:
             for volume in node_vol_is[node]:
               if node not in node_vol_should or volume not in node_vol_should[node]:
                 feedback_fn("  - ERROR: volume %s on node %s should not exist" %
                             (volume, node))
                 bad = True
           return bad
         def _VerifyOrphanInstances(self, instancelist, node_instance, feedback_fn):
           """Verify the list of running instances.
           This checks what instances are running but unknown to the cluster.
           """
           bad = False
           for node in node_instance:
             for runninginstance in node_instance[node]:
               if runninginstance not in instancelist:
                 feedback_fn("  - ERROR: instance %s on node %s should not exist" %
                                 (runninginstance, node))
                 bad = True
           return bad
         def _VerifyNPlusOneMemory(self, node_info, instance_cfg, feedback_fn):
           """Verify N+1 Memory Resilience.
           Check that if one single node dies we can still start all the instances it
           was primary for.
           """
           bad = False
           for node, nodeinfo in node_info.iteritems():
             # 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.
             for prinode, instances in nodeinfo['sinst-by-pnode'].iteritems():
               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]
               if nodeinfo['mfree'] < needed_mem:
                 feedback_fn("  - ERROR: not enough memory on node %s to accomodate"
                             " failovers should node %s fail" % (node, prinode))
                 bad = True
           return bad
         def CheckPrereq(self):
           """Check prerequisites.
           Transform the list of checks we're going to skip into a set and check that
           all its members are valid.
           """
           self.skip_set = frozenset(self.op.skip_checks)
           if not constants.VERIFY_OPTIONAL_CHECKS.issuperset(self.skip_set):
             raise errors.OpPrereqError("Invalid checks to be skipped specified")
         def BuildHooksEnv(self):
           """Build hooks env.
           Cluster-Verify hooks just rone 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.
           """
           bad = False
           feedback_fn("* Verifying global settings")
           for msg in self.cfg.VerifyConfig():
             feedback_fn("  - ERROR: %s" % msg)
           vg_name = self.cfg.GetVGName()
           hypervisors = self.cfg.GetClusterInfo().enabled_hypervisors
           nodelist = utils.NiceSort(self.cfg.GetNodeList())
           nodeinfo = [self.cfg.GetNodeInfo(nname) for nname in nodelist]
           instancelist = utils.NiceSort(self.cfg.GetInstanceList())
           instanceinfo = dict((iname, self.cfg.GetInstanceInfo(iname))
                               for iname in instancelist)
           i_non_redundant = [] # Non redundant instances
           i_non_a_balanced = [] # Non auto-balanced instances
           n_offline = [] # List of offline nodes
           n_drained = [] # List of nodes being drained
           node_volume = {}
           node_instance = {}
           node_info = {}
           instance_cfg = {}
           # FIXME: verify OS list
           # do local checksums
           master_files = [constants.CLUSTER_CONF_FILE]
           file_names = ssconf.SimpleStore().GetFileList()
           file_names.append(constants.SSL_CERT_FILE)
           file_names.append(constants.RAPI_CERT_FILE)
           file_names.extend(master_files)
           local_checksums = utils.FingerprintFiles(file_names)
           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_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(),
+            }
           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_DRBDLIST] = None
           all_nvinfo = self.rpc.call_node_verify(nodelist, node_verify_param,
                                                  self.cfg.GetClusterName())
           cluster = self.cfg.GetClusterInfo()
           master_node = self.cfg.GetMasterNode()
           all_drbd_map = self.cfg.ComputeDRBDMap()
           for node_i in nodeinfo:
             node = node_i.name
             if node_i.offline:
               feedback_fn("* Skipping offline node %s" % (node,))
               n_offline.append(node)
               continue
             if node == master_node:
               ntype = "master"
             elif node_i.master_candidate:
               ntype = "master candidate"
             elif node_i.drained:
               ntype = "drained"
               n_drained.append(node)
             else:
               ntype = "regular"
             feedback_fn("* Verifying node %s (%s)" % (node, ntype))
             msg = all_nvinfo[node].RemoteFailMsg()
             if msg:
               feedback_fn("  - ERROR: while contacting node %s: %s" % (node, msg))
               bad = True
               continue
             nresult = all_nvinfo[node].payload
             node_drbd = {}
             for minor, instance in all_drbd_map[node].items():
               if instance not in instanceinfo:
                 feedback_fn("  - ERROR: 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)
                 node_drbd[minor] = (instance, False)
               else:
                 instance = instanceinfo[instance]
                 node_drbd[minor] = (instance.name, instance.admin_up)
             result = self._VerifyNode(node_i, file_names, local_checksums,
                                       nresult, feedback_fn, master_files,
                                       node_drbd, vg_name)
             bad = bad or result
             lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")
             if vg_name is None:
               node_volume[node] = {}
             elif isinstance(lvdata, basestring):
               feedback_fn("  - ERROR: LVM problem on node %s: %s" %
                           (node, utils.SafeEncode(lvdata)))
               bad = True
               node_volume[node] = {}
             elif not isinstance(lvdata, dict):
               feedback_fn("  - ERROR: connection to %s failed (lvlist)" % (node,))
               bad = True
               continue
             else:
               node_volume[node] = lvdata
             # node_instance
             idata = nresult.get(constants.NV_INSTANCELIST, None)
             if not isinstance(idata, list):
               feedback_fn("  - ERROR: connection to %s failed (instancelist)" %
                           (node,))
               bad = True
               continue
             node_instance[node] = idata
             # node_info
             nodeinfo = nresult.get(constants.NV_HVINFO, None)
             if not isinstance(nodeinfo, dict):
               feedback_fn("  - ERROR: connection to %s failed (hvinfo)" % (node,))
               bad = True
               continue
             try:
               node_info[node] = {
                 "mfree": int(nodeinfo['memory_free']),
                 "pinst": [],
                 "sinst": [],
                 # dictionary holding all instances this node is secondary for,
                 # grouped by their primary node. Each key is a cluster node, and each
                 # value is a list of instances which have the key as primary and the
                 # current node as secondary.  this is handy to calculate N+1 memory
                 # availability if you can only failover from a primary to its
                 # secondary.
                 "sinst-by-pnode": {},
+              }
               # FIXME: devise a free space model for file based instances as well
               if vg_name is not None:
                 if (constants.NV_VGLIST not in nresult or
                     vg_name not in nresult[constants.NV_VGLIST]):
                   feedback_fn("  - ERROR: node %s didn't return data for the"
                               " volume group '%s' - it is either missing or broken" %
                               (node, vg_name))
                   bad = True
                   continue
                 node_info[node]["dfree"] = int(nresult[constants.NV_VGLIST][vg_name])
             except (ValueError, KeyError):
               feedback_fn("  - ERROR: invalid nodeinfo value returned"
                           " from node %s" % (node,))
               bad = True
               continue
           node_vol_should = {}
           for instance in instancelist:
             feedback_fn("* Verifying instance %s" % instance)
             inst_config = instanceinfo[instance]
             result =  self._VerifyInstance(instance, inst_config, node_volume,
                                            node_instance, feedback_fn, n_offline)
             bad = bad or result
             inst_nodes_offline = []
             inst_config.MapLVsByNode(node_vol_should)
             instance_cfg[instance] = inst_config
             pnode = inst_config.primary_node
             if pnode in node_info:
               node_info[pnode]['pinst'].append(instance)
             elif pnode not in n_offline:
               feedback_fn("  - ERROR: instance %s, connection to primary node"
                           " %s failed" % (instance, pnode))
               bad = True
             if pnode in n_offline:
               inst_nodes_offline.append(pnode)
             # 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 len(inst_config.secondary_nodes) == 0:
               i_non_redundant.append(instance)
             elif len(inst_config.secondary_nodes) > 1:
               feedback_fn("  - WARNING: multiple secondaries for instance %s"
                           % instance)
             if not cluster.FillBE(inst_config)[constants.BE_AUTO_BALANCE]:
               i_non_a_balanced.append(instance)
             for snode in inst_config.secondary_nodes:
               if snode in node_info:
                 node_info[snode]['sinst'].append(instance)
                 if pnode not in node_info[snode]['sinst-by-pnode']:
                   node_info[snode]['sinst-by-pnode'][pnode] = []
                 node_info[snode]['sinst-by-pnode'][pnode].append(instance)
               elif snode not in n_offline:
                 feedback_fn("  - ERROR: instance %s, connection to secondary node"
                             " %s failed" % (instance, snode))
                 bad = True
               if snode in n_offline:
                 inst_nodes_offline.append(snode)
             if inst_nodes_offline:
               # warn that the instance lives on offline nodes, and set bad=True
               feedback_fn("  - ERROR: instance lives on offline node(s) %s" %
                           ", ".join(inst_nodes_offline))
               bad = True
           feedback_fn("* Verifying orphan volumes")
           result = self._VerifyOrphanVolumes(node_vol_should, node_volume,
                                              feedback_fn)
           bad = bad or result
           feedback_fn("* Verifying remaining instances")
           result = self._VerifyOrphanInstances(instancelist, node_instance,
                                                feedback_fn)
           bad = bad or result
           if constants.VERIFY_NPLUSONE_MEM not in self.skip_set:
             feedback_fn("* Verifying N+1 Memory redundancy")
             result = self._VerifyNPlusOneMemory(node_info, instance_cfg, feedback_fn)
             bad = bad or result
           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." % len(n_offline))
           if n_drained:
             feedback_fn("  - NOTICE: %d drained node(s) found." % len(n_drained))
           return not bad
         def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):
           """Analize 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
             indent_re = re.compile('^', re.M)
             feedback_fn("* Hooks Results")
             if not hooks_results:
               feedback_fn("  - ERROR: general communication failure")
               lu_result = 1
             else:
               for node_name in hooks_results:
                 show_node_header = True
                 res = hooks_results[node_name]
                 if res.failed or res.data is False or not isinstance(res.data, list):
                   if res.offline:
                     # no need to warn or set fail return value
                     continue
                   feedback_fn("    Communication failure in hooks execution")
                   lu_result = 1
                   continue
                 for script, hkr, output in res.data:
                   if hkr == constants.HKR_FAIL:
                     # The node header is only shown once, if there are
                     # failing hooks on that node
                     if show_node_header:
                       feedback_fn("  Node %s:" % node_name)
                       show_node_header = False
                     feedback_fn("    ERROR: Script %s failed, output:" % script)
                     output = indent_re.sub('      ', output)
                     feedback_fn("%s" % output)
                     lu_result = 1
             return lu_result
       class LUVerifyDisks(NoHooksLU):
         """Verifies the cluster disks status.
         """
         _OP_REQP = []
         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(((i, 1) for i in locking.LEVELS))
         def CheckPrereq(self):
           """Check prerequisites.
           This has no prerequisites.
           """
           pass
         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 = {}, [], {}
           vg_name = self.cfg.GetVGName()
           nodes = utils.NiceSort(self.cfg.GetNodeList())
           instances = [self.cfg.GetInstanceInfo(name)
                        for name in self.cfg.GetInstanceList()]
           nv_dict = {}
           for inst in instances:
             inst_lvs = {}
             if (not inst.admin_up or
                 inst.disk_template not in constants.DTS_NET_MIRROR):
               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_volume_list(nodes, vg_name)
           to_act = set()
           for node in nodes:
             # node_volume
             node_res = node_lvs[node]
             if node_res.offline:
               continue
             msg = node_res.RemoteFailMsg()
             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_inactive, 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 LURenameCluster(LogicalUnit):
         """Rename the cluster.
         """
         HPATH = "cluster-rename"
         HTYPE = constants.HTYPE_CLUSTER
         _OP_REQP = ["name"]
         def BuildHooksEnv(self):
           """Build hooks env.
           """
           env = {
             "OP_TARGET": self.cfg.GetClusterName(),
             "NEW_NAME": self.op.name,
+            }
           mn = self.cfg.GetMasterNode()
           return env, [mn], [mn]
         def CheckPrereq(self):
           """Verify that the passed name is a valid one.
           """
           hostname = utils.HostInfo(self.op.name)
           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")
           if new_ip != old_ip:
             if utils.TcpPing(new_ip, constants.DEFAULT_NODED_PORT):
               raise errors.OpPrereqError("The given cluster IP address (%s) is"
                                          " reachable on the network. Aborting." %
                                          new_ip)
           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)
           if result.failed or not result.data:
             raise errors.OpExecError("Could not disable the master role")
           try:
             cluster = self.cfg.GetClusterInfo()
             cluster.cluster_name = clustername
             cluster.master_ip = ip
             self.cfg.Update(cluster)
             # update the known hosts file
             ssh.WriteKnownHostsFile(self.cfg, constants.SSH_KNOWN_HOSTS_FILE)
             node_list = self.cfg.GetNodeList()
             try:
               node_list.remove(master)
             except ValueError:
               pass
             result = self.rpc.call_upload_file(node_list,
                                                constants.SSH_KNOWN_HOSTS_FILE)
             for to_node, to_result in result.iteritems():
                msg = to_result.RemoteFailMsg()
                if msg:
                  msg = ("Copy of file %s to node %s failed: %s" %
                          (constants.SSH_KNOWN_HOSTS_FILE, to_node, msg))
                  self.proc.LogWarning(msg)
           finally:
             result = self.rpc.call_node_start_master(master, False)
             msg = result.RemoteFailMsg()
             if msg:
               self.LogWarning("Could not re-enable the master role on"
                               " the master, please restart manually: %s", msg)
       def _RecursiveCheckIfLVMBased(disk):
         """Check if the given disk or its children are lvm-based.
         @type disk: L{objects.Disk}
         @param disk: the disk to check
         @rtype: booleean
         @return: boolean indicating whether a LD_LV dev_type was found or not
         """
         if disk.children:
           for chdisk in disk.children:
             if _RecursiveCheckIfLVMBased(chdisk):
               return True
         return disk.dev_type == constants.LD_LV
       class LUSetClusterParams(LogicalUnit):
         """Change the parameters of the cluster.
         """
         HPATH = "cluster-modify"
         HTYPE = constants.HTYPE_CLUSTER
         _OP_REQP = []
         REQ_BGL = False
         def CheckArguments(self):
           """Check parameters
           """
           if not hasattr(self.op, "candidate_pool_size"):
             self.op.candidate_pool_size = None
           if self.op.candidate_pool_size is not None:
             try:
               self.op.candidate_pool_size = int(self.op.candidate_pool_size)
             except (ValueError, TypeError), err:
               raise errors.OpPrereqError("Invalid candidate_pool_size value: %s" %
                                          str(err))
             if self.op.candidate_pool_size < 1:
               raise errors.OpPrereqError("At least one master candidate needed")
         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:
             instances = self.cfg.GetAllInstancesInfo().values()
             for inst in instances:
               for disk in inst.disks:
                 if _RecursiveCheckIfLVMBased(disk):
                   raise errors.OpPrereqError("Cannot disable lvm storage while"
                                              " lvm-based instances exist")
           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].RemoteFailMsg()
               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))
           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 = objects.FillDict(
               cluster.beparams[constants.PP_DEFAULT], self.op.beparams)
           if self.op.nicparams:
             utils.ForceDictType(self.op.nicparams, constants.NICS_PARAMETER_TYPES)
             self.new_nicparams = objects.FillDict(
               cluster.nicparams[constants.PP_DEFAULT], self.op.nicparams)
             objects.NIC.CheckParameterSyntax(self.new_nicparams)
           # hypervisor list/parameters
           self.new_hvparams = objects.FillDict(cluster.hvparams, {})
           if self.op.hvparams:
             if not isinstance(self.op.hvparams, dict):
               raise errors.OpPrereqError("Invalid 'hvparams' parameter on input")
             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)
           if self.op.enabled_hypervisors is not None:
             self.hv_list = self.op.enabled_hypervisors
           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)
         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.hvparams:
             self.cluster.hvparams = self.new_hvparams
           if self.op.enabled_hypervisors is not None:
             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.candidate_pool_size is not None:
             self.cluster.candidate_pool_size = self.op.candidate_pool_size
           self.cfg.Update(self.cluster)
           # we want to update nodes after the cluster so that if any errors
           # happen, we have recorded and saved the cluster info
           if self.op.candidate_pool_size is not None:
             _AdjustCandidatePool(self)
       def _RedistributeAncillaryFiles(lu, additional_nodes=None):
         """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
         """
         # 1. Gather target nodes
         myself = lu.cfg.GetNodeInfo(lu.cfg.GetMasterNode())
         dist_nodes = lu.cfg.GetNodeList()
         if additional_nodes is not None:
           dist_nodes.extend(additional_nodes)
         if myself.name in dist_nodes:
           dist_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,
                          ])
         enabled_hypervisors = lu.cfg.GetClusterInfo().enabled_hypervisors
         for hv_name in enabled_hypervisors:
           hv_class = hypervisor.GetHypervisor(hv_name)
           dist_files.update(hv_class.GetAncillaryFiles())
         # 3. Perform the files upload
         for fname in dist_files:
           if os.path.exists(fname):
             result = lu.rpc.call_upload_file(dist_nodes, fname)
             for to_node, to_result in result.items():
                msg = to_result.RemoteFailMsg()
                if msg:
                  msg = ("Copy of file %s to node %s failed: %s" %
                          (fname, to_node, msg))
                  lu.proc.LogWarning(msg)
       class LURedistributeConfig(NoHooksLU):
         """Force the redistribution of cluster configuration.
         This is a very simple LU.
         """
         _OP_REQP = []
         REQ_BGL = False
         def ExpandNames(self):
           self.needed_locks = {
             locking.LEVEL_NODE: locking.ALL_SET,
+          }
           self.share_locks[locking.LEVEL_NODE] = 1
         def CheckPrereq(self):
           """Check prerequisites.
           """
         def Exec(self, feedback_fn):
           """Redistribute the configuration.
           """
           self.cfg.Update(self.cfg.GetClusterInfo())
           _RedistributeAncillaryFiles(self)
       def _WaitForSync(lu, instance, oneshot=False, unlock=False):
         """Sleep and poll for an instance's disk to sync.
         """
         if not instance.disks:
           return True
         if not oneshot:
           lu.proc.LogInfo("Waiting for instance %s to sync disks." % instance.name)
         node = instance.primary_node
         for dev in instance.disks:
           lu.cfg.SetDiskID(dev, node)
         retries = 0
         while True:
           max_time = 0
           done = True
           cumul_degraded = False
           rstats = lu.rpc.call_blockdev_getmirrorstatus(node, instance.disks)
           msg = rstats.RemoteFailMsg()
           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, instance.disks[i].iv_name)
               continue
             # we ignore the ldisk parameter
             perc_done, est_time, is_degraded, _ = mstat
             cumul_degraded = cumul_degraded or (is_degraded and perc_done is None)
             if perc_done is not None:
               done = False
               if est_time is not None:
                 rem_time = "%d estimated seconds remaining" % est_time
                 max_time = est_time
               else:
                 rem_time = "no time estimate"
               lu.proc.LogInfo("- device %s: %5.2f%% done, %s" %
                               (instance.disks[i].iv_name, perc_done, rem_time))
           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)
         if ldisk:
           idx = 6
         else:
           idx = 5
         result = True
         if on_primary or dev.AssembleOnSecondary():
           rstats = lu.rpc.call_blockdev_find(node, dev)
           msg = rstats.RemoteFailMsg()
           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:
             result = result and (not rstats.payload[idx])
         if dev.children:
           for child in dev.children:
             result = result and _CheckDiskConsistency(lu, child, node, on_primary)
         return result
       class LUDiagnoseOS(NoHooksLU):
         """Logical unit for OS diagnose/query.
         """
         _OP_REQP = ["output_fields", "names"]
         REQ_BGL = False
         _FIELDS_STATIC = utils.FieldSet()
         _FIELDS_DYNAMIC = utils.FieldSet("name", "valid", "node_status")
         def ExpandNames(self):
           if self.op.names:
             raise errors.OpPrereqError("Selective OS query not supported")
           _CheckOutputFields(static=self._FIELDS_STATIC,
                              dynamic=self._FIELDS_DYNAMIC,
                              selected=self.op.output_fields)
           # 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
         def CheckPrereq(self):
           """Check prerequisites.
           """
         @staticmethod
         def _DiagnoseByOS(node_list, rlist):
           """Remaps a per-node return list into an a per-os per-node dictionary
           @param node_list: a list with the names of all nodes
           @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 list of OS objects as values, eg::
                 {"debian-etch": {"node1": [<object>,...],
                                  "node2": [<object>,]}
+                }
           """
           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].failed]
           for node_name, nr in rlist.iteritems():
             if nr.failed or not nr.data:
               continue
             for os_obj in nr.data:
               if os_obj.name not in all_os:
                 # build a list of nodes for this os containing empty lists
                 # for each node in node_list
                 all_os[os_obj.name] = {}
                 for nname in good_nodes:
                   all_os[os_obj.name][nname] = []
               all_os[os_obj.name][node_name].append(os_obj)
           return all_os
         def Exec(self, feedback_fn):
           """Compute the list of OSes.
           """
           valid_nodes = [node for node in self.cfg.GetOnlineNodeList()]
           node_data = self.rpc.call_os_diagnose(valid_nodes)
           if node_data == False:
             raise errors.OpExecError("Can't gather the list of OSes")
           pol = self._DiagnoseByOS(valid_nodes, node_data)
           output = []
           for os_name, os_data in pol.iteritems():
             row = []
             for field in self.op.output_fields:
               if field == "name":
                 val = os_name
               elif field == "valid":
                 val = utils.all([osl and osl[0] for osl in os_data.values()])
               elif field == "node_status":
                 val = {}
                 for node_name, nos_list in os_data.iteritems():
                   val[node_name] = [(v.status, v.path) for v in nos_list]
               else:
                 raise errors.ParameterError(field)
               row.append(val)
             output.append(row)
           return output
       class LURemoveNode(LogicalUnit):
         """Logical unit for removing a node.
         """
         HPATH = "node-remove"
         HTYPE = constants.HTYPE_NODE
         _OP_REQP = ["node_name"]
         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()
           all_nodes.remove(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 signalled by raising errors.OpPrereqError.
           """
           node = self.cfg.GetNodeInfo(self.cfg.ExpandNodeName(self.op.node_name))
           if node is None:
             raise errors.OpPrereqError, ("Node '%s' is unknown." % self.op.node_name)
           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.")
           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)
           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)
           self.context.RemoveNode(node.name)
           self.rpc.call_node_leave_cluster(node.name)
           # Promote nodes to master candidate as needed
           _AdjustCandidatePool(self)
       class LUQueryNodes(NoHooksLU):
         """Logical unit for querying nodes.
         """
         _OP_REQP = ["output_fields", "names", "use_locking"]
         REQ_BGL = False
         _FIELDS_DYNAMIC = utils.FieldSet(
           "dtotal", "dfree",
           "mtotal", "mnode", "mfree",
           "bootid",
           "ctotal", "cnodes", "csockets",
+          )
         _FIELDS_STATIC = utils.FieldSet(
           "name", "pinst_cnt", "sinst_cnt",
           "pinst_list", "sinst_list",
           "pip", "sip", "tags",
           "serial_no",
           "master_candidate",
           "master",
           "offline",
           "drained",
+          )
         def ExpandNames(self):
           _CheckOutputFields(static=self._FIELDS_STATIC,
                              dynamic=self._FIELDS_DYNAMIC,
                              selected=self.op.output_fields)
           self.needed_locks = {}
           self.share_locks[locking.LEVEL_NODE] = 1
           if self.op.names:
             self.wanted = _GetWantedNodes(self, self.op.names)
           else:
             self.wanted = locking.ALL_SET
           self.do_node_query = self._FIELDS_STATIC.NonMatching(self.op.output_fields)
           self.do_locking = self.do_node_query and self.op.use_locking
           if self.do_locking:
             # if we don't request only static fields, we need to lock the nodes
             self.needed_locks[locking.LEVEL_NODE] = self.wanted
         def CheckPrereq(self):
           """Check prerequisites.
           """
           # The validation of the node list is done in the _GetWantedNodes,
           # if non empty, and if empty, there's no validation to do
           pass
         def Exec(self, feedback_fn):
           """Computes the list of nodes and their attributes.
           """
           all_info = self.cfg.GetAllNodesInfo()
           if self.do_locking:
             nodenames = self.acquired_locks[locking.LEVEL_NODE]
           elif self.wanted != locking.ALL_SET:
             nodenames = self.wanted
             missing = set(nodenames).difference(all_info.keys())
             if missing:
               raise errors.OpExecError(
                 "Some nodes were removed before retrieving their data: %s" % missing)
           else:
             nodenames = all_info.keys()
           nodenames = utils.NiceSort(nodenames)
           nodelist = [all_info[name] for name in nodenames]
           # begin data gathering
           if self.do_node_query:
             live_data = {}
             node_data = self.rpc.call_node_info(nodenames, self.cfg.GetVGName(),
                                                 self.cfg.GetHypervisorType())
             for name in nodenames:
               nodeinfo = node_data[name]
               if not nodeinfo.RemoteFailMsg() and nodeinfo.payload:
                 nodeinfo = nodeinfo.payload
                 fn = utils.TryConvert
                 live_data[name] = {
                   "mtotal": fn(int, nodeinfo.get('memory_total', None)),
                   "mnode": fn(int, nodeinfo.get('memory_dom0', None)),
                   "mfree": fn(int, nodeinfo.get('memory_free', None)),
                   "dtotal": fn(int, nodeinfo.get('vg_size', None)),
                   "dfree": fn(int, nodeinfo.get('vg_free', None)),
                   "ctotal": fn(int, nodeinfo.get('cpu_total', None)),
                   "bootid": nodeinfo.get('bootid', None),
                   "cnodes": fn(int, nodeinfo.get('cpu_nodes', None)),
                   "csockets": fn(int, nodeinfo.get('cpu_sockets', None)),
+                  }
               else:
                 live_data[name] = {}
           else:
             live_data = dict.fromkeys(nodenames, {})
           node_to_primary = dict([(name, set()) for name in nodenames])
           node_to_secondary = dict([(name, set()) for name in nodenames])
           inst_fields = frozenset(("pinst_cnt", "pinst_list",
                                    "sinst_cnt", "sinst_list"))
           if inst_fields & frozenset(self.op.output_fields):
             instancelist = self.cfg.GetInstanceList()
             for instance_name in instancelist:
               inst = self.cfg.GetInstanceInfo(instance_name)
               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)
           master_node = self.cfg.GetMasterNode()
           # end data gathering
           output = []
           for node in nodelist:
             node_output = []
             for field in self.op.output_fields:
               if field == "name":
                 val = node.name
               elif field == "pinst_list":
                 val = list(node_to_primary[node.name])
               elif field == "sinst_list":
                 val = list(node_to_secondary[node.name])
               elif field == "pinst_cnt":
                 val = len(node_to_primary[node.name])
               elif field == "sinst_cnt":
                 val = len(node_to_secondary[node.name])
               elif field == "pip":
                 val = node.primary_ip
               elif field == "sip":
                 val = node.secondary_ip
               elif field == "tags":
                 val = list(node.GetTags())
               elif field == "serial_no":
                 val = node.serial_no
               elif field == "master_candidate":
                 val = node.master_candidate
               elif field == "master":
                 val = node.name == master_node
               elif field == "offline":
                 val = node.offline
               elif field == "drained":
                 val = node.drained
               elif self._FIELDS_DYNAMIC.Matches(field):
                 val = live_data[node.name].get(field, None)
               else:
                 raise errors.ParameterError(field)
               node_output.append(val)
             output.append(node_output)
           return output
       class LUQueryNodeVolumes(NoHooksLU):
         """Logical unit for getting volumes on node(s).
         """
         _OP_REQP = ["nodes", "output_fields"]
         REQ_BGL = False
         _FIELDS_DYNAMIC = utils.FieldSet("phys", "vg", "name", "size", "instance")
         _FIELDS_STATIC = utils.FieldSet("node")
         def ExpandNames(self):
           _CheckOutputFields(static=self._FIELDS_STATIC,
                              dynamic=self._FIELDS_DYNAMIC,
                              selected=self.op.output_fields)
           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 CheckPrereq(self):
           """Check prerequisites.
           This checks that the fields required are valid output fields.
           """
           self.nodes = self.acquired_locks[locking.LEVEL_NODE]
         def Exec(self, feedback_fn):
           """Computes the list of nodes and their attributes.
           """
           nodenames = self.nodes
           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:
             if node not in volumes or volumes[node].failed or not volumes[node].data:
               continue
             node_vols = volumes[node].data[:]
             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 LUAddNode(LogicalUnit):
         """Logical unit for adding node to the cluster.
         """
         HPATH = "node-add"
         HTYPE = constants.HTYPE_NODE
         _OP_REQP = ["node_name"]
         def BuildHooksEnv(self):
           """Build hooks env.
           This will run on all nodes before, and on all nodes + the new node after.
           """
           env = {
             "OP_TARGET": self.op.node_name,
             "NODE_NAME": self.op.node_name,
             "NODE_PIP": self.op.primary_ip,
             "NODE_SIP": self.op.secondary_ip,
+            }
           nodes_0 = self.cfg.GetNodeList()
           nodes_1 = nodes_0 + [self.op.node_name, ]
           return env, nodes_0, nodes_1
         def CheckPrereq(self):
           """Check prerequisites.
           This checks:
            - the new node is not already in the config
            - it is resolvable
            - its parameters (single/dual homed) matches the cluster
           Any errors are signalled by raising errors.OpPrereqError.
           """
           node_name = self.op.node_name
           cfg = self.cfg
           dns_data = utils.HostInfo(node_name)
           node = dns_data.name
           primary_ip = self.op.primary_ip = dns_data.ip
           secondary_ip = getattr(self.op, "secondary_ip", None)
           if secondary_ip is None:
             secondary_ip = primary_ip
           if not utils.IsValidIP(secondary_ip):
             raise errors.OpPrereqError("Invalid secondary IP given")
           self.op.secondary_ip = secondary_ip
           node_list = cfg.GetNodeList()
           if not self.op.readd and node in node_list:
             raise errors.OpPrereqError("Node %s is already in the configuration" %
                                        node)
           elif self.op.readd and node not in node_list:
             raise errors.OpPrereqError("Node %s is not in the configuration" % node)
           for existing_node_name in node_list:
             existing_node = cfg.GetNodeInfo(existing_node_name)
             if self.op.readd and node == existing_node_name:
               if (existing_node.primary_ip != primary_ip or
                   existing_node.secondary_ip != secondary_ip):
                 raise errors.OpPrereqError("Readded node doesn't have the same IP"
                                            " address configuration as before")
               continue
             if (existing_node.primary_ip == primary_ip or
                 existing_node.secondary_ip == primary_ip or
                 existing_node.primary_ip == secondary_ip or
                 existing_node.secondary_ip == secondary_ip):
               raise errors.OpPrereqError("New node ip address(es) conflict with"
                                          " existing node %s" % existing_node.name)
           # check that the type of the node (single versus dual homed) is the
           # same as for the master
           myself = cfg.GetNodeInfo(self.cfg.GetMasterNode())
           master_singlehomed = myself.secondary_ip == myself.primary_ip
           newbie_singlehomed = secondary_ip == primary_ip
           if master_singlehomed != newbie_singlehomed:
             if master_singlehomed:
               raise errors.OpPrereqError("The master has no private ip but the"
                                          " new node has one")
             else:
               raise errors.OpPrereqError("The master has a private ip but the"
                                          " new node doesn't have one")
           # checks reachablity
           if not utils.TcpPing(primary_ip, constants.DEFAULT_NODED_PORT):
             raise errors.OpPrereqError("Node not reachable by ping")
           if not newbie_singlehomed:
             # check reachability from my secondary ip to newbie's secondary ip
             if not utils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,
                                  source=myself.secondary_ip):
               raise errors.OpPrereqError("Node secondary ip not reachable by TCP"
                                          " based ping to noded port")
           cp_size = self.cfg.GetClusterInfo().candidate_pool_size
           mc_now, _ = self.cfg.GetMasterCandidateStats()
           master_candidate = mc_now < cp_size
           self.new_node = objects.Node(name=node,
                                        primary_ip=primary_ip,
                                        secondary_ip=secondary_ip,
                                        master_candidate=master_candidate,
                                        offline=False, drained=False)
         def Exec(self, feedback_fn):
           """Adds the new node to the cluster.
           """
           new_node = self.new_node
           node = new_node.name
           # check connectivity
           result = self.rpc.call_version([node])[node]
           result.Raise()
           if result.data:
             if constants.PROTOCOL_VERSION == result.data:
               logging.info("Communication to node %s fine, sw version %s match",
                            node, result.data)
             else:
               raise errors.OpExecError("Version mismatch master version %s,"
                                        " node version %s" %
                                        (constants.PROTOCOL_VERSION, result.data))
           else:
             raise errors.OpExecError("Cannot get version from the new node")
           # setup ssh on node
           logging.info("Copy ssh key to node %s", node)
           priv_key, pub_key, _ = ssh.GetUserFiles(constants.GANETI_RUNAS)
           keyarray = []
           keyfiles = [constants.SSH_HOST_DSA_PRIV, constants.SSH_HOST_DSA_PUB,
                       constants.SSH_HOST_RSA_PRIV, constants.SSH_HOST_RSA_PUB,
                       priv_key, pub_key]
           for i in keyfiles:
             f = open(i, 'r')
             try:
               keyarray.append(f.read())
             finally:
               f.close()
           result = self.rpc.call_node_add(node, keyarray[0], keyarray[1],
                                           keyarray[2],
                                           keyarray[3], keyarray[4], keyarray[5])
           msg = result.RemoteFailMsg()
           if msg:
             raise errors.OpExecError("Cannot transfer ssh keys to the"
                                      " new node: %s" % msg)
           # Add node to our /etc/hosts, and add key to known_hosts
           if self.cfg.GetClusterInfo().modify_etc_hosts:
             utils.AddHostToEtcHosts(new_node.name)
           if new_node.secondary_ip != new_node.primary_ip:
             result = self.rpc.call_node_has_ip_address(new_node.name,
                                                        new_node.secondary_ip)
             msg = result.RemoteFailMsg()
             if msg:
               raise errors.OpPrereqError("Failure checking secondary ip"
                                          " on node %s: %s" % (new_node.name, msg))
             if not result.payload:
               raise errors.OpExecError("Node claims it doesn't have the secondary ip"
                                        " you gave (%s). Please fix and re-run this"
                                        " command." % new_node.secondary_ip)
           node_verify_list = [self.cfg.GetMasterNode()]
           node_verify_param = {
             'nodelist': [node],
             # TODO: do a node-net-test as well?
+          }
           result = self.rpc.call_node_verify(node_verify_list, node_verify_param,
                                              self.cfg.GetClusterName())
           for verifier in node_verify_list:
             msg = result[verifier].RemoteFailMsg()
             if msg:
               raise errors.OpExecError("Cannot communicate with node %s: %s" %
                                        (verifier, msg))
             nl_payload = result[verifier].payload['nodelist']
             if nl_payload:
               for failed in nl_payload:
                 feedback_fn("ssh/hostname verification failed %s -> %s" %
                             (verifier, nl_payload[failed]))
               raise errors.OpExecError("ssh/hostname verification failed.")
           if self.op.readd:
             _RedistributeAncillaryFiles(self)
             self.context.ReaddNode(new_node)
           else:
             _RedistributeAncillaryFiles(self, additional_nodes=[node])
             self.context.AddNode(new_node)
       class LUSetNodeParams(LogicalUnit):
         """Modifies the parameters of a node.
         """
         HPATH = "node-modify"
         HTYPE = constants.HTYPE_NODE
         _OP_REQP = ["node_name"]
         REQ_BGL = False
         def CheckArguments(self):
           node_name = self.cfg.ExpandNodeName(self.op.node_name)
           if node_name is None:
             raise errors.OpPrereqError("Invalid node name '%s'" % self.op.node_name)
           self.op.node_name = node_name
           _CheckBooleanOpField(self.op, 'master_candidate')
           _CheckBooleanOpField(self.op, 'offline')
           _CheckBooleanOpField(self.op, 'drained')
           all_mods = [self.op.offline, self.op.master_candidate, self.op.drained]
           if all_mods.count(None) == 3:
             raise errors.OpPrereqError("Please pass at least one modification")
           if all_mods.count(True) > 1:
             raise errors.OpPrereqError("Can't set the node into more than one"
                                        " state at the same time")
         def ExpandNames(self):
           self.needed_locks = {locking.LEVEL_NODE: self.op.node_name}
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on the master node.
           """
           env = {
             "OP_TARGET": self.op.node_name,
             "MASTER_CANDIDATE": str(self.op.master_candidate),
             "OFFLINE": str(self.op.offline),
             "DRAINED": str(self.op.drained),
+            }
           nl = [self.cfg.GetMasterNode(),
                 self.op.node_name]
           return env, nl, nl
         def CheckPrereq(self):
           """Check prerequisites.
           This only checks the instance list against the existing names.
           """
           node = self.node = self.cfg.GetNodeInfo(self.op.node_name)
           if ((self.op.master_candidate == False or self.op.offline == True or
                self.op.drained == True) and node.master_candidate):
             # we will demote the node from master_candidate
             if self.op.node_name == self.cfg.GetMasterNode():
               raise errors.OpPrereqError("The master node has to be a"
                                          " master candidate, online and not drained")
             cp_size = self.cfg.GetClusterInfo().candidate_pool_size
             num_candidates, _ = self.cfg.GetMasterCandidateStats()
             if num_candidates <= cp_size:
               msg = ("Not enough master candidates (desired"
                      " %d, new value will be %d)" % (cp_size, num_candidates-1))
               if self.op.force:
                 self.LogWarning(msg)
               else:
                 raise errors.OpPrereqError(msg)
           if (self.op.master_candidate == True and
               ((node.offline and not self.op.offline == False) or
                (node.drained and not self.op.drained == False))):
             raise errors.OpPrereqError("Node '%s' is offline or drained, can't set"
                                        " to master_candidate" % node.name)
           return
         def Exec(self, feedback_fn):
           """Modifies a node.
           """
           node = self.node
           result = []
           changed_mc = False
           if self.op.offline is not None:
             node.offline = self.op.offline
             result.append(("offline", str(self.op.offline)))
             if self.op.offline == True:
               if node.master_candidate:
                 node.master_candidate = False
                 changed_mc = True
                 result.append(("master_candidate", "auto-demotion due to offline"))
               if node.drained:
                 node.drained = False
                 result.append(("drained", "clear drained status due to offline"))
           if self.op.master_candidate is not None:
             node.master_candidate = self.op.master_candidate
             changed_mc = True
             result.append(("master_candidate", str(self.op.master_candidate)))
             if self.op.master_candidate == False:
               rrc = self.rpc.call_node_demote_from_mc(node.name)
               msg = rrc.RemoteFailMsg()
               if msg:
                 self.LogWarning("Node failed to demote itself: %s" % msg)
           if self.op.drained is not None:
             node.drained = self.op.drained
             result.append(("drained", str(self.op.drained)))
             if self.op.drained == True:
               if node.master_candidate:
                 node.master_candidate = False
                 changed_mc = True
                 result.append(("master_candidate", "auto-demotion due to drain"))
               if node.offline:
                 node.offline = False
                 result.append(("offline", "clear offline status due to drain"))
           # this will trigger configuration file update, if needed
           self.cfg.Update(node)
           # this will trigger job queue propagation or cleanup
           if changed_mc:
             self.context.ReaddNode(node)
           return result
       class LUPowercycleNode(NoHooksLU):
         """Powercycles a node.
         """
         _OP_REQP = ["node_name", "force"]
         REQ_BGL = False
         def CheckArguments(self):
           node_name = self.cfg.ExpandNodeName(self.op.node_name)
           if node_name is None:
             raise errors.OpPrereqError("Invalid node name '%s'" % self.op.node_name)
           self.op.node_name = node_name
           if node_name == self.cfg.GetMasterNode() and not self.op.force:
             raise errors.OpPrereqError("The node is the master and the force"
                                        " parameter was not set")
         def ExpandNames(self):
           """Locking for PowercycleNode.
           This is a last-resource option and shouldn't block on other
           jobs. Therefore, we grab no locks.
           """
           self.needed_locks = {}
         def CheckPrereq(self):
           """Check prerequisites.
           This LU has no prereqs.
           """
           pass
         def Exec(self, feedback_fn):
           """Reboots a node.
           """
           result = self.rpc.call_node_powercycle(self.op.node_name,
                                                  self.cfg.GetHypervisorType())
           msg = result.RemoteFailMsg()
           if msg:
             raise errors.OpExecError("Failed to schedule the reboot: %s" % msg)
           return result.payload
       class LUQueryClusterInfo(NoHooksLU):
         """Query cluster configuration.
         """
         _OP_REQP = []
         REQ_BGL = False
         def ExpandNames(self):
           self.needed_locks = {}
         def CheckPrereq(self):
           """No prerequsites needed for this LU.
           """
           pass
         def Exec(self, feedback_fn):
           """Return cluster config.
           """
           cluster = self.cfg.GetClusterInfo()
           result = {
             "software_version": constants.RELEASE_VERSION,
             "protocol_version": constants.PROTOCOL_VERSION,
             "config_version": constants.CONFIG_VERSION,
             "os_api_version": constants.OS_API_VERSION,
             "export_version": constants.EXPORT_VERSION,
             "architecture": (platform.architecture()[0], platform.machine()),
             "name": cluster.cluster_name,
             "master": cluster.master_node,
             "default_hypervisor": cluster.default_hypervisor,
             "enabled_hypervisors": cluster.enabled_hypervisors,
             "hvparams": dict([(hypervisor, cluster.hvparams[hypervisor])
                               for hypervisor in cluster.enabled_hypervisors]),
             "beparams": cluster.beparams,
             "nicparams": cluster.nicparams,
             "candidate_pool_size": cluster.candidate_pool_size,
             "master_netdev": cluster.master_netdev,
             "volume_group_name": cluster.volume_group_name,
             "file_storage_dir": cluster.file_storage_dir,
+            }
           return result
       class LUQueryConfigValues(NoHooksLU):
         """Return configuration values.
         """
         _OP_REQP = []
         REQ_BGL = False
         _FIELDS_DYNAMIC = utils.FieldSet()
         _FIELDS_STATIC = utils.FieldSet("cluster_name", "master_node", "drain_flag")
         def ExpandNames(self):
           self.needed_locks = {}
           _CheckOutputFields(static=self._FIELDS_STATIC,
                              dynamic=self._FIELDS_DYNAMIC,
                              selected=self.op.output_fields)
         def CheckPrereq(self):
           """No prerequisites.
           """
           pass
         def Exec(self, feedback_fn):
           """Dump a representation of the cluster config to the standard output.
           """
           values = []
           for field in self.op.output_fields:
             if field == "cluster_name":
               entry = self.cfg.GetClusterName()
             elif field == "master_node":
               entry = self.cfg.GetMasterNode()
             elif field == "drain_flag":
               entry = os.path.exists(constants.JOB_QUEUE_DRAIN_FILE)
             else:
               raise errors.ParameterError(field)
             values.append(entry)
           return values
       class LUActivateInstanceDisks(NoHooksLU):
         """Bring up an instance's disks.
         """
         _OP_REQP = ["instance_name"]
         REQ_BGL = False
         def ExpandNames(self):
           self._ExpandAndLockInstance()
           self.needed_locks[locking.LEVEL_NODE] = []
           self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
         def DeclareLocks(self, level):
           if level == locking.LEVEL_NODE:
             self._LockInstancesNodes()
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster.
           """
           self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
           assert self.instance is not None, \
             "Cannot retrieve locked instance %s" % self.op.instance_name
           _CheckNodeOnline(self, self.instance.primary_node)
         def Exec(self, feedback_fn):
           """Activate the disks.
           """
           disks_ok, disks_info = _AssembleInstanceDisks(self, self.instance)
           if not disks_ok:
             raise errors.OpExecError("Cannot activate block devices")
           return disks_info
       def _AssembleInstanceDisks(lu, instance, ignore_secondaries=False):
         """Prepare the block devices for an instance.
         This sets up the block devices on all nodes.
         @type lu: L{LogicalUnit}
         @param lu: the logical unit on whose behalf we execute
         @type instance: L{objects.Instance}
         @param instance: the instance for whose disks we assemble
         @type ignore_secondaries: boolean
         @param ignore_secondaries: if true, errors on secondary nodes
             won't result in an error return from the function
         @return: False if the operation failed, otherwise a list of
             (host, instance_visible_name, node_visible_name)
             with the mapping from node devices to instance devices
         """
         device_info = []
         disks_ok = True
         iname = instance.name
         # With the two passes mechanism we try to reduce the window of
         # opportunity for the race condition of switching DRBD to primary
         # before handshaking occured, but we do not eliminate it
         # The proper fix would be to wait (with some limits) until the
         # connection has been made and drbd transitions from WFConnection
         # into any other network-connected state (Connected, SyncTarget,
         # SyncSource, etc.)
         # 1st pass, assemble on all nodes in secondary mode
         for inst_disk in instance.disks:
           for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):
             lu.cfg.SetDiskID(node_disk, node)
             result = lu.rpc.call_blockdev_assemble(node, node_disk, iname, False)
             msg = result.RemoteFailMsg()
             if msg:
               lu.proc.LogWarning("Could not prepare block device %s on node %s"
                                  " (is_primary=False, pass=1): %s",
                                  inst_disk.iv_name, node, msg)
               if not ignore_secondaries:
                 disks_ok = False
         # FIXME: race condition on drbd migration to primary
         # 2nd pass, do only the primary node
         for inst_disk in instance.disks:
           for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):
             if node != instance.primary_node:
               continue
             lu.cfg.SetDiskID(node_disk, node)
             result = lu.rpc.call_blockdev_assemble(node, node_disk, iname, True)
             msg = result.RemoteFailMsg()
             if msg:
               lu.proc.LogWarning("Could not prepare block device %s on node %s"
                                  " (is_primary=True, pass=2): %s",
                                  inst_disk.iv_name, node, msg)
               disks_ok = False
           device_info.append((instance.primary_node, inst_disk.iv_name,
                               result.payload))
         # leave the disks configured for the primary node
         # this is a workaround that would be fixed better by
         # improving the logical/physical id handling
         for disk in instance.disks:
           lu.cfg.SetDiskID(disk, instance.primary_node)
         return disks_ok, device_info
       def _StartInstanceDisks(lu, instance, force):
         """Start the disks of an instance.
         """
         disks_ok, dummy = _AssembleInstanceDisks(lu, instance,
                                                  ignore_secondaries=force)
         if not disks_ok:
           _ShutdownInstanceDisks(lu, instance)
           if force is not None and not force:
             lu.proc.LogWarning("", hint="If the message above refers to a"
                                " secondary node,"
                                " you can retry the operation using '--force'.")
           raise errors.OpExecError("Disk consistency error")
       class LUDeactivateInstanceDisks(NoHooksLU):
         """Shutdown an instance's disks.
         """
         _OP_REQP = ["instance_name"]
         REQ_BGL = False
         def ExpandNames(self):
           self._ExpandAndLockInstance()
           self.needed_locks[locking.LEVEL_NODE] = []
           self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
         def DeclareLocks(self, level):
           if level == locking.LEVEL_NODE:
             self._LockInstancesNodes()
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster.
           """
           self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
           assert self.instance is not None, \
             "Cannot retrieve locked instance %s" % self.op.instance_name
         def Exec(self, feedback_fn):
           """Deactivate the disks
           """
           instance = self.instance
           _SafeShutdownInstanceDisks(self, instance)
       def _SafeShutdownInstanceDisks(lu, instance):
         """Shutdown block devices of an instance.
         This function checks if an instance is running, before calling
         _ShutdownInstanceDisks.
         """
         pnode = instance.primary_node
         ins_l = lu.rpc.call_instance_list([pnode], [instance.hypervisor])
         ins_l = ins_l[pnode]
         msg = ins_l.RemoteFailMsg()
         if msg:
           raise errors.OpExecError("Can't contact node %s: %s" % (pnode, msg))
         if instance.name in ins_l.payload:
           raise errors.OpExecError("Instance is running, can't shutdown"
                                    " block devices.")
         _ShutdownInstanceDisks(lu, instance)
       def _ShutdownInstanceDisks(lu, instance, ignore_primary=False):
         """Shutdown block devices of an instance.
         This does the shutdown on all nodes of the instance.
         If the ignore_primary is false, errors on the primary node are
         ignored.
         """
         all_result = True
         for disk in instance.disks:
           for node, top_disk in disk.ComputeNodeTree(instance.primary_node):
             lu.cfg.SetDiskID(top_disk, node)
             result = lu.rpc.call_blockdev_shutdown(node, top_disk)
             msg = result.RemoteFailMsg()
             if msg:
               lu.LogWarning("Could not shutdown block device %s on node %s: %s",
                             disk.iv_name, node, msg)
               if not ignore_primary or node != instance.primary_node:
                 all_result = False
         return all_result
       def _CheckNodeFreeMemory(lu, node, reason, requested, hypervisor_name):
         """Checks if a node has enough free memory.
         This function check if a given node has the needed amount of free
         memory. In case the node has less memory or we cannot get the
         information from the node, this function raise an OpPrereqError
         exception.
         @type lu: C{LogicalUnit}
         @param lu: a logical unit from which we get configuration data
         @type node: C{str}
         @param node: the node to check
         @type reason: C{str}
         @param reason: string to use in the error message
         @type requested: C{int}
         @param requested: the amount of memory in MiB to check for
         @type hypervisor_name: C{str}
         @param hypervisor_name: the hypervisor to ask for memory stats
         @raise errors.OpPrereqError: if the node doesn't have enough memory, or
             we cannot check the node
         """
         nodeinfo = lu.rpc.call_node_info([node], lu.cfg.GetVGName(), hypervisor_name)
         msg = nodeinfo[node].RemoteFailMsg()
         if msg:
           raise errors.OpPrereqError("Can't get data from node %s: %s" % (node, msg))
         free_mem = nodeinfo[node].payload.get('memory_free', None)
         if not isinstance(free_mem, int):
           raise errors.OpPrereqError("Can't compute free memory on node %s, result"
                                      " was '%s'" % (node, free_mem))
         if requested > free_mem:
           raise errors.OpPrereqError("Not enough memory on node %s for %s:"
                                      " needed %s MiB, available %s MiB" %
                                      (node, reason, requested, free_mem))
       class LUStartupInstance(LogicalUnit):
         """Starts an instance.
         """
         HPATH = "instance-start"
         HTYPE = constants.HTYPE_INSTANCE
         _OP_REQP = ["instance_name", "force"]
         REQ_BGL = False
         def ExpandNames(self):
           self._ExpandAndLockInstance()
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on master, primary and secondary nodes of the instance.
           """
           env = {
             "FORCE": self.op.force,
+            }
           env.update(_BuildInstanceHookEnvByObject(self, self.instance))
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return env, nl, nl
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster.
           """
           self.instance = instance = self.cfg.GetInstanceInfo(self.op.instance_name)
           assert self.instance is not None, \
             "Cannot retrieve locked instance %s" % self.op.instance_name
           # extra beparams
           self.beparams = getattr(self.op, "beparams", {})
           if self.beparams:
             if not isinstance(self.beparams, dict):
               raise errors.OpPrereqError("Invalid beparams passed: %s, expected"
                                          " dict" % (type(self.beparams), ))
             # fill the beparams dict
             utils.ForceDictType(self.beparams, constants.BES_PARAMETER_TYPES)
             self.op.beparams = self.beparams
           # extra hvparams
           self.hvparams = getattr(self.op, "hvparams", {})
           if self.hvparams:
             if not isinstance(self.hvparams, dict):
               raise errors.OpPrereqError("Invalid hvparams passed: %s, expected"
                                          " dict" % (type(self.hvparams), ))
             # check hypervisor parameter syntax (locally)
             cluster = self.cfg.GetClusterInfo()
             utils.ForceDictType(self.hvparams, constants.HVS_PARAMETER_TYPES)
             filled_hvp = objects.FillDict(cluster.hvparams[instance.hypervisor],
                                           instance.hvparams)
             filled_hvp.update(self.hvparams)
             hv_type = hypervisor.GetHypervisor(instance.hypervisor)
             hv_type.CheckParameterSyntax(filled_hvp)
             _CheckHVParams(self, instance.all_nodes, instance.hypervisor, filled_hvp)
             self.op.hvparams = self.hvparams
           _CheckNodeOnline(self, instance.primary_node)
           bep = self.cfg.GetClusterInfo().FillBE(instance)
           # check bridges existance
           _CheckInstanceBridgesExist(self, instance)
           remote_info = self.rpc.call_instance_info(instance.primary_node,
                                                     instance.name,
                                                     instance.hypervisor)
           msg = remote_info.RemoteFailMsg()
           if msg:
             raise errors.OpPrereqError("Error checking node %s: %s" %
                                        (instance.primary_node, msg))
           if not remote_info.payload: # not running already
             _CheckNodeFreeMemory(self, instance.primary_node,
                                  "starting instance %s" % instance.name,
                                  bep[constants.BE_MEMORY], instance.hypervisor)
         def Exec(self, feedback_fn):
           """Start the instance.
           """
           instance = self.instance
           force = self.op.force
           self.cfg.MarkInstanceUp(instance.name)
           node_current = instance.primary_node
           _StartInstanceDisks(self, instance, force)
           result = self.rpc.call_instance_start(node_current, instance,
                                                 self.hvparams, self.beparams)
           msg = result.RemoteFailMsg()
           if msg:
             _ShutdownInstanceDisks(self, instance)
             raise errors.OpExecError("Could not start instance: %s" % msg)
       class LURebootInstance(LogicalUnit):
         """Reboot an instance.
         """
         HPATH = "instance-reboot"
         HTYPE = constants.HTYPE_INSTANCE
         _OP_REQP = ["instance_name", "ignore_secondaries", "reboot_type"]
         REQ_BGL = False
         def ExpandNames(self):
           if self.op.reboot_type not in [constants.INSTANCE_REBOOT_SOFT,
                                          constants.INSTANCE_REBOOT_HARD,
                                          constants.INSTANCE_REBOOT_FULL]:
             raise errors.ParameterError("reboot type not in [%s, %s, %s]" %
                                         (constants.INSTANCE_REBOOT_SOFT,
                                          constants.INSTANCE_REBOOT_HARD,
                                          constants.INSTANCE_REBOOT_FULL))
           self._ExpandAndLockInstance()
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on master, primary and secondary nodes of the instance.
           """
           env = {
             "IGNORE_SECONDARIES": self.op.ignore_secondaries,
             "REBOOT_TYPE": self.op.reboot_type,
+            }
           env.update(_BuildInstanceHookEnvByObject(self, self.instance))
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return env, nl, nl
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster.
           """
           self.instance = instance = self.cfg.GetInstanceInfo(self.op.instance_name)
           assert self.instance is not None, \
             "Cannot retrieve locked instance %s" % self.op.instance_name
           _CheckNodeOnline(self, instance.primary_node)
           # check bridges existance
           _CheckInstanceBridgesExist(self, instance)
         def Exec(self, feedback_fn):
           """Reboot the instance.
           """
           instance = self.instance
           ignore_secondaries = self.op.ignore_secondaries
           reboot_type = self.op.reboot_type
           node_current = instance.primary_node
           if reboot_type in [constants.INSTANCE_REBOOT_SOFT,
                              constants.INSTANCE_REBOOT_HARD]:
             for disk in instance.disks:
               self.cfg.SetDiskID(disk, node_current)
             result = self.rpc.call_instance_reboot(node_current, instance,
                                                    reboot_type)
             msg = result.RemoteFailMsg()
             if msg:
               raise errors.OpExecError("Could not reboot instance: %s" % msg)
           else:
             result = self.rpc.call_instance_shutdown(node_current, instance)
             msg = result.RemoteFailMsg()
             if msg:
               raise errors.OpExecError("Could not shutdown instance for"
                                        " full reboot: %s" % msg)
             _ShutdownInstanceDisks(self, instance)
             _StartInstanceDisks(self, instance, ignore_secondaries)
             result = self.rpc.call_instance_start(node_current, instance, None, None)
             msg = result.RemoteFailMsg()
             if msg:
               _ShutdownInstanceDisks(self, instance)
               raise errors.OpExecError("Could not start instance for"
                                        " full reboot: %s" % msg)
           self.cfg.MarkInstanceUp(instance.name)
       class LUShutdownInstance(LogicalUnit):
         """Shutdown an instance.
         """
         HPATH = "instance-stop"
         HTYPE = constants.HTYPE_INSTANCE
         _OP_REQP = ["instance_name"]
         REQ_BGL = False
         def ExpandNames(self):
           self._ExpandAndLockInstance()
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on master, primary and secondary nodes of the instance.
           """
           env = _BuildInstanceHookEnvByObject(self, self.instance)
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return env, nl, nl
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster.
           """
           self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
           assert self.instance is not None, \
             "Cannot retrieve locked instance %s" % self.op.instance_name
           _CheckNodeOnline(self, self.instance.primary_node)
         def Exec(self, feedback_fn):
           """Shutdown the instance.
           """
           instance = self.instance
           node_current = instance.primary_node
           self.cfg.MarkInstanceDown(instance.name)
           result = self.rpc.call_instance_shutdown(node_current, instance)
           msg = result.RemoteFailMsg()
           if msg:
             self.proc.LogWarning("Could not shutdown instance: %s" % msg)
           _ShutdownInstanceDisks(self, instance)
       class LUReinstallInstance(LogicalUnit):
         """Reinstall an instance.
         """
         HPATH = "instance-reinstall"
         HTYPE = constants.HTYPE_INSTANCE
         _OP_REQP = ["instance_name"]
         REQ_BGL = False
         def ExpandNames(self):
           self._ExpandAndLockInstance()
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on master, primary and secondary nodes of the instance.
           """
           env = _BuildInstanceHookEnvByObject(self, self.instance)
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return env, nl, nl
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster and is not running.
           """
           instance = self.cfg.GetInstanceInfo(self.op.instance_name)
           assert instance is not None, \
             "Cannot retrieve locked instance %s" % self.op.instance_name
           _CheckNodeOnline(self, instance.primary_node)
           if instance.disk_template == constants.DT_DISKLESS:
             raise errors.OpPrereqError("Instance '%s' has no disks" %
                                        self.op.instance_name)
           if instance.admin_up:
             raise errors.OpPrereqError("Instance '%s' is marked to be up" %
                                        self.op.instance_name)
           remote_info = self.rpc.call_instance_info(instance.primary_node,
                                                     instance.name,
                                                     instance.hypervisor)
           msg = remote_info.RemoteFailMsg()
           if msg:
             raise errors.OpPrereqError("Error checking node %s: %s" %
                                        (instance.primary_node, msg))
           if remote_info.payload:
             raise errors.OpPrereqError("Instance '%s' is running on the node %s" %
                                        (self.op.instance_name,
                                         instance.primary_node))
           self.op.os_type = getattr(self.op, "os_type", None)
           if self.op.os_type is not None:
             # OS verification
             pnode = self.cfg.GetNodeInfo(
               self.cfg.ExpandNodeName(instance.primary_node))
             if pnode is None:
               raise errors.OpPrereqError("Primary node '%s' is unknown" %
                                          self.op.pnode)
             result = self.rpc.call_os_get(pnode.name, self.op.os_type)
             result.Raise()
             if not isinstance(result.data, objects.OS):
               raise errors.OpPrereqError("OS '%s' not in supported OS list for"
                                          " primary node"  % self.op.os_type)
           self.instance = instance
         def Exec(self, feedback_fn):
           """Reinstall the instance.
           """
           inst = self.instance
           if self.op.os_type is not None:
             feedback_fn("Changing OS to '%s'..." % self.op.os_type)
             inst.os = self.op.os_type
             self.cfg.Update(inst)
           _StartInstanceDisks(self, inst, None)
           try:
             feedback_fn("Running the instance OS create scripts...")
             result = self.rpc.call_instance_os_add(inst.primary_node, inst, True)
             msg = result.RemoteFailMsg()
             if msg:
               raise errors.OpExecError("Could not install OS for instance %s"
                                        " on node %s: %s" %
                                        (inst.name, inst.primary_node, msg))
           finally:
             _ShutdownInstanceDisks(self, inst)
       class LURenameInstance(LogicalUnit):
         """Rename an instance.
         """
         HPATH = "instance-rename"
         HTYPE = constants.HTYPE_INSTANCE
         _OP_REQP = ["instance_name", "new_name"]
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on master, primary and secondary nodes of the instance.
           """
           env = _BuildInstanceHookEnvByObject(self, self.instance)
           env["INSTANCE_NEW_NAME"] = self.op.new_name
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return env, nl, nl
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster and is not running.
           """
           instance = self.cfg.GetInstanceInfo(
             self.cfg.ExpandInstanceName(self.op.instance_name))
           if instance is None:
             raise errors.OpPrereqError("Instance '%s' not known" %
                                        self.op.instance_name)
           _CheckNodeOnline(self, instance.primary_node)
           if instance.admin_up:
             raise errors.OpPrereqError("Instance '%s' is marked to be up" %
                                        self.op.instance_name)
           remote_info = self.rpc.call_instance_info(instance.primary_node,
                                                     instance.name,
                                                     instance.hypervisor)
           msg = remote_info.RemoteFailMsg()
           if msg:
             raise errors.OpPrereqError("Error checking node %s: %s" %
                                        (instance.primary_node, msg))
           if remote_info.payload:
             raise errors.OpPrereqError("Instance '%s' is running on the node %s" %
                                        (self.op.instance_name,
                                         instance.primary_node))
           self.instance = instance
           # new name verification
           name_info = utils.HostInfo(self.op.new_name)
           self.op.new_name = new_name = name_info.name
           instance_list = self.cfg.GetInstanceList()
           if new_name in instance_list:
             raise errors.OpPrereqError("Instance '%s' is already in the cluster" %
                                        new_name)
           if not getattr(self.op, "ignore_ip", False):
             if utils.TcpPing(name_info.ip, constants.DEFAULT_NODED_PORT):
               raise errors.OpPrereqError("IP %s of instance %s already in use" %
                                          (name_info.ip, new_name))
         def Exec(self, feedback_fn):
           """Reinstall the instance.
           """
           inst = self.instance
           old_name = inst.name
           if inst.disk_template == constants.DT_FILE:
             old_file_storage_dir = os.path.dirname(inst.disks[0].logical_id[1])
           self.cfg.RenameInstance(inst.name, self.op.new_name)
           # Change the instance lock. This is definitely safe while we hold the BGL
           self.context.glm.remove(locking.LEVEL_INSTANCE, old_name)
           self.context.glm.add(locking.LEVEL_INSTANCE, self.op.new_name)
           # re-read the instance from the configuration after rename
           inst = self.cfg.GetInstanceInfo(self.op.new_name)
           if inst.disk_template == constants.DT_FILE:
             new_file_storage_dir = os.path.dirname(inst.disks[0].logical_id[1])
             result = self.rpc.call_file_storage_dir_rename(inst.primary_node,
                                                            old_file_storage_dir,
                                                            new_file_storage_dir)
             result.Raise()
             if not result.data:
               raise errors.OpExecError("Could not connect to node '%s' to rename"
                                        " directory '%s' to '%s' (but the instance"
                                        " has been renamed in Ganeti)" % (
                                        inst.primary_node, old_file_storage_dir,
                                        new_file_storage_dir))
             if not result.data[0]:
               raise errors.OpExecError("Could not rename directory '%s' to '%s'"
                                        " (but the instance has been renamed in"
                                        " Ganeti)" % (old_file_storage_dir,
                                                      new_file_storage_dir))
           _StartInstanceDisks(self, inst, None)
           try:
             result = self.rpc.call_instance_run_rename(inst.primary_node, inst,
                                                        old_name)
             msg = result.RemoteFailMsg()
             if msg:
               msg = ("Could not run OS rename script for instance %s on node %s"
                      " (but the instance has been renamed in Ganeti): %s" %
                      (inst.name, inst.primary_node, msg))
               self.proc.LogWarning(msg)
           finally:
             _ShutdownInstanceDisks(self, inst)
       class LURemoveInstance(LogicalUnit):
         """Remove an instance.
         """
         HPATH = "instance-remove"
         HTYPE = constants.HTYPE_INSTANCE
         _OP_REQP = ["instance_name", "ignore_failures"]
         REQ_BGL = False
         def ExpandNames(self):
           self._ExpandAndLockInstance()
           self.needed_locks[locking.LEVEL_NODE] = []
           self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
         def DeclareLocks(self, level):
           if level == locking.LEVEL_NODE:
             self._LockInstancesNodes()
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on master, primary and secondary nodes of the instance.
           """
           env = _BuildInstanceHookEnvByObject(self, self.instance)
           nl = [self.cfg.GetMasterNode()]
           return env, nl, nl
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster.
           """
           self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
           assert self.instance is not None, \
             "Cannot retrieve locked instance %s" % self.op.instance_name
         def Exec(self, feedback_fn):
           """Remove the instance.
           """
           instance = self.instance
           logging.info("Shutting down instance %s on node %s",
                        instance.name, instance.primary_node)
           result = self.rpc.call_instance_shutdown(instance.primary_node, instance)
           msg = result.RemoteFailMsg()
           if msg:
             if self.op.ignore_failures:
               feedback_fn("Warning: can't shutdown instance: %s" % msg)
             else:
               raise errors.OpExecError("Could not shutdown instance %s on"
                                        " node %s: %s" %
                                        (instance.name, instance.primary_node, msg))
           logging.info("Removing block devices for instance %s", instance.name)
           if not _RemoveDisks(self, instance):
             if self.op.ignore_failures:
               feedback_fn("Warning: can't remove instance's disks")
             else:
               raise errors.OpExecError("Can't remove instance's disks")
           logging.info("Removing instance %s out of cluster config", instance.name)
           self.cfg.RemoveInstance(instance.name)
           self.remove_locks[locking.LEVEL_INSTANCE] = instance.name
       class LUQueryInstances(NoHooksLU):
         """Logical unit for querying instances.
         """
         _OP_REQP = ["output_fields", "names", "use_locking"]
         REQ_BGL = False
         _FIELDS_STATIC = utils.FieldSet(*["name", "os", "pnode", "snodes",
                                           "admin_state",
                                           "disk_template", "ip", "mac", "bridge",
                                           "sda_size", "sdb_size", "vcpus", "tags",
                                           "network_port", "beparams",
                                           r"(disk)\.(size)/([0-9]+)",
                                           r"(disk)\.(sizes)", "disk_usage",
                                           r"(nic)\.(mac|ip|bridge)/([0-9]+)",
                                           r"(nic)\.(macs|ips|bridges)",
                                           r"(disk|nic)\.(count)",
                                           "serial_no", "hypervisor", "hvparams",] +
                                         ["hv/%s" % name
                                          for name in constants.HVS_PARAMETERS] +
                                         ["be/%s" % name
                                          for name in constants.BES_PARAMETERS])
         _FIELDS_DYNAMIC = utils.FieldSet("oper_state", "oper_ram", "status")
         def ExpandNames(self):
           _CheckOutputFields(static=self._FIELDS_STATIC,
                              dynamic=self._FIELDS_DYNAMIC,
                              selected=self.op.output_fields)
           self.needed_locks = {}
           self.share_locks[locking.LEVEL_INSTANCE] = 1
           self.share_locks[locking.LEVEL_NODE] = 1
           if self.op.names:
             self.wanted = _GetWantedInstances(self, self.op.names)
           else:
             self.wanted = locking.ALL_SET
           self.do_node_query = self._FIELDS_STATIC.NonMatching(self.op.output_fields)
           self.do_locking = self.do_node_query and self.op.use_locking
           if self.do_locking:
             self.needed_locks[locking.LEVEL_INSTANCE] = self.wanted
             self.needed_locks[locking.LEVEL_NODE] = []
             self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
         def DeclareLocks(self, level):
           if level == locking.LEVEL_NODE and self.do_locking:
             self._LockInstancesNodes()
         def CheckPrereq(self):
           """Check prerequisites.
           """
           pass
         def Exec(self, feedback_fn):
           """Computes the list of nodes and their attributes.
           """
           all_info = self.cfg.GetAllInstancesInfo()
           if self.wanted == locking.ALL_SET:
             # caller didn't specify instance names, so ordering is not important
             if self.do_locking:
               instance_names = self.acquired_locks[locking.LEVEL_INSTANCE]
             else:
               instance_names = all_info.keys()
             instance_names = utils.NiceSort(instance_names)
           else:
             # caller did specify names, so we must keep the ordering
             if self.do_locking:
               tgt_set = self.acquired_locks[locking.LEVEL_INSTANCE]
             else:
               tgt_set = all_info.keys()
             missing = set(self.wanted).difference(tgt_set)
             if missing:
               raise errors.OpExecError("Some instances were removed before"
                                        " retrieving their data: %s" % missing)
             instance_names = self.wanted
           instance_list = [all_info[iname] for iname in instance_names]
           # begin data gathering
           nodes = frozenset([inst.primary_node for inst in instance_list])
           hv_list = list(set([inst.hypervisor for inst in instance_list]))
           bad_nodes = []
           off_nodes = []
           if self.do_node_query:
             live_data = {}
             node_data = self.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
                 off_nodes.append(name)
               if result.failed or result.RemoteFailMsg():
                 bad_nodes.append(name)
               else:
                 if result.payload:
                   live_data.update(result.payload)
                 # else no instance is alive
           else:
             live_data = dict([(name, {}) for name in instance_names])
           # end data gathering
           HVPREFIX = "hv/"
           BEPREFIX = "be/"
           output = []
           for instance in instance_list:
             iout = []
             i_hv = self.cfg.GetClusterInfo().FillHV(instance)
             i_be = self.cfg.GetClusterInfo().FillBE(instance)
             for field in self.op.output_fields:
               st_match = self._FIELDS_STATIC.Matches(field)
               if field == "name":
                 val = instance.name
               elif field == "os":
                 val = instance.os
               elif field == "pnode":
                 val = instance.primary_node
               elif field == "snodes":
                 val = list(instance.secondary_nodes)
               elif field == "admin_state":
                 val = instance.admin_up
               elif field == "oper_state":
                 if instance.primary_node in bad_nodes:
                   val = None
                 else:
                   val = bool(live_data.get(instance.name))
               elif field == "status":
                 if instance.primary_node in off_nodes:
                   val = "ERROR_nodeoffline"
                 elif instance.primary_node in bad_nodes:
                   val = "ERROR_nodedown"
                 else:
                   running = bool(live_data.get(instance.name))
                   if running:
                     if instance.admin_up:
                       val = "running"
                     else:
                       val = "ERROR_up"
                   else:
                     if instance.admin_up:
                       val = "ERROR_down"
                     else:
                       val = "ADMIN_down"
               elif field == "oper_ram":
                 if instance.primary_node in bad_nodes:
                   val = None
                 elif instance.name in live_data:
                   val = live_data[instance.name].get("memory", "?")
                 else:
                   val = "-"
               elif field == "disk_template":
                 val = instance.disk_template
               elif field == "ip":
                 val = instance.nics[0].ip
               elif field == "bridge":
                 val = instance.nics[0].bridge
               elif field == "mac":
                 val = instance.nics[0].mac
               elif field == "sda_size" or field == "sdb_size":
                 idx = ord(field[2]) - ord('a')
                 try:
                   val = instance.FindDisk(idx).size
                 except errors.OpPrereqError:
                   val = None
               elif field == "disk_usage": # total disk usage per node
                 disk_sizes = [{'size': disk.size} for disk in instance.disks]
                 val = _ComputeDiskSize(instance.disk_template, disk_sizes)
               elif field == "tags":
                 val = list(instance.GetTags())
               elif field == "serial_no":
                 val = instance.serial_no
               elif field == "network_port":
                 val = instance.network_port
               elif field == "hypervisor":
                 val = instance.hypervisor
               elif field == "hvparams":
                 val = i_hv
               elif (field.startswith(HVPREFIX) and
                     field[len(HVPREFIX):] in constants.HVS_PARAMETERS):
                 val = i_hv.get(field[len(HVPREFIX):], None)
               elif field == "beparams":
                 val = i_be
               elif (field.startswith(BEPREFIX) and
                     field[len(BEPREFIX):] in constants.BES_PARAMETERS):
                 val = i_be.get(field[len(BEPREFIX):], None)
               elif st_match and st_match.groups():
                 # matches a variable list
                 st_groups = st_match.groups()
                 if st_groups and st_groups[0] == "disk":
                   if st_groups[1] == "count":
                     val = len(instance.disks)
                   elif st_groups[1] == "sizes":
                     val = [disk.size for disk in instance.disks]
                   elif st_groups[1] == "size":
                     try:
                       val = instance.FindDisk(st_groups[2]).size
                     except errors.OpPrereqError:
                       val = None
                   else:
                     assert False, "Unhandled disk parameter"
                 elif st_groups[0] == "nic":
                   if st_groups[1] == "count":
                     val = len(instance.nics)
                   elif st_groups[1] == "macs":
                     val = [nic.mac for nic in instance.nics]
                   elif st_groups[1] == "ips":
                     val = [nic.ip for nic in instance.nics]
                   elif st_groups[1] == "bridges":
                     val = [nic.bridge for nic in instance.nics]
                   else:
                     # index-based item
                     nic_idx = int(st_groups[2])
                     if nic_idx >= len(instance.nics):
                       val = None
                     else:
                       if st_groups[1] == "mac":
                         val = instance.nics[nic_idx].mac
                       elif st_groups[1] == "ip":
                         val = instance.nics[nic_idx].ip
                       elif st_groups[1] == "bridge":
                         val = instance.nics[nic_idx].bridge
                       else:
                         assert False, "Unhandled NIC parameter"
                 else:
                   assert False, "Unhandled variable parameter"
               else:
                 raise errors.ParameterError(field)
               iout.append(val)
             output.append(iout)
           return output
       class LUFailoverInstance(LogicalUnit):
         """Failover an instance.
         """
         HPATH = "instance-failover"
         HTYPE = constants.HTYPE_INSTANCE
         _OP_REQP = ["instance_name", "ignore_consistency"]
         REQ_BGL = False
         def ExpandNames(self):
           self._ExpandAndLockInstance()
           self.needed_locks[locking.LEVEL_NODE] = []
           self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
         def DeclareLocks(self, level):
           if level == locking.LEVEL_NODE:
             self._LockInstancesNodes()
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on master, primary and secondary nodes of the instance.
           """
           env = {
             "IGNORE_CONSISTENCY": self.op.ignore_consistency,
+            }
           env.update(_BuildInstanceHookEnvByObject(self, self.instance))
           nl = [self.cfg.GetMasterNode()] + list(self.instance.secondary_nodes)
           return env, nl, nl
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster.
           """
           self.instance = instance = self.cfg.GetInstanceInfo(self.op.instance_name)
           assert self.instance is not None, \
             "Cannot retrieve locked instance %s" % self.op.instance_name
           bep = self.cfg.GetClusterInfo().FillBE(instance)
           if instance.disk_template not in constants.DTS_NET_MIRROR:
             raise errors.OpPrereqError("Instance's disk layout is not"
                                        " network mirrored, cannot failover.")
           secondary_nodes = instance.secondary_nodes
           if not secondary_nodes:
             raise errors.ProgrammerError("no secondary node but using "
                                          "a mirrored disk template")
           target_node = secondary_nodes[0]
           _CheckNodeOnline(self, target_node)
           _CheckNodeNotDrained(self, target_node)
           # check memory requirements on the secondary node
           _CheckNodeFreeMemory(self, target_node, "failing over instance %s" %
                                instance.name, bep[constants.BE_MEMORY],
                                instance.hypervisor)
           # check bridge existance
           _CheckInstanceBridgesExist(self, instance, node=target_node)
         def Exec(self, feedback_fn):
           """Failover an instance.
           The failover is done by shutting it down on its present node and
           starting it on the secondary.
           """
           instance = self.instance
           source_node = instance.primary_node
           target_node = instance.secondary_nodes[0]
           feedback_fn("* checking disk consistency between source and target")
           for dev in instance.disks:
             # for drbd, these are drbd over lvm
             if not _CheckDiskConsistency(self, dev, target_node, False):
               if instance.admin_up and not self.op.ignore_consistency:
                 raise errors.OpExecError("Disk %s is degraded on target node,"
                                          " aborting failover." % dev.iv_name)
           feedback_fn("* shutting down instance on source node")
           logging.info("Shutting down instance %s on node %s",
                        instance.name, source_node)
           result = self.rpc.call_instance_shutdown(source_node, instance)
           msg = result.RemoteFailMsg()
           if msg:
             if self.op.ignore_consistency:
               self.proc.LogWarning("Could not shutdown instance %s on node %s."
                                    " Proceeding anyway. Please make sure node"
                                    " %s is down. Error details: %s",
                                    instance.name, source_node, source_node, msg)
             else:
               raise errors.OpExecError("Could not shutdown instance %s on"
                                        " node %s: %s" %
                                        (instance.name, source_node, msg))
           feedback_fn("* deactivating the instance's disks on source node")
           if not _ShutdownInstanceDisks(self, instance, ignore_primary=True):
             raise errors.OpExecError("Can't shut down the instance's disks.")
           instance.primary_node = target_node
           # distribute new instance config to the other nodes
           self.cfg.Update(instance)
           # Only start the instance if it's marked as up
           if instance.admin_up:
             feedback_fn("* activating the instance's disks on target node")
             logging.info("Starting instance %s on node %s",
                          instance.name, target_node)
             disks_ok, dummy = _AssembleInstanceDisks(self, instance,
                                                      ignore_secondaries=True)
             if not disks_ok:
               _ShutdownInstanceDisks(self, instance)
               raise errors.OpExecError("Can't activate the instance's disks")
             feedback_fn("* starting the instance on the target node")
             result = self.rpc.call_instance_start(target_node, instance, None, None)
             msg = result.RemoteFailMsg()
             if msg:
               _ShutdownInstanceDisks(self, instance)
               raise errors.OpExecError("Could not start instance %s on node %s: %s" %
                                        (instance.name, target_node, msg))
       class LUMigrateInstance(LogicalUnit):
         """Migrate an instance.
         This is migration without shutting down, compared to the failover,
         which is done with shutdown.
         """
         HPATH = "instance-migrate"
         HTYPE = constants.HTYPE_INSTANCE
         _OP_REQP = ["instance_name", "live", "cleanup"]
         REQ_BGL = False
         def ExpandNames(self):
           self._ExpandAndLockInstance()
           self.needed_locks[locking.LEVEL_NODE] = []
           self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
         def DeclareLocks(self, level):
           if level == locking.LEVEL_NODE:
             self._LockInstancesNodes()
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on master, primary and secondary nodes of the instance.
           """
           env = _BuildInstanceHookEnvByObject(self, self.instance)
           env["MIGRATE_LIVE"] = self.op.live
           env["MIGRATE_CLEANUP"] = self.op.cleanup
           nl = [self.cfg.GetMasterNode()] + list(self.instance.secondary_nodes)
           return env, nl, nl
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster.
           """
           instance = self.cfg.GetInstanceInfo(
             self.cfg.ExpandInstanceName(self.op.instance_name))
           if instance is None:
             raise errors.OpPrereqError("Instance '%s' not known" %
                                        self.op.instance_name)
           if instance.disk_template != constants.DT_DRBD8:
             raise errors.OpPrereqError("Instance's disk layout is not"
                                        " drbd8, cannot migrate.")
           secondary_nodes = instance.secondary_nodes
           if not secondary_nodes:
             raise errors.ConfigurationError("No secondary node but using"
                                             " drbd8 disk template")
           i_be = self.cfg.GetClusterInfo().FillBE(instance)
           target_node = secondary_nodes[0]
           # check memory requirements on the secondary node
           _CheckNodeFreeMemory(self, target_node, "migrating instance %s" %
                                instance.name, i_be[constants.BE_MEMORY],
                                instance.hypervisor)
           # check bridge existance
           _CheckInstanceBridgesExist(self, instance, node=target_node)
           if not self.op.cleanup:
             _CheckNodeNotDrained(self, target_node)
             result = self.rpc.call_instance_migratable(instance.primary_node,
                                                        instance)
             msg = result.RemoteFailMsg()
             if msg:
               raise errors.OpPrereqError("Can't migrate: %s - please use failover" %
                                          msg)
           self.instance = instance
         def _WaitUntilSync(self):
           """Poll with custom rpc for disk sync.
           This uses our own step-based rpc call.
           """
           self.feedback_fn("* wait until resync is done")
           all_done = False
           while not all_done:
             all_done = True
             result = self.rpc.call_drbd_wait_sync(self.all_nodes,
                                                   self.nodes_ip,
                                                   self.instance.disks)
             min_percent = 100
             for node, nres in result.items():
               msg = nres.RemoteFailMsg()
               if msg:
                 raise errors.OpExecError("Cannot resync disks on node %s: %s" %
                                          (node, msg))
               node_done, node_percent = nres.payload
               all_done = all_done and node_done
               if node_percent is not None:
                 min_percent = min(min_percent, node_percent)
             if not all_done:
               if min_percent < 100:
                 self.feedback_fn("   - progress: %.1f%%" % min_percent)
               time.sleep(2)
         def _EnsureSecondary(self, node):
           """Demote a node to secondary.
           """
           self.feedback_fn("* switching node %s to secondary mode" % node)
           for dev in self.instance.disks:
             self.cfg.SetDiskID(dev, node)
           result = self.rpc.call_blockdev_close(node, self.instance.name,
                                                 self.instance.disks)
           msg = result.RemoteFailMsg()
           if msg:
             raise errors.OpExecError("Cannot change disk to secondary on node %s,"
                                      " error %s" % (node, msg))
         def _GoStandalone(self):
           """Disconnect from the network.
           """
           self.feedback_fn("* changing into standalone mode")
           result = self.rpc.call_drbd_disconnect_net(self.all_nodes, self.nodes_ip,
                                                      self.instance.disks)
           for node, nres in result.items():
             msg = nres.RemoteFailMsg()
             if msg:
               raise errors.OpExecError("Cannot disconnect disks node %s,"
                                        " error %s" % (node, msg))
         def _GoReconnect(self, multimaster):
           """Reconnect to the network.
           """
           if multimaster:
             msg = "dual-master"
           else:
             msg = "single-master"
           self.feedback_fn("* changing disks into %s mode" % msg)
           result = self.rpc.call_drbd_attach_net(self.all_nodes, self.nodes_ip,
                                                  self.instance.disks,
                                                  self.instance.name, multimaster)
           for node, nres in result.items():
             msg = nres.RemoteFailMsg()
             if msg:
               raise errors.OpExecError("Cannot change disks config on node %s,"
                                        " error: %s" % (node, msg))
         def _ExecCleanup(self):
           """Try to cleanup after a failed migration.
           The cleanup is done by:
             - check that the instance is running only on one node
               (and update the config if needed)
             - change disks on its secondary node to secondary
             - wait until disks are fully synchronized
             - disconnect from the network
             - change disks into single-master mode
             - wait again until disks are fully synchronized
           """
           instance = self.instance
           target_node = self.target_node
           source_node = self.source_node
           # check running on only one node
           self.feedback_fn("* checking where the instance actually runs"
                            " (if this hangs, the hypervisor might be in"
                            " a bad state)")
           ins_l = self.rpc.call_instance_list(self.all_nodes, [instance.hypervisor])
           for node, result in ins_l.items():
             msg = result.RemoteFailMsg()
             if msg:
               raise errors.OpExecError("Can't contact node %s: %s" % (node, msg))
           runningon_source = instance.name in ins_l[source_node].payload
           runningon_target = instance.name in ins_l[target_node].payload
           if runningon_source and runningon_target:
             raise errors.OpExecError("Instance seems to be running on two nodes,"
                                      " or the hypervisor is confused. You will have"
                                      " to ensure manually that it runs only on one"
                                      " and restart this operation.")
           if not (runningon_source or runningon_target):
             raise errors.OpExecError("Instance does not seem to be running at all."
                                      " In this case, it's safer to repair by"
                                      " running 'gnt-instance stop' to ensure disk"
                                      " shutdown, and then restarting it.")
           if runningon_target:
             # the migration has actually succeeded, we need to update the config
             self.feedback_fn("* instance running on secondary node (%s),"
                              " updating config" % target_node)
             instance.primary_node = target_node
             self.cfg.Update(instance)
             demoted_node = source_node
           else:
             self.feedback_fn("* instance confirmed to be running on its"
                              " primary node (%s)" % source_node)
             demoted_node = target_node
           self._EnsureSecondary(demoted_node)
           try:
             self._WaitUntilSync()
           except errors.OpExecError:
             # we ignore here errors, since if the device is standalone, it
             # won't be able to sync
             pass
           self._GoStandalone()
           self._GoReconnect(False)
           self._WaitUntilSync()
           self.feedback_fn("* done")
         def _RevertDiskStatus(self):
           """Try to revert the disk status after a failed migration.
           """
           target_node = self.target_node
           try:
             self._EnsureSecondary(target_node)
             self._GoStandalone()
             self._GoReconnect(False)
             self._WaitUntilSync()
           except errors.OpExecError, err:
             self.LogWarning("Migration failed and I can't reconnect the"
                             " drives: error '%s'\n"
                             "Please look and recover the instance status" %
                             str(err))
         def _AbortMigration(self):
           """Call the hypervisor code to abort a started migration.
           """
           instance = self.instance
           target_node = self.target_node
           migration_info = self.migration_info
           abort_result = self.rpc.call_finalize_migration(target_node,
                                                           instance,
                                                           migration_info,
                                                           False)
           abort_msg = abort_result.RemoteFailMsg()
           if abort_msg:
             logging.error("Aborting migration failed on target node %s: %s" %
                           (target_node, abort_msg))
             # Don't raise an exception here, as we stil have to try to revert the
             # disk status, even if this step failed.
         def _ExecMigration(self):
           """Migrate an instance.
           The migrate is done by:
             - change the disks into dual-master mode
             - wait until disks are fully synchronized again
             - migrate the instance
             - change disks on the new secondary node (the old primary) to secondary
             - wait until disks are fully synchronized
             - change disks into single-master mode
           """
           instance = self.instance
           target_node = self.target_node
           source_node = self.source_node
           self.feedback_fn("* checking disk consistency between source and target")
           for dev in instance.disks:
             if not _CheckDiskConsistency(self, dev, target_node, False):
               raise errors.OpExecError("Disk %s is degraded or not fully"
                                        " synchronized on target node,"
                                        " aborting migrate." % dev.iv_name)
           # First get the migration information from the remote node
           result = self.rpc.call_migration_info(source_node, instance)
           msg = result.RemoteFailMsg()
           if msg:
             log_err = ("Failed fetching source migration information from %s: %s" %
                        (source_node, msg))
             logging.error(log_err)

Synnefo » snf-ganeti » ganeti-local

root / lib / cmdlib.py @ b726aff0