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

| Branch: | Tag: | Revision:

root / lib / cmdlib / init.py @ 7352d33b

History | View | Annotate | Download (434.3 kB)

+      #
+      #
       # Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 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=W0201,C0302
       # W0201 since most LU attributes are defined in CheckPrereq or similar
       # functions
       # C0302: since we have waaaay too many lines in this module
       import os
       import time
       import logging
       import copy
       import OpenSSL
       import itertools
       import operator
       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 compat
       from ganeti import masterd
       from ganeti import netutils
       from ganeti import query
       from ganeti import qlang
       from ganeti import opcodes
       from ganeti import ht
       from ganeti import rpc
       from ganeti import pathutils
       from ganeti import network
       from ganeti.masterd import iallocator
       from ganeti.cmdlib.base import ResultWithJobs, LogicalUnit, NoHooksLU, \
         Tasklet, _QueryBase
       from ganeti.cmdlib.common import _ExpandInstanceName, _ExpandItemName, \
         _ExpandNodeName, _ShareAll, _CheckNodeGroupInstances, _GetWantedNodes, \
         _GetWantedInstances, _RunPostHook, _RedistributeAncillaryFiles, \
         _MergeAndVerifyHvState, _MergeAndVerifyDiskState, _GetUpdatedIPolicy, \
         _ComputeNewInstanceViolations, _GetUpdatedParams, _CheckOSParams, \
         _CheckHVParams, _AdjustCandidatePool, _CheckNodePVs, \
         _ComputeIPolicyInstanceViolation, _AnnotateDiskParams, _SupportsOob, \
         _ComputeIPolicySpecViolation
       from ganeti.cmdlib.cluster import LUClusterActivateMasterIp, \
         LUClusterDeactivateMasterIp, LUClusterConfigQuery, LUClusterDestroy, \
         LUClusterPostInit, _ClusterQuery, LUClusterQuery, LUClusterRedistConf, \
         LUClusterRename, LUClusterRepairDiskSizes, LUClusterSetParams, \
         LUClusterVerify, LUClusterVerifyConfig, LUClusterVerifyGroup, \
         LUClusterVerifyDisks
       from ganeti.cmdlib.tags import LUTagsGet, LUTagsSearch, LUTagsSet, LUTagsDel
       from ganeti.cmdlib.network import LUNetworkAdd, LUNetworkRemove, \
         LUNetworkSetParams, _NetworkQuery, LUNetworkQuery, LUNetworkConnect, \
         LUNetworkDisconnect
       from ganeti.cmdlib.test import LUTestDelay, LUTestJqueue, LUTestAllocator
       import ganeti.masterd.instance # pylint: disable=W0611
       # States of instance
       INSTANCE_DOWN = [constants.ADMINST_DOWN]
       INSTANCE_ONLINE = [constants.ADMINST_DOWN, constants.ADMINST_UP]
       INSTANCE_NOT_RUNNING = [constants.ADMINST_DOWN, constants.ADMINST_OFFLINE]
       #: Instance status in which an instance can be marked as offline/online
       CAN_CHANGE_INSTANCE_OFFLINE = (frozenset(INSTANCE_DOWN) | frozenset([
         constants.ADMINST_OFFLINE,
         ]))
       def _CheckInstancesNodeGroups(cfg, instances, owned_groups, owned_nodes,
                                     cur_group_uuid):
         """Checks if node groups for locked instances are still correct.
         @type cfg: L{config.ConfigWriter}
         @param cfg: Cluster configuration
         @type instances: dict; string as key, L{objects.Instance} as value
         @param instances: Dictionary, instance name as key, instance object as value
         @type owned_groups: iterable of string
         @param owned_groups: List of owned groups
         @type owned_nodes: iterable of string
         @param owned_nodes: List of owned nodes
         @type cur_group_uuid: string or None
         @param cur_group_uuid: Optional group UUID to check against instance's groups
         """
         for (name, inst) in instances.items():
           assert owned_nodes.issuperset(inst.all_nodes), \
             "Instance %s's nodes changed while we kept the lock" % name
           inst_groups = _CheckInstanceNodeGroups(cfg, name, owned_groups)
           assert cur_group_uuid is None or cur_group_uuid in inst_groups, \
             "Instance %s has no node in group %s" % (name, cur_group_uuid)
       def _CheckInstanceNodeGroups(cfg, instance_name, owned_groups,
                                    primary_only=False):
         """Checks if the owned node groups are still correct for an instance.
         @type cfg: L{config.ConfigWriter}
         @param cfg: The cluster configuration
         @type instance_name: string
         @param instance_name: Instance name
         @type owned_groups: set or frozenset
         @param owned_groups: List of currently owned node groups
         @type primary_only: boolean
         @param primary_only: Whether to check node groups for only the primary node
         """
         inst_groups = cfg.GetInstanceNodeGroups(instance_name, primary_only)
         if not owned_groups.issuperset(inst_groups):
           raise errors.OpPrereqError("Instance %s's node groups changed since"
                                      " locks were acquired, current groups are"
                                      " are '%s', owning groups '%s'; retry the"
                                      " operation" %
                                      (instance_name,
                                       utils.CommaJoin(inst_groups),
                                       utils.CommaJoin(owned_groups)),
                                      errors.ECODE_STATE)
         return inst_groups
       def _IsExclusiveStorageEnabledNode(cfg, node):
         """Whether exclusive_storage is in effect for the given node.
         @type cfg: L{config.ConfigWriter}
         @param cfg: The cluster configuration
         @type node: L{objects.Node}
         @param node: The node
         @rtype: bool
         @return: The effective value of exclusive_storage
         """
         return cfg.GetNdParams(node)[constants.ND_EXCLUSIVE_STORAGE]
       def _IsExclusiveStorageEnabledNodeName(cfg, nodename):
         """Whether exclusive_storage is in effect for the given node.
         @type cfg: L{config.ConfigWriter}
         @param cfg: The cluster configuration
         @type nodename: string
         @param nodename: The node
         @rtype: bool
         @return: The effective value of exclusive_storage
         @raise errors.OpPrereqError: if no node exists with the given name
         """
         ni = cfg.GetNodeInfo(nodename)
         if ni is None:
           raise errors.OpPrereqError("Invalid node name %s" % nodename,
                                      errors.ECODE_NOENT)
         return _IsExclusiveStorageEnabledNode(cfg, ni)
       def _CopyLockList(names):
         """Makes a copy of a list of lock names.
         Handles L{locking.ALL_SET} correctly.
         """
         if names == locking.ALL_SET:
           return locking.ALL_SET
         else:
           return names[:]
       def _ReleaseLocks(lu, level, names=None, keep=None):
         """Releases locks owned by an LU.
         @type lu: L{LogicalUnit}
         @param level: Lock level
         @type names: list or None
         @param names: Names of locks to release
         @type keep: list or None
         @param keep: Names of locks to retain
         """
         assert not (keep is not None and names is not None), \
                "Only one of the 'names' and the 'keep' parameters can be given"
         if names is not None:
           should_release = names.__contains__
         elif keep:
           should_release = lambda name: name not in keep
         else:
           should_release = None
         owned = lu.owned_locks(level)
         if not owned:
           # Not owning any lock at this level, do nothing
           pass
         elif should_release:
           retain = []
           release = []
           # Determine which locks to release
           for name in owned:
             if should_release(name):
               release.append(name)
             else:
               retain.append(name)
           assert len(lu.owned_locks(level)) == (len(retain) + len(release))
           # Release just some locks
           lu.glm.release(level, names=release)
           assert frozenset(lu.owned_locks(level)) == frozenset(retain)
         else:
           # Release everything
           lu.glm.release(level)
           assert not lu.glm.is_owned(level), "No locks should be owned"
       def _MapInstanceDisksToNodes(instances):
         """Creates a map from (node, volume) to instance name.
         @type instances: list of L{objects.Instance}
         @rtype: dict; tuple of (node name, volume name) as key, instance name as value
         """
         return dict(((node, vol), inst.name)
                     for inst in instances
                     for (node, vols) in inst.MapLVsByNode().items()
                     for vol in vols)
       def _CheckOutputFields(static, dynamic, selected):
         """Checks whether all selected fields are valid.
         @type static: L{utils.FieldSet}
         @param static: static fields set
         @type dynamic: L{utils.FieldSet}
         @param dynamic: dynamic fields set
         """
         f = utils.FieldSet()
         f.Extend(static)
         f.Extend(dynamic)
         delta = f.NonMatching(selected)
         if delta:
           raise errors.OpPrereqError("Unknown output fields selected: %s"
                                      % ",".join(delta), errors.ECODE_INVAL)
       def _CheckParamsNotGlobal(params, glob_pars, kind, bad_levels, good_levels):
         """Make sure that none of the given paramters is global.
         If a global parameter is found, an L{errors.OpPrereqError} exception is
         raised. This is used to avoid setting global parameters for individual nodes.
         @type params: dictionary
         @param params: Parameters to check
         @type glob_pars: dictionary
         @param glob_pars: Forbidden parameters
         @type kind: string
         @param kind: Kind of parameters (e.g. "node")
         @type bad_levels: string
         @param bad_levels: Level(s) at which the parameters are forbidden (e.g.
             "instance")
         @type good_levels: strings
         @param good_levels: Level(s) at which the parameters are allowed (e.g.
             "cluster or group")
         """
         used_globals = glob_pars.intersection(params)
         if used_globals:
           msg = ("The following %s parameters are global and cannot"
                  " be customized at %s level, please modify them at"
                  " %s level: %s" %
                  (kind, bad_levels, good_levels, utils.CommaJoin(used_globals)))
           raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
       def _CheckNodeOnline(lu, node, msg=None):
         """Ensure that a given node is online.
         @param lu: the LU on behalf of which we make the check
         @param node: the node to check
         @param msg: if passed, should be a message to replace the default one
         @raise errors.OpPrereqError: if the node is offline
         """
         if msg is None:
           msg = "Can't use offline node"
         if lu.cfg.GetNodeInfo(node).offline:
           raise errors.OpPrereqError("%s: %s" % (msg, node), errors.ECODE_STATE)
       def _CheckNodeNotDrained(lu, node):
         """Ensure that a given node is not drained.
         @param lu: the LU on behalf of which we make the check
         @param node: the node to check
         @raise errors.OpPrereqError: if the node is drained
         """
         if lu.cfg.GetNodeInfo(node).drained:
           raise errors.OpPrereqError("Can't use drained node %s" % node,
                                      errors.ECODE_STATE)
       def _CheckNodeVmCapable(lu, node):
         """Ensure that a given node is vm capable.
         @param lu: the LU on behalf of which we make the check
         @param node: the node to check
         @raise errors.OpPrereqError: if the node is not vm capable
         """
         if not lu.cfg.GetNodeInfo(node).vm_capable:
           raise errors.OpPrereqError("Can't use non-vm_capable node %s" % node,
                                      errors.ECODE_STATE)
       def _CheckNodeHasOS(lu, node, os_name, force_variant):
         """Ensure that a node supports a given OS.
         @param lu: the LU on behalf of which we make the check
         @param node: the node to check
         @param os_name: the OS to query about
         @param force_variant: whether to ignore variant errors
         @raise errors.OpPrereqError: if the node is not supporting the OS
         """
         result = lu.rpc.call_os_get(node, os_name)
         result.Raise("OS '%s' not in supported OS list for node %s" %
                      (os_name, node),
                      prereq=True, ecode=errors.ECODE_INVAL)
         if not force_variant:
           _CheckOSVariant(result.payload, os_name)
       def _CheckNodeHasSecondaryIP(lu, node, secondary_ip, prereq):
         """Ensure that a node has the given secondary ip.
         @type lu: L{LogicalUnit}
         @param lu: the LU on behalf of which we make the check
         @type node: string
         @param node: the node to check
         @type secondary_ip: string
         @param secondary_ip: the ip to check
         @type prereq: boolean
         @param prereq: whether to throw a prerequisite or an execute error
         @raise errors.OpPrereqError: if the node doesn't have the ip, and prereq=True
         @raise errors.OpExecError: if the node doesn't have the ip, and prereq=False
         """
         result = lu.rpc.call_node_has_ip_address(node, secondary_ip)
         result.Raise("Failure checking secondary ip on node %s" % node,
                      prereq=prereq, ecode=errors.ECODE_ENVIRON)
         if not result.payload:
           msg = ("Node claims it doesn't have the secondary ip you gave (%s),"
                  " please fix and re-run this command" % secondary_ip)
           if prereq:
             raise errors.OpPrereqError(msg, errors.ECODE_ENVIRON)
           else:
             raise errors.OpExecError(msg)
       def _GetClusterDomainSecret():
         """Reads the cluster domain secret.
         """
         return utils.ReadOneLineFile(pathutils.CLUSTER_DOMAIN_SECRET_FILE,
                                      strict=True)
       def _CheckInstanceState(lu, instance, req_states, msg=None):
         """Ensure that an instance is in one of the required states.
         @param lu: the LU on behalf of which we make the check
         @param instance: the instance to check
         @param msg: if passed, should be a message to replace the default one
         @raise errors.OpPrereqError: if the instance is not in the required state
         """
         if msg is None:
           msg = ("can't use instance from outside %s states" %
                  utils.CommaJoin(req_states))
         if instance.admin_state not in req_states:
           raise errors.OpPrereqError("Instance '%s' is marked to be %s, %s" %
                                      (instance.name, instance.admin_state, msg),
                                      errors.ECODE_STATE)
         if constants.ADMINST_UP not in req_states:
           pnode = instance.primary_node
           if not lu.cfg.GetNodeInfo(pnode).offline:
             ins_l = lu.rpc.call_instance_list([pnode], [instance.hypervisor])[pnode]
             ins_l.Raise("Can't contact node %s for instance information" % pnode,
                         prereq=True, ecode=errors.ECODE_ENVIRON)
             if instance.name in ins_l.payload:
               raise errors.OpPrereqError("Instance %s is running, %s" %
                                          (instance.name, msg), errors.ECODE_STATE)
           else:
             lu.LogWarning("Primary node offline, ignoring check that instance"
                            " is down")
       def _ComputeIPolicyInstanceSpecViolation(
         ipolicy, instance_spec, disk_template,
         _compute_fn=_ComputeIPolicySpecViolation):
         """Compute if instance specs meets the specs of ipolicy.
         @type ipolicy: dict
         @param ipolicy: The ipolicy to verify against
         @param instance_spec: dict
         @param instance_spec: The instance spec to verify
         @type disk_template: string
         @param disk_template: the disk template of the instance
         @param _compute_fn: The function to verify ipolicy (unittest only)
         @see: L{_ComputeIPolicySpecViolation}
         """
         mem_size = instance_spec.get(constants.ISPEC_MEM_SIZE, None)
         cpu_count = instance_spec.get(constants.ISPEC_CPU_COUNT, None)
         disk_count = instance_spec.get(constants.ISPEC_DISK_COUNT, 0)
         disk_sizes = instance_spec.get(constants.ISPEC_DISK_SIZE, [])
         nic_count = instance_spec.get(constants.ISPEC_NIC_COUNT, 0)
         spindle_use = instance_spec.get(constants.ISPEC_SPINDLE_USE, None)
         return _compute_fn(ipolicy, mem_size, cpu_count, disk_count, nic_count,
                            disk_sizes, spindle_use, disk_template)
       def _ComputeIPolicyNodeViolation(ipolicy, instance, current_group,
                                        target_group, cfg,
                                        _compute_fn=_ComputeIPolicyInstanceViolation):
         """Compute if instance meets the specs of the new target group.
         @param ipolicy: The ipolicy to verify
         @param instance: The instance object to verify
         @param current_group: The current group of the instance
         @param target_group: The new group of the instance
         @type cfg: L{config.ConfigWriter}
         @param cfg: Cluster configuration
         @param _compute_fn: The function to verify ipolicy (unittest only)
         @see: L{_ComputeIPolicySpecViolation}
         """
         if current_group == target_group:
           return []
         else:
           return _compute_fn(ipolicy, instance, cfg)
       def _CheckTargetNodeIPolicy(lu, ipolicy, instance, node, cfg, ignore=False,
                                   _compute_fn=_ComputeIPolicyNodeViolation):
         """Checks that the target node is correct in terms of instance policy.
         @param ipolicy: The ipolicy to verify
         @param instance: The instance object to verify
         @param node: The new node to relocate
         @type cfg: L{config.ConfigWriter}
         @param cfg: Cluster configuration
         @param ignore: Ignore violations of the ipolicy
         @param _compute_fn: The function to verify ipolicy (unittest only)
         @see: L{_ComputeIPolicySpecViolation}
         """
         primary_node = lu.cfg.GetNodeInfo(instance.primary_node)
         res = _compute_fn(ipolicy, instance, primary_node.group, node.group, cfg)
         if res:
           msg = ("Instance does not meet target node group's (%s) instance"
                  " policy: %s") % (node.group, utils.CommaJoin(res))
           if ignore:
             lu.LogWarning(msg)
           else:
             raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
       def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,
                                 minmem, maxmem, vcpus, nics, disk_template, disks,
                                 bep, hvp, hypervisor_name, tags):
         """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: string
         @param status: the desired status of the instance
         @type minmem: string
         @param minmem: the minimum memory size of the instance
         @type maxmem: string
         @param maxmem: the maximum 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 (name, uuid, ip, mac, mode, link, net, netinfo)
             representing the NICs the instance has
         @type disk_template: string
         @param disk_template: the disk template of the instance
         @type disks: list
         @param disks: list of tuples (name, uuid, size, mode)
         @type bep: dict
         @param bep: the backend parameters for the instance
         @type hvp: dict
         @param hvp: the hypervisor parameters for the instance
         @type hypervisor_name: string
         @param hypervisor_name: the hypervisor for the instance
         @type tags: list
         @param tags: list of instance tags as strings
         @rtype: dict
         @return: the hook environment for this instance
         """
         env = {
           "OP_TARGET": name,
           "INSTANCE_NAME": name,
           "INSTANCE_PRIMARY": primary_node,
           "INSTANCE_SECONDARIES": " ".join(secondary_nodes),
           "INSTANCE_OS_TYPE": os_type,
           "INSTANCE_STATUS": status,
           "INSTANCE_MINMEM": minmem,
           "INSTANCE_MAXMEM": maxmem,
           # TODO(2.9) remove deprecated "memory" value
           "INSTANCE_MEMORY": maxmem,
           "INSTANCE_VCPUS": vcpus,
           "INSTANCE_DISK_TEMPLATE": disk_template,
           "INSTANCE_HYPERVISOR": hypervisor_name,
+        }
         if nics:
           nic_count = len(nics)
           for idx, (name, _, ip, mac, mode, link, net, netinfo) in enumerate(nics):
             if ip is None:
               ip = ""
             env["INSTANCE_NIC%d_NAME" % idx] = name
             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 netinfo:
               nobj = objects.Network.FromDict(netinfo)
               env.update(nobj.HooksDict("INSTANCE_NIC%d_" % idx))
             elif network:
               # FIXME: broken network reference: the instance NIC specifies a
               # network, but the relevant network entry was not in the config. This
               # should be made impossible.
               env["INSTANCE_NIC%d_NETWORK_NAME" % idx] = net
             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, (name, size, mode) in enumerate(disks):
             env["INSTANCE_DISK%d_NAME" % idx] = name
             env["INSTANCE_DISK%d_SIZE" % idx] = size
             env["INSTANCE_DISK%d_MODE" % idx] = mode
         else:
           disk_count = 0
         env["INSTANCE_DISK_COUNT"] = disk_count
         if not tags:
           tags = []
         env["INSTANCE_TAGS"] = " ".join(tags)
         for source, kind in [(bep, "BE"), (hvp, "HV")]:
           for key, value in source.items():
             env["INSTANCE_%s_%s" % (kind, key)] = value
         return env
       def _NICToTuple(lu, nic):
         """Build a tupple of nic information.
         @type lu:  L{LogicalUnit}
         @param lu: the logical unit on whose behalf we execute
         @type nic: L{objects.NIC}
         @param nic: nic to convert to hooks tuple
         """
         cluster = lu.cfg.GetClusterInfo()
         filled_params = cluster.SimpleFillNIC(nic.nicparams)
         mode = filled_params[constants.NIC_MODE]
         link = filled_params[constants.NIC_LINK]
         netinfo = None
         if nic.network:
           nobj = lu.cfg.GetNetwork(nic.network)
           netinfo = objects.Network.ToDict(nobj)
         return (nic.name, nic.uuid, nic.ip, nic.mac, mode, link, nic.network, netinfo)
       def _NICListToTuple(lu, nics):
         """Build a list of nic information tuples.
         This list is suitable to be passed to _BuildInstanceHookEnv or as a return
         value in LUInstanceQueryData.
         @type lu:  L{LogicalUnit}
         @param lu: the logical unit on whose behalf we execute
         @type nics: list of L{objects.NIC}
         @param nics: list of nics to convert to hooks tuples
         """
         hooks_nics = []
         for nic in nics:
           hooks_nics.append(_NICToTuple(lu, nic))
         return hooks_nics
       def _BuildInstanceHookEnvByObject(lu, instance, override=None):
         """Builds instance related env variables for hooks from an object.
         @type lu: L{LogicalUnit}
         @param lu: the logical unit on whose behalf we execute
         @type instance: L{objects.Instance}
         @param instance: the instance for which we should build the
             environment
         @type override: dict
         @param override: dictionary with key/values that will override
             our values
         @rtype: dict
         @return: the hook environment dictionary
         """
         cluster = lu.cfg.GetClusterInfo()
         bep = cluster.FillBE(instance)
         hvp = cluster.FillHV(instance)
         args = {
           "name": instance.name,
           "primary_node": instance.primary_node,
           "secondary_nodes": instance.secondary_nodes,
           "os_type": instance.os,
           "status": instance.admin_state,
           "maxmem": bep[constants.BE_MAXMEM],
           "minmem": bep[constants.BE_MINMEM],
           "vcpus": bep[constants.BE_VCPUS],
           "nics": _NICListToTuple(lu, instance.nics),
           "disk_template": instance.disk_template,
           "disks": [(disk.name, disk.size, disk.mode)
                     for disk in instance.disks],
           "bep": bep,
           "hvp": hvp,
           "hypervisor_name": instance.hypervisor,
           "tags": instance.tags,
+        }
         if override:
           args.update(override)
         return _BuildInstanceHookEnv(**args) # pylint: disable=W0142
       def _DecideSelfPromotion(lu, exceptions=None):
         """Decide whether I should promote myself as a master candidate.
         """
         cp_size = lu.cfg.GetClusterInfo().candidate_pool_size
         mc_now, mc_should, _ = lu.cfg.GetMasterCandidateStats(exceptions)
         # the new node will increase mc_max with one, so:
         mc_should = min(mc_should + 1, cp_size)
         return mc_now < mc_should
       def _CheckNicsBridgesExist(lu, target_nics, target_node):
         """Check that the brigdes needed by a list of nics exist.
         """
         cluster = lu.cfg.GetClusterInfo()
         paramslist = [cluster.SimpleFillNIC(nic.nicparams) for nic in target_nics]
         brlist = [params[constants.NIC_LINK] for params in paramslist
                   if params[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED]
         if brlist:
           result = lu.rpc.call_bridges_exist(target_node, brlist)
           result.Raise("Error checking bridges on destination node '%s'" %
                        target_node, prereq=True, ecode=errors.ECODE_ENVIRON)
       def _CheckInstanceBridgesExist(lu, instance, node=None):
         """Check that the brigdes needed by an instance exist.
         """
         if node is None:
           node = instance.primary_node
         _CheckNicsBridgesExist(lu, instance.nics, node)
       def _CheckOSVariant(os_obj, name):
         """Check whether an OS name conforms to the os variants specification.
         @type os_obj: L{objects.OS}
         @param os_obj: OS object to check
         @type name: string
         @param name: OS name passed by the user, to check for validity
         """
         variant = objects.OS.GetVariant(name)
         if not os_obj.supported_variants:
           if variant:
             raise errors.OpPrereqError("OS '%s' doesn't support variants ('%s'"
                                        " passed)" % (os_obj.name, variant),
                                        errors.ECODE_INVAL)
           return
         if not variant:
           raise errors.OpPrereqError("OS name must include a variant",
                                      errors.ECODE_INVAL)
         if variant not in os_obj.supported_variants:
           raise errors.OpPrereqError("Unsupported OS variant", errors.ECODE_INVAL)
       def _GetNodeInstancesInner(cfg, fn):
         return [i for i in cfg.GetAllInstancesInfo().values() if fn(i)]
       def _GetNodeInstances(cfg, node_name):
         """Returns a list of all primary and secondary instances on a node.
         """
         return _GetNodeInstancesInner(cfg, lambda inst: node_name in inst.all_nodes)
       def _GetNodePrimaryInstances(cfg, node_name):
         """Returns primary instances on a node.
         """
         return _GetNodeInstancesInner(cfg,
                                       lambda inst: node_name == inst.primary_node)
       def _GetNodeSecondaryInstances(cfg, node_name):
         """Returns secondary instances on a node.
         """
         return _GetNodeInstancesInner(cfg,
                                       lambda inst: node_name in inst.secondary_nodes)
       def _GetStorageTypeArgs(cfg, storage_type):
         """Returns the arguments for a storage type.
         """
         # Special case for file storage
         if storage_type == constants.ST_FILE:
           # storage.FileStorage wants a list of storage directories
           return [[cfg.GetFileStorageDir(), cfg.GetSharedFileStorageDir()]]
         return []
       def _FindFaultyInstanceDisks(cfg, rpc_runner, instance, node_name, prereq):
         faulty = []
         for dev in instance.disks:
           cfg.SetDiskID(dev, node_name)
         result = rpc_runner.call_blockdev_getmirrorstatus(node_name, (instance.disks,
                                                                       instance))
         result.Raise("Failed to get disk status from node %s" % node_name,
                      prereq=prereq, ecode=errors.ECODE_ENVIRON)
         for idx, bdev_status in enumerate(result.payload):
           if bdev_status and bdev_status.ldisk_status == constants.LDS_FAULTY:
             faulty.append(idx)
         return faulty
       def _CheckIAllocatorOrNode(lu, iallocator_slot, node_slot):
         """Check the sanity of iallocator and node arguments and use the
         cluster-wide iallocator if appropriate.
         Check that at most one of (iallocator, node) is specified. If none is
         specified, or the iallocator is L{constants.DEFAULT_IALLOCATOR_SHORTCUT},
         then the LU's opcode's iallocator slot is filled with the cluster-wide
         default iallocator.
         @type iallocator_slot: string
         @param iallocator_slot: the name of the opcode iallocator slot
         @type node_slot: string
         @param node_slot: the name of the opcode target node slot
         """
         node = getattr(lu.op, node_slot, None)
         ialloc = getattr(lu.op, iallocator_slot, None)
         if node == []:
           node = None
         if node is not None and ialloc is not None:
           raise errors.OpPrereqError("Do not specify both, iallocator and node",
                                      errors.ECODE_INVAL)
         elif ((node is None and ialloc is None) or
               ialloc == constants.DEFAULT_IALLOCATOR_SHORTCUT):
           default_iallocator = lu.cfg.GetDefaultIAllocator()
           if default_iallocator:
             setattr(lu.op, iallocator_slot, default_iallocator)
           else:
             raise errors.OpPrereqError("No iallocator or node given and no"
                                        " cluster-wide default iallocator found;"
                                        " please specify either an iallocator or a"
                                        " node, or set a cluster-wide default"
                                        " iallocator", errors.ECODE_INVAL)
       def _GetDefaultIAllocator(cfg, ialloc):
         """Decides on which iallocator to use.
         @type cfg: L{config.ConfigWriter}
         @param cfg: Cluster configuration object
         @type ialloc: string or None
         @param ialloc: Iallocator specified in opcode
         @rtype: string
         @return: Iallocator name
         """
         if not ialloc:
           # Use default iallocator
           ialloc = cfg.GetDefaultIAllocator()
         if not ialloc:
           raise errors.OpPrereqError("No iallocator was specified, neither in the"
                                      " opcode nor as a cluster-wide default",
                                      errors.ECODE_INVAL)
         return ialloc
       def _CheckHostnameSane(lu, name):
         """Ensures that a given hostname resolves to a 'sane' name.
         The given name is required to be a prefix of the resolved hostname,
         to prevent accidental mismatches.
         @param lu: the logical unit on behalf of which we're checking
         @param name: the name we should resolve and check
         @return: the resolved hostname object
         """
         hostname = netutils.GetHostname(name=name)
         if hostname.name != name:
           lu.LogInfo("Resolved given name '%s' to '%s'", name, hostname.name)
         if not utils.MatchNameComponent(name, [hostname.name]):
           raise errors.OpPrereqError(("Resolved hostname '%s' does not look the"
                                       " same as given hostname '%s'") %
                                       (hostname.name, name), errors.ECODE_INVAL)
         return hostname
       class LUGroupVerifyDisks(NoHooksLU):
         """Verifies the status of all disks in a node group.
         """
         REQ_BGL = False
         def ExpandNames(self):
           # Raises errors.OpPrereqError on its own if group can't be found
           self.group_uuid = self.cfg.LookupNodeGroup(self.op.group_name)
           self.share_locks = _ShareAll()
           self.needed_locks = {
             locking.LEVEL_INSTANCE: [],
             locking.LEVEL_NODEGROUP: [],
             locking.LEVEL_NODE: [],
             # This opcode is acquires all node locks in a group. LUClusterVerifyDisks
             # starts one instance of this opcode for every group, which means all
             # nodes will be locked for a short amount of time, so it's better to
             # acquire the node allocation lock as well.
             locking.LEVEL_NODE_ALLOC: locking.ALL_SET,
+            }
         def DeclareLocks(self, level):
           if level == locking.LEVEL_INSTANCE:
             assert not self.needed_locks[locking.LEVEL_INSTANCE]
             # Lock instances optimistically, needs verification once node and group
             # locks have been acquired
             self.needed_locks[locking.LEVEL_INSTANCE] = \
               self.cfg.GetNodeGroupInstances(self.group_uuid)
           elif level == locking.LEVEL_NODEGROUP:
             assert not self.needed_locks[locking.LEVEL_NODEGROUP]
             self.needed_locks[locking.LEVEL_NODEGROUP] = \
               set([self.group_uuid] +
                   # Lock all groups used by instances optimistically; this requires
                   # going via the node before it's locked, requiring verification
                   # later on
                   [group_uuid
                    for instance_name in self.owned_locks(locking.LEVEL_INSTANCE)
                    for group_uuid in self.cfg.GetInstanceNodeGroups(instance_name)])
           elif level == locking.LEVEL_NODE:
             # This will only lock the nodes in the group to be verified which contain
             # actual instances
             self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_APPEND
             self._LockInstancesNodes()
             # Lock all nodes in group to be verified
             assert self.group_uuid in self.owned_locks(locking.LEVEL_NODEGROUP)
             member_nodes = self.cfg.GetNodeGroup(self.group_uuid).members
             self.needed_locks[locking.LEVEL_NODE].extend(member_nodes)
         def CheckPrereq(self):
           owned_instances = frozenset(self.owned_locks(locking.LEVEL_INSTANCE))
           owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))
           owned_nodes = frozenset(self.owned_locks(locking.LEVEL_NODE))
           assert self.group_uuid in owned_groups
           # Check if locked instances are still correct
           _CheckNodeGroupInstances(self.cfg, self.group_uuid, owned_instances)
           # Get instance information
           self.instances = dict(self.cfg.GetMultiInstanceInfo(owned_instances))
           # Check if node groups for locked instances are still correct
           _CheckInstancesNodeGroups(self.cfg, self.instances,
                                     owned_groups, owned_nodes, self.group_uuid)
         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
           """
           res_nodes = {}
           res_instances = set()
           res_missing = {}
           nv_dict = _MapInstanceDisksToNodes(
             [inst for inst in self.instances.values()
              if inst.admin_state == constants.ADMINST_UP])
           if nv_dict:
             nodes = utils.NiceSort(set(self.owned_locks(locking.LEVEL_NODE)) &
                                    set(self.cfg.GetVmCapableNodeList()))
             node_lvs = self.rpc.call_lv_list(nodes, [])
             for (node, node_res) in node_lvs.items():
               if node_res.offline:
                 continue
               msg = node_res.fail_msg
               if msg:
                 logging.warning("Error enumerating LVs on node %s: %s", node, msg)
                 res_nodes[node] = msg
                 continue
               for lv_name, (_, _, lv_online) in node_res.payload.items():
                 inst = nv_dict.pop((node, lv_name), None)
                 if not (lv_online or inst is None):
                   res_instances.add(inst)
             # any leftover items in nv_dict are missing LVs, let's arrange the data
             # better
             for key, inst in nv_dict.iteritems():
               res_missing.setdefault(inst, []).append(list(key))
           return (res_nodes, list(res_instances), res_missing)
       def _WaitForSync(lu, instance, disks=None, oneshot=False):
         """Sleep and poll for an instance's disk to sync.
         """
         if not instance.disks or disks is not None and not disks:
           return True
         disks = _ExpandCheckDisks(instance, disks)
         if not oneshot:
           lu.LogInfo("Waiting for instance %s to sync disks", instance.name)
         node = instance.primary_node
         for dev in disks:
           lu.cfg.SetDiskID(dev, node)
         # TODO: Convert to utils.Retry
         retries = 0
         degr_retries = 10 # in seconds, as we sleep 1 second each time
         while True:
           max_time = 0
           done = True
           cumul_degraded = False
           rstats = lu.rpc.call_blockdev_getmirrorstatus(node, (disks, instance))
           msg = rstats.fail_msg
           if msg:
             lu.LogWarning("Can't get any data from node %s: %s", node, msg)
             retries += 1
             if retries >= 10:
               raise errors.RemoteError("Can't contact node %s for mirror data,"
                                        " aborting." % node)
             time.sleep(6)
             continue
           rstats = rstats.payload
           retries = 0
           for i, mstat in enumerate(rstats):
             if mstat is None:
               lu.LogWarning("Can't compute data for node %s/%s",
                                  node, disks[i].iv_name)
               continue
             cumul_degraded = (cumul_degraded or
                               (mstat.is_degraded and mstat.sync_percent is None))
             if mstat.sync_percent is not None:
               done = False
               if mstat.estimated_time is not None:
                 rem_time = ("%s remaining (estimated)" %
                             utils.FormatSeconds(mstat.estimated_time))
                 max_time = mstat.estimated_time
               else:
                 rem_time = "no time estimate"
               lu.LogInfo("- device %s: %5.2f%% done, %s",
                          disks[i].iv_name, mstat.sync_percent, rem_time)
           # if we're done but degraded, let's do a few small retries, to
           # make sure we see a stable and not transient situation; therefore
           # we force restart of the loop
           if (done or oneshot) and cumul_degraded and degr_retries > 0:
             logging.info("Degraded disks found, %d retries left", degr_retries)
             degr_retries -= 1
             time.sleep(1)
             continue
           if done or oneshot:
             break
           time.sleep(min(60, max_time))
         if done:
           lu.LogInfo("Instance %s's disks are in sync", instance.name)
         return not cumul_degraded
       def _BlockdevFind(lu, node, dev, instance):
         """Wrapper around call_blockdev_find to annotate diskparams.
         @param lu: A reference to the lu object
         @param node: The node to call out
         @param dev: The device to find
         @param instance: The instance object the device belongs to
         @returns The result of the rpc call
         """
         (disk,) = _AnnotateDiskParams(instance, [dev], lu.cfg)
         return lu.rpc.call_blockdev_find(node, disk)
       def _CheckDiskConsistency(lu, instance, dev, node, on_primary, ldisk=False):
         """Wrapper around L{_CheckDiskConsistencyInner}.
         """
         (disk,) = _AnnotateDiskParams(instance, [dev], lu.cfg)
         return _CheckDiskConsistencyInner(lu, instance, disk, node, on_primary,
                                           ldisk=ldisk)
       def _CheckDiskConsistencyInner(lu, instance, dev, node, on_primary,
                                      ldisk=False):
         """Check that mirrors are not degraded.
         @attention: The device has to be annotated already.
         The ldisk parameter, if True, will change the test from the
         is_degraded attribute (which represents overall non-ok status for
         the device(s)) to the ldisk (representing the local storage status).
         """
         lu.cfg.SetDiskID(dev, node)
         result = True
         if on_primary or dev.AssembleOnSecondary():
           rstats = lu.rpc.call_blockdev_find(node, dev)
           msg = rstats.fail_msg
           if msg:
             lu.LogWarning("Can't find disk on node %s: %s", node, msg)
             result = False
           elif not rstats.payload:
             lu.LogWarning("Can't find disk on node %s", node)
             result = False
           else:
             if ldisk:
               result = result and rstats.payload.ldisk_status == constants.LDS_OKAY
             else:
               result = result and not rstats.payload.is_degraded
         if dev.children:
           for child in dev.children:
             result = result and _CheckDiskConsistencyInner(lu, instance, child, node,
                                                            on_primary)
         return result
       class LUOobCommand(NoHooksLU):
         """Logical unit for OOB handling.
         """
         REQ_BGL = False
         _SKIP_MASTER = (constants.OOB_POWER_OFF, constants.OOB_POWER_CYCLE)
         def ExpandNames(self):
           """Gather locks we need.
           """
           if self.op.node_names:
             self.op.node_names = _GetWantedNodes(self, self.op.node_names)
             lock_names = self.op.node_names
           else:
             lock_names = locking.ALL_SET
           self.needed_locks = {
             locking.LEVEL_NODE: lock_names,
+            }
           self.share_locks[locking.LEVEL_NODE_ALLOC] = 1
           if not self.op.node_names:
             # Acquire node allocation lock only if all nodes are affected
             self.needed_locks[locking.LEVEL_NODE_ALLOC] = locking.ALL_SET
         def CheckPrereq(self):
           """Check prerequisites.
           This checks:
            - the node exists in the configuration
            - OOB is supported
           Any errors are signaled by raising errors.OpPrereqError.
           """
           self.nodes = []
           self.master_node = self.cfg.GetMasterNode()
           assert self.op.power_delay >= 0.0
           if self.op.node_names:
             if (self.op.command in self._SKIP_MASTER and
                 self.master_node in self.op.node_names):
               master_node_obj = self.cfg.GetNodeInfo(self.master_node)
               master_oob_handler = _SupportsOob(self.cfg, master_node_obj)
               if master_oob_handler:
                 additional_text = ("run '%s %s %s' if you want to operate on the"
                                    " master regardless") % (master_oob_handler,
                                                             self.op.command,
                                                             self.master_node)
               else:
                 additional_text = "it does not support out-of-band operations"
               raise errors.OpPrereqError(("Operating on the master node %s is not"
                                           " allowed for %s; %s") %
                                          (self.master_node, self.op.command,
                                           additional_text), errors.ECODE_INVAL)
           else:
             self.op.node_names = self.cfg.GetNodeList()
             if self.op.command in self._SKIP_MASTER:
               self.op.node_names.remove(self.master_node)
           if self.op.command in self._SKIP_MASTER:
             assert self.master_node not in self.op.node_names
           for (node_name, node) in self.cfg.GetMultiNodeInfo(self.op.node_names):
             if node is None:
               raise errors.OpPrereqError("Node %s not found" % node_name,
                                          errors.ECODE_NOENT)
             else:
               self.nodes.append(node)
             if (not self.op.ignore_status and
                 (self.op.command == constants.OOB_POWER_OFF and not node.offline)):
               raise errors.OpPrereqError(("Cannot power off node %s because it is"
                                           " not marked offline") % node_name,
                                          errors.ECODE_STATE)
         def Exec(self, feedback_fn):
           """Execute OOB and return result if we expect any.
           """
           master_node = self.master_node
           ret = []
           for idx, node in enumerate(utils.NiceSort(self.nodes,
                                                     key=lambda node: node.name)):
             node_entry = [(constants.RS_NORMAL, node.name)]
             ret.append(node_entry)
             oob_program = _SupportsOob(self.cfg, node)
             if not oob_program:
               node_entry.append((constants.RS_UNAVAIL, None))
               continue
             logging.info("Executing out-of-band command '%s' using '%s' on %s",
                          self.op.command, oob_program, node.name)
             result = self.rpc.call_run_oob(master_node, oob_program,
                                            self.op.command, node.name,
                                            self.op.timeout)
             if result.fail_msg:
               self.LogWarning("Out-of-band RPC failed on node '%s': %s",
                               node.name, result.fail_msg)
               node_entry.append((constants.RS_NODATA, None))
             else:
               try:
                 self._CheckPayload(result)
               except errors.OpExecError, err:
                 self.LogWarning("Payload returned by node '%s' is not valid: %s",
                                 node.name, err)
                 node_entry.append((constants.RS_NODATA, None))
               else:
                 if self.op.command == constants.OOB_HEALTH:
                   # For health we should log important events
                   for item, status in result.payload:
                     if status in [constants.OOB_STATUS_WARNING,
                                   constants.OOB_STATUS_CRITICAL]:
                       self.LogWarning("Item '%s' on node '%s' has status '%s'",
                                       item, node.name, status)
                 if self.op.command == constants.OOB_POWER_ON:
                   node.powered = True
                 elif self.op.command == constants.OOB_POWER_OFF:
                   node.powered = False
                 elif self.op.command == constants.OOB_POWER_STATUS:
                   powered = result.payload[constants.OOB_POWER_STATUS_POWERED]
                   if powered != node.powered:
                     logging.warning(("Recorded power state (%s) of node '%s' does not"
                                      " match actual power state (%s)"), node.powered,
                                     node.name, powered)
                 # For configuration changing commands we should update the node
                 if self.op.command in (constants.OOB_POWER_ON,
                                        constants.OOB_POWER_OFF):
                   self.cfg.Update(node, feedback_fn)
                 node_entry.append((constants.RS_NORMAL, result.payload))
                 if (self.op.command == constants.OOB_POWER_ON and
                     idx < len(self.nodes) - 1):
                   time.sleep(self.op.power_delay)
           return ret
         def _CheckPayload(self, result):
           """Checks if the payload is valid.
           @param result: RPC result
           @raises errors.OpExecError: If payload is not valid
           """
           errs = []
           if self.op.command == constants.OOB_HEALTH:
             if not isinstance(result.payload, list):
               errs.append("command 'health' is expected to return a list but got %s" %
                           type(result.payload))
             else:
               for item, status in result.payload:
                 if status not in constants.OOB_STATUSES:
                   errs.append("health item '%s' has invalid status '%s'" %
                               (item, status))
           if self.op.command == constants.OOB_POWER_STATUS:
             if not isinstance(result.payload, dict):
               errs.append("power-status is expected to return a dict but got %s" %
                           type(result.payload))
           if self.op.command in [
             constants.OOB_POWER_ON,
             constants.OOB_POWER_OFF,
             constants.OOB_POWER_CYCLE,
             ]:
             if result.payload is not None:
               errs.append("%s is expected to not return payload but got '%s'" %
                           (self.op.command, result.payload))
           if errs:
             raise errors.OpExecError("Check of out-of-band payload failed due to %s" %
                                      utils.CommaJoin(errs))
       class _OsQuery(_QueryBase):
         FIELDS = query.OS_FIELDS
         def ExpandNames(self, lu):
           # Lock all nodes in shared mode
           # Temporary removal of locks, should be reverted later
           # TODO: reintroduce locks when they are lighter-weight
           lu.needed_locks = {}
           #self.share_locks[locking.LEVEL_NODE] = 1
           #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
           # The following variables interact with _QueryBase._GetNames
           if self.names:
             self.wanted = self.names
           else:
             self.wanted = locking.ALL_SET
           self.do_locking = self.use_locking
         def DeclareLocks(self, lu, level):
           pass
         @staticmethod
         def _DiagnoseByOS(rlist):
           """Remaps a per-node return list into an a per-os per-node dictionary
           @param rlist: a map with node names as keys and OS objects as values
           @rtype: dict
           @return: a dictionary with osnames as keys and as value another
               map, with nodes as keys and tuples of (path, status, diagnose,
               variants, parameters, api_versions) as values, eg::
                 {"debian-etch": {"node1": [(/usr/lib/..., True, "", [], []),
                                            (/srv/..., False, "invalid api")],
                                  "node2": [(/srv/..., True, "", [], [])]}
+                }
           """
           all_os = {}
           # we build here the list of nodes that didn't fail the RPC (at RPC
           # level), so that nodes with a non-responding node daemon don't
           # make all OSes invalid
           good_nodes = [node_name for node_name in rlist
                         if not rlist[node_name].fail_msg]
           for node_name, nr in rlist.items():
             if nr.fail_msg or not nr.payload:
               continue
             for (name, path, status, diagnose, variants,
                  params, api_versions) in nr.payload:
               if name not in all_os:
                 # build a list of nodes for this os containing empty lists
                 # for each node in node_list
                 all_os[name] = {}
                 for nname in good_nodes:
                   all_os[name][nname] = []
               # convert params from [name, help] to (name, help)
               params = [tuple(v) for v in params]
               all_os[name][node_name].append((path, status, diagnose,
                                               variants, params, api_versions))
           return all_os
         def _GetQueryData(self, lu):
           """Computes the list of nodes and their attributes.
           """
           # Locking is not used
           assert not (compat.any(lu.glm.is_owned(level)
                                  for level in locking.LEVELS
                                  if level != locking.LEVEL_CLUSTER) or
                       self.do_locking or self.use_locking)
           valid_nodes = [node.name
                          for node in lu.cfg.GetAllNodesInfo().values()
                          if not node.offline and node.vm_capable]
           pol = self._DiagnoseByOS(lu.rpc.call_os_diagnose(valid_nodes))
           cluster = lu.cfg.GetClusterInfo()
           data = {}
           for (os_name, os_data) in pol.items():
             info = query.OsInfo(name=os_name, valid=True, node_status=os_data,
                                 hidden=(os_name in cluster.hidden_os),
                                 blacklisted=(os_name in cluster.blacklisted_os))
             variants = set()
             parameters = set()
             api_versions = set()
             for idx, osl in enumerate(os_data.values()):
               info.valid = bool(info.valid and osl and osl[0][1])
               if not info.valid:
                 break
               (node_variants, node_params, node_api) = osl[0][3:6]
               if idx == 0:
                 # First entry
                 variants.update(node_variants)
                 parameters.update(node_params)
                 api_versions.update(node_api)
               else:
                 # Filter out inconsistent values
                 variants.intersection_update(node_variants)
                 parameters.intersection_update(node_params)
                 api_versions.intersection_update(node_api)
             info.variants = list(variants)
             info.parameters = list(parameters)
             info.api_versions = list(api_versions)
             data[os_name] = info
           # Prepare data in requested order
           return [data[name] for name in self._GetNames(lu, pol.keys(), None)
                   if name in data]
       class LUOsDiagnose(NoHooksLU):
         """Logical unit for OS diagnose/query.
         """
         REQ_BGL = False
         @staticmethod
         def _BuildFilter(fields, names):
           """Builds a filter for querying OSes.
           """
           name_filter = qlang.MakeSimpleFilter("name", names)
           # Legacy behaviour: Hide hidden, blacklisted or invalid OSes if the
           # respective field is not requested
           status_filter = [[qlang.OP_NOT, [qlang.OP_TRUE, fname]]
                            for fname in ["hidden", "blacklisted"]
                            if fname not in fields]
           if "valid" not in fields:
             status_filter.append([qlang.OP_TRUE, "valid"])
           if status_filter:
             status_filter.insert(0, qlang.OP_AND)
           else:
             status_filter = None
           if name_filter and status_filter:
             return [qlang.OP_AND, name_filter, status_filter]
           elif name_filter:
             return name_filter
           else:
             return status_filter
         def CheckArguments(self):
           self.oq = _OsQuery(self._BuildFilter(self.op.output_fields, self.op.names),
                              self.op.output_fields, False)
         def ExpandNames(self):
           self.oq.ExpandNames(self)
         def Exec(self, feedback_fn):
           return self.oq.OldStyleQuery(self)
       class _ExtStorageQuery(_QueryBase):
         FIELDS = query.EXTSTORAGE_FIELDS
         def ExpandNames(self, lu):
           # Lock all nodes in shared mode
           # Temporary removal of locks, should be reverted later
           # TODO: reintroduce locks when they are lighter-weight
           lu.needed_locks = {}
           #self.share_locks[locking.LEVEL_NODE] = 1
           #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
           # The following variables interact with _QueryBase._GetNames
           if self.names:
             self.wanted = self.names
           else:
             self.wanted = locking.ALL_SET
           self.do_locking = self.use_locking
         def DeclareLocks(self, lu, level):
           pass
         @staticmethod
         def _DiagnoseByProvider(rlist):
           """Remaps a per-node return list into an a per-provider per-node dictionary
           @param rlist: a map with node names as keys and ExtStorage objects as values
           @rtype: dict
           @return: a dictionary with extstorage providers as keys and as
               value another map, with nodes as keys and tuples of
               (path, status, diagnose, parameters) as values, eg::
                 {"provider1": {"node1": [(/usr/lib/..., True, "", [])]
                                "node2": [(/srv/..., False, "missing file")]
                                "node3": [(/srv/..., True, "", [])]
+                }
           """
           all_es = {}
           # we build here the list of nodes that didn't fail the RPC (at RPC
           # level), so that nodes with a non-responding node daemon don't
           # make all OSes invalid
           good_nodes = [node_name for node_name in rlist
                         if not rlist[node_name].fail_msg]
           for node_name, nr in rlist.items():
             if nr.fail_msg or not nr.payload:
               continue
             for (name, path, status, diagnose, params) in nr.payload:
               if name not in all_es:
                 # build a list of nodes for this os containing empty lists
                 # for each node in node_list
                 all_es[name] = {}
                 for nname in good_nodes:
                   all_es[name][nname] = []
               # convert params from [name, help] to (name, help)
               params = [tuple(v) for v in params]
               all_es[name][node_name].append((path, status, diagnose, params))
           return all_es
         def _GetQueryData(self, lu):
           """Computes the list of nodes and their attributes.
           """
           # Locking is not used
           assert not (compat.any(lu.glm.is_owned(level)
                                  for level in locking.LEVELS
                                  if level != locking.LEVEL_CLUSTER) or
                       self.do_locking or self.use_locking)
           valid_nodes = [node.name
                          for node in lu.cfg.GetAllNodesInfo().values()
                          if not node.offline and node.vm_capable]
           pol = self._DiagnoseByProvider(lu.rpc.call_extstorage_diagnose(valid_nodes))
           data = {}
           nodegroup_list = lu.cfg.GetNodeGroupList()
           for (es_name, es_data) in pol.items():
             # For every provider compute the nodegroup validity.
             # To do this we need to check the validity of each node in es_data
             # and then construct the corresponding nodegroup dict:
             #      { nodegroup1: status
             #        nodegroup2: status
             #      }
             ndgrp_data = {}
             for nodegroup in nodegroup_list:
               ndgrp = lu.cfg.GetNodeGroup(nodegroup)
               nodegroup_nodes = ndgrp.members
               nodegroup_name = ndgrp.name
               node_statuses = []
               for node in nodegroup_nodes:
                 if node in valid_nodes:
                   if es_data[node] != []:
                     node_status = es_data[node][0][1]
                     node_statuses.append(node_status)
                   else:
                     node_statuses.append(False)
               if False in node_statuses:
                 ndgrp_data[nodegroup_name] = False
               else:
                 ndgrp_data[nodegroup_name] = True
             # Compute the provider's parameters
             parameters = set()
             for idx, esl in enumerate(es_data.values()):
               valid = bool(esl and esl[0][1])
               if not valid:
                 break
               node_params = esl[0][3]
               if idx == 0:
                 # First entry
                 parameters.update(node_params)
               else:
                 # Filter out inconsistent values
                 parameters.intersection_update(node_params)
             params = list(parameters)
             # Now fill all the info for this provider
             info = query.ExtStorageInfo(name=es_name, node_status=es_data,
                                         nodegroup_status=ndgrp_data,
                                         parameters=params)
             data[es_name] = info
           # Prepare data in requested order
           return [data[name] for name in self._GetNames(lu, pol.keys(), None)
                   if name in data]
       class LUExtStorageDiagnose(NoHooksLU):
         """Logical unit for ExtStorage diagnose/query.
         """
         REQ_BGL = False
         def CheckArguments(self):
           self.eq = _ExtStorageQuery(qlang.MakeSimpleFilter("name", self.op.names),
                                      self.op.output_fields, False)
         def ExpandNames(self):
           self.eq.ExpandNames(self)
         def Exec(self, feedback_fn):
           return self.eq.OldStyleQuery(self)
       class LUNodeRemove(LogicalUnit):
         """Logical unit for removing a node.
         """
         HPATH = "node-remove"
         HTYPE = constants.HTYPE_NODE
         def BuildHooksEnv(self):
           """Build hooks env.
           """
           return {
             "OP_TARGET": self.op.node_name,
             "NODE_NAME": self.op.node_name,
+            }
         def BuildHooksNodes(self):
           """Build hooks nodes.
           This doesn't run on the target node in the pre phase as a failed
           node would then be impossible to remove.
           """
           all_nodes = self.cfg.GetNodeList()
           try:
             all_nodes.remove(self.op.node_name)
           except ValueError:
             pass
           return (all_nodes, all_nodes)
         def CheckPrereq(self):
           """Check prerequisites.
           This checks:
            - the node exists in the configuration
            - it does not have primary or secondary instances
            - it's not the master
           Any errors are signaled by raising errors.OpPrereqError.
           """
           self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
           node = self.cfg.GetNodeInfo(self.op.node_name)
           assert node is not None
           masternode = self.cfg.GetMasterNode()
           if node.name == masternode:
             raise errors.OpPrereqError("Node is the master node, failover to another"
                                        " node is required", errors.ECODE_INVAL)
           for instance_name, instance in self.cfg.GetAllInstancesInfo().items():
             if node.name in instance.all_nodes:
               raise errors.OpPrereqError("Instance %s is still running on the node,"
                                          " please remove first" % instance_name,
                                          errors.ECODE_INVAL)
           self.op.node_name = node.name
           self.node = node
         def Exec(self, feedback_fn):
           """Removes the node from the cluster.
           """
           node = self.node
           logging.info("Stopping the node daemon and removing configs from node %s",
                        node.name)
           modify_ssh_setup = self.cfg.GetClusterInfo().modify_ssh_setup
           assert locking.BGL in self.owned_locks(locking.LEVEL_CLUSTER), \
             "Not owning BGL"
           # Promote nodes to master candidate as needed
           _AdjustCandidatePool(self, exceptions=[node.name])
           self.context.RemoveNode(node.name)
           # Run post hooks on the node before it's removed
           _RunPostHook(self, node.name)
           result = self.rpc.call_node_leave_cluster(node.name, modify_ssh_setup)
           msg = result.fail_msg
           if msg:
             self.LogWarning("Errors encountered on the remote node while leaving"
                             " the cluster: %s", msg)
           # Remove node from our /etc/hosts
           if self.cfg.GetClusterInfo().modify_etc_hosts:
             master_node = self.cfg.GetMasterNode()
             result = self.rpc.call_etc_hosts_modify(master_node,
                                                     constants.ETC_HOSTS_REMOVE,
                                                     node.name, None)
             result.Raise("Can't update hosts file with new host data")
             _RedistributeAncillaryFiles(self)
       class _NodeQuery(_QueryBase):
         FIELDS = query.NODE_FIELDS
         def ExpandNames(self, lu):
           lu.needed_locks = {}
           lu.share_locks = _ShareAll()
           if self.names:
             self.wanted = _GetWantedNodes(lu, self.names)
           else:
             self.wanted = locking.ALL_SET
           self.do_locking = (self.use_locking and
                              query.NQ_LIVE in self.requested_data)
           if self.do_locking:
             # If any non-static field is requested we need to lock the nodes
             lu.needed_locks[locking.LEVEL_NODE] = self.wanted
             lu.needed_locks[locking.LEVEL_NODE_ALLOC] = locking.ALL_SET
         def DeclareLocks(self, lu, level):
           pass
         def _GetQueryData(self, lu):
           """Computes the list of nodes and their attributes.
           """
           all_info = lu.cfg.GetAllNodesInfo()
           nodenames = self._GetNames(lu, all_info.keys(), locking.LEVEL_NODE)
           # Gather data as requested
           if query.NQ_LIVE in self.requested_data:
             # filter out non-vm_capable nodes
             toquery_nodes = [name for name in nodenames if all_info[name].vm_capable]
             es_flags = rpc.GetExclusiveStorageForNodeNames(lu.cfg, toquery_nodes)
             node_data = lu.rpc.call_node_info(toquery_nodes, [lu.cfg.GetVGName()],
                                               [lu.cfg.GetHypervisorType()], es_flags)
             live_data = dict((name, rpc.MakeLegacyNodeInfo(nresult.payload))
                              for (name, nresult) in node_data.items()
                              if not nresult.fail_msg and nresult.payload)
           else:
             live_data = None
           if query.NQ_INST in self.requested_data:
             node_to_primary = dict([(name, set()) for name in nodenames])
             node_to_secondary = dict([(name, set()) for name in nodenames])
             inst_data = lu.cfg.GetAllInstancesInfo()
             for inst in inst_data.values():
               if inst.primary_node in node_to_primary:
                 node_to_primary[inst.primary_node].add(inst.name)
               for secnode in inst.secondary_nodes:
                 if secnode in node_to_secondary:
                   node_to_secondary[secnode].add(inst.name)
           else:
             node_to_primary = None
             node_to_secondary = None
           if query.NQ_OOB in self.requested_data:
             oob_support = dict((name, bool(_SupportsOob(lu.cfg, node)))
                                for name, node in all_info.iteritems())
           else:
             oob_support = None
           if query.NQ_GROUP in self.requested_data:
             groups = lu.cfg.GetAllNodeGroupsInfo()
           else:
             groups = {}
           return query.NodeQueryData([all_info[name] for name in nodenames],
                                      live_data, lu.cfg.GetMasterNode(),
                                      node_to_primary, node_to_secondary, groups,
                                      oob_support, lu.cfg.GetClusterInfo())
       class LUNodeQuery(NoHooksLU):
         """Logical unit for querying nodes.
         """
         # pylint: disable=W0142
         REQ_BGL = False
         def CheckArguments(self):
           self.nq = _NodeQuery(qlang.MakeSimpleFilter("name", self.op.names),
                                self.op.output_fields, self.op.use_locking)
         def ExpandNames(self):
           self.nq.ExpandNames(self)
         def DeclareLocks(self, level):
           self.nq.DeclareLocks(self, level)
         def Exec(self, feedback_fn):
           return self.nq.OldStyleQuery(self)
       class LUNodeQueryvols(NoHooksLU):
         """Logical unit for getting volumes on node(s).
         """
         REQ_BGL = False
         _FIELDS_DYNAMIC = utils.FieldSet("phys", "vg", "name", "size", "instance")
         _FIELDS_STATIC = utils.FieldSet("node")
         def CheckArguments(self):
           _CheckOutputFields(static=self._FIELDS_STATIC,
                              dynamic=self._FIELDS_DYNAMIC,
                              selected=self.op.output_fields)
         def ExpandNames(self):
           self.share_locks = _ShareAll()
           if self.op.nodes:
             self.needed_locks = {
               locking.LEVEL_NODE: _GetWantedNodes(self, self.op.nodes),
+              }
           else:
             self.needed_locks = {
               locking.LEVEL_NODE: locking.ALL_SET,
               locking.LEVEL_NODE_ALLOC: locking.ALL_SET,
+              }
         def Exec(self, feedback_fn):
           """Computes the list of nodes and their attributes.
           """
           nodenames = self.owned_locks(locking.LEVEL_NODE)
           volumes = self.rpc.call_node_volumes(nodenames)
           ilist = self.cfg.GetAllInstancesInfo()
           vol2inst = _MapInstanceDisksToNodes(ilist.values())
           output = []
           for node in nodenames:
             nresult = volumes[node]
             if nresult.offline:
               continue
             msg = nresult.fail_msg
             if msg:
               self.LogWarning("Can't compute volume data on node %s: %s", node, msg)
               continue
             node_vols = sorted(nresult.payload,
                                key=operator.itemgetter("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":
                   val = vol2inst.get((node, vol["vg"] + "/" + vol["name"]), "-")
                 else:
                   raise errors.ParameterError(field)
                 node_output.append(str(val))
               output.append(node_output)
           return output
       class LUNodeQueryStorage(NoHooksLU):
         """Logical unit for getting information on storage units on node(s).
         """
         _FIELDS_STATIC = utils.FieldSet(constants.SF_NODE)
         REQ_BGL = False
         def CheckArguments(self):
           _CheckOutputFields(static=self._FIELDS_STATIC,
                              dynamic=utils.FieldSet(*constants.VALID_STORAGE_FIELDS),
                              selected=self.op.output_fields)
         def ExpandNames(self):
           self.share_locks = _ShareAll()
           if self.op.nodes:
             self.needed_locks = {
               locking.LEVEL_NODE: _GetWantedNodes(self, self.op.nodes),
+              }
           else:
             self.needed_locks = {
               locking.LEVEL_NODE: locking.ALL_SET,
               locking.LEVEL_NODE_ALLOC: locking.ALL_SET,
+              }
         def Exec(self, feedback_fn):
           """Computes the list of nodes and their attributes.
           """
           self.nodes = self.owned_locks(locking.LEVEL_NODE)
           # Always get name to sort by
           if constants.SF_NAME in self.op.output_fields:
             fields = self.op.output_fields[:]
           else:
             fields = [constants.SF_NAME] + self.op.output_fields
           # Never ask for node or type as it's only known to the LU
           for extra in [constants.SF_NODE, constants.SF_TYPE]:
             while extra in fields:
               fields.remove(extra)
           field_idx = dict([(name, idx) for (idx, name) in enumerate(fields)])
           name_idx = field_idx[constants.SF_NAME]
           st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
           data = self.rpc.call_storage_list(self.nodes,
                                             self.op.storage_type, st_args,
                                             self.op.name, fields)
           result = []
           for node in utils.NiceSort(self.nodes):
             nresult = data[node]
             if nresult.offline:
               continue
             msg = nresult.fail_msg
             if msg:
               self.LogWarning("Can't get storage data from node %s: %s", node, msg)
               continue
             rows = dict([(row[name_idx], row) for row in nresult.payload])
             for name in utils.NiceSort(rows.keys()):
               row = rows[name]
               out = []
               for field in self.op.output_fields:
                 if field == constants.SF_NODE:
                   val = node
                 elif field == constants.SF_TYPE:
                   val = self.op.storage_type
                 elif field in field_idx:
                   val = row[field_idx[field]]
                 else:
                   raise errors.ParameterError(field)
                 out.append(val)
               result.append(out)
           return result
       class _InstanceQuery(_QueryBase):
         FIELDS = query.INSTANCE_FIELDS
         def ExpandNames(self, lu):
           lu.needed_locks = {}
           lu.share_locks = _ShareAll()
           if self.names:
             self.wanted = _GetWantedInstances(lu, self.names)
           else:
             self.wanted = locking.ALL_SET
           self.do_locking = (self.use_locking and
                              query.IQ_LIVE in self.requested_data)
           if self.do_locking:
             lu.needed_locks[locking.LEVEL_INSTANCE] = self.wanted
             lu.needed_locks[locking.LEVEL_NODEGROUP] = []
             lu.needed_locks[locking.LEVEL_NODE] = []
             lu.needed_locks[locking.LEVEL_NETWORK] = []
             lu.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
           self.do_grouplocks = (self.do_locking and
                                 query.IQ_NODES in self.requested_data)
         def DeclareLocks(self, lu, level):
           if self.do_locking:
             if level == locking.LEVEL_NODEGROUP and self.do_grouplocks:
               assert not lu.needed_locks[locking.LEVEL_NODEGROUP]
               # Lock all groups used by instances optimistically; this requires going
               # via the node before it's locked, requiring verification later on
               lu.needed_locks[locking.LEVEL_NODEGROUP] = \
                 set(group_uuid
                     for instance_name in lu.owned_locks(locking.LEVEL_INSTANCE)
                     for group_uuid in lu.cfg.GetInstanceNodeGroups(instance_name))
             elif level == locking.LEVEL_NODE:
               lu._LockInstancesNodes() # pylint: disable=W0212
             elif level == locking.LEVEL_NETWORK:
               lu.needed_locks[locking.LEVEL_NETWORK] = \
                 frozenset(net_uuid
                           for instance_name in lu.owned_locks(locking.LEVEL_INSTANCE)
                           for net_uuid in lu.cfg.GetInstanceNetworks(instance_name))
         @staticmethod
         def _CheckGroupLocks(lu):
           owned_instances = frozenset(lu.owned_locks(locking.LEVEL_INSTANCE))
           owned_groups = frozenset(lu.owned_locks(locking.LEVEL_NODEGROUP))
           # Check if node groups for locked instances are still correct
           for instance_name in owned_instances:
             _CheckInstanceNodeGroups(lu.cfg, instance_name, owned_groups)
         def _GetQueryData(self, lu):
           """Computes the list of instances and their attributes.
           """
           if self.do_grouplocks:
             self._CheckGroupLocks(lu)
           cluster = lu.cfg.GetClusterInfo()
           all_info = lu.cfg.GetAllInstancesInfo()
           instance_names = self._GetNames(lu, all_info.keys(), locking.LEVEL_INSTANCE)
           instance_list = [all_info[name] for name in instance_names]
           nodes = frozenset(itertools.chain(*(inst.all_nodes
                                               for inst in instance_list)))
           hv_list = list(set([inst.hypervisor for inst in instance_list]))
           bad_nodes = []
           offline_nodes = []
           wrongnode_inst = set()
           # Gather data as requested
           if self.requested_data & set([query.IQ_LIVE, query.IQ_CONSOLE]):
             live_data = {}
             node_data = lu.rpc.call_all_instances_info(nodes, hv_list)
             for name in nodes:
               result = node_data[name]
               if result.offline:
                 # offline nodes will be in both lists
                 assert result.fail_msg
                 offline_nodes.append(name)
               if result.fail_msg:
                 bad_nodes.append(name)
               elif result.payload:
                 for inst in result.payload:
                   if inst in all_info:
                     if all_info[inst].primary_node == name:
                       live_data.update(result.payload)
                     else:
                       wrongnode_inst.add(inst)
                   else:
                     # orphan instance; we don't list it here as we don't
                     # handle this case yet in the output of instance listing
                     logging.warning("Orphan instance '%s' found on node %s",
                                     inst, name)
               # else no instance is alive
           else:
             live_data = {}
           if query.IQ_DISKUSAGE in self.requested_data:
             gmi = ganeti.masterd.instance
             disk_usage = dict((inst.name,
                                gmi.ComputeDiskSize(inst.disk_template,
                                                    [{constants.IDISK_SIZE: disk.size}
                                                     for disk in inst.disks]))
                               for inst in instance_list)
           else:
             disk_usage = None
           if query.IQ_CONSOLE in self.requested_data:
             consinfo = {}
             for inst in instance_list:
               if inst.name in live_data:
                 # Instance is running
                 consinfo[inst.name] = _GetInstanceConsole(cluster, inst)
               else:
                 consinfo[inst.name] = None
             assert set(consinfo.keys()) == set(instance_names)
           else:
             consinfo = None
           if query.IQ_NODES in self.requested_data:
             node_names = set(itertools.chain(*map(operator.attrgetter("all_nodes"),
                                                   instance_list)))
             nodes = dict(lu.cfg.GetMultiNodeInfo(node_names))
             groups = dict((uuid, lu.cfg.GetNodeGroup(uuid))
                           for uuid in set(map(operator.attrgetter("group"),
                                               nodes.values())))
           else:
             nodes = None
             groups = None
           if query.IQ_NETWORKS in self.requested_data:
             net_uuids = itertools.chain(*(lu.cfg.GetInstanceNetworks(i.name)
                                           for i in instance_list))
             networks = dict((uuid, lu.cfg.GetNetwork(uuid)) for uuid in net_uuids)
           else:
             networks = None
           return query.InstanceQueryData(instance_list, lu.cfg.GetClusterInfo(),
                                          disk_usage, offline_nodes, bad_nodes,
                                          live_data, wrongnode_inst, consinfo,
                                          nodes, groups, networks)
       class LUQuery(NoHooksLU):
         """Query for resources/items of a certain kind.
         """
         # pylint: disable=W0142
         REQ_BGL = False
         def CheckArguments(self):
           qcls = _GetQueryImplementation(self.op.what)
           self.impl = qcls(self.op.qfilter, self.op.fields, self.op.use_locking)
         def ExpandNames(self):
           self.impl.ExpandNames(self)
         def DeclareLocks(self, level):
           self.impl.DeclareLocks(self, level)
         def Exec(self, feedback_fn):
           return self.impl.NewStyleQuery(self)
       class LUQueryFields(NoHooksLU):
         """Query for resources/items of a certain kind.
         """
         # pylint: disable=W0142
         REQ_BGL = False
         def CheckArguments(self):
           self.qcls = _GetQueryImplementation(self.op.what)
         def ExpandNames(self):
           self.needed_locks = {}
         def Exec(self, feedback_fn):
           return query.QueryFields(self.qcls.FIELDS, self.op.fields)
       class LUNodeModifyStorage(NoHooksLU):
         """Logical unit for modifying a storage volume on a node.
         """
         REQ_BGL = False
         def CheckArguments(self):
           self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
           storage_type = self.op.storage_type
           try:
             modifiable = constants.MODIFIABLE_STORAGE_FIELDS[storage_type]
           except KeyError:
             raise errors.OpPrereqError("Storage units of type '%s' can not be"
                                        " modified" % storage_type,
                                        errors.ECODE_INVAL)
           diff = set(self.op.changes.keys()) - modifiable
           if diff:
             raise errors.OpPrereqError("The following fields can not be modified for"
                                        " storage units of type '%s': %r" %
                                        (storage_type, list(diff)),
                                        errors.ECODE_INVAL)
         def ExpandNames(self):
           self.needed_locks = {
             locking.LEVEL_NODE: self.op.node_name,
+            }
         def Exec(self, feedback_fn):
           """Computes the list of nodes and their attributes.
           """
           st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)
           result = self.rpc.call_storage_modify(self.op.node_name,
                                                 self.op.storage_type, st_args,
                                                 self.op.name, self.op.changes)
           result.Raise("Failed to modify storage unit '%s' on %s" %
                        (self.op.name, self.op.node_name))
       class LUNodeAdd(LogicalUnit):
         """Logical unit for adding node to the cluster.
         """
         HPATH = "node-add"
         HTYPE = constants.HTYPE_NODE
         _NFLAGS = ["master_capable", "vm_capable"]
         def CheckArguments(self):
           self.primary_ip_family = self.cfg.GetPrimaryIPFamily()
           # validate/normalize the node name
           self.hostname = netutils.GetHostname(name=self.op.node_name,
                                                family=self.primary_ip_family)
           self.op.node_name = self.hostname.name
           if self.op.readd and self.op.node_name == self.cfg.GetMasterNode():
             raise errors.OpPrereqError("Cannot readd the master node",
                                        errors.ECODE_STATE)
           if self.op.readd and self.op.group:
             raise errors.OpPrereqError("Cannot pass a node group when a node is"
                                        " being readded", errors.ECODE_INVAL)
         def BuildHooksEnv(self):
           """Build hooks env.
           This will run on all nodes before, and on all nodes + the new node after.
           """
           return {
             "OP_TARGET": self.op.node_name,
             "NODE_NAME": self.op.node_name,
             "NODE_PIP": self.op.primary_ip,
             "NODE_SIP": self.op.secondary_ip,
             "MASTER_CAPABLE": str(self.op.master_capable),
             "VM_CAPABLE": str(self.op.vm_capable),
+            }
         def BuildHooksNodes(self):
           """Build hooks nodes.
           """
           # Exclude added node
           pre_nodes = list(set(self.cfg.GetNodeList()) - set([self.op.node_name]))
           post_nodes = pre_nodes + [self.op.node_name, ]
           return (pre_nodes, post_nodes)
         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 signaled by raising errors.OpPrereqError.
           """
           cfg = self.cfg
           hostname = self.hostname
           node = hostname.name
           primary_ip = self.op.primary_ip = hostname.ip
           if self.op.secondary_ip is None:
             if self.primary_ip_family == netutils.IP6Address.family:
               raise errors.OpPrereqError("When using a IPv6 primary address, a valid"
                                          " IPv4 address must be given as secondary",
                                          errors.ECODE_INVAL)
             self.op.secondary_ip = primary_ip
           secondary_ip = self.op.secondary_ip
           if not netutils.IP4Address.IsValid(secondary_ip):
             raise errors.OpPrereqError("Secondary IP (%s) needs to be a valid IPv4"
                                        " address" % secondary_ip, errors.ECODE_INVAL)
           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, errors.ECODE_EXISTS)
           elif self.op.readd and node not in node_list:
             raise errors.OpPrereqError("Node %s is not in the configuration" % node,
                                        errors.ECODE_NOENT)
           self.changed_primary_ip = False
           for existing_node_name, existing_node in cfg.GetMultiNodeInfo(node_list):
             if self.op.readd and node == existing_node_name:
               if existing_node.secondary_ip != secondary_ip:
                 raise errors.OpPrereqError("Readded node doesn't have the same IP"
                                            " address configuration as before",
                                            errors.ECODE_INVAL)
               if existing_node.primary_ip != primary_ip:
                 self.changed_primary_ip = True
               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,
                                          errors.ECODE_NOTUNIQUE)
           # After this 'if' block, None is no longer a valid value for the
           # _capable op attributes
           if self.op.readd:
             old_node = self.cfg.GetNodeInfo(node)
             assert old_node is not None, "Can't retrieve locked node %s" % node
             for attr in self._NFLAGS:
               if getattr(self.op, attr) is None:
                 setattr(self.op, attr, getattr(old_node, attr))
           else:
             for attr in self._NFLAGS:
               if getattr(self.op, attr) is None:
                 setattr(self.op, attr, True)
           if self.op.readd and not self.op.vm_capable:
             pri, sec = cfg.GetNodeInstances(node)
             if pri or sec:
               raise errors.OpPrereqError("Node %s being re-added with vm_capable"
                                          " flag set to false, but it already holds"
                                          " instances" % node,
                                          errors.ECODE_STATE)
           # 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 secondary ip but the"
                                          " new node has one",
                                          errors.ECODE_INVAL)
             else:
               raise errors.OpPrereqError("The master has a secondary ip but the"
                                          " new node doesn't have one",
                                          errors.ECODE_INVAL)
           # checks reachability
           if not netutils.TcpPing(primary_ip, constants.DEFAULT_NODED_PORT):
             raise errors.OpPrereqError("Node not reachable by ping",
                                        errors.ECODE_ENVIRON)
           if not newbie_singlehomed:
             # check reachability from my secondary ip to newbie's secondary ip
             if not netutils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,
                                     source=myself.secondary_ip):
               raise errors.OpPrereqError("Node secondary ip not reachable by TCP"
                                          " based ping to node daemon port",
                                          errors.ECODE_ENVIRON)
           if self.op.readd:
             exceptions = [node]
           else:
             exceptions = []
           if self.op.master_capable:
             self.master_candidate = _DecideSelfPromotion(self, exceptions=exceptions)
           else:
             self.master_candidate = False
           if self.op.readd:
             self.new_node = old_node
           else:
             node_group = cfg.LookupNodeGroup(self.op.group)
             self.new_node = objects.Node(name=node,
                                          primary_ip=primary_ip,
                                          secondary_ip=secondary_ip,
                                          master_candidate=self.master_candidate,
                                          offline=False, drained=False,
                                          group=node_group, ndparams={})
           if self.op.ndparams:
             utils.ForceDictType(self.op.ndparams, constants.NDS_PARAMETER_TYPES)
             _CheckParamsNotGlobal(self.op.ndparams, constants.NDC_GLOBALS, "node",
                                   "node", "cluster or group")
           if self.op.hv_state:
             self.new_hv_state = _MergeAndVerifyHvState(self.op.hv_state, None)
           if self.op.disk_state:
             self.new_disk_state = _MergeAndVerifyDiskState(self.op.disk_state, None)
           # TODO: If we need to have multiple DnsOnlyRunner we probably should make
           #       it a property on the base class.
           rpcrunner = rpc.DnsOnlyRunner()
           result = rpcrunner.call_version([node])[node]
           result.Raise("Can't get version information from node %s" % node)
           if constants.PROTOCOL_VERSION == result.payload:
             logging.info("Communication to node %s fine, sw version %s match",
                          node, result.payload)
           else:
             raise errors.OpPrereqError("Version mismatch master version %s,"
                                        " node version %s" %
                                        (constants.PROTOCOL_VERSION, result.payload),
                                        errors.ECODE_ENVIRON)
           vg_name = cfg.GetVGName()
           if vg_name is not None:
             vparams = {constants.NV_PVLIST: [vg_name]}
             excl_stor = _IsExclusiveStorageEnabledNode(cfg, self.new_node)
             cname = self.cfg.GetClusterName()
             result = rpcrunner.call_node_verify_light([node], vparams, cname)[node]
             (errmsgs, _) = _CheckNodePVs(result.payload, excl_stor)
             if errmsgs:
               raise errors.OpPrereqError("Checks on node PVs failed: %s" %
                                          "; ".join(errmsgs), errors.ECODE_ENVIRON)
         def Exec(self, feedback_fn):
           """Adds the new node to the cluster.
           """
           new_node = self.new_node
           node = new_node.name
           assert locking.BGL in self.owned_locks(locking.LEVEL_CLUSTER), \
             "Not owning BGL"
           # We adding a new node so we assume it's powered
           new_node.powered = True
           # for re-adds, reset the offline/drained/master-candidate flags;
           # we need to reset here, otherwise offline would prevent RPC calls
           # later in the procedure; this also means that if the re-add
           # fails, we are left with a non-offlined, broken node
           if self.op.readd:
             new_node.drained = new_node.offline = False # pylint: disable=W0201
             self.LogInfo("Readding a node, the offline/drained flags were reset")
             # if we demote the node, we do cleanup later in the procedure
             new_node.master_candidate = self.master_candidate
             if self.changed_primary_ip:
               new_node.primary_ip = self.op.primary_ip
           # copy the master/vm_capable flags
           for attr in self._NFLAGS:
             setattr(new_node, attr, getattr(self.op, attr))
           # notify the user about any possible mc promotion
           if new_node.master_candidate:
             self.LogInfo("Node will be a master candidate")
           if self.op.ndparams:
             new_node.ndparams = self.op.ndparams
           else:
             new_node.ndparams = {}
           if self.op.hv_state:
             new_node.hv_state_static = self.new_hv_state
           if self.op.disk_state:
             new_node.disk_state_static = self.new_disk_state
           # Add node to our /etc/hosts, and add key to known_hosts
           if self.cfg.GetClusterInfo().modify_etc_hosts:
             master_node = self.cfg.GetMasterNode()
             result = self.rpc.call_etc_hosts_modify(master_node,
                                                     constants.ETC_HOSTS_ADD,
                                                     self.hostname.name,
                                                     self.hostname.ip)
             result.Raise("Can't update hosts file with new host data")
           if new_node.secondary_ip != new_node.primary_ip:
             _CheckNodeHasSecondaryIP(self, new_node.name, new_node.secondary_ip,
                                      False)
           node_verify_list = [self.cfg.GetMasterNode()]
           node_verify_param = {
             constants.NV_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:
             result[verifier].Raise("Cannot communicate with node %s" % verifier)
             nl_payload = result[verifier].payload[constants.NV_NODELIST]
             if nl_payload:
               for failed in nl_payload:
                 feedback_fn("ssh/hostname verification failed"
                             " (checking from %s): %s" %
                             (verifier, nl_payload[failed]))
               raise errors.OpExecError("ssh/hostname verification failed")
           if self.op.readd:
             _RedistributeAncillaryFiles(self)
             self.context.ReaddNode(new_node)
             # make sure we redistribute the config
             self.cfg.Update(new_node, feedback_fn)
             # and make sure the new node will not have old files around
             if not new_node.master_candidate:
               result = self.rpc.call_node_demote_from_mc(new_node.name)
               msg = result.fail_msg
               if msg:
                 self.LogWarning("Node failed to demote itself from master"
                                 " candidate status: %s" % msg)
           else:
             _RedistributeAncillaryFiles(self, additional_nodes=[node],
                                         additional_vm=self.op.vm_capable)
             self.context.AddNode(new_node, self.proc.GetECId())
       class LUNodeSetParams(LogicalUnit):
         """Modifies the parameters of a node.
         @cvar _F2R: a dictionary from tuples of flags (mc, drained, offline)
             to the node role (as _ROLE_*)
         @cvar _R2F: a dictionary from node role to tuples of flags
         @cvar _FLAGS: a list of attribute names corresponding to the flags
         """
         HPATH = "node-modify"
         HTYPE = constants.HTYPE_NODE
         REQ_BGL = False
         (_ROLE_CANDIDATE, _ROLE_DRAINED, _ROLE_OFFLINE, _ROLE_REGULAR) = range(4)
         _F2R = {
           (True, False, False): _ROLE_CANDIDATE,
           (False, True, False): _ROLE_DRAINED,
           (False, False, True): _ROLE_OFFLINE,
           (False, False, False): _ROLE_REGULAR,
+          }
         _R2F = dict((v, k) for k, v in _F2R.items())
         _FLAGS = ["master_candidate", "drained", "offline"]
         def CheckArguments(self):
           self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
           all_mods = [self.op.offline, self.op.master_candidate, self.op.drained,
                       self.op.master_capable, self.op.vm_capable,
                       self.op.secondary_ip, self.op.ndparams, self.op.hv_state,
                       self.op.disk_state]
           if all_mods.count(None) == len(all_mods):
             raise errors.OpPrereqError("Please pass at least one modification",
                                        errors.ECODE_INVAL)
           if all_mods.count(True) > 1:
             raise errors.OpPrereqError("Can't set the node into more than one"
                                        " state at the same time",
                                        errors.ECODE_INVAL)
           # Boolean value that tells us whether we might be demoting from MC
           self.might_demote = (self.op.master_candidate is False or
                                self.op.offline is True or
                                self.op.drained is True or
                                self.op.master_capable is False)
           if self.op.secondary_ip:
             if not netutils.IP4Address.IsValid(self.op.secondary_ip):
               raise errors.OpPrereqError("Secondary IP (%s) needs to be a valid IPv4"
                                          " address" % self.op.secondary_ip,
                                          errors.ECODE_INVAL)
           self.lock_all = self.op.auto_promote and self.might_demote
           self.lock_instances = self.op.secondary_ip is not None
         def _InstanceFilter(self, instance):
           """Filter for getting affected instances.
           """
           return (instance.disk_template in constants.DTS_INT_MIRROR and
                   self.op.node_name in instance.all_nodes)
         def ExpandNames(self):
           if self.lock_all:
             self.needed_locks = {
               locking.LEVEL_NODE: locking.ALL_SET,
               # Block allocations when all nodes are locked
               locking.LEVEL_NODE_ALLOC: locking.ALL_SET,
+              }
           else:
             self.needed_locks = {
               locking.LEVEL_NODE: self.op.node_name,
+              }
           # Since modifying a node can have severe effects on currently running
           # operations the resource lock is at least acquired in shared mode
           self.needed_locks[locking.LEVEL_NODE_RES] = \
             self.needed_locks[locking.LEVEL_NODE]
           # Get all locks except nodes in shared mode; they are not used for anything
           # but read-only access
           self.share_locks = _ShareAll()
           self.share_locks[locking.LEVEL_NODE] = 0
           self.share_locks[locking.LEVEL_NODE_RES] = 0
           self.share_locks[locking.LEVEL_NODE_ALLOC] = 0
           if self.lock_instances:
             self.needed_locks[locking.LEVEL_INSTANCE] = \
               frozenset(self.cfg.GetInstancesInfoByFilter(self._InstanceFilter))
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on the master node.
           """
           return {
             "OP_TARGET": self.op.node_name,
             "MASTER_CANDIDATE": str(self.op.master_candidate),
             "OFFLINE": str(self.op.offline),
             "DRAINED": str(self.op.drained),
             "MASTER_CAPABLE": str(self.op.master_capable),
             "VM_CAPABLE": str(self.op.vm_capable),
+            }
         def BuildHooksNodes(self):
           """Build hooks nodes.
           """
           nl = [self.cfg.GetMasterNode(), self.op.node_name]
           return (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.lock_instances:
             affected_instances = \
               self.cfg.GetInstancesInfoByFilter(self._InstanceFilter)
             # Verify instance locks
             owned_instances = self.owned_locks(locking.LEVEL_INSTANCE)
             wanted_instances = frozenset(affected_instances.keys())
             if wanted_instances - owned_instances:
               raise errors.OpPrereqError("Instances affected by changing node %s's"
                                          " secondary IP address have changed since"
                                          " locks were acquired, wanted '%s', have"
                                          " '%s'; retry the operation" %
                                          (self.op.node_name,
                                           utils.CommaJoin(wanted_instances),
                                           utils.CommaJoin(owned_instances)),
                                          errors.ECODE_STATE)
           else:
             affected_instances = None
           if (self.op.master_candidate is not None or
               self.op.drained is not None or
               self.op.offline is not None):
             # we can't change the master's node flags
             if self.op.node_name == self.cfg.GetMasterNode():
               raise errors.OpPrereqError("The master role can be changed"
                                          " only via master-failover",
                                          errors.ECODE_INVAL)
           if self.op.master_candidate and not node.master_capable:
             raise errors.OpPrereqError("Node %s is not master capable, cannot make"
                                        " it a master candidate" % node.name,
                                        errors.ECODE_STATE)
           if self.op.vm_capable is False:
             (ipri, isec) = self.cfg.GetNodeInstances(self.op.node_name)
             if ipri or isec:
               raise errors.OpPrereqError("Node %s hosts instances, cannot unset"
                                          " the vm_capable flag" % node.name,
                                          errors.ECODE_STATE)
           if node.master_candidate and self.might_demote and not self.lock_all:
             assert not self.op.auto_promote, "auto_promote set but lock_all not"
             # check if after removing the current node, we're missing master
             # candidates
             (mc_remaining, mc_should, _) = \
                 self.cfg.GetMasterCandidateStats(exceptions=[node.name])
             if mc_remaining < mc_should:
               raise errors.OpPrereqError("Not enough master candidates, please"
                                          " pass auto promote option to allow"
                                          " promotion (--auto-promote or RAPI"
                                          " auto_promote=True)", errors.ECODE_STATE)
           self.old_flags = old_flags = (node.master_candidate,
                                         node.drained, node.offline)
           assert old_flags in self._F2R, "Un-handled old flags %s" % str(old_flags)
           self.old_role = old_role = self._F2R[old_flags]
           # Check for ineffective changes
           for attr in self._FLAGS:
             if (getattr(self.op, attr) is False and getattr(node, attr) is False):
               self.LogInfo("Ignoring request to unset flag %s, already unset", attr)
               setattr(self.op, attr, None)
           # Past this point, any flag change to False means a transition
           # away from the respective state, as only real changes are kept
           # TODO: We might query the real power state if it supports OOB
           if _SupportsOob(self.cfg, node):
             if self.op.offline is False and not (node.powered or
                                                  self.op.powered is True):
               raise errors.OpPrereqError(("Node %s needs to be turned on before its"
                                           " offline status can be reset") %
                                          self.op.node_name, errors.ECODE_STATE)
           elif self.op.powered is not None:
             raise errors.OpPrereqError(("Unable to change powered state for node %s"
                                         " as it does not support out-of-band"
                                         " handling") % self.op.node_name,
                                        errors.ECODE_STATE)
           # If we're being deofflined/drained, we'll MC ourself if needed
           if (self.op.drained is False or self.op.offline is False or
               (self.op.master_capable and not node.master_capable)):
             if _DecideSelfPromotion(self):
               self.op.master_candidate = True
               self.LogInfo("Auto-promoting node to master candidate")
           # If we're no longer master capable, we'll demote ourselves from MC
           if self.op.master_capable is False and node.master_candidate:
             self.LogInfo("Demoting from master candidate")
             self.op.master_candidate = False
           # Compute new role
           assert [getattr(self.op, attr) for attr in self._FLAGS].count(True) <= 1
           if self.op.master_candidate:
             new_role = self._ROLE_CANDIDATE
           elif self.op.drained:
             new_role = self._ROLE_DRAINED
           elif self.op.offline:
             new_role = self._ROLE_OFFLINE
           elif False in [self.op.master_candidate, self.op.drained, self.op.offline]:
             # False is still in new flags, which means we're un-setting (the
             # only) True flag
             new_role = self._ROLE_REGULAR
           else: # no new flags, nothing, keep old role
             new_role = old_role
           self.new_role = new_role
           if old_role == self._ROLE_OFFLINE and new_role != old_role:
             # Trying to transition out of offline status
             result = self.rpc.call_version([node.name])[node.name]
             if result.fail_msg:
               raise errors.OpPrereqError("Node %s is being de-offlined but fails"
                                          " to report its version: %s" %
                                          (node.name, result.fail_msg),
                                          errors.ECODE_STATE)
             else:
               self.LogWarning("Transitioning node from offline to online state"
                               " without using re-add. Please make sure the node"
                               " is healthy!")
           # When changing the secondary ip, verify if this is a single-homed to
           # multi-homed transition or vice versa, and apply the relevant
           # restrictions.
           if self.op.secondary_ip:
             # Ok even without locking, because this can't be changed by any LU
             master = self.cfg.GetNodeInfo(self.cfg.GetMasterNode())
             master_singlehomed = master.secondary_ip == master.primary_ip
             if master_singlehomed and self.op.secondary_ip != node.primary_ip:
               if self.op.force and node.name == master.name:
                 self.LogWarning("Transitioning from single-homed to multi-homed"
                                 " cluster; all nodes will require a secondary IP"
                                 " address")
               else:
                 raise errors.OpPrereqError("Changing the secondary ip on a"
                                            " single-homed cluster requires the"
                                            " --force option to be passed, and the"
                                            " target node to be the master",
                                            errors.ECODE_INVAL)
             elif not master_singlehomed and self.op.secondary_ip == node.primary_ip:
               if self.op.force and node.name == master.name:
                 self.LogWarning("Transitioning from multi-homed to single-homed"
                                 " cluster; secondary IP addresses will have to be"
                                 " removed")
               else:
                 raise errors.OpPrereqError("Cannot set the secondary IP to be the"
                                            " same as the primary IP on a multi-homed"
                                            " cluster, unless the --force option is"
                                            " passed, and the target node is the"
                                            " master", errors.ECODE_INVAL)
             assert not (frozenset(affected_instances) -
                         self.owned_locks(locking.LEVEL_INSTANCE))
             if node.offline:
               if affected_instances:
                 msg = ("Cannot change secondary IP address: offline node has"
                        " instances (%s) configured to use it" %
                        utils.CommaJoin(affected_instances.keys()))
                 raise errors.OpPrereqError(msg, errors.ECODE_STATE)
             else:
               # On online nodes, check that no instances are running, and that
               # the node has the new ip and we can reach it.
               for instance in affected_instances.values():
                 _CheckInstanceState(self, instance, INSTANCE_DOWN,
                                     msg="cannot change secondary ip")
               _CheckNodeHasSecondaryIP(self, node.name, self.op.secondary_ip, True)
               if master.name != node.name:
                 # check reachability from master secondary ip to new secondary ip
                 if not netutils.TcpPing(self.op.secondary_ip,
                                         constants.DEFAULT_NODED_PORT,
                                         source=master.secondary_ip):
                   raise errors.OpPrereqError("Node secondary ip not reachable by TCP"
                                              " based ping to node daemon port",
                                              errors.ECODE_ENVIRON)
           if self.op.ndparams:
             new_ndparams = _GetUpdatedParams(self.node.ndparams, self.op.ndparams)
             utils.ForceDictType(new_ndparams, constants.NDS_PARAMETER_TYPES)
             _CheckParamsNotGlobal(self.op.ndparams, constants.NDC_GLOBALS, "node",
                                   "node", "cluster or group")
             self.new_ndparams = new_ndparams
           if self.op.hv_state:
             self.new_hv_state = _MergeAndVerifyHvState(self.op.hv_state,
                                                        self.node.hv_state_static)
           if self.op.disk_state:
             self.new_disk_state = \
               _MergeAndVerifyDiskState(self.op.disk_state,
                                        self.node.disk_state_static)
         def Exec(self, feedback_fn):
           """Modifies a node.
           """
           node = self.node
           old_role = self.old_role
           new_role = self.new_role
           result = []
           if self.op.ndparams:
             node.ndparams = self.new_ndparams
           if self.op.powered is not None:
             node.powered = self.op.powered
           if self.op.hv_state:
             node.hv_state_static = self.new_hv_state
           if self.op.disk_state:
             node.disk_state_static = self.new_disk_state
           for attr in ["master_capable", "vm_capable"]:
             val = getattr(self.op, attr)
             if val is not None:
               setattr(node, attr, val)
               result.append((attr, str(val)))
           if new_role != old_role:
             # Tell the node to demote itself, if no longer MC and not offline
             if old_role == self._ROLE_CANDIDATE and new_role != self._ROLE_OFFLINE:
               msg = self.rpc.call_node_demote_from_mc(node.name).fail_msg
               if msg:
                 self.LogWarning("Node failed to demote itself: %s", msg)
             new_flags = self._R2F[new_role]
             for of, nf, desc in zip(self.old_flags, new_flags, self._FLAGS):
               if of != nf:
                 result.append((desc, str(nf)))
             (node.master_candidate, node.drained, node.offline) = new_flags
             # we locked all nodes, we adjust the CP before updating this node
             if self.lock_all:
               _AdjustCandidatePool(self, [node.name])
           if self.op.secondary_ip:
             node.secondary_ip = self.op.secondary_ip
             result.append(("secondary_ip", self.op.secondary_ip))
           # this will trigger configuration file update, if needed
           self.cfg.Update(node, feedback_fn)
           # this will trigger job queue propagation or cleanup if the mc
           # flag changed
           if [old_role, new_role].count(self._ROLE_CANDIDATE) == 1:
             self.context.ReaddNode(node)
           return result
       class LUNodePowercycle(NoHooksLU):
         """Powercycles a node.
         """
         REQ_BGL = False
         def CheckArguments(self):
           self.op.node_name = _ExpandNodeName(self.cfg, self.op.node_name)
           if self.op.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",
                                        errors.ECODE_INVAL)
         def ExpandNames(self):
           """Locking for PowercycleNode.
           This is a last-resort option and shouldn't block on other
           jobs. Therefore, we grab no locks.
           """
           self.needed_locks = {}
         def Exec(self, feedback_fn):
           """Reboots a node.
           """
           result = self.rpc.call_node_powercycle(self.op.node_name,
                                                  self.cfg.GetHypervisorType())
           result.Raise("Failed to schedule the reboot")
           return result.payload
       class LUInstanceActivateDisks(NoHooksLU):
         """Bring up an instance's disks.
         """
         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,
                                            ignore_size=self.op.ignore_size)
           if not disks_ok:
             raise errors.OpExecError("Cannot activate block devices")
           if self.op.wait_for_sync:
             if not _WaitForSync(self, self.instance):
               raise errors.OpExecError("Some disks of the instance are degraded!")
           return disks_info
       def _AssembleInstanceDisks(lu, instance, disks=None, ignore_secondaries=False,
                                  ignore_size=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 disks: list of L{objects.Disk} or None
         @param disks: which disks to assemble (or all, if None)
         @type ignore_secondaries: boolean
         @param ignore_secondaries: if true, errors on secondary nodes
             won't result in an error return from the function
         @type ignore_size: boolean
         @param ignore_size: if true, the current known size of the disk
             will not be used during the disk activation, useful for cases
             when the size is wrong
         @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
         disks = _ExpandCheckDisks(instance, disks)
         # 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 idx, inst_disk in enumerate(disks):
           for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):
             if ignore_size:
               node_disk = node_disk.Copy()
               node_disk.UnsetSize()
             lu.cfg.SetDiskID(node_disk, node)
             result = lu.rpc.call_blockdev_assemble(node, (node_disk, instance), iname,
                                                    False, idx)
             msg = result.fail_msg
             if msg:
               is_offline_secondary = (node in instance.secondary_nodes and
                                       result.offline)
               lu.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 or is_offline_secondary):
                 disks_ok = False
         # FIXME: race condition on drbd migration to primary
         # 2nd pass, do only the primary node
         for idx, inst_disk in enumerate(disks):
           dev_path = None
           for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):
             if node != instance.primary_node:
               continue
             if ignore_size:
               node_disk = node_disk.Copy()
               node_disk.UnsetSize()
             lu.cfg.SetDiskID(node_disk, node)
             result = lu.rpc.call_blockdev_assemble(node, (node_disk, instance), iname,
                                                    True, idx)
             msg = result.fail_msg
             if msg:
               lu.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
             else:
               dev_path = result.payload
           device_info.append((instance.primary_node, inst_disk.iv_name, dev_path))
         # 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 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, _ = _AssembleInstanceDisks(lu, instance,
                                                  ignore_secondaries=force)
         if not disks_ok:
           _ShutdownInstanceDisks(lu, instance)
           if force is not None and not force:
             lu.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 LUInstanceDeactivateDisks(NoHooksLU):
         """Shutdown an instance's disks.
         """
         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
           if self.op.force:
             _ShutdownInstanceDisks(self, instance)
           else:
             _SafeShutdownInstanceDisks(self, instance)
       def _SafeShutdownInstanceDisks(lu, instance, disks=None):
         """Shutdown block devices of an instance.
         This function checks if an instance is running, before calling
         _ShutdownInstanceDisks.
         """
         _CheckInstanceState(lu, instance, INSTANCE_DOWN, msg="cannot shutdown disks")
         _ShutdownInstanceDisks(lu, instance, disks=disks)
       def _ExpandCheckDisks(instance, disks):
         """Return the instance disks selected by the disks list
         @type disks: list of L{objects.Disk} or None
         @param disks: selected disks
         @rtype: list of L{objects.Disk}
         @return: selected instance disks to act on
         """
         if disks is None:
           return instance.disks
         else:
           if not set(disks).issubset(instance.disks):
             raise errors.ProgrammerError("Can only act on disks belonging to the"
                                          " target instance")
           return disks
       def _ShutdownInstanceDisks(lu, instance, disks=None, 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
         disks = _ExpandCheckDisks(instance, disks)
         for disk in 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, instance))
             msg = result.fail_msg
             if msg:
               lu.LogWarning("Could not shutdown block device %s on node %s: %s",
                             disk.iv_name, node, msg)
               if ((node == instance.primary_node and not ignore_primary) or
                   (node != instance.primary_node and not result.offline)):
                 all_result = False
         return all_result
       def _CheckNodeFreeMemory(lu, node, reason, requested, hypervisor_name):
         """Checks if a node has enough free memory.
         This function checks 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 raises 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
         @rtype: integer
         @return: node current free memory
         @raise errors.OpPrereqError: if the node doesn't have enough memory, or
             we cannot check the node
         """
         nodeinfo = lu.rpc.call_node_info([node], None, [hypervisor_name], False)
         nodeinfo[node].Raise("Can't get data from node %s" % node,
                              prereq=True, ecode=errors.ECODE_ENVIRON)
         (_, _, (hv_info, )) = nodeinfo[node].payload
         free_mem = hv_info.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),
                                      errors.ECODE_ENVIRON)
         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),
                                      errors.ECODE_NORES)
         return free_mem
       def _CheckNodesFreeDiskPerVG(lu, nodenames, req_sizes):
         """Checks if nodes have enough free disk space in all the VGs.
         This function checks if all given nodes have the needed amount of
         free disk. In case any node has less disk or we cannot get the
         information from the node, this function raises an OpPrereqError
         exception.
         @type lu: C{LogicalUnit}
         @param lu: a logical unit from which we get configuration data
         @type nodenames: C{list}
         @param nodenames: the list of node names to check
         @type req_sizes: C{dict}
         @param req_sizes: the hash of vg and corresponding amount of disk in
             MiB to check for
         @raise errors.OpPrereqError: if the node doesn't have enough disk,
             or we cannot check the node
         """
         for vg, req_size in req_sizes.items():
           _CheckNodesFreeDiskOnVG(lu, nodenames, vg, req_size)
       def _CheckNodesFreeDiskOnVG(lu, nodenames, vg, requested):
         """Checks if nodes have enough free disk space in the specified VG.
         This function checks if all given nodes have the needed amount of
         free disk. In case any node has less disk or we cannot get the
         information from the node, this function raises an OpPrereqError
         exception.
         @type lu: C{LogicalUnit}
         @param lu: a logical unit from which we get configuration data
         @type nodenames: C{list}
         @param nodenames: the list of node names to check
         @type vg: C{str}
         @param vg: the volume group to check
         @type requested: C{int}
         @param requested: the amount of disk in MiB to check for
         @raise errors.OpPrereqError: if the node doesn't have enough disk,
             or we cannot check the node
         """
         es_flags = rpc.GetExclusiveStorageForNodeNames(lu.cfg, nodenames)
         nodeinfo = lu.rpc.call_node_info(nodenames, [vg], None, es_flags)
         for node in nodenames:
           info = nodeinfo[node]
           info.Raise("Cannot get current information from node %s" % node,
                      prereq=True, ecode=errors.ECODE_ENVIRON)
           (_, (vg_info, ), _) = info.payload
           vg_free = vg_info.get("vg_free", None)
           if not isinstance(vg_free, int):
             raise errors.OpPrereqError("Can't compute free disk space on node"
                                        " %s for vg %s, result was '%s'" %
                                        (node, vg, vg_free), errors.ECODE_ENVIRON)
           if requested > vg_free:
             raise errors.OpPrereqError("Not enough disk space on target node %s"
                                        " vg %s: required %d MiB, available %d MiB" %
                                        (node, vg, requested, vg_free),
                                        errors.ECODE_NORES)
       def _CheckNodesPhysicalCPUs(lu, nodenames, requested, hypervisor_name):
         """Checks if nodes have enough physical CPUs
         This function checks if all given nodes have the needed number of
         physical CPUs. In case any node has less CPUs or we cannot get the
         information from the node, this function raises an OpPrereqError
         exception.
         @type lu: C{LogicalUnit}
         @param lu: a logical unit from which we get configuration data
         @type nodenames: C{list}
         @param nodenames: the list of node names to check
         @type requested: C{int}
         @param requested: the minimum acceptable number of physical CPUs
         @raise errors.OpPrereqError: if the node doesn't have enough CPUs,
             or we cannot check the node
         """
         nodeinfo = lu.rpc.call_node_info(nodenames, None, [hypervisor_name], None)
         for node in nodenames:
           info = nodeinfo[node]
           info.Raise("Cannot get current information from node %s" % node,
                      prereq=True, ecode=errors.ECODE_ENVIRON)
           (_, _, (hv_info, )) = info.payload
           num_cpus = hv_info.get("cpu_total", None)
           if not isinstance(num_cpus, int):
             raise errors.OpPrereqError("Can't compute the number of physical CPUs"
                                        " on node %s, result was '%s'" %
                                        (node, num_cpus), errors.ECODE_ENVIRON)
           if requested > num_cpus:
             raise errors.OpPrereqError("Node %s has %s physical CPUs, but %s are "
                                        "required" % (node, num_cpus, requested),
                                        errors.ECODE_NORES)
       class LUInstanceStartup(LogicalUnit):
         """Starts an instance.
         """
         HPATH = "instance-start"
         HTYPE = constants.HTYPE_INSTANCE
         REQ_BGL = False
         def CheckArguments(self):
           # extra beparams
           if self.op.beparams:
             # fill the beparams dict
             objects.UpgradeBeParams(self.op.beparams)
             utils.ForceDictType(self.op.beparams, constants.BES_PARAMETER_TYPES)
         def ExpandNames(self):
           self._ExpandAndLockInstance()
           self.recalculate_locks[locking.LEVEL_NODE_RES] = constants.LOCKS_REPLACE
         def DeclareLocks(self, level):
           if level == locking.LEVEL_NODE_RES:
             self._LockInstancesNodes(primary_only=True, level=locking.LEVEL_NODE_RES)
         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))
           return env
         def BuildHooksNodes(self):
           """Build hooks nodes.
           """
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return (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 hvparams
           if self.op.hvparams:
             # check hypervisor parameter syntax (locally)
             cluster = self.cfg.GetClusterInfo()
             utils.ForceDictType(self.op.hvparams, constants.HVS_PARAMETER_TYPES)
             filled_hvp = cluster.FillHV(instance)
             filled_hvp.update(self.op.hvparams)
             hv_type = hypervisor.GetHypervisorClass(instance.hypervisor)
             hv_type.CheckParameterSyntax(filled_hvp)
             _CheckHVParams(self, instance.all_nodes, instance.hypervisor, filled_hvp)
           _CheckInstanceState(self, instance, INSTANCE_ONLINE)
           self.primary_offline = self.cfg.GetNodeInfo(instance.primary_node).offline
           if self.primary_offline and self.op.ignore_offline_nodes:
             self.LogWarning("Ignoring offline primary node")
             if self.op.hvparams or self.op.beparams:
               self.LogWarning("Overridden parameters are ignored")
           else:
             _CheckNodeOnline(self, instance.primary_node)
             bep = self.cfg.GetClusterInfo().FillBE(instance)
             bep.update(self.op.beparams)
             # check bridges existence
             _CheckInstanceBridgesExist(self, instance)
             remote_info = self.rpc.call_instance_info(instance.primary_node,
                                                       instance.name,
                                                       instance.hypervisor)
             remote_info.Raise("Error checking node %s" % instance.primary_node,
                               prereq=True, ecode=errors.ECODE_ENVIRON)
             if not remote_info.payload: # not running already
               _CheckNodeFreeMemory(self, instance.primary_node,
                                    "starting instance %s" % instance.name,
                                    bep[constants.BE_MINMEM], instance.hypervisor)
         def Exec(self, feedback_fn):
           """Start the instance.
           """
           instance = self.instance
           force = self.op.force
           reason = self.op.reason
           if not self.op.no_remember:
             self.cfg.MarkInstanceUp(instance.name)
           if self.primary_offline:
             assert self.op.ignore_offline_nodes
             self.LogInfo("Primary node offline, marked instance as started")
           else:
             node_current = instance.primary_node
             _StartInstanceDisks(self, instance, force)
             result = \
               self.rpc.call_instance_start(node_current,
                                            (instance, self.op.hvparams,
                                             self.op.beparams),
                                            self.op.startup_paused, reason)
             msg = result.fail_msg
             if msg:
               _ShutdownInstanceDisks(self, instance)
               raise errors.OpExecError("Could not start instance: %s" % msg)
       class LUInstanceReboot(LogicalUnit):
         """Reboot an instance.
         """
         HPATH = "instance-reboot"
         HTYPE = constants.HTYPE_INSTANCE
         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 = {
             "IGNORE_SECONDARIES": self.op.ignore_secondaries,
             "REBOOT_TYPE": self.op.reboot_type,
             "SHUTDOWN_TIMEOUT": self.op.shutdown_timeout,
+            }
           env.update(_BuildInstanceHookEnvByObject(self, self.instance))
           return env
         def BuildHooksNodes(self):
           """Build hooks nodes.
           """
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return (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
           _CheckInstanceState(self, instance, INSTANCE_ONLINE)
           _CheckNodeOnline(self, instance.primary_node)
           # check bridges existence
           _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
           reason = self.op.reason
           remote_info = self.rpc.call_instance_info(instance.primary_node,
                                                     instance.name,
                                                     instance.hypervisor)
           remote_info.Raise("Error checking node %s" % instance.primary_node)
           instance_running = bool(remote_info.payload)
           node_current = instance.primary_node
           if instance_running and 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,
                                                    self.op.shutdown_timeout, reason)
             result.Raise("Could not reboot instance")
           else:
             if instance_running:
               result = self.rpc.call_instance_shutdown(node_current, instance,
                                                        self.op.shutdown_timeout,
                                                        reason)
               result.Raise("Could not shutdown instance for full reboot")
               _ShutdownInstanceDisks(self, instance)
             else:
               self.LogInfo("Instance %s was already stopped, starting now",
                            instance.name)
             _StartInstanceDisks(self, instance, ignore_secondaries)
             result = self.rpc.call_instance_start(node_current,
                                                   (instance, None, None), False,
                                                    reason)
             msg = result.fail_msg
             if msg:
               _ShutdownInstanceDisks(self, instance)
               raise errors.OpExecError("Could not start instance for"
                                        " full reboot: %s" % msg)
           self.cfg.MarkInstanceUp(instance.name)
       class LUInstanceShutdown(LogicalUnit):
         """Shutdown an instance.
         """
         HPATH = "instance-stop"
         HTYPE = constants.HTYPE_INSTANCE
         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)
           env["TIMEOUT"] = self.op.timeout
           return env
         def BuildHooksNodes(self):
           """Build hooks nodes.
           """
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return (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
           if not self.op.force:
             _CheckInstanceState(self, self.instance, INSTANCE_ONLINE)
           else:
             self.LogWarning("Ignoring offline instance check")
           self.primary_offline = \
             self.cfg.GetNodeInfo(self.instance.primary_node).offline
           if self.primary_offline and self.op.ignore_offline_nodes:
             self.LogWarning("Ignoring offline primary node")
           else:
             _CheckNodeOnline(self, self.instance.primary_node)
         def Exec(self, feedback_fn):
           """Shutdown the instance.
           """
           instance = self.instance
           node_current = instance.primary_node
           timeout = self.op.timeout
           reason = self.op.reason
           # If the instance is offline we shouldn't mark it as down, as that
           # resets the offline flag.
           if not self.op.no_remember and instance.admin_state in INSTANCE_ONLINE:
             self.cfg.MarkInstanceDown(instance.name)
           if self.primary_offline:
             assert self.op.ignore_offline_nodes
             self.LogInfo("Primary node offline, marked instance as stopped")
           else:
             result = self.rpc.call_instance_shutdown(node_current, instance, timeout,
                                                      reason)
             msg = result.fail_msg
             if msg:
               self.LogWarning("Could not shutdown instance: %s", msg)
             _ShutdownInstanceDisks(self, instance)
       class LUInstanceReinstall(LogicalUnit):
         """Reinstall an instance.
         """
         HPATH = "instance-reinstall"
         HTYPE = constants.HTYPE_INSTANCE
         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.
           """
           return _BuildInstanceHookEnvByObject(self, self.instance)
         def BuildHooksNodes(self):
           """Build hooks nodes.
           """
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return (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, "Instance primary node"
                            " offline, cannot reinstall")
           if instance.disk_template == constants.DT_DISKLESS:
             raise errors.OpPrereqError("Instance '%s' has no disks" %
                                        self.op.instance_name,
                                        errors.ECODE_INVAL)
           _CheckInstanceState(self, instance, INSTANCE_DOWN, msg="cannot reinstall")
           if self.op.os_type is not None:
             # OS verification
             pnode = _ExpandNodeName(self.cfg, instance.primary_node)
             _CheckNodeHasOS(self, pnode, self.op.os_type, self.op.force_variant)
             instance_os = self.op.os_type
           else:
             instance_os = instance.os
           nodelist = list(instance.all_nodes)
           if self.op.osparams:
             i_osdict = _GetUpdatedParams(instance.osparams, self.op.osparams)
             _CheckOSParams(self, True, nodelist, instance_os, i_osdict)
             self.os_inst = i_osdict # the new dict (without defaults)
           else:
             self.os_inst = None
           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
             # Write to configuration
             self.cfg.Update(inst, feedback_fn)
           _StartInstanceDisks(self, inst, None)
           try:
             feedback_fn("Running the instance OS create scripts...")
             # FIXME: pass debug option from opcode to backend
             result = self.rpc.call_instance_os_add(inst.primary_node,
                                                    (inst, self.os_inst), True,
                                                    self.op.debug_level)
             result.Raise("Could not install OS for instance %s on node %s" %
                          (inst.name, inst.primary_node))
           finally:
             _ShutdownInstanceDisks(self, inst)
       class LUInstanceRecreateDisks(LogicalUnit):
         """Recreate an instance's missing disks.
         """
         HPATH = "instance-recreate-disks"
         HTYPE = constants.HTYPE_INSTANCE
         REQ_BGL = False
         _MODIFYABLE = compat.UniqueFrozenset([
           constants.IDISK_SIZE,
           constants.IDISK_MODE,
           ])
         # New or changed disk parameters may have different semantics
         assert constants.IDISK_PARAMS == (_MODIFYABLE | frozenset([
           constants.IDISK_ADOPT,
           # TODO: Implement support changing VG while recreating
           constants.IDISK_VG,
           constants.IDISK_METAVG,
           constants.IDISK_PROVIDER,
           constants.IDISK_NAME,
           ]))
         def _RunAllocator(self):
           """Run the allocator based on input opcode.
           """
           be_full = self.cfg.GetClusterInfo().FillBE(self.instance)
           # FIXME
           # The allocator should actually run in "relocate" mode, but current
           # allocators don't support relocating all the nodes of an instance at
           # the same time. As a workaround we use "allocate" mode, but this is
           # suboptimal for two reasons:
           # - The instance name passed to the allocator is present in the list of
           #   existing instances, so there could be a conflict within the
           #   internal structures of the allocator. This doesn't happen with the
           #   current allocators, but it's a liability.
           # - The allocator counts the resources used by the instance twice: once
           #   because the instance exists already, and once because it tries to
           #   allocate a new instance.
           # The allocator could choose some of the nodes on which the instance is
           # running, but that's not a problem. If the instance nodes are broken,
           # they should be already be marked as drained or offline, and hence
           # skipped by the allocator. If instance disks have been lost for other
           # reasons, then recreating the disks on the same nodes should be fine.
           disk_template = self.instance.disk_template
           spindle_use = be_full[constants.BE_SPINDLE_USE]
           req = iallocator.IAReqInstanceAlloc(name=self.op.instance_name,
                                               disk_template=disk_template,
                                               tags=list(self.instance.GetTags()),
                                               os=self.instance.os,
                                               nics=[{}],
                                               vcpus=be_full[constants.BE_VCPUS],
                                               memory=be_full[constants.BE_MAXMEM],
                                               spindle_use=spindle_use,
                                               disks=[{constants.IDISK_SIZE: d.size,
                                                       constants.IDISK_MODE: d.mode}
                                                       for d in self.instance.disks],
                                               hypervisor=self.instance.hypervisor,
                                               node_whitelist=None)
           ial = iallocator.IAllocator(self.cfg, self.rpc, req)
           ial.Run(self.op.iallocator)
           assert req.RequiredNodes() == len(self.instance.all_nodes)
           if not ial.success:
             raise errors.OpPrereqError("Can't compute nodes using iallocator '%s':"
                                        " %s" % (self.op.iallocator, ial.info),
                                        errors.ECODE_NORES)
           self.op.nodes = ial.result
           self.LogInfo("Selected nodes for instance %s via iallocator %s: %s",
                        self.op.instance_name, self.op.iallocator,
                        utils.CommaJoin(ial.result))
         def CheckArguments(self):
           if self.op.disks and ht.TNonNegativeInt(self.op.disks[0]):
             # Normalize and convert deprecated list of disk indices
             self.op.disks = [(idx, {}) for idx in sorted(frozenset(self.op.disks))]
           duplicates = utils.FindDuplicates(map(compat.fst, self.op.disks))
           if duplicates:
             raise errors.OpPrereqError("Some disks have been specified more than"
                                        " once: %s" % utils.CommaJoin(duplicates),
                                        errors.ECODE_INVAL)
           # We don't want _CheckIAllocatorOrNode selecting the default iallocator
           # when neither iallocator nor nodes are specified
           if self.op.iallocator or self.op.nodes:
             _CheckIAllocatorOrNode(self, "iallocator", "nodes")
           for (idx, params) in self.op.disks:
             utils.ForceDictType(params, constants.IDISK_PARAMS_TYPES)
             unsupported = frozenset(params.keys()) - self._MODIFYABLE
             if unsupported:
               raise errors.OpPrereqError("Parameters for disk %s try to change"
                                          " unmodifyable parameter(s): %s" %
                                          (idx, utils.CommaJoin(unsupported)),
                                          errors.ECODE_INVAL)
         def ExpandNames(self):
           self._ExpandAndLockInstance()
           self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_APPEND
           if self.op.nodes:
             self.op.nodes = [_ExpandNodeName(self.cfg, n) for n in self.op.nodes]
             self.needed_locks[locking.LEVEL_NODE] = list(self.op.nodes)
           else:
             self.needed_locks[locking.LEVEL_NODE] = []
             if self.op.iallocator:
               # iallocator will select a new node in the same group
               self.needed_locks[locking.LEVEL_NODEGROUP] = []
               self.needed_locks[locking.LEVEL_NODE_ALLOC] = locking.ALL_SET
           self.needed_locks[locking.LEVEL_NODE_RES] = []
         def DeclareLocks(self, level):
           if level == locking.LEVEL_NODEGROUP:
             assert self.op.iallocator is not None
             assert not self.op.nodes
             assert not self.needed_locks[locking.LEVEL_NODEGROUP]
             self.share_locks[locking.LEVEL_NODEGROUP] = 1
             # Lock the primary group used by the instance optimistically; this
             # requires going via the node before it's locked, requiring
             # verification later on
             self.needed_locks[locking.LEVEL_NODEGROUP] = \
               self.cfg.GetInstanceNodeGroups(self.op.instance_name, primary_only=True)
           elif level == locking.LEVEL_NODE:
             # If an allocator is used, then we lock all the nodes in the current
             # instance group, as we don't know yet which ones will be selected;
             # if we replace the nodes without using an allocator, locks are
             # already declared in ExpandNames; otherwise, we need to lock all the
             # instance nodes for disk re-creation
             if self.op.iallocator:
               assert not self.op.nodes
               assert not self.needed_locks[locking.LEVEL_NODE]
               assert len(self.owned_locks(locking.LEVEL_NODEGROUP)) == 1
               # Lock member nodes of the group of the primary node
               for group_uuid in self.owned_locks(locking.LEVEL_NODEGROUP):
                 self.needed_locks[locking.LEVEL_NODE].extend(
                   self.cfg.GetNodeGroup(group_uuid).members)
               assert locking.NAL in self.owned_locks(locking.LEVEL_NODE_ALLOC)
             elif not self.op.nodes:
               self._LockInstancesNodes(primary_only=False)
           elif level == locking.LEVEL_NODE_RES:
             # Copy node locks
             self.needed_locks[locking.LEVEL_NODE_RES] = \
               _CopyLockList(self.needed_locks[locking.LEVEL_NODE])
         def BuildHooksEnv(self):
           """Build hooks env.
           This runs on master, primary and secondary nodes of the instance.
           """
           return _BuildInstanceHookEnvByObject(self, self.instance)
         def BuildHooksNodes(self):
           """Build hooks nodes.
           """
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return (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
           if self.op.nodes:
             if len(self.op.nodes) != len(instance.all_nodes):
               raise errors.OpPrereqError("Instance %s currently has %d nodes, but"
                                          " %d replacement nodes were specified" %
                                          (instance.name, len(instance.all_nodes),
                                           len(self.op.nodes)),
                                          errors.ECODE_INVAL)
             assert instance.disk_template != constants.DT_DRBD8 or \
                 len(self.op.nodes) == 2
             assert instance.disk_template != constants.DT_PLAIN or \
                 len(self.op.nodes) == 1
             primary_node = self.op.nodes[0]
           else:
             primary_node = instance.primary_node
           if not self.op.iallocator:
             _CheckNodeOnline(self, primary_node)
           if instance.disk_template == constants.DT_DISKLESS:
             raise errors.OpPrereqError("Instance '%s' has no disks" %
                                        self.op.instance_name, errors.ECODE_INVAL)
           # Verify if node group locks are still correct
           owned_groups = self.owned_locks(locking.LEVEL_NODEGROUP)
           if owned_groups:
             # Node group locks are acquired only for the primary node (and only
             # when the allocator is used)
             _CheckInstanceNodeGroups(self.cfg, self.op.instance_name, owned_groups,
                                      primary_only=True)
           # if we replace nodes *and* the old primary is offline, we don't
           # check the instance state
           old_pnode = self.cfg.GetNodeInfo(instance.primary_node)
           if not ((self.op.iallocator or self.op.nodes) and old_pnode.offline):
             _CheckInstanceState(self, instance, INSTANCE_NOT_RUNNING,
                                 msg="cannot recreate disks")
           if self.op.disks:
             self.disks = dict(self.op.disks)
           else:
             self.disks = dict((idx, {}) for idx in range(len(instance.disks)))
           maxidx = max(self.disks.keys())
           if maxidx >= len(instance.disks):
             raise errors.OpPrereqError("Invalid disk index '%s'" % maxidx,
                                        errors.ECODE_INVAL)
           if ((self.op.nodes or self.op.iallocator) and
               sorted(self.disks.keys()) != range(len(instance.disks))):
             raise errors.OpPrereqError("Can't recreate disks partially and"
                                        " change the nodes at the same time",
                                        errors.ECODE_INVAL)
           self.instance = instance
           if self.op.iallocator:
             self._RunAllocator()
             # Release unneeded node and node resource locks
             _ReleaseLocks(self, locking.LEVEL_NODE, keep=self.op.nodes)
             _ReleaseLocks(self, locking.LEVEL_NODE_RES, keep=self.op.nodes)
             _ReleaseLocks(self, locking.LEVEL_NODE_ALLOC)
           assert not self.glm.is_owned(locking.LEVEL_NODE_ALLOC)
         def Exec(self, feedback_fn):
           """Recreate the disks.
           """
           instance = self.instance
           assert (self.owned_locks(locking.LEVEL_NODE) ==
                   self.owned_locks(locking.LEVEL_NODE_RES))
           to_skip = []
           mods = [] # keeps track of needed changes
           for idx, disk in enumerate(instance.disks):
             try:
               changes = self.disks[idx]
             except KeyError:
               # Disk should not be recreated
               to_skip.append(idx)
               continue
             # update secondaries for disks, if needed
             if self.op.nodes and disk.dev_type == constants.LD_DRBD8:
               # need to update the nodes and minors
               assert len(self.op.nodes) == 2
               assert len(disk.logical_id) == 6 # otherwise disk internals
                                                # have changed
               (_, _, old_port, _, _, old_secret) = disk.logical_id
               new_minors = self.cfg.AllocateDRBDMinor(self.op.nodes, instance.name)
               new_id = (self.op.nodes[0], self.op.nodes[1], old_port,
                         new_minors[0], new_minors[1], old_secret)
               assert len(disk.logical_id) == len(new_id)
             else:
               new_id = None
             mods.append((idx, new_id, changes))
           # now that we have passed all asserts above, we can apply the mods
           # in a single run (to avoid partial changes)
           for idx, new_id, changes in mods:
             disk = instance.disks[idx]
             if new_id is not None:
               assert disk.dev_type == constants.LD_DRBD8
               disk.logical_id = new_id
             if changes:
               disk.Update(size=changes.get(constants.IDISK_SIZE, None),
                           mode=changes.get(constants.IDISK_MODE, None))
           # change primary node, if needed
           if self.op.nodes:
             instance.primary_node = self.op.nodes[0]
             self.LogWarning("Changing the instance's nodes, you will have to"
                             " remove any disks left on the older nodes manually")
           if self.op.nodes:
             self.cfg.Update(instance, feedback_fn)
           # All touched nodes must be locked
           mylocks = self.owned_locks(locking.LEVEL_NODE)
           assert mylocks.issuperset(frozenset(instance.all_nodes))
           _CreateDisks(self, instance, to_skip=to_skip)
       class LUInstanceRename(LogicalUnit):
         """Rename an instance.
         """
         HPATH = "instance-rename"
         HTYPE = constants.HTYPE_INSTANCE
         def CheckArguments(self):
           """Check arguments.
           """
           if self.op.ip_check and not self.op.name_check:
             # TODO: make the ip check more flexible and not depend on the name check
             raise errors.OpPrereqError("IP address check requires a name check",
                                        errors.ECODE_INVAL)
         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
           return env
         def BuildHooksNodes(self):
           """Build hooks nodes.
           """
           nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
           return (nl, nl)
         def CheckPrereq(self):
           """Check prerequisites.
           This checks that the instance is in the cluster and is not running.
           """
           self.op.instance_name = _ExpandInstanceName(self.cfg,
                                                       self.op.instance_name)
           instance = self.cfg.GetInstanceInfo(self.op.instance_name)
           assert instance is not None
           _CheckNodeOnline(self, instance.primary_node)
           _CheckInstanceState(self, instance, INSTANCE_NOT_RUNNING,
                               msg="cannot rename")
           self.instance = instance
           new_name = self.op.new_name
           if self.op.name_check:
             hostname = _CheckHostnameSane(self, new_name)
             new_name = self.op.new_name = hostname.name
             if (self.op.ip_check and
                 netutils.TcpPing(hostname.ip, constants.DEFAULT_NODED_PORT)):
               raise errors.OpPrereqError("IP %s of instance %s already in use" %
                                          (hostname.ip, new_name),
                                          errors.ECODE_NOTUNIQUE)
           instance_list = self.cfg.GetInstanceList()
           if new_name in instance_list and new_name != instance.name:
             raise errors.OpPrereqError("Instance '%s' is already in the cluster" %
                                        new_name, errors.ECODE_EXISTS)
         def Exec(self, feedback_fn):
           """Rename the instance.
           """
           inst = self.instance
           old_name = inst.name
           rename_file_storage = False
           if (inst.disk_template in constants.DTS_FILEBASED and
               self.op.new_name != inst.name):
             old_file_storage_dir = os.path.dirname(inst.disks[0].logical_id[1])
             rename_file_storage = True
           self.cfg.RenameInstance(inst.name, self.op.new_name)
           # Change the instance lock. This is definitely safe while we hold the BGL.
           # Otherwise the new lock would have to be added in acquired mode.
           assert self.REQ_BGL
           assert locking.BGL in self.owned_locks(locking.LEVEL_CLUSTER)
           self.glm.remove(locking.LEVEL_INSTANCE, old_name)
           self.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 rename_file_storage:
             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("Could not rename on node %s directory '%s' to '%s'"
                          " (but the instance has been renamed in Ganeti)" %
                          (inst.primary_node, old_file_storage_dir,
                           new_file_storage_dir))
           _StartInstanceDisks(self, inst, None)
           # update info on disks
           info = _GetInstanceInfoText(inst)
           for (idx, disk) in enumerate(inst.disks):
             for node in inst.all_nodes:
               self.cfg.SetDiskID(disk, node)
               result = self.rpc.call_blockdev_setinfo(node, disk, info)
               if result.fail_msg:
                 self.LogWarning("Error setting info on node %s for disk %s: %s",
                                 node, idx, result.fail_msg)
           try:
             result = self.rpc.call_instance_run_rename(inst.primary_node, inst,
                                                        old_name, self.op.debug_level)
             msg = result.fail_msg
             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.LogWarning(msg)
           finally:
             _ShutdownInstanceDisks(self, inst)
           return inst.name

Synnefo » snf-ganeti » ganeti-local

root / lib / cmdlib / __init__.py @ 7352d33b

root / lib / cmdlib / init.py @ 7352d33b