VirtualBox

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

最後變更 在這個檔案從101645是 101076,由 vboxsync 提交於 19 月 前

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette