vbox.py@ 58218

Last change on this file since 58218 was 58218, checked in by vboxsync, 9 years ago
validation kit: show drag and drop mode
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 141.3 KB

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

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

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

Download in other formats: