tdAutostart1.py@ 84641

Last change on this file since 84641 was 84641, checked in by vboxsync, 5 years ago
Main: bugref:9341: Improved some testcase reporting
Property svn:eol-style set to `LF` Property svn:executable set to ``* Property svn:keywords set to `Author Date Id Revision`
File size: 72.2 KB

Line
1	#!/usr/bin/env python
2	# -- coding: utf-8 --
3
4	"""
5	AUtostart testcase using.
6	"""
7
8	__copyright__ = \
9	"""
10	Copyright (C) 2013-2020 Oracle Corporation
11
12	This file is part of VirtualBox Open Source Edition (OSE), as
13	available from http://www.virtualbox.org. This file is free software;
14	you can redistribute it and/or modify it under the terms of the GNU
15	General Public License (GPL) as published by the Free Software
16	Foundation, in version 2 as it comes in the "COPYING" file of the
17	VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19
20	The contents of this file may alternatively be used under the terms
21	of the Common Development and Distribution License Version 1.0
22	(CDDL) only, as it comes in the "COPYING.CDDL" file of the
23	VirtualBox OSE distribution, in which case the provisions of the
24	CDDL are applicable instead of those of the GPL.
25
26	You may elect to license modified versions of this file under the
27	terms and conditions of either the GPL or the CDDL or both.
28	"""
29	__version__ = "$Id: tdAutostart1.py 84641 2020-06-02 13:57:33Z vboxsync $"
30
31
32	# Standard Python imports.
33	import os;
34	import sys;
35	import re;
36	import ssl;
37
38	# Python 3 hacks:
39	if sys.version_info[0] < 3:
40	import urllib2 as urllib; # pylint: disable=import-error,no-name-in-module
41	from urllib2 import ProxyHandler as urllib_ProxyHandler; # pylint: disable=import-error,no-name-in-module
42	from urllib2 import build_opener as urllib_build_opener; # pylint: disable=import-error,no-name-in-module
43	else:
44	import urllib; # pylint: disable=import-error,no-name-in-module
45	from urllib.request import ProxyHandler as urllib_ProxyHandler; # pylint: disable=import-error,no-name-in-module
46	from urllib.request import build_opener as urllib_build_opener; # pylint: disable=import-error,no-name-in-module
47
48
49	# Only the main script needs to modify the path.
50	try: __file__
51	except: __file__ = sys.argv[0];
52	g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))));
53	sys.path.append(g_ksValidationKitDir);
54
55	# Validation Kit imports.
56	from testdriver import reporter;
57	from testdriver import base;
58	from testdriver import vbox;
59	from testdriver import vboxcon;
60	from testdriver import vboxwrappers;
61	from common import utils;
62
63	# Python 3 hacks:
64	if sys.version_info[0] >= 3:
65	long = int # pylint: disable=redefined-builtin,invalid-name
66	xrange = range; # pylint: disable=redefined-builtin,invalid-name
67
68
69	class VBoxManageStdOutWrapper(object):
70	""" Parser for VBoxManage list runningvms """
71	def __init__(self):
72	self.sVmRunning = '';
73
74	def __del__(self):
75	self.close();
76
77	def close(self):
78	"""file.close"""
79	return;
80
81	def read(self, cb):
82	"""file.read"""
83	_ = cb;
84	return "";
85
86	def write(self, sText):
87	"""VBoxManage stdout write"""
88	if sText is None:
89	return None;
90
91	try: sText = str(sText); # pylint: disable=redefined-variable-type
92	except: pass;
93
94	asLines = sText.splitlines();
95	for sLine in asLines:
96	sLine = sLine.strip();
97
98	reporter.log('Logging: ' + sLine);
99
100	# Extract the value
101	idxVmNameStart = sLine.find('"');
102	if idxVmNameStart == -1:
103	raise Exception('VBoxManageStdOutWrapper: Invalid output');
104
105	idxVmNameStart += 1;
106	idxVmNameEnd = idxVmNameStart;
107	while sLine[idxVmNameEnd] != '"':
108	idxVmNameEnd += 1;
109
110	self.sVmRunning = sLine[idxVmNameStart:idxVmNameEnd];
111	reporter.log('Logging: ' + self.sVmRunning);
112
113	return None;
114
115
116	def downloadFile(sUrlFile, sDstFile, sLocalPrefix, fnLog, fnError = None, fNoProxies=True):
117	"""
118	Downloads the given file if an URL is given, otherwise assume it's
119	something on the build share and copy it from there.
120
121	Raises no exceptions, returns log + success indicator instead.
122
123	Note! This method may use proxies configured on the system and the
124	http_proxy, ftp_proxy, no_proxy environment variables.
125
126	"""
127	if fnError is None:
128	fnError = fnLog;
129
130	if sUrlFile.startswith('http://') \
131	or sUrlFile.startswith('https://') \
132	or sUrlFile.startswith('ftp://'):
133	# Download the file.
134	fnLog('Downloading "%s" to "%s"...' % (sUrlFile, sDstFile));
135	try:
136	# Disable SSL certificate verification for our servers
137	ssl_ctx = ssl.create_default_context();
138	ssl_ctx.check_hostname = False;
139	ssl_ctx.verify_mode = ssl.CERT_NONE;
140
141	## @todo We get 404.html content instead of exceptions here, which is confusing and should be addressed.
142	if not fNoProxies:
143	oOpener = urllib_build_opener(urllib.HTTPSHandler(context = ssl_ctx));
144	else:
145	oOpener = urllib_build_opener(urllib.HTTPSHandler(context = ssl_ctx), urllib_ProxyHandler(proxies = dict()));
146	oSrc = oOpener.open(sUrlFile);
147	oDst = utils.openNoInherit(sDstFile, 'wb');
148	oDst.write(oSrc.read());
149	oDst.close();
150	oSrc.close();
151	except Exception as oXcpt:
152	fnError('Error downloading "%s" to "%s": %s' % (sUrlFile, sDstFile, oXcpt));
153	return False;
154	else:
155	# Assumes file from the build share.
156	sSrcPath = os.path.join(sLocalPrefix, sUrlFile);
157	fnLog('Copying "%s" to "%s"...' % (sSrcPath, sDstFile));
158	try:
159	utils.copyFileSimple(sSrcPath, sDstFile);
160	except Exception as oXcpt:
161	fnError('Error copying "%s" to "%s": %s' % (sSrcPath, sDstFile, oXcpt));
162	return False;
163
164	return True;
165
166
167	class tdAutostartOs(object):
168	"""
169	Base autostart helper class to provide common methods.
170	"""
171
172	def __init__(self, oTestDriver, fpApiVer, sGuestAdditionsIso):
173	self.oTestDriver = oTestDriver;
174	self.fpApiVer = fpApiVer;
175	self.sGuestAdditionsIso = sGuestAdditionsIso;
176
177	def _findFile(self, sRegExp, asTestBuildDirs):
178	"""
179	Returns a filepath based on the given regex and paths to look into
180	or None if no matching file is found.
181	"""
182
183	oRegExp = re.compile(sRegExp);
184	for sTestBuildDir in asTestBuildDirs:
185	try:
186	#return most recent file if there are several ones matching the pattern
187	asFiles = [s for s in os.listdir(sTestBuildDir)
188	if os.path.isfile(os.path.join(sTestBuildDir, s))];
189	asFiles = (s for s in asFiles
190	if oRegExp.match(os.path.basename(s))
191	and os.path.exists(sTestBuildDir + '/' + s));
192	asFiles = sorted(asFiles, reverse = True,
193	key = lambda s, sTstBuildDir = sTestBuildDir: os.path.getmtime(os.path.join(sTstBuildDir, s)));
194	if asFiles:
195	return sTestBuildDir + '/' + asFiles[0];
196	except:
197	pass;
198
199	reporter.error('Failed to find a file matching "%s" in %s.' % (sRegExp, ','.join(asTestBuildDirs)));
200	return None;
201
202	def _createAutostartCfg(self, sDefaultPolicy = 'allow', asUserAllow = (), asUserDeny = ()):
203	"""
204	Creates a autostart config for VirtualBox
205	"""
206
207	sVBoxCfg = 'default_policy=' + sDefaultPolicy + '\n';
208
209	for sUserAllow in asUserAllow:
210	sVBoxCfg = sVBoxCfg + sUserAllow + ' = {\n allow = true\n }\n';
211
212	for sUserDeny in asUserDeny:
213	sVBoxCfg = sVBoxCfg + sUserDeny + ' = {\n allow = false\n }\n';
214
215	return sVBoxCfg;
216
217	def createSession(self, oSession, sName, sUser, sPassword, cMsTimeout = 10 * 1000, fIsError = True):
218	"""
219	Creates (opens) a guest session.
220	Returns (True, IGuestSession) on success or (False, None) on failure.
221	"""
222	oGuest = oSession.o.console.guest;
223	if sName is None:
224	sName = "<untitled>";
225
226	reporter.log('Creating session "%s" ...' % (sName,));
227	try:
228	oGuestSession = oGuest.createSession(sUser, sPassword, '', sName);
229	except:
230	# Just log, don't assume an error here (will be done in the main loop then).
231	reporter.maybeErrXcpt(fIsError, 'Creating a guest session "%s" failed; sUser="%s", pw="%s"'
232	% (sName, sUser, sPassword));
233	return (False, None);
234
235	reporter.log('Waiting for session "%s" to start within %dms...' % (sName, cMsTimeout));
236	aeWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start, ];
237	try:
238	waitResult = oGuestSession.waitForArray(aeWaitFor, cMsTimeout);
239
240	#
241	# Be nice to Guest Additions < 4.3: They don't support session handling and
242	# therefore return WaitFlagNotSupported.
243	#
244	if waitResult not in (vboxcon.GuestSessionWaitResult_Start, vboxcon.GuestSessionWaitResult_WaitFlagNotSupported):
245	# Just log, don't assume an error here (will be done in the main loop then).
246	reporter.maybeErr(fIsError, 'Session did not start successfully, returned wait result: %d' % (waitResult,));
247	return (False, None);
248	reporter.log('Session "%s" successfully started' % (sName,));
249	except:
250	# Just log, don't assume an error here (will be done in the main loop then).
251	reporter.maybeErrXcpt(fIsError, 'Waiting for guest session "%s" (usr=%s;pw=%s) to start failed:'
252	% (sName, sUser, sPassword,));
253	return (False, None);
254	return (True, oGuestSession);
255
256	def closeSession(self, oGuestSession, fIsError = True):
257	"""
258	Closes the guest session.
259	"""
260	if oGuestSession is not None:
261	try:
262	sName = oGuestSession.name;
263	except:
264	return reporter.errorXcpt();
265
266	reporter.log('Closing session "%s" ...' % (sName,));
267	try:
268	oGuestSession.close();
269	oGuestSession = None;
270	except:
271	# Just log, don't assume an error here (will be done in the main loop then).
272	reporter.maybeErrXcpt(fIsError, 'Closing guest session "%s" failed:' % (sName,));
273	return False;
274	return True;
275
276	def guestProcessExecute(self, oGuestSession, sTestName, cMsTimeout, sExecName, asArgs = (),
277	fGetStdOut = True, fIsError = True):
278	"""
279	Helper function to execute a program on a guest, specified in the current test.
280	Returns (True, ProcessStatus, ProcessExitCode, ProcessStdOutBuffer) on success or (False, 0, 0, None) on failure.
281	"""
282	_ = sTestName;
283	fRc = True; # Be optimistic.
284
285	reporter.log2('Using session user=%s, name=%s, timeout=%d'
286	% (oGuestSession.user, oGuestSession.name, oGuestSession.timeout,));
287
288	#
289	# Start the process:
290	#
291	reporter.log2('Executing sCmd=%s, timeoutMS=%d, asArgs=%s'
292	% (sExecName, cMsTimeout, asArgs, ));
293	fTaskFlags = [];
294	if fGetStdOut:
295	fTaskFlags = [vboxcon.ProcessCreateFlag_WaitForStdOut,
296	vboxcon.ProcessCreateFlag_WaitForStdErr];
297	try:
298	oProcess = oGuestSession.processCreate(sExecName,
299	asArgs if self.fpApiVer >= 5.0 else asArgs[1:],
300	[], fTaskFlags, cMsTimeout);
301	except:
302	reporter.maybeErrXcpt(fIsError, 'asArgs=%s' % (asArgs,));
303	return (False, 0, 0, None);
304	if oProcess is None:
305	return (reporter.error('oProcess is None! (%s)' % (asArgs,)), 0, 0, None);
306
307	#time.sleep(5); # try this if you want to see races here.
308
309	# Wait for the process to start properly:
310	reporter.log2('Process start requested, waiting for start (%dms) ...' % (cMsTimeout,));
311	iPid = -1;
312	aeWaitFor = [ vboxcon.ProcessWaitForFlag_Start, ];
313	aBuf = None;
314	try:
315	eWaitResult = oProcess.waitForArray(aeWaitFor, cMsTimeout);
316	except:
317	reporter.maybeErrXcpt(fIsError, 'waitforArray failed for asArgs=%s' % (asArgs,));
318	fRc = False;
319	else:
320	try:
321	eStatus = oProcess.status;
322	iPid = oProcess.PID;
323	except:
324	fRc = reporter.errorXcpt('asArgs=%s' % (asArgs,));
325	else:
326	reporter.log2('Wait result returned: %d, current process status is: %d' % (eWaitResult, eStatus,));
327
328	#
329	# Wait for the process to run to completion if necessary.
330	#
331	# Note! The above eWaitResult return value can be ignored as it will
332	# (mostly) reflect the process status anyway.
333	#
334	if eStatus == vboxcon.ProcessStatus_Started:
335
336	# What to wait for:
337	aeWaitFor = [ vboxcon.ProcessWaitForFlag_Terminate,
338	vboxcon.ProcessWaitForFlag_StdOut,
339	vboxcon.ProcessWaitForFlag_StdErr];
340
341	reporter.log2('Process (PID %d) started, waiting for termination (%dms), aeWaitFor=%s ...'
342	% (iPid, cMsTimeout, aeWaitFor));
343	acbFdOut = [0,0,0];
344	while True:
345	try:
346	eWaitResult = oProcess.waitForArray(aeWaitFor, cMsTimeout);
347	except KeyboardInterrupt: # Not sure how helpful this is, but whatever.
348	reporter.error('Process (PID %d) execution interrupted' % (iPid,));
349	try: oProcess.close();
350	except: pass;
351	break;
352	except:
353	fRc = reporter.errorXcpt('asArgs=%s' % (asArgs,));
354	break;
355	reporter.log2('Wait returned: %d' % (eWaitResult,));
356
357	# Process output:
358	for eFdResult, iFd, sFdNm in [ (vboxcon.ProcessWaitResult_StdOut, 1, 'stdout'),
359	(vboxcon.ProcessWaitResult_StdErr, 2, 'stderr'), ]:
360	if eWaitResult in (eFdResult, vboxcon.ProcessWaitResult_WaitFlagNotSupported):
361	reporter.log2('Reading %s ...' % (sFdNm,));
362	try:
363	abBuf = oProcess.Read(1, 64 * 1024, cMsTimeout);
364	except KeyboardInterrupt: # Not sure how helpful this is, but whatever.
365	reporter.error('Process (PID %d) execution interrupted' % (iPid,));
366	try: oProcess.close();
367	except: pass;
368	except:
369	pass; ## @todo test for timeouts and fail on anything else!
370	else:
371	if abBuf:
372	reporter.log2('Process (PID %d) got %d bytes of %s data' % (iPid, len(abBuf), sFdNm,));
373	acbFdOut[iFd] += len(abBuf);
374	## @todo Figure out how to uniform + append!
375	if aBuf:
376	aBuf += str(abBuf);
377	else:
378	aBuf = str(abBuf);
379
380	## Process input (todo):
381	#if eWaitResult in (vboxcon.ProcessWaitResult_StdIn, vboxcon.ProcessWaitResult_WaitFlagNotSupported):
382	# reporter.log2('Process (PID %d) needs stdin data' % (iPid,));
383
384	# Termination or error?
385	if eWaitResult in (vboxcon.ProcessWaitResult_Terminate,
386	vboxcon.ProcessWaitResult_Error,
387	vboxcon.ProcessWaitResult_Timeout,):
388	try: eStatus = oProcess.status;
389	except: fRc = reporter.errorXcpt('asArgs=%s' % (asArgs,));
390	reporter.log2('Process (PID %d) reported terminate/error/timeout: %d, status: %d'
391	% (iPid, eWaitResult, eStatus,));
392	break;
393
394	# End of the wait loop.
395	_, cbStdOut, cbStdErr = acbFdOut;
396
397	try: eStatus = oProcess.status;
398	except: fRc = reporter.errorXcpt('asArgs=%s' % (asArgs,));
399	reporter.log2('Final process status (PID %d) is: %d' % (iPid, eStatus));
400	reporter.log2('Process (PID %d) %d stdout, %d stderr' % (iPid, cbStdOut, cbStdErr));
401
402	#
403	# Get the final status and exit code of the process.
404	#
405	try:
406	uExitStatus = oProcess.status;
407	iExitCode = oProcess.exitCode;
408	except:
409	fRc = reporter.errorXcpt('asArgs=%s' % (asArgs,));
410	reporter.log2('Process (PID %d) has exit code: %d; status: %d ' % (iPid, iExitCode, uExitStatus));
411
412	return (fRc, uExitStatus, iExitCode, aBuf);
413
414	def uploadString(self, oGuestSession, sSrcString, sDst):
415	"""
416	Upload the string into guest.
417	"""
418	fRc = True;
419	try:
420	oFile = oGuestSession.fileOpenEx(sDst, vboxcon.FileAccessMode_ReadWrite, vboxcon.FileOpenAction_CreateOrReplace,
421	vboxcon.FileSharingMode_All, 0, []);
422	except:
423	fRc = reporter.errorXcpt('Upload string failed. Could not create and open the file %s' % sDst);
424	else:
425	try:
426	oFile.write(bytearray(sSrcString), 60*1000);
427	except:
428	fRc = reporter.errorXcpt('Upload string failed. Could not write the string into the file %s' % sDst);
429	try:
430	oFile.close();
431	except:
432	fRc = reporter.errorXcpt('Upload string failed. Could not close the file %s' % sDst);
433
434	return fRc;
435
436	def uploadFile(self, oGuestSession, sSrc, sDst):
437	"""
438	Upload the string into guest.
439	"""
440	fRc = True;
441	try:
442	if self.fpApiVer >= 5.0:
443	oCurProgress = oGuestSession.fileCopyToGuest(sSrc, sDst, [0]);
444	else:
445	oCurProgress = oGuestSession.copyTo(sSrc, sDst, [0]);
446	except:
447	reporter.maybeErrXcpt(True, 'Upload file exception for sSrc="%s":'
448	% (self.sGuestAdditionsIso,));
449	fRc = False;
450	else:
451	if oCurProgress is not None:
452	oWrapperProgress = vboxwrappers.ProgressWrapper(oCurProgress, self.oTestDriver.oVBoxMgr,
453	self.oTestDriver, "uploadFile");
454	oWrapperProgress.wait();
455	if not oWrapperProgress.isSuccess():
456	oWrapperProgress.logResult(fIgnoreErrors = False);
457	fRc = False;
458	else:
459	fRc = reporter.error('No progress object returned');
460
461	return fRc;
462
463	def downloadFile(self, oGuestSession, sSrc, sDst, fIgnoreErrors = False):
464	"""
465	Upload the string into guest.
466	"""
467	fRc = True;
468	try:
469	if self.fpApiVer >= 5.0:
470	oCurProgress = oGuestSession.fileCopyFromGuest(sSrc, sDst, [0]);
471	else:
472	oCurProgress = oGuestSession.copyFrom(sSrc, sDst, [0]);
473	except:
474	if not fIgnoreErrors:
475	reporter.errorXcpt('Download file exception for sSrc="%s":' % (self.sGuestAdditionsIso,));
476	else:
477	reporter.log('warning: Download file exception for sSrc="%s":' % (self.sGuestAdditionsIso,));
478	fRc = False;
479	else:
480	if oCurProgress is not None:
481	oWrapperProgress = vboxwrappers.ProgressWrapper(oCurProgress, self.oTestDriver.oVBoxMgr,
482	self.oTestDriver, "downloadFile");
483	oWrapperProgress.wait();
484	if not oWrapperProgress.isSuccess():
485	oWrapperProgress.logResult(fIgnoreErrors);
486	fRc = False;
487	else:
488	if not fIgnoreErrors:
489	reporter.error('No progress object returned');
490	else:
491	reporter.log('warning: No progress object returned');
492	fRc = False;
493
494	return fRc;
495
496	def downloadFiles(self, oGuestSession, asFiles, fIgnoreErrors = False):
497	"""
498	Convenience function to get files from the guest and stores it
499	into the scratch directory for later (manual) review.
500
501	Returns True on success.
502
503	Returns False on failure, logged.
504	"""
505	fRc = True;
506	for sGstFile in asFiles:
507	sTmpFile = os.path.join(self.oTestDriver.sScratchPath, 'tmp-' + os.path.basename(sGstFile));
508	reporter.log2('Downloading file "%s" to "%s" ...' % (sGstFile, sTmpFile));
509	# First try to remove (unlink) an existing temporary file, as we don't truncate the file.
510	try: os.unlink(sTmpFile);
511	except: pass;
512	## @todo Check for already existing files on the host and create a new
513	# name for the current file to download.
514	fRc = self.downloadFile(oGuestSession, sGstFile, sTmpFile, fIgnoreErrors);
515	if fRc:
516	reporter.addLogFile(sTmpFile, 'misc/other', 'guest - ' + sGstFile);
517	else:
518	if fIgnoreErrors is not True:
519	reporter.error('error downloading file "%s" to "%s"' % (sGstFile, sTmpFile));
520	return fRc;
521	reporter.log('warning: file "%s" was not downloaded, ignoring.' % (sGstFile,));
522	return True;
523
524
525	class tdAutostartOsLinux(tdAutostartOs):
526	"""
527	Autostart support methods for Linux guests.
528	"""
529
530	def __init__(self, oTestDriver, asTestBuildDirs, fpApiVer, sGuestAdditionsIso):
531	tdAutostartOs.__init__(self, oTestDriver, fpApiVer, sGuestAdditionsIso);
532	self.sTestBuild = self._findFile('^VirtualBox-.*\\.run$', asTestBuildDirs);
533	if not self.sTestBuild:
534	raise base.GenError("VirtualBox install package not found");
535
536	def waitVMisReady(self, oSession):
537	"""
538	Waits the VM is ready after start or reboot.
539	Returns result (true or false) and guest session obtained
540	"""
541	# Give the VM a time to reboot
542	self.oTestDriver.sleep(30);
543
544	# Waiting the VM is ready.
545	# To do it, one will try to open the guest session and start the guest process in loop
546
547	cAttempt = 0;
548	oGuestSession = None;
549	fRc = False;
550	while cAttempt < 30:
551	fRc, oGuestSession = self.createSession(oSession, 'Session for user: vbox',
552	'vbox', 'password', 10 * 1000, False);
553	if fRc:
554	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Start a guest process',
555	30 * 1000, '/sbin/ifconfig',
556	['ifconfig',],
557	False, False);
558	if fRc:
559	break;
560
561	self.oTestDriver.sleep(10);
562	cAttempt += 1;
563
564	return (fRc, oGuestSession);
565
566	def rebootVMAndCheckReady(self, oSession, oGuestSession):
567	"""
568	Reboot the VM and wait the VM is ready.
569	Returns result and guest session obtained after reboot
570	"""
571	reporter.testStart('Reboot VM and wait for readiness');
572	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Reboot the VM',
573	30 * 1000, '/usr/bin/sudo',
574	['sudo', 'reboot'],
575	False, True);
576	if not fRc:
577	reporter.error('Calling the reboot utility failed');
578	fRc = self.closeSession(oGuestSession, True) and fRc and True; # pychecker hack.
579	if fRc:
580	(fRc, oGuestSession) = self.waitVMisReady(oSession);
581
582	if not fRc:
583	reporter.error('VM is not ready after reboot');
584	reporter.testDone();
585	return (fRc, oGuestSession);
586
587	def powerDownVM(self, oGuestSession):
588	"""
589	Power down the VM by calling guest process without wating
590	the VM is really powered off. Also, closes the guest session.
591	It helps the terminateBySession to stop the VM without aborting.
592	"""
593
594	if oGuestSession is None:
595	return False;
596
597	reporter.testStart('Power down the VM');
598
599	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Power down the VM',
600	30 * 1000, '/usr/bin/sudo',
601	['sudo', 'poweroff'],
602	False, True);
603	if not fRc:
604	reporter.error('Calling the poweroff utility failed');
605	fRc = self.closeSession(oGuestSession, True) and fRc and True; # pychecker hack.
606
607	if not fRc:
608	reporter.error('Power down the VM failed');
609	reporter.testDone();
610	return fRc;
611
612	def installAdditions(self, oSession, oGuestSession, oVM):
613	"""
614	Install guest additions in the guest.
615	"""
616	reporter.testStart('Install Guest Additions');
617
618	fRc = False;
619	# Install Kernel headers, which are required for actually installing the Linux Additions.
620	if oVM.OSTypeId.startswith('Debian') \
621	or oVM.OSTypeId.startswith('Ubuntu'):
622	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Installing Kernel headers',
623	5 * 60 *1000, '/usr/bin/apt-get',
624	['/usr/bin/apt-get', 'install', '-y',
625	'linux-headers-generic'],
626	False, True);
627	if not fRc:
628	reporter.error('Error installing Kernel headers');
629	else:
630	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Installing Guest Additions depdendencies',
631	5 * 60 *1000, '/usr/bin/apt-get',
632	['/usr/bin/apt-get', 'install', '-y', 'build-essential',
633	'perl'], False, True);
634	if not fRc:
635	reporter.error('Error installing additional installer dependencies');
636
637	elif oVM.OSTypeId.startswith('OL') \
638	or oVM.OSTypeId.startswith('Oracle') \
639	or oVM.OSTypeId.startswith('RHEL') \
640	or oVM.OSTypeId.startswith('Redhat') \
641	or oVM.OSTypeId.startswith('Cent'):
642	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Installing Kernel headers',
643	5 * 60 *1000, '/usr/bin/yum',
644	['/usr/bin/yum', '-y', 'install', 'kernel-headers'],
645	False, True);
646	if not fRc:
647	reporter.error('Error installing Kernel headers');
648	else:
649	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Installing Guest Additions depdendencies',
650	5 * 60 *1000, '/usr/bin/yum',
651	['/usr/bin/yum', '-y', 'install', 'make', 'automake', 'gcc',
652	'kernel-devel', 'dkms', 'bzip2', 'perl'], False, True);
653	if not fRc:
654	reporter.error('Error installing additional installer dependencies');
655
656	else:
657	reporter.error('Installing Linux Additions for the "%s" is not supported yet' % oVM.OSTypeId);
658	fRc = False;
659
660	if fRc:
661	#
662	# The actual install.
663	# Also tell the installer to produce the appropriate log files.
664	#
665
666	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Installing guest additions',
667	5 * 60 *1000, '/usr/bin/sudo',
668	['/usr/bin/sudo', '/bin/sh',
669	'/media/cdrom/VBoxLinuxAdditions.run'],
670	False, True);
671	if fRc:
672	# Due to the GA updates as separate process the above function returns before
673	# the actual installation finished. So just wait until the GA installed
674	fRc = self.closeSession(oGuestSession);
675	if fRc:
676	(fRc, oGuestSession) = self.waitVMisReady(oSession);
677
678	# Download log files.
679	# Ignore errors as all files above might not be present for whatever reason.
680	#
681	if fRc:
682	asLogFile = [];
683	asLogFile.append('/var/log/vboxadd-install.log');
684	self.downloadFiles(oGuestSession, asLogFile, fIgnoreErrors = True);
685	else:
686	reporter.error('Installing guest additions failed: Error occured during vbox installer execution')
687
688	if fRc:
689	(fRc, oGuestSession) = self.rebootVMAndCheckReady(oSession, oGuestSession);
690	if not fRc:
691	reporter.error('Reboot after installing GuestAdditions failed');
692	reporter.testDone();
693	return (fRc, oGuestSession);
694
695	def installVirtualBox(self, oGuestSession):
696	"""
697	Install VirtualBox in the guest.
698	"""
699	if self.sTestBuild is None:
700	return False;
701
702	reporter.testStart('Install Virtualbox into the guest VM');
703
704	fRc = self.uploadFile(oGuestSession, self.sTestBuild,
705	'/tmp/' + os.path.basename(self.sTestBuild));
706	if not fRc:
707	reporter.error('Upload the vbox installer into guest VM failed');
708	else:
709	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession,
710	'Allowing execution for the vbox installer',
711	30 * 1000, '/usr/bin/sudo',
712	['/usr/bin/sudo', '/bin/chmod', '755',
713	'/tmp/' + os.path.basename(self.sTestBuild)],
714	False, True);
715	if not fRc:
716	reporter.error('Allowing execution for the vbox installer failed');
717	if fRc:
718	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Installing VBox',
719	240 * 1000, '/usr/bin/sudo',
720	['/usr/bin/sudo',
721	'/tmp/' + os.path.basename(self.sTestBuild),],
722	False, True);
723	if not fRc:
724	reporter.error('Installing VBox failed');
725	reporter.testDone();
726	return fRc;
727
728	def configureAutostart(self, oGuestSession, sDefaultPolicy = 'allow',
729	asUserAllow = (), asUserDeny = ()):
730	"""
731	Configures the autostart feature in the guest.
732	"""
733	reporter.testStart('Configure autostart');
734	# Create autostart database directory writeable for everyone
735	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Creating autostart database',
736	30 * 1000, '/usr/bin/sudo',
737	['/usr/bin/sudo', '/bin/mkdir', '-m', '1777', '/etc/vbox/autostart.d'],
738	False, True);
739	if not fRc:
740	reporter.error('Creating autostart database failed');
741	# Create /etc/default/virtualbox
742	if fRc:
743	sVBoxCfg = 'VBOXAUTOSTART_CONFIG=/etc/vbox/autostart.cfg\n' \
744	+ 'VBOXAUTOSTART_DB=/etc/vbox/autostart.d\n';
745	fRc = self.uploadString(oGuestSession, sVBoxCfg, '/tmp/virtualbox');
746	if not fRc:
747	reporter.error('Upload to /tmp/virtualbox failed');
748	if fRc:
749	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Moving to destination',
750	30 * 1000, '/usr/bin/sudo',
751	['/usr/bin/sudo', '/bin/mv', '/tmp/virtualbox',
752	'/etc/default/virtualbox'],
753	False, True);
754	if not fRc:
755	reporter.error('Moving the /tmp/virtualbox to destination failed');
756	if fRc:
757	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Setting permissions',
758	30 * 1000, '/usr/bin/sudo',
759	['/usr/bin/sudo', '/bin/chmod', '644',
760	'/etc/default/virtualbox'],
761	False, True);
762	if not fRc:
763	reporter.error('Setting permissions for the virtualbox failed');
764
765	if fRc:
766	sVBoxCfg = self._createAutostartCfg(sDefaultPolicy, asUserAllow, asUserDeny);
767	fRc = self.uploadString(oGuestSession, sVBoxCfg, '/tmp/autostart.cfg');
768	if not fRc:
769	reporter.error('Upload to /tmp/autostart.cfg failed');
770
771	if fRc:
772	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Moving to destination',
773	30 * 1000, '/usr/bin/sudo',
774	['/usr/bin/sudo', '/bin/mv', '/tmp/autostart.cfg',
775	'/etc/vbox/autostart.cfg'],
776	False, True);
777	if not fRc:
778	reporter.error('Moving the /tmp/autostart.cfg to destination failed');
779	if fRc:
780	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Setting permissions',
781	30 * 1000, '/usr/bin/sudo',
782	['/usr/bin/sudo', '/bin/chmod', '644',
783	'/etc/vbox/autostart.cfg'],
784	False, True);
785	if not fRc:
786	reporter.error('Setting permissions for the autostart.cfg failed');
787	reporter.testDone();
788	return fRc;
789
790	def createUser(self, oGuestSession, sUser):
791	"""
792	Create a new user with the given name
793	"""
794	reporter.testStart('Create user %s' % sUser);
795	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Creating new user',
796	30 * 1000, '/usr/bin/sudo',
797	['/usr/bin/sudo', '/usr/sbin/useradd', '-m', '-U',
798	sUser], False, True);
799	if not fRc:
800	reporter.error('Create user %s failed' % sUser);
801	reporter.testDone();
802	return fRc;
803
804	# pylint: enable=too-many-arguments
805
806	def createTestVM(self, oSession, oGuestSession, sUser, sVmName):
807	"""
808	Create a test VM in the guest and enable autostart.
809	Due to the sUser is created whithout password,
810	all calls will be perfomed using 'sudo -u sUser'
811	"""
812
813	_ = oSession;
814
815	reporter.testStart('Create test VM for user %s' % sUser);
816
817	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Configuring autostart database',
818	30 * 1000, '/usr/bin/sudo',
819	['/usr/bin/sudo', '-u', sUser, '-H', '/opt/VirtualBox/VBoxManage',
820	'setproperty', 'autostartdbpath', '/etc/vbox/autostart.d'],
821	False, True);
822	if not fRc:
823	reporter.error('Configuring autostart database failed');
824	else:
825	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Create VM ' + sVmName,
826	30 * 1000, '/usr/bin/sudo',
827	['/usr/bin/sudo', '-u', sUser, '-H',
828	'/opt/VirtualBox/VBoxManage', 'createvm',
829	'--name', sVmName, '--register'], False, True);
830	if not fRc:
831	reporter.error('Create VM %s failed' % sVmName);
832	if fRc:
833	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Enabling autostart for test VM',
834	30 * 1000, '/usr/bin/sudo',
835	['/usr/bin/sudo', '-u', sUser, '-H',
836	'/opt/VirtualBox/VBoxManage', 'modifyvm',
837	sVmName, '--autostart-enabled', 'on'], False, True);
838	if not fRc:
839	reporter.error('Enabling autostart for %s failed' % sVmName);
840	reporter.testDone();
841	return fRc;
842
843	def checkForRunningVM(self, oSession, oGuestSession, sUser, sVmName):
844	"""
845	Check for VM running in the guest after autostart.
846	Due to the sUser is created whithout password,
847	all calls will be perfomed using 'sudo -u sUser'
848	"""
849
850	_ = oSession;
851
852	reporter.testStart('Check the VM %s is running for user %s' % (sVmName, sUser));
853	(fRc, _, _, aBuf) = self.guestProcessExecute(oGuestSession, 'Check for running VM',
854	30 * 1000, '/usr/bin/sudo',
855	['/usr/bin/sudo', '-u', sUser, '-H',
856	'/opt/VirtualBox/VBoxManage',
857	'list', 'runningvms'], True, True);
858	if not fRc:
859	reporter.error('Checking the VM %s is running for user %s failed' % (sVmName, sUser));
860	else:
861	bufWrapper = VBoxManageStdOutWrapper();
862	bufWrapper.write(aBuf);
863	fRc = bufWrapper.sVmRunning == sVmName;
864
865	reporter.testDone();
866	return fRc;
867
868
869	class tdAutostartOsDarwin(tdAutostartOs):
870	"""
871	Autostart support methods for Darwin guests.
872	"""
873
874	def __init__(self, oTestDriver, sTestBuildDir, fpApiVer, sGuestAdditionsIso):
875	_ = sTestBuildDir;
876	tdAutostartOs.__init__(self, oTestDriver, fpApiVer, sGuestAdditionsIso);
877	raise base.GenError('Testing the autostart functionality for Darwin is not implemented');
878
879
880	class tdAutostartOsSolaris(tdAutostartOs):
881	"""
882	Autostart support methods for Solaris guests.
883	"""
884
885	def __init__(self, oTestDriver, sTestBuildDir, fpApiVer, sGuestAdditionsIso):
886	_ = sTestBuildDir;
887	tdAutostartOs.__init__(self, oTestDriver, fpApiVer, sGuestAdditionsIso);
888	raise base.GenError('Testing the autostart functionality for Solaris is not implemented');
889
890
891	class tdAutostartOsWin(tdAutostartOs):
892	"""
893	Autostart support methods for Windows guests.
894	"""
895
896	def __init__(self, oTestDriver, asTestBuildDirs, fpApiVer, sGuestAdditionsIso):
897	tdAutostartOs.__init__(self, oTestDriver, fpApiVer, sGuestAdditionsIso);
898	self.sTestBuild = self._findFile('^VirtualBox-.*\\.(exe\|msi)$', asTestBuildDirs);
899	if not self.sTestBuild:
900	raise base.GenError("VirtualBox install package not found");
901	return;
902
903	def waitVMisReady(self, oSession):
904	"""
905	Waits the VM is ready after start or reboot.
906	"""
907	# Give the VM a time to reboot
908	self.oTestDriver.sleep(30);
909
910	# Waiting the VM is ready.
911	# To do it, one will try to open the guest session and start the guest process in loop
912
913	cAttempt = 0;
914	oGuestSession = None;
915	while cAttempt < 10:
916	fRc, oGuestSession = self.createSession(oSession, 'Session for user: vbox',
917	'vbox', 'password', 10 * 1000, False);
918	if fRc:
919	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Start a guest process',
920	30 * 1000, 'C:\\Windows\\System32\\ipconfig.exe',
921	['C:\\Windows\\System32\\ipconfig.exe',],
922	False, False);
923	if fRc:
924	break;
925
926	self.oTestDriver.sleep(10);
927	cAttempt += 1;
928
929	return (fRc, oGuestSession);
930
931	def rebootVMAndCheckReady(self, oSession, oGuestSession):
932	"""
933	Reboot the VM and wait the VM is ready.
934	"""
935	reporter.testStart('Reboot VM and wait for readiness');
936	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Reboot the VM',
937	30 * 1000, 'C:\\Windows\\System32\\shutdown.exe',
938	['C:\\Windows\\System32\\shutdown.exe', '/f',
939	'/r', '/t', '0'],
940	False, True);
941	if not fRc:
942	reporter.error('Calling the shutdown utility failed');
943	fRc = self.closeSession(oGuestSession, True) and fRc and True; # pychecker hack.
944	if fRc:
945	(fRc, oGuestSession) = self.waitVMisReady(oSession);
946	if not fRc:
947	reporter.error('VM is not ready after reboot');
948	reporter.testDone();
949	return (fRc, oGuestSession);
950
951	def powerDownVM(self, oGuestSession):
952	"""
953	Power down the VM by calling guest process without wating
954	the VM is really powered off. Also, closes the guest session.
955	It helps the terminateBySession to stop the VM without aborting.
956	"""
957
958	if oGuestSession is None:
959	return False;
960
961	reporter.testStart('Power down the VM');
962	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Power down the VM',
963	30 * 1000, 'C:\\Windows\\System32\\shutdown.exe',
964	['C:\\Windows\\System32\\shutdown.exe', '/f',
965	'/s', '/t', '0'],
966	False, True);
967	if not fRc:
968	reporter.error('Calling the shutdown utility failed');
969	fRc = self.closeSession(oGuestSession, True) and fRc and True; # pychecker hack.
970	if not fRc:
971	reporter.error('Power down the VM failed');
972	reporter.testDone();
973	return fRc;
974
975	def installAdditions(self, oSession, oGuestSession, oVM):
976	"""
977	Installs the Windows guest additions using the test execution service.
978	"""
979	#
980	# Delete relevant log files.
981	#
982	# Note! On some guests the files in question still can be locked by the OS, so ignore
983	# deletion errors from the guest side (e.g. sharing violations) and just continue.
984	#
985	reporter.testStart('Install Guest Additions');
986	asLogFiles = [];
987	fHaveSetupApiDevLog = False;
988	if oVM.OSTypeId in ('WindowsNT4',):
989	sWinDir = 'C:/WinNT/';
990	else:
991	sWinDir = 'C:/Windows/';
992	asLogFiles = [sWinDir + 'setupapi.log', sWinDir + 'setupact.log', sWinDir + 'setuperr.log'];
993
994	# Apply The SetupAPI logging level so that we also get the (most verbose) setupapi.dev.log file.
995	## @todo !!! HACK ALERT !!! Add the value directly into the testing source image. Later.
996	(fHaveSetupApiDevLog, _, _, _) = \
997	self.guestProcessExecute(oGuestSession, 'Enabling setupapi.dev.log',
998	60 * 1000, 'c:\\Windows\\System32\\reg.exe',
999	['c:\\Windows\\System32\\reg.exe', 'add',
1000	'"HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\Setup"',
1001	'/v', 'LogLevel', '/t', 'REG_DWORD', '/d', '0xFF'],
1002	False, True);
1003	for sFile in asLogFiles:
1004	try: oGuestSession.fsObjRemove(sFile);
1005	except: pass;
1006
1007	fRc = self.closeSession(oGuestSession, True); # pychecker hack.
1008
1009	try:
1010	oCurProgress = oSession.o.console.guest.updateGuestAdditions(self.sGuestAdditionsIso, None, None);
1011	except:
1012	reporter.maybeErrXcpt(True, 'Updating Guest Additions exception for sSrc="%s":'
1013	% (self.sGuestAdditionsIso,));
1014	fRc = False;
1015	else:
1016	if oCurProgress is not None:
1017	oWrapperProgress = vboxwrappers.ProgressWrapper(oCurProgress, self.oTestDriver.oVBoxMgr,
1018	self.oTestDriver, "installAdditions");
1019	oWrapperProgress.wait();
1020	if not oWrapperProgress.isSuccess():
1021	oWrapperProgress.logResult(fIgnoreErrors = False);
1022	fRc = False;
1023	else:
1024	fRc = reporter.error('No progress object returned');
1025
1026	if fRc:
1027	fRc, oGuestSession = self.createSession(oSession, 'Session for user: vbox',
1028	'vbox', 'password', 10 * 1000, True);
1029	if fRc is True:
1030	(fRc, oGuestSession) = self.rebootVMAndCheckReady(oSession, oGuestSession);
1031	if fRc is True:
1032	# Add the Windows Guest Additions installer files to the files we want to download
1033	# from the guest.
1034	sGuestAddsDir = 'C:/Program Files/Oracle/VirtualBox Guest Additions/';
1035	asLogFiles.append(sGuestAddsDir + 'install.log');
1036	# Note: There won't be a install_ui.log because of the silent installation.
1037	asLogFiles.append(sGuestAddsDir + 'install_drivers.log');
1038	asLogFiles.append('C:/Windows/setupapi.log');
1039
1040	# Note: setupapi.dev.log only is available since Windows 2000.
1041	if fHaveSetupApiDevLog:
1042	asLogFiles.append('C:/Windows/setupapi.dev.log');
1043
1044	#
1045	# Download log files.
1046	# Ignore errors as all files above might not be present (or in different locations)
1047	# on different Windows guests.
1048	#
1049	self.downloadFiles(oGuestSession, asLogFiles, fIgnoreErrors = True);
1050	else:
1051	reporter.error('Reboot after installing GuestAdditions failed');
1052	else:
1053	reporter.error('Create session for user vbox after GA updating failed');
1054	reporter.testDone();
1055	return (fRc, oGuestSession);
1056
1057	def installVirtualBox(self, oGuestSession):
1058	"""
1059	Install VirtualBox in the guest.
1060	"""
1061
1062	if self.sTestBuild is None:
1063	return False;
1064	reporter.testStart('Install Virtualbox into the guest VM');
1065	# Used windows image already contains the C:\Temp
1066	fRc = self.uploadFile(oGuestSession, self.sTestBuild,
1067	'C:\\Temp\\' + os.path.basename(self.sTestBuild));
1068	if not fRc:
1069	reporter.error('Upload the installing into guest VM failed');
1070	else:
1071	if self.sTestBuild.endswith('.msi'):
1072	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Installing VBox',
1073	240 * 1000, 'C:\\Windows\\System32\\msiexec.exe',
1074	['msiexec', '/quiet', '/i',
1075	'C:\\Temp\\' + os.path.basename(self.sTestBuild)],
1076	False, True);
1077	if not fRc:
1078	reporter.error('Installing the VBox from msi installer failed');
1079	else:
1080	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Installing VBox',
1081	240 * 1000, 'C:\\Temp\\' + os.path.basename(self.sTestBuild),
1082	['C:\\Temp\\' + os.path.basename(self.sTestBuild), '--silent'],
1083	False, True);
1084	if not fRc:
1085	reporter.error('Installing the VBox failed');
1086	reporter.testDone();
1087	return fRc;
1088
1089	def configureAutostart(self, oGuestSession, sDefaultPolicy = 'allow',
1090	asUserAllow = (), asUserDeny = ()):
1091	"""
1092	Configures the autostart feature in the guest.
1093	"""
1094	reporter.testStart('Configure autostart');
1095	# Create autostart database directory writeable for everyone
1096	(fRc, _, _, _) = \
1097	self.guestProcessExecute(oGuestSession, 'Setting the autostart environment variable',
1098	30 * 1000, 'C:\\Windows\\System32\\reg.exe',
1099	['reg', 'add',
1100	'HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment',
1101	'/v', 'VBOXAUTOSTART_CONFIG', '/d',
1102	'C:\\ProgramData\\autostart.cfg', '/f'],
1103	False, True);
1104	if not fRc:
1105	reporter.error('Setting the autostart environment variable failed');
1106
1107	if fRc:
1108	sVBoxCfg = self._createAutostartCfg(sDefaultPolicy, asUserAllow, asUserDeny);
1109	fRc = self.uploadString(oGuestSession, sVBoxCfg, 'C:\\ProgramData\\autostart.cfg');
1110	if not fRc:
1111	reporter.error('Upload the autostart.cfg failed');
1112	reporter.testDone();
1113	return fRc;
1114
1115	def createTestVM(self, oSession, oGuestSession, sUser, sVmName):
1116	"""
1117	Create a test VM in the guest and enable autostart.
1118	"""
1119	_ = oGuestSession;
1120
1121	reporter.testStart('Create test VM for user %s' % sUser);
1122
1123	fRc, oGuestSession = self.createSession(oSession, 'Session for user: %s' % (sUser,),
1124	sUser, 'password', 10 * 1000, True);
1125	if not fRc:
1126	reporter.error('Create session for user %s failed' % sUser);
1127	else:
1128	(fRc, _, _, _) = \
1129	self.guestProcessExecute(oGuestSession, 'Create VM ' + sVmName,
1130	30 * 1000, 'C:\\Program Files\\Oracle\\VirtualBox\\VBoxManage.exe',
1131	['C:\\Program Files\\Oracle\\VirtualBox\\VBoxManage.exe', 'createvm',
1132	'--name', sVmName, '--register'], False, True);
1133	if not fRc:
1134	reporter.error('Create VM %s for user %s failed' % (sVmName, sUser));
1135	else:
1136	(fRc, _, _, _) = \
1137	self.guestProcessExecute(oGuestSession, 'Enabling autostart for test VM',
1138	30 * 1000, 'C:\\Program Files\\Oracle\\VirtualBox\\VBoxManage.exe',
1139	['C:\\Program Files\\Oracle\\VirtualBox\\VBoxManage.exe',
1140	'modifyvm', sVmName, '--autostart-enabled', 'on'], False, True);
1141	if not fRc:
1142	reporter.error('Enabling autostart for VM %s for user %s failed' % (sVmName, sUser));
1143	if fRc:
1144	fRc = self.uploadString(oGuestSession, 'password', 'C:\\ProgramData\\password.cfg');
1145	if not fRc:
1146	reporter.error('Upload the password.cfg failed');
1147	if fRc:
1148	(fRc, _, _, _) = \
1149	self.guestProcessExecute(oGuestSession, 'Install autostart service for the user',
1150	30 * 1000, 'C:\\Program Files\\Oracle\\VirtualBox\\VBoxAutostartSvc.exe',
1151	['C:\\Program Files\\Oracle\\VirtualBox\\VBoxAutostartSvc.exe',
1152	'install', '--user=' + sUser,
1153	'--password-file=C:\\ProgramData\\password.cfg'],
1154	False, True);
1155	if not fRc:
1156	reporter.error('Install autostart service for user %s failed' % (sVmName, sUser));
1157	fRc1 = self.closeSession(oGuestSession, True);
1158	if not fRc1:
1159	reporter.error('Closing session for user %s failed' % sUser);
1160	fRc = fRc1 and fRc and True; # pychecker hack.
1161	reporter.testDone();
1162	return fRc;
1163
1164	def checkForRunningVM(self, oSession, oGuestSession, sUser, sVmName):
1165	"""
1166	Check for VM running in the guest after autostart.
1167	"""
1168
1169	_ = oGuestSession;
1170
1171	reporter.testStart('Check the VM %s is running for user %s' % (sVmName, sUser));
1172
1173	fRc, oGuestSession = self.createSession(oSession, 'Session for user: %s' % (sUser,),
1174	sUser, 'password', 10 * 1000, True);
1175	if not fRc:
1176	reporter.error('Create session for user %s failed' % sUser);
1177	else:
1178	(fRc, _, _, aBuf) = self.guestProcessExecute(oGuestSession, 'Check for running VM',
1179	30 * 1000, 'C:\\Program Files\\Oracle\\VirtualBox\\VBoxManage.exe',
1180	['C:\\Program Files\\Oracle\\VirtualBox\\VBoxManage.exe',
1181	'list', 'runningvms'], True, True);
1182	if not fRc:
1183	reporter.error('Checking the VM %s is running for user %s failed' % (sVmName, sUser));
1184	else:
1185	bufWrapper = VBoxManageStdOutWrapper();
1186	bufWrapper.write(aBuf);
1187	fRc = bufWrapper.sVmRunning == sVmName;
1188
1189	fRc1 = self.closeSession(oGuestSession, True);
1190	if not fRc1:
1191	reporter.error('Closing session for user %s failed' % sUser);
1192	fRc = fRc1 and fRc and True; # pychecker hack.
1193	reporter.testDone();
1194	return fRc;
1195
1196	def createUser(self, oGuestSession, sUser):
1197	"""
1198	Create a new user with the given name
1199	"""
1200	reporter.testStart('Create user %s' % sUser);
1201	# Create user
1202	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Creating user %s to run a VM' % sUser,
1203	30 * 1000, 'C:\\Windows\\System32\\net.exe',
1204	['net', 'user', sUser, 'password', '/add' ], False, True);
1205	if not fRc:
1206	reporter.error('Creating user %s to run a VM failed' % sUser);
1207	# Add the user to Administrators group
1208	else:
1209	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession, 'Adding the user %s to Administrators group' % sUser,
1210	30 * 1000, 'C:\\Windows\\System32\\net.exe',
1211	['net', 'localgroup', 'Administrators', sUser, '/add' ], False, True);
1212	if not fRc:
1213	reporter.error('Adding the user %s to Administrators group failed' % sUser);
1214
1215	#Allow the user to logon as service
1216	if fRc:
1217	sSecPolicyEditor = """
1218	' SetLogonAsAServiceRight.vbs
1219	' Sample VBScript to set or grant Logon As A Service Right.
1220	' Author: http://www.morgantechspace.com/
1221	' ------------------------------------------------------'
1222
1223	Dim strUserName,ConfigFileName,OrgStr,RepStr,inputFile,strInputFile,outputFile,obj
1224	strUserName = "%s"
1225	Dim oShell
1226	Set oShell = CreateObject ("WScript.Shell")
1227	oShell.Run "secedit /export /cfg config.inf", 0, true
1228	oShell.Run "secedit /import /cfg config.inf /db database.sdb", 0, true
1229
1230	ConfigFileName = "config.inf"
1231	OrgStr = "SeServiceLogonRight ="
1232	RepStr = "SeServiceLogonRight = " & strUserName & ","
1233	Set inputFile = CreateObject("Scripting.FileSystemObject").OpenTextFile("config.inf", 1,1,-1)
1234	strInputFile = inputFile.ReadAll
1235	inputFile.Close
1236	Set inputFile = Nothing
1237
1238	Set outputFile = CreateObject("Scripting.FileSystemObject").OpenTextFile("config.inf",2,1,-1)
1239	outputFile.Write (Replace(strInputFile,OrgStr,RepStr))
1240	outputFile.Close
1241	Set outputFile = Nothing
1242
1243	oShell.Run "secedit /configure /db database.sdb /cfg config.inf",0,true
1244	set oShell= Nothing
1245
1246	Set obj = CreateObject("Scripting.FileSystemObject")
1247	obj.DeleteFile("config.inf")
1248	obj.DeleteFile("database.sdb")
1249
1250	WScript.Echo "Logon As A Service Right granted to user '"& strUserName &"'"
1251	""" % sUser;
1252	fRc = self.uploadString(oGuestSession, sSecPolicyEditor, 'C:\\Temp\\adjustsec.vbs');
1253	if not fRc:
1254	reporter.error('Upload the adjustsec.vbs failed');
1255	if fRc:
1256	(fRc, _, _, _) = self.guestProcessExecute(oGuestSession,
1257	'Setting the "Logon as service" policy to the user %s' % sUser,
1258	30 * 1000, 'C:\\Windows\\System32\\cscript.exe',
1259	['cscript.exe', 'C:\\Temp\\adjustsec.vbs', '//Nologo'], False, True);
1260	if not fRc:
1261	reporter.error('Setting the "Logon as service" policy to the user %s failed' % sUser);
1262	try:
1263	oGuestSession.fsObjRemove('C:\\Temp\\adjustsec.vbs');
1264	except:
1265	fRc = reporter.errorXcpt('Removing policy script failed');
1266	reporter.testDone();
1267	return fRc;
1268
1269
1270	class tdAutostart(vbox.TestDriver): # pylint: disable=too-many-instance-attributes
1271	"""
1272	Autostart testcase.
1273	"""
1274
1275	ksOsLinux = 'tst-linux'
1276	ksOsWindows = 'tst-win'
1277	ksOsDarwin = 'tst-darwin'
1278	ksOsSolaris = 'tst-solaris'
1279	ksOsFreeBSD = 'tst-freebsd'
1280
1281	def __init__(self):
1282	vbox.TestDriver.__init__(self);
1283	self.asRsrcs = None;
1284	self.asTestVMsDef = [self.ksOsWindows, self.ksOsLinux]; #[self.ksOsLinux, self.ksOsWindows];
1285	self.asTestVMs = self.asTestVMsDef;
1286	self.asSkipVMs = [];
1287	self.asTestBuildDirs = None; #'D:/AlexD/TestBox/TestAdditionalFiles';
1288	self.sGuestAdditionsIso = None; #'D:/AlexD/TestBox/TestAdditionalFiles/VBoxGuestAdditions_6.1.2.iso';
1289
1290	#
1291	# Overridden methods.
1292	#
1293	def showUsage(self):
1294	rc = vbox.TestDriver.showUsage(self);
1295	reporter.log('');
1296	reporter.log('tdAutostart Options:');
1297	reporter.log(' --test-build-dirs <path1[,path2[,...]]>');
1298	reporter.log(' The list of directories with VirtualBox distros. The option is mandatory');
1299	reporter.log(' without any default value. The test raises an exception if the');
1300	reporter.log(' option is not specified. At least, one directory should be pointed.');
1301	reporter.log(' --guest-additions-iso <path/to/iso>');
1302	reporter.log(' The path to fresh VirtualBox Guest Additions iso. The option is');
1303	reporter.log(' mandatory without any default value. The test raises an exception');
1304	reporter.log(' if the option is not specified.');
1305	reporter.log(' --test-vms <vm1[:vm2[:...]]>');
1306	reporter.log(' Test the specified VMs in the given order. Use this to change');
1307	reporter.log(' the execution order or limit the choice of VMs');
1308	reporter.log(' Default: %s (all)' % (':'.join(self.asTestVMsDef)));
1309	reporter.log(' --skip-vms <vm1[:vm2[:...]]>');
1310	reporter.log(' Skip the specified VMs when testing.');
1311	return rc;
1312
1313	def parseOption(self, asArgs, iArg): # pylint: disable=too-many-branches,too-many-statements
1314	if asArgs[iArg] == '--test-build-dirs':
1315	iArg += 1;
1316	if iArg >= len(asArgs): raise base.InvalidOption('The "--test-build-dirs" takes a paths argument');
1317	self.asTestBuildDirs = asArgs[iArg].split(',');
1318	elif asArgs[iArg] == '--guest-additions-iso':
1319	iArg += 1;
1320	if iArg >= len(asArgs): raise base.InvalidOption('The "--guest-additions-iso" takes a path or url to iso argument');
1321	self.sGuestAdditionsIso = asArgs[iArg];
1322	elif asArgs[iArg] == '--test-vms':
1323	iArg += 1;
1324	if iArg >= len(asArgs): raise base.InvalidOption('The "--test-vms" takes colon separated list');
1325	self.asTestVMs = asArgs[iArg].split(':');
1326	for s in self.asTestVMs:
1327	if s not in self.asTestVMsDef:
1328	raise base.InvalidOption('The "--test-vms" value "%s" is not valid; valid values are: %s' \
1329	% (s, ' '.join(self.asTestVMsDef)));
1330	elif asArgs[iArg] == '--skip-vms':
1331	iArg += 1;
1332	if iArg >= len(asArgs): raise base.InvalidOption('The "--skip-vms" takes colon separated list');
1333	self.asSkipVMs = asArgs[iArg].split(':');
1334	for s in self.asSkipVMs:
1335	if s not in self.asTestVMsDef:
1336	reporter.log('warning: The "--test-vms" value "%s" does not specify any of our test VMs.' % (s));
1337	else:
1338	return vbox.TestDriver.parseOption(self, asArgs, iArg);
1339	return iArg + 1;
1340
1341	def completeOptions(self):
1342	# Remove skipped VMs from the test list.
1343	if self.asTestBuildDirs is None:
1344	raise base.InvalidOption('--test-build-dirs is not specified')
1345	if self.sGuestAdditionsIso is None:
1346	raise base.InvalidOption('--guest-additions-iso is not specified')
1347
1348	for sVM in self.asSkipVMs:
1349	try: self.asTestVMs.remove(sVM);
1350	except: pass;
1351
1352	return vbox.TestDriver.completeOptions(self);
1353
1354	def getResourceSet(self):
1355	# Construct the resource list the first time it's queried.
1356	if self.asRsrcs is None:
1357	self.asRsrcs = [];
1358	if self.ksOsLinux in self.asTestVMs:
1359	self.asRsrcs.append('6.0/ub1804piglit/ub1804piglit.vdi');
1360	if self.ksOsWindows in self.asTestVMs:
1361	self.asRsrcs.append('6.0/windows7piglit/windows7piglit.vdi');
1362	#disabled
1363	#if self.ksOsSolaris in self.asTestVMs:
1364	# self.asRsrcs.append('4.2/autostart/tst-solaris.vdi');
1365
1366	return self.asRsrcs;
1367
1368	def actionConfig(self):
1369
1370	# Make sure vboxapi has been imported so we can use the constants.
1371	if not self.importVBoxApi():
1372	return False;
1373
1374	# Download VBoxGuestAdditions.iso before work
1375	sDestinationIso = os.path.join(self.sScratchPath, 'VBoxGuestAdditions.iso');
1376	utils.noxcptDeleteFile(sDestinationIso);
1377	if not downloadFile(self.sGuestAdditionsIso, sDestinationIso, '', reporter.log, reporter.error):
1378	raise base.GenError("Could not download VBoxGuestAdditions.iso");
1379	self.sGuestAdditionsIso = sDestinationIso;
1380
1381	#
1382	# Configure the VMs we're going to use.
1383	#
1384
1385	fRc = True;
1386
1387	# Linux VMs
1388	if self.ksOsLinux in self.asTestVMs:
1389	# ub1804piglit is created with 2 CPUs.
1390	oVM = self.createTestVM(self.ksOsLinux, 1, '6.0/ub1804piglit/ub1804piglit.vdi', sKind = 'Ubuntu_64', \
1391	fIoApic = True, eNic0AttachType = vboxcon.NetworkAttachmentType_NAT, \
1392	eNic0Type = vboxcon.NetworkAdapterType_Am79C973, cMbRam = 4096, \
1393	cCpus = 2, sDvdImage = self.sGuestAdditionsIso);
1394	if oVM is None:
1395	return False;
1396	# Windows VMs
1397	if self.ksOsWindows in self.asTestVMs:
1398	# windows7piglit is created with PAE enabled and 2 CPUs.
1399	oVM = self.createTestVM(self.ksOsWindows, 1, '6.0/windows7piglit/windows7piglit.vdi', sKind = 'Windows7_64', \
1400	fIoApic = True, eNic0AttachType = vboxcon.NetworkAttachmentType_NAT, \
1401	sHddControllerType = "SATA Controller", cMbRam = 4096, fPae = True, cCpus = 2, \
1402	sDvdImage = self.sGuestAdditionsIso);
1403	if oVM is None:
1404	return False;
1405
1406	# additional options used during the windows7piglit creation
1407	oSession = self.openSession(oVM);
1408	if oSession is not None:
1409	fRc = fRc and oSession.setVRamSize(256);
1410	fRc = fRc and oSession.setVideoControllerType(vboxcon.GraphicsControllerType_VBoxSVGA)
1411	fRc = fRc and oSession.setAccelerate3DEnabled(True);
1412	fRc = fRc and oSession.enableUsbOhci(True);
1413	fRc = fRc and oSession.enableUsbHid(True);
1414	fRc = fRc and oSession.saveSettings();
1415	fRc = oSession.close() and fRc and True; # pychecker hack.
1416	oSession = None;
1417	else:
1418	fRc = False;
1419
1420	# disabled
1421	# Solaris VMs
1422	#if self.ksOsSolaris in self.asTestVMs:
1423	# oVM = self.createTestVM(self.ksOsSolaris, 1, '4.2/autostart/tst-solaris.vdi', sKind = 'Solaris_64', \
1424	# fIoApic = True, eNic0AttachType = vboxcon.NetworkAttachmentType_NAT, \
1425	# sHddControllerType = "SATA Controller");
1426	# if oVM is None:
1427	# return False;
1428
1429	return fRc;
1430
1431	def actionExecute(self):
1432	"""
1433	Execute the testcase.
1434	"""
1435	fRc = self.testAutostart();
1436	return fRc;
1437
1438	#
1439	# Test execution helpers.
1440	#
1441	def testAutostartRunProgs(self, oSession, sVmName, oVM):
1442	"""
1443	Test VirtualBoxs autostart feature in a VM.
1444	"""
1445	reporter.testStart('Autostart ' + sVmName);
1446
1447	oGuestOsHlp = None # type: tdAutostartOs
1448	if sVmName == self.ksOsLinux:
1449	oGuestOsHlp = tdAutostartOsLinux(self, self.asTestBuildDirs, self.fpApiVer, # pylint: disable=redefined-variable-type
1450	self.sGuestAdditionsIso);
1451	elif sVmName == self.ksOsSolaris:
1452	oGuestOsHlp = tdAutostartOsSolaris(self, self.asTestBuildDirs, self.fpApiVer, # pylint: disable=redefined-variable-type
1453	self.sGuestAdditionsIso);
1454	elif sVmName == self.ksOsDarwin:
1455	oGuestOsHlp = tdAutostartOsDarwin(self, self.asTestBuildDirs, self.fpApiVer, # pylint: disable=redefined-variable-type
1456	self.sGuestAdditionsIso);
1457	elif sVmName == self.ksOsWindows:
1458	oGuestOsHlp = tdAutostartOsWin(self, self.asTestBuildDirs, self.fpApiVer, # pylint: disable=redefined-variable-type
1459	self.sGuestAdditionsIso);
1460
1461	sTestUserAllow = 'test1';
1462	sTestUserDeny = 'test2';
1463	sTestVmName = 'TestVM';
1464
1465	if oGuestOsHlp is not None:
1466	#wait the VM is ready after starting
1467	(fRc, oGuestSession) = oGuestOsHlp.waitVMisReady(oSession);
1468	#install fresh guest additions
1469	if fRc:
1470	(fRc, oGuestSession) = oGuestOsHlp.installAdditions(oSession, oGuestSession, oVM);
1471	# Create two new users
1472	fRc = fRc and oGuestOsHlp.createUser(oGuestSession, sTestUserAllow);
1473	fRc = fRc and oGuestOsHlp.createUser(oGuestSession, sTestUserDeny);
1474	if fRc is True:
1475	# Install VBox first
1476	fRc = oGuestOsHlp.installVirtualBox(oGuestSession);
1477	if fRc is True:
1478	fRc = oGuestOsHlp.configureAutostart(oGuestSession, 'allow', (sTestUserAllow,), (sTestUserDeny,));
1479	if fRc is True:
1480	# Create a VM with autostart enabled in the guest for both users
1481	fRc = oGuestOsHlp.createTestVM(oSession, oGuestSession, sTestUserAllow, sTestVmName);
1482	fRc = fRc and oGuestOsHlp.createTestVM(oSession, oGuestSession, sTestUserDeny, sTestVmName);
1483	if fRc is True:
1484	# Reboot the guest
1485	(fRc, oGuestSession) = oGuestOsHlp.rebootVMAndCheckReady(oSession, oGuestSession);
1486	if fRc is True:
1487	# Fudge factor - Allow the guest to finish starting up.
1488	self.sleep(30);
1489	fRc = oGuestOsHlp.checkForRunningVM(oSession, oGuestSession, sTestUserAllow, sTestVmName);
1490	if fRc is True:
1491	fRc = oGuestOsHlp.checkForRunningVM(oSession, oGuestSession, sTestUserDeny, sTestVmName);
1492	if fRc is True:
1493	reporter.error('Test VM is running inside the guest for denied user');
1494	fRc = not fRc;
1495	else:
1496	reporter.error('Test VM is not running inside the guest for allowed user');
1497	else:
1498	reporter.error('Rebooting the guest failed');
1499	else:
1500	reporter.error('Creating test VM failed');
1501	else:
1502	reporter.error('Configuring autostart in the guest failed');
1503	else:
1504	reporter.error('Installing VirtualBox in the guest failed');
1505	else:
1506	reporter.error('Creating test users failed');
1507
1508	if oGuestSession is not None:
1509	try: oGuestOsHlp.powerDownVM(oGuestSession);
1510	except: pass;
1511	else:
1512	reporter.error('Guest OS helper not created for VM %s' % (sVmName));
1513	fRc = False;
1514
1515	reporter.testDone();
1516	return fRc;
1517
1518	def testAutostartOneCfg(self, sVmName):
1519	"""
1520	Runs the specified VM thru test #1.
1521
1522	Returns a success indicator on the general test execution. This is not
1523	the actual test result.
1524	"""
1525	oVM = self.getVmByName(sVmName);
1526
1527	# Reconfigure the VM
1528	fRc = True;
1529	oSession = self.openSession(oVM);
1530	if oSession is not None:
1531	fRc = fRc and oSession.enableVirtEx(True);
1532	fRc = fRc and oSession.enableNestedPaging(True);
1533	fRc = fRc and oSession.enableNestedHwVirt(True);
1534	fRc = fRc and oSession.saveSettings();
1535	fRc = oSession.close() and fRc and True; # pychecker hack.
1536	oSession = None;
1537	else:
1538	fRc = False;
1539
1540	# Start up.
1541	if fRc is True:
1542	self.logVmInfo(oVM);
1543	oSession = self.startVmByName(sVmName);
1544	if oSession is not None:
1545	fRc = self.testAutostartRunProgs(oSession, sVmName, oVM);
1546	try: self.terminateVmBySession(oSession);
1547	except: pass;
1548	else:
1549	fRc = False;
1550	return fRc;
1551
1552	def testAutostartForOneVM(self, sVmName):
1553	"""
1554	Runs one VM thru the various configurations.
1555	"""
1556	reporter.testStart(sVmName);
1557	fRc = True;
1558	self.testAutostartOneCfg(sVmName);
1559	reporter.testDone();
1560	return fRc;
1561
1562	def testAutostart(self):
1563	"""
1564	Executes autostart test.
1565	"""
1566
1567	# Loop thru the test VMs.
1568	for sVM in self.asTestVMs:
1569	# run test on the VM.
1570	if not self.testAutostartForOneVM(sVM):
1571	fRc = False;
1572	else:
1573	fRc = True;
1574
1575	return fRc;
1576
1577
1578
1579	if __name__ == '__main__':
1580	sys.exit(tdAutostart().main(sys.argv));
1581

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

source: vbox/trunk/src/VBox/ValidationKit/tests/autostart/tdAutostart1.py@ 84641

Download in other formats: