def GetPostOpInput(self):
"""Try to allocate multiple instances.
@return: A dict with submitted jobs, allocatable instances and failed
allocations
"""
if "instances" not in self.request_body:
raise http.HttpBadRequest(
"Request is missing required 'instances' field"
" in body")
op_id = {
"OP_ID": self.POST_OPCODE.OP_ID, # pylint: disable=E1101
}
body = objects.FillDict(
self.request_body, {
"instances": [
objects.FillDict(inst, op_id)
for inst in self.request_body["instances"]
],
})
return (body, {
"dry_run": self.dryRun(),
})
def _MakeInstance(self):
# Copy default parameters
bep = objects.FillDict(constants.BEC_DEFAULTS, {})
hvp = objects.FillDict(constants.HVC_DEFAULTS[self.HVNAME], {})
# Override default VNC password file path
if constants.HV_VNC_PASSWORD_FILE in hvp:
hvp[constants.HV_VNC_PASSWORD_FILE] = self.vncpw_path
disks = [
(objects.Disk(dev_type=constants.DT_PLAIN,
mode=constants.DISK_RDWR),
utils.PathJoin(self.tmpdir, "disk0"), NotImplemented),
(objects.Disk(dev_type=constants.DT_PLAIN,
mode=constants.DISK_RDONLY),
utils.PathJoin(self.tmpdir, "disk1"), NotImplemented),
]
inst = objects.Instance(name="server01.example.com",
hvparams=hvp,
beparams=bep,
osparams={},
nics=[],
os="deb1",
disks=map(compat.fst, disks))
inst.UpgradeConfig()
return (inst, disks)
def _AnnotateDParamsDRBD(disk, params):
"""Annotates just DRBD disks layouts.
"""
(drbd_params, data_params, meta_params) = params
assert disk.dev_type == constants.DT_DRBD8
disk.params = objects.FillDict(drbd_params, disk.params)
(dev_data, dev_meta) = disk.children
dev_data.params = objects.FillDict(data_params, dev_data.params)
dev_meta.params = objects.FillDict(meta_params, dev_meta.params)
return disk
def ConnectNetwork(opts, args):
"""Map a network to a node group.
@param opts: the command line options selected by the user
@type args: list
@param args: Network, mode, physlink and node groups
@rtype: int
@return: the desired exit code
"""
cl = GetClient()
network = args[0]
nicparams = objects.FillDict(constants.NICC_DEFAULTS, opts.nicparams)
groups = _GetDefaultGroups(cl, args[1:])
# TODO: Change logic to support "--submit"
for group in groups:
op = opcodes.OpNetworkConnect(
group_name=group,
network_name=network,
network_mode=nicparams[constants.NIC_MODE],
network_link=nicparams[constants.NIC_LINK],
network_vlan=nicparams[constants.NIC_VLAN],
conflicts_check=opts.conflicts_check)
SubmitOpCode(op, opts=opts, cl=cl)
def GetPostOpInput(self):
"""Try to allocate multiple instances.
@return: A dict with submitted jobs, allocatable instances and failed
allocations
"""
if "instances" not in self.request_body:
raise http.HttpBadRequest(
"Request is missing required 'instances' field"
" in body")
# Unlike most other RAPI calls, this one is composed of individual opcodes,
# and we have to do the filling ourselves
OPCODE_RENAME = {
"os": "os_type",
"name": "instance_name",
}
body = objects.FillDict(
self.request_body, {
"instances": [
baserlib.FillOpcode(opcodes.OpInstanceCreate,
inst, {},
rename=OPCODE_RENAME)
for inst in self.request_body["instances"]
],
})
return (body, {
"dry_run": self.dryRun(),
})
def CheckHVParams(lu, node_uuids, hvname, hvparams):
"""Hypervisor parameter validation.
This function abstract the hypervisor parameter validation to be
used in both instance create and instance modify.
@type lu: L{LogicalUnit}
@param lu: the logical unit for which we check
@type node_uuids: list
@param node_uuids: the list of nodes on which we should check
@type hvname: string
@param hvname: the name of the hypervisor we should use
@type hvparams: dict
@param hvparams: the parameters which we need to check
@raise errors.OpPrereqError: if the parameters are not valid
"""
node_uuids = _FilterVmNodes(lu, node_uuids)
cluster = lu.cfg.GetClusterInfo()
hvfull = objects.FillDict(cluster.hvparams.get(hvname, {}), hvparams)
hvinfo = lu.rpc.call_hypervisor_validate_params(node_uuids, hvname, hvfull)
for node_uuid in node_uuids:
info = hvinfo[node_uuid]
if info.offline:
continue
info.Raise("Hypervisor parameter validation failed on node %s" %
lu.cfg.GetNodeName(node_uuid))
def _AnnotateDParamsGeneric(disk, params):
"""Generic disk parameter annotation routine.
"""
assert disk.dev_type != constants.DT_DRBD8
disk.params = objects.FillDict(params[0], disk.params)
return disk
def CheckPrereq(self):
"""Check prerequisites.
"""
owned_instance_names = frozenset(
self.owned_locks(locking.LEVEL_INSTANCE))
# Check if locked instances are still correct
CheckNodeGroupInstances(self.cfg, self.group_uuid,
owned_instance_names)
self.group = self.cfg.GetNodeGroup(self.group_uuid)
cluster = self.cfg.GetClusterInfo()
if self.group is None:
raise errors.OpExecError(
"Could not retrieve group '%s' (UUID: %s)" %
(self.op.group_name, self.group_uuid))
if self.op.ndparams:
new_ndparams = GetUpdatedParams(self.group.ndparams,
self.op.ndparams)
utils.ForceDictType(new_ndparams, constants.NDS_PARAMETER_TYPES)
self.new_ndparams = new_ndparams
if self.op.diskparams:
diskparams = self.group.diskparams
uavdp = self._UpdateAndVerifyDiskParams
# For each disktemplate subdict update and verify the values
new_diskparams = dict(
(dt, uavdp(diskparams.get(dt, {}), self.op.diskparams[dt]))
for dt in constants.DISK_TEMPLATES if dt in self.op.diskparams)
# As we've all subdicts of diskparams ready, lets merge the actual
# dict with all updated subdicts
self.new_diskparams = objects.FillDict(diskparams, new_diskparams)
try:
utils.VerifyDictOptions(self.new_diskparams,
constants.DISK_DT_DEFAULTS)
CheckDiskAccessModeConsistency(self.new_diskparams,
self.cfg,
group=self.group)
except errors.OpPrereqError as err:
raise errors.OpPrereqError(
"While verify diskparams options: %s" % err,
errors.ECODE_INVAL)
if self.op.hv_state:
self.new_hv_state = MergeAndVerifyHvState(
self.op.hv_state, self.group.hv_state_static)
if self.op.disk_state:
self.new_disk_state = \
MergeAndVerifyDiskState(self.op.disk_state,
self.group.disk_state_static)
self._CheckIpolicy(cluster, owned_instance_names)
def _InstDict(self, node, instance, hvp=None, bep=None, osp=None):
"""Convert the given instance to a dict.
This is done via the instance's ToDict() method and additionally
we fill the hvparams with the cluster defaults.
@type instance: L{objects.Instance}
@param instance: an Instance object
@type hvp: dict or None
@param hvp: a dictionary with overridden hypervisor parameters
@type bep: dict or None
@param bep: a dictionary with overridden backend parameters
@type osp: dict or None
@param osp: a dictionary with overridden os parameters
@rtype: dict
@return: the instance dict, with the hvparams filled with the
cluster defaults
"""
idict = instance.ToDict()
cluster = self._cfg.GetClusterInfo()
idict["hvparams"] = cluster.FillHV(instance)
idict["secondary_nodes"] = \
self._cfg.GetInstanceSecondaryNodes(instance.uuid)
if hvp is not None:
idict["hvparams"].update(hvp)
idict["beparams"] = cluster.FillBE(instance)
if bep is not None:
idict["beparams"].update(bep)
idict["osparams"] = cluster.SimpleFillOS(instance.os,
instance.osparams)
if osp is not None:
idict["osparams"].update(osp)
disks = self._cfg.GetInstanceDisks(instance.uuid)
idict["disks_info"] = self._DisksDictDP(node, (disks, instance))
for nic in idict["nics"]:
nic["nicparams"] = objects.FillDict(
cluster.nicparams[constants.PP_DEFAULT], nic["nicparams"])
network = nic.get("network", None)
if network:
net_uuid = self._cfg.LookupNetwork(network)
if net_uuid:
nobj = self._cfg.GetNetwork(net_uuid)
nic["netinfo"] = objects.Network.ToDict(nobj)
return idict
def CheckPrereq(self):
"""Check prerequisite.
"""
if self.op.iallocator:
cluster = self.cfg.GetClusterInfo()
default_vg = self.cfg.GetVGName()
ec_id = self.proc.GetECId()
if self.op.opportunistic_locking:
# Only consider nodes for which a lock is held
node_whitelist = self.cfg.GetNodeNames(
set(self.owned_locks(locking.LEVEL_NODE))
& set(self.owned_locks(locking.LEVEL_NODE_RES)))
else:
node_whitelist = None
insts = [
CreateInstanceAllocRequest(
op, ComputeDisks(op.disks, op.disk_template, default_vg),
ComputeNics(op, cluster, None, self.cfg, ec_id),
ComputeFullBeParams(op, cluster), node_whitelist)
for op in self.op.instances
]
req = iallocator.IAReqMultiInstanceAlloc(instances=insts)
ial = iallocator.IAllocator(self.cfg, self.rpc, req)
ial.Run(self.op.iallocator)
if not ial.success:
raise errors.OpPrereqError(
"Can't compute nodes using"
" iallocator '%s': %s" % (self.op.iallocator, ial.info),
errors.ECODE_NORES)
self.ia_result = ial.result
if self.op.dry_run:
self.dry_run_result = objects.FillDict(
self._ConstructPartialResult(), {
constants.JOB_IDS_KEY: [],
})
ret = utils.JoinDisjointDicts(hv_info, {"bootid": bootid})
_AddSpindlesToLegacyNodeInfo(ret, space_info)
_AddStorageInfoToLegacyNodeInfoByTemplate(ret, space_info, disk_template)
return ret
def _AnnotateDParamsDRBD(disk, (drbd_params, data_params, meta_params)):
"""Annotates just DRBD disks layouts.
"""
assert disk.dev_type == constants.DT_DRBD8
disk.params = objects.FillDict(drbd_params, disk.params)
(dev_data, dev_meta) = disk.children
dev_data.params = objects.FillDict(data_params, dev_data.params)
dev_meta.params = objects.FillDict(meta_params, dev_meta.params)
return disk
def _AnnotateDParamsGeneric(disk, (params, )):
"""Generic disk parameter annotation routine.
"""
assert disk.dev_type != constants.DT_DRBD8
disk.params = objects.FillDict(params, disk.params)
def testFillDict(self):
pDict = serializer.PrivateDict()
pDict["bar"] = "egg"
self.assertEqual(pDict, objects.FillDict({}, pDict))
