summaryrefslogtreecommitdiffstats
path: root/src/VBox/ValidationKit/testdriver
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
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')
-rw-r--r--src/VBox/ValidationKit/testdriver/Makefile.kmk48
-rw-r--r--src/VBox/ValidationKit/testdriver/__init__.py41
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/base.py1860
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/btresolver.py626
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/reporter.py1984
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/testfileset.py690
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/tst-txsclient.py315
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/txsclient.py2376
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/vbox.py4581
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/vboxcon.py94
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/vboxinstaller.py1251
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/vboxtestfileset.py149
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/vboxtestvms.py2105
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/vboxwrappers.py3666
-rw-r--r--src/VBox/ValidationKit/testdriver/win-vbox-net-drvstore-cleanup.ps171
-rw-r--r--src/VBox/ValidationKit/testdriver/win-vbox-net-uninstall.ps1253
-rwxr-xr-xsrc/VBox/ValidationKit/testdriver/winbase.py336
17 files changed, 20446 insertions, 0 deletions
diff --git a/src/VBox/ValidationKit/testdriver/Makefile.kmk b/src/VBox/ValidationKit/testdriver/Makefile.kmk
new file mode 100644
index 00000000..4247abd8
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/Makefile.kmk
@@ -0,0 +1,48 @@
+# $Id: Makefile.kmk $
+## @file
+# VirtualBox Validation Kit - Python Test Driver.
+#
+
+#
+# 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
+#
+
+SUB_DEPTH = ../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+
+VBOX_VALIDATIONKIT_PYTHON_SOURCES += $(filter-out %/winbase.py %/vboxcon.py, $(wildcard $(PATH_SUB_CURRENT)/*.py))
+ifeq ($(KBUILD_HOST),win)
+ VBOX_VALIDATIONKIT_PYTHON_SOURCES += $(PATH_SUB_CURRENT)/winbase.py
+endif
+
+$(evalcall def_vbox_validationkit_process_python_sources)
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/ValidationKit/testdriver/__init__.py b/src/VBox/ValidationKit/testdriver/__init__.py
new file mode 100644
index 00000000..0214450b
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/__init__.py
@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+# $Id: __init__.py $
+
+"""
+Test driver package
+"""
+
+__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 $";
+
diff --git a/src/VBox/ValidationKit/testdriver/base.py b/src/VBox/ValidationKit/testdriver/base.py
new file mode 100755
index 00000000..e7bd49de
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/base.py
@@ -0,0 +1,1860 @@
+# -*- coding: utf-8 -*-
+# $Id: base.py $
+# pylint: disable=too-many-lines
+
+"""
+Base testdriver module.
+"""
+
+__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 os
+import os.path
+import signal
+import socket
+import stat
+import subprocess
+import sys
+import time
+if sys.version_info[0] < 3: import thread; # pylint: disable=import-error
+else: import _thread as thread; # pylint: disable=import-error
+import threading
+import traceback
+import tempfile;
+import unittest;
+
+# Validation Kit imports.
+from common import utils;
+from common.constants import rtexitcode;
+from testdriver import reporter;
+if sys.platform == 'win32':
+ from testdriver import winbase;
+
+# Figure where we are.
+try: __file__
+except: __file__ = sys.argv[0];
+g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)));
+
+# Python 3 hacks:
+if sys.version_info[0] >= 3:
+ long = int; # pylint: disable=redefined-builtin,invalid-name
+
+
+#
+# Some utility functions.
+#
+
+def exeSuff():
+ """
+ Returns the executable suffix.
+ """
+ if os.name in ('nt', 'os2'):
+ return '.exe';
+ return '';
+
+def searchPath(sExecName):
+ """
+ Searches the PATH for the specified executable name, returning the first
+ existing file/directory/whatever. The return is abspath'ed.
+ """
+ sSuff = exeSuff();
+
+ sPath = os.getenv('PATH', os.getenv('Path', os.path.defpath));
+ aPaths = sPath.split(os.path.pathsep)
+ for sDir in aPaths:
+ sFullExecName = os.path.join(sDir, sExecName);
+ if os.path.exists(sFullExecName):
+ return os.path.abspath(sFullExecName);
+ sFullExecName += sSuff;
+ if os.path.exists(sFullExecName):
+ return os.path.abspath(sFullExecName);
+ return sExecName;
+
+def getEnv(sVar, sLocalAlternative = None):
+ """
+ Tries to get an environment variable, optionally with a local run alternative.
+ Will raise an exception if sLocalAlternative is None and the variable is
+ empty or missing.
+ """
+ try:
+ sVal = os.environ.get(sVar, None);
+ if sVal is None:
+ raise GenError('environment variable "%s" is missing' % (sVar));
+ if sVal == "":
+ raise GenError('environment variable "%s" is empty' % (sVar));
+ except:
+ if sLocalAlternative is None or not reporter.isLocal():
+ raise
+ sVal = sLocalAlternative;
+ return sVal;
+
+def getDirEnv(sVar, sAlternative = None, fLocalReq = False, fTryCreate = False):
+ """
+ Tries to get an environment variable specifying a directory path.
+
+ Resolves it into an absolute path and verifies its existance before
+ returning it.
+
+ If the environment variable is empty or isn't set, or if the directory
+ doesn't exist or isn't a directory, sAlternative is returned instead.
+ If sAlternative is None, then we'll raise a GenError. For local runs we'll
+ only do this if fLocalReq is True.
+ """
+ assert sAlternative is None or fTryCreate is False;
+ try:
+ sVal = os.environ.get(sVar, None);
+ if sVal is None:
+ raise GenError('environment variable "%s" is missing' % (sVar));
+ if sVal == "":
+ raise GenError('environment variable "%s" is empty' % (sVar));
+
+ sVal = os.path.abspath(sVal);
+ if not os.path.isdir(sVal):
+ if not fTryCreate or os.path.exists(sVal):
+ reporter.error('the value of env.var. "%s" is not a dir: "%s"' % (sVar, sVal));
+ raise GenError('the value of env.var. "%s" is not a dir: "%s"' % (sVar, sVal));
+ try:
+ os.makedirs(sVal, 0o700);
+ except:
+ reporter.error('makedirs failed on the value of env.var. "%s": "%s"' % (sVar, sVal));
+ raise GenError('makedirs failed on the value of env.var. "%s": "%s"' % (sVar, sVal));
+ except:
+ if sAlternative is None:
+ if reporter.isLocal() and fLocalReq:
+ raise;
+ sVal = None;
+ else:
+ sVal = os.path.abspath(sAlternative);
+ return sVal;
+
+def timestampMilli():
+ """
+ Gets a millisecond timestamp.
+ """
+ return utils.timestampMilli();
+
+def timestampNano():
+ """
+ Gets a nanosecond timestamp.
+ """
+ return utils.timestampNano();
+
+def tryGetHostByName(sName):
+ """
+ Wrapper around gethostbyname.
+ """
+ if sName is not None:
+ try:
+ sIpAddr = socket.gethostbyname(sName);
+ except:
+ reporter.errorXcpt('gethostbyname(%s)' % (sName));
+ else:
+ if sIpAddr != '0.0.0.0':
+ sName = sIpAddr;
+ else:
+ reporter.error('gethostbyname(%s) -> %s' % (sName, sIpAddr));
+ return sName;
+
+def __processSudoKill(uPid, iSignal, fSudo):
+ """
+ Does the sudo kill -signal pid thing if fSudo is true, else uses os.kill.
+ """
+ try:
+ if fSudo:
+ return utils.sudoProcessCall(['/bin/kill', '-%s' % (iSignal,), str(uPid)]) == 0;
+ os.kill(uPid, iSignal);
+ return True;
+ except:
+ reporter.logXcpt('uPid=%s' % (uPid,));
+ return False;
+
+def processInterrupt(uPid, fSudo = False):
+ """
+ Sends a SIGINT or equivalent to interrupt the specified process.
+ Returns True on success, False on failure.
+
+ On Windows hosts this may not work unless the process happens to be a
+ process group leader.
+ """
+ if sys.platform == 'win32':
+ fRc = winbase.processInterrupt(uPid)
+ else:
+ fRc = __processSudoKill(uPid, signal.SIGINT, fSudo);
+ return fRc;
+
+def sendUserSignal1(uPid, fSudo = False):
+ """
+ Sends a SIGUSR1 or equivalent to nudge the process into shutting down
+ (VBoxSVC) or something.
+ Returns True on success, False on failure or if not supported (win).
+
+ On Windows hosts this may not work unless the process happens to be a
+ process group leader.
+ """
+ if sys.platform == 'win32':
+ fRc = False;
+ else:
+ fRc = __processSudoKill(uPid, signal.SIGUSR1, fSudo); # pylint: disable=no-member
+ return fRc;
+
+def processTerminate(uPid, fSudo = False):
+ """
+ Terminates the process in a nice manner (SIGTERM or equivalent).
+ Returns True on success, False on failure (logged).
+ """
+ fRc = False;
+ if sys.platform == 'win32':
+ fRc = winbase.processTerminate(uPid);
+ else:
+ fRc = __processSudoKill(uPid, signal.SIGTERM, fSudo);
+ return fRc;
+
+def processKill(uPid, fSudo = False):
+ """
+ Terminates the process with extreme prejudice (SIGKILL).
+ Returns True on success, False on failure.
+ """
+ fRc = False;
+ if sys.platform == 'win32':
+ fRc = winbase.processKill(uPid);
+ else:
+ fRc = __processSudoKill(uPid, signal.SIGKILL, fSudo); # pylint: disable=no-member
+ return fRc;
+
+def processKillWithNameCheck(uPid, sName):
+ """
+ Like processKill(), but checks if the process name matches before killing
+ it. This is intended for killing using potentially stale pid values.
+
+ Returns True on success, False on failure.
+ """
+
+ if processCheckPidAndName(uPid, sName) is not True:
+ return False;
+ return processKill(uPid);
+
+
+def processExists(uPid):
+ """
+ Checks if the specified process exits.
+ This will only work if we can signal/open the process.
+
+ Returns True if it positively exists, False otherwise.
+ """
+ return utils.processExists(uPid);
+
+def processCheckPidAndName(uPid, sName):
+ """
+ Checks if a process PID and NAME matches.
+ """
+ if sys.platform == 'win32':
+ fRc = winbase.processCheckPidAndName(uPid, sName);
+ else:
+ sOs = utils.getHostOs();
+ if sOs == 'linux':
+ asPsCmd = ['/bin/ps', '-p', '%u' % (uPid,), '-o', 'fname='];
+ elif sOs == 'solaris':
+ asPsCmd = ['/usr/bin/ps', '-p', '%u' % (uPid,), '-o', 'fname='];
+ elif sOs == 'darwin':
+ asPsCmd = ['/bin/ps', '-p', '%u' % (uPid,), '-o', 'ucomm='];
+ else:
+ asPsCmd = None;
+
+ if asPsCmd is not None:
+ try:
+ oPs = subprocess.Popen(asPsCmd, stdout=subprocess.PIPE); # pylint: disable=consider-using-with
+ sCurName = oPs.communicate()[0];
+ iExitCode = oPs.wait();
+ except:
+ reporter.logXcpt();
+ return False;
+
+ # ps fails with non-zero exit code if the pid wasn't found.
+ if iExitCode != 0:
+ return False;
+ if sCurName is None:
+ return False;
+ sCurName = sCurName.strip();
+ if sCurName == '':
+ return False;
+
+ if os.path.basename(sName) == sName:
+ sCurName = os.path.basename(sCurName);
+ elif os.path.basename(sCurName) == sCurName:
+ sName = os.path.basename(sName);
+
+ if sCurName != sName:
+ return False;
+
+ fRc = True;
+ return fRc;
+
+def wipeDirectory(sDir):
+ """
+ Deletes all file and sub-directories in sDir, leaving sDir in empty afterwards.
+ Returns the number of errors after logging them as errors.
+ """
+ if not os.path.exists(sDir):
+ return 0;
+
+ try:
+ asNames = os.listdir(sDir);
+ except:
+ return reporter.errorXcpt('os.listdir("%s")' % (sDir));
+
+ cErrors = 0;
+ for sName in asNames:
+ # Build full path and lstat the object.
+ sFullName = os.path.join(sDir, sName)
+ try:
+ oStat = os.lstat(sFullName);
+ except:
+ reporter.errorXcpt('lstat("%s")' % (sFullName,));
+ cErrors = cErrors + 1;
+ continue;
+
+ if stat.S_ISDIR(oStat.st_mode):
+ # Directory - recurse and try remove it.
+ cErrors = cErrors + wipeDirectory(sFullName);
+ try:
+ os.rmdir(sFullName);
+ except:
+ reporter.errorXcpt('rmdir("%s")' % (sFullName,));
+ cErrors = cErrors + 1;
+ else:
+ # File, symlink, fifo or something - remove/unlink.
+ try:
+ os.remove(sFullName);
+ except:
+ reporter.errorXcpt('remove("%s")' % (sFullName,));
+ cErrors = cErrors + 1;
+ return cErrors;
+
+
+#
+# Classes
+#
+
+class GenError(Exception):
+ """
+ Exception class which only purpose it is to allow us to only catch our own
+ exceptions. Better design later.
+ """
+
+ def __init__(self, sWhat = "whatever"):
+ Exception.__init__(self);
+ self.sWhat = sWhat
+
+ def str(self):
+ """Get the message string."""
+ return self.sWhat;
+
+
+class InvalidOption(GenError):
+ """
+ Exception thrown by TestDriverBase.parseOption(). It contains the error message.
+ """
+ def __init__(self, sWhat):
+ GenError.__init__(self, sWhat);
+
+
+class QuietInvalidOption(GenError):
+ """
+ Exception thrown by TestDriverBase.parseOption(). Error already printed, just
+ return failure.
+ """
+ def __init__(self):
+ GenError.__init__(self, "");
+
+
+class TdTaskBase(object):
+ """
+ The base task.
+ """
+
+ def __init__(self, sCaller, fnProcessEvents = None):
+ self.sDbgCreated = '%s: %s' % (utils.getTimePrefix(), sCaller);
+ self.fSignalled = False;
+ self.__oRLock = threading.RLock();
+ self.oCv = threading.Condition(self.__oRLock);
+ self.oOwner = None;
+ self.msStart = timestampMilli();
+ self.oLocker = None;
+
+ ## Callback function that takes no parameters and will not be called holding the lock.
+ ## It is a hack to work the XPCOM and COM event queues, so we won't hold back events
+ ## that could block task progress (i.e. hangs VM).
+ self.fnProcessEvents = fnProcessEvents;
+
+ def __del__(self):
+ """In case we need it later on."""
+ pass; # pylint: disable=unnecessary-pass
+
+ def toString(self):
+ """
+ Stringifies the object, mostly as a debug aid.
+ """
+ return '<%s: fSignalled=%s, __oRLock=%s, oCv=%s, oOwner=%s, oLocker=%s, msStart=%s, sDbgCreated=%s>' \
+ % (type(self).__name__, self.fSignalled, self.__oRLock, self.oCv, repr(self.oOwner), self.oLocker, self.msStart,
+ self.sDbgCreated,);
+
+ def __str__(self):
+ return self.toString();
+
+ def lockTask(self):
+ """ Wrapper around oCv.acquire(). """
+ if True is True: # change to False for debugging deadlocks. # pylint: disable=comparison-with-itself
+ self.oCv.acquire();
+ else:
+ msStartWait = timestampMilli();
+ while self.oCv.acquire(0) is False:
+ if timestampMilli() - msStartWait > 30*1000:
+ reporter.error('!!! timed out waiting for %s' % (self, ));
+ traceback.print_stack();
+ reporter.logAllStacks()
+ self.oCv.acquire();
+ break;
+ time.sleep(0.5);
+ self.oLocker = thread.get_ident()
+ return None;
+
+ def unlockTask(self):
+ """ Wrapper around oCv.release(). """
+ self.oLocker = None;
+ self.oCv.release();
+ return None;
+
+ def getAgeAsMs(self):
+ """
+ Returns the number of milliseconds the task has existed.
+ """
+ return timestampMilli() - self.msStart;
+
+ def setTaskOwner(self, oOwner):
+ """
+ Sets or clears the task owner. (oOwner can be None.)
+
+ Returns the previous owner, this means None if not owned.
+ """
+ self.lockTask();
+ oOldOwner = self.oOwner;
+ self.oOwner = oOwner;
+ self.unlockTask();
+ return oOldOwner;
+
+ def signalTaskLocked(self):
+ """
+ Variant of signalTask that can be called while owning the lock.
+ """
+ fOld = self.fSignalled;
+ if not fOld:
+ reporter.log2('signalTaskLocked(%s)' % (self,));
+ self.fSignalled = True;
+ self.oCv.notifyAll(); # pylint: disable=deprecated-method
+ if self.oOwner is not None:
+ self.oOwner.notifyAboutReadyTask(self);
+ return fOld;
+
+ def signalTask(self):
+ """
+ Signals the task, internal use only.
+
+ Returns the previous state.
+ """
+ self.lockTask();
+ fOld = self.signalTaskLocked();
+ self.unlockTask();
+ return fOld
+
+ def resetTaskLocked(self):
+ """
+ Variant of resetTask that can be called while owning the lock.
+ """
+ fOld = self.fSignalled;
+ self.fSignalled = False;
+ return fOld;
+
+ def resetTask(self):
+ """
+ Resets the task signal, internal use only.
+
+ Returns the previous state.
+ """
+ self.lockTask();
+ fOld = self.resetTaskLocked();
+ self.unlockTask();
+ return fOld
+
+ def pollTask(self, fLocked = False):
+ """
+ Poll the signal status of the task.
+ Returns True if signalled, False if not.
+
+ Override this method.
+ """
+ if not fLocked:
+ self.lockTask();
+ fState = self.fSignalled;
+ if not fLocked:
+ self.unlockTask();
+ return fState
+
+ def waitForTask(self, cMsTimeout = 0):
+ """
+ Waits for the task to be signalled.
+
+ Returns True if the task is/became ready before the timeout expired.
+ Returns False if the task is still not after cMsTimeout have elapsed.
+
+ Overriable.
+ """
+ if self.fnProcessEvents:
+ self.fnProcessEvents();
+
+ self.lockTask();
+
+ fState = self.pollTask(True);
+ if not fState:
+ # Don't wait more than 1s. This allow lazy state polling and avoid event processing trouble.
+ msStart = timestampMilli();
+ while not fState:
+ cMsElapsed = timestampMilli() - msStart;
+ if cMsElapsed >= cMsTimeout:
+ break;
+
+ cMsWait = cMsTimeout - cMsElapsed
+ cMsWait = min(cMsWait, 1000);
+ try:
+ self.oCv.wait(cMsWait / 1000.0);
+ except:
+ pass;
+
+ if self.fnProcessEvents:
+ self.unlockTask();
+ self.fnProcessEvents();
+ self.lockTask();
+
+ reporter.doPollWork('TdTaskBase.waitForTask');
+ fState = self.pollTask(True);
+
+ self.unlockTask();
+
+ if self.fnProcessEvents:
+ self.fnProcessEvents();
+
+ return fState;
+
+
+class Process(TdTaskBase):
+ """
+ Child Process.
+ """
+
+ def __init__(self, sName, asArgs, uPid, hWin = None, uTid = None):
+ TdTaskBase.__init__(self, utils.getCallerName());
+ self.sName = sName;
+ self.asArgs = asArgs;
+ self.uExitCode = -127;
+ self.uPid = uPid;
+ self.hWin = hWin;
+ self.uTid = uTid;
+ self.sKindCrashReport = None;
+ self.sKindCrashDump = None;
+
+ def toString(self):
+ return '<%s uExitcode=%s, uPid=%s, sName=%s, asArgs=%s, hWin=%s, uTid=%s>' \
+ % (TdTaskBase.toString(self), self.uExitCode, self.uPid, self.sName, self.asArgs, self.hWin, self.uTid);
+
+ #
+ # Instantiation methods.
+ #
+
+ @staticmethod
+ def spawn(sName, *asArgsIn):
+ """
+ Similar to os.spawnl(os.P_NOWAIT,).
+
+ """
+ # Make argument array (can probably use asArgsIn directly, but wtf).
+ asArgs = [];
+ for sArg in asArgsIn:
+ asArgs.append(sArg);
+
+ # Special case: Windows.
+ if sys.platform == 'win32':
+ (uPid, hProcess, uTid) = winbase.processCreate(searchPath(sName), asArgs);
+ if uPid == -1:
+ return None;
+ return Process(sName, asArgs, uPid, hProcess, uTid);
+
+ # Unixy.
+ try:
+ uPid = os.spawnv(os.P_NOWAIT, sName, asArgs);
+ except:
+ reporter.logXcpt('sName=%s' % (sName,));
+ return None;
+ return Process(sName, asArgs, uPid);
+
+ @staticmethod
+ def spawnp(sName, *asArgsIn):
+ """
+ Similar to os.spawnlp(os.P_NOWAIT,).
+
+ """
+ return Process.spawn(searchPath(sName), *asArgsIn);
+
+ #
+ # Task methods
+ #
+
+ def pollTask(self, fLocked = False):
+ """
+ Overridden pollTask method.
+ """
+ if not fLocked:
+ self.lockTask();
+
+ fRc = self.fSignalled;
+ if not fRc:
+ if sys.platform == 'win32':
+ if winbase.processPollByHandle(self.hWin):
+ try:
+ if hasattr(self.hWin, '__int__'): # Needed for newer pywin32 versions.
+ (uPid, uStatus) = os.waitpid(self.hWin.__int__(), 0);
+ else:
+ (uPid, uStatus) = os.waitpid(self.hWin, 0);
+ if uPid in (self.hWin, self.uPid,):
+ self.hWin.Detach(); # waitpid closed it, so it's now invalid.
+ self.hWin = None;
+ uPid = self.uPid;
+ except:
+ reporter.logXcpt();
+ uPid = self.uPid;
+ uStatus = 0xffffffff;
+ else:
+ uPid = 0;
+ uStatus = 0; # pylint: disable=redefined-variable-type
+ else:
+ try:
+ (uPid, uStatus) = os.waitpid(self.uPid, os.WNOHANG); # pylint: disable=no-member
+ except:
+ reporter.logXcpt();
+ uPid = self.uPid;
+ uStatus = 0xffffffff;
+
+ # Got anything?
+ if uPid == self.uPid:
+ self.uExitCode = uStatus;
+ reporter.log('Process %u -> %u (%#x)' % (uPid, uStatus, uStatus));
+ self.signalTaskLocked();
+ if self.uExitCode != 0 and (self.sKindCrashReport is not None or self.sKindCrashDump is not None):
+ reporter.error('Process "%s" returned/crashed with a non-zero status code!! rc=%u sig=%u%s (raw=%#x)'
+ % ( self.sName, self.uExitCode >> 8, self.uExitCode & 0x7f,
+ ' w/ core' if self.uExitCode & 0x80 else '', self.uExitCode))
+ utils.processCollectCrashInfo(self.uPid, reporter.log, self._addCrashFile);
+
+ fRc = self.fSignalled;
+ if not fLocked:
+ self.unlockTask();
+ return fRc;
+
+ def _addCrashFile(self, sFile, fBinary):
+ """
+ Helper for adding a crash report or dump to the test report.
+ """
+ sKind = self.sKindCrashDump if fBinary else self.sKindCrashReport;
+ if sKind is not None:
+ reporter.addLogFile(sFile, sKind);
+ return None;
+
+
+ #
+ # Methods
+ #
+
+ def enableCrashReporting(self, sKindCrashReport, sKindCrashDump):
+ """
+ Enabling (or disables) automatic crash reporting on systems where that
+ is possible. The two file kind parameters are on the form
+ 'crash/log/client' and 'crash/dump/client'. If both are None,
+ reporting will be disabled.
+ """
+ self.sKindCrashReport = sKindCrashReport;
+ self.sKindCrashDump = sKindCrashDump;
+
+ sCorePath = None;
+ sOs = utils.getHostOs();
+ if sOs == 'solaris':
+ if sKindCrashDump is not None: # Enable.
+ sCorePath = getDirEnv('TESTBOX_PATH_SCRATCH', sAlternative = '/var/cores', fTryCreate = False);
+ (iExitCode, _, sErr) = utils.processOutputUnchecked([ 'coreadm', '-e', 'global', '-e', 'global-setid', \
+ '-e', 'process', '-e', 'proc-setid', \
+ '-g', os.path.join(sCorePath, '%f.%p.core')]);
+ else: # Disable.
+ (iExitCode, _, sErr) = utils.processOutputUnchecked([ 'coreadm', \
+ '-d', 'global', '-d', 'global-setid', \
+ '-d', 'process', '-d', 'proc-setid' ]);
+ if iExitCode != 0: # Don't report an actual error, just log this.
+ reporter.log('%s coreadm failed: %s' % ('Enabling' if sKindCrashDump else 'Disabling', sErr));
+
+ if sKindCrashDump is not None:
+ if sCorePath is not None:
+ reporter.log('Crash dumps enabled -- path is "%s"' % (sCorePath,));
+ else:
+ reporter.log('Crash dumps disabled');
+
+ return True;
+
+ def isRunning(self):
+ """
+ Returns True if the process is still running, False if not.
+ """
+ return not self.pollTask();
+
+ def wait(self, cMsTimeout = 0):
+ """
+ Wait for the process to exit.
+
+ Returns True if the process exited withint the specified wait period.
+ Returns False if still running.
+ """
+ return self.waitForTask(cMsTimeout);
+
+ def getExitCode(self):
+ """
+ Returns the exit code of the process.
+ The process must have exited or the result will be wrong.
+ """
+ if self.isRunning():
+ return -127;
+ return self.uExitCode >> 8;
+
+ def isNormalExit(self):
+ """
+ Returns True if regular exit(), False if signal or still running.
+ """
+ if self.isRunning():
+ return False;
+ if sys.platform == 'win32':
+ return True;
+ return os.WIFEXITED(self.uExitCode); # pylint: disable=no-member
+
+ def interrupt(self):
+ """
+ Sends a SIGINT or equivalent to interrupt the process.
+ Returns True on success, False on failure.
+
+ On Windows hosts this may not work unless the process happens to be a
+ process group leader.
+ """
+ if sys.platform == 'win32':
+ return winbase.postThreadMesssageQuit(self.uTid);
+ return processInterrupt(self.uPid);
+
+ def sendUserSignal1(self):
+ """
+ Sends a SIGUSR1 or equivalent to nudge the process into shutting down
+ (VBoxSVC) or something.
+ Returns True on success, False on failure.
+
+ On Windows hosts this may not work unless the process happens to be a
+ process group leader.
+ """
+ #if sys.platform == 'win32':
+ # return winbase.postThreadMesssageClose(self.uTid);
+ return sendUserSignal1(self.uPid);
+
+ def terminate(self):
+ """
+ Terminates the process in a nice manner (SIGTERM or equivalent).
+ Returns True on success, False on failure (logged).
+ """
+ if sys.platform == 'win32':
+ return winbase.processTerminateByHandle(self.hWin);
+ return processTerminate(self.uPid);
+
+ def getPid(self):
+ """ Returns the process id. """
+ return self.uPid;
+
+
+class SubTestDriverBase(object):
+ """
+ The base sub-test driver.
+
+ It helps thinking of these as units/sets/groups of tests, where the test
+ cases are (mostly) realized in python.
+
+ The sub-test drivers are subordinates of one or more test drivers. They
+ can be viewed as test code libraries that is responsible for parts of a
+ test driver run in different setups. One example would be testing a guest
+ additions component, which is applicable both to freshly installed guest
+ additions and VMs with old guest.
+
+ The test drivers invokes the sub-test drivers in a private manner during
+ test execution, but some of the generic bits are done automagically by the
+ base class: options, help, resources, various other actions.
+ """
+
+ def __init__(self, oTstDrv, sName, sTestName):
+ self.oTstDrv = oTstDrv # type: TestDriverBase
+ self.sName = sName; # For use with options (--enable-sub-driver sName:sName2)
+ self.sTestName = sTestName; # More descriptive for passing to reporter.testStart().
+ self.asRsrcs = [] # type: List(str)
+ self.fEnabled = True; # TestDriverBase --enable-sub-driver and --disable-sub-driver.
+
+ def showUsage(self):
+ """
+ Show usage information if any.
+
+ The default implementation only prints the name.
+ """
+ reporter.log('');
+ reporter.log('Options for sub-test driver %s (%s):' % (self.sTestName, self.sName,));
+ return True;
+
+ def parseOption(self, asArgs, iArg):
+ """
+ Parse an option. Override this.
+
+ @param asArgs The argument vector.
+ @param iArg The index of the current argument.
+
+ @returns The index of the next argument if consumed, @a iArg if not.
+
+ @throws InvalidOption or QuietInvalidOption on syntax error or similar.
+ """
+ _ = asArgs;
+ return iArg;
+
+
+class TestDriverBase(object): # pylint: disable=too-many-instance-attributes
+ """
+ The base test driver.
+ """
+
+ def __init__(self):
+ self.fInterrupted = False;
+
+ # Actions.
+ self.asSpecialActions = ['extract', 'abort'];
+ self.asNormalActions = ['cleanup-before', 'verify', 'config', 'execute', 'cleanup-after' ];
+ self.asActions = [];
+ self.sExtractDstPath = None;
+
+ # Options.
+ self.fNoWipeClean = False;
+
+ # Tasks - only accessed by one thread atm, so no need for locking.
+ self.aoTasks = [];
+
+ # Host info.
+ self.sHost = utils.getHostOs();
+ self.sHostArch = utils.getHostArch();
+
+ # Skipped status modifier (see end of innerMain()).
+ self.fBadTestbox = False;
+
+ #
+ # Get our bearings and adjust the environment.
+ #
+ if not utils.isRunningFromCheckout():
+ self.sBinPath = os.path.join(g_ksValidationKitDir, utils.getHostOs(), utils.getHostArch());
+ else:
+ self.sBinPath = os.path.join(g_ksValidationKitDir, os.pardir, os.pardir, os.pardir, 'out', utils.getHostOsDotArch(),
+ os.environ.get('KBUILD_TYPE', 'debug'),
+ 'validationkit', utils.getHostOs(), utils.getHostArch());
+ self.sOrgShell = os.environ.get('SHELL');
+ self.sOurShell = os.path.join(self.sBinPath, 'vts_shell' + exeSuff()); # No shell yet.
+ os.environ['SHELL'] = self.sOurShell;
+
+ self.sScriptPath = getDirEnv('TESTBOX_PATH_SCRIPTS');
+ if self.sScriptPath is None:
+ self.sScriptPath = os.path.abspath(os.path.join(os.getcwd(), '..'));
+ os.environ['TESTBOX_PATH_SCRIPTS'] = self.sScriptPath;
+
+ self.sScratchPath = getDirEnv('TESTBOX_PATH_SCRATCH', fTryCreate = True);
+ if self.sScratchPath is None:
+ sTmpDir = tempfile.gettempdir();
+ if sTmpDir == '/tmp': # /var/tmp is generally more suitable on all platforms.
+ sTmpDir = '/var/tmp';
+ self.sScratchPath = os.path.abspath(os.path.join(sTmpDir, 'VBoxTestTmp'));
+ if not os.path.isdir(self.sScratchPath):
+ os.makedirs(self.sScratchPath, 0o700);
+ os.environ['TESTBOX_PATH_SCRATCH'] = self.sScratchPath;
+
+ self.sTestBoxName = getEnv( 'TESTBOX_NAME', 'local');
+ self.sTestSetId = getEnv( 'TESTBOX_TEST_SET_ID', 'local');
+ self.sBuildPath = getDirEnv('TESTBOX_PATH_BUILDS');
+ self.sUploadPath = getDirEnv('TESTBOX_PATH_UPLOAD');
+ self.sResourcePath = getDirEnv('TESTBOX_PATH_RESOURCES');
+ if self.sResourcePath is None:
+ if self.sHost == 'darwin': self.sResourcePath = "/Volumes/testrsrc/";
+ elif self.sHost == 'freebsd': self.sResourcePath = "/mnt/testrsrc/";
+ elif self.sHost == 'linux': self.sResourcePath = "/mnt/testrsrc/";
+ elif self.sHost == 'os2': self.sResourcePath = "T:/";
+ elif self.sHost == 'solaris': self.sResourcePath = "/mnt/testrsrc/";
+ elif self.sHost == 'win': self.sResourcePath = "T:/";
+ else: raise GenError('unknown host OS "%s"' % (self.sHost));
+
+ # PID file for the testdriver.
+ self.sPidFile = os.path.join(self.sScratchPath, 'testdriver.pid');
+
+ # Some stuff for the log...
+ reporter.log('scratch: %s' % (self.sScratchPath,));
+
+ # Get the absolute timeout (seconds since epoch, see
+ # utils.timestampSecond()). None if not available.
+ self.secTimeoutAbs = os.environ.get('TESTBOX_TIMEOUT_ABS', None);
+ if self.secTimeoutAbs is not None:
+ self.secTimeoutAbs = long(self.secTimeoutAbs);
+ reporter.log('secTimeoutAbs: %s' % (self.secTimeoutAbs,));
+ else:
+ reporter.log('TESTBOX_TIMEOUT_ABS not found in the environment');
+
+ # Distance from secTimeoutAbs that timeouts should be adjusted to.
+ self.secTimeoutFudge = 30;
+
+ # List of sub-test drivers (SubTestDriverBase derivatives).
+ self.aoSubTstDrvs = [] # type: list(SubTestDriverBase)
+
+ # Use the scratch path for temporary files.
+ if self.sHost in ['win', 'os2']:
+ os.environ['TMP'] = self.sScratchPath;
+ os.environ['TEMP'] = self.sScratchPath;
+ os.environ['TMPDIR'] = self.sScratchPath;
+ os.environ['IPRT_TMPDIR'] = self.sScratchPath; # IPRT/VBox specific.
+
+
+ #
+ # Resource utility methods.
+ #
+
+ def isResourceFile(self, sFile):
+ """
+ Checks if sFile is in in the resource set.
+ """
+ ## @todo need to deal with stuff in the validationkit.zip and similar.
+ asRsrcs = self.getResourceSet();
+ if sFile in asRsrcs:
+ return os.path.isfile(os.path.join(self.sResourcePath, sFile));
+ for sRsrc in asRsrcs:
+ if sFile.startswith(sRsrc):
+ sFull = os.path.join(self.sResourcePath, sRsrc);
+ if os.path.isdir(sFull):
+ return os.path.isfile(os.path.join(self.sResourcePath, sRsrc));
+ return False;
+
+ def getFullResourceName(self, sName):
+ """
+ Returns the full resource name.
+ """
+ if os.path.isabs(sName): ## @todo Hack. Need to deal properly with stuff in the validationkit.zip and similar.
+ return sName;
+ return os.path.join(self.sResourcePath, sName);
+
+ #
+ # Scratch related utility methods.
+ #
+
+ def wipeScratch(self):
+ """
+ Removes the content of the scratch directory.
+ Returns True on no errors, False + log entries on errors.
+ """
+ cErrors = wipeDirectory(self.sScratchPath);
+ return cErrors == 0;
+
+ #
+ # Sub-test driver related methods.
+ #
+
+ def addSubTestDriver(self, oSubTstDrv):
+ """
+ Adds a sub-test driver.
+
+ Returns True on success, false on failure.
+ """
+ assert isinstance(oSubTstDrv, SubTestDriverBase);
+ if oSubTstDrv in self.aoSubTstDrvs:
+ reporter.error('Attempt at adding sub-test driver %s twice.' % (oSubTstDrv.sName,));
+ return False;
+ self.aoSubTstDrvs.append(oSubTstDrv);
+ return True;
+
+ def showSubTstDrvUsage(self):
+ """
+ Shows the usage of the sub-test drivers.
+ """
+ for oSubTstDrv in self.aoSubTstDrvs:
+ oSubTstDrv.showUsage();
+ return True;
+
+ def subTstDrvParseOption(self, asArgs, iArgs):
+ """
+ Lets the sub-test drivers have a go at the option.
+ Returns the index of the next option if handled, otherwise iArgs.
+ """
+ for oSubTstDrv in self.aoSubTstDrvs:
+ iNext = oSubTstDrv.parseOption(asArgs, iArgs)
+ if iNext != iArgs:
+ assert iNext > iArgs;
+ assert iNext <= len(asArgs);
+ return iNext;
+ return iArgs;
+
+ def findSubTstDrvByShortName(self, sShortName):
+ """
+ Locates a sub-test driver by it's short name.
+ Returns sub-test driver object reference if found, None if not.
+ """
+ for oSubTstDrv in self.aoSubTstDrvs:
+ if oSubTstDrv.sName == sShortName:
+ return oSubTstDrv;
+ return None;
+
+
+ #
+ # Task related methods.
+ #
+
+ def addTask(self, oTask):
+ """
+ Adds oTask to the task list.
+
+ Returns True if the task was added.
+
+ Returns False if the task was already in the task list.
+ """
+ if oTask in self.aoTasks:
+ return False;
+ #reporter.log2('adding task %s' % (oTask,));
+ self.aoTasks.append(oTask);
+ oTask.setTaskOwner(self);
+ #reporter.log2('tasks now in list: %d - %s' % (len(self.aoTasks), self.aoTasks));
+ return True;
+
+ def removeTask(self, oTask):
+ """
+ Removes oTask to the task list.
+
+ Returns oTask on success and None on failure.
+ """
+ try:
+ #reporter.log2('removing task %s' % (oTask,));
+ self.aoTasks.remove(oTask);
+ except:
+ return None;
+ else:
+ oTask.setTaskOwner(None);
+ #reporter.log2('tasks left: %d - %s' % (len(self.aoTasks), self.aoTasks));
+ return oTask;
+
+ def removeAllTasks(self):
+ """
+ Removes all the task from the task list.
+
+ Returns None.
+ """
+ aoTasks = self.aoTasks;
+ self.aoTasks = [];
+ for oTask in aoTasks:
+ oTask.setTaskOwner(None);
+ return None;
+
+ def notifyAboutReadyTask(self, oTask):
+ """
+ Notificiation that there is a ready task. May be called owning the
+ task lock, so be careful wrt deadlocks.
+
+ Remember to call super when overriding this.
+ """
+ if oTask is None: pass; # lint
+ return None;
+
+ def pollTasks(self):
+ """
+ Polls the task to see if any of them are ready.
+ Returns the ready task, None if none are ready.
+ """
+ for oTask in self.aoTasks:
+ if oTask.pollTask():
+ return oTask;
+ return None;
+
+ def waitForTasksSleepWorker(self, cMsTimeout):
+ """
+ Overridable method that does the sleeping for waitForTask().
+
+ cMsTimeout will not be larger than 1000, so there is normally no need
+ to do any additional splitting up of the polling interval.
+
+ Returns True if cMillieSecs elapsed.
+ Returns False if some exception was raised while we waited or
+ there turned out to be nothing to wait on.
+ """
+ try:
+ self.aoTasks[0].waitForTask(cMsTimeout);
+ return True;
+ except Exception as oXcpt:
+ reporter.log("waitForTasksSleepWorker: %s" % (str(oXcpt),));
+ return False;
+
+ def waitForTasks(self, cMsTimeout):
+ """
+ Waits for any of the tasks to require attention or a KeyboardInterrupt.
+ Returns the ready task on success, None on timeout or interrupt.
+ """
+ try:
+ #reporter.log2('waitForTasks: cMsTimeout=%d' % (cMsTimeout,));
+
+ if cMsTimeout == 0:
+ return self.pollTasks();
+
+ if not self.aoTasks:
+ return None;
+
+ fMore = True;
+ if cMsTimeout < 0:
+ while fMore:
+ oTask = self.pollTasks();
+ if oTask is not None:
+ return oTask;
+ fMore = self.waitForTasksSleepWorker(1000);
+ else:
+ msStart = timestampMilli();
+ while fMore:
+ oTask = self.pollTasks();
+ if oTask is not None:
+ #reporter.log2('waitForTasks: returning %s, msStart=%d' % \
+ # (oTask, msStart));
+ return oTask;
+
+ cMsElapsed = timestampMilli() - msStart;
+ if cMsElapsed > cMsTimeout: # not ==, we want the final waitForEvents.
+ break;
+ cMsSleep = cMsTimeout - cMsElapsed;
+ cMsSleep = min(cMsSleep, 1000);
+ fMore = self.waitForTasksSleepWorker(cMsSleep);
+ except KeyboardInterrupt:
+ self.fInterrupted = True;
+ reporter.errorXcpt('KeyboardInterrupt', 6);
+ except:
+ reporter.errorXcpt(None, 6);
+ return None;
+
+ #
+ # PID file management methods.
+ #
+
+ def pidFileRead(self):
+ """
+ Worker that reads the PID file.
+ Returns dictionary of PID with value (sName, fSudo), empty if no file.
+ """
+ dPids = {};
+ if os.path.isfile(self.sPidFile):
+ try:
+ oFile = utils.openNoInherit(self.sPidFile, 'r');
+ sContent = str(oFile.read());
+ oFile.close();
+ except:
+ reporter.errorXcpt();
+ return dPids;
+
+ sContent = str(sContent).strip().replace('\n', ' ').replace('\r', ' ').replace('\t', ' ');
+ for sProcess in sContent.split(' '):
+ asFields = sProcess.split(':');
+ if len(asFields) == 3 and asFields[0].isdigit():
+ try:
+ dPids[int(asFields[0])] = (asFields[2], asFields[1] == 'sudo');
+ except:
+ reporter.logXcpt('sProcess=%s' % (sProcess,));
+ else:
+ reporter.log('%s: "%s"' % (self.sPidFile, sProcess));
+
+ return dPids;
+
+ def pidFileAdd(self, iPid, sName, fSudo = False):
+ """
+ Adds a PID to the PID file, creating the file if necessary.
+ """
+ try:
+ oFile = utils.openNoInherit(self.sPidFile, 'a');
+ oFile.write('%s:%s:%s\n'
+ % ( iPid,
+ 'sudo' if fSudo else 'normal',
+ sName.replace(' ', '_').replace(':','_').replace('\n','_').replace('\r','_').replace('\t','_'),));
+ oFile.close();
+ except:
+ reporter.errorXcpt();
+ return False;
+ ## @todo s/log/log2/
+ reporter.log('pidFileAdd: added %s (%#x) %s fSudo=%s (new content: %s)'
+ % (iPid, iPid, sName, fSudo, self.pidFileRead(),));
+ return True;
+
+ def pidFileRemove(self, iPid, fQuiet = False):
+ """
+ Removes a PID from the PID file.
+ """
+ dPids = self.pidFileRead();
+ if iPid not in dPids:
+ if not fQuiet:
+ reporter.log('pidFileRemove could not find %s in the PID file (content: %s)' % (iPid, dPids));
+ return False;
+
+ sName = dPids[iPid][0];
+ del dPids[iPid];
+
+ sPid = '';
+ for iPid2, tNameSudo in dPids.items():
+ sPid += '%s:%s:%s\n' % (iPid2, 'sudo' if tNameSudo[1] else 'normal', tNameSudo[0]);
+
+ try:
+ oFile = utils.openNoInherit(self.sPidFile, 'w');
+ oFile.write(sPid);
+ oFile.close();
+ except:
+ reporter.errorXcpt();
+ return False;
+ ## @todo s/log/log2/
+ reporter.log('pidFileRemove: removed PID %d [%s] (new content: %s)' % (iPid, sName, self.pidFileRead(),));
+ return True;
+
+ def pidFileDelete(self):
+ """Creates the testdriver PID file."""
+ if os.path.isfile(self.sPidFile):
+ try:
+ os.unlink(self.sPidFile);
+ except:
+ reporter.logXcpt();
+ return False;
+ ## @todo s/log/log2/
+ reporter.log('pidFileDelete: deleted "%s"' % (self.sPidFile,));
+ return True;
+
+ #
+ # Misc helper methods.
+ #
+
+ def requireMoreArgs(self, cMinNeeded, asArgs, iArg):
+ """
+ Checks that asArgs has at least cMinNeeded args following iArg.
+
+ Returns iArg + 1 if it checks out fine.
+ Raise appropritate exception if not, ASSUMING that the current argument
+ is found at iArg.
+ """
+ assert cMinNeeded >= 1;
+ if iArg + cMinNeeded > len(asArgs):
+ if cMinNeeded > 1:
+ raise InvalidOption('The "%s" option takes %s values' % (asArgs[iArg], cMinNeeded,));
+ raise InvalidOption('The "%s" option takes 1 value' % (asArgs[iArg],));
+ return iArg + 1;
+
+ def getBinTool(self, sName):
+ """
+ Returns the full path to the given binary validation kit tool.
+ """
+ return os.path.join(self.sBinPath, sName) + exeSuff();
+
+ def adjustTimeoutMs(self, cMsTimeout, cMsMinimum = None):
+ """
+ Adjusts the given timeout (milliseconds) to take TESTBOX_TIMEOUT_ABS
+ and cMsMinimum (optional) into account.
+
+ Returns adjusted timeout.
+ Raises no exceptions.
+ """
+ if self.secTimeoutAbs is not None:
+ cMsToDeadline = self.secTimeoutAbs * 1000 - utils.timestampMilli();
+ if cMsToDeadline >= 0:
+ # Adjust for fudge and enforce the minimum timeout
+ cMsToDeadline -= self.secTimeoutFudge * 1000;
+ if cMsToDeadline < (cMsMinimum if cMsMinimum is not None else 10000):
+ cMsToDeadline = cMsMinimum if cMsMinimum is not None else 10000;
+
+ # Is the timeout beyond the (adjusted) deadline, if so change it.
+ if cMsTimeout > cMsToDeadline:
+ reporter.log('adjusting timeout: %s ms -> %s ms (deadline)\n' % (cMsTimeout, cMsToDeadline,));
+ return cMsToDeadline;
+ reporter.log('adjustTimeoutMs: cMsTimeout (%s) > cMsToDeadline (%s)' % (cMsTimeout, cMsToDeadline,));
+ else:
+ # Don't bother, we've passed the deadline.
+ reporter.log('adjustTimeoutMs: ooops! cMsToDeadline=%s (%s), timestampMilli()=%s, timestampSecond()=%s'
+ % (cMsToDeadline, cMsToDeadline*1000, utils.timestampMilli(), utils.timestampSecond()));
+
+ # Only enforce the minimum timeout if specified.
+ if cMsMinimum is not None and cMsTimeout < cMsMinimum:
+ reporter.log('adjusting timeout: %s ms -> %s ms (minimum)\n' % (cMsTimeout, cMsMinimum,));
+ cMsTimeout = cMsMinimum;
+
+ return cMsTimeout;
+
+ def prepareResultFile(self, sName = 'results.xml'):
+ """
+ Given a base name (no path, but extension if required), a scratch file
+ name is computed and any previous file removed.
+
+ Returns the full path to the file sName.
+ Raises exception on failure.
+ """
+ sXmlFile = os.path.join(self.sScratchPath, sName);
+ if os.path.exists(sXmlFile):
+ os.unlink(sXmlFile);
+ return sXmlFile;
+
+
+ #
+ # Overridable methods.
+ #
+
+ def showUsage(self):
+ """
+ Shows the usage.
+
+ When overriding this, call super first.
+ """
+ sName = os.path.basename(sys.argv[0]);
+ reporter.log('Usage: %s [options] <action(s)>' % (sName,));
+ reporter.log('');
+ reporter.log('Actions (in execution order):');
+ reporter.log(' cleanup-before');
+ reporter.log(' Cleanups done at the start of testing.');
+ reporter.log(' verify');
+ reporter.log(' Verify that all necessary resources are present.');
+ reporter.log(' config');
+ reporter.log(' Configure the tests.');
+ reporter.log(' execute');
+ reporter.log(' Execute the tests.');
+ reporter.log(' cleanup-after');
+ reporter.log(' Cleanups done at the end of the testing.');
+ reporter.log('');
+ reporter.log('Special Actions:');
+ reporter.log(' all');
+ reporter.log(' Alias for: %s' % (' '.join(self.asNormalActions),));
+ reporter.log(' extract <path>');
+ reporter.log(' Extract the test resources and put them in the specified');
+ reporter.log(' path for off side/line testing.');
+ reporter.log(' abort');
+ reporter.log(' Aborts the test.');
+ reporter.log('');
+ reporter.log('Base Options:');
+ reporter.log(' -h, --help');
+ reporter.log(' Show this help message.');
+ reporter.log(' -v, --verbose');
+ reporter.log(' Increase logging verbosity, repeat for more logging.');
+ reporter.log(' -d, --debug');
+ reporter.log(' Increase the debug logging level, repeat for more info.');
+ reporter.log(' --no-wipe-clean');
+ reporter.log(' Do not wipe clean the scratch area during the two clean up');
+ reporter.log(' actions. This is for facilitating nested test driver execution.');
+ if self.aoSubTstDrvs:
+ reporter.log(' --enable-sub-driver <sub1>[:..]');
+ reporter.log(' --disable-sub-driver <sub1>[:..]');
+ reporter.log(' Enables or disables one or more of the sub drivers: %s'
+ % (', '.join([oSubTstDrv.sName for oSubTstDrv in self.aoSubTstDrvs]),));
+ return True;
+
+ def parseOption(self, asArgs, iArg):
+ """
+ Parse an option. Override this.
+
+ Keyword arguments:
+ asArgs -- The argument vector.
+ iArg -- The index of the current argument.
+
+ Returns iArg if the option was not recognized.
+ Returns the index of the next argument when something is consumed.
+ In the event of a syntax error, a InvalidOption or QuietInvalidOption
+ should be thrown.
+ """
+
+ if asArgs[iArg] in ('--help', '-help', '-h', '-?', '/?', '/help', '/H', '-H'):
+ self.showUsage();
+ self.showSubTstDrvUsage();
+ raise QuietInvalidOption();
+
+ # options
+ if asArgs[iArg] in ('--verbose', '-v'):
+ reporter.incVerbosity()
+ elif asArgs[iArg] in ('--debug', '-d'):
+ reporter.incDebug()
+ elif asArgs[iArg] == '--no-wipe-clean':
+ self.fNoWipeClean = True;
+ elif asArgs[iArg] in ('--enable-sub-driver', '--disable-sub-driver') and self.aoSubTstDrvs:
+ sOption = asArgs[iArg];
+ iArg = self.requireMoreArgs(1, asArgs, iArg);
+ for sSubTstDrvName in asArgs[iArg].split(':'):
+ oSubTstDrv = self.findSubTstDrvByShortName(sSubTstDrvName);
+ if oSubTstDrv is None:
+ raise InvalidOption('Unknown sub-test driver given to %s: %s' % (sOption, sSubTstDrvName,));
+ oSubTstDrv.fEnabled = sOption == '--enable-sub-driver';
+ elif (asArgs[iArg] == 'all' or asArgs[iArg] in self.asNormalActions) \
+ and self.asActions in self.asSpecialActions:
+ raise InvalidOption('selected special action "%s" already' % (self.asActions[0], ));
+ # actions
+ elif asArgs[iArg] == 'all':
+ self.asActions = [ 'all' ];
+ elif asArgs[iArg] in self.asNormalActions:
+ self.asActions.append(asArgs[iArg])
+ elif asArgs[iArg] in self.asSpecialActions:
+ if self.asActions:
+ raise InvalidOption('selected special action "%s" already' % (self.asActions[0], ));
+ self.asActions = [ asArgs[iArg] ];
+ # extact <destination>
+ if asArgs[iArg] == 'extract':
+ iArg = iArg + 1;
+ if iArg >= len(asArgs): raise InvalidOption('The "extract" action requires a destination directory');
+ self.sExtractDstPath = asArgs[iArg];
+ else:
+ return iArg;
+ return iArg + 1;
+
+ def completeOptions(self):
+ """
+ This method is called after parsing all the options.
+ Returns success indicator. Use the reporter to complain.
+
+ Overriable, call super.
+ """
+ return True;
+
+ def getResourceSet(self):
+ """
+ Returns a set of file and/or directory names relative to
+ TESTBOX_PATH_RESOURCES.
+
+ Override this, call super when using sub-test drivers.
+ """
+ asRsrcs = [];
+ for oSubTstDrv in self.aoSubTstDrvs:
+ asRsrcs.extend(oSubTstDrv.asRsrcs);
+ return asRsrcs;
+
+ def actionExtract(self):
+ """
+ Handle the action that extracts the test resources for off site use.
+ Returns a success indicator and error details with the reporter.
+
+ There is usually no need to override this.
+ """
+ fRc = True;
+ asRsrcs = self.getResourceSet();
+ for iRsrc, sRsrc in enumerate(asRsrcs):
+ reporter.log('Resource #%s: "%s"' % (iRsrc, sRsrc));
+ sSrcPath = os.path.normpath(os.path.abspath(os.path.join(self.sResourcePath, sRsrc.replace('/', os.path.sep))));
+ sDstPath = os.path.normpath(os.path.join(self.sExtractDstPath, sRsrc.replace('/', os.path.sep)));
+
+ sDstDir = os.path.dirname(sDstPath);
+ if not os.path.exists(sDstDir):
+ try: os.makedirs(sDstDir, 0o775);
+ except: fRc = reporter.errorXcpt('Error creating directory "%s":' % (sDstDir,));
+
+ if os.path.isfile(sSrcPath):
+ try: utils.copyFileSimple(sSrcPath, sDstPath);
+ except: fRc = reporter.errorXcpt('Error copying "%s" to "%s":' % (sSrcPath, sDstPath,));
+ elif os.path.isdir(sSrcPath):
+ fRc = reporter.error('Extracting directories have not been implemented yet');
+ else:
+ fRc = reporter.error('Missing or unsupported resource type: %s' % (sSrcPath,));
+ return fRc;
+
+ def actionVerify(self):
+ """
+ Handle the action that verify the test resources.
+ Returns a success indicator and error details with the reporter.
+
+ There is usually no need to override this.
+ """
+
+ asRsrcs = self.getResourceSet();
+ for sRsrc in asRsrcs:
+ # Go thru some pain to catch escape sequences.
+ if sRsrc.find("//") >= 0:
+ reporter.error('Double slash test resource name: "%s"' % (sRsrc));
+ return False;
+ if sRsrc == ".." \
+ or sRsrc.startswith("../") \
+ or sRsrc.find("/../") >= 0 \
+ or sRsrc.endswith("/.."):
+ reporter.error('Relative path in test resource name: "%s"' % (sRsrc));
+ return False;
+
+ sFull = os.path.normpath(os.path.abspath(os.path.join(self.sResourcePath, sRsrc)));
+ if not sFull.startswith(os.path.normpath(self.sResourcePath)):
+ reporter.error('sFull="%s" self.sResourcePath=%s' % (sFull, self.sResourcePath));
+ reporter.error('The resource "%s" seems to specify a relative path' % (sRsrc));
+ return False;
+
+ reporter.log2('Checking for resource "%s" at "%s" ...' % (sRsrc, sFull));
+ if os.path.isfile(sFull):
+ try:
+ oFile = utils.openNoInherit(sFull, "rb");
+ oFile.close();
+ except Exception as oXcpt:
+ reporter.error('The file resource "%s" cannot be accessed: %s' % (sFull, oXcpt));
+ return False;
+ elif os.path.isdir(sFull):
+ if not os.path.isdir(os.path.join(sFull, '.')):
+ reporter.error('The directory resource "%s" cannot be accessed' % (sFull));
+ return False;
+ elif os.path.exists(sFull):
+ reporter.error('The resource "%s" is not a file or directory' % (sFull));
+ return False;
+ else:
+ reporter.error('The resource "%s" was not found' % (sFull));
+ return False;
+ return True;
+
+ def actionConfig(self):
+ """
+ Handle the action that configures the test.
+ Returns True (success), False (failure) or None (skip the test),
+ posting complaints and explanations with the reporter.
+
+ Override this.
+ """
+ return True;
+
+ def actionExecute(self):
+ """
+ Handle the action that executes the test.
+
+ Returns True (success), False (failure) or None (skip the test),
+ posting complaints and explanations with the reporter.
+
+ Override this.
+ """
+ return True;
+
+ def actionCleanupBefore(self):
+ """
+ Handle the action that cleans up spills from previous tests before
+ starting the tests. This is mostly about wiping the scratch space
+ clean in local runs. On a testbox the testbox script will use the
+ cleanup-after if the test is interrupted.
+
+ Returns True (success), False (failure) or None (skip the test),
+ posting complaints and explanations with the reporter.
+
+ Override this, but call super to wipe the scratch directory.
+ """
+ if self.fNoWipeClean is False:
+ self.wipeScratch();
+ return True;
+
+ def actionCleanupAfter(self):
+ """
+ Handle the action that cleans up all spills from executing the test.
+
+ Returns True (success) or False (failure) posting complaints and
+ explanations with the reporter.
+
+ Override this, but call super to wipe the scratch directory.
+ """
+ if self.fNoWipeClean is False:
+ self.wipeScratch();
+ return True;
+
+ def actionAbort(self):
+ """
+ Handle the action that aborts a (presumed) running testdriver, making
+ sure to include all it's children.
+
+ Returns True (success) or False (failure) posting complaints and
+ explanations with the reporter.
+
+ Override this, but call super to kill the testdriver script and any
+ other process covered by the testdriver PID file.
+ """
+
+ dPids = self.pidFileRead();
+ reporter.log('The pid file contained: %s' % (dPids,));
+
+ #
+ # Try convince the processes to quit with increasing impoliteness.
+ #
+ if sys.platform == 'win32':
+ afnMethods = [ processInterrupt, processTerminate ];
+ else:
+ afnMethods = [ sendUserSignal1, processInterrupt, processTerminate, processKill ];
+ for fnMethod in afnMethods:
+ for iPid, tNameSudo in dPids.items():
+ fnMethod(iPid, fSudo = tNameSudo[1]);
+
+ for i in range(10):
+ if i > 0:
+ time.sleep(1);
+
+ dPidsToRemove = []; # Temporary dict to append PIDs to remove later.
+
+ for iPid, tNameSudo in dPids.items():
+ if not processExists(iPid):
+ reporter.log('%s (%s) terminated' % (tNameSudo[0], iPid,));
+ self.pidFileRemove(iPid, fQuiet = True);
+ dPidsToRemove.append(iPid);
+ continue;
+
+ # Remove PIDs from original dictionary, as removing keys from a
+ # dictionary while iterating on it won't work and will result in a RuntimeError.
+ for iPidToRemove in dPidsToRemove:
+ del dPids[iPidToRemove];
+
+ if not dPids:
+ reporter.log('All done.');
+ return True;
+
+ if i in [4, 8]:
+ reporter.log('Still waiting for: %s (method=%s)' % (dPids, fnMethod,));
+
+ reporter.log('Failed to terminate the following processes: %s' % (dPids,));
+ return False;
+
+
+ def onExit(self, iRc):
+ """
+ Hook for doing very important cleanups on the way out.
+
+ iRc is the exit code or -1 in the case of an unhandled exception.
+ Returns nothing and shouldn't raise exceptions (will be muted+ignored).
+ """
+ _ = iRc;
+ return None;
+
+
+ #
+ # main() - don't override anything!
+ #
+
+ def main(self, asArgs = None):
+ """
+ The main function of the test driver.
+
+ Keyword arguments:
+ asArgs -- The argument vector. Defaults to sys.argv.
+
+ Returns exit code. No exceptions.
+ """
+
+ #
+ # Wrap worker in exception handler and always call a 'finally' like
+ # method to do crucial cleanups on the way out.
+ #
+ try:
+ iRc = self.innerMain(asArgs);
+ except:
+ reporter.logXcpt(cFrames = None);
+ try:
+ self.onExit(-1);
+ except:
+ reporter.logXcpt();
+ raise;
+ self.onExit(iRc);
+ return iRc;
+
+
+ def innerMain(self, asArgs = None): # pylint: disable=too-many-statements
+ """
+ Exception wrapped main() worker.
+ """
+
+ #
+ # Parse the arguments.
+ #
+ if asArgs is None:
+ asArgs = list(sys.argv);
+ iArg = 1;
+ try:
+ while iArg < len(asArgs):
+ iNext = self.parseOption(asArgs, iArg);
+ if iNext == iArg:
+ iNext = self.subTstDrvParseOption(asArgs, iArg);
+ if iNext == iArg:
+ raise InvalidOption('unknown option: %s' % (asArgs[iArg]))
+ iArg = iNext;
+ except QuietInvalidOption:
+ return rtexitcode.RTEXITCODE_SYNTAX;
+ except InvalidOption as oXcpt:
+ reporter.error(oXcpt.str());
+ return rtexitcode.RTEXITCODE_SYNTAX;
+ except:
+ reporter.error('unexpected exception while parsing argument #%s' % (iArg));
+ traceback.print_exc();
+ return rtexitcode.RTEXITCODE_SYNTAX;
+
+ if not self.completeOptions():
+ return rtexitcode.RTEXITCODE_SYNTAX;
+
+ if not self.asActions:
+ reporter.error('no action was specified');
+ reporter.error('valid actions: %s' % (self.asNormalActions + self.asSpecialActions + ['all']));
+ return rtexitcode.RTEXITCODE_SYNTAX;
+
+ #
+ # Execte the actions.
+ #
+ fRc = True; # Tristate - True (success), False (failure), None (skipped).
+ asActions = list(self.asActions); # Must copy it or vboxinstaller.py breaks.
+ if 'extract' in asActions:
+ reporter.log('*** extract action ***');
+ asActions.remove('extract');
+ fRc = self.actionExtract();
+ reporter.log('*** extract action completed (fRc=%s) ***' % (fRc));
+ elif 'abort' in asActions:
+ reporter.appendToProcessName('/abort'); # Make it easier to spot in the log.
+ reporter.log('*** abort action ***');
+ asActions.remove('abort');
+ fRc = self.actionAbort();
+ reporter.log('*** abort action completed (fRc=%s) ***' % (fRc));
+ else:
+ if asActions == [ 'all' ]:
+ asActions = list(self.asNormalActions);
+
+ if 'verify' in asActions:
+ reporter.log('*** verify action ***');
+ asActions.remove('verify');
+ fRc = self.actionVerify();
+ if fRc is True: reporter.log("verified succeeded");
+ else: reporter.log("verified failed (fRc=%s)" % (fRc,));
+ reporter.log('*** verify action completed (fRc=%s) ***' % (fRc,));
+
+ if 'cleanup-before' in asActions:
+ reporter.log('*** cleanup-before action ***');
+ asActions.remove('cleanup-before');
+ fRc2 = self.actionCleanupBefore();
+ if fRc2 is not True: reporter.log("cleanup-before failed");
+ if fRc2 is not True and fRc is True: fRc = fRc2;
+ reporter.log('*** cleanup-before action completed (fRc2=%s, fRc=%s) ***' % (fRc2, fRc,));
+
+ self.pidFileAdd(os.getpid(), os.path.basename(sys.argv[0]));
+
+ if 'config' in asActions and fRc is True:
+ asActions.remove('config');
+ reporter.log('*** config action ***');
+ fRc = self.actionConfig();
+ if fRc is True: reporter.log("config succeeded");
+ elif fRc is None: reporter.log("config skipping test");
+ else: reporter.log("config failed");
+ reporter.log('*** config action completed (fRc=%s) ***' % (fRc,));
+
+ if 'execute' in asActions and fRc is True:
+ asActions.remove('execute');
+ reporter.log('*** execute action ***');
+ fRc = self.actionExecute();
+ if fRc is True: reporter.log("execute succeeded");
+ elif fRc is None: reporter.log("execute skipping test");
+ else: reporter.log("execute failed (fRc=%s)" % (fRc,));
+ reporter.testCleanup();
+ reporter.log('*** execute action completed (fRc=%s) ***' % (fRc,));
+
+ if 'cleanup-after' in asActions:
+ reporter.log('*** cleanup-after action ***');
+ asActions.remove('cleanup-after');
+ fRc2 = self.actionCleanupAfter();
+ if fRc2 is not True: reporter.log("cleanup-after failed");
+ if fRc2 is not True and fRc is True: fRc = fRc2;
+ reporter.log('*** cleanup-after action completed (fRc2=%s, fRc=%s) ***' % (fRc2, fRc,));
+
+ self.pidFileRemove(os.getpid());
+
+ if asActions and fRc is True:
+ reporter.error('unhandled actions: %s' % (asActions,));
+ fRc = False;
+
+ #
+ # Done - report the final result.
+ #
+ if fRc is None:
+ if self.fBadTestbox:
+ reporter.log('****************************************************************');
+ reporter.log('*** The test driver SKIPPED the test because of BAD_TESTBOX. ***');
+ reporter.log('****************************************************************');
+ return rtexitcode.RTEXITCODE_BAD_TESTBOX;
+ reporter.log('*****************************************');
+ reporter.log('*** The test driver SKIPPED the test. ***');
+ reporter.log('*****************************************');
+ return rtexitcode.RTEXITCODE_SKIPPED;
+ if fRc is not True:
+ reporter.error('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+ reporter.error('!!! The test driver FAILED (in case we forgot to mention it). !!!');
+ reporter.error('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+ return rtexitcode.RTEXITCODE_FAILURE;
+ reporter.log('*******************************************');
+ reporter.log('*** The test driver exits successfully. ***');
+ reporter.log('*******************************************');
+ return rtexitcode.RTEXITCODE_SUCCESS;
+
+# The old, deprecated name.
+TestDriver = TestDriverBase; # pylint: disable=invalid-name
+
+
+#
+# Unit testing.
+#
+
+# pylint: disable=missing-docstring
+class TestDriverBaseTestCase(unittest.TestCase):
+ def setUp(self):
+ self.oTstDrv = TestDriverBase();
+ self.oTstDrv.pidFileDelete();
+
+ def tearDown(self):
+ pass; # clean up scratch dir and such.
+
+ def testPidFile(self):
+
+ iPid1 = os.getpid() + 1;
+ iPid2 = os.getpid() + 2;
+
+ self.assertTrue(self.oTstDrv.pidFileAdd(iPid1, 'test1'));
+ self.assertEqual(self.oTstDrv.pidFileRead(), {iPid1:('test1',False)});
+
+ self.assertTrue(self.oTstDrv.pidFileAdd(iPid2, 'test2', fSudo = True));
+ self.assertEqual(self.oTstDrv.pidFileRead(), {iPid1:('test1',False), iPid2:('test2',True)});
+
+ self.assertTrue(self.oTstDrv.pidFileRemove(iPid1));
+ self.assertEqual(self.oTstDrv.pidFileRead(), {iPid2:('test2',True)});
+
+ self.assertTrue(self.oTstDrv.pidFileRemove(iPid2));
+ self.assertEqual(self.oTstDrv.pidFileRead(), {});
+
+ self.assertTrue(self.oTstDrv.pidFileDelete());
+
+if __name__ == '__main__':
+ unittest.main();
+ # not reached.
diff --git a/src/VBox/ValidationKit/testdriver/btresolver.py b/src/VBox/ValidationKit/testdriver/btresolver.py
new file mode 100755
index 00000000..58d39853
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/btresolver.py
@@ -0,0 +1,626 @@
+# -*- coding: utf-8 -*-
+# $Id: btresolver.py $
+# pylint: disable=too-many-lines
+
+"""
+Backtrace resolver using external debugging symbols and RTLdrFlt.
+"""
+
+__copyright__ = \
+"""
+Copyright (C) 2016-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 os;
+import re;
+import shutil;
+import subprocess;
+
+# Validation Kit imports.
+from common import utils;
+
+def getRTLdrFltPath(asPaths):
+ """
+ Returns the path to the RTLdrFlt tool looking in the provided paths
+ or None if not found.
+ """
+
+ for sPath in asPaths:
+ for sDirPath, _, asFiles in os.walk(sPath):
+ if 'RTLdrFlt' in asFiles:
+ return os.path.join(sDirPath, 'RTLdrFlt');
+
+ return None;
+
+
+
+class BacktraceResolverOs(object):
+ """
+ Base class for all OS specific resolvers.
+ """
+
+ def __init__(self, sScratchPath, sBuildRoot, fnLog = None):
+ self.sScratchPath = sScratchPath;
+ self.sBuildRoot = sBuildRoot;
+ self.fnLog = fnLog;
+
+ def log(self, sText):
+ """
+ Internal logger callback.
+ """
+ if self.fnLog is not None:
+ self.fnLog(sText);
+
+
+
+class BacktraceResolverOsLinux(BacktraceResolverOs):
+ """
+ Linux specific backtrace resolver.
+ """
+
+ def __init__(self, sScratchPath, sBuildRoot, fnLog = None):
+ """
+ Constructs a Linux host specific backtrace resolver.
+ """
+ BacktraceResolverOs.__init__(self, sScratchPath, sBuildRoot, fnLog);
+
+ self.asDbgFiles = {};
+
+ def prepareEnv(self):
+ """
+ Prepares the environment for annotating Linux reports.
+ """
+ fRc = False;
+ try:
+ sDbgArchive = os.path.join(self.sBuildRoot, 'bin', 'VirtualBox-dbg.tar.bz2');
+
+ # Extract debug symbol archive if it was found.
+ if os.path.exists(sDbgArchive):
+ asMembers = utils.unpackFile(sDbgArchive, self.sScratchPath, self.fnLog,
+ self.fnLog);
+ if asMembers:
+ # Populate the list of debug files.
+ for sMember in asMembers:
+ if os.path.isfile(sMember):
+ self.asDbgFiles[os.path.basename(sMember)] = sMember;
+ fRc = True;
+ except:
+ self.log('Failed to setup debug symbols');
+
+ return fRc;
+
+ def cleanupEnv(self):
+ """
+ Cleans up the environment.
+ """
+ fRc = False;
+ try:
+ shutil.rmtree(self.sScratchPath, True);
+ fRc = True;
+ except:
+ pass;
+
+ return fRc;
+
+ def getDbgSymPathFromBinary(self, sBinary, sArch):
+ """
+ Returns the path to file containing the debug symbols for the specified binary.
+ """
+ _ = sArch;
+ sDbgFilePath = None;
+ try:
+ sDbgFilePath = self.asDbgFiles[sBinary];
+ except:
+ pass;
+
+ return sDbgFilePath;
+
+ def getBinaryListWithLoadAddrFromReport(self, asReport):
+ """
+ Parses the given VM state report and returns a list of binaries and their
+ load address.
+
+ Returns a list if tuples containing the binary and load addres or an empty
+ list on failure.
+ """
+ asListBinaries = [];
+
+ # Look for the line "Mapped address spaces:"
+ iLine = 0;
+ while iLine < len(asReport):
+ if asReport[iLine].startswith('Mapped address spaces:'):
+ break;
+ iLine += 1;
+
+ for sLine in asReport[iLine:]:
+ asCandidate = sLine.split();
+ if len(asCandidate) == 5 \
+ and asCandidate[0].startswith('0x') \
+ and asCandidate[1].startswith('0x') \
+ and asCandidate[2].startswith('0x') \
+ and (asCandidate[3] == '0x0' or asCandidate[3] == '0')\
+ and 'VirtualBox' in asCandidate[4]:
+ asListBinaries.append((asCandidate[0], os.path.basename(asCandidate[4])));
+
+ return asListBinaries;
+
+
+
+class BacktraceResolverOsDarwin(BacktraceResolverOs):
+ """
+ Darwin specific backtrace resolver.
+ """
+
+ def __init__(self, sScratchPath, sBuildRoot, fnLog = None):
+ """
+ Constructs a Linux host specific backtrace resolver.
+ """
+ BacktraceResolverOs.__init__(self, sScratchPath, sBuildRoot, fnLog);
+
+ self.asDbgFiles = {};
+
+ def prepareEnv(self):
+ """
+ Prepares the environment for annotating Darwin reports.
+ """
+ fRc = False;
+ try:
+ #
+ # Walk the scratch path directory and look for .dSYM directories, building a
+ # list of them.
+ #
+ asDSymPaths = [];
+
+ for sDirPath, asDirs, _ in os.walk(self.sBuildRoot):
+ for sDir in asDirs:
+ if sDir.endswith('.dSYM'):
+ asDSymPaths.append(os.path.join(sDirPath, sDir));
+
+ # Expand the dSYM paths to full DWARF debug files in the next step
+ # and add them to the debug files dictionary.
+ for sDSymPath in asDSymPaths:
+ sBinary = os.path.basename(sDSymPath).strip('.dSYM');
+ self.asDbgFiles[sBinary] = os.path.join(sDSymPath, 'Contents', 'Resources',
+ 'DWARF', sBinary);
+
+ fRc = True;
+ except:
+ self.log('Failed to setup debug symbols');
+
+ return fRc;
+
+ def cleanupEnv(self):
+ """
+ Cleans up the environment.
+ """
+ fRc = False;
+ try:
+ shutil.rmtree(self.sScratchPath, True);
+ fRc = True;
+ except:
+ pass;
+
+ return fRc;
+
+ def getDbgSymPathFromBinary(self, sBinary, sArch):
+ """
+ Returns the path to file containing the debug symbols for the specified binary.
+ """
+ # Hack to exclude executables as RTLdrFlt has some problems with it currently.
+ _ = sArch;
+ sDbgSym = None;
+ try:
+ sDbgSym = self.asDbgFiles[sBinary];
+ except:
+ pass;
+
+ if sDbgSym is not None and sDbgSym.endswith('.dylib'):
+ return sDbgSym;
+
+ return None;
+
+ def _getReportVersion(self, asReport):
+ """
+ Returns the version of the darwin report.
+ """
+ # Find the line starting with "Report Version:"
+ iLine = 0;
+ iVersion = 0;
+ while iLine < len(asReport):
+ if asReport[iLine].startswith('Report Version:'):
+ break;
+ iLine += 1;
+
+ if iLine < len(asReport):
+ # Look for the start of the number
+ sVersion = asReport[iLine];
+ iStartVersion = len('Report Version:');
+ iEndVersion = len(sVersion);
+
+ while iStartVersion < len(sVersion) \
+ and not sVersion[iStartVersion:iStartVersion+1].isdigit():
+ iStartVersion += 1;
+
+ while iEndVersion > 0 \
+ and not sVersion[iEndVersion-1:iEndVersion].isdigit():
+ iEndVersion -= 1;
+
+ iVersion = int(sVersion[iStartVersion:iEndVersion]);
+ else:
+ self.log('Couldn\'t find the report version');
+
+ return iVersion;
+
+ def _getListOfBinariesFromReportPreSierra(self, asReport):
+ """
+ Returns a list of loaded binaries with their load address obtained from
+ a pre Sierra report.
+ """
+ asListBinaries = [];
+
+ # Find the line starting with "Binary Images:"
+ iLine = 0;
+ while iLine < len(asReport):
+ if asReport[iLine].startswith('Binary Images:'):
+ break;
+ iLine += 1;
+
+ if iLine < len(asReport):
+ # List starts after that
+ iLine += 1;
+
+ # A line for a loaded binary looks like the following:
+ # 0x100042000 - 0x100095fff +VBoxDDU.dylib (4.3.15) <EB19C44D-F882-0803-DBDD-9995723111B7> /Application...
+ # We need the start address and the library name.
+ # To distinguish between our own libraries and ones from Apple we check whether the path at the end starts with
+ # /Applications/VirtualBox.app/Contents/MacOS
+ oRegExpPath = re.compile(r'/VirtualBox.app/Contents/MacOS');
+ oRegExpAddr = re.compile(r'0x\w+');
+ oRegExpBinPath = re.compile(r'VirtualBox.app/Contents/MacOS/\S*');
+ while iLine < len(asReport):
+ asMatches = oRegExpPath.findall(asReport[iLine]);
+ if asMatches:
+ # Line contains the path, extract start address and path to binary
+ sAddr = oRegExpAddr.findall(asReport[iLine]);
+ sPath = oRegExpBinPath.findall(asReport[iLine]);
+
+ if sAddr and sPath:
+ # Construct the path in into the build cache containing the debug symbols
+ oRegExp = re.compile(r'\w+\.{0,1}\w*$');
+ sFilename = oRegExp.findall(sPath[0]);
+
+ asListBinaries.append((sAddr[0], sFilename[0]));
+ else:
+ break; # End of image list
+ iLine += 1;
+ else:
+ self.log('Couldn\'t find the list of loaded binaries in the given report');
+
+ return asListBinaries;
+
+ def _getListOfBinariesFromReportSierra(self, asReport):
+ """
+ Returns a list of loaded binaries with their load address obtained from
+ a Sierra+ report.
+ """
+ asListBinaries = [];
+
+ # A line for a loaded binary looks like the following:
+ # 4 VBoxXPCOMIPCC.dylib 0x00000001139f17ea 0x1139e4000 + 55274
+ # We need the start address and the library name.
+ # To distinguish between our own libraries and ones from Apple we check whether the library
+ # name contains VBox or VirtualBox
+ iLine = 0;
+ while iLine < len(asReport):
+ asStackTrace = asReport[iLine].split();
+
+ # Check whether the line is made up of 6 elements separated by whitespace
+ # and the first one is a number.
+ if len(asStackTrace) == 6 and asStackTrace[0].isdigit() \
+ and (asStackTrace[1].find('VBox') != -1 or asStackTrace[1].find('VirtualBox') != -1) \
+ and asStackTrace[3].startswith('0x'):
+
+ # Check whether the library is already in our list an only add new ones
+ fFound = False;
+ for _, sLibrary in asListBinaries:
+ if asStackTrace[1] == sLibrary:
+ fFound = True;
+ break;
+
+ if not fFound:
+ asListBinaries.append((asStackTrace[3], asStackTrace[1]));
+ iLine += 1;
+
+ return asListBinaries;
+
+ def getBinaryListWithLoadAddrFromReport(self, asReport):
+ """
+ Parses the given VM state report and returns a list of binaries and their
+ load address.
+
+ Returns a list if tuples containing the binary and load addres or an empty
+ list on failure.
+ """
+ asListBinaries = [];
+
+ iVersion = self._getReportVersion(asReport);
+ if iVersion > 0:
+ if iVersion <= 11:
+ self.log('Pre Sierra Report');
+ asListBinaries = self._getListOfBinariesFromReportPreSierra(asReport);
+ elif iVersion == 12:
+ self.log('Sierra report');
+ asListBinaries = self._getListOfBinariesFromReportSierra(asReport);
+ else:
+ self.log('Unsupported report version %s' % (iVersion, ));
+
+ return asListBinaries;
+
+
+
+class BacktraceResolverOsSolaris(BacktraceResolverOs):
+ """
+ Solaris specific backtrace resolver.
+ """
+
+ def __init__(self, sScratchPath, sBuildRoot, fnLog = None):
+ """
+ Constructs a Linux host specific backtrace resolver.
+ """
+ BacktraceResolverOs.__init__(self, sScratchPath, sBuildRoot, fnLog);
+
+ self.asDbgFiles = {};
+
+ def prepareEnv(self):
+ """
+ Prepares the environment for annotating Linux reports.
+ """
+ fRc = False;
+ try:
+ sDbgArchive = os.path.join(self.sBuildRoot, 'bin', 'VirtualBoxDebug.tar.bz2');
+
+ # Extract debug symbol archive if it was found.
+ if os.path.exists(sDbgArchive):
+ asMembers = utils.unpackFile(sDbgArchive, self.sScratchPath, self.fnLog,
+ self.fnLog);
+ if asMembers:
+ # Populate the list of debug files.
+ for sMember in asMembers:
+ if os.path.isfile(sMember):
+ sArch = '';
+ if 'amd64' in sMember:
+ sArch = 'amd64';
+ else:
+ sArch = 'x86';
+ self.asDbgFiles[os.path.basename(sMember) + '/' + sArch] = sMember;
+ fRc = True;
+ else:
+ self.log('Unpacking the debug archive failed');
+ except:
+ self.log('Failed to setup debug symbols');
+
+ return fRc;
+
+ def cleanupEnv(self):
+ """
+ Cleans up the environment.
+ """
+ fRc = False;
+ try:
+ shutil.rmtree(self.sScratchPath, True);
+ fRc = True;
+ except:
+ pass;
+
+ return fRc;
+
+ def getDbgSymPathFromBinary(self, sBinary, sArch):
+ """
+ Returns the path to file containing the debug symbols for the specified binary.
+ """
+ sDbgFilePath = None;
+ try:
+ sDbgFilePath = self.asDbgFiles[sBinary + '/' + sArch];
+ except:
+ pass;
+
+ return sDbgFilePath;
+
+ def getBinaryListWithLoadAddrFromReport(self, asReport):
+ """
+ Parses the given VM state report and returns a list of binaries and their
+ load address.
+
+ Returns a list if tuples containing the binary and load addres or an empty
+ list on failure.
+ """
+ asListBinaries = [];
+
+ # Look for the beginning of the process address space mappings"
+ for sLine in asReport:
+ asItems = sLine.split();
+ if len(asItems) == 4 \
+ and asItems[3].startswith('/opt/VirtualBox') \
+ and ( asItems[2] == 'r-x--' \
+ or asItems[2] == 'r-x----'):
+ fFound = False;
+ sBinaryFile = os.path.basename(asItems[3]);
+ for _, sBinary in asListBinaries:
+ if sBinary == sBinaryFile:
+ fFound = True;
+ break;
+ if not fFound:
+ asListBinaries.append(('0x' + asItems[0], sBinaryFile));
+
+ return asListBinaries;
+
+
+
+class BacktraceResolver(object):
+ """
+ A backtrace resolving class.
+ """
+
+ def __init__(self, sScratchPath, sBuildRoot, sTargetOs, sArch, sRTLdrFltPath = None, fnLog = None):
+ """
+ Constructs a backtrace resolver object for the given target OS,
+ architecture and path to the directory containing the debug symbols and tools
+ we need.
+ """
+ # Initialize all members first.
+ self.sScratchPath = sScratchPath;
+ self.sBuildRoot = sBuildRoot;
+ self.sTargetOs = sTargetOs;
+ self.sArch = sArch;
+ self.sRTLdrFltPath = sRTLdrFltPath;
+ self.fnLog = fnLog;
+ self.sDbgSymPath = None;
+ self.oResolverOs = None;
+ self.sScratchDbgPath = os.path.join(self.sScratchPath, 'dbgsymbols');
+
+ if self.fnLog is None:
+ self.fnLog = self.logStub;
+
+ if self.sRTLdrFltPath is None:
+ self.sRTLdrFltPath = getRTLdrFltPath([self.sScratchPath, self.sBuildRoot]);
+ if self.sRTLdrFltPath is not None:
+ self.log('Found RTLdrFlt in %s' % (self.sRTLdrFltPath,));
+ else:
+ self.log('Couldn\'t find RTLdrFlt in either %s or %s' % (self.sScratchPath, self.sBuildRoot));
+
+ def log(self, sText):
+ """
+ Internal logger callback.
+ """
+ if self.fnLog is not None:
+ self.fnLog(sText);
+
+ def logStub(self, sText):
+ """
+ Logging stub doing nothing.
+ """
+ _ = sText;
+
+ def prepareEnv(self):
+ """
+ Prepares the environment to annotate backtraces, finding the required tools
+ and retrieving the debug symbols depending on the host OS.
+
+ Returns True on success and False on error or if not supported.
+ """
+
+ # No access to the RTLdrFlt tool means no symbols so no point in trying
+ # to set something up.
+ if self.sRTLdrFltPath is None:
+ return False;
+
+ # Create a directory containing the scratch space for the OS resolver backends.
+ fRc = True;
+ if not os.path.exists(self.sScratchDbgPath):
+ try:
+ os.makedirs(self.sScratchDbgPath, 0o750);
+ except:
+ fRc = False;
+ self.log('Failed to create scratch directory for debug symbols');
+
+ if fRc:
+ if self.sTargetOs == 'linux':
+ self.oResolverOs = BacktraceResolverOsLinux(self.sScratchDbgPath, self.sScratchPath, self.fnLog);
+ elif self.sTargetOs == 'darwin':
+ self.oResolverOs = BacktraceResolverOsDarwin(self.sScratchDbgPath, self.sScratchPath, self.fnLog); # pylint: disable=redefined-variable-type
+ elif self.sTargetOs == 'solaris':
+ self.oResolverOs = BacktraceResolverOsSolaris(self.sScratchDbgPath, self.sScratchPath, self.fnLog); # pylint: disable=redefined-variable-type
+ else:
+ self.log('The backtrace resolver is not supported on %s' % (self.sTargetOs,));
+ fRc = False;
+
+ if fRc:
+ fRc = self.oResolverOs.prepareEnv();
+ if not fRc:
+ self.oResolverOs = None;
+
+ if not fRc:
+ shutil.rmtree(self.sScratchDbgPath, True)
+
+ return fRc;
+
+ def cleanupEnv(self):
+ """
+ Prepares the environment to annotate backtraces, finding the required tools
+ and retrieving the debug symbols depending on the host OS.
+
+ Returns True on success and False on error or if not supported.
+ """
+ fRc = False;
+ if self.oResolverOs is not None:
+ fRc = self.oResolverOs.cleanupEnv();
+
+ shutil.rmtree(self.sScratchDbgPath, True);
+ return fRc;
+
+ def annotateReport(self, sReport):
+ """
+ Annotates the given report with the previously prepared environment.
+
+ Returns the annotated report on success or None on failure.
+ """
+ sReportAn = None;
+
+ if self.oResolverOs is not None:
+ asListBinaries = self.oResolverOs.getBinaryListWithLoadAddrFromReport(sReport.split('\n'));
+
+ if asListBinaries:
+ asArgs = [self.sRTLdrFltPath, ];
+
+ for sLoadAddr, sBinary in asListBinaries:
+ sDbgSymPath = self.oResolverOs.getDbgSymPathFromBinary(sBinary, self.sArch);
+ if sDbgSymPath is not None:
+ asArgs.append(sDbgSymPath);
+ asArgs.append(sLoadAddr);
+
+ oRTLdrFltProc = subprocess.Popen(asArgs, stdin=subprocess.PIPE, # pylint: disable=consider-using-with
+ stdout=subprocess.PIPE, bufsize=0);
+ if oRTLdrFltProc is not None:
+ try:
+ sReportAn, _ = oRTLdrFltProc.communicate(sReport);
+ except:
+ self.log('Retrieving annotation report failed (broken pipe / no matching interpreter?)');
+ else:
+ self.log('Error spawning RTLdrFlt process');
+ else:
+ self.log('Getting list of loaded binaries failed');
+ else:
+ self.log('Backtrace resolver not fully initialized, not possible to annotate');
+
+ return sReportAn;
+
diff --git a/src/VBox/ValidationKit/testdriver/reporter.py b/src/VBox/ValidationKit/testdriver/reporter.py
new file mode 100755
index 00000000..e5c55fd0
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/reporter.py
@@ -0,0 +1,1984 @@
+# -*- coding: utf-8 -*-
+# $Id: reporter.py $
+# pylint: disable=too-many-lines
+
+"""
+Testdriver reporter module.
+"""
+
+from __future__ import print_function;
+
+__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 array
+import datetime
+import errno
+import gc
+import os
+import os.path
+import sys
+import time
+import threading
+import traceback
+
+# Validation Kit imports.
+from common import utils;
+
+## test reporter instance
+g_oReporter = None # type: ReporterBase
+g_sReporterName = None;
+
+
+class ReporterLock(object):
+ """
+ Work around problem with garbage collection triggering __del__ method with
+ logging while inside the logger lock and causing a deadlock.
+ """
+
+ def __init__(self, sName):
+ self.sName = sName;
+ self.oLock = threading.RLock();
+ self.oOwner = None;
+ self.cRecursion = 0;
+ self.fRestoreGC = False;
+
+ def acquire(self):
+ """ Acquire the lock. """
+ oSelf = threading.current_thread();
+
+ # Take the lock.
+ if not self.oLock.acquire(): # pylint: disable=consider-using-with
+ return False;
+
+ self.oOwner = oSelf;
+ self.cRecursion += 1;
+
+ # Disable GC to avoid __del__ w/ log statement randomly reenter the logger.
+ if self.cRecursion == 1:
+ self.fRestoreGC = gc.isenabled();
+ if self.fRestoreGC:
+ gc.disable();
+
+ return True;
+
+ def release(self):
+ """ Release the lock. """
+ oSelf = threading.current_thread();
+
+ # Check the ownership.
+ if oSelf != self.oOwner:
+ raise threading.ThreadError();
+
+ # Drop one recursion.
+ self.cRecursion -= 1;
+ if self.cRecursion <= 0:
+
+ # Final recursion. Clear owner and re-enable GC.
+ self.oOwner = None;
+ if self.fRestoreGC:
+ self.fRestoreGC = False;
+ gc.enable();
+
+ self.oLock.release();
+
+## Reporter lock.
+g_oLock = ReporterLock('reporter');
+
+
+
+class PythonLoggingStream(object):
+ """
+ Python logging => testdriver/reporter.py stream.
+ """
+
+ def write(self, sText):
+ """Writes python log message to our stream."""
+ if g_oReporter is not None:
+ sText = sText.rstrip("\r\n");
+ #g_oReporter.log(0, 'python: %s' % (sText), utils.getCallerName(), utils.getTimePrefix());
+ return True;
+
+ def flush(self):
+ """Flushes the stream."""
+ return True;
+
+
+class ReporterBase(object):
+ """
+ Base class for the reporters.
+ """
+
+ def __init__(self):
+ self.iVerbose = 1;
+ self.iDebug = 0;
+ self.cErrors = 0;
+ self.fTimedOut = False; # Once set, it trickles all the way up.
+ self.atTests = [];
+ self.sName = os.path.splitext(os.path.basename(sys.argv[0]))[0];
+
+ # Hook into the python logging.
+ import logging;
+ logging.basicConfig(stream = PythonLoggingStream(),
+ level = logging.DEBUG,
+ format = '%(name)-12s %(levelname)-8s %(message)s');
+ #
+ # Introspection and configuration.
+ #
+
+ def isLocal(self):
+ """Is this a local reporter?"""
+ return False;
+
+ def incVerbosity(self):
+ """Increases the verbosity level."""
+ self.iVerbose += 1;
+
+ def incDebug(self):
+ """Increases the debug level."""
+ self.iDebug += 1;
+
+ def getVerbosity(self):
+ """Returns the current verbosity level."""
+ return self.iVerbose;
+
+ def getDebug(self):
+ """Returns the current debug level."""
+ return self.iDebug;
+
+ def appendToProcessName(self, sAppend):
+ """
+ Appends sAppend to the base process name.
+ Returns the new process name.
+ """
+ self.sName = os.path.splitext(os.path.basename(sys.argv[0]))[0] + sAppend;
+ return self.sName;
+
+
+ #
+ # Generic logging.
+ #
+
+ def log(self, iLevel, sText, sCaller, sTsPrf):
+ """
+ Writes the specfied text to the log if iLevel is less or requal
+ to iVerbose.
+ """
+ _ = iLevel; _ = sText; _ = sCaller; _ = sTsPrf;
+ return 0;
+
+ #
+ # XML output from the reporter.
+ #
+
+ def _xmlEscAttr(self, sValue):
+ """Escapes an XML attribute value."""
+ sValue = sValue.replace('&', '&amp;');
+ sValue = sValue.replace('<', '&lt;');
+ sValue = sValue.replace('>', '&gt;');
+ #sValue = sValue.replace('\'', '&apos;');
+ sValue = sValue.replace('"', '&quot;');
+ sValue = sValue.replace('\n', '&#xA');
+ sValue = sValue.replace('\r', '&#xD');
+ return sValue;
+
+ def _xmlWrite(self, asText, fIndent = True):
+ """XML output function for the reporter."""
+ _ = asText; _ = fIndent;
+ return None;
+
+ def xmlFlush(self, fRetry = False, fForce = False):
+ """Flushes XML output if buffered."""
+ _ = fRetry; _ = fForce;
+ return True;
+
+ #
+ # XML output from child.
+ #
+
+ def subXmlStart(self, oFileWrapper):
+ """Called by the file wrapper when the first bytes are written to the test pipe."""
+ _ = oFileWrapper;
+ return None;
+
+ def subXmlWrite(self, oFileWrapper, sRawXml, sCaller):
+ """Called by the file wrapper write method for test pipes."""
+ return self.log(0, 'raw xml%s: %s' % (oFileWrapper.sPrefix, sRawXml), sCaller, utils.getTimePrefix());
+
+ def subXmlEnd(self, oFileWrapper):
+ """Called by the file wrapper __del__ method for test pipes."""
+ _ = oFileWrapper;
+ return None;
+
+ #
+ # File output.
+ #
+
+ def addLogFile(self, oSrcFile, sSrcFilename, sAltName, sDescription, sKind, sCaller, sTsPrf):
+ """
+ Adds the file to the report.
+ Returns True on success, False on failure.
+ """
+ _ = oSrcFile; _ = sSrcFilename; _ = sAltName; _ = sDescription; _ = sKind; _ = sCaller; _ = sTsPrf;
+ return True;
+
+ def addLogString(self, sLog, sLogName, sDescription, sKind, sCaller, sTsPrf):
+ """
+ Adds the file to the report.
+ Returns True on success, False on failure.
+ """
+ _ = sLog; _ = sLogName; _ = sDescription; _ = sKind; _ = sCaller; _ = sTsPrf;
+ return True;
+
+ #
+ # Test reporting
+ #
+
+ def _testGetFullName(self):
+ """
+ Mangles the test names in atTest into a single name to make it easier
+ to spot where we are.
+ """
+ sName = '';
+ for t in self.atTests:
+ if sName != '':
+ sName += ', ';
+ sName += t[0];
+ return sName;
+
+ def testIncErrors(self):
+ """Increates the error count."""
+ self.cErrors += 1;
+ return self.cErrors;
+
+ def testSetTimedOut(self):
+ """Sets time out indicator for the current test and increases the error counter."""
+ self.fTimedOut = True;
+ self.cErrors += 1;
+ return None;
+
+ def testStart(self, sName, sCaller):
+ """ Starts a new test, may be nested. """
+ (sTsPrf, sTsIso) = utils.getTimePrefixAndIsoTimestamp();
+ self._xmlWrite([ '<Test timestamp="%s" name="%s">' % (sTsIso, self._xmlEscAttr(sName),), ]);
+ self.atTests.append((sName, self.cErrors, self.fTimedOut));
+ self.fTimedOut = False;
+ return self.log(1, ' %-50s: TESTING' % (self._testGetFullName()), sCaller, sTsPrf);
+
+ def testValue(self, sName, sValue, sUnit, sCaller):
+ """ Reports a benchmark value or something simiarlly useful. """
+ (sTsPrf, sTsIso) = utils.getTimePrefixAndIsoTimestamp();
+ self._xmlWrite([ '<Value timestamp="%s" name="%s" unit="%s" value="%s"/>'
+ % (sTsIso, self._xmlEscAttr(sName), self._xmlEscAttr(sUnit), self._xmlEscAttr(sValue)), ]);
+ return self.log(0, '** %-48s: %12s %s' % (sName, sValue, sUnit), sCaller, sTsPrf);
+
+ def testFailure(self, sDetails, sCaller):
+ """ Reports a failure. """
+ (sTsPrf, sTsIso) = utils.getTimePrefixAndIsoTimestamp();
+ self.cErrors = self.cErrors + 1;
+ self._xmlWrite([ '<FailureDetails timestamp="%s" text="%s"/>' % (sTsIso, self._xmlEscAttr(sDetails),), ]);
+ return self.log(0, sDetails, sCaller, sTsPrf);
+
+ def testDone(self, fSkipped, sCaller):
+ """
+ Marks the current test as DONE, pops it and maks the next test on the
+ stack current.
+ Returns (name, errors).
+ """
+ (sTsPrf, sTsIso) = utils.getTimePrefixAndIsoTimestamp();
+ sFullName = self._testGetFullName();
+
+ # safe pop
+ if not self.atTests:
+ self.log(0, 'testDone on empty test stack!', sCaller, sTsPrf);
+ return ('internal error', 0);
+ fTimedOut = self.fTimedOut;
+ sName, cErrorsStart, self.fTimedOut = self.atTests.pop();
+
+ # log + xml.
+ cErrors = self.cErrors - cErrorsStart;
+ if cErrors == 0:
+ if fSkipped is not True:
+ self._xmlWrite([ ' <Passed timestamp="%s"/>' % (sTsIso,), '</Test>' ],);
+ self.log(1, '** %-50s: PASSED' % (sFullName,), sCaller, sTsPrf);
+ else:
+ self._xmlWrite([ ' <Skipped timestamp="%s"/>' % (sTsIso,), '</Test>' ]);
+ self.log(1, '** %-50s: SKIPPED' % (sFullName,), sCaller, sTsPrf);
+ elif fTimedOut:
+ self._xmlWrite([ ' <TimedOut timestamp="%s" errors="%d"/>' % (sTsIso, cErrors), '</Test>' ]);
+ self.log(0, '** %-50s: TIMED-OUT - %d errors' % (sFullName, cErrors), sCaller, sTsPrf);
+ else:
+ self._xmlWrite([ ' <Failed timestamp="%s" errors="%d"/>' % (sTsIso, cErrors), '</Test>' ]);
+ self.log(0, '** %-50s: FAILED - %d errors' % (sFullName, cErrors), sCaller, sTsPrf);
+
+ # Flush buffers when reaching the last test.
+ if not self.atTests:
+ self.xmlFlush(fRetry = True);
+
+ return (sName, cErrors);
+
+ def testErrorCount(self):
+ """
+ Returns the number of errors accumulated by the current test.
+ """
+ cTests = len(self.atTests);
+ if cTests <= 0:
+ return self.cErrors;
+ return self.cErrors - self.atTests[cTests - 1][1];
+
+ def testCleanup(self, sCaller):
+ """
+ Closes all open test as failed.
+ Returns True if no open tests, False if there were open tests.
+ """
+ if not self.atTests:
+ return True;
+ for _ in range(len(self.atTests)):
+ self.testFailure('Test not closed by test drver', sCaller)
+ self.testDone(False, sCaller);
+ return False;
+
+ #
+ # Misc.
+ #
+
+ def doPollWork(self, sDebug = None):
+ """
+ Check if any pending stuff expired and needs doing.
+ """
+ _ = sDebug;
+ return None;
+
+
+
+
+class LocalReporter(ReporterBase):
+ """
+ Local reporter instance.
+ """
+
+ def __init__(self):
+ ReporterBase.__init__(self);
+ self.oLogFile = None;
+ self.oXmlFile = None;
+ self.fXmlOk = True;
+ self.iSubXml = 0;
+ self.iOtherFile = 0;
+ self.fnGetIsoTimestamp = utils.getIsoTimestamp; # Hack to get a timestamp in __del__.
+ self.oStdErr = sys.stderr; # Hack for __del__ output.
+
+ #
+ # Figure the main log directory.
+ #
+ try:
+ self.sDefLogDir = os.path.abspath(os.path.expanduser(os.path.join('~', 'VBoxTestLogs')));
+ except:
+ self.sDefLogDir = os.path.abspath("VBoxTestLogs");
+ try:
+ sLogDir = os.path.abspath(os.environ.get('TESTBOX_REPORTER_LOG_DIR', self.sDefLogDir));
+ if not os.path.isdir(sLogDir):
+ os.makedirs(sLogDir, 0o750);
+ except:
+ sLogDir = self.sDefLogDir;
+ if not os.path.isdir(sLogDir):
+ os.makedirs(sLogDir, 0o750);
+
+ #
+ # Make a subdirectory for this test run.
+ #
+ sTs = datetime.datetime.utcnow().strftime('%Y-%m-%dT%H-%M-%S.log');
+ self.sLogDir = sLogDir = os.path.join(sLogDir, '%s-%s' % (sTs, self.sName));
+ try:
+ os.makedirs(self.sLogDir, 0o750);
+ except:
+ self.sLogDir = '%s-%s' % (self.sLogDir, os.getpid());
+ os.makedirs(self.sLogDir, 0o750);
+
+ #
+ # Open the log file and write a header.
+ #
+ sLogName = os.path.join(self.sLogDir, 'testsuite.log');
+ sTsIso = utils.getIsoTimestamp();
+ if sys.version_info[0] >= 3: # Add 'b' to prevent write taking issue with encode('utf-8') not returning a string.
+ self.oLogFile = utils.openNoInherit(sLogName, "wb");
+ else:
+ self.oLogFile = utils.openNoInherit(sLogName, "w");
+ self.oLogFile.write(('Created log file at %s.\nRunning: %s' % (sTsIso, sys.argv)).encode('utf-8'));
+
+ #
+ # Open the xml log file and write the mandatory introduction.
+ #
+ # Note! This is done here and not in the base class because the remote
+ # logger doesn't really need this. It doesn't need the outer
+ # test wrapper either.
+ #
+ sXmlName = os.path.join(self.sLogDir, 'testsuite.xml');
+ if sys.version_info[0] >= 3: # Add 'b' to prevent write taking issue with encode('utf-8') not returning a string.
+ self.oXmlFile = utils.openNoInherit(sXmlName, "wb");
+ else:
+ self.oXmlFile = utils.openNoInherit(sXmlName, "w");
+ self._xmlWrite([ '<?xml version="1.0" encoding="UTF-8" ?>',
+ '<Test timestamp="%s" name="%s">' % (sTsIso, self._xmlEscAttr(self.sName),), ],
+ fIndent = False);
+
+ def __del__(self):
+ """Ends and completes the log files."""
+ try: sTsIso = self.fnGetIsoTimestamp();
+ except Exception as oXcpt:
+ sTsIso = str(oXcpt);
+
+ if self.oLogFile is not None:
+ try:
+ self.oLogFile.write(('\nThe End %s\n' % (sTsIso,)).encode('utf-8'));
+ self.oLogFile.close();
+ except: pass;
+ self.oLogFile = None;
+
+ if self.oXmlFile is not None:
+ self._closeXml(sTsIso);
+ self.oXmlFile = None;
+
+ def _closeXml(self, sTsIso):
+ """Closes the XML file."""
+ if self.oXmlFile is not None:
+ # pop the test stack
+ while self.atTests:
+ sName, cErrorsStart, self.fTimedOut = self.atTests.pop();
+ self._xmlWrite([ '<End timestamp="%s" errors="%d"/>' % (sTsIso, self.cErrors - cErrorsStart,),
+ '</%s>' % (sName,), ]);
+
+ # The outer one is not on the stack.
+ self._xmlWrite([ ' <End timestamp="%s"/>' % (sTsIso,),
+ '</Test>', ], fIndent = False);
+ try:
+ self.oXmlFile.close();
+ self.oXmlFile = None;
+ except:
+ pass;
+
+ def _xmlWrite(self, asText, fIndent = True):
+ """Writes to the XML file."""
+ for sText in asText:
+ if fIndent:
+ sIndent = ''.ljust((len(self.atTests) + 1) * 2);
+ sText = sIndent + sText;
+ sText += '\n';
+
+ try:
+ self.oXmlFile.write(sText.encode('utf-8'));
+ except:
+ if self.fXmlOk:
+ traceback.print_exc();
+ self.fXmlOk = False;
+ return False;
+ return True;
+
+ #
+ # Overridden methods.
+ #
+
+ def isLocal(self):
+ """Is this a local reporter?"""
+ return True;
+
+ def log(self, iLevel, sText, sCaller, sTsPrf):
+ if iLevel <= self.iVerbose:
+ # format it.
+ if self.iDebug <= 0:
+ sLogText = '%s %s' % (sTsPrf, sText);
+ elif self.iDebug <= 1:
+ sLogText = '%s %30s: %s' % (sTsPrf, sCaller, sText);
+ else:
+ sLogText = '%s e=%u %30s: %s' % (sTsPrf, self.cErrors, sCaller, sText);
+
+ # output it.
+ if sys.version_info[0] >= 3:
+ sAscii = sLogText;
+ else:
+ sAscii = sLogText.encode('ascii', 'replace');
+ if self.iDebug == 0:
+ print('%s: %s' % (self.sName, sAscii), file = self.oStdErr);
+ else:
+ print('%s' % (sAscii), file = self.oStdErr);
+ sLogText += '\n';
+ try:
+ self.oLogFile.write(sLogText.encode('utf-8'));
+ except:
+ pass;
+ return 0;
+
+ def addLogFile(self, oSrcFile, sSrcFilename, sAltName, sDescription, sKind, sCaller, sTsPrf):
+ # Figure the destination filename.
+ iOtherFile = self.iOtherFile;
+ self.iOtherFile += 1;
+ sDstFilename = os.path.join(self.sLogDir, 'other-%d-%s.log' \
+ % (iOtherFile, os.path.splitext(os.path.basename(sSrcFilename))[0]));
+ self.log(0, '** Other log file: %s - %s (%s)' % (sDstFilename, sDescription, sSrcFilename), sCaller, sTsPrf);
+
+ # Open the destination file and copy over the data.
+ fRc = True;
+ try:
+ oDstFile = utils.openNoInherit(sDstFilename, 'wb');
+ except Exception as oXcpt:
+ self.log(0, 'error opening %s: %s' % (sDstFilename, oXcpt), sCaller, sTsPrf);
+ else:
+ while True:
+ try:
+ abBuf = oSrcFile.read(65536);
+ except Exception as oXcpt:
+ fRc = False;
+ self.log(0, 'error reading %s: %s' % (sSrcFilename, oXcpt), sCaller, sTsPrf);
+ else:
+ try:
+ oDstFile.write(abBuf);
+ except Exception as oXcpt:
+ fRc = False;
+ self.log(0, 'error writing %s: %s' % (sDstFilename, oXcpt), sCaller, sTsPrf);
+ else:
+ if abBuf:
+ continue;
+ break;
+ oDstFile.close();
+
+ # Leave a mark in the XML log.
+ self._xmlWrite(['<LogFile timestamp="%s" filename="%s" source="%s" kind="%s" ok="%s">%s</LogFile>\n'
+ % (utils.getIsoTimestamp(), self._xmlEscAttr(os.path.basename(sDstFilename)), self._xmlEscAttr(sSrcFilename), \
+ self._xmlEscAttr(sKind), fRc, self._xmlEscAttr(sDescription))] );
+ _ = sAltName;
+ return fRc;
+
+ def addLogString(self, sLog, sLogName, sDescription, sKind, sCaller, sTsPrf):
+ # Figure the destination filename.
+ iOtherFile = self.iOtherFile;
+ self.iOtherFile += 1;
+ sDstFilename = os.path.join(self.sLogDir, 'other-%d-%s.log' \
+ % (iOtherFile, os.path.splitext(os.path.basename(sLogName))[0]));
+ self.log(0, '** Other log file: %s - %s (%s)' % (sDstFilename, sDescription, sLogName), sCaller, sTsPrf);
+
+ # Open the destination file and copy over the data.
+ fRc = True;
+ try:
+ oDstFile = utils.openNoInherit(sDstFilename, 'w');
+ except Exception as oXcpt:
+ self.log(0, 'error opening %s: %s' % (sDstFilename, oXcpt), sCaller, sTsPrf);
+ else:
+ try:
+ oDstFile.write(sLog);
+ except Exception as oXcpt:
+ fRc = False;
+ self.log(0, 'error writing %s: %s' % (sDstFilename, oXcpt), sCaller, sTsPrf);
+
+ oDstFile.close();
+
+ # Leave a mark in the XML log.
+ self._xmlWrite(['<LogFile timestamp="%s" filename="%s" source="%s" kind="%s" ok="%s">%s</LogFile>\n'
+ % (utils.getIsoTimestamp(), self._xmlEscAttr(os.path.basename(sDstFilename)), self._xmlEscAttr(sLogName), \
+ self._xmlEscAttr(sKind), fRc, self._xmlEscAttr(sDescription))] );
+ return fRc;
+
+ def subXmlStart(self, oFileWrapper):
+ # Open a new file and just include it from the main XML.
+ iSubXml = self.iSubXml;
+ self.iSubXml += 1;
+ sSubXmlName = os.path.join(self.sLogDir, 'sub-%d.xml' % (iSubXml,));
+ try:
+ oFileWrapper.oSubXmlFile = utils.openNoInherit(sSubXmlName, "w");
+ except:
+ errorXcpt('open(%s)' % oFileWrapper.oSubXmlName);
+ oFileWrapper.oSubXmlFile = None;
+ else:
+ self._xmlWrite(['<Include timestamp="%s" filename="%s"/>\n'
+ % (utils.getIsoTimestamp(), self._xmlEscAttr(os.path.basename(sSubXmlName)))]);
+ return None;
+
+ def subXmlWrite(self, oFileWrapper, sRawXml, sCaller):
+ if oFileWrapper.oSubXmlFile is not None:
+ try:
+ oFileWrapper.oSubXmlFile.write(sRawXml);
+ except:
+ pass;
+ if sCaller is None: pass; # pychecker - NOREF
+ return None;
+
+ def subXmlEnd(self, oFileWrapper):
+ if oFileWrapper.oSubXmlFile is not None:
+ try:
+ oFileWrapper.oSubXmlFile.close();
+ oFileWrapper.oSubXmlFile = None;
+ except:
+ pass;
+ return None;
+
+
+
+class RemoteReporter(ReporterBase):
+ """
+ Reporter that talks to the test manager server.
+ """
+
+
+ ## The XML sync min time (seconds).
+ kcSecXmlFlushMin = 30;
+ ## The XML sync max time (seconds).
+ kcSecXmlFlushMax = 120;
+ ## The XML sync idle time before flushing (seconds).
+ kcSecXmlFlushIdle = 5;
+ ## The XML sync line count threshold.
+ kcLinesXmlFlush = 512;
+
+ ## The retry timeout.
+ kcSecTestManagerRetryTimeout = 120;
+ ## The request timeout.
+ kcSecTestManagerRequestTimeout = 30;
+
+
+ def __init__(self):
+ ReporterBase.__init__(self);
+ self.sTestManagerUrl = os.environ.get('TESTBOX_MANAGER_URL');
+ self.sTestBoxUuid = os.environ.get('TESTBOX_UUID');
+ self.idTestBox = int(os.environ.get('TESTBOX_ID'));
+ self.idTestSet = int(os.environ.get('TESTBOX_TEST_SET_ID'));
+ self._asXml = [];
+ self._secTsXmlFlush = utils.timestampSecond();
+ self._secTsXmlLast = self._secTsXmlFlush;
+ self._fXmlFlushing = False;
+ self.oOutput = sys.stdout; # Hack for __del__ output.
+ self.fFlushEachLine = True;
+ self.fDebugXml = 'TESTDRIVER_REPORTER_DEBUG_XML' in os.environ;
+
+ # Prepare the TM connecting.
+ from common import constants;
+ if sys.version_info[0] >= 3:
+ import urllib;
+ self._fnUrlEncode = urllib.parse.urlencode; # pylint: disable=no-member
+ self._fnUrlParseQs = urllib.parse.parse_qs; # pylint: disable=no-member
+ self._oParsedTmUrl = urllib.parse.urlparse(self.sTestManagerUrl); # pylint: disable=no-member
+ import http.client as httplib; # pylint: disable=no-name-in-module,import-error
+ else:
+ import urllib;
+ self._fnUrlEncode = urllib.urlencode; # pylint: disable=no-member
+ import urlparse; # pylint: disable=import-error
+ self._fnUrlParseQs = urlparse.parse_qs; # pylint: disable=no-member
+ self._oParsedTmUrl = urlparse.urlparse(self.sTestManagerUrl); # pylint: disable=no-member
+ import httplib; # pylint: disable=no-name-in-module,import-error
+
+ if sys.version_info[0] >= 3 \
+ or (sys.version_info[0] == 2 and sys.version_info[1] >= 6):
+ if self._oParsedTmUrl.scheme == 'https': # pylint: disable=no-member
+ self._fnTmConnect = lambda: httplib.HTTPSConnection(self._oParsedTmUrl.hostname,
+ timeout = self.kcSecTestManagerRequestTimeout);
+ else:
+ self._fnTmConnect = lambda: httplib.HTTPConnection( self._oParsedTmUrl.hostname,
+ timeout = self.kcSecTestManagerRequestTimeout);
+ else:
+ if self._oParsedTmUrl.scheme == 'https': # pylint: disable=no-member
+ self._fnTmConnect = lambda: httplib.HTTPSConnection(self._oParsedTmUrl.hostname);
+ else:
+ self._fnTmConnect = lambda: httplib.HTTPConnection( self._oParsedTmUrl.hostname);
+ self._dHttpHeader = \
+ {
+ 'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
+ 'User-Agent': 'TestDriverReporter/%s.0 (%s, %s)' % (__version__, utils.getHostOs(), utils.getHostArch(),),
+ 'Accept': 'text/plain,application/x-www-form-urlencoded',
+ 'Accept-Encoding': 'identity',
+ 'Cache-Control': 'max-age=0',
+ #'Connection': 'keep-alive',
+ };
+
+ dParams = {
+ constants.tbreq.ALL_PARAM_TESTBOX_UUID: self.sTestBoxUuid,
+ constants.tbreq.ALL_PARAM_TESTBOX_ID: self.idTestBox,
+ constants.tbreq.RESULT_PARAM_TEST_SET_ID: self.idTestSet,
+ };
+ self._sTmServerPath = '/%s/testboxdisp.py?%s' \
+ % ( self._oParsedTmUrl.path.strip('/'), # pylint: disable=no-member
+ self._fnUrlEncode(dParams), );
+
+ def __del__(self):
+ """Flush pending log messages?"""
+ if self._asXml:
+ self._xmlDoFlush(self._asXml, fRetry = True, fDtor = True);
+
+ def _writeOutput(self, sText):
+ """ Does the actual writing and flushing. """
+ if sys.version_info[0] >= 3:
+ print(sText, file = self.oOutput);
+ else:
+ print(sText.encode('ascii', 'replace'), file = self.oOutput);
+ if self.fFlushEachLine: self.oOutput.flush();
+ return None;
+
+ #
+ # Talking to TM.
+ #
+
+ def _processTmStatusResponse(self, oConn, sOperation, fClose = True):
+ """
+ Processes HTTP reponse from the test manager.
+ Returns True, False or None. None should be retried, the others not.
+ May raise exception on HTTP issue (retry ok).
+ """
+ if sys.version_info[0] >= 3: import http.client as httplib; # pylint: disable=no-name-in-module,import-error
+ else: import httplib; # pylint: disable=import-error
+ from common import constants;
+
+ # Read the response and (optionally) close the connection.
+ oResponse = oConn.getresponse();
+ try:
+ sRspBody = oResponse.read();
+ except httplib.IncompleteRead as oXcpt:
+ self._writeOutput('%s: %s: Warning: httplib.IncompleteRead: %s [expected %s, got %s]'
+ % (utils.getTimePrefix(), sOperation, oXcpt, oXcpt.expected, len(oXcpt.partial),));
+ sRspBody = oXcpt.partial;
+ if fClose is True:
+ try: oConn.close();
+ except: pass;
+
+ # Make sure it's a string which encoding we grok.
+ if hasattr(sRspBody, 'decode'):
+ sRspBody = sRspBody.decode('utf-8', 'ignore');
+
+ # Check the content type.
+ sContentType = oResponse.getheader('Content-Type');
+ if sContentType is not None and sContentType == 'application/x-www-form-urlencoded; charset=utf-8':
+
+ # Parse the body and check the RESULT parameter.
+ dResponse = self._fnUrlParseQs(sRspBody, strict_parsing = True);
+ sResult = dResponse.get(constants.tbresp.ALL_PARAM_RESULT, None);
+ if isinstance(sResult, list):
+ sResult = sResult[0] if len(sResult) == 1 else '%d results' % (len(sResult),);
+
+ if sResult is not None:
+ if sResult == constants.tbresp.STATUS_ACK:
+ return True;
+ if sResult == constants.tbresp.STATUS_NACK:
+ self._writeOutput('%s: %s: Failed (%s). (dResponse=%s)'
+ % (utils.getTimePrefix(), sOperation, sResult, dResponse,));
+ return False;
+
+ self._writeOutput('%s: %s: Failed - dResponse=%s' % (utils.getTimePrefix(), sOperation, dResponse,));
+ else:
+ self._writeOutput('%s: %s: Unexpected Content-Type: %s' % (utils.getTimePrefix(), sOperation, sContentType,));
+ self._writeOutput('%s: %s: Body: %s' % (utils.getTimePrefix(), sOperation, sRspBody,));
+ return None;
+
+ def _doUploadFile(self, oSrcFile, sSrcFilename, sDescription, sKind, sMime):
+ """ Uploads the given file to the test manager. """
+
+ # Prepare header and url.
+ dHeader = dict(self._dHttpHeader);
+ dHeader['Content-Type'] = 'application/octet-stream';
+ self._writeOutput('%s: _doUploadFile: sHeader=%s' % (utils.getTimePrefix(), dHeader,));
+ oSrcFile.seek(0, 2);
+ cbFileSize = oSrcFile.tell();
+ self._writeOutput('%s: _doUploadFile: size=%d' % (utils.getTimePrefix(), cbFileSize,));
+ oSrcFile.seek(0);
+
+ if cbFileSize <= 0: # The Test Manager will bitch if the file size is 0, so skip uploading.
+ self._writeOutput('%s: _doUploadFile: Empty file, skipping upload' % utils.getTimePrefix());
+ return False;
+
+ from common import constants;
+ sUrl = self._sTmServerPath + '&' \
+ + self._fnUrlEncode({ constants.tbreq.UPLOAD_PARAM_NAME: os.path.basename(sSrcFilename),
+ constants.tbreq.UPLOAD_PARAM_DESC: sDescription,
+ constants.tbreq.UPLOAD_PARAM_KIND: sKind,
+ constants.tbreq.UPLOAD_PARAM_MIME: sMime,
+ constants.tbreq.ALL_PARAM_ACTION: constants.tbreq.UPLOAD,
+ });
+
+ # Retry loop.
+ secStart = utils.timestampSecond();
+ while True:
+ try:
+ oConn = self._fnTmConnect();
+ oConn.request('POST', sUrl, oSrcFile.read(), dHeader);
+ fRc = self._processTmStatusResponse(oConn, '_doUploadFile', fClose = True);
+ oConn.close();
+ if fRc is not None:
+ return fRc;
+ except:
+ logXcpt('warning: exception during UPLOAD request');
+
+ if utils.timestampSecond() - secStart >= self.kcSecTestManagerRetryTimeout:
+ self._writeOutput('%s: _doUploadFile: Timed out.' % (utils.getTimePrefix(),));
+ break;
+ try: oSrcFile.seek(0);
+ except:
+ logXcpt();
+ break;
+ self._writeOutput('%s: _doUploadFile: Retrying...' % (utils.getTimePrefix(), ));
+ time.sleep(2);
+
+ return False;
+
+ def _doUploadString(self, sSrc, sSrcName, sDescription, sKind, sMime):
+ """ Uploads the given string as a separate file to the test manager. """
+
+ # Prepare header and url.
+ dHeader = dict(self._dHttpHeader);
+ dHeader['Content-Type'] = 'application/octet-stream';
+ self._writeOutput('%s: _doUploadString: sHeader=%s' % (utils.getTimePrefix(), dHeader,));
+ self._writeOutput('%s: _doUploadString: size=%d' % (utils.getTimePrefix(), sys.getsizeof(sSrc),));
+
+ from common import constants;
+ sUrl = self._sTmServerPath + '&' \
+ + self._fnUrlEncode({ constants.tbreq.UPLOAD_PARAM_NAME: os.path.basename(sSrcName),
+ constants.tbreq.UPLOAD_PARAM_DESC: sDescription,
+ constants.tbreq.UPLOAD_PARAM_KIND: sKind,
+ constants.tbreq.UPLOAD_PARAM_MIME: sMime,
+ constants.tbreq.ALL_PARAM_ACTION: constants.tbreq.UPLOAD,
+ });
+
+ # Retry loop.
+ secStart = utils.timestampSecond();
+ while True:
+ try:
+ oConn = self._fnTmConnect();
+ oConn.request('POST', sUrl, sSrc, dHeader);
+ fRc = self._processTmStatusResponse(oConn, '_doUploadString', fClose = True);
+ oConn.close();
+ if fRc is not None:
+ return fRc;
+ except:
+ logXcpt('warning: exception during UPLOAD request');
+
+ if utils.timestampSecond() - secStart >= self.kcSecTestManagerRetryTimeout:
+ self._writeOutput('%s: _doUploadString: Timed out.' % (utils.getTimePrefix(),));
+ break;
+ self._writeOutput('%s: _doUploadString: Retrying...' % (utils.getTimePrefix(), ));
+ time.sleep(2);
+
+ return False;
+
+ def _xmlDoFlush(self, asXml, fRetry = False, fDtor = False):
+ """
+ The code that does the actual talking to the server.
+ Used by both xmlFlush and __del__.
+ """
+ secStart = utils.timestampSecond();
+ while True:
+ fRc = None;
+ try:
+ # Post.
+ from common import constants;
+ sPostBody = self._fnUrlEncode({constants.tbreq.XML_RESULT_PARAM_BODY: '\n'.join(asXml),});
+ oConn = self._fnTmConnect();
+ oConn.request('POST',
+ self._sTmServerPath + ('&%s=%s' % (constants.tbreq.ALL_PARAM_ACTION, constants.tbreq.XML_RESULTS)),
+ sPostBody,
+ self._dHttpHeader);
+
+ fRc = self._processTmStatusResponse(oConn, '_xmlDoFlush', fClose = True);
+ if fRc is True:
+ if self.fDebugXml:
+ self._writeOutput('_xmlDoFlush:\n%s' % ('\n'.join(asXml),));
+ return (None, False);
+ if fRc is False:
+ self._writeOutput('_xmlDoFlush: Failed - we should abort the test, really.');
+ return (None, True);
+ except Exception as oXcpt:
+ if not fDtor:
+ logXcpt('warning: exception during XML_RESULTS request');
+ else:
+ self._writeOutput('warning: exception during XML_RESULTS request: %s' % (oXcpt,));
+
+ if fRetry is not True \
+ or utils.timestampSecond() - secStart >= self.kcSecTestManagerRetryTimeout:
+ break;
+ time.sleep(2);
+
+ return (asXml, False);
+
+
+ #
+ # Overridden methods.
+ #
+
+ def isLocal(self):
+ return False;
+
+ def log(self, iLevel, sText, sCaller, sTsPrf):
+ if iLevel <= self.iVerbose:
+ if self.iDebug <= 0:
+ sLogText = '%s %s' % (sTsPrf, sText);
+ elif self.iDebug <= 1:
+ sLogText = '%s %30s: %s' % (sTsPrf, sCaller, sText);
+ else:
+ sLogText = '%s e=%u %30s: %s' % (sTsPrf, self.cErrors, sCaller, sText);
+ self._writeOutput(sLogText);
+ return 0;
+
+ def addLogFile(self, oSrcFile, sSrcFilename, sAltName, sDescription, sKind, sCaller, sTsPrf):
+ fRc = True;
+ if sKind in [ 'text', 'log', 'process'] \
+ or sKind.startswith('log/') \
+ or sKind.startswith('info/') \
+ or sKind.startswith('process/'):
+ self.log(0, '*** Uploading "%s" - KIND: "%s" - DESC: "%s" ***'
+ % (sSrcFilename, sKind, sDescription), sCaller, sTsPrf);
+ self.xmlFlush();
+ g_oLock.release();
+ try:
+ self._doUploadFile(oSrcFile, sAltName, sDescription, sKind, 'text/plain');
+ finally:
+ g_oLock.acquire();
+ elif sKind.startswith('screenshot/'):
+ self.log(0, '*** Uploading "%s" - KIND: "%s" - DESC: "%s" ***'
+ % (sSrcFilename, sKind, sDescription), sCaller, sTsPrf);
+ self.xmlFlush();
+ g_oLock.release();
+ try:
+ self._doUploadFile(oSrcFile, sAltName, sDescription, sKind, 'image/png');
+ finally:
+ g_oLock.acquire();
+ elif sKind.startswith('screenrecording/'):
+ self.log(0, '*** Uploading "%s" - KIND: "%s" - DESC: "%s" ***'
+ % (sSrcFilename, sKind, sDescription), sCaller, sTsPrf);
+ self.xmlFlush();
+ g_oLock.release();
+ try:
+ self._doUploadFile(oSrcFile, sAltName, sDescription, sKind, 'video/webm');
+ finally:
+ g_oLock.acquire();
+ elif sKind.startswith('misc/'):
+ self.log(0, '*** Uploading "%s" - KIND: "%s" - DESC: "%s" ***'
+ % (sSrcFilename, sKind, sDescription), sCaller, sTsPrf);
+ self.xmlFlush();
+ g_oLock.release();
+ try:
+ self._doUploadFile(oSrcFile, sAltName, sDescription, sKind, 'application/octet-stream');
+ finally:
+ g_oLock.acquire();
+ else:
+ self.log(0, '*** UNKNOWN FILE "%s" - KIND "%s" - DESC "%s" ***'
+ % (sSrcFilename, sKind, sDescription), sCaller, sTsPrf);
+ return fRc;
+
+ def addLogString(self, sLog, sLogName, sDescription, sKind, sCaller, sTsPrf):
+ fRc = True;
+ if sKind in [ 'text', 'log', 'process'] \
+ or sKind.startswith('log/') \
+ or sKind.startswith('info/') \
+ or sKind.startswith('process/'):
+ self.log(0, '*** Uploading "%s" - KIND: "%s" - DESC: "%s" ***'
+ % (sLogName, sKind, sDescription), sCaller, sTsPrf);
+ self.xmlFlush();
+ g_oLock.release();
+ try:
+ self._doUploadString(sLog, sLogName, sDescription, sKind, 'text/plain');
+ finally:
+ g_oLock.acquire();
+ else:
+ self.log(0, '*** UNKNOWN FILE "%s" - KIND "%s" - DESC "%s" ***'
+ % (sLogName, sKind, sDescription), sCaller, sTsPrf);
+ return fRc;
+
+ def xmlFlush(self, fRetry = False, fForce = False):
+ """
+ Flushes the XML back log. Called with the lock held, may leave it
+ while communicating with the server.
+ """
+ if not self._fXmlFlushing:
+ asXml = self._asXml;
+ self._asXml = [];
+ if asXml or fForce is True:
+ self._fXmlFlushing = True;
+
+ g_oLock.release();
+ try:
+ (asXml, fIncErrors) = self._xmlDoFlush(asXml, fRetry = fRetry);
+ finally:
+ g_oLock.acquire();
+
+ if fIncErrors:
+ self.testIncErrors();
+
+ self._fXmlFlushing = False;
+ if asXml is None:
+ self._secTsXmlFlush = utils.timestampSecond();
+ else:
+ self._asXml = asXml + self._asXml;
+ return True;
+
+ self._secTsXmlFlush = utils.timestampSecond();
+ return False;
+
+ def _xmlFlushIfNecessary(self, fPolling = False, sDebug = None):
+ """Flushes the XML back log if necessary."""
+ tsNow = utils.timestampSecond();
+ cSecs = tsNow - self._secTsXmlFlush;
+ cSecsLast = tsNow - self._secTsXmlLast;
+ if fPolling is not True:
+ self._secTsXmlLast = tsNow;
+
+ # Absolute flush thresholds.
+ if cSecs >= self.kcSecXmlFlushMax:
+ return self.xmlFlush();
+ if len(self._asXml) >= self.kcLinesXmlFlush:
+ return self.xmlFlush();
+
+ # Flush if idle long enough.
+ if cSecs >= self.kcSecXmlFlushMin \
+ and cSecsLast >= self.kcSecXmlFlushIdle:
+ return self.xmlFlush();
+
+ _ = sDebug;
+ return False;
+
+ def _xmlWrite(self, asText, fIndent = True):
+ """XML output function for the reporter."""
+ self._asXml += asText;
+ self._xmlFlushIfNecessary();
+ _ = fIndent; # No pretty printing, thank you.
+ return None;
+
+ def subXmlStart(self, oFileWrapper):
+ oFileWrapper.sXmlBuffer = '';
+ return None;
+
+ def subXmlWrite(self, oFileWrapper, sRawXml, sCaller):
+ oFileWrapper.sXmlBuffer += sRawXml;
+ _ = sCaller;
+ return None;
+
+ def subXmlEnd(self, oFileWrapper):
+ sRawXml = oFileWrapper.sXmlBuffer;
+ ## @todo should validate the document here and maybe auto terminate things. Adding some hints to have the server do
+ # this instead.
+ g_oLock.acquire();
+ try:
+ self._asXml += [ '<PushHint testdepth="%d"/>' % (len(self.atTests),),
+ sRawXml,
+ '<PopHint testdepth="%d"/>' % (len(self.atTests),),];
+ self._xmlFlushIfNecessary();
+ finally:
+ g_oLock.release();
+ return None;
+
+ def doPollWork(self, sDebug = None):
+ if self._asXml:
+ g_oLock.acquire();
+ try:
+ self._xmlFlushIfNecessary(fPolling = True, sDebug = sDebug);
+ finally:
+ g_oLock.release();
+ return None;
+
+
+#
+# Helpers
+#
+
+g_fnComXcptFormatter = None;
+
+def setComXcptFormatter(fnCallback):
+ """
+ Install callback for prettier COM exception formatting.
+
+ The callback replaces the work done by format_exception_only() and
+ takes the same arguments. It returns None if not interested in the
+ exception.
+ """
+ global g_fnComXcptFormatter;
+ g_fnComXcptFormatter = fnCallback;
+ return True;
+
+def formatExceptionOnly(oType, oXcpt, sCaller, sTsPrf):
+ """
+ Wrapper around traceback.format_exception_only and __g_fnComXcptFormatter.
+ """
+ #asRet = ['oType=%s type(oXcpt)=%s' % (oType, type(oXcpt),)];
+ asRet = [];
+
+ # Try the callback first.
+ fnCallback = g_fnComXcptFormatter;
+ if fnCallback:
+ try:
+ asRetCb = fnCallback(oType, oXcpt);
+ if asRetCb:
+ return asRetCb;
+ #asRet += asRetCb;
+ except:
+ g_oReporter.log(0, '** internal-error: Hit exception #2 in __g_fnComXcptFormatter! %s'
+ % (traceback.format_exc()), sCaller, sTsPrf);
+ asRet += ['internal error: exception in __g_fnComXcptFormatter'];
+
+ # Now try format_exception_only:
+ try:
+ asRet += traceback.format_exception_only(oType, oXcpt);
+ except:
+ g_oReporter.log(0, '** internal-error: Hit exception #2 in format_exception_only! %s'
+ % (traceback.format_exc()), sCaller, sTsPrf);
+ asRet += ['internal error: Exception in format_exception_only!'];
+ return asRet;
+
+
+def logXcptWorker(iLevel, fIncErrors, sPrefix="", sText=None, cFrames=1):
+ """
+ Log an exception, optionally with a preceeding message and more than one
+ call frame.
+ """
+ g_oLock.acquire();
+ try:
+
+ if fIncErrors:
+ g_oReporter.testIncErrors();
+
+ ## @todo skip all this if iLevel is too high!
+
+ # Try get exception info.
+ sTsPrf = utils.getTimePrefix();
+ try:
+ oType, oValue, oTraceback = sys.exc_info();
+ except:
+ oType = oValue = oTraceback = None;
+ if oType is not None:
+
+ # Try format the info
+ try:
+ rc = 0;
+ sCaller = utils.getCallerName(oTraceback.tb_frame);
+ if sText is not None:
+ rc = g_oReporter.log(iLevel, "%s%s" % (sPrefix, sText), sCaller, sTsPrf);
+ asInfo = None;
+ try:
+ asInfo = formatExceptionOnly(oType, oValue, sCaller, sTsPrf);
+ atEntries = traceback.extract_tb(oTraceback);
+ atEntries.reverse();
+ if cFrames is not None and cFrames <= 1:
+ if atEntries:
+ asInfo = asInfo + traceback.format_list(atEntries[:1]);
+ else:
+ asInfo.append('Traceback (stack order):')
+ if cFrames is not None and cFrames < len(atEntries):
+ asInfo = asInfo + traceback.format_list(atEntries[:cFrames]);
+ else:
+ asInfo = asInfo + traceback.format_list(atEntries);
+ asInfo.append('Stack:')
+ asInfo = asInfo + traceback.format_stack(oTraceback.tb_frame.f_back, cFrames);
+ except:
+ g_oReporter.log(0, '** internal-error: Hit exception #2! %s' % (traceback.format_exc()), sCaller, sTsPrf);
+
+ if asInfo:
+ # Do the logging.
+ for sItem in asInfo:
+ asLines = sItem.splitlines();
+ for sLine in asLines:
+ rc = g_oReporter.log(iLevel, '%s%s' % (sPrefix, sLine), sCaller, sTsPrf);
+
+ else:
+ g_oReporter.log(iLevel, 'No exception info...', sCaller, sTsPrf);
+ rc = -3;
+ except:
+ g_oReporter.log(0, '** internal-error: Hit exception! %s' % (traceback.format_exc()), None, sTsPrf);
+ rc = -2;
+ else:
+ g_oReporter.log(0, '** internal-error: No exception! %s'
+ % (utils.getCallerName(iFrame=3)), utils.getCallerName(iFrame=3), sTsPrf);
+ rc = -1;
+
+ finally:
+ g_oLock.release();
+ return rc;
+
+
+#
+# The public Classes
+#
+class FileWrapper(object):
+ """ File like class for TXS EXEC and similar. """
+ def __init__(self, sPrefix):
+ self.sPrefix = sPrefix;
+
+ def __del__(self):
+ self.close();
+
+ def close(self):
+ """ file.close """
+ # Nothing to be done.
+ return;
+
+ def read(self, cb):
+ """file.read"""
+ _ = cb;
+ return "";
+
+ def write(self, sText):
+ """file.write"""
+ if not utils.isString(sText):
+ if isinstance(sText, array.array):
+ try:
+ if sys.version_info < (3, 9, 0):
+ # Removed since Python 3.9.
+ sText = sText.tostring(); # pylint: disable=no-member
+ else:
+ sText = sText.tobytes();
+ except:
+ pass;
+ if hasattr(sText, 'decode'):
+ try:
+ sText = sText.decode('utf-8', 'ignore');
+ except:
+ pass;
+ g_oLock.acquire();
+ try:
+ sTsPrf = utils.getTimePrefix();
+ sCaller = utils.getCallerName();
+ asLines = sText.splitlines();
+ for sLine in asLines:
+ g_oReporter.log(0, '%s: %s' % (self.sPrefix, sLine), sCaller, sTsPrf);
+ except:
+ traceback.print_exc();
+ finally:
+ g_oLock.release();
+ return None;
+
+class FileWrapperTestPipe(object):
+ """
+ File like class for the test pipe (TXS EXEC and similar).
+
+ This is also used to submit XML test result files.
+ """
+ def __init__(self):
+ self.sPrefix = '';
+ self.fStarted = False;
+ self.fClosed = False;
+ self.sTagBuffer = None;
+ self.cTestDepth = 0;
+ self.acTestErrors = [];
+
+ def __del__(self):
+ self.close();
+
+ def close(self):
+ """ file.close """
+ if self.fStarted is True and self.fClosed is False:
+ self.fClosed = True;
+
+ # Close open <Test> elements:
+ if self.cTestDepth > 0:
+ sNow = utils.getIsoTimestamp()
+ cErrors = 0;
+ while self.cTestDepth > 0:
+ self.cTestDepth -= 1;
+ if self.acTestErrors:
+ cErrors += self.acTestErrors.pop();
+ cErrors += 1;
+ g_oReporter.subXmlWrite(self,
+ '\n%s <Failed timestamp="%s" errors="%s"/>\n%s</Test>\n'
+ % (' ' * self.cTestDepth, sNow, cErrors, ' ' * self.cTestDepth),
+ utils.getCallerName());
+
+ # Tell the reporter that the XML input is done.
+ try: g_oReporter.subXmlEnd(self);
+ except:
+ try: traceback.print_exc();
+ except: pass;
+ return True;
+
+ def read(self, cb = None):
+ """file.read"""
+ _ = cb;
+ return "";
+
+ def write(self, sText):
+ """file.write"""
+ # lazy start.
+ if self.fStarted is not True:
+ try:
+ g_oReporter.subXmlStart(self);
+ except:
+ traceback.print_exc();
+ self.fStarted = True;
+
+ # Turn non-string stuff into strings.
+ if not utils.isString(sText):
+ if isinstance(sText, array.array):
+ try:
+ if sys.version_info < (3, 9, 0):
+ # Removed since Python 3.9.
+ sText = sText.tostring(); # pylint: disable=no-member
+ else:
+ sText = sText.tobytes();
+ except:
+ pass;
+ if hasattr(sText, 'decode'):
+ try: sText = sText.decode('utf-8', 'ignore');
+ except: pass;
+
+ try:
+ #
+ # Write the XML to the reporter.
+ #
+ g_oReporter.subXmlWrite(self, sText, utils.getCallerName());
+
+ #
+ # Parse the supplied text and look for <Failed.../> tags to keep track of the
+ # error counter. This is only a very lazy aproach.
+ #
+ idxText = 0;
+ while sText:
+ if self.sTagBuffer is None:
+ # Look for the start of a tag.
+ idxStart = sText.find('<', idxText);
+ if idxStart != -1:
+ # If the end was found inside the current buffer, parse the line,
+ # otherwise we have to save it for later.
+ idxEnd = sText.find('>', idxStart);
+ if idxEnd != -1:
+ self._processXmlElement(sText[idxStart:idxEnd+1]);
+ idxText = idxEnd;
+ else:
+ self.sTagBuffer = sText[idxStart:];
+ break;
+ else:
+ break;
+ else:
+ # Search for the end of the tag and parse the whole tag.
+ assert(idxText == 0);
+ idxEnd = sText.find('>');
+ if idxEnd != -1:
+ self._processXmlElement(self.sTagBuffer + sText[:idxEnd+1]);
+ self.sTagBuffer = None;
+ idxText = idxEnd;
+ else:
+ self.sTagBuffer = self.sTagBuffer + sText[idxText:];
+ break;
+ except:
+ traceback.print_exc();
+ return None;
+
+ def _processXmlElement(self, sElement):
+ """
+ Processes a complete XML tag.
+
+ We handle the 'Failed' tag to keep track of the error counter.
+ We also track 'Test' tags to make sure we close with all of them properly closed.
+ """
+ # Make sure we don't parse any space between < and the element name.
+ sElement = sElement.strip();
+
+ # Find the end of the name
+ idxEndName = sElement.find(' ');
+ if idxEndName == -1:
+ idxEndName = sElement.find('>');
+ if idxEndName >= 0:
+ if sElement[idxEndName - 1] == '/':
+ idxEndName -= 1;
+ else:
+ idxEndName = len(sElement);
+ sElementName = sElement[1:idxEndName];
+
+ # <Failed>:
+ if sElementName == 'Failed':
+ g_oLock.acquire();
+ try:
+ g_oReporter.testIncErrors();
+ finally:
+ g_oLock.release();
+ if self.acTestErrors:
+ self.acTestErrors[-1] += 1; # get errors attrib
+ # <Test>
+ elif sElementName == 'Test':
+ self.cTestDepth += 1;
+ self.acTestErrors.append(0);
+ # </Test>
+ elif sElementName == '/Test':
+ self.cTestDepth -= 1;
+ if self.acTestErrors:
+ cErrors = self.acTestErrors.pop();
+ if self.acTestErrors:
+ self.acTestErrors[-1] += cErrors;
+
+
+#
+# The public APIs.
+#
+
+def log(sText, sCaller = None):
+ """Writes the specfied text to the log."""
+ g_oLock.acquire();
+ try:
+ rc = g_oReporter.log(1, sText, sCaller if sCaller else utils.getCallerName(), utils.getTimePrefix());
+ except:
+ rc = -1;
+ finally:
+ g_oLock.release();
+ return rc;
+
+def logXcpt(sText=None, cFrames=1):
+ """
+ Log an exception, optionally with a preceeding message and more than one
+ call frame.
+ """
+ return logXcptWorker(1, False, "", sText, cFrames);
+
+def log2(sText, sCaller = None):
+ """Log level 2: Writes the specfied text to the log."""
+ g_oLock.acquire();
+ try:
+ rc = g_oReporter.log(2, sText, sCaller if sCaller else utils.getCallerName(), utils.getTimePrefix());
+ except:
+ rc = -1;
+ finally:
+ g_oLock.release();
+ return rc;
+
+def log2Xcpt(sText=None, cFrames=1):
+ """
+ Log level 2: Log an exception, optionally with a preceeding message and
+ more than one call frame.
+ """
+ return logXcptWorker(2, False, "", sText, cFrames);
+
+def log3(sText, sCaller = None):
+ """Log level 3: Writes the specfied text to the log."""
+ g_oLock.acquire();
+ try:
+ rc = g_oReporter.log(3, sText, sCaller if sCaller else utils.getCallerName(), utils.getTimePrefix());
+ except:
+ rc = -1;
+ finally:
+ g_oLock.release();
+ return rc;
+
+def log3Xcpt(sText=None, cFrames=1):
+ """
+ Log level 3: Log an exception, optionally with a preceeding message and
+ more than one call frame.
+ """
+ return logXcptWorker(3, False, "", sText, cFrames);
+
+def log4(sText, sCaller = None):
+ """Log level 4: Writes the specfied text to the log."""
+ g_oLock.acquire();
+ try:
+ rc = g_oReporter.log(4, sText, sCaller if sCaller else utils.getCallerName(), utils.getTimePrefix());
+ except:
+ rc = -1;
+ finally:
+ g_oLock.release();
+ return rc;
+
+def log4Xcpt(sText=None, cFrames=1):
+ """
+ Log level 4: Log an exception, optionally with a preceeding message and
+ more than one call frame.
+ """
+ return logXcptWorker(4, False, "", sText, cFrames);
+
+def log5(sText, sCaller = None):
+ """Log level 2: Writes the specfied text to the log."""
+ g_oLock.acquire();
+ try:
+ rc = g_oReporter.log(5, sText, sCaller if sCaller else utils.getCallerName(), utils.getTimePrefix());
+ except:
+ rc = -1;
+ finally:
+ g_oLock.release();
+ return rc;
+
+def log5Xcpt(sText=None, cFrames=1):
+ """
+ Log level 5: Log an exception, optionally with a preceeding message and
+ more than one call frame.
+ """
+ return logXcptWorker(5, False, "", sText, cFrames);
+
+def log6(sText, sCaller = None):
+ """Log level 6: Writes the specfied text to the log."""
+ g_oLock.acquire();
+ try:
+ rc = g_oReporter.log(6, sText, sCaller if sCaller else utils.getCallerName(), utils.getTimePrefix());
+ except:
+ rc = -1;
+ finally:
+ g_oLock.release();
+ return rc;
+
+def log6Xcpt(sText=None, cFrames=1):
+ """
+ Log level 6: Log an exception, optionally with a preceeding message and
+ more than one call frame.
+ """
+ return logXcptWorker(6, False, "", sText, cFrames);
+
+def maybeErr(fIsError, sText):
+ """ Maybe error or maybe normal log entry. """
+ if fIsError is True:
+ return error(sText, sCaller = utils.getCallerName());
+ return log(sText, sCaller = utils.getCallerName());
+
+def maybeErrXcpt(fIsError, sText=None, cFrames=1):
+ """ Maybe error or maybe normal log exception entry. """
+ if fIsError is True:
+ return errorXcpt(sText, cFrames);
+ return logXcpt(sText, cFrames);
+
+def maybeLog(fIsNotError, sText):
+ """ Maybe error or maybe normal log entry. """
+ if fIsNotError is not True:
+ return error(sText, sCaller = utils.getCallerName());
+ return log(sText, sCaller = utils.getCallerName());
+
+def maybeLogXcpt(fIsNotError, sText=None, cFrames=1):
+ """ Maybe error or maybe normal log exception entry. """
+ if fIsNotError is not True:
+ return errorXcpt(sText, cFrames);
+ return logXcpt(sText, cFrames);
+
+def error(sText, sCaller = None):
+ """
+ Writes the specfied error message to the log.
+
+ This will add an error to the current test.
+
+ Always returns False for the convenience of methods returning boolean
+ success indicators.
+ """
+ g_oLock.acquire();
+ try:
+ g_oReporter.testIncErrors();
+ g_oReporter.log(0, '** error: %s' % (sText), sCaller if sCaller else utils.getCallerName(), utils.getTimePrefix());
+ except:
+ pass;
+ finally:
+ g_oLock.release();
+ return False;
+
+def errorXcpt(sText=None, cFrames=1):
+ """
+ Log an error caused by an exception. If sText is given, it will preceed
+ the exception information. cFrames can be used to display more stack.
+
+ This will add an error to the current test.
+
+ Always returns False for the convenience of methods returning boolean
+ success indicators.
+ """
+ logXcptWorker(0, True, '** error: ', sText, cFrames);
+ return False;
+
+def errorTimeout(sText):
+ """
+ Flags the current test as having timed out and writes the specified message to the log.
+
+ This will add an error to the current test.
+
+ Always returns False for the convenience of methods returning boolean
+ success indicators.
+ """
+ g_oLock.acquire();
+ try:
+ g_oReporter.testSetTimedOut();
+ g_oReporter.log(0, '** timeout-error: %s' % (sText), utils.getCallerName(), utils.getTimePrefix());
+ except:
+ pass;
+ finally:
+ g_oLock.release();
+ return False;
+
+def fatal(sText):
+ """
+ Writes a fatal error to the log.
+
+ This will add an error to the current test.
+
+ Always returns False for the convenience of methods returning boolean
+ success indicators.
+ """
+ g_oLock.acquire();
+ try:
+ g_oReporter.testIncErrors();
+ g_oReporter.log(0, '** fatal error: %s' % (sText), utils.getCallerName(), utils.getTimePrefix());
+ except:
+ pass
+ finally:
+ g_oLock.release();
+ return False;
+
+def fatalXcpt(sText=None, cFrames=1):
+ """
+ Log a fatal error caused by an exception. If sText is given, it will
+ preceed the exception information. cFrames can be used to display more
+ stack.
+
+ This will add an error to the current test.
+
+ Always returns False for the convenience of methods returning boolean
+ success indicators.
+ """
+ logXcptWorker(0, True, "** fatal error: ", sText, cFrames);
+ return False;
+
+def addLogFile(sFilename, sKind, sDescription = '', sAltName = None):
+ """
+ Adds the specified log file to the report if the file exists.
+
+ The sDescription is a free form description of the log file.
+
+ The sKind parameter is for adding some machine parsable hint what kind of
+ log file this really is.
+
+ Returns True on success, False on failure (no ENOENT errors are logged).
+ """
+ sTsPrf = utils.getTimePrefix();
+ sCaller = utils.getCallerName();
+ fRc = False;
+ if sAltName is None:
+ sAltName = sFilename;
+
+ try:
+ oSrcFile = utils.openNoInherit(sFilename, 'rb');
+ except IOError as oXcpt:
+ if oXcpt.errno != errno.ENOENT:
+ logXcpt('addLogFile(%s,%s,%s)' % (sFilename, sDescription, sKind));
+ else:
+ logXcpt('addLogFile(%s,%s,%s) IOError' % (sFilename, sDescription, sKind));
+ except:
+ logXcpt('addLogFile(%s,%s,%s)' % (sFilename, sDescription, sKind));
+ else:
+ g_oLock.acquire();
+ try:
+ fRc = g_oReporter.addLogFile(oSrcFile, sFilename, sAltName, sDescription, sKind, sCaller, sTsPrf);
+ finally:
+ g_oLock.release();
+ oSrcFile.close();
+ return fRc;
+
+def addLogString(sLog, sLogName, sKind, sDescription = ''):
+ """
+ Adds the specified log string to the report.
+
+ The sLog parameter sets the name of the log file.
+
+ The sDescription is a free form description of the log file.
+
+ The sKind parameter is for adding some machine parsable hint what kind of
+ log file this really is.
+
+ Returns True on success, False on failure (no ENOENT errors are logged).
+ """
+ sTsPrf = utils.getTimePrefix();
+ sCaller = utils.getCallerName();
+ fRc = False;
+
+ g_oLock.acquire();
+ try:
+ fRc = g_oReporter.addLogString(sLog, sLogName, sDescription, sKind, sCaller, sTsPrf);
+ finally:
+ g_oLock.release();
+ return fRc;
+
+def isLocal():
+ """Is this a local reporter?"""
+ return g_oReporter.isLocal()
+
+def incVerbosity():
+ """Increases the verbosity level."""
+ return g_oReporter.incVerbosity()
+
+def incDebug():
+ """Increases the debug level."""
+ return g_oReporter.incDebug()
+
+def getVerbosity():
+ """Returns the current verbosity level."""
+ return g_oReporter.getVerbosity()
+
+def getDebug():
+ """Returns the current debug level."""
+ return g_oReporter.getDebug()
+
+def appendToProcessName(sAppend):
+ """
+ Appends sAppend to the base process name.
+ Returns the new process name.
+ """
+ return g_oReporter.appendToProcessName(sAppend);
+
+def getErrorCount():
+ """
+ Get the current error count for the entire test run.
+ """
+ g_oLock.acquire();
+ try:
+ cErrors = g_oReporter.cErrors;
+ finally:
+ g_oLock.release();
+ return cErrors;
+
+def doPollWork(sDebug = None):
+ """
+ This can be called from wait loops and similar to make the reporter call
+ home with pending XML and such.
+ """
+ g_oReporter.doPollWork(sDebug);
+ return None;
+
+
+#
+# Test reporting, a bit similar to RTTestI*.
+#
+
+def testStart(sName):
+ """
+ Starts a new test (pushes it).
+ """
+ g_oLock.acquire();
+ try:
+ rc = g_oReporter.testStart(sName, utils.getCallerName());
+ finally:
+ g_oLock.release();
+ return rc;
+
+def testValue(sName, sValue, sUnit):
+ """
+ Reports a benchmark value or something simiarlly useful.
+ """
+ g_oLock.acquire();
+ try:
+ rc = g_oReporter.testValue(sName, str(sValue), sUnit, utils.getCallerName());
+ finally:
+ g_oLock.release();
+ return rc;
+
+def testFailure(sDetails):
+ """
+ Reports a failure.
+ We count these calls and testDone will use them to report PASSED or FAILED.
+
+ Returns False so that a return False line can be saved.
+ """
+ g_oLock.acquire();
+ try:
+ g_oReporter.testFailure(sDetails, utils.getCallerName());
+ finally:
+ g_oLock.release();
+ return False;
+
+def testFailureXcpt(sDetails = ''):
+ """
+ Reports a failure with exception.
+ We count these calls and testDone will use them to report PASSED or FAILED.
+
+ Returns False so that a return False line can be saved.
+ """
+ # Extract exception info.
+ try:
+ oType, oValue, oTraceback = sys.exc_info();
+ except:
+ oType = oValue, oTraceback = None;
+ if oType is not None:
+ sCaller = utils.getCallerName(oTraceback.tb_frame);
+ sXcpt = ' '.join(formatExceptionOnly(oType, oValue, sCaller, utils.getTimePrefix()));
+ else:
+ sCaller = utils.getCallerName();
+ sXcpt = 'No exception at %s' % (sCaller,);
+
+ # Use testFailure to do the work.
+ g_oLock.acquire();
+ try:
+ if sDetails == '':
+ g_oReporter.testFailure('Exception: %s' % (sXcpt,), sCaller);
+ else:
+ g_oReporter.testFailure('%s: %s' % (sDetails, sXcpt), sCaller);
+ finally:
+ g_oLock.release();
+ return False;
+
+def testDone(fSkipped = False):
+ """
+ Completes the current test (pops it), logging PASSED / FAILURE.
+
+ Returns a tuple with the name of the test and its error count.
+ """
+ g_oLock.acquire();
+ try:
+ rc = g_oReporter.testDone(fSkipped, utils.getCallerName());
+ finally:
+ g_oLock.release();
+ return rc;
+
+def testErrorCount():
+ """
+ Gets the error count of the current test.
+
+ Returns the number of errors.
+ """
+ g_oLock.acquire();
+ try:
+ cErrors = g_oReporter.testErrorCount();
+ finally:
+ g_oLock.release();
+ return cErrors;
+
+def testCleanup():
+ """
+ Closes all open tests with a generic error condition.
+
+ Returns True if no open tests, False if something had to be closed with failure.
+ """
+ g_oLock.acquire();
+ try:
+ fRc = g_oReporter.testCleanup(utils.getCallerName());
+ g_oReporter.xmlFlush(fRetry = False, fForce = True);
+ finally:
+ g_oLock.release();
+ fRc = False;
+ return fRc;
+
+
+#
+# Sub XML stuff.
+#
+
+def addSubXmlFile(sFilename):
+ """
+ Adds a sub-xml result file to the party.
+ """
+ fRc = False;
+ try:
+ oSrcFile = utils.openNoInherit(sFilename, 'r');
+ except IOError as oXcpt:
+ if oXcpt.errno != errno.ENOENT:
+ logXcpt('addSubXmlFile(%s)' % (sFilename,));
+ except:
+ logXcpt('addSubXmlFile(%s)' % (sFilename,));
+ else:
+ try:
+ oWrapper = FileWrapperTestPipe()
+ oWrapper.write(oSrcFile.read());
+ oWrapper.close();
+ except:
+ logXcpt('addSubXmlFile(%s)' % (sFilename,));
+ oSrcFile.close();
+
+ return fRc;
+
+
+#
+# Other useful debugging tools.
+#
+
+def logAllStacks(cFrames = None):
+ """
+ Logs the stacks of all python threads.
+ """
+ sTsPrf = utils.getTimePrefix();
+ sCaller = utils.getCallerName();
+ g_oLock.acquire();
+
+ cThread = 0;
+ for idThread, oStack in sys._current_frames().items(): # >=2.5, a bit ugly - pylint: disable=protected-access
+ try:
+ if cThread > 0:
+ g_oReporter.log(1, '', sCaller, sTsPrf);
+ g_oReporter.log(1, 'Thread %s (%#x)' % (idThread, idThread), sCaller, sTsPrf);
+ try:
+ asInfo = traceback.format_stack(oStack, cFrames);
+ except:
+ g_oReporter.log(1, ' Stack formatting failed w/ exception', sCaller, sTsPrf);
+ else:
+ for sInfo in asInfo:
+ asLines = sInfo.splitlines();
+ for sLine in asLines:
+ g_oReporter.log(1, sLine, sCaller, sTsPrf);
+ except:
+ pass;
+ cThread += 1;
+
+ g_oLock.release();
+ return None;
+
+def checkTestManagerConnection():
+ """
+ Checks the connection to the test manager.
+
+ Returns True if the connection is fine, False if not, None if not remote
+ reporter.
+
+ Note! This as the sideeffect of flushing XML.
+ """
+ g_oLock.acquire();
+ try:
+ fRc = g_oReporter.xmlFlush(fRetry = False, fForce = True);
+ finally:
+ g_oLock.release();
+ fRc = False;
+ return fRc;
+
+def flushall(fSkipXml = False):
+ """
+ Flushes all output streams, both standard and logger related.
+ This may also push data to the remote test manager.
+ """
+ try: sys.stdout.flush();
+ except: pass;
+ try: sys.stderr.flush();
+ except: pass;
+
+ if fSkipXml is not True:
+ g_oLock.acquire();
+ try:
+ g_oReporter.xmlFlush(fRetry = False);
+ finally:
+ g_oLock.release();
+
+ return True;
+
+
+#
+# Module initialization.
+#
+
+def _InitReporterModule():
+ """
+ Instantiate the test reporter.
+ """
+ global g_oReporter, g_sReporterName
+
+ g_sReporterName = os.getenv("TESTBOX_REPORTER", "local");
+ if g_sReporterName == "local":
+ g_oReporter = LocalReporter();
+ elif g_sReporterName == "remote":
+ g_oReporter = RemoteReporter(); # Correct, but still plain stupid. pylint: disable=redefined-variable-type
+ else:
+ print(os.path.basename(__file__) + ": Unknown TESTBOX_REPORTER value: '" + g_sReporterName + "'", file = sys.stderr);
+ raise Exception("Unknown TESTBOX_REPORTER value '" + g_sReporterName + "'");
+
+if __name__ != "checker": # pychecker avoidance.
+ _InitReporterModule();
diff --git a/src/VBox/ValidationKit/testdriver/testfileset.py b/src/VBox/ValidationKit/testdriver/testfileset.py
new file mode 100755
index 00000000..33ea8c72
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/testfileset.py
@@ -0,0 +1,690 @@
+# -*- coding: utf-8 -*-
+# $Id: testfileset.py $
+# pylint: disable=too-many-lines
+
+"""
+Test File Set
+"""
+
+__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 os;
+import random;
+import string;
+import sys;
+import tarfile;
+import unittest;
+
+# Validation Kit imports.
+from common import utils;
+from common import pathutils;
+from testdriver import reporter;
+
+# Python 3 hacks:
+if sys.version_info[0] >= 3:
+ xrange = range; # pylint: disable=redefined-builtin,invalid-name
+
+
+
+class TestFsObj(object):
+ """ A file system object we created in for test purposes. """
+ def __init__(self, oParent, sPath, sName = None):
+ self.oParent = oParent # type: TestDir
+ self.sPath = sPath # type: str
+ self.sName = sName # type: str
+ if oParent:
+ assert sPath.startswith(oParent.sPath);
+ assert sName is None;
+ self.sName = sPath[len(oParent.sPath) + 1:];
+ # Add to parent.
+ oParent.aoChildren.append(self);
+ oParent.dChildrenUpper[self.sName.upper()] = self;
+
+ def buildPath(self, sRoot, sSep):
+ """
+ Build the path from sRoot using sSep.
+
+ This is handy for getting the path to an object in a different context
+ (OS, path) than what it was generated for.
+ """
+ if self.oParent:
+ return self.oParent.buildPath(sRoot, sSep) + sSep + self.sName;
+ return sRoot + sSep + self.sName;
+
+
+class TestFile(TestFsObj):
+ """ A file object in the guest. """
+ def __init__(self, oParent, sPath, abContent):
+ TestFsObj.__init__(self, oParent, sPath);
+ self.abContent = abContent # type: bytearray
+ self.cbContent = len(abContent);
+ self.off = 0;
+
+ def read(self, cbToRead):
+ """ read() emulation. """
+ assert self.off <= self.cbContent;
+ cbLeft = self.cbContent - self.off;
+ if cbLeft < cbToRead:
+ cbToRead = cbLeft;
+ abRet = self.abContent[self.off:(self.off + cbToRead)];
+ assert len(abRet) == cbToRead;
+ self.off += cbToRead;
+ if sys.version_info[0] < 3:
+ return bytes(abRet);
+ return abRet;
+
+ def equalFile(self, oFile):
+ """ Compares the content of oFile with self.abContent. """
+
+ # Check the size first.
+ try:
+ cbFile = os.fstat(oFile.fileno()).st_size;
+ except:
+ return reporter.errorXcpt();
+ if cbFile != self.cbContent:
+ return reporter.error('file size differs: %s, cbContent=%s' % (cbFile, self.cbContent));
+
+ # Compare the bytes next.
+ offFile = 0;
+ try:
+ oFile.seek(offFile);
+ except:
+ return reporter.error('seek error');
+ while offFile < self.cbContent:
+ cbToRead = self.cbContent - offFile;
+ if cbToRead > 256*1024:
+ cbToRead = 256*1024;
+ try:
+ abRead = oFile.read(cbToRead);
+ except:
+ return reporter.error('read error at offset %s' % (offFile,));
+ cbRead = len(abRead);
+ if cbRead == 0:
+ return reporter.error('premature end of file at offset %s' % (offFile,));
+ if not utils.areBytesEqual(abRead, self.abContent[offFile:(offFile + cbRead)]):
+ return reporter.error('%s byte block at offset %s differs' % (cbRead, offFile,));
+ # Advance:
+ offFile += cbRead;
+
+ return True;
+
+ @staticmethod
+ def hexFormatBytes(abBuf):
+ """ Formats a buffer/string/whatever as a string of hex bytes """
+ if sys.version_info[0] >= 3:
+ if utils.isString(abBuf):
+ try: abBuf = bytes(abBuf, 'utf-8');
+ except: pass;
+ else:
+ if utils.isString(abBuf):
+ try: abBuf = bytearray(abBuf, 'utf-8'); # pylint: disable=redefined-variable-type
+ except: pass;
+ sRet = '';
+ off = 0;
+ for off, bByte in enumerate(abBuf):
+ if off > 0:
+ sRet += ' ' if off & 7 else '-';
+ if isinstance(bByte, int):
+ sRet += '%02x' % (bByte,);
+ else:
+ sRet += '%02x' % (ord(bByte),);
+ return sRet;
+
+ def checkRange(self, cbRange, offFile = 0):
+ """ Check if the specified range is entirely within the file or not. """
+ if offFile >= self.cbContent:
+ return reporter.error('buffer @ %s LB %s is beyond the end of the file (%s bytes)!'
+ % (offFile, cbRange, self.cbContent,));
+ if offFile + cbRange > self.cbContent:
+ return reporter.error('buffer @ %s LB %s is partially beyond the end of the file (%s bytes)!'
+ % (offFile, cbRange, self.cbContent,));
+ return True;
+
+ def equalMemory(self, abBuf, offFile = 0):
+ """
+ Compares the content of the given buffer with the file content at that
+ file offset.
+
+ Returns True if it matches, False + error logging if it does not match.
+ """
+ if not abBuf:
+ return True;
+
+ if not self.checkRange(len(abBuf), offFile):
+ return False;
+
+ if sys.version_info[0] >= 3:
+ if utils.areBytesEqual(abBuf, self.abContent[offFile:(offFile + len(abBuf))]):
+ return True;
+ else:
+ if utils.areBytesEqual(abBuf, buffer(self.abContent, offFile, len(abBuf))): # pylint: disable=undefined-variable
+ return True;
+
+ reporter.error('mismatch with buffer @ %s LB %s (cbContent=%s)!' % (offFile, len(abBuf), self.cbContent,));
+ reporter.error(' type(abBuf): %s' % (type(abBuf),));
+ #if isinstance(abBuf, memoryview):
+ # reporter.error(' nbytes=%s len=%s itemsize=%s type(obj)=%s'
+ # % (abBuf.nbytes, len(abBuf), abBuf.itemsize, type(abBuf.obj),));
+ reporter.error('type(abContent): %s' % (type(self.abContent),));
+
+ offBuf = 0;
+ cbLeft = len(abBuf);
+ while cbLeft > 0:
+ cbLine = min(16, cbLeft);
+ abBuf1 = abBuf[offBuf:(offBuf + cbLine)];
+ abBuf2 = self.abContent[offFile:(offFile + cbLine)];
+ if not utils.areBytesEqual(abBuf1, abBuf2):
+ try: sStr1 = self.hexFormatBytes(abBuf1);
+ except: sStr1 = 'oops';
+ try: sStr2 = self.hexFormatBytes(abBuf2);
+ except: sStr2 = 'oops';
+ reporter.log('%#10x: %s' % (offBuf, sStr1,));
+ reporter.log('%#10x: %s' % (offFile, sStr2,));
+
+ # Advance.
+ offBuf += 16;
+ offFile += 16;
+ cbLeft -= 16;
+
+ return False;
+
+
+class TestFileZeroFilled(TestFile):
+ """
+ Zero filled test file.
+ """
+
+ def __init__(self, oParent, sPath, cbContent):
+ TestFile.__init__(self, oParent, sPath, bytearray(1));
+ self.cbContent = cbContent;
+
+ def read(self, cbToRead):
+ """ read() emulation. """
+ assert self.off <= self.cbContent;
+ cbLeft = self.cbContent - self.off;
+ if cbLeft < cbToRead:
+ cbToRead = cbLeft;
+ abRet = bytearray(cbToRead);
+ assert len(abRet) == cbToRead;
+ self.off += cbToRead;
+ if sys.version_info[0] < 3:
+ return bytes(abRet);
+ return abRet;
+
+ def equalFile(self, oFile):
+ _ = oFile;
+ assert False, "not implemented";
+ return False;
+
+ def equalMemory(self, abBuf, offFile = 0):
+ if not abBuf:
+ return True;
+
+ if not self.checkRange(len(abBuf), offFile):
+ return False;
+
+ if utils.areBytesEqual(abBuf, bytearray(len(abBuf))):
+ return True;
+
+ cErrors = 0;
+ offBuf = 0
+ while offBuf < len(abBuf):
+ bByte = abBuf[offBuf];
+ if not isinstance(bByte, int):
+ bByte = ord(bByte);
+ if bByte != 0:
+ reporter.error('Mismatch @ %s/%s: %#x, expected 0!' % (offFile, offBuf, bByte,));
+ cErrors += 1;
+ if cErrors > 32:
+ return False;
+ offBuf += 1;
+ return cErrors == 0;
+
+
+class TestDir(TestFsObj):
+ """ A file object in the guest. """
+ def __init__(self, oParent, sPath, sName = None):
+ TestFsObj.__init__(self, oParent, sPath, sName);
+ self.aoChildren = [] # type: list(TestFsObj)
+ self.dChildrenUpper = {} # type: dict(str, TestFsObj)
+
+ def contains(self, sName):
+ """ Checks if the directory contains the given name. """
+ return sName.upper() in self.dChildrenUpper
+
+
+class TestFileSet(object):
+ """
+ A generated set of files and directories for use in a test.
+
+ Can be wrapped up into a tarball or written directly to the file system.
+ """
+
+ ksReservedWinOS2 = '/\\"*:<>?|\t\v\n\r\f\a\b';
+ ksReservedUnix = '/';
+ ksReservedTrailingWinOS2 = ' .';
+ ksReservedTrailingUnix = '';
+
+ ## @name Path style.
+ ## @{
+
+ ## @}
+
+ def __init__(self, fDosStyle, sBasePath, sSubDir, # pylint: disable=too-many-arguments
+ asCompatibleWith = None, # List of getHostOs values to the names must be compatible with.
+ oRngFileSizes = xrange(0, 16384),
+ oRngManyFiles = xrange(128, 512),
+ oRngTreeFiles = xrange(128, 384),
+ oRngTreeDepth = xrange(92, 256),
+ oRngTreeDirs = xrange(2, 16),
+ cchMaxPath = 230,
+ cchMaxName = 230,
+ uSeed = None):
+ ## @name Parameters
+ ## @{
+ self.fDosStyle = fDosStyle;
+ self.sMinStyle = 'win' if fDosStyle else 'linux';
+ if asCompatibleWith is not None:
+ for sOs in asCompatibleWith:
+ assert sOs in ('win', 'os2', 'darwin', 'linux', 'solaris', 'cross'), sOs;
+ if 'os2' in asCompatibleWith:
+ self.sMinStyle = 'os2';
+ elif 'win' in asCompatibleWith:
+ self.sMinStyle = 'win';
+ # 'cross' marks a lowest common denominator for all supported platforms.
+ # Used for Guest Control testing.
+ elif 'cross' in asCompatibleWith:
+ self.sMinStyle = 'cross';
+ self.sBasePath = sBasePath;
+ self.sSubDir = sSubDir;
+ self.oRngFileSizes = oRngFileSizes;
+ self.oRngManyFiles = oRngManyFiles;
+ self.oRngTreeFiles = oRngTreeFiles;
+ self.oRngTreeDepth = oRngTreeDepth;
+ self.oRngTreeDirs = oRngTreeDirs;
+ self.cchMaxPath = cchMaxPath;
+ self.cchMaxName = cchMaxName
+ ## @}
+
+ ## @name Charset stuff
+ ## @todo allow more chars for unix hosts + guests.
+ ## @todo include unicode stuff, except on OS/2 and DOS.
+ ## @{
+ ## The filename charset.
+ self.sFileCharset = string.printable;
+ ## Set of characters that should not trail a guest filename.
+ self.sReservedTrailing = self.ksReservedTrailingWinOS2;
+ if self.sMinStyle in ('win', 'os2'):
+ for ch in self.ksReservedWinOS2:
+ self.sFileCharset = self.sFileCharset.replace(ch, '');
+ elif self.sMinStyle in ('darwin', 'linux', 'solaris'):
+ self.sReservedTrailing = self.ksReservedTrailingUnix;
+ for ch in self.ksReservedUnix:
+ self.sFileCharset = self.sFileCharset.replace(ch, '');
+ else: # 'cross'
+ # Filter out all reserved charsets from all platforms.
+ for ch in self.ksReservedWinOS2:
+ self.sFileCharset = self.sFileCharset.replace(ch, '');
+ for ch in self.ksReservedUnix:
+ self.sFileCharset = self.sFileCharset.replace(ch, '');
+ self.sReservedTrailing = self.ksReservedTrailingWinOS2 \
+ + self.ksReservedTrailingUnix;
+ # More spaces and dot:
+ self.sFileCharset += ' ...';
+ ## @}
+
+ ## The root directory.
+ self.oRoot = None # type: TestDir;
+ ## An empty directory (under root).
+ self.oEmptyDir = None # type: TestDir;
+
+ ## A directory with a lot of files in it.
+ self.oManyDir = None # type: TestDir;
+
+ ## A directory with a mixed tree structure under it.
+ self.oTreeDir = None # type: TestDir;
+ ## Number of files in oTreeDir.
+ self.cTreeFiles = 0;
+ ## Number of directories under oTreeDir.
+ self.cTreeDirs = 0;
+ ## Number of other file types under oTreeDir.
+ self.cTreeOthers = 0;
+
+ ## All directories in creation order.
+ self.aoDirs = [] # type: list(TestDir);
+ ## All files in creation order.
+ self.aoFiles = [] # type: list(TestFile);
+ ## Path to object lookup.
+ self.dPaths = {} # type: dict(str, TestFsObj);
+
+ #
+ # Do the creating.
+ #
+ self.uSeed = uSeed if uSeed is not None else utils.timestampMilli();
+ self.oRandom = random.Random();
+ self.oRandom.seed(self.uSeed);
+ reporter.log('prepareGuestForTesting: random seed %s' % (self.uSeed,));
+
+ self.__createTestStuff();
+
+ def __createFilename(self, oParent, sCharset, sReservedTrailing):
+ """
+ Creates a filename contains random characters from sCharset and together
+ with oParent.sPath doesn't exceed the given max chars in length.
+ """
+ ## @todo Consider extending this to take UTF-8 and UTF-16 encoding so we
+ ## can safely use the full unicode range. Need to check how
+ ## RTZipTarCmd handles file name encoding in general...
+
+ if oParent:
+ cchMaxName = self.cchMaxPath - len(oParent.sPath) - 1;
+ else:
+ cchMaxName = self.cchMaxPath - 4;
+ if cchMaxName > self.cchMaxName:
+ cchMaxName = self.cchMaxName;
+ if cchMaxName <= 1:
+ cchMaxName = 2;
+
+ while True:
+ cchName = self.oRandom.randrange(1, cchMaxName);
+ sName = ''.join(self.oRandom.choice(sCharset) for _ in xrange(cchName));
+ if oParent is None or not oParent.contains(sName):
+ if sName[-1] not in sReservedTrailing:
+ if sName not in ('.', '..',):
+ return sName;
+ return ''; # never reached, but makes pylint happy.
+
+ def generateFilenameEx(self, cchMax = -1, cchMin = -1):
+ """
+ Generates a filename according to the given specs.
+
+ This is for external use, whereas __createFilename is for internal.
+
+ Returns generated filename.
+ """
+ assert cchMax == -1 or (cchMax >= 1 and cchMax > cchMin);
+ if cchMin <= 0:
+ cchMin = 1;
+ if cchMax < cchMin:
+ cchMax = self.cchMaxName;
+
+ while True:
+ cchName = self.oRandom.randrange(cchMin, cchMax + 1);
+ sName = ''.join(self.oRandom.choice(self.sFileCharset) for _ in xrange(cchName));
+ if sName[-1] not in self.sReservedTrailing:
+ if sName not in ('.', '..',):
+ return sName;
+ return ''; # never reached, but makes pylint happy.
+
+ def __createTestDir(self, oParent, sDir, sName = None):
+ """
+ Creates a test directory.
+ """
+ oDir = TestDir(oParent, sDir, sName);
+ self.aoDirs.append(oDir);
+ self.dPaths[sDir] = oDir;
+ return oDir;
+
+ def __createTestFile(self, oParent, sFile):
+ """
+ Creates a test file with random size up to cbMaxContent and random content.
+ """
+ cbFile = self.oRandom.choice(self.oRngFileSizes);
+ abContent = bytearray(self.oRandom.getrandbits(8) for _ in xrange(cbFile));
+
+ oFile = TestFile(oParent, sFile, abContent);
+ self.aoFiles.append(oFile);
+ self.dPaths[sFile] = oFile;
+ return oFile;
+
+ def __createTestStuff(self):
+ """
+ Create a random file set that we can work on in the tests.
+ Returns True/False.
+ """
+
+ #
+ # Create the root test dir.
+ #
+ sRoot = pathutils.joinEx(self.fDosStyle, self.sBasePath, self.sSubDir);
+ self.oRoot = self.__createTestDir(None, sRoot, self.sSubDir);
+ self.oEmptyDir = self.__createTestDir(self.oRoot, pathutils.joinEx(self.fDosStyle, sRoot, 'empty'));
+
+ #
+ # Create a directory with lots of files in it:
+ #
+ oDir = self.__createTestDir(self.oRoot, pathutils.joinEx(self.fDosStyle, sRoot, 'many'));
+ self.oManyDir = oDir;
+ cManyFiles = self.oRandom.choice(self.oRngManyFiles);
+ for _ in xrange(cManyFiles):
+ sName = self.__createFilename(oDir, self.sFileCharset, self.sReservedTrailing);
+ self.__createTestFile(oDir, pathutils.joinEx(self.fDosStyle, oDir.sPath, sName));
+
+ #
+ # Generate a tree of files and dirs.
+ #
+ oDir = self.__createTestDir(self.oRoot, pathutils.joinEx(self.fDosStyle, sRoot, 'tree'));
+ uMaxDepth = self.oRandom.choice(self.oRngTreeDepth);
+ cMaxFiles = self.oRandom.choice(self.oRngTreeFiles);
+ cMaxDirs = self.oRandom.choice(self.oRngTreeDirs);
+ self.oTreeDir = oDir;
+ self.cTreeFiles = 0;
+ self.cTreeDirs = 0;
+ uDepth = 0;
+ while self.cTreeFiles < cMaxFiles and self.cTreeDirs < cMaxDirs:
+ iAction = self.oRandom.randrange(0, 2+1);
+ # 0: Add a file:
+ if iAction == 0 and self.cTreeFiles < cMaxFiles and len(oDir.sPath) < 230 - 2:
+ sName = self.__createFilename(oDir, self.sFileCharset, self.sReservedTrailing);
+ self.__createTestFile(oDir, pathutils.joinEx(self.fDosStyle, oDir.sPath, sName));
+ self.cTreeFiles += 1;
+ # 1: Add a subdirector and descend into it:
+ elif iAction == 1 and self.cTreeDirs < cMaxDirs and uDepth < uMaxDepth and len(oDir.sPath) < 220:
+ sName = self.__createFilename(oDir, self.sFileCharset, self.sReservedTrailing);
+ oDir = self.__createTestDir(oDir, pathutils.joinEx(self.fDosStyle, oDir.sPath, sName));
+ self.cTreeDirs += 1;
+ uDepth += 1;
+ # 2: Ascend to parent dir:
+ elif iAction == 2 and uDepth > 0:
+ oDir = oDir.oParent;
+ uDepth -= 1;
+
+ return True;
+
+ def createTarball(self, sTarFileHst):
+ """
+ Creates a tarball on the host.
+ Returns success indicator.
+ """
+ reporter.log('Creating tarball "%s" with test files for the guest...' % (sTarFileHst,));
+
+ cchSkip = len(self.sBasePath) + 1;
+
+ # Open the tarball:
+ try:
+ # Make sure to explicitly set GNU_FORMAT here, as with Python 3.8 the default format (tarfile.DEFAULT_FORMAT)
+ # has been changed to tarfile.PAX_FORMAT, which our extraction code (vts_tar) currently can't handle.
+ ## @todo Remove tarfile.GNU_FORMAT and use tarfile.PAX_FORMAT as soon as we have PAX support.
+ oTarFile = tarfile.open(sTarFileHst, 'w:gz', format = tarfile.GNU_FORMAT); # pylint: disable=consider-using-with
+ except:
+ return reporter.errorXcpt('Failed to open new tar file: %s' % (sTarFileHst,));
+
+ # Directories:
+ for oDir in self.aoDirs:
+ sPath = oDir.sPath[cchSkip:];
+ if self.fDosStyle:
+ sPath = sPath.replace('\\', '/');
+ oTarInfo = tarfile.TarInfo(sPath + '/');
+ oTarInfo.mode = 0o777;
+ oTarInfo.type = tarfile.DIRTYPE;
+ try:
+ oTarFile.addfile(oTarInfo);
+ except:
+ return reporter.errorXcpt('Failed adding directory tarfile: %s' % (oDir.sPath,));
+
+ # Files:
+ for oFile in self.aoFiles:
+ sPath = oFile.sPath[cchSkip:];
+ if self.fDosStyle:
+ sPath = sPath.replace('\\', '/');
+ oTarInfo = tarfile.TarInfo(sPath);
+ oTarInfo.mode = 0o666;
+ oTarInfo.size = len(oFile.abContent);
+ oFile.off = 0;
+ try:
+ oTarFile.addfile(oTarInfo, oFile);
+ except:
+ return reporter.errorXcpt('Failed adding directory tarfile: %s' % (oFile.sPath,));
+
+ # Complete the tarball.
+ try:
+ oTarFile.close();
+ except:
+ return reporter.errorXcpt('Error closing new tar file: %s' % (sTarFileHst,));
+ return True;
+
+ def writeToDisk(self, sAltBase = None):
+ """
+ Writes out the files to disk.
+ Returns True on success, False + error logging on failure.
+ """
+
+ # We only need to flip DOS slashes to unix ones, since windows & OS/2 can handle unix slashes.
+ fDosToUnix = self.fDosStyle and os.path.sep != '\\';
+
+ # The directories:
+ for oDir in self.aoDirs:
+ sPath = oDir.sPath;
+ if sAltBase:
+ if fDosToUnix:
+ sPath = sAltBase + sPath[len(self.sBasePath):].replace('\\', os.path.sep);
+ else:
+ sPath = sAltBase + sPath[len(self.sBasePath):];
+ elif fDosToUnix:
+ sPath = sPath.replace('\\', os.path.sep);
+
+ try:
+ os.mkdir(sPath, 0o770);
+ except:
+ return reporter.errorXcpt('mkdir(%s) failed' % (sPath,));
+
+ # The files:
+ for oFile in self.aoFiles:
+ sPath = oFile.sPath;
+ if sAltBase:
+ if fDosToUnix:
+ sPath = sAltBase + sPath[len(self.sBasePath):].replace('\\', os.path.sep);
+ else:
+ sPath = sAltBase + sPath[len(self.sBasePath):];
+ elif fDosToUnix:
+ sPath = sPath.replace('\\', os.path.sep);
+
+ try:
+ oOutFile = open(sPath, 'wb'); # pylint: disable=consider-using-with
+ except:
+ return reporter.errorXcpt('open(%s, "wb") failed' % (sPath,));
+ try:
+ if sys.version_info[0] < 3:
+ oOutFile.write(bytes(oFile.abContent));
+ else:
+ oOutFile.write(oFile.abContent);
+ except:
+ try: oOutFile.close();
+ except: pass;
+ return reporter.errorXcpt('%s: write(%s bytes) failed' % (sPath, oFile.cbContent,));
+ try:
+ oOutFile.close();
+ except:
+ return reporter.errorXcpt('%s: close() failed' % (sPath,));
+
+ return True;
+
+
+ def chooseRandomFile(self):
+ """
+ Returns a random file.
+ """
+ return self.aoFiles[self.oRandom.choice(xrange(len(self.aoFiles)))];
+
+ def chooseRandomDirFromTree(self, fLeaf = False, fNonEmpty = False, cMaxRetries = 1024):
+ """
+ Returns a random directory from the tree (self.oTreeDir).
+ Will return None if no directory with given parameters was found.
+ """
+ cRetries = 0;
+ while cRetries < cMaxRetries:
+ oDir = self.aoDirs[self.oRandom.choice(xrange(len(self.aoDirs)))];
+ # Check fNonEmpty requirement:
+ if not fNonEmpty or oDir.aoChildren:
+ # Check leaf requirement:
+ if not fLeaf:
+ for oChild in oDir.aoChildren:
+ if isinstance(oChild, TestDir):
+ continue; # skip it.
+
+ # Return if in the tree:
+ oParent = oDir.oParent;
+ while oParent is not None:
+ if oParent is self.oTreeDir:
+ return oDir;
+ oParent = oParent.oParent;
+ cRetries += 1;
+
+ return None; # make pylint happy
+
+#
+# Unit testing.
+#
+
+# pylint: disable=missing-docstring
+# pylint: disable=undefined-variable
+class TestFileSetUnitTests(unittest.TestCase):
+ def testGeneral(self):
+ oSet = TestFileSet(False, '/tmp', 'unittest');
+ self.assertTrue(isinstance(oSet.chooseRandomDirFromTree(), TestDir));
+ self.assertTrue(isinstance(oSet.chooseRandomFile(), TestFile));
+
+ def testHexFormatBytes(self):
+ self.assertEqual(TestFile.hexFormatBytes(bytearray([0,1,2,3,4,5,6,7,8,9])),
+ '00 01 02 03 04 05 06 07-08 09');
+ self.assertEqual(TestFile.hexFormatBytes(memoryview(bytearray([0,1,2,3,4,5,6,7,8,9,10, 16]))),
+ '00 01 02 03 04 05 06 07-08 09 0a 10');
+
+
+if __name__ == '__main__':
+ unittest.main();
+ # not reached.
+
diff --git a/src/VBox/ValidationKit/testdriver/tst-txsclient.py b/src/VBox/ValidationKit/testdriver/tst-txsclient.py
new file mode 100755
index 00000000..6b7353b5
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/tst-txsclient.py
@@ -0,0 +1,315 @@
+# -*- coding: utf-8 -*-
+# $Id: tst-txsclient.py $
+
+"""
+Simple testcase for txsclient.py.
+"""
+
+from __future__ import print_function;
+
+__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 os
+import sys
+
+# Validation Kit imports.
+sys.path.insert(0, '.');
+sys.path.insert(0, '..');
+from common import utils;
+from testdriver import txsclient;
+from testdriver import reporter;
+
+# Python 3 hacks:
+if sys.version_info[0] >= 3:
+ long = int; # pylint: disable=redefined-builtin,invalid-name
+
+g_cTests = 0;
+g_cFailures = 0
+
+def boolRes(rc, fExpect = True):
+ """Checks a boolean result."""
+ global g_cTests, g_cFailures;
+ g_cTests = g_cTests + 1;
+ if isinstance(rc, bool):
+ if rc == fExpect:
+ return 'PASSED';
+ g_cFailures = g_cFailures + 1;
+ return 'FAILED';
+
+def stringRes(rc, sExpect):
+ """Checks a string result."""
+ global g_cTests, g_cFailures;
+ g_cTests = g_cTests + 1;
+ if utils.isString(rc):
+ if rc == sExpect:
+ return 'PASSED';
+ g_cFailures = g_cFailures + 1;
+ return 'FAILED';
+
+def main(asArgs): # pylint: disable=missing-docstring,too-many-locals,too-many-statements
+ cMsTimeout = long(30*1000);
+ sAddress = 'localhost';
+ uPort = None;
+ fReversedSetup = False;
+ fReboot = False;
+ fShutdown = False;
+ fStdTests = True;
+
+ i = 1;
+ while i < len(asArgs):
+ if asArgs[i] == '--hostname':
+ sAddress = asArgs[i + 1];
+ i = i + 2;
+ elif asArgs[i] == '--port':
+ uPort = int(asArgs[i + 1]);
+ i = i + 2;
+ elif asArgs[i] == '--reversed-setup':
+ fReversedSetup = True;
+ i = i + 1;
+ elif asArgs[i] == '--timeout':
+ cMsTimeout = long(asArgs[i + 1]);
+ i = i + 2;
+ elif asArgs[i] == '--reboot':
+ fReboot = True;
+ fShutdown = False;
+ fStdTests = False;
+ i = i + 1;
+ elif asArgs[i] == '--shutdown':
+ fShutdown = True;
+ fReboot = False;
+ fStdTests = False;
+ i = i + 1;
+ elif asArgs[i] == '--help':
+ print('tst-txsclient.py [--hostname <addr|name>] [--port <num>] [--timeout <cMS>] '
+ '[--reboot|--shutdown] [--reversed-setup]');
+ return 0;
+ else:
+ print('Unknown argument: %s' % (asArgs[i]));
+ return 2;
+
+ if uPort is None:
+ oSession = txsclient.openTcpSession(cMsTimeout, sAddress, fReversedSetup = fReversedSetup);
+ else:
+ oSession = txsclient.openTcpSession(cMsTimeout, sAddress, uPort = uPort, fReversedSetup = fReversedSetup);
+ if oSession is None:
+ print('openTcpSession failed');
+ return 1;
+
+ fDone = oSession.waitForTask(30*1000);
+ print('connect: waitForTask -> %s, result %s' % (fDone, oSession.getResult()));
+ if fDone is True and oSession.isSuccess():
+ if fStdTests:
+ # Get the UUID of the remote instance.
+ sUuid = oSession.syncUuid();
+ if sUuid is not False:
+ print('%s: UUID = %s' % (boolRes(True), sUuid));
+ else:
+ print('%s: UUID' % (boolRes(False),));
+
+ # Create and remove a directory on the scratch area.
+ rc = oSession.syncMkDir('${SCRATCH}/testdir1');
+ print('%s: MKDIR(${SCRATCH}/testdir1) -> %s' % (boolRes(rc), rc));
+
+ rc = oSession.syncIsDir('${SCRATCH}/testdir1');
+ print('%s: ISDIR(${SCRATCH}/testdir1) -> %s' % (boolRes(rc), rc));
+
+ rc = oSession.syncRmDir('${SCRATCH}/testdir1');
+ print('%s: RMDIR(${SCRATCH}/testdir1) -> %s' % (boolRes(rc), rc));
+
+ # Create a two-level subdir.
+ rc = oSession.syncMkDirPath('${SCRATCH}/testdir2/subdir1');
+ print('%s: MKDRPATH(${SCRATCH}/testdir2/subdir1) -> %s' % (boolRes(rc), rc));
+
+ rc = oSession.syncIsDir('${SCRATCH}/testdir2');
+ print('%s: ISDIR(${SCRATCH}/testdir2) -> %s' % (boolRes(rc), rc));
+ rc = oSession.syncIsDir('${SCRATCH}/testdir2/');
+ print('%s: ISDIR(${SCRATCH}/testdir2/) -> %s' % (boolRes(rc), rc));
+ rc = oSession.syncIsDir('${SCRATCH}/testdir2/subdir1');
+ print('%s: ISDIR(${SCRATCH}/testdir2/subdir1) -> %s' % (boolRes(rc), rc));
+
+ rc = oSession.syncRmTree('${SCRATCH}/testdir2');
+ print('%s: RMTREE(${SCRATCH}/testdir2) -> %s' % (boolRes(rc), rc));
+
+ # Check out a simple file.
+ rc = oSession.syncUploadString('howdy', '${SCRATCH}/howdyfile');
+ print('%s: PUT FILE(${SCRATCH}/howdyfile) -> %s' % (boolRes(rc), rc));
+
+ rc = oSession.syncUploadString('howdy-replaced', '${SCRATCH}/howdyfile');
+ print('%s: PUT FILE(${SCRATCH}/howdyfile) -> %s' % (boolRes(rc), rc));
+
+ rc = oSession.syncDownloadString('${SCRATCH}/howdyfile');
+ print('%s: GET FILE(${SCRATCH}/howdyfile) -> "%s" expected "howdy-replaced"' % (stringRes(rc, 'howdy-replaced'), rc));
+
+ rc = oSession.syncIsFile('${SCRATCH}/howdyfile');
+ print('%s: ISFILE(${SCRATCH}/howdyfile) -> %s' % (boolRes(rc), rc));
+ rc = oSession.syncIsDir('${SCRATCH}/howdyfile');
+ print('%s: ISDIR(${SCRATCH}/howdyfile) -> %s' % (boolRes(rc, False), rc));
+ rc = oSession.syncIsSymlink('${SCRATCH}/howdyfile');
+ print('%s: ISSYMLNK(${SCRATCH}/howdyfile) -> %s' % (boolRes(rc, False), rc));
+
+ rc = oSession.syncRmFile('${SCRATCH}/howdyfile');
+ print('%s: RMFILE(${SCRATCH}/howdyfile) -> %s' % (boolRes(rc), rc));
+
+ # Unicode filename (may or may not work, LANG/LC_TYPE dependent on some hosts).
+ rc = oSession.syncUploadString('howdy', u'${SCRATCH}/Schröder');
+ print((u'%s: PUT FILE(${SCRATCH}/Schröder) -> %s' % (boolRes(rc), rc)).encode('ascii', 'replace'));
+
+ rc = oSession.syncIsFile(u'${SCRATCH}/Schröder');
+ print((u'%s: ISFILE(${SCRATCH}/Schröder) -> %s' % (boolRes(rc), rc)).encode('ascii', 'replace'));
+
+ rc = oSession.syncRmFile(u'${SCRATCH}/Schröder');
+ print((u'%s: RMFILE(${SCRATCH}/Schröder) -> %s' % (boolRes(rc), rc)).encode('ascii', 'replace'));
+
+ # Finally, some file uploading and downloading with unicode filenames.
+ strUpFile = 'tst-txsclient-upload.bin';
+ strDwnFile = 'tst-txsclient-download.bin';
+ try:
+ abRandFile = os.urandom(257897);
+ except:
+ print('INFO: no urandom... falling back on a simple string.');
+ abRandFile = 'asdflkjasdlfkjasdlfkjq023942relwjgkna9epr865u2nm345;hndafgoukhasre5kb2453km';
+ for i in range(1, 64):
+ abRandFile += abRandFile;
+ try:
+ oLocalFile = utils.openNoInherit(strUpFile, 'w+b');
+ oLocalFile.write(abRandFile);
+ oLocalFile.close();
+ rc = True;
+ except:
+ rc = False;
+ print('%s: creating file (%s) to upload failed....' % (boolRes(rc), strUpFile));
+
+ if rc is True:
+ rc = oSession.syncUploadFile(strUpFile, '${SCRATCH}/tst-txsclient-uploaded.bin')
+ print('%s: PUT FILE(%s, ${SCRATCH}/tst-txsclient-uploaded.bin) -> %s' % (boolRes(rc), strUpFile, rc));
+
+ rc = oSession.syncDownloadFile('${SCRATCH}/tst-txsclient-uploaded.bin', strDwnFile)
+ print('%s: GET FILE(${SCRATCH}/tst-txsclient-uploaded.bin, tst-txsclient-downloaded.txt) -> %s'
+ % (boolRes(rc), rc));
+
+ try:
+ oLocalFile = utils.openNoInherit(strDwnFile, "rb");
+ abDwnFile = oLocalFile.read();
+ oLocalFile.close();
+ if abRandFile == abDwnFile:
+ print('%s: downloaded file matches the uploaded file' % (boolRes(True),));
+ else:
+ print('%s: downloaded file does not match the uploaded file' % (boolRes(False),));
+ print('abRandFile=%s' % (abRandFile,));
+ print('abDwnFile =%s' % (abRandFile,));
+ except:
+ print('%s: reading downloaded file (%s) failed....' % (boolRes(False), strDwnFile));
+
+ rc = oSession.syncRmFile(u'${SCRATCH}/tst-txsclient-uploaded.bin');
+ print('%s: RMFILE(${SCRATCH}/tst-txsclient-uploaded.bin) -> %s' % (boolRes(rc), rc));
+
+ try: os.remove(strUpFile);
+ except: pass;
+ try: os.remove(strDwnFile);
+ except: pass;
+
+ # Execute some simple thing, if available.
+ # Intentionally skip this test if file is not available due to
+ # another inserted CD-ROM (e.g. not TestSuite.iso).
+ sProg = '${CDROM}/${OS/ARCH}/NetPerf${EXESUFF}';
+ rc = oSession.syncIsFile(sProg, 30 * 1000, True);
+ if rc is True:
+ rc = oSession.syncExecEx(sProg, (sProg, '--help'));
+ print('%s: EXEC(%s ${SCRATCH}) -> %s' % (boolRes(rc), sProg, rc));
+
+ rc = oSession.syncExecEx(sProg, (sProg, 'there', 'is no such', 'parameter'), \
+ oStdOut='${SCRATCH}/stdout', \
+ oStdErr='${SCRATCH}/stderr');
+ print('%s: EXEC(%s there is not such parameter > ${SCRATCH}/stdout 2> ${SCRATCH}/stderr) -> %s'
+ % (boolRes(rc, False), sProg, rc));
+
+ rc = oSession.syncDownloadString('${SCRATCH}/stdout');
+ print('INFO: GET FILE(${SCRATCH}/stdout) -> "%s"' % (rc));
+ rc = oSession.syncDownloadString('${SCRATCH}/stderr');
+ print('INFO: GET FILE(${SCRATCH}/stderr) -> "%s"' % (rc));
+
+ print('TESTING: syncExec...');
+ rc = oSession.syncExec(sProg, (sProg, '--version'));
+ print('%s: EXEC(%s --version) -> %s' % (boolRes(rc), sProg, rc));
+
+ print('TESTING: syncExec...');
+ rc = oSession.syncExec(sProg, (sProg, '--help'));
+ print('%s: EXEC(%s --help) -> %s' % (boolRes(rc), sProg, rc));
+
+ #print('TESTING: syncExec sleep 30...'
+ #rc = oSession.syncExec('/usr/bin/sleep', ('/usr/bin/sleep', '30')));
+ #print('%s: EXEC(/bin/sleep 30) -> %s' % (boolRes(rc), rc));
+ else:
+ print('SKIP: Execution of %s skipped, does not exist on CD-ROM' % (sProg,));
+
+ # Execute a non-existing file on CD-ROM.
+ sProg = '${CDROM}/${OS/ARCH}/NonExisting${EXESUFF}';
+ rc = oSession.syncExecEx(sProg, (sProg,), oStdIn = '/dev/null', oStdOut = '/dev/null', \
+ oStdErr = '/dev/null', oTestPipe = '/dev/null', \
+ sAsUser = '', cMsTimeout = 3600000, fIgnoreErrors = True);
+ if rc is None:
+ rc = True;
+ else:
+ reporter.error('Unexpected value \"%s\" while executing non-existent file "%s"' % (rc, sProg));
+ print('%s: EXEC(%s ${SCRATCH}) -> %s' % (boolRes(rc), sProg, rc));
+
+ # Done
+ rc = oSession.syncDisconnect();
+ print('%s: disconnect() -> %s' % (boolRes(rc), rc));
+
+ elif fReboot:
+ print('TESTING: syncReboot...');
+ rc = oSession.syncReboot();
+ print('%s: REBOOT() -> %s' % (boolRes(rc), rc));
+ elif fShutdown:
+ print('TESTING: syncShutdown...');
+ rc = oSession.syncShutdown();
+ print('%s: SHUTDOWN() -> %s' % (boolRes(rc), rc));
+
+
+ if g_cFailures != 0:
+ print('tst-txsclient.py: %u out of %u test failed' % (g_cFailures, g_cTests));
+ return 1;
+ print('tst-txsclient.py: all %u tests passed!' % (g_cTests));
+ return 0;
+
+
+if __name__ == '__main__':
+ reporter.incVerbosity();
+ reporter.incVerbosity();
+ reporter.incVerbosity();
+ reporter.incVerbosity();
+ sys.exit(main(sys.argv));
+
diff --git a/src/VBox/ValidationKit/testdriver/txsclient.py b/src/VBox/ValidationKit/testdriver/txsclient.py
new file mode 100755
index 00000000..343071d6
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/txsclient.py
@@ -0,0 +1,2376 @@
+# -*- coding: utf-8 -*-
+# $Id: txsclient.py $
+# pylint: disable=too-many-lines
+
+"""
+Test eXecution Service Client.
+"""
+__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 array;
+import errno;
+import os;
+import select;
+import socket;
+import sys;
+import threading;
+import time;
+import zlib;
+import uuid;
+
+# Validation Kit imports.
+from common import utils;
+from testdriver import base;
+from testdriver import reporter;
+from testdriver.base import TdTaskBase;
+
+# Python 3 hacks:
+if sys.version_info[0] >= 3:
+ long = int; # pylint: disable=redefined-builtin,invalid-name
+
+#
+# Helpers for decoding data received from the TXS.
+# These are used both the Session and Transport classes.
+#
+
+def getU32(abData, off):
+ """Get a U32 field."""
+ return abData[off] \
+ + abData[off + 1] * 256 \
+ + abData[off + 2] * 65536 \
+ + abData[off + 3] * 16777216;
+
+def getSZ(abData, off, sDefault = None):
+ """
+ Get a zero-terminated string field.
+ Returns sDefault if the string is invalid.
+ """
+ cchStr = getSZLen(abData, off);
+ if cchStr >= 0:
+ abStr = abData[off:(off + cchStr)];
+ try:
+ if sys.version_info < (3, 9, 0):
+ # Removed since Python 3.9.
+ sStr = abStr.tostring(); # pylint: disable=no-member
+ else:
+ sStr = abStr.tobytes();
+ return sStr.decode('utf_8');
+ except:
+ reporter.errorXcpt('getSZ(,%u)' % (off));
+ return sDefault;
+
+def getSZLen(abData, off):
+ """
+ Get the length of a zero-terminated string field, in bytes.
+ Returns -1 if off is beyond the data packet or not properly terminated.
+ """
+ cbData = len(abData);
+ if off >= cbData:
+ return -1;
+
+ offCur = off;
+ while abData[offCur] != 0:
+ offCur = offCur + 1;
+ if offCur >= cbData:
+ return -1;
+
+ return offCur - off;
+
+def isValidOpcodeEncoding(sOpcode):
+ """
+ Checks if the specified opcode is valid or not.
+ Returns True on success.
+ Returns False if it is invalid, details in the log.
+ """
+ sSet1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ sSet2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_ ";
+ if len(sOpcode) != 8:
+ reporter.error("invalid opcode length: %s" % (len(sOpcode)));
+ return False;
+ for i in range(0, 1):
+ if sSet1.find(sOpcode[i]) < 0:
+ reporter.error("invalid opcode char #%u: %s" % (i, sOpcode));
+ return False;
+ for i in range(2, 7):
+ if sSet2.find(sOpcode[i]) < 0:
+ reporter.error("invalid opcode char #%u: %s" % (i, sOpcode));
+ return False;
+ return True;
+
+#
+# Helper for encoding data sent to the TXS.
+#
+
+def u32ToByteArray(u32):
+ """Encodes the u32 value as a little endian byte (B) array."""
+ return array.array('B',
+ ( u32 % 256,
+ (u32 // 256) % 256,
+ (u32 // 65536) % 256,
+ (u32 // 16777216) % 256) );
+
+def escapeString(sString):
+ """
+ Does $ escaping of the string so TXS doesn't try do variable expansion.
+ """
+ return sString.replace('$', '$$');
+
+
+
+class TransportBase(object):
+ """
+ Base class for the transport layer.
+ """
+
+ def __init__(self, sCaller):
+ self.sDbgCreated = '%s: %s' % (utils.getTimePrefix(), sCaller);
+ self.fDummy = 0;
+ self.abReadAheadHdr = array.array('B');
+
+ def toString(self):
+ """
+ Stringify the instance for logging and debugging.
+ """
+ return '<%s: abReadAheadHdr=%s, sDbgCreated=%s>' % (type(self).__name__, self.abReadAheadHdr, self.sDbgCreated);
+
+ def __str__(self):
+ return self.toString();
+
+ def cancelConnect(self):
+ """
+ Cancels any pending connect() call.
+ Returns None;
+ """
+ return None;
+
+ def connect(self, cMsTimeout):
+ """
+ Quietly attempts to connect to the TXS.
+
+ Returns True on success.
+ Returns False on retryable errors (no logging).
+ Returns None on fatal errors with details in the log.
+
+ Override this method, don't call super.
+ """
+ _ = cMsTimeout;
+ return False;
+
+ def disconnect(self, fQuiet = False):
+ """
+ Disconnect from the TXS.
+
+ Returns True.
+
+ Override this method, don't call super.
+ """
+ _ = fQuiet;
+ return True;
+
+ def sendBytes(self, abBuf, cMsTimeout):
+ """
+ Sends the bytes in the buffer abBuf to the TXS.
+
+ Returns True on success.
+ Returns False on failure and error details in the log.
+
+ Override this method, don't call super.
+
+ Remarks: len(abBuf) is always a multiple of 16.
+ """
+ _ = abBuf; _ = cMsTimeout;
+ return False;
+
+ def recvBytes(self, cb, cMsTimeout, fNoDataOk):
+ """
+ Receive cb number of bytes from the TXS.
+
+ Returns the bytes (array('B')) on success.
+ Returns None on failure and error details in the log.
+
+ Override this method, don't call super.
+
+ Remarks: cb is always a multiple of 16.
+ """
+ _ = cb; _ = cMsTimeout; _ = fNoDataOk;
+ return None;
+
+ def isConnectionOk(self):
+ """
+ Checks if the connection is OK.
+
+ Returns True if it is.
+ Returns False if it isn't (caller should call diconnect).
+
+ Override this method, don't call super.
+ """
+ return True;
+
+ def isRecvPending(self, cMsTimeout = 0):
+ """
+ Checks if there is incoming bytes, optionally waiting cMsTimeout
+ milliseconds for something to arrive.
+
+ Returns True if there is, False if there isn't.
+
+ Override this method, don't call super.
+ """
+ _ = cMsTimeout;
+ return False;
+
+ def sendMsgInt(self, sOpcode, cMsTimeout, abPayload = array.array('B')):
+ """
+ Sends a message (opcode + encoded payload).
+
+ Returns True on success.
+ Returns False on failure and error details in the log.
+ """
+ # Fix + check the opcode.
+ if len(sOpcode) < 2:
+ reporter.fatal('sendMsgInt: invalid opcode length: %d (\"%s\")' % (len(sOpcode), sOpcode));
+ return False;
+ sOpcode = sOpcode.ljust(8);
+ if not isValidOpcodeEncoding(sOpcode):
+ reporter.fatal('sendMsgInt: invalid opcode encoding: \"%s\"' % (sOpcode));
+ return False;
+
+ # Start construct the message.
+ cbMsg = 16 + len(abPayload);
+ abMsg = array.array('B');
+ abMsg.extend(u32ToByteArray(cbMsg));
+ abMsg.extend((0, 0, 0, 0)); # uCrc32
+ try:
+ abMsg.extend(array.array('B', \
+ ( ord(sOpcode[0]), \
+ ord(sOpcode[1]), \
+ ord(sOpcode[2]), \
+ ord(sOpcode[3]), \
+ ord(sOpcode[4]), \
+ ord(sOpcode[5]), \
+ ord(sOpcode[6]), \
+ ord(sOpcode[7]) ) ) );
+ if abPayload:
+ abMsg.extend(abPayload);
+ except:
+ reporter.fatalXcpt('sendMsgInt: packing problem...');
+ return False;
+
+ # checksum it, padd it and send it off.
+ uCrc32 = zlib.crc32(abMsg[8:]);
+ abMsg[4:8] = u32ToByteArray(uCrc32);
+
+ while len(abMsg) % 16:
+ abMsg.append(0);
+
+ reporter.log2('sendMsgInt: op=%s len=%d timeout=%d' % (sOpcode, len(abMsg), cMsTimeout));
+ return self.sendBytes(abMsg, cMsTimeout);
+
+ def recvMsg(self, cMsTimeout, fNoDataOk = False):
+ """
+ Receives a message from the TXS.
+
+ Returns the message three-tuple: length, opcode, payload.
+ Returns (None, None, None) on failure and error details in the log.
+ """
+
+ # Read the header.
+ if self.abReadAheadHdr:
+ assert(len(self.abReadAheadHdr) == 16);
+ abHdr = self.abReadAheadHdr;
+ self.abReadAheadHdr = array.array('B');
+ else:
+ abHdr = self.recvBytes(16, cMsTimeout, fNoDataOk); # (virtual method) # pylint: disable=assignment-from-none
+ if abHdr is None:
+ return (None, None, None);
+ if len(abHdr) != 16:
+ reporter.fatal('recvBytes(16) returns %d bytes!' % (len(abHdr)));
+ return (None, None, None);
+
+ # Unpack and validate the header.
+ cbMsg = getU32(abHdr, 0);
+ uCrc32 = getU32(abHdr, 4);
+
+ if sys.version_info < (3, 9, 0):
+ # Removed since Python 3.9.
+ sOpcode = abHdr[8:16].tostring(); # pylint: disable=no-member
+ else:
+ sOpcode = abHdr[8:16].tobytes();
+ sOpcode = sOpcode.decode('ascii');
+
+ if cbMsg < 16:
+ reporter.fatal('recvMsg: message length is out of range: %s (min 16 bytes)' % (cbMsg));
+ return (None, None, None);
+ if cbMsg > 1024*1024:
+ reporter.fatal('recvMsg: message length is out of range: %s (max 1MB)' % (cbMsg));
+ return (None, None, None);
+ if not isValidOpcodeEncoding(sOpcode):
+ reporter.fatal('recvMsg: invalid opcode \"%s\"' % (sOpcode));
+ return (None, None, None);
+
+ # Get the payload (if any), dropping the padding.
+ abPayload = array.array('B');
+ if cbMsg > 16:
+ if cbMsg % 16:
+ cbPadding = 16 - (cbMsg % 16);
+ else:
+ cbPadding = 0;
+ abPayload = self.recvBytes(cbMsg - 16 + cbPadding, cMsTimeout, False); # pylint: disable=assignment-from-none
+ if abPayload is None:
+ self.abReadAheadHdr = abHdr;
+ if not fNoDataOk :
+ reporter.log('recvMsg: failed to recv payload bytes!');
+ return (None, None, None);
+
+ while cbPadding > 0:
+ abPayload.pop();
+ cbPadding = cbPadding - 1;
+
+ # Check the CRC-32.
+ if uCrc32 != 0:
+ uActualCrc32 = zlib.crc32(abHdr[8:]);
+ if cbMsg > 16:
+ uActualCrc32 = zlib.crc32(abPayload, uActualCrc32);
+ uActualCrc32 = uActualCrc32 & 0xffffffff;
+ if uCrc32 != uActualCrc32:
+ reporter.fatal('recvMsg: crc error: expected %s, got %s' % (hex(uCrc32), hex(uActualCrc32)));
+ return (None, None, None);
+
+ reporter.log2('recvMsg: op=%s len=%d' % (sOpcode, len(abPayload)));
+ return (cbMsg, sOpcode, abPayload);
+
+ def sendMsg(self, sOpcode, cMsTimeout, aoPayload = ()):
+ """
+ Sends a message (opcode + payload tuple).
+
+ Returns True on success.
+ Returns False on failure and error details in the log.
+ Returns None if you pass the incorrectly typed parameters.
+ """
+ # Encode the payload.
+ abPayload = array.array('B');
+ for o in aoPayload:
+ try:
+ if utils.isString(o):
+ if sys.version_info[0] >= 3:
+ abPayload.extend(o.encode('utf_8'));
+ else:
+ # the primitive approach...
+ sUtf8 = o.encode('utf_8');
+ for ch in sUtf8:
+ abPayload.append(ord(ch))
+ abPayload.append(0);
+ elif isinstance(o, (long, int)):
+ if o < 0 or o > 0xffffffff:
+ reporter.fatal('sendMsg: uint32_t payload is out of range: %s' % (hex(o)));
+ return None;
+ abPayload.extend(u32ToByteArray(o));
+ elif isinstance(o, array.array):
+ abPayload.extend(o);
+ else:
+ reporter.fatal('sendMsg: unexpected payload type: %s (%s) (aoPayload=%s)' % (type(o), o, aoPayload));
+ return None;
+ except:
+ reporter.fatalXcpt('sendMsg: screwed up the encoding code...');
+ return None;
+ return self.sendMsgInt(sOpcode, cMsTimeout, abPayload);
+
+
+class Session(TdTaskBase):
+ """
+ A Test eXecution Service (TXS) client session.
+ """
+
+ def __init__(self, oTransport, cMsTimeout, cMsIdleFudge, fTryConnect = False, fnProcessEvents = None):
+ """
+ Construct a TXS session.
+
+ This starts by connecting to the TXS and will enter the signalled state
+ when connected or the timeout has been reached.
+ """
+ TdTaskBase.__init__(self, utils.getCallerName(), fnProcessEvents);
+ self.oTransport = oTransport;
+ self.sStatus = "";
+ self.cMsTimeout = 0;
+ self.fErr = True; # Whether to report errors as error.
+ self.msStart = 0;
+ self.oThread = None;
+ self.fnTask = self.taskDummy;
+ self.aTaskArgs = None;
+ self.oTaskRc = None;
+ self.t3oReply = (None, None, None);
+ self.fScrewedUpMsgState = False;
+ self.fTryConnect = fTryConnect;
+
+ if not self.startTask(cMsTimeout, False, "connecting", self.taskConnect, (cMsIdleFudge,)):
+ raise base.GenError("startTask failed");
+
+ def __del__(self):
+ """Make sure to cancel the task when deleted."""
+ self.cancelTask();
+
+ def toString(self):
+ return '<%s fnTask=%s, aTaskArgs=%s, sStatus=%s, oTaskRc=%s, cMsTimeout=%s,' \
+ ' msStart=%s, fTryConnect=%s, fErr=%s, fScrewedUpMsgState=%s, t3oReply=%s oTransport=%s, oThread=%s>' \
+ % (TdTaskBase.toString(self), self.fnTask, self.aTaskArgs, self.sStatus, self.oTaskRc, self.cMsTimeout,
+ self.msStart, self.fTryConnect, self.fErr, self.fScrewedUpMsgState, self.t3oReply, self.oTransport, self.oThread);
+
+ def taskDummy(self):
+ """Place holder to catch broken state handling."""
+ raise Exception();
+
+ def startTask(self, cMsTimeout, fIgnoreErrors, sStatus, fnTask, aArgs = ()):
+ """
+ Kicks of a new task.
+
+ cMsTimeout: The task timeout in milliseconds. Values less than
+ 500 ms will be adjusted to 500 ms. This means it is
+ OK to use negative value.
+ sStatus: The task status.
+ fnTask: The method that'll execute the task.
+ aArgs: Arguments to pass to fnTask.
+
+ Returns True on success, False + error in log on failure.
+ """
+ if not self.cancelTask():
+ reporter.maybeErr(not fIgnoreErrors, 'txsclient.Session.startTask: failed to cancel previous task.');
+ return False;
+
+ # Change status and make sure we're the
+ self.lockTask();
+ if self.sStatus != "":
+ self.unlockTask();
+ reporter.maybeErr(not fIgnoreErrors, 'txsclient.Session.startTask: race.');
+ return False;
+ self.sStatus = "setup";
+ self.oTaskRc = None;
+ self.t3oReply = (None, None, None);
+ self.resetTaskLocked();
+ self.unlockTask();
+
+ self.cMsTimeout = max(cMsTimeout, 500);
+ self.fErr = not fIgnoreErrors;
+ self.fnTask = fnTask;
+ self.aTaskArgs = aArgs;
+ self.oThread = threading.Thread(target=self.taskThread, args=(), name=('TXS-%s' % (sStatus)));
+ self.oThread.setDaemon(True); # pylint: disable=deprecated-method
+ self.msStart = base.timestampMilli();
+
+ self.lockTask();
+ self.sStatus = sStatus;
+ self.unlockTask();
+ self.oThread.start();
+
+ return True;
+
+ def cancelTask(self, fSync = True):
+ """
+ Attempts to cancel any pending tasks.
+ Returns success indicator (True/False).
+ """
+ self.lockTask();
+
+ if self.sStatus == "":
+ self.unlockTask();
+ return True;
+ if self.sStatus == "setup":
+ self.unlockTask();
+ return False;
+ if self.sStatus == "cancelled":
+ self.unlockTask();
+ return False;
+
+ reporter.log('txsclient: cancelling "%s"...' % (self.sStatus));
+ if self.sStatus == 'connecting':
+ self.oTransport.cancelConnect();
+
+ self.sStatus = "cancelled";
+ oThread = self.oThread;
+ self.unlockTask();
+
+ if not fSync:
+ return False;
+
+ oThread.join(61.0);
+
+ if sys.version_info < (3, 9, 0):
+ # Removed since Python 3.9.
+ return oThread.isAlive(); # pylint: disable=no-member
+ return oThread.is_alive();
+
+ def taskThread(self):
+ """
+ The task thread function.
+ This does some housekeeping activities around the real task method call.
+ """
+ if not self.isCancelled():
+ try:
+ fnTask = self.fnTask;
+ oTaskRc = fnTask(*self.aTaskArgs);
+ except:
+ reporter.fatalXcpt('taskThread', 15);
+ oTaskRc = None;
+ else:
+ reporter.log('taskThread: cancelled already');
+
+ self.lockTask();
+
+ reporter.log('taskThread: signalling task with status "%s", oTaskRc=%s' % (self.sStatus, oTaskRc));
+ self.oTaskRc = oTaskRc;
+ self.oThread = None;
+ self.sStatus = '';
+ self.signalTaskLocked();
+
+ self.unlockTask();
+ return None;
+
+ def isCancelled(self):
+ """Internal method for checking if the task has been cancelled."""
+ self.lockTask();
+ sStatus = self.sStatus;
+ self.unlockTask();
+ if sStatus == "cancelled":
+ return True;
+ return False;
+
+ def hasTimedOut(self):
+ """Internal method for checking if the task has timed out or not."""
+ cMsLeft = self.getMsLeft();
+ if cMsLeft <= 0:
+ return True;
+ return False;
+
+ def getMsLeft(self, cMsMin = 0, cMsMax = -1):
+ """Gets the time left until the timeout."""
+ cMsElapsed = base.timestampMilli() - self.msStart;
+ if cMsElapsed < 0:
+ return cMsMin;
+ cMsLeft = self.cMsTimeout - cMsElapsed;
+ if cMsLeft <= cMsMin:
+ return cMsMin;
+ if cMsLeft > cMsMax > 0:
+ return cMsMax
+ return cMsLeft;
+
+ def recvReply(self, cMsTimeout = None, fNoDataOk = False):
+ """
+ Wrapper for TransportBase.recvMsg that stashes the response away
+ so the client can inspect it later on.
+ """
+ if cMsTimeout is None:
+ cMsTimeout = self.getMsLeft(500);
+ cbMsg, sOpcode, abPayload = self.oTransport.recvMsg(cMsTimeout, fNoDataOk);
+ self.lockTask();
+ self.t3oReply = (cbMsg, sOpcode, abPayload);
+ self.unlockTask();
+ return (cbMsg, sOpcode, abPayload);
+
+ def recvAck(self, fNoDataOk = False):
+ """
+ Receives an ACK or error response from the TXS.
+
+ Returns True on success.
+ Returns False on timeout or transport error.
+ Returns (sOpcode, sDetails) tuple on failure. The opcode is stripped
+ and there are always details of some sort or another.
+ """
+ cbMsg, sOpcode, abPayload = self.recvReply(None, fNoDataOk);
+ if cbMsg is None:
+ return False;
+ sOpcode = sOpcode.strip()
+ if sOpcode == "ACK":
+ return True;
+ return (sOpcode, getSZ(abPayload, 0, sOpcode));
+
+ def recvAckLogged(self, sCommand, fNoDataOk = False):
+ """
+ Wrapper for recvAck and logging.
+ Returns True on success (ACK).
+ Returns False on time, transport error and errors signalled by TXS.
+ """
+ rc = self.recvAck(fNoDataOk);
+ if rc is not True and not fNoDataOk:
+ if rc is False:
+ reporter.maybeErr(self.fErr, 'recvAckLogged: %s transport error' % (sCommand));
+ else:
+ reporter.maybeErr(self.fErr, 'recvAckLogged: %s response was %s: %s' % (sCommand, rc[0], rc[1]));
+ rc = False;
+ return rc;
+
+ def recvTrueFalse(self, sCommand):
+ """
+ Receives a TRUE/FALSE response from the TXS.
+ Returns True on TRUE, False on FALSE and None on error/other (logged).
+ """
+ cbMsg, sOpcode, abPayload = self.recvReply();
+ if cbMsg is None:
+ reporter.maybeErr(self.fErr, 'recvAckLogged: %s transport error' % (sCommand));
+ return None;
+
+ sOpcode = sOpcode.strip()
+ if sOpcode == "TRUE":
+ return True;
+ if sOpcode == "FALSE":
+ return False;
+ reporter.maybeErr(self.fErr, 'recvAckLogged: %s response was %s: %s' % (sCommand, sOpcode, getSZ(abPayload, 0, sOpcode)));
+ return None;
+
+ def sendMsg(self, sOpcode, aoPayload = (), cMsTimeout = None):
+ """
+ Wrapper for TransportBase.sendMsg that inserts the correct timeout.
+ """
+ if cMsTimeout is None:
+ cMsTimeout = self.getMsLeft(500);
+ return self.oTransport.sendMsg(sOpcode, cMsTimeout, aoPayload);
+
+ def asyncToSync(self, fnAsync, *aArgs):
+ """
+ Wraps an asynchronous task into a synchronous operation.
+
+ Returns False on failure, task return status on success.
+ """
+ rc = fnAsync(*aArgs);
+ if rc is False:
+ reporter.log2('asyncToSync(%s): returns False (#1)' % (fnAsync));
+ return rc;
+
+ rc = self.waitForTask(self.cMsTimeout + 5000);
+ if rc is False:
+ reporter.maybeErr(self.fErr, 'asyncToSync: waitForTask (timeout %d) failed...' % (self.cMsTimeout,));
+ self.cancelTask();
+ #reporter.log2('asyncToSync(%s): returns False (#2)' % (fnAsync, rc));
+ return False;
+
+ rc = self.getResult();
+ #reporter.log2('asyncToSync(%s): returns %s' % (fnAsync, rc));
+ return rc;
+
+ #
+ # Connection tasks.
+ #
+
+ def taskConnect(self, cMsIdleFudge):
+ """Tries to connect to the TXS"""
+ while not self.isCancelled():
+ reporter.log2('taskConnect: connecting ...');
+ rc = self.oTransport.connect(self.getMsLeft(500));
+ if rc is True:
+ reporter.log('taskConnect: succeeded');
+ return self.taskGreet(cMsIdleFudge);
+ if rc is None:
+ reporter.log2('taskConnect: unable to connect');
+ return None;
+ if self.hasTimedOut():
+ reporter.log2('taskConnect: timed out');
+ if not self.fTryConnect:
+ reporter.maybeErr(self.fErr, 'taskConnect: timed out');
+ return False;
+ time.sleep(self.getMsLeft(1, 1000) / 1000.0);
+ if not self.fTryConnect:
+ reporter.maybeErr(self.fErr, 'taskConnect: cancelled');
+ return False;
+
+ def taskGreet(self, cMsIdleFudge):
+ """Greets the TXS"""
+ rc = self.sendMsg("HOWDY", ());
+ if rc is True:
+ rc = self.recvAckLogged("HOWDY", self.fTryConnect);
+ if rc is True:
+ while cMsIdleFudge > 0:
+ cMsIdleFudge -= 1000;
+ time.sleep(1);
+ else:
+ self.oTransport.disconnect(self.fTryConnect);
+ return rc;
+
+ def taskBye(self):
+ """Says goodbye to the TXS"""
+ rc = self.sendMsg("BYE");
+ if rc is True:
+ rc = self.recvAckLogged("BYE");
+ self.oTransport.disconnect();
+ return rc;
+
+ def taskVer(self):
+ """Requests version information from TXS"""
+ rc = self.sendMsg("VER");
+ if rc is True:
+ rc = False;
+ cbMsg, sOpcode, abPayload = self.recvReply();
+ if cbMsg is not None:
+ sOpcode = sOpcode.strip();
+ if sOpcode == "ACK VER":
+ sVer = getSZ(abPayload, 0);
+ if sVer is not None:
+ rc = sVer;
+ else:
+ reporter.maybeErr(self.fErr, 'taskVer got a bad reply: %s' % (sOpcode,));
+ else:
+ reporter.maybeErr(self.fErr, 'taskVer got 3xNone from recvReply.');
+ return rc;
+
+ def taskUuid(self):
+ """Gets the TXS UUID"""
+ rc = self.sendMsg("UUID");
+ if rc is True:
+ rc = False;
+ cbMsg, sOpcode, abPayload = self.recvReply();
+ if cbMsg is not None:
+ sOpcode = sOpcode.strip()
+ if sOpcode == "ACK UUID":
+ sUuid = getSZ(abPayload, 0);
+ if sUuid is not None:
+ sUuid = '{%s}' % (sUuid,)
+ try:
+ _ = uuid.UUID(sUuid);
+ rc = sUuid;
+ except:
+ reporter.errorXcpt('taskUuid got an invalid UUID string %s' % (sUuid,));
+ else:
+ reporter.maybeErr(self.fErr, 'taskUuid did not get a UUID string.');
+ else:
+ reporter.maybeErr(self.fErr, 'taskUuid got a bad reply: %s' % (sOpcode,));
+ else:
+ reporter.maybeErr(self.fErr, 'taskUuid got 3xNone from recvReply.');
+ return rc;
+
+ #
+ # Process task
+ # pylint: disable=missing-docstring
+ #
+
+ def taskExecEx(self, sExecName, fFlags, asArgs, asAddEnv, oStdIn, oStdOut, oStdErr, oTestPipe, sAsUser): # pylint: disable=too-many-arguments,too-many-locals,too-many-statements,line-too-long
+ # Construct the payload.
+ aoPayload = [long(fFlags), '%s' % (sExecName), long(len(asArgs))];
+ for sArg in asArgs:
+ aoPayload.append('%s' % (sArg));
+ aoPayload.append(long(len(asAddEnv)));
+ for sPutEnv in asAddEnv:
+ aoPayload.append('%s' % (sPutEnv));
+ for o in (oStdIn, oStdOut, oStdErr, oTestPipe):
+ if utils.isString(o):
+ aoPayload.append(o);
+ elif o is not None:
+ aoPayload.append('|');
+ o.uTxsClientCrc32 = zlib.crc32(b'');
+ else:
+ aoPayload.append('');
+ aoPayload.append('%s' % (sAsUser));
+ aoPayload.append(long(self.cMsTimeout));
+
+ # Kick of the EXEC command.
+ rc = self.sendMsg('EXEC', aoPayload)
+ if rc is True:
+ rc = self.recvAckLogged('EXEC');
+ if rc is True:
+ # Loop till the process completes, feed input to the TXS and
+ # receive output from it.
+ sFailure = "";
+ msPendingInputReply = None;
+ cbMsg, sOpcode, abPayload = (None, None, None);
+ while True:
+ # Pending input?
+ if msPendingInputReply is None \
+ and oStdIn is not None \
+ and not utils.isString(oStdIn):
+ try:
+ sInput = oStdIn.read(65536);
+ except:
+ reporter.errorXcpt('read standard in');
+ sFailure = 'exception reading stdin';
+ rc = None;
+ break;
+ if sInput:
+ # Convert to a byte array before handing it of to sendMsg or the string
+ # will get some zero termination added breaking the CRC (and injecting
+ # unwanted bytes).
+ abInput = array.array('B', sInput.encode('utf-8'));
+ oStdIn.uTxsClientCrc32 = zlib.crc32(abInput, oStdIn.uTxsClientCrc32);
+ rc = self.sendMsg('STDIN', (long(oStdIn.uTxsClientCrc32 & 0xffffffff), abInput));
+ if rc is not True:
+ sFailure = 'sendMsg failure';
+ break;
+ msPendingInputReply = base.timestampMilli();
+ continue;
+
+ rc = self.sendMsg('STDINEOS');
+ oStdIn = None;
+ if rc is not True:
+ sFailure = 'sendMsg failure';
+ break;
+ msPendingInputReply = base.timestampMilli();
+
+ # Wait for input (500 ms timeout).
+ if cbMsg is None:
+ cbMsg, sOpcode, abPayload = self.recvReply(cMsTimeout=500, fNoDataOk=True);
+ if cbMsg is None:
+ # Check for time out before restarting the loop.
+ # Note! Only doing timeout checking here does mean that
+ # the TXS may prevent us from timing out by
+ # flooding us with data. This is unlikely though.
+ if self.hasTimedOut() \
+ and ( msPendingInputReply is None \
+ or base.timestampMilli() - msPendingInputReply > 30000):
+ reporter.maybeErr(self.fErr, 'taskExecEx: timed out');
+ sFailure = 'timeout';
+ rc = None;
+ break;
+ # Check that the connection is OK.
+ if not self.oTransport.isConnectionOk():
+ self.oTransport.disconnect();
+ sFailure = 'disconnected';
+ rc = False;
+ break;
+ continue;
+
+ # Handle the response.
+ sOpcode = sOpcode.rstrip();
+ if sOpcode == 'STDOUT':
+ oOut = oStdOut;
+ elif sOpcode == 'STDERR':
+ oOut = oStdErr;
+ elif sOpcode == 'TESTPIPE':
+ oOut = oTestPipe;
+ else:
+ oOut = None;
+ if oOut is not None:
+ # Output from the process.
+ if len(abPayload) < 4:
+ sFailure = 'malformed output packet (%s, %u bytes)' % (sOpcode, cbMsg);
+ reporter.maybeErr(self.fErr, 'taskExecEx: %s' % (sFailure));
+ rc = None;
+ break;
+ uStreamCrc32 = getU32(abPayload, 0);
+ oOut.uTxsClientCrc32 = zlib.crc32(abPayload[4:], oOut.uTxsClientCrc32);
+ if uStreamCrc32 != (oOut.uTxsClientCrc32 & 0xffffffff):
+ sFailure = 'crc error - mine=%#x their=%#x (%s, %u bytes)' \
+ % (oOut.uTxsClientCrc32 & 0xffffffff, uStreamCrc32, sOpcode, cbMsg);
+ reporter.maybeErr(self.fErr, 'taskExecEx: %s' % (sFailure));
+ rc = None;
+ break;
+ try:
+ oOut.write(abPayload[4:]);
+ except:
+ sFailure = 'exception writing %s' % (sOpcode);
+ reporter.errorXcpt('taskExecEx: %s' % (sFailure));
+ rc = None;
+ break;
+ elif sOpcode == 'STDINIGN' and msPendingInputReply is not None:
+ # Standard input is ignored. Ignore this condition for now.
+ msPendingInputReply = None;
+ reporter.log('taskExecEx: Standard input is ignored... why?');
+ del oStdIn.uTxsClientCrc32;
+ oStdIn = '/dev/null';
+ elif sOpcode in ('STDINMEM', 'STDINBAD', 'STDINCRC',)\
+ and msPendingInputReply is not None:
+ # TXS STDIN error, abort.
+ # TODO: STDINMEM - consider undoing the previous stdin read and try resubmitt it.
+ msPendingInputReply = None;
+ sFailure = 'TXS is out of memory for std input buffering';
+ reporter.maybeErr(self.fErr, 'taskExecEx: %s' % (sFailure));
+ rc = None;
+ break;
+ elif sOpcode == 'ACK' and msPendingInputReply is not None:
+ msPendingInputReply = None;
+ elif sOpcode.startswith('PROC '):
+ # Process status message, handle it outside the loop.
+ rc = True;
+ break;
+ else:
+ sFailure = 'Unexpected opcode %s' % (sOpcode);
+ reporter.maybeErr(self.fErr, 'taskExecEx: %s' % (sFailure));
+ rc = None;
+ break;
+ # Clear the message.
+ cbMsg, sOpcode, abPayload = (None, None, None);
+
+ # If we sent an STDIN packet and didn't get a reply yet, we'll give
+ # TXS some 5 seconds to reply to this. If we don't wait here we'll
+ # get screwed later on if we mix it up with the reply to some other
+ # command. Hackish.
+ if msPendingInputReply is not None:
+ cbMsg2, sOpcode2, abPayload2 = self.oTransport.recvMsg(5000);
+ if cbMsg2 is not None:
+ reporter.log('taskExecEx: Out of order STDIN, got reply: %s, %s, %s [ignored]'
+ % (cbMsg2, sOpcode2, abPayload2));
+ msPendingInputReply = None;
+ else:
+ reporter.maybeErr(self.fErr, 'taskExecEx: Pending STDIN, no reply after 5 secs!');
+ self.fScrewedUpMsgState = True;
+
+ # Parse the exit status (True), abort (None) or do nothing (False).
+ if rc is True:
+ if sOpcode == 'PROC OK':
+ pass;
+ else:
+ rc = False;
+ # Do proper parsing some other day if needed:
+ # PROC TOK, PROC TOA, PROC DWN, PROC DOO,
+ # PROC NOK + rc, PROC SIG + sig, PROC ABD, FAILED.
+ if sOpcode == 'PROC DOO':
+ reporter.log('taskExecEx: PROC DOO[FUS]: %s' % (abPayload,));
+ elif sOpcode.startswith('PROC NOK'):
+ reporter.log('taskExecEx: PROC NOK: rcExit=%s' % (abPayload,));
+ elif abPayload and sOpcode.startswith('PROC '):
+ reporter.log('taskExecEx: %s payload=%s' % (sOpcode, abPayload,));
+
+ else:
+ if rc is None:
+ # Abort it.
+ reporter.log('taskExecEx: sending ABORT...');
+ rc = self.sendMsg('ABORT');
+ while rc is True:
+ cbMsg, sOpcode, abPayload = self.oTransport.recvMsg(30000);
+ if cbMsg is None:
+ reporter.maybeErr(self.fErr, 'taskExecEx: Pending ABORT, no reply after 30 secs!')
+ self.fScrewedUpMsgState = True;
+ break;
+ if sOpcode.startswith('PROC '):
+ reporter.log('taskExecEx: ABORT reply: %s, %s, %s [ignored]' % (cbMsg, sOpcode, abPayload));
+ break;
+ reporter.log('taskExecEx: ABORT in process, ignoring reply: %s, %s, %s' % (cbMsg, sOpcode, abPayload));
+ # Check that the connection is OK before looping.
+ if not self.oTransport.isConnectionOk():
+ self.oTransport.disconnect();
+ break;
+
+ # Fake response with the reason why we quit.
+ if sFailure is not None:
+ self.t3oReply = (0, 'EXECFAIL', sFailure);
+ rc = None;
+ else:
+ rc = None;
+
+ # Cleanup.
+ for o in (oStdIn, oStdOut, oStdErr, oTestPipe):
+ if o is not None and not utils.isString(o):
+ del o.uTxsClientCrc32; # pylint: disable=maybe-no-member
+ # Make sure all files are closed
+ o.close(); # pylint: disable=maybe-no-member
+ reporter.log('taskExecEx: returns %s' % (rc));
+ return rc;
+
+ #
+ # Admin tasks
+ #
+
+ def hlpRebootShutdownWaitForAck(self, sCmd):
+ """Wait for reboot/shutodwn ACK."""
+ rc = self.recvAckLogged(sCmd);
+ if rc is True:
+ # poll a little while for server to disconnect.
+ uMsStart = base.timestampMilli();
+ while self.oTransport.isConnectionOk() \
+ and base.timestampMilli() - uMsStart >= 5000:
+ if self.oTransport.isRecvPending(min(500, self.getMsLeft())):
+ break;
+ self.oTransport.disconnect();
+ return rc;
+
+ def taskReboot(self):
+ rc = self.sendMsg('REBOOT');
+ if rc is True:
+ rc = self.hlpRebootShutdownWaitForAck('REBOOT');
+ return rc;
+
+ def taskShutdown(self):
+ rc = self.sendMsg('SHUTDOWN');
+ if rc is True:
+ rc = self.hlpRebootShutdownWaitForAck('SHUTDOWN');
+ return rc;
+
+ #
+ # CD/DVD control tasks.
+ #
+
+ ## TODO
+
+ #
+ # File system tasks
+ #
+
+ def taskMkDir(self, sRemoteDir, fMode):
+ rc = self.sendMsg('MKDIR', (fMode, sRemoteDir));
+ if rc is True:
+ rc = self.recvAckLogged('MKDIR');
+ return rc;
+
+ def taskMkDirPath(self, sRemoteDir, fMode):
+ rc = self.sendMsg('MKDRPATH', (fMode, sRemoteDir));
+ if rc is True:
+ rc = self.recvAckLogged('MKDRPATH');
+ return rc;
+
+ def taskMkSymlink(self, sLinkTarget, sLink):
+ rc = self.sendMsg('MKSYMLNK', (sLinkTarget, sLink));
+ if rc is True:
+ rc = self.recvAckLogged('MKSYMLNK');
+ return rc;
+
+ def taskRmDir(self, sRemoteDir):
+ rc = self.sendMsg('RMDIR', (sRemoteDir,));
+ if rc is True:
+ rc = self.recvAckLogged('RMDIR');
+ return rc;
+
+ def taskRmFile(self, sRemoteFile):
+ rc = self.sendMsg('RMFILE', (sRemoteFile,));
+ if rc is True:
+ rc = self.recvAckLogged('RMFILE');
+ return rc;
+
+ def taskRmSymlink(self, sRemoteSymlink):
+ rc = self.sendMsg('RMSYMLNK', (sRemoteSymlink,));
+ if rc is True:
+ rc = self.recvAckLogged('RMSYMLNK');
+ return rc;
+
+ def taskRmTree(self, sRemoteTree):
+ rc = self.sendMsg('RMTREE', (sRemoteTree,));
+ if rc is True:
+ rc = self.recvAckLogged('RMTREE');
+ return rc;
+
+ def taskChMod(self, sRemotePath, fMode):
+ rc = self.sendMsg('CHMOD', (int(fMode), sRemotePath,));
+ if rc is True:
+ rc = self.recvAckLogged('CHMOD');
+ return rc;
+
+ def taskChOwn(self, sRemotePath, idUser, idGroup):
+ rc = self.sendMsg('CHOWN', (int(idUser), int(idGroup), sRemotePath,));
+ if rc is True:
+ rc = self.recvAckLogged('CHOWN');
+ return rc;
+
+ def taskIsDir(self, sRemoteDir):
+ rc = self.sendMsg('ISDIR', (sRemoteDir,));
+ if rc is True:
+ rc = self.recvTrueFalse('ISDIR');
+ return rc;
+
+ def taskIsFile(self, sRemoteFile):
+ rc = self.sendMsg('ISFILE', (sRemoteFile,));
+ if rc is True:
+ rc = self.recvTrueFalse('ISFILE');
+ return rc;
+
+ def taskIsSymlink(self, sRemoteSymlink):
+ rc = self.sendMsg('ISSYMLNK', (sRemoteSymlink,));
+ if rc is True:
+ rc = self.recvTrueFalse('ISSYMLNK');
+ return rc;
+
+ #def "STAT "
+ #def "LSTAT "
+ #def "LIST "
+
+ def taskCopyFile(self, sSrcFile, sDstFile, fMode, fFallbackOkay):
+ """ Copies a file within the remote from source to destination. """
+ _ = fFallbackOkay; # Not used yet.
+ # Note: If fMode is set to 0, it's up to the target OS' implementation with
+ # what a file mode the destination file gets created (i.e. via umask).
+ rc = self.sendMsg('CPFILE', (int(fMode), sSrcFile, sDstFile,));
+ if rc is True:
+ rc = self.recvAckLogged('CPFILE');
+ return rc;
+
+ def taskUploadFile(self, sLocalFile, sRemoteFile, fMode, fFallbackOkay):
+ #
+ # Open the local file (make sure it exist before bothering TXS) and
+ # tell TXS that we want to upload a file.
+ #
+ try:
+ oLocalFile = utils.openNoInherit(sLocalFile, 'rb');
+ except:
+ reporter.errorXcpt('taskUpload: failed to open "%s"' % (sLocalFile));
+ return False;
+
+ # Common cause with taskUploadStr
+ rc = self.taskUploadCommon(oLocalFile, sRemoteFile, fMode, fFallbackOkay);
+
+ # Cleanup.
+ oLocalFile.close();
+ return rc;
+
+ def taskUploadString(self, sContent, sRemoteFile, fMode, fFallbackOkay):
+ # Wrap sContent in a file like class.
+ class InStringFile(object): # pylint: disable=too-few-public-methods
+ def __init__(self, sContent):
+ self.sContent = sContent;
+ self.off = 0;
+
+ def read(self, cbMax):
+ cbLeft = len(self.sContent) - self.off;
+ if cbLeft == 0:
+ return "";
+ if cbLeft <= cbMax:
+ sRet = self.sContent[self.off:(self.off + cbLeft)];
+ else:
+ sRet = self.sContent[self.off:(self.off + cbMax)];
+ self.off = self.off + len(sRet);
+ return sRet;
+
+ oLocalString = InStringFile(sContent);
+ return self.taskUploadCommon(oLocalString, sRemoteFile, fMode, fFallbackOkay);
+
+ def taskUploadCommon(self, oLocalFile, sRemoteFile, fMode, fFallbackOkay):
+ """Common worker used by taskUploadFile and taskUploadString."""
+ #
+ # Command + ACK.
+ #
+ # Only used the new PUT2FILE command if we've got a non-zero mode mask.
+ # Fall back on the old command if the new one is not known by the TXS.
+ #
+ if fMode == 0:
+ rc = self.sendMsg('PUT FILE', (sRemoteFile,));
+ if rc is True:
+ rc = self.recvAckLogged('PUT FILE');
+ else:
+ rc = self.sendMsg('PUT2FILE', (fMode, sRemoteFile));
+ if rc is True:
+ rc = self.recvAck();
+ if rc is False:
+ reporter.maybeErr(self.fErr, 'recvAckLogged: PUT2FILE transport error');
+ elif rc is not True:
+ if rc[0] == 'UNKNOWN' and fFallbackOkay:
+ # Fallback:
+ rc = self.sendMsg('PUT FILE', (sRemoteFile,));
+ if rc is True:
+ rc = self.recvAckLogged('PUT FILE');
+ else:
+ reporter.maybeErr(self.fErr, 'recvAckLogged: PUT2FILE response was %s: %s' % (rc[0], rc[1],));
+ rc = False;
+ if rc is True:
+ #
+ # Push data packets until eof.
+ #
+ uMyCrc32 = zlib.crc32(b'');
+ while True:
+ # Read up to 64 KB of data.
+ try:
+ sRaw = oLocalFile.read(65536);
+ except:
+ rc = None;
+ break;
+
+ # Convert to array - this is silly!
+ abBuf = array.array('B');
+ if utils.isString(sRaw):
+ for i, _ in enumerate(sRaw):
+ abBuf.append(ord(sRaw[i]));
+ else:
+ abBuf.extend(sRaw);
+ sRaw = None;
+
+ # Update the file stream CRC and send it off.
+ uMyCrc32 = zlib.crc32(abBuf, uMyCrc32);
+ if not abBuf:
+ rc = self.sendMsg('DATA EOF', (long(uMyCrc32 & 0xffffffff), ));
+ else:
+ rc = self.sendMsg('DATA ', (long(uMyCrc32 & 0xffffffff), abBuf));
+ if rc is False:
+ break;
+
+ # Wait for the reply.
+ rc = self.recvAck();
+ if rc is not True:
+ if rc is False:
+ reporter.maybeErr(self.fErr, 'taskUpload: transport error waiting for ACK');
+ else:
+ reporter.maybeErr(self.fErr, 'taskUpload: DATA response was %s: %s' % (rc[0], rc[1]));
+ rc = False;
+ break;
+
+ # EOF?
+ if not abBuf:
+ break;
+
+ # Send ABORT on ACK and I/O errors.
+ if rc is None:
+ rc = self.sendMsg('ABORT');
+ if rc is True:
+ self.recvAckLogged('ABORT');
+ rc = False;
+ return rc;
+
+ def taskDownloadFile(self, sRemoteFile, sLocalFile):
+ try:
+ oLocalFile = utils.openNoInherit(sLocalFile, 'wb');
+ except:
+ reporter.errorXcpt('taskDownload: failed to open "%s"' % (sLocalFile));
+ return False;
+
+ rc = self.taskDownloadCommon(sRemoteFile, oLocalFile);
+
+ oLocalFile.close();
+ if rc is False:
+ try:
+ os.remove(sLocalFile);
+ except:
+ reporter.errorXcpt();
+ return rc;
+
+ def taskDownloadString(self, sRemoteFile, sEncoding = 'utf-8', fIgnoreEncodingErrors = True):
+ # Wrap sContent in a file like class.
+ class OutStringFile(object): # pylint: disable=too-few-public-methods
+ def __init__(self):
+ self.asContent = [];
+
+ def write(self, sBuf):
+ self.asContent.append(sBuf);
+ return None;
+
+ oLocalString = OutStringFile();
+ rc = self.taskDownloadCommon(sRemoteFile, oLocalString);
+ if rc is True:
+ rc = '';
+ for sBuf in oLocalString.asContent:
+ if hasattr(sBuf, 'decode'):
+ rc += sBuf.decode(sEncoding, 'ignore' if fIgnoreEncodingErrors else 'strict');
+ else:
+ rc += sBuf;
+ return rc;
+
+ def taskDownloadCommon(self, sRemoteFile, oLocalFile):
+ """Common worker for taskDownloadFile and taskDownloadString."""
+ rc = self.sendMsg('GET FILE', (sRemoteFile,))
+ if rc is True:
+ #
+ # Process data packets until eof.
+ #
+ uMyCrc32 = zlib.crc32(b'');
+ while rc is True:
+ cbMsg, sOpcode, abPayload = self.recvReply();
+ if cbMsg is None:
+ reporter.maybeErr(self.fErr, 'taskDownload got 3xNone from recvReply.');
+ rc = None;
+ break;
+
+ # Validate.
+ sOpcode = sOpcode.rstrip();
+ if sOpcode not in ('DATA', 'DATA EOF',):
+ reporter.maybeErr(self.fErr, 'taskDownload got a error reply: opcode="%s" details="%s"'
+ % (sOpcode, getSZ(abPayload, 0, "None")));
+ rc = False;
+ break;
+ if sOpcode == 'DATA' and len(abPayload) < 4:
+ reporter.maybeErr(self.fErr, 'taskDownload got a bad DATA packet: len=%u' % (len(abPayload)));
+ rc = None;
+ break;
+ if sOpcode == 'DATA EOF' and len(abPayload) != 4:
+ reporter.maybeErr(self.fErr, 'taskDownload got a bad EOF packet: len=%u' % (len(abPayload)));
+ rc = None;
+ break;
+
+ # Check the CRC (common for both packets).
+ uCrc32 = getU32(abPayload, 0);
+ if sOpcode == 'DATA':
+ uMyCrc32 = zlib.crc32(abPayload[4:], uMyCrc32);
+ if uCrc32 != (uMyCrc32 & 0xffffffff):
+ reporter.maybeErr(self.fErr, 'taskDownload got a bad CRC: mycrc=%s remotecrc=%s'
+ % (hex(uMyCrc32), hex(uCrc32)));
+ rc = None;
+ break;
+ if sOpcode == 'DATA EOF':
+ rc = self.sendMsg('ACK');
+ break;
+
+ # Finally, push the data to the file.
+ try:
+ if sys.version_info < (3, 9, 0):
+ # Removed since Python 3.9.
+ abData = abPayload[4:].tostring();
+ else:
+ abData = abPayload[4:].tobytes();
+ oLocalFile.write(abData);
+ except:
+ reporter.errorXcpt('I/O error writing to "%s"' % (sRemoteFile));
+ rc = None;
+ break;
+ rc = self.sendMsg('ACK');
+
+ # Send NACK on validation and I/O errors.
+ if rc is None:
+ rc = self.sendMsg('NACK');
+ rc = False;
+ return rc;
+
+ def taskPackFile(self, sRemoteFile, sRemoteSource):
+ rc = self.sendMsg('PKFILE', (sRemoteFile, sRemoteSource));
+ if rc is True:
+ rc = self.recvAckLogged('PKFILE');
+ return rc;
+
+ def taskUnpackFile(self, sRemoteFile, sRemoteDir):
+ rc = self.sendMsg('UNPKFILE', (sRemoteFile, sRemoteDir));
+ if rc is True:
+ rc = self.recvAckLogged('UNPKFILE');
+ return rc;
+
+ def taskExpandString(self, sString):
+ rc = self.sendMsg('EXP STR ', (sString,));
+ if rc is True:
+ rc = False;
+ cbMsg, sOpcode, abPayload = self.recvReply();
+ if cbMsg is not None:
+ sOpcode = sOpcode.strip();
+ if sOpcode == "STRING":
+ sStringExp = getSZ(abPayload, 0);
+ if sStringExp is not None:
+ rc = sStringExp;
+ else: # Also handles SHORTSTR reply (not enough space to store result).
+ reporter.maybeErr(self.fErr, 'taskExpandString got a bad reply: %s' % (sOpcode,));
+ else:
+ reporter.maybeErr(self.fErr, 'taskExpandString got 3xNone from recvReply.');
+ return rc;
+
+ # pylint: enable=missing-docstring
+
+
+ #
+ # Public methods - generic task queries
+ #
+
+ def isSuccess(self):
+ """Returns True if the task completed successfully, otherwise False."""
+ self.lockTask();
+ sStatus = self.sStatus;
+ oTaskRc = self.oTaskRc;
+ self.unlockTask();
+ if sStatus != "":
+ return False;
+ if oTaskRc is False or oTaskRc is None:
+ return False;
+ return True;
+
+ def getResult(self):
+ """
+ Returns the result of a completed task.
+ Returns None if not completed yet or no previous task.
+ """
+ self.lockTask();
+ sStatus = self.sStatus;
+ oTaskRc = self.oTaskRc;
+ self.unlockTask();
+ if sStatus != "":
+ return None;
+ return oTaskRc;
+
+ def getLastReply(self):
+ """
+ Returns the last reply three-tuple: cbMsg, sOpcode, abPayload.
+ Returns a None, None, None three-tuple if there was no last reply.
+ """
+ self.lockTask();
+ t3oReply = self.t3oReply;
+ self.unlockTask();
+ return t3oReply;
+
+ #
+ # Public methods - connection.
+ #
+
+ def asyncDisconnect(self, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a disconnect task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success and False on failure.
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "bye", self.taskBye);
+
+ def syncDisconnect(self, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncDisconnect, cMsTimeout, fIgnoreErrors);
+
+ def asyncVer(self, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a task for getting the TXS version information.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns the version string on success and False on failure.
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "ver", self.taskVer);
+
+ def syncVer(self, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncVer, cMsTimeout, fIgnoreErrors);
+
+ def asyncUuid(self, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a task for getting the TXS UUID.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns UUID string (in {}) on success and False on failure.
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "uuid", self.taskUuid);
+
+ def syncUuid(self, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncUuid, cMsTimeout, fIgnoreErrors);
+
+ #
+ # Public methods - execution.
+ #
+
+ def asyncExecEx(self, sExecName, asArgs = (), asAddEnv = (), # pylint: disable=too-many-arguments
+ oStdIn = None, oStdOut = None, oStdErr = None, oTestPipe = None,
+ sAsUser = "", cMsTimeout = 3600000, fIgnoreErrors = False):
+ """
+ Initiates a exec process task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True if the process exited normally with status code 0.
+ The task returns None if on failure prior to executing the process, and
+ False if the process exited with a different status or in an abnormal
+ manner. Both None and False are logged of course and further info can
+ also be obtained by getLastReply().
+
+ The oStdIn, oStdOut, oStdErr and oTestPipe specifiy how to deal with
+ these streams. If None, no special action is taken and the output goes
+ to where ever the TXS sends its output, and ditto for input.
+ - To send to / read from the bitbucket, pass '/dev/null'.
+ - To redirect to/from a file, just specify the remote filename.
+ - To append to a file use '>>' followed by the remote filename.
+ - To pipe the stream to/from the TXS, specify a file like
+ object. For StdIn a non-blocking read() method is required. For
+ the other a write() method is required. Watch out for deadlock
+ conditions between StdIn and StdOut/StdErr/TestPipe piping.
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "exec", self.taskExecEx,
+ (sExecName, long(0), asArgs, asAddEnv, oStdIn,
+ oStdOut, oStdErr, oTestPipe, sAsUser));
+
+ def syncExecEx(self, sExecName, asArgs = (), asAddEnv = (), # pylint: disable=too-many-arguments
+ oStdIn = '/dev/null', oStdOut = '/dev/null',
+ oStdErr = '/dev/null', oTestPipe = '/dev/null',
+ sAsUser = '', cMsTimeout = 3600000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncExecEx, sExecName, asArgs, asAddEnv, oStdIn, oStdOut, \
+ oStdErr, oTestPipe, sAsUser, cMsTimeout, fIgnoreErrors);
+
+ def asyncExec(self, sExecName, asArgs = (), asAddEnv = (), sAsUser = "", fWithTestPipe = True, sPrefix = '', \
+ cMsTimeout = 3600000, fIgnoreErrors = False):
+ """
+ Initiates a exec process test task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True if the process exited normally with status code 0.
+ The task returns None if on failure prior to executing the process, and
+ False if the process exited with a different status or in an abnormal
+ manner. Both None and False are logged of course and further info can
+ also be obtained by getLastReply().
+
+ Standard in is taken from /dev/null. While both standard output and
+ standard error goes directly to reporter.log(). The testpipe is piped
+ to reporter.xxxx.
+ """
+
+ sStdIn = '/dev/null';
+ oStdOut = reporter.FileWrapper('%sstdout' % sPrefix);
+ oStdErr = reporter.FileWrapper('%sstderr' % sPrefix);
+ if fWithTestPipe: oTestPipe = reporter.FileWrapperTestPipe();
+ else: oTestPipe = '/dev/null'; # pylint: disable=redefined-variable-type
+
+ return self.startTask(cMsTimeout, fIgnoreErrors, "exec", self.taskExecEx,
+ (sExecName, long(0), asArgs, asAddEnv, sStdIn, oStdOut, oStdErr, oTestPipe, sAsUser));
+
+ def syncExec(self, sExecName, asArgs = (), asAddEnv = (), sAsUser = '', fWithTestPipe = True, sPrefix = '',
+ cMsTimeout = 3600000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncExec, sExecName, asArgs, asAddEnv, sAsUser, fWithTestPipe, sPrefix, \
+ cMsTimeout, fIgnoreErrors);
+
+ #
+ # Public methods - system
+ #
+
+ def asyncReboot(self, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a reboot task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged). The
+ session will be disconnected on successful task completion.
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "reboot", self.taskReboot, ());
+
+ def syncReboot(self, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncReboot, cMsTimeout, fIgnoreErrors);
+
+ def asyncShutdown(self, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a shutdown task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "shutdown", self.taskShutdown, ());
+
+ def syncShutdown(self, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncShutdown, cMsTimeout, fIgnoreErrors);
+
+
+ #
+ # Public methods - file system
+ #
+
+ def asyncMkDir(self, sRemoteDir, fMode = 0o700, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a mkdir task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "mkDir", self.taskMkDir, (sRemoteDir, long(fMode)));
+
+ def syncMkDir(self, sRemoteDir, fMode = 0o700, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncMkDir, sRemoteDir, long(fMode), cMsTimeout, fIgnoreErrors);
+
+ def asyncMkDirPath(self, sRemoteDir, fMode = 0o700, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a mkdir -p task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "mkDirPath", self.taskMkDirPath, (sRemoteDir, long(fMode)));
+
+ def syncMkDirPath(self, sRemoteDir, fMode = 0o700, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncMkDirPath, sRemoteDir, long(fMode), cMsTimeout, fIgnoreErrors);
+
+ def asyncMkSymlink(self, sLinkTarget, sLink, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a symlink task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "mkSymlink", self.taskMkSymlink, (sLinkTarget, sLink));
+
+ def syncMkSymlink(self, sLinkTarget, sLink, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncMkSymlink, sLinkTarget, sLink, cMsTimeout, fIgnoreErrors);
+
+ def asyncRmDir(self, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a rmdir task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "rmDir", self.taskRmDir, (sRemoteDir,));
+
+ def syncRmDir(self, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncRmDir, sRemoteDir, cMsTimeout, fIgnoreErrors);
+
+ def asyncRmFile(self, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a rmfile task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "rmFile", self.taskRmFile, (sRemoteFile,));
+
+ def syncRmFile(self, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncRmFile, sRemoteFile, cMsTimeout, fIgnoreErrors);
+
+ def asyncRmSymlink(self, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a rmsymlink task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "rmSymlink", self.taskRmSymlink, (sRemoteSymlink,));
+
+ def syncRmSymlink(self, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncRmSymlink, sRemoteSymlink, cMsTimeout, fIgnoreErrors);
+
+ def asyncRmTree(self, sRemoteTree, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a rmtree task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "rmTree", self.taskRmTree, (sRemoteTree,));
+
+ def syncRmTree(self, sRemoteTree, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncRmTree, sRemoteTree, cMsTimeout, fIgnoreErrors);
+
+ def asyncChMod(self, sRemotePath, fMode, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a chmod task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "chMod", self.taskChMod, (sRemotePath, fMode));
+
+ def syncChMod(self, sRemotePath, fMode, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncChMod, sRemotePath, fMode, cMsTimeout, fIgnoreErrors);
+
+ def asyncChOwn(self, sRemotePath, idUser, idGroup, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a chown task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "chOwn", self.taskChOwn, (sRemotePath, idUser, idGroup));
+
+ def syncChOwn(self, sRemotePath, idUser, idGroup, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncChMod, sRemotePath, idUser, idGroup, cMsTimeout, fIgnoreErrors);
+
+ def asyncIsDir(self, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a is-dir query task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True if it's a directory, False if it isn't, and
+ None on error (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "isDir", self.taskIsDir, (sRemoteDir,));
+
+ def syncIsDir(self, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncIsDir, sRemoteDir, cMsTimeout, fIgnoreErrors);
+
+ def asyncIsFile(self, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a is-file query task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True if it's a file, False if it isn't, and None on
+ error (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "isFile", self.taskIsFile, (sRemoteFile,));
+
+ def syncIsFile(self, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncIsFile, sRemoteFile, cMsTimeout, fIgnoreErrors);
+
+ def asyncIsSymlink(self, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a is-symbolic-link query task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True if it's a symbolic linke, False if it isn't, and
+ None on error (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "isSymlink", self.taskIsSymlink, (sRemoteSymlink,));
+
+ def syncIsSymlink(self, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncIsSymlink, sRemoteSymlink, cMsTimeout, fIgnoreErrors);
+
+ #def "STAT "
+ #def "LSTAT "
+ #def "LIST "
+
+ @staticmethod
+ def calcFileXferTimeout(cbFile):
+ """
+ Calculates a reasonable timeout for an upload/download given the file size.
+
+ Returns timeout in milliseconds.
+ """
+ return 30000 + cbFile / 32; # 32 KiB/s (picked out of thin air)
+
+ @staticmethod
+ def calcUploadTimeout(sLocalFile):
+ """
+ Calculates a reasonable timeout for an upload given the file (will stat it).
+
+ Returns timeout in milliseconds.
+ """
+ try: cbFile = os.path.getsize(sLocalFile);
+ except: cbFile = 1024*1024;
+ return Session.calcFileXferTimeout(cbFile);
+
+ def asyncCopyFile(self, sSrcFile, sDstFile,
+ fMode = 0, fFallbackOkay = True, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a file copying task on the remote.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "cpfile",
+ self.taskCopyFile, (sSrcFile, sDstFile, fMode, fFallbackOkay));
+
+ def syncCopyFile(self, sSrcFile, sDstFile, fMode = 0, cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncCopyFile, sSrcFile, sDstFile, fMode, cMsTimeout, fIgnoreErrors);
+
+ def asyncUploadFile(self, sLocalFile, sRemoteFile,
+ fMode = 0, fFallbackOkay = True, cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a download query task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "upload",
+ self.taskUploadFile, (sLocalFile, sRemoteFile, fMode, fFallbackOkay));
+
+ def syncUploadFile(self, sLocalFile, sRemoteFile, fMode = 0, fFallbackOkay = True, cMsTimeout = 0, fIgnoreErrors = False):
+ """Synchronous version."""
+ if cMsTimeout <= 0:
+ cMsTimeout = self.calcUploadTimeout(sLocalFile);
+ return self.asyncToSync(self.asyncUploadFile, sLocalFile, sRemoteFile, fMode, fFallbackOkay, cMsTimeout, fIgnoreErrors);
+
+ def asyncUploadString(self, sContent, sRemoteFile,
+ fMode = 0, fFallbackOkay = True, cMsTimeout = 0, fIgnoreErrors = False):
+ """
+ Initiates a upload string task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ if cMsTimeout <= 0:
+ cMsTimeout = self.calcFileXferTimeout(len(sContent));
+ return self.startTask(cMsTimeout, fIgnoreErrors, "uploadString",
+ self.taskUploadString, (sContent, sRemoteFile, fMode, fFallbackOkay));
+
+ def syncUploadString(self, sContent, sRemoteFile, fMode = 0, fFallbackOkay = True, cMsTimeout = 0, fIgnoreErrors = False):
+ """Synchronous version."""
+ if cMsTimeout <= 0:
+ cMsTimeout = self.calcFileXferTimeout(len(sContent));
+ return self.asyncToSync(self.asyncUploadString, sContent, sRemoteFile, fMode, fFallbackOkay, cMsTimeout, fIgnoreErrors);
+
+ def asyncDownloadFile(self, sRemoteFile, sLocalFile, cMsTimeout = 120000, fIgnoreErrors = False):
+ """
+ Initiates a download file task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "downloadFile", self.taskDownloadFile, (sRemoteFile, sLocalFile));
+
+ def syncDownloadFile(self, sRemoteFile, sLocalFile, cMsTimeout = 120000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncDownloadFile, sRemoteFile, sLocalFile, cMsTimeout, fIgnoreErrors);
+
+ def asyncDownloadString(self, sRemoteFile, sEncoding = 'utf-8', fIgnoreEncodingErrors = True,
+ cMsTimeout = 30000, fIgnoreErrors = False):
+ """
+ Initiates a download string task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns a byte string on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "downloadString",
+ self.taskDownloadString, (sRemoteFile, sEncoding, fIgnoreEncodingErrors));
+
+ def syncDownloadString(self, sRemoteFile, sEncoding = 'utf-8', fIgnoreEncodingErrors = True,
+ cMsTimeout = 30000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncDownloadString, sRemoteFile, sEncoding, fIgnoreEncodingErrors,
+ cMsTimeout, fIgnoreErrors);
+
+ def asyncPackFile(self, sRemoteFile, sRemoteSource, cMsTimeout = 120000, fIgnoreErrors = False):
+ """
+ Initiates a packing file/directory task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "packFile", self.taskPackFile,
+ (sRemoteFile, sRemoteSource));
+
+ def syncPackFile(self, sRemoteFile, sRemoteSource, cMsTimeout = 120000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncPackFile, sRemoteFile, sRemoteSource, cMsTimeout, fIgnoreErrors);
+
+ def asyncUnpackFile(self, sRemoteFile, sRemoteDir, cMsTimeout = 120000, fIgnoreErrors = False):
+ """
+ Initiates a unpack file task.
+
+ Returns True on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "unpackFile", self.taskUnpackFile,
+ (sRemoteFile, sRemoteDir));
+
+ def syncUnpackFile(self, sRemoteFile, sRemoteDir, cMsTimeout = 120000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncUnpackFile, sRemoteFile, sRemoteDir, cMsTimeout, fIgnoreErrors);
+
+ def asyncExpandString(self, sString, cMsTimeout = 120000, fIgnoreErrors = False):
+ """
+ Initiates an expand string task.
+
+ Returns expanded string on success, False on failure (logged).
+
+ The task returns True on success, False on failure (logged).
+ """
+ return self.startTask(cMsTimeout, fIgnoreErrors, "expandString",
+ self.taskExpandString, (sString,));
+
+ def syncExpandString(self, sString, cMsTimeout = 120000, fIgnoreErrors = False):
+ """Synchronous version."""
+ return self.asyncToSync(self.asyncExpandString, sString, cMsTimeout, fIgnoreErrors);
+
+
+class TransportTcp(TransportBase):
+ """
+ TCP transport layer for the TXS client session class.
+ """
+
+ def __init__(self, sHostname, uPort, fReversedSetup):
+ """
+ Save the parameters. The session will call us back to make the
+ connection later on its worker thread.
+ """
+ TransportBase.__init__(self, utils.getCallerName());
+ self.sHostname = sHostname;
+ self.fReversedSetup = fReversedSetup;
+ self.uPort = uPort if uPort is not None else 5042 if fReversedSetup is False else 5048;
+ self.oSocket = None;
+ self.oWakeupW = None;
+ self.oWakeupR = None;
+ self.fConnectCanceled = False;
+ self.fIsConnecting = False;
+ self.oCv = threading.Condition();
+ self.abReadAhead = array.array('B');
+
+ def toString(self):
+ return '<%s sHostname=%s, fReversedSetup=%s, uPort=%s, oSocket=%s,'\
+ ' fConnectCanceled=%s, fIsConnecting=%s, oCv=%s, abReadAhead=%s>' \
+ % (TransportBase.toString(self), self.sHostname, self.fReversedSetup, self.uPort, self.oSocket,
+ self.fConnectCanceled, self.fIsConnecting, self.oCv, self.abReadAhead);
+
+ def __isInProgressXcpt(self, oXcpt):
+ """ In progress exception? """
+ try:
+ if isinstance(oXcpt, socket.error):
+ try:
+ if oXcpt.errno == errno.EINPROGRESS:
+ return True;
+ except: pass;
+ # Windows?
+ try:
+ if oXcpt.errno == errno.EWOULDBLOCK:
+ return True;
+ except: pass;
+ except:
+ pass;
+ return False;
+
+ def __isWouldBlockXcpt(self, oXcpt):
+ """ Would block exception? """
+ try:
+ if isinstance(oXcpt, socket.error):
+ try:
+ if oXcpt.errno == errno.EWOULDBLOCK:
+ return True;
+ except: pass;
+ try:
+ if oXcpt.errno == errno.EAGAIN:
+ return True;
+ except: pass;
+ except:
+ pass;
+ return False;
+
+ def __isConnectionReset(self, oXcpt):
+ """ Connection reset by Peer or others. """
+ try:
+ if isinstance(oXcpt, socket.error):
+ try:
+ if oXcpt.errno == errno.ECONNRESET:
+ return True;
+ except: pass;
+ try:
+ if oXcpt.errno == errno.ENETRESET:
+ return True;
+ except: pass;
+ except:
+ pass;
+ return False;
+
+ def _closeWakeupSockets(self):
+ """ Closes the wakup sockets. Caller should own the CV. """
+ oWakeupR = self.oWakeupR;
+ self.oWakeupR = None;
+ if oWakeupR is not None:
+ oWakeupR.close();
+
+ oWakeupW = self.oWakeupW;
+ self.oWakeupW = None;
+ if oWakeupW is not None:
+ oWakeupW.close();
+
+ return None;
+
+ def cancelConnect(self):
+ # This is bad stuff.
+ self.oCv.acquire();
+ reporter.log2('TransportTcp::cancelConnect: fIsConnecting=%s oSocket=%s' % (self.fIsConnecting, self.oSocket));
+ self.fConnectCanceled = True;
+ if self.fIsConnecting:
+ oSocket = self.oSocket;
+ self.oSocket = None;
+ if oSocket is not None:
+ reporter.log2('TransportTcp::cancelConnect: closing the socket');
+ oSocket.close();
+
+ oWakeupW = self.oWakeupW;
+ self.oWakeupW = None;
+ if oWakeupW is not None:
+ reporter.log2('TransportTcp::cancelConnect: wakeup call');
+ try: oWakeupW.send(b'cancelled!\n');
+ except: reporter.logXcpt();
+ try: oWakeupW.shutdown(socket.SHUT_WR);
+ except: reporter.logXcpt();
+ oWakeupW.close();
+ self.oCv.release();
+
+ def _connectAsServer(self, oSocket, oWakeupR, cMsTimeout):
+ """ Connects to the TXS server as server, i.e. the reversed setup. """
+ assert(self.fReversedSetup);
+
+ reporter.log2('TransportTcp::_connectAsServer: oSocket=%s, cMsTimeout=%u' % (oSocket, cMsTimeout));
+
+ # Workaround for bind() failure...
+ try:
+ oSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1);
+ except:
+ reporter.errorXcpt('socket.listen(1) failed');
+ return None;
+
+ # Bind the socket and make it listen.
+ try:
+ oSocket.bind((self.sHostname, self.uPort));
+ except:
+ reporter.errorXcpt('socket.bind((%s,%s)) failed' % (self.sHostname, self.uPort));
+ return None;
+ try:
+ oSocket.listen(1);
+ except:
+ reporter.errorXcpt('socket.listen(1) failed');
+ return None;
+
+ # Accept connections.
+ oClientSocket = None;
+ tClientAddr = None;
+ try:
+ (oClientSocket, tClientAddr) = oSocket.accept();
+ except socket.error as e:
+ if not self.__isInProgressXcpt(e):
+ raise;
+
+ # Do the actual waiting.
+ reporter.log2('TransportTcp::accept: operation in progress (%s)...' % (e,));
+ try:
+ select.select([oSocket, oWakeupR], [], [oSocket, oWakeupR], cMsTimeout / 1000.0);
+ except socket.error as oXctp:
+ if oXctp.errno != errno.EBADF or not self.fConnectCanceled:
+ raise;
+ reporter.log('socket.select() on accept was canceled');
+ return None;
+ except:
+ reporter.logXcpt('socket.select() on accept');
+
+ # Try accept again.
+ try:
+ (oClientSocket, tClientAddr) = oSocket.accept();
+ except socket.error as oXcpt:
+ if not self.__isInProgressXcpt(e):
+ if oXcpt.errno != errno.EBADF or not self.fConnectCanceled:
+ raise;
+ reporter.log('socket.accept() was canceled');
+ return None;
+ reporter.log('socket.accept() timed out');
+ return False;
+ except:
+ reporter.errorXcpt('socket.accept() failed');
+ return None;
+ except:
+ reporter.errorXcpt('socket.accept() failed');
+ return None;
+
+ # Store the connected socket and throw away the server socket.
+ self.oCv.acquire();
+ if not self.fConnectCanceled:
+ self.oSocket.close();
+ self.oSocket = oClientSocket;
+ self.sHostname = "%s:%s" % (tClientAddr[0], tClientAddr[1]);
+ self.oCv.release();
+ return True;
+
+ def _connectAsClient(self, oSocket, oWakeupR, cMsTimeout):
+ """ Connects to the TXS server as client. """
+ assert(not self.fReversedSetup);
+
+ # Connect w/ timeouts.
+ rc = None;
+ try:
+ oSocket.connect((self.sHostname, self.uPort));
+ rc = True;
+ except socket.error as oXcpt:
+ iRc = oXcpt.errno;
+ if self.__isInProgressXcpt(oXcpt):
+ # Do the actual waiting.
+ reporter.log2('TransportTcp::connect: operation in progress (%s)...' % (oXcpt,));
+ try:
+ ttRc = select.select([oWakeupR], [oSocket], [oSocket, oWakeupR], cMsTimeout / 1000.0);
+ if len(ttRc[1]) + len(ttRc[2]) == 0:
+ raise socket.error(errno.ETIMEDOUT, 'select timed out');
+ iRc = oSocket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR);
+ rc = iRc == 0;
+ except socket.error as oXcpt2:
+ iRc = oXcpt2.errno;
+ except:
+ iRc = -42;
+ reporter.fatalXcpt('socket.select() on connect failed');
+
+ if rc is True:
+ pass;
+ elif iRc in (errno.ECONNREFUSED, errno.EHOSTUNREACH, errno.EINTR, errno.ENETDOWN, errno.ENETUNREACH, errno.ETIMEDOUT):
+ rc = False; # try again.
+ else:
+ if iRc != errno.EBADF or not self.fConnectCanceled:
+ reporter.fatalXcpt('socket.connect((%s,%s)) failed; iRc=%s' % (self.sHostname, self.uPort, iRc));
+ reporter.log2('TransportTcp::connect: rc=%s iRc=%s' % (rc, iRc));
+ except:
+ reporter.fatalXcpt('socket.connect((%s,%s)) failed' % (self.sHostname, self.uPort));
+ return rc;
+
+
+ def connect(self, cMsTimeout):
+ # Create a non-blocking socket.
+ reporter.log2('TransportTcp::connect: cMsTimeout=%s sHostname=%s uPort=%s' % (cMsTimeout, self.sHostname, self.uPort));
+ try:
+ oSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0);
+ except:
+ reporter.fatalXcpt('socket.socket() failed');
+ return None;
+ try:
+ oSocket.setblocking(0);
+ except:
+ oSocket.close();
+ reporter.fatalXcpt('socket.socket() failed');
+ return None;
+
+ # Create wakeup socket pair for unix (select doesn't wake up on socket close on Linux).
+ oWakeupR = None;
+ oWakeupW = None;
+ if hasattr(socket, 'socketpair'):
+ try: (oWakeupR, oWakeupW) = socket.socketpair(); # pylint: disable=no-member
+ except: reporter.logXcpt('socket.socketpair() failed');
+
+ # Update the state.
+ self.oCv.acquire();
+ rc = None;
+ if not self.fConnectCanceled:
+ self.oSocket = oSocket;
+ self.oWakeupW = oWakeupW;
+ self.oWakeupR = oWakeupR;
+ self.fIsConnecting = True;
+ self.oCv.release();
+
+ # Try connect.
+ if oWakeupR is None:
+ oWakeupR = oSocket; # Avoid select failure.
+ if self.fReversedSetup:
+ rc = self._connectAsServer(oSocket, oWakeupR, cMsTimeout);
+ else:
+ rc = self._connectAsClient(oSocket, oWakeupR, cMsTimeout);
+ oSocket = None;
+
+ # Update the state and cleanup on failure/cancel.
+ self.oCv.acquire();
+ if rc is True and self.fConnectCanceled:
+ rc = False;
+ self.fIsConnecting = False;
+
+ if rc is not True:
+ if self.oSocket is not None:
+ self.oSocket.close();
+ self.oSocket = None;
+ self._closeWakeupSockets();
+ self.oCv.release();
+
+ reporter.log2('TransportTcp::connect: returning %s' % (rc,));
+ return rc;
+
+ def disconnect(self, fQuiet = False):
+ if self.oSocket is not None:
+ self.abReadAhead = array.array('B');
+
+ # Try a shutting down the socket gracefully (draining it).
+ try:
+ self.oSocket.shutdown(socket.SHUT_WR);
+ except:
+ if not fQuiet:
+ reporter.error('shutdown(SHUT_WR)');
+ try:
+ self.oSocket.setblocking(0); # just in case it's not set.
+ sData = "1";
+ while sData:
+ sData = self.oSocket.recv(16384);
+ except:
+ pass;
+
+ # Close it.
+ self.oCv.acquire();
+ try: self.oSocket.setblocking(1);
+ except: pass;
+ self.oSocket.close();
+ self.oSocket = None;
+ else:
+ self.oCv.acquire();
+ self._closeWakeupSockets();
+ self.oCv.release();
+
+ def sendBytes(self, abBuf, cMsTimeout):
+ if self.oSocket is None:
+ reporter.error('TransportTcp.sendBytes: No connection.');
+ return False;
+
+ # Try send it all.
+ try:
+ cbSent = self.oSocket.send(abBuf);
+ if cbSent == len(abBuf):
+ return True;
+ except Exception as oXcpt:
+ if not self.__isWouldBlockXcpt(oXcpt):
+ reporter.errorXcpt('TranportTcp.sendBytes: %s bytes' % (len(abBuf)));
+ return False;
+ cbSent = 0;
+
+ # Do a timed send.
+ msStart = base.timestampMilli();
+ while True:
+ cMsElapsed = base.timestampMilli() - msStart;
+ if cMsElapsed > cMsTimeout:
+ reporter.error('TranportTcp.sendBytes: %s bytes timed out (1)' % (len(abBuf)));
+ break;
+
+ # wait.
+ try:
+ ttRc = select.select([], [self.oSocket], [self.oSocket], (cMsTimeout - cMsElapsed) / 1000.0);
+ if ttRc[2] and not ttRc[1]:
+ reporter.error('TranportTcp.sendBytes: select returned with exception');
+ break;
+ if not ttRc[1]:
+ reporter.error('TranportTcp.sendBytes: %s bytes timed out (2)' % (len(abBuf)));
+ break;
+ except:
+ reporter.errorXcpt('TranportTcp.sendBytes: select failed');
+ break;
+
+ # Try send more.
+ try:
+ cbSent += self.oSocket.send(abBuf[cbSent:]);
+ if cbSent == len(abBuf):
+ return True;
+ except Exception as oXcpt:
+ if not self.__isWouldBlockXcpt(oXcpt):
+ reporter.errorXcpt('TranportTcp.sendBytes: %s bytes' % (len(abBuf)));
+ break;
+
+ return False;
+
+ def __returnReadAheadBytes(self, cb):
+ """ Internal worker for recvBytes. """
+ assert(len(self.abReadAhead) >= cb);
+ abRet = self.abReadAhead[:cb];
+ self.abReadAhead = self.abReadAhead[cb:];
+ return abRet;
+
+ def recvBytes(self, cb, cMsTimeout, fNoDataOk):
+ if self.oSocket is None:
+ reporter.error('TransportTcp.recvBytes(%s,%s): No connection.' % (cb, cMsTimeout));
+ return None;
+
+ # Try read in some more data without bothering with timeout handling first.
+ if len(self.abReadAhead) < cb:
+ try:
+ abBuf = self.oSocket.recv(cb - len(self.abReadAhead));
+ if abBuf:
+ self.abReadAhead.extend(array.array('B', abBuf));
+ except Exception as oXcpt:
+ if not self.__isWouldBlockXcpt(oXcpt):
+ reporter.errorXcpt('TranportTcp.recvBytes: 0/%s bytes' % (cb,));
+ return None;
+
+ if len(self.abReadAhead) >= cb:
+ return self.__returnReadAheadBytes(cb);
+
+ # Timeout loop.
+ msStart = base.timestampMilli();
+ while True:
+ cMsElapsed = base.timestampMilli() - msStart;
+ if cMsElapsed > cMsTimeout:
+ if not fNoDataOk or self.abReadAhead:
+ reporter.error('TranportTcp.recvBytes: %s/%s bytes timed out (1)' % (len(self.abReadAhead), cb));
+ break;
+
+ # Wait.
+ try:
+ ttRc = select.select([self.oSocket], [], [self.oSocket], (cMsTimeout - cMsElapsed) / 1000.0);
+ if ttRc[2] and not ttRc[0]:
+ reporter.error('TranportTcp.recvBytes: select returned with exception');
+ break;
+ if not ttRc[0]:
+ if not fNoDataOk or self.abReadAhead:
+ reporter.error('TranportTcp.recvBytes: %s/%s bytes timed out (2) fNoDataOk=%s'
+ % (len(self.abReadAhead), cb, fNoDataOk));
+ break;
+ except:
+ reporter.errorXcpt('TranportTcp.recvBytes: select failed');
+ break;
+
+ # Try read more.
+ try:
+ abBuf = self.oSocket.recv(cb - len(self.abReadAhead));
+ if not abBuf:
+ reporter.error('TranportTcp.recvBytes: %s/%s bytes (%s) - connection has been shut down'
+ % (len(self.abReadAhead), cb, fNoDataOk));
+ self.disconnect();
+ return None;
+
+ self.abReadAhead.extend(array.array('B', abBuf));
+
+ except Exception as oXcpt:
+ reporter.log('recv => exception %s' % (oXcpt,));
+ if not self.__isWouldBlockXcpt(oXcpt):
+ if not fNoDataOk or not self.__isConnectionReset(oXcpt) or self.abReadAhead:
+ reporter.errorXcpt('TranportTcp.recvBytes: %s/%s bytes (%s)' % (len(self.abReadAhead), cb, fNoDataOk));
+ break;
+
+ # Done?
+ if len(self.abReadAhead) >= cb:
+ return self.__returnReadAheadBytes(cb);
+
+ #reporter.log('recv => None len(self.abReadAhead) -> %d' % (len(self.abReadAhead), ));
+ return None;
+
+ def isConnectionOk(self):
+ if self.oSocket is None:
+ return False;
+ try:
+ ttRc = select.select([], [], [self.oSocket], 0.0);
+ if ttRc[2]:
+ return False;
+
+ self.oSocket.send(array.array('B')); # send zero bytes.
+ except:
+ return False;
+ return True;
+
+ def isRecvPending(self, cMsTimeout = 0):
+ try:
+ ttRc = select.select([self.oSocket], [], [], cMsTimeout / 1000.0);
+ if not ttRc[0]:
+ return False;
+ except:
+ pass;
+ return True;
+
+
+def openTcpSession(cMsTimeout, sHostname, uPort = None, fReversedSetup = False, cMsIdleFudge = 0, fnProcessEvents = None):
+ """
+ Opens a connection to a Test Execution Service via TCP, given its name.
+
+ The optional fnProcessEvents callback should be set to vbox.processPendingEvents
+ or similar.
+ """
+ reporter.log2('openTcpSession(%s, %s, %s, %s, %s)' %
+ (cMsTimeout, sHostname, uPort, fReversedSetup, cMsIdleFudge));
+ try:
+ oTransport = TransportTcp(sHostname, uPort, fReversedSetup);
+ oSession = Session(oTransport, cMsTimeout, cMsIdleFudge, fnProcessEvents = fnProcessEvents);
+ except:
+ reporter.errorXcpt(None, 15);
+ return None;
+ return oSession;
+
+
+def tryOpenTcpSession(cMsTimeout, sHostname, uPort = None, fReversedSetup = False, cMsIdleFudge = 0, fnProcessEvents = None):
+ """
+ Tries to open a connection to a Test Execution Service via TCP, given its name.
+
+ This differs from openTcpSession in that it won't log a connection failure
+ as an error.
+ """
+ try:
+ oTransport = TransportTcp(sHostname, uPort, fReversedSetup);
+ oSession = Session(oTransport, cMsTimeout, cMsIdleFudge, fTryConnect = True, fnProcessEvents = fnProcessEvents);
+ except:
+ reporter.errorXcpt(None, 15);
+ return None;
+ return oSession;
diff --git a/src/VBox/ValidationKit/testdriver/vbox.py b/src/VBox/ValidationKit/testdriver/vbox.py
new file mode 100755
index 00000000..0958e5a7
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/vbox.py
@@ -0,0 +1,4581 @@
+# -*- coding: utf-8 -*-
+# $Id: vbox.py $
+# pylint: disable=too-many-lines
+
+"""
+VirtualBox Specific base testdriver.
+"""
+
+__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: 155472 $"
+
+# pylint: disable=unnecessary-semicolon
+
+# Standard Python imports.
+import datetime
+import os
+import platform
+import re;
+import sys
+import threading
+import time
+import traceback
+
+# Figure out where the validation kit lives and make sure it's in the path.
+try: __file__
+except: __file__ = sys.argv[0];
+g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)));
+if g_ksValidationKitDir not in sys.path:
+ sys.path.append(g_ksValidationKitDir);
+
+# Validation Kit imports.
+from common import utils;
+from testdriver import base;
+from testdriver import btresolver;
+from testdriver import reporter;
+from testdriver import vboxcon;
+from testdriver import vboxtestvms;
+
+# Python 3 hacks:
+if sys.version_info[0] >= 3:
+ xrange = range; # pylint: disable=redefined-builtin,invalid-name
+ long = int; # pylint: disable=redefined-builtin,invalid-name
+
+#
+# Exception and Error Unification Hacks.
+# Note! This is pretty gross stuff. Be warned!
+# TODO: Find better ways of doing these things, preferrably in vboxapi.
+#
+
+ComException = None; # pylint: disable=invalid-name
+__fnComExceptionGetAttr__ = None; # pylint: disable=invalid-name
+
+def __MyDefaultGetAttr(oSelf, sName):
+ """ __getattribute__/__getattr__ default fake."""
+ try:
+ oAttr = oSelf.__dict__[sName];
+ except:
+ oAttr = dir(oSelf)[sName];
+ return oAttr;
+
+def __MyComExceptionGetAttr(oSelf, sName):
+ """ ComException.__getattr__ wrapper - both XPCOM and COM. """
+ try:
+ oAttr = __fnComExceptionGetAttr__(oSelf, sName);
+ except AttributeError:
+ if platform.system() == 'Windows':
+ if sName == 'errno':
+ oAttr = __fnComExceptionGetAttr__(oSelf, 'hresult');
+ elif sName == 'msg':
+ oAttr = __fnComExceptionGetAttr__(oSelf, 'strerror');
+ else:
+ raise;
+ else:
+ if sName == 'hresult':
+ oAttr = __fnComExceptionGetAttr__(oSelf, 'errno');
+ elif sName == 'strerror':
+ oAttr = __fnComExceptionGetAttr__(oSelf, 'msg');
+ elif sName == 'excepinfo':
+ oAttr = None;
+ elif sName == 'argerror':
+ oAttr = None;
+ else:
+ raise;
+ #print '__MyComExceptionGetAttr(,%s) -> "%s"' % (sName, oAttr);
+ return oAttr;
+
+def __deployExceptionHacks__(oNativeComExceptionClass):
+ """
+ Deploys the exception and error hacks that helps unifying COM and XPCOM
+ exceptions and errors.
+ """
+ global ComException # pylint: disable=invalid-name
+ global __fnComExceptionGetAttr__ # pylint: disable=invalid-name
+
+ # Hook up our attribute getter for the exception class (ASSUMES new-style).
+ if __fnComExceptionGetAttr__ is None:
+ try:
+ __fnComExceptionGetAttr__ = getattr(oNativeComExceptionClass, '__getattr__');
+ except:
+ try:
+ __fnComExceptionGetAttr__ = getattr(oNativeComExceptionClass, '__getattribute__');
+ except:
+ __fnComExceptionGetAttr__ = __MyDefaultGetAttr;
+ setattr(oNativeComExceptionClass, '__getattr__', __MyComExceptionGetAttr)
+
+ # Make the modified classes accessible (are there better ways to do this?)
+ ComException = oNativeComExceptionClass
+ return None;
+
+
+
+#
+# Utility functions.
+#
+
+def isIpAddrValid(sIpAddr):
+ """
+ Checks if a IPv4 address looks valid. This will return false for
+ localhost and similar.
+ Returns True / False.
+ """
+ if sIpAddr is None: return False;
+ if len(sIpAddr.split('.')) != 4: return False;
+ if sIpAddr.endswith('.0'): return False;
+ if sIpAddr.endswith('.255'): return False;
+ if sIpAddr.startswith('127.'): return False;
+ if sIpAddr.startswith('169.254.'): return False;
+ if sIpAddr.startswith('192.0.2.'): return False;
+ if sIpAddr.startswith('224.0.0.'): return False;
+ return True;
+
+def stringifyErrorInfo(oErrInfo):
+ """
+ Stringifies the error information in a IVirtualBoxErrorInfo object.
+
+ Returns string with error info.
+ """
+ try:
+ rc = oErrInfo.resultCode;
+ sText = oErrInfo.text;
+ sIid = oErrInfo.interfaceID;
+ sComponent = oErrInfo.component;
+ except:
+ sRet = 'bad error object (%s)?' % (oErrInfo,);
+ traceback.print_exc();
+ else:
+ sRet = 'rc=%s text="%s" IID=%s component=%s' % (ComError.toString(rc), sText, sIid, sComponent);
+ return sRet;
+
+def reportError(oErr, sText):
+ """
+ Report a VirtualBox error on oErr. oErr can be IVirtualBoxErrorInfo
+ or IProgress. Anything else is ignored.
+
+ Returns the same a reporter.error().
+ """
+ try:
+ oErrObj = oErr.errorInfo; # IProgress.
+ except:
+ oErrObj = oErr;
+ reporter.error(sText);
+ return reporter.error(stringifyErrorInfo(oErrObj));
+
+def formatComOrXpComException(oType, oXcpt):
+ """
+ Callback installed with the reporter to better format COM exceptions.
+ Similar to format_exception_only, only it returns None if not interested.
+ """
+ _ = oType;
+ oVBoxMgr = vboxcon.goHackModuleClass.oVBoxMgr;
+ if oVBoxMgr is None:
+ return None;
+ if not oVBoxMgr.xcptIsOurXcptKind(oXcpt): # pylint: disable=not-callable
+ return None;
+
+ if platform.system() == 'Windows':
+ hrc = oXcpt.hresult;
+ if hrc == ComError.DISP_E_EXCEPTION and oXcpt.excepinfo is not None and len(oXcpt.excepinfo) > 5:
+ hrc = oXcpt.excepinfo[5];
+ sWhere = oXcpt.excepinfo[1];
+ sMsg = oXcpt.excepinfo[2];
+ else:
+ sWhere = None;
+ sMsg = oXcpt.strerror;
+ else:
+ hrc = oXcpt.errno;
+ sWhere = None;
+ sMsg = oXcpt.msg;
+
+ sHrc = oVBoxMgr.xcptToString(hrc); # pylint: disable=not-callable
+ if sHrc.find('(') < 0:
+ sHrc = '%s (%#x)' % (sHrc, hrc & 0xffffffff,);
+
+ asRet = ['COM-Xcpt: %s' % (sHrc,)];
+ if sMsg and sWhere:
+ asRet.append('--------- %s: %s' % (sWhere, sMsg,));
+ elif sMsg:
+ asRet.append('--------- %s' % (sMsg,));
+ return asRet;
+ #if sMsg and sWhere:
+ # return ['COM-Xcpt: %s - %s: %s' % (sHrc, sWhere, sMsg,)];
+ #if sMsg:
+ # return ['COM-Xcpt: %s - %s' % (sHrc, sMsg,)];
+ #return ['COM-Xcpt: %s' % (sHrc,)];
+
+#
+# Classes
+#
+
+class ComError(object):
+ """
+ Unified COM and XPCOM status code repository.
+ This works more like a module than a class since it's replacing a module.
+ """
+
+ # The VBOX_E_XXX bits:
+ __VBOX_E_BASE = -2135228416;
+ VBOX_E_OBJECT_NOT_FOUND = __VBOX_E_BASE + 1;
+ VBOX_E_INVALID_VM_STATE = __VBOX_E_BASE + 2;
+ VBOX_E_VM_ERROR = __VBOX_E_BASE + 3;
+ VBOX_E_FILE_ERROR = __VBOX_E_BASE + 4;
+ VBOX_E_IPRT_ERROR = __VBOX_E_BASE + 5;
+ VBOX_E_PDM_ERROR = __VBOX_E_BASE + 6;
+ VBOX_E_INVALID_OBJECT_STATE = __VBOX_E_BASE + 7;
+ VBOX_E_HOST_ERROR = __VBOX_E_BASE + 8;
+ VBOX_E_NOT_SUPPORTED = __VBOX_E_BASE + 9;
+ VBOX_E_XML_ERROR = __VBOX_E_BASE + 10;
+ VBOX_E_INVALID_SESSION_STATE = __VBOX_E_BASE + 11;
+ VBOX_E_OBJECT_IN_USE = __VBOX_E_BASE + 12;
+ VBOX_E_DONT_CALL_AGAIN = __VBOX_E_BASE + 13;
+
+ # Reverse lookup table.
+ dDecimalToConst = {}; # pylint: disable=invalid-name
+
+ def __init__(self):
+ raise base.GenError('No instances, please');
+
+ @staticmethod
+ def copyErrors(oNativeComErrorClass):
+ """
+ Copy all error codes from oNativeComErrorClass to this class and
+ install compatability mappings.
+ """
+
+ # First, add the VBOX_E_XXX constants to dDecimalToConst.
+ for sAttr in dir(ComError):
+ if sAttr.startswith('VBOX_E'):
+ oAttr = getattr(ComError, sAttr);
+ ComError.dDecimalToConst[oAttr] = sAttr;
+
+ # Copy all error codes from oNativeComErrorClass to this class.
+ for sAttr in dir(oNativeComErrorClass):
+ if sAttr[0].isupper():
+ oAttr = getattr(oNativeComErrorClass, sAttr);
+ setattr(ComError, sAttr, oAttr);
+ if isinstance(oAttr, int):
+ ComError.dDecimalToConst[oAttr] = sAttr;
+
+ # Install mappings to the other platform.
+ if platform.system() == 'Windows':
+ ComError.NS_OK = ComError.S_OK;
+ ComError.NS_ERROR_FAILURE = ComError.E_FAIL;
+ ComError.NS_ERROR_ABORT = ComError.E_ABORT;
+ ComError.NS_ERROR_NULL_POINTER = ComError.E_POINTER;
+ ComError.NS_ERROR_NO_INTERFACE = ComError.E_NOINTERFACE;
+ ComError.NS_ERROR_INVALID_ARG = ComError.E_INVALIDARG;
+ ComError.NS_ERROR_OUT_OF_MEMORY = ComError.E_OUTOFMEMORY;
+ ComError.NS_ERROR_NOT_IMPLEMENTED = ComError.E_NOTIMPL;
+ ComError.NS_ERROR_UNEXPECTED = ComError.E_UNEXPECTED;
+ else:
+ ComError.E_ACCESSDENIED = -2147024891; # see VBox/com/defs.h
+ ComError.S_OK = ComError.NS_OK;
+ ComError.E_FAIL = ComError.NS_ERROR_FAILURE;
+ ComError.E_ABORT = ComError.NS_ERROR_ABORT;
+ ComError.E_POINTER = ComError.NS_ERROR_NULL_POINTER;
+ ComError.E_NOINTERFACE = ComError.NS_ERROR_NO_INTERFACE;
+ ComError.E_INVALIDARG = ComError.NS_ERROR_INVALID_ARG;
+ ComError.E_OUTOFMEMORY = ComError.NS_ERROR_OUT_OF_MEMORY;
+ ComError.E_NOTIMPL = ComError.NS_ERROR_NOT_IMPLEMENTED;
+ ComError.E_UNEXPECTED = ComError.NS_ERROR_UNEXPECTED;
+ ComError.DISP_E_EXCEPTION = -2147352567; # For COM compatability only.
+ return True;
+
+ @staticmethod
+ def getXcptResult(oXcpt):
+ """
+ Gets the result code for an exception.
+ Returns COM status code (or E_UNEXPECTED).
+ """
+ if platform.system() == 'Windows':
+ # The DISP_E_EXCEPTION + excptinfo fun needs checking up, only
+ # empirical info on it so far.
+ try:
+ hrXcpt = oXcpt.hresult;
+ except AttributeError:
+ hrXcpt = ComError.E_UNEXPECTED;
+ if hrXcpt == ComError.DISP_E_EXCEPTION and oXcpt.excepinfo is not None:
+ hrXcpt = oXcpt.excepinfo[5];
+ else:
+ try:
+ hrXcpt = oXcpt.errno;
+ except AttributeError:
+ hrXcpt = ComError.E_UNEXPECTED;
+ return hrXcpt;
+
+ @staticmethod
+ def equal(oXcpt, hr):
+ """
+ Checks if the ComException e is not equal to the COM status code hr.
+ This takes DISP_E_EXCEPTION & excepinfo into account.
+
+ This method can be used with any Exception derivate, however it will
+ only return True for classes similar to the two ComException variants.
+ """
+ if platform.system() == 'Windows':
+ # The DISP_E_EXCEPTION + excptinfo fun needs checking up, only
+ # empirical info on it so far.
+ try:
+ hrXcpt = oXcpt.hresult;
+ except AttributeError:
+ return False;
+ if hrXcpt == ComError.DISP_E_EXCEPTION and oXcpt.excepinfo is not None:
+ hrXcpt = oXcpt.excepinfo[5];
+ else:
+ try:
+ hrXcpt = oXcpt.errno;
+ except AttributeError:
+ return False;
+ return hrXcpt == hr;
+
+ @staticmethod
+ def notEqual(oXcpt, hr):
+ """
+ Checks if the ComException e is not equal to the COM status code hr.
+ See equal() for more details.
+ """
+ return not ComError.equal(oXcpt, hr)
+
+ @staticmethod
+ def toString(hr):
+ """
+ Converts the specified COM status code to a string.
+ """
+ try:
+ sStr = ComError.dDecimalToConst[int(hr)];
+ except KeyError:
+ hrLong = long(hr);
+ sStr = '%#x (%d)' % (hrLong, hrLong);
+ return sStr;
+
+
+class Build(object): # pylint: disable=too-few-public-methods
+ """
+ A VirtualBox build.
+
+ Note! After dropping the installation of VBox from this code and instead
+ realizing that with the vboxinstall.py wrapper driver, this class is
+ of much less importance and contains unnecessary bits and pieces.
+ """
+
+ def __init__(self, oDriver, strInstallPath):
+ """
+ Construct a build object from a build file name and/or install path.
+ """
+ # Initialize all members first.
+ self.oDriver = oDriver;
+ self.sInstallPath = strInstallPath;
+ self.sSdkPath = None;
+ self.sSrcRoot = None;
+ self.sKind = None;
+ self.sDesignation = None;
+ self.sType = None;
+ self.sOs = None;
+ self.sArch = None;
+ self.sGuestAdditionsIso = None;
+
+ # Figure out the values as best we can.
+ if strInstallPath is None:
+ #
+ # Both parameters are None, which means we're falling back on a
+ # build in the development tree.
+ #
+ self.sKind = "development";
+
+ if self.sType is None:
+ self.sType = os.environ.get("KBUILD_TYPE", "release");
+ if self.sOs is None:
+ self.sOs = os.environ.get("KBUILD_TARGET", oDriver.sHost);
+ if self.sArch is None:
+ self.sArch = os.environ.get("KBUILD_TARGET_ARCH", oDriver.sHostArch);
+
+ sOut = os.path.join('out', self.sOs + '.' + self.sArch, self.sType);
+ sSearch = os.environ.get('VBOX_TD_DEV_TREE', os.path.dirname(__file__)); # Env.var. for older trees or testboxscript.
+ sCandidat = None;
+ for i in range(0, 10): # pylint: disable=unused-variable
+ sBldDir = os.path.join(sSearch, sOut);
+ if os.path.isdir(sBldDir):
+ sCandidat = os.path.join(sBldDir, 'bin', 'VBoxSVC' + base.exeSuff());
+ if os.path.isfile(sCandidat):
+ self.sSdkPath = os.path.join(sBldDir, 'bin/sdk');
+ break;
+ sCandidat = os.path.join(sBldDir, 'dist/VirtualBox.app/Contents/MacOS/VBoxSVC');
+ if os.path.isfile(sCandidat):
+ self.sSdkPath = os.path.join(sBldDir, 'dist/sdk');
+ break;
+ sSearch = os.path.abspath(os.path.join(sSearch, '..'));
+ if sCandidat is None or not os.path.isfile(sCandidat):
+ raise base.GenError();
+ self.sInstallPath = os.path.abspath(os.path.dirname(sCandidat));
+ self.sSrcRoot = os.path.abspath(sSearch);
+
+ self.sDesignation = os.environ.get('TEST_BUILD_DESIGNATION', None);
+ if self.sDesignation is None:
+ try:
+ oFile = utils.openNoInherit(os.path.join(self.sSrcRoot, sOut, 'revision.kmk'), 'r');
+ except:
+ pass;
+ else:
+ s = oFile.readline();
+ oFile.close();
+ oMatch = re.search("VBOX_SVN_REV=(\\d+)", s);
+ if oMatch is not None:
+ self.sDesignation = oMatch.group(1);
+
+ if self.sDesignation is None:
+ self.sDesignation = 'XXXXX'
+ else:
+ #
+ # We've been pointed to an existing installation, this could be
+ # in the out dir of a svn checkout, untarred VBoxAll or a real
+ # installation directory.
+ #
+ self.sKind = "preinstalled";
+ self.sType = "release";
+ self.sOs = oDriver.sHost;
+ self.sArch = oDriver.sHostArch;
+ self.sInstallPath = os.path.abspath(strInstallPath);
+ self.sSdkPath = os.path.join(self.sInstallPath, 'sdk');
+ self.sSrcRoot = None;
+ self.sDesignation = os.environ.get('TEST_BUILD_DESIGNATION', 'XXXXX');
+ ## @todo Much more work is required here.
+
+ # Try Determine the build type.
+ sVBoxManage = os.path.join(self.sInstallPath, 'VBoxManage' + base.exeSuff());
+ if os.path.isfile(sVBoxManage):
+ try:
+ (iExit, sStdOut, _) = utils.processOutputUnchecked([sVBoxManage, '--dump-build-type']);
+ sStdOut = sStdOut.strip();
+ if iExit == 0 and sStdOut in ('release', 'debug', 'strict', 'dbgopt', 'asan'):
+ self.sType = sStdOut;
+ reporter.log('Build: Detected build type: %s' % (self.sType));
+ else:
+ reporter.log('Build: --dump-build-type -> iExit=%u sStdOut=%s' % (iExit, sStdOut,));
+ except:
+ reporter.logXcpt('Build: Running "%s --dump-build-type" failed!' % (sVBoxManage,));
+ else:
+ reporter.log3('Build: sVBoxManage=%s not found' % (sVBoxManage,));
+
+ # Do some checks.
+ sVMMR0 = os.path.join(self.sInstallPath, 'VMMR0.r0');
+ if not os.path.isfile(sVMMR0) and utils.getHostOs() == 'solaris': # solaris is special.
+ sVMMR0 = os.path.join(self.sInstallPath, 'amd64' if utils.getHostArch() == 'amd64' else 'i386', 'VMMR0.r0');
+ if not os.path.isfile(sVMMR0):
+ raise base.GenError('%s is missing' % (sVMMR0,));
+
+ # Guest additions location is different on windows for some _stupid_ reason.
+ if self.sOs == 'win' and self.sKind != 'development':
+ self.sGuestAdditionsIso = '%s/VBoxGuestAdditions.iso' % (self.sInstallPath,);
+ elif self.sOs == 'darwin':
+ self.sGuestAdditionsIso = '%s/VBoxGuestAdditions.iso' % (self.sInstallPath,);
+ elif self.sOs == 'solaris':
+ self.sGuestAdditionsIso = '%s/VBoxGuestAdditions.iso' % (self.sInstallPath,);
+ else:
+ self.sGuestAdditionsIso = '%s/additions/VBoxGuestAdditions.iso' % (self.sInstallPath,);
+
+ # __init__ end;
+
+ def isDevBuild(self):
+ """ Returns True if it's development build (kind), otherwise False. """
+ return self.sKind == 'development';
+
+
+class EventHandlerBase(object):
+ """
+ Base class for both Console and VirtualBox event handlers.
+ """
+
+ def __init__(self, dArgs, fpApiVer, sName = None):
+ self.oVBoxMgr = dArgs['oVBoxMgr'];
+ self.oEventSrc = dArgs['oEventSrc']; # Console/VirtualBox for < 3.3
+ self.oListener = dArgs['oListener'];
+ self.fPassive = self.oListener is not None;
+ self.sName = sName
+ self.fShutdown = False;
+ self.oThread = None;
+ self.fpApiVer = fpApiVer;
+ self.dEventNo2Name = {};
+ for sKey, iValue in self.oVBoxMgr.constants.all_values('VBoxEventType').items():
+ self.dEventNo2Name[iValue] = sKey;
+
+ def threadForPassiveMode(self):
+ """
+ The thread procedure for the event processing thread.
+ """
+ assert self.fPassive is not None;
+ while not self.fShutdown:
+ try:
+ oEvt = self.oEventSrc.getEvent(self.oListener, 500);
+ except:
+ if not self.oVBoxMgr.xcptIsDeadInterface(): reporter.logXcpt();
+ else: reporter.log('threadForPassiveMode/%s: interface croaked (ignored)' % (self.sName,));
+ break;
+ if oEvt:
+ self.handleEvent(oEvt);
+ if not self.fShutdown:
+ try:
+ self.oEventSrc.eventProcessed(self.oListener, oEvt);
+ except:
+ reporter.logXcpt();
+ break;
+ self.unregister(fWaitForThread = False);
+ return None;
+
+ def startThreadForPassiveMode(self):
+ """
+ Called when working in passive mode.
+ """
+ self.oThread = threading.Thread(target = self.threadForPassiveMode, \
+ args=(), name=('PAS-%s' % (self.sName,)));
+ self.oThread.setDaemon(True); # pylint: disable=deprecated-method
+ self.oThread.start();
+ return None;
+
+ def unregister(self, fWaitForThread = True):
+ """
+ Unregister the event handler.
+ """
+ fRc = False;
+ if not self.fShutdown:
+ self.fShutdown = True;
+
+ if self.oEventSrc is not None:
+ if self.fpApiVer < 3.3:
+ try:
+ self.oEventSrc.unregisterCallback(self.oListener);
+ fRc = True;
+ except:
+ reporter.errorXcpt('unregisterCallback failed on %s' % (self.oListener,));
+ else:
+ try:
+ self.oEventSrc.unregisterListener(self.oListener);
+ fRc = True;
+ except:
+ if self.oVBoxMgr.xcptIsDeadInterface():
+ reporter.log('unregisterListener failed on %s because of dead interface (%s)'
+ % (self.oListener, self.oVBoxMgr.xcptToString(),));
+ else:
+ reporter.errorXcpt('unregisterListener failed on %s' % (self.oListener,));
+
+ if self.oThread is not None \
+ and self.oThread != threading.current_thread():
+ self.oThread.join();
+ self.oThread = None;
+
+ _ = fWaitForThread;
+ return fRc;
+
+ def handleEvent(self, oEvt):
+ """
+ Compatibility wrapper that child classes implement.
+ """
+ _ = oEvt;
+ return None;
+
+ @staticmethod
+ def registerDerivedEventHandler(oVBoxMgr, fpApiVer, oSubClass, dArgsCopy, # pylint: disable=too-many-arguments
+ oSrcParent, sSrcParentNm, sICallbackNm,
+ fMustSucceed = True, sLogSuffix = '', aenmEvents = None):
+ """
+ Registers the callback / event listener.
+ """
+ dArgsCopy['oVBoxMgr'] = oVBoxMgr;
+ dArgsCopy['oListener'] = None;
+ if fpApiVer < 3.3:
+ dArgsCopy['oEventSrc'] = oSrcParent;
+ try:
+ oRet = oVBoxMgr.createCallback(sICallbackNm, oSubClass, dArgsCopy);
+ except:
+ reporter.errorXcpt('%s::registerCallback(%s) failed%s' % (sSrcParentNm, oRet, sLogSuffix));
+ else:
+ try:
+ oSrcParent.registerCallback(oRet);
+ return oRet;
+ except Exception as oXcpt:
+ if fMustSucceed or ComError.notEqual(oXcpt, ComError.E_UNEXPECTED):
+ reporter.errorXcpt('%s::registerCallback(%s)%s' % (sSrcParentNm, oRet, sLogSuffix));
+ else:
+ #
+ # Scalable event handling introduced in VBox 4.0.
+ #
+ fPassive = sys.platform == 'win32'; # or webservices.
+
+ if not aenmEvents:
+ aenmEvents = (vboxcon.VBoxEventType_Any,);
+
+ try:
+ oEventSrc = oSrcParent.eventSource;
+ dArgsCopy['oEventSrc'] = oEventSrc;
+ if not fPassive:
+ oListener = oRet = oVBoxMgr.createListener(oSubClass, dArgsCopy);
+ else:
+ oListener = oEventSrc.createListener();
+ dArgsCopy['oListener'] = oListener;
+ oRet = oSubClass(dArgsCopy);
+ except:
+ reporter.errorXcpt('%s::eventSource.createListener(%s) failed%s' % (sSrcParentNm, oListener, sLogSuffix));
+ else:
+ try:
+ oEventSrc.registerListener(oListener, aenmEvents, not fPassive);
+ except Exception as oXcpt:
+ if fMustSucceed or ComError.notEqual(oXcpt, ComError.E_UNEXPECTED):
+ reporter.errorXcpt('%s::eventSource.registerListener(%s) failed%s'
+ % (sSrcParentNm, oListener, sLogSuffix));
+ else:
+ if not fPassive:
+ if sys.platform == 'win32':
+ from win32com.server.util import unwrap # pylint: disable=import-error
+ oRet = unwrap(oRet);
+ oRet.oListener = oListener;
+ else:
+ oRet.startThreadForPassiveMode();
+ return oRet;
+ return None;
+
+
+
+
+class ConsoleEventHandlerBase(EventHandlerBase):
+ """
+ Base class for handling IConsole events.
+
+ The class has IConsoleCallback (<=3.2) compatible callback methods which
+ the user can override as needed.
+
+ Note! This class must not inherit from object or we'll get type errors in VBoxPython.
+ """
+ def __init__(self, dArgs, sName = None):
+ self.oSession = dArgs['oSession'];
+ self.oConsole = dArgs['oConsole'];
+ if sName is None:
+ sName = self.oSession.sName;
+ EventHandlerBase.__init__(self, dArgs, self.oSession.fpApiVer, sName);
+
+
+ # pylint: disable=missing-docstring,too-many-arguments,unused-argument
+ def onMousePointerShapeChange(self, fVisible, fAlpha, xHot, yHot, cx, cy, abShape):
+ reporter.log2('onMousePointerShapeChange/%s' % (self.sName));
+ def onMouseCapabilityChange(self, fSupportsAbsolute, *aArgs): # Extra argument was added in 3.2.
+ reporter.log2('onMouseCapabilityChange/%s' % (self.sName));
+ def onKeyboardLedsChange(self, fNumLock, fCapsLock, fScrollLock):
+ reporter.log2('onKeyboardLedsChange/%s' % (self.sName));
+ def onStateChange(self, eState):
+ reporter.log2('onStateChange/%s' % (self.sName));
+ def onAdditionsStateChange(self):
+ reporter.log2('onAdditionsStateChange/%s' % (self.sName));
+ def onNetworkAdapterChange(self, oNic):
+ reporter.log2('onNetworkAdapterChange/%s' % (self.sName));
+ def onSerialPortChange(self, oPort):
+ reporter.log2('onSerialPortChange/%s' % (self.sName));
+ def onParallelPortChange(self, oPort):
+ reporter.log2('onParallelPortChange/%s' % (self.sName));
+ def onStorageControllerChange(self):
+ reporter.log2('onStorageControllerChange/%s' % (self.sName));
+ def onMediumChange(self, attachment):
+ reporter.log2('onMediumChange/%s' % (self.sName));
+ def onCPUChange(self, iCpu, fAdd):
+ reporter.log2('onCPUChange/%s' % (self.sName));
+ def onVRDPServerChange(self):
+ reporter.log2('onVRDPServerChange/%s' % (self.sName));
+ def onRemoteDisplayInfoChange(self):
+ reporter.log2('onRemoteDisplayInfoChange/%s' % (self.sName));
+ def onUSBControllerChange(self):
+ reporter.log2('onUSBControllerChange/%s' % (self.sName));
+ def onUSBDeviceStateChange(self, oDevice, fAttached, oError):
+ reporter.log2('onUSBDeviceStateChange/%s' % (self.sName));
+ def onSharedFolderChange(self, fGlobal):
+ reporter.log2('onSharedFolderChange/%s' % (self.sName));
+ def onRuntimeError(self, fFatal, sErrId, sMessage):
+ reporter.log2('onRuntimeError/%s' % (self.sName));
+ def onCanShowWindow(self):
+ reporter.log2('onCanShowWindow/%s' % (self.sName));
+ return True
+ def onShowWindow(self):
+ reporter.log2('onShowWindow/%s' % (self.sName));
+ return None;
+ # pylint: enable=missing-docstring,too-many-arguments,unused-argument
+
+ def handleEvent(self, oEvt):
+ """
+ Compatibility wrapper.
+ """
+ try:
+ oEvtBase = self.oVBoxMgr.queryInterface(oEvt, 'IEvent');
+ eType = oEvtBase.type;
+ except:
+ reporter.logXcpt();
+ return None;
+ if eType == vboxcon.VBoxEventType_OnRuntimeError:
+ try:
+ oEvtIt = self.oVBoxMgr.queryInterface(oEvtBase, 'IRuntimeErrorEvent');
+ return self.onRuntimeError(oEvtIt.fatal, oEvtIt.id, oEvtIt.message)
+ except:
+ reporter.logXcpt();
+ ## @todo implement the other events.
+ try:
+ if eType not in (vboxcon.VBoxEventType_OnMousePointerShapeChanged,
+ vboxcon.VBoxEventType_OnCursorPositionChanged):
+ if eType in self.dEventNo2Name:
+ reporter.log2('%s(%s)/%s' % (self.dEventNo2Name[eType], str(eType), self.sName));
+ else:
+ reporter.log2('%s/%s' % (str(eType), self.sName));
+ except AttributeError: # Handle older VBox versions which don't have a specific event.
+ pass;
+ return None;
+
+
+class VirtualBoxEventHandlerBase(EventHandlerBase):
+ """
+ Base class for handling IVirtualBox events.
+
+ The class has IConsoleCallback (<=3.2) compatible callback methods which
+ the user can override as needed.
+
+ Note! This class must not inherit from object or we'll get type errors in VBoxPython.
+ """
+ def __init__(self, dArgs, sName = "emanon"):
+ self.oVBoxMgr = dArgs['oVBoxMgr'];
+ self.oVBox = dArgs['oVBox'];
+ EventHandlerBase.__init__(self, dArgs, self.oVBox.fpApiVer, sName);
+
+ # pylint: disable=missing-docstring,unused-argument
+ def onMachineStateChange(self, sMachineId, eState):
+ pass;
+ def onMachineDataChange(self, sMachineId):
+ pass;
+ def onExtraDataCanChange(self, sMachineId, sKey, sValue):
+ # The COM bridge does tuples differently. Not very funny if you ask me... ;-)
+ if self.oVBoxMgr.type == 'MSCOM':
+ return '', 0, True;
+ return True, ''
+ def onExtraDataChange(self, sMachineId, sKey, sValue):
+ pass;
+ def onMediumRegistered(self, sMediumId, eMediumType, fRegistered):
+ pass;
+ def onMachineRegistered(self, sMachineId, fRegistered):
+ pass;
+ def onSessionStateChange(self, sMachineId, eState):
+ pass;
+ def onSnapshotTaken(self, sMachineId, sSnapshotId):
+ pass;
+ def onSnapshotDiscarded(self, sMachineId, sSnapshotId):
+ pass;
+ def onSnapshotChange(self, sMachineId, sSnapshotId):
+ pass;
+ def onGuestPropertyChange(self, sMachineId, sName, sValue, sFlags, fWasDeleted):
+ pass;
+ # pylint: enable=missing-docstring,unused-argument
+
+ def handleEvent(self, oEvt):
+ """
+ Compatibility wrapper.
+ """
+ try:
+ oEvtBase = self.oVBoxMgr.queryInterface(oEvt, 'IEvent');
+ eType = oEvtBase.type;
+ except:
+ reporter.logXcpt();
+ return None;
+ if eType == vboxcon.VBoxEventType_OnMachineStateChanged:
+ try:
+ oEvtIt = self.oVBoxMgr.queryInterface(oEvtBase, 'IMachineStateChangedEvent');
+ return self.onMachineStateChange(oEvtIt.machineId, oEvtIt.state)
+ except:
+ reporter.logXcpt();
+ elif eType == vboxcon.VBoxEventType_OnGuestPropertyChanged:
+ try:
+ oEvtIt = self.oVBoxMgr.queryInterface(oEvtBase, 'IGuestPropertyChangedEvent');
+ if hasattr(oEvtIt, 'fWasDeleted'): # Since 7.0 we have a dedicated flag
+ fWasDeleted = oEvtIt.fWasDeleted;
+ else:
+ fWasDeleted = False; # Don't indicate deletion here -- there can be empty guest properties.
+ return self.onGuestPropertyChange(oEvtIt.machineId, oEvtIt.name, oEvtIt.value, oEvtIt.flags, fWasDeleted);
+ except:
+ reporter.logXcpt();
+ ## @todo implement the other events.
+ if eType in self.dEventNo2Name:
+ reporter.log2('%s(%s)/%s' % (self.dEventNo2Name[eType], str(eType), self.sName));
+ else:
+ reporter.log2('%s/%s' % (str(eType), self.sName));
+ return None;
+
+
+class SessionConsoleEventHandler(ConsoleEventHandlerBase):
+ """
+ For catching machine state changes and waking up the task machinery at that point.
+ """
+ def __init__(self, dArgs):
+ ConsoleEventHandlerBase.__init__(self, dArgs);
+
+ def onMachineStateChange(self, sMachineId, eState): # pylint: disable=unused-argument
+ """ Just interrupt the wait loop here so it can check again. """
+ _ = sMachineId; _ = eState;
+ self.oVBoxMgr.interruptWaitEvents();
+
+ def onRuntimeError(self, fFatal, sErrId, sMessage):
+ reporter.log('onRuntimeError/%s: fFatal=%d sErrId=%s sMessage=%s' % (self.sName, fFatal, sErrId, sMessage));
+ oSession = self.oSession;
+ if oSession is not None: # paranoia
+ if sErrId == 'HostMemoryLow':
+ oSession.signalHostMemoryLow();
+ if sys.platform == 'win32':
+ from testdriver import winbase;
+ winbase.logMemoryStats();
+ oSession.signalTask();
+ self.oVBoxMgr.interruptWaitEvents();
+
+
+
+class TestDriver(base.TestDriver): # pylint: disable=too-many-instance-attributes
+ """
+ This is the VirtualBox test driver.
+ """
+
+ def __init__(self):
+ base.TestDriver.__init__(self);
+ self.fImportedVBoxApi = False;
+ self.fpApiVer = 3.2;
+ self.uRevision = 0;
+ self.uApiRevision = 0;
+ self.oBuild = None;
+ self.oVBoxMgr = None;
+ self.oVBox = None;
+ self.aoRemoteSessions = [];
+ self.aoVMs = []; ## @todo not sure if this list will be of any use.
+ self.oTestVmManager = vboxtestvms.TestVmManager(self.sResourcePath);
+ self.oTestVmSet = vboxtestvms.TestVmSet();
+ self.sSessionTypeDef = 'headless';
+ self.sSessionType = self.sSessionTypeDef;
+ self.fEnableVrdp = True;
+ self.uVrdpBasePortDef = 6000;
+ self.uVrdpBasePort = self.uVrdpBasePortDef;
+ self.sDefBridgedNic = None;
+ self.fUseDefaultSvc = False;
+ self.sLogSelfGroups = '';
+ self.sLogSelfFlags = 'time';
+ self.sLogSelfDest = '';
+ self.sLogSessionGroups = '';
+ self.sLogSessionFlags = 'time';
+ self.sLogSessionDest = '';
+ self.sLogSvcGroups = '';
+ self.sLogSvcFlags = 'time';
+ self.sLogSvcDest = '';
+ self.sSelfLogFile = None;
+ self.sSessionLogFile = None;
+ self.sVBoxSvcLogFile = None;
+ self.oVBoxSvcProcess = None;
+ self.sVBoxSvcPidFile = None;
+ self.fVBoxSvcInDebugger = False;
+ self.fVBoxSvcWaitForDebugger = False;
+ self.sVBoxValidationKit = None;
+ self.sVBoxValidationKitIso = None;
+ self.sVBoxBootSectors = None;
+ self.fAlwaysUploadLogs = False;
+ self.fAlwaysUploadScreenshots = False;
+ self.fAlwaysUploadRecordings = False; # Only upload recording files on failure by default.
+ self.fEnableDebugger = True;
+ self.fVmNoTerminate = False; # Whether to skip exit handling and tearing down the VMs.
+ self.adRecordingFiles = [];
+ self.fRecordingEnabled = False; # Don't record by default (yet).
+ self.fRecordingAudio = False; # Don't record audio by default.
+ self.cSecsRecordingMax = 0; # No recording time limit in seconds.
+ self.cMbRecordingMax = 195; # The test manager web server has a configured upload limit of 200 MiBs.
+ ## @todo Can we query the configured value here
+ # (via `from testmanager import config`)?
+
+ # Drop LD_PRELOAD and enable memory leak detection in LSAN_OPTIONS from vboxinstall.py
+ # before doing build detection. This is a little crude and inflexible...
+ if 'LD_PRELOAD' in os.environ:
+ del os.environ['LD_PRELOAD'];
+ if 'LSAN_OPTIONS' in os.environ:
+ asLSanOptions = os.environ['LSAN_OPTIONS'].split(':');
+ try: asLSanOptions.remove('detect_leaks=0');
+ except: pass;
+ if asLSanOptions: os.environ['LSAN_OPTIONS'] = ':'.join(asLSanOptions);
+ else: del os.environ['LSAN_OPTIONS'];
+
+ # Quietly detect build and validation kit.
+ self._detectBuild(False);
+ self._detectValidationKit(False);
+
+ # Make sure all debug logs goes to the scratch area unless
+ # specified otherwise (more of this later on).
+ if 'VBOX_LOG_DEST' not in os.environ:
+ os.environ['VBOX_LOG_DEST'] = 'nodeny dir=%s' % (self.sScratchPath);
+
+
+ def _detectBuild(self, fQuiet = False):
+ """
+ This is used internally to try figure a locally installed build when
+ running tests manually.
+ """
+ if self.oBuild is not None:
+ return True;
+
+ # Try dev build first since that's where I'll be using it first...
+ if True is True: # pylint: disable=comparison-with-itself
+ try:
+ self.oBuild = Build(self, None);
+ reporter.log('VBox %s build at %s (%s).'
+ % (self.oBuild.sType, self.oBuild.sInstallPath, self.oBuild.sDesignation,));
+ return True;
+ except base.GenError:
+ pass;
+
+ # Try default installation locations.
+ if self.sHost == 'win':
+ sProgFiles = os.environ.get('ProgramFiles', 'C:\\Program Files');
+ asLocs = [
+ os.path.join(sProgFiles, 'Oracle', 'VirtualBox'),
+ os.path.join(sProgFiles, 'OracleVM', 'VirtualBox'),
+ os.path.join(sProgFiles, 'Sun', 'VirtualBox'),
+ ];
+ elif self.sHost == 'solaris':
+ asLocs = [ '/opt/VirtualBox-3.2', '/opt/VirtualBox-3.1', '/opt/VirtualBox-3.0', '/opt/VirtualBox' ];
+ elif self.sHost == 'darwin':
+ asLocs = [ '/Applications/VirtualBox.app/Contents/MacOS' ];
+ elif self.sHost == 'linux':
+ asLocs = [ '/opt/VirtualBox-3.2', '/opt/VirtualBox-3.1', '/opt/VirtualBox-3.0', '/opt/VirtualBox' ];
+ else:
+ asLocs = [ '/opt/VirtualBox' ];
+ if 'VBOX_INSTALL_PATH' in os.environ:
+ asLocs.insert(0, os.environ['VBOX_INSTALL_PATH']);
+
+ for sLoc in asLocs:
+ try:
+ self.oBuild = Build(self, sLoc);
+ reporter.log('VBox %s build at %s (%s).'
+ % (self.oBuild.sType, self.oBuild.sInstallPath, self.oBuild.sDesignation,));
+ return True;
+ except base.GenError:
+ pass;
+
+ if not fQuiet:
+ reporter.error('failed to find VirtualBox installation');
+ return False;
+
+ def _detectValidationKit(self, fQuiet = False):
+ """
+ This is used internally by the constructor to try locate an unzipped
+ VBox Validation Kit somewhere in the immediate proximity.
+ """
+ if self.sVBoxValidationKit is not None:
+ return True;
+
+ #
+ # Normally it's found where we're running from, which is the same as
+ # the script directly on the testboxes.
+ #
+ asCandidates = [self.sScriptPath, ];
+ if g_ksValidationKitDir not in asCandidates:
+ asCandidates.append(g_ksValidationKitDir);
+ if os.getcwd() not in asCandidates:
+ asCandidates.append(os.getcwd());
+ if self.oBuild is not None and self.oBuild.sInstallPath not in asCandidates:
+ asCandidates.append(self.oBuild.sInstallPath);
+
+ #
+ # When working out of the tree, we'll search the current directory
+ # as well as parent dirs.
+ #
+ for sDir in list(asCandidates):
+ for i in range(10):
+ sDir = os.path.dirname(sDir);
+ if sDir not in asCandidates:
+ asCandidates.append(sDir);
+
+ #
+ # Do the searching.
+ #
+ sCandidate = None;
+ for i, _ in enumerate(asCandidates):
+ sCandidate = asCandidates[i];
+ if os.path.isfile(os.path.join(sCandidate, 'VBoxValidationKit.iso')):
+ break;
+ sCandidate = os.path.join(sCandidate, 'validationkit');
+ if os.path.isfile(os.path.join(sCandidate, 'VBoxValidationKit.iso')):
+ break;
+ sCandidate = None;
+
+ fRc = sCandidate is not None;
+ if fRc is False:
+ if not fQuiet:
+ reporter.error('failed to find VBox Validation Kit installation (candidates: %s)' % (asCandidates,));
+ sCandidate = os.path.join(self.sScriptPath, 'validationkit'); # Don't leave the values as None.
+
+ #
+ # Set the member values.
+ #
+ self.sVBoxValidationKit = sCandidate;
+ self.sVBoxValidationKitIso = os.path.join(sCandidate, 'VBoxValidationKit.iso');
+ self.sVBoxBootSectors = os.path.join(sCandidate, 'bootsectors');
+ return fRc;
+
+ def _makeEnvironmentChanges(self):
+ """
+ Make the necessary VBox related environment changes.
+ Children not importing the VBox API should call this.
+ """
+ # Make sure we've got our own VirtualBox config and VBoxSVC (on XPCOM at least).
+ if not self.fUseDefaultSvc:
+ os.environ['VBOX_USER_HOME'] = os.path.join(self.sScratchPath, 'VBoxUserHome');
+ sUser = os.environ.get('USERNAME', os.environ.get('USER', os.environ.get('LOGNAME', 'unknown')));
+ os.environ['VBOX_IPC_SOCKETID'] = sUser + '-VBoxTest';
+ return True;
+
+ @staticmethod
+ def makeApiRevision(uMajor, uMinor, uBuild, uApiRevision):
+ """ Calculates an API revision number. """
+ return (long(uMajor) << 56) | (long(uMinor) << 48) | (long(uBuild) << 40) | uApiRevision;
+
+ def importVBoxApi(self):
+ """
+ Import the 'vboxapi' module from the VirtualBox build we're using and
+ instantiate the two basic objects.
+
+ This will try detect an development or installed build if no build has
+ been associated with the driver yet.
+ """
+ if self.fImportedVBoxApi:
+ return True;
+
+ self._makeEnvironmentChanges();
+
+ # Do the detecting.
+ self._detectBuild();
+ if self.oBuild is None:
+ return False;
+
+ # Avoid crashing when loading the 32-bit module (or whatever it is that goes bang).
+ if self.oBuild.sArch == 'x86' \
+ and self.sHost == 'darwin' \
+ and platform.architecture()[0] == '64bit' \
+ and self.oBuild.sKind == 'development' \
+ and os.getenv('VERSIONER_PYTHON_PREFER_32_BIT') != 'yes':
+ reporter.log("WARNING: 64-bit python on darwin, 32-bit VBox development build => crash");
+ reporter.log("WARNING: bash-3.2$ /usr/bin/python2.5 ./testdriver");
+ reporter.log("WARNING: or");
+ reporter.log("WARNING: bash-3.2$ VERSIONER_PYTHON_PREFER_32_BIT=yes ./testdriver");
+ return False;
+
+ # Start VBoxSVC and load the vboxapi bits.
+ if self._startVBoxSVC() is True:
+ assert(self.oVBoxSvcProcess is not None);
+
+ sSavedSysPath = sys.path;
+ self._setupVBoxApi();
+ sys.path = sSavedSysPath;
+
+ # Adjust the default machine folder.
+ if self.fImportedVBoxApi and not self.fUseDefaultSvc and self.fpApiVer >= 4.0:
+ sNewFolder = os.path.join(self.sScratchPath, 'VBoxUserHome', 'Machines');
+ try:
+ self.oVBox.systemProperties.defaultMachineFolder = sNewFolder;
+ except:
+ self.fImportedVBoxApi = False;
+ self.oVBoxMgr = None;
+ self.oVBox = None;
+ reporter.logXcpt("defaultMachineFolder exception (sNewFolder=%s)" % (sNewFolder,));
+
+ # Kill VBoxSVC on failure.
+ if self.oVBoxMgr is None:
+ self._stopVBoxSVC();
+ else:
+ assert(self.oVBoxSvcProcess is None);
+ return self.fImportedVBoxApi;
+
+ def _startVBoxSVC(self): # pylint: disable=too-many-statements
+ """ Starts VBoxSVC. """
+ assert(self.oVBoxSvcProcess is None);
+
+ # Setup vbox logging for VBoxSVC now and start it manually. This way
+ # we can control both logging and shutdown.
+ self.sVBoxSvcLogFile = '%s/VBoxSVC-debug.log' % (self.sScratchPath,);
+ try: os.remove(self.sVBoxSvcLogFile);
+ except: pass;
+ os.environ['VBOX_LOG'] = self.sLogSvcGroups;
+ os.environ['VBOX_LOG_FLAGS'] = '%s append' % (self.sLogSvcFlags,); # Append becuse of VBoxXPCOMIPCD.
+ if self.sLogSvcDest:
+ os.environ['VBOX_LOG_DEST'] = 'nodeny ' + self.sLogSvcDest;
+ else:
+ os.environ['VBOX_LOG_DEST'] = 'nodeny file=%s' % (self.sVBoxSvcLogFile,);
+ os.environ['VBOXSVC_RELEASE_LOG_FLAGS'] = 'time append';
+
+ reporter.log2('VBoxSVC environment:');
+ for sKey, sVal in sorted(os.environ.items()):
+ reporter.log2('%s=%s' % (sKey, sVal));
+
+ # Always leave a pid file behind so we can kill it during cleanup-before.
+ self.sVBoxSvcPidFile = '%s/VBoxSVC.pid' % (self.sScratchPath,);
+ fWritePidFile = True;
+
+ cMsFudge = 1;
+ sVBoxSVC = '%s/VBoxSVC' % (self.oBuild.sInstallPath,); ## @todo .exe and stuff.
+ if self.fVBoxSvcInDebugger:
+ if self.sHost in ('darwin', 'freebsd', 'linux', 'solaris', ):
+ # Start VBoxSVC in gdb in a new terminal.
+ #sTerm = '/usr/bin/gnome-terminal'; - doesn't work, some fork+exec stuff confusing us.
+ sTerm = '/usr/bin/xterm';
+ if not os.path.isfile(sTerm): sTerm = '/usr/X11/bin/xterm';
+ if not os.path.isfile(sTerm): sTerm = '/usr/X11R6/bin/xterm';
+ if not os.path.isfile(sTerm): sTerm = '/usr/bin/xterm';
+ if not os.path.isfile(sTerm): sTerm = 'xterm';
+ sGdb = '/usr/bin/gdb';
+ if not os.path.isfile(sGdb): sGdb = '/usr/local/bin/gdb';
+ if not os.path.isfile(sGdb): sGdb = '/usr/sfw/bin/gdb';
+ if not os.path.isfile(sGdb): sGdb = 'gdb';
+ sGdbCmdLine = '%s --args %s --pidfile %s' % (sGdb, sVBoxSVC, self.sVBoxSvcPidFile);
+ # Cool tweak to run performance analysis instead of gdb:
+ #sGdb = '/usr/bin/valgrind';
+ #sGdbCmdLine = '%s --tool=callgrind --collect-atstart=no -- %s --pidfile %s' \
+ # % (sGdb, sVBoxSVC, self.sVBoxSvcPidFile);
+ reporter.log('term="%s" gdb="%s"' % (sTerm, sGdbCmdLine));
+ os.environ['SHELL'] = self.sOrgShell; # Non-working shell may cause gdb and/or the term problems.
+ ## @todo -e is deprecated; use "-- <args>".
+ self.oVBoxSvcProcess = base.Process.spawnp(sTerm, sTerm, '-e', sGdbCmdLine);
+ os.environ['SHELL'] = self.sOurShell;
+ if self.oVBoxSvcProcess is not None:
+ reporter.log('Press enter or return after starting VBoxSVC in the debugger...');
+ sys.stdin.read(1);
+ fWritePidFile = False;
+
+ elif self.sHost == 'win':
+ sWinDbg = 'c:\\Program Files\\Debugging Tools for Windows\\windbg.exe';
+ if not os.path.isfile(sWinDbg): sWinDbg = 'c:\\Program Files\\Debugging Tools for Windows (x64)\\windbg.exe';
+ if not os.path.isfile(sWinDbg): sWinDbg = 'c:\\Programme\\Debugging Tools for Windows\\windbg.exe'; # Localization rulez! pylint: disable=line-too-long
+ if not os.path.isfile(sWinDbg): sWinDbg = 'c:\\Programme\\Debugging Tools for Windows (x64)\\windbg.exe';
+ if not os.path.isfile(sWinDbg): sWinDbg = 'windbg'; # WinDbg must be in the path; better than nothing.
+ # Assume that everything WinDbg needs is defined using the environment variables.
+ # See WinDbg help for more information.
+ reporter.log('windbg="%s"' % (sWinDbg));
+ self.oVBoxSvcProcess = base.Process.spawn(sWinDbg, sWinDbg, sVBoxSVC + base.exeSuff());
+ if self.oVBoxSvcProcess is not None:
+ reporter.log('Press enter or return after starting VBoxSVC in the debugger...');
+ sys.stdin.read(1);
+ fWritePidFile = False;
+ ## @todo add a pipe interface similar to xpcom if feasible, i.e. if
+ # we can get actual handle values for pipes in python.
+
+ else:
+ reporter.error('Port me!');
+ else: # Run without a debugger attached.
+ if self.sHost in ('darwin', 'freebsd', 'linux', 'solaris', ):
+ #
+ # XPCOM - We can use a pipe to let VBoxSVC notify us when it's ready.
+ #
+ iPipeR, iPipeW = os.pipe();
+ if hasattr(os, 'set_inheritable'):
+ os.set_inheritable(iPipeW, True); # pylint: disable=no-member
+ os.environ['NSPR_INHERIT_FDS'] = 'vboxsvc:startup-pipe:5:0x%x' % (iPipeW,);
+ reporter.log2("NSPR_INHERIT_FDS=%s" % (os.environ['NSPR_INHERIT_FDS']));
+
+ self.oVBoxSvcProcess = base.Process.spawn(sVBoxSVC, sVBoxSVC, '--auto-shutdown'); # SIGUSR1 requirement.
+ try: # Try make sure we get the SIGINT and not VBoxSVC.
+ os.setpgid(self.oVBoxSvcProcess.getPid(), 0); # pylint: disable=no-member
+ os.setpgid(0, 0); # pylint: disable=no-member
+ except:
+ reporter.logXcpt();
+
+ os.close(iPipeW);
+ try:
+ sResponse = os.read(iPipeR, 32);
+ except:
+ reporter.logXcpt();
+ sResponse = None;
+ os.close(iPipeR);
+
+ if hasattr(sResponse, 'decode'):
+ sResponse = sResponse.decode('utf-8', 'ignore');
+
+ if sResponse is None or sResponse.strip() != 'READY':
+ reporter.error('VBoxSVC failed starting up... (sResponse=%s)' % (sResponse,));
+ if not self.oVBoxSvcProcess.wait(5000):
+ self.oVBoxSvcProcess.terminate();
+ self.oVBoxSvcProcess.wait(5000);
+ self.oVBoxSvcProcess = None;
+
+ elif self.sHost == 'win':
+ #
+ # Windows - Just fudge it for now.
+ #
+ cMsFudge = 2000;
+ self.oVBoxSvcProcess = base.Process.spawn(sVBoxSVC, sVBoxSVC);
+
+ else:
+ reporter.error('Port me!');
+
+ #
+ # Enable automatic crash reporting if we succeeded.
+ #
+ if self.oVBoxSvcProcess is not None:
+ self.oVBoxSvcProcess.enableCrashReporting('crash/report/svc', 'crash/dump/svc');
+
+ #
+ # Wait for debugger to attach.
+ #
+ if self.oVBoxSvcProcess is not None and self.fVBoxSvcWaitForDebugger:
+ reporter.log('Press any key after attaching to VBoxSVC (pid %s) with a debugger...'
+ % (self.oVBoxSvcProcess.getPid(),));
+ sys.stdin.read(1);
+
+ #
+ # Fudge and pid file.
+ #
+ if self.oVBoxSvcProcess is not None and not self.oVBoxSvcProcess.wait(cMsFudge):
+ if fWritePidFile:
+ iPid = self.oVBoxSvcProcess.getPid();
+ try:
+ oFile = utils.openNoInherit(self.sVBoxSvcPidFile, "w+");
+ oFile.write('%s' % (iPid,));
+ oFile.close();
+ except:
+ reporter.logXcpt('sPidFile=%s' % (self.sVBoxSvcPidFile,));
+ reporter.log('VBoxSVC PID=%u' % (iPid,));
+
+ #
+ # Finally add the task so we'll notice when it dies in a relatively timely manner.
+ #
+ self.addTask(self.oVBoxSvcProcess);
+ else:
+ self.oVBoxSvcProcess = None;
+ try: os.remove(self.sVBoxSvcPidFile);
+ except: pass;
+
+ return self.oVBoxSvcProcess is not None;
+
+
+ def _killVBoxSVCByPidFile(self, sPidFile):
+ """ Kill a VBoxSVC given the pid from it's pid file. """
+
+ # Read the pid file.
+ if not os.path.isfile(sPidFile):
+ return False;
+ try:
+ oFile = utils.openNoInherit(sPidFile, "r");
+ sPid = oFile.readline().strip();
+ oFile.close();
+ except:
+ reporter.logXcpt('sPidfile=%s' % (sPidFile,));
+ return False;
+
+ # Convert the pid to an integer and validate the range a little bit.
+ try:
+ iPid = long(sPid);
+ except:
+ reporter.logXcpt('sPidfile=%s sPid="%s"' % (sPidFile, sPid));
+ return False;
+ if iPid <= 0:
+ reporter.log('negative pid - sPidfile=%s sPid="%s" iPid=%d' % (sPidFile, sPid, iPid));
+ return False;
+
+ # Take care checking that it's VBoxSVC we're about to inhume.
+ if base.processCheckPidAndName(iPid, "VBoxSVC") is not True:
+ reporter.log('Ignoring stale VBoxSVC pid file (pid=%s)' % (iPid,));
+ return False;
+
+ # Loop thru our different ways of getting VBoxSVC to terminate.
+ for aHow in [ [ base.sendUserSignal1, 5000, 'Dropping VBoxSVC a SIGUSR1 hint...'], \
+ [ base.processInterrupt, 5000, 'Dropping VBoxSVC a SIGINT hint...'], \
+ [ base.processTerminate, 7500, 'VBoxSVC is still around, killing it...'] ]:
+ reporter.log(aHow[2]);
+ if aHow[0](iPid) is True:
+ msStart = base.timestampMilli();
+ while base.timestampMilli() - msStart < 5000 \
+ and base.processExists(iPid):
+ time.sleep(0.2);
+
+ fRc = not base.processExists(iPid);
+ if fRc is True:
+ break;
+ if fRc:
+ reporter.log('Successfully killed VBoxSVC (pid=%s)' % (iPid,));
+ else:
+ reporter.log('Failed to kill VBoxSVC (pid=%s)' % (iPid,));
+ return fRc;
+
+ def _stopVBoxSVC(self):
+ """
+ Stops VBoxSVC. Try the polite way first.
+ """
+
+ if self.oVBoxSvcProcess:
+ self.removeTask(self.oVBoxSvcProcess);
+ self.oVBoxSvcProcess.enableCrashReporting(None, None); # Disables it.
+
+ fRc = False;
+ if self.oVBoxSvcProcess is not None \
+ and not self.fVBoxSvcInDebugger:
+ # by process object.
+ if self.oVBoxSvcProcess.isRunning():
+ reporter.log('Dropping VBoxSVC a SIGUSR1 hint...');
+ if not self.oVBoxSvcProcess.sendUserSignal1() \
+ or not self.oVBoxSvcProcess.wait(5000):
+ reporter.log('Dropping VBoxSVC a SIGINT hint...');
+ if not self.oVBoxSvcProcess.interrupt() \
+ or not self.oVBoxSvcProcess.wait(5000):
+ reporter.log('VBoxSVC is still around, killing it...');
+ self.oVBoxSvcProcess.terminate();
+ self.oVBoxSvcProcess.wait(7500);
+ else:
+ reporter.log('VBoxSVC is no longer running...');
+
+ if not self.oVBoxSvcProcess.isRunning():
+ iExit = self.oVBoxSvcProcess.getExitCode();
+ if iExit != 0 or not self.oVBoxSvcProcess.isNormalExit():
+ reporter.error("VBoxSVC exited with status %d (%#x)" % (iExit, self.oVBoxSvcProcess.uExitCode));
+ self.oVBoxSvcProcess = None;
+ else:
+ # by pid file.
+ self._killVBoxSVCByPidFile('%s/VBoxSVC.pid' % (self.sScratchPath,));
+ return fRc;
+
+ def _setupVBoxApi(self):
+ """
+ Import and set up the vboxapi.
+ The caller saves and restores sys.path.
+ """
+
+ # Setup vbox logging for self (the test driver).
+ self.sSelfLogFile = '%s/VBoxTestDriver.log' % (self.sScratchPath,);
+ try: os.remove(self.sSelfLogFile);
+ except: pass;
+ os.environ['VBOX_LOG'] = self.sLogSelfGroups;
+ os.environ['VBOX_LOG_FLAGS'] = '%s append' % (self.sLogSelfFlags, );
+ if self.sLogSelfDest:
+ os.environ['VBOX_LOG_DEST'] = 'nodeny ' + self.sLogSelfDest;
+ else:
+ os.environ['VBOX_LOG_DEST'] = 'nodeny file=%s' % (self.sSelfLogFile,);
+ os.environ['VBOX_RELEASE_LOG_FLAGS'] = 'time append';
+
+ reporter.log2('Self environment:');
+ for sKey, sVal in sorted(os.environ.items()):
+ reporter.log2('%s=%s' % (sKey, sVal));
+
+ # Hack the sys.path + environment so the vboxapi can be found.
+ sys.path.insert(0, self.oBuild.sInstallPath);
+ if self.oBuild.sSdkPath is not None:
+ sys.path.insert(0, os.path.join(self.oBuild.sSdkPath, 'installer'))
+ sys.path.insert(1, os.path.join(self.oBuild.sSdkPath, 'install')); # stupid stupid windows installer!
+ sys.path.insert(2, os.path.join(self.oBuild.sSdkPath, 'bindings', 'xpcom', 'python'))
+ os.environ['VBOX_PROGRAM_PATH'] = self.oBuild.sInstallPath;
+ reporter.log("sys.path: %s" % (sys.path));
+
+ try:
+ from vboxapi import VirtualBoxManager; # pylint: disable=import-error
+ except:
+ reporter.logXcpt('Error importing vboxapi');
+ return False;
+
+ # Exception and error hacks.
+ try:
+ # pylint: disable=import-error
+ if self.sHost == 'win':
+ from pythoncom import com_error as NativeComExceptionClass # pylint: disable=no-name-in-module
+ import winerror as NativeComErrorClass
+ else:
+ from xpcom import Exception as NativeComExceptionClass
+ from xpcom import nsError as NativeComErrorClass
+ # pylint: enable=import-error
+ except:
+ reporter.logXcpt('Error importing (XP)COM related stuff for exception hacks and errors');
+ return False;
+ __deployExceptionHacks__(NativeComExceptionClass)
+ ComError.copyErrors(NativeComErrorClass);
+
+ # Create the manager.
+ try:
+ self.oVBoxMgr = VirtualBoxManager(None, None)
+ except:
+ self.oVBoxMgr = None;
+ reporter.logXcpt('VirtualBoxManager exception');
+ return False;
+
+ # Figure the API version.
+ try:
+ oVBox = self.oVBoxMgr.getVirtualBox();
+
+ try:
+ sVer = oVBox.version;
+ except:
+ reporter.logXcpt('Failed to get VirtualBox version, assuming 4.0.0');
+ sVer = "4.0.0";
+ reporter.log("IVirtualBox.version=%s" % (sVer,));
+
+ # Convert the string to three integer values and check ranges.
+ asVerComponents = sVer.split('.');
+ try:
+ sLast = asVerComponents[2].split('_')[0].split('r')[0];
+ aiVerComponents = (int(asVerComponents[0]), int(asVerComponents[1]), int(sLast));
+ except:
+ raise base.GenError('Malformed version "%s"' % (sVer,));
+ if aiVerComponents[0] < 3 or aiVerComponents[0] > 19:
+ raise base.GenError('Malformed version "%s" - 1st component is out of bounds 3..19: %u'
+ % (sVer, aiVerComponents[0]));
+ if aiVerComponents[1] < 0 or aiVerComponents[1] > 9:
+ raise base.GenError('Malformed version "%s" - 2nd component is out of bounds 0..9: %u'
+ % (sVer, aiVerComponents[1]));
+ if aiVerComponents[2] < 0 or aiVerComponents[2] > 99:
+ raise base.GenError('Malformed version "%s" - 3rd component is out of bounds 0..99: %u'
+ % (sVer, aiVerComponents[2]));
+
+ # Convert the three integers into a floating point value. The API is stable within a
+ # x.y release, so the third component only indicates whether it's a stable or
+ # development build of the next release.
+ self.fpApiVer = aiVerComponents[0] + 0.1 * aiVerComponents[1];
+ if aiVerComponents[2] >= 51:
+ if self.fpApiVer not in [6.1, 5.2, 4.3, 3.2,]:
+ self.fpApiVer += 0.1;
+ else:
+ self.fpApiVer = int(self.fpApiVer) + 1.0;
+ # fudge value to be always bigger than the nominal value (0.1 gets rounded down)
+ if round(self.fpApiVer, 1) > self.fpApiVer:
+ self.fpApiVer += sys.float_info.epsilon * self.fpApiVer / 2.0;
+
+ try:
+ self.uRevision = oVBox.revision;
+ except:
+ reporter.logXcpt('Failed to get VirtualBox revision, assuming 0');
+ self.uRevision = 0;
+ reporter.log("IVirtualBox.revision=%u" % (self.uRevision,));
+
+ try:
+ self.uApiRevision = oVBox.APIRevision;
+ except:
+ reporter.logXcpt('Failed to get VirtualBox APIRevision, faking it.');
+ self.uApiRevision = self.makeApiRevision(aiVerComponents[0], aiVerComponents[1], aiVerComponents[2], 0);
+ reporter.log("IVirtualBox.APIRevision=%#x" % (self.uApiRevision,));
+
+ # Patch VBox manage to gloss over portability issues (error constants, etc).
+ self._patchVBoxMgr();
+
+ # Wrap oVBox.
+ from testdriver.vboxwrappers import VirtualBoxWrapper;
+ self.oVBox = VirtualBoxWrapper(oVBox, self.oVBoxMgr, self.fpApiVer, self);
+
+ # Install the constant wrapping hack.
+ vboxcon.goHackModuleClass.oVBoxMgr = self.oVBoxMgr; # VBoxConstantWrappingHack.
+ vboxcon.fpApiVer = self.fpApiVer;
+ reporter.setComXcptFormatter(formatComOrXpComException);
+
+ except:
+ self.oVBoxMgr = None;
+ self.oVBox = None;
+ reporter.logXcpt("getVirtualBox / API version exception");
+ return False;
+
+ # Done
+ self.fImportedVBoxApi = True;
+ reporter.log('Found version %s (%s)' % (self.fpApiVer, sVer));
+ return True;
+
+ def _patchVBoxMgr(self):
+ """
+ Glosses over missing self.oVBoxMgr methods on older VBox versions.
+ """
+
+ def _xcptGetResult(oSelf, oXcpt = None):
+ """ See vboxapi. """
+ _ = oSelf;
+ if oXcpt is None: oXcpt = sys.exc_info()[1];
+ if sys.platform == 'win32':
+ import winerror; # pylint: disable=import-error
+ hrXcpt = oXcpt.hresult;
+ if hrXcpt == winerror.DISP_E_EXCEPTION:
+ hrXcpt = oXcpt.excepinfo[5];
+ else:
+ hrXcpt = oXcpt.error;
+ return hrXcpt;
+
+ def _xcptIsDeadInterface(oSelf, oXcpt = None):
+ """ See vboxapi. """
+ return oSelf.xcptGetStatus(oXcpt) in [
+ 0x80004004, -2147467260, # NS_ERROR_ABORT
+ 0x800706be, -2147023170, # NS_ERROR_CALL_FAILED (RPC_S_CALL_FAILED)
+ 0x800706ba, -2147023174, # RPC_S_SERVER_UNAVAILABLE.
+ 0x800706be, -2147023170, # RPC_S_CALL_FAILED.
+ 0x800706bf, -2147023169, # RPC_S_CALL_FAILED_DNE.
+ 0x80010108, -2147417848, # RPC_E_DISCONNECTED.
+ 0x800706b5, -2147023179, # RPC_S_UNKNOWN_IF
+ ];
+
+ def _xcptIsOurXcptKind(oSelf, oXcpt = None):
+ """ See vboxapi. """
+ _ = oSelf;
+ if oXcpt is None: oXcpt = sys.exc_info()[1];
+ if sys.platform == 'win32':
+ from pythoncom import com_error as NativeComExceptionClass # pylint: disable=import-error,no-name-in-module
+ else:
+ from xpcom import Exception as NativeComExceptionClass # pylint: disable=import-error
+ return isinstance(oXcpt, NativeComExceptionClass);
+
+ def _xcptIsEqual(oSelf, oXcpt, hrStatus):
+ """ See vboxapi. """
+ hrXcpt = oSelf.xcptGetResult(oXcpt);
+ return hrXcpt == hrStatus or hrXcpt == hrStatus - 0x100000000; # pylint: disable=consider-using-in
+
+ def _xcptToString(oSelf, oXcpt):
+ """ See vboxapi. """
+ _ = oSelf;
+ if oXcpt is None: oXcpt = sys.exc_info()[1];
+ return str(oXcpt);
+
+ def _getEnumValueName(oSelf, sEnumTypeNm, oEnumValue, fTypePrefix = False):
+ """ See vboxapi. """
+ _ = oSelf; _ = fTypePrefix;
+ return '%s::%s' % (sEnumTypeNm, oEnumValue);
+
+ # Add utilities found in newer vboxapi revision.
+ if not hasattr(self.oVBoxMgr, 'xcptIsDeadInterface'):
+ import types;
+ self.oVBoxMgr.xcptGetResult = types.MethodType(_xcptGetResult, self.oVBoxMgr);
+ self.oVBoxMgr.xcptIsDeadInterface = types.MethodType(_xcptIsDeadInterface, self.oVBoxMgr);
+ self.oVBoxMgr.xcptIsOurXcptKind = types.MethodType(_xcptIsOurXcptKind, self.oVBoxMgr);
+ self.oVBoxMgr.xcptIsEqual = types.MethodType(_xcptIsEqual, self.oVBoxMgr);
+ self.oVBoxMgr.xcptToString = types.MethodType(_xcptToString, self.oVBoxMgr);
+ if not hasattr(self.oVBoxMgr, 'getEnumValueName'):
+ import types;
+ self.oVBoxMgr.getEnumValueName = types.MethodType(_getEnumValueName, self.oVBoxMgr);
+
+
+ def _teardownVBoxApi(self): # pylint: disable=too-many-statements
+ """
+ Drop all VBox object references and shutdown com/xpcom.
+ """
+ if not self.fImportedVBoxApi:
+ return True;
+ import gc;
+
+ # Drop all references we've have to COM objects.
+ self.aoRemoteSessions = [];
+ self.aoVMs = [];
+ self.oVBoxMgr = None;
+ self.oVBox = None;
+ vboxcon.goHackModuleClass.oVBoxMgr = None; # VBoxConstantWrappingHack.
+ reporter.setComXcptFormatter(None);
+
+ # Do garbage collection to try get rid of those objects.
+ try:
+ gc.collect();
+ except:
+ reporter.logXcpt();
+ self.fImportedVBoxApi = False;
+
+ # Check whether the python is still having any COM objects/interfaces around.
+ cVBoxMgrs = 0;
+ aoObjsLeftBehind = [];
+ if self.sHost == 'win':
+ import pythoncom; # pylint: disable=import-error
+ try:
+ cIfs = pythoncom._GetInterfaceCount(); # pylint: disable=no-member,protected-access
+ cObjs = pythoncom._GetGatewayCount(); # pylint: disable=no-member,protected-access
+ if cObjs == 0 and cIfs == 0:
+ reporter.log('_teardownVBoxApi: no interfaces or objects left behind.');
+ else:
+ reporter.log('_teardownVBoxApi: Python COM still has %s objects and %s interfaces...' % ( cObjs, cIfs));
+
+ from win32com.client import DispatchBaseClass; # pylint: disable=import-error
+ for oObj in gc.get_objects():
+ if isinstance(oObj, DispatchBaseClass):
+ reporter.log('_teardownVBoxApi: %s' % (oObj,));
+ aoObjsLeftBehind.append(oObj);
+ elif utils.getObjectTypeName(oObj) == 'VirtualBoxManager':
+ reporter.log('_teardownVBoxApi: %s' % (oObj,));
+ cVBoxMgrs += 1;
+ aoObjsLeftBehind.append(oObj);
+ oObj = None;
+ except:
+ reporter.logXcpt();
+
+ # If not being used, we can safely uninitialize COM.
+ if cIfs == 0 and cObjs == 0 and cVBoxMgrs == 0 and not aoObjsLeftBehind:
+ reporter.log('_teardownVBoxApi: Calling CoUninitialize...');
+ try: pythoncom.CoUninitialize(); # pylint: disable=no-member
+ except: reporter.logXcpt();
+ else:
+ reporter.log('_teardownVBoxApi: Returned from CoUninitialize.');
+ else:
+ try:
+ # XPCOM doesn't crash and burn like COM if you shut it down with interfaces and objects around.
+ # Also, it keeps a number of internal objects and interfaces around to do its job, so shutting
+ # it down before we go looking for dangling interfaces is more or less required.
+ from xpcom import _xpcom as _xpcom; # pylint: disable=import-error,useless-import-alias
+ hrc = _xpcom.DeinitCOM();
+ cIfs = _xpcom._GetInterfaceCount(); # pylint: disable=protected-access
+ cObjs = _xpcom._GetGatewayCount(); # pylint: disable=protected-access
+
+ if cObjs == 0 and cIfs == 0:
+ reporter.log('_teardownVBoxApi: No XPCOM interfaces or objects active. (hrc=%#x)' % (hrc,));
+ else:
+ reporter.log('_teardownVBoxApi: %s XPCOM objects and %s interfaces still around! (hrc=%#x)'
+ % (cObjs, cIfs, hrc));
+ if hasattr(_xpcom, '_DumpInterfaces'):
+ try: _xpcom._DumpInterfaces(); # pylint: disable=protected-access
+ except: reporter.logXcpt('_teardownVBoxApi: _DumpInterfaces failed');
+
+ from xpcom.client import Component; # pylint: disable=import-error
+ for oObj in gc.get_objects():
+ if isinstance(oObj, Component):
+ reporter.log('_teardownVBoxApi: %s' % (oObj,));
+ aoObjsLeftBehind.append(oObj);
+ if utils.getObjectTypeName(oObj) == 'VirtualBoxManager':
+ reporter.log('_teardownVBoxApi: %s' % (oObj,));
+ cVBoxMgrs += 1;
+ aoObjsLeftBehind.append(oObj);
+ oObj = None;
+ except:
+ reporter.logXcpt();
+
+ # Try get the referrers to (XP)COM interfaces and objects that was left behind.
+ for iObj in range(len(aoObjsLeftBehind)): # pylint: disable=consider-using-enumerate
+ try:
+ aoReferrers = gc.get_referrers(aoObjsLeftBehind[iObj]);
+ reporter.log('_teardownVBoxApi: Found %u referrers to %s:' % (len(aoReferrers), aoObjsLeftBehind[iObj],));
+ for oReferrer in aoReferrers:
+ oMyFrame = sys._getframe(0); # pylint: disable=protected-access
+ if oReferrer is oMyFrame:
+ reporter.log('_teardownVBoxApi: - frame of this function');
+ elif oReferrer is aoObjsLeftBehind:
+ reporter.log('_teardownVBoxApi: - aoObjsLeftBehind');
+ else:
+ fPrinted = False;
+ if isinstance(oReferrer, (dict, list, tuple)):
+ try:
+ aoSubReferreres = gc.get_referrers(oReferrer);
+ for oSubRef in aoSubReferreres:
+ if not isinstance(oSubRef, list) \
+ and not isinstance(oSubRef, dict) \
+ and oSubRef is not oMyFrame \
+ and oSubRef is not aoSubReferreres:
+ reporter.log('_teardownVBoxApi: - %s :: %s:'
+ % (utils.getObjectTypeName(oSubRef), utils.getObjectTypeName(oReferrer)));
+ fPrinted = True;
+ break;
+ del aoSubReferreres;
+ except:
+ reporter.logXcpt('subref');
+ if not fPrinted:
+ reporter.log('_teardownVBoxApi: - %s:' % (utils.getObjectTypeName(oReferrer),));
+ try:
+ import pprint;
+ for sLine in pprint.pformat(oReferrer, width = 130).split('\n'):
+ reporter.log('_teardownVBoxApi: %s' % (sLine,));
+ except:
+ reporter.log('_teardownVBoxApi: %s' % (oReferrer,));
+ except:
+ reporter.logXcpt();
+ del aoObjsLeftBehind;
+
+ # Force garbage collection again, just for good measure.
+ try:
+ gc.collect();
+ time.sleep(0.5); # fudge factor
+ except:
+ reporter.logXcpt();
+ return True;
+
+ def _powerOffAllVms(self):
+ """
+ Tries to power off all running VMs.
+ """
+ for oSession in self.aoRemoteSessions:
+ uPid = oSession.getPid();
+ if uPid is not None:
+ reporter.log('_powerOffAllVms: PID is %s for %s, trying to kill it.' % (uPid, oSession.sName,));
+ base.processKill(uPid);
+ else:
+ reporter.log('_powerOffAllVms: No PID for %s' % (oSession.sName,));
+ oSession.close();
+ return None;
+
+
+
+ #
+ # Build type, OS and arch getters.
+ #
+
+ def getBuildType(self):
+ """
+ Get the build type.
+ """
+ if not self._detectBuild():
+ return 'release';
+ return self.oBuild.sType;
+
+ def getBuildOs(self):
+ """
+ Get the build OS.
+ """
+ if not self._detectBuild():
+ return self.sHost;
+ return self.oBuild.sOs;
+
+ def getBuildArch(self):
+ """
+ Get the build arch.
+ """
+ if not self._detectBuild():
+ return self.sHostArch;
+ return self.oBuild.sArch;
+
+ def getGuestAdditionsIso(self):
+ """
+ Get the path to the guest addition iso.
+ """
+ if not self._detectBuild():
+ return None;
+ return self.oBuild.sGuestAdditionsIso;
+
+ #
+ # Override everything from the base class so the testdrivers don't have to
+ # check whether we have overridden a method or not.
+ #
+
+ def showUsage(self):
+ rc = base.TestDriver.showUsage(self);
+ reporter.log('');
+ reporter.log('Generic VirtualBox Options:');
+ reporter.log(' --vbox-session-type <type>');
+ reporter.log(' Sets the session type. Typical values are: gui, headless, sdl');
+ reporter.log(' Default: %s' % (self.sSessionTypeDef));
+ reporter.log(' --vrdp, --no-vrdp');
+ reporter.log(' Enables VRDP, ports starting at 6000');
+ reporter.log(' Default: --vrdp');
+ reporter.log(' --vrdp-base-port <port>');
+ reporter.log(' Sets the base for VRDP port assignments.');
+ reporter.log(' Default: %s' % (self.uVrdpBasePortDef));
+ reporter.log(' --vbox-default-bridged-nic <interface>');
+ reporter.log(' Sets the default interface for bridged networking.');
+ reporter.log(' Default: autodetect');
+ reporter.log(' --vbox-use-svc-defaults');
+ reporter.log(' Use default locations and files for VBoxSVC. This is useful');
+ reporter.log(' for automatically configuring the test VMs for debugging.');
+ reporter.log(' --vbox-log');
+ reporter.log(' The VBox logger group settings for everyone.');
+ reporter.log(' --vbox-log-flags');
+ reporter.log(' The VBox logger flags settings for everyone.');
+ reporter.log(' --vbox-log-dest');
+ reporter.log(' The VBox logger destination settings for everyone.');
+ reporter.log(' --vbox-self-log');
+ reporter.log(' The VBox logger group settings for the testdriver.');
+ reporter.log(' --vbox-self-log-flags');
+ reporter.log(' The VBox logger flags settings for the testdriver.');
+ reporter.log(' --vbox-self-log-dest');
+ reporter.log(' The VBox logger destination settings for the testdriver.');
+ reporter.log(' --vbox-session-log');
+ reporter.log(' The VM session logger group settings.');
+ reporter.log(' --vbox-session-log-flags');
+ reporter.log(' The VM session logger flags.');
+ reporter.log(' --vbox-session-log-dest');
+ reporter.log(' The VM session logger destination settings.');
+ reporter.log(' --vbox-svc-log');
+ reporter.log(' The VBoxSVC logger group settings.');
+ reporter.log(' --vbox-svc-log-flags');
+ reporter.log(' The VBoxSVC logger flag settings.');
+ reporter.log(' --vbox-svc-log-dest');
+ reporter.log(' The VBoxSVC logger destination settings.');
+ reporter.log(' --vbox-svc-debug');
+ reporter.log(' Start VBoxSVC in a debugger.');
+ reporter.log(' --vbox-svc-wait-debug');
+ reporter.log(' Start VBoxSVC and wait for debugger to attach to it.');
+ reporter.log(' --vbox-always-upload-logs');
+ reporter.log(' Whether to always upload log files, or only do so on failure.');
+ reporter.log(' --vbox-always-upload-screenshots');
+ reporter.log(' Whether to always upload final screen shots, or only do so on failure.');
+ reporter.log(' --vbox-always-upload-recordings, --no-vbox-always-upload-recordings');
+ reporter.log(' Whether to always upload recordings, or only do so on failure.');
+ reporter.log(' Default: --no-vbox-always-upload-recordings');
+ reporter.log(' --vbox-debugger, --no-vbox-debugger');
+ reporter.log(' Enables the VBox debugger, port at 5000');
+ reporter.log(' Default: --vbox-debugger');
+ reporter.log(' --vbox-recording, --no-vbox-recording');
+ reporter.log(' Enables/disables recording.');
+ reporter.log(' Default: --no-vbox-recording');
+ reporter.log(' --vbox-recording-audio, --no-vbox-recording-audio');
+ reporter.log(' Enables/disables audio recording.');
+ reporter.log(' Default: --no-vbox-recording-audio');
+ reporter.log(' --vbox-recording-max-time <seconds>');
+ reporter.log(' Limits the maximum recording time in seconds.');
+ reporter.log(' Default: Unlimited.');
+ reporter.log(' --vbox-recording-max-file-size <MiB>');
+ reporter.log(' Limits the maximum per-file size in MiB.');
+ reporter.log(' Explicitly specify 0 for unlimited size.');
+ reporter.log(' Default: 195 MB.');
+ reporter.log(' --vbox-vm-no-terminate');
+ reporter.log(' Does not terminate the test VM after running the test driver.');
+ if self.oTestVmSet is not None:
+ self.oTestVmSet.showUsage();
+ return rc;
+
+ def parseOption(self, asArgs, iArg): # pylint: disable=too-many-branches,too-many-statements
+ if asArgs[iArg] == '--vbox-session-type':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-session-type" takes an argument');
+ self.sSessionType = asArgs[iArg];
+ elif asArgs[iArg] == '--vrdp':
+ self.fEnableVrdp = True;
+ elif asArgs[iArg] == '--no-vrdp':
+ self.fEnableVrdp = False;
+ elif asArgs[iArg] == '--vrdp-base-port':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vrdp-base-port" takes an argument');
+ try: self.uVrdpBasePort = int(asArgs[iArg]);
+ except: raise base.InvalidOption('The "--vrdp-base-port" value "%s" is not a valid integer' % (asArgs[iArg],));
+ if self.uVrdpBasePort <= 0 or self.uVrdpBasePort >= 65530:
+ raise base.InvalidOption('The "--vrdp-base-port" value "%s" is not in the valid range (1..65530)'
+ % (asArgs[iArg],));
+ elif asArgs[iArg] == '--vbox-default-bridged-nic':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-default-bridged-nic" takes an argument');
+ self.sDefBridgedNic = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-use-svc-defaults':
+ self.fUseDefaultSvc = True;
+ elif asArgs[iArg] == '--vbox-self-log':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-self-log" takes an argument');
+ self.sLogSelfGroups = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-self-log-flags':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-self-log-flags" takes an argument');
+ self.sLogSelfFlags = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-self-log-dest':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-self-log-dest" takes an argument');
+ self.sLogSelfDest = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-session-log':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-session-log" takes an argument');
+ self.sLogSessionGroups = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-session-log-flags':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-session-log-flags" takes an argument');
+ self.sLogSessionFlags = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-session-log-dest':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-session-log-dest" takes an argument');
+ self.sLogSessionDest = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-svc-log':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-svc-log" takes an argument');
+ self.sLogSvcGroups = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-svc-log-flags':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-svc-log-flags" takes an argument');
+ self.sLogSvcFlags = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-svc-log-dest':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-svc-log-dest" takes an argument');
+ self.sLogSvcDest = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-log':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-log" takes an argument');
+ self.sLogSelfGroups = asArgs[iArg];
+ self.sLogSessionGroups = asArgs[iArg];
+ self.sLogSvcGroups = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-log-flags':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-svc-flags" takes an argument');
+ self.sLogSelfFlags = asArgs[iArg];
+ self.sLogSessionFlags = asArgs[iArg];
+ self.sLogSvcFlags = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-log-dest':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-log-dest" takes an argument');
+ self.sLogSelfDest = asArgs[iArg];
+ self.sLogSessionDest = asArgs[iArg];
+ self.sLogSvcDest = asArgs[iArg];
+ elif asArgs[iArg] == '--vbox-svc-debug':
+ self.fVBoxSvcInDebugger = True;
+ elif asArgs[iArg] == '--vbox-svc-wait-debug':
+ self.fVBoxSvcWaitForDebugger = True;
+ elif asArgs[iArg] == '--vbox-always-upload-logs':
+ self.fAlwaysUploadLogs = True;
+ elif asArgs[iArg] == '--vbox-always-upload-screenshots':
+ self.fAlwaysUploadScreenshots = True;
+ elif asArgs[iArg] == '--no-vbox-always-upload-recordings':
+ self.fAlwaysUploadRecordings = False;
+ elif asArgs[iArg] == '--vbox-always-upload-recordings':
+ self.fAlwaysUploadRecordings = True;
+ elif asArgs[iArg] == '--vbox-debugger':
+ self.fEnableDebugger = True;
+ elif asArgs[iArg] == '--no-vbox-debugger':
+ self.fEnableDebugger = False;
+ elif asArgs[iArg] == '--vbox-recording':
+ self.fRecordingEnabled = True;
+ elif asArgs[iArg] == '--vbox-no-recording':
+ self.fRecordingEnabled = False;
+ elif asArgs[iArg] == '--no-vbox-recording-audio':
+ self.fRecordingAudio = False;
+ elif asArgs[iArg] == '--vbox-recording-audio':
+ self.fRecordingAudio = True;
+ elif asArgs[iArg] == '--vbox-recording-max-time':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-recording-max-time" takes an argument');
+ self.cSecsRecordingMax = int(asArgs[iArg]);
+ elif asArgs[iArg] == '--vbox-recording-max-file-size':
+ iArg += 1;
+ if iArg >= len(asArgs):
+ raise base.InvalidOption('The "--vbox-recording-max-file-size" takes an argument');
+ self.cMbRecordingMax = int(asArgs[iArg]);
+ elif asArgs[iArg] == '--vbox-vm-no-terminate':
+ self.fVmNoTerminate = True;
+ else:
+ # Relevant for selecting VMs to test?
+ if self.oTestVmSet is not None:
+ iRc = self.oTestVmSet.parseOption(asArgs, iArg);
+ if iRc != iArg:
+ return iRc;
+
+ # Hand it to the base class.
+ return base.TestDriver.parseOption(self, asArgs, iArg);
+ return iArg + 1;
+
+ def completeOptions(self):
+ return base.TestDriver.completeOptions(self);
+
+ def getNetworkAdapterNameFromType(self, oNic):
+ """
+ Returns the network adapter name from a given adapter type.
+
+ Returns an empty string if not found / invalid.
+ """
+ sAdpName = '';
+ if oNic.adapterType in (vboxcon.NetworkAdapterType_Am79C970A, \
+ vboxcon.NetworkAdapterType_Am79C973, \
+ vboxcon.NetworkAdapterType_Am79C960):
+ sAdpName = 'pcnet';
+ elif oNic.adapterType in (vboxcon.NetworkAdapterType_I82540EM, \
+ vboxcon.NetworkAdapterType_I82543GC, \
+ vboxcon.NetworkAdapterType_I82545EM):
+ sAdpName = 'e1000';
+ elif oNic.adapterType == vboxcon.NetworkAdapterType_Virtio:
+ sAdpName = 'virtio-net';
+ return sAdpName;
+
+ def getResourceSet(self):
+ asRsrcs = [];
+ if self.oTestVmSet is not None:
+ asRsrcs.extend(self.oTestVmSet.getResourceSet());
+ asRsrcs.extend(base.TestDriver.getResourceSet(self));
+ return asRsrcs;
+
+ def actionExtract(self):
+ return base.TestDriver.actionExtract(self);
+
+ def actionVerify(self):
+ return base.TestDriver.actionVerify(self);
+
+ def actionConfig(self):
+ return base.TestDriver.actionConfig(self);
+
+ def actionExecute(self):
+ return base.TestDriver.actionExecute(self);
+
+ def actionCleanupBefore(self):
+ """
+ Kill any VBoxSVC left behind by a previous test run.
+ """
+ self._killVBoxSVCByPidFile('%s/VBoxSVC.pid' % (self.sScratchPath,));
+ return base.TestDriver.actionCleanupBefore(self);
+
+ def actionCleanupAfter(self):
+ """
+ Clean up the VBox bits and then call the base driver.
+
+ If your test driver overrides this, it should normally call us at the
+ end of the job.
+ """
+ cErrorsEntry = reporter.getErrorCount();
+
+ # Kill any left over VM processes.
+ self._powerOffAllVms();
+
+ # Drop all VBox object references and shutdown xpcom then
+ # terminating VBoxSVC, with extreme prejudice if need be.
+ self._teardownVBoxApi();
+ self._stopVBoxSVC();
+
+ # Add the VBoxSVC and testdriver debug+release log files.
+ if self.fAlwaysUploadLogs or reporter.getErrorCount() > 0:
+ if self.sVBoxSvcLogFile is not None and os.path.isfile(self.sVBoxSvcLogFile):
+ reporter.addLogFile(self.sVBoxSvcLogFile, 'log/debug/svc', 'Debug log file for VBoxSVC');
+ self.sVBoxSvcLogFile = None;
+
+ if self.sSelfLogFile is not None and os.path.isfile(self.sSelfLogFile):
+ reporter.addLogFile(self.sSelfLogFile, 'log/debug/client', 'Debug log file for the test driver');
+ self.sSelfLogFile = None;
+
+ if self.sSessionLogFile is not None and os.path.isfile(self.sSessionLogFile):
+ reporter.addLogFile(self.sSessionLogFile, 'log/debug/session', 'Debug log file for the VM session');
+ self.sSessionLogFile = None;
+
+ sVBoxSvcRelLog = os.path.join(self.sScratchPath, 'VBoxUserHome', 'VBoxSVC.log');
+ if os.path.isfile(sVBoxSvcRelLog):
+ reporter.addLogFile(sVBoxSvcRelLog, 'log/release/svc', 'Release log file for VBoxSVC');
+ for sSuff in [ '.1', '.2', '.3', '.4', '.5', '.6', '.7', '.8' ]:
+ if os.path.isfile(sVBoxSvcRelLog + sSuff):
+ reporter.addLogFile(sVBoxSvcRelLog + sSuff, 'log/release/svc', 'Release log file for VBoxSVC');
+
+ # Finally, call the base driver to wipe the scratch space.
+ fRc = base.TestDriver.actionCleanupAfter(self);
+
+ # Flag failure if the error count increased.
+ if reporter.getErrorCount() > cErrorsEntry:
+ fRc = False;
+ return fRc;
+
+
+ def actionAbort(self):
+ """
+ Terminate VBoxSVC if we've got a pid file.
+ """
+ #
+ # Take default action first, then kill VBoxSVC. The other way around
+ # is problematic since the testscript would continue running and possibly
+ # trigger a new VBoxSVC to start.
+ #
+ fRc1 = base.TestDriver.actionAbort(self);
+ fRc2 = self._killVBoxSVCByPidFile('%s/VBoxSVC.pid' % (self.sScratchPath,));
+ return fRc1 is True and fRc2 is True;
+
+ def onExit(self, iRc):
+ """
+ Stop VBoxSVC if we've started it.
+ """
+ if not self.fVmNoTerminate \
+ and self.oVBoxSvcProcess is not None:
+ reporter.log('*** Shutting down the VBox API... (iRc=%s)' % (iRc,));
+ self._powerOffAllVms();
+ self._teardownVBoxApi();
+ self._stopVBoxSVC();
+ reporter.log('*** VBox API shutdown done.');
+ return base.TestDriver.onExit(self, iRc);
+
+
+ #
+ # Task wait method override.
+ #
+
+ def notifyAboutReadyTask(self, oTask):
+ """
+ Overriding base.TestDriver.notifyAboutReadyTask.
+ """
+ try:
+ self.oVBoxMgr.interruptWaitEvents();
+ reporter.log2('vbox.notifyAboutReadyTask: called interruptWaitEvents');
+ except:
+ reporter.logXcpt('vbox.notifyAboutReadyTask');
+ return base.TestDriver.notifyAboutReadyTask(self, oTask);
+
+ def waitForTasksSleepWorker(self, cMsTimeout):
+ """
+ Overriding base.TestDriver.waitForTasksSleepWorker.
+ """
+ try:
+ rc = self.oVBoxMgr.waitForEvents(int(cMsTimeout));
+ _ = rc; #reporter.log2('vbox.waitForTasksSleepWorker(%u): true (waitForEvents -> %s)' % (cMsTimeout, rc));
+ reporter.doPollWork('vbox.TestDriver.waitForTasksSleepWorker');
+ return True;
+ except KeyboardInterrupt:
+ raise;
+ except:
+ reporter.logXcpt('vbox.waitForTasksSleepWorker');
+ return False;
+
+ #
+ # Utility methods.
+ #
+
+ def processEvents(self, cMsTimeout = 0):
+ """
+ Processes events, returning after the first batch has been processed
+ or the time limit has been reached.
+
+ Only Ctrl-C exception, no return.
+ """
+ try:
+ self.oVBoxMgr.waitForEvents(cMsTimeout);
+ except KeyboardInterrupt:
+ raise;
+ except:
+ pass;
+ return None;
+
+ def processPendingEvents(self):
+ """ processEvents(0) - no waiting. """
+ return self.processEvents(0);
+
+ def sleep(self, cSecs):
+ """
+ Sleep for a specified amount of time, processing XPCOM events all the while.
+ """
+ cMsTimeout = long(cSecs * 1000);
+ msStart = base.timestampMilli();
+ self.processEvents(0);
+ while True:
+ cMsElapsed = base.timestampMilli() - msStart;
+ if cMsElapsed > cMsTimeout:
+ break;
+ #reporter.log2('cMsTimeout=%s - cMsElapsed=%d => %s' % (cMsTimeout, cMsElapsed, cMsTimeout - cMsElapsed));
+ self.processEvents(cMsTimeout - cMsElapsed);
+ return None;
+
+ def _logVmInfoUnsafe(self, oVM): # pylint: disable=too-many-statements,too-many-branches
+ """
+ Internal worker for logVmInfo that is wrapped in try/except.
+ """
+ reporter.log(" Name: %s" % (oVM.name,));
+ reporter.log(" ID: %s" % (oVM.id,));
+ oOsType = self.oVBox.getGuestOSType(oVM.OSTypeId);
+ reporter.log(" OS Type: %s - %s" % (oVM.OSTypeId, oOsType.description,));
+ reporter.log(" Machine state: %s" % (oVM.state,));
+ reporter.log(" Session state: %s" % (oVM.sessionState,));
+ if self.fpApiVer >= 4.2:
+ reporter.log(" Session PID: %u (%#x)" % (oVM.sessionPID, oVM.sessionPID,));
+ else:
+ reporter.log(" Session PID: %u (%#x)" % (oVM.sessionPid, oVM.sessionPid,));
+ if self.fpApiVer >= 5.0:
+ reporter.log(" Session Name: %s" % (oVM.sessionName,));
+ else:
+ reporter.log(" Session Name: %s" % (oVM.sessionType,));
+ reporter.log(" CPUs: %s" % (oVM.CPUCount,));
+ reporter.log(" RAM: %sMB" % (oVM.memorySize,));
+ if self.fpApiVer >= 6.1 and hasattr(oVM, 'graphicsAdapter'):
+ reporter.log(" VRAM: %sMB" % (oVM.graphicsAdapter.VRAMSize,));
+ reporter.log(" Monitors: %s" % (oVM.graphicsAdapter.monitorCount,));
+ reporter.log(" GraphicsController: %s"
+ % (self.oVBoxMgr.getEnumValueName('GraphicsControllerType', # pylint: disable=not-callable
+ oVM.graphicsAdapter.graphicsControllerType),));
+ else:
+ reporter.log(" VRAM: %sMB" % (oVM.VRAMSize,));
+ reporter.log(" Monitors: %s" % (oVM.monitorCount,));
+ reporter.log(" GraphicsController: %s"
+ % (self.oVBoxMgr.getEnumValueName('GraphicsControllerType', oVM.graphicsControllerType),)); # pylint: disable=not-callable
+ reporter.log(" Chipset: %s" % (self.oVBoxMgr.getEnumValueName('ChipsetType', oVM.chipsetType),)); # pylint: disable=not-callable
+ if self.fpApiVer >= 6.2 and hasattr(vboxcon, 'IommuType_None'):
+ reporter.log(" IOMMU: %s" % (self.oVBoxMgr.getEnumValueName('IommuType', oVM.iommuType),)); # pylint: disable=not-callable
+ reporter.log(" Firmware: %s" % (self.oVBoxMgr.getEnumValueName('FirmwareType', oVM.firmwareType),)); # pylint: disable=not-callable
+ reporter.log(" HwVirtEx: %s" % (oVM.getHWVirtExProperty(vboxcon.HWVirtExPropertyType_Enabled),));
+ reporter.log(" VPID support: %s" % (oVM.getHWVirtExProperty(vboxcon.HWVirtExPropertyType_VPID),));
+ reporter.log(" Nested paging: %s" % (oVM.getHWVirtExProperty(vboxcon.HWVirtExPropertyType_NestedPaging),));
+ atTypes = [
+ ( 'CPUPropertyType_PAE', 'PAE: '),
+ ( 'CPUPropertyType_LongMode', 'Long-mode: '),
+ ( 'CPUPropertyType_HWVirt', 'Nested VT-x/AMD-V: '),
+ ( 'CPUPropertyType_APIC', 'APIC: '),
+ ( 'CPUPropertyType_X2APIC', 'X2APIC: '),
+ ( 'CPUPropertyType_TripleFaultReset', 'TripleFaultReset: '),
+ ( 'CPUPropertyType_IBPBOnVMExit', 'IBPBOnVMExit: '),
+ ( 'CPUPropertyType_SpecCtrl', 'SpecCtrl: '),
+ ( 'CPUPropertyType_SpecCtrlByHost', 'SpecCtrlByHost: '),
+ ];
+ for sEnumValue, sDesc in atTypes:
+ if hasattr(vboxcon, sEnumValue):
+ reporter.log(" %s%s" % (sDesc, oVM.getCPUProperty(getattr(vboxcon, sEnumValue)),));
+ reporter.log(" ACPI: %s" % (oVM.BIOSSettings.ACPIEnabled,));
+ reporter.log(" IO-APIC: %s" % (oVM.BIOSSettings.IOAPICEnabled,));
+ if self.fpApiVer >= 3.2:
+ if self.fpApiVer >= 4.2:
+ reporter.log(" HPET: %s" % (oVM.HPETEnabled,));
+ else:
+ reporter.log(" HPET: %s" % (oVM.hpetEnabled,));
+ if self.fpApiVer >= 6.1 and hasattr(oVM, 'graphicsAdapter'):
+ reporter.log(" 3D acceleration: %s" % (oVM.graphicsAdapter.accelerate3DEnabled,));
+ reporter.log(" 2D acceleration: %s" % (oVM.graphicsAdapter.accelerate2DVideoEnabled,));
+ else:
+ reporter.log(" 3D acceleration: %s" % (oVM.accelerate3DEnabled,));
+ reporter.log(" 2D acceleration: %s" % (oVM.accelerate2DVideoEnabled,));
+ reporter.log(" TeleporterEnabled: %s" % (oVM.teleporterEnabled,));
+ reporter.log(" TeleporterPort: %s" % (oVM.teleporterPort,));
+ reporter.log(" TeleporterAddress: %s" % (oVM.teleporterAddress,));
+ reporter.log(" TeleporterPassword: %s" % (oVM.teleporterPassword,));
+ reporter.log(" Clipboard mode: %s" % (oVM.clipboardMode,));
+ if self.fpApiVer >= 5.0:
+ reporter.log(" Drag and drop mode: %s" % (oVM.dnDMode,));
+ elif self.fpApiVer >= 4.3:
+ reporter.log(" Drag and drop mode: %s" % (oVM.dragAndDropMode,));
+ if self.fpApiVer >= 4.0:
+ reporter.log(" VRDP server: %s" % (oVM.VRDEServer.enabled,));
+ try: sPorts = oVM.VRDEServer.getVRDEProperty("TCP/Ports");
+ except: sPorts = "";
+ reporter.log(" VRDP server ports: %s" % (sPorts,));
+ reporter.log(" VRDP auth: %s (%s)" % (oVM.VRDEServer.authType, oVM.VRDEServer.authLibrary,));
+ else:
+ reporter.log(" VRDP server: %s" % (oVM.VRDPServer.enabled,));
+ reporter.log(" VRDP server ports: %s" % (oVM.VRDPServer.ports,));
+ reporter.log(" Last changed: %s" % (oVM.lastStateChange,));
+
+ aoControllers = self.oVBoxMgr.getArray(oVM, 'storageControllers')
+ if aoControllers:
+ reporter.log(" Controllers:");
+ for oCtrl in aoControllers:
+ reporter.log(" %s %s bus: %s type: %s" % (oCtrl.name, oCtrl.controllerType, oCtrl.bus, oCtrl.controllerType,));
+ if self.fpApiVer >= 7.0:
+ oAdapter = oVM.audioSettings.adapter;
+ else:
+ oAdapter = oVM.audioAdapter;
+ reporter.log(" AudioController: %s"
+ % (self.oVBoxMgr.getEnumValueName('AudioControllerType', oAdapter.audioController),)); # pylint: disable=not-callable
+ reporter.log(" AudioEnabled: %s" % (oAdapter.enabled,));
+ reporter.log(" Host AudioDriver: %s"
+ % (self.oVBoxMgr.getEnumValueName('AudioDriverType', oAdapter.audioDriver),)); # pylint: disable=not-callable
+
+ self.processPendingEvents();
+ aoAttachments = self.oVBoxMgr.getArray(oVM, 'mediumAttachments')
+ if aoAttachments:
+ reporter.log(" Attachments:");
+ for oAtt in aoAttachments:
+ sCtrl = "Controller: %s port: %s device: %s type: %s" % (oAtt.controller, oAtt.port, oAtt.device, oAtt.type);
+ oMedium = oAtt.medium
+ if oAtt.type == vboxcon.DeviceType_HardDisk:
+ reporter.log(" %s: HDD" % sCtrl);
+ reporter.log(" Id: %s" % (oMedium.id,));
+ reporter.log(" Name: %s" % (oMedium.name,));
+ reporter.log(" Format: %s" % (oMedium.format,));
+ reporter.log(" Location: %s" % (oMedium.location,));
+
+ if oAtt.type == vboxcon.DeviceType_DVD:
+ reporter.log(" %s: DVD" % sCtrl);
+ if oMedium:
+ reporter.log(" Id: %s" % (oMedium.id,));
+ reporter.log(" Name: %s" % (oMedium.name,));
+ if oMedium.hostDrive:
+ reporter.log(" Host DVD %s" % (oMedium.location,));
+ if oAtt.passthrough:
+ reporter.log(" [passthrough mode]");
+ else:
+ reporter.log(" Virtual image: %s" % (oMedium.location,));
+ reporter.log(" Size: %s" % (oMedium.size,));
+ else:
+ reporter.log(" empty");
+
+ if oAtt.type == vboxcon.DeviceType_Floppy:
+ reporter.log(" %s: Floppy" % sCtrl);
+ if oMedium:
+ reporter.log(" Id: %s" % (oMedium.id,));
+ reporter.log(" Name: %s" % (oMedium.name,));
+ if oMedium.hostDrive:
+ reporter.log(" Host floppy: %s" % (oMedium.location,));
+ else:
+ reporter.log(" Virtual image: %s" % (oMedium.location,));
+ reporter.log(" Size: %s" % (oMedium.size,));
+ else:
+ reporter.log(" empty");
+ self.processPendingEvents();
+
+ reporter.log(" Network Adapter:");
+ for iSlot in range(0, 32):
+ try: oNic = oVM.getNetworkAdapter(iSlot)
+ except: break;
+ if not oNic.enabled:
+ reporter.log2(" slot #%d found but not enabled, skipping" % (iSlot,));
+ continue;
+ reporter.log(" slot #%d: type: %s (%s) MAC Address: %s lineSpeed: %s"
+ % (iSlot, self.oVBoxMgr.getEnumValueName('NetworkAdapterType', oNic.adapterType), # pylint: disable=not-callable
+ oNic.adapterType, oNic.MACAddress, oNic.lineSpeed) );
+
+ if oNic.attachmentType == vboxcon.NetworkAttachmentType_NAT:
+ reporter.log(" attachmentType: NAT (%s)" % (oNic.attachmentType,));
+ if self.fpApiVer >= 4.1:
+ reporter.log(" nat-network: %s" % (oNic.NATNetwork,));
+ if self.fpApiVer >= 7.0 and hasattr(oNic.NATEngine, 'localhostReachable'):
+ reporter.log(" localhostReachable: %s" % (oNic.NATEngine.localhostReachable,));
+
+ elif oNic.attachmentType == vboxcon.NetworkAttachmentType_Bridged:
+ reporter.log(" attachmentType: Bridged (%s)" % (oNic.attachmentType,));
+ if self.fpApiVer >= 4.1:
+ reporter.log(" hostInterface: %s" % (oNic.bridgedInterface,));
+ else:
+ reporter.log(" hostInterface: %s" % (oNic.hostInterface,));
+ elif oNic.attachmentType == vboxcon.NetworkAttachmentType_Internal:
+ reporter.log(" attachmentType: Internal (%s)" % (oNic.attachmentType,));
+ reporter.log(" intnet-name: %s" % (oNic.internalNetwork,));
+ elif oNic.attachmentType == vboxcon.NetworkAttachmentType_HostOnly:
+ reporter.log(" attachmentType: HostOnly (%s)" % (oNic.attachmentType,));
+ if self.fpApiVer >= 4.1:
+ reporter.log(" hostInterface: %s" % (oNic.hostOnlyInterface,));
+ else:
+ reporter.log(" hostInterface: %s" % (oNic.hostInterface,));
+ else:
+ if self.fpApiVer >= 7.0:
+ if oNic.attachmentType == vboxcon.NetworkAttachmentType_HostOnlyNetwork:
+ reporter.log(" attachmentType: HostOnlyNetwork (%s)" % (oNic.attachmentType,));
+ reporter.log(" hostonly-net: %s" % (oNic.hostOnlyNetwork,));
+ elif self.fpApiVer >= 4.1:
+ if oNic.attachmentType == vboxcon.NetworkAttachmentType_Generic:
+ reporter.log(" attachmentType: Generic (%s)" % (oNic.attachmentType,));
+ reporter.log(" generic-driver: %s" % (oNic.GenericDriver,));
+ else:
+ reporter.log(" attachmentType: unknown-%s" % (oNic.attachmentType,));
+ else:
+ reporter.log(" attachmentType: unknown-%s" % (oNic.attachmentType,));
+ if oNic.traceEnabled:
+ reporter.log(" traceFile: %s" % (oNic.traceFile,));
+ self.processPendingEvents();
+
+ reporter.log(" Serial ports:");
+ for iSlot in range(0, 8):
+ try: oPort = oVM.getSerialPort(iSlot)
+ except: break;
+ if oPort is not None and oPort.enabled:
+ enmHostMode = oPort.hostMode;
+ reporter.log(" slot #%d: hostMode: %s (%s) I/O port: %s IRQ: %s server: %s path: %s" %
+ (iSlot, self.oVBoxMgr.getEnumValueName('PortMode', enmHostMode), # pylint: disable=not-callable
+ enmHostMode, oPort.IOBase, oPort.IRQ, oPort.server, oPort.path,) );
+ self.processPendingEvents();
+
+ return True;
+
+ def logVmInfo(self, oVM): # pylint: disable=too-many-statements,too-many-branches
+ """
+ Logs VM configuration details.
+
+ This is copy, past, search, replace and edit of infoCmd from vboxshell.py.
+ """
+ try:
+ fRc = self._logVmInfoUnsafe(oVM);
+ except:
+ reporter.logXcpt();
+ fRc = False;
+ return fRc;
+
+ def logVmInfoByName(self, sName):
+ """
+ logVmInfo + getVmByName.
+ """
+ return self.logVmInfo(self.getVmByName(sName));
+
+ def tryFindGuestOsId(self, sIdOrDesc):
+ """
+ Takes a guest OS ID or Description and returns the ID.
+ If nothing matching it is found, the input is returned unmodified.
+ """
+
+ if self.fpApiVer >= 4.0:
+ if sIdOrDesc == 'Solaris (64 bit)':
+ sIdOrDesc = 'Oracle Solaris 10 5/09 and earlier (64 bit)';
+
+ try:
+ aoGuestTypes = self.oVBoxMgr.getArray(self.oVBox, 'GuestOSTypes');
+ except:
+ reporter.logXcpt();
+ else:
+ for oGuestOS in aoGuestTypes:
+ try:
+ sId = oGuestOS.id;
+ sDesc = oGuestOS.description;
+ except:
+ reporter.logXcpt();
+ else:
+ if sIdOrDesc in (sId, sDesc,):
+ sIdOrDesc = sId;
+ break;
+ self.processPendingEvents();
+ return sIdOrDesc
+
+ def resourceFindVmHd(self, sVmName, sFlavor):
+ """
+ Search the test resources for the most recent VM HD.
+
+ Returns path relative to the test resource root.
+ """
+ ## @todo implement a proper search algo here.
+ return '4.2/' + sFlavor + '/' + sVmName + '/t-' + sVmName + '.vdi';
+
+
+ #
+ # VM Api wrappers that logs errors, hides exceptions and other details.
+ #
+
+ def createTestVMOnly(self, sName, sKind):
+ """
+ Creates and register a test VM without doing any kind of configuration.
+
+ Returns VM object (IMachine) on success, None on failure.
+ """
+ if not self.importVBoxApi():
+ return None;
+
+ # create + register the VM
+ try:
+ if self.fpApiVer >= 7.0: # Introduces VM encryption (three new parameters, empty for now).
+ oVM = self.oVBox.createMachine("", sName, [], self.tryFindGuestOsId(sKind), "", "", "", "");
+ elif self.fpApiVer >= 4.2: # Introduces grouping (third parameter, empty for now).
+ oVM = self.oVBox.createMachine("", sName, [], self.tryFindGuestOsId(sKind), "");
+ elif self.fpApiVer >= 4.0:
+ oVM = self.oVBox.createMachine("", sName, self.tryFindGuestOsId(sKind), "", False);
+ elif self.fpApiVer >= 3.2:
+ oVM = self.oVBox.createMachine(sName, self.tryFindGuestOsId(sKind), "", "", False);
+ else:
+ oVM = self.oVBox.createMachine(sName, self.tryFindGuestOsId(sKind), "", "");
+ try:
+ oVM.saveSettings();
+ try:
+ self.oVBox.registerMachine(oVM);
+ return oVM;
+ except:
+ reporter.logXcpt();
+ raise;
+ except:
+ reporter.logXcpt();
+ if self.fpApiVer >= 4.0:
+ try:
+ if self.fpApiVer >= 4.3:
+ oProgress = oVM.deleteConfig([]);
+ else:
+ oProgress = oVM.delete(None);
+ self.waitOnProgress(oProgress);
+ except:
+ reporter.logXcpt();
+ else:
+ try: oVM.deleteSettings();
+ except: reporter.logXcpt();
+ raise;
+ except:
+ reporter.errorXcpt('failed to create vm "%s"' % (sName));
+ return None;
+
+ # pylint: disable=too-many-arguments,too-many-locals,too-many-statements,too-many-branches
+ def createTestVM(self,
+ sName,
+ iGroup,
+ sHd = None,
+ cMbRam = None,
+ cCpus = 1,
+ fVirtEx = None,
+ fNestedPaging = None,
+ sDvdImage = None,
+ sKind = "Other",
+ fIoApic = None,
+ fNstHwVirt = None,
+ fPae = None,
+ fFastBootLogo = True,
+ eNic0Type = None,
+ eNic0AttachType = None,
+ sNic0NetName = 'default',
+ sNic0MacAddr = 'grouped',
+ sFloppy = None,
+ fNatForwardingForTxs = None,
+ sHddControllerType = 'IDE Controller',
+ fVmmDevTestingPart = None,
+ fVmmDevTestingMmio = False,
+ sFirmwareType = 'bios',
+ sChipsetType = 'piix3',
+ sIommuType = 'none',
+ sDvdControllerType = 'IDE Controller',
+ sCom1RawFile = None):
+ """
+ Creates a test VM with a immutable HD from the test resources.
+ """
+ # create + register the VM
+ oVM = self.createTestVMOnly(sName, sKind);
+ if not oVM:
+ return None;
+
+ # Configure the VM.
+ fRc = True;
+ oSession = self.openSession(oVM);
+ if oSession is not None:
+ fRc = oSession.setupPreferredConfig();
+
+ if fRc and cMbRam is not None :
+ fRc = oSession.setRamSize(cMbRam);
+ if fRc and cCpus is not None:
+ fRc = oSession.setCpuCount(cCpus);
+ if fRc and fVirtEx is not None:
+ fRc = oSession.enableVirtEx(fVirtEx);
+ if fRc and fNestedPaging is not None:
+ fRc = oSession.enableNestedPaging(fNestedPaging);
+ if fRc and fIoApic is not None:
+ fRc = oSession.enableIoApic(fIoApic);
+ if fRc and fNstHwVirt is not None:
+ fRc = oSession.enableNestedHwVirt(fNstHwVirt);
+ if fRc and fPae is not None:
+ fRc = oSession.enablePae(fPae);
+ if fRc and sDvdImage is not None:
+ fRc = oSession.attachDvd(sDvdImage, sDvdControllerType);
+ if fRc and sHd is not None:
+ fRc = oSession.attachHd(sHd, sHddControllerType);
+ if fRc and sFloppy is not None:
+ fRc = oSession.attachFloppy(sFloppy);
+ if fRc and eNic0Type is not None:
+ fRc = oSession.setNicType(eNic0Type, 0);
+ if fRc and (eNic0AttachType is not None or (sNic0NetName is not None and sNic0NetName != 'default')):
+ fRc = oSession.setNicAttachment(eNic0AttachType, sNic0NetName, 0);
+ if fRc and sNic0MacAddr is not None:
+ if sNic0MacAddr == 'grouped':
+ sNic0MacAddr = '%02X' % (iGroup);
+ fRc = oSession.setNicMacAddress(sNic0MacAddr, 0);
+ # Needed to reach the host (localhost) from the guest. See xTracker #9896.
+ if fRc and self.fpApiVer >= 7.0:
+ fRc = oSession.setNicLocalhostReachable(True, 0);
+ if fRc and fNatForwardingForTxs is True:
+ fRc = oSession.setupNatForwardingForTxs();
+ if fRc and fFastBootLogo is not None:
+ fRc = oSession.setupBootLogo(fFastBootLogo);
+ if fRc and self.fEnableVrdp:
+ fRc = oSession.setupVrdp(True, self.uVrdpBasePort + iGroup);
+ if fRc and fVmmDevTestingPart is not None:
+ fRc = oSession.enableVmmDevTestingPart(fVmmDevTestingPart, fVmmDevTestingMmio);
+ if fRc and sFirmwareType == 'bios':
+ fRc = oSession.setFirmwareType(vboxcon.FirmwareType_BIOS);
+ elif fRc and sFirmwareType == 'efi':
+ fRc = oSession.setFirmwareType(vboxcon.FirmwareType_EFI);
+ if fRc and self.fEnableDebugger:
+ fRc = oSession.setExtraData('VBoxInternal/DBGC/Enabled', '1');
+ if fRc and self.fRecordingEnabled:
+ try:
+ if self.fpApiVer >= 6.1: # Only for VBox 6.1 and up now.
+ reporter.log('Recording enabled');
+ if self.cSecsRecordingMax > 0:
+ reporter.log('Recording time limit is set to %d seconds' % (self.cSecsRecordingMax));
+ if self.cMbRecordingMax > 0:
+ reporter.log('Recording file limit is set to %d MB' % (self.cMbRecordingMax));
+ oRecSettings = oSession.o.machine.recordingSettings;
+ oRecSettings.enabled = True;
+ aoScreens = self.oVBoxMgr.getArray(oRecSettings, 'screens');
+ for oScreen in aoScreens:
+ try:
+ oScreen.enabled = True;
+ sRecFile = os.path.join(self.sScratchPath, "recording-%s.webm" % (sName));
+ oScreen.filename = sRecFile;
+ sRecFile = oScreen.filename; # Get back the file from Main, in case it was modified somehow.
+ dRecFile = { 'id' : oScreen.id, 'file' : sRecFile };
+ self.adRecordingFiles.append(dRecFile);
+ if self.fpApiVer >= 7.0:
+ aFeatures = [ vboxcon.RecordingFeature_Video, ];
+ if self.fRecordingAudio:
+ aFeatures.append(vboxcon.RecordingFeature_Audio);
+ try:
+ oScreen.setFeatures(aFeatures);
+ except: ## @todo Figure out why this is needed on Windows.
+ oScreen.features = aFeatures;
+ else: # <= VBox 6.1 the feature were kept as a ULONG.
+ uFeatures = vboxcon.RecordingFeature_Video;
+ if self.fRecordingAudio:
+ uFeatures = uFeatures | vboxcon.RecordingFeature_Audio;
+ oScreen.features = uFeatures;
+ reporter.log2('Recording screen %d to "%s"' % (dRecFile['id'], dRecFile['file'],));
+ oScreen.maxTime = self.cSecsRecordingMax;
+ oScreen.maxFileSize = self.cMbRecordingMax;
+ except:
+ reporter.errorXcpt('failed to configure recording for "%s" (screen %d)' % (sName, oScreen.id));
+ else:
+ # Not fatal.
+ reporter.log('Recording only available for VBox >= 6.1, sorry!')
+ except:
+ reporter.errorXcpt('failed to configure recording for "%s"' % (sName));
+ if fRc and sChipsetType == 'piix3':
+ fRc = oSession.setChipsetType(vboxcon.ChipsetType_PIIX3);
+ elif fRc and sChipsetType == 'ich9':
+ fRc = oSession.setChipsetType(vboxcon.ChipsetType_ICH9);
+ if fRc and sCom1RawFile:
+ fRc = oSession.setupSerialToRawFile(0, sCom1RawFile);
+ if fRc and self.fpApiVer >= 6.2 and hasattr(vboxcon, 'IommuType_AMD') and sIommuType == 'amd':
+ fRc = oSession.setIommuType(vboxcon.IommuType_AMD);
+ elif fRc and self.fpApiVer >= 6.2 and hasattr(vboxcon, 'IommuType_Intel') and sIommuType == 'intel':
+ fRc = oSession.setIommuType(vboxcon.IommuType_Intel);
+
+ if fRc: fRc = oSession.saveSettings();
+ if not fRc: oSession.discardSettings(True);
+ oSession.close();
+ if not fRc:
+ if self.fpApiVer >= 4.0:
+ try: oVM.unregister(vboxcon.CleanupMode_Full);
+ except: reporter.logXcpt();
+ try:
+ if self.fpApiVer >= 4.3:
+ oProgress = oVM.deleteConfig([]);
+ else:
+ oProgress = oVM.delete([]);
+ self.waitOnProgress(oProgress);
+ except:
+ reporter.logXcpt();
+ else:
+ try: self.oVBox.unregisterMachine(oVM.id);
+ except: reporter.logXcpt();
+ try: oVM.deleteSettings();
+ except: reporter.logXcpt();
+ return None;
+
+ # success.
+ reporter.log('created "%s" with name "%s"' % (oVM.id, sName));
+ self.aoVMs.append(oVM);
+ self.logVmInfo(oVM); # testing...
+ return oVM;
+ # pylint: enable=too-many-arguments,too-many-locals,too-many-statements
+
+ def createTestVmWithDefaults(self, # pylint: disable=too-many-arguments
+ sName,
+ iGroup,
+ sKind,
+ sDvdImage = None,
+ fFastBootLogo = True,
+ eNic0AttachType = None,
+ sNic0NetName = 'default',
+ sNic0MacAddr = 'grouped',
+ fVmmDevTestingPart = None,
+ fVmmDevTestingMmio = False,
+ sCom1RawFile = None):
+ """
+ Creates a test VM with all defaults and no HDs.
+ """
+ # create + register the VM
+ oVM = self.createTestVMOnly(sName, sKind);
+ if oVM is not None:
+ # Configure the VM with defaults according to sKind.
+ fRc = True;
+ oSession = self.openSession(oVM);
+ if oSession is not None:
+ if self.fpApiVer >= 6.0:
+ try:
+ oSession.o.machine.applyDefaults('');
+ except:
+ reporter.errorXcpt('failed to apply defaults to vm "%s"' % (sName,));
+ fRc = False;
+ else:
+ reporter.error("Implement applyDefaults for vbox version %s" % (self.fpApiVer,));
+ #fRc = oSession.setupPreferredConfig();
+ fRc = False;
+
+ # Apply the specified configuration:
+ if fRc and sDvdImage is not None:
+ #fRc = oSession.insertDvd(sDvdImage); # attachDvd
+ reporter.error('Implement: oSession.insertDvd(%s)' % (sDvdImage,));
+ fRc = False;
+
+ if fRc and fFastBootLogo is not None:
+ fRc = oSession.setupBootLogo(fFastBootLogo);
+
+ if fRc and (eNic0AttachType is not None or (sNic0NetName is not None and sNic0NetName != 'default')):
+ fRc = oSession.setNicAttachment(eNic0AttachType, sNic0NetName, 0);
+ if fRc and sNic0MacAddr is not None:
+ if sNic0MacAddr == 'grouped':
+ sNic0MacAddr = '%02X' % (iGroup,);
+ fRc = oSession.setNicMacAddress(sNic0MacAddr, 0);
+ # Needed to reach the host (localhost) from the guest. See xTracker #9896.
+ if fRc and self.fpApiVer >= 7.0:
+ fRc = oSession.setNicLocalhostReachable(True, 0);
+
+ if fRc and self.fEnableVrdp:
+ fRc = oSession.setupVrdp(True, self.uVrdpBasePort + iGroup);
+
+ if fRc and fVmmDevTestingPart is not None:
+ fRc = oSession.enableVmmDevTestingPart(fVmmDevTestingPart, fVmmDevTestingMmio);
+
+ if fRc and sCom1RawFile:
+ fRc = oSession.setupSerialToRawFile(0, sCom1RawFile);
+
+ # Save the settings if we were successfull, otherwise discard them.
+ if fRc:
+ fRc = oSession.saveSettings();
+ if not fRc:
+ oSession.discardSettings(True);
+ oSession.close();
+
+ if fRc is True:
+ # If we've been successful, add the VM to the list and return it.
+ # success.
+ reporter.log('created "%s" with name "%s"' % (oVM.id, sName, ));
+ self.aoVMs.append(oVM);
+ self.logVmInfo(oVM); # testing...
+ return oVM;
+
+ # Failed. Unregister the machine and delete it.
+ if self.fpApiVer >= 4.0:
+ try: oVM.unregister(vboxcon.CleanupMode_Full);
+ except: reporter.logXcpt();
+ try:
+ if self.fpApiVer >= 4.3:
+ oProgress = oVM.deleteConfig([]);
+ else:
+ oProgress = oVM.delete([]);
+ self.waitOnProgress(oProgress);
+ except:
+ reporter.logXcpt();
+ else:
+ try: self.oVBox.unregisterMachine(oVM.id);
+ except: reporter.logXcpt();
+ try: oVM.deleteSettings();
+ except: reporter.logXcpt();
+ return None;
+
+ def addTestMachine(self, sNameOrId, fQuiet = False):
+ """
+ Adds an already existing (that is, configured) test VM to the
+ test VM list.
+
+ Returns the VM object on success, None if failed.
+ """
+ # find + add the VM to the list.
+ oVM = None;
+ try:
+ if self.fpApiVer >= 4.0:
+ oVM = self.oVBox.findMachine(sNameOrId);
+ else:
+ reporter.error('fpApiVer=%s - did you remember to initialize the API' % (self.fpApiVer,));
+ except:
+ reporter.errorXcpt('could not find vm "%s"' % (sNameOrId,));
+
+ if oVM:
+ self.aoVMs.append(oVM);
+ if not fQuiet:
+ reporter.log('Added "%s" with name "%s"' % (oVM.id, sNameOrId));
+ self.logVmInfo(oVM);
+ return oVM;
+
+ def forgetTestMachine(self, oVM, fQuiet = False):
+ """
+ Forget about an already known test VM in the test VM list.
+
+ Returns True on success, False if failed.
+ """
+ try:
+ sUuid = oVM.id;
+ sName = oVM.name;
+ except:
+ reporter.errorXcpt('failed to get the UUID for VM "%s"' % (oVM,));
+ return False;
+ try:
+ self.aoVMs.remove(oVM);
+ if not fQuiet:
+ reporter.log('Removed "%s" with name "%s"' % (sUuid, sName));
+ except:
+ reporter.errorXcpt('could not find vm "%s"' % (sName,));
+ return False;
+ return True;
+
+ def openSession(self, oVM):
+ """
+ Opens a session for the VM. Returns the a Session wrapper object that
+ will automatically close the session when the wrapper goes out of scope.
+
+ On failure None is returned and an error is logged.
+ """
+ try:
+ sUuid = oVM.id;
+ except:
+ reporter.errorXcpt('failed to get the UUID for VM "%s"' % (oVM,));
+ return None;
+
+ # This loop is a kludge to deal with us racing the closing of the
+ # direct session of a previous VM run. See waitOnDirectSessionClose.
+ for i in range(10):
+ try:
+ if self.fpApiVer <= 3.2:
+ oSession = self.oVBoxMgr.openMachineSession(sUuid);
+ else:
+ oSession = self.oVBoxMgr.openMachineSession(oVM);
+ break;
+ except:
+ if i == 9:
+ reporter.errorXcpt('failed to open session for "%s" ("%s")' % (sUuid, oVM));
+ return None;
+ if i > 0:
+ reporter.logXcpt('warning: failed to open session for "%s" ("%s") - retrying in %u secs' % (sUuid, oVM, i));
+ self.waitOnDirectSessionClose(oVM, 5000 + i * 1000);
+ from testdriver.vboxwrappers import SessionWrapper;
+ return SessionWrapper(oSession, oVM, self.oVBox, self.oVBoxMgr, self, False);
+
+ #
+ # Guest locations.
+ #
+
+ @staticmethod
+ def getGuestTempDir(oTestVm):
+ """
+ Helper for finding a temporary directory in the test VM.
+
+ Note! It may be necessary to create it!
+ """
+ if oTestVm.isWindows():
+ return "C:\\Temp";
+ if oTestVm.isOS2():
+ return "C:\\Temp";
+ return '/var/tmp';
+
+ @staticmethod
+ def getGuestSystemDir(oTestVm, sPathPrefix = ''):
+ """
+ Helper for finding a system directory in the test VM that we can play around with.
+ sPathPrefix can be used to specify other directories, such as /usr/local/bin/ or /usr/bin, for instance.
+
+ On Windows this is always the System32 directory, so this function can be used as
+ basis for locating other files in or under that directory.
+ """
+ if oTestVm.isWindows():
+ return oTestVm.pathJoin(TestDriver.getGuestWinDir(oTestVm), 'System32');
+ if oTestVm.isOS2():
+ return 'C:\\OS2\\DLL';
+
+ # OL / RHEL symlinks "/bin"/ to "/usr/bin". To avoid (unexpectedly) following symlinks, use "/usr/bin" then instead.
+ if not sPathPrefix \
+ and oTestVm.sKind in ('Oracle_64', 'Oracle'): ## @todo Does this apply for "RedHat" as well?
+ return "/usr/bin";
+
+ return sPathPrefix + "/bin";
+
+ @staticmethod
+ def getGuestSystemAdminDir(oTestVm, sPathPrefix = ''):
+ """
+ Helper for finding a system admin directory ("sbin") in the test VM that we can play around with.
+ sPathPrefix can be used to specify other directories, such as /usr/local/sbin/ or /usr/sbin, for instance.
+
+ On Windows this is always the System32 directory, so this function can be used as
+ basis for locating other files in or under that directory.
+ On UNIX-y systems this always is the "sh" shell to guarantee a common shell syntax.
+ """
+ if oTestVm.isWindows():
+ return oTestVm.pathJoin(TestDriver.getGuestWinDir(oTestVm), 'System32');
+ if oTestVm.isOS2():
+ return 'C:\\OS2\\DLL'; ## @todo r=andy Not sure here.
+
+ # OL / RHEL symlinks "/sbin"/ to "/usr/sbin". To avoid (unexpectedly) following symlinks, use "/usr/sbin" then instead.
+ if not sPathPrefix \
+ and oTestVm.sKind in ('Oracle_64', 'Oracle'): ## @todo Does this apply for "RedHat" as well?
+ return "/usr/sbin";
+
+ return sPathPrefix + "/sbin";
+
+ @staticmethod
+ def getGuestWinDir(oTestVm):
+ """
+ Helper for finding the Windows directory in the test VM that we can play around with.
+ ASSUMES that we always install Windows on drive C.
+
+ Returns the Windows directory, or an empty string when executed on a non-Windows guest (asserts).
+ """
+ sWinDir = '';
+ if oTestVm.isWindows():
+ if oTestVm.sKind in ['WindowsNT4', 'WindowsNT3x',]:
+ sWinDir = 'C:\\WinNT\\';
+ else:
+ sWinDir = 'C:\\Windows\\';
+ assert sWinDir != '', 'Retrieving Windows directory for non-Windows OS';
+ return sWinDir;
+
+ @staticmethod
+ def getGuestSystemShell(oTestVm):
+ """
+ Helper for finding the default system shell in the test VM.
+ """
+ if oTestVm.isWindows():
+ return TestDriver.getGuestSystemDir(oTestVm) + '\\cmd.exe';
+ if oTestVm.isOS2():
+ return TestDriver.getGuestSystemDir(oTestVm) + '\\..\\CMD.EXE';
+ return "/bin/sh";
+
+ @staticmethod
+ def getGuestSystemFileForReading(oTestVm):
+ """
+ Helper for finding a file in the test VM that we can read.
+ """
+ if oTestVm.isWindows():
+ return TestDriver.getGuestSystemDir(oTestVm) + '\\ntdll.dll';
+ if oTestVm.isOS2():
+ return TestDriver.getGuestSystemDir(oTestVm) + '\\DOSCALL1.DLL';
+ return "/bin/sh";
+
+ def getVmByName(self, sName):
+ """
+ Get a test VM by name. Returns None if not found, logged.
+ """
+ # Look it up in our 'cache'.
+ for oVM in self.aoVMs:
+ try:
+ #reporter.log2('cur: %s / %s (oVM=%s)' % (oVM.name, oVM.id, oVM));
+ if oVM.name == sName:
+ return oVM;
+ except:
+ reporter.errorXcpt('failed to get the name from the VM "%s"' % (oVM));
+
+ # Look it up the standard way.
+ return self.addTestMachine(sName, fQuiet = True);
+
+ def getVmByUuid(self, sUuid):
+ """
+ Get a test VM by uuid. Returns None if not found, logged.
+ """
+ # Look it up in our 'cache'.
+ for oVM in self.aoVMs:
+ try:
+ if oVM.id == sUuid:
+ return oVM;
+ except:
+ reporter.errorXcpt('failed to get the UUID from the VM "%s"' % (oVM));
+
+ # Look it up the standard way.
+ return self.addTestMachine(sUuid, fQuiet = True);
+
+ def waitOnProgress(self, oProgress, cMsTimeout = 1000000, fErrorOnTimeout = True, cMsInterval = 1000):
+ """
+ Waits for a progress object to complete. Returns the status code.
+ """
+ # Wait for progress no longer than cMsTimeout time period.
+ tsStart = datetime.datetime.now()
+ while True:
+ self.processPendingEvents();
+ try:
+ if oProgress.completed:
+ break;
+ except:
+ return -1;
+ self.processPendingEvents();
+
+ tsNow = datetime.datetime.now()
+ tsDelta = tsNow - tsStart
+ if ((tsDelta.microseconds + tsDelta.seconds * 1000000) // 1000) > cMsTimeout:
+ if fErrorOnTimeout:
+ reporter.errorTimeout('Timeout while waiting for progress.')
+ return -1
+
+ reporter.doPollWork('vbox.TestDriver.waitOnProgress');
+ try: oProgress.waitForCompletion(cMsInterval);
+ except: return -2;
+
+ try: rc = oProgress.resultCode;
+ except: rc = -2;
+ self.processPendingEvents();
+ return rc;
+
+ def waitOnDirectSessionClose(self, oVM, cMsTimeout):
+ """
+ Waits for the VM process to close it's current direct session.
+
+ Returns None.
+ """
+ # Get the original values so we're not subject to
+ try:
+ eCurState = oVM.sessionState;
+ if self.fpApiVer >= 5.0:
+ sCurName = sOrgName = oVM.sessionName;
+ else:
+ sCurName = sOrgName = oVM.sessionType;
+ if self.fpApiVer >= 4.2:
+ iCurPid = iOrgPid = oVM.sessionPID;
+ else:
+ iCurPid = iOrgPid = oVM.sessionPid;
+ except Exception as oXcpt:
+ if ComError.notEqual(oXcpt, ComError.E_ACCESSDENIED):
+ reporter.logXcpt();
+ self.processPendingEvents();
+ return None;
+ self.processPendingEvents();
+
+ msStart = base.timestampMilli();
+ while iCurPid == iOrgPid \
+ and sCurName == sOrgName \
+ and sCurName != '' \
+ and base.timestampMilli() - msStart < cMsTimeout \
+ and eCurState in (vboxcon.SessionState_Unlocking, vboxcon.SessionState_Spawning, vboxcon.SessionState_Locked,):
+ self.processEvents(1000);
+ try:
+ eCurState = oVM.sessionState;
+ sCurName = oVM.sessionName if self.fpApiVer >= 5.0 else oVM.sessionType;
+ iCurPid = oVM.sessionPID if self.fpApiVer >= 4.2 else oVM.sessionPid;
+ except Exception as oXcpt:
+ if ComError.notEqual(oXcpt, ComError.E_ACCESSDENIED):
+ reporter.logXcpt();
+ break;
+ self.processPendingEvents();
+ self.processPendingEvents();
+ return None;
+
+ def uploadStartupLogFile(self, oVM, sVmName):
+ """
+ Uploads the VBoxStartup.log when present.
+ """
+ fRc = True;
+ try:
+ sLogFile = os.path.join(oVM.logFolder, 'VBoxHardening.log');
+ except:
+ reporter.logXcpt();
+ fRc = False;
+ else:
+ if os.path.isfile(sLogFile):
+ reporter.addLogFile(sLogFile, 'log/release/vm', '%s hardening log' % (sVmName, ),
+ sAltName = '%s-%s' % (sVmName, os.path.basename(sLogFile),));
+ return fRc;
+
+ def annotateAndUploadProcessReport(self, sProcessReport, sFilename, sKind, sDesc):
+ """
+ Annotates the given VM process report and uploads it if successfull.
+ """
+ fRc = False;
+ if self.oBuild is not None and self.oBuild.sInstallPath is not None:
+ oResolver = btresolver.BacktraceResolver(self.sScratchPath, self.oBuild.sInstallPath,
+ self.getBuildOs(), self.getBuildArch(),
+ fnLog = reporter.log);
+ fRcTmp = oResolver.prepareEnv();
+ if fRcTmp:
+ reporter.log('Successfully prepared environment');
+ sReportDbgSym = oResolver.annotateReport(sProcessReport);
+ if sReportDbgSym and len(sReportDbgSym) > 8:
+ reporter.addLogString(sReportDbgSym, sFilename, sKind, sDesc);
+ fRc = True;
+ else:
+ reporter.log('Annotating report failed');
+ oResolver.cleanupEnv();
+ return fRc;
+
+ def startVmEx(self, oVM, fWait = True, sType = None, sName = None, asEnv = None): # pylint: disable=too-many-locals,too-many-statements
+ """
+ Start the VM, returning the VM session and progress object on success.
+ The session is also added to the task list and to the aoRemoteSessions set.
+
+ asEnv is a list of string on the putenv() form.
+
+ On failure (None, None) is returned and an error is logged.
+ """
+ # Massage and check the input.
+ if sType is None:
+ sType = self.sSessionType;
+ if sName is None:
+ try: sName = oVM.name;
+ except: sName = 'bad-vm-handle';
+ reporter.log('startVmEx: sName=%s fWait=%s sType=%s' % (sName, fWait, sType));
+ if oVM is None:
+ return (None, None);
+
+ ## @todo Do this elsewhere.
+ # Hack alert. Disables all annoying GUI popups.
+ if sType == 'gui' and not self.aoRemoteSessions:
+ try:
+ self.oVBox.setExtraData('GUI/Input/AutoCapture', 'false');
+ if self.fpApiVer >= 3.2:
+ self.oVBox.setExtraData('GUI/LicenseAgreed', '8');
+ else:
+ self.oVBox.setExtraData('GUI/LicenseAgreed', '7');
+ self.oVBox.setExtraData('GUI/RegistrationData', 'triesLeft=0');
+ self.oVBox.setExtraData('GUI/SUNOnlineData', 'triesLeft=0');
+ self.oVBox.setExtraData('GUI/SuppressMessages', 'confirmVMReset,remindAboutMouseIntegrationOn,'
+ 'remindAboutMouseIntegrationOff,remindAboutPausedVMInput,confirmInputCapture,'
+ 'confirmGoingFullscreen,remindAboutInaccessibleMedia,remindAboutWrongColorDepth,'
+ 'confirmRemoveMedium,allPopupPanes,allMessageBoxes,all');
+ self.oVBox.setExtraData('GUI/UpdateDate', 'never');
+ self.oVBox.setExtraData('GUI/PreventBetaWarning', self.oVBox.version);
+ except:
+ reporter.logXcpt();
+
+ # The UUID for the name.
+ try:
+ sUuid = oVM.id;
+ except:
+ reporter.errorXcpt('failed to get the UUID for VM "%s"' % (oVM));
+ return (None, None);
+ self.processPendingEvents();
+
+ # Construct the environment.
+ self.sSessionLogFile = '%s/VM-%s.log' % (self.sScratchPath, sUuid);
+ try: os.remove(self.sSessionLogFile);
+ except: pass;
+ if self.sLogSessionDest:
+ sLogDest = self.sLogSessionDest;
+ else:
+ sLogDest = 'file=%s' % (self.sSessionLogFile,);
+ asEnvFinal = [
+ 'VBOX_LOG=%s' % (self.sLogSessionGroups,),
+ 'VBOX_LOG_FLAGS=%s' % (self.sLogSessionFlags,),
+ 'VBOX_LOG_DEST=nodeny %s' % (sLogDest,),
+ 'VBOX_RELEASE_LOG_FLAGS=append time',
+ ];
+ if sType == 'gui':
+ asEnvFinal.append('VBOX_GUI_DBG_ENABLED=1');
+ if asEnv is not None and asEnv:
+ asEnvFinal += asEnv;
+
+ reporter.log2('Session environment:\n%s' % (asEnvFinal,));
+
+ # Shortcuts for local testing.
+ oProgress = oWrapped = None;
+ oTestVM = self.oTestVmSet.findTestVmByName(sName) if self.oTestVmSet is not None else None;
+ try:
+ if oTestVM is not None \
+ and oTestVM.fSnapshotRestoreCurrent is True:
+ if oVM.state is vboxcon.MachineState_Running:
+ reporter.log2('Machine "%s" already running.' % (sName,));
+ oProgress = None;
+ oWrapped = self.openSession(oVM);
+ else:
+ reporter.log2('Checking if snapshot for machine "%s" exists.' % (sName,));
+ oSessionWrapperRestore = self.openSession(oVM);
+ if oSessionWrapperRestore is not None:
+ oSnapshotCur = oVM.currentSnapshot;
+ if oSnapshotCur is not None:
+ reporter.log2('Restoring snapshot for machine "%s".' % (sName,));
+ oSessionWrapperRestore.restoreSnapshot(oSnapshotCur);
+ reporter.log2('Current snapshot for machine "%s" restored.' % (sName,));
+ else:
+ reporter.log('warning: no current snapshot for machine "%s" found.' % (sName,));
+ oSessionWrapperRestore.close();
+ except:
+ reporter.errorXcpt();
+ return (None, None);
+
+ oSession = None; # Must be initialized, otherwise the log statement at the end of the function can fail.
+
+ # Open a remote session, wait for this operation to complete.
+ # (The loop is a kludge to deal with us racing the closing of the
+ # direct session of a previous VM run. See waitOnDirectSessionClose.)
+ if oWrapped is None:
+ for i in range(10):
+ try:
+ if self.fpApiVer < 4.3 \
+ or (self.fpApiVer == 4.3 and not hasattr(self.oVBoxMgr, 'getSessionObject')):
+ oSession = self.oVBoxMgr.mgr.getSessionObject(self.oVBox); # pylint: disable=no-member
+ elif self.fpApiVer < 5.2 \
+ or (self.fpApiVer == 5.2 and hasattr(self.oVBoxMgr, 'vbox')):
+ oSession = self.oVBoxMgr.getSessionObject(self.oVBox); # pylint: disable=no-member
+ else:
+ oSession = self.oVBoxMgr.getSessionObject(); # pylint: disable=no-member,no-value-for-parameter
+ if self.fpApiVer < 3.3:
+ oProgress = self.oVBox.openRemoteSession(oSession, sUuid, sType, '\n'.join(asEnvFinal));
+ else:
+ if self.uApiRevision >= self.makeApiRevision(6, 1, 0, 1):
+ oProgress = oVM.launchVMProcess(oSession, sType, asEnvFinal);
+ else:
+ oProgress = oVM.launchVMProcess(oSession, sType, '\n'.join(asEnvFinal));
+ break;
+ except:
+ if i == 9:
+ reporter.errorXcpt('failed to start VM "%s" ("%s"), aborting.' % (sUuid, sName));
+ return (None, None);
+ oSession = None;
+ if i >= 0:
+ reporter.logXcpt('warning: failed to start VM "%s" ("%s") - retrying in %u secs.' % (sUuid, oVM, i)); # pylint: disable=line-too-long
+ self.waitOnDirectSessionClose(oVM, 5000 + i * 1000);
+ if fWait and oProgress is not None:
+ rc = self.waitOnProgress(oProgress);
+ if rc < 0:
+ self.waitOnDirectSessionClose(oVM, 5000);
+
+ # VM failed to power up, still collect VBox.log, need to wrap the session object
+ # in order to use the helper for adding the log files to the report.
+ from testdriver.vboxwrappers import SessionWrapper;
+ oTmp = SessionWrapper(oSession, oVM, self.oVBox, self.oVBoxMgr, self, True, sName, self.sSessionLogFile);
+ oTmp.addLogsToReport();
+
+ # Try to collect a stack trace of the process for further investigation of any startup hangs.
+ uPid = oTmp.getPid();
+ if uPid is not None:
+ sHostProcessInfoHung = utils.processGetInfo(uPid, fSudo = True);
+ if sHostProcessInfoHung is not None:
+ reporter.log('Trying to annotate the hung VM startup process report, please stand by...');
+ fRcTmp = self.annotateAndUploadProcessReport(sHostProcessInfoHung, 'vmprocess-startup-hung.log',
+ 'process/report/vm', 'Annotated hung VM process state during startup'); # pylint: disable=line-too-long
+ # Upload the raw log for manual annotation in case resolving failed.
+ if not fRcTmp:
+ reporter.log('Failed to annotate hung VM process report, uploading raw report');
+ reporter.addLogString(sHostProcessInfoHung, 'vmprocess-startup-hung.log', 'process/report/vm',
+ 'Hung VM process state during startup');
+
+ try:
+ if oSession is not None:
+ oSession.close();
+ except: pass;
+ reportError(oProgress, 'failed to open session for "%s"' % (sName));
+ self.uploadStartupLogFile(oVM, sName);
+ return (None, None);
+ reporter.log2('waitOnProgress -> %s' % (rc,));
+
+ # Wrap up the session object and push on to the list before returning it.
+ if oWrapped is None:
+ from testdriver.vboxwrappers import SessionWrapper;
+ oWrapped = SessionWrapper(oSession, oVM, self.oVBox, self.oVBoxMgr, self, True, sName, self.sSessionLogFile);
+
+ oWrapped.registerEventHandlerForTask();
+ self.aoRemoteSessions.append(oWrapped);
+ if oWrapped is not self.aoRemoteSessions[len(self.aoRemoteSessions) - 1]:
+ reporter.error('not by reference: oWrapped=%s aoRemoteSessions[%s]=%s'
+ % (oWrapped, len(self.aoRemoteSessions) - 1,
+ self.aoRemoteSessions[len(self.aoRemoteSessions) - 1]));
+ self.addTask(oWrapped);
+
+ reporter.log2('startVmEx: oSession=%s, oSessionWrapper=%s, oProgress=%s' % (oSession, oWrapped, oProgress));
+
+ from testdriver.vboxwrappers import ProgressWrapper;
+ return (oWrapped, ProgressWrapper(oProgress, self.oVBoxMgr, self,
+ 'starting %s' % (sName,)) if oProgress else None);
+
+ def startVm(self, oVM, sType=None, sName = None, asEnv = None):
+ """ Simplified version of startVmEx. """
+ oSession, _ = self.startVmEx(oVM, True, sType, sName, asEnv = asEnv);
+ return oSession;
+
+ def startVmByNameEx(self, sName, fWait=True, sType=None, asEnv = None):
+ """
+ Start the VM, returning the VM session and progress object on success.
+ The session is also added to the task list and to the aoRemoteSessions set.
+
+ On failure (None, None) is returned and an error is logged.
+ """
+ oVM = self.getVmByName(sName);
+ if oVM is None:
+ return (None, None);
+ return self.startVmEx(oVM, fWait, sType, sName, asEnv = asEnv);
+
+ def startVmByName(self, sName, sType=None, asEnv = None):
+ """
+ Start the VM, returning the VM session on success. The session is
+ also added to the task list and to the aoRemoteSessions set.
+
+ On failure None is returned and an error is logged.
+ """
+ oSession, _ = self.startVmByNameEx(sName, True, sType, asEnv = asEnv);
+ return oSession;
+
+ def terminateVmBySession(self, oSession, oProgress = None, fTakeScreenshot = None): # pylint: disable=too-many-statements
+ """
+ Terminates the VM specified by oSession and adds the release logs to
+ the test report.
+
+ This will try achieve this by using powerOff, but will resort to
+ tougher methods if that fails.
+
+ The session will always be removed from the task list.
+ The session will be closed unless we fail to kill the process.
+ The session will be removed from the remote session list if closed.
+
+ The progress object (a wrapper!) is for teleportation and similar VM
+ operations, it will be attempted canceled before powering off the VM.
+ Failures are logged but ignored.
+ The progress object will always be removed from the task list.
+
+ Returns True if powerOff and session close both succeed.
+ Returns False if on failure (logged), including when we successfully
+ kill the VM process.
+ """
+
+ reporter.log2('terminateVmBySession: oSession=%s (pid=%s) oProgress=%s' % (oSession.sName, oSession.getPid(), oProgress));
+
+ if self.fVmNoTerminate:
+ reporter.log('terminateVmBySession: Skipping, as --vbox-vm-no-terminate was specified');
+ # Make sure that we still process the events the VM needs.
+ self.sleep(24 * 60 * 60 * 1000);
+
+ # Call getPid first to make sure the PID is cached in the wrapper.
+ oSession.getPid();
+
+ #
+ # If the host is out of memory, just skip all the info collection as it
+ # requires memory too and seems to wedge.
+ #
+ sHostProcessInfo = None;
+ sHostProcessInfoHung = None;
+ sLastScreenshotPath = None;
+ sOsKernelLog = None;
+ sVgaText = None;
+ asMiscInfos = [];
+
+ if not oSession.fHostMemoryLow:
+ # Try to fetch the VM process info before meddling with its state.
+ if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
+ sHostProcessInfo = utils.processGetInfo(oSession.getPid(), fSudo = True);
+
+ #
+ # Pause the VM if we're going to take any screenshots or dig into the
+ # guest. Failures are quitely ignored.
+ #
+ if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
+ try:
+ if oSession.oVM.state in [ vboxcon.MachineState_Running,
+ vboxcon.MachineState_LiveSnapshotting,
+ vboxcon.MachineState_Teleporting ]:
+ oSession.o.console.pause();
+ except:
+ reporter.logXcpt();
+
+ #
+ # Take Screenshot and upload it (see below) to Test Manager if appropriate/requested.
+ #
+ if fTakeScreenshot is True or self.fAlwaysUploadScreenshots or reporter.testErrorCount() > 0:
+ sLastScreenshotPath = os.path.join(self.sScratchPath, "LastScreenshot-%s.png" % oSession.sName);
+ fRc = oSession.takeScreenshot(sLastScreenshotPath);
+ if fRc is not True:
+ sLastScreenshotPath = None;
+
+ # Query the OS kernel log from the debugger if appropriate/requested.
+ if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
+ sOsKernelLog = oSession.queryOsKernelLog();
+
+ # Do "info vgatext all" separately.
+ if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
+ sVgaText = oSession.queryDbgInfoVgaText();
+
+ # Various infos (do after kernel because of symbols).
+ if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
+ # Dump the guest stack for all CPUs.
+ cCpus = oSession.getCpuCount();
+ if cCpus > 0:
+ for iCpu in xrange(0, cCpus):
+ sThis = oSession.queryDbgGuestStack(iCpu);
+ if sThis:
+ asMiscInfos += [
+ '================ start guest stack VCPU %s ================\n' % (iCpu,),
+ sThis,
+ '================ end guest stack VCPU %s ==================\n' % (iCpu,),
+ ];
+
+ for sInfo, sArg in [ ('mode', 'all'),
+ ('fflags', ''),
+ ('cpumguest', 'verbose all'),
+ ('cpumguestinstr', 'symbol all'),
+ ('exits', ''),
+ ('pic', ''),
+ ('apic', ''),
+ ('apiclvt', ''),
+ ('apictimer', ''),
+ ('ioapic', ''),
+ ('pit', ''),
+ ('phys', ''),
+ ('clocks', ''),
+ ('timers', ''),
+ ('gdt', ''),
+ ('ldt', ''),
+ ]:
+ if sInfo in ['apic',] and self.fpApiVer < 5.1: # asserts and burns
+ continue;
+ sThis = oSession.queryDbgInfo(sInfo, sArg);
+ if sThis:
+ if sThis[-1] != '\n':
+ sThis += '\n';
+ asMiscInfos += [
+ '================ start %s %s ================\n' % (sInfo, sArg),
+ sThis,
+ '================ end %s %s ==================\n' % (sInfo, sArg),
+ ];
+
+ #
+ # Terminate the VM
+ #
+
+ # Cancel the progress object if specified.
+ if oProgress is not None:
+ if not oProgress.isCompleted() and oProgress.isCancelable():
+ reporter.log2('terminateVmBySession: canceling "%s"...' % (oProgress.sName));
+ try:
+ oProgress.o.cancel();
+ except:
+ reporter.logXcpt();
+ else:
+ oProgress.wait();
+ self.removeTask(oProgress);
+
+ # Check if the VM has terminated by itself before powering it off.
+ fClose = True;
+ fRc = True;
+ if oSession.needsPoweringOff():
+ reporter.log('terminateVmBySession: powering off "%s"...' % (oSession.sName,));
+ fRc = oSession.powerOff(fFudgeOnFailure = False);
+ if fRc is not True:
+ # power off failed, try terminate it in a nice manner.
+ fRc = False;
+ uPid = oSession.getPid();
+ if uPid is not None:
+ #
+ # Collect some information about the VM process first to have
+ # some state information for further investigation why powering off failed.
+ #
+ sHostProcessInfoHung = utils.processGetInfo(uPid, fSudo = True);
+
+ # Exterminate...
+ reporter.error('terminateVmBySession: Terminating PID %u (VM %s)' % (uPid, oSession.sName));
+ fClose = base.processTerminate(uPid);
+ if fClose is True:
+ self.waitOnDirectSessionClose(oSession.oVM, 5000);
+ fClose = oSession.waitForTask(1000);
+
+ if fClose is not True:
+ # Being nice failed...
+ reporter.error('terminateVmBySession: Termination failed, trying to kill PID %u (VM %s) instead' \
+ % (uPid, oSession.sName));
+ fClose = base.processKill(uPid);
+ if fClose is True:
+ self.waitOnDirectSessionClose(oSession.oVM, 5000);
+ fClose = oSession.waitForTask(1000);
+ if fClose is not True:
+ reporter.error('terminateVmBySession: Failed to kill PID %u (VM %s)' % (uPid, oSession.sName));
+
+ # The final steps.
+ if fClose is True:
+ reporter.log('terminateVmBySession: closing session "%s"...' % (oSession.sName,));
+ oSession.close();
+ self.waitOnDirectSessionClose(oSession.oVM, 10000);
+ try:
+ eState = oSession.oVM.state;
+ except:
+ reporter.logXcpt();
+ else:
+ if eState == vboxcon.MachineState_Aborted:
+ reporter.error('terminateVmBySession: The VM "%s" aborted!' % (oSession.sName,));
+ self.removeTask(oSession);
+
+ #
+ # Add the release log, debug log and a screenshot of the VM to the test report.
+ #
+ if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
+ oSession.addLogsToReport();
+
+ # Add a screenshot if it has been requested and taken successfully.
+ if sLastScreenshotPath is not None:
+ if reporter.testErrorCount() > 0:
+ reporter.addLogFile(sLastScreenshotPath, 'screenshot/failure', 'Last VM screenshot');
+ else:
+ reporter.addLogFile(sLastScreenshotPath, 'screenshot/success', 'Last VM screenshot');
+
+ # Add the guest OS log if it has been requested and taken successfully.
+ if sOsKernelLog is not None:
+ reporter.addLogString(sOsKernelLog, 'kernel.log', 'log/guest/kernel', 'Guest OS kernel log');
+
+ # Add "info vgatext all" if we've got it.
+ if sVgaText is not None:
+ reporter.addLogString(sVgaText, 'vgatext.txt', 'info/vgatext', 'info vgatext all');
+
+ # Add the "info xxxx" items if we've got any.
+ if asMiscInfos:
+ reporter.addLogString(u''.join(asMiscInfos), 'info.txt', 'info/collection', 'A bunch of info items.');
+
+ # Add the host process info if we were able to retrieve it.
+ if sHostProcessInfo is not None:
+ reporter.log('Trying to annotate the VM process report, please stand by...');
+ fRcTmp = self.annotateAndUploadProcessReport(sHostProcessInfo, 'vmprocess.log',
+ 'process/report/vm', 'Annotated VM process state');
+ # Upload the raw log for manual annotation in case resolving failed.
+ if not fRcTmp:
+ reporter.log('Failed to annotate VM process report, uploading raw report');
+ reporter.addLogString(sHostProcessInfo, 'vmprocess.log', 'process/report/vm', 'VM process state');
+
+ # Add the host process info for failed power off attempts if we were able to retrieve it.
+ if sHostProcessInfoHung is not None:
+ reporter.log('Trying to annotate the hung VM process report, please stand by...');
+ fRcTmp = self.annotateAndUploadProcessReport(sHostProcessInfoHung, 'vmprocess-hung.log',
+ 'process/report/vm', 'Annotated hung VM process state');
+ # Upload the raw log for manual annotation in case resolving failed.
+ if not fRcTmp:
+ reporter.log('Failed to annotate hung VM process report, uploading raw report');
+ fRcTmp = reporter.addLogString(sHostProcessInfoHung, 'vmprocess-hung.log', 'process/report/vm',
+ 'Hung VM process state');
+ if not fRcTmp:
+ try: reporter.log('******* START vmprocess-hung.log *******\n%s\n******* END vmprocess-hung.log *******\n'
+ % (sHostProcessInfoHung,));
+ except: pass; # paranoia
+
+ # Upload the screen video recordings if appropriate.
+ if self.fAlwaysUploadRecordings or reporter.testErrorCount() > 0:
+ reporter.log2('Uploading %d screen recordings ...' % (len(self.adRecordingFiles),));
+ for dRecFile in self.adRecordingFiles:
+ reporter.log2('Uploading screen recording "%s" (screen %d)' % (dRecFile['file'], dRecFile['id']));
+ reporter.addLogFile(dRecFile['file'],
+ 'screenrecording/failure' if reporter.testErrorCount() > 0 else 'screenrecording/success',
+ 'Recording of screen #%d' % (dRecFile['id'],));
+
+ return fRc;
+
+
+ #
+ # Some information query functions (mix).
+ #
+ # Methods require the VBox API. If the information is provided by both
+ # the testboxscript as well as VBox API, we'll check if it matches.
+ #
+
+ def _hasHostCpuFeature(self, sEnvVar, sEnum, fpApiMinVer, fQuiet):
+ """
+ Common Worker for hasHostNestedPaging() and hasHostHwVirt().
+
+ Returns True / False.
+ Raises exception on environment / host mismatch.
+ """
+ fEnv = os.environ.get(sEnvVar, None);
+ if fEnv is not None:
+ fEnv = fEnv.lower() not in [ 'false', 'f', 'not', 'no', 'n', '0', ];
+
+ fVBox = None;
+ self.importVBoxApi();
+ if self.fpApiVer >= fpApiMinVer and hasattr(vboxcon, sEnum):
+ try:
+ fVBox = self.oVBox.host.getProcessorFeature(getattr(vboxcon, sEnum));
+ except:
+ if not fQuiet:
+ reporter.logXcpt();
+
+ if fVBox is not None:
+ if fEnv is not None:
+ if fEnv != fVBox and not fQuiet:
+ reporter.log('TestBox configuration overwritten: fVBox=%s (%s) vs. fEnv=%s (%s)'
+ % (fVBox, sEnum, fEnv, sEnvVar));
+ return fEnv;
+ return fVBox;
+ if fEnv is not None:
+ return fEnv;
+ return False;
+
+ def hasHostHwVirt(self, fQuiet = False):
+ """
+ Checks if hardware assisted virtualization is supported by the host.
+
+ Returns True / False.
+ Raises exception on environment / host mismatch.
+ """
+ return self._hasHostCpuFeature('TESTBOX_HAS_HW_VIRT', 'ProcessorFeature_HWVirtEx', 3.1, fQuiet);
+
+ def hasHostNestedPaging(self, fQuiet = False):
+ """
+ Checks if nested paging is supported by the host.
+
+ Returns True / False.
+ Raises exception on environment / host mismatch.
+ """
+ return self._hasHostCpuFeature('TESTBOX_HAS_NESTED_PAGING', 'ProcessorFeature_NestedPaging', 4.2, fQuiet) \
+ and self.hasHostHwVirt(fQuiet);
+
+ def hasHostNestedHwVirt(self, fQuiet = False):
+ """
+ Checks if nested hardware-assisted virtualization is supported by the host.
+
+ Returns True / False.
+ Raises exception on environment / host mismatch.
+ """
+ return self._hasHostCpuFeature('TESTBOX_HAS_NESTED_HWVIRT', 'ProcessorFeature_NestedHWVirt', 6.0, fQuiet) \
+ and self.hasHostHwVirt(fQuiet);
+
+ def hasHostLongMode(self, fQuiet = False):
+ """
+ Checks if the host supports 64-bit guests.
+
+ Returns True / False.
+ Raises exception on environment / host mismatch.
+ """
+ # Note that the testboxscript doesn't export this variable atm.
+ return self._hasHostCpuFeature('TESTBOX_HAS_LONG_MODE', 'ProcessorFeature_LongMode', 3.1, fQuiet);
+
+ def getHostCpuCount(self, fQuiet = False):
+ """
+ Returns the number of CPUs on the host.
+
+ Returns True / False.
+ Raises exception on environment / host mismatch.
+ """
+ cEnv = os.environ.get('TESTBOX_CPU_COUNT', None);
+ if cEnv is not None:
+ cEnv = int(cEnv);
+
+ try:
+ cVBox = self.oVBox.host.processorOnlineCount;
+ except:
+ if not fQuiet:
+ reporter.logXcpt();
+ cVBox = None;
+
+ if cVBox is not None:
+ if cEnv is not None:
+ assert cVBox == cEnv, 'Misconfigured TestBox: VBox: %u CPUs, testboxscript: %u CPUs' % (cVBox, cEnv);
+ return cVBox;
+ if cEnv is not None:
+ return cEnv;
+ return 1;
+
+ def _getHostCpuDesc(self, fQuiet = False):
+ """
+ Internal method used for getting the host CPU description from VBoxSVC.
+ Returns description string, on failure an empty string is returned.
+ """
+ try:
+ return self.oVBox.host.getProcessorDescription(0);
+ except:
+ if not fQuiet:
+ reporter.logXcpt();
+ return '';
+
+ def isHostCpuAmd(self, fQuiet = False):
+ """
+ Checks if the host CPU vendor is AMD.
+
+ Returns True / False.
+ """
+ sCpuDesc = self._getHostCpuDesc(fQuiet);
+ return 'AMD' in sCpuDesc or sCpuDesc == 'AuthenticAMD';
+
+ def isHostCpuIntel(self, fQuiet = False):
+ """
+ Checks if the host CPU vendor is Intel.
+
+ Returns True / False.
+ """
+ sCpuDesc = self._getHostCpuDesc(fQuiet);
+ return sCpuDesc.startswith("Intel") or sCpuDesc == 'GenuineIntel';
+
+ def isHostCpuVia(self, fQuiet = False):
+ """
+ Checks if the host CPU vendor is VIA (or Centaur).
+
+ Returns True / False.
+ """
+ sCpuDesc = self._getHostCpuDesc(fQuiet);
+ return sCpuDesc.startswith("VIA") or sCpuDesc == 'CentaurHauls';
+
+ def isHostCpuShanghai(self, fQuiet = False):
+ """
+ Checks if the host CPU vendor is Shanghai (or Zhaoxin).
+
+ Returns True / False.
+ """
+ sCpuDesc = self._getHostCpuDesc(fQuiet);
+ return sCpuDesc.startswith("ZHAOXIN") or sCpuDesc.strip(' ') == 'Shanghai';
+
+ def isHostCpuP4(self, fQuiet = False):
+ """
+ Checks if the host CPU is a Pentium 4 / Pentium D.
+
+ Returns True / False.
+ """
+ if not self.isHostCpuIntel(fQuiet):
+ return False;
+
+ (uFamilyModel, _, _, _) = self.oVBox.host.getProcessorCPUIDLeaf(0, 0x1, 0);
+ return ((uFamilyModel >> 8) & 0xf) == 0xf;
+
+ def hasRawModeSupport(self, fQuiet = False):
+ """
+ Checks if raw-mode is supported by VirtualBox that the testbox is
+ configured for it.
+
+ Returns True / False.
+ Raises no exceptions.
+
+ Note! Differs from the rest in that we don't require the
+ TESTBOX_WITH_RAW_MODE value to match the API. It is
+ sometimes helpful to disable raw-mode on individual
+ test boxes. (This probably goes for
+ """
+ # The environment variable can be used to disable raw-mode.
+ fEnv = os.environ.get('TESTBOX_WITH_RAW_MODE', None);
+ if fEnv is not None:
+ fEnv = fEnv.lower() not in [ 'false', 'f', 'not', 'no', 'n', '0', ];
+ if fEnv is False:
+ return False;
+
+ # Starting with 5.0 GA / RC2 the API can tell us whether VBox was built
+ # with raw-mode support or not.
+ self.importVBoxApi();
+ if self.fpApiVer >= 5.0:
+ try:
+ fVBox = self.oVBox.systemProperties.rawModeSupported;
+ except:
+ if not fQuiet:
+ reporter.logXcpt();
+ fVBox = True;
+ if fVBox is False:
+ return False;
+
+ return True;
+
+ #
+ # Testdriver execution methods.
+ #
+
+ def handleTask(self, oTask, sMethod):
+ """
+ Callback method for handling unknown tasks in the various run loops.
+
+ The testdriver should override this if it already tasks running when
+ calling startVmAndConnectToTxsViaTcp, txsRunTest or similar methods.
+ Call super to handle unknown tasks.
+
+ Returns True if handled, False if not.
+ """
+ reporter.error('%s: unknown task %s' % (sMethod, oTask));
+ return False;
+
+ def txsDoTask(self, oSession, oTxsSession, fnAsync, aArgs):
+ """
+ Generic TXS task wrapper which waits both on the TXS and the session tasks.
+
+ Returns False on error, logged.
+ Returns task result on success.
+ """
+ # All async methods ends with the following two args.
+ cMsTimeout = aArgs[-2];
+ fIgnoreErrors = aArgs[-1];
+
+ fRemoveVm = self.addTask(oSession);
+ fRemoveTxs = self.addTask(oTxsSession);
+
+ rc = fnAsync(*aArgs); # pylint: disable=star-args
+ if rc is True:
+ rc = False;
+ oTask = self.waitForTasks(cMsTimeout + 1);
+ if oTask is oTxsSession:
+ if oTxsSession.isSuccess():
+ rc = oTxsSession.getResult();
+ elif fIgnoreErrors is True:
+ reporter.log( 'txsDoTask: task failed (%s)' % (oTxsSession.getLastReply()[1],));
+ else:
+ reporter.error('txsDoTask: task failed (%s)' % (oTxsSession.getLastReply()[1],));
+ else:
+ oTxsSession.cancelTask();
+ if oTask is None:
+ if fIgnoreErrors is True:
+ reporter.log( 'txsDoTask: The task timed out.');
+ else:
+ reporter.errorTimeout('txsDoTask: The task timed out.');
+ elif oTask is oSession:
+ reporter.error('txsDoTask: The VM terminated unexpectedly');
+ else:
+ if fIgnoreErrors is True:
+ reporter.log( 'txsDoTask: An unknown task %s was returned' % (oTask,));
+ else:
+ reporter.error('txsDoTask: An unknown task %s was returned' % (oTask,));
+ else:
+ reporter.error('txsDoTask: fnAsync returned %s' % (rc,));
+
+ if fRemoveTxs:
+ self.removeTask(oTxsSession);
+ if fRemoveVm:
+ self.removeTask(oSession);
+ return rc;
+
+ # pylint: disable=missing-docstring
+
+ def txsDisconnect(self, oSession, oTxsSession, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDisconnect,
+ (self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsVer(self, oSession, oTxsSession, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncVer,
+ (self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsUuid(self, oSession, oTxsSession, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUuid,
+ (self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsMkDir(self, oSession, oTxsSession, sRemoteDir, fMode = 0o700, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkDir,
+ (sRemoteDir, fMode, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsMkDirPath(self, oSession, oTxsSession, sRemoteDir, fMode = 0o700, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkDirPath,
+ (sRemoteDir, fMode, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsMkSymlink(self, oSession, oTxsSession, sLinkTarget, sLink, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkSymlink,
+ (sLinkTarget, sLink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsRmDir(self, oSession, oTxsSession, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmDir,
+ (sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsRmFile(self, oSession, oTxsSession, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmFile,
+ (sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsRmSymlink(self, oSession, oTxsSession, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmSymlink,
+ (sRemoteSymlink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsRmTree(self, oSession, oTxsSession, sRemoteTree, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmTree,
+ (sRemoteTree, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsIsDir(self, oSession, oTxsSession, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsDir,
+ (sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsIsFile(self, oSession, oTxsSession, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsFile,
+ (sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsIsSymlink(self, oSession, oTxsSession, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsSymlink,
+ (sRemoteSymlink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsCopyFile(self, oSession, oTxsSession, sSrcFile, sDstFile, fMode = 0, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncCopyFile, \
+ (sSrcFile, sDstFile, fMode, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsUploadFile(self, oSession, oTxsSession, sLocalFile, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUploadFile, \
+ (sLocalFile, sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsUploadString(self, oSession, oTxsSession, sContent, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUploadString, \
+ (sContent, sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsDownloadFile(self, oSession, oTxsSession, sRemoteFile, sLocalFile, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDownloadFile, \
+ (sRemoteFile, sLocalFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsDownloadFiles(self, oSession, oTxsSession, aasFiles, fAddToLog = True, fIgnoreErrors = False):
+ """
+ Convenience function to get files from the guest, storing them in the
+ scratch and adding them to the test result set (optional, but default).
+
+ The aasFiles parameter contains an array of with guest-path + host-path
+ pairs, optionally a file 'kind', description and an alternative upload
+ filename can also be specified.
+
+ Host paths are relative to the scratch directory or they must be given
+ in absolute form. The guest path should be using guest path style.
+
+ Returns True on success.
+ Returns False on failure (unless fIgnoreErrors is set), logged.
+ """
+ for asEntry in aasFiles:
+ # Unpack:
+ sGstFile = asEntry[0];
+ sHstFile = asEntry[1];
+ sKind = asEntry[2] if len(asEntry) > 2 and asEntry[2] else 'misc/other';
+ sDescription = asEntry[3] if len(asEntry) > 3 and asEntry[3] else '';
+ sAltName = asEntry[4] if len(asEntry) > 4 and asEntry[4] else None;
+ assert len(asEntry) <= 5 and sGstFile and sHstFile;
+ if not os.path.isabs(sHstFile):
+ sHstFile = os.path.join(self.sScratchPath, sHstFile);
+
+ reporter.log2('Downloading file "%s" to "%s" ...' % (sGstFile, sHstFile,));
+
+ try: os.unlink(sHstFile); ## @todo txsDownloadFile doesn't truncate the output file.
+ except: pass;
+
+ fRc = self.txsDownloadFile(oSession, oTxsSession, sGstFile, sHstFile, 30 * 1000, fIgnoreErrors);
+ if fRc:
+ if fAddToLog:
+ reporter.addLogFile(sHstFile, sKind, sDescription, sAltName);
+ else:
+ if fIgnoreErrors is not True:
+ return reporter.error('error downloading file "%s" to "%s"' % (sGstFile, sHstFile));
+ reporter.log('warning: file "%s" was not downloaded, ignoring.' % (sGstFile,));
+ return True;
+
+ def txsDownloadString(self, oSession, oTxsSession, sRemoteFile, sEncoding = 'utf-8', fIgnoreEncodingErrors = True,
+ cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDownloadString,
+ (sRemoteFile, sEncoding, fIgnoreEncodingErrors, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsPackFile(self, oSession, oTxsSession, sRemoteFile, sRemoteSource, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncPackFile, \
+ (sRemoteFile, sRemoteSource, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsUnpackFile(self, oSession, oTxsSession, sRemoteFile, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUnpackFile, \
+ (sRemoteFile, sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ def txsExpandString(self, oSession, oTxsSession, sString, cMsTimeout = 30000, fIgnoreErrors = False):
+ return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncExpandString, \
+ (sString, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
+
+ # pylint: enable=missing-docstring
+
+ def txsCdWait(self,
+ oSession, # type: vboxwrappers.SessionWrapper
+ oTxsSession, # type: txsclient.Session
+ cMsTimeout = 30000, # type: int
+ sFile = None # type: String
+ ): # -> bool
+ """
+ Mostly an internal helper for txsRebootAndReconnectViaTcp and
+ startVmAndConnectToTxsViaTcp that waits for the CDROM drive to become
+ ready. It does this by polling for a file it knows to exist on the CD.
+
+ Returns True on success.
+
+ Returns False on failure, logged.
+ """
+
+ if sFile is None:
+ sFile = 'valkit.txt';
+
+ reporter.log('txsCdWait: Waiting for file "%s" to become available ...' % (sFile,));
+
+ fRemoveVm = self.addTask(oSession);
+ fRemoveTxs = self.addTask(oTxsSession);
+ cMsTimeout = self.adjustTimeoutMs(cMsTimeout);
+ msStart = base.timestampMilli();
+ cMsTimeout2 = cMsTimeout;
+ fRc = oTxsSession.asyncIsFile('${CDROM}/%s' % (sFile,), cMsTimeout2);
+ if fRc is True:
+ while True:
+ # wait for it to complete.
+ oTask = self.waitForTasks(cMsTimeout2 + 1);
+ if oTask is not oTxsSession:
+ oTxsSession.cancelTask();
+ if oTask is None:
+ reporter.errorTimeout('txsCdWait: The task timed out (after %s ms).'
+ % (base.timestampMilli() - msStart,));
+ elif oTask is oSession:
+ reporter.error('txsCdWait: The VM terminated unexpectedly');
+ else:
+ reporter.error('txsCdWait: An unknown task %s was returned' % (oTask,));
+ fRc = False;
+ break;
+ if oTxsSession.isSuccess():
+ break;
+
+ # Check for timeout.
+ cMsElapsed = base.timestampMilli() - msStart;
+ if cMsElapsed >= cMsTimeout:
+ reporter.error('txsCdWait: timed out');
+ fRc = False;
+ break;
+ # delay.
+ self.sleep(1);
+
+ # resubmit the task.
+ cMsTimeout2 = msStart + cMsTimeout - base.timestampMilli();
+ cMsTimeout2 = max(cMsTimeout2, 500);
+ fRc = oTxsSession.asyncIsFile('${CDROM}/%s' % (sFile,), cMsTimeout2);
+ if fRc is not True:
+ reporter.error('txsCdWait: asyncIsFile failed');
+ break;
+ else:
+ reporter.error('txsCdWait: asyncIsFile failed');
+
+ if not fRc:
+ # Do some diagnosis to find out why this failed.
+ ## @todo Identify guest OS type and only run one of the following commands.
+ fIsNotWindows = True;
+ reporter.log('txsCdWait: Listing root contents of ${CDROM}:');
+ if fIsNotWindows:
+ reporter.log('txsCdWait: Tiggering udevadm ...');
+ oTxsSession.syncExec("/sbin/udevadm", ("/sbin/udevadm", "trigger", "--verbose"), fIgnoreErrors = True);
+ time.sleep(15);
+ oTxsSession.syncExec("/bin/ls", ("/bin/ls", "-al", "${CDROM}"), fIgnoreErrors = True);
+ reporter.log('txsCdWait: Listing media directory:');
+ oTxsSession.syncExec('/bin/ls', ('/bin/ls', '-l', '-a', '-R', '/media'), fIgnoreErrors = True);
+ reporter.log('txsCdWait: Listing mount points / drives:');
+ oTxsSession.syncExec('/bin/mount', ('/bin/mount',), fIgnoreErrors = True);
+ oTxsSession.syncExec('/bin/cat', ('/bin/cat', '/etc/fstab'), fIgnoreErrors = True);
+ oTxsSession.syncExec('/bin/dmesg', ('/bin/dmesg',), fIgnoreErrors = True);
+ oTxsSession.syncExec('/usr/bin/lshw', ('/usr/bin/lshw', '-c', 'disk'), fIgnoreErrors = True);
+ oTxsSession.syncExec('/bin/journalctl',
+ ('/bin/journalctl', '-x', '-b'), fIgnoreErrors = True);
+ oTxsSession.syncExec('/bin/journalctl',
+ ('/bin/journalctl', '-x', '-b', '/usr/lib/udisks2/udisksd'), fIgnoreErrors = True);
+ oTxsSession.syncExec('/usr/bin/udisksctl',
+ ('/usr/bin/udisksctl', 'info', '-b', '/dev/sr0'), fIgnoreErrors = True);
+ oTxsSession.syncExec('/bin/systemctl',
+ ('/bin/systemctl', 'status', 'udisks2'), fIgnoreErrors = True);
+ oTxsSession.syncExec('/bin/ps',
+ ('/bin/ps', '-a', '-u', '-x'), fIgnoreErrors = True);
+ reporter.log('txsCdWait: Mounting manually ...');
+ for _ in range(3):
+ oTxsSession.syncExec('/bin/mount', ('/bin/mount', '/dev/sr0', '${CDROM}'), fIgnoreErrors = True);
+ time.sleep(5);
+ reporter.log('txsCdWait: Re-Listing media directory:');
+ oTxsSession.syncExec('/bin/ls', ('/bin/ls', '-l', '-a', '-R', '/media'), fIgnoreErrors = True);
+ else:
+ # ASSUMES that we always install Windows on drive C right now.
+ sWinDir = "C:\\Windows\\System32\\";
+ # Should work since WinXP Pro.
+ oTxsSession.syncExec(sWinDir + "wbem\\WMIC.exe",
+ ("WMIC.exe", "logicaldisk", "get",
+ "deviceid, volumename, description"),
+ fIgnoreErrors = True);
+ oTxsSession.syncExec(sWinDir + " cmd.exe",
+ ('cmd.exe', '/C', 'dir', '${CDROM}'),
+ fIgnoreErrors = True);
+
+ if fRemoveTxs:
+ self.removeTask(oTxsSession);
+ if fRemoveVm:
+ self.removeTask(oSession);
+ return fRc;
+
+ def txsDoConnectViaTcp(self, oSession, cMsTimeout, fNatForwardingForTxs = False):
+ """
+ Mostly an internal worker for connecting to TXS via TCP used by the
+ *ViaTcp methods.
+
+ Returns a tuplet with True/False and TxsSession/None depending on the
+ result. Errors are logged.
+ """
+
+ reporter.log2('txsDoConnectViaTcp: oSession=%s, cMsTimeout=%s, fNatForwardingForTxs=%s'
+ % (oSession, cMsTimeout, fNatForwardingForTxs));
+
+ cMsTimeout = self.adjustTimeoutMs(cMsTimeout);
+ oTxsConnect = oSession.txsConnectViaTcp(cMsTimeout, fNatForwardingForTxs = fNatForwardingForTxs);
+ if oTxsConnect is not None:
+ self.addTask(oTxsConnect);
+ fRemoveVm = self.addTask(oSession);
+ oTask = self.waitForTasks(cMsTimeout + 1);
+ reporter.log2('txsDoConnectViaTcp: waitForTasks returned %s' % (oTask,));
+ self.removeTask(oTxsConnect);
+ if oTask is oTxsConnect:
+ oTxsSession = oTxsConnect.getResult();
+ if oTxsSession is not None:
+ reporter.log('txsDoConnectViaTcp: Connected to TXS on %s.' % (oTxsSession.oTransport.sHostname,));
+ return (True, oTxsSession);
+
+ reporter.error('txsDoConnectViaTcp: failed to connect to TXS.');
+ else:
+ oTxsConnect.cancelTask();
+ if oTask is None:
+ reporter.errorTimeout('txsDoConnectViaTcp: connect stage 1 timed out');
+ elif oTask is oSession:
+ oSession.reportPrematureTermination('txsDoConnectViaTcp: ');
+ else:
+ reporter.error('txsDoConnectViaTcp: unknown/wrong task %s' % (oTask,));
+ if fRemoveVm:
+ self.removeTask(oSession);
+ else:
+ reporter.error('txsDoConnectViaTcp: txsConnectViaTcp failed');
+ return (False, None);
+
+ def startVmAndConnectToTxsViaTcp(self, sVmName, fCdWait = False, cMsTimeout = 15*60000, \
+ cMsCdWait = 30000, sFileCdWait = None, \
+ fNatForwardingForTxs = False):
+ """
+ Starts the specified VM and tries to connect to its TXS via TCP.
+ The VM will be powered off if TXS doesn't respond before the specified
+ time has elapsed.
+
+ Returns a the VM and TXS sessions (a two tuple) on success. The VM
+ session is in the task list, the TXS session is not.
+ Returns (None, None) on failure, fully logged.
+ """
+
+ # Zap the guest IP to make sure we're not getting a stale entry
+ # (unless we're restoring the VM of course).
+ oTestVM = self.oTestVmSet.findTestVmByName(sVmName) if self.oTestVmSet is not None else None;
+ if oTestVM is None \
+ or oTestVM.fSnapshotRestoreCurrent is False:
+ try:
+ oSession1 = self.openSession(self.getVmByName(sVmName));
+ oSession1.delGuestPropertyValue('/VirtualBox/GuestInfo/Net/0/V4/IP');
+ oSession1.saveSettings(True);
+ del oSession1;
+ except:
+ reporter.logXcpt();
+
+ # Start the VM.
+ reporter.log('startVmAndConnectToTxsViaTcp: Starting(/preparing) "%s" (timeout %s s)...' % (sVmName, cMsTimeout / 1000));
+ reporter.flushall();
+ oSession = self.startVmByName(sVmName);
+ if oSession is not None:
+ # Connect to TXS.
+ reporter.log2('startVmAndConnectToTxsViaTcp: Started(/prepared) "%s", connecting to TXS ...' % (sVmName,));
+ (fRc, oTxsSession) = self.txsDoConnectViaTcp(oSession, cMsTimeout, fNatForwardingForTxs);
+ if fRc is True:
+ if fCdWait:
+ # Wait for CD?
+ reporter.log2('startVmAndConnectToTxsViaTcp: Waiting for file "%s" to become available ...' % (sFileCdWait,));
+ fRc = self.txsCdWait(oSession, oTxsSession, cMsCdWait, sFileCdWait);
+ if fRc is not True:
+ reporter.error('startVmAndConnectToTxsViaTcp: txsCdWait failed');
+
+ sVer = self.txsVer(oSession, oTxsSession, cMsTimeout, fIgnoreErrors = True);
+ if sVer is not False:
+ reporter.log('startVmAndConnectToTxsViaTcp: TestExecService version %s' % (sVer,));
+ else:
+ reporter.log('startVmAndConnectToTxsViaTcp: Unable to retrieve TestExecService version');
+
+ if fRc is True:
+ # Success!
+ return (oSession, oTxsSession);
+ else:
+ reporter.error('startVmAndConnectToTxsViaTcp: txsDoConnectViaTcp failed');
+ # If something went wrong while waiting for TXS to be started - take VM screenshot before terminate it
+ self.terminateVmBySession(oSession);
+ return (None, None);
+
+ def txsRebootAndReconnectViaTcp(self, oSession, oTxsSession, fCdWait = False, cMsTimeout = 15*60000, \
+ cMsCdWait = 30000, sFileCdWait = None, fNatForwardingForTxs = False):
+ """
+ Executes the TXS reboot command
+
+ Returns A tuple of True and the new TXS session on success.
+
+ Returns A tuple of False and either the old TXS session or None on failure.
+ """
+ reporter.log2('txsRebootAndReconnect: cMsTimeout=%u' % (cMsTimeout,));
+
+ #
+ # This stuff is a bit complicated because of rebooting being kind of
+ # disruptive to the TXS and such... The protocol is that TXS will:
+ # - ACK the reboot command.
+ # - Shutdown the transport layer, implicitly disconnecting us.
+ # - Execute the reboot operation.
+ # - On failure, it will be re-init the transport layer and be
+ # available pretty much immediately. UUID unchanged.
+ # - On success, it will be respawed after the reboot (hopefully),
+ # with a different UUID.
+ #
+ fRc = False;
+ iStart = base.timestampMilli();
+
+ # Get UUID.
+ cMsTimeout2 = min(60000, cMsTimeout);
+ sUuidBefore = self.txsUuid(oSession, oTxsSession, self.adjustTimeoutMs(cMsTimeout2, 60000));
+ if sUuidBefore is not False:
+ # Reboot.
+ cMsElapsed = base.timestampMilli() - iStart;
+ cMsTimeout2 = cMsTimeout - cMsElapsed;
+ fRc = self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncReboot,
+ (self.adjustTimeoutMs(cMsTimeout2, 60000), False));
+ if fRc is True:
+ # Reconnect.
+ if fNatForwardingForTxs is True:
+ self.sleep(22); # NAT fudge - Two fixes are wanted: 1. TXS connect retries. 2. Main API reboot/reset hint.
+ cMsElapsed = base.timestampMilli() - iStart;
+ (fRc, oTxsSession) = self.txsDoConnectViaTcp(oSession, cMsTimeout - cMsElapsed, fNatForwardingForTxs);
+ if fRc is True:
+ # Check the UUID.
+ cMsElapsed = base.timestampMilli() - iStart;
+ cMsTimeout2 = min(60000, cMsTimeout - cMsElapsed);
+ sUuidAfter = self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUuid,
+ (self.adjustTimeoutMs(cMsTimeout2, 60000), False));
+ if sUuidBefore is not False:
+ if sUuidAfter != sUuidBefore:
+ reporter.log('The guest rebooted (UUID %s -> %s)' % (sUuidBefore, sUuidAfter))
+
+ # Do CD wait if specified.
+ if fCdWait:
+ fRc = self.txsCdWait(oSession, oTxsSession, cMsCdWait, sFileCdWait);
+ if fRc is not True:
+ reporter.error('txsRebootAndReconnectViaTcp: txsCdWait failed');
+
+ sVer = self.txsVer(oSession, oTxsSession, cMsTimeout, fIgnoreErrors = True);
+ if sVer is not False:
+ reporter.log('txsRebootAndReconnectViaTcp: TestExecService version %s' % (sVer,));
+ else:
+ reporter.log('txsRebootAndReconnectViaTcp: Unable to retrieve TestExecService version');
+ else:
+ reporter.error('txsRebootAndReconnectViaTcp: failed to get UUID (after)');
+ else:
+ reporter.error('txsRebootAndReconnectViaTcp: did not reboot (UUID %s)' % (sUuidBefore,));
+ else:
+ reporter.error('txsRebootAndReconnectViaTcp: txsDoConnectViaTcp failed');
+ else:
+ reporter.error('txsRebootAndReconnectViaTcp: reboot failed');
+ else:
+ reporter.error('txsRebootAndReconnectViaTcp: failed to get UUID (before)');
+ return (fRc, oTxsSession);
+
+ # pylint: disable=too-many-locals,too-many-arguments
+
+ def txsRunTest(self, oTxsSession, sTestName, cMsTimeout, sExecName, asArgs = (), asAddEnv = (), sAsUser = "",
+ fCheckSessionStatus = False):
+ """
+ Executes the specified test task, waiting till it completes or times out.
+
+ The VM session (if any) must be in the task list.
+
+ Returns True if we executed the task and nothing abnormal happend.
+ Query the process status from the TXS session.
+
+ Returns False if some unexpected task was signalled or we failed to
+ submit the job.
+
+ If fCheckSessionStatus is set to True, the overall session status will be
+ taken into account and logged as an error on failure.
+ """
+ reporter.testStart(sTestName);
+ reporter.log2('txsRunTest: cMsTimeout=%u sExecName=%s asArgs=%s' % (cMsTimeout, sExecName, asArgs));
+
+ # Submit the job.
+ fRc = False;
+ if oTxsSession.asyncExec(sExecName, asArgs, asAddEnv, sAsUser, cMsTimeout = self.adjustTimeoutMs(cMsTimeout)):
+ self.addTask(oTxsSession);
+
+ # Wait for the job to complete.
+ while True:
+ oTask = self.waitForTasks(cMsTimeout + 1);
+ if oTask is None:
+ if fCheckSessionStatus:
+ reporter.error('txsRunTest: waitForTasks for test "%s" timed out' % (sTestName,));
+ else:
+ reporter.log('txsRunTest: waitForTasks for test "%s" timed out' % (sTestName,));
+ break;
+ if oTask is oTxsSession:
+ if fCheckSessionStatus \
+ and not oTxsSession.isSuccess():
+ reporter.error('txsRunTest: Test "%s" failed' % (sTestName,));
+ else:
+ fRc = True;
+ reporter.log('txsRunTest: isSuccess=%s getResult=%s' \
+ % (oTxsSession.isSuccess(), oTxsSession.getResult()));
+ break;
+ if not self.handleTask(oTask, 'txsRunTest'):
+ break;
+
+ self.removeTask(oTxsSession);
+ if not oTxsSession.pollTask():
+ oTxsSession.cancelTask();
+ else:
+ reporter.error('txsRunTest: asyncExec failed');
+
+ reporter.testDone();
+ return fRc;
+
+ def txsRunTestRedirectStd(self, oTxsSession, sTestName, cMsTimeout, sExecName, asArgs = (), asAddEnv = (), sAsUser = "",
+ oStdIn = '/dev/null', oStdOut = '/dev/null', oStdErr = '/dev/null', oTestPipe = '/dev/null'):
+ """
+ Executes the specified test task, waiting till it completes or times out,
+ redirecting stdin, stdout and stderr to the given objects.
+
+ The VM session (if any) must be in the task list.
+
+ Returns True if we executed the task and nothing abnormal happend.
+ Query the process status from the TXS session.
+
+ Returns False if some unexpected task was signalled or we failed to
+ submit the job.
+ """
+ reporter.testStart(sTestName);
+ reporter.log2('txsRunTestRedirectStd: cMsTimeout=%u sExecName=%s asArgs=%s' % (cMsTimeout, sExecName, asArgs));
+
+ # Submit the job.
+ fRc = False;
+ if oTxsSession.asyncExecEx(sExecName, asArgs, asAddEnv, oStdIn, oStdOut, oStdErr,
+ oTestPipe, sAsUser, cMsTimeout = self.adjustTimeoutMs(cMsTimeout)):
+ self.addTask(oTxsSession);
+
+ # Wait for the job to complete.
+ while True:
+ oTask = self.waitForTasks(cMsTimeout + 1);
+ if oTask is None:
+ reporter.log('txsRunTestRedirectStd: waitForTasks timed out');
+ break;
+ if oTask is oTxsSession:
+ fRc = True;
+ reporter.log('txsRunTestRedirectStd: isSuccess=%s getResult=%s'
+ % (oTxsSession.isSuccess(), oTxsSession.getResult()));
+ break;
+ if not self.handleTask(oTask, 'txsRunTestRedirectStd'):
+ break;
+
+ self.removeTask(oTxsSession);
+ if not oTxsSession.pollTask():
+ oTxsSession.cancelTask();
+ else:
+ reporter.error('txsRunTestRedirectStd: asyncExec failed');
+
+ reporter.testDone();
+ return fRc;
+
+ def txsRunTest2(self, oTxsSession1, oTxsSession2, sTestName, cMsTimeout,
+ sExecName1, asArgs1,
+ sExecName2, asArgs2,
+ asAddEnv1 = (), sAsUser1 = '', fWithTestPipe1 = True,
+ asAddEnv2 = (), sAsUser2 = '', fWithTestPipe2 = True):
+ """
+ Executes the specified test tasks, waiting till they complete or
+ times out. The 1st task is started after the 2nd one.
+
+ The VM session (if any) must be in the task list.
+
+ Returns True if we executed the task and nothing abnormal happend.
+ Query the process status from the TXS sessions.
+
+ Returns False if some unexpected task was signalled or we failed to
+ submit the job.
+ """
+ reporter.testStart(sTestName);
+
+ # Submit the jobs.
+ fRc = False;
+ if oTxsSession1.asyncExec(sExecName1, asArgs1, asAddEnv1, sAsUser1, fWithTestPipe1, '1-',
+ self.adjustTimeoutMs(cMsTimeout)):
+ self.addTask(oTxsSession1);
+
+ self.sleep(2); # fudge! grr
+
+ if oTxsSession2.asyncExec(sExecName2, asArgs2, asAddEnv2, sAsUser2, fWithTestPipe2, '2-',
+ self.adjustTimeoutMs(cMsTimeout)):
+ self.addTask(oTxsSession2);
+
+ # Wait for the jobs to complete.
+ cPendingJobs = 2;
+ while True:
+ oTask = self.waitForTasks(cMsTimeout + 1);
+ if oTask is None:
+ reporter.log('txsRunTest2: waitForTasks timed out');
+ break;
+
+ if oTask is oTxsSession1 or oTask is oTxsSession2:
+ if oTask is oTxsSession1: iTask = 1;
+ else: iTask = 2;
+ reporter.log('txsRunTest2: #%u - isSuccess=%s getResult=%s' \
+ % (iTask, oTask.isSuccess(), oTask.getResult()));
+ self.removeTask(oTask);
+ cPendingJobs -= 1;
+ if cPendingJobs <= 0:
+ fRc = True;
+ break;
+
+ elif not self.handleTask(oTask, 'txsRunTest'):
+ break;
+
+ self.removeTask(oTxsSession2);
+ if not oTxsSession2.pollTask():
+ oTxsSession2.cancelTask();
+ else:
+ reporter.error('txsRunTest2: asyncExec #2 failed');
+
+ self.removeTask(oTxsSession1);
+ if not oTxsSession1.pollTask():
+ oTxsSession1.cancelTask();
+ else:
+ reporter.error('txsRunTest2: asyncExec #1 failed');
+
+ reporter.testDone();
+ return fRc;
+
+ # pylint: enable=too-many-locals,too-many-arguments
+
+
+ #
+ # Working with test results via serial port.
+ #
+
+ class TxsMonitorComFile(base.TdTaskBase):
+ """
+ Class that monitors a COM output file.
+ """
+
+ def __init__(self, sComRawFile, asStopWords = None):
+ base.TdTaskBase.__init__(self, utils.getCallerName());
+ self.sComRawFile = sComRawFile;
+ self.oStopRegExp = re.compile('\\b(' + '|'.join(asStopWords if asStopWords else ('PASSED', 'FAILED',)) + ')\\b');
+ self.sResult = None; ##< The result.
+ self.cchDisplayed = 0; ##< Offset into the file string of what we've already fed to the logger.
+
+ def toString(self):
+ return '<%s sComRawFile=%s oStopRegExp=%s sResult=%s cchDisplayed=%s>' \
+ % (base.TdTaskBase.toString(self), self.sComRawFile, self.oStopRegExp, self.sResult, self.cchDisplayed,);
+
+ def pollTask(self, fLocked = False):
+ """
+ Overrides TdTaskBase.pollTask() for the purpose of polling the file.
+ """
+ if not fLocked:
+ self.lockTask();
+
+ sFile = utils.noxcptReadFile(self.sComRawFile, '', 'rU');
+ if len(sFile) > self.cchDisplayed:
+ sNew = sFile[self.cchDisplayed:];
+ oMatch = self.oStopRegExp.search(sNew);
+ if oMatch:
+ # Done! Get result, flush all the output and signal the task.
+ self.sResult = oMatch.group(1);
+ for sLine in sNew.split('\n'):
+ reporter.log('COM OUTPUT: %s' % (sLine,));
+ self.cchDisplayed = len(sFile);
+ self.signalTaskLocked();
+ else:
+ # Output whole lines only.
+ offNewline = sFile.find('\n', self.cchDisplayed);
+ while offNewline >= 0:
+ reporter.log('COM OUTPUT: %s' % (sFile[self.cchDisplayed:offNewline]))
+ self.cchDisplayed = offNewline + 1;
+ offNewline = sFile.find('\n', self.cchDisplayed);
+
+ fRet = self.fSignalled;
+ if not fLocked:
+ self.unlockTask();
+ return fRet;
+
+ # Our stuff.
+ def getResult(self):
+ """
+ Returns the connected TXS session object on success.
+ Returns None on failure or if the task has not yet completed.
+ """
+ self.oCv.acquire();
+ sResult = self.sResult;
+ self.oCv.release();
+ return sResult;
+
+ def cancelTask(self):
+ """ Cancels the task. """
+ self.signalTask();
+ return True;
+
+
+ def monitorComRawFile(self, oSession, sComRawFile, cMsTimeout = 15*60000, asStopWords = None):
+ """
+ Monitors the COM output file for stop words (PASSED and FAILED by default).
+
+ Returns the stop word.
+ Returns None on VM error and timeout.
+ """
+
+ reporter.log2('monitorComRawFile: oSession=%s, cMsTimeout=%s, sComRawFile=%s' % (oSession, cMsTimeout, sComRawFile));
+
+ oMonitorTask = self.TxsMonitorComFile(sComRawFile, asStopWords);
+ self.addTask(oMonitorTask);
+
+ cMsTimeout = self.adjustTimeoutMs(cMsTimeout);
+ oTask = self.waitForTasks(cMsTimeout + 1);
+ reporter.log2('monitorComRawFile: waitForTasks returned %s' % (oTask,));
+
+ if oTask is not oMonitorTask:
+ oMonitorTask.cancelTask();
+ self.removeTask(oMonitorTask);
+
+ oMonitorTask.pollTask();
+ return oMonitorTask.getResult();
+
+
+ def runVmAndMonitorComRawFile(self, sVmName, sComRawFile, cMsTimeout = 15*60000, asStopWords = None):
+ """
+ Runs the specified VM and monitors the given COM output file for stop
+ words (PASSED and FAILED by default).
+
+ The caller is assumed to have configured the VM to use the given
+ file. The method will take no action to verify this.
+
+ Returns the stop word.
+ Returns None on VM error and timeout.
+ """
+
+ # Start the VM.
+ reporter.log('runVmAndMonitorComRawFile: Starting(/preparing) "%s" (timeout %s s)...' % (sVmName, cMsTimeout / 1000));
+ reporter.flushall();
+ oSession = self.startVmByName(sVmName);
+ if oSession is not None:
+ # Let it run and then terminate it.
+ sRet = self.monitorComRawFile(oSession, sComRawFile, cMsTimeout, asStopWords);
+ self.terminateVmBySession(oSession);
+ else:
+ sRet = None;
+ return sRet;
+
+ #
+ # Other stuff
+ #
+
+ def waitForGAs(self,
+ oSession, # type: vboxwrappers.SessionWrapper
+ cMsTimeout = 120000, aenmWaitForRunLevels = None, aenmWaitForActive = None, aenmWaitForInactive = None):
+ """
+ Waits for the guest additions to enter a certain state.
+
+ aenmWaitForRunLevels - List of run level values to wait for (success if one matches).
+ aenmWaitForActive - List facilities (type values) that must be active.
+ aenmWaitForInactive - List facilities (type values) that must be inactive.
+
+ Defaults to wait for AdditionsRunLevelType_Userland if nothing else is given.
+
+ Returns True on success, False w/ error logging on timeout or failure.
+ """
+ reporter.log2('waitForGAs: oSession=%s, cMsTimeout=%s' % (oSession, cMsTimeout,));
+
+ #
+ # Get IGuest:
+ #
+ try:
+ oIGuest = oSession.o.console.guest;
+ except:
+ return reporter.errorXcpt();
+
+ #
+ # Create a wait task:
+ #
+ from testdriver.vboxwrappers import AdditionsStatusTask;
+ try:
+ oGaStatusTask = AdditionsStatusTask(oSession = oSession,
+ oIGuest = oIGuest,
+ cMsTimeout = cMsTimeout,
+ aenmWaitForRunLevels = aenmWaitForRunLevels,
+ aenmWaitForActive = aenmWaitForActive,
+ aenmWaitForInactive = aenmWaitForInactive);
+ except:
+ return reporter.errorXcpt();
+
+ #
+ # Add the task and make sure the VM session is also present.
+ #
+ self.addTask(oGaStatusTask);
+ fRemoveSession = self.addTask(oSession);
+ oTask = self.waitForTasks(cMsTimeout + 1);
+ reporter.log2('waitForGAs: returned %s (oGaStatusTask=%s, oSession=%s)' % (oTask, oGaStatusTask, oSession,));
+ self.removeTask(oGaStatusTask);
+ if fRemoveSession:
+ self.removeTask(oSession);
+
+ #
+ # Digest the result.
+ #
+ if oTask is oGaStatusTask:
+ fSucceeded = oGaStatusTask.getResult();
+ if fSucceeded is True:
+ reporter.log('waitForGAs: Succeeded.');
+ else:
+ reporter.error('waitForGAs: Failed.');
+ else:
+ oGaStatusTask.cancelTask();
+ if oTask is None:
+ reporter.error('waitForGAs: Timed out.');
+ elif oTask is oSession:
+ oSession.reportPrematureTermination('waitForGAs: ');
+ else:
+ reporter.error('waitForGAs: unknown/wrong task %s' % (oTask,));
+ fSucceeded = False;
+ return fSucceeded;
+
+ @staticmethod
+ def controllerTypeToName(eControllerType):
+ """
+ Translate a controller type to a standard controller name.
+ """
+ if eControllerType in (vboxcon.StorageControllerType_PIIX3, vboxcon.StorageControllerType_PIIX4,):
+ sName = "IDE Controller";
+ elif eControllerType == vboxcon.StorageControllerType_IntelAhci:
+ sName = "SATA Controller";
+ elif eControllerType == vboxcon.StorageControllerType_LsiLogicSas:
+ sName = "SAS Controller";
+ elif eControllerType in (vboxcon.StorageControllerType_LsiLogic, vboxcon.StorageControllerType_BusLogic,):
+ sName = "SCSI Controller";
+ elif eControllerType == vboxcon.StorageControllerType_NVMe:
+ sName = "NVMe Controller";
+ elif eControllerType == vboxcon.StorageControllerType_VirtioSCSI:
+ sName = "VirtIO SCSI Controller";
+ else:
+ sName = "Storage Controller";
+ return sName;
diff --git a/src/VBox/ValidationKit/testdriver/vboxcon.py b/src/VBox/ValidationKit/testdriver/vboxcon.py
new file mode 100755
index 00000000..1ab7321f
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/vboxcon.py
@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+# $Id: vboxcon.py $
+
+"""
+VirtualBox Constants.
+
+See VBoxConstantWrappingHack for details.
+"""
+
+__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 sys
+
+
+class VBoxConstantWrappingHack(object): # pylint: disable=too-few-public-methods
+ """
+ This is a hack to avoid the self.oVBoxMgr.constants.MachineState_Running
+ ugliness that forces one into the right margin... Anyone using this module
+ can get to the constants easily by:
+
+ from testdriver import vboxcon
+ if self.o.machine.state == vboxcon.MachineState_Running:
+ do stuff;
+
+ For our own convenience there's a vboxcon attribute set up in vbox.py,
+ class TestDriver which is the basis for the VirtualBox testcases. It takes
+ care of setting things up properly through the global variable
+ 'goHackModuleClass' that refers to the instance of this class(if we didn't
+ we'd have to use testdriver.vboxcon.MachineState_Running).
+ """
+ def __init__(self, oWrapped):
+ self.oWrapped = oWrapped;
+ self.oVBoxMgr = None;
+ self.fpApiVer = 99.0;
+
+ def __getattr__(self, sName):
+ # Our self.
+ try:
+ return getattr(self.oWrapped, sName)
+ except AttributeError:
+ # The VBox constants.
+ if self.oVBoxMgr is None:
+ raise;
+ try:
+ return getattr(self.oVBoxMgr.constants, sName);
+ except AttributeError:
+ # Do some compatability mappings to keep it working with
+ # older versions.
+ if self.fpApiVer < 3.3:
+ if sName == 'SessionState_Locked':
+ return getattr(self.oVBoxMgr.constants, 'SessionState_Open');
+ if sName == 'SessionState_Unlocked':
+ return getattr(self.oVBoxMgr.constants, 'SessionState_Closed');
+ if sName == 'SessionState_Unlocking':
+ return getattr(self.oVBoxMgr.constants, 'SessionState_Closing');
+ raise;
+
+
+goHackModuleClass = VBoxConstantWrappingHack(sys.modules[__name__]); # pylint: disable=invalid-name
+sys.modules[__name__] = goHackModuleClass;
+
diff --git a/src/VBox/ValidationKit/testdriver/vboxinstaller.py b/src/VBox/ValidationKit/testdriver/vboxinstaller.py
new file mode 100755
index 00000000..6c72ac91
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/vboxinstaller.py
@@ -0,0 +1,1251 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+VirtualBox Installer Wrapper Driver.
+
+This installs VirtualBox, starts a sub driver which does the real testing,
+and then uninstall VirtualBox afterwards. This reduces the complexity of the
+other VBox test drivers.
+"""
+
+__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 os
+import sys
+import re
+import socket
+import tempfile
+import time
+
+# Only the main script needs to modify the path.
+try: __file__
+except: __file__ = sys.argv[0];
+g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)));
+sys.path.append(g_ksValidationKitDir);
+
+# Validation Kit imports.
+from common import utils, webutils;
+from common.constants import rtexitcode;
+from testdriver import reporter;
+from testdriver.base import TestDriverBase;
+
+
+
+class VBoxInstallerTestDriver(TestDriverBase):
+ """
+ Implementation of a top level test driver.
+ """
+
+
+ ## State file indicating that we've skipped installation.
+ ksVar_Skipped = 'vboxinstaller-skipped';
+
+
+ def __init__(self):
+ TestDriverBase.__init__(self);
+ self._asSubDriver = []; # The sub driver and it's arguments.
+ self._asBuildUrls = []; # The URLs passed us on the command line.
+ self._asBuildFiles = []; # The downloaded file names.
+ self._fUnpackedBuildFiles = False;
+ self._fAutoInstallPuelExtPack = True;
+ self._fKernelDrivers = True;
+ self._fWinForcedInstallTimestampCA = True;
+ self._fInstallMsCrt = False; # By default we don't install the Microsoft CRT (only needed once).
+
+ #
+ # Base method we override
+ #
+
+ def showUsage(self):
+ rc = TestDriverBase.showUsage(self);
+ # 0 1 2 3 4 5 6 7 8
+ # 012345678901234567890123456789012345678901234567890123456789012345678901234567890
+ reporter.log('');
+ reporter.log('vboxinstaller Options:');
+ reporter.log(' --vbox-build <url[,url2[,...]]>');
+ reporter.log(' Comma separated list of URL to file to download and install or/and');
+ reporter.log(' unpack. URLs without a schema are assumed to be files on the');
+ reporter.log(' build share and will be copied off it.');
+ reporter.log(' --no-puel-extpack');
+ reporter.log(' Indicates that the PUEL extension pack should not be installed if found.');
+ reporter.log(' The default is to install it when found in the vbox-build.');
+ reporter.log(' --no-kernel-drivers');
+ reporter.log(' Indicates that the kernel drivers should not be installed on platforms');
+ reporter.log(' where this is optional. The default is to install them.');
+ reporter.log(' --forced-win-install-timestamp-ca, --no-forced-win-install-timestamp-ca');
+ reporter.log(' Whether to force installation of the legacy Windows timestamp CA.');
+ reporter.log(' If not forced, it will only installed on the hosts that needs it.');
+ reporter.log(' Default: --no-forced-win-install-timestamp-ca');
+ reporter.log(' --win-install-mscrt, --no-win-install-mscrt');
+ reporter.log(' Whether to install the MS Visual Studio Redistributable.');
+ reporter.log(' Default: --no-win-install-mscrt');
+ reporter.log(' --');
+ reporter.log(' Indicates the end of our parameters and the start of the sub');
+ reporter.log(' testdriver and its arguments.');
+ return rc;
+
+ def parseOption(self, asArgs, iArg):
+ """
+ Parse our arguments.
+ """
+ if asArgs[iArg] == '--':
+ # End of our parameters and start of the sub driver invocation.
+ iArg = self.requireMoreArgs(1, asArgs, iArg);
+ assert not self._asSubDriver;
+ self._asSubDriver = asArgs[iArg:];
+ self._asSubDriver[0] = self._asSubDriver[0].replace('/', os.path.sep);
+ iArg = len(asArgs) - 1;
+ elif asArgs[iArg] == '--vbox-build':
+ # List of files to copy/download and install.
+ iArg = self.requireMoreArgs(1, asArgs, iArg);
+ self._asBuildUrls = asArgs[iArg].split(',');
+ elif asArgs[iArg] == '--no-puel-extpack':
+ self._fAutoInstallPuelExtPack = False;
+ elif asArgs[iArg] == '--puel-extpack':
+ self._fAutoInstallPuelExtPack = True;
+ elif asArgs[iArg] == '--no-kernel-drivers':
+ self._fKernelDrivers = False;
+ elif asArgs[iArg] == '--kernel-drivers':
+ self._fKernelDrivers = True;
+ elif asArgs[iArg] == '--no-forced-win-install-timestamp-ca':
+ self._fWinForcedInstallTimestampCA = False;
+ elif asArgs[iArg] == '--forced-win-install-timestamp-ca':
+ self._fWinForcedInstallTimestampCA = True;
+ elif asArgs[iArg] == '--no-win-install-mscrt':
+ self._fInstallMsCrt = False;
+ elif asArgs[iArg] == '--win-install-mscrt':
+ self._fInstallMsCrt = True;
+ else:
+ return TestDriverBase.parseOption(self, asArgs, iArg);
+ return iArg + 1;
+
+ def completeOptions(self):
+ #
+ # Check that we've got what we need.
+ #
+ if not self._asBuildUrls:
+ reporter.error('No build files specified ("--vbox-build file1[,file2[...]]")');
+ return False;
+ if not self._asSubDriver:
+ reporter.error('No sub testdriver specified. (" -- test/stuff/tdStuff1.py args")');
+ return False;
+
+ #
+ # Construct _asBuildFiles as an array parallel to _asBuildUrls.
+ #
+ for sUrl in self._asBuildUrls:
+ sDstFile = os.path.join(self.sScratchPath, webutils.getFilename(sUrl));
+ self._asBuildFiles.append(sDstFile);
+
+ return TestDriverBase.completeOptions(self);
+
+ def actionExtract(self):
+ reporter.error('vboxinstall does not support extracting resources, you have to do that using the sub testdriver.');
+ return False;
+
+ def actionCleanupBefore(self):
+ """
+ Kills all VBox process we see.
+
+ This is only supposed to execute on a testbox so we don't need to go
+ all complicated wrt other users.
+ """
+ return self._killAllVBoxProcesses();
+
+ def actionConfig(self):
+ """
+ Install VBox and pass on the configure request to the sub testdriver.
+ """
+ fRc = self._installVBox();
+ if fRc is None:
+ self._persistentVarSet(self.ksVar_Skipped, 'true');
+ self.fBadTestbox = True;
+ else:
+ self._persistentVarUnset(self.ksVar_Skipped);
+
+ ## @todo vbox.py still has bugs preventing us from invoking it seperately with each action.
+ if fRc is True and 'execute' not in self.asActions and 'all' not in self.asActions:
+ fRc = self._executeSubDriver([ 'verify', ]);
+ if fRc is True and 'execute' not in self.asActions and 'all' not in self.asActions:
+ fRc = self._executeSubDriver([ 'config', ], fPreloadASan = True);
+ return fRc;
+
+ def actionExecute(self):
+ """
+ Execute the sub testdriver.
+ """
+ return self._executeSubDriver(self.asActions, fPreloadASan = True);
+
+ def actionCleanupAfter(self):
+ """
+ Forward this to the sub testdriver, then uninstall VBox.
+ """
+ fRc = True;
+ if 'execute' not in self.asActions and 'all' not in self.asActions:
+ fRc = self._executeSubDriver([ 'cleanup-after', ], fMaySkip = False);
+
+ if not self._killAllVBoxProcesses():
+ fRc = False;
+
+ if not self._uninstallVBox(self._persistentVarExists(self.ksVar_Skipped)):
+ fRc = False;
+
+ if utils.getHostOs() == 'darwin':
+ self._darwinUnmountDmg(fIgnoreError = True); # paranoia
+
+ if not TestDriverBase.actionCleanupAfter(self):
+ fRc = False;
+
+ return fRc;
+
+
+ def actionAbort(self):
+ """
+ Forward this to the sub testdriver first, then wipe all VBox like
+ processes, and finally do the pid file processing (again).
+ """
+ fRc1 = self._executeSubDriver([ 'abort', ], fMaySkip = False, fPreloadASan = True);
+ fRc2 = self._killAllVBoxProcesses();
+ fRc3 = TestDriverBase.actionAbort(self);
+ return fRc1 and fRc2 and fRc3;
+
+
+ #
+ # Persistent variables.
+ #
+ ## @todo integrate into the base driver. Persistent accross scratch wipes?
+
+ def __persistentVarCalcName(self, sVar):
+ """Returns the (full) filename for the given persistent variable."""
+ assert re.match(r'^[a-zA-Z0-9_-]*$', sVar) is not None;
+ return os.path.join(self.sScratchPath, 'persistent-%s.var' % (sVar,));
+
+ def _persistentVarSet(self, sVar, sValue = ''):
+ """
+ Sets a persistent variable.
+
+ Returns True on success, False + reporter.error on failure.
+
+ May raise exception if the variable name is invalid or something
+ unexpected happens.
+ """
+ sFull = self.__persistentVarCalcName(sVar);
+ try:
+ with open(sFull, 'w') as oFile: # pylint: disable=unspecified-encoding
+ if sValue:
+ oFile.write(sValue.encode('utf-8'));
+ except:
+ reporter.errorXcpt('Error creating "%s"' % (sFull,));
+ return False;
+ return True;
+
+ def _persistentVarUnset(self, sVar):
+ """
+ Unsets a persistent variable.
+
+ Returns True on success, False + reporter.error on failure.
+
+ May raise exception if the variable name is invalid or something
+ unexpected happens.
+ """
+ sFull = self.__persistentVarCalcName(sVar);
+ if os.path.exists(sFull):
+ try:
+ os.unlink(sFull);
+ except:
+ reporter.errorXcpt('Error unlinking "%s"' % (sFull,));
+ return False;
+ return True;
+
+ def _persistentVarExists(self, sVar):
+ """
+ Checks if a persistent variable exists.
+
+ Returns true/false.
+
+ May raise exception if the variable name is invalid or something
+ unexpected happens.
+ """
+ return os.path.exists(self.__persistentVarCalcName(sVar));
+
+ def _persistentVarGet(self, sVar):
+ """
+ Gets the value of a persistent variable.
+
+ Returns variable value on success.
+ Returns None if the variable doesn't exist or if an
+ error (reported) occured.
+
+ May raise exception if the variable name is invalid or something
+ unexpected happens.
+ """
+ sFull = self.__persistentVarCalcName(sVar);
+ if not os.path.exists(sFull):
+ return None;
+ try:
+ with open(sFull, 'r') as oFile: # pylint: disable=unspecified-encoding
+ sValue = oFile.read().decode('utf-8');
+ except:
+ reporter.errorXcpt('Error creating "%s"' % (sFull,));
+ return None;
+ return sValue;
+
+
+ #
+ # Helpers.
+ #
+
+ def _killAllVBoxProcesses(self):
+ """
+ Kills all virtual box related processes we find in the system.
+ """
+ sHostOs = utils.getHostOs();
+ asDebuggers = [ 'cdb', 'windbg', ] if sHostOs == 'windows' else [ 'gdb', 'gdb-i386-apple-darwin', 'lldb' ];
+
+ for iIteration in range(22):
+ # Gather processes to kill.
+ aoTodo = [];
+ aoDebuggers = [];
+ for oProcess in utils.processListAll():
+ sBase = oProcess.getBaseImageNameNoExeSuff();
+ if sBase is None:
+ continue;
+ sBase = sBase.lower();
+ if sBase in [ 'vboxsvc', 'vboxsds', 'virtualbox', 'virtualboxvm', 'vboxheadless', 'vboxmanage', 'vboxsdl',
+ 'vboxwebsrv', 'vboxautostart', 'vboxballoonctrl', 'vboxbfe', 'vboxextpackhelperapp', 'vboxnetdhcp',
+ 'vboxnetnat', 'vboxnetadpctl', 'vboxtestogl', 'vboxtunctl', 'vboxvmmpreload', 'vboxxpcomipcd', ]:
+ aoTodo.append(oProcess);
+ if sBase.startswith('virtualbox-') and sBase.endswith('-multiarch.exe'):
+ aoTodo.append(oProcess);
+ if sBase in asDebuggers:
+ aoDebuggers.append(oProcess);
+ if iIteration in [0, 21]:
+ reporter.log('Warning: debugger running: %s (%s %s)' % (oProcess.iPid, sBase, oProcess.asArgs));
+ if not aoTodo:
+ return True;
+
+ # Are any of the debugger processes hooked up to a VBox process?
+ if sHostOs == 'windows':
+ # On demand debugging windows: windbg -p <decimal-pid> -e <decimal-event> -g
+ for oDebugger in aoDebuggers:
+ for oProcess in aoTodo:
+ # The whole command line is asArgs[0] here. Fix if that changes.
+ if oDebugger.asArgs and oDebugger.asArgs[0].find('-p %s ' % (oProcess.iPid,)) >= 0:
+ aoTodo.append(oDebugger);
+ break;
+ else:
+ for oDebugger in aoDebuggers:
+ for oProcess in aoTodo:
+ # Simplistic approach: Just check for argument equaling our pid.
+ if oDebugger.asArgs and ('%s' % oProcess.iPid) in oDebugger.asArgs:
+ aoTodo.append(oDebugger);
+ break;
+
+ # Kill.
+ for oProcess in aoTodo:
+ reporter.log('Loop #%d - Killing %s (%s, uid=%s)'
+ % ( iIteration, oProcess.iPid, oProcess.sImage if oProcess.sName is None else oProcess.sName,
+ oProcess.iUid, ));
+ if not utils.processKill(oProcess.iPid) \
+ and sHostOs != 'windows' \
+ and utils.processExists(oProcess.iPid):
+ # Many of the vbox processes are initially set-uid-to-root and associated debuggers are running
+ # via sudo, so we might not be able to kill them unless we sudo and use /bin/kill.
+ try: utils.sudoProcessCall(['/bin/kill', '-9', '%s' % (oProcess.iPid,)]);
+ except: reporter.logXcpt();
+
+ # Check if they're all dead like they should be.
+ time.sleep(0.1);
+ for oProcess in aoTodo:
+ if utils.processExists(oProcess.iPid):
+ time.sleep(2);
+ break;
+
+ return False;
+
+ def _executeSync(self, asArgs, fMaySkip = False):
+ """
+ Executes a child process synchronously.
+
+ Returns True if the process executed successfully and returned 0.
+ Returns None if fMaySkip is true and the child exits with RTEXITCODE_SKIPPED.
+ Returns False for all other cases.
+ """
+ reporter.log('Executing: %s' % (asArgs, ));
+ reporter.flushall();
+ try:
+ iRc = utils.processCall(asArgs, shell = False, close_fds = False);
+ except:
+ reporter.errorXcpt();
+ return False;
+ reporter.log('Exit code: %s (%s)' % (iRc, asArgs));
+ if fMaySkip and iRc == rtexitcode.RTEXITCODE_SKIPPED:
+ return None;
+ return iRc == 0;
+
+ def _sudoExecuteSync(self, asArgs):
+ """
+ Executes a sudo child process synchronously.
+ Returns a tuple [True, 0] if the process executed successfully
+ and returned 0, otherwise [False, rc] is returned.
+ """
+ reporter.log('Executing [sudo]: %s' % (asArgs, ));
+ reporter.flushall();
+ iRc = 0;
+ try:
+ iRc = utils.sudoProcessCall(asArgs, shell = False, close_fds = False);
+ except:
+ reporter.errorXcpt();
+ return (False, 0);
+ reporter.log('Exit code [sudo]: %s (%s)' % (iRc, asArgs));
+ return (iRc == 0, iRc);
+
+ def _findASanLibsForASanBuild(self):
+ """
+ Returns a list of (address) santizier related libraries to preload
+ when launching the sub driver.
+ Returns empty list for non-asan builds or on platforms where this isn't needed.
+ """
+ # Note! We include libasan.so.X in the VBoxAll tarball for asan builds, so we
+ # can use its presence both to detect an 'asan' build and to return it.
+ # Only the libasan.so.X library needs preloading at present.
+ if self.sHost in ('linux',):
+ sLibASan = self._findFile(r'libasan\.so\..*');
+ if sLibASan:
+ return [sLibASan,];
+ return [];
+
+ def _executeSubDriver(self, asActions, fMaySkip = True, fPreloadASan = True):
+ """
+ Execute the sub testdriver with the specified action.
+ """
+ asArgs = list(self._asSubDriver)
+ asArgs.append('--no-wipe-clean');
+ asArgs.extend(asActions);
+
+ asASanLibs = [];
+ if fPreloadASan:
+ asASanLibs = self._findASanLibsForASanBuild();
+ if asASanLibs:
+ os.environ['LD_PRELOAD'] = ':'.join(asASanLibs);
+ os.environ['LSAN_OPTIONS'] = 'detect_leaks=0'; # We don't want python leaks. vbox.py disables this.
+
+ # Because of https://github.com/google/sanitizers/issues/856 we must try use setarch to disable
+ # address space randomization.
+
+ reporter.log('LD_PRELOAD...')
+ if utils.getHostArch() == 'amd64':
+ sSetArch = utils.whichProgram('setarch');
+ reporter.log('sSetArch=%s' % (sSetArch,));
+ if sSetArch:
+ asArgs = [ sSetArch, 'x86_64', '-R', sys.executable ] + asArgs;
+ reporter.log('asArgs=%s' % (asArgs,));
+
+ rc = self._executeSync(asArgs, fMaySkip = fMaySkip);
+
+ del os.environ['LSAN_OPTIONS'];
+ del os.environ['LD_PRELOAD'];
+ return rc;
+
+ return self._executeSync(asArgs, fMaySkip = fMaySkip);
+
+ def _maybeUnpackArchive(self, sMaybeArchive, fNonFatal = False):
+ """
+ Attempts to unpack the given build file.
+ Updates _asBuildFiles.
+ Returns True/False. No exceptions.
+ """
+ def unpackFilter(sMember):
+ # type: (string) -> bool
+ """ Skips debug info. """
+ sLower = sMember.lower();
+ if sLower.endswith('.pdb'):
+ return False;
+ return True;
+
+ asMembers = utils.unpackFile(sMaybeArchive, self.sScratchPath, reporter.log,
+ reporter.log if fNonFatal else reporter.error,
+ fnFilter = unpackFilter);
+ if asMembers is None:
+ return False;
+ self._asBuildFiles.extend(asMembers);
+ return True;
+
+
+ def _installVBox(self):
+ """
+ Download / copy the build files into the scratch area and install them.
+ """
+ reporter.testStart('Installing VirtualBox');
+ reporter.log('CWD=%s' % (os.getcwd(),)); # curious
+
+ #
+ # Download the build files.
+ #
+ for i, sBuildUrl in enumerate(self._asBuildUrls):
+ if webutils.downloadFile(sBuildUrl, self._asBuildFiles[i], self.sBuildPath, reporter.log, reporter.log) is not True:
+ reporter.testDone(fSkipped = True);
+ return None; # Failed to get binaries, probably deleted. Skip the test run.
+
+ #
+ # Unpack anything we know what is and append it to the build files
+ # list. This allows us to use VBoxAll*.tar.gz files.
+ #
+ for sFile in list(self._asBuildFiles): # Note! We copy the list as _maybeUnpackArchive updates it.
+ if self._maybeUnpackArchive(sFile, fNonFatal = True) is not True:
+ reporter.testDone(fSkipped = True);
+ return None; # Failed to unpack. Probably local error, like busy
+ # DLLs on windows, no reason for failing the build.
+ self._fUnpackedBuildFiles = True;
+
+ #
+ # Go to system specific installation code.
+ #
+ sHost = utils.getHostOs()
+ if sHost == 'darwin': fRc = self._installVBoxOnDarwin();
+ elif sHost == 'linux': fRc = self._installVBoxOnLinux();
+ elif sHost == 'solaris': fRc = self._installVBoxOnSolaris();
+ elif sHost == 'win': fRc = self._installVBoxOnWindows();
+ else:
+ reporter.error('Unsupported host "%s".' % (sHost,));
+ if fRc is False:
+ reporter.testFailure('Installation error.');
+ elif fRc is not True:
+ reporter.log('Seems installation was skipped. Old version lurking behind? Not the fault of this build/test run!');
+
+ #
+ # Install the extension pack.
+ #
+ if fRc is True and self._fAutoInstallPuelExtPack:
+ fRc = self._installExtPack();
+ if fRc is False:
+ reporter.testFailure('Extension pack installation error.');
+
+ # Some debugging...
+ try:
+ cMbFreeSpace = utils.getDiskUsage(self.sScratchPath);
+ reporter.log('Disk usage after VBox install: %d MB available at %s' % (cMbFreeSpace, self.sScratchPath,));
+ except:
+ reporter.logXcpt('Unable to get disk free space. Ignored. Continuing.');
+
+ reporter.testDone(fRc is None);
+ return fRc;
+
+ def _uninstallVBox(self, fIgnoreError = False):
+ """
+ Uninstall VirtualBox.
+ """
+ reporter.testStart('Uninstalling VirtualBox');
+
+ sHost = utils.getHostOs()
+ if sHost == 'darwin': fRc = self._uninstallVBoxOnDarwin();
+ elif sHost == 'linux': fRc = self._uninstallVBoxOnLinux();
+ elif sHost == 'solaris': fRc = self._uninstallVBoxOnSolaris(True);
+ elif sHost == 'win': fRc = self._uninstallVBoxOnWindows('uninstall');
+ else:
+ reporter.error('Unsupported host "%s".' % (sHost,));
+ if fRc is False and not fIgnoreError:
+ reporter.testFailure('Uninstallation failed.');
+
+ fRc2 = self._uninstallAllExtPacks();
+ if not fRc2 and fRc:
+ fRc = fRc2;
+
+ reporter.testDone(fSkipped = (fRc is None));
+ return fRc;
+
+ def _findFile(self, sRegExp, fMandatory = False):
+ """
+ Returns the first build file that matches the given regular expression
+ (basename only).
+
+ Returns None if no match was found, logging it as an error if
+ fMandatory is set.
+ """
+ oRegExp = re.compile(sRegExp);
+
+ reporter.log('_findFile: %s' % (sRegExp,));
+ for sFile in self._asBuildFiles:
+ if oRegExp.match(os.path.basename(sFile)) and os.path.exists(sFile):
+ return sFile;
+
+ # If we didn't unpack the build files, search all the files in the scratch area:
+ if not self._fUnpackedBuildFiles:
+ for sDir, _, asFiles in os.walk(self.sScratchPath):
+ for sFile in asFiles:
+ #reporter.log('_findFile: considering %s' % (sFile,));
+ if oRegExp.match(sFile):
+ return os.path.join(sDir, sFile);
+
+ if fMandatory:
+ reporter.error('Failed to find a file matching "%s" in %s.' % (sRegExp, self._asBuildFiles,));
+ return None;
+
+ def _waitForTestManagerConnectivity(self, cSecTimeout):
+ """
+ Check and wait for network connectivity to the test manager.
+
+ This is used with the windows installation and uninstallation since
+ these usually disrupts network connectivity when installing the filter
+ driver. If we proceed to quickly, we might finish the test at a time
+ when we cannot report to the test manager and thus end up with an
+ abandonded test error.
+ """
+ cSecElapsed = 0;
+ secStart = utils.timestampSecond();
+ while reporter.checkTestManagerConnection() is False:
+ cSecElapsed = utils.timestampSecond() - secStart;
+ if cSecElapsed >= cSecTimeout:
+ reporter.log('_waitForTestManagerConnectivity: Giving up after %u secs.' % (cSecTimeout,));
+ return False;
+ time.sleep(2);
+
+ if cSecElapsed > 0:
+ reporter.log('_waitForTestManagerConnectivity: Waited %s secs.' % (cSecTimeout,));
+ return True;
+
+
+ #
+ # Darwin (Mac OS X).
+ #
+
+ def _darwinDmgPath(self):
+ """ Returns the path to the DMG mount."""
+ return os.path.join(self.sScratchPath, 'DmgMountPoint');
+
+ def _darwinUnmountDmg(self, fIgnoreError):
+ """
+ Umount any DMG on at the default mount point.
+ """
+ sMountPath = self._darwinDmgPath();
+ if not os.path.exists(sMountPath):
+ return True;
+
+ # Unmount.
+ fRc = self._executeSync(['hdiutil', 'detach', sMountPath ]);
+ if not fRc and not fIgnoreError:
+ # In case it's busy for some reason or another, just retry after a little delay.
+ for iTry in range(6):
+ time.sleep(5);
+ reporter.error('Retry #%s unmount DMT at %s' % (iTry + 1, sMountPath,));
+ fRc = self._executeSync(['hdiutil', 'detach', sMountPath ]);
+ if fRc:
+ break;
+ if not fRc:
+ reporter.error('Failed to unmount DMG at %s' % (sMountPath,));
+
+ # Remove dir.
+ try:
+ os.rmdir(sMountPath);
+ except:
+ if not fIgnoreError:
+ reporter.errorXcpt('Failed to remove directory %s' % (sMountPath,));
+ return fRc;
+
+ def _darwinMountDmg(self, sDmg):
+ """
+ Mount the DMG at the default mount point.
+ """
+ self._darwinUnmountDmg(fIgnoreError = True)
+
+ sMountPath = self._darwinDmgPath();
+ if not os.path.exists(sMountPath):
+ try:
+ os.mkdir(sMountPath, 0o755);
+ except:
+ reporter.logXcpt();
+ return False;
+
+ return self._executeSync(['hdiutil', 'attach', '-readonly', '-mount', 'required', '-mountpoint', sMountPath, sDmg, ]);
+
+ def _generateWithoutKextsChoicesXmlOnDarwin(self):
+ """
+ Generates the choices XML when kernel drivers are disabled.
+ None is returned on failure.
+ """
+ sPath = os.path.join(self.sScratchPath, 'DarwinChoices.xml');
+ oFile = utils.openNoInherit(sPath, 'wt');
+ oFile.write('<?xml version="1.0" encoding="UTF-8"?>\n'
+ '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n'
+ '<plist version="1.0">\n'
+ '<array>\n'
+ ' <dict>\n'
+ ' <key>attributeSetting</key>\n'
+ ' <integer>0</integer>\n'
+ ' <key>choiceAttribute</key>\n'
+ ' <string>selected</string>\n'
+ ' <key>choiceIdentifier</key>\n'
+ ' <string>choiceVBoxKEXTs</string>\n'
+ ' </dict>\n'
+ '</array>\n'
+ '</plist>\n');
+ oFile.close();
+ return sPath;
+
+ def _installVBoxOnDarwin(self):
+ """ Installs VBox on Mac OS X."""
+
+ # TEMPORARY HACK - START
+ # Don't install the kernel drivers on the testboxes with BigSur and later
+ # Needs a more generic approach but that one needs more effort.
+ sHostName = socket.getfqdn();
+ if sHostName.startswith('testboxmac10') \
+ or sHostName.startswith('testboxmac11'):
+ self._fKernelDrivers = False;
+ # TEMPORARY HACK - END
+
+ sDmg = self._findFile('^VirtualBox-.*\\.dmg$');
+ if sDmg is None:
+ return False;
+
+ # Mount the DMG.
+ fRc = self._darwinMountDmg(sDmg);
+ if fRc is not True:
+ return False;
+
+ # Uninstall any previous vbox version first.
+ sUninstaller = os.path.join(self._darwinDmgPath(), 'VirtualBox_Uninstall.tool');
+ fRc, _ = self._sudoExecuteSync([sUninstaller, '--unattended',]);
+ if fRc is True:
+
+ # Install the package.
+ sPkg = os.path.join(self._darwinDmgPath(), 'VirtualBox.pkg');
+ if self._fKernelDrivers:
+ fRc, _ = self._sudoExecuteSync(['installer', '-verbose', '-dumplog', '-pkg', sPkg, '-target', '/']);
+ else:
+ sChoicesXml = self._generateWithoutKextsChoicesXmlOnDarwin();
+ if sChoicesXml is not None:
+ fRc, _ = self._sudoExecuteSync(['installer', '-verbose', '-dumplog', '-pkg', sPkg, \
+ '-applyChoiceChangesXML', sChoicesXml, '-target', '/']);
+ else:
+ fRc = False;
+
+ # Unmount the DMG and we're done.
+ if not self._darwinUnmountDmg(fIgnoreError = False):
+ fRc = False;
+ return fRc;
+
+ def _uninstallVBoxOnDarwin(self):
+ """ Uninstalls VBox on Mac OS X."""
+
+ # Is VirtualBox installed? If not, don't try uninstall it.
+ sVBox = self._getVBoxInstallPath(fFailIfNotFound = False);
+ if sVBox is None:
+ return True;
+
+ # Find the dmg.
+ sDmg = self._findFile('^VirtualBox-.*\\.dmg$');
+ if sDmg is None:
+ return False;
+ if not os.path.exists(sDmg):
+ return True;
+
+ # Mount the DMG.
+ fRc = self._darwinMountDmg(sDmg);
+ if fRc is not True:
+ return False;
+
+ # Execute the uninstaller.
+ sUninstaller = os.path.join(self._darwinDmgPath(), 'VirtualBox_Uninstall.tool');
+ fRc, _ = self._sudoExecuteSync([sUninstaller, '--unattended',]);
+
+ # Unmount the DMG and we're done.
+ if not self._darwinUnmountDmg(fIgnoreError = False):
+ fRc = False;
+ return fRc;
+
+ #
+ # GNU/Linux
+ #
+
+ def _installVBoxOnLinux(self):
+ """ Installs VBox on Linux."""
+ sRun = self._findFile('^VirtualBox-.*\\.run$');
+ if sRun is None:
+ return False;
+ utils.chmodPlusX(sRun);
+
+ # Install the new one.
+ fRc, _ = self._sudoExecuteSync([sRun,]);
+ return fRc;
+
+ def _uninstallVBoxOnLinux(self):
+ """ Uninstalls VBox on Linux."""
+
+ # Is VirtualBox installed? If not, don't try uninstall it.
+ sVBox = self._getVBoxInstallPath(fFailIfNotFound = False);
+ if sVBox is None:
+ return True;
+
+ # Find the .run file and use it.
+ sRun = self._findFile('^VirtualBox-.*\\.run$', fMandatory = False);
+ if sRun is not None:
+ utils.chmodPlusX(sRun);
+ fRc, _ = self._sudoExecuteSync([sRun, 'uninstall']);
+ return fRc;
+
+ # Try the installed uninstaller.
+ for sUninstaller in [os.path.join(sVBox, 'uninstall.sh'), '/opt/VirtualBox/uninstall.sh', ]:
+ if os.path.isfile(sUninstaller):
+ reporter.log('Invoking "%s"...' % (sUninstaller,));
+ fRc, _ = self._sudoExecuteSync([sUninstaller, 'uninstall']);
+ return fRc;
+
+ reporter.log('Did not find any VirtualBox install to uninstall.');
+ return True;
+
+
+ #
+ # Solaris
+ #
+
+ def _generateAutoResponseOnSolaris(self):
+ """
+ Generates an autoresponse file on solaris, returning the name.
+ None is return on failure.
+ """
+ sPath = os.path.join(self.sScratchPath, 'SolarisAutoResponse');
+ oFile = utils.openNoInherit(sPath, 'wt');
+ oFile.write('basedir=default\n'
+ 'runlevel=nocheck\n'
+ 'conflict=quit\n'
+ 'setuid=nocheck\n'
+ 'action=nocheck\n'
+ 'partial=quit\n'
+ 'instance=unique\n'
+ 'idepend=quit\n'
+ 'rdepend=quit\n'
+ 'space=quit\n'
+ 'mail=\n');
+ oFile.close();
+ return sPath;
+
+ def _installVBoxOnSolaris(self):
+ """ Installs VBox on Solaris."""
+ sPkg = self._findFile('^VirtualBox-.*\\.pkg$', fMandatory = False);
+ if sPkg is None:
+ sTar = self._findFile('^VirtualBox-.*-SunOS-.*\\.tar.gz$', fMandatory = False);
+ if sTar is not None:
+ if self._maybeUnpackArchive(sTar) is not True:
+ return False;
+ sPkg = self._findFile('^VirtualBox-.*\\.pkg$', fMandatory = True);
+ sRsp = self._findFile('^autoresponse$', fMandatory = True);
+ if sPkg is None or sRsp is None:
+ return False;
+
+ # Uninstall first (ignore result).
+ self._uninstallVBoxOnSolaris(False);
+
+ # Install the new one.
+ fRc, _ = self._sudoExecuteSync(['pkgadd', '-d', sPkg, '-n', '-a', sRsp, 'SUNWvbox']);
+ return fRc;
+
+ def _uninstallVBoxOnSolaris(self, fRestartSvcConfigD):
+ """ Uninstalls VBox on Solaris."""
+ reporter.flushall();
+ if utils.processCall(['pkginfo', '-q', 'SUNWvbox']) != 0:
+ return True;
+ sRsp = self._generateAutoResponseOnSolaris();
+ fRc, _ = self._sudoExecuteSync(['pkgrm', '-n', '-a', sRsp, 'SUNWvbox']);
+
+ #
+ # Restart the svc.configd as it has a tendency to clog up with time and
+ # become unresponsive. It will handle SIGHUP by exiting the sigwait()
+ # look in the main function and shut down the service nicely (backend_fini).
+ # The restarter will then start a new instance of it.
+ #
+ if fRestartSvcConfigD:
+ time.sleep(1); # Give it a chance to flush pkgrm stuff.
+ self._sudoExecuteSync(['pkill', '-HUP', 'svc.configd']);
+ time.sleep(5); # Spare a few cpu cycles it to shutdown and restart.
+
+ return fRc;
+
+ #
+ # Windows
+ #
+
+ ## VBox windows services we can query the status of.
+ kasWindowsServices = [ 'vboxsup', 'vboxusbmon', 'vboxnetadp', 'vboxnetflt', 'vboxnetlwf' ];
+
+ def _installVBoxOnWindows(self):
+ """ Installs VBox on Windows."""
+ sExe = self._findFile('^VirtualBox-.*-(MultiArch|Win).exe$');
+ if sExe is None:
+ return False;
+
+ # TEMPORARY HACK - START
+ # It seems that running the NDIS cleanup script upon uninstallation is not
+ # a good idea, so let's run it before installing VirtualBox.
+ #sHostName = socket.getfqdn();
+ #if not sHostName.startswith('testboxwin3') \
+ # and not sHostName.startswith('testboxharp2') \
+ # and not sHostName.startswith('wei01-b6ka-3') \
+ # and utils.getHostOsVersion() in ['8', '8.1', '9', '2008Server', '2008ServerR2', '2012Server']:
+ # reporter.log('Peforming extra NDIS cleanup...');
+ # sMagicScript = os.path.abspath(os.path.join(g_ksValidationKitDir, 'testdriver', 'win-vbox-net-uninstall.ps1'));
+ # fRc2, _ = self._sudoExecuteSync(['powershell.exe', '-Command', 'set-executionpolicy unrestricted']);
+ # if not fRc2:
+ # reporter.log('set-executionpolicy failed.');
+ # self._sudoExecuteSync(['powershell.exe', '-Command', 'get-executionpolicy']);
+ # fRc2, _ = self._sudoExecuteSync(['powershell.exe', '-File', sMagicScript]);
+ # if not fRc2:
+ # reporter.log('NDIS cleanup failed.');
+ # TEMPORARY HACK - END
+
+ # Uninstall any previous vbox version first.
+ fRc = self._uninstallVBoxOnWindows('install');
+ if fRc is not True:
+ return None; # There shouldn't be anything to uninstall, and if there is, it's not our fault.
+
+ # Install the MS Visual Studio Redistributable, if requested. (VBox 7.0+ needs this installed once.)
+ if self._fInstallMsCrt:
+ reporter.log('Installing MS Visual Studio Redistributable (untested code)...');
+ ## @todo Test this.
+ ## @todo We could cache this on the testrsrc share.
+ sName = "vc_redist.x64.exe"
+ sUrl = "https://aka.ms/vs/17/release/" + sName # Permalink, according to MS.
+ sExe = os.path.join(self.sBuildPath, sName);
+ if webutils.downloadFile(sUrl, sExe, None, reporter.log, reporter.log):
+ asArgs = [ sExe, '/Q' ];
+ fRc2, iRc = self._sudoExecuteSync(asArgs);
+ if fRc2 is False:
+ return reporter.error('Installing MS Visual Studio Redistributable failed, exit code: %s' % (iRc,));
+ reporter.log('Installing MS Visual Studio Redistributable done');
+ else:
+ return False;
+
+ # We need the help text to detect supported options below.
+ reporter.log('Executing: %s' % ([sExe, '--silent', '--help'], ));
+ reporter.flushall();
+ (iExitCode, sHelp, _) = utils.processOutputUnchecked([sExe, '--silent', '--help'], fIgnoreEncoding = True);
+ reporter.log('Exit code: %d, %u chars of help text' % (iExitCode, len(sHelp),));
+
+ # Gather installer arguments.
+ asArgs = [sExe, '-vvvv', '--silent', '--logging'];
+ asArgs.extend(['--msiparams', 'REBOOT=ReallySuppress']);
+ sVBoxInstallPath = os.environ.get('VBOX_INSTALL_PATH', None);
+ if sVBoxInstallPath is not None:
+ asArgs.extend(['INSTALLDIR="%s"' % (sVBoxInstallPath,)]);
+
+ if sHelp.find("--msi-log-file") >= 0:
+ sLogFile = os.path.join(self.sScratchPath, 'VBoxInstallLog.txt'); # Specify location to prevent a random one.
+ asArgs.extend(['--msi-log-file', sLogFile]);
+ else:
+ sLogFile = os.path.join(tempfile.gettempdir(), 'VirtualBox', 'VBoxInstallLog.txt'); # Hardcoded TMP location.
+
+ if self._fWinForcedInstallTimestampCA and sHelp.find("--force-install-timestamp-ca") >= 0:
+ asArgs.extend(['--force-install-timestamp-ca']);
+
+ # Install it.
+ fRc2, iRc = self._sudoExecuteSync(asArgs);
+ if fRc2 is False:
+ if iRc == 3010: # ERROR_SUCCESS_REBOOT_REQUIRED
+ reporter.error('Installer required a reboot to complete installation (ERROR_SUCCESS_REBOOT_REQUIRED)');
+ else:
+ reporter.error('Installer failed, exit code: %s' % (iRc,));
+ fRc = False;
+
+ # Add the installer log if present and wait for the network connection to be restore after the filter driver upset.
+ if os.path.isfile(sLogFile):
+ reporter.addLogFile(sLogFile, 'log/installer', "Verbose MSI installation log file");
+ self._waitForTestManagerConnectivity(30);
+
+ return fRc;
+
+ def _isProcessPresent(self, sName):
+ """ Checks whether the named process is present or not. """
+ for oProcess in utils.processListAll():
+ sBase = oProcess.getBaseImageNameNoExeSuff();
+ if sBase is not None and sBase.lower() == sName:
+ return True;
+ return False;
+
+ def _killProcessesByName(self, sName, sDesc, fChildren = False):
+ """ Kills the named process, optionally including children. """
+ cKilled = 0;
+ aoProcesses = utils.processListAll();
+ for oProcess in aoProcesses:
+ sBase = oProcess.getBaseImageNameNoExeSuff();
+ if sBase is not None and sBase.lower() == sName:
+ reporter.log('Killing %s process: %s (%s)' % (sDesc, oProcess.iPid, sBase));
+ utils.processKill(oProcess.iPid);
+ cKilled += 1;
+
+ if fChildren:
+ for oChild in aoProcesses:
+ if oChild.iParentPid == oProcess.iPid and oChild.iParentPid is not None:
+ reporter.log('Killing %s child process: %s (%s)' % (sDesc, oChild.iPid, sBase));
+ utils.processKill(oChild.iPid);
+ cKilled += 1;
+ return cKilled;
+
+ def _terminateProcessesByNameAndArgSubstr(self, sName, sArg, sDesc):
+ """
+ Terminates the named process using taskkill.exe, if any of its args
+ contains the passed string.
+ """
+ cKilled = 0;
+ aoProcesses = utils.processListAll();
+ for oProcess in aoProcesses:
+ sBase = oProcess.getBaseImageNameNoExeSuff();
+ if sBase is not None and sBase.lower() == sName and any(sArg in s for s in oProcess.asArgs):
+
+ reporter.log('Killing %s process: %s (%s)' % (sDesc, oProcess.iPid, sBase));
+ self._executeSync(['taskkill.exe', '/pid', '%u' % (oProcess.iPid,)]);
+ cKilled += 1;
+ return cKilled;
+
+ def _uninstallVBoxOnWindows(self, sMode):
+ """
+ Uninstalls VBox on Windows, all installations we find to be on the safe side...
+ """
+ assert sMode in ['install', 'uninstall',];
+
+ import win32com.client; # pylint: disable=import-error
+ win32com.client.gencache.EnsureModule('{000C1092-0000-0000-C000-000000000046}', 1033, 1, 0);
+ oInstaller = win32com.client.Dispatch('WindowsInstaller.Installer',
+ resultCLSID = '{000C1090-0000-0000-C000-000000000046}')
+
+ # Search installed products for VirtualBox.
+ asProdCodes = [];
+ for sProdCode in oInstaller.Products:
+ try:
+ sProdName = oInstaller.ProductInfo(sProdCode, "ProductName");
+ except:
+ reporter.logXcpt();
+ continue;
+ #reporter.log('Info: %s=%s' % (sProdCode, sProdName));
+ if sProdName.startswith('Oracle VM VirtualBox') \
+ or sProdName.startswith('Sun VirtualBox'):
+ asProdCodes.append([sProdCode, sProdName]);
+
+ # Before we start uninstalling anything, just ruthlessly kill any cdb,
+ # msiexec, drvinst and some rundll process we might find hanging around.
+ if self._isProcessPresent('rundll32'):
+ cTimes = 0;
+ while cTimes < 3:
+ cTimes += 1;
+ cKilled = self._terminateProcessesByNameAndArgSubstr('rundll32', 'InstallSecurityPromptRunDllW',
+ 'MSI driver installation');
+ if cKilled <= 0:
+ break;
+ time.sleep(10); # Give related drvinst process a chance to clean up after we killed the verification dialog.
+
+ if self._isProcessPresent('drvinst'):
+ time.sleep(15); # In the hope that it goes away.
+ cTimes = 0;
+ while cTimes < 4:
+ cTimes += 1;
+ cKilled = self._killProcessesByName('drvinst', 'MSI driver installation', True);
+ if cKilled <= 0:
+ break;
+ time.sleep(10); # Give related MSI process a chance to clean up after we killed the driver installer.
+
+ if self._isProcessPresent('msiexec'):
+ cTimes = 0;
+ while cTimes < 3:
+ reporter.log('found running msiexec process, waiting a bit...');
+ time.sleep(20) # In the hope that it goes away.
+ if not self._isProcessPresent('msiexec'):
+ break;
+ cTimes += 1;
+ ## @todo this could also be the msiexec system service, try to detect this case!
+ if cTimes >= 6:
+ cKilled = self._killProcessesByName('msiexec', 'MSI driver installation');
+ if cKilled > 0:
+ time.sleep(16); # fudge.
+
+ # cdb.exe sometimes stays running (from utils.getProcessInfo), blocking
+ # the scratch directory. No idea why.
+ if self._isProcessPresent('cdb'):
+ cTimes = 0;
+ while cTimes < 3:
+ cKilled = self._killProcessesByName('cdb', 'cdb.exe from getProcessInfo');
+ if cKilled <= 0:
+ break;
+ time.sleep(2); # fudge.
+
+ # Do the uninstalling.
+ fRc = True;
+ sLogFile = os.path.join(self.sScratchPath, 'VBoxUninstallLog.txt');
+ for sProdCode, sProdName in asProdCodes:
+ reporter.log('Uninstalling %s (%s)...' % (sProdName, sProdCode));
+ fRc2, iRc = self._sudoExecuteSync(['msiexec', '/uninstall', sProdCode, '/quiet', '/passive', '/norestart',
+ '/L*v', '%s' % (sLogFile), ]);
+ if fRc2 is False:
+ if iRc == 3010: # ERROR_SUCCESS_REBOOT_REQUIRED
+ reporter.error('Uninstaller required a reboot to complete uninstallation');
+ else:
+ reporter.error('Uninstaller failed, exit code: %s' % (iRc,));
+ fRc = False;
+
+ self._waitForTestManagerConnectivity(30);
+
+ # Upload the log on failure. Do it early if the extra cleanups below causes trouble.
+ if fRc is False and os.path.isfile(sLogFile):
+ reporter.addLogFile(sLogFile, 'log/uninstaller', "Verbose MSI uninstallation log file");
+ sLogFile = None;
+
+ # Log driver service states (should ls \Driver\VBox* and \Device\VBox*).
+ fHadLeftovers = False;
+ asLeftovers = [];
+ for sService in reversed(self.kasWindowsServices):
+ cTries = 0;
+ while True:
+ fRc2, _ = self._sudoExecuteSync(['sc.exe', 'query', sService]);
+ if not fRc2:
+ break;
+ fHadLeftovers = True;
+
+ cTries += 1;
+ if cTries > 3:
+ asLeftovers.append(sService,);
+ break;
+
+ # Get the status output.
+ try:
+ sOutput = utils.sudoProcessOutputChecked(['sc.exe', 'query', sService]);
+ except:
+ reporter.logXcpt();
+ else:
+ if re.search(r'STATE\s+:\s*1\s*STOPPED', sOutput) is None:
+ reporter.log('Trying to stop %s...' % (sService,));
+ fRc2, _ = self._sudoExecuteSync(['sc.exe', 'stop', sService]);
+ time.sleep(1); # fudge
+
+ reporter.log('Trying to delete %s...' % (sService,));
+ self._sudoExecuteSync(['sc.exe', 'delete', sService]);
+
+ time.sleep(1); # fudge
+
+ if asLeftovers:
+ reporter.log('Warning! Leftover VBox drivers: %s' % (', '.join(asLeftovers),));
+ fRc = False;
+
+ if fHadLeftovers:
+ self._waitForTestManagerConnectivity(30);
+
+ # Upload the log if we have any leftovers and didn't upload it already.
+ if sLogFile is not None and (fRc is False or fHadLeftovers) and os.path.isfile(sLogFile):
+ reporter.addLogFile(sLogFile, 'log/uninstaller', "Verbose MSI uninstallation log file");
+
+ return fRc;
+
+
+ #
+ # Extension pack.
+ #
+
+ def _getVBoxInstallPath(self, fFailIfNotFound):
+ """ Returns the default VBox installation path. """
+ sHost = utils.getHostOs();
+ if sHost == 'win':
+ sProgFiles = os.environ.get('ProgramFiles', 'C:\\Program Files');
+ asLocs = [
+ os.path.join(sProgFiles, 'Oracle', 'VirtualBox'),
+ os.path.join(sProgFiles, 'OracleVM', 'VirtualBox'),
+ os.path.join(sProgFiles, 'Sun', 'VirtualBox'),
+ ];
+ elif sHost in ('linux', 'solaris',):
+ asLocs = [ '/opt/VirtualBox', '/opt/VirtualBox-3.2', '/opt/VirtualBox-3.1', '/opt/VirtualBox-3.0'];
+ elif sHost == 'darwin':
+ asLocs = [ '/Applications/VirtualBox.app/Contents/MacOS' ];
+ else:
+ asLocs = [ '/opt/VirtualBox' ];
+ if 'VBOX_INSTALL_PATH' in os.environ:
+ asLocs.insert(0, os.environ.get('VBOX_INSTALL_PATH', None));
+
+ for sLoc in asLocs:
+ if os.path.isdir(sLoc):
+ return sLoc;
+ if fFailIfNotFound:
+ reporter.error('Failed to locate VirtualBox installation: %s' % (asLocs,));
+ else:
+ reporter.log2('Failed to locate VirtualBox installation: %s' % (asLocs,));
+ return None;
+
+ def _installExtPack(self):
+ """ Installs the extension pack. """
+ sVBox = self._getVBoxInstallPath(fFailIfNotFound = True);
+ if sVBox is None:
+ return False;
+ sExtPackDir = os.path.join(sVBox, 'ExtensionPacks');
+
+ if self._uninstallAllExtPacks() is not True:
+ return False;
+
+ sExtPack = self._findFile('Oracle_VM_VirtualBox_Extension_Pack.vbox-extpack');
+ if sExtPack is None:
+ sExtPack = self._findFile('Oracle_VM_VirtualBox_Extension_Pack.*.vbox-extpack');
+ if sExtPack is None:
+ return True;
+
+ sDstDir = os.path.join(sExtPackDir, 'Oracle_VM_VirtualBox_Extension_Pack');
+ reporter.log('Installing extension pack "%s" to "%s"...' % (sExtPack, sExtPackDir));
+ fRc, _ = self._sudoExecuteSync([ self.getBinTool('vts_tar'),
+ '--extract',
+ '--verbose',
+ '--gzip',
+ '--file', sExtPack,
+ '--directory', sDstDir,
+ '--file-mode-and-mask', '0644',
+ '--file-mode-or-mask', '0644',
+ '--dir-mode-and-mask', '0755',
+ '--dir-mode-or-mask', '0755',
+ '--owner', '0',
+ '--group', '0',
+ ]);
+ return fRc;
+
+ def _uninstallAllExtPacks(self):
+ """ Uninstalls all extension packs. """
+ sVBox = self._getVBoxInstallPath(fFailIfNotFound = False);
+ if sVBox is None:
+ return True;
+
+ sExtPackDir = os.path.join(sVBox, 'ExtensionPacks');
+ if not os.path.exists(sExtPackDir):
+ return True;
+
+ fRc, _ = self._sudoExecuteSync([self.getBinTool('vts_rm'), '-Rfv', '--', sExtPackDir]);
+ return fRc;
+
+
+
+if __name__ == '__main__':
+ sys.exit(VBoxInstallerTestDriver().main(sys.argv));
diff --git a/src/VBox/ValidationKit/testdriver/vboxtestfileset.py b/src/VBox/ValidationKit/testdriver/vboxtestfileset.py
new file mode 100755
index 00000000..e5b88664
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/vboxtestfileset.py
@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+# $Id: vboxtestfileset.py $
+# pylint: disable=too-many-lines
+
+"""
+Test File Set
+"""
+
+__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 os;
+import sys;
+
+# Validation Kit imports.
+from common import utils;
+from testdriver import reporter;
+from testdriver import testfileset;
+
+# Python 3 hacks:
+if sys.version_info[0] >= 3:
+ xrange = range; # pylint: disable=redefined-builtin,invalid-name
+
+
+class TestFileSet(testfileset.TestFileSet):
+ """
+ A generated set of files and directories for uploading to a VM.
+
+ The file and directory names are compatible with the host, so it is
+ possible to copy them to the host without changing any names.
+
+ Uploaded as a tarball and expanded via TXS (if new enough) or uploaded vts_tar
+ utility from the validation kit.
+ """
+
+ def __init__(self, oTestVm, sBasePath, sSubDir, # pylint: disable=too-many-arguments
+ oRngFileSizes = xrange(0, 16384),
+ oRngManyFiles = xrange(128, 512),
+ oRngTreeFiles = xrange(128, 384),
+ oRngTreeDepth = xrange(92, 256),
+ oRngTreeDirs = xrange(2, 16),
+ cchMaxPath = 230,
+ cchMaxName = 230,
+ asCompatibleWith = None,
+ uSeed = None):
+
+ asCompOses = [oTestVm.getGuestOs(), ];
+ sHostOs = utils.getHostOs();
+ if sHostOs not in asCompOses:
+ asCompOses.append(sHostOs);
+
+ testfileset.TestFileSet.__init__(self,
+ fDosStyle = oTestVm.isWindows() or oTestVm.isOS2(),
+ asCompatibleWith = asCompOses,
+ sBasePath = sBasePath,
+ sSubDir = sSubDir,
+ oRngFileSizes = oRngFileSizes,
+ oRngManyFiles = oRngManyFiles,
+ oRngTreeFiles = oRngTreeFiles,
+ oRngTreeDepth = oRngTreeDepth,
+ oRngTreeDirs = oRngTreeDirs,
+ cchMaxPath = cchMaxPath,
+ cchMaxName = cchMaxName,
+ uSeed = uSeed);
+ self.oTestVm = oTestVm;
+
+ def __uploadFallback(self, oTxsSession, sTarFileGst, oTstDrv):
+ """
+ Fallback upload method.
+ """
+ sVtsTarExe = 'vts_tar' + self.oTestVm.getGuestExeSuff();
+ sVtsTarHst = os.path.join(oTstDrv.sVBoxValidationKit, self.oTestVm.getGuestOs(),
+ self.oTestVm.getGuestArch(), sVtsTarExe);
+ sVtsTarGst = self.oTestVm.pathJoin(self.sBasePath, sVtsTarExe);
+
+ if oTxsSession.syncUploadFile(sVtsTarHst, sVtsTarGst) is not True:
+ return reporter.error('Failed to upload "%s" to the guest as "%s"!' % (sVtsTarHst, sVtsTarGst,));
+
+ fRc = oTxsSession.syncExec(sVtsTarGst, [sVtsTarGst, '-xzf', sTarFileGst, '-C', self.sBasePath,], fWithTestPipe = False);
+ if fRc is not True:
+ return reporter.error('vts_tar failed!');
+ return True;
+
+ def upload(self, oTxsSession, oTstDrv):
+ """
+ Uploads the files into the guest via the given TXS session.
+
+ Returns True / False.
+ """
+
+ #
+ # Create a tarball.
+ #
+ sTarFileHst = os.path.join(oTstDrv.sScratchPath, 'tdAddGuestCtrl-1-Stuff.tar.gz');
+ sTarFileGst = self.oTestVm.pathJoin(self.sBasePath, 'tdAddGuestCtrl-1-Stuff.tar.gz');
+ if self.createTarball(sTarFileHst) is not True:
+ return False;
+
+ #
+ # Upload it.
+ #
+ reporter.log('Uploading tarball "%s" to the guest as "%s"...' % (sTarFileHst, sTarFileGst));
+ if oTxsSession.syncUploadFile(sTarFileHst, sTarFileGst) is not True:
+ return reporter.error('Failed upload tarball "%s" as "%s"!' % (sTarFileHst, sTarFileGst,));
+
+ #
+ # Try unpack it.
+ #
+ reporter.log('Unpacking "%s" into "%s"...' % (sTarFileGst, self.sBasePath));
+ if oTxsSession.syncUnpackFile(sTarFileGst, self.sBasePath, fIgnoreErrors = True) is not True:
+ reporter.log('Failed to expand tarball "%s" into "%s", falling back on individual directory and file creation...'
+ % (sTarFileGst, self.sBasePath,));
+ if self.__uploadFallback(oTxsSession, sTarFileGst, oTstDrv) is not True:
+ return False;
+ reporter.log('Successfully placed test files and directories in the VM.');
+ return True;
+
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;
diff --git a/src/VBox/ValidationKit/testdriver/vboxwrappers.py b/src/VBox/ValidationKit/testdriver/vboxwrappers.py
new file mode 100755
index 00000000..179e9cdc
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/vboxwrappers.py
@@ -0,0 +1,3666 @@
+# -*- coding: utf-8 -*-
+# $Id: vboxwrappers.py $
+# pylint: disable=too-many-lines
+
+"""
+VirtualBox Wrapper Classes
+"""
+
+__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 os;
+import socket;
+import sys;
+
+# Validation Kit imports.
+from common import utils;
+from common import netutils;
+from testdriver import base;
+from testdriver import reporter;
+from testdriver import txsclient;
+from testdriver import vboxcon;
+from testdriver import vbox;
+from testdriver.base import TdTaskBase;
+
+
+def _ControllerNameToBusAndType(sController):
+ """ Translate a controller name to a storage bus. """
+ if sController == "IDE Controller":
+ eBus = vboxcon.StorageBus_IDE;
+ eType = vboxcon.StorageControllerType_PIIX4;
+ elif sController == "SATA Controller":
+ eBus = vboxcon.StorageBus_SATA;
+ eType = vboxcon.StorageControllerType_IntelAhci;
+ elif sController == "Floppy Controller":
+ eType = vboxcon.StorageControllerType_I82078;
+ eBus = vboxcon.StorageBus_Floppy;
+ elif sController == "SAS Controller":
+ eBus = vboxcon.StorageBus_SAS;
+ eType = vboxcon.StorageControllerType_LsiLogicSas;
+ elif sController == "SCSI Controller":
+ eBus = vboxcon.StorageBus_SCSI;
+ eType = vboxcon.StorageControllerType_LsiLogic;
+ elif sController == "BusLogic SCSI Controller":
+ eBus = vboxcon.StorageBus_SCSI;
+ eType = vboxcon.StorageControllerType_BusLogic;
+ elif sController == "NVMe Controller":
+ eBus = vboxcon.StorageBus_PCIe;
+ eType = vboxcon.StorageControllerType_NVMe;
+ elif sController == "VirtIO SCSI Controller":
+ eBus = vboxcon.StorageBus_VirtioSCSI;
+ eType = vboxcon.StorageControllerType_VirtioSCSI;
+ else:
+ eBus = vboxcon.StorageBus_Null;
+ eType = vboxcon.StorageControllerType_Null;
+ return (eBus, eType);
+
+
+def _nameMachineState(eState):
+ """ Gets the name (string) of a machine state."""
+ if eState == vboxcon.MachineState_PoweredOff: return 'PoweredOff';
+ if eState == vboxcon.MachineState_Saved: return 'Saved';
+ if eState == vboxcon.MachineState_Teleported: return 'Teleported';
+ if eState == vboxcon.MachineState_Aborted: return 'Aborted';
+ if eState == vboxcon.MachineState_Running: return 'Running';
+ if eState == vboxcon.MachineState_Paused: return 'Paused';
+ if eState == vboxcon.MachineState_Stuck: return 'GuruMeditation';
+ if eState == vboxcon.MachineState_Teleporting: return 'Teleporting';
+ if eState == vboxcon.MachineState_LiveSnapshotting: return 'LiveSnapshotting';
+ if eState == vboxcon.MachineState_Starting: return 'Starting';
+ if eState == vboxcon.MachineState_Stopping: return 'Stopping';
+ if eState == vboxcon.MachineState_Saving: return 'Saving';
+ if eState == vboxcon.MachineState_Restoring: return 'Restoring';
+ if eState == vboxcon.MachineState_TeleportingPausedVM: return 'TeleportingPausedVM';
+ if eState == vboxcon.MachineState_TeleportingIn: return 'TeleportingIn';
+ if eState == vboxcon.MachineState_DeletingSnapshotOnline: return 'DeletingSnapshotOnline';
+ if eState == vboxcon.MachineState_DeletingSnapshotPaused: return 'DeletingSnapshotPaused';
+ if eState == vboxcon.MachineState_RestoringSnapshot: return 'RestoringSnapshot';
+ if eState == vboxcon.MachineState_DeletingSnapshot: return 'DeletingSnapshot';
+ if eState == vboxcon.MachineState_SettingUp: return 'SettingUp';
+ if hasattr(vboxcon, 'MachineState_FaultTolerantSyncing'):
+ if eState == vboxcon.MachineState_FaultTolerantSyncing: return 'FaultTolerantSyncing';
+ if hasattr(vboxcon, 'MachineState_AbortedSaved'): # since r147033 / 7.0
+ if eState == vboxcon.MachineState_AbortedSaved: return 'Aborted-Saved';
+ return 'Unknown-%s' % (eState,);
+
+
+class VirtualBoxWrapper(object): # pylint: disable=too-few-public-methods
+ """
+ Wrapper around the IVirtualBox object that adds some (hopefully) useful
+ utility methods
+
+ The real object can be accessed thru the o member. That said, members can
+ be accessed directly as well.
+ """
+
+ def __init__(self, oVBox, oVBoxMgr, fpApiVer, oTstDrv):
+ self.o = oVBox;
+ self.oVBoxMgr = oVBoxMgr;
+ self.fpApiVer = fpApiVer;
+ self.oTstDrv = oTstDrv;
+
+ def __getattr__(self, sName):
+ # Try ourselves first.
+ try:
+ oAttr = self.__dict__[sName];
+ except:
+ #try:
+ # oAttr = dir(self)[sName];
+ #except AttributeError:
+ oAttr = getattr(self.o, sName);
+ return oAttr;
+
+ #
+ # Utilities.
+ #
+
+ def registerDerivedEventHandler(self, oSubClass, dArgs = None):
+ """
+ Create an instance of the given VirtualBoxEventHandlerBase sub-class
+ and register it.
+
+ The new instance is returned on success. None is returned on error.
+ """
+ dArgsCopy = dArgs.copy() if dArgs is not None else {};
+ dArgsCopy['oVBox'] = self;
+ return oSubClass.registerDerivedEventHandler(self.oVBoxMgr, self.fpApiVer, oSubClass, dArgsCopy,
+ self.o, 'IVirtualBox', 'IVirtualBoxCallback');
+
+ def deleteHdByLocation(self, sHdLocation):
+ """
+ Deletes a disk image from the host, given it's location.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ try:
+ oIMedium = self.o.findHardDisk(sHdLocation);
+ except:
+ try:
+ if self.fpApiVer >= 4.1:
+ oIMedium = self.o.openMedium(sHdLocation, vboxcon.DeviceType_HardDisk,
+ vboxcon.AccessMode_ReadWrite, False);
+ elif self.fpApiVer >= 4.0:
+ oIMedium = self.o.openMedium(sHdLocation, vboxcon.DeviceType_HardDisk,
+ vboxcon.AccessMode_ReadWrite);
+ else:
+ oIMedium = self.o.openHardDisk(sHdLocation, vboxcon.AccessMode_ReadOnly, False, "", False, "");
+ except:
+ return reporter.errorXcpt('failed to open hd "%s"' % (sHdLocation));
+ return self.deleteHdByMedium(oIMedium)
+
+ def deleteHdByMedium(self, oIMedium):
+ """
+ Deletes a disk image from the host, given an IMedium reference.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ try: oProgressCom = oIMedium.deleteStorage();
+ except: return reporter.errorXcpt('deleteStorage() for disk %s failed' % (oIMedium,));
+ try: oProgress = ProgressWrapper(oProgressCom, self.oVBoxMgr, self.oTstDrv, 'delete disk %s' % (oIMedium.location));
+ except: return reporter.errorXcpt();
+ oProgress.wait();
+ oProgress.logResult();
+ return oProgress.isSuccess();
+
+
+
+class ProgressWrapper(TdTaskBase):
+ """
+ Wrapper around a progress object for making it a task and providing useful
+ utility methods.
+ The real progress object can be accessed thru the o member.
+ """
+
+ def __init__(self, oProgress, oVBoxMgr, oTstDrv, sName):
+ TdTaskBase.__init__(self, utils.getCallerName());
+ self.o = oProgress;
+ self.oVBoxMgr = oVBoxMgr;
+ self.oTstDrv = oTstDrv;
+ self.sName = sName;
+
+ def toString(self):
+ return '<%s sName=%s, oProgress=%s >' \
+ % (TdTaskBase.toString(self), self.sName, self.o);
+
+ #
+ # TdTaskBase overrides.
+ #
+
+ def pollTask(self, fLocked = False):
+ """
+ Overrides TdTaskBase.pollTask().
+
+ This method returns False until the progress object has completed.
+ """
+ self.doQuickApiTest();
+ try:
+ try:
+ if self.o.completed:
+ return True;
+ except:
+ pass;
+ finally:
+ self.oTstDrv.processPendingEvents();
+ return False;
+
+ def waitForTask(self, cMsTimeout = 0):
+ """
+ Overrides TdTaskBase.waitForTask().
+ Process XPCOM/COM events while waiting.
+ """
+ msStart = base.timestampMilli();
+ fState = self.pollTask(False);
+ while not fState:
+ cMsElapsed = base.timestampMilli() - msStart;
+ if cMsElapsed > cMsTimeout:
+ break;
+ cMsToWait = cMsTimeout - cMsElapsed;
+ cMsToWait = min(cMsToWait, 500);
+ try:
+ self.o.waitForCompletion(cMsToWait);
+ except KeyboardInterrupt: raise;
+ except: pass;
+ if self.fnProcessEvents:
+ self.fnProcessEvents();
+ reporter.doPollWork('ProgressWrapper.waitForTask');
+ fState = self.pollTask(False);
+ return fState;
+
+ #
+ # Utility methods.
+ #
+
+ def isSuccess(self):
+ """
+ Tests if the progress object completed successfully.
+ Returns True on success, False on failure or incomplete.
+ """
+ if not self.isCompleted():
+ return False;
+ return self.getResult() >= 0;
+
+ def isCompleted(self):
+ """
+ Wrapper around IProgress.completed.
+ """
+ return self.pollTask();
+
+ def isCancelable(self):
+ """
+ Wrapper around IProgress.cancelable.
+ """
+ try:
+ fRc = self.o.cancelable;
+ except:
+ reporter.logXcpt();
+ fRc = False;
+ return fRc;
+
+ def wasCanceled(self):
+ """
+ Wrapper around IProgress.canceled.
+ """
+ try:
+ fRc = self.o.canceled;
+ except:
+ reporter.logXcpt(self.sName);
+ fRc = False;
+ return fRc;
+
+ def cancel(self):
+ """
+ Wrapper around IProgress.cancel()
+ Returns True on success, False on failure (logged as error).
+ """
+ try:
+ self.o.cancel();
+ except:
+ reporter.errorXcpt(self.sName);
+ return False;
+ return True;
+
+ def getResult(self):
+ """
+ Wrapper around IProgress.resultCode.
+ """
+ try:
+ iRc = self.o.resultCode;
+ except:
+ reporter.logXcpt(self.sName);
+ iRc = -1;
+ return iRc;
+
+ def getErrInfoResultCode(self):
+ """
+ Wrapper around IProgress.errorInfo.resultCode.
+
+ Returns the string on success, -1 on bad objects (logged as error), and
+ -2 on missing errorInfo object.
+ """
+ iRc = -1;
+ try:
+ oErrInfo = self.o.errorInfo;
+ except:
+ reporter.errorXcpt(self.sName);
+ else:
+ if oErrInfo is None:
+ iRc = -2;
+ else:
+ try:
+ iRc = oErrInfo.resultCode;
+ except:
+ reporter.errorXcpt();
+ return iRc;
+
+ def getErrInfoText(self):
+ """
+ Wrapper around IProgress.errorInfo.text.
+
+ Returns the string on success, None on failure. Missing errorInfo is
+ not logged as an error, all other failures are.
+ """
+ sText = None;
+ try:
+ oErrInfo = self.o.errorInfo;
+ except:
+ reporter.log2Xcpt(self.sName);
+ else:
+ if oErrInfo is not None:
+ try:
+ sText = oErrInfo.text;
+ except:
+ reporter.errorXcpt();
+ return sText;
+
+ def stringifyErrorInfo(self):
+ """
+ Formats IProgress.errorInfo into a string.
+ """
+ try:
+ oErrInfo = self.o.errorInfo;
+ except:
+ reporter.logXcpt(self.sName);
+ sErr = 'no error info';
+ else:
+ sErr = vbox.stringifyErrorInfo(oErrInfo);
+ return sErr;
+
+ def stringifyResult(self):
+ """
+ Stringify the result.
+ """
+ if self.isCompleted():
+ if self.wasCanceled():
+ sRet = 'Progress %s: Canceled, hrc=%s' % (self.sName, vbox.ComError.toString(self.getResult()));
+ elif self.getResult() == 0:
+ sRet = 'Progress %s: Success' % (self.sName,);
+ elif self.getResult() > 0:
+ sRet = 'Progress %s: Success (hrc=%s)' % (self.sName, vbox.ComError.toString(self.getResult()));
+ else:
+ sRet = 'Progress %s: Failed! %s' % (self.sName, self.stringifyErrorInfo());
+ else:
+ sRet = 'Progress %s: Not completed yet...' % (self.sName);
+ return sRet;
+
+ def logResult(self, fIgnoreErrors = False):
+ """
+ Logs the result, failure logged as error unless fIgnoreErrors is True.
+ Return True on success, False on failure (and fIgnoreErrors is false).
+ """
+ sText = self.stringifyResult();
+ if self.isCompleted() and self.getResult() < 0 and fIgnoreErrors is False:
+ return reporter.error(sText);
+ reporter.log(sText);
+ return True;
+
+ def waitOnProgress(self, cMsInterval = 1000):
+ """
+ See vbox.TestDriver.waitOnProgress.
+ """
+ self.doQuickApiTest();
+ return self.oTstDrv.waitOnProgress(self.o, cMsInterval);
+
+ def wait(self, cMsTimeout = 60000, fErrorOnTimeout = True, cMsInterval = 1000):
+ """
+ Wait on the progress object for a while.
+
+ Returns the resultCode of the progress object if completed.
+ Returns -1 on timeout, logged as error if fErrorOnTimeout is set.
+ Returns -2 is the progress object is invalid or waitForCompletion
+ fails (logged as errors).
+ """
+ msStart = base.timestampMilli();
+ while True:
+ self.oTstDrv.processPendingEvents();
+ self.doQuickApiTest();
+ try:
+ if self.o.completed:
+ break;
+ except:
+ reporter.errorXcpt(self.sName);
+ return -2;
+ self.oTstDrv.processPendingEvents();
+
+ cMsElapsed = base.timestampMilli() - msStart;
+ if cMsElapsed > cMsTimeout:
+ if fErrorOnTimeout:
+ reporter.error('Timing out after waiting for %u s on "%s"' % (cMsTimeout / 1000, self.sName))
+ return -1;
+
+ try:
+ self.o.waitForCompletion(cMsInterval);
+ except:
+ reporter.errorXcpt(self.sName);
+ return -2;
+ reporter.doPollWork('ProgressWrapper.wait');
+
+ try:
+ rc = self.o.resultCode;
+ except:
+ rc = -2;
+ reporter.errorXcpt(self.sName);
+ self.oTstDrv.processPendingEvents();
+ return rc;
+
+ def waitForOperation(self, iOperation, cMsTimeout = 60000, fErrorOnTimeout = True, cMsInterval = 1000, \
+ fIgnoreErrors = False):
+ """
+ Wait for the completion of a operation.
+
+ Negative iOperation values are relative to operationCount (this
+ property may changed at runtime).
+
+ Returns 0 if the operation completed normally.
+ Returns -1 on timeout, logged as error if fErrorOnTimeout is set.
+ Returns -2 is the progress object is invalid or waitForCompletion
+ fails (logged as errors).
+ Returns -3 if if the operation completed with an error, this is logged
+ as an error.
+ """
+ msStart = base.timestampMilli();
+ while True:
+ self.oTstDrv.processPendingEvents();
+ self.doQuickApiTest();
+ try:
+ iCurrentOperation = self.o.operation;
+ cOperations = self.o.operationCount;
+ if iOperation >= 0:
+ iRealOperation = iOperation;
+ else:
+ iRealOperation = cOperations + iOperation;
+
+ if iCurrentOperation > iRealOperation:
+ return 0;
+ if iCurrentOperation == iRealOperation \
+ and iRealOperation >= cOperations - 1 \
+ and self.o.completed:
+ if self.o.resultCode < 0:
+ self.logResult(fIgnoreErrors);
+ return -3;
+ return 0;
+ except:
+ if fIgnoreErrors:
+ reporter.logXcpt();
+ else:
+ reporter.errorXcpt();
+ return -2;
+ self.oTstDrv.processPendingEvents();
+
+ cMsElapsed = base.timestampMilli() - msStart;
+ if cMsElapsed > cMsTimeout:
+ if fErrorOnTimeout:
+ if fIgnoreErrors:
+ reporter.log('Timing out after waiting for %s s on "%s" operation %d' \
+ % (cMsTimeout / 1000, self.sName, iOperation))
+ else:
+ reporter.error('Timing out after waiting for %s s on "%s" operation %d' \
+ % (cMsTimeout / 1000, self.sName, iOperation))
+ return -1;
+
+ try:
+ self.o.waitForOperationCompletion(iRealOperation, cMsInterval);
+ except:
+ if fIgnoreErrors:
+ reporter.logXcpt(self.sName);
+ else:
+ reporter.errorXcpt(self.sName);
+ return -2;
+ reporter.doPollWork('ProgressWrapper.waitForOperation');
+ # Not reached.
+ return -3; # Make pylin happy (for now).
+
+ def doQuickApiTest(self):
+ """
+ Queries everything that is stable and easy to get at and checks that
+ they don't throw errors.
+ """
+ if True is True: # pylint: disable=comparison-with-itself
+ try:
+ iPct = self.o.operationPercent;
+ sDesc = self.o.description;
+ fCancelable = self.o.cancelable;
+ cSecsRemain = self.o.timeRemaining;
+ fCanceled = self.o.canceled;
+ fCompleted = self.o.completed;
+ iOp = self.o.operation;
+ cOps = self.o.operationCount;
+ iOpPct = self.o.operationPercent;
+ sOpDesc = self.o.operationDescription;
+ except:
+ reporter.errorXcpt('%s: %s' % (self.sName, self.o,));
+ return False;
+ try:
+ # Very noisy -- only enable for debugging purposes.
+ #reporter.log2('%s: op=%u/%u/%s: %u%%; total=%u%% cancel=%s/%s compl=%s rem=%us; desc=%s' \
+ # % (self.sName, iOp, cOps, sOpDesc, iOpPct, iPct, fCanceled, fCancelable, fCompleted, \
+ # cSecsRemain, sDesc));
+ _ = iPct; _ = sDesc; _ = fCancelable; _ = cSecsRemain; _ = fCanceled; _ = fCompleted; _ = iOp;
+ _ = cOps; _ = iOpPct; _ = sOpDesc;
+ except:
+ reporter.errorXcpt();
+ return False;
+
+ return True;
+
+
+class SessionWrapper(TdTaskBase):
+ """
+ Wrapper around a machine session. The real session object can be accessed
+ thru the o member (short is good, right :-).
+ """
+
+ def __init__(self, oSession, oVM, oVBox, oVBoxMgr, oTstDrv, fRemoteSession, sFallbackName = None, sLogFile = None):
+ """
+ Initializes the session wrapper.
+ """
+ TdTaskBase.__init__(self, utils.getCallerName());
+ self.o = oSession;
+ self.oVBox = oVBox;
+ self.oVBoxMgr = oVBoxMgr;
+ self.oVM = oVM; # Not the session machine. Useful backdoor...
+ self.oTstDrv = oTstDrv;
+ self.fpApiVer = oTstDrv.fpApiVer;
+ self.fRemoteSession = fRemoteSession;
+ self.sLogFile = sLogFile;
+ self.oConsoleEventHandler = None;
+ self.uPid = None;
+ self.fPidFile = True;
+ self.fHostMemoryLow = False; # see signalHostMemoryLow; read-only for outsiders.
+
+ try:
+ self.sName = oSession.machine.name;
+ except:
+ if sFallbackName is not None:
+ self.sName = sFallbackName;
+ else:
+ try: self.sName = str(oSession.machine);
+ except: self.sName = 'is-this-vm-already-off'
+
+ try:
+ self.sUuid = oSession.machine.id;
+ except:
+ self.sUuid = None;
+
+ # Try cache the SessionPID.
+ self.getPid();
+
+ def __del__(self):
+ """
+ Destructor that makes sure the callbacks are deregistered and
+ that the session is closed.
+ """
+ self.deregisterEventHandlerForTask();
+
+ if self.o is not None:
+ try:
+ self.close();
+ reporter.log('close session %s' % (self.o));
+ except:
+ pass;
+ self.o = None;
+
+ TdTaskBase.__del__(self);
+
+ def toString(self):
+ return '<%s: sUuid=%s, sName=%s, uPid=%s, sDbgCreated=%s, fRemoteSession=%s, oSession=%s,' \
+ ' oConsoleEventHandler=%s, oVM=%s >' \
+ % (type(self).__name__, self.sUuid, self.sName, self.uPid, self.sDbgCreated, self.fRemoteSession,
+ self.o, self.oConsoleEventHandler, self.oVM,);
+
+ def __str__(self):
+ return self.toString();
+
+ #
+ # TdTaskBase overrides.
+ #
+
+ def __pollTask(self):
+ """ Internal poller """
+ # Poll for events after doing the remote GetState call, otherwise we
+ # might end up sleepless because XPCOM queues a cleanup event.
+ try:
+ try:
+ eState = self.o.machine.state;
+ except Exception as oXcpt:
+ if vbox.ComError.notEqual(oXcpt, vbox.ComError.E_UNEXPECTED):
+ reporter.logXcpt();
+ return True;
+ finally:
+ self.oTstDrv.processPendingEvents();
+
+ # Switch
+ if eState == vboxcon.MachineState_Running:
+ return False;
+ if eState == vboxcon.MachineState_Paused:
+ return False;
+ if eState == vboxcon.MachineState_Teleporting:
+ return False;
+ if eState == vboxcon.MachineState_LiveSnapshotting:
+ return False;
+ if eState == vboxcon.MachineState_Starting:
+ return False;
+ if eState == vboxcon.MachineState_Stopping:
+ return False;
+ if eState == vboxcon.MachineState_Saving:
+ return False;
+ if eState == vboxcon.MachineState_Restoring:
+ return False;
+ if eState == vboxcon.MachineState_TeleportingPausedVM:
+ return False;
+ if eState == vboxcon.MachineState_TeleportingIn:
+ return False;
+
+ # *Beeep* fudge!
+ if self.fpApiVer < 3.2 \
+ and eState == vboxcon.MachineState_PoweredOff \
+ and self.getAgeAsMs() < 3000:
+ return False;
+
+ reporter.log('SessionWrapper::pollTask: eState=%s' % (eState));
+ return True;
+
+
+ def pollTask(self, fLocked = False):
+ """
+ Overrides TdTaskBase.pollTask().
+
+ This method returns False while the VM is online and running normally.
+ """
+
+ # Call super to check if the task was signalled by runtime error or similar,
+ # if not then check the VM state via __pollTask.
+ fRc = super(SessionWrapper, self).pollTask(fLocked);
+ if not fRc:
+ fRc = self.__pollTask();
+
+ # HACK ALERT: Lazily try registering the console event handler if
+ # we're not ready.
+ if not fRc and self.oConsoleEventHandler is None:
+ self.registerEventHandlerForTask();
+
+ # HACK ALERT: Lazily try get the PID and add it to the PID file.
+ if not fRc and self.uPid is None:
+ self.getPid();
+
+ return fRc;
+
+ def waitForTask(self, cMsTimeout = 0):
+ """
+ Overrides TdTaskBase.waitForTask().
+ Process XPCOM/COM events while waiting.
+ """
+ msStart = base.timestampMilli();
+ fState = self.pollTask(False);
+ while not fState:
+ cMsElapsed = base.timestampMilli() - msStart;
+ if cMsElapsed > cMsTimeout:
+ break;
+ cMsSleep = cMsTimeout - cMsElapsed;
+ cMsSleep = min(cMsSleep, 10000);
+ try: self.oVBoxMgr.waitForEvents(cMsSleep);
+ except KeyboardInterrupt: raise;
+ except: pass;
+ if self.fnProcessEvents:
+ self.fnProcessEvents();
+ reporter.doPollWork('SessionWrapper.waitForTask');
+ fState = self.pollTask(False);
+ return fState;
+
+ def setTaskOwner(self, oOwner):
+ """
+ HACK ALERT!
+ Overrides TdTaskBase.setTaskOwner() so we can try call
+ registerEventHandlerForTask() again when when the testdriver calls
+ addTask() after VM has been spawned. Related to pollTask() above.
+
+ The testdriver must not add the task too early for this to work!
+ """
+ if oOwner is not None:
+ self.registerEventHandlerForTask()
+ return TdTaskBase.setTaskOwner(self, oOwner);
+
+
+ #
+ # Task helpers.
+ #
+
+ def registerEventHandlerForTask(self):
+ """
+ Registers the console event handlers for working the task state.
+ """
+ if self.oConsoleEventHandler is not None:
+ return True;
+ self.oConsoleEventHandler = self.registerDerivedEventHandler(vbox.SessionConsoleEventHandler, {}, False);
+ return self.oConsoleEventHandler is not None;
+
+ def deregisterEventHandlerForTask(self):
+ """
+ Deregisters the console event handlers.
+ """
+ if self.oConsoleEventHandler is not None:
+ self.oConsoleEventHandler.unregister();
+ self.oConsoleEventHandler = None;
+
+ def signalHostMemoryLow(self):
+ """
+ Used by a runtime error event handler to indicate that we're low on memory.
+ Signals the task.
+ """
+ self.fHostMemoryLow = True;
+ self.signalTask();
+ return True;
+
+ def needsPoweringOff(self):
+ """
+ Examins the machine state to see if the VM needs powering off.
+ """
+ try:
+ try:
+ eState = self.o.machine.state;
+ except Exception as oXcpt:
+ if vbox.ComError.notEqual(oXcpt, vbox.ComError.E_UNEXPECTED):
+ reporter.logXcpt();
+ return False;
+ finally:
+ self.oTstDrv.processPendingEvents();
+
+ # Switch
+ if eState == vboxcon.MachineState_Running:
+ return True;
+ if eState == vboxcon.MachineState_Paused:
+ return True;
+ if eState == vboxcon.MachineState_Stuck:
+ return True;
+ if eState == vboxcon.MachineState_Teleporting:
+ return True;
+ if eState == vboxcon.MachineState_LiveSnapshotting:
+ return True;
+ if eState == vboxcon.MachineState_Starting:
+ return True;
+ if eState == vboxcon.MachineState_Saving:
+ return True;
+ if eState == vboxcon.MachineState_Restoring:
+ return True;
+ if eState == vboxcon.MachineState_TeleportingPausedVM:
+ return True;
+ if eState == vboxcon.MachineState_TeleportingIn:
+ return True;
+ if hasattr(vboxcon, 'MachineState_FaultTolerantSyncing'):
+ if eState == vboxcon.MachineState_FaultTolerantSyncing:
+ return True;
+ return False;
+
+ def assertPoweredOff(self):
+ """
+ Asserts that the VM is powered off, reporting an error if not.
+ Returns True if powered off, False + error msg if not.
+ """
+ try:
+ try:
+ eState = self.oVM.state;
+ except Exception:
+ reporter.errorXcpt();
+ return True;
+ finally:
+ self.oTstDrv.processPendingEvents();
+
+ if eState == vboxcon.MachineState_PoweredOff:
+ return True;
+ reporter.error('Expected machine state "PoweredOff", machine is in the "%s" state instead.'
+ % (_nameMachineState(eState),));
+ return False;
+
+ def getMachineStateWithName(self):
+ """
+ Gets the current machine state both as a constant number/whatever and
+ as a human readable string. On error, the constants will be set to
+ None and the string will be the error message.
+ """
+ try:
+ eState = self.oVM.state;
+ except:
+ return (None, '[error getting state: %s]' % (self.oVBoxMgr.xcptToString(),));
+ finally:
+ self.oTstDrv.processPendingEvents();
+ return (eState, _nameMachineState(eState));
+
+ def reportPrematureTermination(self, sPrefix = ''):
+ """
+ Reports a premature virtual machine termination.
+ Returns False to facilitate simpler error paths.
+ """
+
+ reporter.error(sPrefix + 'The virtual machine terminated prematurely!!');
+ (enmState, sStateNm) = self.getMachineStateWithName();
+ reporter.error(sPrefix + 'Machine state: %s' % (sStateNm,));
+
+ if enmState is not None \
+ and enmState == vboxcon.MachineState_Aborted \
+ and self.uPid is not None:
+ #
+ # Look for process crash info.
+ #
+ def addCrashFile(sLogFile, fBinary):
+ """ processCollectCrashInfo callback. """
+ reporter.addLogFile(sLogFile, 'crash/dump/vm' if fBinary else 'crash/report/vm');
+ utils.processCollectCrashInfo(self.uPid, reporter.log, addCrashFile);
+
+ return False;
+
+
+
+ #
+ # ISession / IMachine / ISomethingOrAnother wrappers.
+ #
+
+ def close(self):
+ """
+ Closes the session if it's open and removes it from the
+ vbox.TestDriver.aoRemoteSessions list.
+ Returns success indicator.
+ """
+ fRc = True;
+ if self.o is not None:
+ # Get the pid in case we need to kill the process later on.
+ self.getPid();
+
+ # Try close it.
+ try:
+ if self.fpApiVer < 3.3:
+ self.o.close();
+ else:
+ self.o.unlockMachine();
+ self.o = None;
+ except KeyboardInterrupt:
+ raise;
+ except:
+ # Kludge to ignore VBoxSVC's closing of our session when the
+ # direct session closes / VM process terminates. Fun!
+ try: fIgnore = self.o.state == vboxcon.SessionState_Unlocked;
+ except: fIgnore = False;
+ if fIgnore:
+ self.o = None; # Must prevent a retry during GC.
+ else:
+ reporter.errorXcpt('ISession::unlockMachine failed on %s' % (self.o));
+ fRc = False;
+
+ # Remove it from the remote session list if applicable (not 100% clean).
+ if fRc and self.fRemoteSession:
+ try:
+ if self in self.oTstDrv.aoRemoteSessions:
+ reporter.log2('SessionWrapper::close: Removing myself from oTstDrv.aoRemoteSessions');
+ self.oTstDrv.aoRemoteSessions.remove(self)
+ except:
+ reporter.logXcpt();
+
+ if self.uPid is not None and self.fPidFile:
+ self.oTstDrv.pidFileRemove(self.uPid);
+ self.fPidFile = False;
+
+ # It's only logical to deregister the event handler after the session
+ # is closed. It also avoids circular references between the session
+ # and the listener, which causes trouble with garbage collection.
+ self.deregisterEventHandlerForTask();
+
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def saveSettings(self, fClose = False):
+ """
+ Saves the settings and optionally closes the session.
+ Returns success indicator.
+ """
+ try:
+ try:
+ self.o.machine.saveSettings();
+ except:
+ reporter.errorXcpt('saveSettings failed on %s' % (self.o));
+ return False;
+ finally:
+ self.oTstDrv.processPendingEvents();
+ if fClose:
+ return self.close();
+ return True;
+
+ def discardSettings(self, fClose = False):
+ """
+ Discards the settings and optionally closes the session.
+ """
+ try:
+ try:
+ self.o.machine.discardSettings();
+ except:
+ reporter.errorXcpt('discardSettings failed on %s' % (self.o));
+ return False;
+ finally:
+ self.oTstDrv.processPendingEvents();
+ if fClose:
+ return self.close();
+ return True;
+
+ def enableVirtEx(self, fEnable):
+ """
+ Enables or disables AMD-V/VT-x.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ # Enable/disable it.
+ fRc = True;
+ try:
+ self.o.machine.setHWVirtExProperty(vboxcon.HWVirtExPropertyType_Enabled, fEnable);
+ except:
+ reporter.errorXcpt('failed to set HWVirtExPropertyType_Enabled=%s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set HWVirtExPropertyType_Enabled=%s for "%s"' % (fEnable, self.sName));
+
+ # Force/unforce it.
+ if fRc and hasattr(vboxcon, 'HWVirtExPropertyType_Force'):
+ try:
+ self.o.machine.setHWVirtExProperty(vboxcon.HWVirtExPropertyType_Force, fEnable);
+ except:
+ reporter.errorXcpt('failed to set HWVirtExPropertyType_Force=%s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set HWVirtExPropertyType_Force=%s for "%s"' % (fEnable, self.sName));
+ else:
+ reporter.log('Warning! vboxcon has no HWVirtExPropertyType_Force attribute.');
+ ## @todo Modify CFGM to do the same for old VBox versions?
+
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def enableNestedPaging(self, fEnable):
+ """
+ Enables or disables nested paging..
+ Returns True on success and False on failure. Error information is logged.
+ """
+ ## @todo Add/remove force CFGM thing, we don't want fallback logic when testing.
+ fRc = True;
+ try:
+ self.o.machine.setHWVirtExProperty(vboxcon.HWVirtExPropertyType_NestedPaging, fEnable);
+ except:
+ reporter.errorXcpt('failed to set HWVirtExPropertyType_NestedPaging=%s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set HWVirtExPropertyType_NestedPaging=%s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def enableLongMode(self, fEnable):
+ """
+ Enables or disables LongMode.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ # Supported.
+ if self.fpApiVer < 4.2 or not hasattr(vboxcon, 'HWVirtExPropertyType_LongMode'):
+ return True;
+
+ # Enable/disable it.
+ fRc = True;
+ try:
+ self.o.machine.setCPUProperty(vboxcon.CPUPropertyType_LongMode, fEnable);
+ except:
+ reporter.errorXcpt('failed to set CPUPropertyType_LongMode=%s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set CPUPropertyType_LongMode=%s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def enableNestedHwVirt(self, fEnable):
+ """
+ Enables or disables Nested Hardware-Virtualization.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ # Supported.
+ if self.fpApiVer < 5.3 or not hasattr(vboxcon, 'CPUPropertyType_HWVirt'):
+ return True;
+
+ # Enable/disable it.
+ fRc = True;
+ try:
+ self.o.machine.setCPUProperty(vboxcon.CPUPropertyType_HWVirt, fEnable);
+ except:
+ reporter.errorXcpt('failed to set CPUPropertyType_HWVirt=%s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set CPUPropertyType_HWVirt=%s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def enablePae(self, fEnable):
+ """
+ Enables or disables PAE
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ if self.fpApiVer >= 3.2: # great, ain't it?
+ self.o.machine.setCPUProperty(vboxcon.CPUPropertyType_PAE, fEnable);
+ else:
+ self.o.machine.setCpuProperty(vboxcon.CpuPropertyType_PAE, fEnable);
+ except:
+ reporter.errorXcpt('failed to set CPUPropertyType_PAE=%s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set CPUPropertyType_PAE=%s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def enableIoApic(self, fEnable):
+ """
+ Enables or disables the IO-APIC
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ self.o.machine.BIOSSettings.IOAPICEnabled = fEnable;
+ except:
+ reporter.errorXcpt('failed to set BIOSSettings.IOAPICEnabled=%s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set BIOSSettings.IOAPICEnabled=%s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def enableHpet(self, fEnable):
+ """
+ Enables or disables the HPET
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ if self.fpApiVer >= 4.2:
+ self.o.machine.HPETEnabled = fEnable;
+ else:
+ self.o.machine.hpetEnabled = fEnable;
+ except:
+ reporter.errorXcpt('failed to set HpetEnabled=%s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set HpetEnabled=%s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def enableUsbHid(self, fEnable):
+ """
+ Enables or disables the USB HID
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ if fEnable:
+ if self.fpApiVer >= 4.3:
+ cOhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_OHCI);
+ if cOhciCtls == 0:
+ self.o.machine.addUSBController('OHCI', vboxcon.USBControllerType_OHCI);
+ else:
+ self.o.machine.usbController.enabled = True;
+
+ if self.fpApiVer >= 4.2:
+ self.o.machine.pointingHIDType = vboxcon.PointingHIDType_ComboMouse;
+ self.o.machine.keyboardHIDType = vboxcon.KeyboardHIDType_ComboKeyboard;
+ else:
+ self.o.machine.pointingHidType = vboxcon.PointingHidType_ComboMouse;
+ self.o.machine.keyboardHidType = vboxcon.KeyboardHidType_ComboKeyboard;
+ else:
+ if self.fpApiVer >= 4.2:
+ self.o.machine.pointingHIDType = vboxcon.PointingHIDType_PS2Mouse;
+ self.o.machine.keyboardHIDType = vboxcon.KeyboardHIDType_PS2Keyboard;
+ else:
+ self.o.machine.pointingHidType = vboxcon.PointingHidType_PS2Mouse;
+ self.o.machine.keyboardHidType = vboxcon.KeyboardHidType_PS2Keyboard;
+ except:
+ reporter.errorXcpt('failed to change UsbHid to %s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('changed UsbHid to %s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def enableUsbOhci(self, fEnable):
+ """
+ Enables or disables the USB OHCI controller
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ if fEnable:
+ if self.fpApiVer >= 4.3:
+ cOhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_OHCI);
+ if cOhciCtls == 0:
+ self.o.machine.addUSBController('OHCI', vboxcon.USBControllerType_OHCI);
+ else:
+ self.o.machine.usbController.enabled = True;
+ else:
+ if self.fpApiVer >= 4.3:
+ cOhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_OHCI);
+ if cOhciCtls == 1:
+ self.o.machine.removeUSBController('OHCI');
+ else:
+ self.o.machine.usbController.enabled = False;
+ except:
+ reporter.errorXcpt('failed to change OHCI to %s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('changed OHCI to %s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def enableUsbEhci(self, fEnable):
+ """
+ Enables or disables the USB EHCI controller, enables also OHCI if it is still disabled.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ if fEnable:
+ if self.fpApiVer >= 4.3:
+ cOhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_OHCI);
+ if cOhciCtls == 0:
+ self.o.machine.addUSBController('OHCI', vboxcon.USBControllerType_OHCI);
+
+ cEhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_EHCI);
+ if cEhciCtls == 0:
+ self.o.machine.addUSBController('EHCI', vboxcon.USBControllerType_EHCI);
+ else:
+ self.o.machine.usbController.enabled = True;
+ self.o.machine.usbController.enabledEHCI = True;
+ else:
+ if self.fpApiVer >= 4.3:
+ cEhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_EHCI);
+ if cEhciCtls == 1:
+ self.o.machine.removeUSBController('EHCI');
+ else:
+ self.o.machine.usbController.enabledEHCI = False;
+ except:
+ reporter.errorXcpt('failed to change EHCI to %s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('changed EHCI to %s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def enableUsbXhci(self, fEnable):
+ """
+ Enables or disables the USB XHCI controller. Error information is logged.
+ """
+ fRc = True;
+ try:
+ if fEnable:
+ cXhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_XHCI);
+ if cXhciCtls == 0:
+ self.o.machine.addUSBController('XHCI', vboxcon.USBControllerType_XHCI);
+ else:
+ cXhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_XHCI);
+ if cXhciCtls == 1:
+ self.o.machine.removeUSBController('XHCI');
+ except:
+ reporter.errorXcpt('failed to change XHCI to %s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('changed XHCI to %s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setFirmwareType(self, eType):
+ """
+ Sets the firmware type.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ self.o.machine.firmwareType = eType;
+ except:
+ reporter.errorXcpt('failed to set firmwareType=%s for "%s"' % (eType, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set firmwareType=%s for "%s"' % (eType, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setChipsetType(self, eType):
+ """
+ Sets the chipset type.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ self.o.machine.chipsetType = eType;
+ except:
+ reporter.errorXcpt('failed to set chipsetType=%s for "%s"' % (eType, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set chipsetType=%s for "%s"' % (eType, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setIommuType(self, eType):
+ """
+ Sets the IOMMU type.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ # Supported.
+ if self.fpApiVer < 6.2 or not hasattr(vboxcon, 'IommuType_Intel') or not hasattr(vboxcon, 'IommuType_AMD'):
+ return True;
+ fRc = True;
+ try:
+ self.o.machine.iommuType = eType;
+ except:
+ reporter.errorXcpt('failed to set iommuType=%s for "%s"' % (eType, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set iommuType=%s for "%s"' % (eType, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setupBootLogo(self, fEnable, cMsLogoDisplay = 0):
+ """
+ Sets up the boot logo. fEnable toggles the fade and boot menu
+ settings as well as the mode.
+ """
+ fRc = True;
+ try:
+ self.o.machine.BIOSSettings.logoFadeIn = not fEnable;
+ self.o.machine.BIOSSettings.logoFadeOut = not fEnable;
+ self.o.machine.BIOSSettings.logoDisplayTime = cMsLogoDisplay;
+ if fEnable:
+ self.o.machine.BIOSSettings.bootMenuMode = vboxcon.BIOSBootMenuMode_Disabled;
+ else:
+ self.o.machine.BIOSSettings.bootMenuMode = vboxcon.BIOSBootMenuMode_MessageAndMenu;
+ except:
+ reporter.errorXcpt('failed to set logoFadeIn/logoFadeOut/bootMenuMode=%s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+ else:
+ reporter.log('set logoFadeIn/logoFadeOut/bootMenuMode=%s for "%s"' % (fEnable, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setupVrdp(self, fEnable, uPort = None):
+ """
+ Configures VRDP.
+ """
+ fRc = True;
+ try:
+ if self.fpApiVer >= 4.0:
+ self.o.machine.VRDEServer.enabled = fEnable;
+ else:
+ self.o.machine.VRDPServer.enabled = fEnable;
+ except:
+ reporter.errorXcpt('failed to set VRDEServer::enabled=%s for "%s"' % (fEnable, self.sName));
+ fRc = False;
+
+ if uPort is not None and fRc:
+ try:
+ if self.fpApiVer >= 4.0:
+ self.o.machine.VRDEServer.setVRDEProperty("TCP/Ports", str(uPort));
+ else:
+ self.o.machine.VRDPServer.ports = str(uPort);
+ except:
+ reporter.errorXcpt('failed to set VRDEServer::ports=%s for "%s"' % (uPort, self.sName));
+ fRc = False;
+ if fRc:
+ reporter.log('set VRDEServer.enabled/ports=%s/%s for "%s"' % (fEnable, uPort, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def getNicDriverNameFromType(self, eNicType):
+ """
+ Helper that translate the adapter type into a driver name.
+ """
+ if eNicType in (vboxcon.NetworkAdapterType_Am79C970A, vboxcon.NetworkAdapterType_Am79C973):
+ sName = 'pcnet';
+ elif eNicType in (vboxcon.NetworkAdapterType_I82540EM,
+ vboxcon.NetworkAdapterType_I82543GC,
+ vboxcon.NetworkAdapterType_I82545EM):
+ sName = 'e1000';
+ elif eNicType == vboxcon.NetworkAdapterType_Virtio:
+ sName = 'virtio-net';
+ else:
+ reporter.error('Unknown adapter type "%s" (VM: "%s")' % (eNicType, self.sName));
+ sName = 'pcnet';
+ return sName;
+
+ def setupNatForwardingForTxs(self, iNic = 0, iHostPort = 5042):
+ """
+ Sets up NAT forwarding for port 5042 if applicable, cleans up if not.
+ """
+ try:
+ oNic = self.o.machine.getNetworkAdapter(iNic);
+ except:
+ reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName));
+ return False;
+
+ # Nuke the old setup for all possible adapter types (in case we're
+ # called after it changed).
+ for sName in ('pcnet', 'e1000', 'virtio-net'):
+ for sConfig in ('VBoxInternal/Devices/%s/%u/LUN#0/AttachedDriver/Config' % (sName, iNic), \
+ 'VBoxInternal/Devices/%s/%u/LUN#0/Config' % (sName, iNic)):
+ try:
+ self.o.machine.setExtraData('%s/txs/Protocol' % (sConfig), '');
+ self.o.machine.setExtraData('%s/txs/HostPort' % (sConfig), '');
+ self.o.machine.setExtraData('%s/txs/GuestPort' % (sConfig), '');
+ except:
+ reporter.errorXcpt();
+
+ # Set up port forwarding if NAT attachment.
+ try:
+ eAttType = oNic.attachmentType;
+ except:
+ reporter.errorXcpt('attachmentType on %s failed for "%s"' % (iNic, self.sName));
+ return False;
+ if eAttType != vboxcon.NetworkAttachmentType_NAT:
+ return True;
+
+ try:
+ eNicType = oNic.adapterType;
+ fTraceEnabled = oNic.traceEnabled;
+ except:
+ reporter.errorXcpt('attachmentType/traceEnabled on %s failed for "%s"' % (iNic, self.sName));
+ return False;
+
+ if self.fpApiVer >= 4.1:
+ try:
+ if self.fpApiVer >= 4.2:
+ oNatEngine = oNic.NATEngine;
+ else:
+ oNatEngine = oNic.natDriver;
+ except:
+ reporter.errorXcpt('Failed to get INATEngine data on "%s"' % (self.sName));
+ return False;
+ try: oNatEngine.removeRedirect('txs');
+ except: pass;
+ try:
+ oNatEngine.addRedirect('txs', vboxcon.NATProtocol_TCP, '127.0.0.1', '%s' % (iHostPort), '', '5042');
+ except:
+ reporter.errorXcpt('Failed to add a addRedirect redirect on "%s"' % (self.sName));
+ return False;
+
+ else:
+ sName = self.getNicDriverNameFromType(eNicType);
+ if fTraceEnabled:
+ sConfig = 'VBoxInternal/Devices/%s/%u/LUN#0/AttachedDriver/Config' % (sName, iNic)
+ else:
+ sConfig = 'VBoxInternal/Devices/%s/%u/LUN#0/Config' % (sName, iNic)
+
+ try:
+ self.o.machine.setExtraData('%s/txs/Protocol' % (sConfig), 'TCP');
+ self.o.machine.setExtraData('%s/txs/HostPort' % (sConfig), '%s' % (iHostPort));
+ self.o.machine.setExtraData('%s/txs/GuestPort' % (sConfig), '5042');
+ except:
+ reporter.errorXcpt('Failed to set NAT extra data on "%s"' % (self.sName));
+ return False;
+ return True;
+
+ def setNicType(self, eType, iNic = 0):
+ """
+ Sets the NIC type of the specified NIC.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ try:
+ try:
+ oNic = self.o.machine.getNetworkAdapter(iNic);
+ except:
+ reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName));
+ return False;
+ try:
+ oNic.adapterType = eType;
+ except:
+ reporter.errorXcpt('failed to set NIC type on slot %s to %s for VM "%s"' % (iNic, eType, self.sName));
+ return False;
+ finally:
+ self.oTstDrv.processPendingEvents();
+
+ if not self.setupNatForwardingForTxs(iNic):
+ return False;
+ reporter.log('set NIC type on slot %s to %s for VM "%s"' % (iNic, eType, self.sName));
+ return True;
+
+ def setNicTraceEnabled(self, fTraceEnabled, sTraceFile, iNic = 0):
+ """
+ Sets the NIC trace enabled flag and file path.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ try:
+ try:
+ oNic = self.o.machine.getNetworkAdapter(iNic);
+ except:
+ reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName));
+ return False;
+ try:
+ oNic.traceEnabled = fTraceEnabled;
+ oNic.traceFile = sTraceFile;
+ except:
+ reporter.errorXcpt('failed to set NIC trace flag on slot %s to %s for VM "%s"' \
+ % (iNic, fTraceEnabled, self.sName));
+ return False;
+ finally:
+ self.oTstDrv.processPendingEvents();
+
+ if not self.setupNatForwardingForTxs(iNic):
+ return False;
+ reporter.log('set NIC trace on slot %s to "%s" (path "%s") for VM "%s"' %
+ (iNic, fTraceEnabled, sTraceFile, self.sName));
+ return True;
+
+ def getDefaultNicName(self, eAttachmentType):
+ """
+ Return the default network / interface name for the NIC attachment type.
+ """
+ sRetName = '';
+ if eAttachmentType == vboxcon.NetworkAttachmentType_Bridged:
+ if self.oTstDrv.sDefBridgedNic is not None:
+ sRetName = self.oTstDrv.sDefBridgedNic;
+ else:
+ sRetName = 'eth0';
+ try:
+ aoHostNics = self.oVBoxMgr.getArray(self.oVBox.host, 'networkInterfaces');
+ for oHostNic in aoHostNics:
+ if oHostNic.interfaceType == vboxcon.HostNetworkInterfaceType_Bridged \
+ and oHostNic.status == vboxcon.HostNetworkInterfaceStatus_Up:
+ sRetName = oHostNic.name;
+ break;
+ except:
+ reporter.errorXcpt();
+
+ elif eAttachmentType == vboxcon.NetworkAttachmentType_HostOnly:
+ try:
+ aoHostNics = self.oVBoxMgr.getArray(self.oVBox.host, 'networkInterfaces');
+ for oHostNic in aoHostNics:
+ if oHostNic.interfaceType == vboxcon.HostNetworkInterfaceType_HostOnly:
+ if oHostNic.status == vboxcon.HostNetworkInterfaceStatus_Up:
+ sRetName = oHostNic.name;
+ break;
+ if sRetName == '':
+ sRetName = oHostNic.name;
+ except:
+ reporter.errorXcpt();
+ if sRetName == '':
+ # Create a new host-only interface.
+ reporter.log("Creating host only NIC ...");
+ try:
+ (oIProgress, oIHostOnly) = self.oVBox.host.createHostOnlyNetworkInterface();
+ oProgress = ProgressWrapper(oIProgress, self.oVBoxMgr, self.oTstDrv, 'Create host only NIC');
+ oProgress.wait();
+ if oProgress.logResult() is False:
+ return '';
+ sRetName = oIHostOnly.name;
+ except:
+ reporter.errorXcpt();
+ return '';
+ reporter.log("Created host only NIC: '%s'" % (sRetName,));
+
+ elif self.fpApiVer >= 7.0 and eAttachmentType == vboxcon.NetworkAttachmentType_HostOnlyNetwork:
+ aoHostNetworks = self.oVBoxMgr.getArray(self.oVBox, 'hostOnlyNetworks');
+ if aoHostNetworks:
+ sRetName = aoHostNetworks[0].networkName;
+ else:
+ try:
+ oHostOnlyNet = self.oVBox.createHostOnlyNetwork('Host-only Test Network');
+ oHostOnlyNet.lowerIP = '192.168.56.1';
+ oHostOnlyNet.upperIP = '192.168.56.199';
+ oHostOnlyNet.networkMask = '255.255.255.0';
+ sRetName = oHostOnlyNet.networkName;
+ except:
+ reporter.errorXcpt();
+ return '';
+
+ elif eAttachmentType == vboxcon.NetworkAttachmentType_Internal:
+ sRetName = 'VBoxTest';
+
+ elif eAttachmentType == vboxcon.NetworkAttachmentType_NAT:
+ sRetName = '';
+
+ else: ## @todo Support NetworkAttachmentType_NATNetwork
+ reporter.error('eAttachmentType=%s is not known' % (eAttachmentType));
+ return sRetName;
+
+ def setNicAttachment(self, eAttachmentType, sName = None, iNic = 0):
+ """
+ Sets the attachment type of the specified NIC.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ try:
+ oNic = self.o.machine.getNetworkAdapter(iNic);
+ except:
+ reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName));
+ return False;
+
+ try:
+ if eAttachmentType is not None:
+ try:
+ if self.fpApiVer >= 4.1:
+ oNic.attachmentType = eAttachmentType;
+ else:
+ if eAttachmentType == vboxcon.NetworkAttachmentType_NAT:
+ oNic.attachToNAT();
+ elif eAttachmentType == vboxcon.NetworkAttachmentType_Bridged:
+ oNic.attachToBridgedInterface();
+ elif eAttachmentType == vboxcon.NetworkAttachmentType_Internal:
+ oNic.attachToInternalNetwork();
+ elif eAttachmentType == vboxcon.NetworkAttachmentType_HostOnly:
+ oNic.attachToHostOnlyInterface();
+ else:
+ raise base.GenError("eAttachmentType=%s is invalid" % (eAttachmentType));
+ except:
+ reporter.errorXcpt('failed to set the attachment type on slot %s to %s for VM "%s"' \
+ % (iNic, eAttachmentType, self.sName));
+ return False;
+ else:
+ try:
+ eAttachmentType = oNic.attachmentType;
+ except:
+ reporter.errorXcpt('failed to get the attachment type on slot %s for VM "%s"' % (iNic, self.sName));
+ return False;
+ finally:
+ self.oTstDrv.processPendingEvents();
+
+ if sName is not None:
+ # Resolve the special 'default' name.
+ if sName == 'default':
+ sName = self.getDefaultNicName(eAttachmentType);
+
+ # The name translate to different attributes depending on the
+ # attachment type.
+ try:
+ if eAttachmentType == vboxcon.NetworkAttachmentType_Bridged:
+ ## @todo check this out on windows, may have to do a
+ # translation of the name there or smth IIRC.
+ try:
+ if self.fpApiVer >= 4.1:
+ oNic.bridgedInterface = sName;
+ else:
+ oNic.hostInterface = sName;
+ except:
+ reporter.errorXcpt('failed to set the hostInterface property on slot %s to "%s" for VM "%s"'
+ % (iNic, sName, self.sName,));
+ return False;
+ elif eAttachmentType == vboxcon.NetworkAttachmentType_HostOnly:
+ try:
+ if self.fpApiVer >= 4.1:
+ oNic.hostOnlyInterface = sName;
+ else:
+ oNic.hostInterface = sName;
+ except:
+ reporter.errorXcpt('failed to set the internalNetwork property on slot %s to "%s" for VM "%s"'
+ % (iNic, sName, self.sName,));
+ return False;
+ elif self.fpApiVer >= 7.0 and eAttachmentType == vboxcon.NetworkAttachmentType_HostOnlyNetwork:
+ try:
+ oNic.hostOnlyNetwork = sName;
+ except:
+ reporter.errorXcpt('failed to set the hostOnlyNetwork property on slot %s to "%s" for VM "%s"'
+ % (iNic, sName, self.sName,));
+ return False;
+ elif eAttachmentType == vboxcon.NetworkAttachmentType_Internal:
+ try:
+ oNic.internalNetwork = sName;
+ except:
+ reporter.errorXcpt('failed to set the internalNetwork property on slot %s to "%s" for VM "%s"'
+ % (iNic, sName, self.sName,));
+ return False;
+ elif eAttachmentType == vboxcon.NetworkAttachmentType_NAT:
+ try:
+ oNic.NATNetwork = sName;
+ except:
+ reporter.errorXcpt('failed to set the NATNetwork property on slot %s to "%s" for VM "%s"'
+ % (iNic, sName, self.sName,));
+ return False;
+ finally:
+ self.oTstDrv.processPendingEvents();
+
+ if not self.setupNatForwardingForTxs(iNic):
+ return False;
+ reporter.log('set NIC attachment type on slot %s to %s for VM "%s"' % (iNic, eAttachmentType, self.sName));
+ return True;
+
+ def setNicLocalhostReachable(self, fReachable, iNic = 0):
+ """
+ Sets whether the specified NIC can reach the host or not.
+ Only affects (enabled) NICs configured to NAT at the moment.
+
+ Returns True on success and False on failure. Error information is logged.
+ """
+ try:
+ oNic = self.o.machine.getNetworkAdapter(iNic);
+ except:
+ return reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName,));
+
+ try:
+ if not oNic.enabled: # NIC not enabled? Nothing to do here.
+ return True;
+ except:
+ return reporter.errorXcpt('NIC enabled status (%s) failed for "%s"' % (iNic, self.sName,));
+
+ reporter.log('Setting "LocalhostReachable" for network adapter in slot %d to %s' % (iNic, fReachable));
+
+ try:
+ oNatEngine = oNic.NATEngine;
+ except:
+ return reporter.errorXcpt('Getting NIC NAT engine (%s) failed for "%s"' % (iNic, self.sName,));
+
+ try:
+ if hasattr(oNatEngine, "localhostReachable"):
+ oNatEngine.localhostReachable = fReachable;
+ else:
+ oNatEngine.LocalhostReachable = fReachable;
+ except:
+ return reporter.errorXcpt('LocalhostReachable (%s) failed for "%s"' % (iNic, self.sName,));
+
+ return True;
+
+ def setNicMacAddress(self, sMacAddr, iNic = 0):
+ """
+ Sets the MAC address of the specified NIC.
+
+ The sMacAddr parameter is a string supplying the tail end of the MAC
+ address, missing quads are supplied from a constant byte (2), the IPv4
+ address of the host, and the NIC number.
+
+ Returns True on success and False on failure. Error information is logged.
+ """
+
+ # Resolve missing MAC address prefix by feeding in the host IP address bytes.
+ cchMacAddr = len(sMacAddr);
+ if 0 < cchMacAddr < 12:
+ sHostIP = netutils.getPrimaryHostIp();
+ abHostIP = socket.inet_aton(sHostIP);
+ if sys.version_info[0] < 3:
+ abHostIP = (ord(abHostIP[0]), ord(abHostIP[1]), ord(abHostIP[2]), ord(abHostIP[3]));
+
+ if abHostIP[0] == 127 \
+ or (abHostIP[0] == 169 and abHostIP[1] == 254) \
+ or (abHostIP[0] == 192 and abHostIP[1] == 168 and abHostIP[2] == 56):
+ return reporter.error('host IP for "%s" is %s, most likely not unique.' % (netutils.getHostnameFqdn(), sHostIP,));
+
+ sDefaultMac = '%02X%02X%02X%02X%02X%02X' % (0x02, abHostIP[0], abHostIP[1], abHostIP[2], abHostIP[3], iNic);
+ sMacAddr = sDefaultMac[0:(12 - cchMacAddr)] + sMacAddr;
+
+ # Get the NIC object and try set it address.
+ try:
+ oNic = self.o.machine.getNetworkAdapter(iNic);
+ except:
+ return reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName,));
+
+ try:
+ oNic.MACAddress = sMacAddr;
+ except:
+ return reporter.errorXcpt('failed to set the MAC address on slot %s to "%s" for VM "%s"'
+ % (iNic, sMacAddr, self.sName));
+
+ reporter.log('set MAC address on slot %s to %s for VM "%s"' % (iNic, sMacAddr, self.sName,));
+ return True;
+
+ def setRamSize(self, cMB):
+ """
+ Set the RAM size of the VM.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ self.o.machine.memorySize = cMB;
+ except:
+ reporter.errorXcpt('failed to set the RAM size of "%s" to %s' % (self.sName, cMB));
+ fRc = False;
+ else:
+ reporter.log('set the RAM size of "%s" to %s' % (self.sName, cMB));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setLargePages(self, fUseLargePages):
+ """
+ Configures whether the VM should use large pages or not.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ self.o.machine.setHWVirtExProperty(vboxcon.HWVirtExPropertyType_LargePages, fUseLargePages);
+ except:
+ reporter.errorXcpt('failed to set large pages of "%s" to %s' % (self.sName, fUseLargePages));
+ fRc = False;
+ else:
+ reporter.log('set the large pages of "%s" to %s' % (self.sName, fUseLargePages));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setVRamSize(self, cMB):
+ """
+ Set the RAM size of the VM.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ if self.fpApiVer >= 6.1 and hasattr(self.o.machine, 'graphicsAdapter'):
+ self.o.machine.graphicsAdapter.VRAMSize = cMB;
+ else:
+ self.o.machine.VRAMSize = cMB;
+ except:
+ reporter.errorXcpt('failed to set the VRAM size of "%s" to %s' % (self.sName, cMB));
+ fRc = False;
+ else:
+ reporter.log('set the VRAM size of "%s" to %s' % (self.sName, cMB));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setVideoControllerType(self, eControllerType):
+ """
+ Set the video controller type of the VM.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ if self.fpApiVer >= 6.1 and hasattr(self.o.machine, 'graphicsAdapter'):
+ self.o.machine.graphicsAdapter.graphicsControllerType = eControllerType;
+ else:
+ self.o.machine.graphicsControllerType = eControllerType;
+ except:
+ reporter.errorXcpt('failed to set the video controller type of "%s" to %s' % (self.sName, eControllerType));
+ fRc = False;
+ else:
+ reporter.log('set the video controller type of "%s" to %s' % (self.sName, eControllerType));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setAccelerate3DEnabled(self, fEnabled):
+ """
+ Set the video controller type of the VM.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ if self.fpApiVer >= 6.1 and hasattr(self.o.machine, 'graphicsAdapter'):
+ self.o.machine.graphicsAdapter.accelerate3DEnabled = fEnabled;
+ else:
+ self.o.machine.accelerate3DEnabled = fEnabled;
+ except:
+ reporter.errorXcpt('failed to set the accelerate3DEnabled of "%s" to %s' % (self.sName, fEnabled));
+ fRc = False;
+ else:
+ reporter.log('set the accelerate3DEnabled of "%s" to %s' % (self.sName, fEnabled));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setCpuCount(self, cCpus):
+ """
+ Set the number of CPUs.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ self.o.machine.CPUCount = cCpus;
+ except:
+ reporter.errorXcpt('failed to set the CPU count of "%s" to %s' % (self.sName, cCpus));
+ fRc = False;
+ else:
+ reporter.log('set the CPU count of "%s" to %s' % (self.sName, cCpus));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def getCpuCount(self):
+ """
+ Returns the number of CPUs.
+ Returns the number of CPUs on success and 0 on failure. Error information is logged.
+ """
+ cCpus = 0;
+ try:
+ cCpus = self.o.machine.CPUCount;
+ except:
+ reporter.errorXcpt('failed to get the CPU count of "%s"' % (self.sName,));
+
+ self.oTstDrv.processPendingEvents();
+ return cCpus;
+
+ def ensureControllerAttached(self, sController):
+ """
+ Makes sure the specified controller is attached to the VM, attaching it
+ if necessary.
+ """
+ try:
+ try:
+ self.o.machine.getStorageControllerByName(sController);
+ except:
+ (eBus, eType) = _ControllerNameToBusAndType(sController);
+ try:
+ oCtl = self.o.machine.addStorageController(sController, eBus);
+ except:
+ reporter.errorXcpt('addStorageController("%s",%s) failed on "%s"' % (sController, eBus, self.sName) );
+ return False;
+ else:
+ try:
+ oCtl.controllerType = eType;
+ reporter.log('added storage controller "%s" (bus %s, type %s) to %s'
+ % (sController, eBus, eType, self.sName));
+ except:
+ reporter.errorXcpt('controllerType = %s on ("%s" / %s) failed on "%s"'
+ % (eType, sController, eBus, self.sName) );
+ return False;
+ finally:
+ self.oTstDrv.processPendingEvents();
+ return True;
+
+ def setStorageControllerPortCount(self, sController, iPortCount):
+ """
+ Set maximum ports count for storage controller
+ """
+ try:
+ oCtl = self.o.machine.getStorageControllerByName(sController)
+ oCtl.portCount = iPortCount
+ self.oTstDrv.processPendingEvents()
+ reporter.log('set controller "%s" port count to value %d' % (sController, iPortCount))
+ return True
+ except:
+ reporter.log('unable to set storage controller "%s" ports count to %d' % (sController, iPortCount))
+
+ return False
+
+ def setStorageControllerHostIoCache(self, sController, fUseHostIoCache):
+ """
+ Set maximum ports count for storage controller
+ """
+ try:
+ oCtl = self.o.machine.getStorageControllerByName(sController);
+ oCtl.useHostIOCache = fUseHostIoCache;
+ self.oTstDrv.processPendingEvents();
+ reporter.log('set controller "%s" host I/O cache setting to %r' % (sController, fUseHostIoCache));
+ return True;
+ except:
+ reporter.log('unable to set storage controller "%s" host I/O cache setting to %r' % (sController, fUseHostIoCache));
+
+ return False;
+
+ def setBootOrder(self, iPosition, eType):
+ """
+ Set guest boot order type
+ @param iPosition boot order position
+ @param eType device type (vboxcon.DeviceType_HardDisk,
+ vboxcon.DeviceType_DVD, vboxcon.DeviceType_Floppy)
+ """
+ try:
+ self.o.machine.setBootOrder(iPosition, eType)
+ except:
+ return reporter.errorXcpt('Unable to set boot order.')
+
+ reporter.log('Set boot order [%d] for device %s' % (iPosition, str(eType)))
+ self.oTstDrv.processPendingEvents();
+
+ return True
+
+ def setStorageControllerType(self, eType, sController = "IDE Controller"):
+ """
+ Similar to ensureControllerAttached, except it will change the type.
+ """
+ try:
+ oCtl = self.o.machine.getStorageControllerByName(sController);
+ except:
+ (eBus, _) = _ControllerNameToBusAndType(sController);
+ try:
+ oCtl = self.o.machine.addStorageController(sController, eBus);
+ reporter.log('added storage controller "%s" (bus %s) to %s' % (sController, eBus, self.sName));
+ except:
+ reporter.errorXcpt('addStorageController("%s",%s) failed on "%s"' % (sController, eBus, self.sName) );
+ return False;
+ try:
+ oCtl.controllerType = eType;
+ except:
+ reporter.errorXcpt('failed to set controller type of "%s" on "%s" to %s' % (sController, self.sName, eType) );
+ return False;
+ reporter.log('set controller type of "%s" on "%s" to %s' % (sController, self.sName, eType) );
+ self.oTstDrv.processPendingEvents();
+ return True;
+
+ def attachDvd(self, sImage = None, sController = "IDE Controller", iPort = 1, iDevice = 0):
+ """
+ Attaches a DVD drive to a VM, optionally with an ISO inserted.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ # Input validation.
+ if sImage is not None and not self.oTstDrv.isResourceFile(sImage)\
+ and not os.path.isabs(sImage): ## fixme - testsuite unzip ++
+ reporter.fatal('"%s" is not in the resource set' % (sImage));
+ return None;
+
+ if not self.ensureControllerAttached(sController):
+ return False;
+
+ # Find/register the image if specified.
+ oImage = None;
+ sImageUuid = "";
+ if sImage is not None:
+ sFullName = self.oTstDrv.getFullResourceName(sImage)
+ try:
+ oImage = self.oVBox.findDVDImage(sFullName);
+ except:
+ try:
+ if self.fpApiVer >= 4.1:
+ oImage = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_DVD, vboxcon.AccessMode_ReadOnly, False);
+ elif self.fpApiVer >= 4.0:
+ oImage = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_DVD, vboxcon.AccessMode_ReadOnly);
+ else:
+ oImage = self.oVBox.openDVDImage(sFullName, "");
+ except vbox.ComException as oXcpt:
+ if oXcpt.errno != -1:
+ reporter.errorXcpt('failed to open DVD image "%s" xxx' % (sFullName));
+ else:
+ reporter.errorXcpt('failed to open DVD image "%s" yyy' % (sFullName));
+ return False;
+ except:
+ reporter.errorXcpt('failed to open DVD image "%s"' % (sFullName));
+ return False;
+ try:
+ sImageUuid = oImage.id;
+ except:
+ reporter.errorXcpt('failed to get the UUID of "%s"' % (sFullName));
+ return False;
+
+ # Attach the DVD.
+ fRc = True;
+ try:
+ if self.fpApiVer >= 4.0:
+ self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_DVD, oImage);
+ else:
+ self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_DVD, sImageUuid);
+ except:
+ reporter.errorXcpt('attachDevice("%s",%s,%s,HardDisk,"%s") failed on "%s"' \
+ % (sController, iPort, iDevice, sImageUuid, self.sName) );
+ fRc = False;
+ else:
+ reporter.log('attached DVD to %s, image="%s"' % (self.sName, sImage));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def attachHd(self, sHd, sController = "IDE Controller", iPort = 0, iDevice = 0, fImmutable = True, fForceResource = True):
+ """
+ Attaches a HD to a VM.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ # Input validation.
+ if fForceResource and not self.oTstDrv.isResourceFile(sHd):
+ reporter.fatal('"%s" is not in the resource set' % (sHd,));
+ return None;
+
+ if not self.ensureControllerAttached(sController):
+ return False;
+
+ # Find the HD, registering it if necessary (as immutable).
+ if fForceResource:
+ sFullName = self.oTstDrv.getFullResourceName(sHd);
+ else:
+ sFullName = sHd;
+ try:
+ oHd = self.oVBox.findHardDisk(sFullName);
+ except:
+ try:
+ if self.fpApiVer >= 4.1:
+ oHd = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_HardDisk, vboxcon.AccessMode_ReadOnly, False);
+ elif self.fpApiVer >= 4.0:
+ oHd = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_HardDisk, vboxcon.AccessMode_ReadOnly);
+ else:
+ oHd = self.oVBox.openHardDisk(sFullName, vboxcon.AccessMode_ReadOnly, False, "", False, "");
+ except:
+ reporter.errorXcpt('failed to open hd "%s"' % (sFullName));
+ return False;
+ try:
+ if fImmutable:
+ oHd.type = vboxcon.MediumType_Immutable;
+ else:
+ oHd.type = vboxcon.MediumType_Normal;
+ except:
+ if fImmutable:
+ reporter.errorXcpt('failed to set hd "%s" immutable' % (sHd));
+ else:
+ reporter.errorXcpt('failed to set hd "%s" normal' % (sHd));
+ return False;
+
+ # Attach it.
+ fRc = True;
+ try:
+ if self.fpApiVer >= 4.0:
+ self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_HardDisk, oHd);
+ else:
+ self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_HardDisk, oHd.id);
+ except:
+ reporter.errorXcpt('attachDevice("%s",%s,%s,HardDisk,"%s") failed on "%s"' \
+ % (sController, iPort, iDevice, oHd.id, self.sName) );
+ fRc = False;
+ else:
+ reporter.log('attached "%s" to %s' % (sHd, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def createBaseHd(self, sHd, sFmt = "VDI", cb = 10*1024*1024*1024, cMsTimeout = 60000, tMediumVariant = None):
+ """
+ Creates a base HD.
+ Returns Medium object on success and None on failure. Error information is logged.
+ """
+ if tMediumVariant is None:
+ tMediumVariant = (vboxcon.MediumVariant_Standard, );
+
+ try:
+ if self.fpApiVer >= 5.0:
+ oHd = self.oVBox.createMedium(sFmt, sHd, vboxcon.AccessMode_ReadWrite, vboxcon.DeviceType_HardDisk);
+ else:
+ oHd = self.oVBox.createHardDisk(sFmt, sHd);
+ oProgressXpcom = oHd.createBaseStorage(cb, tMediumVariant);
+ oProgress = ProgressWrapper(oProgressXpcom, self.oVBoxMgr, self.oTstDrv, 'create base disk %s' % (sHd));
+ oProgress.wait(cMsTimeout);
+ oProgress.logResult();
+ except:
+ reporter.errorXcpt('failed to create base hd "%s"' % (sHd));
+ oHd = None
+
+ return oHd;
+
+ def createDiffHd(self, oParentHd, sHd, sFmt = "VDI"):
+ """
+ Creates a differencing HD.
+ Returns Medium object on success and None on failure. Error information is logged.
+ """
+ # Detect the proper format if requested
+ if sFmt is None:
+ try:
+ oHdFmt = oParentHd.mediumFormat;
+ lstCaps = self.oVBoxMgr.getArray(oHdFmt, 'capabilities');
+ if vboxcon.MediumFormatCapabilities_Differencing in lstCaps:
+ sFmt = oHdFmt.id;
+ else:
+ sFmt = 'VDI';
+ except:
+ reporter.errorXcpt('failed to get preferred diff format for "%s"' % (sHd));
+ return None;
+ try:
+ if self.fpApiVer >= 5.0:
+ oHd = self.oVBox.createMedium(sFmt, sHd, vboxcon.AccessMode_ReadWrite, vboxcon.DeviceType_HardDisk);
+ else:
+ oHd = self.oVBox.createHardDisk(sFmt, sHd);
+ oProgressXpcom = oParentHd.createDiffStorage(oHd, (vboxcon.MediumVariant_Standard, ))
+ oProgress = ProgressWrapper(oProgressXpcom, self.oVBoxMgr, self.oTstDrv, 'create diff disk %s' % (sHd));
+ oProgress.wait();
+ oProgress.logResult();
+ except:
+ reporter.errorXcpt('failed to create diff hd "%s"' % (sHd));
+ oHd = None
+
+ return oHd;
+
+ def createAndAttachHd(self, sHd, sFmt = "VDI", sController = "IDE Controller", cb = 10*1024*1024*1024, # pylint: disable=too-many-arguments
+ iPort = 0, iDevice = 0, fImmutable = True, cMsTimeout = 60000, tMediumVariant = None):
+ """
+ Creates and attaches a HD to a VM.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ if not self.ensureControllerAttached(sController):
+ return False;
+
+ oHd = self.createBaseHd(sHd, sFmt, cb, cMsTimeout, tMediumVariant);
+ if oHd is None:
+ return False;
+
+ fRc = True;
+ try:
+ if fImmutable:
+ oHd.type = vboxcon.MediumType_Immutable;
+ else:
+ oHd.type = vboxcon.MediumType_Normal;
+ except:
+ if fImmutable:
+ reporter.errorXcpt('failed to set hd "%s" immutable' % (sHd));
+ else:
+ reporter.errorXcpt('failed to set hd "%s" normal' % (sHd));
+ fRc = False;
+
+ # Attach it.
+ if fRc is True:
+ try:
+ if self.fpApiVer >= 4.0:
+ self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_HardDisk, oHd);
+ else:
+ self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_HardDisk, oHd.id);
+ except:
+ reporter.errorXcpt('attachDevice("%s",%s,%s,HardDisk,"%s") failed on "%s"' \
+ % (sController, iPort, iDevice, oHd.id, self.sName) );
+ fRc = False;
+ else:
+ reporter.log('attached "%s" to %s' % (sHd, self.sName));
+
+ # Delete disk in case of an error
+ if fRc is False:
+ try:
+ oProgressCom = oHd.deleteStorage();
+ except:
+ reporter.errorXcpt('deleteStorage() for disk %s failed' % (sHd,));
+ else:
+ oProgress = ProgressWrapper(oProgressCom, self.oVBoxMgr, self.oTstDrv, 'delete disk %s' % (sHd));
+ oProgress.wait();
+ oProgress.logResult();
+
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def detachHd(self, sController = "IDE Controller", iPort = 0, iDevice = 0):
+ """
+ Detaches a HD, if attached, and returns a reference to it (IMedium).
+
+ In order to delete the detached medium, the caller must first save
+ the changes made in this session.
+
+ Returns (fRc, oHd), where oHd is None unless fRc is True, and fRc is
+ your standard success indicator. Error information is logged.
+ """
+
+ # What's attached?
+ try:
+ oHd = self.o.machine.getMedium(sController, iPort, iDevice);
+ except:
+ if self.oVBoxMgr.xcptIsOurXcptKind() \
+ and self.oVBoxMgr.xcptIsEqual(None, self.oVBoxMgr.constants.VBOX_E_OBJECT_NOT_FOUND):
+ reporter.log('No HD attached (to %s %s:%s)' % (sController, iPort, iDevice));
+ return (True, None);
+ return (reporter.errorXcpt('Error getting media at port %s, device %s, on %s.'
+ % (iPort, iDevice, sController)), None);
+ # Detach it.
+ try:
+ self.o.machine.detachDevice(sController, iPort, iDevice);
+ except:
+ return (reporter.errorXcpt('detachDevice("%s",%s,%s) failed on "%s"' \
+ % (sController, iPort, iDevice, self.sName) ), None);
+ reporter.log('detached HD ("%s",%s,%s) from %s' % (sController, iPort, iDevice, self.sName));
+ return (True, oHd);
+
+ def attachFloppy(self, sFloppy, sController = "Floppy Controller", iPort = 0, iDevice = 0):
+ """
+ Attaches a floppy image to a VM.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ # Input validation.
+ ## @todo Fix this wrt to bootsector-xxx.img from the validationkit.zip.
+ ##if not self.oTstDrv.isResourceFile(sFloppy):
+ ## reporter.fatal('"%s" is not in the resource set' % (sFloppy));
+ ## return None;
+
+ if not self.ensureControllerAttached(sController):
+ return False;
+
+ # Find the floppy image, registering it if necessary (as immutable).
+ sFullName = self.oTstDrv.getFullResourceName(sFloppy);
+ try:
+ oFloppy = self.oVBox.findFloppyImage(sFullName);
+ except:
+ try:
+ if self.fpApiVer >= 4.1:
+ oFloppy = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_Floppy, vboxcon.AccessMode_ReadOnly, False);
+ elif self.fpApiVer >= 4.0:
+ oFloppy = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_Floppy, vboxcon.AccessMode_ReadOnly);
+ else:
+ oFloppy = self.oVBox.openFloppyImage(sFullName, "");
+ except:
+ reporter.errorXcpt('failed to open floppy "%s"' % (sFullName));
+ return False;
+ ## @todo the following works but causes trouble below (asserts in main).
+ #try:
+ # oFloppy.type = vboxcon.MediumType_Immutable;
+ #except:
+ # reporter.errorXcpt('failed to make floppy "%s" immutable' % (sFullName));
+ # return False;
+
+ # Attach it.
+ fRc = True;
+ try:
+ if self.fpApiVer >= 4.0:
+ self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_Floppy, oFloppy);
+ else:
+ self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_Floppy, oFloppy.id);
+ except:
+ reporter.errorXcpt('attachDevice("%s",%s,%s,Floppy,"%s") failed on "%s"' \
+ % (sController, iPort, iDevice, oFloppy.id, self.sName) );
+ fRc = False;
+ else:
+ reporter.log('attached "%s" to %s' % (sFloppy, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ def setupNic(self, sType, sXXX):
+ """
+ Sets up a NIC to a VM.
+ Returns True on success and False on failure. Error information is logged.
+ """
+ if sType == "PCNet": enmType = vboxcon.NetworkAdapterType_Am79C973;
+ elif sType == "PCNetOld": enmType = vboxcon.NetworkAdapterType_Am79C970A;
+ elif sType == "E1000": enmType = vboxcon.NetworkAdapterType_I82545EM; # MT Server
+ elif sType == "E1000Desk": enmType = vboxcon.NetworkAdapterType_I82540EM; # MT Desktop
+ elif sType == "E1000Srv2": enmType = vboxcon.NetworkAdapterType_I82543GC; # T Server
+ elif sType == "Virtio": enmType = vboxcon.NetworkAdapterType_Virtio;
+ else:
+ reporter.error('Invalid NIC type: "%s" (sXXX=%s)' % (sType, sXXX));
+ return False;
+ ## @todo Implement me!
+ if enmType is not None: pass
+ return True;
+
+ def setupAudio(self, eAudioControllerType, fEnable = True, fEnableIn = False, fEnableOut = True, eAudioDriverType = None):
+ """
+ Sets up audio.
+
+ :param eAudioControllerType: The audio controller type (vboxcon.AudioControllerType_XXX).
+ :param fEnable: Whether to enable or disable the audio controller (default enable).
+ :param fEnableIn: Whether to enable or disable audio input (default disable).
+ :param fEnableOut: Whether to enable or disable audio output (default enable).
+ :param eAudioDriverType: The audio driver type (vboxcon.AudioDriverType_XXX), picks something suitable
+ if None is passed (default).
+ """
+ try:
+ if self.fpApiVer >= 7.0:
+ oAdapter = self.o.machine.audioSettings.adapter;
+ else:
+ oAdapter = self.o.machine.audioAdapter;
+ except: return reporter.errorXcpt('Failed to get the audio adapter.');
+
+ try: oAdapter.audioController = eAudioControllerType;
+ except: return reporter.errorXcpt('Failed to set the audio controller to %s.' % (eAudioControllerType,));
+
+ if eAudioDriverType is None:
+ sHost = utils.getHostOs()
+ if sHost == 'darwin': eAudioDriverType = vboxcon.AudioDriverType_CoreAudio;
+ elif sHost == 'win': eAudioDriverType = vboxcon.AudioDriverType_DirectSound;
+ elif sHost == 'linux': eAudioDriverType = vboxcon.AudioDriverType_Pulse;
+ elif sHost == 'solaris': eAudioDriverType = vboxcon.AudioDriverType_OSS;
+ else:
+ reporter.error('PORTME: Do not know which audio driver to pick for: %s!' % (sHost,));
+ eAudioDriverType = vboxcon.AudioDriverType_Null;
+
+ try: oAdapter.audioDriver = eAudioDriverType;
+ except: return reporter.errorXcpt('Failed to set the audio driver to %s.' % (eAudioDriverType,))
+
+ try: oAdapter.enabled = fEnable;
+ except: return reporter.errorXcpt('Failed to set the "enabled" property to %s.' % (fEnable,));
+
+ try: oAdapter.enabledIn = fEnableIn;
+ except: return reporter.errorXcpt('Failed to set the "enabledIn" property to %s.' % (fEnable,));
+
+ try: oAdapter.enabledOut = fEnableOut;
+ except: return reporter.errorXcpt('Failed to set the "enabledOut" property to %s.' % (fEnable,));
+
+ reporter.log('set audio adapter type to %d, driver to %d, and enabled to %s (input is %s, output is %s)'
+ % (eAudioControllerType, eAudioDriverType, fEnable, fEnableIn, fEnableOut,));
+ self.oTstDrv.processPendingEvents();
+ return True;
+
+ def setupPreferredConfig(self): # pylint: disable=too-many-locals
+ """
+ Configures the VM according to the preferences of the guest type.
+ """
+ try:
+ sOsTypeId = self.o.machine.OSTypeId;
+ except:
+ reporter.errorXcpt('failed to obtain the OSTypeId for "%s"' % (self.sName));
+ return False;
+
+ try:
+ oOsType = self.oVBox.getGuestOSType(sOsTypeId);
+ except:
+ reporter.errorXcpt('getGuestOSType("%s") failed for "%s"' % (sOsTypeId, self.sName));
+ return False;
+
+ # get the attributes.
+ try:
+ #sFamilyId = oOsType.familyId;
+ #f64Bit = oOsType.is64Bit;
+ fIoApic = oOsType.recommendedIOAPIC;
+ fVirtEx = oOsType.recommendedVirtEx;
+ cMBRam = oOsType.recommendedRAM;
+ cMBVRam = oOsType.recommendedVRAM;
+ #cMBHdd = oOsType.recommendedHDD;
+ eNicType = oOsType.adapterType;
+ if self.fpApiVer >= 3.2:
+ if self.fpApiVer >= 4.2:
+ fPae = oOsType.recommendedPAE;
+ fUsbHid = oOsType.recommendedUSBHID;
+ fHpet = oOsType.recommendedHPET;
+ eStorCtlType = oOsType.recommendedHDStorageController;
+ else:
+ fPae = oOsType.recommendedPae;
+ fUsbHid = oOsType.recommendedUsbHid;
+ fHpet = oOsType.recommendedHpet;
+ eStorCtlType = oOsType.recommendedHdStorageController;
+ eFirmwareType = oOsType.recommendedFirmware;
+ else:
+ fPae = False;
+ fUsbHid = False;
+ fHpet = False;
+ eFirmwareType = -1;
+ eStorCtlType = vboxcon.StorageControllerType_PIIX4;
+ if self.fpApiVer >= 4.0:
+ eAudioCtlType = oOsType.recommendedAudioController;
+ except:
+ reporter.errorXcpt('exception reading IGuestOSType(%s) attribute' % (sOsTypeId));
+ self.oTstDrv.processPendingEvents();
+ return False;
+ self.oTstDrv.processPendingEvents();
+
+ # Do the setting. Continue applying settings on error in case the
+ # caller ignores the return code
+ fRc = True;
+ if not self.enableIoApic(fIoApic): fRc = False;
+ if not self.enableVirtEx(fVirtEx): fRc = False;
+ if not self.enablePae(fPae): fRc = False;
+ if not self.setRamSize(cMBRam): fRc = False;
+ if not self.setVRamSize(cMBVRam): fRc = False;
+ if not self.setNicType(eNicType, 0): fRc = False;
+ if self.fpApiVer >= 3.2:
+ if not self.setFirmwareType(eFirmwareType): fRc = False;
+ if not self.enableUsbHid(fUsbHid): fRc = False;
+ if not self.enableHpet(fHpet): fRc = False;
+ if eStorCtlType in (vboxcon.StorageControllerType_PIIX3,
+ vboxcon.StorageControllerType_PIIX4,
+ vboxcon.StorageControllerType_ICH6,):
+ if not self.setStorageControllerType(eStorCtlType, "IDE Controller"):
+ fRc = False;
+ if self.fpApiVer >= 4.0:
+ if not self.setupAudio(eAudioCtlType): fRc = False;
+
+ return fRc;
+
+ def addUsbDeviceFilter(self, sName, sVendorId = None, sProductId = None, sRevision = None, # pylint: disable=too-many-arguments
+ sManufacturer = None, sProduct = None, sSerialNumber = None,
+ sPort = None, sRemote = None):
+ """
+ Creates a USB device filter and inserts it into the VM.
+ Returns True on success.
+ Returns False on failure (logged).
+ """
+ fRc = True;
+
+ try:
+ oUsbDevFilter = self.o.machine.USBDeviceFilters.createDeviceFilter(sName);
+ oUsbDevFilter.active = True;
+ if sVendorId is not None:
+ oUsbDevFilter.vendorId = sVendorId;
+ if sProductId is not None:
+ oUsbDevFilter.productId = sProductId;
+ if sRevision is not None:
+ oUsbDevFilter.revision = sRevision;
+ if sManufacturer is not None:
+ oUsbDevFilter.manufacturer = sManufacturer;
+ if sProduct is not None:
+ oUsbDevFilter.product = sProduct;
+ if sSerialNumber is not None:
+ oUsbDevFilter.serialnumber = sSerialNumber;
+ if sPort is not None:
+ oUsbDevFilter.port = sPort;
+ if sRemote is not None:
+ oUsbDevFilter.remote = sRemote;
+ try:
+ self.o.machine.USBDeviceFilters.insertDeviceFilter(0, oUsbDevFilter);
+ except:
+ reporter.errorXcpt('insertDeviceFilter(%s) failed on "%s"' \
+ % (0, self.sName) );
+ fRc = False;
+ else:
+ reporter.log('inserted USB device filter "%s" to %s' % (sName, self.sName));
+ except:
+ reporter.errorXcpt('createDeviceFilter("%s") failed on "%s"' \
+ % (sName, self.sName) );
+ fRc = False;
+ return fRc;
+
+ def getGuestPropertyValue(self, sName):
+ """
+ Gets a guest property value.
+ Returns the value on success, None on failure (logged).
+ """
+ try:
+ sValue = self.o.machine.getGuestPropertyValue(sName);
+ except:
+ reporter.errorXcpt('IMachine::getGuestPropertyValue("%s") failed' % (sName));
+ return None;
+ return sValue;
+
+ def setGuestPropertyValue(self, sName, sValue):
+ """
+ Sets a guest property value.
+ Returns the True on success, False on failure (logged).
+ """
+ try:
+ self.o.machine.setGuestPropertyValue(sName, sValue);
+ except:
+ reporter.errorXcpt('IMachine::setGuestPropertyValue("%s","%s") failed' % (sName, sValue));
+ return False;
+ return True;
+
+ def delGuestPropertyValue(self, sName):
+ """
+ Deletes a guest property value.
+ Returns the True on success, False on failure (logged).
+ """
+ try:
+ oMachine = self.o.machine;
+ if self.fpApiVer >= 4.2:
+ oMachine.deleteGuestProperty(sName);
+ else:
+ oMachine.setGuestPropertyValue(sName, '');
+ except:
+ reporter.errorXcpt('Unable to delete guest property "%s"' % (sName,));
+ return False;
+ return True;
+
+ def setExtraData(self, sKey, sValue):
+ """
+ Sets extra data.
+ Returns the True on success, False on failure (logged).
+ """
+ try:
+ self.o.machine.setExtraData(sKey, sValue);
+ except:
+ reporter.errorXcpt('IMachine::setExtraData("%s","%s") failed' % (sKey, sValue));
+ return False;
+ return True;
+
+ def getExtraData(self, sKey):
+ """
+ Gets extra data.
+ Returns value on success, None on failure.
+ """
+ try:
+ sValue = self.o.machine.getExtraData(sKey)
+ except:
+ reporter.errorXcpt('IMachine::setExtraData("%s","%s") failed' % (sKey, sValue))
+ return None
+ return sValue
+
+ def setupTeleporter(self, fEnabled=True, uPort = 6500, sAddress = '', sPassword = ''):
+ """
+ Sets up the teleporter for the VM.
+ Returns True on success, False on failure (logged).
+ """
+ try:
+ self.o.machine.teleporterAddress = sAddress;
+ self.o.machine.teleporterPort = uPort;
+ self.o.machine.teleporterPassword = sPassword;
+ self.o.machine.teleporterEnabled = fEnabled;
+ except:
+ reporter.errorXcpt('setupTeleporter(%s, %s, %s, %s)' % (fEnabled, sPassword, uPort, sAddress));
+ return False;
+ return True;
+
+ def enableTeleporter(self, fEnable=True):
+ """
+ Enables or disables the teleporter of the VM.
+ Returns True on success, False on failure (logged).
+ """
+ try:
+ self.o.machine.teleporterEnabled = fEnable;
+ except:
+ reporter.errorXcpt('IMachine::teleporterEnabled=%s failed' % (fEnable));
+ return False;
+ return True;
+
+ def teleport(self, sHostname = 'localhost', uPort = 6500, sPassword = 'password', cMsMaxDowntime = 250):
+ """
+ Wrapper around the IConsole::teleport() method.
+ Returns a progress object on success, None on failure (logged).
+ """
+ reporter.log2('"%s"::teleport(%s,%s,%s,%s)...' % (self.sName, sHostname, uPort, sPassword, cMsMaxDowntime));
+ try:
+ oProgress = self.o.console.teleport(sHostname, uPort, sPassword, cMsMaxDowntime)
+ except:
+ reporter.errorXcpt('IConsole::teleport(%s,%s,%s,%s) failed' % (sHostname, uPort, sPassword, cMsMaxDowntime));
+ return None;
+ return ProgressWrapper(oProgress, self.oVBoxMgr, self.oTstDrv, 'teleport %s' % (self.sName,));
+
+ def getOsType(self):
+ """
+ Gets the IGuestOSType interface for the machine.
+
+ return IGuestOSType interface on success, None + errorXcpt on failure.
+ No exceptions raised.
+ """
+ try:
+ sOsTypeId = self.o.machine.OSTypeId;
+ except:
+ reporter.errorXcpt('failed to obtain the OSTypeId for "%s"' % (self.sName));
+ return None;
+
+ try:
+ oOsType = self.oVBox.getGuestOSType(sOsTypeId);
+ except:
+ reporter.errorXcpt('getGuestOSType("%s") failed for "%s"' % (sOsTypeId, self.sName));
+ return None;
+
+ return oOsType;
+
+ def setOsType(self, sNewTypeId):
+ """
+ Changes the OS type.
+
+ returns True on success, False + errorXcpt on failure.
+ No exceptions raised.
+ """
+ try:
+ self.o.machine.OSTypeId = sNewTypeId;
+ except:
+ reporter.errorXcpt('failed to set the OSTypeId for "%s" to "%s"' % (self.sName, sNewTypeId));
+ return False;
+ return True;
+
+
+ def setParavirtProvider(self, iProvider):
+ """
+ Sets a paravirtualisation provider.
+ Returns the True on success, False on failure (logged).
+ """
+ try:
+ self.o.machine.paravirtProvider = iProvider
+ except:
+ reporter.errorXcpt('Unable to set paravirtualisation provider "%s"' % (iProvider,))
+ return False;
+ return True;
+
+
+ def setupSerialToRawFile(self, iSerialPort, sRawFile):
+ """
+ Enables the given serial port (zero based) and redirects it to sRawFile.
+ Returns the True on success, False on failure (logged).
+ """
+ try:
+ oPort = self.o.machine.getSerialPort(iSerialPort);
+ except:
+ fRc = reporter.errorXcpt('failed to get serial port #%u' % (iSerialPort,));
+ else:
+ try:
+ oPort.path = sRawFile;
+ except:
+ fRc = reporter.errorXcpt('failed to set the "path" property on serial port #%u to "%s"'
+ % (iSerialPort, sRawFile));
+ else:
+ try:
+ oPort.hostMode = vboxcon.PortMode_RawFile;
+ except:
+ fRc = reporter.errorXcpt('failed to set the "hostMode" property on serial port #%u to PortMode_RawFile'
+ % (iSerialPort,));
+ else:
+ try:
+ oPort.enabled = True;
+ except:
+ fRc = reporter.errorXcpt('failed to set the "enable" property on serial port #%u to True'
+ % (iSerialPort,));
+ else:
+ reporter.log('set SerialPort[%s].enabled/hostMode/path=True/RawFile/%s' % (iSerialPort, sRawFile,));
+ fRc = True;
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+
+ def enableSerialPort(self, iSerialPort):
+ """
+ Enables the given serial port setting the initial port mode to disconnected.
+ """
+ try:
+ oPort = self.o.machine.getSerialPort(iSerialPort);
+ except:
+ fRc = reporter.errorXcpt('failed to get serial port #%u' % (iSerialPort,));
+ else:
+ try:
+ oPort.hostMode = vboxcon.PortMode_Disconnected;
+ except:
+ fRc = reporter.errorXcpt('failed to set the "hostMode" property on serial port #%u to PortMode_Disconnected'
+ % (iSerialPort,));
+ else:
+ try:
+ oPort.enabled = True;
+ except:
+ fRc = reporter.errorXcpt('failed to set the "enable" property on serial port #%u to True'
+ % (iSerialPort,));
+ else:
+ reporter.log('set SerialPort[%s].enabled/hostMode/=True/Disconnected' % (iSerialPort,));
+ fRc = True;
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+
+ def changeSerialPortAttachment(self, iSerialPort, ePortMode, sPath, fServer):
+ """
+ Changes the attachment of the given serial port to the attachment config given.
+ """
+ try:
+ oPort = self.o.machine.getSerialPort(iSerialPort);
+ except:
+ fRc = reporter.errorXcpt('failed to get serial port #%u' % (iSerialPort,));
+ else:
+ try:
+ # Change port mode to disconnected first so changes get picked up by a potentially running VM.
+ oPort.hostMode = vboxcon.PortMode_Disconnected;
+ except:
+ fRc = reporter.errorXcpt('failed to set the "hostMode" property on serial port #%u to PortMode_Disconnected'
+ % (iSerialPort,));
+ else:
+ try:
+ oPort.path = sPath;
+ oPort.server = fServer;
+ oPort.hostMode = ePortMode;
+ except:
+ fRc = reporter.errorXcpt('failed to configure the serial port');
+ else:
+ reporter.log('set SerialPort[%s].hostMode/path/server=%s/%s/%s'
+ % (iSerialPort, ePortMode, sPath, fServer));
+ fRc = True;
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ #
+ # IConsole wrappers.
+ #
+
+ def powerOff(self, fFudgeOnFailure = True):
+ """
+ Powers off the VM.
+
+ Returns True on success.
+ Returns False on IConsole::powerDown() failure.
+ Returns None if the progress object returns failure.
+ """
+ #
+ # Deregister event handler before we power off the VM, otherwise we're
+ # racing for VM process termination and cause misleading spurious
+ # error messages in the event handling code, because the event objects
+ # disappear.
+ #
+ # Note! Doing this before powerDown to try prevent numerous smoketest
+ # timeouts on XPCOM hosts.
+ #
+ self.deregisterEventHandlerForTask();
+
+
+ # Try power if off.
+ try:
+ oProgress = self.o.console.powerDown();
+ except:
+ reporter.logXcpt('IConsole::powerDown failed on %s' % (self.sName));
+ if fFudgeOnFailure:
+ self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
+ self.waitForTask(1000); # fudge
+ return False;
+
+ # Wait on power off operation to complete.
+ rc = self.oTstDrv.waitOnProgress(oProgress);
+ if rc < 0:
+ self.close();
+ if fFudgeOnFailure:
+ vbox.reportError(oProgress, 'powerDown for "%s" failed' % (self.sName));
+ self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
+ return None;
+
+ # Wait for the VM to really power off or we'll fail to open a new session to it.
+ self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
+ return self.waitForTask(30 * 1000); # fudge
+
+ def saveState(self, fPause = True):
+ """
+ Saves state of the VM.
+
+ Returns True on success.
+ Returns False on IConsole::saveState() failure.
+ Returns None if the progress object returns Failure.
+ """
+
+ if fPause is True \
+ and self.oVM.state is vboxcon.MachineState_Running:
+ self.o.console.pause();
+ if self.oVM.state is not vboxcon.MachineState_Paused:
+ reporter.error('pause for "%s" failed' % (self.sName));
+ # Try saving state.
+ try:
+ if self.fpApiVer >= 5.0:
+ oProgress = self.o.machine.saveState()
+ else:
+ oProgress = self.o.console.saveState()
+ except:
+ reporter.logXcpt('IMachine::saveState failed on %s' % (self.sName));
+ return False;
+
+ # Wait for saving state operation to complete.
+ rc = self.oTstDrv.waitOnProgress(oProgress);
+ if rc < 0:
+ self.close();
+ return None;
+
+ # Wait for the VM to really terminate or we'll fail to open a new session to it.
+ self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
+ return self.waitForTask(30 * 1000); # fudge
+
+ def discardSavedState(self, fRemove = True):
+ """
+ Discards saved state of the VM.
+
+ Returns True on success.
+ Returns False on IConsole::discardSaveState() failure.
+ """
+
+ try:
+ if self.fpApiVer >= 5.0:
+ self.o.machine.discardSavedState(fRemove)
+ else:
+ self.o.console.discardSavedState(fRemove)
+ except:
+ reporter.logXcpt('IMachine::discardSavedState failed on %s' % (self.sName))
+ return False
+ return True
+
+ def restoreSnapshot(self, oSnapshot, fFudgeOnFailure = True):
+ """
+ Restores the given snapshot.
+
+ Returns True on success.
+ Returns False on IMachine::restoreSnapshot() failure.
+ Returns None if the progress object returns failure.
+ """
+ try:
+ if self.fpApiVer >= 5.0:
+ oProgress = self.o.machine.restoreSnapshot(oSnapshot);
+ else:
+ oProgress = self.o.console.restoreSnapshot(oSnapshot);
+ except:
+ reporter.logXcpt('IMachine::restoreSnapshot failed on %s' % (self.sName));
+ if fFudgeOnFailure:
+ self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
+ self.waitForTask(1000); # fudge
+ return False;
+
+ rc = self.oTstDrv.waitOnProgress(oProgress);
+ if rc < 0:
+ self.close();
+ if fFudgeOnFailure:
+ vbox.reportError(oProgress, 'restoreSnapshot for "%s" failed' % (self.sName));
+ return None;
+
+ return self.waitForTask(30 * 1000);
+
+ def deleteSnapshot(self, oSnapshot, fFudgeOnFailure = True, cMsTimeout = 30 * 1000):
+ """
+ Deletes the given snapshot merging the diff image into the base.
+
+ Returns True on success.
+ Returns False on IMachine::deleteSnapshot() failure.
+ """
+ try:
+ if self.fpApiVer >= 5.0:
+ oProgressCom = self.o.machine.deleteSnapshot(oSnapshot);
+ else:
+ oProgressCom = self.o.console.deleteSnapshot(oSnapshot);
+ oProgress = ProgressWrapper(oProgressCom, self.oVBoxMgr, self.oTstDrv, 'Delete Snapshot %s' % (oSnapshot));
+ oProgress.wait(cMsTimeout);
+ oProgress.logResult();
+ except:
+ reporter.logXcpt('IMachine::deleteSnapshot failed on %s' % (self.sName));
+ if fFudgeOnFailure:
+ self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
+ self.waitForTask(1000); # fudge
+ return False;
+
+ return True;
+
+ def takeSnapshot(self, sName, sDescription = '', fPause = True, fFudgeOnFailure = True, cMsTimeout = 30 * 1000):
+ """
+ Takes a snapshot with the given name
+
+ Returns True on success.
+ Returns False on IMachine::takeSnapshot() or VM state change failure.
+ """
+ try:
+ if fPause is True \
+ and self.oVM.state is vboxcon.MachineState_Running:
+ self.o.console.pause();
+ if self.fpApiVer >= 5.0:
+ (oProgressCom, _) = self.o.machine.takeSnapshot(sName, sDescription, True);
+ else:
+ oProgressCom = self.o.console.takeSnapshot(sName, sDescription);
+ oProgress = ProgressWrapper(oProgressCom, self.oVBoxMgr, self.oTstDrv, 'Take Snapshot %s' % (sName));
+ oProgress.wait(cMsTimeout);
+ oProgress.logResult();
+ except:
+ reporter.logXcpt('IMachine::takeSnapshot failed on %s' % (self.sName));
+ if fFudgeOnFailure:
+ self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
+ self.waitForTask(1000); # fudge
+ return False;
+
+ if fPause is True \
+ and self.oVM.state is vboxcon.MachineState_Paused:
+ self.o.console.resume();
+
+ return True;
+
+ def findSnapshot(self, sName):
+ """
+ Returns the snapshot object with the given name
+
+ Returns snapshot object on success.
+ Returns None if there is no snapshot with the given name.
+ """
+ return self.oVM.findSnapshot(sName);
+
+ def takeScreenshot(self, sFilename, iScreenId=0):
+ """
+ Take screenshot from the given display and save it to specified file.
+
+ Returns True on success
+ Returns False on failure.
+ """
+ try:
+ if self.fpApiVer >= 5.0:
+ iWidth, iHeight, _, _, _, _ = self.o.console.display.getScreenResolution(iScreenId)
+ aPngData = self.o.console.display.takeScreenShotToArray(iScreenId, iWidth, iHeight,
+ vboxcon.BitmapFormat_PNG)
+ else:
+ iWidth, iHeight, _, _, _ = self.o.console.display.getScreenResolution(iScreenId)
+ aPngData = self.o.console.display.takeScreenShotPNGToArray(iScreenId, iWidth, iHeight)
+ except:
+ reporter.logXcpt("Unable to take screenshot")
+ return False
+
+ with open(sFilename, 'wb') as oFile: # pylint: disable=unspecified-encoding
+ oFile.write(aPngData)
+
+ return True
+
+ def attachUsbDevice(self, sUuid, sCaptureFilename = None):
+ """
+ Attach given USB device UUID to the VM.
+
+ Returns True on success
+ Returns False on failure.
+ """
+ fRc = True;
+ try:
+ if sCaptureFilename is None:
+ self.o.console.attachUSBDevice(sUuid, '');
+ else:
+ self.o.console.attachUSBDevice(sUuid, sCaptureFilename);
+ except:
+ reporter.logXcpt('Unable to attach USB device %s' % (sUuid,));
+ fRc = False;
+
+ return fRc;
+
+ def detachUsbDevice(self, sUuid):
+ """
+ Detach given USB device UUID from the VM.
+
+ Returns True on success
+ Returns False on failure.
+ """
+ fRc = True;
+ try:
+ _ = self.o.console.detachUSBDevice(sUuid);
+ except:
+ reporter.logXcpt('Unable to detach USB device %s' % (sUuid,));
+ fRc = False;
+
+ return fRc;
+
+
+ #
+ # IMachineDebugger wrappers.
+ #
+
+ def queryOsKernelLog(self):
+ """
+ Tries to get the OS kernel log using the VM debugger interface.
+
+ Returns string containing the kernel log on success.
+ Returns None on failure.
+ """
+ sOsKernelLog = None;
+ try:
+ self.o.console.debugger.loadPlugIn('all');
+ except:
+ reporter.logXcpt('Unable to load debugger plugins');
+ else:
+ try:
+ sOsDetected = self.o.console.debugger.detectOS();
+ except:
+ reporter.logXcpt('Failed to detect the guest OS');
+ else:
+ try:
+ sOsKernelLog = self.o.console.debugger.queryOSKernelLog(0);
+ except:
+ reporter.logXcpt('Unable to get the guest OS (%s) kernel log' % (sOsDetected,));
+ return sOsKernelLog;
+
+ def queryDbgInfo(self, sItem, sArg = '', sDefault = None):
+ """
+ Simple wrapper around IMachineDebugger::info.
+
+ Returns string on success, sDefault on failure (logged).
+ """
+ try:
+ return self.o.console.debugger.info(sItem, sArg);
+ except:
+ reporter.logXcpt('Unable to query "%s" with arg "%s"' % (sItem, sArg,));
+ return sDefault;
+
+ def queryDbgInfoVgaText(self, sArg = 'all'):
+ """
+ Tries to get the 'info vgatext' output, provided we're in next mode.
+
+ Returns string containing text on success.
+ Returns None on failure or not text mode.
+ """
+ sVgaText = None;
+ try:
+ sVgaText = self.o.console.debugger.info('vgatext', sArg);
+ if sVgaText.startswith('Not in text mode!'):
+ sVgaText = None;
+ except:
+ reporter.logXcpt('Unable to query vgatext with arg "%s"' % (sArg,));
+ return sVgaText;
+
+ def queryDbgGuestStack(self, iCpu = 0):
+ """
+ Returns the guest stack for the given VCPU.
+
+ Returns string containing the guest stack for the selected VCPU on success.
+ Returns None on failure.
+ """
+
+ #
+ # Load all plugins first and try to detect the OS so we can
+ # get nicer stack traces.
+ #
+ try:
+ self.o.console.debugger.loadPlugIn('all');
+ except:
+ reporter.logXcpt('Unable to load debugger plugins');
+ else:
+ try:
+ sOsDetected = self.o.console.debugger.detectOS();
+ _ = sOsDetected;
+ except:
+ reporter.logXcpt('Failed to detect the guest OS');
+
+ sGuestStack = None;
+ try:
+ sGuestStack = self.o.console.debugger.dumpGuestStack(iCpu);
+ except:
+ reporter.logXcpt('Unable to query guest stack for CPU %s' % (iCpu, ));
+
+ return sGuestStack;
+
+
+ #
+ # Other methods.
+ #
+
+ def getPrimaryIp(self):
+ """
+ Tries to obtain the primary IP address of the guest via the guest
+ properties.
+
+ Returns IP address on success.
+ Returns empty string on failure.
+ """
+ sIpAddr = self.getGuestPropertyValue('/VirtualBox/GuestInfo/Net/0/V4/IP');
+ if vbox.isIpAddrValid(sIpAddr):
+ return sIpAddr;
+ return '';
+
+ def getPid(self):
+ """
+ Gets the process ID for the direct session unless it's ourselves.
+ """
+ if self.uPid is None and self.o is not None and self.fRemoteSession:
+ try:
+ if self.fpApiVer >= 4.2:
+ uPid = self.o.machine.sessionPID;
+ else:
+ uPid = self.o.machine.sessionPid;
+ if uPid != os.getpid() and uPid != 0xffffffff:
+ self.uPid = uPid;
+ except Exception as oXcpt:
+ if vbox.ComError.equal(oXcpt, vbox.ComError.E_UNEXPECTED):
+ try:
+ if self.fpApiVer >= 4.2:
+ uPid = self.oVM.sessionPID;
+ else:
+ uPid = self.oVM.sessionPid;
+ if uPid != os.getpid() and uPid != 0xffffffff:
+ self.uPid = uPid;
+ except:
+ reporter.log2Xcpt();
+ else:
+ reporter.log2Xcpt();
+ if self.uPid is not None:
+ reporter.log2('getPid: %u' % (self.uPid,));
+ self.fPidFile = self.oTstDrv.pidFileAdd(self.uPid, 'vm_%s' % (self.sName,), # Set-uid-to-root is similar to SUDO.
+ fSudo = True);
+ return self.uPid;
+
+ def addLogsToReport(self, cReleaseLogs = 1):
+ """
+ Retrieves and adds the release and debug logs to the test report.
+ """
+ fRc = True;
+
+ # Add each of the requested release logs to the report.
+ for iLog in range(0, cReleaseLogs):
+ try:
+ if self.fpApiVer >= 3.2:
+ sLogFile = self.oVM.queryLogFilename(iLog);
+ elif iLog > 0:
+ sLogFile = '%s/VBox.log' % (self.oVM.logFolder,);
+ else:
+ sLogFile = '%s/VBox.log.%u' % (self.oVM.logFolder, iLog);
+ except:
+ reporter.logXcpt('iLog=%s' % (iLog,));
+ fRc = False;
+ else:
+ if sLogFile is not None and sLogFile != '': # the None bit is for a 3.2.0 bug.
+ reporter.addLogFile(sLogFile, 'log/release/vm', '%s #%u' % (self.sName, iLog),
+ sAltName = '%s-%s' % (self.sName, os.path.basename(sLogFile),));
+
+ # Now for the hardened windows startup log.
+ try:
+ sLogFile = os.path.join(self.oVM.logFolder, 'VBoxHardening.log');
+ except:
+ reporter.logXcpt();
+ fRc = False;
+ else:
+ if os.path.isfile(sLogFile):
+ reporter.addLogFile(sLogFile, 'log/release/vm', '%s hardening log' % (self.sName, ),
+ sAltName = '%s-%s' % (self.sName, os.path.basename(sLogFile),));
+
+ # Now for the debug log.
+ if self.sLogFile is not None and os.path.isfile(self.sLogFile):
+ reporter.addLogFile(self.sLogFile, 'log/debug/vm', '%s debug' % (self.sName, ),
+ sAltName = '%s-%s' % (self.sName, os.path.basename(self.sLogFile),));
+
+ return fRc;
+
+ def registerDerivedEventHandler(self, oSubClass, dArgs = None, fMustSucceed = True):
+ """
+ Create an instance of the given ConsoleEventHandlerBase sub-class and
+ register it.
+
+ The new instance is returned on success. None is returned on error.
+ """
+
+ # We need a console object.
+ try:
+ oConsole = self.o.console;
+ except Exception as oXcpt:
+ if fMustSucceed or vbox.ComError.notEqual(oXcpt, vbox.ComError.E_UNEXPECTED):
+ reporter.errorXcpt('Failed to get ISession::console for "%s"' % (self.sName, ));
+ return None;
+
+ # Add the base class arguments.
+ dArgsCopy = dArgs.copy() if dArgs is not None else {};
+ dArgsCopy['oSession'] = self;
+ dArgsCopy['oConsole'] = oConsole;
+ sLogSuffix = 'on %s' % (self.sName,)
+ return oSubClass.registerDerivedEventHandler(self.oVBoxMgr, self.fpApiVer, oSubClass, dArgsCopy,
+ oConsole, 'IConsole', 'IConsoleCallback',
+ fMustSucceed = fMustSucceed, sLogSuffix = sLogSuffix);
+
+ def enableVmmDevTestingPart(self, fEnabled, fEnableMMIO = False):
+ """
+ Enables the testing part of the VMMDev.
+
+ Returns True on success and False on failure. Error information is logged.
+ """
+ fRc = True;
+ try:
+ self.o.machine.setExtraData('VBoxInternal/Devices/VMMDev/0/Config/TestingEnabled',
+ '1' if fEnabled else '');
+ self.o.machine.setExtraData('VBoxInternal/Devices/VMMDev/0/Config/TestingMMIO',
+ '1' if fEnableMMIO and fEnabled else '');
+ except:
+ reporter.errorXcpt('VM name "%s", fEnabled=%s' % (self.sName, fEnabled));
+ fRc = False;
+ else:
+ reporter.log('set VMMDevTesting=%s for "%s"' % (fEnabled, self.sName));
+ self.oTstDrv.processPendingEvents();
+ return fRc;
+
+ #
+ # Test eXecution Service methods.
+ #
+
+ def txsConnectViaTcp(self, cMsTimeout = 10*60000, sIpAddr = None, fNatForwardingForTxs = False):
+ """
+ Connects to the TXS using TCP/IP as transport. If no IP or MAC is
+ addresses are specified, we'll get the IP from the guest additions.
+
+ Returns a TxsConnectTask object on success, None + log on failure.
+ """
+ # If the VM is configured with a NAT interface, connect to local host.
+ fReversedSetup = False;
+ fUseNatForTxs = False;
+ sMacAddr = None;
+ oIDhcpServer = None;
+ if sIpAddr is None:
+ try:
+ oNic = self.oVM.getNetworkAdapter(0);
+ enmAttachmentType = oNic.attachmentType;
+ if enmAttachmentType == vboxcon.NetworkAttachmentType_NAT:
+ fUseNatForTxs = True;
+ elif enmAttachmentType == vboxcon.NetworkAttachmentType_HostOnly and not sIpAddr:
+ # Get the MAC address and find the DHCP server.
+ sMacAddr = oNic.MACAddress;
+ sHostOnlyNIC = oNic.hostOnlyInterface;
+ oIHostOnlyIf = self.oVBox.host.findHostNetworkInterfaceByName(sHostOnlyNIC);
+ sHostOnlyNet = oIHostOnlyIf.networkName;
+ oIDhcpServer = self.oVBox.findDHCPServerByNetworkName(sHostOnlyNet);
+ except:
+ reporter.errorXcpt();
+ return None;
+
+ if fUseNatForTxs:
+ fReversedSetup = not fNatForwardingForTxs;
+ sIpAddr = '127.0.0.1';
+
+ # Kick off the task.
+ try:
+ oTask = TxsConnectTask(self, cMsTimeout, sIpAddr, sMacAddr, oIDhcpServer, fReversedSetup,
+ fnProcessEvents = self.oTstDrv.processPendingEvents);
+ except:
+ reporter.errorXcpt();
+ oTask = None;
+ return oTask;
+
+ def txsTryConnectViaTcp(self, cMsTimeout, sHostname, fReversed = False):
+ """
+ Attempts to connect to a TXS instance.
+
+ Returns True if a connection was established, False if not (only grave
+ failures are logged as errors).
+
+ Note! The timeout is more of a guideline...
+ """
+
+ if sHostname is None or sHostname.strip() == '':
+ raise base.GenError('Empty sHostname is not implemented yet');
+
+ oTxsSession = txsclient.tryOpenTcpSession(cMsTimeout, sHostname, fReversedSetup = fReversed,
+ cMsIdleFudge = cMsTimeout // 2,
+ fnProcessEvents = self.oTstDrv.processPendingEvents);
+ if oTxsSession is None:
+ return False;
+
+ # Wait for the connect task to time out.
+ self.oTstDrv.addTask(oTxsSession);
+ self.oTstDrv.processPendingEvents();
+ oRc = self.oTstDrv.waitForTasks(cMsTimeout);
+ self.oTstDrv.removeTask(oTxsSession);
+ if oRc != oTxsSession:
+ if oRc is not None:
+ reporter.log('oRc=%s, expected %s' % (oRc, oTxsSession));
+ self.oTstDrv.processPendingEvents();
+ oTxsSession.cancelTask(); # this is synchronous
+ return False;
+
+ # Check the status.
+ reporter.log2('TxsSession is ready, isSuccess() -> %s.' % (oTxsSession.isSuccess(),));
+ if not oTxsSession.isSuccess():
+ return False;
+
+ reporter.log2('Disconnecting from TXS...');
+ return oTxsSession.syncDisconnect();
+
+
+
+class TxsConnectTask(TdTaskBase):
+ """
+ Class that takes care of connecting to a VM.
+ """
+
+ class TxsConnectTaskVBoxCallback(vbox.VirtualBoxEventHandlerBase):
+ """ Class for looking for IPv4 address changes on interface 0."""
+ def __init__(self, dArgs):
+ vbox.VirtualBoxEventHandlerBase.__init__(self, dArgs);
+ self.oParentTask = dArgs['oParentTask'];
+ self.sMachineId = dArgs['sMachineId'];
+
+ def onGuestPropertyChange(self, sMachineId, sName, sValue, sFlags, fWasDeleted):
+ """Look for IP address."""
+ reporter.log2('onGuestPropertyChange(,%s,%s,%s,%s,%s)' % (sMachineId, sName, sValue, sFlags, fWasDeleted));
+ if sMachineId == self.sMachineId \
+ and sName == '/VirtualBox/GuestInfo/Net/0/V4/IP':
+ oParentTask = self.oParentTask;
+ if oParentTask:
+ oParentTask._setIp(sValue); # pylint: disable=protected-access
+
+
+ def __init__(self, oSession, cMsTimeout, sIpAddr, sMacAddr, oIDhcpServer, fReversedSetup, fnProcessEvents = None):
+ TdTaskBase.__init__(self, utils.getCallerName(), fnProcessEvents = fnProcessEvents);
+ self.cMsTimeout = cMsTimeout;
+ self.fnProcessEvents = fnProcessEvents;
+ self.sIpAddr = None;
+ self.sNextIpAddr = None;
+ self.sMacAddr = sMacAddr;
+ self.oIDhcpServer = oIDhcpServer;
+ self.fReversedSetup = fReversedSetup;
+ self.oVBoxEventHandler = None;
+ self.oTxsSession = None;
+
+ # Check that the input makes sense:
+ if (sMacAddr is None) != (oIDhcpServer is None) \
+ or (sMacAddr and fReversedSetup) \
+ or (sMacAddr and sIpAddr):
+ reporter.error('TxsConnectTask sMacAddr=%s oIDhcpServer=%s sIpAddr=%s fReversedSetup=%s'
+ % (sMacAddr, oIDhcpServer, sIpAddr, fReversedSetup,));
+ raise base.GenError();
+
+ reporter.log2('TxsConnectTask: sIpAddr=%s fReversedSetup=%s' % (sIpAddr, fReversedSetup))
+ if fReversedSetup is True:
+ self._openTcpSession(sIpAddr, fReversedSetup = True);
+ elif sIpAddr is not None and sIpAddr.strip() != '':
+ self._openTcpSession(sIpAddr, cMsIdleFudge = 5000);
+ else:
+ #
+ # If we've got no IP address, register callbacks that listens for
+ # the primary network adaptor of the VM to set a IPv4 guest prop.
+ # Note! The order in which things are done here is kind of important.
+ #
+
+ # 0. The caller zaps the property before starting the VM.
+ #try:
+ # oSession.delGuestPropertyValue('/VirtualBox/GuestInfo/Net/0/V4/IP');
+ #except:
+ # reporter.logXcpt();
+
+ # 1. Register the callback / event listener object.
+ dArgs = {'oParentTask':self, 'sMachineId':oSession.o.machine.id};
+ self.oVBoxEventHandler = oSession.oVBox.registerDerivedEventHandler(self.TxsConnectTaskVBoxCallback, dArgs);
+
+ # 2. Query the guest properties.
+ try:
+ sIpAddr = oSession.getGuestPropertyValue('/VirtualBox/GuestInfo/Net/0/V4/IP');
+ except:
+ reporter.errorXcpt('IMachine::getGuestPropertyValue("/VirtualBox/GuestInfo/Net/0/V4/IP") failed');
+ self._deregisterEventHandler();
+ raise;
+ else:
+ if sIpAddr is not None:
+ self._setIp(sIpAddr);
+
+ #
+ # If the network adapter of the VM is host-only we can talk poll IDHCPServer
+ # for the guest IP, allowing us to detect it for VMs without guest additions.
+ # This will when we're polled.
+ #
+ if sMacAddr is not None:
+ assert self.oIDhcpServer is not None;
+
+
+ # end __init__
+
+ def __del__(self):
+ """ Make sure we deregister the callback. """
+ self._deregisterEventHandler();
+ return TdTaskBase.__del__(self);
+
+ def toString(self):
+ return '<%s cMsTimeout=%s, sIpAddr=%s, sNextIpAddr=%s, sMacAddr=%s, fReversedSetup=%s,' \
+ ' oTxsSession=%s oVBoxEventHandler=%s>' \
+ % (TdTaskBase.toString(self), self.cMsTimeout, self.sIpAddr, self.sNextIpAddr, self.sMacAddr, self.fReversedSetup,
+ self.oTxsSession, self.oVBoxEventHandler);
+
+ def _deregisterEventHandler(self):
+ """Deregisters the event handler."""
+ fRc = True;
+ oVBoxEventHandler = self.oVBoxEventHandler;
+ if oVBoxEventHandler is not None:
+ self.oVBoxEventHandler = None;
+ fRc = oVBoxEventHandler.unregister();
+ oVBoxEventHandler.oParentTask = None; # Try avoid cylic deps.
+ return fRc;
+
+ def _setIp(self, sIpAddr, fInitCall = False):
+ """Called when we get an IP. Will create a TXS session and signal the task."""
+ sIpAddr = sIpAddr.strip();
+
+ if sIpAddr is not None \
+ and sIpAddr != '':
+ if vbox.isIpAddrValid(sIpAddr) or fInitCall:
+ try:
+ for s in sIpAddr.split('.'):
+ i = int(s);
+ if str(i) != s:
+ raise Exception();
+ except:
+ reporter.fatalXcpt();
+ else:
+ reporter.log('TxsConnectTask: opening session to ip "%s"' % (sIpAddr));
+ self._openTcpSession(sIpAddr, cMsIdleFudge = 5000);
+ return None;
+
+ reporter.log('TxsConnectTask: Ignoring Bad ip "%s"' % (sIpAddr));
+ else:
+ reporter.log2('TxsConnectTask: Ignoring empty ip "%s"' % (sIpAddr));
+ return None;
+
+ def _openTcpSession(self, sIpAddr, uPort = None, fReversedSetup = False, cMsIdleFudge = 0):
+ """
+ Calls txsclient.openTcpSession and switches our task to reflect the
+ state of the subtask.
+ """
+ self.oCv.acquire();
+ if self.oTxsSession is None:
+ reporter.log2('_openTcpSession: sIpAddr=%s, uPort=%d, fReversedSetup=%s' %
+ (sIpAddr, uPort if uPort is not None else 0, fReversedSetup));
+ self.sIpAddr = sIpAddr;
+ self.oTxsSession = txsclient.openTcpSession(self.cMsTimeout, sIpAddr, uPort, fReversedSetup,
+ cMsIdleFudge, fnProcessEvents = self.fnProcessEvents);
+ self.oTxsSession.setTaskOwner(self);
+ else:
+ self.sNextIpAddr = sIpAddr;
+ reporter.log2('_openTcpSession: sNextIpAddr=%s' % (sIpAddr,));
+ self.oCv.release();
+ return None;
+
+ def notifyAboutReadyTask(self, oTxsSession):
+ """
+ Called by the TXS session task when it's done.
+
+ We'll signal the task completed or retry depending on the result.
+ """
+
+ self.oCv.acquire();
+
+ # Disassociate ourselves with the session (avoid cyclic ref)
+ oTxsSession.setTaskOwner(None);
+ fSuccess = oTxsSession.isSuccess();
+ if self.oTxsSession is not None:
+ if not fSuccess:
+ self.oTxsSession = None;
+ if fSuccess and self.fReversedSetup:
+ self.sIpAddr = oTxsSession.oTransport.sHostname;
+ else:
+ fSuccess = False;
+
+ # Signal done, or retry?
+ fDeregister = False;
+ if fSuccess \
+ or self.fReversedSetup \
+ or self.getAgeAsMs() >= self.cMsTimeout:
+ self.signalTaskLocked();
+ fDeregister = True;
+ else:
+ sIpAddr = self.sNextIpAddr if self.sNextIpAddr is not None else self.sIpAddr;
+ self._openTcpSession(sIpAddr, cMsIdleFudge = 5000);
+
+ self.oCv.release();
+
+ # If we're done, deregister the callback (w/o owning lock). It will
+ if fDeregister:
+ self._deregisterEventHandler();
+ return True;
+
+ def _pollDhcpServer(self):
+ """
+ Polls the DHCP server by MAC address in host-only setups.
+ """
+
+ if self.sIpAddr:
+ return False;
+
+ if self.oIDhcpServer is None or not self.sMacAddr:
+ return False;
+
+ try:
+ (sIpAddr, sState, secIssued, secExpire) = self.oIDhcpServer.findLeaseByMAC(self.sMacAddr, 0);
+ except:
+ reporter.log4Xcpt('sMacAddr=%s' % (self.sMacAddr,));
+ return False;
+
+ secNow = utils.secondsSinceUnixEpoch();
+ reporter.log2('dhcp poll: secNow=%s secExpire=%s secIssued=%s sState=%s sIpAddr=%s'
+ % (secNow, secExpire, secIssued, sState, sIpAddr,));
+ if secNow > secExpire or sState != 'acked' or not sIpAddr:
+ return False;
+
+ reporter.log('dhcp poll: sIpAddr=%s secExpire=%s (%s TTL) secIssued=%s (%s ago)'
+ % (sIpAddr, secExpire, secExpire - secNow, secIssued, secNow - secIssued,));
+ self._setIp(sIpAddr);
+ return True;
+
+ #
+ # Task methods
+ #
+
+ def pollTask(self, fLocked = False):
+ """
+ Overridden pollTask method.
+ """
+ self._pollDhcpServer();
+ return TdTaskBase.pollTask(self, fLocked);
+
+ #
+ # Public methods
+ #
+
+ def getResult(self):
+ """
+ Returns the connected TXS session object on success.
+ Returns None on failure or if the task has not yet completed.
+ """
+ self.oCv.acquire();
+ oTxsSession = self.oTxsSession;
+ self.oCv.release();
+
+ if oTxsSession is not None and not oTxsSession.isSuccess():
+ oTxsSession = None;
+ return oTxsSession;
+
+ def cancelTask(self):
+ """ Cancels the task. """
+ self._deregisterEventHandler(); # (make sure to avoid cyclic fun)
+ self.oCv.acquire();
+ if not self.fSignalled:
+ oTxsSession = self.oTxsSession;
+ if oTxsSession is not None:
+ self.oCv.release();
+ oTxsSession.setTaskOwner(None);
+ oTxsSession.cancelTask();
+ oTxsSession.waitForTask(1000);
+ self.oCv.acquire();
+ self.signalTaskLocked();
+ self.oCv.release();
+ return True;
+
+
+
+class AdditionsStatusTask(TdTaskBase):
+ """
+ Class that takes care of waiting till the guest additions are in a given state.
+ """
+
+ class AdditionsStatusTaskCallback(vbox.EventHandlerBase):
+ """ Class for looking for IPv4 address changes on interface 0."""
+ def __init__(self, dArgs):
+ self.oParentTask = dArgs['oParentTask'];
+ vbox.EventHandlerBase.__init__(self, dArgs, self.oParentTask.oSession.fpApiVer,
+ 'AdditionsStatusTaskCallback/%s' % (self.oParentTask.oSession.sName,));
+
+ def handleEvent(self, oEvt):
+ try:
+ enmType = oEvt.type;
+ except:
+ reporter.errorXcpt();
+ else:
+ reporter.log2('AdditionsStatusTaskCallback:handleEvent: enmType=%s' % (enmType,));
+ if enmType == vboxcon.VBoxEventType_OnGuestAdditionsStatusChanged:
+ oParentTask = self.oParentTask;
+ if oParentTask:
+ oParentTask.pollTask();
+
+ # end
+
+
+ def __init__(self, oSession, oIGuest, cMsTimeout = 120000, aenmWaitForRunLevels = None, aenmWaitForActive = None,
+ aenmWaitForInactive = None):
+ """
+ aenmWaitForRunLevels - List of run level values to wait for (success if one matches).
+ aenmWaitForActive - List facilities (type values) that must be active.
+ aenmWaitForInactive - List facilities (type values) that must be inactive.
+
+ The default is to wait for AdditionsRunLevelType_Userland if all three lists
+ are unspecified or empty.
+ """
+ TdTaskBase.__init__(self, utils.getCallerName());
+ self.oSession = oSession # type: vboxwrappers.SessionWrapper
+ self.oIGuest = oIGuest;
+ self.cMsTimeout = cMsTimeout;
+ self.fSucceeded = False;
+ self.oVBoxEventHandler = None;
+ self.aenmWaitForRunLevels = aenmWaitForRunLevels if aenmWaitForRunLevels else [];
+ self.aenmWaitForActive = aenmWaitForActive if aenmWaitForActive else [];
+ self.aenmWaitForInactive = aenmWaitForInactive if aenmWaitForInactive else [];
+
+ # Provide a sensible default if nothing is given.
+ if not self.aenmWaitForRunLevels and not self.aenmWaitForActive and not self.aenmWaitForInactive:
+ self.aenmWaitForRunLevels = [vboxcon.AdditionsRunLevelType_Userland,];
+
+ # Register the event handler on hosts which has it:
+ if oSession.fpApiVer >= 6.1 or hasattr(vboxcon, 'VBoxEventType_OnGuestAdditionsStatusChanged'):
+ aenmEvents = (vboxcon.VBoxEventType_OnGuestAdditionsStatusChanged,);
+ dArgs = {
+ 'oParentTask': self,
+ };
+ self.oVBoxEventHandler = vbox.EventHandlerBase.registerDerivedEventHandler(oSession.oVBoxMgr,
+ oSession.fpApiVer,
+ self.AdditionsStatusTaskCallback,
+ dArgs,
+ oIGuest,
+ 'IGuest',
+ 'AdditionsStatusTaskCallback',
+ aenmEvents = aenmEvents);
+ reporter.log2('AdditionsStatusTask: %s' % (self.toString(), ));
+
+ def __del__(self):
+ """ Make sure we deregister the callback. """
+ self._deregisterEventHandler();
+ self.oIGuest = None;
+ return TdTaskBase.__del__(self);
+
+ def toString(self):
+ return '<%s cMsTimeout=%s, fSucceeded=%s, aenmWaitForRunLevels=%s, aenmWaitForActive=%s, aenmWaitForInactive=%s, ' \
+ 'oVBoxEventHandler=%s>' \
+ % (TdTaskBase.toString(self), self.cMsTimeout, self.fSucceeded, self.aenmWaitForRunLevels, self.aenmWaitForActive,
+ self.aenmWaitForInactive, self.oVBoxEventHandler,);
+
+ def _deregisterEventHandler(self):
+ """Deregisters the event handler."""
+ fRc = True;
+ oVBoxEventHandler = self.oVBoxEventHandler;
+ if oVBoxEventHandler is not None:
+ self.oVBoxEventHandler = None;
+ fRc = oVBoxEventHandler.unregister();
+ oVBoxEventHandler.oParentTask = None; # Try avoid cylic deps.
+ return fRc;
+
+ def _poll(self):
+ """
+ Internal worker for pollTask() that returns the new signalled state.
+ """
+
+ #
+ # Check if any of the runlevels we wait for have been reached:
+ #
+ if self.aenmWaitForRunLevels:
+ try:
+ enmRunLevel = self.oIGuest.additionsRunLevel;
+ except:
+ reporter.errorXcpt();
+ return True;
+ if enmRunLevel not in self.aenmWaitForRunLevels:
+ reporter.log6('AdditionsStatusTask/poll: enmRunLevel=%s not in %s' % (enmRunLevel, self.aenmWaitForRunLevels,));
+ return False;
+ reporter.log2('AdditionsStatusTask/poll: enmRunLevel=%s matched %s!' % (enmRunLevel, self.aenmWaitForRunLevels,));
+
+
+ #
+ # Check for the facilities that must all be active.
+ #
+ for enmFacility in self.aenmWaitForActive:
+ try:
+ (enmStatus, _) = self.oIGuest.getFacilityStatus(enmFacility);
+ except:
+ reporter.errorXcpt('enmFacility=%s' % (enmFacility,));
+ return True;
+ if enmStatus != vboxcon.AdditionsFacilityStatus_Active:
+ reporter.log2('AdditionsStatusTask/poll: enmFacility=%s not active: %s' % (enmFacility, enmStatus,));
+ return False;
+
+ #
+ # Check for the facilities that must all be inactive or terminated.
+ #
+ for enmFacility in self.aenmWaitForInactive:
+ try:
+ (enmStatus, _) = self.oIGuest.getFacilityStatus(enmFacility);
+ except:
+ reporter.errorXcpt('enmFacility=%s' % (enmFacility,));
+ return True;
+ if enmStatus not in (vboxcon.AdditionsFacilityStatus_Inactive,
+ vboxcon.AdditionsFacilityStatus_Terminated):
+ reporter.log2('AdditionsStatusTask/poll: enmFacility=%s not inactive: %s' % (enmFacility, enmStatus,));
+ return False;
+
+
+ reporter.log('AdditionsStatusTask: Poll succeeded, signalling...');
+ self.fSucceeded = True;
+ return True;
+
+
+ #
+ # Task methods
+ #
+
+ def pollTask(self, fLocked = False):
+ """
+ Overridden pollTask method.
+ """
+ if not fLocked:
+ self.lockTask();
+
+ fDeregister = False;
+ fRc = self.fSignalled;
+ if not fRc:
+ fRc = self._poll();
+ if fRc or self.getAgeAsMs() >= self.cMsTimeout:
+ self.signalTaskLocked();
+ fDeregister = True;
+
+ if not fLocked:
+ self.unlockTask();
+
+ # If we're done, deregister the event callback (w/o owning lock).
+ if fDeregister:
+ self._deregisterEventHandler();
+ return fRc;
+
+ def getResult(self):
+ """
+ Returns true if the we succeeded.
+ Returns false if not. If the task is signalled already, then we
+ encountered a problem while polling.
+ """
+ return self.fSucceeded;
+
+ def cancelTask(self):
+ """
+ Cancels the task.
+ Just to actively disengage the event handler.
+ """
+ self._deregisterEventHandler();
+ return True;
+
diff --git a/src/VBox/ValidationKit/testdriver/win-vbox-net-drvstore-cleanup.ps1 b/src/VBox/ValidationKit/testdriver/win-vbox-net-drvstore-cleanup.ps1
new file mode 100644
index 00000000..aca5d547
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/win-vbox-net-drvstore-cleanup.ps1
@@ -0,0 +1,71 @@
+# $Id: win-vbox-net-drvstore-cleanup.ps1 $
+## @file
+# VirtualBox Validation Kit - network cleanup script (powershell).
+#
+
+#
+# Copyright (C) 2006-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
+#
+
+param([switch]$confirm)
+
+Function AskForConfirmation ($title_text, $message_text, $yes_text, $no_text)
+{
+ if ($confirm) {
+ $title = $title_text
+ $message = $message_text
+
+ $yes = New-Object System.Management.Automation.Host.ChoiceDescription "&Yes", $yes_text
+
+ $no = New-Object System.Management.Automation.Host.ChoiceDescription "&No", $no_text
+
+ $options = [System.Management.Automation.Host.ChoiceDescription[]]($yes, $no)
+
+ $result = $host.ui.PromptForChoice($title, $message, $options, 0)
+ } else {
+ $result = 0
+ }
+
+ return $result
+}
+
+pnputil -e | ForEach-Object { if ($_ -match "Published name :.*(oem\d+\.inf)") {$inf=$matches[1]} elseif ($_ -match "Driver package provider :.*Oracle") {$inf + " " + $_} }
+
+$result = AskForConfirmation "Clean up the driver store" `
+ "Do you want to delete all VirtualBox drivers from the driver store?" `
+ "Deletes all VirtualBox drivers from the driver store." `
+ "No modifications to the driver store will be made."
+
+switch ($result)
+ {
+ 0 {pnputil -e | ForEach-Object { if ($_ -match "Published name :.*(oem\d+\.inf)") {$inf=$matches[1]} elseif ($_ -match "Driver package provider :.*Oracle") {$inf} } | ForEach-Object { pnputil -d $inf } }
+ 1 {"Removal cancelled."}
+ }
+
diff --git a/src/VBox/ValidationKit/testdriver/win-vbox-net-uninstall.ps1 b/src/VBox/ValidationKit/testdriver/win-vbox-net-uninstall.ps1
new file mode 100644
index 00000000..f03a842e
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/win-vbox-net-uninstall.ps1
@@ -0,0 +1,253 @@
+# $Id: win-vbox-net-uninstall.ps1 $
+## @file
+# VirtualBox Validation Kit - network cleanup script (powershell).
+#
+
+#
+# Copyright (C) 2006-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
+#
+
+param([switch]$confirm)
+
+Function AskForConfirmation ($title_text, $message_text, $yes_text, $no_text)
+{
+ if ($confirm) {
+ $title = $title_text
+ $message = $message_text
+
+ $yes = New-Object System.Management.Automation.Host.ChoiceDescription "&Yes", $yes_text
+
+ $no = New-Object System.Management.Automation.Host.ChoiceDescription "&No", $no_text
+
+ $options = [System.Management.Automation.Host.ChoiceDescription[]]($yes, $no)
+
+ $result = $host.ui.PromptForChoice($title, $message, $options, 0)
+ } else {
+ $result = 0
+ }
+
+ return $result
+}
+
+Function DeleteUnmatchingKeys ($title_text, $reg_key)
+{
+ $ghostcon = @(Get-ChildItem ($reg_key) | Where-Object { !$connections.ContainsKey($_.PSChildName) } )
+ if ($ghostcon.count -eq 0) {
+ Write-Host "`nNo ghost connections has been found -- nothing to do"
+ } else {
+ Write-Host "`nParameter keys for the following connections will be removed:"
+ Write-Host ($ghostcon | Out-String)
+
+ $result = AskForConfirmation $title_text `
+ "Do you want to delete the keys listed above?" `
+ "Deletes all ghost connection keys from the registry." `
+ "No modifications to the registry will be made."
+
+ switch ($result)
+ {
+ 0 {$ghostcon.GetEnumerator() | ForEach-Object { Remove-Item -Path $_ -Recurse }}
+ 1 {"Removal cancelled."}
+ }
+ }
+}
+
+
+Push-Location
+cd "Registry::"
+Write-Host "Retrieving valid connections:"
+$iftypes = @{}
+$connections = @{}
+$ghostcon_names = @{}
+Get-Item ".\HKLM\SYSTEM\CurrentControlSet\Control\Class\{4D36E972-E325-11CE-BFC1-08002BE10318}\0*" | `
+ ForEach-Object {
+ $prop = (Get-ItemProperty $_.PSPath)
+ $conn = $null
+ if (Test-Path ("HKLM\SYSTEM\CurrentControlSet\Control\Network\{4D36E972-E325-11CE-BFC1-08002BE10318}\" + $prop.NetCfgInstanceId + "\Connection")) {
+ $conn = (Get-ItemProperty ("HKLM\SYSTEM\CurrentControlSet\Control\Network\{4D36E972-E325-11CE-BFC1-08002BE10318}\" + $prop.NetCfgInstanceId + "\Connection"))
+ }
+ $iftype = $prop."*IfType"
+ if ($iftypes.ContainsKey($iftype)) {
+ $iftypes[$iftype] = $iftypes[$iftype] + [Math]::pow(2,$prop.NetLuidIndex)
+ } else {
+ $iftypes[$iftype] = [Math]::pow(2,$prop.NetLuidIndex)
+ }
+ if ($conn -ne $null) {
+ $connections[$prop.NetCfgInstanceId] = $conn.Name
+ Write-Host $prop.NetCfgInstanceId $conn.Name "|" $prop."*IfType" $prop.NetLuidIndex $prop.DriverDesc
+ } else {
+ Write-Host $prop.NetCfgInstanceId [MISSING] "|" $prop."*IfType" $prop.NetLuidIndex $prop.DriverDesc
+ }
+ }
+
+# Someday we may want to process other types than Ethernet as well: $iftypes.GetEnumerator() | ForEach-Object {
+if ($iftypes[6] -gt 9223372036854775808) {
+ Write-Host "Found more than 63 interfaces (mask=" $iftypes[6] ") -- bailing out"
+ exit
+}
+Write-Host "`nChecking if the used LUID index mask is correct:"
+$correctmask = [BitConverter]::GetBytes([int64]($iftypes[6]))
+$actualmask = (Get-ItemProperty -Path "HKLM\SYSTEM\CurrentControlSet\Services\NDIS\IfTypes\6" -Name "IfUsedNetLuidIndices").IfUsedNetLuidIndices
+$needcorrection = $FALSE
+$ai = 0
+$lastnonzero = 0
+for ($ci = 0; $ci -lt $correctmask.Length; $ci++) {
+ if ($ai -lt $actualmask.Length) {
+ $aval = $actualmask[$ai++]
+ } else {
+ $aval = 0
+ }
+ if ($correctmask[$ci] -ne 0) {
+ $lastnonzero = $ci
+ }
+ if ($correctmask[$ci] -eq $aval) {
+ Write-Host "DEBUG: " $correctmask[$ci].ToString("X2") " == " $aval.ToString("X2")
+ } else {
+ Write-Host "DEBUG: " $correctmask[$ci].ToString("X2") " != " $aval.ToString("X2")
+ $needcorrection = $TRUE
+ }
+}
+if ($ai -lt $actualmask.Length) {
+ for (; $ai -lt $actualmask.Length; $ai++) {
+ if ($actualmask[$ai] -eq 0) {
+ Write-Host "DEBUG: 0 == 0"
+ } else {
+ Write-Host "DEBUG: " $actualmask[$ai].ToString("X2") " != 0"
+ $needcorrection = $TRUE
+ }
+ }
+}
+if ($needcorrection) {
+ Write-Host "Current mask is " ($actualmask|foreach {$_.ToString("X2")}) ", while it should be" ($correctmask|foreach {$_.ToString("X2")})
+ if ($confirm) {
+ Set-ItemProperty -Path "HKLM\SYSTEM\CurrentControlSet\Services\NDIS\IfTypes\6" -Name "IfUsedNetLuidIndices" -Value $correctmask -Type Binary -Confirm
+ } else {
+ Set-ItemProperty -Path "HKLM\SYSTEM\CurrentControlSet\Services\NDIS\IfTypes\6" -Name "IfUsedNetLuidIndices" -Value $correctmask -Type Binary
+ }
+} else {
+ Write-Host "The used LUID index mask is correct -- nothing to do"
+}
+
+#Write-Host ($connections | Out-String)
+$ghostcon = @(Get-ChildItem ("HKLM\SYSTEM\CurrentControlSet\Control\Network\{4D36E972-E325-11CE-BFC1-08002BE10318}") | Where-Object { !$connections.ContainsKey($_.PSChildName) -and $_.PSChildName -ne "Descriptions" } )
+if ($ghostcon -eq $null) {
+ Write-Host "`nNo ghost connections has been found -- nothing to do"
+} else {
+ Write-Host "`nThe following connections will be removed:"
+ #Write-Host ($ghostcon | Out-String)
+
+ $ghostcon.GetEnumerator() | ForEach-Object {
+ $prop = (Get-ItemProperty "$_\Connection")
+ if ($prop.PnPInstanceId -eq $null) {
+ Write-Host "WARNING! PnPInstanceId does not exist for" $_.PSChildName
+ } elseif (!($prop.PnPInstanceId.ToString() -match "SUN_VBOXNETFLTMP")) {
+ Write-Host "WARNING! PnPInstanceId (" $prop.PnPInstanceId.ToString() ") does not match ROOT\SUN_VBOXNETFLTMP for" $_.PSChildName
+ }
+ if ($prop.Name -eq $null) {
+ Write-Host "WARNING! Name does not exist for" $_.PSChildName
+ } else {
+ $ghostcon_names.Add($_.PSChildName, $prop.Name)
+ Write-Host $_.PSChildName -nonewline
+ Write-Host " " -nonewline
+ Write-Host $prop.Name
+ }
+ }
+
+ $result = AskForConfirmation "Delete Registry Keys" `
+ "Do you want to delete the keys listed above?" `
+ "Deletes all ghost connection keys from the registry." `
+ "No modifications to the registry will be made."
+
+ switch ($result)
+ {
+ 0 {$ghostcon.GetEnumerator() | ForEach-Object { Remove-Item -Path $_.PSPath -Recurse }}
+ 1 {"Removal cancelled."}
+ }
+}
+
+# Delete WFPLWFS parameter keys
+DeleteUnmatchingKeys "Delete WFPLWFS Parameter Keys (Adapter subkey)" "HKLM\SYSTEM\CurrentControlSet\Services\WFPLWFS\Parameters\Adapters"
+DeleteUnmatchingKeys "Delete WFPLWFS Parameter Keys (NdisAdapter subkey)" "HKLM\SYSTEM\CurrentControlSet\Services\WFPLWFS\Parameters\NdisAdapters"
+# Delete Psched parameter keys
+DeleteUnmatchingKeys "Delete Psched Parameter Keys (Adapter subkey)" "HKLM\SYSTEM\CurrentControlSet\Services\Psched\Parameters\Adapters"
+DeleteUnmatchingKeys "Delete Psched Parameter Keys (NdisAdapter subkey)" "HKLM\SYSTEM\CurrentControlSet\Services\Psched\Parameters\NdisAdapters"
+
+# Clean up NSI entries
+$nsi_obsolete = New-Object System.Collections.ArrayList
+$nsi_path = "HKLM\SYSTEM\CurrentControlSet\Control\Nsi\{EB004A11-9B1A-11D4-9123-0050047759BC}\10"
+$nsi = (Get-Item $nsi_path) | Select-Object -ExpandProperty property
+$nsi | ForEach-Object {
+ $value = (Get-ItemProperty -Path $nsi_path -Name $_).$_
+ [byte[]]$guid_bytes = $value[1040..1055]
+ $guid = New-Object -TypeName System.Guid -ArgumentList (,$guid_bytes)
+ $guid_string = $guid.ToString("B").ToUpper()
+ $nsi_conn_name_last = 6 + $value[4] + $value[5]*256
+ $nsi_conn_name = [Text.Encoding]::Unicode.GetString($value[6..$nsi_conn_name_last])
+ $nsi_if_name_last = 522 + $value[520] + $value[521]*256
+ $nsi_if_name = [Text.Encoding]::Unicode.GetString($value[522..$nsi_if_name_last])
+ Write-Host $_ -nonewline
+ Write-Host " " -nonewline
+ Write-Host $guid_string -nonewline
+ Write-Host " " -nonewline
+ if ($connections.ContainsKey($guid_string)) {
+ Write-Host $nsi_if_name
+ } else {
+ [void] $nsi_obsolete.Add($_)
+ Write-Host "[OBSOLETE] " $nsi_if_name -foregroundcolor red
+ }
+}
+
+$result = AskForConfirmation "Delete NSI Entries" `
+ "Do you want to delete the entries marked in red above?" `
+ "Deletes all marked entries from the NSI registry key." `
+ "No modifications to the registry will be made."
+
+switch ($result)
+ {
+ 0 {$nsi_obsolete.GetEnumerator() | ForEach-Object { Remove-ItemProperty -Path $nsi_path -Name $_ }}
+ 1 {"Removal cancelled."}
+ }
+
+# Clean up uninstalled connections
+if ( (Get-ChildItem "HKLM\SYSTEM\CurrentControlSet\Control\Network\Uninstalled" | Measure-Object).Count -gt 10 ) {
+ $result = AskForConfirmation "Delete Uninstalled Network Connection Registry Keys" `
+ "There are over 10 uninstalled network connections accumulated in the registry. Do you want to delete them?" `
+ "Deletes uninstalled connection keys from the registry." `
+ "No modifications to the registry will be made."
+
+ switch ($result)
+ {
+ 0 {Remove-Item -Path "HKLM\SYSTEM\CurrentControlSet\Control\Network\Uninstalled\*" -Recurse}
+ 1 {"Removal cancelled."}
+ }
+} else {
+ Write-Host "Less than 10 uninstalled connections -- no action yet required."
+}
+
+Pop-Location
diff --git a/src/VBox/ValidationKit/testdriver/winbase.py b/src/VBox/ValidationKit/testdriver/winbase.py
new file mode 100755
index 00000000..f043c3f2
--- /dev/null
+++ b/src/VBox/ValidationKit/testdriver/winbase.py
@@ -0,0 +1,336 @@
+# -*- coding: utf-8 -*-
+# $Id: winbase.py $
+
+"""
+This module is here to externalize some Windows specifics that gives pychecker
+a hard time when running on non-Windows systems.
+"""
+
+__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 ctypes;
+import os;
+import sys;
+
+# Windows specific imports.
+import pywintypes; # pylint: disable=import-error
+import winerror; # pylint: disable=import-error
+import win32con; # pylint: disable=import-error
+import win32api; # pylint: disable=import-error
+import win32console; # pylint: disable=import-error
+import win32event; # pylint: disable=import-error
+import win32process; # pylint: disable=import-error
+
+# Validation Kit imports.
+from testdriver import reporter;
+
+# Python 3 hacks:
+if sys.version_info[0] >= 3:
+ long = int; # pylint: disable=redefined-builtin,invalid-name
+
+
+#
+# Windows specific implementation of base functions.
+#
+
+def processInterrupt(uPid):
+ """
+ The Windows version of base.processInterrupt
+
+ Note! This doesn't work terribly well with a lot of processes.
+ """
+ try:
+ # pylint: disable=no-member
+ win32console.GenerateConsoleCtrlEvent(win32con.CTRL_BREAK_EVENT, uPid); # pylint: disable=c-extension-no-member
+ #GenerateConsoleCtrlEvent = ctypes.windll.kernel32.GenerateConsoleCtrlEvent
+ #rc = GenerateConsoleCtrlEvent(1, uPid);
+ #reporter.log('GenerateConsoleCtrlEvent -> %s' % (rc,));
+ fRc = True;
+ except:
+ reporter.logXcpt('uPid=%s' % (uPid,));
+ fRc = False;
+ return fRc;
+
+def postThreadMesssageClose(uTid):
+ """ Posts a WM_CLOSE message to the specified thread."""
+ fRc = False;
+ try:
+ win32api.PostThreadMessage(uTid, win32con.WM_CLOSE, 0, 0); # pylint: disable=no-member,c-extension-no-member
+ fRc = True;
+ except:
+ reporter.logXcpt('uTid=%s' % (uTid,));
+ return fRc;
+
+def postThreadMesssageQuit(uTid):
+ """ Posts a WM_QUIT message to the specified thread."""
+ fRc = False;
+ try:
+ win32api.PostThreadMessage(uTid, win32con.WM_QUIT, # pylint: disable=no-member,c-extension-no-member
+ 0x40010004, 0); # DBG_TERMINATE_PROCESS
+ fRc = True;
+ except:
+ reporter.logXcpt('uTid=%s' % (uTid,));
+ return fRc;
+
+def processTerminate(uPid):
+ """ The Windows version of base.processTerminate """
+ # pylint: disable=no-member
+ fRc = False;
+ try:
+ hProcess = win32api.OpenProcess(win32con.PROCESS_TERMINATE, # pylint: disable=no-member,c-extension-no-member
+ False, uPid);
+ except:
+ reporter.logXcpt('uPid=%s' % (uPid,));
+ else:
+ try:
+ win32process.TerminateProcess(hProcess, # pylint: disable=no-member,c-extension-no-member
+ 0x40010004); # DBG_TERMINATE_PROCESS
+ fRc = True;
+ except:
+ reporter.logXcpt('uPid=%s' % (uPid,));
+ hProcess.Close(); #win32api.CloseHandle(hProcess)
+ return fRc;
+
+def processKill(uPid):
+ """ The Windows version of base.processKill """
+ return processTerminate(uPid);
+
+def processExists(uPid):
+ """ The Windows version of base.processExists """
+ # We try open the process for waiting since this is generally only forbidden in a very few cases.
+ try:
+ hProcess = win32api.OpenProcess(win32con.SYNCHRONIZE, False, uPid); # pylint: disable=no-member,c-extension-no-member
+ except pywintypes.error as oXcpt: # pylint: disable=no-member
+ if oXcpt.winerror == winerror.ERROR_INVALID_PARAMETER:
+ return False;
+ if oXcpt.winerror != winerror.ERROR_ACCESS_DENIED:
+ reporter.logXcpt('uPid=%s oXcpt=%s' % (uPid, oXcpt));
+ return False;
+ reporter.logXcpt('uPid=%s oXcpt=%s' % (uPid, oXcpt));
+ except Exception as oXcpt:
+ reporter.logXcpt('uPid=%s' % (uPid,));
+ return False;
+ else:
+ hProcess.Close(); #win32api.CloseHandle(hProcess)
+ return True;
+
+def processCheckPidAndName(uPid, sName):
+ """ The Windows version of base.processCheckPidAndName """
+ fRc = processExists(uPid);
+ if fRc is True:
+ try:
+ from win32com.client import GetObject; # pylint: disable=import-error
+ oWmi = GetObject('winmgmts:');
+ aoProcesses = oWmi.InstancesOf('Win32_Process');
+ for oProcess in aoProcesses:
+ if long(oProcess.Properties_("ProcessId").Value) == uPid:
+ sCurName = oProcess.Properties_("Name").Value;
+ reporter.log2('uPid=%s sName=%s sCurName=%s' % (uPid, sName, sCurName));
+ sName = sName.lower();
+ sCurName = sCurName.lower();
+ if os.path.basename(sName) == sName:
+ sCurName = os.path.basename(sCurName);
+
+ if sCurName == sName \
+ or sCurName + '.exe' == sName \
+ or sCurName == sName + '.exe':
+ fRc = True;
+ break;
+ except:
+ reporter.logXcpt('uPid=%s sName=%s' % (uPid, sName));
+ return fRc;
+
+#
+# Some helper functions.
+#
+def processCreate(sName, asArgs):
+ """
+ Returns a (pid, handle, tid) tuple on success. (-1, None) on failure (logged).
+ """
+
+ # Construct a command line.
+ sCmdLine = '';
+ for sArg in asArgs:
+ if sCmdLine == '':
+ sCmdLine += '"';
+ else:
+ sCmdLine += ' "';
+ sCmdLine += sArg;
+ sCmdLine += '"';
+
+ # Try start the process.
+ # pylint: disable=no-member
+ dwCreationFlags = win32con.CREATE_NEW_PROCESS_GROUP;
+ oStartupInfo = win32process.STARTUPINFO(); # pylint: disable=c-extension-no-member
+ try:
+ (hProcess, hThread, uPid, uTid) = win32process.CreateProcess(sName, # pylint: disable=c-extension-no-member
+ sCmdLine, # CommandLine
+ None, # ProcessAttributes
+ None, # ThreadAttibutes
+ 1, # fInheritHandles
+ dwCreationFlags,
+ None, # Environment
+ None, # CurrentDirectory.
+ oStartupInfo);
+ except:
+ reporter.logXcpt('sName="%s" sCmdLine="%s"' % (sName, sCmdLine));
+ return (-1, None, -1);
+
+ # Dispense with the thread handle.
+ try:
+ hThread.Close(); # win32api.CloseHandle(hThread);
+ except:
+ reporter.logXcpt();
+
+ # Try get full access to the process.
+ try:
+ hProcessFullAccess = win32api.DuplicateHandle( # pylint: disable=c-extension-no-member
+ win32api.GetCurrentProcess(), # pylint: disable=c-extension-no-member
+ hProcess,
+ win32api.GetCurrentProcess(), # pylint: disable=c-extension-no-member
+ win32con.PROCESS_TERMINATE
+ | win32con.PROCESS_QUERY_INFORMATION
+ | win32con.SYNCHRONIZE
+ | win32con.DELETE,
+ False,
+ 0);
+ hProcess.Close(); # win32api.CloseHandle(hProcess);
+ hProcess = hProcessFullAccess;
+ except:
+ reporter.logXcpt();
+ reporter.log2('processCreate -> %#x, hProcess=%s %#x' % (uPid, hProcess, hProcess.handle,));
+ return (uPid, hProcess, uTid);
+
+def processPollByHandle(hProcess):
+ """
+ Polls the process handle to see if it has finished (True) or not (False).
+ """
+ try:
+ dwWait = win32event.WaitForSingleObject(hProcess, 0); # pylint: disable=no-member,c-extension-no-member
+ except:
+ reporter.logXcpt('hProcess=%s %#x' % (hProcess, hProcess.handle,));
+ return True;
+ return dwWait != win32con.WAIT_TIMEOUT; #0x102; #
+
+
+def processTerminateByHandle(hProcess):
+ """
+ Terminates the process.
+ """
+ try:
+ win32api.TerminateProcess(hProcess, # pylint: disable=no-member,c-extension-no-member
+ 0x40010004); # DBG_TERMINATE_PROCESS
+ except:
+ reporter.logXcpt('hProcess=%s %#x' % (hProcess, hProcess.handle,));
+ return False;
+ return True;
+
+#
+# Misc
+#
+
+def logMemoryStats():
+ """
+ Logs windows memory stats.
+ """
+ class MemoryStatusEx(ctypes.Structure):
+ """ MEMORYSTATUSEX """
+ kaFields = [
+ ( 'dwLength', ctypes.c_ulong ),
+ ( 'dwMemoryLoad', ctypes.c_ulong ),
+ ( 'ullTotalPhys', ctypes.c_ulonglong ),
+ ( 'ullAvailPhys', ctypes.c_ulonglong ),
+ ( 'ullTotalPageFile', ctypes.c_ulonglong ),
+ ( 'ullAvailPageFile', ctypes.c_ulonglong ),
+ ( 'ullTotalVirtual', ctypes.c_ulonglong ),
+ ( 'ullAvailVirtual', ctypes.c_ulonglong ),
+ ( 'ullAvailExtendedVirtual', ctypes.c_ulonglong ),
+ ];
+ _fields_ = kaFields; # pylint: disable=invalid-name
+
+ def __init__(self):
+ super(MemoryStatusEx, self).__init__();
+ self.dwLength = ctypes.sizeof(self);
+
+ try:
+ oStats = MemoryStatusEx();
+ ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(oStats));
+ except:
+ reporter.logXcpt();
+ return False;
+
+ reporter.log('Memory statistics:');
+ for sField, _ in MemoryStatusEx.kaFields:
+ reporter.log(' %32s: %s' % (sField, getattr(oStats, sField)));
+ return True;
+
+def checkProcessHeap():
+ """
+ Calls HeapValidate(GetProcessHeap(), 0, NULL);
+ """
+
+ # Get the process heap.
+ try:
+ hHeap = ctypes.windll.kernel32.GetProcessHeap();
+ except:
+ reporter.logXcpt();
+ return False;
+
+ # Check it.
+ try:
+ fIsOkay = ctypes.windll.kernel32.HeapValidate(hHeap, 0, None);
+ except:
+ reporter.logXcpt();
+ return False;
+
+ if fIsOkay == 0:
+ reporter.log('HeapValidate failed!');
+
+ # Try trigger a dump using c:\utils\procdump64.exe.
+ from common import utils;
+
+ iPid = os.getpid();
+ asArgs = [ 'e:\\utils\\procdump64.exe', '-ma', '%s' % (iPid,), 'c:\\CrashDumps\\python.exe-%u-heap.dmp' % (iPid,)];
+ if utils.getHostArch() != 'amd64':
+ asArgs[0] = 'c:\\utils\\procdump.exe'
+ reporter.log('Trying to dump this process using: %s' % (asArgs,));
+ utils.processCall(asArgs);
+
+ # Generate a crash exception.
+ ctypes.windll.msvcrt.strcpy(None, None, 1024);
+
+ return True;
+