Changeset 79056 in vbox for trunk/src/VBox/ValidationKit

Timestamp:

Jun 9, 2019 8:55:56 PM (6 years ago)

Author:

vboxsync

Message:

ValKit/tdGuestOsUnattendedInst1: Added option for installing guest additions and implemented waiting for them to come online. bugref:9151

Location:

trunk/src/VBox/ValidationKit

Files:

• testdriver/vbox.py (modified) (4 diffs)
• testdriver/vboxwrappers.py (modified) (1 diff)
• tests/installation/tdGuestOsUnattendedInst1.py (modified) (7 diffs)

trunk/src/VBox/ValidationKit/testdriver/vbox.py

@@ -537 +537 @@
 
     @staticmethod
-    def registerDerivedEventHandler(oVBoxMgr, fpApiVer, oSubClass, dArgsCopy,
+    def registerDerivedEventHandler(oVBoxMgr, fpApiVer, oSubClass, dArgsCopy, # pylint: disable=too-many-arguments
                                     oSrcParent, sSrcParentNm, sICallbackNm,
-                                    fMustSucceed = True, sLogSuffix = ''):
+                                    fMustSucceed = True, sLogSuffix = '', aenmEvents = None):
         """
         Registers the callback / event listener.
@@ -559 +559 @@
                         reporter.errorXcpt('%s::registerCallback(%s)%s' % (sSrcParentNm, oRet, sLogSuffix));
         else:
+            #
+            # Scalable event handling introduced in VBox 4.0.
+            #
             fPassive = sys.platform == 'win32'; # or webservices.
+
+            if not aenmEvents:
+                aenmEvents = (vboxcon.VBoxEventType_Any,);
+
             try:
                 oEventSrc = oSrcParent.eventSource;
@@ -573 +580 @@
             else:
                 try:
-                    oEventSrc.registerListener(oListener, [vboxcon.VBoxEventType_Any], not fPassive);
+                    oEventSrc.registerListener(oListener, aenmEvents, not fPassive);
                 except Exception as oXcpt:
                     if fMustSucceed or ComError.notEqual(oXcpt, ComError.E_UNEXPECTED):
-                        reporter.errorXcpt('%s::eventSource.registerListener(%s) failed%s' \
+                        reporter.errorXcpt('%s::eventSource.registerListener(%s) failed%s'
                                            % (sSrcParentNm, oListener, sLogSuffix));
                 else:
@@ -3922 +3929 @@
             sRet = None;
         return sRet;
+
+    #
+    # Other stuff
+    #
+
+    def waitForGAs(self,
+                   oSession, # type: vboxwrappers.SessionWrapper
+                   cMsTimeout = 120000, aenmWaitForRunLevels = None, aenmWaitForActive = None, aenmWaitForInactive = None):
+        """
+        Waits for the guest additions to enter a certain state.
+
+        aenmWaitForRunLevels - List of run level values to wait for (success if one matches).
+        aenmWaitForActive    - List facilities (type values) that must be active.
+        aenmWaitForInactive  - List facilities (type values) that must be inactive.
+
+        Defaults to wait for AdditionsRunLevelType_Userland if nothing else is given.
+
+        Returns True on success, False w/ error logging on timeout or failure.
+        """
+        reporter.log2('waitForGAs: oSession=%s, cMsTimeout=%s' % (oSession, cMsTimeout,));
+
+        #
+        # Get IGuest:
+        #
+        try:
+            oIGuest = oSession.o.console.guest;
+        except:
+            return reporter.errorXcpt();
+
+        #
+        # Create a wait task:
+        #
+        from testdriver.vboxwrappers import AdditionsStatusTask;
+        try:
+            oGaStatusTask = AdditionsStatusTask(oSession             = oSession,
+                                                oIGuest              = oIGuest,
+                                                cMsTimeout           = cMsTimeout,
+                                                aenmWaitForRunLevels = aenmWaitForRunLevels,
+                                                aenmWaitForActive    = aenmWaitForActive,
+                                                aenmWaitForInactive  = aenmWaitForInactive);
+        except:
+            return reporter.errorXcpt();
+
+        #
+        # Add the task and make sure the VM session is also present.
+        #
+        self.addTask(oGaStatusTask);
+        fRemoveSession = self.addTask(oSession);
+        oTask          = self.waitForTasks(cMsTimeout + 1);
+        reporter.log2('waitForGAs: returned %s (oGaStatusTask=%s, oSession=%s)' % (oTask, oGaStatusTask, oSession,));
+        self.removeTask(oGaStatusTask);
+        if fRemoveSession:
+            self.removeTask(oSession);
+
+        #
+        # Digest the result.
+        #
+        if oTask is oGaStatusTask:
+            fSucceeded = oGaStatusTask.getResult();
+            if fSucceeded is True:
+                reporter.log('waitForGAs: Succeeded.');
+            else:
+                reporter.error('waitForGAs: Failed.');
+        else:
+            oGaStatusTask.cancelTask();
+            if oTask is None:
+                reporter.error('waitForGAs: Timed out.');
+            elif oTask is oSession:
+                oSession.reportPrematureTermination('waitForGAs: ');
+            else:
+                reporter.error('waitForGAs: unknown/wrong task %s' % (oTask,));
+            fSucceeded = False;
+        return fSucceeded;
+

trunk/src/VBox/ValidationKit/testdriver/vboxwrappers.py

@@ -3228 +3228 @@
         return True;
 
+
+
+class AdditionsStatusTask(TdTaskBase):
+    """
+    Class that takes care of waiting till the guest additions are in a given state.
+    """
+
+    class AdditionsStatusTaskCallback(vbox.EventHandlerBase):
+        """ Class for looking for IPv4 address changes on interface 0."""
+        def __init__(self, dArgs):
+            self.oParentTask = dArgs['oParentTask'];
+            vbox.EventHandlerBase.__init__(self, dArgs, self.oParentTask.oSession.fpApiVer,
+                                           'AdditionsStatusTaskCallback/%s' % (self.oParentTask.oSession.sName,));
+
+        def handleEvent(self, oEvt):
+            try:
+                enmType = oEvt.type;
+            except:
+                reporter.errorXcpt();
+            else:
+                reporter.log2('AdditionsStatusTaskCallback:handleEvent: enmType=%s' % (enmType,));
+                if enmType == vboxcon.VBoxEventType_OnGuestAdditionsStatusChanged:
+                    oParentTask = self.oParentTask;
+                    if oParentTask:
+                        oParentTask.pollTask();
+
+            # end
+
+
+    def __init__(self, oSession, oIGuest, cMsTimeout = 120000, aenmWaitForRunLevels = None, aenmWaitForActive = None,
+                 aenmWaitForInactive = None):
+        """
+        aenmWaitForRunLevels - List of run level values to wait for (success if one matches).
+        aenmWaitForActive    - List facilities (type values) that must be active.
+        aenmWaitForInactive  - List facilities (type values) that must be inactive.
+
+        The default is to wait for AdditionsRunLevelType_Userland if all three lists
+        are unspecified or empty.
+        """
+        TdTaskBase.__init__(self, utils.getCallerName());
+        self.oSession               = oSession      # type: vboxwrappers.SessionWrapper
+        self.oIGuest                = oIGuest;
+        self.cMsTimeout             = cMsTimeout;
+        self.fSucceeded             = False;
+        self.oVBoxEventHandler      = None;
+        self.aenmWaitForRunLevels   = aenmWaitForRunLevels if aenmWaitForRunLevels else [];
+        self.aenmWaitForActive      = aenmWaitForActive    if aenmWaitForActive    else [];
+        self.aenmWaitForInactive    = aenmWaitForInactive  if aenmWaitForInactive  else [];
+
+        # Provide a sensible default if nothing is given.
+        if not self.aenmWaitForRunLevels and not self.aenmWaitForActive and not self.aenmWaitForInactive:
+            self.aenmWaitForRunLevels = [vboxcon.AdditionsRunLevelType_Userland,];
+
+        # Register the event handler on hosts which has it:
+        if oSession.fpApiVer >= 6.1 or hasattr(vboxcon, 'VBoxEventType_OnGuestAdditionsStatusChanged'):
+            aenmEvents = (vboxcon.VBoxEventType_OnGuestAdditionsStatusChanged,);
+            dArgs = {
+                'oParentTask': self,
+            };
+            self.oVBoxEventHandler = vbox.EventHandlerBase.registerDerivedEventHandler(oSession.oVBoxMgr,
+                                                                                       oSession.fpApiVer,
+                                                                                       self.AdditionsStatusTaskCallback,
+                                                                                       dArgs,
+                                                                                       oIGuest,
+                                                                                       'IGuest',
+                                                                                       'AdditionsStatusTaskCallback',
+                                                                                       aenmEvents = aenmEvents);
+        reporter.log2('AdditionsStatusTask: %s' % (self.toString(), ));
+
+    def __del__(self):
+        """ Make sure we deregister the callback. """
+        self._deregisterEventHandler();
+        self.oIGuest = None;
+        return TdTaskBase.__del__(self);
+
+    def toString(self):
+        return '<%s cMsTimeout=%s, fSucceeded=%s, aenmWaitForRunLevels=%s, aenmWaitForActive=%s, aenmWaitForInactive=%s, ' \
+               'oVBoxEventHandler=%s>' \
+             % (TdTaskBase.toString(self), self.cMsTimeout, self.fSucceeded, self.aenmWaitForRunLevels, self.aenmWaitForActive,
+                self.aenmWaitForInactive, self.oVBoxEventHandler,);
+
+    def _deregisterEventHandler(self):
+        """Deregisters the event handler."""
+        fRc = True;
+        oVBoxEventHandler = self.oVBoxEventHandler;
+        if oVBoxEventHandler is not None:
+            self.oVBoxEventHandler = None;
+            fRc = oVBoxEventHandler.unregister();
+            oVBoxEventHandler.oParentTask = None; # Try avoid cylic deps.
+        return fRc;
+
+    def _poll(self):
+        """
+        Internal worker for pollTask() that returns the new signalled state.
+        """
+
+        #
+        # Check if any of the runlevels we wait for have been reached:
+        #
+        if self.aenmWaitForRunLevels:
+            try:
+                enmRunLevel = self.oIGuest.additionsRunLevel;
+            except:
+                reporter.errorXcpt();
+                return True;
+            if enmRunLevel not in self.aenmWaitForRunLevels:
+                reporter.log2('AdditionsStatusTask/poll: enmRunLevel=%s not in %s' % (enmRunLevel, self.aenmWaitForRunLevels,));
+                return False;
+            reporter.log2('AdditionsStatusTask/poll: enmRunLevel=%s matched %s!' % (enmRunLevel, self.aenmWaitForRunLevels,));
+
+
+        #
+        # Check for the facilities that must all be active.
+        #
+        for enmFacility in self.aenmWaitForActive:
+            try:
+                (enmStatus, _) = self.oIGuest.getFacilityStatus(enmFacility);
+            except:
+                reporter.errorXcpt('enmFacility=%s' % (enmFacility,));
+                return True;
+            if enmStatus != vboxcon.AdditionsFacilityStatus_Active:
+                reporter.log2('AdditionsStatusTask/poll: enmFacility=%s not active: %s' % (enmFacility, enmStatus,));
+                return False;
+
+        #
+        # Check for the facilities that must all be inactive or terminated.
+        #
+        for enmFacility in self.aenmWaitForInactive:
+            try:
+                (enmStatus, _) = self.oIGuest.getFacilityStatus(enmFacility);
+            except:
+                reporter.errorXcpt('enmFacility=%s' % (enmFacility,));
+                return True;
+            if enmStatus not in (vboxcon.AdditionsFacilityStatus_Inactive,
+                                 vboxcon.AdditionsFacilityStatus_Terminated):
+                reporter.log2('AdditionsStatusTask/poll: enmFacility=%s not inactive: %s' % (enmFacility, enmStatus,));
+                return False;
+
+
+        reporter.log('AdditionsStatusTask: Poll succeeded, signalling...');
+        self.fSucceeded = True;
+        return True;
+
+
+    #
+    # Task methods
+    #
+
+    def pollTask(self, fLocked = False):
+        """
+        Overridden pollTask method.
+        """
+        if not fLocked:
+            self.lockTask();
+
+        fDeregister = False;
+        fRc = self.fSignalled;
+        if not fRc:
+            fRc = self._poll();
+            if fRc or self.getAgeAsMs() >= self.cMsTimeout:
+                self.signalTaskLocked();
+                fDeregister = True;
+
+        if not fLocked:
+            self.unlockTask();
+
+        # If we're done, deregister the event callback (w/o owning lock).
+        if fDeregister:
+            self._deregisterEventHandler();
+        return fRc;
+
+    def getResult(self):
+        """
+        Returns true if the we succeeded.
+        Returns false if not.  If the task is signalled already, then we
+        encountered a problem while polling.
+        """
+        return self.fSucceeded;
+
+    def cancelTask(self):
+        """
+        Cancels the task.
+        Just to actively disengage the event handler.
+        """
+        self._deregisterEventHandler();
+        return True;
+

trunk/src/VBox/ValidationKit/tests/installation/tdGuestOsUnattendedInst1.py

@@ -77 +77 @@
         self.fOptIoApic     = None;
         self.fOptPae        = None;
+        self.fOptInstallGAs = False;
         self.asOptExtraData = [];
         if fFlags & self.kfIdeIrqDelay:
             self.asOptExtraData = self.kasIdeIrqDelay;
+
+    def _unattendedConfigure(self, oIUnattended, oTestDrv): # type: (Any, vbox.TestDriver) -> bool
+        """
+        Configures the unattended install object.
+
+        The ISO attribute has been set and detectIsoOS has been done, the rest of the
+        setup is done here.
+
+        Returns True on success, False w/ errors logged on failure.
+        """
+
+        #
+        # Make it install the TXS.
+        #
+        try:    oIUnattended.installTestExecService = True;
+        except: return reporter.errorXcpt();
+        try:    oIUnattended.validationKitIsoPath   = oTestDrv.sVBoxValidationKitIso;
+        except: return reporter.errorXcpt();
+        oTestDrv.processPendingEvents();
+
+        #
+        # Install GAs?
+        #
+        if self.fOptInstallGAs:
+            try:    oIUnattended.installGuestAdditions = True;
+            except: return reporter.errorXcpt();
+            try:    oIUnattended.additionsIsoPath      = oTestDrv.getGuestAdditionsIso();
+            except: return reporter.errorXcpt();
+            oTestDrv.processPendingEvents();
+
+        return True;
+
+    def _unattendedDoIt(self, oIUnattended, oVM, oTestDrv): # type: (Any, Any, vbox.TestDriver) -> bool
+        """
+        Does the unattended installation preparing, media construction and VM reconfiguration.
+
+        Returns True on success, False w/ errors logged on failure.
+        """
+
+        # Associate oVM with the installer:
+        try:
+            oIUnattended.machine = oVM;
+        except:
+            return reporter.errorXcpt();
+        oTestDrv.processPendingEvents();
+
+        # Prepare and log it:
+        try:
+            oIUnattended.prepare();
+        except:
+            return reporter.errorXcpt("IUnattended.prepare failed");
+        oTestDrv.processPendingEvents();
+
+        reporter.log('IUnattended attributes after prepare():');
+        self._unattendedLogIt(oIUnattended, oTestDrv);
+
+        # Create media:
+        try:
+            oIUnattended.constructMedia();
+        except:
+            return reporter.errorXcpt("IUnattended.constructMedia failed");
+        oTestDrv.processPendingEvents();
+
+        # Reconfigure the VM:
+        try:
+            oIUnattended.reconfigureVM();
+        except:
+            return reporter.errorXcpt("IUnattended.reconfigureVM failed");
+        oTestDrv.processPendingEvents();
+
+        return True;
+
+    def _unattendedLogIt(self, oIUnattended, oTestDrv):
+        """
+        Logs the attributes of the unattended installation object.
+        """
+        fRc = True;
+        asAttribs = ( 'isoPath', 'user', 'password', 'fullUserName', 'productKey', 'additionsIsoPath', 'installGuestAdditions',
+                      'validationKitIsoPath', 'installTestExecService', 'timeZone', 'locale', 'language', 'country', 'proxy',
+                      'packageSelectionAdjustments', 'hostname', 'auxiliaryBasePath', 'imageIndex', 'machine',
+                      'scriptTemplatePath', 'postInstallScriptTemplatePath', 'postInstallCommand',
+                      'extraInstallKernelParameters', 'detectedOSTypeId', 'detectedOSVersion', 'detectedOSLanguages',
+                      'detectedOSFlavor', 'detectedOSHints', );
+        for sAttrib in asAttribs:
+            try:
+                oValue = getattr(oIUnattended, sAttrib);
+            except:
+                fRc = reporter.errorXcpt('sAttrib=%s' % sAttrib);
+            else:
+                reporter.log('%s: %s' % (sAttrib.rjust(32), oValue,));
+                oTestDrv.processPendingEvents();
+        return fRc;
 
 
@@ -172 +265 @@
         return (fRc, oVM)
 
+    def isLoggedOntoDesktop(self):
+        #
+        # Normally all unattended installations should end up on the desktop.
+        # An exception is a minimal install, but we currently don't support that.
+        #
+        return True;
+
     #
     # Our methods.
@@ -226 +326 @@
 
         return True;
-
-    def _unattendedConfigure(self, oIUnattended, oTestDrv): # type: (Any, vbox.TestDriver) -> bool
-        """
-        Configures the unattended install object.
-
-        The ISO attribute has been set and detectIsoOS has been done, the rest of the
-        setup is done here.
-
-        Returns True on success, False w/ errors logged on failure.
-        """
-
-        #
-        # Make it install the TXS.
-        #
-        try:    oIUnattended.installTestExecService = True;
-        except: return reporter.errorXcpt();
-        try:    oIUnattended.validationKitIsoPath = oTestDrv.sVBoxValidationKitIso;
-        except: return reporter.errorXcpt();
-
-        return True;
-
-    def _unattendedDoIt(self, oIUnattended, oVM, oTestDrv): # type: (Any, Any, vbox.TestDriver) -> bool
-        """
-        Does the unattended installation preparing, media construction and VM reconfiguration.
-
-        Returns True on success, False w/ errors logged on failure.
-        """
-
-        # Associate oVM with the installer:
-        try:
-            oIUnattended.machine = oVM;
-        except:
-            return reporter.errorXcpt();
-        oTestDrv.processPendingEvents();
-
-        # Prepare:
-        try:
-            oIUnattended.prepare();
-        except:
-            return reporter.errorXcpt("IUnattended.prepare failed");
-        oTestDrv.processPendingEvents();
-
-        # Create media:
-        try:
-            oIUnattended.constructMedia();
-        except:
-            return reporter.errorXcpt("IUnattended.constructMedia failed");
-        oTestDrv.processPendingEvents();
-
-        # Reconfigure the VM:
-        try:
-            oIUnattended.reconfigureVM();
-        except:
-            return reporter.errorXcpt("IUnattended.reconfigureVM failed");
-        oTestDrv.processPendingEvents();
-
-        return True;
-
-    def _unattendedLogIt(self, oIUnattended):
-        """
-        Logs the attributes of the unattended installation object.
-        """
-        fRc = True;
-        asAttribs = ( 'isoPath', 'user', 'password ', 'fullUserName', 'productKey', 'additionsIsoPath', 'installGuestAdditions',
-                      'validationKitIsoPath', 'installTestExecService', 'timeZone', 'locale', 'language', 'country', 'proxy',
-                      'packageSelectionAdjustments', 'hostname', 'auxiliaryBasePath', 'imageIndex', 'machine',
-                      'scriptTemplatePath', 'postInstallScriptTemplatePath', 'postInstallCommand',
-                      'extraInstallKernelParameters', 'detectedOSTypeId', 'detectedOSVersion', 'detectedOSLanguages',
-                      'detectedOSFlavor', 'detectedOSHints', );
-        for sAttrib in asAttribs:
-            try:
-                oValue = getattr(oIUnattended, sAttrib);
-            except:
-                fRc = reporter.errorXcpt('sAttrib=%s' % sAttrib);
-            else:
-                reporter.log('%s: %s' % (sAttrib.rjust(32), oValue,));
-        return fRc;
 
 
@@ -441 +464 @@
             for oTestVm in self.aoSelectedVms:
                 oTestVm.fOptPae = False;
+        elif asArgs[iArg] == '--install-additions':
+            for oTestVm in self.aoSelectedVms:
+                oTestVm.fOptInstallGAs = True;
+        elif asArgs[iArg] == '--no-install-additions':
+            for oTestVm in self.aoSelectedVms:
+                oTestVm.fOptInstallGAs = False;
         else:
             return vbox.TestDriver.parseOption(self, asArgs, iArg);
@@ -456 +485 @@
         return self.oTestVmSet.actionExecute(self, self.testOneVmConfig)
 
-    def testOneVmConfig(self, oVM, oTestVm):
+    def testOneVmConfig(self, oVM, oTestVm): # type: (Any, UnattendedVm) -> bool
         """
         Install guest OS and wait for result
@@ -462 +491 @@
 
         self.logVmInfo(oVM)
-        reporter.testStart('Installing %s' % (oTestVm.sVmName,))
+        reporter.testStart('Installing %s%s' % (oTestVm.sVmName, ' with GAs' if oTestVm.fOptInstallGAs else ''))
 
         cMsTimeout = 40*60000;
@@ -469 +498 @@
 
         oSession, _ = self.startVmAndConnectToTxsViaTcp(oTestVm.sVmName, fCdWait = False, cMsTimeout = cMsTimeout);
+        #oSession = self.startVmByName(oTestVm.sVmName); # (for quickly testing waitForGAs)
         if oSession is not None:
-            # The guest has connected to TXS, so we're done (for now anyways).
-            reporter.log('Guest reported success')
-            ## @todo Do save + restore.
+            # The guest has connected to TXS.
+            reporter.log('Guest reported success via TXS.');
+            #reporter.log('VM started...');              # (for quickly testing waitForGAs)
+
+            # If we're installing GAs, wait for them to come online:
+            fRc = True;
+            if oTestVm.fOptInstallGAs:
+                aenmRunLevels = [vboxcon.AdditionsRunLevelType_Userland,];
+                if oTestVm.isLoggedOntoDesktop():
+                    aenmRunLevels.append(vboxcon.AdditionsRunLevelType_Desktop);
+                fRc = self.waitForGAs(oSession, cMsTimeout = cMsTimeout / 2, aenmWaitForRunLevels = aenmRunLevels);
+
+            # Now do a save & restore test:
+            if fRc is True:
+                pass; ## @todo Do save + restore.
+
+            # Test GAs if requested:
+            if oTestVm.fOptInstallGAs and fRc is True:
+                pass;
 
             reporter.testDone()
-            fRc = self.terminateVmBySession(oSession)
+            fRc = self.terminateVmBySession(oSession) and fRc;
             return fRc is True
 
         reporter.error('Installation of %s has failed' % (oTestVm.sVmName,))
-        oTestVm.detatchAndDeleteHd(self); # Save space.
+        #oTestVm.detatchAndDeleteHd(self); # Save space.
         reporter.testDone()
         return False