vbox.py@ 98477

Last change on this file since 98477 was 98269, checked in by vboxsync, 23 months ago
Validation Kit/testdriver: Added a new option "--vbox-vm-no-terminate" that leaves the current VM up and running after a test driver run. This is handy to have for manual investigation work during test driver development and should get rid of the custom hacks (some) test drivers have to perform the same result.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 205.9 KB

Line
1	# -- coding: utf-8 --
2	# $Id: vbox.py 98269 2023-01-24 09:48:36Z vboxsync $
3	# pylint: disable=too-many-lines
4
5	"""
6	VirtualBox Specific base testdriver.
7	"""
8
9	__copyright__ = \
10	"""
11	Copyright (C) 2010-2023 Oracle and/or its affiliates.
12
13	This file is part of VirtualBox base platform packages, as
14	available from https://www.virtualbox.org.
15
16	This program is free software; you can redistribute it and/or
17	modify it under the terms of the GNU General Public License
18	as published by the Free Software Foundation, in version 3 of the
19	License.
20
21	This program is distributed in the hope that it will be useful, but
22	WITHOUT ANY WARRANTY; without even the implied warranty of
23	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24	General Public License for more details.
25
26	You should have received a copy of the GNU General Public License
27	along with this program; if not, see <https://www.gnu.org/licenses>.
28
29	The contents of this file may alternatively be used under the terms
30	of the Common Development and Distribution License Version 1.0
31	(CDDL), a copy of it is provided in the "COPYING.CDDL" file included
32	in the VirtualBox distribution, in which case the provisions of the
33	CDDL are applicable instead of those of the GPL.
34
35	You may elect to license modified versions of this file under the
36	terms and conditions of either the GPL or the CDDL or both.
37
38	SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
39	"""
40	__version__ = "$Revision: 98269 $"
41
42	# pylint: disable=unnecessary-semicolon
43
44	# Standard Python imports.
45	import datetime
46	import os
47	import platform
48	import re;
49	import sys
50	import threading
51	import time
52	import traceback
53
54	# Figure out where the validation kit lives and make sure it's in the path.
55	try: __file__
56	except: __file__ = sys.argv[0];
57	g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)));
58	if g_ksValidationKitDir not in sys.path:
59	sys.path.append(g_ksValidationKitDir);
60
61	# Validation Kit imports.
62	from common import utils;
63	from testdriver import base;
64	from testdriver import btresolver;
65	from testdriver import reporter;
66	from testdriver import vboxcon;
67	from testdriver import vboxtestvms;
68
69	# Python 3 hacks:
70	if sys.version_info[0] >= 3:
71	xrange = range; # pylint: disable=redefined-builtin,invalid-name
72	long = int; # pylint: disable=redefined-builtin,invalid-name
73
74	#
75	# Exception and Error Unification Hacks.
76	# Note! This is pretty gross stuff. Be warned!
77	# TODO: Find better ways of doing these things, preferrably in vboxapi.
78	#
79
80	ComException = None; # pylint: disable=invalid-name
81	__fnComExceptionGetAttr__ = None; # pylint: disable=invalid-name
82
83	def __MyDefaultGetAttr(oSelf, sName):
84	""" __getattribute__/__getattr__ default fake."""
85	try:
86	oAttr = oSelf.__dict__[sName];
87	except:
88	oAttr = dir(oSelf)[sName];
89	return oAttr;
90
91	def __MyComExceptionGetAttr(oSelf, sName):
92	""" ComException.__getattr__ wrapper - both XPCOM and COM. """
93	try:
94	oAttr = __fnComExceptionGetAttr__(oSelf, sName);
95	except AttributeError:
96	if platform.system() == 'Windows':
97	if sName == 'errno':
98	oAttr = __fnComExceptionGetAttr__(oSelf, 'hresult');
99	elif sName == 'msg':
100	oAttr = __fnComExceptionGetAttr__(oSelf, 'strerror');
101	else:
102	raise;
103	else:
104	if sName == 'hresult':
105	oAttr = __fnComExceptionGetAttr__(oSelf, 'errno');
106	elif sName == 'strerror':
107	oAttr = __fnComExceptionGetAttr__(oSelf, 'msg');
108	elif sName == 'excepinfo':
109	oAttr = None;
110	elif sName == 'argerror':
111	oAttr = None;
112	else:
113	raise;
114	#print '__MyComExceptionGetAttr(,%s) -> "%s"' % (sName, oAttr);
115	return oAttr;
116
117	def __deployExceptionHacks__(oNativeComExceptionClass):
118	"""
119	Deploys the exception and error hacks that helps unifying COM and XPCOM
120	exceptions and errors.
121	"""
122	global ComException # pylint: disable=invalid-name
123	global __fnComExceptionGetAttr__ # pylint: disable=invalid-name
124
125	# Hook up our attribute getter for the exception class (ASSUMES new-style).
126	if __fnComExceptionGetAttr__ is None:
127	try:
128	__fnComExceptionGetAttr__ = getattr(oNativeComExceptionClass, '__getattr__');
129	except:
130	try:
131	__fnComExceptionGetAttr__ = getattr(oNativeComExceptionClass, '__getattribute__');
132	except:
133	__fnComExceptionGetAttr__ = __MyDefaultGetAttr;
134	setattr(oNativeComExceptionClass, '__getattr__', __MyComExceptionGetAttr)
135
136	# Make the modified classes accessible (are there better ways to do this?)
137	ComException = oNativeComExceptionClass
138	return None;
139
140
141
142	#
143	# Utility functions.
144	#
145
146	def isIpAddrValid(sIpAddr):
147	"""
148	Checks if a IPv4 address looks valid. This will return false for
149	localhost and similar.
150	Returns True / False.
151	"""
152	if sIpAddr is None: return False;
153	if len(sIpAddr.split('.')) != 4: return False;
154	if sIpAddr.endswith('.0'): return False;
155	if sIpAddr.endswith('.255'): return False;
156	if sIpAddr.startswith('127.'): return False;
157	if sIpAddr.startswith('169.254.'): return False;
158	if sIpAddr.startswith('192.0.2.'): return False;
159	if sIpAddr.startswith('224.0.0.'): return False;
160	return True;
161
162	def stringifyErrorInfo(oErrInfo):
163	"""
164	Stringifies the error information in a IVirtualBoxErrorInfo object.
165
166	Returns string with error info.
167	"""
168	try:
169	rc = oErrInfo.resultCode;
170	sText = oErrInfo.text;
171	sIid = oErrInfo.interfaceID;
172	sComponent = oErrInfo.component;
173	except:
174	sRet = 'bad error object (%s)?' % (oErrInfo,);
175	traceback.print_exc();
176	else:
177	sRet = 'rc=%s text="%s" IID=%s component=%s' % (ComError.toString(rc), sText, sIid, sComponent);
178	return sRet;
179
180	def reportError(oErr, sText):
181	"""
182	Report a VirtualBox error on oErr. oErr can be IVirtualBoxErrorInfo
183	or IProgress. Anything else is ignored.
184
185	Returns the same a reporter.error().
186	"""
187	try:
188	oErrObj = oErr.errorInfo; # IProgress.
189	except:
190	oErrObj = oErr;
191	reporter.error(sText);
192	return reporter.error(stringifyErrorInfo(oErrObj));
193
194	def formatComOrXpComException(oType, oXcpt):
195	"""
196	Callback installed with the reporter to better format COM exceptions.
197	Similar to format_exception_only, only it returns None if not interested.
198	"""
199	_ = oType;
200	oVBoxMgr = vboxcon.goHackModuleClass.oVBoxMgr;
201	if oVBoxMgr is None:
202	return None;
203	if not oVBoxMgr.xcptIsOurXcptKind(oXcpt): # pylint: disable=not-callable
204	return None;
205
206	if platform.system() == 'Windows':
207	hrc = oXcpt.hresult;
208	if hrc == ComError.DISP_E_EXCEPTION and oXcpt.excepinfo is not None and len(oXcpt.excepinfo) > 5:
209	hrc = oXcpt.excepinfo[5];
210	sWhere = oXcpt.excepinfo[1];
211	sMsg = oXcpt.excepinfo[2];
212	else:
213	sWhere = None;
214	sMsg = oXcpt.strerror;
215	else:
216	hrc = oXcpt.errno;
217	sWhere = None;
218	sMsg = oXcpt.msg;
219
220	sHrc = oVBoxMgr.xcptToString(hrc); # pylint: disable=not-callable
221	if sHrc.find('(') < 0:
222	sHrc = '%s (%#x)' % (sHrc, hrc & 0xffffffff,);
223
224	asRet = ['COM-Xcpt: %s' % (sHrc,)];
225	if sMsg and sWhere:
226	asRet.append('--------- %s: %s' % (sWhere, sMsg,));
227	elif sMsg:
228	asRet.append('--------- %s' % (sMsg,));
229	return asRet;
230	#if sMsg and sWhere:
231	# return ['COM-Xcpt: %s - %s: %s' % (sHrc, sWhere, sMsg,)];
232	#if sMsg:
233	# return ['COM-Xcpt: %s - %s' % (sHrc, sMsg,)];
234	#return ['COM-Xcpt: %s' % (sHrc,)];
235
236	#
237	# Classes
238	#
239
240	class ComError(object):
241	"""
242	Unified COM and XPCOM status code repository.
243	This works more like a module than a class since it's replacing a module.
244	"""
245
246	# The VBOX_E_XXX bits:
247	__VBOX_E_BASE = -2135228416;
248	VBOX_E_OBJECT_NOT_FOUND = __VBOX_E_BASE + 1;
249	VBOX_E_INVALID_VM_STATE = __VBOX_E_BASE + 2;
250	VBOX_E_VM_ERROR = __VBOX_E_BASE + 3;
251	VBOX_E_FILE_ERROR = __VBOX_E_BASE + 4;
252	VBOX_E_IPRT_ERROR = __VBOX_E_BASE + 5;
253	VBOX_E_PDM_ERROR = __VBOX_E_BASE + 6;
254	VBOX_E_INVALID_OBJECT_STATE = __VBOX_E_BASE + 7;
255	VBOX_E_HOST_ERROR = __VBOX_E_BASE + 8;
256	VBOX_E_NOT_SUPPORTED = __VBOX_E_BASE + 9;
257	VBOX_E_XML_ERROR = __VBOX_E_BASE + 10;
258	VBOX_E_INVALID_SESSION_STATE = __VBOX_E_BASE + 11;
259	VBOX_E_OBJECT_IN_USE = __VBOX_E_BASE + 12;
260	VBOX_E_DONT_CALL_AGAIN = __VBOX_E_BASE + 13;
261
262	# Reverse lookup table.
263	dDecimalToConst = {}; # pylint: disable=invalid-name
264
265	def __init__(self):
266	raise base.GenError('No instances, please');
267
268	@staticmethod
269	def copyErrors(oNativeComErrorClass):
270	"""
271	Copy all error codes from oNativeComErrorClass to this class and
272	install compatability mappings.
273	"""
274
275	# First, add the VBOX_E_XXX constants to dDecimalToConst.
276	for sAttr in dir(ComError):
277	if sAttr.startswith('VBOX_E'):
278	oAttr = getattr(ComError, sAttr);
279	ComError.dDecimalToConst[oAttr] = sAttr;
280
281	# Copy all error codes from oNativeComErrorClass to this class.
282	for sAttr in dir(oNativeComErrorClass):
283	if sAttr[0].isupper():
284	oAttr = getattr(oNativeComErrorClass, sAttr);
285	setattr(ComError, sAttr, oAttr);
286	if isinstance(oAttr, int):
287	ComError.dDecimalToConst[oAttr] = sAttr;
288
289	# Install mappings to the other platform.
290	if platform.system() == 'Windows':
291	ComError.NS_OK = ComError.S_OK;
292	ComError.NS_ERROR_FAILURE = ComError.E_FAIL;
293	ComError.NS_ERROR_ABORT = ComError.E_ABORT;
294	ComError.NS_ERROR_NULL_POINTER = ComError.E_POINTER;
295	ComError.NS_ERROR_NO_INTERFACE = ComError.E_NOINTERFACE;
296	ComError.NS_ERROR_INVALID_ARG = ComError.E_INVALIDARG;
297	ComError.NS_ERROR_OUT_OF_MEMORY = ComError.E_OUTOFMEMORY;
298	ComError.NS_ERROR_NOT_IMPLEMENTED = ComError.E_NOTIMPL;
299	ComError.NS_ERROR_UNEXPECTED = ComError.E_UNEXPECTED;
300	else:
301	ComError.E_ACCESSDENIED = -2147024891; # see VBox/com/defs.h
302	ComError.S_OK = ComError.NS_OK;
303	ComError.E_FAIL = ComError.NS_ERROR_FAILURE;
304	ComError.E_ABORT = ComError.NS_ERROR_ABORT;
305	ComError.E_POINTER = ComError.NS_ERROR_NULL_POINTER;
306	ComError.E_NOINTERFACE = ComError.NS_ERROR_NO_INTERFACE;
307	ComError.E_INVALIDARG = ComError.NS_ERROR_INVALID_ARG;
308	ComError.E_OUTOFMEMORY = ComError.NS_ERROR_OUT_OF_MEMORY;
309	ComError.E_NOTIMPL = ComError.NS_ERROR_NOT_IMPLEMENTED;
310	ComError.E_UNEXPECTED = ComError.NS_ERROR_UNEXPECTED;
311	ComError.DISP_E_EXCEPTION = -2147352567; # For COM compatability only.
312	return True;
313
314	@staticmethod
315	def getXcptResult(oXcpt):
316	"""
317	Gets the result code for an exception.
318	Returns COM status code (or E_UNEXPECTED).
319	"""
320	if platform.system() == 'Windows':
321	# The DISP_E_EXCEPTION + excptinfo fun needs checking up, only
322	# empirical info on it so far.
323	try:
324	hrXcpt = oXcpt.hresult;
325	except AttributeError:
326	hrXcpt = ComError.E_UNEXPECTED;
327	if hrXcpt == ComError.DISP_E_EXCEPTION and oXcpt.excepinfo is not None:
328	hrXcpt = oXcpt.excepinfo[5];
329	else:
330	try:
331	hrXcpt = oXcpt.errno;
332	except AttributeError:
333	hrXcpt = ComError.E_UNEXPECTED;
334	return hrXcpt;
335
336	@staticmethod
337	def equal(oXcpt, hr):
338	"""
339	Checks if the ComException e is not equal to the COM status code hr.
340	This takes DISP_E_EXCEPTION & excepinfo into account.
341
342	This method can be used with any Exception derivate, however it will
343	only return True for classes similar to the two ComException variants.
344	"""
345	if platform.system() == 'Windows':
346	# The DISP_E_EXCEPTION + excptinfo fun needs checking up, only
347	# empirical info on it so far.
348	try:
349	hrXcpt = oXcpt.hresult;
350	except AttributeError:
351	return False;
352	if hrXcpt == ComError.DISP_E_EXCEPTION and oXcpt.excepinfo is not None:
353	hrXcpt = oXcpt.excepinfo[5];
354	else:
355	try:
356	hrXcpt = oXcpt.errno;
357	except AttributeError:
358	return False;
359	return hrXcpt == hr;
360
361	@staticmethod
362	def notEqual(oXcpt, hr):
363	"""
364	Checks if the ComException e is not equal to the COM status code hr.
365	See equal() for more details.
366	"""
367	return not ComError.equal(oXcpt, hr)
368
369	@staticmethod
370	def toString(hr):
371	"""
372	Converts the specified COM status code to a string.
373	"""
374	try:
375	sStr = ComError.dDecimalToConst[int(hr)];
376	except KeyError:
377	hrLong = long(hr);
378	sStr = '%#x (%d)' % (hrLong, hrLong);
379	return sStr;
380
381
382	class Build(object): # pylint: disable=too-few-public-methods
383	"""
384	A VirtualBox build.
385
386	Note! After dropping the installation of VBox from this code and instead
387	realizing that with the vboxinstall.py wrapper driver, this class is
388	of much less importance and contains unnecessary bits and pieces.
389	"""
390
391	def __init__(self, oDriver, strInstallPath):
392	"""
393	Construct a build object from a build file name and/or install path.
394	"""
395	# Initialize all members first.
396	self.oDriver = oDriver;
397	self.sInstallPath = strInstallPath;
398	self.sSdkPath = None;
399	self.sSrcRoot = None;
400	self.sKind = None;
401	self.sDesignation = None;
402	self.sType = None;
403	self.sOs = None;
404	self.sArch = None;
405	self.sGuestAdditionsIso = None;
406
407	# Figure out the values as best we can.
408	if strInstallPath is None:
409	#
410	# Both parameters are None, which means we're falling back on a
411	# build in the development tree.
412	#
413	self.sKind = "development";
414
415	if self.sType is None:
416	self.sType = os.environ.get("KBUILD_TYPE", "release");
417	if self.sOs is None:
418	self.sOs = os.environ.get("KBUILD_TARGET", oDriver.sHost);
419	if self.sArch is None:
420	self.sArch = os.environ.get("KBUILD_TARGET_ARCH", oDriver.sHostArch);
421
422	sOut = os.path.join('out', self.sOs + '.' + self.sArch, self.sType);
423	sSearch = os.environ.get('VBOX_TD_DEV_TREE', os.path.dirname(__file__)); # Env.var. for older trees or testboxscript.
424	sCandidat = None;
425	for i in range(0, 10): # pylint: disable=unused-variable
426	sBldDir = os.path.join(sSearch, sOut);
427	if os.path.isdir(sBldDir):
428	sCandidat = os.path.join(sBldDir, 'bin', 'VBoxSVC' + base.exeSuff());
429	if os.path.isfile(sCandidat):
430	self.sSdkPath = os.path.join(sBldDir, 'bin/sdk');
431	break;
432	sCandidat = os.path.join(sBldDir, 'dist/VirtualBox.app/Contents/MacOS/VBoxSVC');
433	if os.path.isfile(sCandidat):
434	self.sSdkPath = os.path.join(sBldDir, 'dist/sdk');
435	break;
436	sSearch = os.path.abspath(os.path.join(sSearch, '..'));
437	if sCandidat is None or not os.path.isfile(sCandidat):
438	raise base.GenError();
439	self.sInstallPath = os.path.abspath(os.path.dirname(sCandidat));
440	self.sSrcRoot = os.path.abspath(sSearch);
441
442	self.sDesignation = os.environ.get('TEST_BUILD_DESIGNATION', None);
443	if self.sDesignation is None:
444	try:
445	oFile = utils.openNoInherit(os.path.join(self.sSrcRoot, sOut, 'revision.kmk'), 'r');
446	except:
447	pass;
448	else:
449	s = oFile.readline();
450	oFile.close();
451	oMatch = re.search("VBOX_SVN_REV=(\\d+)", s);
452	if oMatch is not None:
453	self.sDesignation = oMatch.group(1);
454
455	if self.sDesignation is None:
456	self.sDesignation = 'XXXXX'
457	else:
458	#
459	# We've been pointed to an existing installation, this could be
460	# in the out dir of a svn checkout, untarred VBoxAll or a real
461	# installation directory.
462	#
463	self.sKind = "preinstalled";
464	self.sType = "release";
465	self.sOs = oDriver.sHost;
466	self.sArch = oDriver.sHostArch;
467	self.sInstallPath = os.path.abspath(strInstallPath);
468	self.sSdkPath = os.path.join(self.sInstallPath, 'sdk');
469	self.sSrcRoot = None;
470	self.sDesignation = os.environ.get('TEST_BUILD_DESIGNATION', 'XXXXX');
471	## @todo Much more work is required here.
472
473	# Try Determine the build type.
474	sVBoxManage = os.path.join(self.sInstallPath, 'VBoxManage' + base.exeSuff());
475	if os.path.isfile(sVBoxManage):
476	try:
477	(iExit, sStdOut, _) = utils.processOutputUnchecked([sVBoxManage, '--dump-build-type']);
478	sStdOut = sStdOut.strip();
479	if iExit == 0 and sStdOut in ('release', 'debug', 'strict', 'dbgopt', 'asan'):
480	self.sType = sStdOut;
481	reporter.log('Build: Detected build type: %s' % (self.sType));
482	else:
483	reporter.log('Build: --dump-build-type -> iExit=%u sStdOut=%s' % (iExit, sStdOut,));
484	except:
485	reporter.logXcpt('Build: Running "%s --dump-build-type" failed!' % (sVBoxManage,));
486	else:
487	reporter.log3('Build: sVBoxManage=%s not found' % (sVBoxManage,));
488
489	# Do some checks.
490	sVMMR0 = os.path.join(self.sInstallPath, 'VMMR0.r0');
491	if not os.path.isfile(sVMMR0) and utils.getHostOs() == 'solaris': # solaris is special.
492	sVMMR0 = os.path.join(self.sInstallPath, 'amd64' if utils.getHostArch() == 'amd64' else 'i386', 'VMMR0.r0');
493	if not os.path.isfile(sVMMR0):
494	raise base.GenError('%s is missing' % (sVMMR0,));
495
496	# Guest additions location is different on windows for some _stupid_ reason.
497	if self.sOs == 'win' and self.sKind != 'development':
498	self.sGuestAdditionsIso = '%s/VBoxGuestAdditions.iso' % (self.sInstallPath,);
499	elif self.sOs == 'darwin':
500	self.sGuestAdditionsIso = '%s/VBoxGuestAdditions.iso' % (self.sInstallPath,);
501	elif self.sOs == 'solaris':
502	self.sGuestAdditionsIso = '%s/VBoxGuestAdditions.iso' % (self.sInstallPath,);
503	else:
504	self.sGuestAdditionsIso = '%s/additions/VBoxGuestAdditions.iso' % (self.sInstallPath,);
505
506	# __init__ end;
507
508	def isDevBuild(self):
509	""" Returns True if it's development build (kind), otherwise False. """
510	return self.sKind == 'development';
511
512
513	class EventHandlerBase(object):
514	"""
515	Base class for both Console and VirtualBox event handlers.
516	"""
517
518	def __init__(self, dArgs, fpApiVer, sName = None):
519	self.oVBoxMgr = dArgs['oVBoxMgr'];
520	self.oEventSrc = dArgs['oEventSrc']; # Console/VirtualBox for < 3.3
521	self.oListener = dArgs['oListener'];
522	self.fPassive = self.oListener is not None;
523	self.sName = sName
524	self.fShutdown = False;
525	self.oThread = None;
526	self.fpApiVer = fpApiVer;
527	self.dEventNo2Name = {};
528	for sKey, iValue in self.oVBoxMgr.constants.all_values('VBoxEventType').items():
529	self.dEventNo2Name[iValue] = sKey;
530
531	def threadForPassiveMode(self):
532	"""
533	The thread procedure for the event processing thread.
534	"""
535	assert self.fPassive is not None;
536	while not self.fShutdown:
537	try:
538	oEvt = self.oEventSrc.getEvent(self.oListener, 500);
539	except:
540	if not self.oVBoxMgr.xcptIsDeadInterface(): reporter.logXcpt();
541	else: reporter.log('threadForPassiveMode/%s: interface croaked (ignored)' % (self.sName,));
542	break;
543	if oEvt:
544	self.handleEvent(oEvt);
545	if not self.fShutdown:
546	try:
547	self.oEventSrc.eventProcessed(self.oListener, oEvt);
548	except:
549	reporter.logXcpt();
550	break;
551	self.unregister(fWaitForThread = False);
552	return None;
553
554	def startThreadForPassiveMode(self):
555	"""
556	Called when working in passive mode.
557	"""
558	self.oThread = threading.Thread(target = self.threadForPassiveMode, \
559	args=(), name=('PAS-%s' % (self.sName,)));
560	self.oThread.setDaemon(True); # pylint: disable=deprecated-method
561	self.oThread.start();
562	return None;
563
564	def unregister(self, fWaitForThread = True):
565	"""
566	Unregister the event handler.
567	"""
568	fRc = False;
569	if not self.fShutdown:
570	self.fShutdown = True;
571
572	if self.oEventSrc is not None:
573	if self.fpApiVer < 3.3:
574	try:
575	self.oEventSrc.unregisterCallback(self.oListener);
576	fRc = True;
577	except:
578	reporter.errorXcpt('unregisterCallback failed on %s' % (self.oListener,));
579	else:
580	try:
581	self.oEventSrc.unregisterListener(self.oListener);
582	fRc = True;
583	except:
584	if self.oVBoxMgr.xcptIsDeadInterface():
585	reporter.log('unregisterListener failed on %s because of dead interface (%s)'
586	% (self.oListener, self.oVBoxMgr.xcptToString(),));
587	else:
588	reporter.errorXcpt('unregisterListener failed on %s' % (self.oListener,));
589
590	if self.oThread is not None \
591	and self.oThread != threading.current_thread():
592	self.oThread.join();
593	self.oThread = None;
594
595	_ = fWaitForThread;
596	return fRc;
597
598	def handleEvent(self, oEvt):
599	"""
600	Compatibility wrapper that child classes implement.
601	"""
602	_ = oEvt;
603	return None;
604
605	@staticmethod
606	def registerDerivedEventHandler(oVBoxMgr, fpApiVer, oSubClass, dArgsCopy, # pylint: disable=too-many-arguments
607	oSrcParent, sSrcParentNm, sICallbackNm,
608	fMustSucceed = True, sLogSuffix = '', aenmEvents = None):
609	"""
610	Registers the callback / event listener.
611	"""
612	dArgsCopy['oVBoxMgr'] = oVBoxMgr;
613	dArgsCopy['oListener'] = None;
614	if fpApiVer < 3.3:
615	dArgsCopy['oEventSrc'] = oSrcParent;
616	try:
617	oRet = oVBoxMgr.createCallback(sICallbackNm, oSubClass, dArgsCopy);
618	except:
619	reporter.errorXcpt('%s::registerCallback(%s) failed%s' % (sSrcParentNm, oRet, sLogSuffix));
620	else:
621	try:
622	oSrcParent.registerCallback(oRet);
623	return oRet;
624	except Exception as oXcpt:
625	if fMustSucceed or ComError.notEqual(oXcpt, ComError.E_UNEXPECTED):
626	reporter.errorXcpt('%s::registerCallback(%s)%s' % (sSrcParentNm, oRet, sLogSuffix));
627	else:
628	#
629	# Scalable event handling introduced in VBox 4.0.
630	#
631	fPassive = sys.platform == 'win32'; # or webservices.
632
633	if not aenmEvents:
634	aenmEvents = (vboxcon.VBoxEventType_Any,);
635
636	try:
637	oEventSrc = oSrcParent.eventSource;
638	dArgsCopy['oEventSrc'] = oEventSrc;
639	if not fPassive:
640	oListener = oRet = oVBoxMgr.createListener(oSubClass, dArgsCopy);
641	else:
642	oListener = oEventSrc.createListener();
643	dArgsCopy['oListener'] = oListener;
644	oRet = oSubClass(dArgsCopy);
645	except:
646	reporter.errorXcpt('%s::eventSource.createListener(%s) failed%s' % (sSrcParentNm, oListener, sLogSuffix));
647	else:
648	try:
649	oEventSrc.registerListener(oListener, aenmEvents, not fPassive);
650	except Exception as oXcpt:
651	if fMustSucceed or ComError.notEqual(oXcpt, ComError.E_UNEXPECTED):
652	reporter.errorXcpt('%s::eventSource.registerListener(%s) failed%s'
653	% (sSrcParentNm, oListener, sLogSuffix));
654	else:
655	if not fPassive:
656	if sys.platform == 'win32':
657	from win32com.server.util import unwrap # pylint: disable=import-error
658	oRet = unwrap(oRet);
659	oRet.oListener = oListener;
660	else:
661	oRet.startThreadForPassiveMode();
662	return oRet;
663	return None;
664
665
666
667
668	class ConsoleEventHandlerBase(EventHandlerBase):
669	"""
670	Base class for handling IConsole events.
671
672	The class has IConsoleCallback (<=3.2) compatible callback methods which
673	the user can override as needed.
674
675	Note! This class must not inherit from object or we'll get type errors in VBoxPython.
676	"""
677	def __init__(self, dArgs, sName = None):
678	self.oSession = dArgs['oSession'];
679	self.oConsole = dArgs['oConsole'];
680	if sName is None:
681	sName = self.oSession.sName;
682	EventHandlerBase.__init__(self, dArgs, self.oSession.fpApiVer, sName);
683
684
685	# pylint: disable=missing-docstring,too-many-arguments,unused-argument
686	def onMousePointerShapeChange(self, fVisible, fAlpha, xHot, yHot, cx, cy, abShape):
687	reporter.log2('onMousePointerShapeChange/%s' % (self.sName));
688	def onMouseCapabilityChange(self, fSupportsAbsolute, *aArgs): # Extra argument was added in 3.2.
689	reporter.log2('onMouseCapabilityChange/%s' % (self.sName));
690	def onKeyboardLedsChange(self, fNumLock, fCapsLock, fScrollLock):
691	reporter.log2('onKeyboardLedsChange/%s' % (self.sName));
692	def onStateChange(self, eState):
693	reporter.log2('onStateChange/%s' % (self.sName));
694	def onAdditionsStateChange(self):
695	reporter.log2('onAdditionsStateChange/%s' % (self.sName));
696	def onNetworkAdapterChange(self, oNic):
697	reporter.log2('onNetworkAdapterChange/%s' % (self.sName));
698	def onSerialPortChange(self, oPort):
699	reporter.log2('onSerialPortChange/%s' % (self.sName));
700	def onParallelPortChange(self, oPort):
701	reporter.log2('onParallelPortChange/%s' % (self.sName));
702	def onStorageControllerChange(self):
703	reporter.log2('onStorageControllerChange/%s' % (self.sName));
704	def onMediumChange(self, attachment):
705	reporter.log2('onMediumChange/%s' % (self.sName));
706	def onCPUChange(self, iCpu, fAdd):
707	reporter.log2('onCPUChange/%s' % (self.sName));
708	def onVRDPServerChange(self):
709	reporter.log2('onVRDPServerChange/%s' % (self.sName));
710	def onRemoteDisplayInfoChange(self):
711	reporter.log2('onRemoteDisplayInfoChange/%s' % (self.sName));
712	def onUSBControllerChange(self):
713	reporter.log2('onUSBControllerChange/%s' % (self.sName));
714	def onUSBDeviceStateChange(self, oDevice, fAttached, oError):
715	reporter.log2('onUSBDeviceStateChange/%s' % (self.sName));
716	def onSharedFolderChange(self, fGlobal):
717	reporter.log2('onSharedFolderChange/%s' % (self.sName));
718	def onRuntimeError(self, fFatal, sErrId, sMessage):
719	reporter.log2('onRuntimeError/%s' % (self.sName));
720	def onCanShowWindow(self):
721	reporter.log2('onCanShowWindow/%s' % (self.sName));
722	return True
723	def onShowWindow(self):
724	reporter.log2('onShowWindow/%s' % (self.sName));
725	return None;
726	# pylint: enable=missing-docstring,too-many-arguments,unused-argument
727
728	def handleEvent(self, oEvt):
729	"""
730	Compatibility wrapper.
731	"""
732	try:
733	oEvtBase = self.oVBoxMgr.queryInterface(oEvt, 'IEvent');
734	eType = oEvtBase.type;
735	except:
736	reporter.logXcpt();
737	return None;
738	if eType == vboxcon.VBoxEventType_OnRuntimeError:
739	try:
740	oEvtIt = self.oVBoxMgr.queryInterface(oEvtBase, 'IRuntimeErrorEvent');
741	return self.onRuntimeError(oEvtIt.fatal, oEvtIt.id, oEvtIt.message)
742	except:
743	reporter.logXcpt();
744	## @todo implement the other events.
745	try:
746	if eType not in (vboxcon.VBoxEventType_OnMousePointerShapeChanged,
747	vboxcon.VBoxEventType_OnCursorPositionChanged):
748	if eType in self.dEventNo2Name:
749	reporter.log2('%s(%s)/%s' % (self.dEventNo2Name[eType], str(eType), self.sName));
750	else:
751	reporter.log2('%s/%s' % (str(eType), self.sName));
752	except AttributeError: # Handle older VBox versions which don't have a specific event.
753	pass;
754	return None;
755
756
757	class VirtualBoxEventHandlerBase(EventHandlerBase):
758	"""
759	Base class for handling IVirtualBox events.
760
761	The class has IConsoleCallback (<=3.2) compatible callback methods which
762	the user can override as needed.
763
764	Note! This class must not inherit from object or we'll get type errors in VBoxPython.
765	"""
766	def __init__(self, dArgs, sName = "emanon"):
767	self.oVBoxMgr = dArgs['oVBoxMgr'];
768	self.oVBox = dArgs['oVBox'];
769	EventHandlerBase.__init__(self, dArgs, self.oVBox.fpApiVer, sName);
770
771	# pylint: disable=missing-docstring,unused-argument
772	def onMachineStateChange(self, sMachineId, eState):
773	pass;
774	def onMachineDataChange(self, sMachineId):
775	pass;
776	def onExtraDataCanChange(self, sMachineId, sKey, sValue):
777	# The COM bridge does tuples differently. Not very funny if you ask me... ;-)
778	if self.oVBoxMgr.type == 'MSCOM':
779	return '', 0, True;
780	return True, ''
781	def onExtraDataChange(self, sMachineId, sKey, sValue):
782	pass;
783	def onMediumRegistered(self, sMediumId, eMediumType, fRegistered):
784	pass;
785	def onMachineRegistered(self, sMachineId, fRegistered):
786	pass;
787	def onSessionStateChange(self, sMachineId, eState):
788	pass;
789	def onSnapshotTaken(self, sMachineId, sSnapshotId):
790	pass;
791	def onSnapshotDiscarded(self, sMachineId, sSnapshotId):
792	pass;
793	def onSnapshotChange(self, sMachineId, sSnapshotId):
794	pass;
795	def onGuestPropertyChange(self, sMachineId, sName, sValue, sFlags, fWasDeleted):
796	pass;
797	# pylint: enable=missing-docstring,unused-argument
798
799	def handleEvent(self, oEvt):
800	"""
801	Compatibility wrapper.
802	"""
803	try:
804	oEvtBase = self.oVBoxMgr.queryInterface(oEvt, 'IEvent');
805	eType = oEvtBase.type;
806	except:
807	reporter.logXcpt();
808	return None;
809	if eType == vboxcon.VBoxEventType_OnMachineStateChanged:
810	try:
811	oEvtIt = self.oVBoxMgr.queryInterface(oEvtBase, 'IMachineStateChangedEvent');
812	return self.onMachineStateChange(oEvtIt.machineId, oEvtIt.state)
813	except:
814	reporter.logXcpt();
815	elif eType == vboxcon.VBoxEventType_OnGuestPropertyChanged:
816	try:
817	oEvtIt = self.oVBoxMgr.queryInterface(oEvtBase, 'IGuestPropertyChangedEvent');
818	if hasattr(oEvtIt, 'fWasDeleted'): # Since 7.0 we have a dedicated flag
819	fWasDeleted = oEvtIt.fWasDeleted;
820	else:
821	fWasDeleted = False; # Don't indicate deletion here -- there can be empty guest properties.
822	return self.onGuestPropertyChange(oEvtIt.machineId, oEvtIt.name, oEvtIt.value, oEvtIt.flags, fWasDeleted);
823	except:
824	reporter.logXcpt();
825	## @todo implement the other events.
826	if eType in self.dEventNo2Name:
827	reporter.log2('%s(%s)/%s' % (self.dEventNo2Name[eType], str(eType), self.sName));
828	else:
829	reporter.log2('%s/%s' % (str(eType), self.sName));
830	return None;
831
832
833	class SessionConsoleEventHandler(ConsoleEventHandlerBase):
834	"""
835	For catching machine state changes and waking up the task machinery at that point.
836	"""
837	def __init__(self, dArgs):
838	ConsoleEventHandlerBase.__init__(self, dArgs);
839
840	def onMachineStateChange(self, sMachineId, eState): # pylint: disable=unused-argument
841	""" Just interrupt the wait loop here so it can check again. """
842	_ = sMachineId; _ = eState;
843	self.oVBoxMgr.interruptWaitEvents();
844
845	def onRuntimeError(self, fFatal, sErrId, sMessage):
846	reporter.log('onRuntimeError/%s: fFatal=%d sErrId=%s sMessage=%s' % (self.sName, fFatal, sErrId, sMessage));
847	oSession = self.oSession;
848	if oSession is not None: # paranoia
849	if sErrId == 'HostMemoryLow':
850	oSession.signalHostMemoryLow();
851	if sys.platform == 'win32':
852	from testdriver import winbase;
853	winbase.logMemoryStats();
854	oSession.signalTask();
855	self.oVBoxMgr.interruptWaitEvents();
856
857
858
859	class TestDriver(base.TestDriver): # pylint: disable=too-many-instance-attributes
860	"""
861	This is the VirtualBox test driver.
862	"""
863
864	def __init__(self):
865	base.TestDriver.__init__(self);
866	self.fImportedVBoxApi = False;
867	self.fpApiVer = 3.2;
868	self.uRevision = 0;
869	self.uApiRevision = 0;
870	self.oBuild = None;
871	self.oVBoxMgr = None;
872	self.oVBox = None;
873	self.aoRemoteSessions = [];
874	self.aoVMs = []; ## @todo not sure if this list will be of any use.
875	self.oTestVmManager = vboxtestvms.TestVmManager(self.sResourcePath);
876	self.oTestVmSet = vboxtestvms.TestVmSet();
877	self.sSessionTypeDef = 'headless';
878	self.sSessionType = self.sSessionTypeDef;
879	self.fEnableVrdp = True;
880	self.uVrdpBasePortDef = 6000;
881	self.uVrdpBasePort = self.uVrdpBasePortDef;
882	self.sDefBridgedNic = None;
883	self.fUseDefaultSvc = False;
884	self.sLogSelfGroups = '';
885	self.sLogSelfFlags = 'time';
886	self.sLogSelfDest = '';
887	self.sLogSessionGroups = '';
888	self.sLogSessionFlags = 'time';
889	self.sLogSessionDest = '';
890	self.sLogSvcGroups = '';
891	self.sLogSvcFlags = 'time';
892	self.sLogSvcDest = '';
893	self.sSelfLogFile = None;
894	self.sSessionLogFile = None;
895	self.sVBoxSvcLogFile = None;
896	self.oVBoxSvcProcess = None;
897	self.sVBoxSvcPidFile = None;
898	self.fVBoxSvcInDebugger = False;
899	self.fVBoxSvcWaitForDebugger = False;
900	self.sVBoxValidationKit = None;
901	self.sVBoxValidationKitIso = None;
902	self.sVBoxBootSectors = None;
903	self.fAlwaysUploadLogs = False;
904	self.fAlwaysUploadScreenshots = False;
905	self.fAlwaysUploadRecordings = False; # Only upload recording files on failure by default.
906	self.fEnableDebugger = True;
907	self.fVmNoTerminate = False; # Whether to skip exit handling and tearing down the VMs.
908	self.adRecordingFiles = [];
909	self.fRecordingEnabled = False; # Don't record by default (yet).
910	self.fRecordingAudio = False; # Don't record audio by default.
911	self.cSecsRecordingMax = 0; # No recording time limit in seconds.
912	self.cMbRecordingMax = 195; # The test manager web server has a configured upload limit of 200 MiBs.
913	## @todo Can we query the configured value here
914	# (via `from testmanager import config`)?
915
916	# Drop LD_PRELOAD and enable memory leak detection in LSAN_OPTIONS from vboxinstall.py
917	# before doing build detection. This is a little crude and inflexible...
918	if 'LD_PRELOAD' in os.environ:
919	del os.environ['LD_PRELOAD'];
920	if 'LSAN_OPTIONS' in os.environ:
921	asLSanOptions = os.environ['LSAN_OPTIONS'].split(':');
922	try: asLSanOptions.remove('detect_leaks=0');
923	except: pass;
924	if asLSanOptions: os.environ['LSAN_OPTIONS'] = ':'.join(asLSanOptions);
925	else: del os.environ['LSAN_OPTIONS'];
926
927	# Quietly detect build and validation kit.
928	self._detectBuild(False);
929	self._detectValidationKit(False);
930
931	# Make sure all debug logs goes to the scratch area unless
932	# specified otherwise (more of this later on).
933	if 'VBOX_LOG_DEST' not in os.environ:
934	os.environ['VBOX_LOG_DEST'] = 'nodeny dir=%s' % (self.sScratchPath);
935
936
937	def _detectBuild(self, fQuiet = False):
938	"""
939	This is used internally to try figure a locally installed build when
940	running tests manually.
941	"""
942	if self.oBuild is not None:
943	return True;
944
945	# Try dev build first since that's where I'll be using it first...
946	if True is True: # pylint: disable=comparison-with-itself
947	try:
948	self.oBuild = Build(self, None);
949	reporter.log('VBox %s build at %s (%s).'
950	% (self.oBuild.sType, self.oBuild.sInstallPath, self.oBuild.sDesignation,));
951	return True;
952	except base.GenError:
953	pass;
954
955	# Try default installation locations.
956	if self.sHost == 'win':
957	sProgFiles = os.environ.get('ProgramFiles', 'C:\\Program Files');
958	asLocs = [
959	os.path.join(sProgFiles, 'Oracle', 'VirtualBox'),
960	os.path.join(sProgFiles, 'OracleVM', 'VirtualBox'),
961	os.path.join(sProgFiles, 'Sun', 'VirtualBox'),
962	];
963	elif self.sHost == 'solaris':
964	asLocs = [ '/opt/VirtualBox-3.2', '/opt/VirtualBox-3.1', '/opt/VirtualBox-3.0', '/opt/VirtualBox' ];
965	elif self.sHost == 'darwin':
966	asLocs = [ '/Applications/VirtualBox.app/Contents/MacOS' ];
967	elif self.sHost == 'linux':
968	asLocs = [ '/opt/VirtualBox-3.2', '/opt/VirtualBox-3.1', '/opt/VirtualBox-3.0', '/opt/VirtualBox' ];
969	else:
970	asLocs = [ '/opt/VirtualBox' ];
971	if 'VBOX_INSTALL_PATH' in os.environ:
972	asLocs.insert(0, os.environ['VBOX_INSTALL_PATH']);
973
974	for sLoc in asLocs:
975	try:
976	self.oBuild = Build(self, sLoc);
977	reporter.log('VBox %s build at %s (%s).'
978	% (self.oBuild.sType, self.oBuild.sInstallPath, self.oBuild.sDesignation,));
979	return True;
980	except base.GenError:
981	pass;
982
983	if not fQuiet:
984	reporter.error('failed to find VirtualBox installation');
985	return False;
986
987	def _detectValidationKit(self, fQuiet = False):
988	"""
989	This is used internally by the constructor to try locate an unzipped
990	VBox Validation Kit somewhere in the immediate proximity.
991	"""
992	if self.sVBoxValidationKit is not None:
993	return True;
994
995	#
996	# Normally it's found where we're running from, which is the same as
997	# the script directly on the testboxes.
998	#
999	asCandidates = [self.sScriptPath, ];
1000	if g_ksValidationKitDir not in asCandidates:
1001	asCandidates.append(g_ksValidationKitDir);
1002	if os.getcwd() not in asCandidates:
1003	asCandidates.append(os.getcwd());
1004	if self.oBuild is not None and self.oBuild.sInstallPath not in asCandidates:
1005	asCandidates.append(self.oBuild.sInstallPath);
1006
1007	#
1008	# When working out of the tree, we'll search the current directory
1009	# as well as parent dirs.
1010	#
1011	for sDir in list(asCandidates):
1012	for i in range(10):
1013	sDir = os.path.dirname(sDir);
1014	if sDir not in asCandidates:
1015	asCandidates.append(sDir);
1016
1017	#
1018	# Do the searching.
1019	#
1020	sCandidate = None;
1021	for i, _ in enumerate(asCandidates):
1022	sCandidate = asCandidates[i];
1023	if os.path.isfile(os.path.join(sCandidate, 'VBoxValidationKit.iso')):
1024	break;
1025	sCandidate = os.path.join(sCandidate, 'validationkit');
1026	if os.path.isfile(os.path.join(sCandidate, 'VBoxValidationKit.iso')):
1027	break;
1028	sCandidate = None;
1029
1030	fRc = sCandidate is not None;
1031	if fRc is False:
1032	if not fQuiet:
1033	reporter.error('failed to find VBox Validation Kit installation (candidates: %s)' % (asCandidates,));
1034	sCandidate = os.path.join(self.sScriptPath, 'validationkit'); # Don't leave the values as None.
1035
1036	#
1037	# Set the member values.
1038	#
1039	self.sVBoxValidationKit = sCandidate;
1040	self.sVBoxValidationKitIso = os.path.join(sCandidate, 'VBoxValidationKit.iso');
1041	self.sVBoxBootSectors = os.path.join(sCandidate, 'bootsectors');
1042	return fRc;
1043
1044	def _makeEnvironmentChanges(self):
1045	"""
1046	Make the necessary VBox related environment changes.
1047	Children not importing the VBox API should call this.
1048	"""
1049	# Make sure we've got our own VirtualBox config and VBoxSVC (on XPCOM at least).
1050	if not self.fUseDefaultSvc:
1051	os.environ['VBOX_USER_HOME'] = os.path.join(self.sScratchPath, 'VBoxUserHome');
1052	sUser = os.environ.get('USERNAME', os.environ.get('USER', os.environ.get('LOGNAME', 'unknown')));
1053	os.environ['VBOX_IPC_SOCKETID'] = sUser + '-VBoxTest';
1054	return True;
1055
1056	@staticmethod
1057	def makeApiRevision(uMajor, uMinor, uBuild, uApiRevision):
1058	""" Calculates an API revision number. """
1059	return (long(uMajor) << 56) \| (long(uMinor) << 48) \| (long(uBuild) << 40) \| uApiRevision;
1060
1061	def importVBoxApi(self):
1062	"""
1063	Import the 'vboxapi' module from the VirtualBox build we're using and
1064	instantiate the two basic objects.
1065
1066	This will try detect an development or installed build if no build has
1067	been associated with the driver yet.
1068	"""
1069	if self.fImportedVBoxApi:
1070	return True;
1071
1072	self._makeEnvironmentChanges();
1073
1074	# Do the detecting.
1075	self._detectBuild();
1076	if self.oBuild is None:
1077	return False;
1078
1079	# Avoid crashing when loading the 32-bit module (or whatever it is that goes bang).
1080	if self.oBuild.sArch == 'x86' \
1081	and self.sHost == 'darwin' \
1082	and platform.architecture()[0] == '64bit' \
1083	and self.oBuild.sKind == 'development' \
1084	and os.getenv('VERSIONER_PYTHON_PREFER_32_BIT') != 'yes':
1085	reporter.log("WARNING: 64-bit python on darwin, 32-bit VBox development build => crash");
1086	reporter.log("WARNING: bash-3.2$ /usr/bin/python2.5 ./testdriver");
1087	reporter.log("WARNING: or");
1088	reporter.log("WARNING: bash-3.2$ VERSIONER_PYTHON_PREFER_32_BIT=yes ./testdriver");
1089	return False;
1090
1091	# Start VBoxSVC and load the vboxapi bits.
1092	if self._startVBoxSVC() is True:
1093	assert(self.oVBoxSvcProcess is not None);
1094
1095	sSavedSysPath = sys.path;
1096	self._setupVBoxApi();
1097	sys.path = sSavedSysPath;
1098
1099	# Adjust the default machine folder.
1100	if self.fImportedVBoxApi and not self.fUseDefaultSvc and self.fpApiVer >= 4.0:
1101	sNewFolder = os.path.join(self.sScratchPath, 'VBoxUserHome', 'Machines');
1102	try:
1103	self.oVBox.systemProperties.defaultMachineFolder = sNewFolder;
1104	except:
1105	self.fImportedVBoxApi = False;
1106	self.oVBoxMgr = None;
1107	self.oVBox = None;
1108	reporter.logXcpt("defaultMachineFolder exception (sNewFolder=%s)" % (sNewFolder,));
1109
1110	# Kill VBoxSVC on failure.
1111	if self.oVBoxMgr is None:
1112	self._stopVBoxSVC();
1113	else:
1114	assert(self.oVBoxSvcProcess is None);
1115	return self.fImportedVBoxApi;
1116
1117	def _startVBoxSVC(self): # pylint: disable=too-many-statements
1118	""" Starts VBoxSVC. """
1119	assert(self.oVBoxSvcProcess is None);
1120
1121	# Setup vbox logging for VBoxSVC now and start it manually. This way
1122	# we can control both logging and shutdown.
1123	self.sVBoxSvcLogFile = '%s/VBoxSVC-debug.log' % (self.sScratchPath,);
1124	try: os.remove(self.sVBoxSvcLogFile);
1125	except: pass;
1126	os.environ['VBOX_LOG'] = self.sLogSvcGroups;
1127	os.environ['VBOX_LOG_FLAGS'] = '%s append' % (self.sLogSvcFlags,); # Append becuse of VBoxXPCOMIPCD.
1128	if self.sLogSvcDest:
1129	os.environ['VBOX_LOG_DEST'] = 'nodeny ' + self.sLogSvcDest;
1130	else:
1131	os.environ['VBOX_LOG_DEST'] = 'nodeny file=%s' % (self.sVBoxSvcLogFile,);
1132	os.environ['VBOXSVC_RELEASE_LOG_FLAGS'] = 'time append';
1133
1134	reporter.log2('VBoxSVC environment:');
1135	for sKey, sVal in sorted(os.environ.items()):
1136	reporter.log2('%s=%s' % (sKey, sVal));
1137
1138	# Always leave a pid file behind so we can kill it during cleanup-before.
1139	self.sVBoxSvcPidFile = '%s/VBoxSVC.pid' % (self.sScratchPath,);
1140	fWritePidFile = True;
1141
1142	cMsFudge = 1;
1143	sVBoxSVC = '%s/VBoxSVC' % (self.oBuild.sInstallPath,); ## @todo .exe and stuff.
1144	if self.fVBoxSvcInDebugger:
1145	if self.sHost in ('darwin', 'freebsd', 'linux', 'solaris', ):
1146	# Start VBoxSVC in gdb in a new terminal.
1147	#sTerm = '/usr/bin/gnome-terminal'; - doesn't work, some fork+exec stuff confusing us.
1148	sTerm = '/usr/bin/xterm';
1149	if not os.path.isfile(sTerm): sTerm = '/usr/X11/bin/xterm';
1150	if not os.path.isfile(sTerm): sTerm = '/usr/X11R6/bin/xterm';
1151	if not os.path.isfile(sTerm): sTerm = '/usr/bin/xterm';
1152	if not os.path.isfile(sTerm): sTerm = 'xterm';
1153	sGdb = '/usr/bin/gdb';
1154	if not os.path.isfile(sGdb): sGdb = '/usr/local/bin/gdb';
1155	if not os.path.isfile(sGdb): sGdb = '/usr/sfw/bin/gdb';
1156	if not os.path.isfile(sGdb): sGdb = 'gdb';
1157	sGdbCmdLine = '%s --args %s --pidfile %s' % (sGdb, sVBoxSVC, self.sVBoxSvcPidFile);
1158	# Cool tweak to run performance analysis instead of gdb:
1159	#sGdb = '/usr/bin/valgrind';
1160	#sGdbCmdLine = '%s --tool=callgrind --collect-atstart=no -- %s --pidfile %s' \
1161	# % (sGdb, sVBoxSVC, self.sVBoxSvcPidFile);
1162	reporter.log('term="%s" gdb="%s"' % (sTerm, sGdbCmdLine));
1163	os.environ['SHELL'] = self.sOrgShell; # Non-working shell may cause gdb and/or the term problems.
1164	## @todo -e is deprecated; use "-- <args>".
1165	self.oVBoxSvcProcess = base.Process.spawnp(sTerm, sTerm, '-e', sGdbCmdLine);
1166	os.environ['SHELL'] = self.sOurShell;
1167	if self.oVBoxSvcProcess is not None:
1168	reporter.log('Press enter or return after starting VBoxSVC in the debugger...');
1169	sys.stdin.read(1);
1170	fWritePidFile = False;
1171
1172	elif self.sHost == 'win':
1173	sWinDbg = 'c:\\Program Files\\Debugging Tools for Windows\\windbg.exe';
1174	if not os.path.isfile(sWinDbg): sWinDbg = 'c:\\Program Files\\Debugging Tools for Windows (x64)\\windbg.exe';
1175	if not os.path.isfile(sWinDbg): sWinDbg = 'c:\\Programme\\Debugging Tools for Windows\\windbg.exe'; # Localization rulez! pylint: disable=line-too-long
1176	if not os.path.isfile(sWinDbg): sWinDbg = 'c:\\Programme\\Debugging Tools for Windows (x64)\\windbg.exe';
1177	if not os.path.isfile(sWinDbg): sWinDbg = 'windbg'; # WinDbg must be in the path; better than nothing.
1178	# Assume that everything WinDbg needs is defined using the environment variables.
1179	# See WinDbg help for more information.
1180	reporter.log('windbg="%s"' % (sWinDbg));
1181	self.oVBoxSvcProcess = base.Process.spawn(sWinDbg, sWinDbg, sVBoxSVC + base.exeSuff());
1182	if self.oVBoxSvcProcess is not None:
1183	reporter.log('Press enter or return after starting VBoxSVC in the debugger...');
1184	sys.stdin.read(1);
1185	fWritePidFile = False;
1186	## @todo add a pipe interface similar to xpcom if feasible, i.e. if
1187	# we can get actual handle values for pipes in python.
1188
1189	else:
1190	reporter.error('Port me!');
1191	else: # Run without a debugger attached.
1192	if self.sHost in ('darwin', 'freebsd', 'linux', 'solaris', ):
1193	#
1194	# XPCOM - We can use a pipe to let VBoxSVC notify us when it's ready.
1195	#
1196	iPipeR, iPipeW = os.pipe();
1197	if hasattr(os, 'set_inheritable'):
1198	os.set_inheritable(iPipeW, True); # pylint: disable=no-member
1199	os.environ['NSPR_INHERIT_FDS'] = 'vboxsvc:startup-pipe:5:0x%x' % (iPipeW,);
1200	reporter.log2("NSPR_INHERIT_FDS=%s" % (os.environ['NSPR_INHERIT_FDS']));
1201
1202	self.oVBoxSvcProcess = base.Process.spawn(sVBoxSVC, sVBoxSVC, '--auto-shutdown'); # SIGUSR1 requirement.
1203	try: # Try make sure we get the SIGINT and not VBoxSVC.
1204	os.setpgid(self.oVBoxSvcProcess.getPid(), 0); # pylint: disable=no-member
1205	os.setpgid(0, 0); # pylint: disable=no-member
1206	except:
1207	reporter.logXcpt();
1208
1209	os.close(iPipeW);
1210	try:
1211	sResponse = os.read(iPipeR, 32);
1212	except:
1213	reporter.logXcpt();
1214	sResponse = None;
1215	os.close(iPipeR);
1216
1217	if hasattr(sResponse, 'decode'):
1218	sResponse = sResponse.decode('utf-8', 'ignore');
1219
1220	if sResponse is None or sResponse.strip() != 'READY':
1221	reporter.error('VBoxSVC failed starting up... (sResponse=%s)' % (sResponse,));
1222	if not self.oVBoxSvcProcess.wait(5000):
1223	self.oVBoxSvcProcess.terminate();
1224	self.oVBoxSvcProcess.wait(5000);
1225	self.oVBoxSvcProcess = None;
1226
1227	elif self.sHost == 'win':
1228	#
1229	# Windows - Just fudge it for now.
1230	#
1231	cMsFudge = 2000;
1232	self.oVBoxSvcProcess = base.Process.spawn(sVBoxSVC, sVBoxSVC);
1233
1234	else:
1235	reporter.error('Port me!');
1236
1237	#
1238	# Enable automatic crash reporting if we succeeded.
1239	#
1240	if self.oVBoxSvcProcess is not None:
1241	self.oVBoxSvcProcess.enableCrashReporting('crash/report/svc', 'crash/dump/svc');
1242
1243	#
1244	# Wait for debugger to attach.
1245	#
1246	if self.oVBoxSvcProcess is not None and self.fVBoxSvcWaitForDebugger:
1247	reporter.log('Press any key after attaching to VBoxSVC (pid %s) with a debugger...'
1248	% (self.oVBoxSvcProcess.getPid(),));
1249	sys.stdin.read(1);
1250
1251	#
1252	# Fudge and pid file.
1253	#
1254	if self.oVBoxSvcProcess is not None and not self.oVBoxSvcProcess.wait(cMsFudge):
1255	if fWritePidFile:
1256	iPid = self.oVBoxSvcProcess.getPid();
1257	try:
1258	oFile = utils.openNoInherit(self.sVBoxSvcPidFile, "w+");
1259	oFile.write('%s' % (iPid,));
1260	oFile.close();
1261	except:
1262	reporter.logXcpt('sPidFile=%s' % (self.sVBoxSvcPidFile,));
1263	reporter.log('VBoxSVC PID=%u' % (iPid,));
1264
1265	#
1266	# Finally add the task so we'll notice when it dies in a relatively timely manner.
1267	#
1268	self.addTask(self.oVBoxSvcProcess);
1269	else:
1270	self.oVBoxSvcProcess = None;
1271	try: os.remove(self.sVBoxSvcPidFile);
1272	except: pass;
1273
1274	return self.oVBoxSvcProcess is not None;
1275
1276
1277	def _killVBoxSVCByPidFile(self, sPidFile):
1278	""" Kill a VBoxSVC given the pid from it's pid file. """
1279
1280	# Read the pid file.
1281	if not os.path.isfile(sPidFile):
1282	return False;
1283	try:
1284	oFile = utils.openNoInherit(sPidFile, "r");
1285	sPid = oFile.readline().strip();
1286	oFile.close();
1287	except:
1288	reporter.logXcpt('sPidfile=%s' % (sPidFile,));
1289	return False;
1290
1291	# Convert the pid to an integer and validate the range a little bit.
1292	try:
1293	iPid = long(sPid);
1294	except:
1295	reporter.logXcpt('sPidfile=%s sPid="%s"' % (sPidFile, sPid));
1296	return False;
1297	if iPid <= 0:
1298	reporter.log('negative pid - sPidfile=%s sPid="%s" iPid=%d' % (sPidFile, sPid, iPid));
1299	return False;
1300
1301	# Take care checking that it's VBoxSVC we're about to inhume.
1302	if base.processCheckPidAndName(iPid, "VBoxSVC") is not True:
1303	reporter.log('Ignoring stale VBoxSVC pid file (pid=%s)' % (iPid,));
1304	return False;
1305
1306	# Loop thru our different ways of getting VBoxSVC to terminate.
1307	for aHow in [ [ base.sendUserSignal1, 5000, 'Dropping VBoxSVC a SIGUSR1 hint...'], \
1308	[ base.processInterrupt, 5000, 'Dropping VBoxSVC a SIGINT hint...'], \
1309	[ base.processTerminate, 7500, 'VBoxSVC is still around, killing it...'] ]:
1310	reporter.log(aHow[2]);
1311	if aHow[0](iPid) is True:
1312	msStart = base.timestampMilli();
1313	while base.timestampMilli() - msStart < 5000 \
1314	and base.processExists(iPid):
1315	time.sleep(0.2);
1316
1317	fRc = not base.processExists(iPid);
1318	if fRc is True:
1319	break;
1320	if fRc:
1321	reporter.log('Successfully killed VBoxSVC (pid=%s)' % (iPid,));
1322	else:
1323	reporter.log('Failed to kill VBoxSVC (pid=%s)' % (iPid,));
1324	return fRc;
1325
1326	def _stopVBoxSVC(self):
1327	"""
1328	Stops VBoxSVC. Try the polite way first.
1329	"""
1330
1331	if self.oVBoxSvcProcess:
1332	self.removeTask(self.oVBoxSvcProcess);
1333	self.oVBoxSvcProcess.enableCrashReporting(None, None); # Disables it.
1334
1335	fRc = False;
1336	if self.oVBoxSvcProcess is not None \
1337	and not self.fVBoxSvcInDebugger:
1338	# by process object.
1339	if self.oVBoxSvcProcess.isRunning():
1340	reporter.log('Dropping VBoxSVC a SIGUSR1 hint...');
1341	if not self.oVBoxSvcProcess.sendUserSignal1() \
1342	or not self.oVBoxSvcProcess.wait(5000):
1343	reporter.log('Dropping VBoxSVC a SIGINT hint...');
1344	if not self.oVBoxSvcProcess.interrupt() \
1345	or not self.oVBoxSvcProcess.wait(5000):
1346	reporter.log('VBoxSVC is still around, killing it...');
1347	self.oVBoxSvcProcess.terminate();
1348	self.oVBoxSvcProcess.wait(7500);
1349	else:
1350	reporter.log('VBoxSVC is no longer running...');
1351
1352	if not self.oVBoxSvcProcess.isRunning():
1353	iExit = self.oVBoxSvcProcess.getExitCode();
1354	if iExit != 0 or not self.oVBoxSvcProcess.isNormalExit():
1355	reporter.error("VBoxSVC exited with status %d (%#x)" % (iExit, self.oVBoxSvcProcess.uExitCode));
1356	self.oVBoxSvcProcess = None;
1357	else:
1358	# by pid file.
1359	self._killVBoxSVCByPidFile('%s/VBoxSVC.pid' % (self.sScratchPath,));
1360	return fRc;
1361
1362	def _setupVBoxApi(self):
1363	"""
1364	Import and set up the vboxapi.
1365	The caller saves and restores sys.path.
1366	"""
1367
1368	# Setup vbox logging for self (the test driver).
1369	self.sSelfLogFile = '%s/VBoxTestDriver.log' % (self.sScratchPath,);
1370	try: os.remove(self.sSelfLogFile);
1371	except: pass;
1372	os.environ['VBOX_LOG'] = self.sLogSelfGroups;
1373	os.environ['VBOX_LOG_FLAGS'] = '%s append' % (self.sLogSelfFlags, );
1374	if self.sLogSelfDest:
1375	os.environ['VBOX_LOG_DEST'] = 'nodeny ' + self.sLogSelfDest;
1376	else:
1377	os.environ['VBOX_LOG_DEST'] = 'nodeny file=%s' % (self.sSelfLogFile,);
1378	os.environ['VBOX_RELEASE_LOG_FLAGS'] = 'time append';
1379
1380	reporter.log2('Self environment:');
1381	for sKey, sVal in sorted(os.environ.items()):
1382	reporter.log2('%s=%s' % (sKey, sVal));
1383
1384	# Hack the sys.path + environment so the vboxapi can be found.
1385	sys.path.insert(0, self.oBuild.sInstallPath);
1386	if self.oBuild.sSdkPath is not None:
1387	sys.path.insert(0, os.path.join(self.oBuild.sSdkPath, 'installer'))
1388	sys.path.insert(1, os.path.join(self.oBuild.sSdkPath, 'install')); # stupid stupid windows installer!
1389	sys.path.insert(2, os.path.join(self.oBuild.sSdkPath, 'bindings', 'xpcom', 'python'))
1390	os.environ['VBOX_PROGRAM_PATH'] = self.oBuild.sInstallPath;
1391	reporter.log("sys.path: %s" % (sys.path));
1392
1393	try:
1394	from vboxapi import VirtualBoxManager; # pylint: disable=import-error
1395	except:
1396	reporter.logXcpt('Error importing vboxapi');
1397	return False;
1398
1399	# Exception and error hacks.
1400	try:
1401	# pylint: disable=import-error
1402	if self.sHost == 'win':
1403	from pythoncom import com_error as NativeComExceptionClass # pylint: disable=no-name-in-module
1404	import winerror as NativeComErrorClass
1405	else:
1406	from xpcom import Exception as NativeComExceptionClass
1407	from xpcom import nsError as NativeComErrorClass
1408	# pylint: enable=import-error
1409	except:
1410	reporter.logXcpt('Error importing (XP)COM related stuff for exception hacks and errors');
1411	return False;
1412	__deployExceptionHacks__(NativeComExceptionClass)
1413	ComError.copyErrors(NativeComErrorClass);
1414
1415	# Create the manager.
1416	try:
1417	self.oVBoxMgr = VirtualBoxManager(None, None)
1418	except:
1419	self.oVBoxMgr = None;
1420	reporter.logXcpt('VirtualBoxManager exception');
1421	return False;
1422
1423	# Figure the API version.
1424	try:
1425	oVBox = self.oVBoxMgr.getVirtualBox();
1426
1427	try:
1428	sVer = oVBox.version;
1429	except:
1430	reporter.logXcpt('Failed to get VirtualBox version, assuming 4.0.0');
1431	sVer = "4.0.0";
1432	reporter.log("IVirtualBox.version=%s" % (sVer,));
1433
1434	# Convert the string to three integer values and check ranges.
1435	asVerComponents = sVer.split('.');
1436	try:
1437	sLast = asVerComponents[2].split('_')[0].split('r')[0];
1438	aiVerComponents = (int(asVerComponents[0]), int(asVerComponents[1]), int(sLast));
1439	except:
1440	raise base.GenError('Malformed version "%s"' % (sVer,));
1441	if aiVerComponents[0] < 3 or aiVerComponents[0] > 19:
1442	raise base.GenError('Malformed version "%s" - 1st component is out of bounds 3..19: %u'
1443	% (sVer, aiVerComponents[0]));
1444	if aiVerComponents[1] < 0 or aiVerComponents[1] > 9:
1445	raise base.GenError('Malformed version "%s" - 2nd component is out of bounds 0..9: %u'
1446	% (sVer, aiVerComponents[1]));
1447	if aiVerComponents[2] < 0 or aiVerComponents[2] > 99:
1448	raise base.GenError('Malformed version "%s" - 3rd component is out of bounds 0..99: %u'
1449	% (sVer, aiVerComponents[2]));
1450
1451	# Convert the three integers into a floating point value. The API is stable within a
1452	# x.y release, so the third component only indicates whether it's a stable or
1453	# development build of the next release.
1454	self.fpApiVer = aiVerComponents[0] + 0.1 * aiVerComponents[1];
1455	if aiVerComponents[2] >= 51:
1456	if self.fpApiVer not in [6.1, 5.2, 4.3, 3.2,]:
1457	self.fpApiVer += 0.1;
1458	else:
1459	self.fpApiVer = int(self.fpApiVer) + 1.0;
1460	# fudge value to be always bigger than the nominal value (0.1 gets rounded down)
1461	if round(self.fpApiVer, 1) > self.fpApiVer:
1462	self.fpApiVer += sys.float_info.epsilon * self.fpApiVer / 2.0;
1463
1464	try:
1465	self.uRevision = oVBox.revision;
1466	except:
1467	reporter.logXcpt('Failed to get VirtualBox revision, assuming 0');
1468	self.uRevision = 0;
1469	reporter.log("IVirtualBox.revision=%u" % (self.uRevision,));
1470
1471	try:
1472	self.uApiRevision = oVBox.APIRevision;
1473	except:
1474	reporter.logXcpt('Failed to get VirtualBox APIRevision, faking it.');
1475	self.uApiRevision = self.makeApiRevision(aiVerComponents[0], aiVerComponents[1], aiVerComponents[2], 0);
1476	reporter.log("IVirtualBox.APIRevision=%#x" % (self.uApiRevision,));
1477
1478	# Patch VBox manage to gloss over portability issues (error constants, etc).
1479	self._patchVBoxMgr();
1480
1481	# Wrap oVBox.
1482	from testdriver.vboxwrappers import VirtualBoxWrapper;
1483	self.oVBox = VirtualBoxWrapper(oVBox, self.oVBoxMgr, self.fpApiVer, self);
1484
1485	# Install the constant wrapping hack.
1486	vboxcon.goHackModuleClass.oVBoxMgr = self.oVBoxMgr; # VBoxConstantWrappingHack.
1487	vboxcon.fpApiVer = self.fpApiVer;
1488	reporter.setComXcptFormatter(formatComOrXpComException);
1489
1490	except:
1491	self.oVBoxMgr = None;
1492	self.oVBox = None;
1493	reporter.logXcpt("getVirtualBox / API version exception");
1494	return False;
1495
1496	# Done
1497	self.fImportedVBoxApi = True;
1498	reporter.log('Found version %s (%s)' % (self.fpApiVer, sVer));
1499	return True;
1500
1501	def _patchVBoxMgr(self):
1502	"""
1503	Glosses over missing self.oVBoxMgr methods on older VBox versions.
1504	"""
1505
1506	def _xcptGetResult(oSelf, oXcpt = None):
1507	""" See vboxapi. """
1508	_ = oSelf;
1509	if oXcpt is None: oXcpt = sys.exc_info()[1];
1510	if sys.platform == 'win32':
1511	import winerror; # pylint: disable=import-error
1512	hrXcpt = oXcpt.hresult;
1513	if hrXcpt == winerror.DISP_E_EXCEPTION:
1514	hrXcpt = oXcpt.excepinfo[5];
1515	else:
1516	hrXcpt = oXcpt.error;
1517	return hrXcpt;
1518
1519	def _xcptIsDeadInterface(oSelf, oXcpt = None):
1520	""" See vboxapi. """
1521	return oSelf.xcptGetStatus(oXcpt) in [
1522	0x80004004, -2147467260, # NS_ERROR_ABORT
1523	0x800706be, -2147023170, # NS_ERROR_CALL_FAILED (RPC_S_CALL_FAILED)
1524	0x800706ba, -2147023174, # RPC_S_SERVER_UNAVAILABLE.
1525	0x800706be, -2147023170, # RPC_S_CALL_FAILED.
1526	0x800706bf, -2147023169, # RPC_S_CALL_FAILED_DNE.
1527	0x80010108, -2147417848, # RPC_E_DISCONNECTED.
1528	0x800706b5, -2147023179, # RPC_S_UNKNOWN_IF
1529	];
1530
1531	def _xcptIsOurXcptKind(oSelf, oXcpt = None):
1532	""" See vboxapi. """
1533	_ = oSelf;
1534	if oXcpt is None: oXcpt = sys.exc_info()[1];
1535	if sys.platform == 'win32':
1536	from pythoncom import com_error as NativeComExceptionClass # pylint: disable=import-error,no-name-in-module
1537	else:
1538	from xpcom import Exception as NativeComExceptionClass # pylint: disable=import-error
1539	return isinstance(oXcpt, NativeComExceptionClass);
1540
1541	def _xcptIsEqual(oSelf, oXcpt, hrStatus):
1542	""" See vboxapi. """
1543	hrXcpt = oSelf.xcptGetResult(oXcpt);
1544	return hrXcpt == hrStatus or hrXcpt == hrStatus - 0x100000000; # pylint: disable=consider-using-in
1545
1546	def _xcptToString(oSelf, oXcpt):
1547	""" See vboxapi. """
1548	_ = oSelf;
1549	if oXcpt is None: oXcpt = sys.exc_info()[1];
1550	return str(oXcpt);
1551
1552	def _getEnumValueName(oSelf, sEnumTypeNm, oEnumValue, fTypePrefix = False):
1553	""" See vboxapi. """
1554	_ = oSelf; _ = fTypePrefix;
1555	return '%s::%s' % (sEnumTypeNm, oEnumValue);
1556
1557	# Add utilities found in newer vboxapi revision.
1558	if not hasattr(self.oVBoxMgr, 'xcptIsDeadInterface'):
1559	import types;
1560	self.oVBoxMgr.xcptGetResult = types.MethodType(_xcptGetResult, self.oVBoxMgr);
1561	self.oVBoxMgr.xcptIsDeadInterface = types.MethodType(_xcptIsDeadInterface, self.oVBoxMgr);
1562	self.oVBoxMgr.xcptIsOurXcptKind = types.MethodType(_xcptIsOurXcptKind, self.oVBoxMgr);
1563	self.oVBoxMgr.xcptIsEqual = types.MethodType(_xcptIsEqual, self.oVBoxMgr);
1564	self.oVBoxMgr.xcptToString = types.MethodType(_xcptToString, self.oVBoxMgr);
1565	if not hasattr(self.oVBoxMgr, 'getEnumValueName'):
1566	import types;
1567	self.oVBoxMgr.getEnumValueName = types.MethodType(_getEnumValueName, self.oVBoxMgr);
1568
1569
1570	def _teardownVBoxApi(self): # pylint: disable=too-many-statements
1571	"""
1572	Drop all VBox object references and shutdown com/xpcom.
1573	"""
1574	if not self.fImportedVBoxApi:
1575	return True;
1576	import gc;
1577
1578	# Drop all references we've have to COM objects.
1579	self.aoRemoteSessions = [];
1580	self.aoVMs = [];
1581	self.oVBoxMgr = None;
1582	self.oVBox = None;
1583	vboxcon.goHackModuleClass.oVBoxMgr = None; # VBoxConstantWrappingHack.
1584	reporter.setComXcptFormatter(None);
1585
1586	# Do garbage collection to try get rid of those objects.
1587	try:
1588	gc.collect();
1589	except:
1590	reporter.logXcpt();
1591	self.fImportedVBoxApi = False;
1592
1593	# Check whether the python is still having any COM objects/interfaces around.
1594	cVBoxMgrs = 0;
1595	aoObjsLeftBehind = [];
1596	if self.sHost == 'win':
1597	import pythoncom; # pylint: disable=import-error
1598	try:
1599	cIfs = pythoncom._GetInterfaceCount(); # pylint: disable=no-member,protected-access
1600	cObjs = pythoncom._GetGatewayCount(); # pylint: disable=no-member,protected-access
1601	if cObjs == 0 and cIfs == 0:
1602	reporter.log('_teardownVBoxApi: no interfaces or objects left behind.');
1603	else:
1604	reporter.log('_teardownVBoxApi: Python COM still has %s objects and %s interfaces...' % ( cObjs, cIfs));
1605
1606	from win32com.client import DispatchBaseClass; # pylint: disable=import-error
1607	for oObj in gc.get_objects():
1608	if isinstance(oObj, DispatchBaseClass):
1609	reporter.log('_teardownVBoxApi: %s' % (oObj,));
1610	aoObjsLeftBehind.append(oObj);
1611	elif utils.getObjectTypeName(oObj) == 'VirtualBoxManager':
1612	reporter.log('_teardownVBoxApi: %s' % (oObj,));
1613	cVBoxMgrs += 1;
1614	aoObjsLeftBehind.append(oObj);
1615	oObj = None;
1616	except:
1617	reporter.logXcpt();
1618
1619	# If not being used, we can safely uninitialize COM.
1620	if cIfs == 0 and cObjs == 0 and cVBoxMgrs == 0 and not aoObjsLeftBehind:
1621	reporter.log('_teardownVBoxApi: Calling CoUninitialize...');
1622	try: pythoncom.CoUninitialize(); # pylint: disable=no-member
1623	except: reporter.logXcpt();
1624	else:
1625	reporter.log('_teardownVBoxApi: Returned from CoUninitialize.');
1626	else:
1627	try:
1628	# XPCOM doesn't crash and burn like COM if you shut it down with interfaces and objects around.
1629	# Also, it keeps a number of internal objects and interfaces around to do its job, so shutting
1630	# it down before we go looking for dangling interfaces is more or less required.
1631	from xpcom import _xpcom as _xpcom; # pylint: disable=import-error,useless-import-alias
1632	hrc = _xpcom.DeinitCOM();
1633	cIfs = _xpcom._GetInterfaceCount(); # pylint: disable=protected-access
1634	cObjs = _xpcom._GetGatewayCount(); # pylint: disable=protected-access
1635
1636	if cObjs == 0 and cIfs == 0:
1637	reporter.log('_teardownVBoxApi: No XPCOM interfaces or objects active. (hrc=%#x)' % (hrc,));
1638	else:
1639	reporter.log('_teardownVBoxApi: %s XPCOM objects and %s interfaces still around! (hrc=%#x)'
1640	% (cObjs, cIfs, hrc));
1641	if hasattr(_xpcom, '_DumpInterfaces'):
1642	try: _xpcom._DumpInterfaces(); # pylint: disable=protected-access
1643	except: reporter.logXcpt('_teardownVBoxApi: _DumpInterfaces failed');
1644
1645	from xpcom.client import Component; # pylint: disable=import-error
1646	for oObj in gc.get_objects():
1647	if isinstance(oObj, Component):
1648	reporter.log('_teardownVBoxApi: %s' % (oObj,));
1649	aoObjsLeftBehind.append(oObj);
1650	if utils.getObjectTypeName(oObj) == 'VirtualBoxManager':
1651	reporter.log('_teardownVBoxApi: %s' % (oObj,));
1652	cVBoxMgrs += 1;
1653	aoObjsLeftBehind.append(oObj);
1654	oObj = None;
1655	except:
1656	reporter.logXcpt();
1657
1658	# Try get the referrers to (XP)COM interfaces and objects that was left behind.
1659	for iObj in range(len(aoObjsLeftBehind)): # pylint: disable=consider-using-enumerate
1660	try:
1661	aoReferrers = gc.get_referrers(aoObjsLeftBehind[iObj]);
1662	reporter.log('_teardownVBoxApi: Found %u referrers to %s:' % (len(aoReferrers), aoObjsLeftBehind[iObj],));
1663	for oReferrer in aoReferrers:
1664	oMyFrame = sys._getframe(0); # pylint: disable=protected-access
1665	if oReferrer is oMyFrame:
1666	reporter.log('_teardownVBoxApi: - frame of this function');
1667	elif oReferrer is aoObjsLeftBehind:
1668	reporter.log('_teardownVBoxApi: - aoObjsLeftBehind');
1669	else:
1670	fPrinted = False;
1671	if isinstance(oReferrer, (dict, list, tuple)):
1672	try:
1673	aoSubReferreres = gc.get_referrers(oReferrer);
1674	for oSubRef in aoSubReferreres:
1675	if not isinstance(oSubRef, list) \
1676	and not isinstance(oSubRef, dict) \
1677	and oSubRef is not oMyFrame \
1678	and oSubRef is not aoSubReferreres:
1679	reporter.log('_teardownVBoxApi: - %s :: %s:'
1680	% (utils.getObjectTypeName(oSubRef), utils.getObjectTypeName(oReferrer)));
1681	fPrinted = True;
1682	break;
1683	del aoSubReferreres;
1684	except:
1685	reporter.logXcpt('subref');
1686	if not fPrinted:
1687	reporter.log('_teardownVBoxApi: - %s:' % (utils.getObjectTypeName(oReferrer),));
1688	try:
1689	import pprint;
1690	for sLine in pprint.pformat(oReferrer, width = 130).split('\n'):
1691	reporter.log('_teardownVBoxApi: %s' % (sLine,));
1692	except:
1693	reporter.log('_teardownVBoxApi: %s' % (oReferrer,));
1694	except:
1695	reporter.logXcpt();
1696	del aoObjsLeftBehind;
1697
1698	# Force garbage collection again, just for good measure.
1699	try:
1700	gc.collect();
1701	time.sleep(0.5); # fudge factor
1702	except:
1703	reporter.logXcpt();
1704	return True;
1705
1706	def _powerOffAllVms(self):
1707	"""
1708	Tries to power off all running VMs.
1709	"""
1710	for oSession in self.aoRemoteSessions:
1711	uPid = oSession.getPid();
1712	if uPid is not None:
1713	reporter.log('_powerOffAllVms: PID is %s for %s, trying to kill it.' % (uPid, oSession.sName,));
1714	base.processKill(uPid);
1715	else:
1716	reporter.log('_powerOffAllVms: No PID for %s' % (oSession.sName,));
1717	oSession.close();
1718	return None;
1719
1720
1721
1722	#
1723	# Build type, OS and arch getters.
1724	#
1725
1726	def getBuildType(self):
1727	"""
1728	Get the build type.
1729	"""
1730	if not self._detectBuild():
1731	return 'release';
1732	return self.oBuild.sType;
1733
1734	def getBuildOs(self):
1735	"""
1736	Get the build OS.
1737	"""
1738	if not self._detectBuild():
1739	return self.sHost;
1740	return self.oBuild.sOs;
1741
1742	def getBuildArch(self):
1743	"""
1744	Get the build arch.
1745	"""
1746	if not self._detectBuild():
1747	return self.sHostArch;
1748	return self.oBuild.sArch;
1749
1750	def getGuestAdditionsIso(self):
1751	"""
1752	Get the path to the guest addition iso.
1753	"""
1754	if not self._detectBuild():
1755	return None;
1756	return self.oBuild.sGuestAdditionsIso;
1757
1758	#
1759	# Override everything from the base class so the testdrivers don't have to
1760	# check whether we have overridden a method or not.
1761	#
1762
1763	def showUsage(self):
1764	rc = base.TestDriver.showUsage(self);
1765	reporter.log('');
1766	reporter.log('Generic VirtualBox Options:');
1767	reporter.log(' --vbox-session-type <type>');
1768	reporter.log(' Sets the session type. Typical values are: gui, headless, sdl');
1769	reporter.log(' Default: %s' % (self.sSessionTypeDef));
1770	reporter.log(' --vrdp, --no-vrdp');
1771	reporter.log(' Enables VRDP, ports starting at 6000');
1772	reporter.log(' Default: --vrdp');
1773	reporter.log(' --vrdp-base-port <port>');
1774	reporter.log(' Sets the base for VRDP port assignments.');
1775	reporter.log(' Default: %s' % (self.uVrdpBasePortDef));
1776	reporter.log(' --vbox-default-bridged-nic <interface>');
1777	reporter.log(' Sets the default interface for bridged networking.');
1778	reporter.log(' Default: autodetect');
1779	reporter.log(' --vbox-use-svc-defaults');
1780	reporter.log(' Use default locations and files for VBoxSVC. This is useful');
1781	reporter.log(' for automatically configuring the test VMs for debugging.');
1782	reporter.log(' --vbox-log');
1783	reporter.log(' The VBox logger group settings for everyone.');
1784	reporter.log(' --vbox-log-flags');
1785	reporter.log(' The VBox logger flags settings for everyone.');
1786	reporter.log(' --vbox-log-dest');
1787	reporter.log(' The VBox logger destination settings for everyone.');
1788	reporter.log(' --vbox-self-log');
1789	reporter.log(' The VBox logger group settings for the testdriver.');
1790	reporter.log(' --vbox-self-log-flags');
1791	reporter.log(' The VBox logger flags settings for the testdriver.');
1792	reporter.log(' --vbox-self-log-dest');
1793	reporter.log(' The VBox logger destination settings for the testdriver.');
1794	reporter.log(' --vbox-session-log');
1795	reporter.log(' The VM session logger group settings.');
1796	reporter.log(' --vbox-session-log-flags');
1797	reporter.log(' The VM session logger flags.');
1798	reporter.log(' --vbox-session-log-dest');
1799	reporter.log(' The VM session logger destination settings.');
1800	reporter.log(' --vbox-svc-log');
1801	reporter.log(' The VBoxSVC logger group settings.');
1802	reporter.log(' --vbox-svc-log-flags');
1803	reporter.log(' The VBoxSVC logger flag settings.');
1804	reporter.log(' --vbox-svc-log-dest');
1805	reporter.log(' The VBoxSVC logger destination settings.');
1806	reporter.log(' --vbox-svc-debug');
1807	reporter.log(' Start VBoxSVC in a debugger.');
1808	reporter.log(' --vbox-svc-wait-debug');
1809	reporter.log(' Start VBoxSVC and wait for debugger to attach to it.');
1810	reporter.log(' --vbox-always-upload-logs');
1811	reporter.log(' Whether to always upload log files, or only do so on failure.');
1812	reporter.log(' --vbox-always-upload-screenshots');
1813	reporter.log(' Whether to always upload final screen shots, or only do so on failure.');
1814	reporter.log(' --vbox-always-upload-recordings, --no-vbox-always-upload-recordings');
1815	reporter.log(' Whether to always upload recordings, or only do so on failure.');
1816	reporter.log(' Default: --no-vbox-always-upload-recordings');
1817	reporter.log(' --vbox-debugger, --no-vbox-debugger');
1818	reporter.log(' Enables the VBox debugger, port at 5000');
1819	reporter.log(' Default: --vbox-debugger');
1820	reporter.log(' --vbox-recording, --no-vbox-recording');
1821	reporter.log(' Enables/disables recording.');
1822	reporter.log(' Default: --no-vbox-recording');
1823	reporter.log(' --vbox-recording-audio, --no-vbox-recording-audio');
1824	reporter.log(' Enables/disables audio recording.');
1825	reporter.log(' Default: --no-vbox-recording-audio');
1826	reporter.log(' --vbox-recording-max-time <seconds>');
1827	reporter.log(' Limits the maximum recording time in seconds.');
1828	reporter.log(' Default: Unlimited.');
1829	reporter.log(' --vbox-recording-max-file-size <MiB>');
1830	reporter.log(' Limits the maximum per-file size in MiB.');
1831	reporter.log(' Explicitly specify 0 for unlimited size.');
1832	reporter.log(' Default: 195 MB.');
1833	reporter.log(' --vbox-vm-no-terminate');
1834	reporter.log(' Does not terminate the test VM after running the test driver.');
1835	if self.oTestVmSet is not None:
1836	self.oTestVmSet.showUsage();
1837	return rc;
1838
1839	def parseOption(self, asArgs, iArg): # pylint: disable=too-many-branches,too-many-statements
1840	if asArgs[iArg] == '--vbox-session-type':
1841	iArg += 1;
1842	if iArg >= len(asArgs):
1843	raise base.InvalidOption('The "--vbox-session-type" takes an argument');
1844	self.sSessionType = asArgs[iArg];
1845	elif asArgs[iArg] == '--vrdp':
1846	self.fEnableVrdp = True;
1847	elif asArgs[iArg] == '--no-vrdp':
1848	self.fEnableVrdp = False;
1849	elif asArgs[iArg] == '--vrdp-base-port':
1850	iArg += 1;
1851	if iArg >= len(asArgs):
1852	raise base.InvalidOption('The "--vrdp-base-port" takes an argument');
1853	try: self.uVrdpBasePort = int(asArgs[iArg]);
1854	except: raise base.InvalidOption('The "--vrdp-base-port" value "%s" is not a valid integer' % (asArgs[iArg],));
1855	if self.uVrdpBasePort <= 0 or self.uVrdpBasePort >= 65530:
1856	raise base.InvalidOption('The "--vrdp-base-port" value "%s" is not in the valid range (1..65530)'
1857	% (asArgs[iArg],));
1858	elif asArgs[iArg] == '--vbox-default-bridged-nic':
1859	iArg += 1;
1860	if iArg >= len(asArgs):
1861	raise base.InvalidOption('The "--vbox-default-bridged-nic" takes an argument');
1862	self.sDefBridgedNic = asArgs[iArg];
1863	elif asArgs[iArg] == '--vbox-use-svc-defaults':
1864	self.fUseDefaultSvc = True;
1865	elif asArgs[iArg] == '--vbox-self-log':
1866	iArg += 1;
1867	if iArg >= len(asArgs):
1868	raise base.InvalidOption('The "--vbox-self-log" takes an argument');
1869	self.sLogSelfGroups = asArgs[iArg];
1870	elif asArgs[iArg] == '--vbox-self-log-flags':
1871	iArg += 1;
1872	if iArg >= len(asArgs):
1873	raise base.InvalidOption('The "--vbox-self-log-flags" takes an argument');
1874	self.sLogSelfFlags = asArgs[iArg];
1875	elif asArgs[iArg] == '--vbox-self-log-dest':
1876	iArg += 1;
1877	if iArg >= len(asArgs):
1878	raise base.InvalidOption('The "--vbox-self-log-dest" takes an argument');
1879	self.sLogSelfDest = asArgs[iArg];
1880	elif asArgs[iArg] == '--vbox-session-log':
1881	iArg += 1;
1882	if iArg >= len(asArgs):
1883	raise base.InvalidOption('The "--vbox-session-log" takes an argument');
1884	self.sLogSessionGroups = asArgs[iArg];
1885	elif asArgs[iArg] == '--vbox-session-log-flags':
1886	iArg += 1;
1887	if iArg >= len(asArgs):
1888	raise base.InvalidOption('The "--vbox-session-log-flags" takes an argument');
1889	self.sLogSessionFlags = asArgs[iArg];
1890	elif asArgs[iArg] == '--vbox-session-log-dest':
1891	iArg += 1;
1892	if iArg >= len(asArgs):
1893	raise base.InvalidOption('The "--vbox-session-log-dest" takes an argument');
1894	self.sLogSessionDest = asArgs[iArg];
1895	elif asArgs[iArg] == '--vbox-svc-log':
1896	iArg += 1;
1897	if iArg >= len(asArgs):
1898	raise base.InvalidOption('The "--vbox-svc-log" takes an argument');
1899	self.sLogSvcGroups = asArgs[iArg];
1900	elif asArgs[iArg] == '--vbox-svc-log-flags':
1901	iArg += 1;
1902	if iArg >= len(asArgs):
1903	raise base.InvalidOption('The "--vbox-svc-log-flags" takes an argument');
1904	self.sLogSvcFlags = asArgs[iArg];
1905	elif asArgs[iArg] == '--vbox-svc-log-dest':
1906	iArg += 1;
1907	if iArg >= len(asArgs):
1908	raise base.InvalidOption('The "--vbox-svc-log-dest" takes an argument');
1909	self.sLogSvcDest = asArgs[iArg];
1910	elif asArgs[iArg] == '--vbox-log':
1911	iArg += 1;
1912	if iArg >= len(asArgs):
1913	raise base.InvalidOption('The "--vbox-log" takes an argument');
1914	self.sLogSelfGroups = asArgs[iArg];
1915	self.sLogSessionGroups = asArgs[iArg];
1916	self.sLogSvcGroups = asArgs[iArg];
1917	elif asArgs[iArg] == '--vbox-log-flags':
1918	iArg += 1;
1919	if iArg >= len(asArgs):
1920	raise base.InvalidOption('The "--vbox-svc-flags" takes an argument');
1921	self.sLogSelfFlags = asArgs[iArg];
1922	self.sLogSessionFlags = asArgs[iArg];
1923	self.sLogSvcFlags = asArgs[iArg];
1924	elif asArgs[iArg] == '--vbox-log-dest':
1925	iArg += 1;
1926	if iArg >= len(asArgs):
1927	raise base.InvalidOption('The "--vbox-log-dest" takes an argument');
1928	self.sLogSelfDest = asArgs[iArg];
1929	self.sLogSessionDest = asArgs[iArg];
1930	self.sLogSvcDest = asArgs[iArg];
1931	elif asArgs[iArg] == '--vbox-svc-debug':
1932	self.fVBoxSvcInDebugger = True;
1933	elif asArgs[iArg] == '--vbox-svc-wait-debug':
1934	self.fVBoxSvcWaitForDebugger = True;
1935	elif asArgs[iArg] == '--vbox-always-upload-logs':
1936	self.fAlwaysUploadLogs = True;
1937	elif asArgs[iArg] == '--vbox-always-upload-screenshots':
1938	self.fAlwaysUploadScreenshots = True;
1939	elif asArgs[iArg] == '--no-vbox-always-upload-recordings':
1940	self.fAlwaysUploadRecordings = False;
1941	elif asArgs[iArg] == '--vbox-always-upload-recordings':
1942	self.fAlwaysUploadRecordings = True;
1943	elif asArgs[iArg] == '--vbox-debugger':
1944	self.fEnableDebugger = True;
1945	elif asArgs[iArg] == '--no-vbox-debugger':
1946	self.fEnableDebugger = False;
1947	elif asArgs[iArg] == '--vbox-recording':
1948	self.fRecordingEnabled = True;
1949	elif asArgs[iArg] == '--vbox-no-recording':
1950	self.fRecordingEnabled = False;
1951	elif asArgs[iArg] == '--no-vbox-recording-audio':
1952	self.fRecordingAudio = False;
1953	elif asArgs[iArg] == '--vbox-recording-audio':
1954	self.fRecordingAudio = True;
1955	elif asArgs[iArg] == '--vbox-recording-max-time':
1956	iArg += 1;
1957	if iArg >= len(asArgs):
1958	raise base.InvalidOption('The "--vbox-recording-max-time" takes an argument');
1959	self.cSecsRecordingMax = int(asArgs[iArg]);
1960	elif asArgs[iArg] == '--vbox-recording-max-file-size':
1961	iArg += 1;
1962	if iArg >= len(asArgs):
1963	raise base.InvalidOption('The "--vbox-recording-max-file-size" takes an argument');
1964	self.cMbRecordingMax = int(asArgs[iArg]);
1965	elif asArgs[iArg] == '--vbox-vm-no-terminate':
1966	self.fVmNoTerminate = True;
1967	else:
1968	# Relevant for selecting VMs to test?
1969	if self.oTestVmSet is not None:
1970	iRc = self.oTestVmSet.parseOption(asArgs, iArg);
1971	if iRc != iArg:
1972	return iRc;
1973
1974	# Hand it to the base class.
1975	return base.TestDriver.parseOption(self, asArgs, iArg);
1976	return iArg + 1;
1977
1978	def completeOptions(self):
1979	return base.TestDriver.completeOptions(self);
1980
1981	def getNetworkAdapterNameFromType(self, oNic):
1982	"""
1983	Returns the network adapter name from a given adapter type.
1984
1985	Returns an empty string if not found / invalid.
1986	"""
1987	sAdpName = '';
1988	if oNic.adapterType in (vboxcon.NetworkAdapterType_Am79C970A, \
1989	vboxcon.NetworkAdapterType_Am79C973, \
1990	vboxcon.NetworkAdapterType_Am79C960):
1991	sAdpName = 'pcnet';
1992	elif oNic.adapterType in (vboxcon.NetworkAdapterType_I82540EM, \
1993	vboxcon.NetworkAdapterType_I82543GC, \
1994	vboxcon.NetworkAdapterType_I82545EM):
1995	sAdpName = 'e1000';
1996	elif oNic.adapterType == vboxcon.NetworkAdapterType_Virtio:
1997	sAdpName = 'virtio-net';
1998	return sAdpName;
1999
2000	def getResourceSet(self):
2001	asRsrcs = [];
2002	if self.oTestVmSet is not None:
2003	asRsrcs.extend(self.oTestVmSet.getResourceSet());
2004	asRsrcs.extend(base.TestDriver.getResourceSet(self));
2005	return asRsrcs;
2006
2007	def actionExtract(self):
2008	return base.TestDriver.actionExtract(self);
2009
2010	def actionVerify(self):
2011	return base.TestDriver.actionVerify(self);
2012
2013	def actionConfig(self):
2014	return base.TestDriver.actionConfig(self);
2015
2016	def actionExecute(self):
2017	return base.TestDriver.actionExecute(self);
2018
2019	def actionCleanupBefore(self):
2020	"""
2021	Kill any VBoxSVC left behind by a previous test run.
2022	"""
2023	self._killVBoxSVCByPidFile('%s/VBoxSVC.pid' % (self.sScratchPath,));
2024	return base.TestDriver.actionCleanupBefore(self);
2025
2026	def actionCleanupAfter(self):
2027	"""
2028	Clean up the VBox bits and then call the base driver.
2029
2030	If your test driver overrides this, it should normally call us at the
2031	end of the job.
2032	"""
2033	cErrorsEntry = reporter.getErrorCount();
2034
2035	# Kill any left over VM processes.
2036	self._powerOffAllVms();
2037
2038	# Drop all VBox object references and shutdown xpcom then
2039	# terminating VBoxSVC, with extreme prejudice if need be.
2040	self._teardownVBoxApi();
2041	self._stopVBoxSVC();
2042
2043	# Add the VBoxSVC and testdriver debug+release log files.
2044	if self.fAlwaysUploadLogs or reporter.getErrorCount() > 0:
2045	if self.sVBoxSvcLogFile is not None and os.path.isfile(self.sVBoxSvcLogFile):
2046	reporter.addLogFile(self.sVBoxSvcLogFile, 'log/debug/svc', 'Debug log file for VBoxSVC');
2047	self.sVBoxSvcLogFile = None;
2048
2049	if self.sSelfLogFile is not None and os.path.isfile(self.sSelfLogFile):
2050	reporter.addLogFile(self.sSelfLogFile, 'log/debug/client', 'Debug log file for the test driver');
2051	self.sSelfLogFile = None;
2052
2053	if self.sSessionLogFile is not None and os.path.isfile(self.sSessionLogFile):
2054	reporter.addLogFile(self.sSessionLogFile, 'log/debug/session', 'Debug log file for the VM session');
2055	self.sSessionLogFile = None;
2056
2057	sVBoxSvcRelLog = os.path.join(self.sScratchPath, 'VBoxUserHome', 'VBoxSVC.log');
2058	if os.path.isfile(sVBoxSvcRelLog):
2059	reporter.addLogFile(sVBoxSvcRelLog, 'log/release/svc', 'Release log file for VBoxSVC');
2060	for sSuff in [ '.1', '.2', '.3', '.4', '.5', '.6', '.7', '.8' ]:
2061	if os.path.isfile(sVBoxSvcRelLog + sSuff):
2062	reporter.addLogFile(sVBoxSvcRelLog + sSuff, 'log/release/svc', 'Release log file for VBoxSVC');
2063
2064	# Finally, call the base driver to wipe the scratch space.
2065	fRc = base.TestDriver.actionCleanupAfter(self);
2066
2067	# Flag failure if the error count increased.
2068	if reporter.getErrorCount() > cErrorsEntry:
2069	fRc = False;
2070	return fRc;
2071
2072
2073	def actionAbort(self):
2074	"""
2075	Terminate VBoxSVC if we've got a pid file.
2076	"""
2077	#
2078	# Take default action first, then kill VBoxSVC. The other way around
2079	# is problematic since the testscript would continue running and possibly
2080	# trigger a new VBoxSVC to start.
2081	#
2082	fRc1 = base.TestDriver.actionAbort(self);
2083	fRc2 = self._killVBoxSVCByPidFile('%s/VBoxSVC.pid' % (self.sScratchPath,));
2084	return fRc1 is True and fRc2 is True;
2085
2086	def onExit(self, iRc):
2087	"""
2088	Stop VBoxSVC if we've started it.
2089	"""
2090	if not self.fVmNoTerminate \
2091	and self.oVBoxSvcProcess is not None:
2092	reporter.log('*** Shutting down the VBox API... (iRc=%s)' % (iRc,));
2093	self._powerOffAllVms();
2094	self._teardownVBoxApi();
2095	self._stopVBoxSVC();
2096	reporter.log('*** VBox API shutdown done.');
2097	return base.TestDriver.onExit(self, iRc);
2098
2099
2100	#
2101	# Task wait method override.
2102	#
2103
2104	def notifyAboutReadyTask(self, oTask):
2105	"""
2106	Overriding base.TestDriver.notifyAboutReadyTask.
2107	"""
2108	try:
2109	self.oVBoxMgr.interruptWaitEvents();
2110	reporter.log2('vbox.notifyAboutReadyTask: called interruptWaitEvents');
2111	except:
2112	reporter.logXcpt('vbox.notifyAboutReadyTask');
2113	return base.TestDriver.notifyAboutReadyTask(self, oTask);
2114
2115	def waitForTasksSleepWorker(self, cMsTimeout):
2116	"""
2117	Overriding base.TestDriver.waitForTasksSleepWorker.
2118	"""
2119	try:
2120	rc = self.oVBoxMgr.waitForEvents(int(cMsTimeout));
2121	_ = rc; #reporter.log2('vbox.waitForTasksSleepWorker(%u): true (waitForEvents -> %s)' % (cMsTimeout, rc));
2122	reporter.doPollWork('vbox.TestDriver.waitForTasksSleepWorker');
2123	return True;
2124	except KeyboardInterrupt:
2125	raise;
2126	except:
2127	reporter.logXcpt('vbox.waitForTasksSleepWorker');
2128	return False;
2129
2130	#
2131	# Utility methods.
2132	#
2133
2134	def processEvents(self, cMsTimeout = 0):
2135	"""
2136	Processes events, returning after the first batch has been processed
2137	or the time limit has been reached.
2138
2139	Only Ctrl-C exception, no return.
2140	"""
2141	try:
2142	self.oVBoxMgr.waitForEvents(cMsTimeout);
2143	except KeyboardInterrupt:
2144	raise;
2145	except:
2146	pass;
2147	return None;
2148
2149	def processPendingEvents(self):
2150	""" processEvents(0) - no waiting. """
2151	return self.processEvents(0);
2152
2153	def sleep(self, cSecs):
2154	"""
2155	Sleep for a specified amount of time, processing XPCOM events all the while.
2156	"""
2157	cMsTimeout = long(cSecs * 1000);
2158	msStart = base.timestampMilli();
2159	self.processEvents(0);
2160	while True:
2161	cMsElapsed = base.timestampMilli() - msStart;
2162	if cMsElapsed > cMsTimeout:
2163	break;
2164	#reporter.log2('cMsTimeout=%s - cMsElapsed=%d => %s' % (cMsTimeout, cMsElapsed, cMsTimeout - cMsElapsed));
2165	self.processEvents(cMsTimeout - cMsElapsed);
2166	return None;
2167
2168	def _logVmInfoUnsafe(self, oVM): # pylint: disable=too-many-statements,too-many-branches
2169	"""
2170	Internal worker for logVmInfo that is wrapped in try/except.
2171	"""
2172	reporter.log(" Name: %s" % (oVM.name,));
2173	reporter.log(" ID: %s" % (oVM.id,));
2174	oOsType = self.oVBox.getGuestOSType(oVM.OSTypeId);
2175	reporter.log(" OS Type: %s - %s" % (oVM.OSTypeId, oOsType.description,));
2176	reporter.log(" Machine state: %s" % (oVM.state,));
2177	reporter.log(" Session state: %s" % (oVM.sessionState,));
2178	if self.fpApiVer >= 4.2:
2179	reporter.log(" Session PID: %u (%#x)" % (oVM.sessionPID, oVM.sessionPID,));
2180	else:
2181	reporter.log(" Session PID: %u (%#x)" % (oVM.sessionPid, oVM.sessionPid,));
2182	if self.fpApiVer >= 5.0:
2183	reporter.log(" Session Name: %s" % (oVM.sessionName,));
2184	else:
2185	reporter.log(" Session Name: %s" % (oVM.sessionType,));
2186	reporter.log(" CPUs: %s" % (oVM.CPUCount,));
2187	reporter.log(" RAM: %sMB" % (oVM.memorySize,));
2188	if self.fpApiVer >= 6.1 and hasattr(oVM, 'graphicsAdapter'):
2189	reporter.log(" VRAM: %sMB" % (oVM.graphicsAdapter.VRAMSize,));
2190	reporter.log(" Monitors: %s" % (oVM.graphicsAdapter.monitorCount,));
2191	reporter.log(" GraphicsController: %s"
2192	% (self.oVBoxMgr.getEnumValueName('GraphicsControllerType', # pylint: disable=not-callable
2193	oVM.graphicsAdapter.graphicsControllerType),));
2194	else:
2195	reporter.log(" VRAM: %sMB" % (oVM.VRAMSize,));
2196	reporter.log(" Monitors: %s" % (oVM.monitorCount,));
2197	reporter.log(" GraphicsController: %s"
2198	% (self.oVBoxMgr.getEnumValueName('GraphicsControllerType', oVM.graphicsControllerType),)); # pylint: disable=not-callable
2199	reporter.log(" Chipset: %s" % (self.oVBoxMgr.getEnumValueName('ChipsetType', oVM.chipsetType),)); # pylint: disable=not-callable
2200	if self.fpApiVer >= 6.2 and hasattr(vboxcon, 'IommuType_None'):
2201	reporter.log(" IOMMU: %s" % (self.oVBoxMgr.getEnumValueName('IommuType', oVM.iommuType),)); # pylint: disable=not-callable
2202	reporter.log(" Firmware: %s" % (self.oVBoxMgr.getEnumValueName('FirmwareType', oVM.firmwareType),)); # pylint: disable=not-callable
2203	reporter.log(" HwVirtEx: %s" % (oVM.getHWVirtExProperty(vboxcon.HWVirtExPropertyType_Enabled),));
2204	reporter.log(" VPID support: %s" % (oVM.getHWVirtExProperty(vboxcon.HWVirtExPropertyType_VPID),));
2205	reporter.log(" Nested paging: %s" % (oVM.getHWVirtExProperty(vboxcon.HWVirtExPropertyType_NestedPaging),));
2206	atTypes = [
2207	( 'CPUPropertyType_PAE', 'PAE: '),
2208	( 'CPUPropertyType_LongMode', 'Long-mode: '),
2209	( 'CPUPropertyType_HWVirt', 'Nested VT-x/AMD-V: '),
2210	( 'CPUPropertyType_APIC', 'APIC: '),
2211	( 'CPUPropertyType_X2APIC', 'X2APIC: '),
2212	( 'CPUPropertyType_TripleFaultReset', 'TripleFaultReset: '),
2213	( 'CPUPropertyType_IBPBOnVMExit', 'IBPBOnVMExit: '),
2214	( 'CPUPropertyType_SpecCtrl', 'SpecCtrl: '),
2215	( 'CPUPropertyType_SpecCtrlByHost', 'SpecCtrlByHost: '),
2216	];
2217	for sEnumValue, sDesc in atTypes:
2218	if hasattr(vboxcon, sEnumValue):
2219	reporter.log(" %s%s" % (sDesc, oVM.getCPUProperty(getattr(vboxcon, sEnumValue)),));
2220	reporter.log(" ACPI: %s" % (oVM.BIOSSettings.ACPIEnabled,));
2221	reporter.log(" IO-APIC: %s" % (oVM.BIOSSettings.IOAPICEnabled,));
2222	if self.fpApiVer >= 3.2:
2223	if self.fpApiVer >= 4.2:
2224	reporter.log(" HPET: %s" % (oVM.HPETEnabled,));
2225	else:
2226	reporter.log(" HPET: %s" % (oVM.hpetEnabled,));
2227	if self.fpApiVer >= 6.1 and hasattr(oVM, 'graphicsAdapter'):
2228	reporter.log(" 3D acceleration: %s" % (oVM.graphicsAdapter.accelerate3DEnabled,));
2229	reporter.log(" 2D acceleration: %s" % (oVM.graphicsAdapter.accelerate2DVideoEnabled,));
2230	else:
2231	reporter.log(" 3D acceleration: %s" % (oVM.accelerate3DEnabled,));
2232	reporter.log(" 2D acceleration: %s" % (oVM.accelerate2DVideoEnabled,));
2233	reporter.log(" TeleporterEnabled: %s" % (oVM.teleporterEnabled,));
2234	reporter.log(" TeleporterPort: %s" % (oVM.teleporterPort,));
2235	reporter.log(" TeleporterAddress: %s" % (oVM.teleporterAddress,));
2236	reporter.log(" TeleporterPassword: %s" % (oVM.teleporterPassword,));
2237	reporter.log(" Clipboard mode: %s" % (oVM.clipboardMode,));
2238	if self.fpApiVer >= 5.0:
2239	reporter.log(" Drag and drop mode: %s" % (oVM.dnDMode,));
2240	elif self.fpApiVer >= 4.3:
2241	reporter.log(" Drag and drop mode: %s" % (oVM.dragAndDropMode,));
2242	if self.fpApiVer >= 4.0:
2243	reporter.log(" VRDP server: %s" % (oVM.VRDEServer.enabled,));
2244	try: sPorts = oVM.VRDEServer.getVRDEProperty("TCP/Ports");
2245	except: sPorts = "";
2246	reporter.log(" VRDP server ports: %s" % (sPorts,));
2247	reporter.log(" VRDP auth: %s (%s)" % (oVM.VRDEServer.authType, oVM.VRDEServer.authLibrary,));
2248	else:
2249	reporter.log(" VRDP server: %s" % (oVM.VRDPServer.enabled,));
2250	reporter.log(" VRDP server ports: %s" % (oVM.VRDPServer.ports,));
2251	reporter.log(" Last changed: %s" % (oVM.lastStateChange,));
2252
2253	aoControllers = self.oVBoxMgr.getArray(oVM, 'storageControllers')
2254	if aoControllers:
2255	reporter.log(" Controllers:");
2256	for oCtrl in aoControllers:
2257	reporter.log(" %s %s bus: %s type: %s" % (oCtrl.name, oCtrl.controllerType, oCtrl.bus, oCtrl.controllerType,));
2258	if self.fpApiVer >= 7.0:
2259	oAdapter = oVM.audioSettings.adapter;
2260	else:
2261	oAdapter = oVM.audioAdapter;
2262	reporter.log(" AudioController: %s"
2263	% (self.oVBoxMgr.getEnumValueName('AudioControllerType', oAdapter.audioController),)); # pylint: disable=not-callable
2264	reporter.log(" AudioEnabled: %s" % (oAdapter.enabled,));
2265	reporter.log(" Host AudioDriver: %s"
2266	% (self.oVBoxMgr.getEnumValueName('AudioDriverType', oAdapter.audioDriver),)); # pylint: disable=not-callable
2267
2268	self.processPendingEvents();
2269	aoAttachments = self.oVBoxMgr.getArray(oVM, 'mediumAttachments')
2270	if aoAttachments:
2271	reporter.log(" Attachments:");
2272	for oAtt in aoAttachments:
2273	sCtrl = "Controller: %s port: %s device: %s type: %s" % (oAtt.controller, oAtt.port, oAtt.device, oAtt.type);
2274	oMedium = oAtt.medium
2275	if oAtt.type == vboxcon.DeviceType_HardDisk:
2276	reporter.log(" %s: HDD" % sCtrl);
2277	reporter.log(" Id: %s" % (oMedium.id,));
2278	reporter.log(" Name: %s" % (oMedium.name,));
2279	reporter.log(" Format: %s" % (oMedium.format,));
2280	reporter.log(" Location: %s" % (oMedium.location,));
2281
2282	if oAtt.type == vboxcon.DeviceType_DVD:
2283	reporter.log(" %s: DVD" % sCtrl);
2284	if oMedium:
2285	reporter.log(" Id: %s" % (oMedium.id,));
2286	reporter.log(" Name: %s" % (oMedium.name,));
2287	if oMedium.hostDrive:
2288	reporter.log(" Host DVD %s" % (oMedium.location,));
2289	if oAtt.passthrough:
2290	reporter.log(" [passthrough mode]");
2291	else:
2292	reporter.log(" Virtual image: %s" % (oMedium.location,));
2293	reporter.log(" Size: %s" % (oMedium.size,));
2294	else:
2295	reporter.log(" empty");
2296
2297	if oAtt.type == vboxcon.DeviceType_Floppy:
2298	reporter.log(" %s: Floppy" % sCtrl);
2299	if oMedium:
2300	reporter.log(" Id: %s" % (oMedium.id,));
2301	reporter.log(" Name: %s" % (oMedium.name,));
2302	if oMedium.hostDrive:
2303	reporter.log(" Host floppy: %s" % (oMedium.location,));
2304	else:
2305	reporter.log(" Virtual image: %s" % (oMedium.location,));
2306	reporter.log(" Size: %s" % (oMedium.size,));
2307	else:
2308	reporter.log(" empty");
2309	self.processPendingEvents();
2310
2311	reporter.log(" Network Adapter:");
2312	for iSlot in range(0, 32):
2313	try: oNic = oVM.getNetworkAdapter(iSlot)
2314	except: break;
2315	if not oNic.enabled:
2316	reporter.log2(" slot #%d found but not enabled, skipping" % (iSlot,));
2317	continue;
2318	reporter.log(" slot #%d: type: %s (%s) MAC Address: %s lineSpeed: %s"
2319	% (iSlot, self.oVBoxMgr.getEnumValueName('NetworkAdapterType', oNic.adapterType), # pylint: disable=not-callable
2320	oNic.adapterType, oNic.MACAddress, oNic.lineSpeed) );
2321
2322	if oNic.attachmentType == vboxcon.NetworkAttachmentType_NAT:
2323	reporter.log(" attachmentType: NAT (%s)" % (oNic.attachmentType,));
2324	if self.fpApiVer >= 4.1:
2325	reporter.log(" nat-network: %s" % (oNic.NATNetwork,));
2326	if self.fpApiVer >= 7.0 and hasattr(oNic.NATEngine, 'localhostReachable'):
2327	reporter.log(" localhostReachable: %s" % (oNic.NATEngine.localhostReachable,));
2328
2329	elif oNic.attachmentType == vboxcon.NetworkAttachmentType_Bridged:
2330	reporter.log(" attachmentType: Bridged (%s)" % (oNic.attachmentType,));
2331	if self.fpApiVer >= 4.1:
2332	reporter.log(" hostInterface: %s" % (oNic.bridgedInterface,));
2333	else:
2334	reporter.log(" hostInterface: %s" % (oNic.hostInterface,));
2335	elif oNic.attachmentType == vboxcon.NetworkAttachmentType_Internal:
2336	reporter.log(" attachmentType: Internal (%s)" % (oNic.attachmentType,));
2337	reporter.log(" intnet-name: %s" % (oNic.internalNetwork,));
2338	elif oNic.attachmentType == vboxcon.NetworkAttachmentType_HostOnly:
2339	reporter.log(" attachmentType: HostOnly (%s)" % (oNic.attachmentType,));
2340	if self.fpApiVer >= 4.1:
2341	reporter.log(" hostInterface: %s" % (oNic.hostOnlyInterface,));
2342	else:
2343	reporter.log(" hostInterface: %s" % (oNic.hostInterface,));
2344	else:
2345	if self.fpApiVer >= 7.0:
2346	if oNic.attachmentType == vboxcon.NetworkAttachmentType_HostOnlyNetwork:
2347	reporter.log(" attachmentType: HostOnlyNetwork (%s)" % (oNic.attachmentType,));
2348	reporter.log(" hostonly-net: %s" % (oNic.hostOnlyNetwork,));
2349	elif self.fpApiVer >= 4.1:
2350	if oNic.attachmentType == vboxcon.NetworkAttachmentType_Generic:
2351	reporter.log(" attachmentType: Generic (%s)" % (oNic.attachmentType,));
2352	reporter.log(" generic-driver: %s" % (oNic.GenericDriver,));
2353	else:
2354	reporter.log(" attachmentType: unknown-%s" % (oNic.attachmentType,));
2355	else:
2356	reporter.log(" attachmentType: unknown-%s" % (oNic.attachmentType,));
2357	if oNic.traceEnabled:
2358	reporter.log(" traceFile: %s" % (oNic.traceFile,));
2359	self.processPendingEvents();
2360
2361	reporter.log(" Serial ports:");
2362	for iSlot in range(0, 8):
2363	try: oPort = oVM.getSerialPort(iSlot)
2364	except: break;
2365	if oPort is not None and oPort.enabled:
2366	enmHostMode = oPort.hostMode;
2367	reporter.log(" slot #%d: hostMode: %s (%s) I/O port: %s IRQ: %s server: %s path: %s" %
2368	(iSlot, self.oVBoxMgr.getEnumValueName('PortMode', enmHostMode), # pylint: disable=not-callable
2369	enmHostMode, oPort.IOBase, oPort.IRQ, oPort.server, oPort.path,) );
2370	self.processPendingEvents();
2371
2372	return True;
2373
2374	def logVmInfo(self, oVM): # pylint: disable=too-many-statements,too-many-branches
2375	"""
2376	Logs VM configuration details.
2377
2378	This is copy, past, search, replace and edit of infoCmd from vboxshell.py.
2379	"""
2380	try:
2381	fRc = self._logVmInfoUnsafe(oVM);
2382	except:
2383	reporter.logXcpt();
2384	fRc = False;
2385	return fRc;
2386
2387	def logVmInfoByName(self, sName):
2388	"""
2389	logVmInfo + getVmByName.
2390	"""
2391	return self.logVmInfo(self.getVmByName(sName));
2392
2393	def tryFindGuestOsId(self, sIdOrDesc):
2394	"""
2395	Takes a guest OS ID or Description and returns the ID.
2396	If nothing matching it is found, the input is returned unmodified.
2397	"""
2398
2399	if self.fpApiVer >= 4.0:
2400	if sIdOrDesc == 'Solaris (64 bit)':
2401	sIdOrDesc = 'Oracle Solaris 10 5/09 and earlier (64 bit)';
2402
2403	try:
2404	aoGuestTypes = self.oVBoxMgr.getArray(self.oVBox, 'GuestOSTypes');
2405	except:
2406	reporter.logXcpt();
2407	else:
2408	for oGuestOS in aoGuestTypes:
2409	try:
2410	sId = oGuestOS.id;
2411	sDesc = oGuestOS.description;
2412	except:
2413	reporter.logXcpt();
2414	else:
2415	if sIdOrDesc in (sId, sDesc,):
2416	sIdOrDesc = sId;
2417	break;
2418	self.processPendingEvents();
2419	return sIdOrDesc
2420
2421	def resourceFindVmHd(self, sVmName, sFlavor):
2422	"""
2423	Search the test resources for the most recent VM HD.
2424
2425	Returns path relative to the test resource root.
2426	"""
2427	## @todo implement a proper search algo here.
2428	return '4.2/' + sFlavor + '/' + sVmName + '/t-' + sVmName + '.vdi';
2429
2430
2431	#
2432	# VM Api wrappers that logs errors, hides exceptions and other details.
2433	#
2434
2435	def createTestVMOnly(self, sName, sKind):
2436	"""
2437	Creates and register a test VM without doing any kind of configuration.
2438
2439	Returns VM object (IMachine) on success, None on failure.
2440	"""
2441	if not self.importVBoxApi():
2442	return None;
2443
2444	# create + register the VM
2445	try:
2446	if self.fpApiVer >= 7.0: # Introduces VM encryption (three new parameters, empty for now).
2447	oVM = self.oVBox.createMachine("", sName, [], self.tryFindGuestOsId(sKind), "", "", "", "");
2448	elif self.fpApiVer >= 4.2: # Introduces grouping (third parameter, empty for now).
2449	oVM = self.oVBox.createMachine("", sName, [], self.tryFindGuestOsId(sKind), "");
2450	elif self.fpApiVer >= 4.0:
2451	oVM = self.oVBox.createMachine("", sName, self.tryFindGuestOsId(sKind), "", False);
2452	elif self.fpApiVer >= 3.2:
2453	oVM = self.oVBox.createMachine(sName, self.tryFindGuestOsId(sKind), "", "", False);
2454	else:
2455	oVM = self.oVBox.createMachine(sName, self.tryFindGuestOsId(sKind), "", "");
2456	try:
2457	oVM.saveSettings();
2458	try:
2459	self.oVBox.registerMachine(oVM);
2460	return oVM;
2461	except:
2462	reporter.logXcpt();
2463	raise;
2464	except:
2465	reporter.logXcpt();
2466	if self.fpApiVer >= 4.0:
2467	try:
2468	if self.fpApiVer >= 4.3:
2469	oProgress = oVM.deleteConfig([]);
2470	else:
2471	oProgress = oVM.delete(None);
2472	self.waitOnProgress(oProgress);
2473	except:
2474	reporter.logXcpt();
2475	else:
2476	try: oVM.deleteSettings();
2477	except: reporter.logXcpt();
2478	raise;
2479	except:
2480	reporter.errorXcpt('failed to create vm "%s"' % (sName));
2481	return None;
2482
2483	# pylint: disable=too-many-arguments,too-many-locals,too-many-statements,too-many-branches
2484	def createTestVM(self,
2485	sName,
2486	iGroup,
2487	sHd = None,
2488	cMbRam = None,
2489	cCpus = 1,
2490	fVirtEx = None,
2491	fNestedPaging = None,
2492	sDvdImage = None,
2493	sKind = "Other",
2494	fIoApic = None,
2495	fNstHwVirt = None,
2496	fPae = None,
2497	fFastBootLogo = True,
2498	eNic0Type = None,
2499	eNic0AttachType = None,
2500	sNic0NetName = 'default',
2501	sNic0MacAddr = 'grouped',
2502	sFloppy = None,
2503	fNatForwardingForTxs = None,
2504	sHddControllerType = 'IDE Controller',
2505	fVmmDevTestingPart = None,
2506	fVmmDevTestingMmio = False,
2507	sFirmwareType = 'bios',
2508	sChipsetType = 'piix3',
2509	sIommuType = 'none',
2510	sDvdControllerType = 'IDE Controller',
2511	sCom1RawFile = None):
2512	"""
2513	Creates a test VM with a immutable HD from the test resources.
2514	"""
2515	# create + register the VM
2516	oVM = self.createTestVMOnly(sName, sKind);
2517	if not oVM:
2518	return None;
2519
2520	# Configure the VM.
2521	fRc = True;
2522	oSession = self.openSession(oVM);
2523	if oSession is not None:
2524	fRc = oSession.setupPreferredConfig();
2525
2526	if fRc and cMbRam is not None :
2527	fRc = oSession.setRamSize(cMbRam);
2528	if fRc and cCpus is not None:
2529	fRc = oSession.setCpuCount(cCpus);
2530	if fRc and fVirtEx is not None:
2531	fRc = oSession.enableVirtEx(fVirtEx);
2532	if fRc and fNestedPaging is not None:
2533	fRc = oSession.enableNestedPaging(fNestedPaging);
2534	if fRc and fIoApic is not None:
2535	fRc = oSession.enableIoApic(fIoApic);
2536	if fRc and fNstHwVirt is not None:
2537	fRc = oSession.enableNestedHwVirt(fNstHwVirt);
2538	if fRc and fPae is not None:
2539	fRc = oSession.enablePae(fPae);
2540	if fRc and sDvdImage is not None:
2541	fRc = oSession.attachDvd(sDvdImage, sDvdControllerType);
2542	if fRc and sHd is not None:
2543	fRc = oSession.attachHd(sHd, sHddControllerType);
2544	if fRc and sFloppy is not None:
2545	fRc = oSession.attachFloppy(sFloppy);
2546	if fRc and eNic0Type is not None:
2547	fRc = oSession.setNicType(eNic0Type, 0);
2548	if fRc and (eNic0AttachType is not None or (sNic0NetName is not None and sNic0NetName != 'default')):
2549	fRc = oSession.setNicAttachment(eNic0AttachType, sNic0NetName, 0);
2550	if fRc and sNic0MacAddr is not None:
2551	if sNic0MacAddr == 'grouped':
2552	sNic0MacAddr = '%02X' % (iGroup);
2553	fRc = oSession.setNicMacAddress(sNic0MacAddr, 0);
2554	# Needed to reach the host (localhost) from the guest. See xTracker #9896.
2555	if fRc and self.fpApiVer >= 7.0:
2556	fRc = oSession.setNicLocalhostReachable(True, 0);
2557	if fRc and fNatForwardingForTxs is True:
2558	fRc = oSession.setupNatForwardingForTxs();
2559	if fRc and fFastBootLogo is not None:
2560	fRc = oSession.setupBootLogo(fFastBootLogo);
2561	if fRc and self.fEnableVrdp:
2562	fRc = oSession.setupVrdp(True, self.uVrdpBasePort + iGroup);
2563	if fRc and fVmmDevTestingPart is not None:
2564	fRc = oSession.enableVmmDevTestingPart(fVmmDevTestingPart, fVmmDevTestingMmio);
2565	if fRc and sFirmwareType == 'bios':
2566	fRc = oSession.setFirmwareType(vboxcon.FirmwareType_BIOS);
2567	elif fRc and sFirmwareType == 'efi':
2568	fRc = oSession.setFirmwareType(vboxcon.FirmwareType_EFI);
2569	if fRc and self.fEnableDebugger:
2570	fRc = oSession.setExtraData('VBoxInternal/DBGC/Enabled', '1');
2571	if fRc and self.fRecordingEnabled:
2572	try:
2573	if self.fpApiVer >= 6.1: # Only for VBox 6.1 and up now.
2574	reporter.log('Recording enabled');
2575	if self.cSecsRecordingMax > 0:
2576	reporter.log('Recording time limit is set to %d seconds' % (self.cSecsRecordingMax));
2577	if self.cMbRecordingMax > 0:
2578	reporter.log('Recording file limit is set to %d MB' % (self.cMbRecordingMax));
2579	oRecSettings = oSession.o.machine.recordingSettings;
2580	oRecSettings.enabled = True;
2581	aoScreens = self.oVBoxMgr.getArray(oRecSettings, 'screens');
2582	for oScreen in aoScreens:
2583	try:
2584	oScreen.enabled = True;
2585	sRecFile = os.path.join(self.sScratchPath, "recording-%s.webm" % (sName));
2586	oScreen.filename = sRecFile;
2587	sRecFile = oScreen.filename; # Get back the file from Main, in case it was modified somehow.
2588	dRecFile = { 'id' : oScreen.id, 'file' : sRecFile };
2589	self.adRecordingFiles.append(dRecFile);
2590	if self.fpApiVer >= 7.0:
2591	aFeatures = [ vboxcon.RecordingFeature_Video, ];
2592	if self.fRecordingAudio:
2593	aFeatures.append(vboxcon.RecordingFeature_Audio);
2594	try:
2595	oScreen.setFeatures(aFeatures);
2596	except: ## @todo Figure out why this is needed on Windows.
2597	oScreen.features = aFeatures;
2598	else: # <= VBox 6.1 the feature were kept as a ULONG.
2599	uFeatures = vboxcon.RecordingFeature_Video;
2600	if self.fRecordingAudio:
2601	uFeatures = uFeatures \| vboxcon.RecordingFeature_Audio;
2602	oScreen.features = uFeatures;
2603	reporter.log2('Recording screen %d to "%s"' % (dRecFile['id'], dRecFile['file'],));
2604	oScreen.maxTime = self.cSecsRecordingMax;
2605	oScreen.maxFileSize = self.cMbRecordingMax;
2606	except:
2607	reporter.errorXcpt('failed to configure recording for "%s" (screen %d)' % (sName, oScreen.id));
2608	else:
2609	# Not fatal.
2610	reporter.log('Recording only available for VBox >= 6.1, sorry!')
2611	except:
2612	reporter.errorXcpt('failed to configure recording for "%s"' % (sName));
2613	if fRc and sChipsetType == 'piix3':
2614	fRc = oSession.setChipsetType(vboxcon.ChipsetType_PIIX3);
2615	elif fRc and sChipsetType == 'ich9':
2616	fRc = oSession.setChipsetType(vboxcon.ChipsetType_ICH9);
2617	if fRc and sCom1RawFile:
2618	fRc = oSession.setupSerialToRawFile(0, sCom1RawFile);
2619	if fRc and self.fpApiVer >= 6.2 and hasattr(vboxcon, 'IommuType_AMD') and sIommuType == 'amd':
2620	fRc = oSession.setIommuType(vboxcon.IommuType_AMD);
2621	elif fRc and self.fpApiVer >= 6.2 and hasattr(vboxcon, 'IommuType_Intel') and sIommuType == 'intel':
2622	fRc = oSession.setIommuType(vboxcon.IommuType_Intel);
2623
2624	if fRc: fRc = oSession.saveSettings();
2625	if not fRc: oSession.discardSettings(True);
2626	oSession.close();
2627	if not fRc:
2628	if self.fpApiVer >= 4.0:
2629	try: oVM.unregister(vboxcon.CleanupMode_Full);
2630	except: reporter.logXcpt();
2631	try:
2632	if self.fpApiVer >= 4.3:
2633	oProgress = oVM.deleteConfig([]);
2634	else:
2635	oProgress = oVM.delete([]);
2636	self.waitOnProgress(oProgress);
2637	except:
2638	reporter.logXcpt();
2639	else:
2640	try: self.oVBox.unregisterMachine(oVM.id);
2641	except: reporter.logXcpt();
2642	try: oVM.deleteSettings();
2643	except: reporter.logXcpt();
2644	return None;
2645
2646	# success.
2647	reporter.log('created "%s" with name "%s"' % (oVM.id, sName));
2648	self.aoVMs.append(oVM);
2649	self.logVmInfo(oVM); # testing...
2650	return oVM;
2651	# pylint: enable=too-many-arguments,too-many-locals,too-many-statements
2652
2653	def createTestVmWithDefaults(self, # pylint: disable=too-many-arguments
2654	sName,
2655	iGroup,
2656	sKind,
2657	sDvdImage = None,
2658	fFastBootLogo = True,
2659	eNic0AttachType = None,
2660	sNic0NetName = 'default',
2661	sNic0MacAddr = 'grouped',
2662	fVmmDevTestingPart = None,
2663	fVmmDevTestingMmio = False,
2664	sCom1RawFile = None):
2665	"""
2666	Creates a test VM with all defaults and no HDs.
2667	"""
2668	# create + register the VM
2669	oVM = self.createTestVMOnly(sName, sKind);
2670	if oVM is not None:
2671	# Configure the VM with defaults according to sKind.
2672	fRc = True;
2673	oSession = self.openSession(oVM);
2674	if oSession is not None:
2675	if self.fpApiVer >= 6.0:
2676	try:
2677	oSession.o.machine.applyDefaults('');
2678	except:
2679	reporter.errorXcpt('failed to apply defaults to vm "%s"' % (sName,));
2680	fRc = False;
2681	else:
2682	reporter.error("Implement applyDefaults for vbox version %s" % (self.fpApiVer,));
2683	#fRc = oSession.setupPreferredConfig();
2684	fRc = False;
2685
2686	# Apply the specified configuration:
2687	if fRc and sDvdImage is not None:
2688	#fRc = oSession.insertDvd(sDvdImage); # attachDvd
2689	reporter.error('Implement: oSession.insertDvd(%s)' % (sDvdImage,));
2690	fRc = False;
2691
2692	if fRc and fFastBootLogo is not None:
2693	fRc = oSession.setupBootLogo(fFastBootLogo);
2694
2695	if fRc and (eNic0AttachType is not None or (sNic0NetName is not None and sNic0NetName != 'default')):
2696	fRc = oSession.setNicAttachment(eNic0AttachType, sNic0NetName, 0);
2697	if fRc and sNic0MacAddr is not None:
2698	if sNic0MacAddr == 'grouped':
2699	sNic0MacAddr = '%02X' % (iGroup,);
2700	fRc = oSession.setNicMacAddress(sNic0MacAddr, 0);
2701	# Needed to reach the host (localhost) from the guest. See xTracker #9896.
2702	if fRc and self.fpApiVer >= 7.0:
2703	fRc = oSession.setNicLocalhostReachable(True, 0);
2704
2705	if fRc and self.fEnableVrdp:
2706	fRc = oSession.setupVrdp(True, self.uVrdpBasePort + iGroup);
2707
2708	if fRc and fVmmDevTestingPart is not None:
2709	fRc = oSession.enableVmmDevTestingPart(fVmmDevTestingPart, fVmmDevTestingMmio);
2710
2711	if fRc and sCom1RawFile:
2712	fRc = oSession.setupSerialToRawFile(0, sCom1RawFile);
2713
2714	# Save the settings if we were successfull, otherwise discard them.
2715	if fRc:
2716	fRc = oSession.saveSettings();
2717	if not fRc:
2718	oSession.discardSettings(True);
2719	oSession.close();
2720
2721	if fRc is True:
2722	# If we've been successful, add the VM to the list and return it.
2723	# success.
2724	reporter.log('created "%s" with name "%s"' % (oVM.id, sName, ));
2725	self.aoVMs.append(oVM);
2726	self.logVmInfo(oVM); # testing...
2727	return oVM;
2728
2729	# Failed. Unregister the machine and delete it.
2730	if self.fpApiVer >= 4.0:
2731	try: oVM.unregister(vboxcon.CleanupMode_Full);
2732	except: reporter.logXcpt();
2733	try:
2734	if self.fpApiVer >= 4.3:
2735	oProgress = oVM.deleteConfig([]);
2736	else:
2737	oProgress = oVM.delete([]);
2738	self.waitOnProgress(oProgress);
2739	except:
2740	reporter.logXcpt();
2741	else:
2742	try: self.oVBox.unregisterMachine(oVM.id);
2743	except: reporter.logXcpt();
2744	try: oVM.deleteSettings();
2745	except: reporter.logXcpt();
2746	return None;
2747
2748	def addTestMachine(self, sNameOrId, fQuiet = False):
2749	"""
2750	Adds an already existing (that is, configured) test VM to the
2751	test VM list.
2752
2753	Returns the VM object on success, None if failed.
2754	"""
2755	# find + add the VM to the list.
2756	oVM = None;
2757	try:
2758	if self.fpApiVer >= 4.0:
2759	oVM = self.oVBox.findMachine(sNameOrId);
2760	else:
2761	reporter.error('fpApiVer=%s - did you remember to initialize the API' % (self.fpApiVer,));
2762	except:
2763	reporter.errorXcpt('could not find vm "%s"' % (sNameOrId,));
2764
2765	if oVM:
2766	self.aoVMs.append(oVM);
2767	if not fQuiet:
2768	reporter.log('Added "%s" with name "%s"' % (oVM.id, sNameOrId));
2769	self.logVmInfo(oVM);
2770	return oVM;
2771
2772	def forgetTestMachine(self, oVM, fQuiet = False):
2773	"""
2774	Forget about an already known test VM in the test VM list.
2775
2776	Returns True on success, False if failed.
2777	"""
2778	try:
2779	sUuid = oVM.id;
2780	sName = oVM.name;
2781	except:
2782	reporter.errorXcpt('failed to get the UUID for VM "%s"' % (oVM,));
2783	return False;
2784	try:
2785	self.aoVMs.remove(oVM);
2786	if not fQuiet:
2787	reporter.log('Removed "%s" with name "%s"' % (sUuid, sName));
2788	except:
2789	reporter.errorXcpt('could not find vm "%s"' % (sName,));
2790	return False;
2791	return True;
2792
2793	def openSession(self, oVM):
2794	"""
2795	Opens a session for the VM. Returns the a Session wrapper object that
2796	will automatically close the session when the wrapper goes out of scope.
2797
2798	On failure None is returned and an error is logged.
2799	"""
2800	try:
2801	sUuid = oVM.id;
2802	except:
2803	reporter.errorXcpt('failed to get the UUID for VM "%s"' % (oVM,));
2804	return None;
2805
2806	# This loop is a kludge to deal with us racing the closing of the
2807	# direct session of a previous VM run. See waitOnDirectSessionClose.
2808	for i in range(10):
2809	try:
2810	if self.fpApiVer <= 3.2:
2811	oSession = self.oVBoxMgr.openMachineSession(sUuid);
2812	else:
2813	oSession = self.oVBoxMgr.openMachineSession(oVM);
2814	break;
2815	except:
2816	if i == 9:
2817	reporter.errorXcpt('failed to open session for "%s" ("%s")' % (sUuid, oVM));
2818	return None;
2819	if i > 0:
2820	reporter.logXcpt('warning: failed to open session for "%s" ("%s") - retrying in %u secs' % (sUuid, oVM, i));
2821	self.waitOnDirectSessionClose(oVM, 5000 + i * 1000);
2822	from testdriver.vboxwrappers import SessionWrapper;
2823	return SessionWrapper(oSession, oVM, self.oVBox, self.oVBoxMgr, self, False);
2824
2825	#
2826	# Guest locations.
2827	#
2828
2829	@staticmethod
2830	def getGuestTempDir(oTestVm):
2831	"""
2832	Helper for finding a temporary directory in the test VM.
2833
2834	Note! It may be necessary to create it!
2835	"""
2836	if oTestVm.isWindows():
2837	return "C:\\Temp";
2838	if oTestVm.isOS2():
2839	return "C:\\Temp";
2840	return '/var/tmp';
2841
2842	@staticmethod
2843	def getGuestSystemDir(oTestVm, sPathPrefix = ''):
2844	"""
2845	Helper for finding a system directory in the test VM that we can play around with.
2846	sPathPrefix can be used to specify other directories, such as /usr/local/bin/ or /usr/bin, for instance.
2847
2848	On Windows this is always the System32 directory, so this function can be used as
2849	basis for locating other files in or under that directory.
2850	"""
2851	if oTestVm.isWindows():
2852	return oTestVm.pathJoin(TestDriver.getGuestWinDir(oTestVm), 'System32');
2853	if oTestVm.isOS2():
2854	return 'C:\\OS2\\DLL';
2855
2856	# OL / RHEL symlinks "/bin"/ to "/usr/bin". To avoid (unexpectedly) following symlinks, use "/usr/bin" then instead.
2857	if not sPathPrefix \
2858	and oTestVm.sKind in ('Oracle_64', 'Oracle'): ## @todo Does this apply for "RedHat" as well?
2859	return "/usr/bin";
2860
2861	return sPathPrefix + "/bin";
2862
2863	@staticmethod
2864	def getGuestSystemAdminDir(oTestVm, sPathPrefix = ''):
2865	"""
2866	Helper for finding a system admin directory ("sbin") in the test VM that we can play around with.
2867	sPathPrefix can be used to specify other directories, such as /usr/local/sbin/ or /usr/sbin, for instance.
2868
2869	On Windows this is always the System32 directory, so this function can be used as
2870	basis for locating other files in or under that directory.
2871	On UNIX-y systems this always is the "sh" shell to guarantee a common shell syntax.
2872	"""
2873	if oTestVm.isWindows():
2874	return oTestVm.pathJoin(TestDriver.getGuestWinDir(oTestVm), 'System32');
2875	if oTestVm.isOS2():
2876	return 'C:\\OS2\\DLL'; ## @todo r=andy Not sure here.
2877
2878	# OL / RHEL symlinks "/sbin"/ to "/usr/sbin". To avoid (unexpectedly) following symlinks, use "/usr/sbin" then instead.
2879	if not sPathPrefix \
2880	and oTestVm.sKind in ('Oracle_64', 'Oracle'): ## @todo Does this apply for "RedHat" as well?
2881	return "/usr/sbin";
2882
2883	return sPathPrefix + "/sbin";
2884
2885	@staticmethod
2886	def getGuestWinDir(oTestVm):
2887	"""
2888	Helper for finding the Windows directory in the test VM that we can play around with.
2889	ASSUMES that we always install Windows on drive C.
2890
2891	Returns the Windows directory, or an empty string when executed on a non-Windows guest (asserts).
2892	"""
2893	sWinDir = '';
2894	if oTestVm.isWindows():
2895	if oTestVm.sKind in ['WindowsNT4', 'WindowsNT3x',]:
2896	sWinDir = 'C:\\WinNT\\';
2897	else:
2898	sWinDir = 'C:\\Windows\\';
2899	assert sWinDir != '', 'Retrieving Windows directory for non-Windows OS';
2900	return sWinDir;
2901
2902	@staticmethod
2903	def getGuestSystemShell(oTestVm):
2904	"""
2905	Helper for finding the default system shell in the test VM.
2906	"""
2907	if oTestVm.isWindows():
2908	return TestDriver.getGuestSystemDir(oTestVm) + '\\cmd.exe';
2909	if oTestVm.isOS2():
2910	return TestDriver.getGuestSystemDir(oTestVm) + '\\..\\CMD.EXE';
2911	return "/bin/sh";
2912
2913	@staticmethod
2914	def getGuestSystemFileForReading(oTestVm):
2915	"""
2916	Helper for finding a file in the test VM that we can read.
2917	"""
2918	if oTestVm.isWindows():
2919	return TestDriver.getGuestSystemDir(oTestVm) + '\\ntdll.dll';
2920	if oTestVm.isOS2():
2921	return TestDriver.getGuestSystemDir(oTestVm) + '\\DOSCALL1.DLL';
2922	return "/bin/sh";
2923
2924	def getVmByName(self, sName):
2925	"""
2926	Get a test VM by name. Returns None if not found, logged.
2927	"""
2928	# Look it up in our 'cache'.
2929	for oVM in self.aoVMs:
2930	try:
2931	#reporter.log2('cur: %s / %s (oVM=%s)' % (oVM.name, oVM.id, oVM));
2932	if oVM.name == sName:
2933	return oVM;
2934	except:
2935	reporter.errorXcpt('failed to get the name from the VM "%s"' % (oVM));
2936
2937	# Look it up the standard way.
2938	return self.addTestMachine(sName, fQuiet = True);
2939
2940	def getVmByUuid(self, sUuid):
2941	"""
2942	Get a test VM by uuid. Returns None if not found, logged.
2943	"""
2944	# Look it up in our 'cache'.
2945	for oVM in self.aoVMs:
2946	try:
2947	if oVM.id == sUuid:
2948	return oVM;
2949	except:
2950	reporter.errorXcpt('failed to get the UUID from the VM "%s"' % (oVM));
2951
2952	# Look it up the standard way.
2953	return self.addTestMachine(sUuid, fQuiet = True);
2954
2955	def waitOnProgress(self, oProgress, cMsTimeout = 1000000, fErrorOnTimeout = True, cMsInterval = 1000):
2956	"""
2957	Waits for a progress object to complete. Returns the status code.
2958	"""
2959	# Wait for progress no longer than cMsTimeout time period.
2960	tsStart = datetime.datetime.now()
2961	while True:
2962	self.processPendingEvents();
2963	try:
2964	if oProgress.completed:
2965	break;
2966	except:
2967	return -1;
2968	self.processPendingEvents();
2969
2970	tsNow = datetime.datetime.now()
2971	tsDelta = tsNow - tsStart
2972	if ((tsDelta.microseconds + tsDelta.seconds * 1000000) // 1000) > cMsTimeout:
2973	if fErrorOnTimeout:
2974	reporter.errorTimeout('Timeout while waiting for progress.')
2975	return -1
2976
2977	reporter.doPollWork('vbox.TestDriver.waitOnProgress');
2978	try: oProgress.waitForCompletion(cMsInterval);
2979	except: return -2;
2980
2981	try: rc = oProgress.resultCode;
2982	except: rc = -2;
2983	self.processPendingEvents();
2984	return rc;
2985
2986	def waitOnDirectSessionClose(self, oVM, cMsTimeout):
2987	"""
2988	Waits for the VM process to close it's current direct session.
2989
2990	Returns None.
2991	"""
2992	# Get the original values so we're not subject to
2993	try:
2994	eCurState = oVM.sessionState;
2995	if self.fpApiVer >= 5.0:
2996	sCurName = sOrgName = oVM.sessionName;
2997	else:
2998	sCurName = sOrgName = oVM.sessionType;
2999	if self.fpApiVer >= 4.2:
3000	iCurPid = iOrgPid = oVM.sessionPID;
3001	else:
3002	iCurPid = iOrgPid = oVM.sessionPid;
3003	except Exception as oXcpt:
3004	if ComError.notEqual(oXcpt, ComError.E_ACCESSDENIED):
3005	reporter.logXcpt();
3006	self.processPendingEvents();
3007	return None;
3008	self.processPendingEvents();
3009
3010	msStart = base.timestampMilli();
3011	while iCurPid == iOrgPid \
3012	and sCurName == sOrgName \
3013	and sCurName != '' \
3014	and base.timestampMilli() - msStart < cMsTimeout \
3015	and eCurState in (vboxcon.SessionState_Unlocking, vboxcon.SessionState_Spawning, vboxcon.SessionState_Locked,):
3016	self.processEvents(1000);
3017	try:
3018	eCurState = oVM.sessionState;
3019	sCurName = oVM.sessionName if self.fpApiVer >= 5.0 else oVM.sessionType;
3020	iCurPid = oVM.sessionPID if self.fpApiVer >= 4.2 else oVM.sessionPid;
3021	except Exception as oXcpt:
3022	if ComError.notEqual(oXcpt, ComError.E_ACCESSDENIED):
3023	reporter.logXcpt();
3024	break;
3025	self.processPendingEvents();
3026	self.processPendingEvents();
3027	return None;
3028
3029	def uploadStartupLogFile(self, oVM, sVmName):
3030	"""
3031	Uploads the VBoxStartup.log when present.
3032	"""
3033	fRc = True;
3034	try:
3035	sLogFile = os.path.join(oVM.logFolder, 'VBoxHardening.log');
3036	except:
3037	reporter.logXcpt();
3038	fRc = False;
3039	else:
3040	if os.path.isfile(sLogFile):
3041	reporter.addLogFile(sLogFile, 'log/release/vm', '%s hardening log' % (sVmName, ),
3042	sAltName = '%s-%s' % (sVmName, os.path.basename(sLogFile),));
3043	return fRc;
3044
3045	def annotateAndUploadProcessReport(self, sProcessReport, sFilename, sKind, sDesc):
3046	"""
3047	Annotates the given VM process report and uploads it if successfull.
3048	"""
3049	fRc = False;
3050	if self.oBuild is not None and self.oBuild.sInstallPath is not None:
3051	oResolver = btresolver.BacktraceResolver(self.sScratchPath, self.oBuild.sInstallPath,
3052	self.getBuildOs(), self.getBuildArch(),
3053	fnLog = reporter.log);
3054	fRcTmp = oResolver.prepareEnv();
3055	if fRcTmp:
3056	reporter.log('Successfully prepared environment');
3057	sReportDbgSym = oResolver.annotateReport(sProcessReport);
3058	if sReportDbgSym and len(sReportDbgSym) > 8:
3059	reporter.addLogString(sReportDbgSym, sFilename, sKind, sDesc);
3060	fRc = True;
3061	else:
3062	reporter.log('Annotating report failed');
3063	oResolver.cleanupEnv();
3064	return fRc;
3065
3066	def startVmEx(self, oVM, fWait = True, sType = None, sName = None, asEnv = None): # pylint: disable=too-many-locals,too-many-statements
3067	"""
3068	Start the VM, returning the VM session and progress object on success.
3069	The session is also added to the task list and to the aoRemoteSessions set.
3070
3071	asEnv is a list of string on the putenv() form.
3072
3073	On failure (None, None) is returned and an error is logged.
3074	"""
3075	# Massage and check the input.
3076	if sType is None:
3077	sType = self.sSessionType;
3078	if sName is None:
3079	try: sName = oVM.name;
3080	except: sName = 'bad-vm-handle';
3081	reporter.log('startVmEx: sName=%s fWait=%s sType=%s' % (sName, fWait, sType));
3082	if oVM is None:
3083	return (None, None);
3084
3085	## @todo Do this elsewhere.
3086	# Hack alert. Disables all annoying GUI popups.
3087	if sType == 'gui' and not self.aoRemoteSessions:
3088	try:
3089	self.oVBox.setExtraData('GUI/Input/AutoCapture', 'false');
3090	if self.fpApiVer >= 3.2:
3091	self.oVBox.setExtraData('GUI/LicenseAgreed', '8');
3092	else:
3093	self.oVBox.setExtraData('GUI/LicenseAgreed', '7');
3094	self.oVBox.setExtraData('GUI/RegistrationData', 'triesLeft=0');
3095	self.oVBox.setExtraData('GUI/SUNOnlineData', 'triesLeft=0');
3096	self.oVBox.setExtraData('GUI/SuppressMessages', 'confirmVMReset,remindAboutMouseIntegrationOn,'
3097	'remindAboutMouseIntegrationOff,remindAboutPausedVMInput,confirmInputCapture,'
3098	'confirmGoingFullscreen,remindAboutInaccessibleMedia,remindAboutWrongColorDepth,'
3099	'confirmRemoveMedium,allPopupPanes,allMessageBoxes,all');
3100	self.oVBox.setExtraData('GUI/UpdateDate', 'never');
3101	self.oVBox.setExtraData('GUI/PreventBetaWarning', self.oVBox.version);
3102	except:
3103	reporter.logXcpt();
3104
3105	# The UUID for the name.
3106	try:
3107	sUuid = oVM.id;
3108	except:
3109	reporter.errorXcpt('failed to get the UUID for VM "%s"' % (oVM));
3110	return (None, None);
3111	self.processPendingEvents();
3112
3113	# Construct the environment.
3114	self.sSessionLogFile = '%s/VM-%s.log' % (self.sScratchPath, sUuid);
3115	try: os.remove(self.sSessionLogFile);
3116	except: pass;
3117	if self.sLogSessionDest:
3118	sLogDest = self.sLogSessionDest;
3119	else:
3120	sLogDest = 'file=%s' % (self.sSessionLogFile,);
3121	asEnvFinal = [
3122	'VBOX_LOG=%s' % (self.sLogSessionGroups,),
3123	'VBOX_LOG_FLAGS=%s' % (self.sLogSessionFlags,),
3124	'VBOX_LOG_DEST=nodeny %s' % (sLogDest,),
3125	'VBOX_RELEASE_LOG_FLAGS=append time',
3126	];
3127	if sType == 'gui':
3128	asEnvFinal.append('VBOX_GUI_DBG_ENABLED=1');
3129	if asEnv is not None and asEnv:
3130	asEnvFinal += asEnv;
3131
3132	reporter.log2('Session environment:\n%s' % (asEnvFinal,));
3133
3134	# Shortcuts for local testing.
3135	oProgress = oWrapped = None;
3136	oTestVM = self.oTestVmSet.findTestVmByName(sName) if self.oTestVmSet is not None else None;
3137	try:
3138	if oTestVM is not None \
3139	and oTestVM.fSnapshotRestoreCurrent is True:
3140	if oVM.state is vboxcon.MachineState_Running:
3141	reporter.log2('Machine "%s" already running.' % (sName,));
3142	oProgress = None;
3143	oWrapped = self.openSession(oVM);
3144	else:
3145	reporter.log2('Checking if snapshot for machine "%s" exists.' % (sName,));
3146	oSessionWrapperRestore = self.openSession(oVM);
3147	if oSessionWrapperRestore is not None:
3148	oSnapshotCur = oVM.currentSnapshot;
3149	if oSnapshotCur is not None:
3150	reporter.log2('Restoring snapshot for machine "%s".' % (sName,));
3151	oSessionWrapperRestore.restoreSnapshot(oSnapshotCur);
3152	reporter.log2('Current snapshot for machine "%s" restored.' % (sName,));
3153	else:
3154	reporter.log('warning: no current snapshot for machine "%s" found.' % (sName,));
3155	oSessionWrapperRestore.close();
3156	except:
3157	reporter.errorXcpt();
3158	return (None, None);
3159
3160	oSession = None; # Must be initialized, otherwise the log statement at the end of the function can fail.
3161
3162	# Open a remote session, wait for this operation to complete.
3163	# (The loop is a kludge to deal with us racing the closing of the
3164	# direct session of a previous VM run. See waitOnDirectSessionClose.)
3165	if oWrapped is None:
3166	for i in range(10):
3167	try:
3168	if self.fpApiVer < 4.3 \
3169	or (self.fpApiVer == 4.3 and not hasattr(self.oVBoxMgr, 'getSessionObject')):
3170	oSession = self.oVBoxMgr.mgr.getSessionObject(self.oVBox); # pylint: disable=no-member
3171	elif self.fpApiVer < 5.2 \
3172	or (self.fpApiVer == 5.2 and hasattr(self.oVBoxMgr, 'vbox')):
3173	oSession = self.oVBoxMgr.getSessionObject(self.oVBox); # pylint: disable=no-member
3174	else:
3175	oSession = self.oVBoxMgr.getSessionObject(); # pylint: disable=no-member,no-value-for-parameter
3176	if self.fpApiVer < 3.3:
3177	oProgress = self.oVBox.openRemoteSession(oSession, sUuid, sType, '\n'.join(asEnvFinal));
3178	else:
3179	if self.uApiRevision >= self.makeApiRevision(6, 1, 0, 1):
3180	oProgress = oVM.launchVMProcess(oSession, sType, asEnvFinal);
3181	else:
3182	oProgress = oVM.launchVMProcess(oSession, sType, '\n'.join(asEnvFinal));
3183	break;
3184	except:
3185	if i == 9:
3186	reporter.errorXcpt('failed to start VM "%s" ("%s"), aborting.' % (sUuid, sName));
3187	return (None, None);
3188	oSession = None;
3189	if i >= 0:
3190	reporter.logXcpt('warning: failed to start VM "%s" ("%s") - retrying in %u secs.' % (sUuid, oVM, i)); # pylint: disable=line-too-long
3191	self.waitOnDirectSessionClose(oVM, 5000 + i * 1000);
3192	if fWait and oProgress is not None:
3193	rc = self.waitOnProgress(oProgress);
3194	if rc < 0:
3195	self.waitOnDirectSessionClose(oVM, 5000);
3196
3197	# VM failed to power up, still collect VBox.log, need to wrap the session object
3198	# in order to use the helper for adding the log files to the report.
3199	from testdriver.vboxwrappers import SessionWrapper;
3200	oTmp = SessionWrapper(oSession, oVM, self.oVBox, self.oVBoxMgr, self, True, sName, self.sSessionLogFile);
3201	oTmp.addLogsToReport();
3202
3203	# Try to collect a stack trace of the process for further investigation of any startup hangs.
3204	uPid = oTmp.getPid();
3205	if uPid is not None:
3206	sHostProcessInfoHung = utils.processGetInfo(uPid, fSudo = True);
3207	if sHostProcessInfoHung is not None:
3208	reporter.log('Trying to annotate the hung VM startup process report, please stand by...');
3209	fRcTmp = self.annotateAndUploadProcessReport(sHostProcessInfoHung, 'vmprocess-startup-hung.log',
3210	'process/report/vm', 'Annotated hung VM process state during startup'); # pylint: disable=line-too-long
3211	# Upload the raw log for manual annotation in case resolving failed.
3212	if not fRcTmp:
3213	reporter.log('Failed to annotate hung VM process report, uploading raw report');
3214	reporter.addLogString(sHostProcessInfoHung, 'vmprocess-startup-hung.log', 'process/report/vm',
3215	'Hung VM process state during startup');
3216
3217	try:
3218	if oSession is not None:
3219	oSession.close();
3220	except: pass;
3221	reportError(oProgress, 'failed to open session for "%s"' % (sName));
3222	self.uploadStartupLogFile(oVM, sName);
3223	return (None, None);
3224	reporter.log2('waitOnProgress -> %s' % (rc,));
3225
3226	# Wrap up the session object and push on to the list before returning it.
3227	if oWrapped is None:
3228	from testdriver.vboxwrappers import SessionWrapper;
3229	oWrapped = SessionWrapper(oSession, oVM, self.oVBox, self.oVBoxMgr, self, True, sName, self.sSessionLogFile);
3230
3231	oWrapped.registerEventHandlerForTask();
3232	self.aoRemoteSessions.append(oWrapped);
3233	if oWrapped is not self.aoRemoteSessions[len(self.aoRemoteSessions) - 1]:
3234	reporter.error('not by reference: oWrapped=%s aoRemoteSessions[%s]=%s'
3235	% (oWrapped, len(self.aoRemoteSessions) - 1,
3236	self.aoRemoteSessions[len(self.aoRemoteSessions) - 1]));
3237	self.addTask(oWrapped);
3238
3239	reporter.log2('startVmEx: oSession=%s, oSessionWrapper=%s, oProgress=%s' % (oSession, oWrapped, oProgress));
3240
3241	from testdriver.vboxwrappers import ProgressWrapper;
3242	return (oWrapped, ProgressWrapper(oProgress, self.oVBoxMgr, self,
3243	'starting %s' % (sName,)) if oProgress else None);
3244
3245	def startVm(self, oVM, sType=None, sName = None, asEnv = None):
3246	""" Simplified version of startVmEx. """
3247	oSession, _ = self.startVmEx(oVM, True, sType, sName, asEnv = asEnv);
3248	return oSession;
3249
3250	def startVmByNameEx(self, sName, fWait=True, sType=None, asEnv = None):
3251	"""
3252	Start the VM, returning the VM session and progress object on success.
3253	The session is also added to the task list and to the aoRemoteSessions set.
3254
3255	On failure (None, None) is returned and an error is logged.
3256	"""
3257	oVM = self.getVmByName(sName);
3258	if oVM is None:
3259	return (None, None);
3260	return self.startVmEx(oVM, fWait, sType, sName, asEnv = asEnv);
3261
3262	def startVmByName(self, sName, sType=None, asEnv = None):
3263	"""
3264	Start the VM, returning the VM session on success. The session is
3265	also added to the task list and to the aoRemoteSessions set.
3266
3267	On failure None is returned and an error is logged.
3268	"""
3269	oSession, _ = self.startVmByNameEx(sName, True, sType, asEnv = asEnv);
3270	return oSession;
3271
3272	def terminateVmBySession(self, oSession, oProgress = None, fTakeScreenshot = None): # pylint: disable=too-many-statements
3273	"""
3274	Terminates the VM specified by oSession and adds the release logs to
3275	the test report.
3276
3277	This will try achieve this by using powerOff, but will resort to
3278	tougher methods if that fails.
3279
3280	The session will always be removed from the task list.
3281	The session will be closed unless we fail to kill the process.
3282	The session will be removed from the remote session list if closed.
3283
3284	The progress object (a wrapper!) is for teleportation and similar VM
3285	operations, it will be attempted canceled before powering off the VM.
3286	Failures are logged but ignored.
3287	The progress object will always be removed from the task list.
3288
3289	Returns True if powerOff and session close both succeed.
3290	Returns False if on failure (logged), including when we successfully
3291	kill the VM process.
3292	"""
3293
3294	reporter.log2('terminateVmBySession: oSession=%s (pid=%s) oProgress=%s' % (oSession.sName, oSession.getPid(), oProgress));
3295
3296	if self.fVmNoTerminate:
3297	reporter.log('terminateVmBySession: Skipping, as --vbox-vm-no-terminate was specified');
3298	# Make sure that we still process the events the VM needs.
3299	self.sleep(24 * 60 * 60 * 1000);
3300
3301	# Call getPid first to make sure the PID is cached in the wrapper.
3302	oSession.getPid();
3303
3304	#
3305	# If the host is out of memory, just skip all the info collection as it
3306	# requires memory too and seems to wedge.
3307	#
3308	sHostProcessInfo = None;
3309	sHostProcessInfoHung = None;
3310	sLastScreenshotPath = None;
3311	sOsKernelLog = None;
3312	sVgaText = None;
3313	asMiscInfos = [];
3314
3315	if not oSession.fHostMemoryLow:
3316	# Try to fetch the VM process info before meddling with its state.
3317	if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
3318	sHostProcessInfo = utils.processGetInfo(oSession.getPid(), fSudo = True);
3319
3320	#
3321	# Pause the VM if we're going to take any screenshots or dig into the
3322	# guest. Failures are quitely ignored.
3323	#
3324	if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
3325	try:
3326	if oSession.oVM.state in [ vboxcon.MachineState_Running,
3327	vboxcon.MachineState_LiveSnapshotting,
3328	vboxcon.MachineState_Teleporting ]:
3329	oSession.o.console.pause();
3330	except:
3331	reporter.logXcpt();
3332
3333	#
3334	# Take Screenshot and upload it (see below) to Test Manager if appropriate/requested.
3335	#
3336	if fTakeScreenshot is True or self.fAlwaysUploadScreenshots or reporter.testErrorCount() > 0:
3337	sLastScreenshotPath = os.path.join(self.sScratchPath, "LastScreenshot-%s.png" % oSession.sName);
3338	fRc = oSession.takeScreenshot(sLastScreenshotPath);
3339	if fRc is not True:
3340	sLastScreenshotPath = None;
3341
3342	# Query the OS kernel log from the debugger if appropriate/requested.
3343	if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
3344	sOsKernelLog = oSession.queryOsKernelLog();
3345
3346	# Do "info vgatext all" separately.
3347	if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
3348	sVgaText = oSession.queryDbgInfoVgaText();
3349
3350	# Various infos (do after kernel because of symbols).
3351	if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
3352	# Dump the guest stack for all CPUs.
3353	cCpus = oSession.getCpuCount();
3354	if cCpus > 0:
3355	for iCpu in xrange(0, cCpus):
3356	sThis = oSession.queryDbgGuestStack(iCpu);
3357	if sThis:
3358	asMiscInfos += [
3359	'================ start guest stack VCPU %s ================\n' % (iCpu,),
3360	sThis,
3361	'================ end guest stack VCPU %s ==================\n' % (iCpu,),
3362	];
3363
3364	for sInfo, sArg in [ ('mode', 'all'),
3365	('fflags', ''),
3366	('cpumguest', 'verbose all'),
3367	('cpumguestinstr', 'symbol all'),
3368	('exits', ''),
3369	('pic', ''),
3370	('apic', ''),
3371	('apiclvt', ''),
3372	('apictimer', ''),
3373	('ioapic', ''),
3374	('pit', ''),
3375	('phys', ''),
3376	('clocks', ''),
3377	('timers', ''),
3378	('gdt', ''),
3379	('ldt', ''),
3380	]:
3381	if sInfo in ['apic',] and self.fpApiVer < 5.1: # asserts and burns
3382	continue;
3383	sThis = oSession.queryDbgInfo(sInfo, sArg);
3384	if sThis:
3385	if sThis[-1] != '\n':
3386	sThis += '\n';
3387	asMiscInfos += [
3388	'================ start %s %s ================\n' % (sInfo, sArg),
3389	sThis,
3390	'================ end %s %s ==================\n' % (sInfo, sArg),
3391	];
3392
3393	#
3394	# Terminate the VM
3395	#
3396
3397	# Cancel the progress object if specified.
3398	if oProgress is not None:
3399	if not oProgress.isCompleted() and oProgress.isCancelable():
3400	reporter.log2('terminateVmBySession: canceling "%s"...' % (oProgress.sName));
3401	try:
3402	oProgress.o.cancel();
3403	except:
3404	reporter.logXcpt();
3405	else:
3406	oProgress.wait();
3407	self.removeTask(oProgress);
3408
3409	# Check if the VM has terminated by itself before powering it off.
3410	fClose = True;
3411	fRc = True;
3412	if oSession.needsPoweringOff():
3413	reporter.log('terminateVmBySession: powering off "%s"...' % (oSession.sName,));
3414	fRc = oSession.powerOff(fFudgeOnFailure = False);
3415	if fRc is not True:
3416	# power off failed, try terminate it in a nice manner.
3417	fRc = False;
3418	uPid = oSession.getPid();
3419	if uPid is not None:
3420	#
3421	# Collect some information about the VM process first to have
3422	# some state information for further investigation why powering off failed.
3423	#
3424	sHostProcessInfoHung = utils.processGetInfo(uPid, fSudo = True);
3425
3426	# Exterminate...
3427	reporter.error('terminateVmBySession: Terminating PID %u (VM %s)' % (uPid, oSession.sName));
3428	fClose = base.processTerminate(uPid);
3429	if fClose is True:
3430	self.waitOnDirectSessionClose(oSession.oVM, 5000);
3431	fClose = oSession.waitForTask(1000);
3432
3433	if fClose is not True:
3434	# Being nice failed...
3435	reporter.error('terminateVmBySession: Termination failed, trying to kill PID %u (VM %s) instead' \
3436	% (uPid, oSession.sName));
3437	fClose = base.processKill(uPid);
3438	if fClose is True:
3439	self.waitOnDirectSessionClose(oSession.oVM, 5000);
3440	fClose = oSession.waitForTask(1000);
3441	if fClose is not True:
3442	reporter.error('terminateVmBySession: Failed to kill PID %u (VM %s)' % (uPid, oSession.sName));
3443
3444	# The final steps.
3445	if fClose is True:
3446	reporter.log('terminateVmBySession: closing session "%s"...' % (oSession.sName,));
3447	oSession.close();
3448	self.waitOnDirectSessionClose(oSession.oVM, 10000);
3449	try:
3450	eState = oSession.oVM.state;
3451	except:
3452	reporter.logXcpt();
3453	else:
3454	if eState == vboxcon.MachineState_Aborted:
3455	reporter.error('terminateVmBySession: The VM "%s" aborted!' % (oSession.sName,));
3456	self.removeTask(oSession);
3457
3458	#
3459	# Add the release log, debug log and a screenshot of the VM to the test report.
3460	#
3461	if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
3462	oSession.addLogsToReport();
3463
3464	# Add a screenshot if it has been requested and taken successfully.
3465	if sLastScreenshotPath is not None:
3466	if reporter.testErrorCount() > 0:
3467	reporter.addLogFile(sLastScreenshotPath, 'screenshot/failure', 'Last VM screenshot');
3468	else:
3469	reporter.addLogFile(sLastScreenshotPath, 'screenshot/success', 'Last VM screenshot');
3470
3471	# Add the guest OS log if it has been requested and taken successfully.
3472	if sOsKernelLog is not None:
3473	reporter.addLogString(sOsKernelLog, 'kernel.log', 'log/guest/kernel', 'Guest OS kernel log');
3474
3475	# Add "info vgatext all" if we've got it.
3476	if sVgaText is not None:
3477	reporter.addLogString(sVgaText, 'vgatext.txt', 'info/vgatext', 'info vgatext all');
3478
3479	# Add the "info xxxx" items if we've got any.
3480	if asMiscInfos:
3481	reporter.addLogString(u''.join(asMiscInfos), 'info.txt', 'info/collection', 'A bunch of info items.');
3482
3483	# Add the host process info if we were able to retrieve it.
3484	if sHostProcessInfo is not None:
3485	reporter.log('Trying to annotate the VM process report, please stand by...');
3486	fRcTmp = self.annotateAndUploadProcessReport(sHostProcessInfo, 'vmprocess.log',
3487	'process/report/vm', 'Annotated VM process state');
3488	# Upload the raw log for manual annotation in case resolving failed.
3489	if not fRcTmp:
3490	reporter.log('Failed to annotate VM process report, uploading raw report');
3491	reporter.addLogString(sHostProcessInfo, 'vmprocess.log', 'process/report/vm', 'VM process state');
3492
3493	# Add the host process info for failed power off attempts if we were able to retrieve it.
3494	if sHostProcessInfoHung is not None:
3495	reporter.log('Trying to annotate the hung VM process report, please stand by...');
3496	fRcTmp = self.annotateAndUploadProcessReport(sHostProcessInfoHung, 'vmprocess-hung.log',
3497	'process/report/vm', 'Annotated hung VM process state');
3498	# Upload the raw log for manual annotation in case resolving failed.
3499	if not fRcTmp:
3500	reporter.log('Failed to annotate hung VM process report, uploading raw report');
3501	fRcTmp = reporter.addLogString(sHostProcessInfoHung, 'vmprocess-hung.log', 'process/report/vm',
3502	'Hung VM process state');
3503	if not fRcTmp:
3504	try: reporter.log('***** START vmprocess-hung.log ***\n%s\n*** END vmprocess-hung.log *****\n'
3505	% (sHostProcessInfoHung,));
3506	except: pass; # paranoia
3507
3508	# Upload the screen video recordings if appropriate.
3509	if self.fAlwaysUploadRecordings or reporter.testErrorCount() > 0:
3510	reporter.log2('Uploading %d screen recordings ...' % (len(self.adRecordingFiles),));
3511	for dRecFile in self.adRecordingFiles:
3512	reporter.log2('Uploading screen recording "%s" (screen %d)' % (dRecFile['file'], dRecFile['id']));
3513	reporter.addLogFile(dRecFile['file'],
3514	'screenrecording/failure' if reporter.testErrorCount() > 0 else 'screenrecording/success',
3515	'Recording of screen #%d' % (dRecFile['id'],));
3516
3517	return fRc;
3518
3519
3520	#
3521	# Some information query functions (mix).
3522	#
3523	# Methods require the VBox API. If the information is provided by both
3524	# the testboxscript as well as VBox API, we'll check if it matches.
3525	#
3526
3527	def _hasHostCpuFeature(self, sEnvVar, sEnum, fpApiMinVer, fQuiet):
3528	"""
3529	Common Worker for hasHostNestedPaging() and hasHostHwVirt().
3530
3531	Returns True / False.
3532	Raises exception on environment / host mismatch.
3533	"""
3534	fEnv = os.environ.get(sEnvVar, None);
3535	if fEnv is not None:
3536	fEnv = fEnv.lower() not in [ 'false', 'f', 'not', 'no', 'n', '0', ];
3537
3538	fVBox = None;
3539	self.importVBoxApi();
3540	if self.fpApiVer >= fpApiMinVer and hasattr(vboxcon, sEnum):
3541	try:
3542	fVBox = self.oVBox.host.getProcessorFeature(getattr(vboxcon, sEnum));
3543	except:
3544	if not fQuiet:
3545	reporter.logXcpt();
3546
3547	if fVBox is not None:
3548	if fEnv is not None:
3549	if fEnv != fVBox and not fQuiet:
3550	reporter.log('TestBox configuration overwritten: fVBox=%s (%s) vs. fEnv=%s (%s)'
3551	% (fVBox, sEnum, fEnv, sEnvVar));
3552	return fEnv;
3553	return fVBox;
3554	if fEnv is not None:
3555	return fEnv;
3556	return False;
3557
3558	def hasHostHwVirt(self, fQuiet = False):
3559	"""
3560	Checks if hardware assisted virtualization is supported by the host.
3561
3562	Returns True / False.
3563	Raises exception on environment / host mismatch.
3564	"""
3565	return self._hasHostCpuFeature('TESTBOX_HAS_HW_VIRT', 'ProcessorFeature_HWVirtEx', 3.1, fQuiet);
3566
3567	def hasHostNestedPaging(self, fQuiet = False):
3568	"""
3569	Checks if nested paging is supported by the host.
3570
3571	Returns True / False.
3572	Raises exception on environment / host mismatch.
3573	"""
3574	return self._hasHostCpuFeature('TESTBOX_HAS_NESTED_PAGING', 'ProcessorFeature_NestedPaging', 4.2, fQuiet) \
3575	and self.hasHostHwVirt(fQuiet);
3576
3577	def hasHostNestedHwVirt(self, fQuiet = False):
3578	"""
3579	Checks if nested hardware-assisted virtualization is supported by the host.
3580
3581	Returns True / False.
3582	Raises exception on environment / host mismatch.
3583	"""
3584	return self._hasHostCpuFeature('TESTBOX_HAS_NESTED_HWVIRT', 'ProcessorFeature_NestedHWVirt', 6.0, fQuiet) \
3585	and self.hasHostHwVirt(fQuiet);
3586
3587	def hasHostLongMode(self, fQuiet = False):
3588	"""
3589	Checks if the host supports 64-bit guests.
3590
3591	Returns True / False.
3592	Raises exception on environment / host mismatch.
3593	"""
3594	# Note that the testboxscript doesn't export this variable atm.
3595	return self._hasHostCpuFeature('TESTBOX_HAS_LONG_MODE', 'ProcessorFeature_LongMode', 3.1, fQuiet);
3596
3597	def getHostCpuCount(self, fQuiet = False):
3598	"""
3599	Returns the number of CPUs on the host.
3600
3601	Returns True / False.
3602	Raises exception on environment / host mismatch.
3603	"""
3604	cEnv = os.environ.get('TESTBOX_CPU_COUNT', None);
3605	if cEnv is not None:
3606	cEnv = int(cEnv);
3607
3608	try:
3609	cVBox = self.oVBox.host.processorOnlineCount;
3610	except:
3611	if not fQuiet:
3612	reporter.logXcpt();
3613	cVBox = None;
3614
3615	if cVBox is not None:
3616	if cEnv is not None:
3617	assert cVBox == cEnv, 'Misconfigured TestBox: VBox: %u CPUs, testboxscript: %u CPUs' % (cVBox, cEnv);
3618	return cVBox;
3619	if cEnv is not None:
3620	return cEnv;
3621	return 1;
3622
3623	def _getHostCpuDesc(self, fQuiet = False):
3624	"""
3625	Internal method used for getting the host CPU description from VBoxSVC.
3626	Returns description string, on failure an empty string is returned.
3627	"""
3628	try:
3629	return self.oVBox.host.getProcessorDescription(0);
3630	except:
3631	if not fQuiet:
3632	reporter.logXcpt();
3633	return '';
3634
3635	def isHostCpuAmd(self, fQuiet = False):
3636	"""
3637	Checks if the host CPU vendor is AMD.
3638
3639	Returns True / False.
3640	"""
3641	sCpuDesc = self._getHostCpuDesc(fQuiet);
3642	return 'AMD' in sCpuDesc or sCpuDesc == 'AuthenticAMD';
3643
3644	def isHostCpuIntel(self, fQuiet = False):
3645	"""
3646	Checks if the host CPU vendor is Intel.
3647
3648	Returns True / False.
3649	"""
3650	sCpuDesc = self._getHostCpuDesc(fQuiet);
3651	return sCpuDesc.startswith("Intel") or sCpuDesc == 'GenuineIntel';
3652
3653	def isHostCpuVia(self, fQuiet = False):
3654	"""
3655	Checks if the host CPU vendor is VIA (or Centaur).
3656
3657	Returns True / False.
3658	"""
3659	sCpuDesc = self._getHostCpuDesc(fQuiet);
3660	return sCpuDesc.startswith("VIA") or sCpuDesc == 'CentaurHauls';
3661
3662	def isHostCpuShanghai(self, fQuiet = False):
3663	"""
3664	Checks if the host CPU vendor is Shanghai (or Zhaoxin).
3665
3666	Returns True / False.
3667	"""
3668	sCpuDesc = self._getHostCpuDesc(fQuiet);
3669	return sCpuDesc.startswith("ZHAOXIN") or sCpuDesc.strip(' ') == 'Shanghai';
3670
3671	def isHostCpuP4(self, fQuiet = False):
3672	"""
3673	Checks if the host CPU is a Pentium 4 / Pentium D.
3674
3675	Returns True / False.
3676	"""
3677	if not self.isHostCpuIntel(fQuiet):
3678	return False;
3679
3680	(uFamilyModel, _, _, _) = self.oVBox.host.getProcessorCPUIDLeaf(0, 0x1, 0);
3681	return ((uFamilyModel >> 8) & 0xf) == 0xf;
3682
3683	def hasRawModeSupport(self, fQuiet = False):
3684	"""
3685	Checks if raw-mode is supported by VirtualBox that the testbox is
3686	configured for it.
3687
3688	Returns True / False.
3689	Raises no exceptions.
3690
3691	Note! Differs from the rest in that we don't require the
3692	TESTBOX_WITH_RAW_MODE value to match the API. It is
3693	sometimes helpful to disable raw-mode on individual
3694	test boxes. (This probably goes for
3695	"""
3696	# The environment variable can be used to disable raw-mode.
3697	fEnv = os.environ.get('TESTBOX_WITH_RAW_MODE', None);
3698	if fEnv is not None:
3699	fEnv = fEnv.lower() not in [ 'false', 'f', 'not', 'no', 'n', '0', ];
3700	if fEnv is False:
3701	return False;
3702
3703	# Starting with 5.0 GA / RC2 the API can tell us whether VBox was built
3704	# with raw-mode support or not.
3705	self.importVBoxApi();
3706	if self.fpApiVer >= 5.0:
3707	try:
3708	fVBox = self.oVBox.systemProperties.rawModeSupported;
3709	except:
3710	if not fQuiet:
3711	reporter.logXcpt();
3712	fVBox = True;
3713	if fVBox is False:
3714	return False;
3715
3716	return True;
3717
3718	#
3719	# Testdriver execution methods.
3720	#
3721
3722	def handleTask(self, oTask, sMethod):
3723	"""
3724	Callback method for handling unknown tasks in the various run loops.
3725
3726	The testdriver should override this if it already tasks running when
3727	calling startVmAndConnectToTxsViaTcp, txsRunTest or similar methods.
3728	Call super to handle unknown tasks.
3729
3730	Returns True if handled, False if not.
3731	"""
3732	reporter.error('%s: unknown task %s' % (sMethod, oTask));
3733	return False;
3734
3735	def txsDoTask(self, oSession, oTxsSession, fnAsync, aArgs):
3736	"""
3737	Generic TXS task wrapper which waits both on the TXS and the session tasks.
3738
3739	Returns False on error, logged.
3740	Returns task result on success.
3741	"""
3742	# All async methods ends with the following two args.
3743	cMsTimeout = aArgs[-2];
3744	fIgnoreErrors = aArgs[-1];
3745
3746	fRemoveVm = self.addTask(oSession);
3747	fRemoveTxs = self.addTask(oTxsSession);
3748
3749	rc = fnAsync(*aArgs); # pylint: disable=star-args
3750	if rc is True:
3751	rc = False;
3752	oTask = self.waitForTasks(cMsTimeout + 1);
3753	if oTask is oTxsSession:
3754	if oTxsSession.isSuccess():
3755	rc = oTxsSession.getResult();
3756	elif fIgnoreErrors is True:
3757	reporter.log( 'txsDoTask: task failed (%s)' % (oTxsSession.getLastReply()[1],));
3758	else:
3759	reporter.error('txsDoTask: task failed (%s)' % (oTxsSession.getLastReply()[1],));
3760	else:
3761	oTxsSession.cancelTask();
3762	if oTask is None:
3763	if fIgnoreErrors is True:
3764	reporter.log( 'txsDoTask: The task timed out.');
3765	else:
3766	reporter.errorTimeout('txsDoTask: The task timed out.');
3767	elif oTask is oSession:
3768	reporter.error('txsDoTask: The VM terminated unexpectedly');
3769	else:
3770	if fIgnoreErrors is True:
3771	reporter.log( 'txsDoTask: An unknown task %s was returned' % (oTask,));
3772	else:
3773	reporter.error('txsDoTask: An unknown task %s was returned' % (oTask,));
3774	else:
3775	reporter.error('txsDoTask: fnAsync returned %s' % (rc,));
3776
3777	if fRemoveTxs:
3778	self.removeTask(oTxsSession);
3779	if fRemoveVm:
3780	self.removeTask(oSession);
3781	return rc;
3782
3783	# pylint: disable=missing-docstring
3784
3785	def txsDisconnect(self, oSession, oTxsSession, cMsTimeout = 30000, fIgnoreErrors = False):
3786	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDisconnect,
3787	(self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3788
3789	def txsVer(self, oSession, oTxsSession, cMsTimeout = 30000, fIgnoreErrors = False):
3790	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncVer,
3791	(self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3792
3793	def txsUuid(self, oSession, oTxsSession, cMsTimeout = 30000, fIgnoreErrors = False):
3794	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUuid,
3795	(self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3796
3797	def txsMkDir(self, oSession, oTxsSession, sRemoteDir, fMode = 0o700, cMsTimeout = 30000, fIgnoreErrors = False):
3798	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkDir,
3799	(sRemoteDir, fMode, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3800
3801	def txsMkDirPath(self, oSession, oTxsSession, sRemoteDir, fMode = 0o700, cMsTimeout = 30000, fIgnoreErrors = False):
3802	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkDirPath,
3803	(sRemoteDir, fMode, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3804
3805	def txsMkSymlink(self, oSession, oTxsSession, sLinkTarget, sLink, cMsTimeout = 30000, fIgnoreErrors = False):
3806	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkSymlink,
3807	(sLinkTarget, sLink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3808
3809	def txsRmDir(self, oSession, oTxsSession, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
3810	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmDir,
3811	(sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3812
3813	def txsRmFile(self, oSession, oTxsSession, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
3814	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmFile,
3815	(sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3816
3817	def txsRmSymlink(self, oSession, oTxsSession, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
3818	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmSymlink,
3819	(sRemoteSymlink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3820
3821	def txsRmTree(self, oSession, oTxsSession, sRemoteTree, cMsTimeout = 30000, fIgnoreErrors = False):
3822	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmTree,
3823	(sRemoteTree, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3824
3825	def txsIsDir(self, oSession, oTxsSession, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
3826	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsDir,
3827	(sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3828
3829	def txsIsFile(self, oSession, oTxsSession, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
3830	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsFile,
3831	(sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3832
3833	def txsIsSymlink(self, oSession, oTxsSession, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
3834	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsSymlink,
3835	(sRemoteSymlink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3836
3837	def txsCopyFile(self, oSession, oTxsSession, sSrcFile, sDstFile, fMode = 0, cMsTimeout = 30000, fIgnoreErrors = False):
3838	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncCopyFile, \
3839	(sSrcFile, sDstFile, fMode, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3840
3841	def txsUploadFile(self, oSession, oTxsSession, sLocalFile, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
3842	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUploadFile, \
3843	(sLocalFile, sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3844
3845	def txsUploadString(self, oSession, oTxsSession, sContent, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
3846	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUploadString, \
3847	(sContent, sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3848
3849	def txsDownloadFile(self, oSession, oTxsSession, sRemoteFile, sLocalFile, cMsTimeout = 30000, fIgnoreErrors = False):
3850	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDownloadFile, \
3851	(sRemoteFile, sLocalFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3852
3853	def txsDownloadFiles(self, oSession, oTxsSession, aasFiles, fAddToLog = True, fIgnoreErrors = False):
3854	"""
3855	Convenience function to get files from the guest, storing them in the
3856	scratch and adding them to the test result set (optional, but default).
3857
3858	The aasFiles parameter contains an array of with guest-path + host-path
3859	pairs, optionally a file 'kind', description and an alternative upload
3860	filename can also be specified.
3861
3862	Host paths are relative to the scratch directory or they must be given
3863	in absolute form. The guest path should be using guest path style.
3864
3865	Returns True on success.
3866	Returns False on failure (unless fIgnoreErrors is set), logged.
3867	"""
3868	for asEntry in aasFiles:
3869	# Unpack:
3870	sGstFile = asEntry[0];
3871	sHstFile = asEntry[1];
3872	sKind = asEntry[2] if len(asEntry) > 2 and asEntry[2] else 'misc/other';
3873	sDescription = asEntry[3] if len(asEntry) > 3 and asEntry[3] else '';
3874	sAltName = asEntry[4] if len(asEntry) > 4 and asEntry[4] else None;
3875	assert len(asEntry) <= 5 and sGstFile and sHstFile;
3876	if not os.path.isabs(sHstFile):
3877	sHstFile = os.path.join(self.sScratchPath, sHstFile);
3878
3879	reporter.log2('Downloading file "%s" to "%s" ...' % (sGstFile, sHstFile,));
3880
3881	try: os.unlink(sHstFile); ## @todo txsDownloadFile doesn't truncate the output file.
3882	except: pass;
3883
3884	fRc = self.txsDownloadFile(oSession, oTxsSession, sGstFile, sHstFile, 30 * 1000, fIgnoreErrors);
3885	if fRc:
3886	if fAddToLog:
3887	reporter.addLogFile(sHstFile, sKind, sDescription, sAltName);
3888	else:
3889	if fIgnoreErrors is not True:
3890	return reporter.error('error downloading file "%s" to "%s"' % (sGstFile, sHstFile));
3891	reporter.log('warning: file "%s" was not downloaded, ignoring.' % (sGstFile,));
3892	return True;
3893
3894	def txsDownloadString(self, oSession, oTxsSession, sRemoteFile, sEncoding = 'utf-8', fIgnoreEncodingErrors = True,
3895	cMsTimeout = 30000, fIgnoreErrors = False):
3896	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDownloadString,
3897	(sRemoteFile, sEncoding, fIgnoreEncodingErrors, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3898
3899	def txsPackFile(self, oSession, oTxsSession, sRemoteFile, sRemoteSource, cMsTimeout = 30000, fIgnoreErrors = False):
3900	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncPackFile, \
3901	(sRemoteFile, sRemoteSource, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3902
3903	def txsUnpackFile(self, oSession, oTxsSession, sRemoteFile, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
3904	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUnpackFile, \
3905	(sRemoteFile, sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3906
3907	def txsExpandString(self, oSession, oTxsSession, sString, cMsTimeout = 30000, fIgnoreErrors = False):
3908	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncExpandString, \
3909	(sString, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
3910
3911	# pylint: enable=missing-docstring
3912
3913	def txsCdWait(self,
3914	oSession, # type: vboxwrappers.SessionWrapper
3915	oTxsSession, # type: txsclient.Session
3916	cMsTimeout = 30000, # type: int
3917	sFile = None # type: String
3918	): # -> bool
3919	"""
3920	Mostly an internal helper for txsRebootAndReconnectViaTcp and
3921	startVmAndConnectToTxsViaTcp that waits for the CDROM drive to become
3922	ready. It does this by polling for a file it knows to exist on the CD.
3923
3924	Returns True on success.
3925
3926	Returns False on failure, logged.
3927	"""
3928
3929	if sFile is None:
3930	sFile = 'valkit.txt';
3931
3932	reporter.log('txsCdWait: Waiting for file "%s" to become available ...' % (sFile,));
3933
3934	fRemoveVm = self.addTask(oSession);
3935	fRemoveTxs = self.addTask(oTxsSession);
3936	cMsTimeout = self.adjustTimeoutMs(cMsTimeout);
3937	msStart = base.timestampMilli();
3938	cMsTimeout2 = cMsTimeout;
3939	fRc = oTxsSession.asyncIsFile('${CDROM}/%s' % (sFile,), cMsTimeout2);
3940	if fRc is True:
3941	while True:
3942	# wait for it to complete.
3943	oTask = self.waitForTasks(cMsTimeout2 + 1);
3944	if oTask is not oTxsSession:
3945	oTxsSession.cancelTask();
3946	if oTask is None:
3947	reporter.errorTimeout('txsCdWait: The task timed out (after %s ms).'
3948	% (base.timestampMilli() - msStart,));
3949	elif oTask is oSession:
3950	reporter.error('txsCdWait: The VM terminated unexpectedly');
3951	else:
3952	reporter.error('txsCdWait: An unknown task %s was returned' % (oTask,));
3953	fRc = False;
3954	break;
3955	if oTxsSession.isSuccess():
3956	break;
3957
3958	# Check for timeout.
3959	cMsElapsed = base.timestampMilli() - msStart;
3960	if cMsElapsed >= cMsTimeout:
3961	reporter.error('txsCdWait: timed out');
3962	fRc = False;
3963	break;
3964	# delay.
3965	self.sleep(1);
3966
3967	# resubmit the task.
3968	cMsTimeout2 = msStart + cMsTimeout - base.timestampMilli();
3969	cMsTimeout2 = max(cMsTimeout2, 500);
3970	fRc = oTxsSession.asyncIsFile('${CDROM}/%s' % (sFile,), cMsTimeout2);
3971	if fRc is not True:
3972	reporter.error('txsCdWait: asyncIsFile failed');
3973	break;
3974	else:
3975	reporter.error('txsCdWait: asyncIsFile failed');
3976
3977	if not fRc:
3978	# Do some diagnosis to find out why this failed.
3979	## @todo Identify guest OS type and only run one of the following commands.
3980	fIsNotWindows = True;
3981	reporter.log('txsCdWait: Listing root contents of ${CDROM}:');
3982	if fIsNotWindows:
3983	reporter.log('txsCdWait: Tiggering udevadm ...');
3984	oTxsSession.syncExec("/sbin/udevadm", ("/sbin/udevadm", "trigger", "--verbose"), fIgnoreErrors = True);
3985	time.sleep(15);
3986	oTxsSession.syncExec("/bin/ls", ("/bin/ls", "-al", "${CDROM}"), fIgnoreErrors = True);
3987	reporter.log('txsCdWait: Listing media directory:');
3988	oTxsSession.syncExec('/bin/ls', ('/bin/ls', '-l', '-a', '-R', '/media'), fIgnoreErrors = True);
3989	reporter.log('txsCdWait: Listing mount points / drives:');
3990	oTxsSession.syncExec('/bin/mount', ('/bin/mount',), fIgnoreErrors = True);
3991	oTxsSession.syncExec('/bin/cat', ('/bin/cat', '/etc/fstab'), fIgnoreErrors = True);
3992	oTxsSession.syncExec('/bin/dmesg', ('/bin/dmesg',), fIgnoreErrors = True);
3993	oTxsSession.syncExec('/usr/bin/lshw', ('/usr/bin/lshw', '-c', 'disk'), fIgnoreErrors = True);
3994	oTxsSession.syncExec('/bin/journalctl',
3995	('/bin/journalctl', '-x', '-b'), fIgnoreErrors = True);
3996	oTxsSession.syncExec('/bin/journalctl',
3997	('/bin/journalctl', '-x', '-b', '/usr/lib/udisks2/udisksd'), fIgnoreErrors = True);
3998	oTxsSession.syncExec('/usr/bin/udisksctl',
3999	('/usr/bin/udisksctl', 'info', '-b', '/dev/sr0'), fIgnoreErrors = True);
4000	oTxsSession.syncExec('/bin/systemctl',
4001	('/bin/systemctl', 'status', 'udisks2'), fIgnoreErrors = True);
4002	oTxsSession.syncExec('/bin/ps',
4003	('/bin/ps', '-a', '-u', '-x'), fIgnoreErrors = True);
4004	reporter.log('txsCdWait: Mounting manually ...');
4005	for _ in range(3):
4006	oTxsSession.syncExec('/bin/mount', ('/bin/mount', '/dev/sr0', '${CDROM}'), fIgnoreErrors = True);
4007	time.sleep(5);
4008	reporter.log('txsCdWait: Re-Listing media directory:');
4009	oTxsSession.syncExec('/bin/ls', ('/bin/ls', '-l', '-a', '-R', '/media'), fIgnoreErrors = True);
4010	else:
4011	# ASSUMES that we always install Windows on drive C right now.
4012	sWinDir = "C:\\Windows\\System32\\";
4013	# Should work since WinXP Pro.
4014	oTxsSession.syncExec(sWinDir + "wbem\\WMIC.exe",
4015	("WMIC.exe", "logicaldisk", "get",
4016	"deviceid, volumename, description"),
4017	fIgnoreErrors = True);
4018	oTxsSession.syncExec(sWinDir + " cmd.exe",
4019	('cmd.exe', '/C', 'dir', '${CDROM}'),
4020	fIgnoreErrors = True);
4021
4022	if fRemoveTxs:
4023	self.removeTask(oTxsSession);
4024	if fRemoveVm:
4025	self.removeTask(oSession);
4026	return fRc;
4027
4028	def txsDoConnectViaTcp(self, oSession, cMsTimeout, fNatForwardingForTxs = False):
4029	"""
4030	Mostly an internal worker for connecting to TXS via TCP used by the
4031	*ViaTcp methods.
4032
4033	Returns a tuplet with True/False and TxsSession/None depending on the
4034	result. Errors are logged.
4035	"""
4036
4037	reporter.log2('txsDoConnectViaTcp: oSession=%s, cMsTimeout=%s, fNatForwardingForTxs=%s'
4038	% (oSession, cMsTimeout, fNatForwardingForTxs));
4039
4040	cMsTimeout = self.adjustTimeoutMs(cMsTimeout);
4041	oTxsConnect = oSession.txsConnectViaTcp(cMsTimeout, fNatForwardingForTxs = fNatForwardingForTxs);
4042	if oTxsConnect is not None:
4043	self.addTask(oTxsConnect);
4044	fRemoveVm = self.addTask(oSession);
4045	oTask = self.waitForTasks(cMsTimeout + 1);
4046	reporter.log2('txsDoConnectViaTcp: waitForTasks returned %s' % (oTask,));
4047	self.removeTask(oTxsConnect);
4048	if oTask is oTxsConnect:
4049	oTxsSession = oTxsConnect.getResult();
4050	if oTxsSession is not None:
4051	reporter.log('txsDoConnectViaTcp: Connected to TXS on %s.' % (oTxsSession.oTransport.sHostname,));
4052	return (True, oTxsSession);
4053
4054	reporter.error('txsDoConnectViaTcp: failed to connect to TXS.');
4055	else:
4056	oTxsConnect.cancelTask();
4057	if oTask is None:
4058	reporter.errorTimeout('txsDoConnectViaTcp: connect stage 1 timed out');
4059	elif oTask is oSession:
4060	oSession.reportPrematureTermination('txsDoConnectViaTcp: ');
4061	else:
4062	reporter.error('txsDoConnectViaTcp: unknown/wrong task %s' % (oTask,));
4063	if fRemoveVm:
4064	self.removeTask(oSession);
4065	else:
4066	reporter.error('txsDoConnectViaTcp: txsConnectViaTcp failed');
4067	return (False, None);
4068
4069	def startVmAndConnectToTxsViaTcp(self, sVmName, fCdWait = False, cMsTimeout = 15*60000, \
4070	cMsCdWait = 30000, sFileCdWait = None, \
4071	fNatForwardingForTxs = False):
4072	"""
4073	Starts the specified VM and tries to connect to its TXS via TCP.
4074	The VM will be powered off if TXS doesn't respond before the specified
4075	time has elapsed.
4076
4077	Returns a the VM and TXS sessions (a two tuple) on success. The VM
4078	session is in the task list, the TXS session is not.
4079	Returns (None, None) on failure, fully logged.
4080	"""
4081
4082	# Zap the guest IP to make sure we're not getting a stale entry
4083	# (unless we're restoring the VM of course).
4084	oTestVM = self.oTestVmSet.findTestVmByName(sVmName) if self.oTestVmSet is not None else None;
4085	if oTestVM is None \
4086	or oTestVM.fSnapshotRestoreCurrent is False:
4087	try:
4088	oSession1 = self.openSession(self.getVmByName(sVmName));
4089	oSession1.delGuestPropertyValue('/VirtualBox/GuestInfo/Net/0/V4/IP');
4090	oSession1.saveSettings(True);
4091	del oSession1;
4092	except:
4093	reporter.logXcpt();
4094
4095	# Start the VM.
4096	reporter.log('startVmAndConnectToTxsViaTcp: Starting(/preparing) "%s" (timeout %s s)...' % (sVmName, cMsTimeout / 1000));
4097	reporter.flushall();
4098	oSession = self.startVmByName(sVmName);
4099	if oSession is not None:
4100	# Connect to TXS.
4101	reporter.log2('startVmAndConnectToTxsViaTcp: Started(/prepared) "%s", connecting to TXS ...' % (sVmName,));
4102	(fRc, oTxsSession) = self.txsDoConnectViaTcp(oSession, cMsTimeout, fNatForwardingForTxs);
4103	if fRc is True:
4104	if fCdWait:
4105	# Wait for CD?
4106	reporter.log2('startVmAndConnectToTxsViaTcp: Waiting for file "%s" to become available ...' % (sFileCdWait,));
4107	fRc = self.txsCdWait(oSession, oTxsSession, cMsCdWait, sFileCdWait);
4108	if fRc is not True:
4109	reporter.error('startVmAndConnectToTxsViaTcp: txsCdWait failed');
4110
4111	sVer = self.txsVer(oSession, oTxsSession, cMsTimeout, fIgnoreErrors = True);
4112	if sVer is not False:
4113	reporter.log('startVmAndConnectToTxsViaTcp: TestExecService version %s' % (sVer,));
4114	else:
4115	reporter.log('startVmAndConnectToTxsViaTcp: Unable to retrieve TestExecService version');
4116
4117	if fRc is True:
4118	# Success!
4119	return (oSession, oTxsSession);
4120	else:
4121	reporter.error('startVmAndConnectToTxsViaTcp: txsDoConnectViaTcp failed');
4122	# If something went wrong while waiting for TXS to be started - take VM screenshot before terminate it
4123	self.terminateVmBySession(oSession);
4124	return (None, None);
4125
4126	def txsRebootAndReconnectViaTcp(self, oSession, oTxsSession, fCdWait = False, cMsTimeout = 15*60000, \
4127	cMsCdWait = 30000, sFileCdWait = None, fNatForwardingForTxs = False):
4128	"""
4129	Executes the TXS reboot command
4130
4131	Returns A tuple of True and the new TXS session on success.
4132
4133	Returns A tuple of False and either the old TXS session or None on failure.
4134	"""
4135	reporter.log2('txsRebootAndReconnect: cMsTimeout=%u' % (cMsTimeout,));
4136
4137	#
4138	# This stuff is a bit complicated because of rebooting being kind of
4139	# disruptive to the TXS and such... The protocol is that TXS will:
4140	# - ACK the reboot command.
4141	# - Shutdown the transport layer, implicitly disconnecting us.
4142	# - Execute the reboot operation.
4143	# - On failure, it will be re-init the transport layer and be
4144	# available pretty much immediately. UUID unchanged.
4145	# - On success, it will be respawed after the reboot (hopefully),
4146	# with a different UUID.
4147	#
4148	fRc = False;
4149	iStart = base.timestampMilli();
4150
4151	# Get UUID.
4152	cMsTimeout2 = min(60000, cMsTimeout);
4153	sUuidBefore = self.txsUuid(oSession, oTxsSession, self.adjustTimeoutMs(cMsTimeout2, 60000));
4154	if sUuidBefore is not False:
4155	# Reboot.
4156	cMsElapsed = base.timestampMilli() - iStart;
4157	cMsTimeout2 = cMsTimeout - cMsElapsed;
4158	fRc = self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncReboot,
4159	(self.adjustTimeoutMs(cMsTimeout2, 60000), False));
4160	if fRc is True:
4161	# Reconnect.
4162	if fNatForwardingForTxs is True:
4163	self.sleep(22); # NAT fudge - Two fixes are wanted: 1. TXS connect retries. 2. Main API reboot/reset hint.
4164	cMsElapsed = base.timestampMilli() - iStart;
4165	(fRc, oTxsSession) = self.txsDoConnectViaTcp(oSession, cMsTimeout - cMsElapsed, fNatForwardingForTxs);
4166	if fRc is True:
4167	# Check the UUID.
4168	cMsElapsed = base.timestampMilli() - iStart;
4169	cMsTimeout2 = min(60000, cMsTimeout - cMsElapsed);
4170	sUuidAfter = self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUuid,
4171	(self.adjustTimeoutMs(cMsTimeout2, 60000), False));
4172	if sUuidBefore is not False:
4173	if sUuidAfter != sUuidBefore:
4174	reporter.log('The guest rebooted (UUID %s -> %s)' % (sUuidBefore, sUuidAfter))
4175
4176	# Do CD wait if specified.
4177	if fCdWait:
4178	fRc = self.txsCdWait(oSession, oTxsSession, cMsCdWait, sFileCdWait);
4179	if fRc is not True:
4180	reporter.error('txsRebootAndReconnectViaTcp: txsCdWait failed');
4181
4182	sVer = self.txsVer(oSession, oTxsSession, cMsTimeout, fIgnoreErrors = True);
4183	if sVer is not False:
4184	reporter.log('txsRebootAndReconnectViaTcp: TestExecService version %s' % (sVer,));
4185	else:
4186	reporter.log('txsRebootAndReconnectViaTcp: Unable to retrieve TestExecService version');
4187	else:
4188	reporter.error('txsRebootAndReconnectViaTcp: failed to get UUID (after)');
4189	else:
4190	reporter.error('txsRebootAndReconnectViaTcp: did not reboot (UUID %s)' % (sUuidBefore,));
4191	else:
4192	reporter.error('txsRebootAndReconnectViaTcp: txsDoConnectViaTcp failed');
4193	else:
4194	reporter.error('txsRebootAndReconnectViaTcp: reboot failed');
4195	else:
4196	reporter.error('txsRebootAndReconnectViaTcp: failed to get UUID (before)');
4197	return (fRc, oTxsSession);
4198
4199	# pylint: disable=too-many-locals,too-many-arguments
4200
4201	def txsRunTest(self, oTxsSession, sTestName, cMsTimeout, sExecName, asArgs = (), asAddEnv = (), sAsUser = "",
4202	fCheckSessionStatus = False):
4203	"""
4204	Executes the specified test task, waiting till it completes or times out.
4205
4206	The VM session (if any) must be in the task list.
4207
4208	Returns True if we executed the task and nothing abnormal happend.
4209	Query the process status from the TXS session.
4210
4211	Returns False if some unexpected task was signalled or we failed to
4212	submit the job.
4213
4214	If fCheckSessionStatus is set to True, the overall session status will be
4215	taken into account and logged as an error on failure.
4216	"""
4217	reporter.testStart(sTestName);
4218	reporter.log2('txsRunTest: cMsTimeout=%u sExecName=%s asArgs=%s' % (cMsTimeout, sExecName, asArgs));
4219
4220	# Submit the job.
4221	fRc = False;
4222	if oTxsSession.asyncExec(sExecName, asArgs, asAddEnv, sAsUser, cMsTimeout = self.adjustTimeoutMs(cMsTimeout)):
4223	self.addTask(oTxsSession);
4224
4225	# Wait for the job to complete.
4226	while True:
4227	oTask = self.waitForTasks(cMsTimeout + 1);
4228	if oTask is None:
4229	if fCheckSessionStatus:
4230	reporter.error('txsRunTest: waitForTasks for test "%s" timed out' % (sTestName,));
4231	else:
4232	reporter.log('txsRunTest: waitForTasks for test "%s" timed out' % (sTestName,));
4233	break;
4234	if oTask is oTxsSession:
4235	if fCheckSessionStatus \
4236	and not oTxsSession.isSuccess():
4237	reporter.error('txsRunTest: Test "%s" failed' % (sTestName,));
4238	else:
4239	fRc = True;
4240	reporter.log('txsRunTest: isSuccess=%s getResult=%s' \
4241	% (oTxsSession.isSuccess(), oTxsSession.getResult()));
4242	break;
4243	if not self.handleTask(oTask, 'txsRunTest'):
4244	break;
4245
4246	self.removeTask(oTxsSession);
4247	if not oTxsSession.pollTask():
4248	oTxsSession.cancelTask();
4249	else:
4250	reporter.error('txsRunTest: asyncExec failed');
4251
4252	reporter.testDone();
4253	return fRc;
4254
4255	def txsRunTestRedirectStd(self, oTxsSession, sTestName, cMsTimeout, sExecName, asArgs = (), asAddEnv = (), sAsUser = "",
4256	oStdIn = '/dev/null', oStdOut = '/dev/null', oStdErr = '/dev/null', oTestPipe = '/dev/null'):
4257	"""
4258	Executes the specified test task, waiting till it completes or times out,
4259	redirecting stdin, stdout and stderr to the given objects.
4260
4261	The VM session (if any) must be in the task list.
4262
4263	Returns True if we executed the task and nothing abnormal happend.
4264	Query the process status from the TXS session.
4265
4266	Returns False if some unexpected task was signalled or we failed to
4267	submit the job.
4268	"""
4269	reporter.testStart(sTestName);
4270	reporter.log2('txsRunTestRedirectStd: cMsTimeout=%u sExecName=%s asArgs=%s' % (cMsTimeout, sExecName, asArgs));
4271
4272	# Submit the job.
4273	fRc = False;
4274	if oTxsSession.asyncExecEx(sExecName, asArgs, asAddEnv, oStdIn, oStdOut, oStdErr,
4275	oTestPipe, sAsUser, cMsTimeout = self.adjustTimeoutMs(cMsTimeout)):
4276	self.addTask(oTxsSession);
4277
4278	# Wait for the job to complete.
4279	while True:
4280	oTask = self.waitForTasks(cMsTimeout + 1);
4281	if oTask is None:
4282	reporter.log('txsRunTestRedirectStd: waitForTasks timed out');
4283	break;
4284	if oTask is oTxsSession:
4285	fRc = True;
4286	reporter.log('txsRunTestRedirectStd: isSuccess=%s getResult=%s'
4287	% (oTxsSession.isSuccess(), oTxsSession.getResult()));
4288	break;
4289	if not self.handleTask(oTask, 'txsRunTestRedirectStd'):
4290	break;
4291
4292	self.removeTask(oTxsSession);
4293	if not oTxsSession.pollTask():
4294	oTxsSession.cancelTask();
4295	else:
4296	reporter.error('txsRunTestRedirectStd: asyncExec failed');
4297
4298	reporter.testDone();
4299	return fRc;
4300
4301	def txsRunTest2(self, oTxsSession1, oTxsSession2, sTestName, cMsTimeout,
4302	sExecName1, asArgs1,
4303	sExecName2, asArgs2,
4304	asAddEnv1 = (), sAsUser1 = '', fWithTestPipe1 = True,
4305	asAddEnv2 = (), sAsUser2 = '', fWithTestPipe2 = True):
4306	"""
4307	Executes the specified test tasks, waiting till they complete or
4308	times out. The 1st task is started after the 2nd one.
4309
4310	The VM session (if any) must be in the task list.
4311
4312	Returns True if we executed the task and nothing abnormal happend.
4313	Query the process status from the TXS sessions.
4314
4315	Returns False if some unexpected task was signalled or we failed to
4316	submit the job.
4317	"""
4318	reporter.testStart(sTestName);
4319
4320	# Submit the jobs.
4321	fRc = False;
4322	if oTxsSession1.asyncExec(sExecName1, asArgs1, asAddEnv1, sAsUser1, fWithTestPipe1, '1-',
4323	self.adjustTimeoutMs(cMsTimeout)):
4324	self.addTask(oTxsSession1);
4325
4326	self.sleep(2); # fudge! grr
4327
4328	if oTxsSession2.asyncExec(sExecName2, asArgs2, asAddEnv2, sAsUser2, fWithTestPipe2, '2-',
4329	self.adjustTimeoutMs(cMsTimeout)):
4330	self.addTask(oTxsSession2);
4331
4332	# Wait for the jobs to complete.
4333	cPendingJobs = 2;
4334	while True:
4335	oTask = self.waitForTasks(cMsTimeout + 1);
4336	if oTask is None:
4337	reporter.log('txsRunTest2: waitForTasks timed out');
4338	break;
4339
4340	if oTask is oTxsSession1 or oTask is oTxsSession2:
4341	if oTask is oTxsSession1: iTask = 1;
4342	else: iTask = 2;
4343	reporter.log('txsRunTest2: #%u - isSuccess=%s getResult=%s' \
4344	% (iTask, oTask.isSuccess(), oTask.getResult()));
4345	self.removeTask(oTask);
4346	cPendingJobs -= 1;
4347	if cPendingJobs <= 0:
4348	fRc = True;
4349	break;
4350
4351	elif not self.handleTask(oTask, 'txsRunTest'):
4352	break;
4353
4354	self.removeTask(oTxsSession2);
4355	if not oTxsSession2.pollTask():
4356	oTxsSession2.cancelTask();
4357	else:
4358	reporter.error('txsRunTest2: asyncExec #2 failed');
4359
4360	self.removeTask(oTxsSession1);
4361	if not oTxsSession1.pollTask():
4362	oTxsSession1.cancelTask();
4363	else:
4364	reporter.error('txsRunTest2: asyncExec #1 failed');
4365
4366	reporter.testDone();
4367	return fRc;
4368
4369	# pylint: enable=too-many-locals,too-many-arguments
4370
4371
4372	#
4373	# Working with test results via serial port.
4374	#
4375
4376	class TxsMonitorComFile(base.TdTaskBase):
4377	"""
4378	Class that monitors a COM output file.
4379	"""
4380
4381	def __init__(self, sComRawFile, asStopWords = None):
4382	base.TdTaskBase.__init__(self, utils.getCallerName());
4383	self.sComRawFile = sComRawFile;
4384	self.oStopRegExp = re.compile('\\b(' + '\|'.join(asStopWords if asStopWords else ('PASSED', 'FAILED',)) + ')\\b');
4385	self.sResult = None; ##< The result.
4386	self.cchDisplayed = 0; ##< Offset into the file string of what we've already fed to the logger.
4387
4388	def toString(self):
4389	return '<%s sComRawFile=%s oStopRegExp=%s sResult=%s cchDisplayed=%s>' \
4390	% (base.TdTaskBase.toString(self), self.sComRawFile, self.oStopRegExp, self.sResult, self.cchDisplayed,);
4391
4392	def pollTask(self, fLocked = False):
4393	"""
4394	Overrides TdTaskBase.pollTask() for the purpose of polling the file.
4395	"""
4396	if not fLocked:
4397	self.lockTask();
4398
4399	sFile = utils.noxcptReadFile(self.sComRawFile, '', 'rU');
4400	if len(sFile) > self.cchDisplayed:
4401	sNew = sFile[self.cchDisplayed:];
4402	oMatch = self.oStopRegExp.search(sNew);
4403	if oMatch:
4404	# Done! Get result, flush all the output and signal the task.
4405	self.sResult = oMatch.group(1);
4406	for sLine in sNew.split('\n'):
4407	reporter.log('COM OUTPUT: %s' % (sLine,));
4408	self.cchDisplayed = len(sFile);
4409	self.signalTaskLocked();
4410	else:
4411	# Output whole lines only.
4412	offNewline = sFile.find('\n', self.cchDisplayed);
4413	while offNewline >= 0:
4414	reporter.log('COM OUTPUT: %s' % (sFile[self.cchDisplayed:offNewline]))
4415	self.cchDisplayed = offNewline + 1;
4416	offNewline = sFile.find('\n', self.cchDisplayed);
4417
4418	fRet = self.fSignalled;
4419	if not fLocked:
4420	self.unlockTask();
4421	return fRet;
4422
4423	# Our stuff.
4424	def getResult(self):
4425	"""
4426	Returns the connected TXS session object on success.
4427	Returns None on failure or if the task has not yet completed.
4428	"""
4429	self.oCv.acquire();
4430	sResult = self.sResult;
4431	self.oCv.release();
4432	return sResult;
4433
4434	def cancelTask(self):
4435	""" Cancels the task. """
4436	self.signalTask();
4437	return True;
4438
4439
4440	def monitorComRawFile(self, oSession, sComRawFile, cMsTimeout = 15*60000, asStopWords = None):
4441	"""
4442	Monitors the COM output file for stop words (PASSED and FAILED by default).
4443
4444	Returns the stop word.
4445	Returns None on VM error and timeout.
4446	"""
4447
4448	reporter.log2('monitorComRawFile: oSession=%s, cMsTimeout=%s, sComRawFile=%s' % (oSession, cMsTimeout, sComRawFile));
4449
4450	oMonitorTask = self.TxsMonitorComFile(sComRawFile, asStopWords);
4451	self.addTask(oMonitorTask);
4452
4453	cMsTimeout = self.adjustTimeoutMs(cMsTimeout);
4454	oTask = self.waitForTasks(cMsTimeout + 1);
4455	reporter.log2('monitorComRawFile: waitForTasks returned %s' % (oTask,));
4456
4457	if oTask is not oMonitorTask:
4458	oMonitorTask.cancelTask();
4459	self.removeTask(oMonitorTask);
4460
4461	oMonitorTask.pollTask();
4462	return oMonitorTask.getResult();
4463
4464
4465	def runVmAndMonitorComRawFile(self, sVmName, sComRawFile, cMsTimeout = 15*60000, asStopWords = None):
4466	"""
4467	Runs the specified VM and monitors the given COM output file for stop
4468	words (PASSED and FAILED by default).
4469
4470	The caller is assumed to have configured the VM to use the given
4471	file. The method will take no action to verify this.
4472
4473	Returns the stop word.
4474	Returns None on VM error and timeout.
4475	"""
4476
4477	# Start the VM.
4478	reporter.log('runVmAndMonitorComRawFile: Starting(/preparing) "%s" (timeout %s s)...' % (sVmName, cMsTimeout / 1000));
4479	reporter.flushall();
4480	oSession = self.startVmByName(sVmName);
4481	if oSession is not None:
4482	# Let it run and then terminate it.
4483	sRet = self.monitorComRawFile(oSession, sComRawFile, cMsTimeout, asStopWords);
4484	self.terminateVmBySession(oSession);
4485	else:
4486	sRet = None;
4487	return sRet;
4488
4489	#
4490	# Other stuff
4491	#
4492
4493	def waitForGAs(self,
4494	oSession, # type: vboxwrappers.SessionWrapper
4495	cMsTimeout = 120000, aenmWaitForRunLevels = None, aenmWaitForActive = None, aenmWaitForInactive = None):
4496	"""
4497	Waits for the guest additions to enter a certain state.
4498
4499	aenmWaitForRunLevels - List of run level values to wait for (success if one matches).
4500	aenmWaitForActive - List facilities (type values) that must be active.
4501	aenmWaitForInactive - List facilities (type values) that must be inactive.
4502
4503	Defaults to wait for AdditionsRunLevelType_Userland if nothing else is given.
4504
4505	Returns True on success, False w/ error logging on timeout or failure.
4506	"""
4507	reporter.log2('waitForGAs: oSession=%s, cMsTimeout=%s' % (oSession, cMsTimeout,));
4508
4509	#
4510	# Get IGuest:
4511	#
4512	try:
4513	oIGuest = oSession.o.console.guest;
4514	except:
4515	return reporter.errorXcpt();
4516
4517	#
4518	# Create a wait task:
4519	#
4520	from testdriver.vboxwrappers import AdditionsStatusTask;
4521	try:
4522	oGaStatusTask = AdditionsStatusTask(oSession = oSession,
4523	oIGuest = oIGuest,
4524	cMsTimeout = cMsTimeout,
4525	aenmWaitForRunLevels = aenmWaitForRunLevels,
4526	aenmWaitForActive = aenmWaitForActive,
4527	aenmWaitForInactive = aenmWaitForInactive);
4528	except:
4529	return reporter.errorXcpt();
4530
4531	#
4532	# Add the task and make sure the VM session is also present.
4533	#
4534	self.addTask(oGaStatusTask);
4535	fRemoveSession = self.addTask(oSession);
4536	oTask = self.waitForTasks(cMsTimeout + 1);
4537	reporter.log2('waitForGAs: returned %s (oGaStatusTask=%s, oSession=%s)' % (oTask, oGaStatusTask, oSession,));
4538	self.removeTask(oGaStatusTask);
4539	if fRemoveSession:
4540	self.removeTask(oSession);
4541
4542	#
4543	# Digest the result.
4544	#
4545	if oTask is oGaStatusTask:
4546	fSucceeded = oGaStatusTask.getResult();
4547	if fSucceeded is True:
4548	reporter.log('waitForGAs: Succeeded.');
4549	else:
4550	reporter.error('waitForGAs: Failed.');
4551	else:
4552	oGaStatusTask.cancelTask();
4553	if oTask is None:
4554	reporter.error('waitForGAs: Timed out.');
4555	elif oTask is oSession:
4556	oSession.reportPrematureTermination('waitForGAs: ');
4557	else:
4558	reporter.error('waitForGAs: unknown/wrong task %s' % (oTask,));
4559	fSucceeded = False;
4560	return fSucceeded;
4561
4562	@staticmethod
4563	def controllerTypeToName(eControllerType):
4564	"""
4565	Translate a controller type to a standard controller name.
4566	"""
4567	if eControllerType in (vboxcon.StorageControllerType_PIIX3, vboxcon.StorageControllerType_PIIX4,):
4568	sName = "IDE Controller";
4569	elif eControllerType == vboxcon.StorageControllerType_IntelAhci:
4570	sName = "SATA Controller";
4571	elif eControllerType == vboxcon.StorageControllerType_LsiLogicSas:
4572	sName = "SAS Controller";
4573	elif eControllerType in (vboxcon.StorageControllerType_LsiLogic, vboxcon.StorageControllerType_BusLogic,):
4574	sName = "SCSI Controller";
4575	elif eControllerType == vboxcon.StorageControllerType_NVMe:
4576	sName = "NVMe Controller";
4577	elif eControllerType == vboxcon.StorageControllerType_VirtioSCSI:
4578	sName = "VirtIO SCSI Controller";
4579	else:
4580	sName = "Storage Controller";
4581	return sName;

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

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

Download in other formats: