Changeset 29927 in vbox

Timestamp:

May 31, 2010 6:40:56 PM (14 years ago)

Author:

vboxsync

Message:

Main: Three state powerOn progress object when teleporting.

Location:

trunk/src/VBox/Main

Files:

• ConsoleImpl.cpp (modified) (1 diff)
• ConsoleImplTeleporter.cpp (modified) (4 diffs)
• idl/VirtualBox.xidl (modified) (1 diff)

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -5230 +5230 @@
     else
         progressDesc = tr("Starting virtual machine");
-    rc = powerupProgress->init(static_cast<IConsole *>(this),
-                               progressDesc,
-                               fTeleporterEnabled /* aCancelable */);
+    if (mMachineState == MachineState_Saved || !fTeleporterEnabled)
+        rc = powerupProgress->init(static_cast<IConsole *>(this),
+                                   progressDesc,
+                                   FALSE /* aCancelable */);
+    else
+        rc = powerupProgress->init(static_cast<IConsole *>(this),
+                                   progressDesc,
+                                   TRUE /* aCancelable */,
+                                   3    /* cOperations */,
+                                   10   /* ulTotalOperationsWeight */,
+                                   Bstr(tr("Teleporting virtual machine")),
+                                   1    /* ulFirstOperationWeight */,
+                                   NULL);
     if (FAILED(rc))
         return rc;

trunk/src/VBox/Main/ConsoleImplTeleporter.cpp

@@ -1060 +1060 @@
             theState.mhServer          = hServer;
 
-            bool fPowerOff;
+            bool fPowerOff = true;
             void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(&theState));
             if (pProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser))
             {
                 LogRel(("Teleporter: Waiting for incoming VM...\n"));
-                vrc = RTTcpServerListen(hServer, Console::teleporterTrgServeConnection, &theState);
-                pProgress->setCancelCallback(NULL, NULL);
-
-                fPowerOff = false;
-                if (vrc == VERR_TCP_SERVER_STOP)
+                hrc = pProgress->SetNextOperation(Bstr(tr("Waiting for incoming VM")), 1);
+                if (SUCCEEDED(hrc))
                 {
-                    vrc = theState.mRc;
-                    /* Power off the VM on failure unless the state callback
-                       already did that. */
-                    if (RT_FAILURE(vrc))
+                    vrc = RTTcpServerListen(hServer, Console::teleporterTrgServeConnection, &theState);
+                    pProgress->setCancelCallback(NULL, NULL);
+
+                    if (vrc == VERR_TCP_SERVER_STOP)
                     {
-                        VMSTATE enmVMState = VMR3GetState(pVM);
-                        if (    enmVMState != VMSTATE_OFF
-                            &&  enmVMState != VMSTATE_POWERING_OFF)
-                            fPowerOff = true;
+                        vrc = theState.mRc;
+                        /* Power off the VM on failure unless the state callback
+                           already did that. */
+                        fPowerOff = false;
+                        if (RT_FAILURE(vrc))
+                        {
+                            VMSTATE enmVMState = VMR3GetState(pVM);
+                            if (    enmVMState != VMSTATE_OFF
+                                &&  enmVMState != VMSTATE_POWERING_OFF)
+                                fPowerOff = true;
+                        }
                     }
-                }
-                else if (vrc == VERR_TCP_SERVER_SHUTDOWN)
-                {
-                    BOOL fCancelled = TRUE;
-                    hrc = pProgress->COMGETTER(Canceled)(&fCancelled);
-                    if (FAILED(hrc) || fCancelled)
+                    else if (vrc == VERR_TCP_SERVER_SHUTDOWN)
                     {
-                        setError(E_FAIL, tr("Teleporting canceled"));
-                        vrc = VERR_SSM_CANCELLED;
+                        BOOL fCancelled = TRUE;
+                        hrc = pProgress->COMGETTER(Canceled)(&fCancelled);
+                        if (FAILED(hrc) || fCancelled)
+                        {
+                            setError(E_FAIL, tr("Teleporting canceled"));
+                            vrc = VERR_SSM_CANCELLED;
+                        }
+                        else
+                        {
+                            setError(E_FAIL, tr("Teleporter timed out waiting for incoming connection"));
+                            vrc = VERR_TIMEOUT;
+                        }
+                        LogRel(("Teleporter: RTTcpServerListen aborted - %Rrc\n", vrc));
                     }
                     else
                     {
-                        setError(E_FAIL, tr("Teleporter timed out waiting for incoming connection"));
-                        vrc = VERR_TIMEOUT;
+                        LogRel(("Teleporter: Unexpected RTTcpServerListen rc: %Rrc\n", vrc));
+                        vrc = VERR_IPE_UNEXPECTED_STATUS;
                     }
-                    LogRel(("Teleporter: RTTcpServerListen aborted - %Rrc\n", vrc));
-                    fPowerOff = true;
                 }
                 else
                 {
-                    LogRel(("Teleporter: Unexpected RTTcpServerListen rc: %Rrc\n", vrc));
-                    vrc = VERR_IPE_UNEXPECTED_STATUS;
-                    fPowerOff = true;
+                    LogThisFunc(("SetNextOperation failed, %Rhrc\n", hrc));
+                    vrc = Global::vboxStatusCodeFromCOM(hrc);
                 }
             }
@@ -1110 +1117 @@
                 LogThisFunc(("Canceled - check point #1\n"));
                 vrc = VERR_SSM_CANCELLED;
-                fPowerOff = true;
             }
 
@@ -1229 +1235 @@
     if (RT_FAILURE(vrc))
         return VINF_SUCCESS;
-    LogRel(("Teleporter: Incoming VM!\n"));
+
+    /*
+     * Update the progress bar, with peer name if available.
+     */
+    HRESULT     hrc;
+    RTNETADDR   Addr;
+    vrc = RTTcpGetPeerAddress(Sock, &Addr);
+    if (RT_SUCCESS(vrc))
+    {
+        LogRel(("Teleporter: Incoming VM from %RTnaddr!\n", &Addr));
+        hrc = pState->mptrProgress->SetNextOperation(Bstr(Utf8StrFmt(tr("Teleporting VM from %RTnaddr"), &Addr)), 8);
+    }
+    else
+    {
+        LogRel(("Teleporter: Incoming VM!\n"));
+        hrc = pState->mptrProgress->SetNextOperation(Bstr(tr("Teleporting VM")), 8);
+    }
+    AssertMsg(SUCCEEDED(hrc) || hrc == E_FAIL, ("%Rhrc\n", hrc));
 
     /*
@@ -1292 +1315 @@
         else if (!strcmp(szCmd, "lock-media"))
         {
-            HRESULT hrc = pState->mpControl->LockMedia();
+            hrc = pState->mpControl->LockMedia();
             if (SUCCEEDED(hrc))
             {

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

@@ -6851 +6851 @@
         been saved.
 
+        If the machine <link to="IMachine::teleporterEnabled"/> property is
+        enabled on the machine being powered up, the machine will wait for an
+        incoming teleportation in the <link to="MachineState_TeleportingIn"/>
+        state. The returned progress object will have at least three
+        operations where the last three are defined as: (1) powering up and
+        starting TCP server, (2) waiting for incoming teleportations, and
+        (3) perform teleportation. These operations will be reflected as the
+        last three operations of the progress objected returned by
+        <link to="IVirtualBox::openRemoteSession"/> as well.
+
         <note>
           Unless you are trying to write a new VirtualBox front-end that