def _GenInstanceAllocationDict(node, instance):
"""Creates an instance allocation dict to be used with the RAPI"""
instance.SetDiskTemplate(constants.DT_PLAIN)
disks = [{
"size": utils.ParseUnit(d.get("size")),
"name": str(d.get("name"))
} for d in qa_config.GetDiskOptions()]
nic0_mac = instance.GetNicMacAddr(0, constants.VALUE_GENERATE)
nics = [{
constants.INIC_MAC: nic0_mac,
}]
beparams = {
constants.BE_MAXMEM:
utils.ParseUnit(qa_config.get(constants.BE_MAXMEM)),
constants.BE_MINMEM:
utils.ParseUnit(qa_config.get(constants.BE_MINMEM)),
}
return _rapi_client.InstanceAllocation(constants.INSTANCE_CREATE,
instance.name,
constants.DT_PLAIN,
disks,
nics,
os=qa_config.get("os"),
pnode=node.primary,
beparams=beparams)
def TestInstanceGrowDisk(instance):
"""gnt-instance grow-disk"""
if instance.disk_template == constants.DT_DISKLESS:
print qa_utils.FormatInfo("Test not supported for diskless instances")
return
name = instance.name
disks = qa_config.GetDiskOptions()
all_size = [d.get("size") for d in disks]
all_grow = [d.get("growth") for d in disks]
if not all_grow:
# missing disk sizes but instance grow disk has been enabled,
# let's set fixed/nomimal growth
all_grow = ["128M" for _ in all_size]
for idx, (size, grow) in enumerate(zip(all_size, all_grow)):
# succeed in grow by amount
AssertCommand(["gnt-instance", "grow-disk", name, str(idx), grow])
# fail in grow to the old size
AssertCommand(
["gnt-instance", "grow-disk", "--absolute", name,
str(idx), size],
fail=True)
# succeed to grow to old size + 2 * growth
int_size = utils.ParseUnit(size)
int_grow = utils.ParseUnit(grow)
AssertCommand([
"gnt-instance", "grow-disk", "--absolute", name,
str(idx),
str(int_size + 2 * int_grow)
])
def TestRapiInstanceAdd(node, use_client):
"""Test adding a new instance via RAPI"""
if not qa_config.IsTemplateSupported(constants.DT_PLAIN):
return
instance = qa_config.AcquireInstance()
instance.SetDiskTemplate(constants.DT_PLAIN)
try:
disks = [{
"size": utils.ParseUnit(d.get("size")),
"name": str(d.get("name"))
} for d in qa_config.GetDiskOptions()]
nic0_mac = instance.GetNicMacAddr(0, constants.VALUE_GENERATE)
nics = [{
constants.INIC_MAC: nic0_mac,
}]
beparams = {
constants.BE_MAXMEM:
utils.ParseUnit(qa_config.get(constants.BE_MAXMEM)),
constants.BE_MINMEM:
utils.ParseUnit(qa_config.get(constants.BE_MINMEM)),
}
if use_client:
job_id = _rapi_client.CreateInstance(constants.INSTANCE_CREATE,
instance.name,
constants.DT_PLAIN,
disks,
nics,
os=qa_config.get("os"),
pnode=node.primary,
beparams=beparams)
else:
body = {
"__version__": 1,
"mode": constants.INSTANCE_CREATE,
"name": instance.name,
"os_type": qa_config.get("os"),
"disk_template": constants.DT_PLAIN,
"pnode": node.primary,
"beparams": beparams,
"disks": disks,
"nics": nics,
}
(job_id, ) = _DoTests([
("/2/instances", _VerifyReturnsJob, "POST", body),
])
_WaitForRapiJob(job_id)
return instance
except:
instance.Release()
raise
def testSuffixes(self):
for sep in ("", " ", " ", "\t", "\t "):
for suffix, scale in self.SCALES:
for func in (lambda x: x, str.lower, str.upper):
self.assertEqual(
utils.ParseUnit("1024" + sep + func(suffix)),
1024 * scale)
def _BuildRecreateDisksOpts(en_disks, with_spindles, with_growth,
spindles_supported):
if with_spindles:
if spindles_supported:
if with_growth:
build_spindles_opt = (
lambda disk: ",spindles=%s" %
(disk["spindles"] + disk["spindles-growth"]))
else:
build_spindles_opt = (
lambda disk: ",spindles=%s" % disk["spindles"])
else:
build_spindles_opt = (lambda _: ",spindles=1")
else:
build_spindles_opt = (lambda _: "")
if with_growth:
build_size_opt = (
lambda disk: "size=%s" %
(utils.ParseUnit(disk["size"]) + utils.ParseUnit(disk["growth"])))
else:
build_size_opt = (lambda disk: "size=%s" % disk["size"])
build_disk_opt = (lambda (idx, disk): "--disk=%s:%s%s" %
(idx, build_size_opt(disk), build_spindles_opt(disk)))
return map(build_disk_opt, en_disks)
def TestAllocator(opts, args):
"""Runs the test allocator opcode.
@param opts: the command line options selected by the user
@type args: list
@param args: should contain only one element, the iallocator name
@rtype: int
@return: the desired exit code
"""
try:
disks = [{
constants.IDISK_SIZE: utils.ParseUnit(val),
constants.IDISK_MODE: constants.DISK_RDWR,
} for val in opts.disks.split(",")]
except errors.UnitParseError, err:
ToStderr("Invalid disks parameter '%s': %s", opts.disks, err)
return 1
def ParseOptions(self):
"""Parses the command line options.
In case of command line errors, it will show the usage and exit the
program.
"""
parser = optparse.OptionParser(usage="\n%s" % USAGE,
version=("%%prog (ganeti) %s" %
constants.RELEASE_VERSION),
option_list=OPTIONS)
options, args = parser.parse_args()
if len(args) < 1 or options.os is None:
Usage()
if options.mem_size:
options.maxmem_size = options.mem_size
options.minmem_size = options.mem_size
elif options.minmem_size > options.maxmem_size:
Err("Maximum memory lower than minimum memory")
if options.disk_template not in _SUPPORTED_DISK_TEMPLATES:
Err("Unknown or unsupported disk template '%s'" %
options.disk_template)
if options.disk_template == constants.DT_DISKLESS:
disk_size = disk_growth = []
options.do_addremove_disks = False
else:
disk_size = [
utils.ParseUnit(v) for v in options.disk_size.split(",")
]
disk_growth = [
utils.ParseUnit(v) for v in options.disk_growth.split(",")
]
if len(disk_growth) != len(disk_size):
Err("Wrong disk sizes/growth combination")
if ((disk_size and options.disk_template == constants.DT_DISKLESS)
or (not disk_size
and options.disk_template != constants.DT_DISKLESS)):
Err("Wrong disk count/disk template combination")
self.disk_size = disk_size
self.disk_growth = disk_growth
self.disk_count = len(disk_size)
if options.nodes and options.iallocator:
Err("Give either the nodes option or the iallocator option, not both"
)
if options.http_check and not options.name_check:
Err("Can't enable HTTP checks without name checks")
self.opts = options
self.instances = args
self.bep = {
constants.BE_MINMEM: options.minmem_size,
constants.BE_MAXMEM: options.maxmem_size,
constants.BE_VCPUS: options.vcpu_count,
}
self.hypervisor = None
self.hvp = {}
if options.hypervisor:
self.hypervisor, self.hvp = options.hypervisor
if options.reboot_types is None:
options.reboot_types = constants.REBOOT_TYPES
else:
options.reboot_types = options.reboot_types.split(",")
rt_diff = set(options.reboot_types).difference(
constants.REBOOT_TYPES)
if rt_diff:
Err("Invalid reboot types specified: %s" %
utils.CommaJoin(rt_diff))
socket.setdefaulttimeout(options.net_timeout)
def TestAllocator(opts, args):
"""Runs the test allocator opcode.
@param opts: the command line options selected by the user
@type args: list
@param args: should contain only one element, the iallocator name
@rtype: int
@return: the desired exit code
"""
try:
disks = [{
constants.IDISK_SIZE: utils.ParseUnit(val),
constants.IDISK_MODE: constants.DISK_RDWR,
} for val in opts.disks.split(",")]
except errors.UnitParseError as err:
ToStderr("Invalid disks parameter '%s': %s", opts.disks, err)
return 1
nics = [val.split("/") for val in opts.nics.split(",")]
for row in nics:
while len(row) < 3:
row.append(None)
for i in range(3):
if row[i] == "":
row[i] = None
nic_dict = [
{
constants.INIC_MAC: v[0],
constants.INIC_IP: v[1],
# The iallocator interface defines a "bridge" item
"bridge": v[2],
} for v in nics
]
if opts.tags is None:
opts.tags = []
else:
opts.tags = opts.tags.split(",")
if opts.target_groups is None:
target_groups = []
else:
target_groups = opts.target_groups
op = opcodes.OpTestAllocator(mode=opts.mode,
name=args[0],
instances=args,
memory=opts.memory,
disks=disks,
disk_template=opts.disk_template,
nics=nic_dict,
os=opts.os,
vcpus=opts.vcpus,
tags=opts.tags,
direction=opts.direction,
iallocator=opts.iallocator,
evac_mode=opts.evac_mode,
target_groups=target_groups,
spindle_use=opts.spindle_use,
count=opts.count)
result = SubmitOpCode(op, opts=opts)
ToStdout("%s" % result)
return 0
def testFloating(self):
self.assertEqual(utils.ParseUnit("0"), 0)
self.assertEqual(utils.ParseUnit("0.5"), 4)
self.assertEqual(utils.ParseUnit("1.75"), 4)
self.assertEqual(utils.ParseUnit("1.99"), 4)
self.assertEqual(utils.ParseUnit("2.00"), 4)
self.assertEqual(utils.ParseUnit("2.01"), 4)
self.assertEqual(utils.ParseUnit("3.99"), 4)
self.assertEqual(utils.ParseUnit("4.00"), 4)
self.assertEqual(utils.ParseUnit("4.01"), 8)
self.assertEqual(utils.ParseUnit("1.5G"), 1536)
self.assertEqual(utils.ParseUnit("1.8G"), 1844)
self.assertEqual(utils.ParseUnit("8.28T"), 8682212)
def testRounding(self):
self.assertEqual(utils.ParseUnit("0"), 0)
self.assertEqual(utils.ParseUnit("1"), 4)
self.assertEqual(utils.ParseUnit("2"), 4)
self.assertEqual(utils.ParseUnit("3"), 4)
self.assertEqual(utils.ParseUnit("124"), 124)
self.assertEqual(utils.ParseUnit("125"), 128)
self.assertEqual(utils.ParseUnit("126"), 128)
self.assertEqual(utils.ParseUnit("127"), 128)
self.assertEqual(utils.ParseUnit("128"), 128)
self.assertEqual(utils.ParseUnit("129"), 132)
self.assertEqual(utils.ParseUnit("130"), 132)
