vboxwrappers.py@ 78339

Last change on this file since 78339 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 125.8 KB

Line
1	# -- coding: utf-8 --
2	# $Id: vboxwrappers.py 76553 2019-01-01 01:45:53Z vboxsync $
3	# pylint: disable=C0302
4
5	"""
6	VirtualBox Wrapper Classes
7	"""
8
9	__copyright__ = \
10	"""
11	Copyright (C) 2010-2019 Oracle Corporation
12
13	This file is part of VirtualBox Open Source Edition (OSE), as
14	available from http://www.virtualbox.org. This file is free software;
15	you can redistribute it and/or modify it under the terms of the GNU
16	General Public License (GPL) as published by the Free Software
17	Foundation, in version 2 as it comes in the "COPYING" file of the
18	VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19	hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20
21	The contents of this file may alternatively be used under the terms
22	of the Common Development and Distribution License Version 1.0
23	(CDDL) only, as it comes in the "COPYING.CDDL" file of the
24	VirtualBox OSE distribution, in which case the provisions of the
25	CDDL are applicable instead of those of the GPL.
26
27	You may elect to license modified versions of this file under the
28	terms and conditions of either the GPL or the CDDL or both.
29	"""
30	__version__ = "$Revision: 76553 $"
31
32
33	# Standard Python imports.
34	import os;
35	import socket;
36	import sys;
37
38	# Validation Kit imports.
39	from common import utils;
40	from common import netutils;
41	from testdriver import base;
42	from testdriver import reporter;
43	from testdriver import txsclient;
44	from testdriver import vboxcon;
45	from testdriver import vbox;
46	from testdriver.base import TdTaskBase;
47
48
49	def _ControllerNameToBusAndType(sController):
50	""" Translate a controller name to a storage bus. """
51	if sController == "IDE Controller":
52	eBus = vboxcon.StorageBus_IDE;
53	eType = vboxcon.StorageControllerType_PIIX4;
54	elif sController == "SATA Controller":
55	eBus = vboxcon.StorageBus_SATA;
56	eType = vboxcon.StorageControllerType_IntelAhci;
57	elif sController == "Floppy Controller":
58	eType = vboxcon.StorageControllerType_I82078;
59	eBus = vboxcon.StorageBus_Floppy;
60	elif sController == "SAS Controller":
61	eBus = vboxcon.StorageBus_SAS;
62	eType = vboxcon.StorageControllerType_LsiLogicSas;
63	elif sController == "SCSI Controller":
64	eBus = vboxcon.StorageBus_SCSI;
65	eType = vboxcon.StorageControllerType_LsiLogic;
66	elif sController == "BusLogic SCSI Controller":
67	eBus = vboxcon.StorageBus_SCSI;
68	eType = vboxcon.StorageControllerType_BusLogic;
69	elif sController == "NVMe Controller":
70	eBus = vboxcon.StorageBus_PCIe;
71	eType = vboxcon.StorageControllerType_NVMe;
72	else:
73	eBus = vboxcon.StorageBus_Null;
74	eType = vboxcon.StorageControllerType_Null;
75	return (eBus, eType);
76
77
78	def _nameMachineState(eState):
79	""" Gets the name (string) of a machine state."""
80	if eState == vboxcon.MachineState_PoweredOff: return 'PoweredOff';
81	if eState == vboxcon.MachineState_Saved: return 'Saved';
82	if eState == vboxcon.MachineState_Teleported: return 'Teleported';
83	if eState == vboxcon.MachineState_Aborted: return 'Aborted';
84	if eState == vboxcon.MachineState_Running: return 'Running';
85	if eState == vboxcon.MachineState_Paused: return 'Paused';
86	if eState == vboxcon.MachineState_Stuck: return 'GuruMeditation';
87	if eState == vboxcon.MachineState_Teleporting: return 'Teleporting';
88	if eState == vboxcon.MachineState_LiveSnapshotting: return 'LiveSnapshotting';
89	if eState == vboxcon.MachineState_Starting: return 'Starting';
90	if eState == vboxcon.MachineState_Stopping: return 'Stopping';
91	if eState == vboxcon.MachineState_Saving: return 'Saving';
92	if eState == vboxcon.MachineState_Restoring: return 'Restoring';
93	if eState == vboxcon.MachineState_TeleportingPausedVM: return 'TeleportingPausedVM';
94	if eState == vboxcon.MachineState_TeleportingIn: return 'TeleportingIn';
95	if eState == vboxcon.MachineState_FaultTolerantSyncing: return 'FaultTolerantSyncing';
96	if eState == vboxcon.MachineState_DeletingSnapshotOnline: return 'DeletingSnapshotOnline';
97	if eState == vboxcon.MachineState_DeletingSnapshotPaused: return 'DeletingSnapshotPaused';
98	if eState == vboxcon.MachineState_RestoringSnapshot: return 'RestoringSnapshot';
99	if eState == vboxcon.MachineState_DeletingSnapshot: return 'DeletingSnapshot';
100	if eState == vboxcon.MachineState_SettingUp: return 'SettingUp';
101	return 'Unknown-%s' % (eState,);
102
103
104	class VirtualBoxWrapper(object): # pylint: disable=R0903
105	"""
106	Wrapper around the IVirtualBox object that adds some (hopefully) useful
107	utility methods
108
109	The real object can be accessed thru the o member. That said, members can
110	be accessed directly as well.
111	"""
112
113	def __init__(self, oVBox, oVBoxMgr, fpApiVer, oTstDrv):
114	self.o = oVBox;
115	self.oVBoxMgr = oVBoxMgr;
116	self.fpApiVer = fpApiVer;
117	self.oTstDrv = oTstDrv;
118
119	def __getattr__(self, sName):
120	# Try ourselves first.
121	try:
122	oAttr = self.__dict__[sName];
123	except:
124	#try:
125	# oAttr = dir(self)[sName];
126	#except AttributeError:
127	oAttr = getattr(self.o, sName);
128	return oAttr;
129
130	#
131	# Utilities.
132	#
133
134	def registerDerivedEventHandler(self, oSubClass, dArgs = None):
135	"""
136	Create an instance of the given VirtualBoxEventHandlerBase sub-class
137	and register it.
138
139	The new instance is returned on success. None is returned on error.
140	"""
141	dArgsCopy = dArgs.copy() if dArgs is not None else dict();
142	dArgsCopy['oVBox'] = self;
143	return oSubClass.registerDerivedEventHandler(self.oVBoxMgr, self.fpApiVer, oSubClass, dArgsCopy,
144	self.o, 'IVirtualBox', 'IVirtualBoxCallback');
145
146	def deleteHdByLocation(self, sHdLocation):
147	"""
148	Deletes a disk image from the host, given it's location.
149	Returns True on success and False on failure. Error information is logged.
150	"""
151	try:
152	oIMedium = self.o.findHardDisk(sHdLocation);
153	except:
154	try:
155	if self.fpApiVer >= 4.1:
156	oIMedium = self.o.openMedium(sHdLocation, vboxcon.DeviceType_HardDisk,
157	vboxcon.AccessMode_ReadWrite, False);
158	elif self.fpApiVer >= 4.0:
159	oIMedium = self.o.openMedium(sHdLocation, vboxcon.DeviceType_HardDisk,
160	vboxcon.AccessMode_ReadWrite);
161	else:
162	oIMedium = self.o.openHardDisk(sHdLocation, vboxcon.AccessMode_ReadOnly, False, "", False, "");
163	except:
164	return reporter.errorXcpt('failed to open hd "%s"' % (sHdLocation));
165	return self.deleteHdByMedium(oIMedium)
166
167	def deleteHdByMedium(self, oIMedium):
168	"""
169	Deletes a disk image from the host, given an IMedium reference.
170	Returns True on success and False on failure. Error information is logged.
171	"""
172	try: oProgressCom = oIMedium.deleteStorage();
173	except: return reporter.errorXcpt('deleteStorage() for disk %s failed' % (oIMedium,));
174	try: oProgress = ProgressWrapper(oProgressCom, self.oVBoxMgr, self.oTstDrv, 'delete disk %s' % (oIMedium.location));
175	except: return reporter.errorXcpt();
176	oProgress.wait();
177	oProgress.logResult();
178	return oProgress.isSuccess();
179
180
181
182	class ProgressWrapper(TdTaskBase):
183	"""
184	Wrapper around a progress object for making it a task and providing useful
185	utility methods.
186	The real progress object can be accessed thru the o member.
187	"""
188
189	def __init__(self, oProgress, oVBoxMgr, oTstDrv, sName):
190	TdTaskBase.__init__(self, utils.getCallerName());
191	self.o = oProgress;
192	self.oVBoxMgr = oVBoxMgr;
193	self.oTstDrv = oTstDrv;
194	self.sName = sName;
195
196	def toString(self):
197	return '<%s sName=%s, oProgress=%s >' \
198	% (TdTaskBase.toString(self), self.sName, self.o);
199
200	#
201	# TdTaskBase overrides.
202	#
203
204	def pollTask(self, fLocked = False):
205	"""
206	Overrides TdTaskBase.pollTask().
207
208	This method returns False until the progress object has completed.
209	"""
210	self.doQuickApiTest();
211	try:
212	try:
213	if self.o.completed:
214	return True;
215	except:
216	pass;
217	finally:
218	self.oTstDrv.processPendingEvents();
219	return False;
220
221	def waitForTask(self, cMsTimeout = 0):
222	"""
223	Overrides TdTaskBase.waitForTask().
224	Process XPCOM/COM events while waiting.
225	"""
226	msStart = base.timestampMilli();
227	fState = self.pollTask(False);
228	while not fState:
229	cMsElapsed = base.timestampMilli() - msStart;
230	if cMsElapsed > cMsTimeout:
231	break;
232	cMsToWait = cMsTimeout - cMsElapsed;
233	if cMsToWait > 500:
234	cMsToWait = 500;
235	try:
236	self.o.waitForCompletion(cMsToWait);
237	except KeyboardInterrupt: raise;
238	except: pass;
239	reporter.doPollWork('ProgressWrapper.waitForTask');
240	fState = self.pollTask(False);
241	return fState;
242
243	#
244	# Utility methods.
245	#
246
247	def isSuccess(self):
248	"""
249	Tests if the progress object completed successfully.
250	Returns True on success, False on failure or incomplete.
251	"""
252	if not self.isCompleted():
253	return False;
254	return self.getResult() >= 0;
255
256	def isCompleted(self):
257	"""
258	Wrapper around IProgress.completed.
259	"""
260	return self.pollTask();
261
262	def isCancelable(self):
263	"""
264	Wrapper around IProgress.cancelable.
265	"""
266	try:
267	fRc = self.o.cancelable;
268	except:
269	reporter.logXcpt();
270	fRc = False;
271	return fRc;
272
273	def wasCanceled(self):
274	"""
275	Wrapper around IProgress.canceled.
276	"""
277	try:
278	fRc = self.o.canceled;
279	except:
280	reporter.logXcpt(self.sName);
281	fRc = False;
282	return fRc;
283
284	def cancel(self):
285	"""
286	Wrapper around IProgress.cancel()
287	Returns True on success, False on failure (logged as error).
288	"""
289	try:
290	self.o.cancel();
291	except:
292	reporter.errorXcpt(self.sName);
293	return False;
294	return True;
295
296	def getResult(self):
297	"""
298	Wrapper around IProgress.resultCode.
299	"""
300	try:
301	iRc = self.o.resultCode;
302	except:
303	reporter.logXcpt(self.sName);
304	iRc = -1;
305	return iRc;
306
307	def getErrInfoResultCode(self):
308	"""
309	Wrapper around IProgress.errorInfo.resultCode.
310
311	Returns the string on success, -1 on bad objects (logged as error), and
312	-2 on missing errorInfo object.
313	"""
314	iRc = -1;
315	try:
316	oErrInfo = self.o.errorInfo;
317	except:
318	reporter.errorXcpt(self.sName);
319	else:
320	if oErrInfo is None:
321	iRc = -2;
322	else:
323	try:
324	iRc = oErrInfo.resultCode;
325	except:
326	reporter.errorXcpt();
327	return iRc;
328
329	def getErrInfoText(self):
330	"""
331	Wrapper around IProgress.errorInfo.text.
332
333	Returns the string on success, None on failure. Missing errorInfo is
334	not logged as an error, all other failures are.
335	"""
336	sText = None;
337	try:
338	oErrInfo = self.o.errorInfo;
339	except:
340	reporter.log2Xcpt(self.sName);
341	else:
342	if oErrInfo is not None:
343	try:
344	sText = oErrInfo.text;
345	except:
346	reporter.errorXcpt();
347	return sText;
348
349	def stringifyErrorInfo(self):
350	"""
351	Formats IProgress.errorInfo into a string.
352	"""
353	try:
354	oErrInfo = self.o.errorInfo;
355	except:
356	reporter.logXcpt(self.sName);
357	sErr = 'no error info';
358	else:
359	sErr = vbox.stringifyErrorInfo(oErrInfo);
360	return sErr;
361
362	def stringifyResult(self):
363	"""
364	Stringify the result.
365	"""
366	if self.isCompleted():
367	if self.wasCanceled():
368	sRet = 'Progress %s: Canceled, hrc=%s' % (self.sName, vbox.ComError.toString(self.getResult()));
369	elif self.getResult() == 0:
370	sRet = 'Progress %s: Success' % (self.sName,);
371	elif self.getResult() > 0:
372	sRet = 'Progress %s: Success (hrc=%s)' % (self.sName, vbox.ComError.toString(self.getResult()));
373	else:
374	sRet = 'Progress %s: Failed! %s' % (self.sName, self.stringifyErrorInfo());
375	else:
376	sRet = 'Progress %s: Not completed yet...' % (self.sName);
377	return sRet;
378
379	def logResult(self, fIgnoreErrors = False):
380	""" Logs the result. """
381	sText = self.stringifyResult();
382	if self.isCompleted() and self.getResult() < 0 \
383	and fIgnoreErrors is False:
384	return reporter.error(sText);
385	return reporter.log(sText);
386
387	def waitOnProgress(self, cMsInterval = 1000):
388	"""
389	See vbox.TestDriver.waitOnProgress.
390	"""
391	self.doQuickApiTest();
392	return self.oTstDrv.waitOnProgress(self.o, cMsInterval);
393
394	def wait(self, cMsTimeout = 60000, fErrorOnTimeout = True, cMsInterval = 1000):
395	"""
396	Wait on the progress object for a while.
397
398	Returns the resultCode of the progress object if completed.
399	Returns -1 on timeout, logged as error if fErrorOnTimeout is set.
400	Returns -2 is the progress object is invalid or waitForCompletion
401	fails (logged as errors).
402	"""
403	msStart = base.timestampMilli();
404	while True:
405	self.oTstDrv.processPendingEvents();
406	self.doQuickApiTest();
407	try:
408	if self.o.completed:
409	break;
410	except:
411	reporter.errorXcpt(self.sName);
412	return -2;
413	self.oTstDrv.processPendingEvents();
414
415	cMsElapsed = base.timestampMilli() - msStart;
416	if cMsElapsed > cMsTimeout:
417	if fErrorOnTimeout:
418	reporter.error('Timing out after waiting for %u s on "%s"' % (cMsTimeout / 1000, self.sName))
419	return -1;
420
421	try:
422	self.o.waitForCompletion(cMsInterval);
423	except:
424	reporter.errorXcpt(self.sName);
425	return -2;
426	reporter.doPollWork('ProgressWrapper.wait');
427
428	try:
429	rc = self.o.resultCode;
430	except:
431	rc = -2;
432	reporter.errorXcpt(self.sName);
433	self.oTstDrv.processPendingEvents();
434	return rc;
435
436	def waitForOperation(self, iOperation, cMsTimeout = 60000, fErrorOnTimeout = True, cMsInterval = 1000, \
437	fIgnoreErrors = False):
438	"""
439	Wait for the completion of a operation.
440
441	Negative iOperation values are relative to operationCount (this
442	property may changed at runtime).
443
444	Returns 0 if the operation completed normally.
445	Returns -1 on timeout, logged as error if fErrorOnTimeout is set.
446	Returns -2 is the progress object is invalid or waitForCompletion
447	fails (logged as errors).
448	Returns -3 if if the operation completed with an error, this is logged
449	as an error.
450	"""
451	msStart = base.timestampMilli();
452	while True:
453	self.oTstDrv.processPendingEvents();
454	self.doQuickApiTest();
455	try:
456	iCurrentOperation = self.o.operation;
457	cOperations = self.o.operationCount;
458	if iOperation >= 0:
459	iRealOperation = iOperation;
460	else:
461	iRealOperation = cOperations + iOperation;
462
463	if iCurrentOperation > iRealOperation:
464	return 0;
465	if iCurrentOperation == iRealOperation \
466	and iRealOperation >= cOperations - 1 \
467	and self.o.completed:
468	if self.o.resultCode < 0:
469	self.logResult(fIgnoreErrors);
470	return -3;
471	return 0;
472	except:
473	if fIgnoreErrors:
474	reporter.logXcpt();
475	else:
476	reporter.errorXcpt();
477	return -2;
478	self.oTstDrv.processPendingEvents();
479
480	cMsElapsed = base.timestampMilli() - msStart;
481	if cMsElapsed > cMsTimeout:
482	if fErrorOnTimeout:
483	if fIgnoreErrors:
484	reporter.log('Timing out after waiting for %s s on "%s" operation %d' \
485	% (cMsTimeout / 1000, self.sName, iOperation))
486	else:
487	reporter.error('Timing out after waiting for %s s on "%s" operation %d' \
488	% (cMsTimeout / 1000, self.sName, iOperation))
489	return -1;
490
491	try:
492	self.o.waitForOperationCompletion(iRealOperation, cMsInterval);
493	except:
494	if fIgnoreErrors:
495	reporter.logXcpt(self.sName);
496	else:
497	reporter.errorXcpt(self.sName);
498	return -2;
499	reporter.doPollWork('ProgressWrapper.waitForOperation');
500	# Not reached.
501	return -3; # Make pylin happy (for now).
502
503	def doQuickApiTest(self):
504	"""
505	Queries everything that is stable and easy to get at and checks that
506	they don't throw errors.
507	"""
508	if True is True:
509	try:
510	iPct = self.o.operationPercent;
511	sDesc = self.o.description;
512	fCancelable = self.o.cancelable;
513	cSecsRemain = self.o.timeRemaining;
514	fCanceled = self.o.canceled;
515	fCompleted = self.o.completed;
516	iOp = self.o.operation;
517	cOps = self.o.operationCount;
518	iOpPct = self.o.operationPercent;
519	sOpDesc = self.o.operationDescription;
520	except:
521	reporter.errorXcpt('%s: %s' % (self.sName, self.o,));
522	return False;
523	try:
524	# Very noisy -- only enable for debugging purposes.
525	#reporter.log2('%s: op=%u/%u/%s: %u%%; total=%u%% cancel=%s/%s compl=%s rem=%us; desc=%s' \
526	# % (self.sName, iOp, cOps, sOpDesc, iOpPct, iPct, fCanceled, fCancelable, fCompleted, \
527	# cSecsRemain, sDesc));
528	_ = iPct; _ = sDesc; _ = fCancelable; _ = cSecsRemain; _ = fCanceled; _ = fCompleted; _ = iOp;
529	_ = cOps; _ = iOpPct; _ = sOpDesc;
530	except:
531	reporter.errorXcpt();
532	return False;
533
534	return True;
535
536
537	class SessionWrapper(TdTaskBase):
538	"""
539	Wrapper around a machine session. The real session object can be accessed
540	thru the o member (short is good, right :-).
541	"""
542
543	def __init__(self, oSession, oVM, oVBox, oVBoxMgr, oTstDrv, fRemoteSession, sFallbackName = None, sLogFile = None):
544	"""
545	Initializes the session wrapper.
546	"""
547	TdTaskBase.__init__(self, utils.getCallerName());
548	self.o = oSession;
549	self.oVBox = oVBox;
550	self.oVBoxMgr = oVBoxMgr;
551	self.oVM = oVM; # Not the session machine. Useful backdoor...
552	self.oTstDrv = oTstDrv;
553	self.fpApiVer = oTstDrv.fpApiVer;
554	self.fRemoteSession = fRemoteSession;
555	self.sLogFile = sLogFile;
556	self.oConsoleEventHandler = None;
557	self.uPid = None;
558	self.fPidFile = True;
559	self.fHostMemoryLow = False; # see signalHostMemoryLow; read-only for outsiders.
560
561	try:
562	self.sName = oSession.machine.name;
563	except:
564	if sFallbackName is not None:
565	self.sName = sFallbackName;
566	else:
567	try: self.sName = str(oSession.machine);
568	except: self.sName = 'is-this-vm-already-off'
569
570	try:
571	self.sUuid = oSession.machine.id;
572	except:
573	self.sUuid = None;
574
575	# Try cache the SessionPID.
576	self.getPid();
577
578	def __del__(self):
579	"""
580	Destructor that makes sure the callbacks are deregistered and
581	that the session is closed.
582	"""
583	self.deregisterEventHandlerForTask();
584
585	if self.o is not None:
586	try:
587	self.close();
588	reporter.log('close session %s' % (self.o));
589	except:
590	pass;
591	self.o = None;
592
593	TdTaskBase.__del__(self);
594
595	def toString(self):
596	return '<%s: sUuid=%s, sName=%s, uPid=%s, sDbgCreated=%s, fRemoteSession=%s, oSession=%s,' \
597	' oConsoleEventHandler=%s, oVM=%s >' \
598	% (type(self).__name__, self.sUuid, self.sName, self.uPid, self.sDbgCreated, self.fRemoteSession,
599	self.o, self.oConsoleEventHandler, self.oVM,);
600
601	def __str__(self):
602	return self.toString();
603
604	#
605	# TdTaskBase overrides.
606	#
607
608	def __pollTask(self):
609	""" Internal poller """
610	# Poll for events after doing the remote GetState call, otherwise we
611	# might end up sleepless because XPCOM queues a cleanup event.
612	try:
613	try:
614	eState = self.o.machine.state;
615	except Exception as oXcpt:
616	if vbox.ComError.notEqual(oXcpt, vbox.ComError.E_UNEXPECTED):
617	reporter.logXcpt();
618	return True;
619	finally:
620	self.oTstDrv.processPendingEvents();
621
622	# Switch
623	if eState == vboxcon.MachineState_Running:
624	return False;
625	if eState == vboxcon.MachineState_Paused:
626	return False;
627	if eState == vboxcon.MachineState_Teleporting:
628	return False;
629	if eState == vboxcon.MachineState_LiveSnapshotting:
630	return False;
631	if eState == vboxcon.MachineState_Starting:
632	return False;
633	if eState == vboxcon.MachineState_Stopping:
634	return False;
635	if eState == vboxcon.MachineState_Saving:
636	return False;
637	if eState == vboxcon.MachineState_Restoring:
638	return False;
639	if eState == vboxcon.MachineState_TeleportingPausedVM:
640	return False;
641	if eState == vboxcon.MachineState_TeleportingIn:
642	return False;
643
644	# Beeep fudge!
645	if self.fpApiVer < 3.2 \
646	and eState == vboxcon.MachineState_PoweredOff \
647	and self.getAgeAsMs() < 3000:
648	return False;
649
650	reporter.log('SessionWrapper::pollTask: eState=%s' % (eState));
651	return True;
652
653
654	def pollTask(self, fLocked = False):
655	"""
656	Overrides TdTaskBase.pollTask().
657
658	This method returns False while the VM is online and running normally.
659	"""
660
661	# Call super to check if the task was signalled by runtime error or similar,
662	# if not then check the VM state via __pollTask.
663	fRc = super(SessionWrapper, self).pollTask(fLocked);
664	if not fRc:
665	fRc = self.__pollTask();
666
667	# HACK ALERT: Lazily try registering the console event handler if
668	# we're not ready.
669	if not fRc and self.oConsoleEventHandler is None:
670	self.registerEventHandlerForTask();
671
672	# HACK ALERT: Lazily try get the PID and add it to the PID file.
673	if not fRc and self.uPid is None:
674	self.getPid();
675
676	return fRc;
677
678	def waitForTask(self, cMsTimeout = 0):
679	"""
680	Overrides TdTaskBase.waitForTask().
681	Process XPCOM/COM events while waiting.
682	"""
683	msStart = base.timestampMilli();
684	fState = self.pollTask(False);
685	while not fState:
686	cMsElapsed = base.timestampMilli() - msStart;
687	if cMsElapsed > cMsTimeout:
688	break;
689	cMsSleep = cMsTimeout - cMsElapsed;
690	if cMsSleep > 10000:
691	cMsSleep = 10000;
692	try: self.oVBoxMgr.waitForEvents(cMsSleep);
693	except KeyboardInterrupt: raise;
694	except: pass;
695	reporter.doPollWork('SessionWrapper.waitForTask');
696	fState = self.pollTask(False);
697	return fState;
698
699	def setTaskOwner(self, oOwner):
700	"""
701	HACK ALERT!
702	Overrides TdTaskBase.setTaskOwner() so we can try call
703	registerEventHandlerForTask() again when when the testdriver calls
704	addTask() after VM has been spawned. Related to pollTask() above.
705
706	The testdriver must not add the task too early for this to work!
707	"""
708	if oOwner is not None:
709	self.registerEventHandlerForTask()
710	return TdTaskBase.setTaskOwner(self, oOwner);
711
712
713	#
714	# Task helpers.
715	#
716
717	def registerEventHandlerForTask(self):
718	"""
719	Registers the console event handlers for working the task state.
720	"""
721	if self.oConsoleEventHandler is not None:
722	return True;
723	self.oConsoleEventHandler = self.registerDerivedEventHandler(vbox.SessionConsoleEventHandler, {}, False);
724	return self.oConsoleEventHandler is not None;
725
726	def deregisterEventHandlerForTask(self):
727	"""
728	Deregisters the console event handlers.
729	"""
730	if self.oConsoleEventHandler is not None:
731	self.oConsoleEventHandler.unregister();
732	self.oConsoleEventHandler = None;
733
734	def signalHostMemoryLow(self):
735	"""
736	Used by a runtime error event handler to indicate that we're low on memory.
737	Signals the task.
738	"""
739	self.fHostMemoryLow = True;
740	self.signalTask();
741	return True;
742
743	def needsPoweringOff(self):
744	"""
745	Examins the machine state to see if the VM needs powering off.
746	"""
747	try:
748	try:
749	eState = self.o.machine.state;
750	except Exception as oXcpt:
751	if vbox.ComError.notEqual(oXcpt, vbox.ComError.E_UNEXPECTED):
752	reporter.logXcpt();
753	return False;
754	finally:
755	self.oTstDrv.processPendingEvents();
756
757	# Switch
758	if eState == vboxcon.MachineState_Running:
759	return True;
760	if eState == vboxcon.MachineState_Paused:
761	return True;
762	if eState == vboxcon.MachineState_Stuck:
763	return True;
764	if eState == vboxcon.MachineState_Teleporting:
765	return True;
766	if eState == vboxcon.MachineState_LiveSnapshotting:
767	return True;
768	if eState == vboxcon.MachineState_Starting:
769	return True;
770	if eState == vboxcon.MachineState_Saving:
771	return True;
772	if eState == vboxcon.MachineState_Restoring:
773	return True;
774	if eState == vboxcon.MachineState_TeleportingPausedVM:
775	return True;
776	if eState == vboxcon.MachineState_TeleportingIn:
777	return True;
778	if eState == vboxcon.MachineState_FaultTolerantSyncing:
779	return True;
780	return False;
781
782	def assertPoweredOff(self):
783	"""
784	Asserts that the VM is powered off, reporting an error if not.
785	Returns True if powered off, False + error msg if not.
786	"""
787	try:
788	try:
789	eState = self.oVM.state;
790	except Exception:
791	reporter.errorXcpt();
792	return True;
793	finally:
794	self.oTstDrv.processPendingEvents();
795
796	if eState == vboxcon.MachineState_PoweredOff:
797	return True;
798	reporter.error('Expected machine state "PoweredOff", machine is in the "%s" state instead.'
799	% (_nameMachineState(eState),));
800	return False;
801
802	def getMachineStateWithName(self):
803	"""
804	Gets the current machine state both as a constant number/whatever and
805	as a human readable string. On error, the constants will be set to
806	None and the string will be the error message.
807	"""
808	try:
809	eState = self.oVM.state;
810	except:
811	return (None, '[error getting state: %s]' % (self.oVBoxMgr.xcptToString(),));
812	finally:
813	self.oTstDrv.processPendingEvents();
814	return (eState, _nameMachineState(eState));
815
816	def reportPrematureTermination(self, sPrefix = ''):
817	"""
818	Reports a premature virtual machine termination.
819	Returns False to facilitate simpler error paths.
820	"""
821
822	reporter.error(sPrefix + 'The virtual machine terminated prematurely!!');
823	(enmState, sStateNm) = self.getMachineStateWithName();
824	reporter.error(sPrefix + 'Machine state: %s' % (sStateNm,));
825
826	if enmState is not None \
827	and enmState == vboxcon.MachineState_Aborted \
828	and self.uPid is not None:
829	#
830	# Look for process crash info.
831	#
832	def addCrashFile(sLogFile, fBinary):
833	""" processCollectCrashInfo callback. """
834	reporter.addLogFile(sLogFile, 'crash/dump/vm' if fBinary else 'crash/report/vm');
835	utils.processCollectCrashInfo(self.uPid, reporter.log, addCrashFile);
836
837	return False;
838
839
840
841	#
842	# ISession / IMachine / ISomethingOrAnother wrappers.
843	#
844
845	def close(self):
846	"""
847	Closes the session if it's open and removes it from the
848	vbox.TestDriver.aoRemoteSessions list.
849	Returns success indicator.
850	"""
851	fRc = True;
852	if self.o is not None:
853	# Get the pid in case we need to kill the process later on.
854	self.getPid();
855
856	# Try close it.
857	try:
858	if self.fpApiVer < 3.3:
859	self.o.close();
860	else:
861	self.o.unlockMachine();
862	self.o = None;
863	except KeyboardInterrupt:
864	raise;
865	except:
866	# Kludge to ignore VBoxSVC's closing of our session when the
867	# direct session closes / VM process terminates. Fun!
868	try: fIgnore = self.o.state == vboxcon.SessionState_Unlocked;
869	except: fIgnore = False;
870	if not fIgnore:
871	reporter.errorXcpt('ISession::unlockMachine failed on %s' % (self.o));
872	fRc = False;
873
874	# Remove it from the remote session list if applicable (not 100% clean).
875	if fRc and self.fRemoteSession:
876	try:
877	if self in self.oTstDrv.aoRemoteSessions:
878	reporter.log2('SessionWrapper::close: Removing myself from oTstDrv.aoRemoteSessions');
879	self.oTstDrv.aoRemoteSessions.remove(self)
880	except:
881	reporter.logXcpt();
882
883	if self.uPid is not None and self.fPidFile:
884	self.oTstDrv.pidFileRemove(self.uPid);
885	self.fPidFile = False;
886
887	# It's only logical to deregister the event handler after the session
888	# is closed. It also avoids circular references between the session
889	# and the listener, which causes trouble with garbage collection.
890	self.deregisterEventHandlerForTask();
891
892	self.oTstDrv.processPendingEvents();
893	return fRc;
894
895	def saveSettings(self, fClose = False):
896	"""
897	Saves the settings and optionally closes the session.
898	Returns success indicator.
899	"""
900	try:
901	try:
902	self.o.machine.saveSettings();
903	except:
904	reporter.errorXcpt('saveSettings failed on %s' % (self.o));
905	return False;
906	finally:
907	self.oTstDrv.processPendingEvents();
908	if fClose:
909	return self.close();
910	return True;
911
912	def discardSettings(self, fClose = False):
913	"""
914	Discards the settings and optionally closes the session.
915	"""
916	try:
917	try:
918	self.o.machine.discardSettings();
919	except:
920	reporter.errorXcpt('discardSettings failed on %s' % (self.o));
921	return False;
922	finally:
923	self.oTstDrv.processPendingEvents();
924	if fClose:
925	return self.close();
926	return True;
927
928	def enableVirtEx(self, fEnable):
929	"""
930	Enables or disables AMD-V/VT-x.
931	Returns True on success and False on failure. Error information is logged.
932	"""
933	# Enable/disable it.
934	fRc = True;
935	try:
936	self.o.machine.setHWVirtExProperty(vboxcon.HWVirtExPropertyType_Enabled, fEnable);
937	except:
938	reporter.errorXcpt('failed to set HWVirtExPropertyType_Enabled=%s for "%s"' % (fEnable, self.sName));
939	fRc = False;
940	else:
941	reporter.log('set HWVirtExPropertyType_Enabled=%s for "%s"' % (fEnable, self.sName));
942
943	# Force/unforce it.
944	if fRc and hasattr(vboxcon, 'HWVirtExPropertyType_Force'):
945	try:
946	self.o.machine.setHWVirtExProperty(vboxcon.HWVirtExPropertyType_Force, fEnable);
947	except:
948	reporter.errorXcpt('failed to set HWVirtExPropertyType_Force=%s for "%s"' % (fEnable, self.sName));
949	fRc = False;
950	else:
951	reporter.log('set HWVirtExPropertyType_Force=%s for "%s"' % (fEnable, self.sName));
952	else:
953	reporter.log('Warning! vboxcon has no HWVirtExPropertyType_Force attribute.');
954	## @todo Modify CFGM to do the same for old VBox versions?
955
956	self.oTstDrv.processPendingEvents();
957	return fRc;
958
959	def enableNestedPaging(self, fEnable):
960	"""
961	Enables or disables nested paging..
962	Returns True on success and False on failure. Error information is logged.
963	"""
964	## @todo Add/remove force CFGM thing, we don't want fallback logic when testing.
965	fRc = True;
966	try:
967	self.o.machine.setHWVirtExProperty(vboxcon.HWVirtExPropertyType_NestedPaging, fEnable);
968	except:
969	reporter.errorXcpt('failed to set HWVirtExPropertyType_NestedPaging=%s for "%s"' % (fEnable, self.sName));
970	fRc = False;
971	else:
972	reporter.log('set HWVirtExPropertyType_NestedPaging=%s for "%s"' % (fEnable, self.sName));
973	self.oTstDrv.processPendingEvents();
974	return fRc;
975
976	def enableLongMode(self, fEnable):
977	"""
978	Enables or disables LongMode.
979	Returns True on success and False on failure. Error information is logged.
980	"""
981	# Supported.
982	if self.fpApiVer < 4.2 or not hasattr(vboxcon, 'HWVirtExPropertyType_LongMode'):
983	return True;
984
985	# Enable/disable it.
986	fRc = True;
987	try:
988	self.o.machine.setCPUProperty(vboxcon.CPUPropertyType_LongMode, fEnable);
989	except:
990	reporter.errorXcpt('failed to set CPUPropertyType_LongMode=%s for "%s"' % (fEnable, self.sName));
991	fRc = False;
992	else:
993	reporter.log('set CPUPropertyType_LongMode=%s for "%s"' % (fEnable, self.sName));
994	self.oTstDrv.processPendingEvents();
995	return fRc;
996
997	def enableNestedHwVirt(self, fEnable):
998	"""
999	Enables or disables Nested Hardware-Virtualization.
1000	Returns True on success and False on failure. Error information is logged.
1001	"""
1002	# Supported.
1003	if self.fpApiVer < 5.3 or not hasattr(vboxcon, 'CPUPropertyType_HWVirt'):
1004	return True;
1005
1006	# Enable/disable it.
1007	fRc = True;
1008	try:
1009	self.o.machine.setCPUProperty(vboxcon.CPUPropertyType_HWVirt, fEnable);
1010	except:
1011	reporter.errorXcpt('failed to set CPUPropertyType_HWVirt=%s for "%s"' % (fEnable, self.sName));
1012	fRc = False;
1013	else:
1014	reporter.log('set CPUPropertyType_HWVirt=%s for "%s"' % (fEnable, self.sName));
1015	self.oTstDrv.processPendingEvents();
1016	return fRc;
1017
1018	def enablePae(self, fEnable):
1019	"""
1020	Enables or disables PAE
1021	Returns True on success and False on failure. Error information is logged.
1022	"""
1023	fRc = True;
1024	try:
1025	if self.fpApiVer >= 3.2: # great, ain't it?
1026	self.o.machine.setCPUProperty(vboxcon.CPUPropertyType_PAE, fEnable);
1027	else:
1028	self.o.machine.setCpuProperty(vboxcon.CpuPropertyType_PAE, fEnable);
1029	except:
1030	reporter.errorXcpt('failed to set CPUPropertyType_PAE=%s for "%s"' % (fEnable, self.sName));
1031	fRc = False;
1032	else:
1033	reporter.log('set CPUPropertyType_PAE=%s for "%s"' % (fEnable, self.sName));
1034	self.oTstDrv.processPendingEvents();
1035	return fRc;
1036
1037	def enableIoApic(self, fEnable):
1038	"""
1039	Enables or disables the IO-APIC
1040	Returns True on success and False on failure. Error information is logged.
1041	"""
1042	fRc = True;
1043	try:
1044	self.o.machine.BIOSSettings.IOAPICEnabled = fEnable;
1045	except:
1046	reporter.errorXcpt('failed to set BIOSSettings.IOAPICEnabled=%s for "%s"' % (fEnable, self.sName));
1047	fRc = False;
1048	else:
1049	reporter.log('set BIOSSettings.IOAPICEnabled=%s for "%s"' % (fEnable, self.sName));
1050	self.oTstDrv.processPendingEvents();
1051	return fRc;
1052
1053	def enableHpet(self, fEnable):
1054	"""
1055	Enables or disables the HPET
1056	Returns True on success and False on failure. Error information is logged.
1057	"""
1058	fRc = True;
1059	try:
1060	if self.fpApiVer >= 4.2:
1061	self.o.machine.HPETEnabled = fEnable;
1062	else:
1063	self.o.machine.hpetEnabled = fEnable;
1064	except:
1065	reporter.errorXcpt('failed to set HpetEnabled=%s for "%s"' % (fEnable, self.sName));
1066	fRc = False;
1067	else:
1068	reporter.log('set HpetEnabled=%s for "%s"' % (fEnable, self.sName));
1069	self.oTstDrv.processPendingEvents();
1070	return fRc;
1071
1072	def enableUsbHid(self, fEnable):
1073	"""
1074	Enables or disables the USB HID
1075	Returns True on success and False on failure. Error information is logged.
1076	"""
1077	fRc = True;
1078	try:
1079	if fEnable:
1080	if self.fpApiVer >= 4.3:
1081	cOhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_OHCI);
1082	if cOhciCtls == 0:
1083	self.o.machine.addUSBController('OHCI', vboxcon.USBControllerType_OHCI);
1084	else:
1085	self.o.machine.usbController.enabled = True;
1086
1087	if self.fpApiVer >= 4.2:
1088	self.o.machine.pointingHIDType = vboxcon.PointingHIDType_ComboMouse;
1089	self.o.machine.keyboardHIDType = vboxcon.KeyboardHIDType_ComboKeyboard;
1090	else:
1091	self.o.machine.pointingHidType = vboxcon.PointingHidType_ComboMouse;
1092	self.o.machine.keyboardHidType = vboxcon.KeyboardHidType_ComboKeyboard;
1093	else:
1094	if self.fpApiVer >= 4.2:
1095	self.o.machine.pointingHIDType = vboxcon.PointingHIDType_PS2Mouse;
1096	self.o.machine.keyboardHIDType = vboxcon.KeyboardHIDType_PS2Keyboard;
1097	else:
1098	self.o.machine.pointingHidType = vboxcon.PointingHidType_PS2Mouse;
1099	self.o.machine.keyboardHidType = vboxcon.KeyboardHidType_PS2Keyboard;
1100	except:
1101	reporter.errorXcpt('failed to change UsbHid to %s for "%s"' % (fEnable, self.sName));
1102	fRc = False;
1103	else:
1104	reporter.log('changed UsbHid to %s for "%s"' % (fEnable, self.sName));
1105	self.oTstDrv.processPendingEvents();
1106	return fRc;
1107
1108	def enableUsbOhci(self, fEnable):
1109	"""
1110	Enables or disables the USB OHCI controller
1111	Returns True on success and False on failure. Error information is logged.
1112	"""
1113	fRc = True;
1114	try:
1115	if fEnable:
1116	if self.fpApiVer >= 4.3:
1117	cOhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_OHCI);
1118	if cOhciCtls == 0:
1119	self.o.machine.addUSBController('OHCI', vboxcon.USBControllerType_OHCI);
1120	else:
1121	self.o.machine.usbController.enabled = True;
1122	else:
1123	if self.fpApiVer >= 4.3:
1124	cOhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_OHCI);
1125	if cOhciCtls == 1:
1126	self.o.machine.removeUSBController('OHCI');
1127	else:
1128	self.o.machine.usbController.enabled = False;
1129	except:
1130	reporter.errorXcpt('failed to change OHCI to %s for "%s"' % (fEnable, self.sName));
1131	fRc = False;
1132	else:
1133	reporter.log('changed OHCI to %s for "%s"' % (fEnable, self.sName));
1134	self.oTstDrv.processPendingEvents();
1135	return fRc;
1136
1137	def enableUsbEhci(self, fEnable):
1138	"""
1139	Enables or disables the USB EHCI controller, enables also OHCI if it is still disabled.
1140	Returns True on success and False on failure. Error information is logged.
1141	"""
1142	fRc = True;
1143	try:
1144	if fEnable:
1145	if self.fpApiVer >= 4.3:
1146	cOhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_OHCI);
1147	if cOhciCtls == 0:
1148	self.o.machine.addUSBController('OHCI', vboxcon.USBControllerType_OHCI);
1149
1150	cEhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_EHCI);
1151	if cEhciCtls == 0:
1152	self.o.machine.addUSBController('EHCI', vboxcon.USBControllerType_EHCI);
1153	else:
1154	self.o.machine.usbController.enabled = True;
1155	self.o.machine.usbController.enabledEHCI = True;
1156	else:
1157	if self.fpApiVer >= 4.3:
1158	cEhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_EHCI);
1159	if cEhciCtls == 1:
1160	self.o.machine.removeUSBController('EHCI');
1161	else:
1162	self.o.machine.usbController.enabledEHCI = False;
1163	except:
1164	reporter.errorXcpt('failed to change EHCI to %s for "%s"' % (fEnable, self.sName));
1165	fRc = False;
1166	else:
1167	reporter.log('changed EHCI to %s for "%s"' % (fEnable, self.sName));
1168	self.oTstDrv.processPendingEvents();
1169	return fRc;
1170
1171	def enableUsbXhci(self, fEnable):
1172	"""
1173	Enables or disables the USB XHCI controller. Error information is logged.
1174	"""
1175	fRc = True;
1176	try:
1177	if fEnable:
1178	cXhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_XHCI);
1179	if cXhciCtls == 0:
1180	self.o.machine.addUSBController('XHCI', vboxcon.USBControllerType_XHCI);
1181	else:
1182	cXhciCtls = self.o.machine.getUSBControllerCountByType(vboxcon.USBControllerType_XHCI);
1183	if cXhciCtls == 1:
1184	self.o.machine.removeUSBController('XHCI');
1185	except:
1186	reporter.errorXcpt('failed to change XHCI to %s for "%s"' % (fEnable, self.sName));
1187	fRc = False;
1188	else:
1189	reporter.log('changed XHCI to %s for "%s"' % (fEnable, self.sName));
1190	self.oTstDrv.processPendingEvents();
1191	return fRc;
1192
1193	def setFirmwareType(self, eType):
1194	"""
1195	Sets the firmware type.
1196	Returns True on success and False on failure. Error information is logged.
1197	"""
1198	fRc = True;
1199	try:
1200	self.o.machine.firmwareType = eType;
1201	except:
1202	reporter.errorXcpt('failed to set firmwareType=%s for "%s"' % (eType, self.sName));
1203	fRc = False;
1204	else:
1205	reporter.log('set firmwareType=%s for "%s"' % (eType, self.sName));
1206	self.oTstDrv.processPendingEvents();
1207	return fRc;
1208
1209	def setChipsetType(self, eType):
1210	"""
1211	Sets the chipset type.
1212	Returns True on success and False on failure. Error information is logged.
1213	"""
1214	fRc = True;
1215	try:
1216	self.o.machine.chipsetType = eType;
1217	except:
1218	reporter.errorXcpt('failed to set chipsetType=%s for "%s"' % (eType, self.sName));
1219	fRc = False;
1220	else:
1221	reporter.log('set chipsetType=%s for "%s"' % (eType, self.sName));
1222	self.oTstDrv.processPendingEvents();
1223	return fRc;
1224
1225	def setupBootLogo(self, fEnable, cMsLogoDisplay = 0):
1226	"""
1227	Sets up the boot logo. fEnable toggles the fade and boot menu
1228	settings as well as the mode.
1229	"""
1230	fRc = True;
1231	try:
1232	self.o.machine.BIOSSettings.logoFadeIn = not fEnable;
1233	self.o.machine.BIOSSettings.logoFadeOut = not fEnable;
1234	self.o.machine.BIOSSettings.logoDisplayTime = cMsLogoDisplay;
1235	if fEnable:
1236	self.o.machine.BIOSSettings.bootMenuMode = vboxcon.BIOSBootMenuMode_Disabled;
1237	else:
1238	self.o.machine.BIOSSettings.bootMenuMode = vboxcon.BIOSBootMenuMode_MessageAndMenu;
1239	except:
1240	reporter.errorXcpt('failed to set logoFadeIn/logoFadeOut/bootMenuMode=%s for "%s"' % (fEnable, self.sName));
1241	fRc = False;
1242	else:
1243	reporter.log('set logoFadeIn/logoFadeOut/bootMenuMode=%s for "%s"' % (fEnable, self.sName));
1244	self.oTstDrv.processPendingEvents();
1245	return fRc;
1246
1247	def setupVrdp(self, fEnable, uPort = None):
1248	"""
1249	Configures VRDP.
1250	"""
1251	fRc = True;
1252	try:
1253	if self.fpApiVer >= 4.0:
1254	self.o.machine.VRDEServer.enabled = fEnable;
1255	else:
1256	self.o.machine.VRDPServer.enabled = fEnable;
1257	except:
1258	reporter.errorXcpt('failed to set VRDEServer::enabled=%s for "%s"' % (fEnable, self.sName));
1259	fRc = False;
1260
1261	if uPort is not None and fRc:
1262	try:
1263	if self.fpApiVer >= 4.0:
1264	self.o.machine.VRDEServer.setVRDEProperty("TCP/Ports", str(uPort));
1265	else:
1266	self.o.machine.VRDPServer.ports = str(uPort);
1267	except:
1268	reporter.errorXcpt('failed to set VRDEServer::ports=%s for "%s"' % (uPort, self.sName));
1269	fRc = False;
1270	if fRc:
1271	reporter.log('set VRDEServer.enabled/ports=%s/%s for "%s"' % (fEnable, uPort, self.sName));
1272	self.oTstDrv.processPendingEvents();
1273	return fRc;
1274
1275	def getNicDriverNameFromType(self, eNicType):
1276	"""
1277	Helper that translate the adapter type into a driver name.
1278	"""
1279	if eNicType == vboxcon.NetworkAdapterType_Am79C970A \
1280	or eNicType == vboxcon.NetworkAdapterType_Am79C973:
1281	sName = 'pcnet';
1282	elif eNicType == vboxcon.NetworkAdapterType_I82540EM \
1283	or eNicType == vboxcon.NetworkAdapterType_I82543GC \
1284	or eNicType == vboxcon.NetworkAdapterType_I82545EM:
1285	sName = 'e1000';
1286	elif eNicType == vboxcon.NetworkAdapterType_Virtio:
1287	sName = 'virtio-net';
1288	else:
1289	reporter.error('Unknown adapter type "%s" (VM: "%s")' % (eNicType, self.sName));
1290	sName = 'pcnet';
1291	return sName;
1292
1293	def setupNatForwardingForTxs(self, iNic = 0, iHostPort = 5042):
1294	"""
1295	Sets up NAT forwarding for port 5042 if applicable, cleans up if not.
1296	"""
1297	try:
1298	oNic = self.o.machine.getNetworkAdapter(iNic);
1299	except:
1300	reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName));
1301	return False;
1302
1303	# Nuke the old setup for all possible adapter types (in case we're
1304	# called after it changed).
1305	for sName in ('pcnet', 'e1000', 'virtio-net'):
1306	for sConfig in ('VBoxInternal/Devices/%s/%u/LUN#0/AttachedDriver/Config' % (sName, iNic), \
1307	'VBoxInternal/Devices/%s/%u/LUN#0/Config' % (sName, iNic)):
1308	try:
1309	self.o.machine.setExtraData('%s/txs/Protocol' % (sConfig), '');
1310	self.o.machine.setExtraData('%s/txs/HostPort' % (sConfig), '');
1311	self.o.machine.setExtraData('%s/txs/GuestPort' % (sConfig), '');
1312	except:
1313	reporter.errorXcpt();
1314
1315	# Set up port forwarding if NAT attachment.
1316	try:
1317	eAttType = oNic.attachmentType;
1318	except:
1319	reporter.errorXcpt('attachmentType on %s failed for "%s"' % (iNic, self.sName));
1320	return False;
1321	if eAttType != vboxcon.NetworkAttachmentType_NAT:
1322	return True;
1323
1324	try:
1325	eNicType = oNic.adapterType;
1326	fTraceEnabled = oNic.traceEnabled;
1327	except:
1328	reporter.errorXcpt('attachmentType/traceEnabled on %s failed for "%s"' % (iNic, self.sName));
1329	return False;
1330
1331	if self.fpApiVer >= 4.1:
1332	try:
1333	if self.fpApiVer >= 4.2:
1334	oNatEngine = oNic.NATEngine;
1335	else:
1336	oNatEngine = oNic.natDriver;
1337	except:
1338	reporter.errorXcpt('Failed to get INATEngine data on "%s"' % (self.sName));
1339	return False;
1340	try: oNatEngine.removeRedirect('txs');
1341	except: pass;
1342	try:
1343	oNatEngine.addRedirect('txs', vboxcon.NATProtocol_TCP, '127.0.0.1', '%s' % (iHostPort), '', '5042');
1344	except:
1345	reporter.errorXcpt('Failed to add a addRedirect redirect on "%s"' % (self.sName));
1346	return False;
1347
1348	else:
1349	sName = self.getNicDriverNameFromType(eNicType);
1350	if fTraceEnabled:
1351	sConfig = 'VBoxInternal/Devices/%s/%u/LUN#0/AttachedDriver/Config' % (sName, iNic)
1352	else:
1353	sConfig = 'VBoxInternal/Devices/%s/%u/LUN#0/Config' % (sName, iNic)
1354
1355	try:
1356	self.o.machine.setExtraData('%s/txs/Protocol' % (sConfig), 'TCP');
1357	self.o.machine.setExtraData('%s/txs/HostPort' % (sConfig), '%s' % (iHostPort));
1358	self.o.machine.setExtraData('%s/txs/GuestPort' % (sConfig), '5042');
1359	except:
1360	reporter.errorXcpt('Failed to set NAT extra data on "%s"' % (self.sName));
1361	return False;
1362	return True;
1363
1364	def setNicType(self, eType, iNic = 0):
1365	"""
1366	Sets the NIC type of the specified NIC.
1367	Returns True on success and False on failure. Error information is logged.
1368	"""
1369	try:
1370	try:
1371	oNic = self.o.machine.getNetworkAdapter(iNic);
1372	except:
1373	reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName));
1374	return False;
1375	try:
1376	oNic.adapterType = eType;
1377	except:
1378	reporter.errorXcpt('failed to set NIC type on slot %s to %s for VM "%s"' % (iNic, eType, self.sName));
1379	return False;
1380	finally:
1381	self.oTstDrv.processPendingEvents();
1382
1383	if not self.setupNatForwardingForTxs(iNic):
1384	return False;
1385	reporter.log('set NIC type on slot %s to %s for VM "%s"' % (iNic, eType, self.sName));
1386	return True;
1387
1388	def setNicTraceEnabled(self, fTraceEnabled, sTraceFile, iNic = 0):
1389	"""
1390	Sets the NIC trace enabled flag and file path.
1391	Returns True on success and False on failure. Error information is logged.
1392	"""
1393	try:
1394	try:
1395	oNic = self.o.machine.getNetworkAdapter(iNic);
1396	except:
1397	reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName));
1398	return False;
1399	try:
1400	oNic.traceEnabled = fTraceEnabled;
1401	oNic.traceFile = sTraceFile;
1402	except:
1403	reporter.errorXcpt('failed to set NIC trace flag on slot %s to %s for VM "%s"' \
1404	% (iNic, fTraceEnabled, self.sName));
1405	return False;
1406	finally:
1407	self.oTstDrv.processPendingEvents();
1408
1409	if not self.setupNatForwardingForTxs(iNic):
1410	return False;
1411	reporter.log('set NIC trace on slot %s to "%s" (path "%s") for VM "%s"' %
1412	(iNic, fTraceEnabled, sTraceFile, self.sName));
1413	return True;
1414
1415	def getDefaultNicName(self, eAttachmentType):
1416	"""
1417	Return the default network / interface name for the NIC attachment type.
1418	"""
1419	sRetName = '';
1420	if eAttachmentType == vboxcon.NetworkAttachmentType_Bridged:
1421	if self.oTstDrv.sDefBridgedNic is not None:
1422	sRetName = self.oTstDrv.sDefBridgedNic;
1423	else:
1424	sRetName = 'eth0';
1425	try:
1426	aoHostNics = self.oVBoxMgr.getArray(self.oVBox.host, 'networkInterfaces');
1427	for oHostNic in aoHostNics:
1428	if oHostNic.interfaceType == vboxcon.HostNetworkInterfaceType_Bridged \
1429	and oHostNic.status == vboxcon.HostNetworkInterfaceStatus_Up:
1430	sRetName = oHostNic.name;
1431	break;
1432	except:
1433	reporter.errorXcpt();
1434	elif eAttachmentType == vboxcon.NetworkAttachmentType_HostOnly:
1435	try:
1436	aoHostNics = self.oVBoxMgr.getArray(self.oVBox.host, 'networkInterfaces');
1437	for oHostNic in aoHostNics:
1438	if oHostNic.interfaceType == vboxcon.HostNetworkInterfaceType_HostOnly:
1439	if oHostNic.status == vboxcon.HostNetworkInterfaceStatus_Up:
1440	sRetName = oHostNic.name;
1441	break;
1442	if sRetName == '':
1443	sRetName = oHostNic.name;
1444	except:
1445	reporter.errorXcpt();
1446	if sRetName == '':
1447	sRetName = 'HostInterfaceNetwork-vboxnet0';
1448	elif eAttachmentType == vboxcon.NetworkAttachmentType_Internal:
1449	sRetName = 'VBoxTest';
1450	elif eAttachmentType == vboxcon.NetworkAttachmentType_NAT:
1451	sRetName = '';
1452	else:
1453	reporter.error('eAttachmentType=%s is not known' % (eAttachmentType));
1454	return sRetName;
1455
1456	def setNicAttachment(self, eAttachmentType, sName = None, iNic = 0):
1457	"""
1458	Sets the attachment type of the specified NIC.
1459	Returns True on success and False on failure. Error information is logged.
1460	"""
1461	try:
1462	oNic = self.o.machine.getNetworkAdapter(iNic);
1463	except:
1464	reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName));
1465	return False;
1466
1467	try:
1468	if eAttachmentType is not None:
1469	try:
1470	if self.fpApiVer >= 4.1:
1471	oNic.attachmentType = eAttachmentType;
1472	else:
1473	if eAttachmentType == vboxcon.NetworkAttachmentType_NAT:
1474	oNic.attachToNAT();
1475	elif eAttachmentType == vboxcon.NetworkAttachmentType_Bridged:
1476	oNic.attachToBridgedInterface();
1477	elif eAttachmentType == vboxcon.NetworkAttachmentType_Internal:
1478	oNic.attachToInternalNetwork();
1479	elif eAttachmentType == vboxcon.NetworkAttachmentType_HostOnly:
1480	oNic.attachToHostOnlyInterface();
1481	else:
1482	raise base.GenError("eAttachmentType=%s is invalid" % (eAttachmentType));
1483	except:
1484	reporter.errorXcpt('failed to set the attachment type on slot %s to %s for VM "%s"' \
1485	% (iNic, eAttachmentType, self.sName));
1486	return False;
1487	else:
1488	try:
1489	eAttachmentType = oNic.attachmentType;
1490	except:
1491	reporter.errorXcpt('failed to get the attachment type on slot %s for VM "%s"' % (iNic, self.sName));
1492	return False;
1493	finally:
1494	self.oTstDrv.processPendingEvents();
1495
1496	if sName is not None:
1497	# Resolve the special 'default' name.
1498	if sName == 'default':
1499	sName = self.getDefaultNicName(eAttachmentType);
1500
1501	# The name translate to different attributes depending on the
1502	# attachment type.
1503	try:
1504	if eAttachmentType == vboxcon.NetworkAttachmentType_Bridged:
1505	## @todo check this out on windows, may have to do a
1506	# translation of the name there or smth IIRC.
1507	try:
1508	if self.fpApiVer >= 4.1:
1509	oNic.bridgedInterface = sName;
1510	else:
1511	oNic.hostInterface = sName;
1512	except:
1513	reporter.errorXcpt('failed to set the hostInterface property on slot %s to "%s" for VM "%s"' \
1514	% (iNic, sName, self.sName));
1515	return False;
1516	elif eAttachmentType == vboxcon.NetworkAttachmentType_HostOnly:
1517	try:
1518	if self.fpApiVer >= 4.1:
1519	oNic.hostOnlyInterface = sName;
1520	else:
1521	oNic.hostInterface = sName;
1522	except:
1523	reporter.errorXcpt('failed to set the internalNetwork property on slot %s to "%s" for VM "%s"' \
1524	% (iNic, sName, self.sName));
1525	return False;
1526	elif eAttachmentType == vboxcon.NetworkAttachmentType_Internal:
1527	try:
1528	oNic.internalNetwork = sName;
1529	except:
1530	reporter.errorXcpt('failed to set the internalNetwork property on slot %s to "%s" for VM "%s"' \
1531	% (iNic, sName, self.sName));
1532	return False;
1533	elif eAttachmentType == vboxcon.NetworkAttachmentType_NAT:
1534	try:
1535	oNic.NATNetwork = sName;
1536	except:
1537	reporter.errorXcpt('failed to set the NATNetwork property on slot %s to "%s" for VM "%s"' \
1538	% (iNic, sName, self.sName));
1539	return False;
1540	finally:
1541	self.oTstDrv.processPendingEvents();
1542
1543	if not self.setupNatForwardingForTxs(iNic):
1544	return False;
1545	reporter.log('set NIC type on slot %s to %s for VM "%s"' % (iNic, eAttachmentType, self.sName));
1546	return True;
1547
1548	def setNicMacAddress(self, sMacAddr, iNic = 0):
1549	"""
1550	Sets the MAC address of the specified NIC.
1551	Returns True on success and False on failure. Error information is logged.
1552	"""
1553
1554	# Resolve missing MAC address prefix by feeding in the host IP address bytes.
1555	cchMacAddr = len(sMacAddr);
1556	if cchMacAddr > 0 and cchMacAddr < 12:
1557	sHostIP = netutils.getPrimaryHostIp();
1558	abHostIP = socket.inet_aton(sHostIP);
1559	if sys.version_info[0] < 3:
1560	abHostIP = (ord(abHostIP[0]), ord(abHostIP[1]), ord(abHostIP[2]), ord(abHostIP[3]));
1561
1562	if abHostIP[0] == 127 \
1563	or (abHostIP[0] == 169 and abHostIP[1] == 254) \
1564	or (abHostIP[0] == 192 and abHostIP[1] == 168 and abHostIP[2] == 56):
1565	return reporter.error('host IP for "%s" is %s, most likely not unique.' % (netutils.getHostnameFqdn(), sHostIP,));
1566
1567	sDefaultMac = '%02X%02X%02X%02X%02X%02X' % (0x02, abHostIP[0], abHostIP[1], abHostIP[2], abHostIP[3], iNic);
1568	sMacAddr = sDefaultMac[0:(12 - cchMacAddr)] + sMacAddr;
1569
1570	# Get the NIC object and try set it address.
1571	try:
1572	oNic = self.o.machine.getNetworkAdapter(iNic);
1573	except:
1574	return reporter.errorXcpt('getNetworkAdapter(%s) failed for "%s"' % (iNic, self.sName,));
1575
1576	try:
1577	oNic.MACAddress = sMacAddr;
1578	except:
1579	return reporter.errorXcpt('failed to set the MAC address on slot %s to "%s" for VM "%s"'
1580	% (iNic, sMacAddr, self.sName));
1581
1582	reporter.log('set MAC address on slot %s to %s for VM "%s"' % (iNic, sMacAddr, self.sName,));
1583	return True;
1584
1585	def setRamSize(self, cMB):
1586	"""
1587	Set the RAM size of the VM.
1588	Returns True on success and False on failure. Error information is logged.
1589	"""
1590	fRc = True;
1591	try:
1592	self.o.machine.memorySize = cMB;
1593	except:
1594	reporter.errorXcpt('failed to set the RAM size of "%s" to %s' % (self.sName, cMB));
1595	fRc = False;
1596	else:
1597	reporter.log('set the RAM size of "%s" to %s' % (self.sName, cMB));
1598	self.oTstDrv.processPendingEvents();
1599	return fRc;
1600
1601	def setVRamSize(self, cMB):
1602	"""
1603	Set the RAM size of the VM.
1604	Returns True on success and False on failure. Error information is logged.
1605	"""
1606	fRc = True;
1607	try:
1608	self.o.machine.VRAMSize = cMB;
1609	except:
1610	reporter.errorXcpt('failed to set the VRAM size of "%s" to %s' % (self.sName, cMB));
1611	fRc = False;
1612	else:
1613	reporter.log('set the VRAM size of "%s" to %s' % (self.sName, cMB));
1614	self.oTstDrv.processPendingEvents();
1615	return fRc;
1616
1617	def setCpuCount(self, cCpus):
1618	"""
1619	Set the number of CPUs.
1620	Returns True on success and False on failure. Error information is logged.
1621	"""
1622	fRc = True;
1623	try:
1624	self.o.machine.CPUCount = cCpus;
1625	except:
1626	reporter.errorXcpt('failed to set the CPU count of "%s" to %s' % (self.sName, cCpus));
1627	fRc = False;
1628	else:
1629	reporter.log('set the CPU count of "%s" to %s' % (self.sName, cCpus));
1630	self.oTstDrv.processPendingEvents();
1631	return fRc;
1632
1633	def getCpuCount(self):
1634	"""
1635	Returns the number of CPUs.
1636	Returns the number of CPUs on success and 0 on failure. Error information is logged.
1637	"""
1638	cCpus = 0;
1639	try:
1640	cCpus = self.o.machine.CPUCount;
1641	except:
1642	reporter.errorXcpt('failed to get the CPU count of "%s"' % (self.sName,));
1643
1644	self.oTstDrv.processPendingEvents();
1645	return cCpus;
1646
1647	def ensureControllerAttached(self, sController):
1648	"""
1649	Makes sure the specified controller is attached to the VM, attaching it
1650	if necessary.
1651	"""
1652	try:
1653	try:
1654	self.o.machine.getStorageControllerByName(sController);
1655	except:
1656	(eBus, eType) = _ControllerNameToBusAndType(sController);
1657	try:
1658	oCtl = self.o.machine.addStorageController(sController, eBus);
1659	except:
1660	reporter.errorXcpt('addStorageController("%s",%s) failed on "%s"' % (sController, eBus, self.sName) );
1661	return False;
1662	else:
1663	try:
1664	oCtl.controllerType = eType;
1665	reporter.log('added storage controller "%s" (bus %s, type %s) to %s'
1666	% (sController, eBus, eType, self.sName));
1667	except:
1668	reporter.errorXcpt('controllerType = %s on ("%s" / %s) failed on "%s"'
1669	% (eType, sController, eBus, self.sName) );
1670	return False;
1671	finally:
1672	self.oTstDrv.processPendingEvents();
1673	return True;
1674
1675	def setStorageControllerPortCount(self, sController, iPortCount):
1676	"""
1677	Set maximum ports count for storage controller
1678	"""
1679	try:
1680	oCtl = self.o.machine.getStorageControllerByName(sController)
1681	oCtl.portCount = iPortCount
1682	self.oTstDrv.processPendingEvents()
1683	reporter.log('set controller "%s" port count to value %d' % (sController, iPortCount))
1684	return True
1685	except:
1686	reporter.log('unable to set storage controller "%s" ports count to %d' % (sController, iPortCount))
1687
1688	return False
1689
1690	def setStorageControllerHostIoCache(self, sController, fUseHostIoCache):
1691	"""
1692	Set maximum ports count for storage controller
1693	"""
1694	try:
1695	oCtl = self.o.machine.getStorageControllerByName(sController);
1696	oCtl.useHostIOCache = fUseHostIoCache;
1697	self.oTstDrv.processPendingEvents();
1698	reporter.log('set controller "%s" host I/O cache setting to %r' % (sController, fUseHostIoCache));
1699	return True;
1700	except:
1701	reporter.log('unable to set storage controller "%s" host I/O cache setting to %r' % (sController, fUseHostIoCache));
1702
1703	return False;
1704
1705	def setBootOrder(self, iPosition, eType):
1706	"""
1707	Set guest boot order type
1708	@param iPosition boot order position
1709	@param eType device type (vboxcon.DeviceType_HardDisk,
1710	vboxcon.DeviceType_DVD, vboxcon.DeviceType_Floppy)
1711	"""
1712	try:
1713	self.o.machine.setBootOrder(iPosition, eType)
1714	except:
1715	return reporter.errorXcpt('Unable to set boot order.')
1716
1717	reporter.log('Set boot order [%d] for device %s' % (iPosition, str(eType)))
1718	self.oTstDrv.processPendingEvents();
1719
1720	return True
1721
1722	def setStorageControllerType(self, eType, sController = "IDE Controller"):
1723	"""
1724	Similar to ensureControllerAttached, except it will change the type.
1725	"""
1726	try:
1727	oCtl = self.o.machine.getStorageControllerByName(sController);
1728	except:
1729	(eBus, _) = _ControllerNameToBusAndType(sController);
1730	try:
1731	oCtl = self.o.machine.addStorageController(sController, eBus);
1732	reporter.log('added storage controller "%s" (bus %s) to %s' % (sController, eBus, self.sName));
1733	except:
1734	reporter.errorXcpt('addStorageController("%s",%s) failed on "%s"' % (sController, eBus, self.sName) );
1735	return False;
1736	try:
1737	oCtl.controllerType = eType;
1738	except:
1739	reporter.errorXcpt('failed to set controller type of "%s" on "%s" to %s' % (sController, self.sName, eType) );
1740	return False;
1741	reporter.log('set controller type of "%s" on "%s" to %s' % (sController, self.sName, eType) );
1742	self.oTstDrv.processPendingEvents();
1743	return True;
1744
1745	def attachDvd(self, sImage = None, sController = "IDE Controller", iPort = 1, iDevice = 0):
1746	"""
1747	Attaches a DVD drive to a VM, optionally with an ISO inserted.
1748	Returns True on success and False on failure. Error information is logged.
1749	"""
1750	# Input validation.
1751	if sImage is not None and not self.oTstDrv.isResourceFile(sImage)\
1752	and not os.path.isabs(sImage): ## fixme - testsuite unzip ++
1753	reporter.fatal('"%s" is not in the resource set' % (sImage));
1754	return None;
1755
1756	if not self.ensureControllerAttached(sController):
1757	return False;
1758
1759	# Find/register the image if specified.
1760	oImage = None;
1761	sImageUuid = "";
1762	if sImage is not None:
1763	sFullName = self.oTstDrv.getFullResourceName(sImage)
1764	try:
1765	oImage = self.oVBox.findDVDImage(sFullName);
1766	except:
1767	try:
1768	if self.fpApiVer >= 4.1:
1769	oImage = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_DVD, vboxcon.AccessMode_ReadOnly, False);
1770	elif self.fpApiVer >= 4.0:
1771	oImage = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_DVD, vboxcon.AccessMode_ReadOnly);
1772	else:
1773	oImage = self.oVBox.openDVDImage(sFullName, "");
1774	except vbox.ComException as oXcpt:
1775	if oXcpt.errno != -1:
1776	reporter.errorXcpt('failed to open DVD image "%s" xxx' % (sFullName));
1777	else:
1778	reporter.errorXcpt('failed to open DVD image "%s" yyy' % (sFullName));
1779	return False;
1780	except:
1781	reporter.errorXcpt('failed to open DVD image "%s"' % (sFullName));
1782	return False;
1783	try:
1784	sImageUuid = oImage.id;
1785	except:
1786	reporter.errorXcpt('failed to get the UUID of "%s"' % (sFullName));
1787	return False;
1788
1789	# Attach the DVD.
1790	fRc = True;
1791	try:
1792	if self.fpApiVer >= 4.0:
1793	self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_DVD, oImage);
1794	else:
1795	self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_DVD, sImageUuid);
1796	except:
1797	reporter.errorXcpt('attachDevice("%s",%s,%s,HardDisk,"%s") failed on "%s"' \
1798	% (sController, iPort, iDevice, sImageUuid, self.sName) );
1799	fRc = False;
1800	else:
1801	reporter.log('attached DVD to %s, image="%s"' % (self.sName, sImage));
1802	self.oTstDrv.processPendingEvents();
1803	return fRc;
1804
1805	def attachHd(self, sHd, sController = "IDE Controller", iPort = 0, iDevice = 0, fImmutable = True, fForceResource = True):
1806	"""
1807	Attaches a HD to a VM.
1808	Returns True on success and False on failure. Error information is logged.
1809	"""
1810	# Input validation.
1811	if fForceResource and not self.oTstDrv.isResourceFile(sHd):
1812	reporter.fatal('"%s" is not in the resource set' % (sHd,));
1813	return None;
1814
1815	if not self.ensureControllerAttached(sController):
1816	return False;
1817
1818	# Find the HD, registering it if necessary (as immutable).
1819	if fForceResource:
1820	sFullName = self.oTstDrv.getFullResourceName(sHd);
1821	else:
1822	sFullName = sHd;
1823	try:
1824	oHd = self.oVBox.findHardDisk(sFullName);
1825	except:
1826	try:
1827	if self.fpApiVer >= 4.1:
1828	oHd = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_HardDisk, vboxcon.AccessMode_ReadOnly, False);
1829	elif self.fpApiVer >= 4.0:
1830	oHd = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_HardDisk, vboxcon.AccessMode_ReadOnly);
1831	else:
1832	oHd = self.oVBox.openHardDisk(sFullName, vboxcon.AccessMode_ReadOnly, False, "", False, "");
1833	except:
1834	reporter.errorXcpt('failed to open hd "%s"' % (sFullName));
1835	return False;
1836	try:
1837	if fImmutable:
1838	oHd.type = vboxcon.MediumType_Immutable;
1839	else:
1840	oHd.type = vboxcon.MediumType_Normal;
1841	except:
1842	if fImmutable:
1843	reporter.errorXcpt('failed to set hd "%s" immutable' % (sHd));
1844	else:
1845	reporter.errorXcpt('failed to set hd "%s" normal' % (sHd));
1846	return False;
1847
1848	# Attach it.
1849	fRc = True;
1850	try:
1851	if self.fpApiVer >= 4.0:
1852	self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_HardDisk, oHd);
1853	else:
1854	self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_HardDisk, oHd.id);
1855	except:
1856	reporter.errorXcpt('attachDevice("%s",%s,%s,HardDisk,"%s") failed on "%s"' \
1857	% (sController, iPort, iDevice, oHd.id, self.sName) );
1858	fRc = False;
1859	else:
1860	reporter.log('attached "%s" to %s' % (sHd, self.sName));
1861	self.oTstDrv.processPendingEvents();
1862	return fRc;
1863
1864	def createBaseHd(self, sHd, sFmt = "VDI", cb = 1010241024*1024, cMsTimeout = 60000, tMediumVariant = None):
1865	"""
1866	Creates a base HD.
1867	Returns Medium object on success and None on failure. Error information is logged.
1868	"""
1869	if tMediumVariant is None:
1870	tMediumVariant = (vboxcon.MediumVariant_Standard, );
1871
1872	try:
1873	if self.fpApiVer >= 5.0:
1874	oHd = self.oVBox.createMedium(sFmt, sHd, vboxcon.AccessMode_ReadWrite, vboxcon.DeviceType_HardDisk);
1875	else:
1876	oHd = self.oVBox.createHardDisk(sFmt, sHd);
1877	oProgressXpcom = oHd.createBaseStorage(cb, tMediumVariant);
1878	oProgress = ProgressWrapper(oProgressXpcom, self.oVBoxMgr, self.oTstDrv, 'create base disk %s' % (sHd));
1879	oProgress.wait(cMsTimeout);
1880	oProgress.logResult();
1881	except:
1882	reporter.errorXcpt('failed to create base hd "%s"' % (sHd));
1883	oHd = None
1884
1885	return oHd;
1886
1887	def createDiffHd(self, oParentHd, sHd, sFmt = "VDI"):
1888	"""
1889	Creates a differencing HD.
1890	Returns Medium object on success and None on failure. Error information is logged.
1891	"""
1892	# Detect the proper format if requested
1893	if sFmt is None:
1894	try:
1895	oHdFmt = oParentHd.mediumFormat;
1896	lstCaps = self.oVBoxMgr.getArray(oHdFmt, 'capabilities');
1897	if vboxcon.MediumFormatCapabilities_Differencing in lstCaps:
1898	sFmt = oHdFmt.id;
1899	else:
1900	sFmt = 'VDI';
1901	except:
1902	reporter.errorXcpt('failed to get preferred diff format for "%s"' % (sHd));
1903	return None;
1904	try:
1905	if self.fpApiVer >= 5.0:
1906	oHd = self.oVBox.createMedium(sFmt, sHd, vboxcon.AccessMode_ReadWrite, vboxcon.DeviceType_HardDisk);
1907	else:
1908	oHd = self.oVBox.createHardDisk(sFmt, sHd);
1909	oProgressXpcom = oParentHd.createDiffStorage(oHd, (vboxcon.MediumVariant_Standard, ))
1910	oProgress = ProgressWrapper(oProgressXpcom, self.oVBoxMgr, self.oTstDrv, 'create diff disk %s' % (sHd));
1911	oProgress.wait();
1912	oProgress.logResult();
1913	except:
1914	reporter.errorXcpt('failed to create diff hd "%s"' % (sHd));
1915	oHd = None
1916
1917	return oHd;
1918
1919	def createAndAttachHd(self, sHd, sFmt = "VDI", sController = "IDE Controller", cb = 1010241024*1024, # pylint: disable=R0913
1920	iPort = 0, iDevice = 0, fImmutable = True, cMsTimeout = 60000, tMediumVariant = None):
1921	"""
1922	Creates and attaches a HD to a VM.
1923	Returns True on success and False on failure. Error information is logged.
1924	"""
1925	if not self.ensureControllerAttached(sController):
1926	return False;
1927
1928	oHd = self.createBaseHd(sHd, sFmt, cb, cMsTimeout, tMediumVariant);
1929	if oHd is None:
1930	return False;
1931
1932	fRc = True;
1933	try:
1934	if fImmutable:
1935	oHd.type = vboxcon.MediumType_Immutable;
1936	else:
1937	oHd.type = vboxcon.MediumType_Normal;
1938	except:
1939	if fImmutable:
1940	reporter.errorXcpt('failed to set hd "%s" immutable' % (sHd));
1941	else:
1942	reporter.errorXcpt('failed to set hd "%s" normal' % (sHd));
1943	fRc = False;
1944
1945	# Attach it.
1946	if fRc is True:
1947	try:
1948	if self.fpApiVer >= 4.0:
1949	self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_HardDisk, oHd);
1950	else:
1951	self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_HardDisk, oHd.id);
1952	except:
1953	reporter.errorXcpt('attachDevice("%s",%s,%s,HardDisk,"%s") failed on "%s"' \
1954	% (sController, iPort, iDevice, oHd.id, self.sName) );
1955	fRc = False;
1956	else:
1957	reporter.log('attached "%s" to %s' % (sHd, self.sName));
1958
1959	# Delete disk in case of an error
1960	if fRc is False:
1961	try:
1962	oProgressCom = oHd.deleteStorage();
1963	except:
1964	reporter.errorXcpt('deleteStorage() for disk %s failed' % (sHd,));
1965	else:
1966	oProgress = ProgressWrapper(oProgressCom, self.oVBoxMgr, self.oTstDrv, 'delete disk %s' % (sHd));
1967	oProgress.wait();
1968	oProgress.logResult();
1969
1970	self.oTstDrv.processPendingEvents();
1971	return fRc;
1972
1973	def detachHd(self, sController = "IDE Controller", iPort = 0, iDevice = 0):
1974	"""
1975	Detaches a HD, if attached, and returns a reference to it (IMedium).
1976
1977	In order to delete the detached medium, the caller must first save
1978	the changes made in this session.
1979
1980	Returns (fRc, oHd), where oHd is None unless fRc is True, and fRc is
1981	your standard success indicator. Error information is logged.
1982	"""
1983
1984	# What's attached?
1985	try:
1986	oHd = self.o.machine.getMedium(sController, iPort, iDevice);
1987	except:
1988	if self.oVBoxMgr.xcptIsOurXcptKind() \
1989	and self.oVBoxMgr.xcptIsEqual(None, self.oVBoxMgr.constants.VBOX_E_OBJECT_NOT_FOUND):
1990	reporter.log('No HD attached (to %s %s:%s)' % (sController, iPort, iDevice));
1991	return (True, None);
1992	return (reporter.errorXcpt('Error getting media at port %s, device %s, on %s.'
1993	% (iPort, iDevice, sController)), None);
1994	# Detach it.
1995	try:
1996	self.o.machine.detachDevice(sController, iPort, iDevice);
1997	except:
1998	return (reporter.errorXcpt('detachDevice("%s",%s,%s) failed on "%s"' \
1999	% (sController, iPort, iDevice, self.sName) ), None);
2000	reporter.log('detached HD ("%s",%s,%s) from %s' % (sController, iPort, iDevice, self.sName));
2001	return (True, oHd);
2002
2003	def attachFloppy(self, sFloppy, sController = "Floppy Controller", iPort = 0, iDevice = 0):
2004	"""
2005	Attaches a floppy image to a VM.
2006	Returns True on success and False on failure. Error information is logged.
2007	"""
2008	# Input validation.
2009	## @todo Fix this wrt to bootsector-xxx.img from the validationkit.zip.
2010	##if not self.oTstDrv.isResourceFile(sFloppy):
2011	## reporter.fatal('"%s" is not in the resource set' % (sFloppy));
2012	## return None;
2013
2014	if not self.ensureControllerAttached(sController):
2015	return False;
2016
2017	# Find the floppy image, registering it if necessary (as immutable).
2018	sFullName = self.oTstDrv.getFullResourceName(sFloppy);
2019	try:
2020	oFloppy = self.oVBox.findFloppyImage(sFullName);
2021	except:
2022	try:
2023	if self.fpApiVer >= 4.1:
2024	oFloppy = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_Floppy, vboxcon.AccessMode_ReadOnly, False);
2025	elif self.fpApiVer >= 4.0:
2026	oFloppy = self.oVBox.openMedium(sFullName, vboxcon.DeviceType_Floppy, vboxcon.AccessMode_ReadOnly);
2027	else:
2028	oFloppy = self.oVBox.openFloppyImage(sFullName, "");
2029	except:
2030	reporter.errorXcpt('failed to open floppy "%s"' % (sFullName));
2031	return False;
2032	## @todo the following works but causes trouble below (asserts in main).
2033	#try:
2034	# oFloppy.type = vboxcon.MediumType_Immutable;
2035	#except:
2036	# reporter.errorXcpt('failed to make floppy "%s" immutable' % (sFullName));
2037	# return False;
2038
2039	# Attach it.
2040	fRc = True;
2041	try:
2042	if self.fpApiVer >= 4.0:
2043	self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_Floppy, oFloppy);
2044	else:
2045	self.o.machine.attachDevice(sController, iPort, iDevice, vboxcon.DeviceType_Floppy, oFloppy.id);
2046	except:
2047	reporter.errorXcpt('attachDevice("%s",%s,%s,Floppy,"%s") failed on "%s"' \
2048	% (sController, iPort, iDevice, oFloppy.id, self.sName) );
2049	fRc = False;
2050	else:
2051	reporter.log('attached "%s" to %s' % (sFloppy, self.sName));
2052	self.oTstDrv.processPendingEvents();
2053	return fRc;
2054
2055	def setupNic(self, sType, sXXX):
2056	"""
2057	Sets up a NIC to a VM.
2058	Returns True on success and False on failure. Error information is logged.
2059	"""
2060	if sType == "PCNet": enmType = vboxcon.NetworkAdapterType_Am79C973;
2061	elif sType == "PCNetOld": enmType = vboxcon.NetworkAdapterType_Am79C970A;
2062	elif sType == "E1000": enmType = vboxcon.NetworkAdapterType_I82545EM; # MT Server
2063	elif sType == "E1000Desk": enmType = vboxcon.NetworkAdapterType_I82540EM; # MT Desktop
2064	elif sType == "E1000Srv2": enmType = vboxcon.NetworkAdapterType_I82543GC; # T Server
2065	elif sType == "Virtio": enmType = vboxcon.NetworkAdapterType_Virtio;
2066	else:
2067	reporter.error('Invalid NIC type: "%s" (sXXX=%s)' % (sType, sXXX));
2068	return False;
2069	## @todo Implement me!
2070	if enmType is not None: pass
2071	return True;
2072
2073	def setupAudio(self, eAudioControllerType, fEnable = True, eAudioDriverType = None):
2074	"""
2075	Sets up audio.
2076
2077	:param eAudioControllerType: The audio controller type (vboxcon.AudioControllerType_XXX).
2078	:param fEnable: Whether to enable or disable the audio controller (default enable).
2079	:param eAudioDriverType: The audio driver type (vboxcon.AudioDriverType_XXX), picks something suitable
2080	if None is passed (default).
2081	"""
2082	try: oAudioAdapter = self.o.machine.audioAdapter;
2083	except: return reporter.errorXcpt('Failed to get the audio adapter.');
2084
2085	try: oAudioAdapter.audioController = eAudioControllerType;
2086	except: return reporter.errorXcpt('Failed to set the audio controller to %s.' % (eAudioControllerType,));
2087
2088	if eAudioDriverType is None:
2089	sHost = utils.getHostOs()
2090	if sHost == 'darwin': eAudioDriverType = vboxcon.AudioDriverType_CoreAudio;
2091	elif sHost == 'win': eAudioDriverType = vboxcon.AudioDriverType_DirectSound;
2092	elif sHost == 'linux': eAudioDriverType = vboxcon.AudioDriverType_Pulse;
2093	elif sHost == 'solaris': eAudioDriverType = vboxcon.AudioDriverType_OSS;
2094	else:
2095	reporter.error('PORTME: Do not know which audio driver to pick for: %s!' % (sHost,));
2096	eAudioDriverType = vboxcon.AudioDriverType_Null;
2097
2098	try: oAudioAdapter.audioDriver = eAudioDriverType;
2099	except: return reporter.errorXcpt('Failed to set the audio driver to %s.' % (eAudioDriverType,))
2100
2101	try: oAudioAdapter.enabled = fEnable;
2102	except: return reporter.errorXcpt('Failed to set the "enabled" property to %s.' % (fEnable,));
2103
2104	reporter.log('set audio adapter type to %d, driver to %d, and enabled to %s'
2105	% (eAudioControllerType, eAudioDriverType, fEnable,));
2106	self.oTstDrv.processPendingEvents();
2107	return True;
2108
2109	def setupPreferredConfig(self): # pylint: disable=R0914
2110	"""
2111	Configures the VM according to the preferences of the guest type.
2112	"""
2113	try:
2114	sOsTypeId = self.o.machine.OSTypeId;
2115	except:
2116	reporter.errorXcpt('failed to obtain the OSTypeId for "%s"' % (self.sName));
2117	return False;
2118
2119	try:
2120	oOsType = self.oVBox.getGuestOSType(sOsTypeId);
2121	except:
2122	reporter.errorXcpt('getGuestOSType("%s") failed for "%s"' % (sOsTypeId, self.sName));
2123	return False;
2124
2125	# get the attributes.
2126	try:
2127	#sFamilyId = oOsType.familyId;
2128	#f64Bit = oOsType.is64Bit;
2129	fIoApic = oOsType.recommendedIOAPIC;
2130	fVirtEx = oOsType.recommendedVirtEx;
2131	cMBRam = oOsType.recommendedRAM;
2132	cMBVRam = oOsType.recommendedVRAM;
2133	#cMBHdd = oOsType.recommendedHDD;
2134	eNicType = oOsType.adapterType;
2135	if self.fpApiVer >= 3.2:
2136	if self.fpApiVer >= 4.2:
2137	fPae = oOsType.recommendedPAE;
2138	fUsbHid = oOsType.recommendedUSBHID;
2139	fHpet = oOsType.recommendedHPET;
2140	eStorCtlType = oOsType.recommendedHDStorageController;
2141	else:
2142	fPae = oOsType.recommendedPae;
2143	fUsbHid = oOsType.recommendedUsbHid;
2144	fHpet = oOsType.recommendedHpet;
2145	eStorCtlType = oOsType.recommendedHdStorageController;
2146	eFirmwareType = oOsType.recommendedFirmware;
2147	else:
2148	fPae = False;
2149	fUsbHid = False;
2150	fHpet = False;
2151	eFirmwareType = -1;
2152	eStorCtlType = vboxcon.StorageControllerType_PIIX4;
2153	if self.fpApiVer >= 4.0:
2154	eAudioCtlType = oOsType.recommendedAudioController;
2155	except:
2156	reporter.errorXcpt('exception reading IGuestOSType(%s) attribute' % (sOsTypeId));
2157	self.oTstDrv.processPendingEvents();
2158	return False;
2159	self.oTstDrv.processPendingEvents();
2160
2161	# Do the setting. Continue applying settings on error in case the
2162	# caller ignores the return code
2163	fRc = True;
2164	if not self.enableIoApic(fIoApic): fRc = False;
2165	if not self.enableVirtEx(fVirtEx): fRc = False;
2166	if not self.enablePae(fPae): fRc = False;
2167	if not self.setRamSize(cMBRam): fRc = False;
2168	if not self.setVRamSize(cMBVRam): fRc = False;
2169	if not self.setNicType(eNicType, 0): fRc = False;
2170	if self.fpApiVer >= 3.2:
2171	if not self.setFirmwareType(eFirmwareType): fRc = False;
2172	if not self.enableUsbHid(fUsbHid): fRc = False;
2173	if not self.enableHpet(fHpet): fRc = False;
2174	if eStorCtlType == vboxcon.StorageControllerType_PIIX3 \
2175	or eStorCtlType == vboxcon.StorageControllerType_PIIX4 \
2176	or eStorCtlType == vboxcon.StorageControllerType_ICH6:
2177	if not self.setStorageControllerType(eStorCtlType, "IDE Controller"):
2178	fRc = False;
2179	if self.fpApiVer >= 4.0:
2180	if not self.setupAudio(eAudioCtlType): fRc = False;
2181
2182	return fRc;
2183
2184	def addUsbDeviceFilter(self, sName, sVendorId = None, sProductId = None, sRevision = None, # pylint: disable=R0913
2185	sManufacturer = None, sProduct = None, sSerialNumber = None,
2186	sPort = None, sRemote = None):
2187	"""
2188	Creates a USB device filter and inserts it into the VM.
2189	Returns True on success.
2190	Returns False on failure (logged).
2191	"""
2192	fRc = True;
2193
2194	try:
2195	oUsbDevFilter = self.o.machine.USBDeviceFilters.createDeviceFilter(sName);
2196	oUsbDevFilter.active = True;
2197	if sVendorId is not None:
2198	oUsbDevFilter.vendorId = sVendorId;
2199	if sProductId is not None:
2200	oUsbDevFilter.productId = sProductId;
2201	if sRevision is not None:
2202	oUsbDevFilter.revision = sRevision;
2203	if sManufacturer is not None:
2204	oUsbDevFilter.manufacturer = sManufacturer;
2205	if sProduct is not None:
2206	oUsbDevFilter.product = sProduct;
2207	if sSerialNumber is not None:
2208	oUsbDevFilter.serialnumber = sSerialNumber;
2209	if sPort is not None:
2210	oUsbDevFilter.port = sPort;
2211	if sRemote is not None:
2212	oUsbDevFilter.remote = sRemote;
2213	try:
2214	self.o.machine.USBDeviceFilters.insertDeviceFilter(0, oUsbDevFilter);
2215	except:
2216	reporter.errorXcpt('insertDeviceFilter(%s) failed on "%s"' \
2217	% (0, self.sName) );
2218	fRc = False;
2219	else:
2220	reporter.log('inserted USB device filter "%s" to %s' % (sName, self.sName));
2221	except:
2222	reporter.errorXcpt('createDeviceFilter("%s") failed on "%s"' \
2223	% (sName, self.sName) );
2224	fRc = False;
2225	return fRc;
2226
2227	def getGuestPropertyValue(self, sName):
2228	"""
2229	Gets a guest property value.
2230	Returns the value on success, None on failure (logged).
2231	"""
2232	try:
2233	sValue = self.o.machine.getGuestPropertyValue(sName);
2234	except:
2235	reporter.errorXcpt('IMachine::getGuestPropertyValue("%s") failed' % (sName));
2236	return None;
2237	return sValue;
2238
2239	def setGuestPropertyValue(self, sName, sValue):
2240	"""
2241	Sets a guest property value.
2242	Returns the True on success, False on failure (logged).
2243	"""
2244	try:
2245	self.o.machine.setGuestPropertyValue(sName, sValue);
2246	except:
2247	reporter.errorXcpt('IMachine::setGuestPropertyValue("%s","%s") failed' % (sName, sValue));
2248	return False;
2249	return True;
2250
2251	def delGuestPropertyValue(self, sName):
2252	"""
2253	Deletes a guest property value.
2254	Returns the True on success, False on failure (logged).
2255	"""
2256	try:
2257	oMachine = self.o.machine;
2258	if self.fpApiVer >= 4.2:
2259	oMachine.deleteGuestProperty(sName);
2260	else:
2261	oMachine.setGuestPropertyValue(sName, '');
2262	except:
2263	reporter.errorXcpt('Unable to delete guest property "%s"' % (sName,));
2264	return False;
2265	return True;
2266
2267	def setExtraData(self, sKey, sValue):
2268	"""
2269	Sets extra data.
2270	Returns the True on success, False on failure (logged).
2271	"""
2272	try:
2273	self.o.machine.setExtraData(sKey, sValue);
2274	except:
2275	reporter.errorXcpt('IMachine::setExtraData("%s","%s") failed' % (sKey, sValue));
2276	return False;
2277	return True;
2278
2279	def getExtraData(self, sKey):
2280	"""
2281	Gets extra data.
2282	Returns value on success, None on failure.
2283	"""
2284	try:
2285	sValue = self.o.machine.getExtraData(sKey)
2286	except:
2287	reporter.errorXcpt('IMachine::setExtraData("%s","%s") failed' % (sKey, sValue))
2288	return None
2289	return sValue
2290
2291	def setupTeleporter(self, fEnabled=True, uPort = 6500, sAddress = '', sPassword = ''):
2292	"""
2293	Sets up the teleporter for the VM.
2294	Returns True on success, False on failure (logged).
2295	"""
2296	try:
2297	self.o.machine.teleporterAddress = sAddress;
2298	self.o.machine.teleporterPort = uPort;
2299	self.o.machine.teleporterPassword = sPassword;
2300	self.o.machine.teleporterEnabled = fEnabled;
2301	except:
2302	reporter.errorXcpt('setupTeleporter(%s, %s, %s, %s)' % (fEnabled, sPassword, uPort, sAddress));
2303	return False;
2304	return True;
2305
2306	def enableTeleporter(self, fEnable=True):
2307	"""
2308	Enables or disables the teleporter of the VM.
2309	Returns True on success, False on failure (logged).
2310	"""
2311	try:
2312	self.o.machine.teleporterEnabled = fEnable;
2313	except:
2314	reporter.errorXcpt('IMachine::teleporterEnabled=%s failed' % (fEnable));
2315	return False;
2316	return True;
2317
2318	def teleport(self, sHostname = 'localhost', uPort = 6500, sPassword = 'password', cMsMaxDowntime = 250):
2319	"""
2320	Wrapper around the IConsole::teleport() method.
2321	Returns a progress object on success, None on failure (logged).
2322	"""
2323	reporter.log2('"%s"::teleport(%s,%s,%s,%s)...' % (self.sName, sHostname, uPort, sPassword, cMsMaxDowntime));
2324	try:
2325	oProgress = self.o.console.teleport(sHostname, uPort, sPassword, cMsMaxDowntime)
2326	except:
2327	reporter.errorXcpt('IConsole::teleport(%s,%s,%s,%s) failed' % (sHostname, uPort, sPassword, cMsMaxDowntime));
2328	return None;
2329	return ProgressWrapper(oProgress, self.oVBoxMgr, self.oTstDrv, 'teleport %s' % (self.sName,));
2330
2331	def getOsType(self):
2332	"""
2333	Gets the IGuestOSType interface for the machine.
2334
2335	return IGuestOSType interface on success, None + errorXcpt on failure.
2336	No exceptions raised.
2337	"""
2338	try:
2339	sOsTypeId = self.o.machine.OSTypeId;
2340	except:
2341	reporter.errorXcpt('failed to obtain the OSTypeId for "%s"' % (self.sName));
2342	return None;
2343
2344	try:
2345	oOsType = self.oVBox.getGuestOSType(sOsTypeId);
2346	except:
2347	reporter.errorXcpt('getGuestOSType("%s") failed for "%s"' % (sOsTypeId, self.sName));
2348	return None;
2349
2350	return oOsType;
2351
2352	def setOsType(self, sNewTypeId):
2353	"""
2354	Changes the OS type.
2355
2356	returns True on success, False + errorXcpt on failure.
2357	No exceptions raised.
2358	"""
2359	try:
2360	self.o.machine.OSTypeId = sNewTypeId;
2361	except:
2362	reporter.errorXcpt('failed to set the OSTypeId for "%s" to "%s"' % (self.sName, sNewTypeId));
2363	return False;
2364	return True;
2365
2366
2367	def setParavirtProvider(self, iProvider):
2368	"""
2369	Sets a paravirtualisation provider.
2370	Returns the True on success, False on failure (logged).
2371	"""
2372	try:
2373	self.o.machine.paravirtProvider = iProvider
2374	except:
2375	reporter.errorXcpt('Unable to set paravirtualisation provider "%s"' % (iProvider,))
2376	return False;
2377	return True;
2378
2379
2380	def setupSerialToRawFile(self, iSerialPort, sRawFile):
2381	"""
2382	Enables the given serial port (zero based) and redirects it to sRawFile.
2383	Returns the True on success, False on failure (logged).
2384	"""
2385	try:
2386	oPort = self.o.machine.getSerialPort(iSerialPort);
2387	except:
2388	fRc = reporter.errorXcpt('failed to get serial port #%u' % (iSerialPort,));
2389	else:
2390	try:
2391	oPort.path = sRawFile;
2392	except:
2393	fRc = reporter.errorXcpt('failed to set the "path" property on serial port #%u to "%s"'
2394	% (iSerialPort, sRawFile));
2395	else:
2396	try:
2397	oPort.hostMode = vboxcon.PortMode_RawFile;
2398	except:
2399	fRc = reporter.errorXcpt('failed to set the "hostMode" property on serial port #%u to PortMode_RawFile'
2400	% (iSerialPort,));
2401	else:
2402	try:
2403	oPort.enabled = True;
2404	except:
2405	fRc = reporter.errorXcpt('failed to set the "enable" property on serial port #%u to True'
2406	% (iSerialPort,));
2407	else:
2408	reporter.log('set SerialPort[%s].enabled/hostMode/path=True/RawFile/%s' % (iSerialPort, sRawFile,));
2409	fRc = True;
2410	self.oTstDrv.processPendingEvents();
2411	return fRc;
2412
2413
2414	def enableSerialPort(self, iSerialPort):
2415	"""
2416	Enables the given serial port setting the initial port mode to disconnected.
2417	"""
2418	try:
2419	oPort = self.o.machine.getSerialPort(iSerialPort);
2420	except:
2421	fRc = reporter.errorXcpt('failed to get serial port #%u' % (iSerialPort,));
2422	else:
2423	try:
2424	oPort.hostMode = vboxcon.PortMode_Disconnected;
2425	except:
2426	fRc = reporter.errorXcpt('failed to set the "hostMode" property on serial port #%u to PortMode_Disconnected'
2427	% (iSerialPort,));
2428	else:
2429	try:
2430	oPort.enabled = True;
2431	except:
2432	fRc = reporter.errorXcpt('failed to set the "enable" property on serial port #%u to True'
2433	% (iSerialPort,));
2434	else:
2435	reporter.log('set SerialPort[%s].enabled/hostMode/=True/Disconnected' % (iSerialPort,));
2436	fRc = True;
2437	self.oTstDrv.processPendingEvents();
2438	return fRc;
2439
2440
2441	def changeSerialPortAttachment(self, iSerialPort, ePortMode, sPath, fServer):
2442	"""
2443	Changes the attachment of the given serial port to the attachment config given.
2444	"""
2445	try:
2446	oPort = self.o.machine.getSerialPort(iSerialPort);
2447	except:
2448	fRc = reporter.errorXcpt('failed to get serial port #%u' % (iSerialPort,));
2449	else:
2450	try:
2451	# Change port mode to disconnected first so changes get picked up by a potentially running VM.
2452	oPort.hostMode = vboxcon.PortMode_Disconnected;
2453	except:
2454	fRc = reporter.errorXcpt('failed to set the "hostMode" property on serial port #%u to PortMode_Disconnected'
2455	% (iSerialPort,));
2456	else:
2457	try:
2458	oPort.path = sPath;
2459	oPort.server = fServer;
2460	oPort.hostMode = ePortMode;
2461	except:
2462	fRc = reporter.errorXcpt('failed to configure the serial port');
2463	else:
2464	reporter.log('set SerialPort[%s].hostMode/path/server=%s/%s/%s'
2465	% (iSerialPort, ePortMode, sPath, fServer));
2466	fRc = True;
2467	self.oTstDrv.processPendingEvents();
2468	return fRc;
2469
2470	#
2471	# IConsole wrappers.
2472	#
2473
2474	def powerOff(self, fFudgeOnFailure = True):
2475	"""
2476	Powers off the VM.
2477
2478	Returns True on success.
2479	Returns False on IConsole::powerDown() failure.
2480	Returns None if the progress object returns failure.
2481	"""
2482	#
2483	# Deregister event handler before we power off the VM, otherwise we're
2484	# racing for VM process termination and cause misleading spurious
2485	# error messages in the event handling code, because the event objects
2486	# disappear.
2487	#
2488	# Note! Doing this before powerDown to try prevent numerous smoketest
2489	# timeouts on XPCOM hosts.
2490	#
2491	self.deregisterEventHandlerForTask();
2492
2493
2494	# Try power if off.
2495	try:
2496	oProgress = self.o.console.powerDown();
2497	except:
2498	reporter.logXcpt('IConsole::powerDown failed on %s' % (self.sName));
2499	if fFudgeOnFailure:
2500	self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
2501	self.waitForTask(1000); # fudge
2502	return False;
2503
2504	# Wait on power off operation to complete.
2505	rc = self.oTstDrv.waitOnProgress(oProgress);
2506	if rc < 0:
2507	self.close();
2508	if fFudgeOnFailure:
2509	vbox.reportError(oProgress, 'powerDown for "%s" failed' % (self.sName));
2510	self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
2511	return None;
2512
2513	# Wait for the VM to really power off or we'll fail to open a new session to it.
2514	self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
2515	return self.waitForTask(30 * 1000); # fudge
2516
2517	def saveState(self, fPause = True):
2518	"""
2519	Saves state of the VM.
2520
2521	Returns True on success.
2522	Returns False on IConsole::saveState() failure.
2523	Returns None if the progress object returns Failure.
2524	"""
2525
2526	if fPause is True \
2527	and self.oVM.state is vboxcon.MachineState_Running:
2528	self.o.console.pause();
2529	if self.oVM.state is not vboxcon.MachineState_Paused:
2530	reporter.error('pause for "%s" failed' % (self.sName));
2531	# Try saving state.
2532	try:
2533	if self.fpApiVer >= 5.0:
2534	oProgress = self.o.machine.saveState()
2535	else:
2536	oProgress = self.o.console.saveState()
2537	except:
2538	reporter.logXcpt('IMachine::saveState failed on %s' % (self.sName));
2539	return False;
2540
2541	# Wait for saving state operation to complete.
2542	rc = self.oTstDrv.waitOnProgress(oProgress);
2543	if rc < 0:
2544	self.close();
2545	return None;
2546
2547	# Wait for the VM to really terminate or we'll fail to open a new session to it.
2548	self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
2549	return self.waitForTask(30 * 1000); # fudge
2550
2551	def discardSavedState(self, fRemove = True):
2552	"""
2553	Discards saved state of the VM.
2554
2555	Returns True on success.
2556	Returns False on IConsole::discardSaveState() failure.
2557	"""
2558
2559	try:
2560	if self.fpApiVer >= 5.0:
2561	self.o.machine.discardSavedState(fRemove)
2562	else:
2563	self.o.console.discardSavedState(fRemove)
2564	except:
2565	reporter.logXcpt('IMachine::discardSavedState failed on %s' % (self.sName))
2566	return False
2567	return True
2568
2569	def restoreSnapshot(self, oSnapshot, fFudgeOnFailure = True):
2570	"""
2571	Restores the given snapshot.
2572
2573	Returns True on success.
2574	Returns False on IMachine::restoreSnapshot() failure.
2575	Returns None if the progress object returns failure.
2576	"""
2577	try:
2578	if self.fpApiVer >= 5.0:
2579	oProgress = self.o.machine.restoreSnapshot(oSnapshot);
2580	else:
2581	oProgress = self.o.console.restoreSnapshot(oSnapshot);
2582	except:
2583	reporter.logXcpt('IMachine::restoreSnapshot failed on %s' % (self.sName));
2584	if fFudgeOnFailure:
2585	self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
2586	self.waitForTask(1000); # fudge
2587	return False;
2588
2589	rc = self.oTstDrv.waitOnProgress(oProgress);
2590	if rc < 0:
2591	self.close();
2592	if fFudgeOnFailure:
2593	vbox.reportError(oProgress, 'restoreSnapshot for "%s" failed' % (self.sName));
2594	return None;
2595
2596	return self.waitForTask(30 * 1000);
2597
2598	def deleteSnapshot(self, oSnapshot, fFudgeOnFailure = True, cMsTimeout = 30 * 1000):
2599	"""
2600	Deletes the given snapshot merging the diff image into the base.
2601
2602	Returns True on success.
2603	Returns False on IMachine::deleteSnapshot() failure.
2604	"""
2605	try:
2606	if self.fpApiVer >= 5.0:
2607	oProgressCom = self.o.machine.deleteSnapshot(oSnapshot);
2608	else:
2609	oProgressCom = self.o.console.deleteSnapshot(oSnapshot);
2610	oProgress = ProgressWrapper(oProgressCom, self.oVBoxMgr, self.oTstDrv, 'Delete Snapshot %s' % (oSnapshot));
2611	oProgress.wait(cMsTimeout);
2612	oProgress.logResult();
2613	except:
2614	reporter.logXcpt('IMachine::deleteSnapshot failed on %s' % (self.sName));
2615	if fFudgeOnFailure:
2616	self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
2617	self.waitForTask(1000); # fudge
2618	return False;
2619
2620	return True;
2621
2622	def takeSnapshot(self, sName, sDescription = '', fPause = True, fFudgeOnFailure = True, cMsTimeout = 30 * 1000):
2623	"""
2624	Takes a snapshot with the given name
2625
2626	Returns True on success.
2627	Returns False on IMachine::takeSnapshot() or VM state change failure.
2628	"""
2629	try:
2630	if fPause is True \
2631	and self.oVM.state is vboxcon.MachineState_Running:
2632	self.o.console.pause();
2633	if self.fpApiVer >= 5.0:
2634	(oProgressCom, _) = self.o.machine.takeSnapshot(sName, sDescription, True);
2635	else:
2636	oProgressCom = self.o.console.takeSnapshot(sName, sDescription);
2637	oProgress = ProgressWrapper(oProgressCom, self.oVBoxMgr, self.oTstDrv, 'Take Snapshot %s' % (sName));
2638	oProgress.wait(cMsTimeout);
2639	oProgress.logResult();
2640	except:
2641	reporter.logXcpt('IMachine::takeSnapshot failed on %s' % (self.sName));
2642	if fFudgeOnFailure:
2643	self.oTstDrv.waitOnDirectSessionClose(self.oVM, 5000); # fudge
2644	self.waitForTask(1000); # fudge
2645	return False;
2646
2647	if fPause is True \
2648	and self.oVM.state is vboxcon.MachineState_Paused:
2649	self.o.console.resume();
2650
2651	return True;
2652
2653	def findSnapshot(self, sName):
2654	"""
2655	Returns the snapshot object with the given name
2656
2657	Returns snapshot object on success.
2658	Returns None if there is no snapshot with the given name.
2659	"""
2660	return self.oVM.findSnapshot(sName);
2661
2662	def takeScreenshot(self, sFilename, iScreenId=0):
2663	"""
2664	Take screenshot from the given display and save it to specified file.
2665
2666	Returns True on success
2667	Returns False on failure.
2668	"""
2669	try:
2670	if self.fpApiVer >= 5.0:
2671	iWidth, iHeight, _, _, _, _ = self.o.console.display.getScreenResolution(iScreenId)
2672	aPngData = self.o.console.display.takeScreenShotToArray(iScreenId, iWidth, iHeight,
2673	vboxcon.BitmapFormat_PNG)
2674	else:
2675	iWidth, iHeight, _, _, _ = self.o.console.display.getScreenResolution(iScreenId)
2676	aPngData = self.o.console.display.takeScreenShotPNGToArray(iScreenId, iWidth, iHeight)
2677	except:
2678	reporter.logXcpt("Unable to take screenshot")
2679	return False
2680
2681	oFile = open(sFilename, 'wb')
2682	oFile.write(aPngData)
2683	oFile.close()
2684
2685	return True
2686
2687	def attachUsbDevice(self, sUuid, sCaptureFilename = None):
2688	"""
2689	Attach given USB device UUID to the VM.
2690
2691	Returns True on success
2692	Returns False on failure.
2693	"""
2694	fRc = True;
2695	try:
2696	if sCaptureFilename is None:
2697	self.o.console.attachUSBDevice(sUuid, '');
2698	else:
2699	self.o.console.attachUSBDevice(sUuid, sCaptureFilename);
2700	except:
2701	reporter.logXcpt('Unable to attach USB device %s' % (sUuid,));
2702	fRc = False;
2703
2704	return fRc;
2705
2706	def detachUsbDevice(self, sUuid):
2707	"""
2708	Detach given USB device UUID from the VM.
2709
2710	Returns True on success
2711	Returns False on failure.
2712	"""
2713	fRc = True;
2714	try:
2715	_ = self.o.console.detachUSBDevice(sUuid);
2716	except:
2717	reporter.logXcpt('Unable to detach USB device %s' % (sUuid,));
2718	fRc = False;
2719
2720	return fRc;
2721
2722
2723	#
2724	# IMachineDebugger wrappers.
2725	#
2726
2727	def queryOsKernelLog(self):
2728	"""
2729	Tries to get the OS kernel log using the VM debugger interface.
2730
2731	Returns string containing the kernel log on success.
2732	Returns None on failure.
2733	"""
2734	sOsKernelLog = None;
2735	try:
2736	self.o.console.debugger.loadPlugIn('all');
2737	except:
2738	reporter.logXcpt('Unable to load debugger plugins');
2739	else:
2740	try:
2741	sOsDetected = self.o.console.debugger.detectOS();
2742	except:
2743	reporter.logXcpt('Failed to detect the guest OS');
2744	else:
2745	try:
2746	sOsKernelLog = self.o.console.debugger.queryOSKernelLog(0);
2747	except:
2748	reporter.logXcpt('Unable to get the guest OS (%s) kernel log' % (sOsDetected,));
2749	return sOsKernelLog;
2750
2751	def queryDbgInfo(self, sItem, sArg = '', sDefault = None):
2752	"""
2753	Simple wrapper around IMachineDebugger::info.
2754
2755	Returns string on success, sDefault on failure (logged).
2756	"""
2757	try:
2758	return self.o.console.debugger.info(sItem, sArg);
2759	except:
2760	reporter.logXcpt('Unable to query "%s" with arg "%s"' % (sItem, sArg,));
2761	return sDefault;
2762
2763	def queryDbgInfoVgaText(self, sArg = 'all'):
2764	"""
2765	Tries to get the 'info vgatext' output, provided we're in next mode.
2766
2767	Returns string containing text on success.
2768	Returns None on failure or not text mode.
2769	"""
2770	sVgaText = None;
2771	try:
2772	sVgaText = self.o.console.debugger.info('vgatext', sArg);
2773	if sVgaText.startswith('Not in text mode!'):
2774	sVgaText = None;
2775	except:
2776	reporter.logXcpt('Unable to query vgatext with arg "%s"' % (sArg,));
2777	return sVgaText;
2778
2779	def queryDbgGuestStack(self, iCpu = 0):
2780	"""
2781	Returns the guest stack for the given VCPU.
2782
2783	Returns string containing the guest stack for the selected VCPU on success.
2784	Returns None on failure.
2785	"""
2786
2787	#
2788	# Load all plugins first and try to detect the OS so we can
2789	# get nicer stack traces.
2790	#
2791	try:
2792	self.o.console.debugger.loadPlugIn('all');
2793	except:
2794	reporter.logXcpt('Unable to load debugger plugins');
2795	else:
2796	try:
2797	sOsDetected = self.o.console.debugger.detectOS();
2798	_ = sOsDetected;
2799	except:
2800	reporter.logXcpt('Failed to detect the guest OS');
2801
2802	sGuestStack = None;
2803	try:
2804	sGuestStack = self.o.console.debugger.dumpGuestStack(iCpu);
2805	except:
2806	reporter.logXcpt('Unable to query guest stack for CPU %s' % (iCpu, ));
2807
2808	return sGuestStack;
2809
2810
2811	#
2812	# Other methods.
2813	#
2814
2815	def getPrimaryIp(self):
2816	"""
2817	Tries to obtain the primary IP address of the guest via the guest
2818	properties.
2819
2820	Returns IP address on success.
2821	Returns empty string on failure.
2822	"""
2823	sIpAddr = self.getGuestPropertyValue('/VirtualBox/GuestInfo/Net/0/V4/IP');
2824	if vbox.isIpAddrValid(sIpAddr):
2825	return sIpAddr;
2826	return '';
2827
2828	def getPid(self):
2829	"""
2830	Gets the process ID for the direct session unless it's ourselves.
2831	"""
2832	if self.uPid is None and self.o is not None and self.fRemoteSession:
2833	try:
2834	if self.fpApiVer >= 4.2:
2835	uPid = self.o.machine.sessionPID;
2836	else:
2837	uPid = self.o.machine.sessionPid;
2838	if uPid != os.getpid() and uPid != 0xffffffff:
2839	self.uPid = uPid;
2840	except Exception as oXcpt:
2841	if vbox.ComError.equal(oXcpt, vbox.ComError.E_UNEXPECTED):
2842	try:
2843	if self.fpApiVer >= 4.2:
2844	uPid = self.oVM.sessionPID;
2845	else:
2846	uPid = self.oVM.sessionPid;
2847	if uPid != os.getpid() and uPid != 0xffffffff:
2848	self.uPid = uPid;
2849	except:
2850	reporter.log2Xcpt();
2851	else:
2852	reporter.log2Xcpt();
2853	if self.uPid is not None:
2854	reporter.log2('getPid: %u' % (self.uPid,));
2855	self.fPidFile = self.oTstDrv.pidFileAdd(self.uPid, 'vm_%s' % (self.sName,), # Set-uid-to-root is similar to SUDO.
2856	fSudo = True);
2857	return self.uPid;
2858
2859	def addLogsToReport(self, cReleaseLogs = 1):
2860	"""
2861	Retrieves and adds the release and debug logs to the test report.
2862	"""
2863	fRc = True;
2864
2865	# Add each of the requested release logs to the report.
2866	for iLog in range(0, cReleaseLogs):
2867	try:
2868	if self.fpApiVer >= 3.2:
2869	sLogFile = self.oVM.queryLogFilename(iLog);
2870	elif iLog > 0:
2871	sLogFile = '%s/VBox.log' % (self.oVM.logFolder,);
2872	else:
2873	sLogFile = '%s/VBox.log.%u' % (self.oVM.logFolder, iLog);
2874	except:
2875	reporter.logXcpt('iLog=%s' % (iLog,));
2876	fRc = False;
2877	else:
2878	if sLogFile is not None and sLogFile != '': # the None bit is for a 3.2.0 bug.
2879	reporter.addLogFile(sLogFile, 'log/release/vm', '%s #%u' % (self.sName, iLog),
2880	sAltName = '%s-%s' % (self.sName, os.path.basename(sLogFile),));
2881
2882	# Now for the hardened windows startup log.
2883	try:
2884	sLogFile = os.path.join(self.oVM.logFolder, 'VBoxHardening.log');
2885	except:
2886	reporter.logXcpt();
2887	fRc = False;
2888	else:
2889	if os.path.isfile(sLogFile):
2890	reporter.addLogFile(sLogFile, 'log/release/vm', '%s hardening log' % (self.sName, ),
2891	sAltName = '%s-%s' % (self.sName, os.path.basename(sLogFile),));
2892
2893	# Now for the debug log.
2894	if self.sLogFile is not None and os.path.isfile(self.sLogFile):
2895	reporter.addLogFile(self.sLogFile, 'log/debug/vm', '%s debug' % (self.sName, ),
2896	sAltName = '%s-%s' % (self.sName, os.path.basename(self.sLogFile),));
2897
2898	return fRc;
2899
2900	def registerDerivedEventHandler(self, oSubClass, dArgs = None, fMustSucceed = True):
2901	"""
2902	Create an instance of the given ConsoleEventHandlerBase sub-class and
2903	register it.
2904
2905	The new instance is returned on success. None is returned on error.
2906	"""
2907
2908	# We need a console object.
2909	try:
2910	oConsole = self.o.console;
2911	except Exception as oXcpt:
2912	if fMustSucceed or vbox.ComError.notEqual(oXcpt, vbox.ComError.E_UNEXPECTED):
2913	reporter.errorXcpt('Failed to get ISession::console for "%s"' % (self.sName, ));
2914	return None;
2915
2916	# Add the base class arguments.
2917	dArgsCopy = dArgs.copy() if dArgs is not None else dict();
2918	dArgsCopy['oSession'] = self;
2919	dArgsCopy['oConsole'] = oConsole;
2920	sLogSuffix = 'on %s' % (self.sName,)
2921	return oSubClass.registerDerivedEventHandler(self.oVBoxMgr, self.fpApiVer, oSubClass, dArgsCopy,
2922	oConsole, 'IConsole', 'IConsoleCallback',
2923	fMustSucceed = fMustSucceed, sLogSuffix = sLogSuffix);
2924
2925	def enableVmmDevTestingPart(self, fEnabled, fEnableMMIO = False):
2926	"""
2927	Enables the testing part of the VMMDev.
2928
2929	Returns True on success and False on failure. Error information is logged.
2930	"""
2931	fRc = True;
2932	try:
2933	self.o.machine.setExtraData('VBoxInternal/Devices/VMMDev/0/Config/TestingEnabled',
2934	'1' if fEnabled else '');
2935	self.o.machine.setExtraData('VBoxInternal/Devices/VMMDev/0/Config/TestingMMIO',
2936	'1' if fEnableMMIO and fEnabled else '');
2937	except:
2938	reporter.errorXcpt('VM name "%s", fEnabled=%s' % (self.sName, fEnabled));
2939	fRc = False;
2940	else:
2941	reporter.log('set VMMDevTesting=%s for "%s"' % (fEnabled, self.sName));
2942	self.oTstDrv.processPendingEvents();
2943	return fRc;
2944
2945	#
2946	# Test eXecution Service methods.
2947	#
2948
2949	def txsConnectViaTcp(self, cMsTimeout = 10*60000, sIpAddr = None, sMacAddr = None, fNatForwardingForTxs = False):
2950	"""
2951	Connects to the TXS using TCP/IP as transport. If no IP or MAC is
2952	addresses are specified, we'll get the IP from the guest additions.
2953
2954	Returns a TxsConnectTask object on success, None + log on failure.
2955	"""
2956	# If the VM is configured with a NAT interface, connect to local host.
2957	fReversedSetup = False;
2958	fUseNatForTxs = False;
2959	if sIpAddr is None:
2960	try:
2961	oNic = self.oVM.getNetworkAdapter(0);
2962	if oNic.attachmentType == vboxcon.NetworkAttachmentType_NAT:
2963	fUseNatForTxs = True;
2964	except:
2965	reporter.errorXcpt();
2966	return None;
2967	if fUseNatForTxs:
2968	fReversedSetup = not fNatForwardingForTxs;
2969	sIpAddr = '127.0.0.1';
2970
2971	# Kick off the task.
2972	try:
2973	oTask = TxsConnectTask(self, cMsTimeout, sIpAddr, sMacAddr, fReversedSetup);
2974	except:
2975	reporter.errorXcpt();
2976	oTask = None;
2977	return oTask;
2978
2979	def txsTryConnectViaTcp(self, cMsTimeout, sHostname, fReversed = False):
2980	"""
2981	Attempts to connect to a TXS instance.
2982
2983	Returns True if a connection was established, False if not (only grave
2984	failures are logged as errors).
2985
2986	Note! The timeout is more of a guideline...
2987	"""
2988
2989	if sHostname is None or sHostname.strip() == '':
2990	raise base.GenError('Empty sHostname is not implemented yet');
2991
2992	oTxsSession = txsclient.tryOpenTcpSession(cMsTimeout, sHostname, fReversedSetup = fReversed,
2993	cMsIdleFudge = cMsTimeout // 2);
2994	if oTxsSession is None:
2995	return False;
2996
2997	# Wait for the connect task to time out.
2998	self.oTstDrv.addTask(oTxsSession);
2999	self.oTstDrv.processPendingEvents();
3000	oRc = self.oTstDrv.waitForTasks(cMsTimeout);
3001	self.oTstDrv.removeTask(oTxsSession);
3002	if oRc != oTxsSession:
3003	if oRc is not None:
3004	reporter.log('oRc=%s, expected %s' % (oRc, oTxsSession));
3005	self.oTstDrv.processPendingEvents();
3006	oTxsSession.cancelTask(); # this is synchronous
3007	return False;
3008
3009	# Check the status.
3010	reporter.log2('TxsSession is ready, isSuccess() -> %s.' % (oTxsSession.isSuccess(),));
3011	if not oTxsSession.isSuccess():
3012	return False;
3013
3014	reporter.log2('Disconnecting from TXS...');
3015	return oTxsSession.syncDisconnect();
3016
3017
3018
3019	class TxsConnectTask(TdTaskBase):
3020	"""
3021	Class that takes care of connecting to a VM.
3022	"""
3023
3024	class TxsConnectTaskVBoxCallback(vbox.VirtualBoxEventHandlerBase):
3025	""" Class for looking for IPv4 address changes on interface 0."""
3026	def __init__(self, dArgs):
3027	vbox.VirtualBoxEventHandlerBase.__init__(self, dArgs); # pylint: disable=W0233
3028	self.oParentTask = dArgs['oParentTask'];
3029	self.sMachineId = dArgs['sMachineId'];
3030
3031	def onGuestPropertyChange(self, sMachineId, sName, sValue, sFlags):
3032	"""Look for IP address."""
3033	reporter.log2('onGuestPropertyChange(,%s,%s,%s,%s)' % (sMachineId, sName, sValue, sFlags));
3034	if sMachineId == self.sMachineId \
3035	and sName == '/VirtualBox/GuestInfo/Net/0/V4/IP':
3036	oParentTask = self.oParentTask;
3037	if oParentTask:
3038	oParentTask._setIp(sValue); # pylint: disable=W0212
3039
3040
3041	def __init__(self, oSession, cMsTimeout, sIpAddr, sMacAddr, fReversedSetup):
3042	TdTaskBase.__init__(self, utils.getCallerName());
3043	self.cMsTimeout = cMsTimeout;
3044	self.sIpAddr = None;
3045	self.sNextIpAddr = None;
3046	self.sMacAddr = sMacAddr;
3047	self.fReversedSetup = fReversedSetup;
3048	self.oVBoxEventHandler = None;
3049	self.oTxsSession = None;
3050
3051	# Skip things we don't implement.
3052	if sMacAddr is not None:
3053	reporter.error('TxsConnectTask does not implement sMacAddr yet');
3054	raise base.GenError();
3055
3056	reporter.log2('TxsConnectTask: sIpAddr=%s fReversedSetup=%s' % (sIpAddr, fReversedSetup))
3057	if fReversedSetup is True:
3058	self._openTcpSession(sIpAddr, fReversedSetup = True);
3059	elif sIpAddr is not None and sIpAddr.strip() != '':
3060	self._openTcpSession(sIpAddr, cMsIdleFudge = 5000);
3061	else:
3062	#
3063	# If we've got no IP address, register callbacks that listens for
3064	# the primary network adaptor of the VM to set a IPv4 guest prop.
3065	# Note! The order in which things are done here is kind of important.
3066	#
3067
3068	# 0. The caller zaps the property before starting the VM.
3069	#try:
3070	# oSession.delGuestPropertyValue('/VirtualBox/GuestInfo/Net/0/V4/IP');
3071	#except:
3072	# reporter.logXcpt();
3073
3074	# 1. Register the callback / event listener object.
3075	dArgs = {'oParentTask':self, 'sMachineId':oSession.o.machine.id};
3076	self.oVBoxEventHandler = oSession.oVBox.registerDerivedEventHandler(self.TxsConnectTaskVBoxCallback, dArgs);
3077
3078	# 2. Query the guest properties.
3079	try:
3080	sIpAddr = oSession.getGuestPropertyValue('/VirtualBox/GuestInfo/Net/0/V4/IP');
3081	except:
3082	reporter.errorXcpt('IMachine::getGuestPropertyValue("/VirtualBox/GuestInfo/Net/0/V4/IP") failed');
3083	self._deregisterEventHandler();
3084	raise;
3085	else:
3086	if sIpAddr is not None:
3087	self._setIp(sIpAddr);
3088	# end __init__
3089
3090	def __del__(self):
3091	""" Make sure we deregister the callback. """
3092	self._deregisterEventHandler();
3093	return TdTaskBase.__del__(self);
3094
3095	def toString(self):
3096	return '<%s cMsTimeout=%s, sIpAddr=%s, sNextIpAddr=%s, sMacAddr=%s, fReversedSetup=%s,' \
3097	' oTxsSession=%s oVBoxEventHandler=%s>' \
3098	% (TdTaskBase.toString(self), self.cMsTimeout, self.sIpAddr, self.sNextIpAddr, self.sMacAddr, self.fReversedSetup,
3099	self.oTxsSession, self.oVBoxEventHandler);
3100
3101	def _deregisterEventHandler(self):
3102	"""Deregisters the event handler."""
3103	fRc = True;
3104	oVBoxEventHandler = self.oVBoxEventHandler;
3105	if oVBoxEventHandler is not None:
3106	self.oVBoxEventHandler = None;
3107	fRc = oVBoxEventHandler.unregister();
3108	oVBoxEventHandler.oParentTask = None; # Try avoid cylic deps.
3109	return fRc;
3110
3111	def _setIp(self, sIpAddr, fInitCall = False):
3112	"""Called when we get an IP. Will create a TXS session and signal the task."""
3113	sIpAddr = sIpAddr.strip();
3114
3115	if sIpAddr is not None \
3116	and sIpAddr != '':
3117	if vbox.isIpAddrValid(sIpAddr) or fInitCall:
3118	try:
3119	for s in sIpAddr.split('.'):
3120	i = int(s);
3121	if str(i) != s:
3122	raise Exception();
3123	except:
3124	reporter.fatalXcpt();
3125	else:
3126	reporter.log('TxsConnectTask: opening session to ip "%s"' % (sIpAddr));
3127	self._openTcpSession(sIpAddr, cMsIdleFudge = 5000);
3128	return None;
3129
3130	reporter.log('TxsConnectTask: Ignoring Bad ip "%s"' % (sIpAddr));
3131	else:
3132	reporter.log2('TxsConnectTask: Ignoring empty ip "%s"' % (sIpAddr));
3133	return None;
3134
3135	def _openTcpSession(self, sIpAddr, uPort = None, fReversedSetup = False, cMsIdleFudge = 0):
3136	"""
3137	Calls txsclient.openTcpSession and switches our task to reflect the
3138	state of the subtask.
3139	"""
3140	self.oCv.acquire();
3141	if self.oTxsSession is None:
3142	reporter.log2('_openTcpSession: sIpAddr=%s, uPort=%d, fReversedSetup=%s' % \
3143	(sIpAddr, uPort if uPort is not None else 0, fReversedSetup));
3144	self.sIpAddr = sIpAddr;
3145	self.oTxsSession = txsclient.openTcpSession(self.cMsTimeout, sIpAddr, uPort, \
3146	fReversedSetup, cMsIdleFudge);
3147	self.oTxsSession.setTaskOwner(self);
3148	else:
3149	self.sNextIpAddr = sIpAddr;
3150	reporter.log2('_openTcpSession: sNextIpAddr=%s' % (sIpAddr,));
3151	self.oCv.release();
3152	return None;
3153
3154	def notifyAboutReadyTask(self, oTxsSession):
3155	"""
3156	Called by the TXS session task when it's done.
3157
3158	We'll signal the task completed or retry depending on the result.
3159	"""
3160
3161	self.oCv.acquire();
3162
3163	# Disassociate ourselves with the session (avoid cyclic ref)
3164	oTxsSession.setTaskOwner(None);
3165	fSuccess = oTxsSession.isSuccess();
3166	if self.oTxsSession is not None:
3167	if not fSuccess:
3168	self.oTxsSession = None;
3169	if fSuccess and self.fReversedSetup:
3170	self.sIpAddr = oTxsSession.oTransport.sHostname;
3171	else:
3172	fSuccess = False;
3173
3174	# Signal done, or retry?
3175	fDeregister = False;
3176	if fSuccess \
3177	or self.fReversedSetup \
3178	or self.getAgeAsMs() >= self.cMsTimeout:
3179	self.signalTaskLocked();
3180	fDeregister = True;
3181	else:
3182	sIpAddr = self.sNextIpAddr if self.sNextIpAddr is not None else self.sIpAddr;
3183	self._openTcpSession(sIpAddr, cMsIdleFudge = 5000);
3184
3185	self.oCv.release();
3186
3187	# If we're done, deregister the callback (w/o owning lock). It will
3188	if fDeregister:
3189	self._deregisterEventHandler();
3190	return True;
3191
3192	#
3193	# Public methods
3194	#
3195
3196	def getResult(self):
3197	"""
3198	Returns the connected TXS session object on success.
3199	Returns None on failure or if the task has not yet completed.
3200	"""
3201	self.oCv.acquire();
3202	oTxsSession = self.oTxsSession;
3203	self.oCv.release();
3204
3205	if oTxsSession is not None and not oTxsSession.isSuccess():
3206	oTxsSession = None;
3207	return oTxsSession;
3208
3209	def cancelTask(self):
3210	""" Cancels the task. """
3211	self._deregisterEventHandler(); # (make sure to avoid cyclic fun)
3212	self.oCv.acquire();
3213	if not self.fSignalled:
3214	oTxsSession = self.oTxsSession;
3215	if oTxsSession is not None:
3216	self.oCv.release();
3217	oTxsSession.setTaskOwner(None);
3218	oTxsSession.cancelTask();
3219	oTxsSession.waitForTask(1000);
3220	self.oCv.acquire();
3221	self.signalTaskLocked();
3222	self.oCv.release();
3223	return True;
3224

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

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

Download in other formats: