vboxtestvms.py@ 78460

Last change on this file since 78460 was 78418, checked in by vboxsync, 6 years ago
testdriver/vboxtestvms.py: Refined Frank's testboxpile1 hack so it doesn't totaly mess up script time when running tests locally on my windows box.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 56.7 KB

Line
1	# -- coding: utf-8 --
2	# $Id: vboxtestvms.py 78418 2019-05-06 23:30:09Z vboxsync $
3
4	"""
5	VirtualBox Test VMs
6	"""
7
8	__copyright__ = \
9	"""
10	Copyright (C) 2010-2019 Oracle Corporation
11
12	This file is part of VirtualBox Open Source Edition (OSE), as
13	available from http://www.virtualbox.org. This file is free software;
14	you can redistribute it and/or modify it under the terms of the GNU
15	General Public License (GPL) as published by the Free Software
16	Foundation, in version 2 as it comes in the "COPYING" file of the
17	VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19
20	The contents of this file may alternatively be used under the terms
21	of the Common Development and Distribution License Version 1.0
22	(CDDL) only, as it comes in the "COPYING.CDDL" file of the
23	VirtualBox OSE distribution, in which case the provisions of the
24	CDDL are applicable instead of those of the GPL.
25
26	You may elect to license modified versions of this file under the
27	terms and conditions of either the GPL or the CDDL or both.
28	"""
29	__version__ = "$Revision: 78418 $"
30
31	# Standard Python imports.
32	import copy;
33	import os;
34	import re;
35	import random;
36	import socket;
37	import string;
38
39	# Validation Kit imports.
40	from testdriver import base;
41	from testdriver import reporter;
42	from testdriver import vboxcon;
43	from common import utils;
44
45
46	# All virtualization modes.
47	g_asVirtModes = ['hwvirt', 'hwvirt-np', 'raw',];
48	# All virtualization modes except for raw-mode.
49	g_asVirtModesNoRaw = ['hwvirt', 'hwvirt-np',];
50	# Dictionary mapping the virtualization mode mnemonics to a little less cryptic
51	# strings used in test descriptions.
52	g_dsVirtModeDescs = {
53	'raw' : 'Raw-mode',
54	'hwvirt' : 'HwVirt',
55	'hwvirt-np' : 'NestedPaging'
56	};
57
58	## @name VM grouping flags
59	## @{
60	g_kfGrpSmoke = 0x0001; ##< Smoke test VM.
61	g_kfGrpStandard = 0x0002; ##< Standard test VM.
62	g_kfGrpStdSmoke = g_kfGrpSmoke \| g_kfGrpStandard; ##< shorthand.
63	g_kfGrpWithGAs = 0x0004; ##< The VM has guest additions installed.
64	g_kfGrpNoTxs = 0x0008; ##< The VM lacks test execution service.
65	g_kfGrpAncient = 0x1000; ##< Ancient OS.
66	g_kfGrpExotic = 0x2000; ##< Exotic OS.
67	## @}
68
69
70	## @name Flags.
71	## @{
72	g_k32 = 32; # pylint: disable=C0103
73	g_k64 = 64; # pylint: disable=C0103
74	g_k32_64 = 96; # pylint: disable=C0103
75	g_kiArchMask = 96;
76	g_kiNoRaw = 128; ##< No raw mode.
77	## @}
78
79	# Array indexes.
80	g_iGuestOsType = 0;
81	g_iKind = 1;
82	g_iFlags = 2;
83	g_iMinCpu = 3;
84	g_iMaxCpu = 4;
85	g_iRegEx = 5;
86
87	# Table translating from VM name core to a more detailed guest info.
88	# pylint: disable=C0301
89	g_aaNameToDetails = \
90	[
91	[ 'WindowsNT3x', 'WindowsNT3x', g_k32, 1, 32, ['nt3', 'nt3[0-9]*']], # max cpus??
92	[ 'WindowsNT4', 'WindowsNT4', g_k32, 1, 32, ['nt4', 'nt4sp[0-9]']], # max cpus??
93	[ 'Windows2000', 'Windows2000', g_k32, 1, 32, ['w2k', 'w2ksp[0-9]', 'win2k', 'win2ksp[0-9]']], # max cpus??
94	[ 'WindowsXP', 'WindowsXP', g_k32, 1, 32, ['xp', 'xpsp[0-9]']],
95	[ 'WindowsXP_64', 'WindowsXP_64', g_k64, 1, 32, ['xp64', 'xp64sp[0-9]']],
96	[ 'Windows2003', 'Windows2003', g_k32, 1, 32, ['w2k3', 'w2k3sp[0-9]', 'win2k3', 'win2k3sp[0-9]']],
97	[ 'WindowsVista', 'WindowsVista', g_k32, 1, 32, ['vista', 'vistasp[0-9]']],
98	[ 'WindowsVista_64','WindowsVista_64', g_k64, 1, 64, ['vista-64', 'vistasp[0-9]-64',]], # max cpus/cores??
99	[ 'Windows2008', 'Windows2008', g_k32, 1, 64, ['w2k8', 'w2k8sp[0-9]', 'win2k8', 'win2k8sp[0-9]']], # max cpus/cores??
100	[ 'Windows2008_64', 'Windows2008_64', g_k64, 1, 64, ['w2k8r2', 'w2k8r2sp[0-9]', 'win2k8r2', 'win2k8r2sp[0-9]']], # max cpus/cores??
101	[ 'Windows7', 'Windows7', g_k32, 1, 32, ['w7', 'w7sp[0-9]', 'win7',]], # max cpus/cores??
102	[ 'Windows7_64', 'Windows7_64', g_k64, 1, 64, ['w7-64', 'w7sp[0-9]-64', 'win7-64',]], # max cpus/cores??
103	[ 'Windows8', 'Windows8', g_k32 \| g_kiNoRaw, 1, 32, ['w8', 'w8sp[0-9]', 'win8',]], # max cpus/cores??
104	[ 'Windows8_64', 'Windows8_64', g_k64, 1, 64, ['w8-64', 'w8sp[0-9]-64', 'win8-64',]], # max cpus/cores??
105	[ 'Windows81', 'Windows81', g_k32 \| g_kiNoRaw, 1, 32, ['w81', 'w81sp[0-9]', 'win81',]], # max cpus/cores??
106	[ 'Windows81_64', 'Windows81_64', g_k64, 1, 64, ['w81-64', 'w81sp[0-9]-64', 'win81-64',]], # max cpus/cores??
107	[ 'Windows10', 'Windows10', g_k32 \| g_kiNoRaw, 1, 32, ['w10', 'w10sp[0-9]', 'win10',]], # max cpus/cores??
108	[ 'Windows10_64', 'Windows10_64', g_k64, 1, 64, ['w10-64', 'w10sp[0-9]-64', 'win10-64',]], # max cpus/cores??
109	[ 'Linux', 'Debian', g_k32, 1, 256, ['deb[0-9]', 'debian[0-9]', ]],
110	[ 'Linux_64', 'Debian_64', g_k64, 1, 256, ['deb[0-9]-64', 'debian[0-9]-64', ]],
111	[ 'Linux', 'RedHat', g_k32, 1, 256, ['rhel', 'rhel[0-9]', 'rhel[0-9]u[0-9]']],
112	[ 'Linux', 'Fedora', g_k32, 1, 256, ['fedora', 'fedora[0-9]*', ]],
113	[ 'Linux_64', 'Fedora_64', g_k64, 1, 256, ['fedora-64', 'fedora[0-9]*-64', ]],
114	[ 'Linux', 'Oracle', g_k32, 1, 256, ['ols[0-9]', 'oel[0-9]', ]],
115	[ 'Linux_64', 'Oracle_64', g_k64, 1, 256, ['ols[0-9]-64', 'oel[0-9]-64', ]],
116	[ 'Linux', 'OpenSUSE', g_k32, 1, 256, ['opensuse[0-9]', 'suse[0-9]', ]],
117	[ 'Linux_64', 'OpenSUSE_64', g_k64, 1, 256, ['opensuse[0-9]-64', 'suse[0-9]-64', ]],
118	[ 'Linux', 'Ubuntu', g_k32, 1, 256, ['ubuntu[0-9]*', ]],
119	[ 'Linux_64', 'Ubuntu_64', g_k64, 1, 256, ['ubuntu[0-9]*-64', ]],
120	[ 'Linux', 'ArchLinux', g_k32, 1, 256, ['arch[0-9]*', ]],
121	[ 'Linux_64', 'ArchLinux_64', g_k64, 1, 256, ['arch[0-9]*-64', ]],
122	[ 'Solaris', 'Solaris', g_k32, 1, 256, ['sol10', 'sol10u[0-9]']],
123	[ 'Solaris_64', 'Solaris_64', g_k64, 1, 256, ['sol10-64', 'sol10u-64[0-9]']],
124	[ 'Solaris_64', 'Solaris11_64', g_k64, 1, 256, ['sol11u1']],
125	[ 'BSD', 'FreeBSD_64', g_k32_64, 1, 1, ['bs-.*']], # boot sectors, wanted 64-bit type.
126	[ 'DOS', 'DOS', g_k32, 1, 1, ['bs-.*']],
127	];
128
129
130	## @name Guest OS type string constants.
131	## @{
132	g_ksGuestOsTypeDarwin = 'darwin';
133	g_ksGuestOsTypeDOS = 'dos';
134	g_ksGuestOsTypeFreeBSD = 'freebsd';
135	g_ksGuestOsTypeLinux = 'linux';
136	g_ksGuestOsTypeOS2 = 'os2';
137	g_ksGuestOsTypeSolaris = 'solaris';
138	g_ksGuestOsTypeWindows = 'windows';
139	## @}
140
141	## @name String constants for paravirtualization providers.
142	## @{
143	g_ksParavirtProviderNone = 'none';
144	g_ksParavirtProviderDefault = 'default';
145	g_ksParavirtProviderLegacy = 'legacy';
146	g_ksParavirtProviderMinimal = 'minimal';
147	g_ksParavirtProviderHyperV = 'hyperv';
148	g_ksParavirtProviderKVM = 'kvm';
149	## @}
150
151	## Valid paravirtualization providers.
152	g_kasParavirtProviders = ( g_ksParavirtProviderNone, g_ksParavirtProviderDefault, g_ksParavirtProviderLegacy,
153	g_ksParavirtProviderMinimal, g_ksParavirtProviderHyperV, g_ksParavirtProviderKVM );
154
155	# Mapping for support of paravirtualisation providers per guest OS.
156	#g_kdaParavirtProvidersSupported = {
157	# g_ksGuestOsTypeDarwin : ( g_ksParavirtProviderMinimal, ),
158	# g_ksGuestOsTypeFreeBSD : ( g_ksParavirtProviderNone, g_ksParavirtProviderMinimal, ),
159	# g_ksGuestOsTypeLinux : ( g_ksParavirtProviderNone, g_ksParavirtProviderMinimal, g_ksParavirtProviderHyperV, g_ksParavirtProviderKVM),
160	# g_ksGuestOsTypeOS2 : ( g_ksParavirtProviderNone, ),
161	# g_ksGuestOsTypeSolaris : ( g_ksParavirtProviderNone, ),
162	# g_ksGuestOsTypeWindows : ( g_ksParavirtProviderNone, g_ksParavirtProviderMinimal, g_ksParavirtProviderHyperV, )
163	#}
164	# Temporary tweak:
165	# since for the most guests g_ksParavirtProviderNone is almost the same as g_ksParavirtProviderMinimal,
166	# g_ksParavirtProviderMinimal is removed from the list in order to get maximum number of unique choices
167	# during independent test runs when paravirt provider is taken randomly.
168	g_kdaParavirtProvidersSupported = {
169	g_ksGuestOsTypeDarwin : ( g_ksParavirtProviderMinimal, ),
170	g_ksGuestOsTypeDOS : ( g_ksParavirtProviderNone, ),
171	g_ksGuestOsTypeFreeBSD : ( g_ksParavirtProviderNone, ),
172	g_ksGuestOsTypeLinux : ( g_ksParavirtProviderNone, g_ksParavirtProviderHyperV, g_ksParavirtProviderKVM),
173	g_ksGuestOsTypeOS2 : ( g_ksParavirtProviderNone, ),
174	g_ksGuestOsTypeSolaris : ( g_ksParavirtProviderNone, ),
175	g_ksGuestOsTypeWindows : ( g_ksParavirtProviderNone, g_ksParavirtProviderHyperV, )
176	}
177
178
179	# pylint: enable=C0301
180
181	def _intersects(asSet1, asSet2):
182	"""
183	Checks if any of the strings in set 1 matches any of the regular
184	expressions in set 2.
185	"""
186	for sStr1 in asSet1:
187	for sRx2 in asSet2:
188	if re.match(sStr1, sRx2 + '$'):
189	return True;
190	return False;
191
192
193	class TestVm(object):
194	"""
195	A Test VM - name + VDI/whatever.
196
197	This is just a data object.
198	"""
199
200	def __init__(self, # pylint: disable=R0913
201	sVmName, # type: str
202	fGrouping = 0, # type: int
203	oSet = None, # type: TestVmSet
204	sHd = None, # type: str
205	sKind = None, # type: str
206	acCpusSup = None, # type: List[int]
207	asVirtModesSup = None, # type: List[str]
208	fIoApic = None, # type: bool
209	fNstHwVirt = False, # type: bool
210	fPae = None, # type: bool
211	sNic0AttachType = None, # type: str
212	sFloppy = None, # type: str
213	fVmmDevTestingPart = None, # type: bool
214	fVmmDevTestingMmio = False, # type: bool
215	asParavirtModesSup = None, # type: List[str]
216	fRandomPvPMode = False, # type: bool
217	sFirmwareType = 'bios', # type: str
218	sChipsetType = 'piix3', # type: str
219	sHddControllerType = 'IDE Controller', # type: str
220	sDvdControllerType = 'IDE Controller' # type: str
221	):
222	self.oSet = oSet;
223	self.sVmName = sVmName;
224	self.fGrouping = fGrouping;
225	self.sHd = sHd; # Relative to the testrsrc root.
226	self.acCpusSup = acCpusSup;
227	self.asVirtModesSup = asVirtModesSup;
228	self.asParavirtModesSup = asParavirtModesSup;
229	self.asParavirtModesSupOrg = asParavirtModesSup; # HACK ALERT! Trick to make the 'effing random mess not get in the
230	# way of actively selecting virtualization modes.
231	self.sKind = sKind;
232	self.sGuestOsType = None;
233	self.sDvdImage = None; # Relative to the testrsrc root.
234	self.sDvdControllerType = sDvdControllerType;
235	self.fIoApic = fIoApic;
236	self.fNstHwVirt = fNstHwVirt;
237	self.fPae = fPae;
238	self.sNic0AttachType = sNic0AttachType;
239	self.sHddControllerType = sHddControllerType;
240	self.sFloppy = sFloppy; # Relative to the testrsrc root, except when it isn't...
241	self.fVmmDevTestingPart = fVmmDevTestingPart;
242	self.fVmmDevTestingMmio = fVmmDevTestingMmio;
243	self.sFirmwareType = sFirmwareType;
244	self.sChipsetType = sChipsetType;
245	self.fCom1RawFile = False;
246
247	self.fSnapshotRestoreCurrent = False; # Whether to restore execution on the current snapshot.
248	self.fSkip = False; # All VMs are included in the configured set by default.
249	self.aInfo = None;
250	self.sCom1RawFile = None; # Set by createVmInner and getReconfiguredVm if fCom1RawFile is set.
251	self._guessStuff(fRandomPvPMode);
252
253	def _mkCanonicalGuestOSType(self, sType):
254	"""
255	Convert guest OS type into constant representation.
256	Raise exception if specified @param sType is unknown.
257	"""
258	if sType.lower().startswith('darwin'):
259	return g_ksGuestOsTypeDarwin
260	if sType.lower().startswith('bsd'):
261	return g_ksGuestOsTypeFreeBSD
262	if sType.lower().startswith('dos'):
263	return g_ksGuestOsTypeDOS
264	if sType.lower().startswith('linux'):
265	return g_ksGuestOsTypeLinux
266	if sType.lower().startswith('os2'):
267	return g_ksGuestOsTypeOS2
268	if sType.lower().startswith('solaris'):
269	return g_ksGuestOsTypeSolaris
270	if sType.lower().startswith('windows'):
271	return g_ksGuestOsTypeWindows
272	raise base.GenError(sWhat="unknown guest OS kind: %s" % str(sType))
273
274	def _guessStuff(self, fRandomPvPMode):
275	"""
276	Used by the constructor to guess stuff.
277	"""
278
279	sNm = self.sVmName.lower().strip();
280	asSplit = sNm.replace('-', ' ').split(' ');
281
282	if self.sKind is None:
283	# From name.
284	for aInfo in g_aaNameToDetails:
285	if _intersects(asSplit, aInfo[g_iRegEx]):
286	self.aInfo = aInfo;
287	self.sGuestOsType = self._mkCanonicalGuestOSType(aInfo[g_iGuestOsType])
288	self.sKind = aInfo[g_iKind];
289	break;
290	if self.sKind is None:
291	reporter.fatal('The OS of test VM "%s" cannot be guessed' % (self.sVmName,));
292
293	# Check for 64-bit, if required and supported.
294	if (self.aInfo[g_iFlags] & g_kiArchMask) == g_k32_64 and _intersects(asSplit, ['64', 'amd64']):
295	self.sKind = self.sKind + '_64';
296	else:
297	# Lookup the kind.
298	for aInfo in g_aaNameToDetails:
299	if self.sKind == aInfo[g_iKind]:
300	self.aInfo = aInfo;
301	break;
302	if self.aInfo is None:
303	reporter.fatal('The OS of test VM "%s" with sKind="%s" cannot be guessed' % (self.sVmName, self.sKind));
304
305	# Translate sKind into sGuest OS Type.
306	if self.sGuestOsType is None:
307	if self.aInfo is not None:
308	self.sGuestOsType = self._mkCanonicalGuestOSType(self.aInfo[g_iGuestOsType])
309	elif self.sKind.find("Windows") >= 0:
310	self.sGuestOsType = g_ksGuestOsTypeWindows
311	elif self.sKind.find("Linux") >= 0:
312	self.sGuestOsType = g_ksGuestOsTypeLinux;
313	elif self.sKind.find("Solaris") >= 0:
314	self.sGuestOsType = g_ksGuestOsTypeSolaris;
315	elif self.sKind.find("DOS") >= 0:
316	self.sGuestOsType = g_ksGuestOsTypeDOS;
317	else:
318	reporter.fatal('The OS of test VM "%s", sKind="%s" cannot be guessed' % (self.sVmName, self.sKind));
319
320	# Restrict modes and such depending on the OS.
321	if self.asVirtModesSup is None:
322	self.asVirtModesSup = list(g_asVirtModes);
323	if self.sGuestOsType in (g_ksGuestOsTypeOS2, g_ksGuestOsTypeDarwin) \
324	or self.sKind.find('_64') > 0 \
325	or (self.aInfo is not None and (self.aInfo[g_iFlags] & g_kiNoRaw)):
326	self.asVirtModesSup = [sVirtMode for sVirtMode in self.asVirtModesSup if sVirtMode != 'raw'];
327	# TEMPORARY HACK - START
328	sHostName = os.environ.get("COMPUTERNAME", None);
329	if sHostName: sHostName = sHostName.lower();
330	else: sHostName = socket.getfqdn(); # Horribly slow on windows without IPv6 DNS/whatever.
331	if sHostName.startswith('testboxpile1'):
332	self.asVirtModesSup = [sVirtMode for sVirtMode in self.asVirtModesSup if sVirtMode != 'raw'];
333	# TEMPORARY HACK - END
334
335	# Restrict the CPU count depending on the OS and/or percieved SMP readiness.
336	if self.acCpusSup is None:
337	if _intersects(asSplit, ['uni']):
338	self.acCpusSup = [1];
339	elif self.aInfo is not None:
340	self.acCpusSup = [i for i in range(self.aInfo[g_iMinCpu], self.aInfo[g_iMaxCpu]) ];
341	else:
342	self.acCpusSup = [1];
343
344	# Figure relevant PV modes based on the OS.
345	if self.asParavirtModesSup is None:
346	self.asParavirtModesSup = g_kdaParavirtProvidersSupported[self.sGuestOsType];
347	## @todo Remove this hack as soon as we've got around to explictly configure test variations
348	## on the server side. Client side random is interesting but not the best option.
349	self.asParavirtModesSupOrg = self.asParavirtModesSup;
350	if fRandomPvPMode:
351	random.seed();
352	self.asParavirtModesSup = (random.choice(self.asParavirtModesSup),);
353
354	return True;
355
356	def getMissingResources(self, sTestRsrc):
357	"""
358	Returns a list of missing resources (paths, stuff) that the VM needs.
359	"""
360	asRet = [];
361	for sPath in [ self.sHd, self.sDvdImage, self.sFloppy]:
362	if sPath is not None:
363	if not os.path.isabs(sPath):
364	sPath = os.path.join(sTestRsrc, sPath);
365	if not os.path.exists(sPath):
366	asRet.append(sPath);
367	return asRet;
368
369	def createVm(self, oTestDrv, eNic0AttachType = None, sDvdImage = None):
370	"""
371	Creates the VM with defaults and the few tweaks as per the arguments.
372
373	Returns same as vbox.TestDriver.createTestVM.
374	"""
375	if sDvdImage is not None:
376	sMyDvdImage = sDvdImage;
377	else:
378	sMyDvdImage = self.sDvdImage;
379
380	if eNic0AttachType is not None:
381	eMyNic0AttachType = eNic0AttachType;
382	elif self.sNic0AttachType is None:
383	eMyNic0AttachType = None;
384	elif self.sNic0AttachType == 'nat':
385	eMyNic0AttachType = vboxcon.NetworkAttachmentType_NAT;
386	elif self.sNic0AttachType == 'bridged':
387	eMyNic0AttachType = vboxcon.NetworkAttachmentType_Bridged;
388	else:
389	assert False, self.sNic0AttachType;
390
391	return self.createVmInner(oTestDrv, eMyNic0AttachType, sMyDvdImage);
392
393	def _generateRawPortFilename(self, oTestDrv, sInfix, sSuffix):
394	""" Generates a raw port filename. """
395	random.seed();
396	sRandom = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(10));
397	return os.path.join(oTestDrv.sScratchPath, self.sVmName + sInfix + sRandom + sSuffix);
398
399	def createVmInner(self, oTestDrv, eNic0AttachType, sDvdImage):
400	"""
401	Same as createVm but parameters resolved.
402
403	Returns same as vbox.TestDriver.createTestVM.
404	"""
405	reporter.log2('');
406	reporter.log2('Calling createTestVM on %s...' % (self.sVmName,))
407	if self.fCom1RawFile:
408	self.sCom1RawFile = self._generateRawPortFilename(oTestDrv, '-com1-', '.out');
409	return oTestDrv.createTestVM(self.sVmName,
410	1, # iGroup
411	sHd = self.sHd,
412	sKind = self.sKind,
413	fIoApic = self.fIoApic,
414	fNstHwVirt = self.fNstHwVirt,
415	fPae = self.fPae,
416	eNic0AttachType = eNic0AttachType,
417	sDvdImage = sDvdImage,
418	sDvdControllerType = self.sDvdControllerType,
419	sHddControllerType = self.sHddControllerType,
420	sFloppy = self.sFloppy,
421	fVmmDevTestingPart = self.fVmmDevTestingPart,
422	fVmmDevTestingMmio = self.fVmmDevTestingPart,
423	sFirmwareType = self.sFirmwareType,
424	sChipsetType = self.sChipsetType,
425	sCom1RawFile = self.sCom1RawFile if self.fCom1RawFile else None
426	);
427
428	def getReconfiguredVm(self, oTestDrv, cCpus, sVirtMode, sParavirtMode = None):
429	"""
430	actionExecute worker that finds and reconfigure a test VM.
431
432	Returns (fRc, oVM) where fRc is True, None or False and oVM is a
433	VBox VM object that is only present when rc is True.
434	"""
435
436	fRc = False;
437	oVM = oTestDrv.getVmByName(self.sVmName);
438	if oVM is not None:
439	if self.fSnapshotRestoreCurrent is True:
440	fRc = True;
441	else:
442	fHostSupports64bit = oTestDrv.hasHostLongMode();
443	if self.is64bitRequired() and not fHostSupports64bit:
444	fRc = None; # Skip the test.
445	elif self.isViaIncompatible() and oTestDrv.isHostCpuVia():
446	fRc = None; # Skip the test.
447	elif self.isShanghaiIncompatible() and oTestDrv.isHostCpuShanghai():
448	fRc = None; # Skip the test.
449	elif self.isP4Incompatible() and oTestDrv.isHostCpuP4():
450	fRc = None; # Skip the test.
451	else:
452	oSession = oTestDrv.openSession(oVM);
453	if oSession is not None:
454	fRc = oSession.enableVirtEx(sVirtMode != 'raw');
455	fRc = fRc and oSession.enableNestedPaging(sVirtMode == 'hwvirt-np');
456	fRc = fRc and oSession.setCpuCount(cCpus);
457	if cCpus > 1:
458	fRc = fRc and oSession.enableIoApic(True);
459
460	if sParavirtMode is not None and oSession.fpApiVer >= 5.0:
461	adParavirtProviders = {
462	g_ksParavirtProviderNone : vboxcon.ParavirtProvider_None,
463	g_ksParavirtProviderDefault: vboxcon.ParavirtProvider_Default,
464	g_ksParavirtProviderLegacy : vboxcon.ParavirtProvider_Legacy,
465	g_ksParavirtProviderMinimal: vboxcon.ParavirtProvider_Minimal,
466	g_ksParavirtProviderHyperV : vboxcon.ParavirtProvider_HyperV,
467	g_ksParavirtProviderKVM : vboxcon.ParavirtProvider_KVM,
468	};
469	fRc = fRc and oSession.setParavirtProvider(adParavirtProviders[sParavirtMode]);
470
471	fCfg64Bit = self.is64bitRequired() or (self.is64bit() and fHostSupports64bit and sVirtMode != 'raw');
472	fRc = fRc and oSession.enableLongMode(fCfg64Bit);
473	if fCfg64Bit: # This is to avoid GUI pedantic warnings in the GUI. Sigh.
474	oOsType = oSession.getOsType();
475	if oOsType is not None:
476	if oOsType.is64Bit and sVirtMode == 'raw':
477	assert(oOsType.id[-3:] == '_64');
478	fRc = fRc and oSession.setOsType(oOsType.id[:-3]);
479	elif not oOsType.is64Bit and sVirtMode != 'raw':
480	fRc = fRc and oSession.setOsType(oOsType.id + '_64');
481
482	# New serial raw file.
483	if fRc and self.fCom1RawFile:
484	self.sCom1RawFile = self._generateRawPortFilename(oTestDrv, '-com1-', '.out');
485	utils.noxcptDeleteFile(self.sCom1RawFile);
486	fRc = oSession.setupSerialToRawFile(0, self.sCom1RawFile);
487
488	# Make life simpler for child classes.
489	if fRc:
490	fRc = self._childVmReconfig(oTestDrv, oVM, oSession);
491
492	fRc = fRc and oSession.saveSettings();
493	if not oSession.close():
494	fRc = False;
495	if fRc is True:
496	return (True, oVM);
497	return (fRc, None);
498
499	def _childVmReconfig(self, oTestDrv, oVM, oSession):
500	""" Hook into getReconfiguredVm() for children. """
501	_ = oTestDrv; _ = oVM; _ = oSession;
502	return True;
503
504	def isWindows(self):
505	""" Checks if it's a Windows VM. """
506	return self.sGuestOsType == g_ksGuestOsTypeWindows;
507
508	def isOS2(self):
509	""" Checks if it's an OS/2 VM. """
510	return self.sGuestOsType == g_ksGuestOsTypeOS2;
511
512	def isLinux(self):
513	""" Checks if it's an Linux VM. """
514	return self.sGuestOsType == g_ksGuestOsTypeLinux;
515
516	def is64bit(self):
517	""" Checks if it's a 64-bit VM. """
518	return self.sKind.find('_64') >= 0;
519
520	def is64bitRequired(self):
521	""" Check if 64-bit is required or not. """
522	return (self.aInfo[g_iFlags] & g_k64) != 0;
523
524	def isLoggedOntoDesktop(self):
525	""" Checks if the test VM is logging onto a graphical desktop by default. """
526	if self.isWindows():
527	return True;
528	if self.isOS2():
529	return True;
530	if self.sVmName.find('-desktop'):
531	return True;
532	return False;
533
534	def isViaIncompatible(self):
535	"""
536	Identifies VMs that doesn't work on VIA.
537
538	Returns True if NOT supported on VIA, False if it IS supported.
539	"""
540	# Oracle linux doesn't like VIA in our experience
541	if self.aInfo[g_iKind] in ['Oracle', 'Oracle_64']:
542	return True;
543	# OS/2: "The system detected an internal processing error at location
544	# 0168:fff1da1f - 000e:ca1f. 0a8606fd
545	if self.isOS2():
546	return True;
547	# Windows NT4 before SP4 won't work because of cmpxchg8b not being
548	# detected, leading to a STOP 3e(80,0,0,0).
549	if self.aInfo[g_iKind] == 'WindowsNT4':
550	if self.sVmName.find('sp') < 0:
551	return True; # no service pack.
552	if self.sVmName.find('sp0') >= 0 \
553	or self.sVmName.find('sp1') >= 0 \
554	or self.sVmName.find('sp2') >= 0 \
555	or self.sVmName.find('sp3') >= 0:
556	return True;
557	# XP x64 on a physical VIA box hangs exactly like a VM.
558	if self.aInfo[g_iKind] in ['WindowsXP_64', 'Windows2003_64']:
559	return True;
560	# Vista 64 throws BSOD 0x5D (UNSUPPORTED_PROCESSOR)
561	if self.aInfo[g_iKind] in ['WindowsVista_64']:
562	return True;
563	# Solaris 11 hangs on VIA, tested on a physical box (testboxvqc)
564	if self.aInfo[g_iKind] in ['Solaris11_64']:
565	return True;
566	return False;
567
568	def isShanghaiIncompatible(self):
569	"""
570	Identifies VMs that doesn't work on Shanghai.
571
572	Returns True if NOT supported on Shanghai, False if it IS supported.
573	"""
574	# For now treat it just like VIA, to be adjusted later
575	return self.isViaIncompatible()
576
577	def isP4Incompatible(self):
578	"""
579	Identifies VMs that doesn't work on Pentium 4 / Pentium D.
580
581	Returns True if NOT supported on P4, False if it IS supported.
582	"""
583	# Stupid 1 kHz timer. Too much for antique CPUs.
584	if self.sVmName.find('rhel5') >= 0:
585	return True;
586	# Due to the boot animation the VM takes forever to boot.
587	if self.aInfo[g_iKind] == 'Windows2000':
588	return True;
589	return False;
590
591
592	class BootSectorTestVm(TestVm):
593	"""
594	A Boot Sector Test VM.
595	"""
596
597	def __init__(self, oSet, sVmName, sFloppy = None, asVirtModesSup = None, f64BitRequired = False):
598	self.f64BitRequired = f64BitRequired;
599	if asVirtModesSup is None:
600	asVirtModesSup = list(g_asVirtModes);
601	TestVm.__init__(self, sVmName,
602	oSet = oSet,
603	acCpusSup = [1,],
604	sFloppy = sFloppy,
605	asVirtModesSup = asVirtModesSup,
606	fPae = True,
607	fIoApic = True,
608	fVmmDevTestingPart = True,
609	fVmmDevTestingMmio = True,
610	);
611
612	def is64bitRequired(self):
613	return self.f64BitRequired;
614
615
616	class AncientTestVm(TestVm):
617	"""
618	A ancient Test VM, using the serial port for communicating results.
619
620	We're looking for 'PASSED' and 'FAILED' lines in the COM1 output.
621	"""
622
623
624	def __init__(self, # pylint: disable=R0913
625	sVmName, # type: str
626	fGrouping = g_kfGrpAncient \| g_kfGrpNoTxs, # type: int
627	sHd = None, # type: str
628	sKind = None, # type: str
629	acCpusSup = None, # type: List[int]
630	asVirtModesSup = None, # type: List[str]
631	sNic0AttachType = None, # type: str
632	sFloppy = None, # type: str
633	sFirmwareType = 'bios', # type: str
634	sChipsetType = 'piix3', # type: str
635	sHddControllerName = 'IDE Controller', # type: str
636	sDvdControllerName = 'IDE Controller', # type: str
637	cMBRamMax = None, # type: int
638	):
639	TestVm.__init__(self,
640	sVmName,
641	fGrouping = fGrouping,
642	sHd = sHd,
643	sKind = sKind,
644	acCpusSup = [1] if acCpusSup is None else acCpusSup,
645	asVirtModesSup = asVirtModesSup,
646	sNic0AttachType = sNic0AttachType,
647	sFloppy = sFloppy,
648	sFirmwareType = sFirmwareType,
649	sChipsetType = sChipsetType,
650	sHddControllerType = sHddControllerName,
651	sDvdControllerType = sDvdControllerName,
652	asParavirtModesSup = (g_ksParavirtProviderNone,)
653	);
654	self.fCom1RawFile = True;
655	self.cMBRamMax= cMBRamMax;
656
657
658	def _childVmReconfig(self, oTestDrv, oVM, oSession):
659	_ = oVM; _ = oTestDrv;
660	fRc = True;
661
662	# DOS 4.01 doesn't like the default 32MB of memory.
663	if fRc and self.cMBRamMax is not None:
664	try:
665	cMBRam = oSession.o.machine.memorySize;
666	except:
667	cMBRam = self.cMBRamMax + 4;
668	if self.cMBRamMax < cMBRam:
669	fRc = oSession.setRamSize(self.cMBRamMax);
670
671	return fRc;
672
673
674	class TestVmSet(object):
675	"""
676	A set of Test VMs.
677	"""
678
679	def __init__(self, oTestVmManager = None, acCpus = None, asVirtModes = None, fIgnoreSkippedVm = False):
680	self.oTestVmManager = oTestVmManager;
681	if acCpus is None:
682	acCpus = [1, 2];
683	self.acCpusDef = acCpus;
684	self.acCpus = acCpus;
685	if asVirtModes is None:
686	asVirtModes = list(g_asVirtModes);
687	self.asVirtModesDef = asVirtModes;
688	self.asVirtModes = asVirtModes;
689	self.aoTestVms = [];
690	self.fIgnoreSkippedVm = fIgnoreSkippedVm;
691	self.asParavirtModes = None; ##< If None, use the first PV mode of the test VM, otherwise all modes in this list.
692
693	def findTestVmByName(self, sVmName):
694	"""
695	Returns the TestVm object with the given name.
696	Returns None if not found.
697	"""
698
699	# The 'tst-' prefix is optional.
700	sAltName = sVmName if sVmName.startswith('tst-') else 'tst-' + sVmName;
701
702	for oTestVm in self.aoTestVms:
703	if oTestVm.sVmName == sVmName or oTestVm.sVmName == sAltName:
704	return oTestVm;
705	return None;
706
707	def getAllVmNames(self, sSep = ':'):
708	"""
709	Returns names of all the test VMs in the set separated by
710	sSep (defaults to ':').
711	"""
712	sVmNames = '';
713	for oTestVm in self.aoTestVms:
714	sName = oTestVm.sVmName;
715	if sName.startswith('tst-'):
716	sName = sName[4:];
717	if sVmNames == '':
718	sVmNames = sName;
719	else:
720	sVmNames = sVmNames + sSep + sName;
721	return sVmNames;
722
723	def showUsage(self):
724	"""
725	Invoked by vbox.TestDriver.
726	"""
727	reporter.log('');
728	reporter.log('Test VM selection and general config options:');
729	reporter.log(' --virt-modes <m1[:m2[:...]]>');
730	reporter.log(' Default: %s' % (':'.join(self.asVirtModesDef)));
731	reporter.log(' --skip-virt-modes <m1[:m2[:...]]>');
732	reporter.log(' Use this to avoid hwvirt or hwvirt-np when not supported by the host');
733	reporter.log(' since we cannot detect it using the main API. Use after --virt-modes.');
734	reporter.log(' --cpu-counts <c1[:c2[:...]]>');
735	reporter.log(' Default: %s' % (':'.join(str(c) for c in self.acCpusDef)));
736	reporter.log(' --test-vms <vm1[:vm2[:...]]>');
737	reporter.log(' Test the specified VMs in the given order. Use this to change');
738	reporter.log(' the execution order or limit the choice of VMs');
739	reporter.log(' Default: %s (all)' % (self.getAllVmNames(),));
740	reporter.log(' --skip-vms <vm1[:vm2[:...]]>');
741	reporter.log(' Skip the specified VMs when testing.');
742	reporter.log(' --snapshot-restore-current');
743	reporter.log(' Restores the current snapshot and resumes execution.');
744	reporter.log(' --paravirt-modes <pv1[:pv2[:...]]>');
745	reporter.log(' Set of paravirtualized providers (modes) to tests. Intersected with what the test VM supports.');
746	reporter.log(' Default is the first PV mode the test VMs support, generally same as "legacy".');
747	reporter.log(' --with-nested-hwvirt-only');
748	reporter.log(' Test VMs using nested hardware-virtualization only.');
749	reporter.log(' --without-nested-hwvirt-only');
750	reporter.log(' Test VMs not using nested hardware-virtualization only.');
751	## @todo Add more options for controlling individual VMs.
752	return True;
753
754	def parseOption(self, asArgs, iArg):
755	"""
756	Parses the set test vm set options (--test-vms and --skip-vms), modifying the set
757	Invoked by the testdriver method with the same name.
758
759	Keyword arguments:
760	asArgs -- The argument vector.
761	iArg -- The index of the current argument.
762
763	Returns iArg if the option was not recognized and the caller should handle it.
764	Returns the index of the next argument when something is consumed.
765
766	In the event of a syntax error, a InvalidOption or QuietInvalidOption
767	is thrown.
768	"""
769
770	if asArgs[iArg] == '--virt-modes':
771	iArg += 1;
772	if iArg >= len(asArgs):
773	raise base.InvalidOption('The "--virt-modes" takes a colon separated list of modes');
774
775	self.asVirtModes = asArgs[iArg].split(':');
776	for s in self.asVirtModes:
777	if s not in self.asVirtModesDef:
778	raise base.InvalidOption('The "--virt-modes" value "%s" is not valid; valid values are: %s' \
779	% (s, ' '.join(self.asVirtModesDef)));
780
781	elif asArgs[iArg] == '--skip-virt-modes':
782	iArg += 1;
783	if iArg >= len(asArgs):
784	raise base.InvalidOption('The "--skip-virt-modes" takes a colon separated list of modes');
785
786	for s in asArgs[iArg].split(':'):
787	if s not in self.asVirtModesDef:
788	raise base.InvalidOption('The "--virt-modes" value "%s" is not valid; valid values are: %s' \
789	% (s, ' '.join(self.asVirtModesDef)));
790	if s in self.asVirtModes:
791	self.asVirtModes.remove(s);
792
793	elif asArgs[iArg] == '--cpu-counts':
794	iArg += 1;
795	if iArg >= len(asArgs):
796	raise base.InvalidOption('The "--cpu-counts" takes a colon separated list of cpu counts');
797
798	self.acCpus = [];
799	for s in asArgs[iArg].split(':'):
800	try: c = int(s);
801	except: raise base.InvalidOption('The "--cpu-counts" value "%s" is not an integer' % (s,));
802	if c <= 0: raise base.InvalidOption('The "--cpu-counts" value "%s" is zero or negative' % (s,));
803	self.acCpus.append(c);
804
805	elif asArgs[iArg] == '--test-vms':
806	iArg += 1;
807	if iArg >= len(asArgs):
808	raise base.InvalidOption('The "--test-vms" takes colon separated list');
809
810	for oTestVm in self.aoTestVms:
811	oTestVm.fSkip = True;
812
813	asTestVMs = asArgs[iArg].split(':');
814	for s in asTestVMs:
815	oTestVm = self.findTestVmByName(s);
816	if oTestVm is None:
817	raise base.InvalidOption('The "--test-vms" value "%s" is not valid; valid values are: %s' \
818	% (s, self.getAllVmNames(' ')));
819	oTestVm.fSkip = False;
820
821	elif asArgs[iArg] == '--skip-vms':
822	iArg += 1;
823	if iArg >= len(asArgs):
824	raise base.InvalidOption('The "--skip-vms" takes colon separated list');
825
826	asTestVMs = asArgs[iArg].split(':');
827	for s in asTestVMs:
828	oTestVm = self.findTestVmByName(s);
829	if oTestVm is None:
830	reporter.log('warning: The "--test-vms" value "%s" does not specify any of our test VMs.' % (s,));
831	else:
832	oTestVm.fSkip = True;
833
834	elif asArgs[iArg] == '--snapshot-restore-current':
835	for oTestVm in self.aoTestVms:
836	if oTestVm.fSkip is False:
837	oTestVm.fSnapshotRestoreCurrent = True;
838	reporter.log('VM "%s" will be restored.' % (oTestVm.sVmName));
839
840	elif asArgs[iArg] == '--paravirt-modes':
841	iArg += 1
842	if iArg >= len(asArgs):
843	raise base.InvalidOption('The "--paravirt-modes" takes a colon separated list of modes');
844
845	self.asParavirtModes = asArgs[iArg].split(':')
846	for sPvMode in self.asParavirtModes:
847	if sPvMode not in g_kasParavirtProviders:
848	raise base.InvalidOption('The "--paravirt-modes" value "%s" is not valid; valid values are: %s'
849	% (sPvMode, ', '.join(g_kasParavirtProviders),));
850	if not self.asParavirtModes:
851	self.asParavirtModes = None;
852
853	# HACK ALERT! Reset the random paravirt selection for members.
854	for oTestVm in self.aoTestVms:
855	oTestVm.asParavirtModesSup = oTestVm.asParavirtModesSupOrg;
856
857	elif asArgs[iArg] == '--with-nested-hwvirt-only':
858	for oTestVm in self.aoTestVms:
859	if oTestVm.fNstHwVirt is False:
860	oTestVm.fSkip = True;
861
862	elif asArgs[iArg] == '--without-nested-hwvirt-only':
863	for oTestVm in self.aoTestVms:
864	if oTestVm.fNstHwVirt is True:
865	oTestVm.fSkip = True;
866
867	else:
868	return iArg;
869	return iArg + 1;
870
871	def getResourceSet(self):
872	"""
873	Implements base.TestDriver.getResourceSet
874	"""
875	asResources = [];
876	for oTestVm in self.aoTestVms:
877	if not oTestVm.fSkip:
878	if oTestVm.sHd is not None:
879	asResources.append(oTestVm.sHd);
880	if oTestVm.sDvdImage is not None:
881	asResources.append(oTestVm.sDvdImage);
882	return asResources;
883
884	def actionConfig(self, oTestDrv, eNic0AttachType = None, sDvdImage = None):
885	"""
886	For base.TestDriver.actionConfig. Configure the VMs with defaults and
887	a few tweaks as per arguments.
888
889	Returns True if successful.
890	Returns False if not.
891	"""
892
893	for oTestVm in self.aoTestVms:
894	if oTestVm.fSkip:
895	continue;
896
897	if oTestVm.fSnapshotRestoreCurrent:
898	# If we want to restore a VM we don't need to create
899	# the machine anymore -- so just add it to the test VM list.
900	oVM = oTestDrv.addTestMachine(oTestVm.sVmName);
901	else:
902	oVM = oTestVm.createVm(oTestDrv, eNic0AttachType, sDvdImage);
903	if oVM is None:
904	return False;
905
906	return True;
907
908	def _removeUnsupportedVirtModes(self, oTestDrv):
909	"""
910	Removes unsupported virtualization modes.
911	"""
912	if 'hwvirt' in self.asVirtModes and not oTestDrv.hasHostHwVirt():
913	reporter.log('Hardware assisted virtualization is not available on the host, skipping it.');
914	self.asVirtModes.remove('hwvirt');
915
916	if 'hwvirt-np' in self.asVirtModes and not oTestDrv.hasHostNestedPaging():
917	reporter.log('Nested paging not supported by the host, skipping it.');
918	self.asVirtModes.remove('hwvirt-np');
919
920	if 'raw' in self.asVirtModes and not oTestDrv.hasRawModeSupport():
921	reporter.log('Raw-mode virtualization is not available in this build (or perhaps for this host), skipping it.');
922	self.asVirtModes.remove('raw');
923
924	return True;
925
926	def actionExecute(self, oTestDrv, fnCallback): # pylint: disable=R0914
927	"""
928	For base.TestDriver.actionExecute. Calls the callback function for
929	each of the VMs and basic configuration variations (virt-mode and cpu
930	count).
931
932	Returns True if all fnCallback calls returned True, otherwise False.
933
934	The callback can return True, False or None. The latter is for when the
935	test is skipped. (True is for success, False is for failure.)
936	"""
937
938	self._removeUnsupportedVirtModes(oTestDrv);
939	cMaxCpus = oTestDrv.getHostCpuCount();
940
941	#
942	# The test loop.
943	#
944	fRc = True;
945	for oTestVm in self.aoTestVms:
946	if oTestVm.fNstHwVirt and not oTestDrv.isHostCpuAmd():
947	reporter.log('Ignoring VM %s (Nested hardware-virtualization only supported on AMD CPUs).' % (oTestVm.sVmName,));
948	continue;
949	if oTestVm.fSkip and self.fIgnoreSkippedVm:
950	reporter.log2('Ignoring VM %s (fSkip = True).' % (oTestVm.sVmName,));
951	continue;
952	reporter.testStart(oTestVm.sVmName);
953	if oTestVm.fSkip:
954	reporter.testDone(fSkipped = True);
955	continue;
956
957	# Intersect the supported modes and the ones being testing.
958	asVirtModesSup = [sMode for sMode in oTestVm.asVirtModesSup if sMode in self.asVirtModes];
959
960	# Ditto for CPUs.
961	acCpusSup = [cCpus for cCpus in oTestVm.acCpusSup if cCpus in self.acCpus];
962
963	# Ditto for paravirtualization modes, except if not specified we got a less obvious default.
964	if self.asParavirtModes is not None and oTestDrv.fpApiVer >= 5.0:
965	asParavirtModes = [sPvMode for sPvMode in oTestVm.asParavirtModesSup if sPvMode in self.asParavirtModes];
966	assert None not in asParavirtModes;
967	elif oTestDrv.fpApiVer >= 5.0:
968	asParavirtModes = (oTestVm.asParavirtModesSup[0],);
969	assert asParavirtModes[0] is not None;
970	else:
971	asParavirtModes = (None,);
972
973	for cCpus in acCpusSup:
974	if cCpus == 1:
975	reporter.testStart('1 cpu');
976	else:
977	reporter.testStart('%u cpus' % (cCpus));
978	if cCpus > cMaxCpus:
979	reporter.testDone(fSkipped = True);
980	continue;
981
982	cTests = 0;
983	for sVirtMode in asVirtModesSup:
984	if sVirtMode == 'raw' and cCpus > 1:
985	continue;
986	reporter.testStart('%s' % ( g_dsVirtModeDescs[sVirtMode], ) );
987	cStartTests = cTests;
988
989	for sParavirtMode in asParavirtModes:
990	if sParavirtMode is not None:
991	assert oTestDrv.fpApiVer >= 5.0;
992	reporter.testStart('%s' % ( sParavirtMode, ) );
993
994	# Reconfigure the VM.
995	try:
996	(rc2, oVM) = oTestVm.getReconfiguredVm(oTestDrv, cCpus, sVirtMode, sParavirtMode = sParavirtMode);
997	except KeyboardInterrupt:
998	raise;
999	except:
1000	reporter.errorXcpt(cFrames = 9);
1001	rc2 = False;
1002	if rc2 is True:
1003	# Do the testing.
1004	try:
1005	rc2 = fnCallback(oVM, oTestVm);
1006	except KeyboardInterrupt:
1007	raise;
1008	except:
1009	reporter.errorXcpt(cFrames = 9);
1010	rc2 = False;
1011	if rc2 is False:
1012	reporter.maybeErr(reporter.testErrorCount() == 0, 'fnCallback failed');
1013	elif rc2 is False:
1014	reporter.log('getReconfiguredVm failed');
1015	if rc2 is False:
1016	fRc = False;
1017
1018	cTests = cTests + (rc2 is not None);
1019	if sParavirtMode is not None:
1020	reporter.testDone(fSkipped = (rc2 is None));
1021
1022	reporter.testDone(fSkipped = cTests == cStartTests);
1023
1024	reporter.testDone(fSkipped = cTests == 0);
1025
1026	_, cErrors = reporter.testDone();
1027	if cErrors > 0:
1028	fRc = False;
1029	return fRc;
1030
1031	def enumerateTestVms(self, fnCallback):
1032	"""
1033	Enumerates all the 'active' VMs.
1034
1035	Returns True if all fnCallback calls returned True.
1036	Returns False if any returned False.
1037	Returns None immediately if fnCallback returned None.
1038	"""
1039	fRc = True;
1040	for oTestVm in self.aoTestVms:
1041	if not oTestVm.fSkip:
1042	fRc2 = fnCallback(oTestVm);
1043	if fRc2 is None:
1044	return fRc2;
1045	fRc = fRc and fRc2;
1046	return fRc;
1047
1048
1049
1050	class TestVmManager(object):
1051	"""
1052	Test VM manager.
1053	"""
1054
1055	## @name VM grouping flags
1056	## @{
1057	kfGrpSmoke = g_kfGrpSmoke;
1058	kfGrpStandard = g_kfGrpStandard;
1059	kfGrpStdSmoke = g_kfGrpStdSmoke;
1060	kfGrpWithGAs = g_kfGrpWithGAs;
1061	kfGrpNoTxs = g_kfGrpNoTxs;
1062	kfGrpAncient = g_kfGrpAncient;
1063	kfGrpExotic = g_kfGrpExotic;
1064	## @}
1065
1066	kaTestVMs = (
1067	# Linux
1068	TestVm('tst-ubuntu-15_10-64-efi', kfGrpStdSmoke, sHd = '4.2/efi/ubuntu-15_10-efi-amd64.vdi',
1069	sKind = 'Ubuntu_64', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi',
1070	asParavirtModesSup = [g_ksParavirtProviderKVM,]),
1071	TestVm('tst-rhel5', kfGrpSmoke, sHd = '3.0/tcp/rhel5.vdi',
1072	sKind = 'RedHat', acCpusSup = range(1, 33), fIoApic = True, sNic0AttachType = 'nat'),
1073	TestVm('tst-arch', kfGrpStandard, sHd = '4.2/usb/tst-arch.vdi',
1074	sKind = 'ArchLinux_64', acCpusSup = range(1, 33), fIoApic = True, sNic0AttachType = 'nat'),
1075	# disabled 2019-03-08 klaus - fails all over the place and pollutes the test results
1076	#TestVm('tst-ubuntu-1804-64', kfGrpStdSmoke, sHd = '4.2/ubuntu-1804/t-ubuntu-1804-64.vdi',
1077	# sKind = 'Ubuntu_64', acCpusSup = range(1, 33), fIoApic = True),
1078	TestVm('tst-ol76-64', kfGrpStdSmoke, sHd = '4.2/ol76/t-ol76-64.vdi',
1079	sKind = 'Oracle_64', acCpusSup = range(1, 33), fIoApic = True),
1080
1081	# Solaris
1082	TestVm('tst-sol10', kfGrpSmoke, sHd = '3.0/tcp/solaris10.vdi',
1083	sKind = 'Solaris', acCpusSup = range(1, 33), fPae = True, sNic0AttachType = 'bridged'),
1084	TestVm('tst-sol10-64', kfGrpSmoke, sHd = '3.0/tcp/solaris10.vdi',
1085	sKind = 'Solaris_64', acCpusSup = range(1, 33), sNic0AttachType = 'bridged'),
1086	TestVm('tst-sol11u1', kfGrpSmoke, sHd = '4.2/nat/sol11u1/t-sol11u1.vdi',
1087	sKind = 'Solaris11_64', acCpusSup = range(1, 33), sNic0AttachType = 'nat', fIoApic = True,
1088	sHddControllerType = 'SATA Controller'),
1089	#TestVm('tst-sol11u1-ich9', kfGrpSmoke, sHd = '4.2/nat/sol11u1/t-sol11u1.vdi',
1090	# sKind = 'Solaris11_64', acCpusSup = range(1, 33), sNic0AttachType = 'nat', fIoApic = True,
1091	# sHddControllerType = 'SATA Controller', sChipsetType = 'ich9'),
1092
1093	# NT 3.x
1094	TestVm('tst-nt310', kfGrpAncient, sHd = '5.2/great-old-ones/t-nt310/t-nt310.vdi',
1095	sKind = 'WindowsNT3x', acCpusSup = [1], sHddControllerType = 'BusLogic SCSI Controller',
1096	sDvdControllerType = 'BusLogic SCSI Controller'),
1097	TestVm('tst-nt350', kfGrpAncient, sHd = '5.2/great-old-ones/t-nt350/t-nt350.vdi',
1098	sKind = 'WindowsNT3x', acCpusSup = [1], sHddControllerType = 'BusLogic SCSI Controller',
1099	sDvdControllerType = 'BusLogic SCSI Controller'),
1100	TestVm('tst-nt351', kfGrpAncient, sHd = '5.2/great-old-ones/t-nt350/t-nt351.vdi',
1101	sKind = 'WindowsNT3x', acCpusSup = [1], sHddControllerType = 'BusLogic SCSI Controller',
1102	sDvdControllerType = 'BusLogic SCSI Controller'),
1103
1104	# NT 4
1105	TestVm('tst-nt4sp1', kfGrpStdSmoke, sHd = '4.2/nat/nt4sp1/t-nt4sp1.vdi',
1106	sKind = 'WindowsNT4', acCpusSup = [1], sNic0AttachType = 'nat'),
1107
1108	TestVm('tst-nt4sp6', kfGrpStdSmoke, sHd = '4.2/nt4sp6/t-nt4sp6.vdi',
1109	sKind = 'WindowsNT4', acCpusSup = range(1, 33)),
1110
1111	# W2K
1112	TestVm('tst-2ksp4', kfGrpStdSmoke, sHd = '4.2/win2ksp4/t-win2ksp4.vdi',
1113	sKind = 'Windows2000', acCpusSup = range(1, 33)),
1114
1115	# XP
1116	TestVm('tst-xppro', kfGrpStdSmoke, sHd = '4.2/nat/xppro/t-xppro.vdi',
1117	sKind = 'WindowsXP', acCpusSup = range(1, 33), sNic0AttachType = 'nat'),
1118	TestVm('tst-xpsp2', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxpsp2.vdi',
1119	sKind = 'WindowsXP', acCpusSup = range(1, 33), fIoApic = True),
1120	TestVm('tst-xpsp2-halaacpi', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxp-halaacpi.vdi',
1121	sKind = 'WindowsXP', acCpusSup = range(1, 33), fIoApic = True),
1122	TestVm('tst-xpsp2-halacpi', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxp-halacpi.vdi',
1123	sKind = 'WindowsXP', acCpusSup = range(1, 33), fIoApic = True),
1124	TestVm('tst-xpsp2-halapic', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxp-halapic.vdi',
1125	sKind = 'WindowsXP', acCpusSup = range(1, 33), fIoApic = True),
1126	TestVm('tst-xpsp2-halmacpi', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxp-halmacpi.vdi',
1127	sKind = 'WindowsXP', acCpusSup = range(2, 33), fIoApic = True),
1128	TestVm('tst-xpsp2-halmps', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxp-halmps.vdi',
1129	sKind = 'WindowsXP', acCpusSup = range(2, 33), fIoApic = True),
1130
1131	# W2K3
1132	TestVm('tst-win2k3ent', kfGrpSmoke, sHd = '3.0/tcp/win2k3ent-acpi.vdi',
1133	sKind = 'Windows2003', acCpusSup = range(1, 33), fPae = True, sNic0AttachType = 'bridged'),
1134
1135	# W7
1136	TestVm('tst-win7', kfGrpStdSmoke, sHd = '4.2/win7-32/t-win7.vdi',
1137	sKind = 'Windows7', acCpusSup = range(1, 33), fIoApic = True),
1138
1139	# W8
1140	TestVm('tst-win8-64', kfGrpStdSmoke, sHd = '4.2/win8-64/t-win8-64.vdi',
1141	sKind = 'Windows8_64', acCpusSup = range(1, 33), fIoApic = True),
1142	#TestVm('tst-win8-64-ich9', kfGrpStdSmoke, sHd = '4.2/win8-64/t-win8-64.vdi',
1143	# sKind = 'Windows8_64', acCpusSup = range(1, 33), fIoApic = True, sChipsetType = 'ich9'),
1144
1145	# W10
1146	TestVm('tst-win10-efi', kfGrpStdSmoke, sHd = '4.2/efi/win10-efi-x86.vdi',
1147	sKind = 'Windows10', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi'),
1148	TestVm('tst-win10-64-efi', kfGrpStdSmoke, sHd = '4.2/efi/win10-efi-amd64.vdi',
1149	sKind = 'Windows10_64', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi'),
1150	#TestVm('tst-win10-64-efi-ich9', kfGrpStdSmoke, sHd = '4.2/efi/win10-efi-amd64.vdi',
1151	# sKind = 'Windows10_64', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi', sChipsetType = 'ich9'),
1152
1153	# Nested hardware-virtualization
1154	TestVm('tst-nsthwvirt-ubuntu-64', kfGrpStdSmoke, sHd = '5.3/nat/nsthwvirt-ubuntu64/t-nsthwvirt-ubuntu64.vdi',
1155	sKind = 'Ubuntu_64', acCpusSup = range(1, 2), asVirtModesSup = ['hwvirt-np',], fIoApic = True, fNstHwVirt = True,
1156	sNic0AttachType = 'nat'),
1157
1158	# DOS and Old Windows.
1159	AncientTestVm('tst-dos20', sKind = 'DOS',
1160	sHd = '5.2/great-old-ones/t-dos20/t-dos20.vdi'),
1161	AncientTestVm('tst-dos401-win30me', sKind = 'DOS',
1162	sHd = '5.2/great-old-ones/t-dos401-win30me/t-dos401-win30me.vdi', cMBRamMax = 4),
1163	AncientTestVm('tst-dos401-emm386-win30me', sKind = 'DOS',
1164	sHd = '5.2/great-old-ones/t-dos401-emm386-win30me/t-dos401-emm386-win30me.vdi', cMBRamMax = 4),
1165	AncientTestVm('tst-dos50-win31', sKind = 'DOS',
1166	sHd = '5.2/great-old-ones/t-dos50-win31/t-dos50-win31.vdi'),
1167	AncientTestVm('tst-dos50-emm386-win31', sKind = 'DOS',
1168	sHd = '5.2/great-old-ones/t-dos50-emm386-win31/t-dos50-emm386-win31.vdi'),
1169	AncientTestVm('tst-dos622', sKind = 'DOS',
1170	sHd = '5.2/great-old-ones/t-dos622/t-dos622.vdi'),
1171	AncientTestVm('tst-dos622-emm386', sKind = 'DOS',
1172	sHd = '5.2/great-old-ones/t-dos622-emm386/t-dos622-emm386.vdi'),
1173	AncientTestVm('tst-dos71', sKind = 'DOS',
1174	sHd = '5.2/great-old-ones/t-dos71/t-dos71.vdi'),
1175
1176	#AncientTestVm('tst-dos5-win311a', sKind = 'DOS', sHd = '5.2/great-old-ones/t-dos5-win311a/t-dos5-win311a.vdi'),
1177	);
1178
1179
1180	def __init__(self, sResourcePath):
1181	self.sResourcePath = sResourcePath;
1182
1183	def selectSet(self, fGrouping, sTxsTransport = None, fCheckResources = True):
1184	"""
1185	Returns a VM set with the selected VMs.
1186	"""
1187	oSet = TestVmSet(oTestVmManager = self);
1188	for oVm in self.kaTestVMs:
1189	if oVm.fGrouping & fGrouping:
1190	if sTxsTransport is None or oVm.sNic0AttachType is None or sTxsTransport == oVm.sNic0AttachType:
1191	if not fCheckResources or not oVm.getMissingResources(self.sResourcePath):
1192	oCopyVm = copy.deepcopy(oVm);
1193	oCopyVm.oSet = oSet;
1194	oSet.aoTestVms.append(oCopyVm);
1195	return oSet;
1196
1197	def getStandardVmSet(self, sTxsTransport):
1198	"""
1199	Gets the set of standard test VMs.
1200
1201	This is supposed to do something seriously clever, like searching the
1202	testrsrc tree for usable VMs, but for the moment it's all hard coded. :-)
1203	"""
1204	return self.selectSet(self.kfGrpStandard, sTxsTransport)
1205
1206	def getSmokeVmSet(self, sTxsTransport = None):
1207	"""Gets a representative set of VMs for smoke testing. """
1208	return self.selectSet(self.kfGrpSmoke, sTxsTransport);
1209
1210	def shutUpPyLint(self):
1211	""" Shut up already! """
1212	return self.sResourcePath;
1213

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/ValidationKit/testdriver/vboxtestvms.py@ 78460

Download in other formats: