vboxinstaller.py@ 66466

Last change on this file since 66466 was 66466, checked in by vboxsync, 8 years ago
ValidationKit: get rid of leftover verification dialogs explicitly, as killing drvinst with children does not get this job done on Windows 10 (but don't ask me why driver verification can't verify the publisher sporadically, makes no sense)
Property svn:eol-style set to `LF` Property svn:executable set to ``* Property svn:keywords set to `Author Date Id Revision`
File size: 37.5 KB

Line
1	#!/usr/bin/env python
2	# -- coding: utf-8 --
3
4	"""
5	VirtualBox Installer Wrapper Driver.
6
7	This installs VirtualBox, starts a sub driver which does the real testing,
8	and then uninstall VirtualBox afterwards. This reduces the complexity of the
9	other VBox test drivers.
10	"""
11
12	__copyright__ = \
13	"""
14	Copyright (C) 2010-2016 Oracle Corporation
15
16	This file is part of VirtualBox Open Source Edition (OSE), as
17	available from http://www.virtualbox.org. This file is free software;
18	you can redistribute it and/or modify it under the terms of the GNU
19	General Public License (GPL) as published by the Free Software
20	Foundation, in version 2 as it comes in the "COPYING" file of the
21	VirtualBox OSE distribution. VirtualBox OSE is distributed in the
22	hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
23
24	The contents of this file may alternatively be used under the terms
25	of the Common Development and Distribution License Version 1.0
26	(CDDL) only, as it comes in the "COPYING.CDDL" file of the
27	VirtualBox OSE distribution, in which case the provisions of the
28	CDDL are applicable instead of those of the GPL.
29
30	You may elect to license modified versions of this file under the
31	terms and conditions of either the GPL or the CDDL or both.
32	"""
33	__version__ = "$Revision: 66466 $"
34
35
36	# Standard Python imports.
37	import os
38	import sys
39	import re
40	#import socket
41	import tempfile
42	import time
43
44	# Only the main script needs to modify the path.
45	try: __file__
46	except: __file__ = sys.argv[0];
47	g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)));
48	sys.path.append(g_ksValidationKitDir);
49
50	# Validation Kit imports.
51	from common import utils, webutils;
52	from common.constants import rtexitcode;
53	from testdriver import reporter;
54	from testdriver.base import TestDriverBase;
55
56
57
58	class VBoxInstallerTestDriver(TestDriverBase):
59	"""
60	Implementation of a top level test driver.
61	"""
62
63
64	## State file indicating that we've skipped installation.
65	ksVar_Skipped = 'vboxinstaller-skipped';
66
67
68	def __init__(self):
69	TestDriverBase.__init__(self);
70	self._asSubDriver = []; # The sub driver and it's arguments.
71	self._asBuildUrls = []; # The URLs passed us on the command line.
72	self._asBuildFiles = []; # The downloaded file names.
73	self._fAutoInstallPuelExtPack = True;
74
75	#
76	# Base method we override
77	#
78
79	def showUsage(self):
80	rc = TestDriverBase.showUsage(self);
81	# 0 1 2 3 4 5 6 7 8
82	# 012345678901234567890123456789012345678901234567890123456789012345678901234567890
83	reporter.log('');
84	reporter.log('vboxinstaller Options:');
85	reporter.log(' --vbox-build <url[,url2[,..]]>');
86	reporter.log(' Comma separated list of URL to file to download and install or/and');
87	reporter.log(' unpack. URLs without a schema are assumed to be files on the');
88	reporter.log(' build share and will be copied off it.');
89	reporter.log(' --no-puel-extpack');
90	reporter.log(' Indicates that the PUEL extension pack should not be installed if found.');
91	reporter.log(' The default is to install it if found in the vbox-build.');
92	reporter.log(' --');
93	reporter.log(' Indicates the end of our parameters and the start of the sub');
94	reporter.log(' testdriver and its arguments.');
95	return rc;
96
97	def parseOption(self, asArgs, iArg):
98	"""
99	Parse our arguments.
100	"""
101	if asArgs[iArg] == '--':
102	# End of our parameters and start of the sub driver invocation.
103	iArg = self.requireMoreArgs(1, asArgs, iArg);
104	assert not self._asSubDriver;
105	self._asSubDriver = asArgs[iArg:];
106	self._asSubDriver[0] = self._asSubDriver[0].replace('/', os.path.sep);
107	iArg = len(asArgs) - 1;
108	elif asArgs[iArg] == '--vbox-build':
109	# List of files to copy/download and install.
110	iArg = self.requireMoreArgs(1, asArgs, iArg);
111	self._asBuildUrls = asArgs[iArg].split(',');
112	elif asArgs[iArg] == '--no-puel-extpack':
113	self._fAutoInstallPuelExtPack = False;
114	elif asArgs[iArg] == '--puel-extpack':
115	self._fAutoInstallPuelExtPack = True;
116	else:
117	return TestDriverBase.parseOption(self, asArgs, iArg);
118	return iArg + 1;
119
120	def completeOptions(self):
121	#
122	# Check that we've got what we need.
123	#
124	if not self._asBuildUrls:
125	reporter.error('No build files specfiied ("--vbox-build file1[,file2[...]]")');
126	return False;
127	if not self._asSubDriver:
128	reporter.error('No sub testdriver specified. (" -- test/stuff/tdStuff1.py args")');
129	return False;
130
131	#
132	# Construct _asBuildFiles as an array parallel to _asBuildUrls.
133	#
134	for sUrl in self._asBuildUrls:
135	sDstFile = os.path.join(self.sScratchPath, webutils.getFilename(sUrl));
136	self._asBuildFiles.append(sDstFile);
137
138	return TestDriverBase.completeOptions(self);
139
140	def actionExtract(self):
141	reporter.error('vboxinstall does not support extracting resources, you have to do that using the sub testdriver.');
142	return False;
143
144	def actionCleanupBefore(self):
145	"""
146	Kills all VBox process we see.
147
148	This is only supposed to execute on a testbox so we don't need to go
149	all complicated wrt other users.
150	"""
151	return self._killAllVBoxProcesses();
152
153	def actionConfig(self):
154	"""
155	Install VBox and pass on the configure request to the sub testdriver.
156	"""
157	fRc = self._installVBox();
158	if fRc is None: self._persistentVarSet(self.ksVar_Skipped, 'true');
159	else: self._persistentVarUnset(self.ksVar_Skipped);
160
161	## @todo vbox.py still has bugs preventing us from invoking it seperately with each action.
162	if fRc is True and 'execute' not in self.asActions and 'all' not in self.asActions:
163	fRc = self._executeSubDriver([ 'verify', ]);
164	if fRc is True and 'execute' not in self.asActions and 'all' not in self.asActions:
165	fRc = self._executeSubDriver([ 'config', ]);
166	return fRc;
167
168	def actionExecute(self):
169	"""
170	Execute the sub testdriver.
171	"""
172	return self._executeSubDriver(self.asActions);
173
174	def actionCleanupAfter(self):
175	"""
176	Forward this to the sub testdriver, then uninstall VBox.
177	"""
178	fRc = True;
179	if 'execute' not in self.asActions and 'all' not in self.asActions:
180	fRc = self._executeSubDriver([ 'cleanup-after', ], fMaySkip = False);
181
182	if not self._killAllVBoxProcesses():
183	fRc = False;
184
185	if not self._uninstallVBox(self._persistentVarExists(self.ksVar_Skipped)):
186	fRc = False;
187
188	if utils.getHostOs() == 'darwin':
189	self._darwinUnmountDmg(fIgnoreError = True); # paranoia
190
191	if not TestDriverBase.actionCleanupAfter(self):
192	fRc = False;
193
194	return fRc;
195
196
197	def actionAbort(self):
198	"""
199	Forward this to the sub testdriver first, then wipe all VBox like
200	processes, and finally do the pid file processing (again).
201	"""
202	fRc1 = self._executeSubDriver([ 'abort', ], fMaySkip = False);
203	fRc2 = self._killAllVBoxProcesses();
204	fRc3 = TestDriverBase.actionAbort(self);
205	return fRc1 and fRc2 and fRc3;
206
207
208	#
209	# Persistent variables.
210	#
211	## @todo integrate into the base driver. Persisten accross scratch wipes?
212
213	def __persistentVarCalcName(self, sVar):
214	"""Returns the (full) filename for the given persistent variable."""
215	assert re.match(r'^[a-zA-Z0-9_-]*$', sVar) is not None;
216	return os.path.join(self.sScratchPath, 'persistent-%s.var' % (sVar,));
217
218	def _persistentVarSet(self, sVar, sValue = ''):
219	"""
220	Sets a persistent variable.
221
222	Returns True on success, False + reporter.error on failure.
223
224	May raise exception if the variable name is invalid or something
225	unexpected happens.
226	"""
227	sFull = self.__persistentVarCalcName(sVar);
228	try:
229	oFile = open(sFull, 'w');
230	if sValue:
231	oFile.write(sValue.encode('utf-8'));
232	oFile.close();
233	except:
234	reporter.errorXcpt('Error creating "%s"' % (sFull,));
235	return False;
236	return True;
237
238	def _persistentVarUnset(self, sVar):
239	"""
240	Unsets a persistent variable.
241
242	Returns True on success, False + reporter.error on failure.
243
244	May raise exception if the variable name is invalid or something
245	unexpected happens.
246	"""
247	sFull = self.__persistentVarCalcName(sVar);
248	if os.path.exists(sFull):
249	try:
250	os.unlink(sFull);
251	except:
252	reporter.errorXcpt('Error unlinking "%s"' % (sFull,));
253	return False;
254	return True;
255
256	def _persistentVarExists(self, sVar):
257	"""
258	Checks if a persistent variable exists.
259
260	Returns true/false.
261
262	May raise exception if the variable name is invalid or something
263	unexpected happens.
264	"""
265	return os.path.exists(self.__persistentVarCalcName(sVar));
266
267	def _persistentVarGet(self, sVar):
268	"""
269	Gets the value of a persistent variable.
270
271	Returns variable value on success.
272	Returns None if the variable doesn't exist or if an
273	error (reported) occured.
274
275	May raise exception if the variable name is invalid or something
276	unexpected happens.
277	"""
278	sFull = self.__persistentVarCalcName(sVar);
279	if not os.path.exists(sFull):
280	return None;
281	try:
282	oFile = open(sFull, 'r');
283	sValue = oFile.read().decode('utf-8');
284	oFile.close();
285	except:
286	reporter.errorXcpt('Error creating "%s"' % (sFull,));
287	return None;
288	return sValue;
289
290
291	#
292	# Helpers.
293	#
294
295	def _killAllVBoxProcesses(self):
296	"""
297	Kills all virtual box related processes we find in the system.
298	"""
299
300	for iIteration in range(22):
301	# Gather processes to kill.
302	aoTodo = [];
303	for oProcess in utils.processListAll():
304	sBase = oProcess.getBaseImageNameNoExeSuff();
305	if sBase is None:
306	continue;
307	sBase = sBase.lower();
308	if sBase in [ 'vboxsvc', 'virtualbox', 'virtualboxvm', 'vboxheadless', 'vboxmanage', 'vboxsdl', 'vboxwebsrv',
309	'vboxautostart', 'vboxballoonctrl', 'vboxbfe', 'vboxextpackhelperapp', 'vboxnetdhcp',
310	'vboxnetadpctl', 'vboxtestogl', 'vboxtunctl', 'vboxvmmpreload', 'vboxxpcomipcd', 'vmCreator', ]:
311	aoTodo.append(oProcess);
312	if sBase.startswith('virtualbox-') and sBase.endswith('-multiarch.exe'):
313	aoTodo.append(oProcess);
314	if iIteration in [0, 21] and sBase in [ 'windbg', 'gdb', 'gdb-i386-apple-darwin', ]:
315	reporter.log('Warning: debugger running: %s (%s)' % (oProcess.iPid, sBase,));
316	if not aoTodo:
317	return True;
318
319	# Kill.
320	for oProcess in aoTodo:
321	reporter.log('Loop #%d - Killing %s (%s, uid=%s)'
322	% ( iIteration, oProcess.iPid, oProcess.sImage if oProcess.sName is None else oProcess.sName,
323	oProcess.iUid, ));
324	utils.processKill(oProcess.iPid); # No mercy.
325
326	# Check if they're all dead like they should be.
327	time.sleep(0.1);
328	for oProcess in aoTodo:
329	if utils.processExists(oProcess.iPid):
330	time.sleep(2);
331	break;
332
333	return False;
334
335	def _executeSync(self, asArgs, fMaySkip = False):
336	"""
337	Executes a child process synchronously.
338
339	Returns True if the process executed successfully and returned 0.
340	Returns None if fMaySkip is true and the child exits with RTEXITCODE_SKIPPED.
341	Returns False for all other cases.
342	"""
343	reporter.log('Executing: %s' % (asArgs, ));
344	reporter.flushall();
345	try:
346	iRc = utils.processCall(asArgs, shell = False, close_fds = False);
347	except:
348	reporter.errorXcpt();
349	return False;
350	reporter.log('Exit code: %s (%s)' % (iRc, asArgs));
351	if fMaySkip and iRc == rtexitcode.RTEXITCODE_SKIPPED:
352	return None;
353	return iRc is 0;
354
355	def _sudoExecuteSync(self, asArgs):
356	"""
357	Executes a sudo child process synchronously.
358	Returns a tuple [True, 0] if the process executed successfully
359	and returned 0, otherwise [False, rc] is returned.
360	"""
361	reporter.log('Executing [sudo]: %s' % (asArgs, ));
362	reporter.flushall();
363	iRc = 0;
364	try:
365	iRc = utils.sudoProcessCall(asArgs, shell = False, close_fds = False);
366	except:
367	reporter.errorXcpt();
368	return (False, 0);
369	reporter.log('Exit code [sudo]: %s (%s)' % (iRc, asArgs));
370	return (iRc is 0, iRc);
371
372	def _executeSubDriver(self, asActions, fMaySkip = True):
373	"""
374	Execute the sub testdriver with the specified action.
375	"""
376	asArgs = list(self._asSubDriver)
377	asArgs.append('--no-wipe-clean');
378	asArgs.extend(asActions);
379	return self._executeSync(asArgs, fMaySkip = fMaySkip);
380
381	def _maybeUnpackArchive(self, sMaybeArchive, fNonFatal = False):
382	"""
383	Attempts to unpack the given build file.
384	Updates _asBuildFiles.
385	Returns True/False. No exceptions.
386	"""
387	def unpackFilter(sMember):
388	# type: (string) -> bool
389	""" Skips debug info. """
390	sLower = sMember.lower();
391	if sLower.endswith('.pdb'):
392	return False;
393	return True;
394
395	asMembers = utils.unpackFile(sMaybeArchive, self.sScratchPath, reporter.log,
396	reporter.log if fNonFatal else reporter.error,
397	fnFilter = unpackFilter);
398	if asMembers is None:
399	return False;
400	self._asBuildFiles.extend(asMembers);
401	return True;
402
403
404	def _installVBox(self):
405	"""
406	Download / copy the build files into the scratch area and install them.
407	"""
408	reporter.testStart('Installing VirtualBox');
409	reporter.log('CWD=%s' % (os.getcwd(),)); # curious
410
411	#
412	# Download the build files.
413	#
414	for i in range(len(self._asBuildUrls)):
415	if webutils.downloadFile(self._asBuildUrls[i], self._asBuildFiles[i],
416	self.sBuildPath, reporter.log, reporter.log) is not True:
417	reporter.testDone(fSkipped = True);
418	return None; # Failed to get binaries, probably deleted. Skip the test run.
419
420	#
421	# Unpack anything we know what is and append it to the build files
422	# list. This allows us to use VBoxAll*.tar.gz files.
423	#
424	for sFile in list(self._asBuildFiles):
425	if self._maybeUnpackArchive(sFile, fNonFatal = True) is not True:
426	reporter.testDone(fSkipped = True);
427	return None; # Failed to unpack. Probably local error, like busy
428	# DLLs on windows, no reason for failing the build.
429
430	#
431	# Go to system specific installation code.
432	#
433	sHost = utils.getHostOs()
434	if sHost == 'darwin': fRc = self._installVBoxOnDarwin();
435	elif sHost == 'linux': fRc = self._installVBoxOnLinux();
436	elif sHost == 'solaris': fRc = self._installVBoxOnSolaris();
437	elif sHost == 'win': fRc = self._installVBoxOnWindows();
438	else:
439	reporter.error('Unsupported host "%s".' % (sHost,));
440	if fRc is False:
441	reporter.testFailure('Installation error.');
442
443	#
444	# Install the extension pack.
445	#
446	if fRc is True and self._fAutoInstallPuelExtPack:
447	fRc = self._installExtPack();
448	if fRc is False:
449	reporter.testFailure('Extension pack installation error.');
450
451	# Some debugging...
452	try:
453	cMbFreeSpace = utils.getDiskUsage(self.sScratchPath);
454	reporter.log('Disk usage after VBox install: %d MB available at %s' % (cMbFreeSpace, self.sScratchPath,));
455	except:
456	reporter.logXcpt('Unable to get disk free space. Ignored. Continuing.');
457
458	reporter.testDone();
459	return fRc;
460
461	def _uninstallVBox(self, fIgnoreError = False):
462	"""
463	Uninstall VirtualBox.
464	"""
465	reporter.testStart('Uninstalling VirtualBox');
466
467	sHost = utils.getHostOs()
468	if sHost == 'darwin': fRc = self._uninstallVBoxOnDarwin();
469	elif sHost == 'linux': fRc = self._uninstallVBoxOnLinux();
470	elif sHost == 'solaris': fRc = self._uninstallVBoxOnSolaris();
471	elif sHost == 'win': fRc = self._uninstallVBoxOnWindows(True);
472	else:
473	reporter.error('Unsupported host "%s".' % (sHost,));
474	if fRc is False and not fIgnoreError:
475	reporter.testFailure('Uninstallation failed.');
476
477	fRc2 = self._uninstallAllExtPacks();
478	if not fRc2 and fRc:
479	fRc = fRc2;
480
481	reporter.testDone(fSkipped = (fRc is None));
482	return fRc;
483
484	def _findFile(self, sRegExp, fMandatory = False):
485	"""
486	Returns the first build file that matches the given regular expression
487	(basename only).
488
489	Returns None if no match was found, logging it as an error if
490	fMandatory is set.
491	"""
492	oRegExp = re.compile(sRegExp);
493
494	for sFile in self._asBuildFiles:
495	if oRegExp.match(os.path.basename(sFile)) and os.path.exists(sFile):
496	return sFile;
497
498	if fMandatory:
499	reporter.error('Failed to find a file matching "%s" in %s.' % (sRegExp, self._asBuildFiles,));
500	return None;
501
502	def _waitForTestManagerConnectivity(self, cSecTimeout):
503	"""
504	Check and wait for network connectivity to the test manager.
505
506	This is used with the windows installation and uninstallation since
507	these usually disrupts network connectivity when installing the filter
508	driver. If we proceed to quickly, we might finish the test at a time
509	when we cannot report to the test manager and thus end up with an
510	abandonded test error.
511	"""
512	cSecElapsed = 0;
513	secStart = utils.timestampSecond();
514	while reporter.checkTestManagerConnection() is False:
515	cSecElapsed = utils.timestampSecond() - secStart;
516	if cSecElapsed >= cSecTimeout:
517	reporter.log('_waitForTestManagerConnectivity: Giving up after %u secs.' % (cSecTimeout,));
518	return False;
519	time.sleep(2);
520
521	if cSecElapsed > 0:
522	reporter.log('_waitForTestManagerConnectivity: Waited %s secs.' % (cSecTimeout,));
523	return True;
524
525
526	#
527	# Darwin (Mac OS X).
528	#
529
530	def _darwinDmgPath(self):
531	""" Returns the path to the DMG mount."""
532	return os.path.join(self.sScratchPath, 'DmgMountPoint');
533
534	def _darwinUnmountDmg(self, fIgnoreError):
535	"""
536	Umount any DMG on at the default mount point.
537	"""
538	sMountPath = self._darwinDmgPath();
539	if not os.path.exists(sMountPath):
540	return True;
541
542	# Unmount.
543	fRc = self._executeSync(['hdiutil', 'detach', sMountPath ]);
544	if not fRc and not fIgnoreError:
545	reporter.error('Failed to unmount DMG at %s' % sMountPath);
546
547	# Remove dir.
548	try:
549	os.rmdir(sMountPath);
550	except:
551	if not fIgnoreError:
552	reporter.errorXcpt('Failed to remove directory %s' % sMountPath);
553	return fRc;
554
555	def _darwinMountDmg(self, sDmg):
556	"""
557	Mount the DMG at the default mount point.
558	"""
559	self._darwinUnmountDmg(fIgnoreError = True)
560
561	sMountPath = self._darwinDmgPath();
562	if not os.path.exists(sMountPath):
563	try:
564	os.mkdir(sMountPath, 0755);
565	except:
566	reporter.logXcpt();
567	return False;
568
569	return self._executeSync(['hdiutil', 'attach', '-readonly', '-mount', 'required', '-mountpoint', sMountPath, sDmg, ]);
570
571	def _installVBoxOnDarwin(self):
572	""" Installs VBox on Mac OS X."""
573	sDmg = self._findFile('^VirtualBox-.*\\.dmg$');
574	if sDmg is None:
575	return False;
576
577	# Mount the DMG.
578	fRc = self._darwinMountDmg(sDmg);
579	if fRc is not True:
580	return False;
581
582	# Uninstall any previous vbox version first.
583	sUninstaller = os.path.join(self._darwinDmgPath(), 'VirtualBox_Uninstall.tool');
584	fRc, _ = self._sudoExecuteSync([sUninstaller, '--unattended',]);
585	if fRc is True:
586
587	# Install the package.
588	sPkg = os.path.join(self._darwinDmgPath(), 'VirtualBox.pkg');
589	fRc, _ = self._sudoExecuteSync(['installer', '-verbose', '-dumplog', '-pkg', sPkg, '-target', '/']);
590
591	# Unmount the DMG and we're done.
592	if not self._darwinUnmountDmg(fIgnoreError = False):
593	fRc = False;
594	return fRc;
595
596	def _uninstallVBoxOnDarwin(self):
597	""" Uninstalls VBox on Mac OS X."""
598
599	# Is VirtualBox installed? If not, don't try uninstall it.
600	sVBox = self._getVBoxInstallPath(fFailIfNotFound = False);
601	if sVBox is None:
602	return True;
603
604	# Find the dmg.
605	sDmg = self._findFile('^VirtualBox-.*\\.dmg$');
606	if sDmg is None:
607	return False;
608	if not os.path.exists(sDmg):
609	return True;
610
611	# Mount the DMG.
612	fRc = self._darwinMountDmg(sDmg);
613	if fRc is not True:
614	return False;
615
616	# Execute the uninstaller.
617	sUninstaller = os.path.join(self._darwinDmgPath(), 'VirtualBox_Uninstall.tool');
618	fRc, _ = self._sudoExecuteSync([sUninstaller, '--unattended',]);
619
620	# Unmount the DMG and we're done.
621	if not self._darwinUnmountDmg(fIgnoreError = False):
622	fRc = False;
623	return fRc;
624
625	#
626	# GNU/Linux
627	#
628
629	def _installVBoxOnLinux(self):
630	""" Installs VBox on Linux."""
631	sRun = self._findFile('^VirtualBox-.*\\.run$');
632	if sRun is None:
633	return False;
634	utils.chmodPlusX(sRun);
635
636	# Install the new one.
637	fRc, _ = self._sudoExecuteSync([sRun,]);
638	return fRc;
639
640	def _uninstallVBoxOnLinux(self):
641	""" Uninstalls VBox on Linux."""
642
643	# Is VirtualBox installed? If not, don't try uninstall it.
644	sVBox = self._getVBoxInstallPath(fFailIfNotFound = False);
645	if sVBox is None:
646	return True;
647
648	# Find the .run file and use it.
649	sRun = self._findFile('^VirtualBox-.*\\.run$', fMandatory = False);
650	if sRun is not None:
651	utils.chmodPlusX(sRun);
652	fRc, _ = self._sudoExecuteSync([sRun, 'uninstall']);
653	return fRc;
654
655	# Try the installed uninstaller.
656	for sUninstaller in [os.path.join(sVBox, 'uninstall.sh'), '/opt/VirtualBox/uninstall.sh', ]:
657	if os.path.isfile(sUninstaller):
658	reporter.log('Invoking "%s"...' % (sUninstaller,));
659	fRc, _ = self._sudoExecuteSync([sUninstaller, 'uninstall']);
660	return fRc;
661
662	reporter.log('Did not find any VirtualBox install to uninstall.');
663	return True;
664
665
666	#
667	# Solaris
668	#
669
670	def _generateAutoResponseOnSolaris(self):
671	"""
672	Generates an autoresponse file on solaris, returning the name.
673	None is return on failure.
674	"""
675	sPath = os.path.join(self.sScratchPath, 'SolarisAutoResponse');
676	oFile = utils.openNoInherit(sPath, 'wt');
677	oFile.write('basedir=default\n'
678	'runlevel=nocheck\n'
679	'conflict=quit\n'
680	'setuid=nocheck\n'
681	'action=nocheck\n'
682	'partial=quit\n'
683	'instance=unique\n'
684	'idepend=quit\n'
685	'rdepend=quit\n'
686	'space=quit\n'
687	'mail=\n');
688	oFile.close();
689	return sPath;
690
691	def _installVBoxOnSolaris(self):
692	""" Installs VBox on Solaris."""
693	sPkg = self._findFile('^VirtualBox-.*\\.pkg$', fMandatory = False);
694	if sPkg is None:
695	sTar = self._findFile('^VirtualBox-.-SunOS-.\\.tar.gz$', fMandatory = False);
696	if sTar is not None:
697	if self._maybeUnpackArchive(sTar) is not True:
698	return False;
699	sPkg = self._findFile('^VirtualBox-.*\\.pkg$', fMandatory = True);
700	sRsp = self._findFile('^autoresponse$', fMandatory = True);
701	if sPkg is None or sRsp is None:
702	return False;
703
704	# Uninstall first (ignore result).
705	self._uninstallVBoxOnSolaris();
706
707	# Install the new one.
708	fRc, _ = self._sudoExecuteSync(['pkgadd', '-d', sPkg, '-n', '-a', sRsp, 'SUNWvbox']);
709	return fRc;
710
711	def _uninstallVBoxOnSolaris(self):
712	""" Uninstalls VBox on Solaris."""
713	reporter.flushall();
714	if utils.processCall(['pkginfo', '-q', 'SUNWvbox']) != 0:
715	return True;
716	sRsp = self._generateAutoResponseOnSolaris();
717	fRc, _ = self._sudoExecuteSync(['pkgrm', '-n', '-a', sRsp, 'SUNWvbox']);
718	return fRc;
719
720	#
721	# Windows
722	#
723
724	## VBox windows services we can query the status of.
725	kasWindowsServices = [ 'vboxdrv', 'vboxusbmon', 'vboxnetadp', 'vboxnetflt', 'vboxnetlwf' ];
726
727	def _installVBoxOnWindows(self):
728	""" Installs VBox on Windows."""
729	sExe = self._findFile('^VirtualBox-.*-(MultiArch\|Win).exe$');
730	if sExe is None:
731	return False;
732
733	# TEMPORARY HACK - START
734	# It seems that running the NDIS cleanup script upon uninstallation is not
735	# a good idea, so let's run it before installing VirtualBox.
736	#sHostName = socket.getfqdn();
737	#if not sHostName.startswith('testboxwin3') \
738	# and not sHostName.startswith('testboxharp2') \
739	# and not sHostName.startswith('wei01-b6ka-3') \
740	# and utils.getHostOsVersion() in ['8', '8.1', '9', '2008Server', '2008ServerR2', '2012Server']:
741	# reporter.log('Peforming extra NDIS cleanup...');
742	# sMagicScript = os.path.abspath(os.path.join(g_ksValidationKitDir, 'testdriver', 'win-vbox-net-uninstall.ps1'));
743	# fRc2, _ = self._sudoExecuteSync(['powershell.exe', '-Command', 'set-executionpolicy unrestricted']);
744	# if not fRc2:
745	# reporter.log('set-executionpolicy failed.');
746	# self._sudoExecuteSync(['powershell.exe', '-Command', 'get-executionpolicy']);
747	# fRc2, _ = self._sudoExecuteSync(['powershell.exe', '-File', sMagicScript]);
748	# if not fRc2:
749	# reporter.log('NDIS cleanup failed.');
750	# TEMPORARY HACK - END
751
752	# Uninstall any previous vbox version first.
753	fRc = self._uninstallVBoxOnWindows(True);
754	if fRc is not True:
755	return None; # There shouldn't be anything to uninstall, and if there is, it's not our fault.
756
757	# Install the new one.
758	asArgs = [sExe, '-vvvv', '--silent', '--logging'];
759	asArgs.extend(['--msiparams', 'REBOOT=ReallySuppress']);
760	sVBoxInstallPath = os.environ.get('VBOX_INSTALL_PATH', None);
761	if sVBoxInstallPath is not None:
762	asArgs.extend(['INSTALLDIR="%s"' % (sVBoxInstallPath,)]);
763	fRc2, iRc = self._sudoExecuteSync(asArgs);
764	if fRc2 is False:
765	if iRc == 3010: # ERROR_SUCCESS_REBOOT_REQUIRED
766	reporter.log('Note: Installer required a reboot to complete installation');
767	# Optional, don't fail.
768	else:
769	fRc = False;
770	sLogFile = os.path.join(tempfile.gettempdir(), 'VirtualBox', 'VBoxInstallLog.txt');
771	if sLogFile is not None \
772	and os.path.isfile(sLogFile):
773	reporter.addLogFile(sLogFile, 'log/installer', "Verbose MSI installation log file");
774	self._waitForTestManagerConnectivity(30);
775	return fRc;
776
777	def _isProcessPresent(self, sName):
778	""" Checks whether the named process is present or not. """
779	for oProcess in utils.processListAll():
780	sBase = oProcess.getBaseImageNameNoExeSuff();
781	if sBase is not None and sBase.lower() == sName:
782	return True;
783	return False;
784
785	def _killProcessesByName(self, sName, sDesc, fChildren = False):
786	""" Kills the named process, optionally including children. """
787	cKilled = 0;
788	aoProcesses = utils.processListAll();
789	for oProcess in aoProcesses:
790	sBase = oProcess.getBaseImageNameNoExeSuff();
791	if sBase is not None and sBase.lower() == sName:
792	reporter.log('Killing %s process: %s (%s)' % (sDesc, oProcess.iPid, sBase));
793	utils.processKill(oProcess.iPid);
794	cKilled += 1;
795
796	if fChildren:
797	for oChild in aoProcesses:
798	if oChild.iParentPid == oProcess.iPid and oChild.iParentPid is not None:
799	reporter.log('Killing %s child process: %s (%s)' % (sDesc, oChild.iPid, sBase));
800	utils.processKill(oChild.iPid);
801	cKilled += 1;
802	return cKilled;
803
804	def _killProcessesByNameAndArgSubstr(self, sName, sArg, sDesc):
805	""" Kills the named process, if one of its args contains the string. """
806	cKilled = 0;
807	aoProcesses = utils.processListAll();
808	for oProcess in aoProcesses:
809	sBase = oProcess.getBaseImageNameNoExeSuff();
810	if sBase is not None and sBase.lower() == sName and any(sArg in s for s in oProcess.asArgs):
811
812	reporter.log('Killing %s process: %s (%s)' % (sDesc, oProcess.iPid, sBase));
813	utils.processKill(oProcess.iPid);
814	cKilled += 1;
815	return cKilled;
816
817	def _uninstallVBoxOnWindows(self, fIgnoreServices = False):
818	"""
819	Uninstalls VBox on Windows, all installations we find to be on the safe side...
820	"""
821
822	import win32com.client; # pylint: disable=F0401
823	win32com.client.gencache.EnsureModule('{000C1092-0000-0000-C000-000000000046}', 1033, 1, 0);
824	oInstaller = win32com.client.Dispatch('WindowsInstaller.Installer',
825	resultCLSID = '{000C1090-0000-0000-C000-000000000046}')
826
827	# Search installed products for VirtualBox.
828	asProdCodes = [];
829	for sProdCode in oInstaller.Products:
830	try:
831	sProdName = oInstaller.ProductInfo(sProdCode, "ProductName");
832	except:
833	reporter.logXcpt();
834	continue;
835	#reporter.log('Info: %s=%s' % (sProdCode, sProdName));
836	if sProdName.startswith('Oracle VM VirtualBox') \
837	or sProdName.startswith('Sun VirtualBox'):
838	asProdCodes.append([sProdCode, sProdName]);
839
840	# Before we start uninstalling anything, just ruthlessly kill any
841	# msiexec, drvinst and some rundll process we might find hanging around.
842	if self._isProcessPresent('rundll32'):
843	cTimes = 0;
844	while cTimes < 3:
845	cTimes += 1;
846	cKilled = self._killProcessesByNameAndArgSubstr('rundll32', 'InstallSecurityPromptRunDllW', 'MSI driver installation');
847	if cKilled <= 0:
848	break;
849	time.sleep(10); # Give related drvinst process a chance to clean up after we killed the verification dialog.
850
851	if self._isProcessPresent('drvinst'):
852	time.sleep(15); # In the hope that it goes away.
853	cTimes = 0;
854	while cTimes < 4:
855	cTimes += 1;
856	cKilled = self._killProcessesByName('drvinst', 'MSI driver installation', True);
857	if cKilled <= 0:
858	break;
859	time.sleep(10); # Give related MSI process a chance to clean up after we killed the driver installer.
860
861	if self._isProcessPresent('msiexec'):
862	cTimes = 0;
863	while cTimes < 3:
864	reporter.log('found running msiexec process, waiting a bit...');
865	time.sleep(20) # In the hope that it goes away.
866	if not self._isProcessPresent('msiexec'):
867	break;
868	cTimes += 1;
869	## @todo this could also be the msiexec system service, try to detect this case!
870	if cTimes >= 6:
871	cKilled = self._killProcessesByName('msiexec', 'MSI driver installation');
872	if cKilled > 0:
873	time.sleep(16); # fudge.
874
875	# Do the uninstalling.
876	fRc = True;
877	sLogFile = os.path.join(self.sScratchPath, 'VBoxUninstallLog.txt');
878	for sProdCode, sProdName in asProdCodes:
879	reporter.log('Uninstalling %s (%s)...' % (sProdName, sProdCode));
880	fRc2, iRc = self._sudoExecuteSync(['msiexec', '/uninstall', sProdCode, '/quiet', '/passive', '/norestart',
881	'/L*v', '%s' % (sLogFile), ]);
882	if fRc2 is False:
883	if iRc == 3010: # ERROR_SUCCESS_REBOOT_REQUIRED
884	reporter.log('Note: Uninstaller required a reboot to complete uninstallation');
885	# Optional, don't fail.
886	else:
887	fRc = False;
888	reporter.addLogFile(sLogFile, 'log/uninstaller', "Verbose MSI uninstallation log file");
889
890	self._waitForTestManagerConnectivity(30);
891	if fRc is False and os.path.isfile(sLogFile):
892	reporter.addLogFile(sLogFile, 'log/uninstaller');
893
894	# Log driver service states (should ls \Driver\VBox* and \Device\VBox*).
895	for sService in self.kasWindowsServices:
896	fRc2, _ = self._sudoExecuteSync(['sc.exe', 'query', sService]);
897	if fIgnoreServices is False and fRc2 is True:
898	fRc = False
899
900	return fRc;
901
902
903	#
904	# Extension pack.
905	#
906
907	def _getVBoxInstallPath(self, fFailIfNotFound):
908	""" Returns the default VBox installation path. """
909	sHost = utils.getHostOs();
910	if sHost == 'win':
911	sProgFiles = os.environ.get('ProgramFiles', 'C:\\Program Files');
912	asLocs = [
913	os.path.join(sProgFiles, 'Oracle', 'VirtualBox'),
914	os.path.join(sProgFiles, 'OracleVM', 'VirtualBox'),
915	os.path.join(sProgFiles, 'Sun', 'VirtualBox'),
916	];
917	elif sHost == 'linux' or sHost == 'solaris':
918	asLocs = [ '/opt/VirtualBox', '/opt/VirtualBox-3.2', '/opt/VirtualBox-3.1', '/opt/VirtualBox-3.0'];
919	elif sHost == 'darwin':
920	asLocs = [ '/Applications/VirtualBox.app/Contents/MacOS' ];
921	else:
922	asLocs = [ '/opt/VirtualBox' ];
923	if 'VBOX_INSTALL_PATH' in os.environ:
924	asLocs.insert(0, os.environ.get('VBOX_INSTALL_PATH', None));
925
926	for sLoc in asLocs:
927	if os.path.isdir(sLoc):
928	return sLoc;
929	if fFailIfNotFound:
930	reporter.error('Failed to locate VirtualBox installation: %s' % (asLocs,));
931	else:
932	reporter.log2('Failed to locate VirtualBox installation: %s' % (asLocs,));
933	return None;
934
935	def _installExtPack(self):
936	""" Installs the extension pack. """
937	sVBox = self._getVBoxInstallPath(fFailIfNotFound = True);
938	if sVBox is None:
939	return False;
940	sExtPackDir = os.path.join(sVBox, 'ExtensionPacks');
941
942	if self._uninstallAllExtPacks() is not True:
943	return False;
944
945	sExtPack = self._findFile('Oracle_VM_VirtualBox_Extension_Pack.vbox-extpack');
946	if sExtPack is None:
947	sExtPack = self._findFile('Oracle_VM_VirtualBox_Extension_Pack.*.vbox-extpack');
948	if sExtPack is None:
949	return True;
950
951	sDstDir = os.path.join(sExtPackDir, 'Oracle_VM_VirtualBox_Extension_Pack');
952	reporter.log('Installing extension pack "%s" to "%s"...' % (sExtPack, sExtPackDir));
953	fRc, _ = self._sudoExecuteSync([ self.getBinTool('vts_tar'),
954	'--extract',
955	'--verbose',
956	'--gzip',
957	'--file', sExtPack,
958	'--directory', sDstDir,
959	'--file-mode-and-mask', '0644',
960	'--file-mode-or-mask', '0644',
961	'--dir-mode-and-mask', '0755',
962	'--dir-mode-or-mask', '0755',
963	'--owner', '0',
964	'--group', '0',
965	]);
966	return fRc;
967
968	def _uninstallAllExtPacks(self):
969	""" Uninstalls all extension packs. """
970	sVBox = self._getVBoxInstallPath(fFailIfNotFound = False);
971	if sVBox is None:
972	return True;
973
974	sExtPackDir = os.path.join(sVBox, 'ExtensionPacks');
975	if not os.path.exists(sExtPackDir):
976	return True;
977
978	fRc, _ = self._sudoExecuteSync([self.getBinTool('vts_rm'), '-Rfv', '--', sExtPackDir]);
979	return fRc;
980
981
982
983	if __name__ == '__main__':
984	sys.exit(VBoxInstallerTestDriver().main(sys.argv));
985

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

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

Download in other formats: