vbox.py@ 65384

Last change on this file since 65384 was 65384, checked in by vboxsync, 8 years ago
Validation Kit: added isHostCpuP4()
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 152.1 KB

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

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

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

Download in other formats: