Changeset 28354 in vbox

Timestamp:

Apr 15, 2010 12:34:53 PM (15 years ago)

Author:

vboxsync

Message:

Guest Control: Update (lProgress handling, wait for exiting process).

Location:

trunk/src/VBox

Files:

• Frontends/VBoxManage/VBoxManageGuestCtrl.cpp (modified) (5 diffs)
• Main/GuestImpl.cpp (modified) (8 diffs)
• Main/idl/VirtualBox.xidl (modified) (3 diffs)
• Main/include/GuestImpl.h (modified) (4 diffs)

trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp

@@ -64 +64 @@
     RTPrintf("VBoxManage guestcontrol     execute <vmname>|<uuid>\n"
              "                            <path to program> [--arguments \"<arguments>\"] [--environment \"NAME=VALUE NAME=VALUE\"]\n"
-             "                            [--flags <flags>] [--username <name> [--password <password>]]\n"
-             "                            [--timeout <msec>] [--verbose] [--wait stdout[,[stderr]]]\n"
+             "                            [--flags <flags>] [--timeout <msec>] [--username <name> [--password <password>]\n"
+             "                            [--verbose] [--wait-for exit]\n"
              "\n");
 }
@@ -87 +87 @@
     Utf8Str Utf8UserName;
     Utf8Str Utf8Password;
-    uint32_t uTimeoutMS = RT_INDEFINITE_WAIT;
-    bool waitForOutput = false;
+    uint32_t uTimeoutMS = 0;
+    bool waitForExit = false;
+    bool waitForStdOut = false;
+    bool waitForStdErr = false;
     bool verbose = false;
 
@@ -176 +178 @@
                 ++i;
         }
-        else if (!strcmp(a->argv[i], "--wait"))
-        {
-            if (i + 1 >= a->argc)
-                usageOK = false;
-            else
-            {
-                /** @todo Check for "stdout" or "stderr"! */
-                waitForOutput = true;
+        else if (!strcmp(a->argv[i], "--wait-for"))
+        {
+            if (i + 1 >= a->argc)
+                usageOK = false;
+            else
+            {
+                if (!strcmp(a->argv[i + 1], "exit"))
+                    waitForExit = true;
+                else if (!strcmp(a->argv[i + 1], "stdout"))
+                    waitForStdOut = true;
+                else if (!strcmp(a->argv[i + 1], "stderr"))
+                    waitForStdErr = true;
+                else
+                    usageOK = false;
                 ++i;
             }
@@ -243 +251 @@
             ULONG uPID = 0;
 
-            if (verbose) RTPrintf("Waiting for guest to start process ...\n");
+            if (verbose) 
+            {
+                if (uTimeoutMS == 0)
+                    RTPrintf("Waiting for guest to start process ...\n");
+                else
+                    RTPrintf("Waiting for guest to start process (within %ums)\n", uTimeoutMS);
+            }
+
+            /* Get current time stamp to later calculate rest of timeout left. */
+            uint32_t uStartMS = RTTimeMilliTS();
+
+            /* Execute the process. */
             CHECK_ERROR_BREAK(guest, ExecuteProcess(Bstr(Utf8Cmd), uFlags,
                                                     ComSafeArrayAsInParam(args), ComSafeArrayAsInParam(env),
@@ -250 +269 @@
                                                     &uPID, progress.asOutParam()));
             if (verbose) RTPrintf("Process '%s' (PID: %u) started.\n", Utf8Cmd.raw(), uPID);
-            if (waitForOutput)
-            {
-                if (verbose) RTPrintf("Waiting for output ...\n");
-                /** @todo */
-            }
-            /** @todo Show some progress here? */
+            if (waitForExit)
+            {
+                /* Calculate timeout value left after process has been started.  */
+                if (uTimeoutMS)
+                    uTimeoutMS = uTimeoutMS - (RTTimeMilliTS() - uStartMS);
+                if (verbose)
+                {
+                    if (uTimeoutMS == 0)
+                        RTPrintf("Waiting for process to exit ...\n");
+                    else
+                        RTPrintf("Waiting for process to exit (%ums left) ...\n", uTimeoutMS);
+                }
+
+                /* Wait for process to exit ... */
+                ASSERT(progress);
+                rc = progress->WaitForCompletion(uTimeoutMS == 0 ? -1 /* Wait forever */ : uTimeoutMS);
+                if (FAILED(rc))
+                {
+                    if (uTimeoutMS)
+                        RTStrmPrintf(g_pStdErr, "Process '%s' (PID: %u) did not end within %ums! Wait aborted.\n",
+                                     Utf8Cmd.raw(), uPID, uTimeoutMS);
+                    break;
+                }
+                else
+                {
+                    BOOL completed;
+                    CHECK_ERROR_RET(progress, COMGETTER(Completed)(&completed), rc);
+                    ASSERT(completed);
+
+                    LONG iRc;
+                    CHECK_ERROR_RET(progress, COMGETTER(ResultCode)(&iRc), rc);
+
+                    if (verbose) 
+                        RTPrintf("Process completed.\n");
+
+                    /* Print output if wanted. */
+                    if (   waitForStdOut
+                        || waitForStdErr)
+                    {
+                        Bstr strOutput;
+                        CHECK_ERROR_BREAK(guest, GetProcessOutput(strOutput.asOutParam(), 0 /* @todo */));
+                        if (verbose) 
+                            RTPrintf("Output is:\n");
+                        //RTPrintf(strOutput.raw());
+                    }
+                }
+            }
             a->session->Close();
         } while (0);

trunk/src/VBox/Main/GuestImpl.cpp

@@ -506 +506 @@
         /* @todo Copy void* buffer contents! */
 
+        /* Do progress handling. */
+        switch (pData->u32Status)
+        {
+            case PROC_STS_TEN: /* Terminated normally. */
+            case PROC_STS_TEA: /* Terminated abnormally. */
+            case PROC_STS_TES: /* Terminated through signal. */
+
+                if (!it->pProgress.isNull())
+                    it->pProgress->notifyComplete(S_OK);
+                break;
+
+            default:
+                break;
+        }
+
         ASMAtomicWriteBool(&it->bCalled, true);
     }
@@ -529 +544 @@
         it->cbData = 0;
         it->pvData = NULL;
+
+        /* Notify outstanding waits for progress ... */
+        if (!it->pProgress.isNull())
+        {
+            it->pProgress->notifyComplete(S_OK);
+            it->pProgress = NULL;
+        }
     }
     mCallbackList.erase(it);
 }
 
-uint32_t Guest::addCtrlCallbackContext(void *pvData, uint32_t cbData)
+uint32_t Guest::addCtrlCallbackContext(void *pvData, uint32_t cbData, Progress* pProgress)
 {
     uint32_t uNewContext = ASMAtomicIncU32(&mNextContextID);
@@ -543 +565 @@
     context.pvData = pvData;
     context.cbData = cbData;
+    context.pProgress = pProgress;
 
     mCallbackList.push_back(context);
@@ -581 +604 @@
          * Create progress object.
          */
-#if 0
         ComObjPtr <Progress> progress;
-        progress.createObject();
-        HRESULT rc = progress->init(/** @todo How to get the machine here? */
-                                    static_cast<IGuest*>(this),
-                                    BstrFmt(tr("Executing process")),
-                                    FALSE);
+        HRESULT rc = progress.createObject();
+        if (SUCCEEDED(rc))
+        {
+            rc = progress->init(static_cast<IGuest*>(this),
+                                //static_cast<IConsole *>(this),
+                                BstrFmt(tr("Executing process")),
+                                FALSE);
+        }
         if (FAILED(rc)) return rc;
-#endif
+
         /*
          * Prepare process execution.
@@ -647 +672 @@
                     PHOSTEXECCALLBACKDATA pData = (HOSTEXECCALLBACKDATA*)RTMemAlloc(sizeof(HOSTEXECCALLBACKDATA));
                     AssertPtr(pData);
-                    uContextID = addCtrlCallbackContext(pData, sizeof(HOSTEXECCALLBACKDATA));
+                    uContextID = addCtrlCallbackContext(pData, sizeof(HOSTEXECCALLBACKDATA), progress);
                     Assert(uContextID > 0);
 
@@ -729 +754 @@
                 else /* If callback not called within time ... well, that's a timeout! */
                     vrc = VERR_TIMEOUT;
-                removeCtrlCallbackContext(it);
-
+                
+                /*
+                 * Do *not* remove the callback yet - we might wait with the IProgress object on something
+                 * else (like end of process) ... 
+                 */
                 if (RT_FAILURE(vrc))
                 {
@@ -759 +787 @@
                     }
                 }
-#if 0
-                progress.queryInterfaceTo(aProgress);
-#endif
+                else
+                {
+                    /* Return the progress to the caller. */
+                    progress.queryInterfaceTo(aProgress);
+                }
             }
             else
@@ -783 +813 @@
 }
 
+STDMETHODIMP Guest::GetProcessOutput(BSTR *aBuffer, ULONG aFlags)
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else  /* VBOX_WITH_GUEST_CONTROL */
+    using namespace guestControl;
+
+    CheckComArgOutPointerValid(aBuffer);
+#endif
+}
+
 // public methods only for internal purposes
 /////////////////////////////////////////////////////////////////////////////

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -8372 +8372 @@
   <interface
      name="IGuest" extends="$unknown"
-     uuid="8cf03bf9-7478-42de-add8-10b2af75a06d"
+     uuid="105f4e9a-b8d5-49e5-9397-032e78155bee"
      wsmap="managed"
      >
@@ -8515 +8515 @@
         Executes an existing program inside the guest VM.
 
-        <result name="E_NOTIMPL">
-          Not implemented yet.
+        <result name="VBOX_E_IPRT_ERROR">
+          Could not execute process.
         </result>
 
@@ -8587 +8587 @@
         <desc>Progress object to track the operation completion.</desc>
       </param>
+    </method>
+
+    <method name="getProcessOutput">
+      <desc>
+        Retrieves output of a formerly started process.
+
+                <result name="VBOX_E_IPRT_ERROR">
+          Could not retrieve output.
+        </result>
+
+      </desc>
+      <param name="buffer" type="wstring" dir="out">
+        <desc>
+          Buffer for retrieving the actual output.
+        </desc>
+      </param>      
+      <param name="flags" type="unsigned long" dir="in">
+        <desc>
+                  Flags describing which output to retrieve.
+        </desc>
+      </param>      
     </method>
 

trunk/src/VBox/Main/include/GuestImpl.h

@@ -47 +47 @@
 
 class Console;
+#ifdef VBOX_WITH_GUEST_CONTROL
+class Progress;
+#endif
 
 class ATL_NO_VTABLE Guest :
@@ -94 +97 @@
                               IN_BSTR aUserName, IN_BSTR aPassword,
                               ULONG aTimeoutMS, ULONG* aPID, IProgress **aProgress);
+    STDMETHOD(GetProcessOutput)(BSTR *aBuffer, ULONG aFlags);
     STDMETHOD(InternalGetStatistics)(ULONG *aCpuUser, ULONG *aCpuKernel, ULONG *aCpuIdle,
                                      ULONG *aMemTotal, ULONG *aMemFree, ULONG *aMemBalloon, ULONG *aMemCache,
@@ -125 +129 @@
         /** Atomic flag whether callback was called. */
         volatile bool   bCalled;
+        ComObjPtr<Progress>      pProgress;
     };
     typedef std::list< CallbackContext > CallbackList;
@@ -136 +141 @@
     CallbackListIter getCtrlCallbackContext(uint32_t u32ContextID);
     void removeCtrlCallbackContext(CallbackListIter it);
-    uint32_t addCtrlCallbackContext(void *pvData, uint32_t cbData);
+    uint32_t addCtrlCallbackContext(void *pvData, uint32_t cbData, Progress* pProgress);
 # endif