Changeset 105266 in vbox for trunk/src/VBox/Main/src-server

Timestamp:

Jul 11, 2024 7:49:37 AM (6 months ago)

Author:

vboxsync

Message:

Recording: Implemented support for a dedicated progress object, which is exposed to API clients. This can be used for better tracking the recording progress as well as for error reporting. The RecordingSettings API also now has a dedicated start() method to start recording, as well as support for attaching to an already ongoing recording by retrieving the progress object at a later time. Adapted FE/Qt (draft, see @todos), FE/VBoxManage and the Validation Kit testdriver to the new APIs. VBoxManage also can attach to an ongoing recording now. The recording progress object also will have multiple operations to get the recording progress for convenience. bugref:10718

Location:

trunk/src/VBox/Main/src-server

Files:

• MachineImpl.cpp (modified) (2 diffs)
• RecordingSettingsImpl.cpp (modified) (10 diffs)

trunk/src/VBox/Main/src-server/MachineImpl.cpp

@@ -14208 +14208 @@
 
 /**
+ * @note Caller needs to take the machine's lock if needed.
+ */
+HRESULT SessionMachine::i_onRecordingStateChange(BOOL aEnable, IProgress **aProgress)
+{
+    LogFlowThisFunc(("\n"));
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
+
+    ComPtr<IInternalSessionControl> directControl;
+    {
+        if (mData->mSession.mLockType == LockType_VM)
+            directControl = mData->mSession.mDirectControl;
+    }
+
+    /* ignore notifications sent after #OnSessionEnd() is called */
+    if (!directControl)
+        return S_OK;
+
+    return directControl->OnRecordingStateChange(aEnable, aProgress);
+}
+
+/**
  * @note Locks this object for reading.
  */
-HRESULT SessionMachine::i_onRecordingChange(BOOL aEnable)
+HRESULT SessionMachine::i_onRecordingScreenStateChange(BOOL aEnable, ULONG aScreen)
 {
     LogFlowThisFunc(("\n"));
@@ -14228 +14251 @@
         return S_OK;
 
-    return directControl->OnRecordingChange(aEnable);
+    return directControl->OnRecordingScreenStateChange(aEnable, aScreen);
 }
 

trunk/src/VBox/Main/src-server/RecordingSettingsImpl.cpp

@@ -56 +56 @@
     const ComObjPtr<RecordingSettings>      pPeer;
     RecordingScreenSettingsObjMap           mapScreenObj;
+    /** The recording progress object.
+     *  There only is one recording progress per VM, shared between multiple recording settings (if any). */
+    ComPtr<IProgress>                       mProgress;
 
     // use the XML settings structure in the members for simplicity
@@ -98 +101 @@
 
     i_applyDefaults();
+
+    /* Note: The progress object gets created in i_start(). */
 
     autoInitSpan.setSucceeded();
@@ -145 +150 @@
 
     m->mapScreenObj = aThat->m->mapScreenObj;
+    m->mProgress = aThat->m->mProgress;
 
     autoInitSpan.setSucceeded();
@@ -199 +205 @@
     }
 
+    m->mProgress = aThat->m->mProgress;
+
     if (SUCCEEDED(hrc))
         autoInitSpan.setSucceeded();
@@ -219 +227 @@
         return;
 
-    /* Make sure to destroy screen objects attached to this object.
-     * Note: This also decrements the refcount of a screens object, in case it's shared among other recording settings. */
-    i_destroyAllScreenObj(m->mapScreenObj);
+    i_reset();
 
     m->bd.free();
@@ -264 +270 @@
 
         alock.release();
-
-        hrc = m->pMachine->i_onRecordingChange(enable);
-        if (FAILED(hrc))
-        {
-            com::ErrorInfo errMachine; /* Get error info from machine call above. */
-
-            /*
-             * Normally we would do the actual change _after_ i_onRecordingChange() succeeded.
-             * We cannot do this because that function uses RecordSettings::GetEnabled to
-             * determine if it should start or stop capturing. Therefore we need to manually
-             * undo change.
-             */
-            alock.acquire();
-            m->bd->fEnabled = m->bd.backedUpData()->fEnabled;
-
-            if (errMachine.isBasicAvailable())
-                hrc = setError(errMachine);
-        }
-        else
-        {
-            AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // pMachine is const, needs no locking
-            m->pMachine->i_setModified(Machine::IsModified_Recording);
-
-            /* Make sure to release the mutable dependency lock from above before
-             * actually saving the settings. */
-            adep.release();
-
-            /** Save settings if online - @todo why is this required? -- @bugref{6818} */
-            if (Global::IsOnline(m->pMachine->i_getMachineState()))
-            {
-                com::ErrorInfo errMachine;
-                hrc = m->pMachine->i_saveSettings(NULL, mlock);
-                if (FAILED(hrc))
-                {
-                    /* Got error info from machine call above. */
-                    if (errMachine.isBasicAvailable())
-                        hrc = setError(errMachine);
-                }
-            }
-        }
     }
 
@@ -354 +320 @@
 }
 
+HRESULT RecordingSettings::getProgress(ComPtr<IProgress> &aProgress)
+{
+#ifndef VBOX_WITH_RECORDING
+    ReturnComNotImplemented();
+#else
+    /* the machine needs to be mutable */
+    AutoMutableOrSavedOrRunningStateDependency adep(m->pMachine);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (m->mProgress.isNull())
+        return setError(E_FAIL, tr("Recording not started"));
+
+    return m->mProgress.queryInterfaceTo(aProgress.asOutParam());
+#endif
+}
+
 HRESULT RecordingSettings::getScreenSettings(ULONG uScreenId, ComPtr<IRecordingScreenSettings> &aRecordScreenSettings)
 {
@@ -380 +364 @@
 
     return VBOX_E_OBJECT_NOT_FOUND;
+}
+
+HRESULT RecordingSettings::start(ComPtr<IProgress> &aProgress)
+{
+#ifndef VBOX_WITH_RECORDING
+    ReturnComNotImplemented();
+#else
+    /* the machine needs to be mutable */
+    AutoMutableOrSavedOrRunningStateDependency adep(m->pMachine);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    /* Recording not explicitly enabled before? Do so now. */
+    if (!m->bd->fEnabled)
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+        m->bd.backup();
+        m->bd->fEnabled = true;
+
+        alock.release();
+
+        /* Note: m->bd->fEnabled is transient here, i.e. we don't save the settings,
+                 as this would otherwise start the recording on VM startup the next time. */
+    }
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (m->mProgress.isNotNull())
+    {
+        BOOL fCompleted = FALSE;
+        HRESULT const hrc = m->mProgress->COMGETTER(Completed)(&fCompleted);
+        ComAssertComRCRetRC(hrc);
+        if (!fCompleted)
+            return setError(E_FAIL, tr("Recording already started"));
+    }
+
+    m->mProgress.setNull(); /* Make sure to release a dangling object from a former run. */
+
+    alock.release();
+
+    int const vrc = i_start();
+    if (RT_FAILURE(vrc))
+    {
+        /* Make the progress' error info available to the caller on failure. */
+        ComObjPtr<IVirtualBoxErrorInfo> pErrorInfo;
+        m->mProgress->COMGETTER(ErrorInfo)(pErrorInfo.asOutParam());
+        return setError(pErrorInfo);
+    }
+
+    return m->mProgress.queryInterfaceTo(aProgress.asOutParam());
+#endif
 }
 
@@ -553 +588 @@
     LogFlowThisFuncEnter();
 
+    i_stop();
+
+    /* Make sure to destroy screen objects attached to this object.
+     * Note: This also decrements the refcount of a screens object, in case it's shared among other recording settings. */
     i_destroyAllScreenObj(m->mapScreenObj);
 }
@@ -824 +863 @@
 
 /**
+ * Starts recording.
+ *
+ * @returns VBox status code.
+ */
+int RecordingSettings::i_start(void)
+{
+    AssertReturn(m->mProgress.isNull(), VERR_WRONG_ORDER);
+
+    HRESULT hrc = m->pMachine->i_onRecordingStateChange(TRUE /* Enable recording */, m->mProgress.asOutParam());
+    if (FAILED(hrc))
+        return VERR_RECORDING_INIT_FAILED;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Stops recording. Does nothing if recording already has been stopped.
+ *
+ * @returns VBox status code.
+ */
+int RecordingSettings::i_stop(void)
+{
+    if (m->mProgress.isNull()) /* Not started? */
+        return VINF_SUCCESS;
+
+    /* Note: Returned progress object is just a dummy / not needed for disabling recording. */
+    HRESULT hrc = m->pMachine->i_onRecordingStateChange(FALSE /* Disable recording */, m->mProgress.asOutParam());
+    if (SUCCEEDED(hrc))
+        m->mProgress.setNull();
+
+    if (FAILED(hrc))
+        return VERR_COM_UNEXPECTED;
+
+    return VINF_SUCCESS;
+}
+
+/**
  * Synchronizes the screen settings (COM) objects and configuration data
  * to the number of the machine's configured displays.