vbox.py@ 56685

Last change on this file since 56685 was 56685, checked in by vboxsync, 10 years ago
vbox.py: Added getXcptResult helper to ComError.
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 56685 2015-06-29 20:04:08Z 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: 56685 $"
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
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	if self.fpApiVer >= 4.0:
2043	try:
2044	if self.fpApiVer >= 4.3:
2045	oProgress = oVM.deleteConfig(None);
2046	else:
2047	oProgress = oVM.delete(None);
2048	self.waitOnProgress(oProgress);
2049	except:
2050	reporter.logXcpt();
2051	else:
2052	try: oVM.deleteSettings();
2053	except: reporter.logXcpt();
2054	raise;
2055	except:
2056	reporter.errorXcpt('failed to create vm "%s"' % (sName));
2057	return None;
2058
2059	# Configure the VM.
2060	fRc = True;
2061	oSession = self.openSession(oVM);
2062	if oSession is not None:
2063	fRc = oSession.setupPreferredConfig();
2064
2065	if fRc and cMbRam is not None :
2066	fRc = oSession.setRamSize(cMbRam);
2067	if fRc and cCpus is not None:
2068	fRc = oSession.setCpuCount(cCpus);
2069	if fRc and fVirtEx is not None:
2070	fRc = oSession.enableVirtEx(fVirtEx);
2071	if fRc and fNestedPaging is not None:
2072	fRc = oSession.enableNestedPaging(fNestedPaging);
2073	if fRc and fIoApic is not None:
2074	fRc = oSession.enableIoApic(fIoApic);
2075	if fRc and fPae is not None:
2076	fRc = oSession.enablePae(fPae);
2077	if fRc and sDvdImage is not None:
2078	fRc = oSession.attachDvd(sDvdImage);
2079	if fRc and sHd is not None:
2080	fRc = oSession.attachHd(sHd, sHddControllerType);
2081	if fRc and sFloppy is not None:
2082	fRc = oSession.attachFloppy(sFloppy);
2083	if fRc and eNic0Type is not None:
2084	fRc = oSession.setNicType(eNic0Type, 0);
2085	if fRc and (eNic0AttachType is not None or (sNic0NetName is not None and sNic0NetName != 'default')):
2086	fRc = oSession.setNicAttachment(eNic0AttachType, sNic0NetName, 0);
2087	if fRc and sNic0MacAddr is not None:
2088	if sNic0MacAddr == 'grouped':
2089	sNic0MacAddr = '%02u' % (iGroup);
2090	fRc = oSession.setNicMacAddress(sNic0MacAddr, 0);
2091	if fRc and fNatForwardingForTxs is True:
2092	fRc = oSession.setupNatForwardingForTxs();
2093	if fRc and fFastBootLogo is not None:
2094	fRc = oSession.setupBootLogo(fFastBootLogo);
2095	if fRc and self.fEnableVrdp:
2096	fRc = oSession.setupVrdp(True, self.uVrdpBasePort + iGroup);
2097	if fRc and fVmmDevTestingPart is not None:
2098	fRc = oSession.enableVmmDevTestingPart(fVmmDevTestingPart, fVmmDevTestingMmio);
2099
2100	if fRc: fRc = oSession.saveSettings();
2101	if not fRc: oSession.discardSettings(True);
2102	oSession.close();
2103	if not fRc:
2104	try: self.oVBox.unregisterMachine(oVM.id);
2105	except: pass;
2106	if self.fpApiVer >= 4.0:
2107	try:
2108	if self.fpApiVer >= 4.3:
2109	oProgress = oVM.deleteConfig(None);
2110	else:
2111	oProgress = oVM.delete(None);
2112	self.waitOnProgress(oProgress);
2113	except:
2114	reporter.logXcpt();
2115	else:
2116	try: oVM.deleteSettings();
2117	except: reporter.logXcpt();
2118	return None;
2119
2120	# success.
2121	reporter.log('created "%s" with name "%s"' % (oVM.id, sName));
2122	self.aoVMs.append(oVM);
2123	self.logVmInfo(oVM); # testing...
2124	return oVM;
2125	# pylint: enable=R0913,R0914
2126
2127	def addTestMachine(self, sNameOrId, fQuiet = False):
2128	"""
2129	Adds an already existing (that is, configured) test VM to the
2130	test VM list.
2131	"""
2132	# find + add the VM to the list.
2133	try:
2134	if self.fpApiVer >= 4.0:
2135	oVM = self.oVBox.findMachine(sNameOrId);
2136	else:
2137	reporter.error('Port me!'); ## @todo Add support for older version < 4.0.
2138	except:
2139	reporter.errorXcpt('could not find vm "%s"' % (sNameOrId,));
2140	return None;
2141
2142	self.aoVMs.append(oVM);
2143	if not fQuiet:
2144	reporter.log('Added "%s" with name "%s"' % (oVM.id, sNameOrId));
2145	self.logVmInfo(oVM);
2146	return oVM;
2147
2148	def openSession(self, oVM):
2149	"""
2150	Opens a session for the VM. Returns the a Session wrapper object that
2151	will automatically close the session when the wrapper goes out of scope.
2152
2153	On failure None is returned and an error is logged.
2154	"""
2155	try:
2156	sUuid = oVM.id;
2157	except:
2158	reporter.errorXcpt('failed to get the UUID for VM "%s"' % (oVM,));
2159	return None;
2160
2161	# This loop is a kludge to deal with us racing the closing of the
2162	# direct session of a previous VM run. See waitOnDirectSessionClose.
2163	for i in range(10):
2164	try:
2165	if self.fpApiVer <= 3.2:
2166	oSession = self.oVBoxMgr.openMachineSession(sUuid);
2167	else:
2168	oSession = self.oVBoxMgr.openMachineSession(oVM);
2169	break;
2170	except:
2171	if i == 9:
2172	reporter.errorXcpt('failed to open session for "%s" ("%s")' % (sUuid, oVM));
2173	return None;
2174	if i > 0:
2175	reporter.logXcpt('warning: failed to open session for "%s" ("%s") - retrying in %u secs' % (sUuid, oVM, i));
2176	self.waitOnDirectSessionClose(oVM, 5000 + i * 1000);
2177	from testdriver.vboxwrappers import SessionWrapper;
2178	return SessionWrapper(oSession, oVM, self.oVBox, self.oVBoxMgr, self, False);
2179
2180	def getVmByName(self, sName):
2181	"""
2182	Get a test VM by name. Returns None if not found, logged.
2183	"""
2184	# Look it up in our 'cache'.
2185	for oVM in self.aoVMs:
2186	try:
2187	#reporter.log2('cur: %s / %s (oVM=%s)' % (oVM.name, oVM.id, oVM));
2188	if oVM.name == sName:
2189	return oVM;
2190	except:
2191	reporter.errorXcpt('failed to get the name from the VM "%s"' % (oVM));
2192
2193	# Look it up the standard way.
2194	return self.addTestMachine(sName, fQuiet = True);
2195
2196	def getVmByUuid(self, sUuid):
2197	"""
2198	Get a test VM by uuid. Returns None if not found, logged.
2199	"""
2200	# Look it up in our 'cache'.
2201	for oVM in self.aoVMs:
2202	try:
2203	if oVM.id == sUuid:
2204	return oVM;
2205	except:
2206	reporter.errorXcpt('failed to get the UUID from the VM "%s"' % (oVM));
2207
2208	# Look it up the standard way.
2209	return self.addTestMachine(sUuid, fQuiet = True);
2210
2211	def waitOnProgress(self, oProgress, cMsTimeout = 1000000, fErrorOnTimeout = True, cMsInterval = 1000):
2212	"""
2213	Waits for a progress object to complete. Returns the status code.
2214	"""
2215	# Wait for progress no longer than cMsTimeout time period.
2216	tsStart = datetime.datetime.now()
2217	while True:
2218	self.processPendingEvents();
2219	try:
2220	if oProgress.completed:
2221	break;
2222	except:
2223	return -1;
2224	self.processPendingEvents();
2225
2226	tsNow = datetime.datetime.now()
2227	tsDelta = tsNow - tsStart
2228	if ((tsDelta.microseconds + tsDelta.seconds * 1000000) / 1000) > cMsTimeout:
2229	if fErrorOnTimeout:
2230	reporter.errorTimeout('Timeout while waiting for progress.')
2231	return -1
2232
2233	try: oProgress.waitForCompletion(cMsInterval);
2234	except: return -2;
2235
2236	try: rc = oProgress.resultCode;
2237	except: rc = -2;
2238	self.processPendingEvents();
2239	return rc;
2240
2241	def waitOnDirectSessionClose(self, oVM, cMsTimeout):
2242	"""
2243	Waits for the VM process to close it's current direct session.
2244
2245	Returns None.
2246	"""
2247	# Get the original values so we're not subject to
2248	try:
2249	eCurState = oVM.sessionState;
2250	if self.fpApiVer >= 5.0:
2251	sCurName = sOrgName = oVM.sessionName;
2252	else:
2253	sCurName = sOrgName = oVM.sessionType;
2254	if self.fpApiVer >= 4.2:
2255	iCurPid = iOrgPid = oVM.sessionPID;
2256	else:
2257	iCurPid = iOrgPid = oVM.sessionPid;
2258	except Exception, oXcpt:
2259	if ComError.notEqual(oXcpt, ComError.E_ACCESSDENIED):
2260	reporter.logXcpt();
2261	self.processPendingEvents();
2262	return None;
2263	self.processPendingEvents();
2264
2265	msStart = base.timestampMilli();
2266	while iCurPid == iOrgPid \
2267	and sCurName == sOrgName \
2268	and sCurName != '' \
2269	and base.timestampMilli() - msStart < cMsTimeout \
2270	and ( eCurState == vboxcon.SessionState_Unlocking \
2271	or eCurState == vboxcon.SessionState_Spawning \
2272	or eCurState == vboxcon.SessionState_Locked):
2273	self.processEvents(1000);
2274	try:
2275	eCurState = oVM.sessionState;
2276	sCurName = oVM.sessionName if self.fpApiVer >= 5.0 else oVM.sessionType;
2277	iCurPid = oVM.sessionPID if self.fpApiVer >= 4.2 else oVM.sessionPid;
2278	except Exception, oXcpt:
2279	if ComError.notEqual(oXcpt, ComError.E_ACCESSDENIED):
2280	reporter.logXcpt();
2281	break;
2282	self.processPendingEvents();
2283	self.processPendingEvents();
2284	return None;
2285
2286	def uploadStartupLogFile(self, oVM, sVmName):
2287	"""
2288	Uploads the VBoxStartup.log when present.
2289	"""
2290	fRc = True;
2291	try:
2292	sLogFile = os.path.join(oVM.logFolder, 'VBoxStartup.log');
2293	except:
2294	reporter.logXcpt();
2295	fRc = False;
2296	else:
2297	if os.path.isfile(sLogFile):
2298	reporter.addLogFile(sLogFile, 'log/release/vm', '%s startup log' % (sVmName, ),
2299	sAltName = '%s-%s' % (sVmName, os.path.basename(sLogFile),));
2300	return fRc;
2301
2302	def startVmEx(self, oVM, fWait = True, sType = None, sName = None, asEnv = None): # pylint: disable=R0914,R0915
2303	"""
2304	Start the VM, returning the VM session and progress object on success.
2305	The session is also added to the task list and to the aoRemoteSessions set.
2306
2307	asEnv is a list of string on the putenv() form.
2308
2309	On failure (None, None) is returned and an error is logged.
2310	"""
2311	# Massage and check the input.
2312	if sType is None:
2313	sType = self.sSessionType;
2314	if sName is None:
2315	try: sName = oVM.name;
2316	except: sName = 'bad-vm-handle';
2317	reporter.log2('startVmEx: sName=%s fWait=%s sType=%s' % (sName, fWait, sType));
2318	if oVM is None:
2319	return (None, None);
2320
2321	## @todo Do this elsewhere.
2322	# Hack alert. Disables all annoying GUI popups.
2323	if sType == 'gui' and len(self.aoRemoteSessions) == 0:
2324	try:
2325	self.oVBox.setExtraData('GUI/Input/AutoCapture', 'false');
2326	if self.fpApiVer >= 3.2:
2327	self.oVBox.setExtraData('GUI/LicenseAgreed', '8');
2328	else:
2329	self.oVBox.setExtraData('GUI/LicenseAgreed', '7');
2330	self.oVBox.setExtraData('GUI/RegistrationData', 'triesLeft=0');
2331	self.oVBox.setExtraData('GUI/SUNOnlineData', 'triesLeft=0');
2332	self.oVBox.setExtraData('GUI/SuppressMessages', 'confirmVMReset,remindAboutMouseIntegrationOn,'
2333	'remindAboutMouseIntegrationOff,remindAboutPausedVMInput,confirmInputCapture,'
2334	'confirmGoingFullscreen,remindAboutInaccessibleMedia,remindAboutWrongColorDepth,'
2335	'confirmRemoveMedium,allPopupPanes,allMessageBoxes,all');
2336	self.oVBox.setExtraData('GUI/UpdateDate', 'never');
2337	self.oVBox.setExtraData('GUI/PreventBetaWarning', self.oVBox.version);
2338	except:
2339	reporter.logXcpt();
2340
2341	# The UUID for the name.
2342	try:
2343	sUuid = oVM.id;
2344	except:
2345	reporter.errorXcpt('failed to get the UUID for VM "%s"' % (oVM));
2346	return (None, None);
2347	self.processPendingEvents();
2348
2349	# Construct the environment.
2350	sLogFile = '%s/VM-%s.log' % (self.sScratchPath, sUuid);
2351	try: os.remove(sLogFile);
2352	except: pass;
2353	if self.sLogSessionDest:
2354	sLogDest = self.sLogSessionDest;
2355	else:
2356	sLogDest = 'file=%s' % sLogFile;
2357	sEnv = 'VBOX_LOG=%s\nVBOX_LOG_FLAGS=%s\nVBOX_LOG_DEST=%s\nVBOX_RELEASE_LOG_FLAGS=append time' \
2358	% (self.sLogSessionGroups, self.sLogSessionFlags, sLogDest,);
2359	if sType == 'gui':
2360	sEnv += '\nVBOX_GUI_DBG_ENABLED=1'
2361	if asEnv is not None and len(asEnv) > 0:
2362	sEnv += '\n' + ('\n'.join(asEnv));
2363
2364	# Shortcuts for local testing.
2365	oProgress = oWrapped = None;
2366	oTestVM = self.oTestVmSet.findTestVmByName(sName) if self.oTestVmSet is not None else None;
2367	try:
2368	if oTestVM is not None \
2369	and oTestVM.fSnapshotRestoreCurrent is True:
2370	if oVM.state is vboxcon.MachineState_Running:
2371	reporter.log2('Machine "%s" already running.' % (sName,));
2372	oProgress = None;
2373	oWrapped = self.openSession(oVM);
2374	else:
2375	reporter.log2('Checking if snapshot for machine "%s" exists.' % (sName,));
2376	oSessionWrapperRestore = self.openSession(oVM);
2377	if oSessionWrapperRestore is not None:
2378	oSnapshotCur = oVM.currentSnapshot;
2379	if oSnapshotCur is not None:
2380	reporter.log2('Restoring snapshot for machine "%s".' % (sName,));
2381	oSessionWrapperRestore.restoreSnapshot(oSnapshotCur);
2382	reporter.log2('Current snapshot for machine "%s" restored.' % (sName,));
2383	else:
2384	reporter.log('warning: no current snapshot for machine "%s" found.' % (sName,));
2385	oSessionWrapperRestore.close();
2386	except:
2387	reporter.errorXcpt();
2388	return (None, None);
2389
2390	# Open a remote session, wait for this operation to complete.
2391	# (The loop is a kludge to deal with us racing the closing of the
2392	# direct session of a previous VM run. See waitOnDirectSessionClose.)
2393	if oWrapped is None:
2394	for i in range(10):
2395	try:
2396	if self.fpApiVer < 4.3 \
2397	or (self.fpApiVer == 4.3 and not hasattr(self.oVBoxMgr, 'getSessionObject')):
2398	oSession = self.oVBoxMgr.mgr.getSessionObject(self.oVBox); # pylint: disable=E1101
2399	else:
2400	oSession = self.oVBoxMgr.getSessionObject(self.oVBox); # pylint: disable=E1101
2401	if self.fpApiVer < 3.3:
2402	oProgress = self.oVBox.openRemoteSession(oSession, sUuid, sType, sEnv);
2403	else:
2404	oProgress = oVM.launchVMProcess(oSession, sType, sEnv);
2405	break;
2406	except:
2407	if i == 9:
2408	reporter.errorXcpt('failed to start VM "%s" ("%s"), aborting.' % (sUuid, sName));
2409	return (None, None);
2410	oSession = None;
2411	if i >= 0:
2412	reporter.logXcpt('warning: failed to start VM "%s" ("%s") - retrying in %u secs.' % (sUuid, oVM, i)); # pylint: disable=C0301
2413	self.waitOnDirectSessionClose(oVM, 5000 + i * 1000);
2414	if fWait and oProgress is not None:
2415	rc = self.waitOnProgress(oProgress);
2416	if rc < 0:
2417	self.waitOnDirectSessionClose(oVM, 5000);
2418	try:
2419	if oSession is not None:
2420	oSession.close();
2421	except: pass;
2422	reportError(oProgress, 'failed to open session for "%s"' % (sName));
2423	self.uploadStartupLogFile(oVM, sName);
2424	return (None, None);
2425	reporter.log2('waitOnProgress -> %s' % (rc,));
2426
2427	# Wrap up the session object and push on to the list before returning it.
2428	if oWrapped is None:
2429	from testdriver.vboxwrappers import SessionWrapper;
2430	oWrapped = SessionWrapper(oSession, oVM, self.oVBox, self.oVBoxMgr, self, True, sName, sLogFile);
2431
2432	oWrapped.registerEventHandlerForTask();
2433	self.aoRemoteSessions.append(oWrapped);
2434	if oWrapped is not self.aoRemoteSessions[len(self.aoRemoteSessions) - 1]:
2435	reporter.error('not by reference: oWrapped=%s aoRemoteSessions[%s]=%s'
2436	% (oWrapped, len(self.aoRemoteSessions) - 1,
2437	self.aoRemoteSessions[len(self.aoRemoteSessions) - 1]));
2438	self.addTask(oWrapped);
2439
2440	reporter.log2('startVmEx: oSession=%s, oSessionWrapper=%s, oProgress=%s' % (oSession, oWrapped, oProgress));
2441
2442	from testdriver.vboxwrappers import ProgressWrapper;
2443	return (oWrapped, ProgressWrapper(oProgress, self.oVBoxMgr, self,
2444	'starting %s' % (sName,)) if oProgress else None);
2445
2446	def startVm(self, oVM, sType=None, sName = None, asEnv = None):
2447	""" Simplified version of startVmEx. """
2448	oSession, _ = self.startVmEx(oVM, True, sType, sName, asEnv = asEnv);
2449	return oSession;
2450
2451	def startVmByNameEx(self, sName, fWait=True, sType=None, asEnv = None):
2452	"""
2453	Start the VM, returning the VM session and progress object on success.
2454	The session is also added to the task list and to the aoRemoteSessions set.
2455
2456	On failure (None, None) is returned and an error is logged.
2457	"""
2458	oVM = self.getVmByName(sName);
2459	if oVM is None:
2460	return (None, None);
2461	return self.startVmEx(oVM, fWait, sType, sName, asEnv = asEnv);
2462
2463	def startVmByName(self, sName, sType=None, asEnv = None):
2464	"""
2465	Start the VM, returning the VM session on success. The session is
2466	also added to the task list and to the aoRemoteSessions set.
2467
2468	On failure None is returned and an error is logged.
2469	"""
2470	oSession, _ = self.startVmByNameEx(sName, True, sType, asEnv = asEnv);
2471	return oSession;
2472
2473	def terminateVmBySession(self, oSession, oProgress = None, fTakeScreenshot = None):
2474	"""
2475	Terminates the VM specified by oSession and adds the release logs to
2476	the test report.
2477
2478	This will try archive this by using powerOff, but will resort to
2479	tougher methods if that fails.
2480
2481	The session will always be removed from the task list.
2482	The session will be closed unless we fail to kill the process.
2483	The session will be removed from the remote session list if closed.
2484
2485	The progress object (a wrapper!) is for teleportation and similar VM
2486	operations, it will be attempted canceled before powering off the VM.
2487	Failures are logged but ignored.
2488	The progress object will always be removed from the task list.
2489
2490	Returns True if powerOff and session close both succeed.
2491	Returns False if on failure (logged), including when we successfully
2492	kill the VM process.
2493	"""
2494	reporter.log2('terminateVmBySession: oSession=%s (pid=%s) oProgress=%s' % (oSession.sName, oSession.getPid(), oProgress));
2495
2496	# Call getPid first to make sure the PID is cached in the wrapper.
2497	oSession.getPid();
2498
2499	#
2500	# Take Screenshot and upload it (see below) to Test Manager if appropriate/requested.
2501	#
2502	sLastScreenshotPath = None
2503	if fTakeScreenshot is True or self.fAlwaysUploadScreenshots or reporter.testErrorCount() > 0:
2504	sLastScreenshotPath = os.path.join(self.sScratchPath, "LastScreenshot-%s.png" % oSession.sName)
2505	fRc = oSession.takeScreenshot(sLastScreenshotPath)
2506	if fRc is not True:
2507	sLastScreenshotPath = None
2508
2509	#
2510	# Terminate the VM
2511	#
2512
2513	# Cancel the progress object if specified.
2514	if oProgress is not None:
2515	if not oProgress.isCompleted() and oProgress.isCancelable():
2516	reporter.log2('terminateVmBySession: canceling "%s"...' % (oProgress.sName));
2517	try:
2518	oProgress.o.cancel();
2519	except:
2520	reporter.logXcpt();
2521	else:
2522	oProgress.wait();
2523	self.removeTask(oProgress);
2524
2525	# Check if the VM has terminated by it self before powering it off.
2526	fClose = True;
2527	fRc = oSession.pollTask();
2528	if fRc is not True:
2529	reporter.log('terminateVmBySession: powering off "%s"...' % (oSession.sName,));
2530	fRc = oSession.powerOff(fFudgeOnFailure = False);
2531	if fRc is not True:
2532	# power off failed, try terminate it in a nice manner.
2533	fRc = False;
2534	uPid = oSession.getPid();
2535	if uPid is not None:
2536	reporter.error('terminateVmBySession: Terminating PID %u (VM %s)' % (uPid, oSession.sName));
2537	fClose = base.processTerminate(uPid);
2538	if fClose is True:
2539	self.waitOnDirectSessionClose(oSession.oVM, 5000);
2540	fClose = oSession.waitForTask(1000);
2541
2542	if fClose is not True:
2543	# Being nice failed...
2544	reporter.error('terminateVmBySession: Termination failed, trying to kill PID %u (VM %s) instead' \
2545	% (uPid, oSession.sName));
2546	fClose = base.processKill(uPid);
2547	if fClose is True:
2548	self.waitOnDirectSessionClose(oSession.oVM, 5000);
2549	fClose = oSession.waitForTask(1000);
2550	if fClose is not True:
2551	reporter.error('terminateVmBySession: Failed to kill PID %u (VM %s)' % (uPid, oSession.sName));
2552
2553	# The final steps.
2554	if fClose is True:
2555	oSession.close();
2556	self.waitOnDirectSessionClose(oSession.oVM, 10000);
2557	try:
2558	eState = oSession.oVM.state;
2559	except:
2560	reporter.logXcpt();
2561	else:
2562	if eState == vboxcon.MachineState_Aborted:
2563	reporter.error('terminateVmBySession: The VM "%s" aborted!' % (oSession.sName,));
2564	self.removeTask(oSession);
2565
2566	#
2567	# Add the release log, debug log and a screenshot of the VM to the test report.
2568	#
2569	if self.fAlwaysUploadLogs or reporter.testErrorCount() > 0:
2570	oSession.addLogsToReport();
2571
2572	# Add a screenshot if it has been requested and taken successfully.
2573	if sLastScreenshotPath is not None:
2574	if reporter.testErrorCount() > 0:
2575	reporter.addLogFile(sLastScreenshotPath, 'screenshot/failure', 'Last VM screenshot');
2576	else:
2577	reporter.addLogFile(sLastScreenshotPath, 'screenshot/success', 'Last VM screenshot');
2578
2579	return fRc;
2580
2581
2582	#
2583	# Some information query functions (mix).
2584	#
2585	# Methods require the VBox API. If the information is provided by both
2586	# the testboxscript as well as VBox API, we'll check if it matches.
2587	#
2588
2589	def _hasHostCpuFeature(self, sEnvVar, sEnum, fpApiMinVer, fQuiet):
2590	"""
2591	Common Worker for hasHostNestedPaging() and hasHostHwVirt().
2592
2593	Returns True / False.
2594	Raises exception on environment / host mismatch.
2595	"""
2596	fEnv = os.environ.get(sEnvVar, None);
2597	if fEnv is not None:
2598	fEnv = fEnv.lower() not in [ 'false', 'f', 'not', 'no', 'n', '0', ];
2599
2600	fVBox = None;
2601	self.importVBoxApi();
2602	if self.fpApiVer >= fpApiMinVer and hasattr(vboxcon, sEnum):
2603	try:
2604	fVBox = self.oVBox.host.getProcessorFeature(getattr(vboxcon, sEnum));
2605	except:
2606	if not fQuiet:
2607	reporter.logXcpt();
2608
2609	if fVBox is not None:
2610	if fEnv is not None:
2611	if fEnv != fVBox and not fQuiet:
2612	reporter.log('TestBox configuration overwritten: fVBox=%s (%s) vs. fEnv=%s (%s)'
2613	% (fVBox, sEnum, fEnv, sEnvVar));
2614	return fEnv;
2615	return fVBox;
2616	if fEnv is not None:
2617	return fEnv;
2618	return False;
2619
2620	def hasHostHwVirt(self, fQuiet = False):
2621	"""
2622	Checks if hardware assisted virtualization is supported by the host.
2623
2624	Returns True / False.
2625	Raises exception on environment / host mismatch.
2626	"""
2627	return self._hasHostCpuFeature('TESTBOX_HAS_HW_VIRT', 'ProcessorFeature_HWVirtEx', 3.1, fQuiet);
2628
2629	def hasHostNestedPaging(self, fQuiet = False):
2630	"""
2631	Checks if nested paging is supported by the host.
2632
2633	Returns True / False.
2634	Raises exception on environment / host mismatch.
2635	"""
2636	return self._hasHostCpuFeature('TESTBOX_HAS_NESTED_PAGING', 'ProcessorFeature_NestedPaging', 4.2, fQuiet) \
2637	and self.hasHostHwVirt(fQuiet);
2638
2639	def hasHostLongMode(self, fQuiet = False):
2640	"""
2641	Checks if the host supports 64-bit guests.
2642
2643	Returns True / False.
2644	Raises exception on environment / host mismatch.
2645	"""
2646	# Note that the testboxscript doesn't export this variable atm.
2647	return self._hasHostCpuFeature('TESTBOX_HAS_LONG_MODE', 'ProcessorFeature_LongMode', 3.1, fQuiet);
2648
2649	def getHostCpuCount(self, fQuiet = False):
2650	"""
2651	Returns the number of CPUs on the host.
2652
2653	Returns True / False.
2654	Raises exception on environment / host mismatch.
2655	"""
2656	cEnv = os.environ.get('TESTBOX_CPU_COUNT', None);
2657	if cEnv is not None:
2658	cEnv = int(cEnv);
2659
2660	try:
2661	cVBox = self.oVBox.host.processorOnlineCount;
2662	except:
2663	if not fQuiet:
2664	reporter.logXcpt();
2665	cVBox = None;
2666
2667	if cVBox is not None:
2668	if cEnv is not None:
2669	assert cVBox == cEnv, 'Misconfigured TestBox: VBox: %u CPUs, testboxscript: %u CPUs' % (cVBox, cEnv);
2670	return cVBox;
2671	if cEnv is not None:
2672	return cEnv;
2673	return 1;
2674
2675	def _getHostCpuDesc(self, fQuiet = False):
2676	"""
2677	Internal method used for getting the host CPU description from VBoxSVC.
2678	Returns description string, on failure an empty string is returned.
2679	"""
2680	try:
2681	return self.oVBox.host.getProcessorDescription(0);
2682	except:
2683	if not fQuiet:
2684	reporter.logXcpt();
2685	return '';
2686
2687	def isHostCpuAmd(self, fQuiet = False):
2688	"""
2689	Checks if the host CPU vendor is AMD.
2690
2691	Returns True / False.
2692	"""
2693	sCpuDesc = self._getHostCpuDesc(fQuiet);
2694	return sCpuDesc.startswith("AMD") or sCpuDesc == 'AuthenticAMD';
2695
2696	def isHostCpuIntel(self, fQuiet = False):
2697	"""
2698	Checks if the host CPU vendor is Intel.
2699
2700	Returns True / False.
2701	"""
2702	sCpuDesc = self._getHostCpuDesc(fQuiet);
2703	return sCpuDesc.startswith("Intel") or sCpuDesc == 'GenuineIntel';
2704
2705	def isHostCpuVia(self, fQuiet = False):
2706	"""
2707	Checks if the host CPU vendor is VIA (or Centaur).
2708
2709	Returns True / False.
2710	"""
2711	sCpuDesc = self._getHostCpuDesc(fQuiet);
2712	return sCpuDesc.startswith("VIA") or sCpuDesc == 'CentaurHauls';
2713
2714	def hasRawModeSupport(self, fQuiet = False):
2715	"""
2716	Checks if raw-mode is supported by VirtualBox that the testbox is
2717	configured for it.
2718
2719	Returns True / False.
2720	Raises no exceptions.
2721
2722	Note! Differs from the rest in that we don't require the
2723	TESTBOX_WITH_RAW_MODE value to match the API. It is
2724	sometimes helpful to disable raw-mode on individual
2725	test boxes. (This probably goes for
2726	"""
2727	# The environment variable can be used to disable raw-mode.
2728	fEnv = os.environ.get('TESTBOX_WITH_RAW_MODE', None);
2729	if fEnv is not None:
2730	fEnv = fEnv.lower() not in [ 'false', 'f', 'not', 'no', 'n', '0', ];
2731	if fEnv is False:
2732	return False;
2733
2734	# Starting with 5.0 GA / RC2 the API can tell us whether VBox was built
2735	# with raw-mode support or not.
2736	self.importVBoxApi();
2737	if self.fpApiVer >= 5.0:
2738	try:
2739	fVBox = self.oVBox.systemProperties.rawModeSupported;
2740	except:
2741	if not fQuiet:
2742	reporter.logXcpt();
2743	fVBox = True;
2744	if fVBox is False:
2745	return False;
2746
2747	return True;
2748
2749	#
2750	# Testdriver execution methods.
2751	#
2752
2753	def handleTask(self, oTask, sMethod):
2754	"""
2755	Callback method for handling unknown tasks in the various run loops.
2756
2757	The testdriver should override this if it already tasks running when
2758	calling startVmAndConnectToTxsViaTcp, txsRunTest or similar methods.
2759	Call super to handle unknown tasks.
2760
2761	Returns True if handled, False if not.
2762	"""
2763	reporter.error('%s: unknown task %s' % (sMethod, oTask));
2764	return False;
2765
2766	def txsDoTask(self, oSession, oTxsSession, fnAsync, aArgs):
2767	"""
2768	Generic TXS task wrapper which waits both on the TXS and the session tasks.
2769
2770	Returns False on error, logged.
2771
2772	Returns task result on success.
2773	"""
2774	# All async methods ends with the following to args.
2775	cMsTimeout = aArgs[-2];
2776	fIgnoreErrors = aArgs[-1];
2777
2778	fRemoveVm = self.addTask(oSession);
2779	fRemoveTxs = self.addTask(oTxsSession);
2780
2781	rc = fnAsync(*aArgs); # pylint: disable=W0142
2782	if rc is True:
2783	rc = False;
2784	oTask = self.waitForTasks(cMsTimeout + 1);
2785	if oTask is oTxsSession:
2786	if oTxsSession.isSuccess():
2787	rc = oTxsSession.getResult();
2788	elif fIgnoreErrors is True:
2789	reporter.log( 'txsDoTask: task failed (%s)' % (oTxsSession.getLastReply()[1],));
2790	else:
2791	reporter.error('txsDoTask: task failed (%s)' % (oTxsSession.getLastReply()[1],));
2792	else:
2793	oTxsSession.cancelTask();
2794	if oTask is None:
2795	if fIgnoreErrors is True:
2796	reporter.log( 'txsDoTask: The task timed out.');
2797	else:
2798	reporter.errorTimeout('txsDoTask: The task timed out.');
2799	elif oTask is oSession:
2800	reporter.error('txsDoTask: The VM terminated unexpectedly');
2801	else:
2802	if fIgnoreErrors is True:
2803	reporter.log( 'txsDoTask: An unknown task %s was returned' % (oTask,));
2804	else:
2805	reporter.error('txsDoTask: An unknown task %s was returned' % (oTask,));
2806	else:
2807	reporter.error('txsDoTask: fnAsync returned %s' % (rc,));
2808
2809	if fRemoveTxs:
2810	self.removeTask(oTxsSession);
2811	if fRemoveVm:
2812	self.removeTask(oSession);
2813	return rc;
2814
2815	# pylint: disable=C0111
2816
2817	def txsDisconnect(self, oSession, oTxsSession, cMsTimeout = 30000, fIgnoreErrors = False):
2818	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDisconnect,
2819	(self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2820
2821	def txsUuid(self, oSession, oTxsSession, cMsTimeout = 30000, fIgnoreErrors = False):
2822	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUuid,
2823	(self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2824
2825	def txsMkDir(self, oSession, oTxsSession, sRemoteDir, fMode = 0700, cMsTimeout = 30000, fIgnoreErrors = False):
2826	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkDir,
2827	(sRemoteDir, fMode, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2828
2829	def txsMkDirPath(self, oSession, oTxsSession, sRemoteDir, fMode = 0700, cMsTimeout = 30000, fIgnoreErrors = False):
2830	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkDirPath,
2831	(sRemoteDir, fMode, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2832
2833	def txsMkSymlink(self, oSession, oTxsSession, sLinkTarget, sLink, cMsTimeout = 30000, fIgnoreErrors = False):
2834	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncMkSymlink,
2835	(sLinkTarget, sLink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2836
2837	def txsRmDir(self, oSession, oTxsSession, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
2838	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmDir,
2839	(sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2840
2841	def txsRmFile(self, oSession, oTxsSession, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
2842	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmFile,
2843	(sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2844
2845	def txsRmSymlink(self, oSession, oTxsSession, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
2846	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmSymlink,
2847	(sRemoteSymlink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2848
2849	def txsRmTree(self, oSession, oTxsSession, sRemoteTree, cMsTimeout = 30000, fIgnoreErrors = False):
2850	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncRmTree,
2851	(sRemoteTree, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2852
2853	def txsIsDir(self, oSession, oTxsSession, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
2854	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsDir,
2855	(sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2856
2857	def txsIsFile(self, oSession, oTxsSession, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
2858	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsFile,
2859	(sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2860
2861	def txsIsSymlink(self, oSession, oTxsSession, sRemoteSymlink, cMsTimeout = 30000, fIgnoreErrors = False):
2862	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncIsSymlink,
2863	(sRemoteSymlink, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2864
2865	def txsUploadFile(self, oSession, oTxsSession, sLocalFile, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
2866	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUploadFile, \
2867	(sLocalFile, sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2868
2869	def txsUploadString(self, oSession, oTxsSession, sContent, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
2870	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUploadString, \
2871	(sContent, sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2872
2873	def txsDownloadFile(self, oSession, oTxsSession, sRemoteFile, sLocalFile, cMsTimeout = 30000, fIgnoreErrors = False):
2874	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDownloadFile, \
2875	(sRemoteFile, sLocalFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2876
2877	def txsDownloadFiles(self, oSession, oTxsSession, asFiles, fIgnoreErrors = False):
2878	"""
2879	Convenience function to get files from the guest and stores it
2880	into the scratch directory for later (manual) review.
2881
2882	Returns True on success.
2883
2884	Returns False on failure, logged.
2885	"""
2886	fRc = True;
2887	for sGstFile in asFiles:
2888	## @todo Check for already existing files on the host and create a new
2889	# name for the current file to download.
2890	sTmpFile = os.path.join(self.sScratchPath, 'tmp-' + os.path.basename(sGstFile));
2891	reporter.log2('Downloading file "%s" to "%s" ...' % (sGstFile, sTmpFile));
2892	fRc = self.txsDownloadFile(oSession, oTxsSession, sGstFile, sTmpFile, 30 * 1000, fIgnoreErrors);
2893	try: os.unlink(sTmpFile);
2894	except: pass;
2895	if fRc:
2896	reporter.addLogFile(sTmpFile, 'misc/other', 'guest - ' + sGstFile);
2897	else:
2898	if fIgnoreErrors is not True:
2899	reporter.error('error downloading file "%s" to "%s"' % (sGstFile, sTmpFile));
2900	return fRc;
2901	reporter.log('warning: file "%s" was not downloaded, ignoring.' % (sGstFile,));
2902	return True;
2903
2904	def txsDownloadString(self, oSession, oTxsSession, sRemoteFile, cMsTimeout = 30000, fIgnoreErrors = False):
2905	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncDownloadString,
2906	(sRemoteFile, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2907
2908	def txsUnpackFile(self, oSession, oTxsSession, sRemoteFile, sRemoteDir, cMsTimeout = 30000, fIgnoreErrors = False):
2909	return self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUnpackFile, \
2910	(sRemoteFile, sRemoteDir, self.adjustTimeoutMs(cMsTimeout), fIgnoreErrors));
2911
2912	# pylint: enable=C0111
2913
2914	def txsCdWait(self, oSession, oTxsSession, cMsTimeout = 30000, sFileCdWait = 'vboxtxs-readme.txt'):
2915	"""
2916	Mostly an internal helper for txsRebootAndReconnectViaTcp and
2917	startVmAndConnectToTxsViaTcp that waits for the CDROM drive to become
2918	ready. It does this by polling for a file it knows to exist on the CD.
2919
2920	Returns True on success.
2921
2922	Returns False on failure, logged.
2923	"""
2924
2925	fRemoveVm = self.addTask(oSession);
2926	fRemoveTxs = self.addTask(oTxsSession);
2927	cMsTimeout = self.adjustTimeoutMs(cMsTimeout);
2928	msStart = base.timestampMilli();
2929	cMsTimeout2 = cMsTimeout;
2930	fRc = oTxsSession.asyncIsFile('${CDROM}/%s' % (sFileCdWait), cMsTimeout2);
2931	if fRc is True:
2932	while True:
2933	# wait for it to complete.
2934	oTask = self.waitForTasks(cMsTimeout2 + 1);
2935	if oTask is not oTxsSession:
2936	oTxsSession.cancelTask();
2937	if oTask is None:
2938	reporter.errorTimeout('txsToCdWait: The task timed out (after %s ms).'
2939	% (base.timestampMilli() - msStart,));
2940	elif oTask is oSession:
2941	reporter.error('txsToCdWait: The VM terminated unexpectedly');
2942	else:
2943	reporter.error('txsToCdWait: An unknown task %s was returned' % (oTask,));
2944	fRc = False;
2945	break;
2946	if oTxsSession.isSuccess():
2947	break;
2948
2949	# Check for timeout.
2950	cMsElapsed = base.timestampMilli() - msStart;
2951	if cMsElapsed >= cMsTimeout:
2952	reporter.error('txsToCdWait: timed out');
2953	fRc = False;
2954	break;
2955
2956	# delay.
2957	self.sleep(1);
2958
2959	# resubmitt the task.
2960	cMsTimeout2 = msStart + cMsTimeout - base.timestampMilli();
2961	if cMsTimeout2 < 500:
2962	cMsTimeout2 = 500;
2963	fRc = oTxsSession.asyncIsFile('${CDROM}/%s' % (sFileCdWait), cMsTimeout2);
2964	if fRc is not True:
2965	reporter.error('txsToCdWait: asyncIsFile failed');
2966	break;
2967	else:
2968	reporter.error('txsToCdWait: asyncIsFile failed');
2969
2970	if fRemoveTxs:
2971	self.removeTask(oTxsSession);
2972	if fRemoveVm:
2973	self.removeTask(oSession);
2974	return fRc;
2975
2976	def txsDoConnectViaTcp(self, oSession, cMsTimeout, fNatForwardingForTxs = False):
2977	"""
2978	Mostly an internal worker for connecting to TXS via TCP used by the
2979	*ViaTcp methods.
2980
2981	Returns a tuplet with True/False and TxsSession/None depending on the
2982	result. Errors are logged.
2983	"""
2984
2985	reporter.log2('txsDoConnectViaTcp: oSession=%s, cMsTimeout=%s, fNatForwardingForTxs=%s'
2986	% (oSession, cMsTimeout, fNatForwardingForTxs));
2987
2988	cMsTimeout = self.adjustTimeoutMs(cMsTimeout);
2989	oTxsConnect = oSession.txsConnectViaTcp(cMsTimeout, fNatForwardingForTxs = fNatForwardingForTxs);
2990	if oTxsConnect is not None:
2991	self.addTask(oTxsConnect);
2992	fRemoveVm = self.addTask(oSession);
2993	oTask = self.waitForTasks(cMsTimeout + 1);
2994	reporter.log2('txsDoConnectViaTcp: waitForTasks returned %s' % (oTask,));
2995	self.removeTask(oTxsConnect);
2996	if oTask is oTxsConnect:
2997	oTxsSession = oTxsConnect.getResult();
2998	if oTxsSession is not None:
2999	reporter.log('txsDoConnectViaTcp: Connected to TXS on %s.' % (oTxsSession.oTransport.sHostname,));
3000	return (True, oTxsSession);
3001
3002	reporter.error('txsDoConnectViaTcp: failed to connect to TXS.');
3003	else:
3004	oTxsConnect.cancelTask();
3005	if oTask is None:
3006	reporter.errorTimeout('txsDoConnectViaTcp: connect stage 1 timed out');
3007	elif oTask is oSession:
3008	oSession.reportPrematureTermination('txsDoConnectViaTcp: ');
3009	else:
3010	reporter.error('txsDoConnectViaTcp: unknown/wrong task %s' % (oTask,));
3011	if fRemoveVm:
3012	self.removeTask(oSession);
3013	else:
3014	reporter.error('txsDoConnectViaTcp: txsConnectViaTcp failed');
3015	return (False, None);
3016
3017	def startVmAndConnectToTxsViaTcp(self, sVmName, fCdWait = False, cMsTimeout = 15*60000, \
3018	cMsCdWait = 30000, sFileCdWait = 'vboxtxs-readme.txt', \
3019	fNatForwardingForTxs = False):
3020	"""
3021	Starts the specified VM and tries to connect to its TXS via TCP.
3022	The VM will be powered off if TXS doesn't respond before the specified
3023	time has elapsed.
3024
3025	Returns a the VM and TXS sessions (a two tuple) on success. The VM
3026	session is in the task list, the TXS session is not.
3027	Returns (None, None) on failure, fully logged.
3028	"""
3029
3030	# Zap the guest IP to make sure we're not getting a stale entry
3031	# (unless we're restoring the VM of course).
3032	oTestVM = self.oTestVmSet.findTestVmByName(sVmName) if self.oTestVmSet is not None else None;
3033	if oTestVM is None \
3034	or oTestVM.fSnapshotRestoreCurrent is False:
3035	try:
3036	oSession1 = self.openSession(self.getVmByName(sVmName));
3037	oSession1.delGuestPropertyValue('/VirtualBox/GuestInfo/Net/0/V4/IP');
3038	oSession1.saveSettings(True);
3039	del oSession1;
3040	except:
3041	reporter.logXcpt();
3042
3043	# Start the VM.
3044	reporter.log('startVmAndConnectToTxsViaTcp: Starting(/preparing) "%s" (timeout %s s)...' % (sVmName, cMsTimeout / 1000));
3045	oSession = self.startVmByName(sVmName);
3046	if oSession is not None:
3047	# Connect to TXS.
3048	reporter.log2('startVmAndConnectToTxsViaTcp: Started(/prepared) "%s", connecting to TXS ...' % (sVmName,));
3049	(fRc, oTxsSession) = self.txsDoConnectViaTcp(oSession, cMsTimeout, fNatForwardingForTxs);
3050	if fRc is True:
3051	if fCdWait:
3052	# Wait for CD?
3053	fRc = self.txsCdWait(oSession, oTxsSession, cMsCdWait, sFileCdWait);
3054	if fRc is not True:
3055	reporter.error('startVmAndConnectToTxsViaTcp: txsCdWait failed');
3056	if fRc is True:
3057	# Success!
3058	return (oSession, oTxsSession);
3059	else:
3060	reporter.error('startVmAndConnectToTxsViaTcp: txsDoConnectViaTcp failed');
3061	# If something went wrong while waiting for TXS to be started - take VM screenshot before terminate it
3062	self.terminateVmBySession(oSession);
3063	return (None, None);
3064
3065	def txsRebootAndReconnectViaTcp(self, oSession, oTxsSession, fCdWait = False, cMsTimeout = 15*60000, \
3066	cMsCdWait = 30000, sFileCdWait = 'vboxtxs-readme.txt', fNatForwardingForTxs = False):
3067	"""
3068	Executes the TXS reboot command
3069
3070	Returns A tuple of True and the new TXS session on success.
3071
3072	Returns A tuple of False and either the old TXS session or None on failure.
3073	"""
3074	reporter.log2('txsRebootAndReconnect: cMsTimeout=%u' % (cMsTimeout,));
3075
3076	#
3077	# This stuff is a bit complicated because of rebooting being kind of
3078	# disruptive to the TXS and such... The protocol is that TXS will:
3079	# - ACK the reboot command.
3080	# - Shutdown the transport layer, implicitly disconnecting us.
3081	# - Execute the reboot operation.
3082	# - On failure, it will be re-init the transport layer and be
3083	# available pretty much immediately. UUID unchanged.
3084	# - On success, it will be respawed after the reboot (hopefully),
3085	# with a different UUID.
3086	#
3087	fRc = False;
3088	iStart = base.timestampMilli();
3089
3090	# Get UUID.
3091	cMsTimeout2 = min(60000, cMsTimeout);
3092	sUuidBefore = self.txsUuid(oSession, oTxsSession, self.adjustTimeoutMs(cMsTimeout2, 60000));
3093	if sUuidBefore is not False:
3094	# Reboot.
3095	cMsElapsed = base.timestampMilli() - iStart;
3096	cMsTimeout2 = cMsTimeout - cMsElapsed;
3097	fRc = self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncReboot,
3098	(self.adjustTimeoutMs(cMsTimeout2, 60000), False));
3099	if fRc is True:
3100	# Reconnect.
3101	if fNatForwardingForTxs is True:
3102	self.sleep(22); # NAT fudge - Two fixes are wanted: 1. TXS connect retries. 2. Main API reboot/reset hint.
3103	cMsElapsed = base.timestampMilli() - iStart;
3104	(fRc, oTxsSession) = self.txsDoConnectViaTcp(oSession, cMsTimeout - cMsElapsed, fNatForwardingForTxs);
3105	if fRc is True:
3106	# Check the UUID.
3107	cMsElapsed = base.timestampMilli() - iStart;
3108	cMsTimeout2 = min(60000, cMsTimeout - cMsElapsed);
3109	sUuidAfter = self.txsDoTask(oSession, oTxsSession, oTxsSession.asyncUuid,
3110	(self.adjustTimeoutMs(cMsTimeout2, 60000), False));
3111	if sUuidBefore is not False:
3112	if sUuidAfter != sUuidBefore:
3113	reporter.log('The guest rebooted (UUID %s -> %s)' % (sUuidBefore, sUuidAfter))
3114
3115	# Do CD wait if specified.
3116	if fCdWait:
3117	fRc = self.txsCdWait(oSession, oTxsSession, cMsCdWait, sFileCdWait);
3118	if fRc is not True:
3119	reporter.error('txsRebootAndReconnectViaTcp: txsCdWait failed');
3120	else:
3121	reporter.error('txsRebootAndReconnectViaTcp: failed to get UUID (after)');
3122	else:
3123	reporter.error('txsRebootAndReconnectViaTcp: did not reboot (UUID %s)' % (sUuidBefore,));
3124	else:
3125	reporter.error('txsRebootAndReconnectViaTcp: txsDoConnectViaTcp failed');
3126	else:
3127	reporter.error('txsRebootAndReconnectViaTcp: reboot failed');
3128	else:
3129	reporter.error('txsRebootAndReconnectViaTcp: failed to get UUID (before)');
3130	return (fRc, oTxsSession);
3131
3132	# pylint: disable=R0914,R0913
3133
3134	def txsRunTest(self, oTxsSession, sTestName, cMsTimeout, sExecName, asArgs = (), asAddEnv = (), sAsUser = ""):
3135	"""
3136	Executes the specified test task, waiting till it completes or times out.
3137
3138	The VM session (if any) must be in the task list.
3139
3140	Returns True if we executed the task and nothing abnormal happend.
3141	Query the process status from the TXS session.
3142
3143	Returns False if some unexpected task was signalled or we failed to
3144	submit the job.
3145	"""
3146	reporter.testStart(sTestName);
3147	reporter.log2('txsRunTest: cMsTimeout=%u sExecName=%s asArgs=%s' % (cMsTimeout, sExecName, asArgs));
3148
3149	# Submit the job.
3150	fRc = False;
3151	if oTxsSession.asyncExec(sExecName, asArgs, asAddEnv, sAsUser, cMsTimeout = self.adjustTimeoutMs(cMsTimeout)):
3152	self.addTask(oTxsSession);
3153
3154	# Wait for the job to complete.
3155	while True:
3156	oTask = self.waitForTasks(cMsTimeout + 1);
3157	if oTask is None:
3158	reporter.log('txsRunTest: waitForTasks timed out');
3159	break;
3160	if oTask is oTxsSession:
3161	fRc = True;
3162	reporter.log('txsRunTest: isSuccess=%s getResult=%s' % (oTxsSession.isSuccess(), oTxsSession.getResult()));
3163	break;
3164	if not self.handleTask(oTask, 'txsRunTest'):
3165	break;
3166
3167	self.removeTask(oTxsSession);
3168	if not oTxsSession.pollTask():
3169	oTxsSession.cancelTask();
3170	else:
3171	reporter.error('txsRunTest: asyncExec failed');
3172
3173	reporter.testDone();
3174	return fRc;
3175
3176	def txsRunTestRedirectStd(self, oTxsSession, sTestName, cMsTimeout, sExecName, asArgs = (), asAddEnv = (), sAsUser = "",
3177	oStdIn = '/dev/null', oStdOut = '/dev/null', oStdErr = '/dev/null', oTestPipe = '/dev/null'):
3178	"""
3179	Executes the specified test task, waiting till it completes or times out,
3180	redirecting stdin, stdout and stderr to the given objects.
3181
3182	The VM session (if any) must be in the task list.
3183
3184	Returns True if we executed the task and nothing abnormal happend.
3185	Query the process status from the TXS session.
3186
3187	Returns False if some unexpected task was signalled or we failed to
3188	submit the job.
3189	"""
3190	reporter.testStart(sTestName);
3191	reporter.log2('txsRunTestRedirectStd: cMsTimeout=%u sExecName=%s asArgs=%s' % (cMsTimeout, sExecName, asArgs));
3192
3193	# Submit the job.
3194	fRc = False;
3195	if oTxsSession.asyncExecEx(sExecName, asArgs, asAddEnv, oStdIn, oStdOut, oStdErr,
3196	oTestPipe, sAsUser, cMsTimeout = self.adjustTimeoutMs(cMsTimeout)):
3197	self.addTask(oTxsSession);
3198
3199	# Wait for the job to complete.
3200	while True:
3201	oTask = self.waitForTasks(cMsTimeout + 1);
3202	if oTask is None:
3203	reporter.log('txsRunTestRedirectStd: waitForTasks timed out');
3204	break;
3205	if oTask is oTxsSession:
3206	fRc = True;
3207	reporter.log('txsRunTestRedirectStd: isSuccess=%s getResult=%s'
3208	% (oTxsSession.isSuccess(), oTxsSession.getResult()));
3209	break;
3210	if not self.handleTask(oTask, 'txsRunTestRedirectStd'):
3211	break;
3212
3213	self.removeTask(oTxsSession);
3214	if not oTxsSession.pollTask():
3215	oTxsSession.cancelTask();
3216	else:
3217	reporter.error('txsRunTestRedirectStd: asyncExec failed');
3218
3219	reporter.testDone();
3220	return fRc;
3221
3222	def txsRunTest2(self, oTxsSession1, oTxsSession2, sTestName, cMsTimeout,
3223	sExecName1, asArgs1,
3224	sExecName2, asArgs2,
3225	asAddEnv1 = (), sAsUser1 = '', fWithTestPipe1 = True,
3226	asAddEnv2 = (), sAsUser2 = '', fWithTestPipe2 = True):
3227	"""
3228	Executes the specified test tasks, waiting till they complete or
3229	times out. The 1st task is started after the 2nd one.
3230
3231	The VM session (if any) must be in the task list.
3232
3233	Returns True if we executed the task and nothing abnormal happend.
3234	Query the process status from the TXS sessions.
3235
3236	Returns False if some unexpected task was signalled or we failed to
3237	submit the job.
3238	"""
3239	reporter.testStart(sTestName);
3240
3241	# Submit the jobs.
3242	fRc = False;
3243	if oTxsSession1.asyncExec(sExecName1, asArgs1, asAddEnv1, sAsUser1, fWithTestPipe1, '1-',
3244	self.adjustTimeoutMs(cMsTimeout)):
3245	self.addTask(oTxsSession1);
3246
3247	self.sleep(2); # fudge! grr
3248
3249	if oTxsSession2.asyncExec(sExecName2, asArgs2, asAddEnv2, sAsUser2, fWithTestPipe2, '2-',
3250	self.adjustTimeoutMs(cMsTimeout)):
3251	self.addTask(oTxsSession2);
3252
3253	# Wait for the jobs to complete.
3254	cPendingJobs = 2;
3255	while True:
3256	oTask = self.waitForTasks(cMsTimeout + 1);
3257	if oTask is None:
3258	reporter.log('txsRunTest2: waitForTasks timed out');
3259	break;
3260
3261	if oTask is oTxsSession1 or oTask is oTxsSession2:
3262	if oTask is oTxsSession1: iTask = 1;
3263	else: iTask = 2;
3264	reporter.log('txsRunTest2: #%u - isSuccess=%s getResult=%s' \
3265	% (iTask, oTask.isSuccess(), oTask.getResult()));
3266	self.removeTask(oTask);
3267	cPendingJobs -= 1;
3268	if cPendingJobs <= 0:
3269	fRc = True;
3270	break;
3271
3272	elif not self.handleTask(oTask, 'txsRunTest'):
3273	break;
3274
3275	self.removeTask(oTxsSession2);
3276	if not oTxsSession2.pollTask():
3277	oTxsSession2.cancelTask();
3278	else:
3279	reporter.error('txsRunTest2: asyncExec #2 failed');
3280
3281	self.removeTask(oTxsSession1);
3282	if not oTxsSession1.pollTask():
3283	oTxsSession1.cancelTask();
3284	else:
3285	reporter.error('txsRunTest2: asyncExec #1 failed');
3286
3287	reporter.testDone();
3288	return fRc;
3289
3290	# pylint: enable=R0914,R0913
3291

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

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

Download in other formats: