summaryrefslogtreecommitdiffstats
path: root/src/VBox/ValidationKit/testdriver/vboxtestvms.py
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-11 08:17:27 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-11 08:17:27 +0000
commitf215e02bf85f68d3a6106c2a1f4f7f063f819064 (patch)
tree6bb5b92c046312c4e95ac2620b10ddf482d3fa8b /src/VBox/ValidationKit/testdriver/vboxtestvms.py
parentInitial commit. (diff)
downloadvirtualbox-f215e02bf85f68d3a6106c2a1f4f7f063f819064.tar.xz
virtualbox-f215e02bf85f68d3a6106c2a1f4f7f063f819064.zip
Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/VBox/ValidationKit/testdriver/vboxtestvms.py')
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/vboxtestvms.py2105
1 files changed, 2105 insertions, 0 deletions
diff --git a/src/VBox/ValidationKit/testdriver/vboxtestvms.py b/src/VBox/ValidationKit/testdriver/vboxtestvms.py
new file mode 100755
index 00000000..fbadf7b5
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/vboxtestvms.py
@@ -0,0 +1,2105 @@
+# -*- coding: utf-8 -*-
+# $Id: vboxtestvms.py $
+
+"""
+VirtualBox Test VMs
+"""
+
+__copyright__ = \
+"""
+Copyright (C) 2010-2023 Oracle and/or its affiliates.
+
+This file is part of VirtualBox base platform packages, as
+available from https://www.virtualbox.org.
+
+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, in version 3 of the
+License.
+
+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, see <https://www.gnu.org/licenses>.
+
+The contents of this file may alternatively be used under the terms
+of the Common Development and Distribution License Version 1.0
+(CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+in the VirtualBox distribution, in which case the provisions of the
+CDDL are applicable instead of those of the GPL.
+
+You may elect to license modified versions of this file under the
+terms and conditions of either the GPL or the CDDL or both.
+
+SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+"""
+__version__ = "$Revision: 155244 $"
+
+# Standard Python imports.
+import copy;
+import os;
+import re;
+import random;
+import socket;
+import string;
+import uuid;
+
+# Validation Kit imports.
+from common import pathutils;
+from common import utils;
+from testdriver import base;
+from testdriver import reporter;
+from testdriver import vboxcon;
+
+
+# All virtualization modes.
+g_asVirtModes = ['hwvirt', 'hwvirt-np', 'raw',];
+# All virtualization modes except for raw-mode.
+g_asVirtModesNoRaw = ['hwvirt', 'hwvirt-np',];
+# Dictionary mapping the virtualization mode mnemonics to a little less cryptic
+# strings used in test descriptions.
+g_dsVirtModeDescs = {
+ 'raw' : 'Raw-mode',
+ 'hwvirt' : 'HwVirt',
+ 'hwvirt-np' : 'NestedPaging'
+};
+
+## @name VM grouping flags
+## @{
+g_kfGrpSmoke = 0x0001; ##< Smoke test VM.
+g_kfGrpStandard = 0x0002; ##< Standard test VM.
+g_kfGrpStdSmoke = g_kfGrpSmoke | g_kfGrpStandard; ##< shorthand.
+g_kfGrpWithGAs = 0x0004; ##< The VM has guest additions installed.
+g_kfGrpNoTxs = 0x0008; ##< The VM lacks test execution service.
+g_kfGrpAncient = 0x1000; ##< Ancient OS.
+g_kfGrpExotic = 0x2000; ##< Exotic OS.
+## @}
+
+
+## @name Flags.
+## @{
+g_k32 = 32; # pylint: disable=invalid-name
+g_k64 = 64; # pylint: disable=invalid-name
+g_k32_64 = 96; # pylint: disable=invalid-name
+g_kiArchMask = 96;
+g_kiNoRaw = 128; ##< No raw mode.
+## @}
+
+# Array indexes.
+g_iGuestOsType = 0;
+g_iKind = 1;
+g_iFlags = 2;
+g_iMinCpu = 3;
+g_iMaxCpu = 4;
+g_iRegEx = 5;
+
+# Table translating from VM name core to a more detailed guest info.
+# pylint: disable=line-too-long
+## @todo what's the difference between the first two columns again?
+g_aaNameToDetails = \
+[
+ [ 'WindowsNT3x', 'WindowsNT3x', g_k32, 1, 32, ['nt3', 'nt3[0-9]*']], # max cpus??
+ [ 'WindowsNT4', 'WindowsNT4', g_k32, 1, 32, ['nt4', 'nt4sp[0-9]']], # max cpus??
+ [ 'Windows2000', 'Windows2000', g_k32, 1, 32, ['w2k', 'w2ksp[0-9]', 'win2k', 'win2ksp[0-9]']], # max cpus??
+ [ 'WindowsXP', 'WindowsXP', g_k32, 1, 32, ['xp', 'xpsp[0-9]']],
+ [ 'WindowsXP_64', 'WindowsXP_64', g_k64, 1, 32, ['xp64', 'xp64sp[0-9]']],
+ [ 'Windows2003', 'Windows2003', g_k32, 1, 32, ['w2k3', 'w2k3sp[0-9]', 'win2k3', 'win2k3sp[0-9]']],
+ [ 'WindowsVista', 'WindowsVista', g_k32, 1, 32, ['vista', 'vistasp[0-9]']],
+ [ 'WindowsVista_64','WindowsVista_64', g_k64, 1, 64, ['vista-64', 'vistasp[0-9]-64',]], # max cpus/cores??
+ [ 'Windows2008', 'Windows2008', g_k32, 1, 64, ['w2k8', 'w2k8sp[0-9]', 'win2k8', 'win2k8sp[0-9]']], # max cpus/cores??
+ [ 'Windows2008_64', 'Windows2008_64', g_k64, 1, 64, ['w2k8r2', 'w2k8r2sp[0-9]', 'win2k8r2', 'win2k8r2sp[0-9]']], # max cpus/cores??
+ [ 'Windows7', 'Windows7', g_k32, 1, 32, ['w7', 'w7sp[0-9]', 'win7',]], # max cpus/cores??
+ [ 'Windows7_64', 'Windows7_64', g_k64, 1, 64, ['w7-64', 'w7sp[0-9]-64', 'win7-64',]], # max cpus/cores??
+ [ 'Windows2012', 'Windows2012', g_k64, 1, 64, ['w2k12', 'w2k12sp[0-9]', 'win2k12', 'win2k12sp[0-9]',]], # max cpus/cores??
+ [ 'Windows8', 'Windows8', g_k32 | g_kiNoRaw, 1, 32, ['w8', 'w8sp[0-9]', 'win8',]], # max cpus/cores??
+ [ 'Windows8_64', 'Windows8_64', g_k64, 1, 64, ['w8-64', 'w8sp[0-9]-64', 'win8-64',]], # max cpus/cores??
+ [ 'Windows81', 'Windows81', g_k32 | g_kiNoRaw, 1, 32, ['w81', 'w81sp[0-9]', 'win81',]], # max cpus/cores??
+ [ 'Windows81_64', 'Windows81_64', g_k64, 1, 64, ['w81-64', 'w81sp[0-9]-64', 'win81-64',]], # max cpus/cores??
+ [ 'Windows10', 'Windows10', g_k32 | g_kiNoRaw, 1, 32, ['w10', 'w10sp[0-9]', 'win10',]], # max cpus/cores??
+ [ 'Windows10_64', 'Windows10_64', g_k64, 1, 64, ['w10-64', 'w10sp[0-9]-64', 'win10-64',]], # max cpus/cores??
+ [ 'Windows2016', 'Windows2016', g_k64, 1, 64, ['w2k16', 'w2k16sp[0-9]', 'win2k16', 'win2k16sp[0-9]',]], # max cpus/cores??
+ [ 'Windows2019', 'Windows2019', g_k64, 1, 64, ['w2k19', 'w2k19sp[0-9]', 'win2k19', 'win2k19sp[0-9]',]], # max cpus/cores??
+ [ 'Windows2022', 'Windows2022', g_k64, 1, 64, ['w2k22', 'w2k22sp[0-9]', 'win2k22', 'win2k22sp[0-9]',]], # max cpus/cores??
+ [ 'Windows11', 'Windows11', g_k64, 1, 64, ['w11', 'w11-64', 'w11sp[0-9]-64', 'win11', 'win11-64',]], # max cpus/cores??
+ [ 'Linux', 'Debian', g_k32, 1, 256, ['deb[0-9]*', 'debian[0-9]*', ]],
+ [ 'Linux_64', 'Debian_64', g_k64, 1, 256, ['deb[0-9]*-64', 'debian[0-9]*-64', ]],
+ [ 'Linux', 'RedHat', g_k32, 1, 256, ['rhel', 'rhel[0-9]', 'rhel[0-9]u[0-9]']],
+ [ 'Linux', 'Fedora', g_k32, 1, 256, ['fedora', 'fedora[0-9]*', ]],
+ [ 'Linux_64', 'Fedora_64', g_k64, 1, 256, ['fedora-64', 'fedora[0-9]*-64', ]],
+ [ 'Linux', 'Oracle', g_k32, 1, 256, ['ols[0-9]*', 'oel[0-9]*', ]],
+ [ 'Linux_64', 'Oracle_64', g_k64, 1, 256, ['ols[0-9]*-64', 'oel[0-9]*-64', ]],
+ [ 'Linux', 'OpenSUSE', g_k32, 1, 256, ['opensuse[0-9]*', 'suse[0-9]*', ]],
+ [ 'Linux_64', 'OpenSUSE_64', g_k64, 1, 256, ['opensuse[0-9]*-64', 'suse[0-9]*-64', ]],
+ [ 'Linux', 'Ubuntu', g_k32, 1, 256, ['ubuntu[0-9]*', ]],
+ [ 'Linux_64', 'Ubuntu_64', g_k64, 1, 256, ['ubuntu[0-9]*-64', ]],
+ [ 'Linux', 'ArchLinux', g_k32, 1, 256, ['arch[0-9]*', ]],
+ [ 'Linux_64', 'ArchLinux_64', g_k64, 1, 256, ['arch[0-9]*-64', ]],
+ [ 'OS2Warp45', 'OS2Warp45', g_k32 | g_kiNoRaw, 1, 1, ['os2.*', 'acp.*','mcp.*', ]], # smp does busy spinning and unattended installer only does UNI at the momen.
+ [ 'Solaris', 'Solaris', g_k32, 1, 256, ['sol10', 'sol10u[0-9]']],
+ [ 'Solaris_64', 'Solaris_64', g_k64, 1, 256, ['sol10-64', 'sol10u-64[0-9]']],
+ [ 'Solaris_64', 'Solaris11_64', g_k64, 1, 256, ['sol11u1']],
+ [ 'BSD', 'FreeBSD_64', g_k32_64, 1, 1, ['bs-.*']], # boot sectors, wanted 64-bit type.
+ [ 'DOS', 'DOS', g_k32, 1, 1, ['bs-.*']],
+];
+
+
+## @name Guest OS type string constants.
+## @{
+g_ksGuestOsTypeDarwin = 'darwin';
+g_ksGuestOsTypeDOS = 'dos';
+g_ksGuestOsTypeFreeBSD = 'freebsd';
+g_ksGuestOsTypeLinux = 'linux';
+g_ksGuestOsTypeOS2 = 'os2';
+g_ksGuestOsTypeSolaris = 'solaris';
+g_ksGuestOsTypeWindows = 'windows';
+## @}
+
+## @name String constants for paravirtualization providers.
+## @{
+g_ksParavirtProviderNone = 'none';
+g_ksParavirtProviderDefault = 'default';
+g_ksParavirtProviderLegacy = 'legacy';
+g_ksParavirtProviderMinimal = 'minimal';
+g_ksParavirtProviderHyperV = 'hyperv';
+g_ksParavirtProviderKVM = 'kvm';
+## @}
+
+## Valid paravirtualization providers.
+g_kasParavirtProviders = ( g_ksParavirtProviderNone, g_ksParavirtProviderDefault, g_ksParavirtProviderLegacy,
+ g_ksParavirtProviderMinimal, g_ksParavirtProviderHyperV, g_ksParavirtProviderKVM );
+
+# Mapping for support of paravirtualisation providers per guest OS.
+#g_kdaParavirtProvidersSupported = {
+# g_ksGuestOsTypeDarwin : ( g_ksParavirtProviderMinimal, ),
+# g_ksGuestOsTypeFreeBSD : ( g_ksParavirtProviderNone, g_ksParavirtProviderMinimal, ),
+# g_ksGuestOsTypeLinux : ( g_ksParavirtProviderNone, g_ksParavirtProviderMinimal, g_ksParavirtProviderHyperV, g_ksParavirtProviderKVM),
+# g_ksGuestOsTypeOS2 : ( g_ksParavirtProviderNone, ),
+# g_ksGuestOsTypeSolaris : ( g_ksParavirtProviderNone, ),
+# g_ksGuestOsTypeWindows : ( g_ksParavirtProviderNone, g_ksParavirtProviderMinimal, g_ksParavirtProviderHyperV, )
+#}
+# Temporary tweak:
+# since for the most guests g_ksParavirtProviderNone is almost the same as g_ksParavirtProviderMinimal,
+# g_ksParavirtProviderMinimal is removed from the list in order to get maximum number of unique choices
+# during independent test runs when paravirt provider is taken randomly.
+g_kdaParavirtProvidersSupported = {
+ g_ksGuestOsTypeDarwin : ( g_ksParavirtProviderMinimal, ),
+ g_ksGuestOsTypeDOS : ( g_ksParavirtProviderNone, ),
+ g_ksGuestOsTypeFreeBSD : ( g_ksParavirtProviderNone, ),
+ g_ksGuestOsTypeLinux : ( g_ksParavirtProviderNone, g_ksParavirtProviderHyperV, g_ksParavirtProviderKVM),
+ g_ksGuestOsTypeOS2 : ( g_ksParavirtProviderNone, ),
+ g_ksGuestOsTypeSolaris : ( g_ksParavirtProviderNone, ),
+ g_ksGuestOsTypeWindows : ( g_ksParavirtProviderNone, g_ksParavirtProviderHyperV, )
+}
+
+
+# pylint: enable=line-too-long
+
+def _intersects(asSet1, asSet2):
+ """
+ Checks if any of the strings in set 1 matches any of the regular
+ expressions in set 2.
+ """
+ for sStr1 in asSet1:
+ for sRx2 in asSet2:
+ if re.match(sStr1, sRx2 + '$'):
+ return True;
+ return False;
+
+
+
+class BaseTestVm(object):
+ """
+ Base class for Test VMs.
+ """
+
+ def __init__(self, # pylint: disable=too-many-arguments
+ sVmName, # type: str
+ fGrouping = 0, # type: int
+ oSet = None, # type: TestVmSet
+ sKind = None, # type: str
+ acCpusSup = None, # type: List[int]
+ asVirtModesSup = None, # type: List[str]
+ asParavirtModesSup = None, # type: List[str]
+ fRandomPvPModeCrap = False, # type: bool
+ fVmmDevTestingPart = None, # type: bool
+ fVmmDevTestingMmio = False, # type: bool
+ iGroup = 1, # type: int
+ ):
+ self.oSet = oSet # type: TestVmSet
+ self.sVmName = sVmName;
+ self.iGroup = iGroup; # Startup group (for MAC address uniqueness and non-NAT networking).
+ self.fGrouping = fGrouping;
+ self.sKind = sKind; # API Guest OS type.
+ self.acCpusSup = acCpusSup;
+ self.asVirtModesSup = asVirtModesSup;
+ self.asParavirtModesSup = asParavirtModesSup;
+ self.asParavirtModesSupOrg = asParavirtModesSup; # HACK ALERT! Trick to make the 'effing random mess not get in the
+ # way of actively selecting virtualization modes.
+
+ self.fSkip = False; # All VMs are included in the configured set by default.
+ self.fSnapshotRestoreCurrent = False; # Whether to restore execution on the current snapshot.
+
+ # VMMDev and serial (TXS++) settings:
+ self.fVmmDevTestingPart = fVmmDevTestingPart;
+ self.fVmmDevTestingMmio = fVmmDevTestingMmio;
+ self.fCom1RawFile = False;
+
+ # Cached stuff (use getters):
+ self.__sCom1RawFile = None; # Set by createVmInner and getReconfiguredVm if fCom1RawFile is set.
+ self.__tHddCtrlPortDev = (None, None, None); # The HDD controller, port and device.
+ self.__tDvdCtrlPortDev = (None, None, None); # The DVD controller, port and device.
+ self.__cbHdd = -1; # The recommended HDD size.
+
+ # Derived stuff:
+ self.aInfo = None;
+ self.sGuestOsType = None; # ksGuestOsTypeXxxx value, API GuestOS Type is in the sKind member.
+ ## @todo rename sGuestOsType
+ self._guessStuff(fRandomPvPModeCrap);
+
+ def _mkCanonicalGuestOSType(self, sType):
+ """
+ Convert guest OS type into constant representation.
+ Raise exception if specified @param sType is unknown.
+ """
+ if sType.lower().startswith('darwin'):
+ return g_ksGuestOsTypeDarwin
+ if sType.lower().startswith('bsd'):
+ return g_ksGuestOsTypeFreeBSD
+ if sType.lower().startswith('dos'):
+ return g_ksGuestOsTypeDOS
+ if sType.lower().startswith('linux'):
+ return g_ksGuestOsTypeLinux
+ if sType.lower().startswith('os2'):
+ return g_ksGuestOsTypeOS2
+ if sType.lower().startswith('solaris'):
+ return g_ksGuestOsTypeSolaris
+ if sType.lower().startswith('windows'):
+ return g_ksGuestOsTypeWindows
+ raise base.GenError(sWhat="unknown guest OS kind: %s" % str(sType))
+
+ def _guessStuff(self, fRandomPvPModeCrap):
+ """
+ Used by the constructor to guess stuff.
+ """
+
+ sNm = self.sVmName.lower().strip();
+ asSplit = sNm.replace('-', ' ').split(' ');
+
+ if self.sKind is None:
+ # From name.
+ for aInfo in g_aaNameToDetails:
+ if _intersects(asSplit, aInfo[g_iRegEx]):
+ self.aInfo = aInfo;
+ self.sGuestOsType = self._mkCanonicalGuestOSType(aInfo[g_iGuestOsType])
+ self.sKind = aInfo[g_iKind];
+ break;
+ if self.sKind is None:
+ reporter.fatal('The OS of test VM "%s" cannot be guessed' % (self.sVmName,));
+
+ # Check for 64-bit, if required and supported.
+ if (self.aInfo[g_iFlags] & g_kiArchMask) == g_k32_64 and _intersects(asSplit, ['64', 'amd64']):
+ self.sKind = self.sKind + '_64';
+ else:
+ # Lookup the kind.
+ for aInfo in g_aaNameToDetails:
+ if self.sKind == aInfo[g_iKind]:
+ self.aInfo = aInfo;
+ break;
+ if self.aInfo is None:
+ reporter.fatal('The OS of test VM "%s" with sKind="%s" cannot be guessed' % (self.sVmName, self.sKind));
+
+ # Translate sKind into sGuest OS Type.
+ if self.sGuestOsType is None:
+ if self.aInfo is not None:
+ self.sGuestOsType = self._mkCanonicalGuestOSType(self.aInfo[g_iGuestOsType])
+ elif self.sKind.find("Windows") >= 0:
+ self.sGuestOsType = g_ksGuestOsTypeWindows
+ elif self.sKind.find("Linux") >= 0:
+ self.sGuestOsType = g_ksGuestOsTypeLinux;
+ elif self.sKind.find("Solaris") >= 0:
+ self.sGuestOsType = g_ksGuestOsTypeSolaris;
+ elif self.sKind.find("DOS") >= 0:
+ self.sGuestOsType = g_ksGuestOsTypeDOS;
+ else:
+ reporter.fatal('The OS of test VM "%s", sKind="%s" cannot be guessed' % (self.sVmName, self.sKind));
+
+ # Restrict modes and such depending on the OS.
+ if self.asVirtModesSup is None:
+ self.asVirtModesSup = list(g_asVirtModes);
+ if self.sGuestOsType in (g_ksGuestOsTypeOS2, g_ksGuestOsTypeDarwin) \
+ or self.sKind.find('_64') > 0 \
+ or (self.aInfo is not None and (self.aInfo[g_iFlags] & g_kiNoRaw)):
+ self.asVirtModesSup = [sVirtMode for sVirtMode in self.asVirtModesSup if sVirtMode != 'raw'];
+ # TEMPORARY HACK - START
+ sHostName = os.environ.get("COMPUTERNAME", None);
+ if sHostName: sHostName = sHostName.lower();
+ else: sHostName = socket.getfqdn(); # Horribly slow on windows without IPv6 DNS/whatever.
+ if sHostName.startswith('testboxpile1'):
+ self.asVirtModesSup = [sVirtMode for sVirtMode in self.asVirtModesSup if sVirtMode != 'raw'];
+ # TEMPORARY HACK - END
+
+ # Restrict the CPU count depending on the OS and/or percieved SMP readiness.
+ if self.acCpusSup is None:
+ if _intersects(asSplit, ['uni']):
+ self.acCpusSup = [1];
+ elif self.aInfo is not None:
+ self.acCpusSup = list(range(self.aInfo[g_iMinCpu], self.aInfo[g_iMaxCpu] + 1));
+ else:
+ self.acCpusSup = [1];
+
+ # Figure relevant PV modes based on the OS.
+ if self.asParavirtModesSup is None:
+ self.asParavirtModesSup = g_kdaParavirtProvidersSupported[self.sGuestOsType];
+ ## @todo Remove this hack as soon as we've got around to explictly configure test variations
+ ## on the server side. Client side random is interesting but not the best option.
+ self.asParavirtModesSupOrg = self.asParavirtModesSup;
+ if fRandomPvPModeCrap:
+ random.seed();
+ self.asParavirtModesSup = (random.choice(self.asParavirtModesSup),);
+
+ return True;
+
+ def _generateRawPortFilename(self, oTestDrv, sInfix, sSuffix):
+ """ Generates a raw port filename. """
+ random.seed();
+ sRandom = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(10));
+ return os.path.join(oTestDrv.sScratchPath, self.sVmName + sInfix + sRandom + sSuffix);
+
+ def _createVmPre(self, oTestDrv, eNic0AttachType, sDvdImage):
+ """
+ Prepares for creating the VM.
+
+ Returns True / False.
+ """
+ _ = eNic0AttachType; _ = sDvdImage;
+ if self.fCom1RawFile:
+ self.__sCom1RawFile = self._generateRawPortFilename(oTestDrv, '-com1-', '.out');
+ return True;
+
+ def _createVmDoIt(self, oTestDrv, eNic0AttachType, sDvdImage):
+ """
+ Creates the VM.
+
+ The default implementation creates a VM with defaults, no disks created or attached.
+
+ Returns Wrapped VM object on success, None on failure.
+ """
+ return oTestDrv.createTestVmWithDefaults(self.sVmName,
+ iGroup = self.iGroup,
+ sKind = self.sKind,
+ eNic0AttachType = eNic0AttachType,
+ sDvdImage = sDvdImage,
+ fVmmDevTestingPart = self.fVmmDevTestingPart,
+ fVmmDevTestingMmio = self.fVmmDevTestingMmio,
+ sCom1RawFile = self.__sCom1RawFile if self.fCom1RawFile else None
+ );
+
+ def _createVmPost(self, oTestDrv, oVM, eNic0AttachType, sDvdImage): # type: (base.testdriver, Any, int, str) -> Any
+ """
+ Returns same oVM on success, None on failure (createVm cleans up).
+ """
+ _ = oTestDrv; _ = eNic0AttachType; _ = sDvdImage;
+ return oVM;
+
+ def _skipVmTest(self, oTestDrv, oVM):
+ """
+ Called by getReconfiguredVm to figure out whether to skip the VM or not.
+
+ Returns True if the VM should be skipped, False otherwise.
+ """
+ _ = oVM;
+ fHostSupports64bit = oTestDrv.hasHostLongMode();
+ if self.is64bitRequired() and not fHostSupports64bit:
+ reporter.log('Skipping 64-bit VM on non-64 capable host.');
+ elif self.isViaIncompatible() and oTestDrv.isHostCpuVia():
+ reporter.log('Skipping VIA incompatible VM.');
+ elif self.isShanghaiIncompatible() and oTestDrv.isHostCpuShanghai():
+ reporter.log('Skipping Shanghai (Zhaoxin) incompatible VM.');
+ elif self.isP4Incompatible() and oTestDrv.isHostCpuP4():
+ reporter.log('Skipping P4 incompatible VM.');
+ else:
+ return False;
+ return True;
+
+
+ def _childVmReconfig(self, oTestDrv, oVM, oSession):
+ """
+ Hook into getReconfiguredVm() for children.
+ """
+ _ = oTestDrv; _ = oVM; _ = oSession;
+ return True;
+
+ def _storageCtrlAndBusToName(self, oVBoxMgr, oVM, eCtrl, eBus):
+ """
+ Resolves the storage controller name given type and bus.
+
+ Returns String on success, None on failure w/ errors logged.
+ """
+ try:
+ aoControllers = oVBoxMgr.getArray(oVM, 'storageControllers');
+ except:
+ reporter.errorXcpt();
+ return None;
+ asSummary = [];
+ for oController in aoControllers:
+ try:
+ eCurCtrl = oController.controllerType;
+ eCurBus = oController.bus;
+ sName = oController.name;
+ except:
+ reporter.errorXcpt();
+ return None;
+ if eCurCtrl == eCtrl and eCurBus == eBus:
+ return sName;
+ asSummary.append('%s-%s-%s' % (eCurCtrl, eCurBus, sName,));
+ reporter.error('Unable to find controller of type %s and bus %s (searched: %s)' % (eCtrl, eBus, ', '.join(asSummary),));
+ return None;
+
+
+ #
+ # Public interface.
+ #
+
+ def getResourceSet(self):
+ """
+ Resturns a list of reosurces that the VM needs.
+ """
+ return [];
+
+ def getMissingResources(self, sResourcePath):
+ """
+ Returns a list of missing resources (paths, stuff) that the VM needs.
+ """
+ asRet = [];
+ asResources = self.getResourceSet();
+ for sPath in asResources:
+ if not os.path.isabs(sPath):
+ sPath = os.path.join(sResourcePath, sPath);
+ if not os.path.exists(sPath):
+ asRet.append(sPath);
+ return asRet;
+
+ def skipCreatingVm(self, oTestDrv):
+ """
+ Called before VM creation to determine whether the VM should be skipped
+ due to host incompatibility or something along those lines.
+
+ returns True if it should be skipped, False if not. Caller updates fSkip.
+
+ See also _skipVmTest().
+ """
+ _ = oTestDrv;
+ return False;
+
+
+ def createVm(self, oTestDrv, eNic0AttachType = None, sDvdImage = None):
+ """
+ Creates the VM with defaults and the few tweaks as per the arguments.
+
+ Returns same as vbox.TestDriver.createTestVM.
+ """
+ reporter.log2('');
+ reporter.log2('Creating %s...' % (self.sVmName,))
+ oVM = None;
+ fRc = self._createVmPre(oTestDrv, eNic0AttachType, sDvdImage);
+ if fRc is True:
+ oVM = self._createVmDoIt(oTestDrv, eNic0AttachType, sDvdImage);
+ if oVM:
+ oVM = self._createVmPost(oTestDrv, oVM, eNic0AttachType, sDvdImage);
+ return oVM;
+
+ def getReconfiguredVm(self, oTestDrv, cCpus, sVirtMode, sParavirtMode = None):
+ """
+ actionExecute worker that finds and reconfigure a test VM.
+
+ Returns (fRc, oVM) where fRc is True, None or False and oVM is a
+ VBox VM object that is only present when rc is True.
+ """
+
+ fRc = False;
+ oVM = oTestDrv.getVmByName(self.sVmName);
+ if oVM is not None:
+ if self.fSnapshotRestoreCurrent is True:
+ fRc = True;
+ else:
+ fHostSupports64bit = oTestDrv.hasHostLongMode();
+ if self._skipVmTest(oTestDrv, oVM):
+ fRc = None; # Skip the test.
+ else:
+ oSession = oTestDrv.openSession(oVM);
+ if oSession is not None:
+ fRc = oSession.enableVirtEx(sVirtMode != 'raw');
+ fRc = fRc and oSession.enableNestedPaging(sVirtMode == 'hwvirt-np');
+ fRc = fRc and oSession.setCpuCount(cCpus);
+ if cCpus > 1:
+ fRc = fRc and oSession.enableIoApic(True);
+
+ if sParavirtMode is not None and oSession.fpApiVer >= 5.0:
+ adParavirtProviders = {
+ g_ksParavirtProviderNone : vboxcon.ParavirtProvider_None,
+ g_ksParavirtProviderDefault: vboxcon.ParavirtProvider_Default,
+ g_ksParavirtProviderLegacy : vboxcon.ParavirtProvider_Legacy,
+ g_ksParavirtProviderMinimal: vboxcon.ParavirtProvider_Minimal,
+ g_ksParavirtProviderHyperV : vboxcon.ParavirtProvider_HyperV,
+ g_ksParavirtProviderKVM : vboxcon.ParavirtProvider_KVM,
+ };
+ fRc = fRc and oSession.setParavirtProvider(adParavirtProviders[sParavirtMode]);
+
+ fCfg64Bit = self.is64bitRequired() or (self.is64bit() and fHostSupports64bit and sVirtMode != 'raw');
+ fRc = fRc and oSession.enableLongMode(fCfg64Bit);
+ if fCfg64Bit: # This is to avoid GUI pedantic warnings in the GUI. Sigh.
+ oOsType = oSession.getOsType();
+ if oOsType is not None:
+ if oOsType.is64Bit and sVirtMode == 'raw':
+ assert(oOsType.id[-3:] == '_64');
+ fRc = fRc and oSession.setOsType(oOsType.id[:-3]);
+ elif not oOsType.is64Bit and sVirtMode != 'raw':
+ fRc = fRc and oSession.setOsType(oOsType.id + '_64');
+
+ # New serial raw file.
+ if fRc and self.fCom1RawFile:
+ self.__sCom1RawFile = self._generateRawPortFilename(oTestDrv, '-com1-', '.out');
+ utils.noxcptDeleteFile(self.__sCom1RawFile);
+ fRc = oSession.setupSerialToRawFile(0, self.__sCom1RawFile);
+
+ # Make life simpler for child classes.
+ if fRc:
+ fRc = self._childVmReconfig(oTestDrv, oVM, oSession);
+
+ fRc = fRc and oSession.saveSettings();
+ if not oSession.close():
+ fRc = False;
+ if fRc is True:
+ return (True, oVM);
+ return (fRc, None);
+
+ def getNonCanonicalGuestOsType(self):
+ """
+ Gets the non-canonical OS type (self.sGuestOsType is canonical).
+ """
+ return self.sKind; #self.aInfo[g_iGuestOsType];
+
+ def getGuestArch(self):
+ """ Same as util.getHostArch. """
+ return 'amd64' if self.sKind.find('_64') >= 0 else 'x86';
+
+ def getGuestOs(self):
+ """ Same as util.getHostOs. """
+ if self.isWindows(): return 'win';
+ if self.isOS2(): return 'os2';
+ if self.isLinux(): return 'linux';
+ reporter.error('getGuestOs does not what to return!');
+ raise Exception();
+
+ def getGuestOsDotArch(self):
+ """ Same as util.getHostOsDotArch. """
+ return self.getGuestOs() + '.' + self.getGuestArch();
+
+ def getGuestExeSuff(self):
+ """ The executable image suffix for the guest. """
+ if self.isWindows() or self.isOS2():
+ return '.exe';
+ return '';
+
+ def isWindows(self):
+ """ Checks if it's a Windows VM. """
+ return self.sGuestOsType == g_ksGuestOsTypeWindows;
+
+ def isOS2(self):
+ """ Checks if it's an OS/2 VM. """
+ return self.sGuestOsType == g_ksGuestOsTypeOS2;
+
+ def isLinux(self):
+ """ Checks if it's an Linux VM. """
+ return self.sGuestOsType == g_ksGuestOsTypeLinux;
+
+ def is64bit(self):
+ """ Checks if it's a 64-bit VM. """
+ return self.sKind.find('_64') >= 0;
+
+ def is64bitRequired(self):
+ """ Check if 64-bit is required or not. """
+ return (self.aInfo[g_iFlags] & g_k64) != 0;
+
+ def isLoggedOntoDesktop(self):
+ """ Checks if the test VM is logging onto a graphical desktop by default. """
+ if self.isWindows():
+ return True;
+ if self.isOS2():
+ return True;
+ if self.sVmName.find('-desktop'):
+ return True;
+ return False;
+
+ def isViaIncompatible(self):
+ """
+ Identifies VMs that doesn't work on VIA.
+
+ Returns True if NOT supported on VIA, False if it IS supported.
+ """
+ # Oracle linux doesn't like VIA in our experience
+ if self.aInfo[g_iKind] in ['Oracle', 'Oracle_64']:
+ return True;
+ # OS/2: "The system detected an internal processing error at location
+ # 0168:fff1da1f - 000e:ca1f. 0a8606fd
+ if self.isOS2():
+ return True;
+ # Windows NT4 before SP4 won't work because of cmpxchg8b not being
+ # detected, leading to a STOP 3e(80,0,0,0).
+ if self.aInfo[g_iKind] == 'WindowsNT4':
+ if self.sVmName.find('sp') < 0:
+ return True; # no service pack.
+ if self.sVmName.find('sp0') >= 0 \
+ or self.sVmName.find('sp1') >= 0 \
+ or self.sVmName.find('sp2') >= 0 \
+ or self.sVmName.find('sp3') >= 0:
+ return True;
+ # XP x64 on a physical VIA box hangs exactly like a VM.
+ if self.aInfo[g_iKind] in ['WindowsXP_64', 'Windows2003_64']:
+ return True;
+ # Vista 64 throws BSOD 0x5D (UNSUPPORTED_PROCESSOR)
+ if self.aInfo[g_iKind] in ['WindowsVista_64']:
+ return True;
+ # Solaris 11 hangs on VIA, tested on a physical box (testboxvqc)
+ if self.aInfo[g_iKind] in ['Solaris11_64']:
+ return True;
+ return False;
+
+ def isShanghaiIncompatible(self):
+ """
+ Identifies VMs that doesn't work on Shanghai.
+
+ Returns True if NOT supported on Shanghai, False if it IS supported.
+ """
+ # For now treat it just like VIA, to be adjusted later
+ return self.isViaIncompatible()
+
+ def isP4Incompatible(self):
+ """
+ Identifies VMs that doesn't work on Pentium 4 / Pentium D.
+
+ Returns True if NOT supported on P4, False if it IS supported.
+ """
+ # Stupid 1 kHz timer. Too much for antique CPUs.
+ if self.sVmName.find('rhel5') >= 0:
+ return True;
+ # Due to the boot animation the VM takes forever to boot.
+ if self.aInfo[g_iKind] == 'Windows2000':
+ return True;
+ return False;
+
+ def isHostCpuAffectedByUbuntuNewAmdBug(self, oTestDrv):
+ """
+ Checks if the host OS is affected by older ubuntu installers being very
+ picky about which families of AMD CPUs it would run on.
+
+ The installer checks for family 15, later 16, later 20, and in 11.10
+ they remove the family check for AMD CPUs.
+ """
+ if not oTestDrv.isHostCpuAmd():
+ return False;
+ try:
+ (uMaxExt, _, _, _) = oTestDrv.oVBox.host.getProcessorCPUIDLeaf(0, 0x80000000, 0);
+ (uFamilyModel, _, _, _) = oTestDrv.oVBox.host.getProcessorCPUIDLeaf(0, 0x80000001, 0);
+ except:
+ reporter.logXcpt();
+ return False;
+ if uMaxExt < 0x80000001 or uMaxExt > 0x8000ffff:
+ return False;
+
+ uFamily = (uFamilyModel >> 8) & 0xf
+ if uFamily == 0xf:
+ uFamily = ((uFamilyModel >> 20) & 0x7f) + 0xf;
+ ## @todo Break this down into which old ubuntu release supports exactly
+ ## which AMD family, if we care.
+ if uFamily <= 15:
+ return False;
+ reporter.log('Skipping "%s" because host CPU is a family %u AMD, which may cause trouble for the guest OS installer.'
+ % (self.sVmName, uFamily,));
+ return True;
+
+ def getTestUser(self):
+ """
+ Gets the primary test user name.
+ """
+ if self.isWindows():
+ return 'Administrator';
+ return 'vbox';
+
+ def getTestUserPassword(self, sUser = None):
+ """
+ Gets the password for the primary user (or other specified one).
+ """
+ if sUser == 'test':
+ return '';
+ if sUser == 'vboxuser': # Default unattended installation user and password.
+ return 'changeme';
+ return 'password';
+
+ def getCom1RawFile(self, oVM):
+ """
+ Gets the name of the COM1 raw file.
+
+ Returns string, None on failure or if not active.
+
+ Note! Do not access __sCom1RawFile directly as it will not be set unless the
+ 'config' action was executed in the same run.
+ """
+ if self.fCom1RawFile:
+ # Retrieve it from the IMachine object and cache the result if needed:
+ if self.__sCom1RawFile is None:
+ try:
+ oPort = oVM.machine.getSerialPort(0);
+ except:
+ reporter.errorXcpt('failed to get serial port #0');
+ else:
+ try:
+ self.__sCom1RawFile = oPort.path;
+ except:
+ reporter.errorXcpt('failed to get the "path" property on serial port #0');
+ return self.__sCom1RawFile;
+
+ reporter.error('getCom1RawFile called when fCom1RawFile is False');
+ return None;
+
+ def getIGuestOSType(self, oVBoxWrapped):
+ """
+ Gets the IGuestOSType object corresponding to self.sKind.
+
+ Returns object on success, None on failure (logged as error).
+ """
+ try:
+ return oVBoxWrapped.o.getGuestOSType(self.sKind);
+ except:
+ reporter.errorXcpt('sVmName=%s sKind=%s' % (self.sVmName, self.sKind,));
+ return None;
+
+ def getRecommendedHddSize(self, oVBoxWrapped):
+ """
+ Gets the recommended HDD size from the IGuestOSType matching self.sKind.
+
+ Returns size in bytes on success, -1 on failure.
+ """
+ if self.__cbHdd < 0:
+ oGuestOSType = self.getIGuestOSType(oVBoxWrapped);
+ if oGuestOSType:
+ try:
+ self.__cbHdd = oGuestOSType.recommendedHDD;
+ except:
+ reporter.errorXcpt();
+ return -1;
+ return self.__cbHdd;
+
+ def getHddAddress(self, oVM, oVBoxWrapped):
+ """
+ Gets the HDD attachment address.
+
+ Returns (sController, iPort, iDevice) on success; (None, None, None) on failure.
+
+ Note! Do not access the cached value directly!
+ """
+ # Cached already?
+ if self.__tHddCtrlPortDev[0] is not None:
+ return self.__tHddCtrlPortDev;
+
+ # First look for HDs attached to the VM:
+ try:
+ aoAttachments = oVBoxWrapped.oVBoxMgr.getArray(oVM, 'mediumAttachments')
+ except:
+ reporter.errorXcpt();
+ else:
+ for oAtt in aoAttachments:
+ try:
+ sCtrl = oAtt.controller
+ iPort = oAtt.port;
+ iDev = oAtt.device;
+ eType = oAtt.type;
+ except:
+ reporter.errorXcpt();
+ return self.__tHddCtrlPortDev;
+ if eType == vboxcon.DeviceType_HardDisk:
+ self.__tHddCtrlPortDev = (sCtrl, iPort, iDev);
+ reporter.log2('getHddAddress: %s, %s, %s' % self.__tHddCtrlPortDev);
+ return self.__tHddCtrlPortDev;
+
+ # Then consult IGuestOSType:
+ oGuestOSType = self.getIGuestOSType(oVBoxWrapped);
+ if oGuestOSType:
+ try:
+ eCtrl = oGuestOSType.recommendedHDStorageController;
+ eBus = oGuestOSType.recommendedHDStorageBus;
+ except:
+ reporter.errorXcpt();
+ else:
+ # ASSUMES port 0, device 0.
+ self.__tHddCtrlPortDev = (self._storageCtrlAndBusToName(oVBoxWrapped.oVBoxMgr, oVM, eCtrl, eBus), 0, 0);
+ reporter.log2('getHddAddress: %s, %s, %s [IGuestOSType]' % self.__tHddCtrlPortDev);
+ return self.__tHddCtrlPortDev;
+
+ def getDvdAddress(self, oVM, oVBoxWrapped):
+ """
+ Gets the DVD attachment address.
+
+ Returns (sController, iPort, iDevice) on success; (None, None, None) on failure.
+
+ Note! Do not access the cached value directly!
+ """
+ # Cached already?
+ if self.__tDvdCtrlPortDev[0] is not None:
+ return self.__tDvdCtrlPortDev;
+
+ # First look for DVD attached to the VM:
+ try:
+ aoAttachments = oVBoxWrapped.oVBoxMgr.getArray(oVM, 'mediumAttachments')
+ except:
+ reporter.errorXcpt();
+ else:
+ for oAtt in aoAttachments:
+ try:
+ sCtrl = oAtt.controller
+ iPort = oAtt.port;
+ iDev = oAtt.device;
+ eType = oAtt.type;
+ except:
+ reporter.errorXcpt();
+ return self.__tDvdCtrlPortDev;
+ if eType == vboxcon.DeviceType_DVD:
+ self.__tDvdCtrlPortDev = (sCtrl, iPort, iDev);
+ reporter.log2('getDvdAddress: %s, %s, %s' % self.__tDvdCtrlPortDev);
+ return self.__tDvdCtrlPortDev;
+
+ # Then consult IGuestOSType:
+ oGuestOSType = self.getIGuestOSType(oVBoxWrapped);
+ if oGuestOSType:
+ try:
+ eCtrl = oGuestOSType.recommendedDVDStorageController;
+ eBus = oGuestOSType.recommendedDVDStorageBus;
+ except:
+ reporter.errorXcpt();
+ else:
+ # ASSUMES port 1, device 0.
+ self.__tDvdCtrlPortDev = (self._storageCtrlAndBusToName(oVBoxWrapped.oVBoxMgr, oVM, eCtrl, eBus), 1, 0);
+ reporter.log2('getDvdAddress: %s, %s, %s [IGuestOSType]' % self.__tDvdCtrlPortDev);
+ return self.__tDvdCtrlPortDev;
+
+ def recreateRecommendedHdd(self, oVM, oTestDrv, sHddPath = None):
+ """
+ Detaches and delete any current hard disk and then ensures that a new
+ one with the recommended size is created and attached to the recommended
+ controller/port/device.
+
+ Returns True/False (errors logged).
+ """
+ # Generate a name if none was given:
+ if not sHddPath:
+ try:
+ sHddPath = oVM.settingsFilePath;
+ except:
+ return reporter.errorXcpt();
+ sHddPath = os.path.join(os.path.dirname(sHddPath), '%s-%s.vdi' % (self.sVmName, uuid.uuid4(),));
+
+ fRc = False;
+
+ # Get the hard disk specs first:
+ cbHdd = self.getRecommendedHddSize(oTestDrv.oVBox);
+ tHddAddress = self.getHddAddress(oVM, oTestDrv.oVBox);
+ assert len(tHddAddress) == 3;
+ if tHddAddress[0] and cbHdd > 0:
+ # Open an session so we can make changes:
+ oSession = oTestDrv.openSession(oVM);
+ if oSession is not None:
+ # Detach the old disk (this will succeed with oOldHd set to None the first time around).
+ (fRc, oOldHd) = oSession.detachHd(tHddAddress[0], tHddAddress[1], tHddAddress[2]);
+ if fRc:
+ # Create a new disk and attach it.
+ fRc = oSession.createAndAttachHd(sHddPath,
+ cb = cbHdd,
+ sController = tHddAddress[0],
+ iPort = tHddAddress[1],
+ iDevice = tHddAddress[2],
+ fImmutable = False);
+ if fRc:
+ # Save the changes.
+ fRc = oSession.saveSettings();
+
+ # Delete the old HD:
+ if fRc and oOldHd is not None:
+ fRc = fRc and oTestDrv.oVBox.deleteHdByMedium(oOldHd);
+ fRc = fRc and oSession.saveSettings(); # Necessary for media reg??
+ else:
+ oSession.discardSettings();
+ fRc = oSession.close() and fRc;
+ return fRc;
+
+ def pathJoin(self, sBase, *asAppend):
+ """ See common.pathutils.joinEx(). """
+ return pathutils.joinEx(self.isWindows() or self.isOS2(), sBase, *asAppend);
+
+ def pathSep(self):
+ """ Returns the preferred paths separator for the guest OS. """
+ return '\\' if self.isWindows() or self.isOS2() else '/';
+
+
+## @todo Inherit from BaseTestVm
+class TestVm(object):
+ """
+ A Test VM - name + VDI/whatever.
+
+ This is just a data object.
+ """
+
+ def __init__(self, # pylint: disable=too-many-arguments
+ sVmName, # type: str
+ fGrouping = 0, # type: int
+ oSet = None, # type: TestVmSet
+ sHd = None, # type: str
+ sKind = None, # type: str
+ acCpusSup = None, # type: List[int]
+ asVirtModesSup = None, # type: List[str]
+ fIoApic = None, # type: bool
+ fNstHwVirt = False, # type: bool
+ fPae = None, # type: bool
+ sNic0AttachType = None, # type: str
+ sFloppy = None, # type: str
+ fVmmDevTestingPart = None, # type: bool
+ fVmmDevTestingMmio = False, # type: bool
+ asParavirtModesSup = None, # type: List[str]
+ fRandomPvPMode = False, # type: bool
+ sFirmwareType = 'bios', # type: str
+ sChipsetType = 'piix3', # type: str
+ sIommuType = 'none', # type: str
+ sHddControllerType = 'IDE Controller', # type: str
+ sDvdControllerType = 'IDE Controller' # type: str
+ ):
+ self.oSet = oSet;
+ self.sVmName = sVmName;
+ self.fGrouping = fGrouping;
+ self.sHd = sHd; # Relative to the testrsrc root.
+ self.acCpusSup = acCpusSup;
+ self.asVirtModesSup = asVirtModesSup;
+ self.asParavirtModesSup = asParavirtModesSup;
+ self.asParavirtModesSupOrg = asParavirtModesSup; # HACK ALERT! Trick to make the 'effing random mess not get in the
+ # way of actively selecting virtualization modes.
+ self.sKind = sKind;
+ self.sGuestOsType = None;
+ self.sDvdImage = None; # Relative to the testrsrc root.
+ self.sDvdControllerType = sDvdControllerType;
+ self.fIoApic = fIoApic;
+ self.fNstHwVirt = fNstHwVirt;
+ self.fPae = fPae;
+ self.sNic0AttachType = sNic0AttachType;
+ self.sHddControllerType = sHddControllerType;
+ self.sFloppy = sFloppy; # Relative to the testrsrc root, except when it isn't...
+ self.fVmmDevTestingPart = fVmmDevTestingPart;
+ self.fVmmDevTestingMmio = fVmmDevTestingMmio;
+ self.sFirmwareType = sFirmwareType;
+ self.sChipsetType = sChipsetType;
+ self.sIommuType = sIommuType;
+ self.fCom1RawFile = False;
+
+ self.fSnapshotRestoreCurrent = False; # Whether to restore execution on the current snapshot.
+ self.fSkip = False; # All VMs are included in the configured set by default.
+ self.aInfo = None;
+ self.sCom1RawFile = None; # Set by createVmInner and getReconfiguredVm if fCom1RawFile is set.
+ self._guessStuff(fRandomPvPMode);
+
+ def _mkCanonicalGuestOSType(self, sType):
+ """
+ Convert guest OS type into constant representation.
+ Raise exception if specified @param sType is unknown.
+ """
+ if sType.lower().startswith('darwin'):
+ return g_ksGuestOsTypeDarwin
+ if sType.lower().startswith('bsd'):
+ return g_ksGuestOsTypeFreeBSD
+ if sType.lower().startswith('dos'):
+ return g_ksGuestOsTypeDOS
+ if sType.lower().startswith('linux'):
+ return g_ksGuestOsTypeLinux
+ if sType.lower().startswith('os2'):
+ return g_ksGuestOsTypeOS2
+ if sType.lower().startswith('solaris'):
+ return g_ksGuestOsTypeSolaris
+ if sType.lower().startswith('windows'):
+ return g_ksGuestOsTypeWindows
+ raise base.GenError(sWhat="unknown guest OS kind: %s" % str(sType))
+
+ def _guessStuff(self, fRandomPvPMode):
+ """
+ Used by the constructor to guess stuff.
+ """
+
+ sNm = self.sVmName.lower().strip();
+ asSplit = sNm.replace('-', ' ').split(' ');
+
+ if self.sKind is None:
+ # From name.
+ for aInfo in g_aaNameToDetails:
+ if _intersects(asSplit, aInfo[g_iRegEx]):
+ self.aInfo = aInfo;
+ self.sGuestOsType = self._mkCanonicalGuestOSType(aInfo[g_iGuestOsType])
+ self.sKind = aInfo[g_iKind];
+ break;
+ if self.sKind is None:
+ reporter.fatal('The OS of test VM "%s" cannot be guessed' % (self.sVmName,));
+
+ # Check for 64-bit, if required and supported.
+ if (self.aInfo[g_iFlags] & g_kiArchMask) == g_k32_64 and _intersects(asSplit, ['64', 'amd64']):
+ self.sKind = self.sKind + '_64';
+ else:
+ # Lookup the kind.
+ for aInfo in g_aaNameToDetails:
+ if self.sKind == aInfo[g_iKind]:
+ self.aInfo = aInfo;
+ break;
+ if self.aInfo is None:
+ reporter.fatal('The OS of test VM "%s" with sKind="%s" cannot be guessed' % (self.sVmName, self.sKind));
+
+ # Translate sKind into sGuest OS Type.
+ if self.sGuestOsType is None:
+ if self.aInfo is not None:
+ self.sGuestOsType = self._mkCanonicalGuestOSType(self.aInfo[g_iGuestOsType])
+ elif self.sKind.find("Windows") >= 0:
+ self.sGuestOsType = g_ksGuestOsTypeWindows
+ elif self.sKind.find("Linux") >= 0:
+ self.sGuestOsType = g_ksGuestOsTypeLinux;
+ elif self.sKind.find("Solaris") >= 0:
+ self.sGuestOsType = g_ksGuestOsTypeSolaris;
+ elif self.sKind.find("DOS") >= 0:
+ self.sGuestOsType = g_ksGuestOsTypeDOS;
+ else:
+ reporter.fatal('The OS of test VM "%s", sKind="%s" cannot be guessed' % (self.sVmName, self.sKind));
+
+ # Restrict modes and such depending on the OS.
+ if self.asVirtModesSup is None:
+ self.asVirtModesSup = list(g_asVirtModes);
+ if self.sGuestOsType in (g_ksGuestOsTypeOS2, g_ksGuestOsTypeDarwin) \
+ or self.sKind.find('_64') > 0 \
+ or (self.aInfo is not None and (self.aInfo[g_iFlags] & g_kiNoRaw)):
+ self.asVirtModesSup = [sVirtMode for sVirtMode in self.asVirtModesSup if sVirtMode != 'raw'];
+ # TEMPORARY HACK - START
+ sHostName = os.environ.get("COMPUTERNAME", None);
+ if sHostName: sHostName = sHostName.lower();
+ else: sHostName = socket.getfqdn(); # Horribly slow on windows without IPv6 DNS/whatever.
+ if sHostName.startswith('testboxpile1'):
+ self.asVirtModesSup = [sVirtMode for sVirtMode in self.asVirtModesSup if sVirtMode != 'raw'];
+ # TEMPORARY HACK - END
+
+ # Restrict the CPU count depending on the OS and/or percieved SMP readiness.
+ if self.acCpusSup is None:
+ if _intersects(asSplit, ['uni']):
+ self.acCpusSup = [1];
+ elif self.aInfo is not None:
+ self.acCpusSup = list(range(self.aInfo[g_iMinCpu], self.aInfo[g_iMaxCpu] + 1));
+ else:
+ self.acCpusSup = [1];
+
+ # Figure relevant PV modes based on the OS.
+ if self.asParavirtModesSup is None:
+ self.asParavirtModesSup = g_kdaParavirtProvidersSupported[self.sGuestOsType];
+ ## @todo Remove this hack as soon as we've got around to explictly configure test variations
+ ## on the server side. Client side random is interesting but not the best option.
+ self.asParavirtModesSupOrg = self.asParavirtModesSup;
+ if fRandomPvPMode:
+ random.seed();
+ self.asParavirtModesSup = (random.choice(self.asParavirtModesSup),);
+
+ return True;
+
+ def getNonCanonicalGuestOsType(self):
+ """
+ Gets the non-canonical OS type (self.sGuestOsType is canonical).
+ """
+ return self.aInfo[g_iGuestOsType];
+
+ def getMissingResources(self, sTestRsrc):
+ """
+ Returns a list of missing resources (paths, stuff) that the VM needs.
+ """
+ asRet = [];
+ for sPath in [ self.sHd, self.sDvdImage, self.sFloppy]:
+ if sPath is not None:
+ if not os.path.isabs(sPath):
+ sPath = os.path.join(sTestRsrc, sPath);
+ if not os.path.exists(sPath):
+ asRet.append(sPath);
+ return asRet;
+
+ def skipCreatingVm(self, oTestDrv):
+ """
+ Called before VM creation to determine whether the VM should be skipped
+ due to host incompatibility or something along those lines.
+
+ returns True if it should be skipped, False if not.
+ """
+ if self.fNstHwVirt and not oTestDrv.hasHostNestedHwVirt():
+ reporter.log('Ignoring VM %s (Nested hardware-virtualization not support on this host).' % (self.sVmName,));
+ return True;
+ return False;
+
+ def createVm(self, oTestDrv, eNic0AttachType = None, sDvdImage = None):
+ """
+ Creates the VM with defaults and the few tweaks as per the arguments.
+
+ Returns same as vbox.TestDriver.createTestVM.
+ """
+ if sDvdImage is not None:
+ sMyDvdImage = sDvdImage;
+ else:
+ sMyDvdImage = self.sDvdImage;
+
+ if eNic0AttachType is not None:
+ eMyNic0AttachType = eNic0AttachType;
+ elif self.sNic0AttachType is None:
+ eMyNic0AttachType = None;
+ elif self.sNic0AttachType == 'nat':
+ eMyNic0AttachType = vboxcon.NetworkAttachmentType_NAT;
+ elif self.sNic0AttachType == 'bridged':
+ eMyNic0AttachType = vboxcon.NetworkAttachmentType_Bridged;
+ else:
+ assert False, self.sNic0AttachType;
+
+ return self.createVmInner(oTestDrv, eMyNic0AttachType, sMyDvdImage);
+
+ def _generateRawPortFilename(self, oTestDrv, sInfix, sSuffix):
+ """ Generates a raw port filename. """
+ random.seed();
+ sRandom = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(10));
+ return os.path.join(oTestDrv.sScratchPath, self.sVmName + sInfix + sRandom + sSuffix);
+
+ def createVmInner(self, oTestDrv, eNic0AttachType, sDvdImage):
+ """
+ Same as createVm but parameters resolved.
+
+ Returns same as vbox.TestDriver.createTestVM.
+ """
+ reporter.log2('');
+ reporter.log2('Calling createTestVM on %s...' % (self.sVmName,))
+ if self.fCom1RawFile:
+ self.sCom1RawFile = self._generateRawPortFilename(oTestDrv, '-com1-', '.out');
+ return oTestDrv.createTestVM(self.sVmName,
+ 1, # iGroup
+ sHd = self.sHd,
+ sKind = self.sKind,
+ fIoApic = self.fIoApic,
+ fNstHwVirt = self.fNstHwVirt,
+ fPae = self.fPae,
+ eNic0AttachType = eNic0AttachType,
+ sDvdImage = sDvdImage,
+ sDvdControllerType = self.sDvdControllerType,
+ sHddControllerType = self.sHddControllerType,
+ sFloppy = self.sFloppy,
+ fVmmDevTestingPart = self.fVmmDevTestingPart,
+ fVmmDevTestingMmio = self.fVmmDevTestingMmio,
+ sFirmwareType = self.sFirmwareType,
+ sChipsetType = self.sChipsetType,
+ sIommuType = self.sIommuType,
+ sCom1RawFile = self.sCom1RawFile if self.fCom1RawFile else None
+ );
+
+ def getReconfiguredVm(self, oTestDrv, cCpus, sVirtMode, sParavirtMode = None):
+ """
+ actionExecute worker that finds and reconfigure a test VM.
+
+ Returns (fRc, oVM) where fRc is True, None or False and oVM is a
+ VBox VM object that is only present when rc is True.
+ """
+
+ fRc = False;
+ oVM = oTestDrv.getVmByName(self.sVmName);
+ if oVM is not None:
+ if self.fSnapshotRestoreCurrent is True:
+ fRc = True;
+ else:
+ fHostSupports64bit = oTestDrv.hasHostLongMode();
+ if self.is64bitRequired() and not fHostSupports64bit:
+ fRc = None; # Skip the test.
+ elif self.isViaIncompatible() and oTestDrv.isHostCpuVia():
+ fRc = None; # Skip the test.
+ elif self.isShanghaiIncompatible() and oTestDrv.isHostCpuShanghai():
+ fRc = None; # Skip the test.
+ elif self.isP4Incompatible() and oTestDrv.isHostCpuP4():
+ fRc = None; # Skip the test.
+ else:
+ oSession = oTestDrv.openSession(oVM);
+ if oSession is not None:
+ fRc = oSession.enableVirtEx(sVirtMode != 'raw');
+ fRc = fRc and oSession.enableNestedPaging(sVirtMode == 'hwvirt-np');
+ fRc = fRc and oSession.setCpuCount(cCpus);
+ if cCpus > 1:
+ fRc = fRc and oSession.enableIoApic(True);
+
+ if sParavirtMode is not None and oSession.fpApiVer >= 5.0:
+ adParavirtProviders = {
+ g_ksParavirtProviderNone : vboxcon.ParavirtProvider_None,
+ g_ksParavirtProviderDefault: vboxcon.ParavirtProvider_Default,
+ g_ksParavirtProviderLegacy : vboxcon.ParavirtProvider_Legacy,
+ g_ksParavirtProviderMinimal: vboxcon.ParavirtProvider_Minimal,
+ g_ksParavirtProviderHyperV : vboxcon.ParavirtProvider_HyperV,
+ g_ksParavirtProviderKVM : vboxcon.ParavirtProvider_KVM,
+ };
+ fRc = fRc and oSession.setParavirtProvider(adParavirtProviders[sParavirtMode]);
+
+ fCfg64Bit = self.is64bitRequired() or (self.is64bit() and fHostSupports64bit and sVirtMode != 'raw');
+ fRc = fRc and oSession.enableLongMode(fCfg64Bit);
+ if fCfg64Bit: # This is to avoid GUI pedantic warnings in the GUI. Sigh.
+ oOsType = oSession.getOsType();
+ if oOsType is not None:
+ if oOsType.is64Bit and sVirtMode == 'raw':
+ assert(oOsType.id[-3:] == '_64');
+ fRc = fRc and oSession.setOsType(oOsType.id[:-3]);
+ elif not oOsType.is64Bit and sVirtMode != 'raw':
+ fRc = fRc and oSession.setOsType(oOsType.id + '_64');
+
+ # New serial raw file.
+ if fRc and self.fCom1RawFile:
+ self.sCom1RawFile = self._generateRawPortFilename(oTestDrv, '-com1-', '.out');
+ utils.noxcptDeleteFile(self.sCom1RawFile);
+ fRc = oSession.setupSerialToRawFile(0, self.sCom1RawFile);
+
+ # Make life simpler for child classes.
+ if fRc:
+ fRc = self._childVmReconfig(oTestDrv, oVM, oSession);
+
+ fRc = fRc and oSession.saveSettings();
+ if not oSession.close():
+ fRc = False;
+ if fRc is True:
+ return (True, oVM);
+ return (fRc, None);
+
+ def _childVmReconfig(self, oTestDrv, oVM, oSession):
+ """ Hook into getReconfiguredVm() for children. """
+ _ = oTestDrv; _ = oVM; _ = oSession;
+ return True;
+
+ def getGuestArch(self):
+ """ Same as util.getHostArch. """
+ return 'amd64' if self.sKind.find('_64') >= 0 else 'x86';
+
+ def getGuestOs(self):
+ """ Same as util.getHostOs. """
+ if self.isWindows(): return 'win';
+ if self.isOS2(): return 'os2';
+ if self.isLinux(): return 'linux';
+ reporter.error('getGuestOs does not what to return!');
+ raise Exception();
+
+ def getGuestExeSuff(self):
+ """ The executable image suffix for the guest. """
+ if self.isWindows() or self.isOS2():
+ return '.exe';
+ return '';
+
+ def getGuestOsDotArch(self):
+ """ Same as util.getHostOsDotArch."""
+ return self.getGuestOs() + '.' + self.getGuestArch();
+
+ def isWindows(self):
+ """ Checks if it's a Windows VM. """
+ return self.sGuestOsType == g_ksGuestOsTypeWindows;
+
+ def isOS2(self):
+ """ Checks if it's an OS/2 VM. """
+ return self.sGuestOsType == g_ksGuestOsTypeOS2;
+
+ def isLinux(self):
+ """ Checks if it's an Linux VM. """
+ return self.sGuestOsType == g_ksGuestOsTypeLinux;
+
+ def is64bit(self):
+ """ Checks if it's a 64-bit VM. """
+ return self.sKind.find('_64') >= 0;
+
+ def is64bitRequired(self):
+ """ Check if 64-bit is required or not. """
+ return (self.aInfo[g_iFlags] & g_k64) != 0;
+
+ def isLoggedOntoDesktop(self):
+ """ Checks if the test VM is logging onto a graphical desktop by default. """
+ if self.isWindows():
+ return True;
+ if self.isOS2():
+ return True;
+ if self.sVmName.find('-desktop'):
+ return True;
+ return False;
+
+ def isViaIncompatible(self):
+ """
+ Identifies VMs that doesn't work on VIA.
+
+ Returns True if NOT supported on VIA, False if it IS supported.
+ """
+ # Oracle linux doesn't like VIA in our experience
+ if self.aInfo[g_iKind] in ['Oracle', 'Oracle_64']:
+ return True;
+ # OS/2: "The system detected an internal processing error at location
+ # 0168:fff1da1f - 000e:ca1f. 0a8606fd
+ if self.isOS2():
+ return True;
+ # Windows NT4 before SP4 won't work because of cmpxchg8b not being
+ # detected, leading to a STOP 3e(80,0,0,0).
+ if self.aInfo[g_iKind] == 'WindowsNT4':
+ if self.sVmName.find('sp') < 0:
+ return True; # no service pack.
+ if self.sVmName.find('sp0') >= 0 \
+ or self.sVmName.find('sp1') >= 0 \
+ or self.sVmName.find('sp2') >= 0 \
+ or self.sVmName.find('sp3') >= 0:
+ return True;
+ # XP x64 on a physical VIA box hangs exactly like a VM.
+ if self.aInfo[g_iKind] in ['WindowsXP_64', 'Windows2003_64']:
+ return True;
+ # Vista 64 throws BSOD 0x5D (UNSUPPORTED_PROCESSOR)
+ if self.aInfo[g_iKind] in ['WindowsVista_64']:
+ return True;
+ # Solaris 11 hangs on VIA, tested on a physical box (testboxvqc)
+ if self.aInfo[g_iKind] in ['Solaris11_64']:
+ return True;
+ return False;
+
+ def isShanghaiIncompatible(self):
+ """
+ Identifies VMs that doesn't work on Shanghai.
+
+ Returns True if NOT supported on Shanghai, False if it IS supported.
+ """
+ # For now treat it just like VIA, to be adjusted later
+ return self.isViaIncompatible()
+
+ def isP4Incompatible(self):
+ """
+ Identifies VMs that doesn't work on Pentium 4 / Pentium D.
+
+ Returns True if NOT supported on P4, False if it IS supported.
+ """
+ # Stupid 1 kHz timer. Too much for antique CPUs.
+ if self.sVmName.find('rhel5') >= 0:
+ return True;
+ # Due to the boot animation the VM takes forever to boot.
+ if self.aInfo[g_iKind] == 'Windows2000':
+ return True;
+ return False;
+
+ def isHostCpuAffectedByUbuntuNewAmdBug(self, oTestDrv):
+ """
+ Checks if the host OS is affected by older ubuntu installers being very
+ picky about which families of AMD CPUs it would run on.
+
+ The installer checks for family 15, later 16, later 20, and in 11.10
+ they remove the family check for AMD CPUs.
+ """
+ if not oTestDrv.isHostCpuAmd():
+ return False;
+ try:
+ (uMaxExt, _, _, _) = oTestDrv.oVBox.host.getProcessorCPUIDLeaf(0, 0x80000000, 0);
+ (uFamilyModel, _, _, _) = oTestDrv.oVBox.host.getProcessorCPUIDLeaf(0, 0x80000001, 0);
+ except:
+ reporter.logXcpt();
+ return False;
+ if uMaxExt < 0x80000001 or uMaxExt > 0x8000ffff:
+ return False;
+
+ uFamily = (uFamilyModel >> 8) & 0xf
+ if uFamily == 0xf:
+ uFamily = ((uFamilyModel >> 20) & 0x7f) + 0xf;
+ ## @todo Break this down into which old ubuntu release supports exactly
+ ## which AMD family, if we care.
+ if uFamily <= 15:
+ return False;
+ reporter.log('Skipping "%s" because host CPU is a family %u AMD, which may cause trouble for the guest OS installer.'
+ % (self.sVmName, uFamily,));
+ return True;
+
+ def getTestUser(self):
+ """
+ Gets the primary test user name.
+ """
+ if self.isWindows():
+ return 'Administrator';
+ return 'vbox';
+
+ def getTestUserPassword(self, sUser = None):
+ """
+ Gets the password for the primary user (or other specified one).
+ """
+ if sUser == 'test':
+ return '';
+ if sUser == 'vboxuser': # Default unattended installation user and password.
+ return 'changeme';
+ return 'password';
+
+ def pathJoin(self, sBase, *asAppend):
+ """ See common.pathutils.joinEx(). """
+ return pathutils.joinEx(self.isWindows() or self.isOS2(), sBase, *asAppend);
+
+ def pathSep(self):
+ """ Returns the preferred paths separator for the guest OS. """
+ return '\\' if self.isWindows() or self.isOS2() else '/';
+
+
+class BootSectorTestVm(TestVm):
+ """
+ A Boot Sector Test VM.
+ """
+
+ def __init__(self, oSet, sVmName, sFloppy = None, asVirtModesSup = None, f64BitRequired = False):
+ self.f64BitRequired = f64BitRequired;
+ if asVirtModesSup is None:
+ asVirtModesSup = list(g_asVirtModes);
+ TestVm.__init__(self, sVmName,
+ oSet = oSet,
+ acCpusSup = [1,],
+ sFloppy = sFloppy,
+ asVirtModesSup = asVirtModesSup,
+ fPae = True,
+ fIoApic = True,
+ fVmmDevTestingPart = True,
+ fVmmDevTestingMmio = True,
+ );
+
+ def is64bitRequired(self):
+ return self.f64BitRequired;
+
+
+class AncientTestVm(TestVm):
+ """
+ A ancient Test VM, using the serial port for communicating results.
+
+ We're looking for 'PASSED' and 'FAILED' lines in the COM1 output.
+ """
+
+
+ def __init__(self, # pylint: disable=too-many-arguments
+ sVmName, # type: str
+ fGrouping = g_kfGrpAncient | g_kfGrpNoTxs, # type: int
+ sHd = None, # type: str
+ sKind = None, # type: str
+ acCpusSup = None, # type: List[int]
+ asVirtModesSup = None, # type: List[str]
+ sNic0AttachType = None, # type: str
+ sFloppy = None, # type: str
+ sFirmwareType = 'bios', # type: str
+ sChipsetType = 'piix3', # type: str
+ sHddControllerName = 'IDE Controller', # type: str
+ sDvdControllerName = 'IDE Controller', # type: str
+ cMBRamMax = None, # type: int
+ ):
+ TestVm.__init__(self,
+ sVmName,
+ fGrouping = fGrouping,
+ sHd = sHd,
+ sKind = sKind,
+ acCpusSup = [1] if acCpusSup is None else acCpusSup,
+ asVirtModesSup = asVirtModesSup,
+ sNic0AttachType = sNic0AttachType,
+ sFloppy = sFloppy,
+ sFirmwareType = sFirmwareType,
+ sChipsetType = sChipsetType,
+ sHddControllerType = sHddControllerName,
+ sDvdControllerType = sDvdControllerName,
+ asParavirtModesSup = (g_ksParavirtProviderNone,)
+ );
+ self.fCom1RawFile = True;
+ self.cMBRamMax= cMBRamMax;
+
+
+ def _childVmReconfig(self, oTestDrv, oVM, oSession):
+ _ = oVM; _ = oTestDrv;
+ fRc = True;
+
+ # DOS 4.01 doesn't like the default 32MB of memory.
+ if fRc and self.cMBRamMax is not None:
+ try:
+ cMBRam = oSession.o.machine.memorySize;
+ except:
+ cMBRam = self.cMBRamMax + 4;
+ if self.cMBRamMax < cMBRam:
+ fRc = oSession.setRamSize(self.cMBRamMax);
+
+ return fRc;
+
+
+class TestVmSet(object):
+ """
+ A set of Test VMs.
+ """
+
+ def __init__(self, oTestVmManager = None, acCpus = None, asVirtModes = None, fIgnoreSkippedVm = False):
+ self.oTestVmManager = oTestVmManager;
+ if acCpus is None:
+ acCpus = [1, 2];
+ self.acCpusDef = acCpus;
+ self.acCpus = acCpus;
+ if asVirtModes is None:
+ asVirtModes = list(g_asVirtModes);
+ self.asVirtModesDef = asVirtModes;
+ self.asVirtModes = asVirtModes;
+ self.aoTestVms = [] # type: list(BaseTestVm)
+ self.fIgnoreSkippedVm = fIgnoreSkippedVm;
+ self.asParavirtModes = None; ##< If None, use the first PV mode of the test VM, otherwise all modes in this list.
+
+ def findTestVmByName(self, sVmName):
+ """
+ Returns the TestVm object with the given name.
+ Returns None if not found.
+ """
+
+ # The 'tst-' prefix is optional.
+ sAltName = sVmName if sVmName.startswith('tst-') else 'tst-' + sVmName;
+
+ for oTestVm in self.aoTestVms:
+ if oTestVm.sVmName in (sVmName, sAltName):
+ return oTestVm;
+ return None;
+
+ def getAllVmNames(self, sSep = ':'):
+ """
+ Returns names of all the test VMs in the set separated by
+ sSep (defaults to ':').
+ """
+ sVmNames = '';
+ for oTestVm in self.aoTestVms:
+ sName = oTestVm.sVmName;
+ if sName.startswith('tst-'):
+ sName = sName[4:];
+ if sVmNames == '':
+ sVmNames = sName;
+ else:
+ sVmNames = sVmNames + sSep + sName;
+ return sVmNames;
+
+ def showUsage(self):
+ """
+ Invoked by vbox.TestDriver.
+ """
+ reporter.log('');
+ reporter.log('Test VM selection and general config options:');
+ reporter.log(' --virt-modes <m1[:m2[:...]]>');
+ reporter.log(' Default: %s' % (':'.join(self.asVirtModesDef)));
+ reporter.log(' --skip-virt-modes <m1[:m2[:...]]>');
+ reporter.log(' Use this to avoid hwvirt or hwvirt-np when not supported by the host');
+ reporter.log(' since we cannot detect it using the main API. Use after --virt-modes.');
+ reporter.log(' --cpu-counts <c1[:c2[:...]]>');
+ reporter.log(' Default: %s' % (':'.join(str(c) for c in self.acCpusDef)));
+ reporter.log(' --test-vms <vm1[:vm2[:...]]>');
+ reporter.log(' Test the specified VMs in the given order. Use this to change');
+ reporter.log(' the execution order or limit the choice of VMs');
+ reporter.log(' Default: %s (all)' % (self.getAllVmNames(),));
+ reporter.log(' --skip-vms <vm1[:vm2[:...]]>');
+ reporter.log(' Skip the specified VMs when testing.');
+ reporter.log(' --snapshot-restore-current');
+ reporter.log(' Restores the current snapshot and resumes execution.');
+ reporter.log(' --paravirt-modes <pv1[:pv2[:...]]>');
+ reporter.log(' Set of paravirtualized providers (modes) to tests. Intersected with what the test VM supports.');
+ reporter.log(' Default is the first PV mode the test VMs support, generally same as "legacy".');
+ reporter.log(' --with-nested-hwvirt-only');
+ reporter.log(' Test VMs using nested hardware-virtualization only.');
+ reporter.log(' --without-nested-hwvirt-only');
+ reporter.log(' Test VMs not using nested hardware-virtualization only.');
+ ## @todo Add more options for controlling individual VMs.
+ return True;
+
+ def parseOption(self, asArgs, iArg):
+ """
+ Parses the set test vm set options (--test-vms and --skip-vms), modifying the set
+ Invoked by the testdriver method with the same name.
+
+ Keyword arguments:
+ asArgs -- The argument vector.
+ iArg -- The index of the current argument.
+
+ Returns iArg if the option was not recognized and the caller should handle it.
+ Returns the index of the next argument when something is consumed.
+
+ In the event of a syntax error, a InvalidOption or QuietInvalidOption
+ is thrown.
+ """
+
+ if asArgs[iArg] == '--virt-modes':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--virt-modes" takes a colon separated list of modes');
+
+ self.asVirtModes = asArgs[iArg].split(':');
+ for s in self.asVirtModes:
+ if s not in self.asVirtModesDef:
+ raise base.InvalidOption('The "--virt-modes" value "%s" is not valid; valid values are: %s' \
+ % (s, ' '.join(self.asVirtModesDef)));
+
+ elif asArgs[iArg] == '--skip-virt-modes':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--skip-virt-modes" takes a colon separated list of modes');
+
+ for s in asArgs[iArg].split(':'):
+ if s not in self.asVirtModesDef:
+ raise base.InvalidOption('The "--virt-modes" value "%s" is not valid; valid values are: %s' \
+ % (s, ' '.join(self.asVirtModesDef)));
+ if s in self.asVirtModes:
+ self.asVirtModes.remove(s);
+
+ elif asArgs[iArg] == '--cpu-counts':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--cpu-counts" takes a colon separated list of cpu counts');
+
+ self.acCpus = [];
+ for s in asArgs[iArg].split(':'):
+ try: c = int(s);
+ except: raise base.InvalidOption('The "--cpu-counts" value "%s" is not an integer' % (s,));
+ if c <= 0: raise base.InvalidOption('The "--cpu-counts" value "%s" is zero or negative' % (s,));
+ self.acCpus.append(c);
+
+ elif asArgs[iArg] == '--test-vms':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--test-vms" takes colon separated list');
+
+ for oTestVm in self.aoTestVms:
+ oTestVm.fSkip = True;
+
+ asTestVMs = asArgs[iArg].split(':');
+ for s in asTestVMs:
+ oTestVm = self.findTestVmByName(s);
+ if oTestVm is None:
+ raise base.InvalidOption('The "--test-vms" value "%s" is not valid; valid values are: %s' \
+ % (s, self.getAllVmNames(' ')));
+ oTestVm.fSkip = False;
+
+ elif asArgs[iArg] == '--skip-vms':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--skip-vms" takes colon separated list');
+
+ asTestVMs = asArgs[iArg].split(':');
+ for s in asTestVMs:
+ oTestVm = self.findTestVmByName(s);
+ if oTestVm is None:
+ reporter.log('warning: The "--test-vms" value "%s" does not specify any of our test VMs.' % (s,));
+ else:
+ oTestVm.fSkip = True;
+
+ elif asArgs[iArg] == '--snapshot-restore-current':
+ for oTestVm in self.aoTestVms:
+ if oTestVm.fSkip is False:
+ oTestVm.fSnapshotRestoreCurrent = True;
+ reporter.log('VM "%s" will be restored.' % (oTestVm.sVmName));
+
+ elif asArgs[iArg] == '--paravirt-modes':
+ iArg += 1
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--paravirt-modes" takes a colon separated list of modes');
+
+ self.asParavirtModes = asArgs[iArg].split(':')
+ for sPvMode in self.asParavirtModes:
+ if sPvMode not in g_kasParavirtProviders:
+ raise base.InvalidOption('The "--paravirt-modes" value "%s" is not valid; valid values are: %s'
+ % (sPvMode, ', '.join(g_kasParavirtProviders),));
+ if not self.asParavirtModes:
+ self.asParavirtModes = None;
+
+ # HACK ALERT! Reset the random paravirt selection for members.
+ for oTestVm in self.aoTestVms:
+ oTestVm.asParavirtModesSup = oTestVm.asParavirtModesSupOrg;
+
+ elif asArgs[iArg] == '--with-nested-hwvirt-only':
+ for oTestVm in self.aoTestVms:
+ if oTestVm.fNstHwVirt is False:
+ oTestVm.fSkip = True;
+
+ elif asArgs[iArg] == '--without-nested-hwvirt-only':
+ for oTestVm in self.aoTestVms:
+ if oTestVm.fNstHwVirt is True:
+ oTestVm.fSkip = True;
+
+ else:
+ return iArg;
+ return iArg + 1;
+
+ def getResourceSet(self):
+ """
+ Called vbox.TestDriver.getResourceSet and returns a list of paths of resources.
+ """
+ asResources = [];
+ for oTestVm in self.aoTestVms:
+ if not oTestVm.fSkip:
+ if isinstance(oTestVm, BaseTestVm): # Temporarily...
+ asResources.extend(oTestVm.getResourceSet());
+ else:
+ if oTestVm.sHd is not None:
+ asResources.append(oTestVm.sHd);
+ if oTestVm.sDvdImage is not None:
+ asResources.append(oTestVm.sDvdImage);
+ return asResources;
+
+ def actionConfig(self, oTestDrv, eNic0AttachType = None, sDvdImage = None):
+ """
+ For base.TestDriver.actionConfig. Configure the VMs with defaults and
+ a few tweaks as per arguments.
+
+ Returns True if successful.
+ Returns False if not.
+ """
+
+ for oTestVm in self.aoTestVms:
+ if oTestVm.fSkip:
+ continue;
+ if oTestVm.skipCreatingVm(oTestDrv):
+ oTestVm.fSkip = True;
+ continue;
+
+ if oTestVm.fSnapshotRestoreCurrent:
+ # If we want to restore a VM we don't need to create
+ # the machine anymore -- so just add it to the test VM list.
+ oVM = oTestDrv.addTestMachine(oTestVm.sVmName);
+ else:
+ oVM = oTestVm.createVm(oTestDrv, eNic0AttachType, sDvdImage);
+ if oVM is None:
+ return False;
+
+ return True;
+
+ def _removeUnsupportedVirtModes(self, oTestDrv):
+ """
+ Removes unsupported virtualization modes.
+ """
+ if 'hwvirt' in self.asVirtModes and not oTestDrv.hasHostHwVirt():
+ reporter.log('Hardware assisted virtualization is not available on the host, skipping it.');
+ self.asVirtModes.remove('hwvirt');
+
+ if 'hwvirt-np' in self.asVirtModes and not oTestDrv.hasHostNestedPaging():
+ reporter.log('Nested paging not supported by the host, skipping it.');
+ self.asVirtModes.remove('hwvirt-np');
+
+ if 'raw' in self.asVirtModes and not oTestDrv.hasRawModeSupport():
+ reporter.log('Raw-mode virtualization is not available in this build (or perhaps for this host), skipping it.');
+ self.asVirtModes.remove('raw');
+
+ return True;
+
+ def actionExecute(self, oTestDrv, fnCallback): # pylint: disable=too-many-locals
+ """
+ For base.TestDriver.actionExecute. Calls the callback function for
+ each of the VMs and basic configuration variations (virt-mode and cpu
+ count).
+
+ Returns True if all fnCallback calls returned True, otherwise False.
+
+ The callback can return True, False or None. The latter is for when the
+ test is skipped. (True is for success, False is for failure.)
+ """
+
+ self._removeUnsupportedVirtModes(oTestDrv);
+ cMaxCpus = oTestDrv.getHostCpuCount();
+
+ #
+ # The test loop.
+ #
+ fRc = True;
+ for oTestVm in self.aoTestVms:
+ if oTestVm.fSkip and self.fIgnoreSkippedVm:
+ reporter.log2('Ignoring VM %s (fSkip = True).' % (oTestVm.sVmName,));
+ continue;
+ reporter.testStart(oTestVm.sVmName);
+ if oTestVm.fSkip:
+ reporter.testDone(fSkipped = True);
+ continue;
+
+ # Intersect the supported modes and the ones being testing.
+ asVirtModesSup = [sMode for sMode in oTestVm.asVirtModesSup if sMode in self.asVirtModes];
+
+ # Ditto for CPUs.
+ acCpusSup = [cCpus for cCpus in oTestVm.acCpusSup if cCpus in self.acCpus];
+
+ # Ditto for paravirtualization modes, except if not specified we got a less obvious default.
+ if self.asParavirtModes is not None and oTestDrv.fpApiVer >= 5.0:
+ asParavirtModes = [sPvMode for sPvMode in oTestVm.asParavirtModesSup if sPvMode in self.asParavirtModes];
+ assert None not in asParavirtModes;
+ elif oTestDrv.fpApiVer >= 5.0:
+ asParavirtModes = (oTestVm.asParavirtModesSup[0],);
+ assert asParavirtModes[0] is not None;
+ else:
+ asParavirtModes = (None,);
+
+ for cCpus in acCpusSup:
+ if cCpus == 1:
+ reporter.testStart('1 cpu');
+ else:
+ reporter.testStart('%u cpus' % (cCpus));
+ if cCpus > cMaxCpus:
+ reporter.testDone(fSkipped = True);
+ continue;
+
+ cTests = 0;
+ for sVirtMode in asVirtModesSup:
+ if sVirtMode == 'raw' and cCpus > 1:
+ continue;
+ reporter.testStart('%s' % ( g_dsVirtModeDescs[sVirtMode], ) );
+ cStartTests = cTests;
+
+ for sParavirtMode in asParavirtModes:
+ if sParavirtMode is not None:
+ assert oTestDrv.fpApiVer >= 5.0;
+ reporter.testStart('%s' % ( sParavirtMode, ) );
+
+ # Reconfigure the VM.
+ try:
+ (rc2, oVM) = oTestVm.getReconfiguredVm(oTestDrv, cCpus, sVirtMode, sParavirtMode = sParavirtMode);
+ except KeyboardInterrupt:
+ raise;
+ except:
+ reporter.errorXcpt(cFrames = 9);
+ rc2 = False;
+ if rc2 is True:
+ # Do the testing.
+ try:
+ rc2 = fnCallback(oVM, oTestVm);
+ except KeyboardInterrupt:
+ raise;
+ except:
+ reporter.errorXcpt(cFrames = 9);
+ rc2 = False;
+ if rc2 is False:
+ reporter.maybeErr(reporter.testErrorCount() == 0, 'fnCallback failed');
+ elif rc2 is False:
+ reporter.log('getReconfiguredVm failed');
+ if rc2 is False:
+ fRc = False;
+
+ cTests = cTests + (rc2 is not None);
+ if sParavirtMode is not None:
+ reporter.testDone(fSkipped = (rc2 is None));
+
+ reporter.testDone(fSkipped = cTests == cStartTests);
+
+ reporter.testDone(fSkipped = cTests == 0);
+
+ _, cErrors = reporter.testDone();
+ if cErrors > 0:
+ fRc = False;
+ return fRc;
+
+ def enumerateTestVms(self, fnCallback):
+ """
+ Enumerates all the 'active' VMs.
+
+ Returns True if all fnCallback calls returned True.
+ Returns False if any returned False.
+ Returns None immediately if fnCallback returned None.
+ """
+ fRc = True;
+ for oTestVm in self.aoTestVms:
+ if not oTestVm.fSkip:
+ fRc2 = fnCallback(oTestVm);
+ if fRc2 is None:
+ return fRc2;
+ fRc = fRc and fRc2;
+ return fRc;
+
+
+
+class TestVmManager(object):
+ """
+ Test VM manager.
+ """
+
+ ## @name VM grouping flags
+ ## @{
+ kfGrpSmoke = g_kfGrpSmoke;
+ kfGrpStandard = g_kfGrpStandard;
+ kfGrpStdSmoke = g_kfGrpStdSmoke;
+ kfGrpWithGAs = g_kfGrpWithGAs;
+ kfGrpNoTxs = g_kfGrpNoTxs;
+ kfGrpAncient = g_kfGrpAncient;
+ kfGrpExotic = g_kfGrpExotic;
+ ## @}
+
+ kaTestVMs = (
+ # Note: The images in the 6.1 folder all have been pre-configured to allow for Guest Additions installation
+ # (come with build essentials, kernel headers).
+ # Linux
+ TestVm('tst-ubuntu-18_04_3-64', kfGrpStdSmoke, sHd = '6.1/ubuntu-18_04_3-amd64-2.vdi',
+ sKind = 'Ubuntu_64', acCpusSup = range(1, 33), fIoApic = True,
+ asParavirtModesSup = [g_ksParavirtProviderKVM,]),
+ # Note: Deprecated; had SELinux + Screensaver (black screen) enabled.
+ #TestVm('tst-ol-8_1-64-efi', kfGrpStdSmoke, sHd = '6.1/efi/ol-8_1-efi-amd64.vdi',
+ # sKind = 'Oracle_64', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi',
+ # asParavirtModesSup = [g_ksParavirtProviderKVM,]),
+ TestVm('tst-ol-8_1-64-efi', kfGrpStdSmoke, sHd = '6.1/efi/ol-8_1-efi-amd64-2.vdi',
+ sKind = 'Oracle_64', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi',
+ asParavirtModesSup = [g_ksParavirtProviderKVM,]),
+ TestVm('tst-ol-6u2-32', kfGrpStdSmoke, sHd = '6.1/ol-6u2-x86.vdi',
+ sKind = 'Oracle', acCpusSup = range(1, 33), fIoApic = True,
+ asParavirtModesSup = [g_ksParavirtProviderKVM,]),
+ TestVm('tst-ubuntu-15_10-64-efi', kfGrpStdSmoke, sHd = '6.1/efi/ubuntu-15_10-efi-amd64-3.vdi',
+ sKind = 'Ubuntu_64', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi',
+ asParavirtModesSup = [g_ksParavirtProviderKVM,]),
+ # Note: Deprecated / buggy; use the one in the 6.1 folder.
+ #TestVm('tst-ubuntu-15_10-64-efi', kfGrpStdSmoke, sHd = '4.2/efi/ubuntu-15_10-efi-amd64.vdi',
+ # sKind = 'Ubuntu_64', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi',
+ # asParavirtModesSup = [g_ksParavirtProviderKVM,]),
+ TestVm('tst-rhel5', kfGrpSmoke, sHd = '3.0/tcp/rhel5.vdi',
+ sKind = 'RedHat', acCpusSup = range(1, 33), fIoApic = True, sNic0AttachType = 'nat'),
+ TestVm('tst-arch', kfGrpStandard, sHd = '4.2/usb/tst-arch.vdi',
+ sKind = 'ArchLinux_64', acCpusSup = range(1, 33), fIoApic = True, sNic0AttachType = 'nat'),
+ # disabled 2019-03-08 klaus - fails all over the place and pollutes the test results
+ #TestVm('tst-ubuntu-1804-64', kfGrpStdSmoke, sHd = '4.2/ubuntu-1804/t-ubuntu-1804-64.vdi',
+ # sKind = 'Ubuntu_64', acCpusSup = range(1, 33), fIoApic = True),
+ TestVm('tst-ol76-64', kfGrpStdSmoke, sHd = '4.2/ol76/t-ol76-64.vdi',
+ sKind = 'Oracle_64', acCpusSup = range(1, 33), fIoApic = True),
+ TestVm('tst-ubuntu-20_04-64-amdvi', kfGrpStdSmoke, sHd = '6.1/ubuntu-20_04-64.vdi',
+ sKind = 'Ubuntu_64', acCpusSup = range(1, 33), fIoApic = True,
+ asParavirtModesSup = [g_ksParavirtProviderKVM,], sNic0AttachType = 'nat', sChipsetType = 'ich9',
+ sIommuType = 'amd'),
+ TestVm('tst-ubuntu-20_04-64-vtd', kfGrpStdSmoke, sHd = '6.1/ubuntu-20_04-64.vdi',
+ sKind = 'Ubuntu_64', acCpusSup = range(1, 33), fIoApic = True,
+ asParavirtModesSup = [g_ksParavirtProviderKVM,], sNic0AttachType = 'nat', sChipsetType = 'ich9',
+ sIommuType = 'intel'),
+
+ # Solaris
+ TestVm('tst-sol10', kfGrpSmoke, sHd = '3.0/tcp/solaris10.vdi',
+ sKind = 'Solaris', acCpusSup = range(1, 33), fPae = True, sNic0AttachType = 'bridged'),
+ TestVm('tst-sol10-64', kfGrpSmoke, sHd = '3.0/tcp/solaris10.vdi',
+ sKind = 'Solaris_64', acCpusSup = range(1, 33), sNic0AttachType = 'bridged'),
+ TestVm('tst-sol11u1', kfGrpSmoke, sHd = '4.2/nat/sol11u1/t-sol11u1.vdi',
+ sKind = 'Solaris11_64', acCpusSup = range(1, 33), sNic0AttachType = 'nat', fIoApic = True,
+ sHddControllerType = 'SATA Controller'),
+ #TestVm('tst-sol11u1-ich9', kfGrpSmoke, sHd = '4.2/nat/sol11u1/t-sol11u1.vdi',
+ # sKind = 'Solaris11_64', acCpusSup = range(1, 33), sNic0AttachType = 'nat', fIoApic = True,
+ # sHddControllerType = 'SATA Controller', sChipsetType = 'ich9'),
+
+ # NT 3.x
+ TestVm('tst-nt310', kfGrpAncient, sHd = '5.2/great-old-ones/t-nt310/t-nt310.vdi',
+ sKind = 'WindowsNT3x', acCpusSup = [1], sHddControllerType = 'BusLogic SCSI Controller',
+ sDvdControllerType = 'BusLogic SCSI Controller'),
+ TestVm('tst-nt350', kfGrpAncient, sHd = '5.2/great-old-ones/t-nt350/t-nt350.vdi',
+ sKind = 'WindowsNT3x', acCpusSup = [1], sHddControllerType = 'BusLogic SCSI Controller',
+ sDvdControllerType = 'BusLogic SCSI Controller'),
+ TestVm('tst-nt351', kfGrpAncient, sHd = '5.2/great-old-ones/t-nt350/t-nt351.vdi',
+ sKind = 'WindowsNT3x', acCpusSup = [1], sHddControllerType = 'BusLogic SCSI Controller',
+ sDvdControllerType = 'BusLogic SCSI Controller'),
+
+ # NT 4
+ TestVm('tst-nt4sp1', kfGrpStdSmoke, sHd = '4.2/nat/nt4sp1/t-nt4sp1.vdi',
+ sKind = 'WindowsNT4', acCpusSup = [1], sNic0AttachType = 'nat'),
+
+ TestVm('tst-nt4sp6', kfGrpStdSmoke, sHd = '4.2/nt4sp6/t-nt4sp6.vdi',
+ sKind = 'WindowsNT4', acCpusSup = range(1, 33)),
+
+ # W2K
+ TestVm('tst-w2ksp4', kfGrpStdSmoke, sHd = '4.2/win2ksp4/t-win2ksp4.vdi',
+ sKind = 'Windows2000', acCpusSup = range(1, 33)),
+
+ # XP
+ TestVm('tst-xppro', kfGrpStdSmoke, sHd = '4.2/nat/xppro/t-xppro.vdi',
+ sKind = 'WindowsXP', acCpusSup = range(1, 33), sNic0AttachType = 'nat'),
+ TestVm('tst-xpsp2', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxpsp2.vdi',
+ sKind = 'WindowsXP', acCpusSup = range(1, 33), fIoApic = True),
+ TestVm('tst-xpsp2-halaacpi', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxp-halaacpi.vdi',
+ sKind = 'WindowsXP', acCpusSup = range(1, 33), fIoApic = True),
+ TestVm('tst-xpsp2-halacpi', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxp-halacpi.vdi',
+ sKind = 'WindowsXP', acCpusSup = range(1, 33), fIoApic = True),
+ TestVm('tst-xpsp2-halapic', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxp-halapic.vdi',
+ sKind = 'WindowsXP', acCpusSup = range(1, 33), fIoApic = True),
+ TestVm('tst-xpsp2-halmacpi', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxp-halmacpi.vdi',
+ sKind = 'WindowsXP', acCpusSup = range(2, 33), fIoApic = True),
+ TestVm('tst-xpsp2-halmps', kfGrpStdSmoke, sHd = '4.2/xpsp2/t-winxp-halmps.vdi',
+ sKind = 'WindowsXP', acCpusSup = range(2, 33), fIoApic = True),
+
+ # W2K3
+ TestVm('tst-win2k3ent', kfGrpSmoke, sHd = '3.0/tcp/win2k3ent-acpi.vdi',
+ sKind = 'Windows2003', acCpusSup = range(1, 33), fPae = True, sNic0AttachType = 'bridged'),
+
+ # W7
+ TestVm('tst-win7', kfGrpStdSmoke, sHd = '6.1/win7-32/t-win7-32-1.vdi',
+ sKind = 'Windows7', acCpusSup = range(1, 33), fIoApic = True),
+ # Note: Deprecated due to activation issues; use t-win7-32-1 instead.
+ #TestVm('tst-win7', kfGrpStdSmoke, sHd = '6.1/win7-32/t-win7-32.vdi',
+ # sKind = 'Windows7', acCpusSup = range(1, 33), fIoApic = True),
+ # Note: Deprecated; use the one in the 6.1 folder.
+ #TestVm('tst-win7', kfGrpStdSmoke, sHd = '4.2/win7-32/t-win7.vdi',
+ # sKind = 'Windows7', acCpusSup = range(1, 33), fIoApic = True),
+
+ # W8
+ TestVm('tst-win8-64', kfGrpStdSmoke, sHd = '4.2/win8-64/t-win8-64.vdi',
+ sKind = 'Windows8_64', acCpusSup = range(1, 33), fIoApic = True),
+ #TestVm('tst-win8-64-ich9', kfGrpStdSmoke, sHd = '4.2/win8-64/t-win8-64.vdi',
+ # sKind = 'Windows8_64', acCpusSup = range(1, 33), fIoApic = True, sChipsetType = 'ich9'),
+
+ # W10
+ TestVm('tst-win10-efi', kfGrpStdSmoke, sHd = '4.2/efi/win10-efi-x86.vdi',
+ sKind = 'Windows10', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi'),
+ TestVm('tst-win10-64-efi', kfGrpStdSmoke, sHd = '4.2/efi/win10-efi-amd64.vdi',
+ sKind = 'Windows10_64', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi'),
+ #TestVm('tst-win10-64-efi-ich9', kfGrpStdSmoke, sHd = '4.2/efi/win10-efi-amd64.vdi',
+ # sKind = 'Windows10_64', acCpusSup = range(1, 33), fIoApic = True, sFirmwareType = 'efi', sChipsetType = 'ich9'),
+
+ # Nested hardware-virtualization
+ TestVm('tst-nsthwvirt-ubuntu-64', kfGrpStdSmoke, sHd = '5.3/nat/nsthwvirt-ubuntu64/t-nsthwvirt-ubuntu64.vdi',
+ sKind = 'Ubuntu_64', acCpusSup = range(1, 2), asVirtModesSup = ['hwvirt-np',], fIoApic = True, fNstHwVirt = True,
+ sNic0AttachType = 'nat'),
+
+ # Audio testing.
+ TestVm('tst-audio-debian10-64', kfGrpStdSmoke, sHd = '6.1/audio/debian10-amd64-7.vdi',
+ sKind = 'Debian_64', acCpusSup = range(1, 33), fIoApic = True),
+
+ # DOS and Old Windows.
+ AncientTestVm('tst-dos20', sKind = 'DOS',
+ sHd = '5.2/great-old-ones/t-dos20/t-dos20.vdi'),
+ AncientTestVm('tst-dos401-win30me', sKind = 'DOS',
+ sHd = '5.2/great-old-ones/t-dos401-win30me/t-dos401-win30me.vdi', cMBRamMax = 4),
+ AncientTestVm('tst-dos401-emm386-win30me', sKind = 'DOS',
+ sHd = '5.2/great-old-ones/t-dos401-emm386-win30me/t-dos401-emm386-win30me.vdi', cMBRamMax = 4),
+ AncientTestVm('tst-dos50-win31', sKind = 'DOS',
+ sHd = '5.2/great-old-ones/t-dos50-win31/t-dos50-win31.vdi'),
+ AncientTestVm('tst-dos50-emm386-win31', sKind = 'DOS',
+ sHd = '5.2/great-old-ones/t-dos50-emm386-win31/t-dos50-emm386-win31.vdi'),
+ AncientTestVm('tst-dos622', sKind = 'DOS',
+ sHd = '5.2/great-old-ones/t-dos622/t-dos622.vdi'),
+ AncientTestVm('tst-dos622-emm386', sKind = 'DOS',
+ sHd = '5.2/great-old-ones/t-dos622-emm386/t-dos622-emm386.vdi'),
+ AncientTestVm('tst-dos71', sKind = 'DOS',
+ sHd = '5.2/great-old-ones/t-dos71/t-dos71.vdi'),
+
+ #AncientTestVm('tst-dos5-win311a', sKind = 'DOS', sHd = '5.2/great-old-ones/t-dos5-win311a/t-dos5-win311a.vdi'),
+ );
+
+
+ def __init__(self, sResourcePath):
+ self.sResourcePath = sResourcePath;
+
+ def selectSet(self, fGrouping, sTxsTransport = None, fCheckResources = True):
+ """
+ Returns a VM set with the selected VMs.
+ """
+ oSet = TestVmSet(oTestVmManager = self);
+ for oVm in self.kaTestVMs:
+ if oVm.fGrouping & fGrouping:
+ if sTxsTransport is None or oVm.sNic0AttachType is None or sTxsTransport == oVm.sNic0AttachType:
+ if not fCheckResources or not oVm.getMissingResources(self.sResourcePath):
+ oCopyVm = copy.deepcopy(oVm);
+ oCopyVm.oSet = oSet;
+ oSet.aoTestVms.append(oCopyVm);
+ return oSet;
+
+ def getStandardVmSet(self, sTxsTransport):
+ """
+ Gets the set of standard test VMs.
+
+ This is supposed to do something seriously clever, like searching the
+ testrsrc tree for usable VMs, but for the moment it's all hard coded. :-)
+ """
+ return self.selectSet(self.kfGrpStandard, sTxsTransport)
+
+ def getSmokeVmSet(self, sTxsTransport = None):
+ """Gets a representative set of VMs for smoke testing. """
+ return self.selectSet(self.kfGrpSmoke, sTxsTransport);
+
+ def shutUpPyLint(self):
+ """ Shut up already! """
+ return self.sResourcePath;