vbox.py@ 57984

Last change on this file since 57984 was 56805, checked in by vboxsync, 9 years ago
vbox.py: pylint fix
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 141.0 KB

Line
1	# -- coding: utf-8 --
2	# $Id: vbox.py 56805 2015-07-03 23:31:13Z vboxsync $
3	# pylint: disable=C0302
4
5	"""
6	VirtualBox Specific base testdriver.
7	"""
8
9	__copyright__ = \
10	"""
11	Copyright (C) 2010-2015 Oracle Corporation
12
13	This file is part of VirtualBox Open Source Edition (OSE), as
14	available from http://www.virtualbox.org. This file is free software;
15	you can redistribute it and/or modify it under the terms of the GNU
16	General Public License (GPL) as published by the Free Software
17	Foundation, in version 2 as it comes in the "COPYING" file of the
18	VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19	hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20
21	The contents of this file may alternatively be used under the terms
22	of the Common Development and Distribution License Version 1.0
23	(CDDL) only, as it comes in the "COPYING.CDDL" file of the
24	VirtualBox OSE distribution, in which case the provisions of the
25	CDDL are applicable instead of those of the GPL.
26
27	You may elect to license modified versions of this file under the
28	terms and conditions of either the GPL or the CDDL or both.
29	"""
30	__version__ = "$Revision: 56805 $"
31
32
33	# Standard Python imports.
34	import os
35	import platform
36	import sys
37	import threading
38	import time
39	import traceback
40	import datetime
41
42	# Figure out where the validation kit lives and make sure it's in the path.
43	try: __file__
44	except: __file__ = sys.argv[0];
45	g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)));
46	if g_ksValidationKitDir not in sys.path:
47	sys.path.append(g_ksValidationKitDir);
48
49	# Validation Kit imports.
50	from common import utils;
51	from testdriver import base;
52	from testdriver import reporter;
53	from testdriver import vboxcon;
54	from testdriver import vboxtestvms;
55
56
57	#
58	# Exception and Error Unification Hacks.
59	# Note! This is pretty gross stuff. Be warned!
60	# TODO: Find better ways of doing these things, preferrably in vboxapi.
61	#
62
63	ComException = None; # pylint: disable=C0103
64	__fnComExceptionGetAttr__ = None; # pylint: disable=C0103
65
66	def __MyDefaultGetAttr(oSelf, sName):
67	""" __getattribute__/__getattr__ default fake."""
68	try:
69	oAttr = oSelf.__dict__[sName];
70	except:
71	oAttr = dir(oSelf)[sName];
72	return oAttr;
73
74	def __MyComExceptionGetAttr(oSelf, sName):
75	""" ComException.__getattr__ wrapper - both XPCOM and COM. """
76	try:
77	oAttr = __fnComExceptionGetAttr__(oSelf, sName);
78	except AttributeError:
79	if platform.system() == 'Windows':
80	if sName == 'errno':
81	oAttr = __fnComExceptionGetAttr__(oSelf, 'hresult');
82	elif sName == 'msg':
83	oAttr = __fnComExceptionGetAttr__(oSelf, 'strerror');
84	else:
85	raise;
86	else:
87	if sName == 'hresult':
88	oAttr = __fnComExceptionGetAttr__(oSelf, 'errno');
89	elif sName == 'strerror':
90	oAttr = __fnComExceptionGetAttr__(oSelf, 'msg');
91	elif sName == 'excepinfo':
92	oAttr = None;
93	elif sName == 'argerror':
94	oAttr = None;
95	else:
96	raise;
97	#print '__MyComExceptionGetAttr(,%s) -> "%s"' % (sName, oAttr);
98	return oAttr;
99
100	def __deployExceptionHacks__(oNativeComExceptionClass):
101	"""
102	Deploys the exception and error hacks that helps unifying COM and XPCOM
103	exceptions and errors.
104	"""
105	global ComException # pylint: disable=C0103
106	global __fnComExceptionGetAttr__ # pylint: disable=C0103
107
108	# Hook up our attribute getter for the exception class (ASSUMES new-style).
109	if __fnComExceptionGetAttr__ is None:
110	try:
111	__fnComExceptionGetAttr__ = getattr(oNativeComExceptionClass, '__getattr__');
112	except:
113	try:
114	__fnComExceptionGetAttr__ = getattr(oNativeComExceptionClass, '__getattribute__');
115	except:
116	__fnComExceptionGetAttr__ = __MyDefaultGetAttr;
117	setattr(oNativeComExceptionClass, '__getattr__', __MyComExceptionGetAttr)
118
119	# Make the modified classes accessible (are there better ways to do this?)
120	ComException = oNativeComExceptionClass
121	return None;
122
123
124
125	#
126	# Utility functions.
127	#
128
129	def isIpAddrValid(sIpAddr):
130	"""
131	Checks if a IPv4 address looks valid. This will return false for
132	localhost and similar.
133	Returns True / False.
134	"""
135	if sIpAddr is None: return False;
136	if len(sIpAddr.split('.')) != 4: return False;
137	if sIpAddr.endswith('.0'): return False;
138	if sIpAddr.endswith('.255'): return False;
139	if sIpAddr.startswith('127.'): return False;
140	if sIpAddr.startswith('169.254.'): return False;
141	if sIpAddr.startswith('192.0.2.'): return False;
142	if sIpAddr.startswith('224.0.0.'): return False;
143	return True;
144
145	def stringifyErrorInfo(oErrInfo):
146	"""
147	Stringifies the error information in a IVirtualBoxErrorInfo object.
148
149	Returns string with error info.
150	"""
151	try:
152	rc = oErrInfo.resultCode;
153	sText = oErrInfo.text;
154	sIid = oErrInfo.interfaceID;
155	sComponent = oErrInfo.component;
156	except:
157	sRet = 'bad error object (%s)?' % (oErrInfo,);
158	traceback.print_exc();
159	else:
160	sRet = 'rc=%s text="%s" IID=%s component=%s' % (ComError.toString(rc), sText, sIid, sComponent);
161	return sRet;
162
163	def reportError(oErr, sText):
164	"""
165	Report a VirtualBox error on oErr. oErr can be IVirtualBoxErrorInfo
166	or IProgress. Anything else is ignored.
167
168	Returns the same a reporter.error().
169	"""
170	try:
171	oErrObj = oErr.errorInfo; # IProgress.
172	except:
173	oErrObj = oErr;
174	reporter.error(sText);
175	return reporter.error(stringifyErrorInfo(oErrObj));
176
177
178	#
179	# Classes
180	#
181
182	class ComError(object):
183	"""
184	Unified COM and XPCOM status code repository.
185	This works more like a module than a class since it's replacing a module.
186	"""
187
188	# The VBOX_E_XXX bits:
189	__VBOX_E_BASE = -2135228416;
190	VBOX_E_OBJECT_NOT_FOUND = __VBOX_E_BASE + 1;
191	VBOX_E_INVALID_VM_STATE = __VBOX_E_BASE + 2;
192	VBOX_E_VM_ERROR = __VBOX_E_BASE + 3;
193	VBOX_E_FILE_ERROR = __VBOX_E_BASE + 4;
194	VBOX_E_IPRT_ERROR = __VBOX_E_BASE + 5;
195	VBOX_E_PDM_ERROR = __VBOX_E_BASE + 6;
196	VBOX_E_INVALID_OBJECT_STATE = __VBOX_E_BASE + 7;
197	VBOX_E_HOST_ERROR = __VBOX_E_BASE + 8;
198	VBOX_E_NOT_SUPPORTED = __VBOX_E_BASE + 9;
199	VBOX_E_XML_ERROR = __VBOX_E_BASE + 10;
200	VBOX_E_INVALID_SESSION_STATE = __VBOX_E_BASE + 11;
201	VBOX_E_OBJECT_IN_USE = __VBOX_E_BASE + 12;
202	VBOX_E_DONT_CALL_AGAIN = __VBOX_E_BASE + 13;
203
204	# Reverse lookup table.
205	dDecimalToConst = {}; # pylint: disable=C0103
206
207	def __init__(self):
208	raise base.GenError('No instances, please');
209
210	@staticmethod
211	def copyErrors(oNativeComErrorClass):
212	"""
213	Copy all error codes from oNativeComErrorClass to this class and
214	install compatability mappings.
215	"""
216
217	# First, add the VBOX_E_XXX constants to dDecimalToConst.
218	for sAttr in dir(ComError):
219	if sAttr.startswith('VBOX_E'):
220	oAttr = getattr(ComError, sAttr);
221	ComError.dDecimalToConst[oAttr] = sAttr;
222
223	# Copy all error codes from oNativeComErrorClass to this class.
224	for sAttr in dir(oNativeComErrorClass):
225	if sAttr[0].isupper():
226	oAttr = getattr(oNativeComErrorClass, sAttr);
227	setattr(ComError, sAttr, oAttr);
228	if type(oAttr) is int:
229	ComError.dDecimalToConst[oAttr] = sAttr;
230
231	# Install mappings to the other platform.
232	if platform.system() == 'Windows':
233	ComError.NS_OK = ComError.S_OK;
234	ComError.NS_ERROR_FAILURE = ComError.E_FAIL;
235	ComError.NS_ERROR_ABORT = ComError.E_ABORT;
236	ComError.NS_ERROR_NULL_POINTER = ComError.E_POINTER;
237	ComError.NS_ERROR_NO_INTERFACE = ComError.E_NOINTERFACE;
238	ComError.NS_ERROR_INVALID_ARG = ComError.E_INVALIDARG;
239	ComError.NS_ERROR_OUT_OF_MEMORY = ComError.E_OUTOFMEMORY;
240	ComError.NS_ERROR_NOT_IMPLEMENTED = ComError.E_NOTIMPL;
241	ComError.NS_ERROR_UNEXPECTED = ComError.E_UNEXPECTED;
242	else:
243	ComError.E_ACCESSDENIED = -2147024891; # see VBox/com/defs.h
244	ComError.S_OK = ComError.NS_OK;
245	ComError.E_FAIL = ComError.NS_ERROR_FAILURE;
246	ComError.E_ABORT = ComError.NS_ERROR_ABORT;
247	ComError.E_POINTER = ComError.NS_ERROR_NULL_POINTER;
248	ComError.E_NOINTERFACE = ComError.NS_ERROR_NO_INTERFACE;
249	ComError.E_INVALIDARG = ComError.NS_ERROR_INVALID_ARG;
250	ComError.E_OUTOFMEMORY = ComError.NS_ERROR_OUT_OF_MEMORY;
251	ComError.E_NOTIMPL = ComError.NS_ERROR_NOT_IMPLEMENTED;
252	ComError.E_UNEXPECTED = ComError.NS_ERROR_UNEXPECTED;
253	ComError.DISP_E_EXCEPTION = -2147352567; # For COM compatability only.
254	return True;
255
256	@staticmethod
257	def getXcptResult(oXcpt):
258	"""
259	Gets the result code for an exception.
260	Returns COM status code (or E_UNEXPECTED).
261	"""
262	if platform.system() == 'Windows':
263	# The DISP_E_EXCEPTION + excptinfo fun needs checking up, only
264	# empirical info on it so far.
265	try:
266	hrXcpt = oXcpt.hresult;
267	except AttributeError:
268	hrXcpt = ComError.E_UNEXPECTED;
269	if hrXcpt == ComError.DISP_E_EXCEPTION and oXcpt.excepinfo is not None:
270	hrXcpt = oXcpt.excepinfo[5];
271	else:
272	try:
273	hrXcpt = oXcpt.errno;
274	except AttributeError:
275	hrXcpt = ComError.E_UNEXPECTED;
276	return hrXcpt;
277
278	@staticmethod
279	def equal(oXcpt, hr):
280	"""
281	Checks if the ComException e is not equal to the COM status code hr.
282	This takes DISP_E_EXCEPTION & excepinfo into account.
283
284	This method can be used with any Exception derivate, however it will
285	only return True for classes similar to the two ComException variants.
286	"""
287	if platform.system() == 'Windows':
288	# The DISP_E_EXCEPTION + excptinfo fun needs checking up, only
289	# empirical info on it so far.
290	try:
291	hrXcpt = oXcpt.hresult;
292	except AttributeError:
293	return False;
294	if hrXcpt == ComError.DISP_E_EXCEPTION and oXcpt.excepinfo is not None:
295	hrXcpt = oXcpt.excepinfo[5];
296	else:
297	try:
298	hrXcpt = oXcpt.errno;
299	except AttributeError:
300	return False;
301	return hrXcpt == hr;
302
303	@staticmethod
304	def notEqual(oXcpt, hr):
305	"""
306	Checks if the ComException e is not equal to the COM status code hr.
307	See equal() for more details.
308	"""
309	return not ComError.equal(oXcpt, hr)
310
311	@staticmethod
312	def toString(hr):
313	"""
314	Converts the specified COM status code to a string.
315	"""
316	try:
317	sStr = ComError.dDecimalToConst[int(hr)];
318	except KeyError:
319	hrLong = long(hr);
320	sStr = '%#x (%d)' % (hrLong, hrLong);
321	return sStr;
322
323
324	class Build(object): # pylint: disable=R0903
325	"""
326	A VirtualBox build.
327
328	Note! After dropping the installation of VBox from this code and instead
329	realizing that with the vboxinstall.py wrapper driver, this class is
330	of much less importance and contains unnecessary bits and pieces.
331	"""
332
333	def __init__(self, oDriver, strInstallPath):
334	"""
335	Construct a build object from a build file name and/or install path.
336	"""
337	# Initialize all members first.
338	self.oDriver = oDriver;
339	self.sInstallPath = strInstallPath;
340	self.sSdkPath = None;
341	self.sSrcRoot = None;
342	self.sKind = None;
343	self.sDesignation = None;
344	self.sType = None;
345	self.sOs = None;
346	self.sArch = None;
347	self.sGuestAdditionsIso = None;
348
349	# Figure out the values as best we can.
350	if strInstallPath is None:
351	#
352	# Both parameters are None, which means we're falling back on a
353	# build in the development tree.
354	#
355	self.sKind = "development";
356
357	if self.sType is None:
358	self.sType = os.environ.get("KBUILD_TYPE", os.environ.get("BUILD_TYPE", "release"));
359	if self.sOs is None:
360	self.sOs = os.environ.get("KBUILD_TARGET", os.environ.get("BUILD_TARGET", oDriver.sHost));
361	if self.sArch is None:
362	self.sArch = os.environ.get("KBUILD_TARGET_ARCH", os.environ.get("BUILD_TARGET_ARCH", oDriver.sHostArch));
363
364	sOut = os.path.join('out', self.sOs + '.' + self.sArch, self.sType);
365	sSearch = os.environ.get('VBOX_TD_DEV_TREE', os.path.dirname(__file__)); # Env.var. for older trees or testboxscript.
366	sCandidat = None;
367	for i in range(0, 10): # pylint: disable=W0612
368	sBldDir = os.path.join(sSearch, sOut);
369	if os.path.isdir(sBldDir):
370	sCandidat = os.path.join(sBldDir, 'bin', 'VBoxSVC' + base.exeSuff());
371	if os.path.isfile(sCandidat):
372	self.sSdkPath = os.path.join(sBldDir, 'bin/sdk');
373	break;
374	sCandidat = os.path.join(sBldDir, 'dist/VirtualBox.app/Contents/MacOS/VBoxSVC');
375	if os.path.isfile(sCandidat):
376	self.sSdkPath = os.path.join(sBldDir, 'dist/sdk');
377	break;
378	sSearch = os.path.abspath(os.path.join(sSearch, '..'));
379	if sCandidat is None or not os.path.isfile(sCandidat):
380	raise base.GenError();
381	self.sInstallPath = os.path.abspath(os.path.dirname(sCandidat));
382	self.sSrcRoot = os.path.abspath(sSearch);
383
384	self.sDesignation = os.environ.get('TEST_BUILD_DESIGNATION', None);
385	if self.sDesignation is None:
386	try:
387	oFile = utils.openNoInherit(os.path.join(self.sSrcRoot, sOut, 'revision.kmk'), 'r');
388	except:
389	pass;
390	else:
391	s = oFile.readline();
392	oFile.close();
393	import re;
394	oMatch = re.search("VBOX_SVN_REV=(\\d+)", s);
395	if oMatch is not None:
396	self.sDesignation = oMatch.group(1);
397
398	if self.sDesignation is None:
399	self.sDesignation = 'XXXXX'
400	else:
401	#
402	# We've been pointed to an existing installation, this could be
403	# in the out dir of a svn checkout, untarred VBoxAll or a real
404	# installation directory.
405	#
406	self.sKind = "preinstalled";
407	self.sType = "release";
408	self.sOs = oDriver.sHost;
409	self.sArch = oDriver.sHostArch;
410	self.sInstallPath = os.path.abspath(strInstallPath);
411	self.sSdkPath = os.path.join(self.sInstallPath, 'sdk');
412	self.sSrcRoot = None;
413	self.sDesignation = os.environ.get('TEST_BUILD_DESIGNATION', 'XXXXX');
414	## @todo Much more work is required here.
415
416	# Do some checks.
417	sVMMR0 = os.path.join(self.sInstallPath, 'VMMR0.r0');
418	if not os.path.isfile(sVMMR0) and utils.getHostOs() == 'solaris': # solaris is special.
419	sVMMR0 = os.path.join(self.sInstallPath, 'amd64' if utils.getHostArch() == 'amd64' else 'i386', 'VMMR0.r0');
420	if not os.path.isfile(sVMMR0):
421	raise base.GenError('%s is missing' % (sVMMR0,));
422
423	# Guest additions location is different on windows for some _stupid_ reason.
424	if self.sOs == 'win' and self.sKind != 'development':
425	self.sGuestAdditionsIso = '%s/VBoxGuestAdditions.iso' % (self.sInstallPath,);
426	elif self.sOs == 'darwin':
427	self.sGuestAdditionsIso = '%s/VBoxGuestAdditions.iso' % (self.sInstallPath,);
428	elif self.sOs == 'solaris':
429	self.sGuestAdditionsIso = '%s/VBoxGuestAdditions.iso' % (self.sInstallPath,);
430	else:
431	self.sGuestAdditionsIso = '%s/additions/VBoxGuestAdditions.iso' % (self.sInstallPath,);
432
433	# __init__ end;
434
435	def dump(self):
436	""" Status dumper for debugging. """
437	print >> sys.stderr, "testdriver.vbox.Build: sInstallPath= '%s'" % self.sInstallPath;
438	print >> sys.stderr, "testdriver.vbox.Build: sSdkPath = '%s'" % self.sSdkPath;
439	print >> sys.stderr, "testdriver.vbox.Build: sSrcRoot = '%s'" % self.sSrcRoot;
440	print >> sys.stderr, "testdriver.vbox.Build: sKind = '%s'" % self.sKind;
441	print >> sys.stderr, "testdriver.vbox.Build: sDesignation= '%s'" % self.sDesignation;
442	print >> sys.stderr, "testdriver.vbox.Build: sType = '%s'" % self.sType;
443	print >> sys.stderr, "testdriver.vbox.Build: sOs = '%s'" % self.sOs;
444	print >> sys.stderr, "testdriver.vbox.Build: sArch = '%s'" % self.sArch;
445
446	def isDevBuild(self):
447	""" Returns True if it's development build (kind), otherwise False. """
448	return self.sKind == 'development';
449
450
451	class EventHandlerBase(object):
452	"""
453	Base class for both Console and VirtualBox event handlers.
454	"""
455
456	def __init__(self, dArgs, fpApiVer, sName = None):
457	self.oVBoxMgr = dArgs['oVBoxMgr'];
458	self.oEventSrc = dArgs['oEventSrc']; # Console/VirtualBox for < 3.3
459	self.oListener = dArgs['oListener'];
460	self.fPassive = self.oListener != None;
461	self.sName = sName
462	self.fShutdown = False;
463	self.oThread = None;
464	self.fpApiVer = fpApiVer;
465
466	def threadForPassiveMode(self):
467	"""
468	The thread procedure for the event processing thread.
469	"""
470	assert self.fPassive is not None;
471	while not self.fShutdown:
472	try:
473	oEvt = self.oEventSrc.getEvent(self.oListener, 500);
474	except:
475	if not self.oVBoxMgr.xcptIsDeadInterface(): reporter.logXcpt();
476	else: reporter.log('threadForPassiveMode/%s: interface croaked (ignored)' % (self.sName,));
477	break;
478	if oEvt:
479	self.handleEvent(oEvt);
480	try:
481	self.oEventSrc.eventProcessed(self.oListener, oEvt);
482	except:
483	reporter.logXcpt();
484	break;
485	self.unregister(fWaitForThread = False);
486	return None;
487
488	def startThreadForPassiveMode(self):
489	"""
490	Called when working in passive mode.
491	"""
492	self.oThread = threading.Thread(target = self.threadForPassiveMode, \
493	args=(), name=('PAS-%s' % (self.sName,)));
494	self.oThread.setDaemon(True)
495	self.oThread.start();
496	return None;
497
498	def unregister(self, fWaitForThread = True):
499	"""
500	Unregister the event handler.
501	"""
502	self.fShutdown = True;
503
504	fRc = False;
505	if self.oEventSrc is not None:
506	if self.fpApiVer < 3.3:
507	try:
508	self.oEventSrc.unregisterCallback(self.oListener);
509	fRc = True;
510	except:
511	reporter.errorXcpt('unregisterCallback failed on %s' % (self.oListener,));
512	else:
513	try:
514	self.oEventSrc.unregisterListener(self.oListener);
515	fRc = True;
516	except:
517	if self.oVBoxMgr.xcptIsDeadInterface():
518	reporter.log('unregisterListener failed on %s because of dead interface (%s)'
519	% (self.oListener, self.oVBoxMgr.xcptToString(),));
520	else:
521	reporter.errorXcpt('unregisterListener failed on %s' % (self.oListener,));
522
523	if self.oThread is not None \
524	and self.oThread != threading.current_thread():
525	self.oThread.join();
526	self.oThread = None;
527
528	_ = fWaitForThread;
529	return fRc;
530
531	def handleEvent(self, oEvt):
532	"""
533	Compatibility wrapper that child classes implement.
534	"""
535	_ = oEvt;
536	return None;
537
538	@staticmethod
539	def registerDerivedEventHandler(oVBoxMgr, fpApiVer, oSubClass, dArgsCopy,
540	oSrcParent, sSrcParentNm, sICallbackNm,
541	fMustSucceed = True, sLogSuffix = ''):
542	"""
543	Registers the callback / event listener.
544	"""
545	dArgsCopy['oVBoxMgr'] = oVBoxMgr;
546	dArgsCopy['oListener'] = None;
547	if fpApiVer < 3.3:
548	dArgsCopy['oEventSrc'] = oSrcParent;
549	try:
550	oRet = oVBoxMgr.createCallback(sICallbackNm, oSubClass, dArgsCopy);
551	except:
552	reporter.errorXcpt('%s::registerCallback(%s) failed%s' % (sSrcParentNm, oRet, sLogSuffix));
553	else:
554	try:
555	oSrcParent.registerCallback(oRet);
556	return oRet;
557	except Exception, oXcpt:
558	if fMustSucceed or ComError.notEqual(oXcpt, ComError.E_UNEXPECTED):
559	reporter.errorXcpt('%s::registerCallback(%s)%s' % (sSrcParentNm, oRet, sLogSuffix));
560	else:
561	fPassive = sys.platform == 'win32'; # or webservices.
562	try:
563	oEventSrc = oSrcParent.eventSource;
564	dArgsCopy['oEventSrc'] = oEventSrc;
565	if not fPassive:
566	oListener = oRet = oVBoxMgr.createListener(oSubClass, dArgsCopy);
567	else:
568	oListener = oEventSrc.createListener();
569	dArgsCopy['oListener'] = oListener;
570	oRet = oSubClass(dArgsCopy);
571	except:
572	reporter.errorXcpt('%s::eventSource.createListener(%s) failed%s' % (sSrcParentNm, oListener, sLogSuffix));
573	else:
574	try:
575	oEventSrc.registerListener(oListener, [vboxcon.VBoxEventType_Any], not fPassive);
576	except Exception, oXcpt:
577	if fMustSucceed or ComError.notEqual(oXcpt, ComError.E_UNEXPECTED):
578	reporter.errorXcpt('%s::eventSource.registerListener(%s) failed%s' \
579	% (sSrcParentNm, oListener, sLogSuffix));
580	else:
581	if not fPassive:
582	if sys.platform == 'win32':
583	from win32com.server.util import unwrap # pylint: disable=F0401
584	oRet = unwrap(oRet);
585	oRet.oListener = oListener;
586	else:
587	oRet.startThreadForPassiveMode();
588	return oRet;
589	return None;
590
591
592
593
594	class ConsoleEventHandlerBase(EventHandlerBase):
595	"""
596	Base class for handling IConsole events.
597
598	The class has IConsoleCallback (<=3.2) compatible callback methods which
599	the user can override as needed.
600
601	Note! This class must not inherit from object or we'll get type errors in VBoxPython.
602	"""
603	def __init__(self, dArgs, sName = None):
604	self.oSession = dArgs['oSession'];
605	self.oConsole = dArgs['oConsole'];
606	if sName is None:
607	sName = self.oSession.sName;
608	EventHandlerBase.__init__(self, dArgs, self.oSession.fpApiVer, sName);
609
610
611	# pylint: disable=C0111,R0913,W0613
612	def onMousePointerShapeChange(self, fVisible, fAlpha, xHot, yHot, cx, cy, abShape):
613	reporter.log2('onMousePointerShapeChange/%s' % (self.sName));
614	def onMouseCapabilityChange(self, fSupportsAbsolute, *aArgs): # Extra argument was added in 3.2.
615	reporter.log2('onMouseCapabilityChange/%s' % (self.sName));
616	def onKeyboardLedsChange(self, fNumLock, fCapsLock, fScrollLock):
617	reporter.log2('onKeyboardLedsChange/%s' % (self.sName));
618	def onStateChange(self, eState):
619	reporter.log2('onStateChange/%s' % (self.sName));
620	def onAdditionsStateChange(self):
621	reporter.log2('onAdditionsStateChange/%s' % (self.sName));
622	def onNetworkAdapterChange(self, oNic):
623	reporter.log2('onNetworkAdapterChange/%s' % (self.sName));
624	def onSerialPortChange(self, oPort):
625	reporter.log2('onSerialPortChange/%s' % (self.sName));
626	def onParallelPortChange(self, oPort):
627	reporter.log2('onParallelPortChange/%s' % (self.sName));
628	def onStorageControllerChange(self):
629	reporter.log2('onStorageControllerChange/%s' % (self.sName));
630	def onMediumChange(self, attachment):
631	reporter.log2('onMediumChange/%s' % (self.sName));
632	def onCPUChange(self, iCpu, fAdd):
633	reporter.log2('onCPUChange/%s' % (self.sName));
634	def onVRDPServerChange(self):
635	reporter.log2('onVRDPServerChange/%s' % (self.sName));
636	def onRemoteDisplayInfoChange(self):
637	reporter.log2('onRemoteDisplayInfoChange/%s' % (self.sName));
638	def onUSBControllerChange(self):
639	reporter.log2('onUSBControllerChange/%s' % (self.sName));
640	def onUSBDeviceStateChange(self, oDevice, fAttached, oError):
641	reporter.log2('onUSBDeviceStateChange/%s' % (self.sName));
642	def onSharedFolderChange(self, fGlobal):
643	reporter.log2('onSharedFolderChange/%s' % (self.sName));
644	def onRuntimeError(self, fFatal, sErrId, sMessage):
645	reporter.log2('onRuntimeError/%s' % (self.sName));
646	def onCanShowWindow(self):
647	reporter.log2('onCanShowWindow/%s' % (self.sName));
648	return True
649	def onShowWindow(self):
650	reporter.log2('onShowWindow/%s' % (self.sName));
651	return None;
652
653	# pylint: enable=C0111,R0913,W0613
654
655	def handleEvent(self, oEvt):
656	"""
657	Compatibility wrapper.
658	"""
659	try:
660	oEvtBase = self.oVBoxMgr.queryInterface(oEvt, 'IEvent');
661	eType = oEvtBase.type;
662	except:
663	reporter.logXcpt();
664	return None;
665	if eType == vboxcon.VBoxEventType_OnRuntimeError:
666	try:
667	oEvtIt = self.oVBoxMgr.queryInterface(oEvtBase, 'IRuntimeErrorEvent');
668	return self.onRuntimeError(oEvtIt.fatal, oEvtIt.id, oEvtIt.message)
669	except:
670	reporter.logXcpt();
671	## @todo implement the other events.
672	if eType != vboxcon.VBoxEventType_OnMousePointerShapeChanged:
673	reporter.log2('%s/%s' % (str(eType), self.sName));
674	return None;
675
676
677	class VirtualBoxEventHandlerBase(EventHandlerBase):
678	"""
679	Base class for handling IVirtualBox events.
680
681	The class has IConsoleCallback (<=3.2) compatible callback methods which
682	the user can override as needed.
683
684	Note! This class must not inherit from object or we'll get type errors in VBoxPython.
685	"""
686	def __init__(self, dArgs, sName = "emanon"):
687	self.oVBoxMgr = dArgs['oVBoxMgr'];
688	self.oVBox = dArgs['oVBox'];
689	EventHandlerBase.__init__(self, dArgs, self.oVBox.fpApiVer, sName);
690
691	# pylint: disable=C0111,W0613
692	def onMachineStateChange(self, sMachineId, eState):
693	pass;
694	def onMachineDataChange(self, sMachineId):
695	pass;
696	def onExtraDataCanChange(self, sMachineId, sKey, sValue):
697	# The COM bridge does tuples differently. Not very funny if you ask me... ;-)
698	if self.oVBoxMgr.type == 'MSCOM':
699	return '', 0, True;
700	return True, ''
701	def onExtraDataChange(self, sMachineId, sKey, sValue):
702	pass;
703	def onMediumRegistered(self, sMediumId, eMediumType, fRegistered):
704	pass;
705	def onMachineRegistered(self, sMachineId, fRegistered):
706	pass;
707	def onSessionStateChange(self, sMachineId, eState):
708	pass;
709	def onSnapshotTaken(self, sMachineId, sSnapshotId):
710	pass;
711	def onSnapshotDiscarded(self, sMachineId, sSnapshotId):
712	pass;
713	def onSnapshotChange(self, sMachineId, sSnapshotId):
714	pass;
715	def onGuestPropertyChange(self, sMachineId, sName, sValue, sFlags):
716	pass;
717	# pylint: enable=C0111,W0613
718
719	def handleEvent(self, oEvt):
720	"""
721	Compatibility wrapper.
722	"""
723	try:
724	oEvtBase = self.oVBoxMgr.queryInterface(oEvt, 'IEvent');
725	eType = oEvtBase.type;
726	except:
727	reporter.logXcpt();
728	return None;
729	if eType == vboxcon.VBoxEventType_OnMachineStateChanged:
730	try:
731	oEvtIt = self.oVBoxMgr.queryInterface(oEvtBase, 'IMachineStateChangedEvent');
732	return self.onMachineStateChange(oEvtIt.machineId, oEvtIt.state)
733	except:
734	reporter.logXcpt();
735	elif eType == vboxcon.VBoxEventType_OnGuestPropertyChanged:
736	try:
737	oEvtIt = self.oVBoxMgr.queryInterface(oEvtBase, 'IGuestPropertyChangedEvent');
738	return self.onGuestPropertyChange(oEvtIt.machineId, oEvtIt.name, oEvtIt.value, oEvtIt.flags);
739	except:
740	reporter.logXcpt();
741	## @todo implement the other events.
742	reporter.log2('%s/%s' % (str(eType), self.sName));
743	return None;
744
745
746	class SessionConsoleEventHandler(ConsoleEventHandlerBase):
747	"""
748	For catching machine state changes and waking up the task machinery at that point.
749	"""
750	def __init__(self, dArgs):
751	ConsoleEventHandlerBase.__init__(self, dArgs);
752
753	def onMachineStateChange(self, sMachineId, eState): # pylint: disable=W0613
754	""" Just interrupt the wait loop here so it can check again. """
755	self.oVBoxMgr.interruptWaitEvents();
756
757
758
759	class TestDriver(base.TestDriver): # pylint: disable=R0902
760	"""
761	This is the VirtualBox test driver.
762	"""
763
764	def __init__(self):
765	base.TestDriver.__init__(self);
766	self.fImportedVBoxApi = False;
767	self.fpApiVer = 3.2;
768	self.oBuild = None;
769	self.oVBoxMgr = None;
770	self.oVBox = None;
771	self.aoRemoteSessions = [];
772	self.aoVMs = []; ## @todo not sure if this list will be of any use.
773	self.oTestVmManager = vboxtestvms.TestVmManager(self.sResourcePath);
774	self.oTestVmSet = vboxtestvms.TestVmSet();
775	self.sSessionTypeDef = 'headless';
776	self.sSessionType = self.sSessionTypeDef;
777	self.fEnableVrdp = True;
778	self.uVrdpBasePortDef = 6000;
779	self.uVrdpBasePort = self.uVrdpBasePortDef;
780	self.sDefBridgedNic = None;
781	self.fUseDefaultSvc = False;
782	self.sLogSelfGroups = '';
783	self.sLogSelfFlags = 'time';
784	self.sLogSelfDest = '';
785	self.sLogSessionGroups = '';
786	self.sLogSessionFlags = 'time';
787	self.sLogSessionDest = '';
788	self.sLogSvcGroups = '';
789	self.sLogSvcFlags = 'time';
790	self.sLogSvcDest = '';
791	self.sSelfLogFile = None;
792	self.sVBoxSvcLogFile = None;
793	self.oVBoxSvcProcess = None;
794	self.sVBoxSvcPidFile = None;
795	self.fVBoxSvcInDebugger = False;
796	self.sVBoxValidationKit = None;
797	self.sVBoxValidationKitIso = None;
798	self.sVBoxBootSectors = None;
799	self.fAlwaysUploadLogs = False;
800	self.fAlwaysUploadScreenshots = False;
801
802	# Quietly detect build and validation kit.
803	self._detectBuild(False);
804	self._detectValidationKit(False);
805
806	# Make sure all debug logs goes to the scratch area unless
807	# specified otherwise (more of this later on).
808	if 'VBOX_LOG_DEST' not in os.environ:
809	os.environ['VBOX_LOG_DEST'] = 'dir=%s' % (self.sScratchPath);
810
811	def dump(self):
812	"""
813	Dump object state, for debugging.
814	"""
815	base.TestDriver.dump(self);
816	print >> sys.stderr, "testdriver.vbox: fImportedVBoxApi = '%s'" % self.fImportedVBoxApi;
817	print >> sys.stderr, "testdriver.vbox: fpApiVer = '%s'" % self.fpApiVer;
818	print >> sys.stderr, "testdriver.vbox: oBuild = '%s'" % self.oBuild;
819	print >> sys.stderr, "testdriver.vbox: oVBoxMgr = '%s'" % self.oVBoxMgr;
820	print >> sys.stderr, "testdriver.vbox: oVBox = '%s'" % self.oVBox;
821	print >> sys.stderr, "testdriver.vbox: aoRemoteSessions = '%s'" % self.aoRemoteSessions;
822	print >> sys.stderr, "testdriver.vbox: aoVMs = '%s'" % self.aoVMs;
823	print >> sys.stderr, "testdriver.vbox: sVBoxValidationKit = '%s'" % self.sVBoxValidationKit;
824	print >> sys.stderr, "testdriver.vbox: sVBoxValidationKitIso = '%s'" % self.sVBoxValidationKitIso;
825	print >> sys.stderr, "testdriver.vbox: sVBoxBootSectors = '%s'" % self.sVBoxBootSectors;
826	if self.oBuild is not None:
827	self.oBuild.dump();
828
829	def _detectBuild(self, fQuiet = False):
830	"""
831	This is used internally to try figure a locally installed build when
832	running tests manually.
833	"""
834	if self.oBuild is not None:
835	return True;
836
837	# Try dev build first since that's where I'll be using it first..
838	if True:
839	try:
840	self.oBuild = Build(self, None);
841	return True;
842	except base.GenError:
843	pass;
844
845	# Try default installation locations.
846	if self.sHost == 'win':
847	sProgFiles = os.environ.get('ProgramFiles', 'C:\\Program Files');
848	asLocs = [
849	os.path.join(sProgFiles, 'Oracle', 'VirtualBox'),
850	os.path.join(sProgFiles, 'OracleVM', 'VirtualBox'),
851	os.path.join(sProgFiles, 'Sun', 'VirtualBox'),
852	];
853	elif self.sHost == 'solaris':
854	asLocs = [ '/opt/VirtualBox-3.2', '/opt/VirtualBox-3.1', '/opt/VirtualBox-3.0', '/opt/VirtualBox' ];
855	elif self.sHost == 'darwin':
856	asLocs = [ '/Applications/VirtualBox.app/Contents/MacOS' ];
857	elif self.sHost == 'linux':
858	asLocs = [ '/opt/VirtualBox-3.2', '/opt/VirtualBox-3.1', '/opt/VirtualBox-3.0', '/opt/VirtualBox' ];
859	else:
860	asLocs = [ '/opt/VirtualBox' ];
861	if 'VBOX_INSTALL_PATH' in os.environ:
862	asLocs.insert(0, os.environ['VBOX_INSTALL_PATH']);
863
864	for sLoc in asLocs:
865	try:
866	self.oBuild = Build(self, sLoc);
867	return True;
868	except base.GenError:
869	pass;
870
871	if not fQuiet:
872	reporter.error('failed to find VirtualBox installation');
873	return False;
874
875	def _detectValidationKit(self, fQuiet = False):
876	"""
877	This is used internally by the constructor to try locate an unzipped
878	VBox Validation Kit somewhere in the immediate proximity.
879	"""
880	if self.sVBoxValidationKit is not None:
881	return True;
882
883	#
884	# Normally it's found where we're running from, which is the same as
885	# the script directly on the testboxes.
886	#
887	asCandidates = [self.sScriptPath, ];
888	if g_ksValidationKitDir not in asCandidates:
889	asCandidates.append(g_ksValidationKitDir);
890	if os.getcwd() not in asCandidates:
891	asCandidates.append(os.getcwd());
892	if self.oBuild is not None and self.oBuild.sInstallPath not in asCandidates:
893	asCandidates.append(self.oBuild.sInstallPath);
894
895	#
896	# When working out of the tree, we'll search the current directory
897	# as well as parent dirs.
898	#
899	for sDir in list(asCandidates):
900	for i in range(10):
901	sDir = os.path.dirname(sDir);
902	if sDir not in asCandidates:
903	asCandidates.append(sDir);
904
905	#
906	# Do the searching.
907	#
908	sCandidate = None;
909	for i in range(len(asCandidates)):
910	sCandidate = asCandidates[i];
911	if os.path.isfile(os.path.join(sCandidate, 'VBoxValidationKit.iso')):
912	break;
913	sCandidate = os.path.join(sCandidate, 'validationkit');
914	if os.path.isfile(os.path.join(sCandidate, 'VBoxValidationKit.iso')):
915	break;
916	sCandidate = None;
917
918	fRc = sCandidate is not None;
919	if fRc is False:
920	if not fQuiet:
921	reporter.error('failed to find VBox Validation Kit installation (candidates: %s)' % (asCandidates,));
922	sCandidate = os.path.join(self.sScriptPath, 'validationkit'); # Don't leave the values as None.
923
924	#
925	# Set the member values.
926	#
927	self.sVBoxValidationKit = sCandidate;
928	self.sVBoxValidationKitIso = os.path.join(sCandidate, 'VBoxValidationKit.iso');
929	self.sVBoxBootSectors = os.path.join(sCandidate, 'bootsectors');
930	return fRc;
931
932	def importVBoxApi(self):
933	"""
934	Import the 'vboxapi' module from the VirtualBox build we're using and
935	instantiate the two basic objects.
936
937	This will try detect an development or installed build if no build has
938	been associated with the driver yet.
939	"""
940	if self.fImportedVBoxApi:
941	return True;
942
943	## @todo split up this messy function.
944
945	# Make sure we've got our own VirtualBox config and VBoxSVC (on XPCOM at least).
946	if not self.fUseDefaultSvc:
947	os.environ['VBOX_USER_HOME'] = os.path.join(self.sScratchPath, 'VBoxUserHome');
948	sUser = os.environ.get('USERNAME', os.environ.get('USER', os.environ.get('LOGNAME', 'unknown')));
949	os.environ['VBOX_IPC_SOCKETID'] = sUser + '-VBoxTest';
950
951	# Do the detecting.
952	self._detectBuild();
953	if self.oBuild is None:
954	return False;
955
956	# Avoid crashing when loading the 32-bit module (or whatever it is that goes bang).
957	if self.oBuild.sArch == 'x86' \
958	and self.sHost == 'darwin' \
959	and platform.architecture()[0] == '64bit' \
960	and self.oBuild.sKind == 'development' \
961	and os.getenv('VERSIONER_PYTHON_PREFER_32_BIT') != 'yes':
962	print "WARNING: 64-bit python on darwin, 32-bit VBox development build => crash"
963	print "WARNING: bash-3.2$ /usr/bin/python2.5 ./testdriver"
964	print "WARNING: or"
965	print "WARNING: bash-3.2$ VERSIONER_PYTHON_PREFER_32_BIT=yes ./testdriver"
966	return False;
967
968	# Start VBoxSVC and load the vboxapi bits.
969	if self._startVBoxSVC() is True:
970	assert(self.oVBoxSvcProcess is not None);
971
972	sSavedSysPath = sys.path;
973	self._setupVBoxApi();
974	sys.path = sSavedSysPath;
975
976	# Adjust the default machine folder.
977	if self.fImportedVBoxApi and not self.fUseDefaultSvc and self.fpApiVer >= 4.0:
978	sNewFolder = os.path.join(self.sScratchPath, 'VBoxUserHome', 'Machines');
979	try:
980	self.oVBox.systemProperties.defaultMachineFolder = sNewFolder;
981	except:
982	self.fImportedVBoxApi = False;
983	self.oVBoxMgr = None;
984	self.oVBox = None;
985	reporter.logXcpt("defaultMachineFolder exception (sNewFolder=%s)" % (sNewFolder,));
986
987	# Kill VBoxSVC on failure.
988	if self.oVBoxMgr is None:
989	self._stopVBoxSVC();
990	else:
991	assert(self.oVBoxSvcProcess is None);
992	return self.fImportedVBoxApi;
993
994	def _startVBoxSVC(self): # pylint: disable=R0915
995	""" Starts VBoxSVC. """
996	assert(self.oVBoxSvcProcess is None);
997
998	# Setup vbox logging for VBoxSVC now and start it manually. This way
999	# we can control both logging and shutdown.
1000	self.sVBoxSvcLogFile = '%s/VBoxSVC-debug.log' % (self.sScratchPath,);
1001	try: os.remove(self.sVBoxSvcLogFile);
1002	except: pass;
1003	os.environ['VBOX_LOG'] = self.sLogSvcGroups;
1004	os.environ['VBOX_LOG_FLAGS'] = '%s append' % (self.sLogSvcFlags,); # Append becuse of VBoxXPCOMIPCD.
1005	if self.sLogSvcDest:
1006	os.environ['VBOX_LOG_DEST'] = self.sLogSvcDest;
1007	else:
1008	os.environ['VBOX_LOG_DEST'] = 'file=%s' % (self.sVBoxSvcLogFile,);
1009	os.environ['VBOXSVC_RELEASE_LOG_FLAGS'] = 'time append';
1010
1011	# Always leave a pid file behind so we can kill it during cleanup-before.
1012	self.sVBoxSvcPidFile = '%s/VBoxSVC.pid' % (self.sScratchPath,);
1013	fWritePidFile = True;
1014
1015	cMsFudge = 1;
1016	sVBoxSVC = '%s/VBoxSVC' % (self.oBuild.sInstallPath,); ## @todo .exe and stuff.
1017	if self.fVBoxSvcInDebugger:
1018	if self.sHost in ('darwin', 'freebsd', 'linux', 'solaris', ):
1019	# Start VBoxSVC in gdb in a new terminal.
1020	#sTerm = '/usr/bin/gnome-terminal'; - doesn't work, some fork+exec stuff confusing us.
1021	sTerm = '/usr/bin/xterm';
1022	if not os.path.isfile(sTerm): sTerm = '/usr/X11/bin/xterm';
1023	if not os.path.isfile(sTerm): sTerm = '/usr/X11R6/bin/xterm';
1024	if not os.path.isfile(sTerm): sTerm = '/usr/bin/xterm';
1025	if not os.path.isfile(sTerm): sTerm = 'xterm';
1026	sGdb = '/usr/bin/gdb';
1027	if not os.path.isfile(sGdb): sGdb = '/usr/local/bin/gdb';
1028	if not os.path.isfile(sGdb): sGdb = '/usr/sfw/bin/gdb';
1029	if not os.path.isfile(sGdb): sGdb = 'gdb';
1030	sGdbCmdLine = '%s --args %s --pidfile %s' % (sGdb, sVBoxSVC, self.sVBoxSvcPidFile);
1031	reporter.log('term="%s" gdb="%s"' % (sTerm, sGdbCmdLine));
1032	os.environ['SHELL'] = self.sOrgShell; # Non-working shell may cause gdb and/or the term problems.
1033	self.oVBoxSvcProcess = base.Process.spawnp(sTerm, sTerm, '-e', sGdbCmdLine);
1034	os.environ['SHELL'] = self.sOurShell;
1035	if self.oVBoxSvcProcess is not None:
1036	reporter.log('Press enter or return after starting VBoxSVC in the debugger...');
1037	sys.stdin.read(1);
1038	fWritePidFile = False;
1039
1040	elif self.sHost == 'win':
1041	sWinDbg = 'c:\\Program Files\\Debugging Tools for Windows\\windbg.exe';
1042	if not os.path.isfile(sWinDbg): sWinDbg = 'c:\\Program Files\\Debugging Tools for Windows (x64)\\windbg.exe';
1043	if not os.path.isfile(sWinDbg): sWinDbg = 'c:\\Programme\\Debugging Tools for Windows\\windbg.exe'; # Localization rulez! pylint: disable=C0301
1044	if not os.path.isfile(sWinDbg): sWinDbg = 'c:\\Programme\\Debugging Tools for Windows (x64)\\windbg.exe';
1045	if not os.path.isfile(sWinDbg): sWinDbg = 'windbg'; # WinDbg must be in the path; better than nothing.
1046	# Assume that everything WinDbg needs is defined using the environment variables.
1047	# See WinDbg help for more information.
1048	reporter.log('windbg="%s"' % (sWinDbg));
1049	self.oVBoxSvcProcess = base.Process.spawn(sWinDbg, sWinDbg, sVBoxSVC + base.exeSuff());
1050	if self.oVBoxSvcProcess is not None:
1051	reporter.log('Press enter or return after starting VBoxSVC in the debugger...');
1052	sys.stdin.read(1);
1053	fWritePidFile = False;
1054	## @todo add a pipe interface similar to xpcom if feasible, i.e. if
1055	# we can get actual handle values for pipes in python.
1056
1057	else:
1058	reporter.error('Port me!');
1059	else: # Run without a debugger attached.
1060	if self.sHost in ('darwin', 'freebsd', 'linux', 'solaris', ):
1061	#
1062	# XPCOM - We can use a pipe to let VBoxSVC notify us when it's ready.
1063	#
1064	iPipeR, iPipeW = os.pipe();
1065	os.environ['NSPR_INHERIT_FDS'] = 'vboxsvc:startup-pipe:5:0x%x' % (iPipeW,);
1066	reporter.log2("NSPR_INHERIT_FDS=%s" % (os.environ['NSPR_INHERIT_FDS']));
1067
1068	self.oVBoxSvcProcess = base.Process.spawn(sVBoxSVC, sVBoxSVC, '--auto-shutdown'); # SIGUSR1 requirement.
1069	try: # Try make sure we get the SIGINT and not VBoxSVC.
1070	os.setpgid(self.oVBoxSvcProcess.getPid(), 0); # pylint: disable=E1101
1071	os.setpgid(0, 0); # pylint: disable=E1101
1072	except:
1073	reporter.logXcpt();
1074
1075	os.close(iPipeW);
1076	try:
1077	sResponse = os.read(iPipeR, 32);
1078	except:
1079	reporter.logXcpt();
1080	sResponse = None;
1081	os.close(iPipeR);
1082
1083	if sResponse is None or sResponse.strip() != 'READY':
1084	reporter.error('VBoxSVC failed starting up... (sResponse=%s)' % (sResponse,));
1085	if not self.oVBoxSvcProcess.wait(5000):
1086	self.oVBoxSvcProcess.terminate(2500);
1087	self.oVBoxSvcProcess.wait(5000);
1088	self.oVBoxSvcProcess = None;
1089
1090	elif self.sHost == 'win':
1091	#
1092	# Windows - Just fudge it for now.
1093	#
1094	cMsFudge = 2000;
1095	self.oVBoxSvcProcess = base.Process.spawn(sVBoxSVC, sVBoxSVC);
1096
1097	else:
1098	reporter.error('Port me!');
1099
1100	#
1101	# Enable automatic crash reporting if we succeeded.
1102	#
1103	if self.oVBoxSvcProcess is not None:
1104	self.oVBoxSvcProcess.enableCrashReporting('crash/report/svc', 'crash/dump/svc');
1105
1106	#
1107	# Fudge and pid file.
1108	#
1109	if self.oVBoxSvcProcess != None and not self.oVBoxSvcProcess.wait(cMsFudge):
1110	if fWritePidFile:
1111	iPid = self.oVBoxSvcProcess.getPid();
1112	try:
1113	oFile = utils.openNoInherit(self.sVBoxSvcPidFile, "w+");
1114	oFile.write('%s' % (iPid,));
1115	oFile.close();
1116	except:
1117	reporter.logXcpt('sPidFile=%s' % (self.sVBoxSvcPidFile,));
1118	reporter.log('VBoxSVC PID=%u' % (iPid,));
1119
1120	#
1121	# Finally add the task so we'll notice when it dies in a relatively timely manner.
1122	#
1123	self.addTask(self.oVBoxSvcProcess);
1124	else:
1125	self.oVBoxSvcProcess = None;
1126	try: os.remove(self.sVBoxSvcPidFile);
1127	except: pass;
1128
1129	return self.oVBoxSvcProcess != None;
1130
1131
1132	def _killVBoxSVCByPidFile(self, sPidFile):
1133	""" Kill a VBoxSVC given the pid from it's pid file. """
1134
1135	# Read the pid file.
1136	if not os.path.isfile(sPidFile):
1137	return False;
1138	try:
1139	oFile = utils.openNoInherit(sPidFile, "r");
1140	sPid = oFile.readline().strip();
1141	oFile.close();
1142	except:
1143	reporter.logXcpt('sPidfile=%s' % (sPidFile,));
1144	return False;
1145
1146	# Convert the pid to an integer and validate the range a little bit.
1147	try:
1148	iPid = long(sPid);
1149	except:
1150	reporter.logXcpt('sPidfile=%s sPid="%s"' % (sPidFile, sPid));
1151	return False;
1152	if iPid <= 0:
1153	reporter.log('negative pid - sPidfile=%s sPid="%s" iPid=%d' % (sPidFile, sPid, iPid));
1154	return False;
1155
1156	# Take care checking that it's VBoxSVC we're about to inhume.
1157	if base.processCheckPidAndName(iPid, "VBoxSVC") is not True:
1158	reporter.log('Ignoring stale VBoxSVC pid file (pid=%s)' % (iPid,));
1159	return False;
1160
1161	# Loop thru our different ways of getting VBoxSVC to terminate.
1162	for aHow in [ [ base.sendUserSignal1, 5000, 'Dropping VBoxSVC a SIGUSR1 hint...'], \
1163	[ base.processInterrupt, 5000, 'Dropping VBoxSVC a SIGINT hint...'], \
1164	[ base.processTerminate, 7500, 'VBoxSVC is still around, killing it...'] ]:
1165	reporter.log(aHow[2]);
1166	if aHow[0](iPid) is True:
1167	msStart = base.timestampMilli();
1168	while base.timestampMilli() - msStart < 5000 \
1169	and base.processExists(iPid):
1170	time.sleep(0.2);
1171
1172	fRc = not base.processExists(iPid);
1173	if fRc is True:
1174	break;
1175	if fRc:
1176	reporter.log('Successfully killed VBoxSVC (pid=%s)' % (iPid,));
1177	else:
1178	reporter.log('Failed to kill VBoxSVC (pid=%s)' % (iPid,));
1179	return fRc;
1180
1181	def _stopVBoxSVC(self):
1182	"""
1183	Stops VBoxSVC. Try the polite way first.
1184	"""
1185
1186	if self.oVBoxSvcProcess:
1187	self.removeTask(self.oVBoxSvcProcess);
1188	self.oVBoxSvcProcess.enableCrashReporting(None, None); # Disables it.
1189
1190	fRc = False;
1191	if self.oVBoxSvcProcess is not None \
1192	and not self.fVBoxSvcInDebugger:
1193	# by process object.
1194	if self.oVBoxSvcProcess.isRunning():
1195	reporter.log('Dropping VBoxSVC a SIGUSR1 hint...');
1196	if not self.oVBoxSvcProcess.sendUserSignal1() \
1197	or not self.oVBoxSvcProcess.wait(5000):
1198	reporter.log('Dropping VBoxSVC a SIGINT hint...');
1199	if not self.oVBoxSvcProcess.interrupt() \
1200	or not self.oVBoxSvcProcess.wait(5000):
1201	reporter.log('VBoxSVC is still around, killing it...');
1202	self.oVBoxSvcProcess.terminate();
1203	self.oVBoxSvcProcess.wait(7500);
1204	else:
1205	reporter.log('VBoxSVC is no longer running...');
1206	if not self.oVBoxSvcProcess.isRunning():
1207	self.oVBoxSvcProcess = None;
1208	else:
1209	# by pid file.
1210	self._killVBoxSVCByPidFile('%s/VBoxSVC.pid' % (self.sScratchPath,));
1211	return fRc;
1212
1213	def _setupVBoxApi(self):
1214	"""
1215	Import and set up the vboxapi.
1216	The caller saves and restores sys.path.
1217	"""
1218
1219	# Setup vbox logging for self (the test driver).
1220	self.sSelfLogFile = '%s/VBoxTestDriver.log' % (self.sScratchPath,);
1221	try: os.remove(self.sSelfLogFile);
1222	except: pass;
1223	os.environ['VBOX_LOG'] = self.sLogSelfGroups;
1224	os.environ['VBOX_LOG_FLAGS'] = '%s append' % (self.sLogSelfFlags, );
1225	if self.sLogSelfDest:
1226	os.environ['VBOX_LOG_DEST'] = self.sLogSelfDest;
1227	else:
1228	os.environ['VBOX_LOG_DEST'] = 'file=%s' % (self.sSelfLogFile,);
1229	os.environ['VBOX_RELEASE_LOG_FLAGS'] = 'time append';
1230
1231	# Hack the sys.path + environment so the vboxapi can be found.
1232	sys.path.insert(0, self.oBuild.sInstallPath);
1233	if self.oBuild.sSdkPath is not None:
1234	sys.path.insert(0, os.path.join(self.oBuild.sSdkPath, 'installer'))
1235	sys.path.insert(1, os.path.join(self.oBuild.sSdkPath, 'bindings', 'xpcom', 'python'))
1236	os.environ['VBOX_PROGRAM_PATH'] = self.oBuild.sInstallPath;
1237	reporter.log("sys.path: %s" % (sys.path));
1238
1239	try:
1240	# pylint: disable=F0401
1241	from vboxapi import VirtualBoxManager
1242	if self.sHost == 'win':
1243	from pythoncom import com_error as NativeComExceptionClass # pylint: disable=E0611
1244	import winerror as NativeComErrorClass
1245	else:
1246	from xpcom import Exception as NativeComExceptionClass
1247	from xpcom import nsError as NativeComErrorClass
1248	# pylint: enable=F0401
1249	except:
1250	traceback.print_exc();
1251	return False;
1252
1253	__deployExceptionHacks__(NativeComExceptionClass)
1254	ComError.copyErrors(NativeComErrorClass);
1255
1256	# Create the manager.
1257	try:
1258	self.oVBoxMgr = VirtualBoxManager(None, None)
1259	except:
1260	self.oVBoxMgr = None;
1261	reporter.logXcpt('VirtualBoxManager exception');
1262	return False;
1263
1264	# Figure the API version.
1265	try:
1266	oVBox = self.oVBoxMgr.getVirtualBox();
1267	try:
1268	sVer = oVBox.version;
1269	except:
1270	reporter.logXcpt('Failed to get VirtualBox version, assuming 4.0.0');
1271	sVer = "4.0.0";
1272	if sVer.startswith("5.0") or (sVer.startswith("4.3.5") and len(sVer) == 6):
1273	self.fpApiVer = 5.0;
1274	elif sVer.startswith("4.3") or (sVer.startswith("4.2.5") and len(sVer) == 6):
1275	self.fpApiVer = 4.3;
1276	elif sVer.startswith("4.2."):
1277	self.fpApiVer = 4.2; ## @todo Fudge: Add (proper) 4.2 API support. Unmount medium etc?
1278	elif sVer.startswith("4.1.") or (sVer.startswith("4.0.5") and len(sVer) == 6):
1279	self.fpApiVer = 4.1;
1280	elif sVer.startswith("4.0."):
1281	self.fpApiVer = 4.0;
1282	elif sVer.startswith("3.2."):
1283	self.fpApiVer = 3.2;
1284	elif sVer.startswith("3.1."):
1285	self.fpApiVer = 3.1;
1286	elif sVer.startswith("3.0."):
1287	self.fpApiVer = 3.0;
1288	else:
1289	raise base.GenError('Unknown version "%s"' % (sVer,));
1290
1291	self._patchVBoxMgr();
1292
1293	from testdriver.vboxwrappers import VirtualBoxWrapper;
1294	self.oVBox = VirtualBoxWrapper(oVBox, self.oVBoxMgr, self.fpApiVer, self);
1295	vboxcon.goHackModuleClass.oVBoxMgr = self.oVBoxMgr; # VBoxConstantWrappingHack.
1296	vboxcon.fpApiVer = self.fpApiVer
1297	self.fImportedVBoxApi = True;
1298	reporter.log('Found version %s (%s)' % (self.fpApiVer, sVer));
1299	except:
1300	self.oVBoxMgr = None;
1301	self.oVBox = None;
1302	reporter.logXcpt("getVirtualBox exception");
1303	return False;
1304	return True;
1305
1306	def _patchVBoxMgr(self):
1307	"""
1308	Glosses over missing self.oVBoxMgr methods on older VBox versions.
1309	"""
1310
1311	def _xcptGetResult(oSelf, oXcpt = None):
1312	""" See vboxapi. """
1313	_ = oSelf;
1314	if oXcpt is None: oXcpt = sys.exc_info()[1];
1315	if sys.platform == 'win32':
1316	import winerror; # pylint: disable=F0401
1317	hrXcpt = oXcpt.hresult;
1318	if hrXcpt == winerror.DISP_E_EXCEPTION:
1319	hrXcpt = oXcpt.excepinfo[5];
1320	else:
1321	hrXcpt = oXcpt.error;
1322	return hrXcpt;
1323
1324	def _xcptIsDeadInterface(oSelf, oXcpt = None):
1325	""" See vboxapi. """
1326	return oSelf.xcptGetStatus(oXcpt) in [
1327	0x80004004, -2147467260, # NS_ERROR_ABORT
1328	0x800706be, -2147023170, # NS_ERROR_CALL_FAILED (RPC_S_CALL_FAILED)
1329	0x800706ba, -2147023174, # RPC_S_SERVER_UNAVAILABLE.
1330	0x800706be, -2147023170, # RPC_S_CALL_FAILED.
1331	0x800706bf, -2147023169, # RPC_S_CALL_FAILED_DNE.
1332	0x80010108, -2147417848, # RPC_E_DISCONNECTED.
1333	0x800706b5, -2147023179, # RPC_S_UNKNOWN_IF
1334	];
1335
1336	def _xcptIsOurXcptKind(oSelf, oXcpt = None):
1337	""" See vboxapi. """
1338	_ = oSelf;
1339	if oXcpt is None: oXcpt = sys.exc_info()[1];
1340	if sys.platform == 'win32':
1341	from pythoncom import com_error as NativeComExceptionClass # pylint: disable=F0401,E0611
1342	else:
1343	from xpcom import Exception as NativeComExceptionClass # pylint: disable=F0401
1344	return isinstance(oXcpt, NativeComExceptionClass);
1345
1346	def _xcptIsEqual(oSelf, oXcpt, hrStatus):
1347	""" See vboxapi. """
1348	hrXcpt = oSelf.xcptGetResult(oXcpt);
1349	return hrXcpt == hrStatus or hrXcpt == hrStatus - 0x100000000;
1350
1351	def _xcptToString(oSelf, oXcpt):
1352	""" See vboxapi. """
1353	_ = oSelf;
1354	if oXcpt is None: oXcpt = sys.exc_info()[1];
1355	return str(oXcpt);
1356
1357	# Add utilities found in newer vboxapi revision.
1358	if not hasattr(self.oVBoxMgr, 'xcptIsDeadInterface'):
1359	import types;
1360	self.oVBoxMgr.xcptGetResult = types.MethodType(_xcptGetResult, self.oVBoxMgr);
1361	self.oVBoxMgr.xcptIsDeadInterface = types.MethodType(_xcptIsDeadInterface, self.oVBoxMgr);
1362	self.oVBoxMgr.xcptIsOurXcptKind = types.MethodType(_xcptIsOurXcptKind, self.oVBoxMgr);
1363	self.oVBoxMgr.xcptIsEqual = types.MethodType(_xcptIsEqual, self.oVBoxMgr);
1364	self.oVBoxMgr.xcptToString = types.MethodType(_xcptToString, self.oVBoxMgr);
1365
1366
1367	def _teardownVBoxApi(self):
1368	"""
1369	Drop all VBox object references and shutdown com/xpcom.
1370	"""
1371	if not self.fImportedVBoxApi:
1372	return True;
1373
1374	self.aoRemoteSessions = [];
1375	self.aoVMs = [];
1376	self.oVBoxMgr = None;
1377	self.oVBox = None;
1378
1379	try:
1380	import gc
1381	gc.collect();
1382	except:
1383	reporter.logXcpt();
1384	self.fImportedVBoxApi = False;
1385
1386	if self.sHost == 'win':
1387	pass; ## TODO shutdown COM if possible/necessary?
1388	else:
1389	try:
1390	from xpcom import _xpcom as _xpcom; # pylint: disable=F0401
1391	hrc = _xpcom.NS_ShutdownXPCOM();
1392	cIfs = _xpcom._GetInterfaceCount(); # pylint: disable=W0212
1393	cObjs = _xpcom._GetGatewayCount(); # pylint: disable=W0212
1394	if cObjs == 0 and cIfs == 0:
1395	reporter.log('actionCleanupAfter: NS_ShutdownXPCOM -> %s, nothing left behind.' % (hrc, ));
1396	else:
1397	reporter.log('actionCleanupAfter: NS_ShutdownXPCOM -> %s, leaving %s objects and %s interfaces behind...' \
1398	% (hrc, cObjs, cIfs));
1399	if hasattr(_xpcom, '_DumpInterfaces'):
1400	try:
1401	_xpcom._DumpInterfaces(); # pylint: disable=W0212
1402	except:
1403	reporter.logXcpt('actionCleanupAfter: _DumpInterfaces failed');
1404	except:
1405	reporter.logXcpt();
1406
1407	try:
1408	gc.collect();
1409	time.sleep(0.5); # fudge factory
1410	except:
1411	reporter.logXcpt();
1412	return True;
1413
1414	def _powerOffAllVms(self):
1415	"""
1416	Tries to power off all running VMs.
1417	"""
1418	for oSession in self.aoRemoteSessions:
1419	uPid = oSession.getPid();
1420	if uPid is not None:
1421	reporter.log('_powerOffAllVms: PID is %s for %s, trying to kill it.' % (uPid, oSession.sName,));
1422	base.processKill(uPid);
1423	else:
1424	reporter.log('_powerOffAllVms: No PID for %s' % (oSession.sName,));
1425	oSession.close();
1426	return None;
1427
1428
1429
1430	#
1431	# Build type, OS and arch getters.
1432	#
1433
1434	def getBuildType(self):
1435	"""
1436	Get the build type.
1437	"""
1438	if not self._detectBuild():
1439	return 'release';
1440	return self.oBuild.sType;
1441
1442	def getBuildOs(self):
1443	"""
1444	Get the build OS.
1445	"""
1446	if not self._detectBuild():
1447	return self.sHost;
1448	return self.oBuild.sOs;
1449
1450	def getBuildArch(self):
1451	"""
1452	Get the build arch.
1453	"""
1454	if not self._detectBuild():
1455	return self.sHostArch;
1456	return self.oBuild.sArch;
1457
1458	def getGuestAdditionsIso(self):
1459	"""
1460	Get the path to the guest addition iso.
1461	"""
1462	if not self._detectBuild():
1463	return None;
1464	return self.oBuild.sGuestAdditionsIso;
1465
1466	#
1467	# Override everything from the base class so the testdrivers don't have to
1468	# check whether we have overridden a method or not.
1469	#
1470
1471	def showUsage(self):
1472	rc = base.TestDriver.showUsage(self);
1473	reporter.log('');
1474	reporter.log('Generic VirtualBox Options:');
1475	reporter.log(' --vbox-session-type <type>');
1476	reporter.log(' Sets the session type. Typical values are: gui, headless, sdl');
1477	reporter.log(' Default: %s' % (self.sSessionTypeDef));
1478	reporter.log(' --vrdp, --no-vrdp');
1479	reporter.log(' Enables VRDP, ports starting at 6000');
1480	reporter.log(' Default: --vrdp');
1481	reporter.log(' --vrdp-base-port <port>');
1482	reporter.log(' Sets the base for VRDP port assignments.');
1483	reporter.log(' Default: %s' % (self.uVrdpBasePortDef));
1484	reporter.log(' --vbox-default-bridged-nic <interface>');
1485	reporter.log(' Sets the default interface for bridged networking.');
1486	reporter.log(' Default: autodetect');
1487	reporter.log(' --vbox-use-svc-defaults');
1488	reporter.log(' Use default locations and files for VBoxSVC. This is useful');
1489	reporter.log(' for automatically configuring the test VMs for debugging.');
1490	reporter.log(' --vbox-self-log');
1491	reporter.log(' The VBox logger group settings for the testdriver.');
1492	reporter.log(' --vbox-self-log-flags');
1493	reporter.log(' The VBox logger flags settings for the testdriver.');
1494	reporter.log(' --vbox-self-log-dest');
1495	reporter.log(' The VBox logger destination settings for the testdriver.');
1496	reporter.log(' --vbox-session-log');
1497	reporter.log(' The VM session logger group settings.');
1498	reporter.log(' --vbox-session-log-flags');
1499	reporter.log(' The VM session logger flags.');
1500	reporter.log(' --vbox-session-log-dest');
1501	reporter.log(' The VM session logger destination settings.');
1502	reporter.log(' --vbox-svc-log');
1503	reporter.log(' The VBoxSVC logger group settings.');
1504	reporter.log(' --vbox-svc-log-flags');
1505	reporter.log(' The VBoxSVC logger flag settings.');
1506	reporter.log(' --vbox-svc-log-dest');
1507	reporter.log(' The VBoxSVC logger destination settings.');
1508	reporter.log(' --vbox-log');
1509	reporter.log(' The VBox logger group settings for everyone.');
1510	reporter.log(' --vbox-log-flags');
1511	reporter.log(' The VBox logger flags settings for everyone.');
1512	reporter.log(' --vbox-log-dest');
1513	reporter.log(' The VBox logger destination settings for everyone.');
1514	reporter.log(' --vbox-svc-debug');
1515	reporter.log(' Start VBoxSVC in a debugger');
1516	reporter.log(' --vbox-always-upload-logs');
1517	reporter.log(' Whether to always upload log files, or only do so on failure.');
1518	reporter.log(' --vbox-always-upload-screenshots');
1519	reporter.log(' Whether to always upload final screen shots, or only do so on failure.');
1520	if self.oTestVmSet is not None:
1521	self.oTestVmSet.showUsage();
1522	return rc;
1523
1524	def parseOption(self, asArgs, iArg): # pylint: disable=R0915
1525	if asArgs[iArg] == '--vbox-session-type':
1526	iArg += 1;
1527	if iArg >= len(asArgs):
1528	raise base.InvalidOption('The "--vbox-session-type" takes an argument');
1529	self.sSessionType = asArgs[iArg];
1530	elif asArgs[iArg] == '--vrdp':
1531	self.fEnableVrdp = True;
1532	elif asArgs[iArg] == '--no-vrdp':
1533	self.fEnableVrdp = False;
1534	elif asArgs[iArg] == '--vrdp-base-port':
1535	iArg += 1;
1536	if iArg >= len(asArgs):
1537	raise base.InvalidOption('The "--vrdp-base-port" takes an argument');
1538	try: self.uVrdpBasePort = int(asArgs[iArg]);
1539	except: raise base.InvalidOption('The "--vrdp-base-port" value "%s" is not a valid integer', asArgs[iArg]);
1540	if self.uVrdpBasePort <= 0 or self.uVrdpBasePort >= 65530:
1541	raise base.InvalidOption('The "--vrdp-base-port" value "%s" is not in the valid range (1..65530)', asArgs[iArg]);
1542	elif asArgs[iArg] == '--vbox-default-bridged-nic':
1543	iArg += 1;
1544	if iArg >= len(asArgs):
1545	raise base.InvalidOption('The "--vbox-default-bridged-nic" takes an argument');
1546	self.sDefBridgedNic = asArgs[iArg];
1547	elif asArgs[iArg] == '--vbox-use-svc-defaults':
1548	self.fUseDefaultSvc = True;
1549	elif asArgs[iArg] == '--vbox-self-log':
1550	iArg += 1;
1551	if iArg >= len(asArgs):
1552	raise base.InvalidOption('The "--vbox-self-log" takes an argument');
1553	self.sLogSelfGroups = asArgs[iArg];
1554	elif asArgs[iArg] == '--vbox-self-log-flags':
1555	iArg += 1;
1556	if iArg >= len(asArgs):
1557	raise base.InvalidOption('The "--vbox-self-log-flags" takes an argument');
1558	self.sLogSelfFlags = asArgs[iArg];
1559	elif asArgs[iArg] == '--vbox-self-log-dest':
1560	iArg += 1;
1561	if iArg >= len(asArgs):
1562	raise base.InvalidOption('The "--vbox-self-log-dest" takes an argument');
1563	self.sLogSelfDest = asArgs[iArg];
1564	elif asArgs[iArg] == '--vbox-session-log':
1565	iArg += 1;
1566	if iArg >= len(asArgs):
1567	raise base.InvalidOption('The "--vbox-session-log" takes an argument');
1568	self.sLogSessionGroups = asArgs[iArg];
1569	elif asArgs[iArg] == '--vbox-session-log-flags':
1570	iArg += 1;
1571	if iArg >= len(asArgs):
1572	raise base.InvalidOption('The "--vbox-session-log-flags" takes an argument');
1573	self.sLogSessionFlags = asArgs[iArg];
1574	elif asArgs[iArg] == '--vbox-session-log-dest':
1575	iArg += 1;
1576	if iArg >= len(asArgs):
1577	raise base.InvalidOption('The "--vbox-session-log-dest" takes an argument');
1578	self.sLogSessionDest = asArgs[iArg];
1579	elif asArgs[iArg] == '--vbox-svc-log':
1580	iArg += 1;
1581	if iArg >= len(asArgs):
1582	raise base.InvalidOption('The "--vbox-svc-log" takes an argument');
1583	self.sLogSvcGroups = asArgs[iArg];
1584	elif asArgs[iArg] == '--vbox-svc-log-flags':
1585	iArg += 1;
1586	if iArg >= len(asArgs):
1587	raise base.InvalidOption('The "--vbox-svc-log-flags" takes an argument');
1588	self.sLogSvcFlags = asArgs[iArg];
1589	elif asArgs[iArg] == '--vbox-svc-log-dest':
1590	iArg += 1;
1591	if iArg >= len(asArgs):
1592	raise base.InvalidOption('The "--vbox-svc-log-dest" takes an argument');
1593	self.sLogSvcDest = asArgs[iArg];
1594	elif asArgs[iArg] == '--vbox-log':
1595	iArg += 1;
1596	if iArg >= len(asArgs):
1597	raise base.InvalidOption('The "--vbox-log" takes an argument');
1598	self.sLogSelfGroups = asArgs[iArg];
1599	self.sLogSessionGroups = asArgs[iArg];
1600	self.sLogSvcGroups = asArgs[iArg];
1601	elif asArgs[iArg] == '--vbox-log-flags':
1602	iArg += 1;
1603	if iArg >= len(asArgs):
1604	raise base.InvalidOption('The "--vbox-svc-flags" takes an argument');
1605	self.sLogSelfFlags = asArgs[iArg];
1606	self.sLogSessionFlags = asArgs[iArg];
1607	self.sLogSvcFlags = asArgs[iArg];
1608	elif asArgs[iArg] == '--vbox-log-dest':
1609	iArg += 1;
1610	if iArg >= len(asArgs):
1611	raise base.InvalidOption('The "--vbox-log-dest" takes an argument');
1612	self.sLogSelfDest = asArgs[iArg];
1613	self.sLogSessionDest = asArgs[iArg];
1614	self.sLogSvcDest = asArgs[iArg];
1615	elif asArgs[iArg] == '--vbox-svc-debug':
1616	self.fVBoxSvcInDebugger = True;
1617	elif asArgs[iArg] == '--vbox-always-upload-logs':
1618	self.fAlwaysUploadLogs = True;
1619	elif asArgs[iArg] == '--vbox-always-upload-screenshots':
1620	self.fAlwaysUploadScreenshots = True;
1621	else:
1622	# Relevant for selecting VMs to test?
1623	if self.oTestVmSet is not None:
1624	iRc = self.oTestVmSet.parseOption(asArgs, iArg);
1625	if iRc != iArg:
1626	return iRc;
1627
1628	# Hand it to the base class.
1629	return base.TestDriver.parseOption(self, asArgs, iArg);
1630	return iArg + 1;
1631
1632	def completeOptions(self):
1633	return base.TestDriver.completeOptions(self);
1634
1635	def getResourceSet(self):
1636	if self.oTestVmSet is not None:
1637	return self.oTestVmSet.getResourceSet();
1638	return base.TestDriver.getResourceSet(self);
1639
1640	def actionExtract(self):
1641	return base.TestDriver.actionExtract(self);
1642
1643	def actionVerify(self):
1644	return base.TestDriver.actionVerify(self);
1645
1646	def actionConfig(self):
1647	return base.TestDriver.actionConfig(self);
1648
1649	def actionExecute(self):
1650	return base.TestDriver.actionExecute(self);
1651
1652	def actionCleanupBefore(self):
1653	"""
1654	Kill any VBoxSVC left behind by a previous test run.
1655	"""
1656	self._killVBoxSVCByPidFile('%s/VBoxSVC.pid' % (self.sScratchPath,));
1657	return base.TestDriver.actionCleanupBefore(self);
1658
1659	def actionCleanupAfter(self):
1660	"""
1661	Clean up the VBox bits and then call the base driver.
1662
1663	If your test driver overrides this, it should normally call us at the
1664	end of the job.
1665	"""
1666
1667	# Kill any left over VM processes.
1668	self._powerOffAllVms();
1669
1670	# Drop all VBox object references and shutdown xpcom then
1671	# terminating VBoxSVC, with extreme prejudice if need be.
1672	self._teardownVBoxApi();
1673	self._stopVBoxSVC();
1674
1675	# Add the VBoxSVC and testdriver debug+release log files.
1676	if self.fAlwaysUploadLogs or reporter.getErrorCount() > 0:
1677	if self.sVBoxSvcLogFile is not None and os.path.isfile(self.sVBoxSvcLogFile):
1678	reporter.addLogFile(self.sVBoxSvcLogFile, 'log/debug/svc', 'Debug log file for VBoxSVC');
1679	self.sVBoxSvcLogFile = None;
1680
1681	if self.sSelfLogFile is not None and os.path.isfile(self.sSelfLogFile):
1682	reporter.addLogFile(self.sSelfLogFile, 'log/debug/client', 'Debug log file for the test driver');
1683	self.sSelfLogFile = None;
1684
1685	sVBoxSvcRelLog = os.path.join(self.sScratchPath, 'VBoxUserHome', 'VBoxSVC.log');
1686	if os.path.isfile(sVBoxSvcRelLog):
1687	reporter.addLogFile(sVBoxSvcRelLog, 'log/release/svc', 'Release log file for VBoxSVC');
1688	for sSuff in [ '.1', '.2', '.3', '.4', '.5', '.6', '.7', '.8' ]:
1689	if os.path.isfile(sVBoxSvcRelLog + sSuff):
1690	reporter.addLogFile(sVBoxSvcRelLog + sSuff, 'log/release/svc', 'Release log file for VBoxSVC');
1691	# Testbox debugging - START - TEMPORARY, REMOVE ASAP.
1692	if self.sHost in ('darwin', 'freebsd', 'linux', 'solaris', ):
1693	try:
1694	print '> ls -la %s' % (os.path.join(self.sScratchPath, 'VBoxUserHome'),);
1695	utils.processCall(['ls', '-la', os.path.join(self.sScratchPath, 'VBoxUserHome')]);
1696	print '> ls -la %s' % (self.sScratchPath,);
1697	utils.processCall(['ls', '-la', self.sScratchPath]);
1698	except: pass;
1699	# Testbox debugging - END - TEMPORARY, REMOVE ASAP.
1700
1701	# Finally, call the base driver to wipe the scratch space.
1702	return base.TestDriver.actionCleanupAfter(self);
1703
1704	def actionAbort(self):
1705	"""
1706	Terminate VBoxSVC if we've got a pid file.
1707	"""
1708	self._killVBoxSVCByPidFile('%s/VBoxSVC.pid' % (self.sScratchPath,));
1709	return base.TestDriver.actionAbort(self);
1710
1711	def onExit(self, iRc):
1712	"""
1713	Stop VBoxSVC if we've started it.
1714	"""
1715	if self.oVBoxSvcProcess is not None:
1716	reporter.log('*** Shutting down the VBox API... (iRc=%s)' % (iRc,));
1717	self._powerOffAllVms();
1718	self._teardownVBoxApi();
1719	self._stopVBoxSVC();
1720	reporter.log('*** VBox API shutdown done.');
1721	return base.TestDriver.onExit(self, iRc);
1722
1723
1724	#
1725	# Task wait method override.
1726	#
1727
1728	def notifyAboutReadyTask(self, oTask):
1729	"""
1730	Overriding base.TestDriver.notifyAboutReadyTask.
1731	"""
1732	try:
1733	self.oVBoxMgr.interruptWaitEvents();
1734	reporter.log2('vbox.notifyAboutReadyTask: called interruptWaitEvents');
1735	except:
1736	reporter.logXcpt('vbox.notifyAboutReadyTask');
1737	return base.TestDriver.notifyAboutReadyTask(self, oTask);
1738
1739	def waitForTasksSleepWorker(self, cMsTimeout):
1740	"""
1741	Overriding base.TestDriver.waitForTasksSleepWorker.
1742	"""
1743	try:
1744	rc = self.oVBoxMgr.waitForEvents(int(cMsTimeout));
1745	_ = rc; #reporter.log2('vbox.waitForTasksSleepWorker(%u): true (waitForEvents -> %s)' % (cMsTimeout, rc));
1746	return True;
1747	except KeyboardInterrupt:
1748	raise;
1749	except:
1750	reporter.logXcpt('vbox.waitForTasksSleepWorker');
1751	return False;
1752
1753	#
1754	# Utility methods.
1755	#
1756
1757	def processEvents(self, cMsTimeout = 0):
1758	"""
1759	Processes events, returning after the first batch has been processed
1760	or the time limit has been reached.
1761
1762	Only Ctrl-C exception, no return.
1763	"""
1764	try:
1765	self.oVBoxMgr.waitForEvents(cMsTimeout);
1766	except KeyboardInterrupt:
1767	raise;
1768	except:
1769	pass;
1770	return None;
1771
1772	def processPendingEvents(self):
1773	""" processEvents(0) - no waiting. """
1774	return self.processEvents(0);
1775
1776	def sleep(self, cSecs):
1777	"""
1778	Sleep for a specified amount of time, processing XPCOM events all the while.
1779	"""
1780	cMsTimeout = long(cSecs * 1000);
1781	msStart = base.timestampMilli();
1782	self.processEvents(0);
1783	while True:
1784	cMsElapsed = base.timestampMilli() - msStart;
1785	if cMsElapsed > cMsTimeout:
1786	break;
1787	#reporter.log2('cMsTimeout=%s - cMsElapsed=%d => %s' % (cMsTimeout, cMsElapsed, cMsTimeout - cMsElapsed));
1788	self.processEvents(cMsTimeout - cMsElapsed);
1789	return None;
1790
1791	def _logVmInfoUnsafe(self, oVM): # pylint: disable=R0915,R0912
1792	"""
1793	Internal worker for logVmInfo that is wrapped in try/except.
1794
1795	This is copy, paste, search, replace and edit of infoCmd from vboxshell.py.
1796	"""
1797	oOsType = self.oVBox.getGuestOSType(oVM.OSTypeId)
1798	reporter.log(" Name: %s" % (oVM.name));
1799	reporter.log(" ID: %s" % (oVM.id));
1800	reporter.log(" OS Type: %s - %s" % (oVM.OSTypeId, oOsType.description));
1801	reporter.log(" Machine state: %s" % (oVM.state));
1802	reporter.log(" Session state: %s" % (oVM.sessionState));
1803	if self.fpApiVer >= 4.2:
1804	reporter.log(" Session PID: %u (%#x)" % (oVM.sessionPID, oVM.sessionPID));
1805	else:
1806	reporter.log(" Session PID: %u (%#x)" % (oVM.sessionPid, oVM.sessionPid));
1807	if self.fpApiVer >= 5.0:
1808	reporter.log(" Session Name: %s" % (oVM.sessionName));
1809	else:
1810	reporter.log(" Session Name: %s" % (oVM.sessionType));
1811	reporter.log(" CPUs: %s" % (oVM.CPUCount));
1812	reporter.log(" RAM: %sMB" % (oVM.memorySize));
1813	reporter.log(" VRAM: %sMB" % (oVM.VRAMSize));
1814	reporter.log(" Monitors: %s" % (oVM.monitorCount));
1815	reporter.log(" Firmware: %s" % (oVM.firmwareType));
1816	reporter.log(" HwVirtEx: %s" % (oVM.getHWVirtExProperty(vboxcon.HWVirtExPropertyType_Enabled)));
1817	reporter.log(" VPID support: %s" % (oVM.getHWVirtExProperty(vboxcon.HWVirtExPropertyType_VPID)));
1818	reporter.log(" Nested paging: %s" % (oVM.getHWVirtExProperty(vboxcon.HWVirtExPropertyType_NestedPaging)));
1819	if self.fpApiVer >= 4.2 and hasattr(vboxcon, 'CPUPropertyType_LongMode'):
1820	reporter.log(" Long-mode: %s" % (oVM.getCPUProperty(vboxcon.CPUPropertyType_LongMode)));
1821	if self.fpApiVer >= 3.2:
1822	reporter.log(" PAE: %s" % (oVM.getCPUProperty(vboxcon.CPUPropertyType_PAE)));
1823	if self.fpApiVer < 5.0:
1824	reporter.log(" Synthetic CPU: %s" % (oVM.getCPUProperty(vboxcon.CPUPropertyType_Synthetic)));
1825	else:
1826	reporter.log(" PAE: %s" % (oVM.getCpuProperty(vboxcon.CpuPropertyType_PAE)));
1827	reporter.log(" Synthetic CPU: %s" % (oVM.getCpuProperty(vboxcon.CpuPropertyType_Synthetic)));
1828	reporter.log(" ACPI: %s" % (oVM.BIOSSettings.ACPIEnabled));
1829	reporter.log(" IO-APIC: %s" % (oVM.BIOSSettings.IOAPICEnabled));
1830	if self.fpApiVer >= 3.2:
1831	if self.fpApiVer >= 4.2:
1832	reporter.log(" HPET: %s" % (oVM.HPETEnabled));
1833	else:
1834	reporter.log(" HPET: %s" % (oVM.hpetEnabled));
1835	reporter.log(" 3D acceleration: %s" % (oVM.accelerate3DEnabled));
1836	reporter.log(" 2D acceleration: %s" % (oVM.accelerate2DVideoEnabled));
1837	reporter.log(" TeleporterEnabled: %s" % (oVM.teleporterEnabled));
1838	reporter.log(" TeleporterPort: %s" % (oVM.teleporterPort));
1839	reporter.log(" TeleporterAddress: %s" % (oVM.teleporterAddress));
1840	reporter.log(" TeleporterPassword: %s" % (oVM.teleporterPassword));
1841	reporter.log(" Clipboard mode: %s" % (oVM.clipboardMode));
1842	if self.fpApiVer >= 4.0:
1843	reporter.log(" VRDP server: %s" % (oVM.VRDEServer.enabled));
1844	try: sPorts = oVM.VRDEServer.getVRDEProperty("TCP/Ports");
1845	except: sPorts = "";
1846	reporter.log(" VRDP server ports: %s" % (sPorts));
1847	reporter.log(" VRDP auth: %s (%s)" % (oVM.VRDEServer.authType, oVM.VRDEServer.authLibrary));
1848	else:
1849	reporter.log(" VRDP server: %s" % (oVM.VRDPServer.enabled));
1850	reporter.log(" VRDP server ports: %s" % (oVM.VRDPServer.ports));
1851	reporter.log(" Last changed: %s" % (oVM.lastStateChange));
1852
1853	aoControllers = self.oVBoxMgr.getArray(oVM, 'storageControllers')
1854	if aoControllers:
1855	reporter.log(" Controllers:");
1856	for oCtrl in aoControllers:
1857	reporter.log(" %s %s bus: %s type: %s" % (oCtrl.name, oCtrl.controllerType, oCtrl.bus, oCtrl.controllerType));
1858
1859	self.processPendingEvents();
1860	aoAttachments = self.oVBoxMgr.getArray(oVM, 'mediumAttachments')
1861	if aoAttachments:
1862	reporter.log(" Attachments:");
1863	for oAtt in aoAttachments:
1864	sCtrl = "Controller: %s port: %s device: %s type: %s" % (oAtt.controller, oAtt.port, oAtt.device, oAtt.type);
1865	oMedium = oAtt.medium
1866	if oAtt.type == vboxcon.DeviceType_HardDisk:
1867	reporter.log(" %s: HDD" % sCtrl);
1868	reporter.log(" Id: %s" % (oMedium.id));
1869	reporter.log(" Name: %s" % (oMedium.name));
1870	reporter.log(" Format: %s" % (oMedium.format));
1871	reporter.log(" Location: %s" % (oMedium.location));
1872
1873	if oAtt.type == vboxcon.DeviceType_DVD:
1874	reporter.log(" %s: DVD" % sCtrl);
1875	if oMedium:
1876	reporter.log(" Id: %s" % (oMedium.id));
1877	reporter.log(" Name: %s" % (oMedium.name));
1878	if oMedium.hostDrive:
1879	reporter.log(" Host DVD %s" % (oMedium.location));
1880	if oAtt.passthrough:
1881	reporter.log(" [passthrough mode]");
1882	else:
1883	reporter.log(" Virtual image: %s" % (oMedium.location));
1884	reporter.log(" Size: %s" % (oMedium.size));
1885	else:
1886	reporter.log(" empty");
1887
1888	if oAtt.type == vboxcon.DeviceType_Floppy:
1889	reporter.log(" %s: Floppy" % sCtrl);
1890	if oMedium:
1891	reporter.log(" Id: %s" % (oMedium.id));
1892	reporter.log(" Name: %s" % (oMedium.name));
1893	if oMedium.hostDrive:
1894	reporter.log(" Host floppy: %s" % (oMedium.location));
1895	else:
1896	reporter.log(" Virtual image: %s" % (oMedium.location));
1897	reporter.log(" Size: %s" % (oMedium.size));
1898	else:
1899	reporter.log(" empty");
1900	self.processPendingEvents();
1901
1902	reporter.log(" Network Adapter:");
1903	for iSlot in range(0, 32):
1904	try: oNic = oVM.getNetworkAdapter(iSlot)
1905	except: break;
1906	if not oNic.enabled:
1907	reporter.log2(" slot #%d found but not enabled, skipping" % (iSlot,));
1908	continue;
1909	if oNic.adapterType == vboxcon.NetworkAdapterType_Am79C973: sType = "PCNet";
1910	elif oNic.adapterType == vboxcon.NetworkAdapterType_Am79C970A: sType = "PCNetOld";
1911	elif oNic.adapterType == vboxcon.NetworkAdapterType_I82545EM: sType = "E1000";
1912	elif oNic.adapterType == vboxcon.NetworkAdapterType_I82540EM: sType = "E1000Desk";
1913	elif oNic.adapterType == vboxcon.NetworkAdapterType_I82543GC: sType = "E1000Srv2";
1914	elif oNic.adapterType == vboxcon.NetworkAdapterType_Virtio: sType = "Virtio";
1915	else: sType = "unknown %s" % (oNic.adapterType);
1916	reporter.log(" slot #%d: type: %s (%s) MAC Address: %s lineSpeed: %s" % \
1917	(iSlot, sType, oNic.adapterType, oNic.MACAddress, oNic.lineSpeed) );
1918
1919	if oNic.attachmentType == vboxcon.NetworkAttachmentType_NAT:
1920	reporter.log(" attachmentType: NAT (%s)" % (oNic.attachmentType));
1921	if self.fpApiVer >= 4.1:
1922	reporter.log(" nat-network: %s" % (oNic.NATNetwork,));
1923	elif oNic.attachmentType == vboxcon.NetworkAttachmentType_Bridged:
1924	reporter.log(" attachmentType: Bridged (%s)" % (oNic.attachmentType));
1925	if self.fpApiVer >= 4.1:
1926	reporter.log(" hostInterface: %s" % (oNic.bridgedInterface));
1927	else:
1928	reporter.log(" hostInterface: %s" % (oNic.hostInterface));
1929	elif oNic.attachmentType == vboxcon.NetworkAttachmentType_Internal:
1930	reporter.log(" attachmentType: Internal (%s)" % (oNic.attachmentType));
1931	reporter.log(" intnet-name: %s" % (oNic.internalNetwork,));
1932	elif oNic.attachmentType == vboxcon.NetworkAttachmentType_HostOnly:
1933	reporter.log(" attachmentType: HostOnly (%s)" % (oNic.attachmentType));
1934	if self.fpApiVer >= 4.1:
1935	reporter.log(" hostInterface: %s" % (oNic.hostOnlyInterface));
1936	else:
1937	reporter.log(" hostInterface: %s" % (oNic.hostInterface));
1938	else:
1939	if self.fpApiVer >= 4.1:
1940	if oNic.attachmentType == vboxcon.NetworkAttachmentType_Generic:
1941	reporter.log(" attachmentType: Generic (%s)" % (oNic.attachmentType));
1942	reporter.log(" generic-driver: %s" % (oNic.GenericDriver));
1943	else:
1944	reporter.log(" attachmentType: unknown-%s" % (oNic.attachmentType));
1945	else:
1946	reporter.log(" attachmentType: unknown-%s" % (oNic.attachmentType));
1947	if oNic.traceEnabled:
1948	reporter.log(" traceFile: %s" % (oNic.traceFile));
1949	self.processPendingEvents();
1950	return True;
1951
1952	def logVmInfo(self, oVM): # pylint: disable=R0915,R0912
1953	"""
1954	Logs VM configuration details.
1955
1956	This is copy, past, search, replace and edit of infoCmd from vboxshell.py.
1957	"""
1958	try:
1959	fRc = self._logVmInfoUnsafe(oVM);
1960	except:
1961	reporter.logXcpt();
1962	fRc = False;
1963	return fRc;
1964
1965	def logVmInfoByName(self, sName):
1966	"""
1967	logVmInfo + getVmByName.
1968	"""
1969	return self.logVmInfo(self.getVmByName(sName));
1970
1971	def tryFindGuestOsId(self, sIdOrDesc):
1972	"""
1973	Takes a guest OS ID or Description and returns the ID.
1974	If nothing matching it is found, the input is returned unmodified.
1975	"""
1976
1977	if self.fpApiVer >= 4.0:
1978	if sIdOrDesc == 'Solaris (64 bit)':
1979	sIdOrDesc = 'Oracle Solaris 10 5/09 and earlier (64 bit)';
1980
1981	try:
1982	aoGuestTypes = self.oVBoxMgr.getArray(self.oVBox, 'GuestOSTypes');
1983	except:
1984	reporter.logXcpt();
1985	else:
1986	for oGuestOS in aoGuestTypes:
1987	try:
1988	sId = oGuestOS.id;
1989	sDesc = oGuestOS.description;
1990	except:
1991	reporter.logXcpt();
1992	else:
1993	if sIdOrDesc == sId or sIdOrDesc == sDesc:
1994	sIdOrDesc = sId;
1995	break;
1996	self.processPendingEvents();
1997	return sIdOrDesc
1998
1999	def resourceFindVmHd(self, sVmName, sFlavor):
2000	"""
2001	Search the test resources for the most recent VM HD.
2002
2003	Returns path relative to the test resource root.
2004	"""
2005	## @todo implement a proper search algo here.
2006	return '4.2/' + sFlavor + '/' + sVmName + '/t-' + sVmName + '.vdi';
2007
2008
2009	#
2010	# VM Api wrappers that logs errors, hides exceptions and other details.
2011	#
2012
2013	# pylint: disable=R0913,R0914,R0915
2014	def createTestVM(self, sName, iGroup, sHd = None, cMbRam = None, cCpus = 1, fVirtEx = None, fNestedPaging = None, \
2015	sDvdImage = None, sKind = "Other", fIoApic = None, fPae = None, fFastBootLogo = True, \
2016	eNic0Type = None, eNic0AttachType = None, sNic0NetName = 'default', sNic0MacAddr = 'grouped', \
2017	sFloppy = None, fNatForwardingForTxs = None, sHddControllerType = 'IDE Controller', \
2018	fVmmDevTestingPart = None, fVmmDevTestingMmio = False):
2019	"""
2020	Creates a test VM with a immutable HD from the test resources.
2021	"""
2022	if not self.importVBoxApi():
2023	return None;
2024
2025	# create + register the VM
2026	try:
2027	if self.fpApiVer >= 4.2: # Introduces grouping (third parameter, empty for now).
2028	oVM = self.oVBox.createMachine("", sName, [], self.tryFindGuestOsId(sKind), "");
2029	elif self.fpApiVer >= 4.0:
2030	oVM = self.oVBox.createMachine("", sName, self.tryFindGuestOsId(sKind), "", False);
2031	elif self.fpApiVer >= 3.2:
2032	oVM = self.oVBox.createMachine(sName, self.tryFindGuestOsId(sKind), "", "", False);
2033	else:
2034	oVM = self.oVBox.createMachine(sName, self.tryFindGuestOsId(sKind), "", "");
2035	try:
2036	oVM.saveSettings();
2037	try:
2038	self.oVBox.registerMachine(oVM);
2039	except:
2040	raise;
2041	except:
2042	reporter.logXcpt();
2043	if self.fpApiVer >= 4.0:
2044	try:
2045	if self.fpApiVer >= 4.3:
2046	oProgress = oVM.deleteConfig([]);
2047	else:
2048	oProgress = oVM.delete(None);
2049	self.waitOnProgress(oProgress);
2050	except:
2051	reporter.logXcpt();
2052	else:
2053	try: oVM.deleteSettings();
2054	except: reporter.logXcpt();
2055	raise;
2056	except:
2057	reporter.errorXcpt('failed to create vm "%s"' % (sName));
2058	return None;
2059
2060	# Configure the VM.
2061	fRc = True;
2062	oSession = self.openSession(oVM);
2063	if oSession is not None:
2064	fRc = oSession.setupPreferredConfig();
2065
2066	if fRc and cMbRam is not None :
2067	fRc = oSession.setRamSize(cMbRam);
2068	if fRc and cCpus is not None:
2069	fRc = oSession.setCpuCount(cCpus);
2070	if fRc and fVirtEx is not None:
2071	fRc = oSession.enableVirtEx(fVirtEx);
2072	if fRc and fNestedPaging is not None:
2073	fRc = oSession.enableNestedPaging(fNestedPaging);
2074	if fRc and fIoApic is not None:
2075	fRc = oSession.enableIoApic(fIoApic);
2076	if fRc and fPae is not None:
2077	fRc = oSession.enablePae(fPae);
2078	if fRc and sDvdImage is not None:
2079	fRc = oSession.attachDvd(sDvdImage);
2080	if fRc and sHd is not None:
2081	fRc = oSession.attachHd(sHd, sHddControllerType);
2082	if fRc and sFloppy is not None:
2083	fRc = oSession.attachFloppy(sFloppy);
2084	if fRc and eNic0Type is not None:
2085	fRc = oSession.setNicType(eNic0Type, 0);
2086	if fRc and (eNic0AttachType is not None or (sNic0NetName is not None and sNic0NetName != 'default')):
2087	fRc = oSession.setNicAttachment(eNic0AttachType, sNic0NetName, 0);
2088	if fRc and sNic0MacAddr is not None:
2089	if sNic0MacAddr == 'grouped':
2090	sNic0MacAddr = '%02u' % (iGroup);
2091	fRc = oSession.setNicMacAddress(sNic0MacAddr, 0);
2092	if fRc and fNatForwardingForTxs is True:
2093	fRc = oSession.setupNatForwardingForTxs();
2094	if fRc and fFastBootLogo is not None:
2095	fRc = oSession.setupBootLogo(fFastBootLogo);
2096	if fRc and self.fEnableVrdp:
2097	fRc = oSession.setupVrdp(True, self.uVrdpBasePort + iGroup);
2098	if fRc and fVmmDevTestingPart is not None:
2099	fRc = oSession.enableVmmDevTestingPart(fVmmDevTestingPart, fVmmDevTestingMmio);
2100
2101	if fRc: fRc = oSession.saveSettings();
2102	if not fRc: oSession.discardSettings(True);
2103	oSession.close();
2104	if not fRc:
2105	try: self.oVBox.unregisterMachine(oVM.id);
2106	except: pass;
2107	if self.fpApiVer >= 4.0:
2108	try:
2109	if self.fpApiVer >= 4.3:
2110	oProgress = oVM.deleteConfig([]);
2111	else:
2112	oProgress = oVM.delete(None);
2113	self.waitOnProgress(oProgress);
2114	except:
2115	reporter.logXcpt();
2116	else:
2117	try: oVM.deleteSettings();
2118	except: reporter.logXcpt();
2119	return None;
2120
2121	# success.
2122	reporter.log('created "%s" with name "%s"' % (oVM.id, sName));
2123	self.aoVMs.append(oVM);
2124	self.logVmInfo(oVM); # testing...
2125	return oVM;
2126	# pylint: enable=R0913,R0914,R0915
2127
2128	def addTestMachine(self, sNameOrId, fQuiet = False):
2129	"""
2130	Adds an already existing (that is, configured) test VM to the
2131	test VM list.
2132	"""
2133	# find + add the VM to the list.
2134	try:
2135	if self.fpApiVer >= 4.0:
2136	oVM = self.oVBox.findMachine(sNameOrId);
2137	else:
2138	reporter.error('Port me!'); ## @todo Add support for older version < 4.0.
2139	except:
2140	reporter.errorXcpt('could not find vm "%s"' % (sNameOrId,));
2141	return None;
2142
2143	self.aoVMs.append(oVM);
2144	if not fQuiet:
2145	reporter.log('Added "%s" with name "%s"' % (oVM.id, sNameOrId));
2146	self.logVmInfo(oVM);
2147	return oVM;
2148
2149	def openSession(self, oVM):
2150	"""
2151	Opens a session for the VM. Returns the a Session wrapper object that
2152	will automatically close the session when the wrapper goes out of scope.
2153
2154	On failure None is returned and an error is logged.
2155	"""
2156	try:
2157	sUuid = oVM.id;
2158	except:
2159	reporter.errorXcpt('failed to get the UUID for VM "%s"' % (oVM,));
2160	return None;
2161
2162	# This loop is a kludge to deal with us racing the closing of the
2163	# direct session of a previous VM run. See waitOnDirectSessionClose.
2164	for i in range(10):
2165	try:
2166	if self.fpApiVer <= 3.2:
2167	oSession = self.oVBoxMgr.openMachineSession(sUuid);
2168	else:
2169	oSession = self.oVBoxMgr.openMachineSession(oVM);
2170	break;
2171	except:
2172	if i == 9:
2173	reporter.errorXcpt('failed to open session for "%s" ("%s")' % (sUuid, oVM));
2174	return None;
2175	if i > 0:
2176	reporter.logXcpt('warning: failed to open session for "%s" ("%s") - retrying in %u secs' % (sUuid, oVM, i));
2177	self.waitOnDirectSessionClose(oVM, 5000 + i * 1000);
2178	from testdriver.vboxwrappers import SessionWrapper;
2179	return SessionWrapper(oSession, oVM, self.oVBox, self.oVBoxMgr, self, False);
2180
2181	def getVmByName(self, sName):
2182	"""
2183	Get a test VM by name. Returns None if not found, logged.
2184	"""
2185	# Look it up in our 'cache'.
2186	for oVM in self.aoVMs:
2187	try:
2188	#reporter.log2('cur: %s / %s (oVM=%s)' % (oVM.name, oVM.id, oVM));
2189	if oVM.name == sName:
2190	return oVM;
2191	except:
2192	reporter.errorXcpt('failed to get the name from the VM "%s"' % (oVM));
2193
2194	# Look it up the standard way.
2195	return self.addTestMachine(sName, fQuiet = True);
2196
2197	def getVmByUuid(self, sUuid):
2198	"""
2199	Get a test VM by uuid. Returns None if not found, logged.
2200	"""
2201	# Look it up in our 'cache'.
2202	for oVM in self.aoVMs:
2203	try:
2204	if oVM.id == sUuid:
2205	return oVM;
2206	except:
2207	reporter.errorXcpt('failed to get the UUID from the VM "%s"' % (oVM));
2208
2209	# Look it up the standard way.
2210	return self.addTestMachine(sUuid, fQuiet = True);
2211
2212	def waitOnProgress(self, oProgress, cMsTimeout = 1000000, fErrorOnTimeout = True, cMsInterval = 1000):
2213	"""
2214	Waits for a progress object to complete. Returns the status code.
2215	"""
2216	# Wait for progress no longer than cMsTimeout time period.
2217	tsStart = datetime.datetime.now()
2218	while True:
2219	self.processPendingEvents();
2220	try:
2221	if oProgress.completed:
2222	break;
2223	except:
2224	return -1;
2225	self.processPendingEvents();
2226
2227	tsNow = datetime.datetime.now()
2228	tsDelta = tsNow - tsStart
2229	if ((tsDelta.microseconds + tsDelta.seconds * 1000000) / 1000) > cMsTimeout:
2230	if fErrorOnTimeout:
2231	reporter.errorTimeout('Timeout while waiting for progress.')
2232	return -1
2233
2234	try: oProgress.waitForCompletion(cMsInterval);
2235	except: return -2;
2236
2237	try: rc = oProgress.resultCode;
2238	except: rc = -2;
2239	self.processPendingEvents();
2240	return rc;
2241
2242	def waitOnDirectSessionClose(self, oVM, cMsTimeout):
2243	"""
2244	Waits for the VM process to close it's current direct session.
2245
2246	Returns None.
2247	"""
2248	# Get the original values so we're not subject to
2249	try:
2250	eCurState = oVM.sessionState;
2251	if self.fpApiVer >= 5.0:
2252	sCurName = sOrgName = oVM.sessionName;
2253	else:
2254	sCurName = sOrgName = oVM.sessionType;
2255	if self.fpApiVer >= 4.2:
2256	iCurPid = iOrgPid = oVM.sessionPID;
2257	else:
2258	iCurPid = iOrgPid = oVM.sessionPid;
2259	except Exception, oXcpt:
2260	if ComError.notEqual(oXcpt, ComError.E_ACCESSDENIED):
2261	reporter.logXcpt();
2262	self.processPendingEvents();
2263	return None;
2264	self.processPendingEvents();
2265
2266	msStart = base.timestampMilli();
2267	while iCurPid == iOrgPid \
2268	and sCurName == sOrgName \
2269	and sCurName != '' \
2270	and base.timestampMilli() - msStart < cMsTimeout \
2271	and ( eCurState == vboxcon.SessionState_Unlocking \
2272	or eCurState == vboxcon.SessionState_Spawning \
2273	or eCurState == vboxcon.SessionState_Locked):
2274	self.processEvents(1000);
2275	try:
2276	eCurState = oVM.sessionState;
2277	sCurName = oVM.sessionName if self.fpApiVer >= 5.0 else oVM.sessionType;
2278	iCurPid = oVM.sessionPID if self.fpApiVer >= 4.2 else oVM.sessionPid;
2279	except Exception, oXcpt:
2280	if ComError.notEqual(oXcpt, ComError.E_ACCESSDENIED):
2281	reporter.logXcpt();
2282	break;
2283	self.processPendingEvents();
2284	self.processPendingEvents();
2285	return None;
2286
2287	def uploadStartupLogFile(self, oVM, sVmName):
2288	"""
2289	Uploads the VBoxStartup.log when present.
2290	"""
2291	fRc = True;
2292	try:
2293	sLogFile = os.path.join(oVM.logFolder, 'VBoxStartup.log');
2294	except:
2295	reporter.logXcpt();
2296	fRc = False;
2297	else:
2298	if os.path.isfile(sLogFile):
2299	reporter.addLogFile(sLogFile, 'log/release/vm', '%s startup log' % (sVmName, ),
2300	sAltName = '%s-%s' % (sVmName, os.path.basename(sLogFile),));
2301	return fRc;
2302
2303	def startVmEx(self, oVM, fWait = True, sType = None, sName = None, asEnv = None): # pylint: disable=R0914,R0915
2304	"""
2305	Start the VM, returning the VM session and progress object on success.
2306	The session is also added to the task list and to the aoRemoteSessions set.
2307
2308	asEnv is a list of string on the putenv() form.
2309
2310	On failure (None, None) is returned and an error is logged.
2311	"""
2312	# Massage and check the input.
2313	if sType is None:
2314	sType = self.sSessionType;
2315	if sName is None:
2316	try: sName = oVM.name;
2317	except: sName = 'bad-vm-handle';
2318	reporter.log2('startVmEx: sName=%s fWait=%s sType=%s' % (sName, fWait, sType));
2319	if oVM is None:
2320	return (None, None);
2321
2322	## @todo Do this elsewhere.
2323	# Hack alert. Disables all annoying GUI popups.
2324	if sType == 'gui' and len(self.aoRemoteSessions) == 0:
2325	try:
2326	self.oVBox.setExtraData('GUI/Input/AutoCapture', 'false');
2327	if self.fpApiVer >= 3.2:
2328	self.oVBox.setExtraData('GUI/LicenseAgreed', '8');
2329	else:
2330	self.oVBox.setExtraData('GUI/LicenseAgreed', '7');
2331	self.oVBox.setExtraData('GUI/RegistrationData', 'triesLeft=0');
2332	self.oVBox.setExtraData('GUI/SUNOnlineData', 'triesLeft=0');
2333	self.oVBox.setExtraData('GUI/SuppressMessages', 'confirmVMReset,remindAboutMouseIntegrationOn,'
2334	'remindAboutMouseIntegrationOff,remindAboutPausedVMInput,confirmInputCapture,'
2335	'confirmGoingFullscreen,remindAboutInaccessibleMedia,remindAboutWrongColorDepth,'
2336	'confirmRemoveMedium,allPopupPanes,allMessageBoxes,all');
2337	self.oVBox.setExtraData('GUI/UpdateDate', 'never');
2338	self.oVBox.setExtraData('GUI/PreventBetaWarning', self.oVBox.version);
2339	except:
2340	reporter.logXcpt();
2341
2342	# The UUID for the name.
2343	try:
2344	sUuid = oVM.id;
2345	except:
2346	reporter.errorXcpt('failed to get the UUID for VM "%s"' % (oVM));
2347	return (None, None);
2348	self.processPendingEvents();
2349
2350	# Construct the environment.
2351	sLogFile = '%s/VM-%s.log' % (self.sScratchPath, sUuid);
2352	try: os.remove(sLogFile);
2353	except: pass;
2354	if self.sLogSessionDest:
2355	sLogDest = self.sLogSessionDest;
2356	else:
2357	sLogDest = 'file=%s' % sLogFile;
2358	sEnv = 'VBOX_LOG=%s\nVBOX_LOG_FLAGS=%s\nVBOX_LOG_DEST=%s\nVBOX_RELEASE_LOG_FLAGS=append time' \
2359	% (self.sLogSessionGroups, self.sLogSessionFlags, sLogDest,);
2360	if sType == 'gui':
2361	sEnv += '\nVBOX_GUI_DBG_ENABLED=1'
2362	if asEnv is not None and len(asEnv) > 0:
2363	sEnv += '\n' + ('\n'.join(asEnv));
2364
2365	# Shortcuts for local testing.
2366	oProgress = oWrapped = None;
2367	oTestVM = self.oTestVmSet.findTestVmByName(sName) if self.oTestVmSet is not None else None;
2368	try:
2369	if oTestVM is not None \
2370	and oTestVM.fSnapshotRestoreCurrent is True:
2371	if oVM.state is vboxcon.MachineState_Running:
2372	reporter.log2('Machine "%s" already running.' % (sName,));
2373	oProgress = None;
2374	oWrapped = self.openSession(oVM);
2375	else:
2376	reporter.log2('Checking if snapshot for machine "%s" exists.' % (sName,));
2377	oSessionWrapperRestore = self.openSession(oVM);
2378	if oSessionWrapperRestore is not None:
2379	oSnapshotCur = oVM.currentSnapshot;
2380	if oSnapshotCur is not None:
2381	reporter.log2('Restoring snapshot for machine "%s".' % (sName,));
2382	oSessionWrapperRestore.restoreSnapshot(oSnapshotCur);
2383	reporter.log2('Current snapshot for machine "%s" restored.' % (sName,));
2384	else:
2385	reporter.log('warning: no current snapshot for machine "%s" found.' % (sName,));
2386	oSessionWrapperRestore.close();
2387	except:
2388	reporter.errorXcpt();
2389	return (None, None);
2390
2391	# Open a remote session, wait for this operation to complete.
2392	# (The loop is a kludge to deal with us racing the closing of the
2393	# direct session of a previous VM run. See waitOnDirectSessionClose.)
2394	if oWrapped is None:
2395	for i in range(10):
2396	try:
2397	if self.fpApiVer < 4.3 \
2398	or (self.fpApiVer == 4.3 and not hasattr(self.oVBoxMgr, 'getSessionObject')):
2399	oSession = self.oVBoxMgr.mgr.getSessionObject(self.oVBox); # pylint: disable=E1101
2400	else:
2401	oSession = self.oVBoxMgr.getSessionObject(self.oVBox); # pylint: disable=E1101
2402	if self.fpApiVer < 3.3:
2403	oProgress = self.oVBox.openRemoteSession(oSession, sUuid, sType, sEnv);
2404	else:
2405	oProgress = oVM.launchVMProcess(oSession, sType, sEnv);
2406	break;
2407	except:
2408	if i == 9:
2409	reporter.errorXcpt('failed to start VM "%s" ("%s"), aborting.' % (sUuid, sName));
2410	return (None, None);
2411	oSession = None;
2412	if i >= 0:
2413	reporter.logXcpt('warning: failed to start VM "%s" ("%s") - retrying in %u secs.' % (sUuid, oVM, i)); # pylint: disable=C0301
2414	self.waitOnDirectSessionClose(oVM, 5000 + i * 1000);
2415	if fWait and oProgress is not None:
2416	rc = self.waitOnProgress(oProgress);
2417	if rc < 0:
2418	self.waitOnDirectSessionClose(oVM, 5000);
2419	try:
2420	if oSession is not None:
2421	oSession.close();
2422	except: pass;
2423	reportError(oProgress, 'failed to open session for "%s"' % (sName));
2424	self.uploadStartupLogFile(oVM, sName);
2425	return (None, None);
2426	reporter.log2('waitOnProgress -> %s' % (rc,));
2427
2428	# Wrap up the session object and push on to the list before returning it.
2429	if oWrapped is None:
2430	from testdriver.vboxwrappers import SessionWrapper;
2431	oWrapped = SessionWrapper(oSession, oVM, self.oVBox, self.oVBoxMgr, self, True, sName, sLogFile);
2432
2433	oWrapped.registerEventHandlerForTask();
2434	self.aoRemoteSessions.append(oWrapped);
2435	if oWrapped is not self.aoRemoteSessions[len(self.aoRemoteSessions) - 1]:
2436	reporter.error('not by reference: oWrapped=%s aoRemoteSessions[%s]=%s'
2437	% (oWrapped, len(self.aoRemoteSessions) - 1,
2438	self.aoRemoteSessions[len(self.aoRemoteSessions) - 1]));
2439	self.addTask(oWrapped);
2440
2441	reporter.log2('startVmEx: oSession=%s, oSessionWrapper=%s, oProgress=%s' % (oSession, oWrapped, oProgress));
2442
2443	from testdriver.vboxwrappers import ProgressWrapper;
2444	return (oWrapped, ProgressWrapper(oProgress, self.oVBoxMgr, self,
2445	'starting %s' % (sName,)) if oProgress else None);
2446
2447	def startVm(self, oVM, sType=None, sName = None, asEnv = None):
2448	""" Simplified version of startVmEx. """
2449	oSession, _ = self.startVmEx(oVM, True, sType, sName, asEnv = asEnv);
2450	return oSession;
2451
2452	def startVmByNameEx(self, sName, fWait=True, sType=None, asEnv = None):
2453	"""
2454	Start the VM, returning the VM session and progress object on success.
2455	The session is also added to the task list and to the aoRemoteSessions set.
2456
2457	On failure (None, None) is returned and an error is logged.
2458	"""
2459	oVM = self.getVmByName(sName);
2460	if oVM is None:
2461	return (None, None);
2462	return self.startVmEx(oVM, fWait, sType, sName, asEnv = asEnv);
2463
2464	def startVmByName(self, sName, sType=None, asEnv = None):
2465	"""
2466	Start the VM, returning the VM session on success. The session is
2467	also added to the task list and to the aoRemoteSessions set.
2468
2469	On failure None is returned and an error is logged.
2470	"""
2471	oSession, _ = self.startVmByNameEx(sName, True, sType, asEnv = asEnv);
2472	return oSession;
2473
2474	def terminateVmBySession(self, oSession, oProgress = None, fTakeScreenshot = None):
2475	"""
2476	Terminates the VM specified by oSession and adds the release logs to
2477	the test report.
2478
2479	This will try archive this by using powerOff, but will resort to
2480	tougher methods if that fails.
2481
2482	The session will always be removed from the task list.
2483	The session will be closed unless we fail to kill the process.
2484	The session will be removed from the remote session list if closed.
2485
2486	The progress object (a wrapper!) is for teleportation and similar VM
2487	operations, it will be attempted canceled before powering off the VM.
2488	Failures are logged but ignored.
2489	The progress object will always be removed from the task list.
2490
2491	Returns True if powerOff and session close both succeed.
2492	Returns False if on failure (logged), including when we successfully
2493	kill the VM process.
2494	"""
2495	reporter.log2('terminateVmBySession: oSession=%s (pid=%s) oProgress=%s' % (oSession.sName, oSession.getPid(), oProgress));
2496
2497	# Call getPid first to make sure the PID is cached in the wrapper.
2498	oSession.getPid();
2499
2500	#
2501	# Take Screenshot and upload it (see below) to Test Manager if appropriate/requested.
2502	#
2503	sLastScreenshotPath = None
2504	if fTakeScreenshot is True or self.fAlwaysUploadScreenshots or reporter.testErrorCount() > 0:
2505	sLastScreenshotPath = os.path.join(self.sScratchPath, "LastScreenshot-%s.png" % oSession.sName)
2506	fRc = oSession.takeScreenshot(sLastScreenshotPath)
2507	if fRc is not True:
2508	sLastScreenshotPath = None
2509
2510	#
2511	# Terminate the VM
2512	#
2513
2514	# Cancel the progress object if specified.
2515	if oProgress is not None:
2516	if not oProgress.isCompleted() and oProgress.isCancelable():
2517	reporter.log2('terminateVmBySession: canceling "%s"...' % (oProgress.sName));
2518	try:
2519	oProgress.o.cancel();
2520	except:
2521	reporter.logXcpt();
2522	else:
2523	oProgress.wait();
2524	self.removeTask(oProgress);
2525
2526	# Check if the VM has terminated by it self before powering it off.
2527	fClose = True;
2528	fRc = oSession.pollTask();
2529	if fRc is not True:
2530	reporter.log('terminateVmBySession: powering off "%s"...' % (oSession.sName,));
2531	fRc = oSession.powerOff(fFudgeOnFailure = False);
2532	if fRc is not True:
2533	# power off failed, try terminate it in a nice manner.
2534	fRc = False;
2535	uPid = oSession.getPid();
2536	if uPid is not None:
2537	reporter.error('terminateVmBySession: Terminating PID %u (VM %s)' % (uPid, oSession.sName));
2538	fClose = base.processTerminate(uPid);
2539	if fClose is True:
2540	self.waitOnDirectSessionClose(oSession.oVM, 5000);
2541	fClose = oSession.waitForTask(1000);
2542
2543	if fClose is not True:
2544	# Being nice failed...
2545	reporter.error('terminateVmBySession: Termination failed, trying to kill PID %u (VM %s) instead' \
2546	% (uPid, oSession.sName));
2547	fClose = base.processKill(uPid);
2548	if fClose is True:
2549	self.waitOnDirectSessionClose(oSession.oVM, 5000);
2550	fClose = oSession.waitForTask(1000);
2551	if fClose is not True:
2552	reporter.error('terminateVmBySession: Failed to kill PID %u (VM %s)' % (uPid, oSession.sName));
2553
2554	# The final steps.
2555	if fClose is True:
2556	oSession.close();
2557	self.waitOnDirectSessionClose(oSession.oVM, 10000);
2558	try:
2559	eState = oSession.oVM.state;
2560	except:
2561	reporter.logXcpt();
2562	else:
2563	if eState == vboxcon.MachineState_Aborted:
2564	reporter.error('terminateVmBySession: The VM "%s" aborted!' % (oSession.sName,));
2565	self.removeTask(oSession);
2566
2567	#
2568	# Add the release log, debug log and a screenshot of the VM to the test report.
2569	#
2570	if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
2571	oSession.addLogsToReport();
2572
2573	# Add a screenshot if it has been requested and taken successfully.
2574	if sLastScreenshotPath is not None:
2575	if reporter.testErrorCount() > 0:
2576	reporter.addLogFile(sLastScreenshotPath, 'screenshot/failure', 'Last VM screenshot');
2577	else:
2578	reporter.addLogFile(sLastScreenshotPath, 'screenshot/success', 'Last VM screenshot');
2579
2580	return fRc;
2581
2582
2583	#
2584	# Some information query functions (mix).
2585	#
2586	# Methods require the VBox API. If the information is provided by both
2587	# the testboxscript as well as VBox API, we'll check if it matches.
2588	#
2589
2590	def _hasHostCpuFeature(self, sEnvVar, sEnum, fpApiMinVer, fQuiet):
2591	"""
2592	Common Worker for hasHostNestedPaging() and hasHostHwVirt().
2593
2594	Returns True / False.
2595	Raises exception on environment / host mismatch.
2596	"""
2597	fEnv = os.environ.get(sEnvVar, None);
2598	if fEnv is not None:
2599	fEnv = fEnv.lower() not in [ 'false', 'f', 'not', 'no', 'n', '0', ];
2600
2601	fVBox = None;
2602	self.importVBoxApi();
2603	if self.fpApiVer >= fpApiMinVer and hasattr(vboxcon, sEnum):
2604	try:
2605	fVBox = self.oVBox.host.getProcessorFeature(getattr(vboxcon, sEnum));
2606	except:
2607	if not fQuiet:
2608	reporter.logXcpt();
2609
2610	if fVBox is not None:
2611	if fEnv is not None:
2612	if fEnv != fVBox and not fQuiet:
2613	reporter.log('TestBox configuration overwritten: fVBox=%s (%s) vs. fEnv=%s (%s)'
2614	% (fVBox, sEnum, fEnv, sEnvVar));
2615	return fEnv;
2616	return fVBox;
2617	if fEnv is not None:
2618	return fEnv;
2619	return False;
2620
2621	def hasHostHwVirt(self, fQuiet = False):
2622	"""
2623	Checks if hardware assisted virtualization is supported by the host.
2624
2625	Returns True / False.
2626	Raises exception on environment / host mismatch.
2627	"""
2628	return self._hasHostCpuFeature('TESTBOX_HAS_HW_VIRT', 'ProcessorFeature_HWVirtEx', 3.1, fQuiet);
2629
2630	def hasHostNestedPaging(self, fQuiet = False):
2631	"""
2632	Checks if nested paging is supported by the host.
2633
2634	Returns True / False.
2635	Raises exception on environment / host mismatch.
2636	"""
2637	return self._hasHostCpuFeature('TESTBOX_HAS_NESTED_PAGING', 'ProcessorFeature_NestedPaging', 4.2, fQuiet) \
2638	and self.hasHostHwVirt(fQuiet);
2639
2640	def hasHostLongMode(self, fQuiet = False):
2641	"""
2642	Checks if the host supports 64-bit guests.
2643
2644	Returns True / False.
2645	Raises exception on environment / host mismatch.
2646	"""
2647	# Note that the testboxscript doesn't export this variable atm.
2648	return self._hasHostCpuFeature('TESTBOX_HAS_LONG_MODE', 'ProcessorFeature_LongMode', 3.1, fQuiet);
2649
2650	def getHostCpuCount(self, fQuiet = False):
2651	"""
2652	Returns the number of CPUs on the host.
2653
2654	Returns True / False.
2655	Raises exception on environment / host mismatch.
2656	"""
2657	cEnv = os.environ.get('TESTBOX_CPU_COUNT', None);
2658	if cEnv is not None:
2659	cEnv = int(cEnv);
2660
2661	try:
2662	cVBox = self.oVBox.host.processorOnlineCount;
2663	except:
2664	if not fQuiet:
2665	reporter.logXcpt();
2666	cVBox = None;
2667
2668	if cVBox is not None:
2669	if cEnv is not None:
2670	assert cVBox == cEnv, 'Misconfigured TestBox: VBox: %u CPUs, testboxscript: %u CPUs' % (cVBox, cEnv);
2671	return cVBox;
2672	if cEnv is not None:
2673	return cEnv;
2674	return 1;
2675
2676	def _getHostCpuDesc(self, fQuiet = False):
2677	"""
2678	Internal method used for getting the host CPU description from VBoxSVC.
2679	Returns description string, on failure an empty string is returned.
2680	"""
2681	try:
2682	return self.oVBox.host.getProcessorDescription(0);
2683	except:
2684	if not fQuiet:
2685	reporter.logXcpt();
2686	return '';
2687
2688	def isHostCpuAmd(self, fQuiet = False):
2689	"""
2690	Checks if the host CPU vendor is AMD.
2691
2692	Returns True / False.
2693	"""
2694	sCpuDesc = self._getHostCpuDesc(fQuiet);
2695	return sCpuDesc.startswith("AMD") or sCpuDesc == 'AuthenticAMD';
2696
2697	def isHostCpuIntel(self, fQuiet = False):
2698	"""
2699	Checks if the host CPU vendor is Intel.
2700
2701	Returns True / False.
2702	"""
2703	sCpuDesc = self._getHostCpuDesc(fQuiet);
2704	return sCpuDesc.startswith("Intel") or sCpuDesc == 'GenuineIntel';
2705
2706	def isHostCpuVia(self, fQuiet = False):
2707	"""
2708	Checks if the host CPU vendor is VIA (or Centaur).
2709
2710	Returns True / False.
2711	"""
2712	sCpuDesc = self._getHostCpuDesc(fQuiet);
2713	return sCpuDesc.startswith("VIA") or sCpuDesc == 'CentaurHauls';
2714
2715	def hasRawModeSupport(self, fQuiet = False):
2716	"""
2717	Checks if raw-mode is supported by VirtualBox that the testbox is
2718	configured for it.
2719
2720	Returns True / False.
2721	Raises no exceptions.
2722
2723	Note! Differs from the rest in that we don't require the
2724	TESTBOX_WITH_RAW_MODE value to match the API. It is
2725	sometimes helpful to disable raw-mode on individual
2726	test boxes. (This probably goes for
2727	"""
2728	# The environment variable can be used to disable raw-mode.
2729	fEnv = os.environ.get('TESTBOX_WITH_RAW_MODE', None);
2730	if fEnv is not None:
2731	fEnv = fEnv.lower() not in [ 'false', 'f', 'not', 'no', 'n', '0', ];
2732	if fEnv is False:
2733	return False;
2734
2735	# Starting with 5.0 GA / RC2 the API can tell us whether VBox was built
2736	# with raw-mode support or not.
2737	self.importVBoxApi();
2738	if self.fpApiVer >= 5.0:
2739	try:
2740	fVBox = self.oVBox.systemProperties.rawModeSupported;
2741	except:
2742	if not fQuiet:
2743	reporter.logXcpt();
2744	fVBox = True;
2745	if fVBox is False:
2746	return False;
2747
2748	return True;
2749
2750	#
2751	# Testdriver execution methods.
2752	#
2753
2754	def handleTask(self, oTask, sMethod):
2755	"""
2756	Callback method for handling unknown tasks in the various run loops.
2757
2758	The testdriver should override this if it already tasks running when
2759	calling startVmAndConnectToTxsViaTcp, txsRunTest or similar methods.
2760	Call super to handle unknown tasks.
2761
2762	Returns True if handled, False if not.
2763	"""
2764	reporter.error('%s: unknown task %s' % (sMethod, oTask));
2765	return False;
2766
2767	def txsDoTask(self, oSession, oTxsSession, fnAsync, aArgs):
2768	"""
2769	Generic TXS task wrapper which waits both on the TXS and the session tasks.
2770
2771	Returns False on error, logged.
2772
2773	Returns task result on success.
2774	"""
2775	# All async methods ends with the following to args.
2776	cMsTimeout = aArgs[-2];
2777	fIgnoreErrors = aArgs[-1];
2778
2779	fRemoveVm = self.addTask(oSession);
2780	fRemoveTxs = self.addTask(oTxsSession);
2781
2782	rc = fnAsync(*aArgs); # pylint: disable=W0142
2783	if rc is True:
2784	rc = False;
2785	oTask = self.waitForTasks(cMsTimeout + 1);
2786	if oTask is oTxsSession:
2787	if oTxsSession.isSuccess():
2788	rc = oTxsSession.getResult();
2789	elif fIgnoreErrors is True:
2790	reporter.log( 'txsDoTask: task failed (%s)' % (oTxsSession.getLastReply()[1],));
2791	else:
2792	reporter.error('txsDoTask: task failed (%s)' % (oTxsSession.getLastReply()[1],));
2793	else:
2794	oTxsSession.cancelTask();
2795	if oTask is None:
2796	if fIgnoreErrors is True:
2797	reporter.log( 'txsDoTask: The task timed out.');
2798	else:
2799	reporter.errorTimeout('txsDoTask: The task timed out.');
2800	elif oTask is oSession:
2801	reporter.error('txsDoTask: The VM terminated unexpectedly');
2802	else:
2803	if fIgnoreErrors is True:
2804	reporter.log( 'txsDoTask: An unknown task %s was returned' % (oTask,));
2805	else:
2806	reporter.error('txsDoTask: An unknown task %s was returned' % (oTask,));
2807	else:
2808	reporter.error('txsDoTask: fnAsync returned %s' % (rc,));
2809
2810	if fRemoveTxs:
2811	self.removeTask(oTxsSession);
2812	if fRemoveVm:
2813	self.removeTask(oSession);
2814	return rc;
2815
2816	# pylint: disable=C0111
2817
2818	def txsDisconnect(self, oSession, oTxsSession, cMsTimeout = 30000, fIgnoreErrors = False):
2819	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDisconnect,
2820	(self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2821
2822	def txsUuid(self, oSession, oTxsSession, cMsTimeout = 30000, fIgnoreErrors = False):
2823	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUuid,
2824	(self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2825
2826	def txsMkDir(self, oSession, oTxsSession, sRemoteDir, fMode = 0700, cMsTimeout = 30000, fIgnoreErrors = False):
2827	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkDir,
2828	(sRemoteDir, fMode, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2829
2830	def txsMkDirPath(self, oSession, oTxsSession, sRemoteDir, fMode = 0700, cMsTimeout = 30000, fIgnoreErrors = False):
2831	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkDirPath,
2832	(sRemoteDir, fMode, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2833
2834	def txsMkSymlink(self, oSession, oTxsSession, sLinkTarget, sLink, cMsTimeout = 30000, fIgnoreErrors = False):
2835	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkSymlink,
2836	(sLinkTarget, sLink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2837
2838	def txsRmDir(self, oSession, oTxsSession, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
2839	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmDir,
2840	(sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2841
2842	def txsRmFile(self, oSession, oTxsSession, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
2843	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmFile,
2844	(sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2845
2846	def txsRmSymlink(self, oSession, oTxsSession, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
2847	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmSymlink,
2848	(sRemoteSymlink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2849
2850	def txsRmTree(self, oSession, oTxsSession, sRemoteTree, cMsTimeout = 30000, fIgnoreErrors = False):
2851	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmTree,
2852	(sRemoteTree, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2853
2854	def txsIsDir(self, oSession, oTxsSession, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
2855	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsDir,
2856	(sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2857
2858	def txsIsFile(self, oSession, oTxsSession, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
2859	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsFile,
2860	(sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2861
2862	def txsIsSymlink(self, oSession, oTxsSession, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
2863	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsSymlink,
2864	(sRemoteSymlink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2865
2866	def txsUploadFile(self, oSession, oTxsSession, sLocalFile, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
2867	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUploadFile, \
2868	(sLocalFile, sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2869
2870	def txsUploadString(self, oSession, oTxsSession, sContent, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
2871	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUploadString, \
2872	(sContent, sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2873
2874	def txsDownloadFile(self, oSession, oTxsSession, sRemoteFile, sLocalFile, cMsTimeout = 30000, fIgnoreErrors = False):
2875	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDownloadFile, \
2876	(sRemoteFile, sLocalFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2877
2878	def txsDownloadFiles(self, oSession, oTxsSession, asFiles, fIgnoreErrors = False):
2879	"""
2880	Convenience function to get files from the guest and stores it
2881	into the scratch directory for later (manual) review.
2882
2883	Returns True on success.
2884
2885	Returns False on failure, logged.
2886	"""
2887	fRc = True;
2888	for sGstFile in asFiles:
2889	## @todo Check for already existing files on the host and create a new
2890	# name for the current file to download.
2891	sTmpFile = os.path.join(self.sScratchPath, 'tmp-' + os.path.basename(sGstFile));
2892	reporter.log2('Downloading file "%s" to "%s" ...' % (sGstFile, sTmpFile));
2893	fRc = self.txsDownloadFile(oSession, oTxsSession, sGstFile, sTmpFile, 30 * 1000, fIgnoreErrors);
2894	try: os.unlink(sTmpFile);
2895	except: pass;
2896	if fRc:
2897	reporter.addLogFile(sTmpFile, 'misc/other', 'guest - ' + sGstFile);
2898	else:
2899	if fIgnoreErrors is not True:
2900	reporter.error('error downloading file "%s" to "%s"' % (sGstFile, sTmpFile));
2901	return fRc;
2902	reporter.log('warning: file "%s" was not downloaded, ignoring.' % (sGstFile,));
2903	return True;
2904
2905	def txsDownloadString(self, oSession, oTxsSession, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
2906	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDownloadString,
2907	(sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2908
2909	def txsUnpackFile(self, oSession, oTxsSession, sRemoteFile, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
2910	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUnpackFile, \
2911	(sRemoteFile, sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2912
2913	# pylint: enable=C0111
2914
2915	def txsCdWait(self, oSession, oTxsSession, cMsTimeout = 30000, sFileCdWait = 'vboxtxs-readme.txt'):
2916	"""
2917	Mostly an internal helper for txsRebootAndReconnectViaTcp and
2918	startVmAndConnectToTxsViaTcp that waits for the CDROM drive to become
2919	ready. It does this by polling for a file it knows to exist on the CD.
2920
2921	Returns True on success.
2922
2923	Returns False on failure, logged.
2924	"""
2925
2926	fRemoveVm = self.addTask(oSession);
2927	fRemoveTxs = self.addTask(oTxsSession);
2928	cMsTimeout = self.adjustTimeoutMs(cMsTimeout);
2929	msStart = base.timestampMilli();
2930	cMsTimeout2 = cMsTimeout;
2931	fRc = oTxsSession.asyncIsFile('${CDROM}/%s' % (sFileCdWait), cMsTimeout2);
2932	if fRc is True:
2933	while True:
2934	# wait for it to complete.
2935	oTask = self.waitForTasks(cMsTimeout2 + 1);
2936	if oTask is not oTxsSession:
2937	oTxsSession.cancelTask();
2938	if oTask is None:
2939	reporter.errorTimeout('txsToCdWait: The task timed out (after %s ms).'
2940	% (base.timestampMilli() - msStart,));
2941	elif oTask is oSession:
2942	reporter.error('txsToCdWait: The VM terminated unexpectedly');
2943	else:
2944	reporter.error('txsToCdWait: An unknown task %s was returned' % (oTask,));
2945	fRc = False;
2946	break;
2947	if oTxsSession.isSuccess():
2948	break;
2949
2950	# Check for timeout.
2951	cMsElapsed = base.timestampMilli() - msStart;
2952	if cMsElapsed >= cMsTimeout:
2953	reporter.error('txsToCdWait: timed out');
2954	fRc = False;
2955	break;
2956
2957	# delay.
2958	self.sleep(1);
2959
2960	# resubmitt the task.
2961	cMsTimeout2 = msStart + cMsTimeout - base.timestampMilli();
2962	if cMsTimeout2 < 500:
2963	cMsTimeout2 = 500;
2964	fRc = oTxsSession.asyncIsFile('${CDROM}/%s' % (sFileCdWait), cMsTimeout2);
2965	if fRc is not True:
2966	reporter.error('txsToCdWait: asyncIsFile failed');
2967	break;
2968	else:
2969	reporter.error('txsToCdWait: asyncIsFile failed');
2970
2971	if fRemoveTxs:
2972	self.removeTask(oTxsSession);
2973	if fRemoveVm:
2974	self.removeTask(oSession);
2975	return fRc;
2976
2977	def txsDoConnectViaTcp(self, oSession, cMsTimeout, fNatForwardingForTxs = False):
2978	"""
2979	Mostly an internal worker for connecting to TXS via TCP used by the
2980	*ViaTcp methods.
2981
2982	Returns a tuplet with True/False and TxsSession/None depending on the
2983	result. Errors are logged.
2984	"""
2985
2986	reporter.log2('txsDoConnectViaTcp: oSession=%s, cMsTimeout=%s, fNatForwardingForTxs=%s'
2987	% (oSession, cMsTimeout, fNatForwardingForTxs));
2988
2989	cMsTimeout = self.adjustTimeoutMs(cMsTimeout);
2990	oTxsConnect = oSession.txsConnectViaTcp(cMsTimeout, fNatForwardingForTxs = fNatForwardingForTxs);
2991	if oTxsConnect is not None:
2992	self.addTask(oTxsConnect);
2993	fRemoveVm = self.addTask(oSession);
2994	oTask = self.waitForTasks(cMsTimeout + 1);
2995	reporter.log2('txsDoConnectViaTcp: waitForTasks returned %s' % (oTask,));
2996	self.removeTask(oTxsConnect);
2997	if oTask is oTxsConnect:
2998	oTxsSession = oTxsConnect.getResult();
2999	if oTxsSession is not None:
3000	reporter.log('txsDoConnectViaTcp: Connected to TXS on %s.' % (oTxsSession.oTransport.sHostname,));
3001	return (True, oTxsSession);
3002
3003	reporter.error('txsDoConnectViaTcp: failed to connect to TXS.');
3004	else:
3005	oTxsConnect.cancelTask();
3006	if oTask is None:
3007	reporter.errorTimeout('txsDoConnectViaTcp: connect stage 1 timed out');
3008	elif oTask is oSession:
3009	oSession.reportPrematureTermination('txsDoConnectViaTcp: ');
3010	else:
3011	reporter.error('txsDoConnectViaTcp: unknown/wrong task %s' % (oTask,));
3012	if fRemoveVm:
3013	self.removeTask(oSession);
3014	else:
3015	reporter.error('txsDoConnectViaTcp: txsConnectViaTcp failed');
3016	return (False, None);
3017
3018	def startVmAndConnectToTxsViaTcp(self, sVmName, fCdWait = False, cMsTimeout = 15*60000, \
3019	cMsCdWait = 30000, sFileCdWait = 'vboxtxs-readme.txt', \
3020	fNatForwardingForTxs = False):
3021	"""
3022	Starts the specified VM and tries to connect to its TXS via TCP.
3023	The VM will be powered off if TXS doesn't respond before the specified
3024	time has elapsed.
3025
3026	Returns a the VM and TXS sessions (a two tuple) on success. The VM
3027	session is in the task list, the TXS session is not.
3028	Returns (None, None) on failure, fully logged.
3029	"""
3030
3031	# Zap the guest IP to make sure we're not getting a stale entry
3032	# (unless we're restoring the VM of course).
3033	oTestVM = self.oTestVmSet.findTestVmByName(sVmName) if self.oTestVmSet is not None else None;
3034	if oTestVM is None \
3035	or oTestVM.fSnapshotRestoreCurrent is False:
3036	try:
3037	oSession1 = self.openSession(self.getVmByName(sVmName));
3038	oSession1.delGuestPropertyValue('/VirtualBox/GuestInfo/Net/0/V4/IP');
3039	oSession1.saveSettings(True);
3040	del oSession1;
3041	except:
3042	reporter.logXcpt();
3043
3044	# Start the VM.
3045	reporter.log('startVmAndConnectToTxsViaTcp: Starting(/preparing) "%s" (timeout %s s)...' % (sVmName, cMsTimeout / 1000));
3046	oSession = self.startVmByName(sVmName);
3047	if oSession is not None:
3048	# Connect to TXS.
3049	reporter.log2('startVmAndConnectToTxsViaTcp: Started(/prepared) "%s", connecting to TXS ...' % (sVmName,));
3050	(fRc, oTxsSession) = self.txsDoConnectViaTcp(oSession, cMsTimeout, fNatForwardingForTxs);
3051	if fRc is True:
3052	if fCdWait:
3053	# Wait for CD?
3054	fRc = self.txsCdWait(oSession, oTxsSession, cMsCdWait, sFileCdWait);
3055	if fRc is not True:
3056	reporter.error('startVmAndConnectToTxsViaTcp: txsCdWait failed');
3057	if fRc is True:
3058	# Success!
3059	return (oSession, oTxsSession);
3060	else:
3061	reporter.error('startVmAndConnectToTxsViaTcp: txsDoConnectViaTcp failed');
3062	# If something went wrong while waiting for TXS to be started - take VM screenshot before terminate it
3063	self.terminateVmBySession(oSession);
3064	return (None, None);
3065
3066	def txsRebootAndReconnectViaTcp(self, oSession, oTxsSession, fCdWait = False, cMsTimeout = 15*60000, \
3067	cMsCdWait = 30000, sFileCdWait = 'vboxtxs-readme.txt', fNatForwardingForTxs = False):
3068	"""
3069	Executes the TXS reboot command
3070
3071	Returns A tuple of True and the new TXS session on success.
3072
3073	Returns A tuple of False and either the old TXS session or None on failure.
3074	"""
3075	reporter.log2('txsRebootAndReconnect: cMsTimeout=%u' % (cMsTimeout,));
3076
3077	#
3078	# This stuff is a bit complicated because of rebooting being kind of
3079	# disruptive to the TXS and such... The protocol is that TXS will:
3080	# - ACK the reboot command.
3081	# - Shutdown the transport layer, implicitly disconnecting us.
3082	# - Execute the reboot operation.
3083	# - On failure, it will be re-init the transport layer and be
3084	# available pretty much immediately. UUID unchanged.
3085	# - On success, it will be respawed after the reboot (hopefully),
3086	# with a different UUID.
3087	#
3088	fRc = False;
3089	iStart = base.timestampMilli();
3090
3091	# Get UUID.
3092	cMsTimeout2 = min(60000, cMsTimeout);
3093	sUuidBefore = self.txsUuid(oSession, oTxsSession, self.adjustTimeoutMs(cMsTimeout2, 60000));
3094	if sUuidBefore is not False:
3095	# Reboot.
3096	cMsElapsed = base.timestampMilli() - iStart;
3097	cMsTimeout2 = cMsTimeout - cMsElapsed;
3098	fRc = self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncReboot,
3099	(self.adjustTimeoutMs(cMsTimeout2, 60000), False));
3100	if fRc is True:
3101	# Reconnect.
3102	if fNatForwardingForTxs is True:
3103	self.sleep(22); # NAT fudge - Two fixes are wanted: 1. TXS connect retries. 2. Main API reboot/reset hint.
3104	cMsElapsed = base.timestampMilli() - iStart;
3105	(fRc, oTxsSession) = self.txsDoConnectViaTcp(oSession, cMsTimeout - cMsElapsed, fNatForwardingForTxs);
3106	if fRc is True:
3107	# Check the UUID.
3108	cMsElapsed = base.timestampMilli() - iStart;
3109	cMsTimeout2 = min(60000, cMsTimeout - cMsElapsed);
3110	sUuidAfter = self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUuid,
3111	(self.adjustTimeoutMs(cMsTimeout2, 60000), False));
3112	if sUuidBefore is not False:
3113	if sUuidAfter != sUuidBefore:
3114	reporter.log('The guest rebooted (UUID %s -> %s)' % (sUuidBefore, sUuidAfter))
3115
3116	# Do CD wait if specified.
3117	if fCdWait:
3118	fRc = self.txsCdWait(oSession, oTxsSession, cMsCdWait, sFileCdWait);
3119	if fRc is not True:
3120	reporter.error('txsRebootAndReconnectViaTcp: txsCdWait failed');
3121	else:
3122	reporter.error('txsRebootAndReconnectViaTcp: failed to get UUID (after)');
3123	else:
3124	reporter.error('txsRebootAndReconnectViaTcp: did not reboot (UUID %s)' % (sUuidBefore,));
3125	else:
3126	reporter.error('txsRebootAndReconnectViaTcp: txsDoConnectViaTcp failed');
3127	else:
3128	reporter.error('txsRebootAndReconnectViaTcp: reboot failed');
3129	else:
3130	reporter.error('txsRebootAndReconnectViaTcp: failed to get UUID (before)');
3131	return (fRc, oTxsSession);
3132
3133	# pylint: disable=R0914,R0913
3134
3135	def txsRunTest(self, oTxsSession, sTestName, cMsTimeout, sExecName, asArgs = (), asAddEnv = (), sAsUser = ""):
3136	"""
3137	Executes the specified test task, waiting till it completes or times out.
3138
3139	The VM session (if any) must be in the task list.
3140
3141	Returns True if we executed the task and nothing abnormal happend.
3142	Query the process status from the TXS session.
3143
3144	Returns False if some unexpected task was signalled or we failed to
3145	submit the job.
3146	"""
3147	reporter.testStart(sTestName);
3148	reporter.log2('txsRunTest: cMsTimeout=%u sExecName=%s asArgs=%s' % (cMsTimeout, sExecName, asArgs));
3149
3150	# Submit the job.
3151	fRc = False;
3152	if oTxsSession.asyncExec(sExecName, asArgs, asAddEnv, sAsUser, cMsTimeout = self.adjustTimeoutMs(cMsTimeout)):
3153	self.addTask(oTxsSession);
3154
3155	# Wait for the job to complete.
3156	while True:
3157	oTask = self.waitForTasks(cMsTimeout + 1);
3158	if oTask is None:
3159	reporter.log('txsRunTest: waitForTasks timed out');
3160	break;
3161	if oTask is oTxsSession:
3162	fRc = True;
3163	reporter.log('txsRunTest: isSuccess=%s getResult=%s' % (oTxsSession.isSuccess(), oTxsSession.getResult()));
3164	break;
3165	if not self.handleTask(oTask, 'txsRunTest'):
3166	break;
3167
3168	self.removeTask(oTxsSession);
3169	if not oTxsSession.pollTask():
3170	oTxsSession.cancelTask();
3171	else:
3172	reporter.error('txsRunTest: asyncExec failed');
3173
3174	reporter.testDone();
3175	return fRc;
3176
3177	def txsRunTestRedirectStd(self, oTxsSession, sTestName, cMsTimeout, sExecName, asArgs = (), asAddEnv = (), sAsUser = "",
3178	oStdIn = '/dev/null', oStdOut = '/dev/null', oStdErr = '/dev/null', oTestPipe = '/dev/null'):
3179	"""
3180	Executes the specified test task, waiting till it completes or times out,
3181	redirecting stdin, stdout and stderr to the given objects.
3182
3183	The VM session (if any) must be in the task list.
3184
3185	Returns True if we executed the task and nothing abnormal happend.
3186	Query the process status from the TXS session.
3187
3188	Returns False if some unexpected task was signalled or we failed to
3189	submit the job.
3190	"""
3191	reporter.testStart(sTestName);
3192	reporter.log2('txsRunTestRedirectStd: cMsTimeout=%u sExecName=%s asArgs=%s' % (cMsTimeout, sExecName, asArgs));
3193
3194	# Submit the job.
3195	fRc = False;
3196	if oTxsSession.asyncExecEx(sExecName, asArgs, asAddEnv, oStdIn, oStdOut, oStdErr,
3197	oTestPipe, sAsUser, cMsTimeout = self.adjustTimeoutMs(cMsTimeout)):
3198	self.addTask(oTxsSession);
3199
3200	# Wait for the job to complete.
3201	while True:
3202	oTask = self.waitForTasks(cMsTimeout + 1);
3203	if oTask is None:
3204	reporter.log('txsRunTestRedirectStd: waitForTasks timed out');
3205	break;
3206	if oTask is oTxsSession:
3207	fRc = True;
3208	reporter.log('txsRunTestRedirectStd: isSuccess=%s getResult=%s'
3209	% (oTxsSession.isSuccess(), oTxsSession.getResult()));
3210	break;
3211	if not self.handleTask(oTask, 'txsRunTestRedirectStd'):
3212	break;
3213
3214	self.removeTask(oTxsSession);
3215	if not oTxsSession.pollTask():
3216	oTxsSession.cancelTask();
3217	else:
3218	reporter.error('txsRunTestRedirectStd: asyncExec failed');
3219
3220	reporter.testDone();
3221	return fRc;
3222
3223	def txsRunTest2(self, oTxsSession1, oTxsSession2, sTestName, cMsTimeout,
3224	sExecName1, asArgs1,
3225	sExecName2, asArgs2,
3226	asAddEnv1 = (), sAsUser1 = '', fWithTestPipe1 = True,
3227	asAddEnv2 = (), sAsUser2 = '', fWithTestPipe2 = True):
3228	"""
3229	Executes the specified test tasks, waiting till they complete or
3230	times out. The 1st task is started after the 2nd one.
3231
3232	The VM session (if any) must be in the task list.
3233
3234	Returns True if we executed the task and nothing abnormal happend.
3235	Query the process status from the TXS sessions.
3236
3237	Returns False if some unexpected task was signalled or we failed to
3238	submit the job.
3239	"""
3240	reporter.testStart(sTestName);
3241
3242	# Submit the jobs.
3243	fRc = False;
3244	if oTxsSession1.asyncExec(sExecName1, asArgs1, asAddEnv1, sAsUser1, fWithTestPipe1, '1-',
3245	self.adjustTimeoutMs(cMsTimeout)):
3246	self.addTask(oTxsSession1);
3247
3248	self.sleep(2); # fudge! grr
3249
3250	if oTxsSession2.asyncExec(sExecName2, asArgs2, asAddEnv2, sAsUser2, fWithTestPipe2, '2-',
3251	self.adjustTimeoutMs(cMsTimeout)):
3252	self.addTask(oTxsSession2);
3253
3254	# Wait for the jobs to complete.
3255	cPendingJobs = 2;
3256	while True:
3257	oTask = self.waitForTasks(cMsTimeout + 1);
3258	if oTask is None:
3259	reporter.log('txsRunTest2: waitForTasks timed out');
3260	break;
3261
3262	if oTask is oTxsSession1 or oTask is oTxsSession2:
3263	if oTask is oTxsSession1: iTask = 1;
3264	else: iTask = 2;
3265	reporter.log('txsRunTest2: #%u - isSuccess=%s getResult=%s' \
3266	% (iTask, oTask.isSuccess(), oTask.getResult()));
3267	self.removeTask(oTask);
3268	cPendingJobs -= 1;
3269	if cPendingJobs <= 0:
3270	fRc = True;
3271	break;
3272
3273	elif not self.handleTask(oTask, 'txsRunTest'):
3274	break;
3275
3276	self.removeTask(oTxsSession2);
3277	if not oTxsSession2.pollTask():
3278	oTxsSession2.cancelTask();
3279	else:
3280	reporter.error('txsRunTest2: asyncExec #2 failed');
3281
3282	self.removeTask(oTxsSession1);
3283	if not oTxsSession1.pollTask():
3284	oTxsSession1.cancelTask();
3285	else:
3286	reporter.error('txsRunTest2: asyncExec #1 failed');
3287
3288	reporter.testDone();
3289	return fRc;
3290
3291	# pylint: enable=R0914,R0913
3292

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

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

Download in other formats: