Changeset 27895 in vbox

Timestamp:

Mar 31, 2010 1:30:14 PM (15 years ago)

Author:

vboxsync

Message:

Main/OVF: cleanup: share thread code, fix error code confusion, less task parameters

Location:

trunk/src/VBox/Main

Files:

• ApplianceImpl.cpp (modified) (5 diffs)
• ApplianceImplExport.cpp (modified) (19 diffs)
• ApplianceImplImport.cpp (modified) (33 diffs)
• include/ApplianceImpl.h (modified) (3 diffs)
• include/ApplianceImplPrivate.h (modified) (2 diffs)

trunk/src/VBox/Main/ApplianceImpl.cpp

@@ -21 +21 @@
  */
 
-#include <iprt/stream.h>
 #include <iprt/path.h>
-#include <iprt/dir.h>
-#include <iprt/file.h>
-#include <iprt/s3.h>
-#include <iprt/sha.h>
-#include <iprt/manifest.h>
-
-#include <VBox/param.h>
-#include <VBox/version.h>
+
+#include <VBox/com/array.h>
 
 #include "ApplianceImpl.h"
@@ -38 +31 @@
 #include "ProgressImpl.h"
 #include "MachineImpl.h"
-#include "MediumImpl.h"
-
-#include "HostNetworkInterfaceImpl.h"
 
 #include "AutoCaller.h"
@@ -602 +592 @@
      * already */
     /* @todo: Maybe too cost-intensive; try to find a lighter way */
-    while (RTPathExists(tmpName) ||
-           mVirtualBox->FindHardDisk(Bstr(tmpName), &harddisk) != VBOX_E_OBJECT_NOT_FOUND)
+    while (    RTPathExists(tmpName)
+            || mVirtualBox->FindHardDisk(Bstr(tmpName), &harddisk) != VBOX_E_OBJECT_NOT_FOUND
+          )
     {
         RTStrFree(tmpName);
@@ -914 +905 @@
 }
 
+/**
+ *
+ * @return
+ */
+int Appliance::TaskOVF::startThread()
+{
+    int vrc = RTThreadCreate(NULL, Appliance::taskThreadImportOrExport, this,
+                             0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
+                             "Appliance::Task");
+
+    ComAssertMsgRCRet(vrc,
+                      ("Could not create OVF task thread (%Rrc)\n", vrc), E_FAIL);
+
+    return S_OK;
+}
+
+/**
+ * Thread function for the thread started in Appliance::readImpl() and Appliance::importImpl()
+ * and Appliance::writeImpl().
+ * This will in turn call Appliance::readFS() or Appliance::readS3() or Appliance::importFS()
+ * or Appliance::importS3() or Appliance::writeFS() or Appliance::writeS3().
+ *
+ * @param aThread
+ * @param pvUser
+ */
+/* static */
+DECLCALLBACK(int) Appliance::taskThreadImportOrExport(RTTHREAD /* aThread */, void *pvUser)
+{
+    std::auto_ptr<TaskOVF> task(static_cast<TaskOVF*>(pvUser));
+    AssertReturn(task.get(), VERR_GENERAL_FAILURE);
+
+    Appliance *pAppliance = task->pAppliance;
+
+    LogFlowFuncEnter();
+    LogFlowFunc(("Appliance %p\n", pAppliance));
+
+    HRESULT taskrc = S_OK;
+
+    switch (task->taskType)
+    {
+        case TaskOVF::Read:
+            if (task->locInfo.storageType == VFSType_File)
+                taskrc = pAppliance->readFS(task->locInfo);
+            else if (task->locInfo.storageType == VFSType_S3)
+                taskrc = pAppliance->readS3(task.get());
+        break;
+
+        case TaskOVF::Import:
+            if (task->locInfo.storageType == VFSType_File)
+                taskrc = pAppliance->importFS(task->locInfo, task->pProgress);
+            else if (task->locInfo.storageType == VFSType_S3)
+                taskrc = pAppliance->importS3(task.get());
+        break;
+
+        case TaskOVF::Write:
+            if (task->locInfo.storageType == VFSType_File)
+                taskrc = pAppliance->writeFS(task->locInfo, task->enFormat, task->pProgress);
+            else if (task->locInfo.storageType == VFSType_S3)
+                taskrc = pAppliance->writeS3(task.get());
+        break;
+    }
+
+    task->rc = taskrc;
+
+    if (!task->pProgress.isNull())
+        task->pProgress->notifyComplete(taskrc);
+
+    LogFlowFuncLeave();
+
+    return VINF_SUCCESS;
+}
+
 /* static */
 int Appliance::TaskOVF::updateProgress(unsigned uPercent, void *pvUser)
@@ -920 +983 @@
 
     if (    pTask
-         && !pTask->progress.isNull())
+         && !pTask->pProgress.isNull())
     {
         BOOL fCanceled;
-        pTask->progress->COMGETTER(Canceled)(&fCanceled);
+        pTask->pProgress->COMGETTER(Canceled)(&fCanceled);
         if (fCanceled)
             return -1;
-        pTask->progress->SetCurrentOperationProgress(uPercent);
+        pTask->pProgress->SetCurrentOperationProgress(uPercent);
     }
     return VINF_SUCCESS;

trunk/src/VBox/Main/ApplianceImplExport.cpp

@@ -21 +21 @@
  */
 
-#include <iprt/stream.h>
 #include <iprt/path.h>
 #include <iprt/dir.h>
-#include <iprt/file.h>
+#include <iprt/param.h>
 #include <iprt/s3.h>
-#include <iprt/sha.h>
 #include <iprt/manifest.h>
 
-#include <VBox/param.h>
 #include <VBox/version.h>
 
 #include "ApplianceImpl.h"
-#include "VFSExplorerImpl.h"
 #include "VirtualBoxImpl.h"
-#include "GuestOSTypeImpl.h"
+
 #include "ProgressImpl.h"
 #include "MachineImpl.h"
-#include "MediumImpl.h"
-
-#include "HostNetworkInterfaceImpl.h"
 
 #include "AutoCaller.h"
@@ -48 +41 @@
 
 using namespace std;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// internal helpers
-//
-////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -619 +606 @@
     try
     {
-        /* Initialize our worker task */
-        std::auto_ptr<TaskExportOVF> task(new TaskExportOVF(this));
-        /* What should the task do */
-        task->taskType = TaskExportOVF::Write;
-        /* The OVF version to write */
-        task->enFormat = aFormat;
-        /* Copy the current location info to the task */
-        task->locInfo = aLocInfo;
-
         Bstr progressDesc = BstrFmt(tr("Export appliance '%s'"),
-                                    task->locInfo.strPath.c_str());
+                                    aLocInfo.strPath.c_str());
 
         /* todo: This progress init stuff should be done a little bit more generic */
-        if (task->locInfo.storageType == VFSType_File)
+        if (aLocInfo.storageType == VFSType_File)
             rc = setUpProgressFS(aProgress, progressDesc);
         else
             rc = setUpProgressWriteS3(aProgress, progressDesc);
 
-        task->progress = aProgress;
+        /* Initialize our worker task */
+        std::auto_ptr<TaskOVF> task(new TaskOVF(this, TaskOVF::Write, aLocInfo, aProgress));
+        /* The OVF version to write */
+        task->enFormat = aFormat;
 
         rc = task->startThread();
@@ -651 +632 @@
 
     return rc;
-}
-
-/**
- *
- * @return
- */
-int Appliance::TaskExportOVF::startThread()
-{
-    int vrc = RTThreadCreate(NULL, Appliance::taskThreadWriteOVF, this,
-                             0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
-                             "Appliance::Task");
-
-    ComAssertMsgRCRet(vrc,
-                      ("Could not create taskThreadWriteOVF (%Rrc)\n", vrc), E_FAIL);
-
-    return S_OK;
-}
-
-/**
- * Thread function for the thread started in Appliance::writeImpl(). This will in turn
- * call Appliance::writeFS() or Appliance::writeS3().
- * @param
- * @param pvUser
- * @return
- */
-DECLCALLBACK(int) Appliance::taskThreadWriteOVF(RTTHREAD /* aThread */, void *pvUser)
-{
-    std::auto_ptr<TaskExportOVF> task(static_cast<TaskExportOVF*>(pvUser));
-    AssertReturn(task.get(), VERR_GENERAL_FAILURE);
-
-    Appliance *pAppliance = task->pAppliance;
-
-    LogFlowFuncEnter();
-    LogFlowFunc(("Appliance %p\n", pAppliance));
-
-    HRESULT rc = S_OK;
-
-    switch(task->taskType)
-    {
-        case TaskExportOVF::Write:
-        {
-            if (task->locInfo.storageType == VFSType_File)
-                rc = pAppliance->writeFS(task.get());
-            else if (task->locInfo.storageType == VFSType_S3)
-                rc = pAppliance->writeS3(task.get());
-            break;
-        }
-    }
-
-    LogFlowFunc(("rc=%Rhrc\n", rc));
-    LogFlowFuncLeave();
-
-    return VINF_SUCCESS;
 }
 
@@ -1324 +1252 @@
  * @return
  */
-int Appliance::writeFS(TaskExportOVF *pTask)
+HRESULT Appliance::writeFS(const LocationInfo &locInfo, const OVFFormat enFormat, ComObjPtr<Progress> &pProgress)
 {
     LogFlowFuncEnter();
@@ -1341 +1269 @@
         xml::ElementNode *pelmRoot = doc.createRootElement("Envelope");
 
-        pelmRoot->setAttribute("ovf:version", (pTask->enFormat == OVF_1_0) ? "1.0" : "0.9");
+        pelmRoot->setAttribute("ovf:version", (enFormat == OVF_1_0) ? "1.0" : "0.9");
         pelmRoot->setAttribute("xml:lang", "en-US");
 
-        Utf8Str strNamespace = (pTask->enFormat == OVF_0_9)
+        Utf8Str strNamespace = (enFormat == OVF_0_9)
             ? "http://www.vmware.com/schema/ovf/1/envelope"     // 0.9
             : "http://schemas.dmtf.org/ovf/envelope/1";         // 1.0
@@ -1366 +1294 @@
             </DiskSection> */
         xml::ElementNode *pelmDiskSection;
-        if (pTask->enFormat == OVF_0_9)
+        if (enFormat == OVF_0_9)
         {
             // <Section xsi:type="ovf:DiskSection_Type">
@@ -1391 +1319 @@
             </NetworkSection> */
         xml::ElementNode *pelmNetworkSection;
-        if (pTask->enFormat == OVF_0_9)
+        if (enFormat == OVF_0_9)
         {
             // <Section xsi:type="ovf:NetworkSection_Type">
@@ -1417 +1345 @@
         if (m->virtualSystemDescriptions.size() > 1)
         {
-            if (pTask->enFormat == OVF_0_9)
+            if (enFormat == OVF_0_9)
                 throw setError(VBOX_E_FILE_ERROR,
                                tr("Cannot export more than one virtual system with OVF 0.9, use OVF 1.0"));
@@ -1436 +1364 @@
             buildXMLForOneVirtualSystem(*pelmToAddVirtualSystemsTo,
                                         vsdescThis,
-                                        pTask->enFormat,
+                                        enFormat,
                                         stack);         // disks and networks stack
         }
@@ -1477 +1405 @@
             const Utf8Str &strTargetFileNameOnly = pDiskEntry->strOvf;
             // target path needs to be composed from where the output OVF is
-            Utf8Str strTargetFilePath(pTask->locInfo.strPath);
+            Utf8Str strTargetFilePath(locInfo.strPath);
             strTargetFilePath.stripFilename();
             strTargetFilePath.append("/");
@@ -1508 +1436 @@
 
                 // advance to the next operation
-                if (!pTask->progress.isNull())
-                    pTask->progress->SetNextOperation(BstrFmt(tr("Exporting virtual disk image '%s'"), strSrcFilePath.c_str()),
-                                                      pDiskEntry->ulSizeMB);     // operation's weight, as set up with the IProgress originally);
+                if (!pProgress.isNull())
+                    pProgress->SetNextOperation(BstrFmt(tr("Exporting virtual disk image '%s'"), strSrcFilePath.c_str()),
+                                                pDiskEntry->ulSizeMB);     // operation's weight, as set up with the IProgress originally);
 
                 // now wait for the background disk operation to complete; this throws HRESULTs on error
-                waitForAsyncProgress(pTask->progress, pProgress2);
+                waitForAsyncProgress(pProgress, pProgress2);
             }
             catch (HRESULT rc3)
@@ -1558 +1486 @@
         // now go write the XML
         xml::XmlFileWriter writer(doc);
-        writer.write(pTask->locInfo.strPath.c_str());
+        writer.write(locInfo.strPath.c_str());
 
         /* Create & write the manifest file */
         const char** ppManifestFiles = (const char**)RTMemAlloc(sizeof(char*)*diskList.size() + 1);
-        ppManifestFiles[0] = pTask->locInfo.strPath.c_str();
+        ppManifestFiles[0] = locInfo.strPath.c_str();
         list<Utf8Str>::const_iterator it1;
         size_t i = 1;
@@ -1569 +1497 @@
              ++it1, ++i)
             ppManifestFiles[i] = (*it1).c_str();
-        Utf8Str strMfFile = manifestFileName(pTask->locInfo.strPath.c_str());
+        Utf8Str strMfFile = manifestFileName(locInfo.strPath.c_str());
         int vrc = RTManifestWriteFiles(strMfFile.c_str(), ppManifestFiles, diskList.size()+1);
         RTMemFree(ppManifestFiles);
@@ -1591 +1519 @@
     m->state = Data::ApplianceIdle;
 
-    pTask->rc = rc;
-
-    if (!pTask->progress.isNull())
-        pTask->progress->notifyComplete(rc);
-
     LogFlowFunc(("rc=%Rhrc\n", rc));
     LogFlowFuncLeave();
 
-    return VINF_SUCCESS;
+    return rc;
 }
 
@@ -1610 +1533 @@
  * @return
  */
-int Appliance::writeS3(TaskExportOVF *pTask)
+HRESULT Appliance::writeS3(TaskOVF *pTask)
 {
     LogFlowFuncEnter();
@@ -1664 +1587 @@
            caller */
         ComPtr<IProgress> progressInt(progress);
-        waitForAsyncProgress(pTask->progress, progressInt); /* Any errors will be thrown */
+        waitForAsyncProgress(pTask->pProgress, progressInt); /* Any errors will be thrown */
 
         /* Again lock the appliance for the next steps */
@@ -1717 +1640 @@
             char *pszFilename = RTPathFilename(s.first.c_str());
             /* Advance to the next operation */
-            if (!pTask->progress.isNull())
-                pTask->progress->SetNextOperation(BstrFmt(tr("Uploading file '%s'"), pszFilename), s.second);
+            if (!pTask->pProgress.isNull())
+                pTask->pProgress->SetNextOperation(BstrFmt(tr("Uploading file '%s'"), pszFilename), s.second);
             vrc = RTS3PutKey(hS3, bucket.c_str(), pszFilename, s.first.c_str());
             if (RT_FAILURE(vrc))
@@ -1765 +1688 @@
         RTStrFree(pszTmpDir);
 
-    pTask->rc = rc;
-
-    if (!pTask->progress.isNull())
-        pTask->progress->notifyComplete(rc);
-
     LogFlowFunc(("rc=%Rhrc\n", rc));
     LogFlowFuncLeave();
 
-    return VINF_SUCCESS;
+    return rc;
 }
 

trunk/src/VBox/Main/ApplianceImplImport.cpp

@@ -21 +21 @@
  */
 
-#include <iprt/stream.h>
 #include <iprt/path.h>
 #include <iprt/dir.h>
@@ -29 +28 @@
 #include <iprt/manifest.h>
 
-#include <VBox/param.h>
-#include <VBox/version.h>
+#include <VBox/com/array.h>
 
 #include "ApplianceImpl.h"
-#include "VFSExplorerImpl.h"
 #include "VirtualBoxImpl.h"
 #include "GuestOSTypeImpl.h"
 #include "ProgressImpl.h"
-#include "MachineImpl.h"
-#include "MediumImpl.h"
-
-#include "HostNetworkInterfaceImpl.h"
 
 #include "AutoCaller.h"
@@ -46 +39 @@
 
 #include "ApplianceImplPrivate.h"
+
+#include <VBox/param.h>
+#include <VBox/version.h>
 
 using namespace std;
@@ -206 +202 @@
             uint64_t ullMemSizeVBox = vsysThis.ullMemorySize / _1M;
             /* Check for the constrains */
-            if (ullMemSizeVBox != 0 &&
-                (ullMemSizeVBox < MM_RAM_MIN_IN_MB ||
-                 ullMemSizeVBox > MM_RAM_MAX_IN_MB))
+            if (    ullMemSizeVBox != 0
+                 && (    ullMemSizeVBox < MM_RAM_MIN_IN_MB
+                      || ullMemSizeVBox > MM_RAM_MAX_IN_MB)
+               )
             {
                 addWarning(tr("The virtual system \"%s\" claims support for %llu MB RAM size, but VirtualBox has support for min %u & max %u MB RAM size only."),
@@ -576 +573 @@
 HRESULT Appliance::readImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress)
 {
-    /* Initialize our worker task */
-    std::auto_ptr<TaskImportOVF> task(new TaskImportOVF(this));
-    /* What should the task do */
-    task->taskType = TaskImportOVF::Read;
-    /* Copy the current location info to the task */
-    task->locInfo = aLocInfo;
-
     BstrFmt bstrDesc = BstrFmt(tr("Read appliance '%s'"),
                                aLocInfo.strPath.c_str());
@@ -588 +578 @@
     /* Create the progress object */
     aProgress.createObject();
-    if (task->locInfo.storageType == VFSType_File)
-    {
+    if (aLocInfo.storageType == VFSType_File)
         /* 1 operation only */
         rc = aProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
                              bstrDesc,
                              TRUE /* aCancelable */);
-    }
     else
-    {
         /* 4/5 is downloading, 1/5 is reading */
         rc = aProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
@@ -606 +593 @@
                                      aLocInfo.strPath.c_str()), // CBSTR bstrFirstOperationDescription,
                              4); // ULONG ulFirstOperationWeight,
-    }
     if (FAILED(rc)) throw rc;
 
-    task->progress = aProgress;
+    /* Initialize our worker task */
+    std::auto_ptr<TaskOVF> task(new TaskOVF(this, TaskOVF::Read, aLocInfo, aProgress));
 
     rc = task->startThread();
@@ -618 +605 @@
 
     return rc;
-}
-
-/**
- *
- * @return
- */
-int Appliance::TaskImportOVF::startThread()
-{
-    int vrc = RTThreadCreate(NULL, Appliance::taskThreadImportOVF, this,
-                             0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
-                             "Appliance::Task");
-
-    ComAssertMsgRCRet(vrc,
-                      ("Could not create taskThreadImportOVF (%Rrc)\n", vrc), E_FAIL);
-
-    return S_OK;
-}
-
-/**
- * Thread function for the thread started in Appliance::readImpl() and Appliance::importImpl().
- * This will in turn call Appliance::readFS() or Appliance::readS3() or Appliance::importFS()
- * or Appliance::importS3().
- *
- * @param aThread
- * @param pvUser
- */
-/* static */
-DECLCALLBACK(int) Appliance::taskThreadImportOVF(RTTHREAD /* aThread */, void *pvUser)
-{
-    std::auto_ptr<TaskImportOVF> task(static_cast<TaskImportOVF*>(pvUser));
-    AssertReturn(task.get(), VERR_GENERAL_FAILURE);
-
-    Appliance *pAppliance = task->pAppliance;
-
-    LogFlowFuncEnter();
-    LogFlowFunc(("Appliance %p\n", pAppliance));
-
-    HRESULT taskrc = S_OK;
-
-    switch (task->taskType)
-    {
-        case TaskImportOVF::Read:
-        {
-            if (task->locInfo.storageType == VFSType_File)
-                taskrc = pAppliance->readFS(task.get());
-            else if (task->locInfo.storageType == VFSType_S3)
-                taskrc = pAppliance->readS3(task.get());
-            break;
-        }
-        case TaskImportOVF::Import:
-        {
-            if (task->locInfo.storageType == VFSType_File)
-                taskrc = pAppliance->importFS(task.get());
-            else if (task->locInfo.storageType == VFSType_S3)
-                taskrc = pAppliance->importS3(task.get());
-            break;
-        }
-    }
-
-    task->rc = taskrc;
-
-    LogFlowFuncLeave();
-
-    return VINF_SUCCESS;
 }
 
@@ -696 +619 @@
  * @return
  */
-int Appliance::readFS(TaskImportOVF *pTask)
+HRESULT Appliance::readFS(const LocationInfo &locInfo)
 {
     LogFlowFuncEnter();
@@ -711 +634 @@
     {
         /* Read & parse the XML structure of the OVF file */
-        m->pReader = new OVFReader(pTask->locInfo.strPath);
+        m->pReader = new OVFReader(locInfo.strPath);
         /* Create the SHA1 sum of the OVF file for later validation */
         char *pszDigest;
-        int vrc = RTSha1Digest(pTask->locInfo.strPath.c_str(), &pszDigest);
+        int vrc = RTSha1Digest(locInfo.strPath.c_str(), &pszDigest);
         if (RT_FAILURE(vrc))
             throw setError(VBOX_E_FILE_ERROR,
                            tr("Couldn't calculate SHA1 digest for file '%s' (%Rrc)"),
-                           RTPathFilename(pTask->locInfo.strPath.c_str()), vrc);
+                           RTPathFilename(locInfo.strPath.c_str()), vrc);
         m->strOVFSHA1Digest = pszDigest;
         RTStrFree(pszDigest);
@@ -732 +655 @@
     }
 
-    pTask->rc = rc;
-
-    if (!pTask->progress.isNull())
-        pTask->progress->notifyComplete(rc);
-
     LogFlowFunc(("rc=%Rhrc\n", rc));
     LogFlowFuncLeave();
 
-    return VINF_SUCCESS;
+    return rc;
 }
 
@@ -751 +669 @@
  * @return
  */
-int Appliance::readS3(TaskImportOVF *pTask)
+HRESULT Appliance::readS3(TaskOVF *pTask)
 {
     LogFlowFuncEnter();
@@ -818 +736 @@
         hS3 = NIL_RTS3;
 
-        if (!pTask->progress.isNull())
-            pTask->progress->SetNextOperation(Bstr(tr("Reading")), 1);
+        if (!pTask->pProgress.isNull())
+            pTask->pProgress->SetNextOperation(Bstr(tr("Reading")), 1);
 
         /* Prepare the temporary reading of the OVF */
@@ -834 +752 @@
            caller */
         ComPtr<IProgress> progressInt(progress);
-        waitForAsyncProgress(pTask->progress, progressInt); /* Any errors will be thrown */
+        waitForAsyncProgress(pTask->pProgress, progressInt); /* Any errors will be thrown */
 
         /* Again lock the appliance for the next steps */
@@ -864 +782 @@
         RTStrFree(pszTmpDir);
 
-    pTask->rc = rc;
-
-    if (!pTask->progress.isNull())
-        pTask->progress->notifyComplete(rc);
-
     LogFlowFunc(("rc=%Rhrc\n", rc));
     LogFlowFuncLeave();
@@ -958 +871 @@
 HRESULT Appliance::importImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress)
 {
-    /* Initialize our worker task */
-    std::auto_ptr<TaskImportOVF> task(new TaskImportOVF(this));
-    /* What should the task do */
-    task->taskType = TaskImportOVF::Import;
-    /* Copy the current location info to the task */
-    task->locInfo = aLocInfo;
-
     Bstr progressDesc = BstrFmt(tr("Import appliance '%s'"),
                                 aLocInfo.strPath.c_str());
-
     HRESULT rc = S_OK;
 
     /* todo: This progress init stuff should be done a little bit more generic */
-    if (task->locInfo.storageType == VFSType_File)
+    if (aLocInfo.storageType == VFSType_File)
         rc = setUpProgressFS(aProgress, progressDesc);
     else
@@ -977 +882 @@
     if (FAILED(rc)) throw rc;
 
-    task->progress = aProgress;
+    /* Initialize our worker task */
+    std::auto_ptr<TaskOVF> task(new TaskOVF(this, TaskOVF::Import, aLocInfo, aProgress));
 
     rc = task->startThread();
@@ -1000 +906 @@
  * @return
  */
-int Appliance::importFS(TaskImportOVF *pTask)
+HRESULT Appliance::importFS(const LocationInfo &locInfo, ComObjPtr<Progress> &pProgress)
 {
     LogFlowFuncEnter();
@@ -1011 +917 @@
 
     if (!isApplianceIdle())
-        return VERR_ACCESS_DENIED;
+        return E_ACCESSDENIED;
 
     // Change the appliance state so we can safely leave the lock while doing time-consuming
@@ -1038 +944 @@
     /* If an manifest file exists, verify the content. Therefore we need all
      * files which are referenced by the OVF & the OVF itself */
-    Utf8Str strMfFile = manifestFileName(pTask->locInfo.strPath);
+    Utf8Str strMfFile = manifestFileName(locInfo.strPath);
     list<Utf8Str> filesList;
     if (RTPathExists(strMfFile.c_str()))
     {
-        Utf8Str strSrcDir(pTask->locInfo.strPath);
+        Utf8Str strSrcDir(locInfo.strPath);
         strSrcDir.stripFilename();
         /* Add every disks of every virtual system to an internal list */
@@ -1067 +973 @@
         /* Create the test list */
         PRTMANIFESTTEST pTestList = (PRTMANIFESTTEST)RTMemAllocZ(sizeof(RTMANIFESTTEST)*(filesList.size()+1));
-        pTestList[0].pszTestFile = (char*)pTask->locInfo.strPath.c_str();
+        pTestList[0].pszTestFile = (char*)locInfo.strPath.c_str();
         pTestList[0].pszTestDigest = (char*)m->strOVFSHA1Digest.c_str();
         int vrc = VINF_SUCCESS;
@@ -1099 +1005 @@
             RTStrFree(pTestList[j].pszTestDigest);
         RTMemFree(pTestList);
-        if (FAILED(rc))
-        {
-            /* Return on error */
-            pTask->rc = rc;
-
-            if (!pTask->progress.isNull())
-                pTask->progress->notifyComplete(rc);
-            return rc;
-        }
+        if (FAILED(rc)) return rc;
     }
 
@@ -1582 +1480 @@
                     /* The disk image has to be on the same place as the OVF file. So
                      * strip the filename out of the full file path. */
-                    Utf8Str strSrcDir(pTask->locInfo.strPath);
+                    Utf8Str strSrcDir(locInfo.strPath);
                     strSrcDir.stripFilename();
 
@@ -1644 +1542 @@
 
                             /* Advance to the next operation */
-                            if (!pTask->progress.isNull())
-                                pTask->progress->SetNextOperation(BstrFmt(tr("Creating virtual disk image '%s'"), vsdeHD->strVbox.c_str()),
-                                                                 vsdeHD->ulSizeMB);     // operation's weight, as set up with the IProgress originally
+                            if (!pProgress.isNull())
+                                pProgress->SetNextOperation(BstrFmt(tr("Creating virtual disk image '%s'"), vsdeHD->strVbox.c_str()),
+                                                            vsdeHD->ulSizeMB);     // operation's weight, as set up with the IProgress originally
                         }
                         else
@@ -1686 +1584 @@
 
                             /* Advance to the next operation */
-                            if (!pTask->progress.isNull())
-                                pTask->progress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), strSrcFilePath.c_str()),
-                                                                 vsdeHD->ulSizeMB);     // operation's weight, as set up with the IProgress originally);
+                            if (!pProgress.isNull())
+                                pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), strSrcFilePath.c_str()),
+                                                            vsdeHD->ulSizeMB);     // operation's weight, as set up with the IProgress originally);
                         }
 
                         // now wait for the background disk operation to complete; this throws HRESULTs on error
-                        waitForAsyncProgress(pTask->progress, pProgress2);
+                        waitForAsyncProgress(pProgress, pProgress2);
 
                         if (fSourceHdNeedsClosing)
@@ -1802 +1700 @@
         {
             ComPtr<IMedium> pDisk = *itHD;
-            ComPtr<IProgress> pProgress;
-            rc2 = pDisk->DeleteStorage(pProgress.asOutParam());
-            rc2 = pProgress->WaitForCompletion(-1);
+            ComPtr<IProgress> pProgress2;
+            rc2 = pDisk->DeleteStorage(pProgress2.asOutParam());
+            rc2 = pProgress2->WaitForCompletion(-1);
         }
 
@@ -1825 +1723 @@
     m->state = Data::ApplianceIdle;
 
-    pTask->rc = rc;
-
-    if (!pTask->progress.isNull())
-        pTask->progress->notifyComplete(rc);
-
     LogFlowFunc(("rc=%Rhrc\n", rc));
     LogFlowFuncLeave();
 
-    return VINF_SUCCESS;
+    return rc;
 }
 
@@ -1841 +1734 @@
  * @return
  */
-int Appliance::importS3(TaskImportOVF *pTask)
+HRESULT Appliance::importS3(TaskOVF *pTask)
 {
     LogFlowFuncEnter();
@@ -1913 +1806 @@
             char *pszFilename = RTPathFilename(strSrcFile.c_str());
             /* Advance to the next operation */
-            if (!pTask->progress.isNull())
-                pTask->progress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename), s.second);
+            if (!pTask->pProgress.isNull())
+                pTask->pProgress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename), s.second);
 
             vrc = RTS3GetKey(hS3, bucket.c_str(), pszFilename, strSrcFile.c_str());
@@ -1939 +1832 @@
         Utf8Str strManifestFile = manifestFileName(strTmpOvf);
         char *pszFilename = RTPathFilename(strManifestFile.c_str());
-        if (!pTask->progress.isNull())
-            pTask->progress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename), 1);
+        if (!pTask->pProgress.isNull())
+            pTask->pProgress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename), 1);
 
         /* Try to download it. If the error is VERR_S3_NOT_FOUND, it isn't fatal. */
@@ -1964 +1857 @@
         hS3 = NIL_RTS3;
 
-        if (!pTask->progress.isNull())
-            pTask->progress->SetNextOperation(BstrFmt(tr("Importing appliance")), m->ulWeightPerOperation);
+        if (!pTask->pProgress.isNull())
+            pTask->pProgress->SetNextOperation(BstrFmt(tr("Importing appliance")), m->ulWeightPerOperation);
 
         ComObjPtr<Progress> progress;
@@ -1979 +1872 @@
            caller */
         ComPtr<IProgress> progressInt(progress);
-        waitForAsyncProgress(pTask->progress, progressInt); /* Any errors will be thrown */
+        waitForAsyncProgress(pTask->pProgress, progressInt); /* Any errors will be thrown */
 
         /* Again lock the appliance for the next steps */
@@ -2013 +1906 @@
         RTStrFree(pszTmpDir);
 
-    pTask->rc = rc;
-
-    if (!pTask->progress.isNull())
-        pTask->progress->notifyComplete(rc);
-
     LogFlowFunc(("rc=%Rhrc\n", rc));
     LogFlowFuncLeave();
 
-    return VINF_SUCCESS;
+    return rc;
 }
 

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

@@ -118 +118 @@
 
     struct TaskOVF;
-
-    struct TaskImportOVF; /* Worker threads for import */
-    int readFS(TaskImportOVF *pTask);
-    int readS3(TaskImportOVF *pTask);
+    static DECLCALLBACK(int) taskThreadImportOrExport(RTTHREAD aThread, void *pvUser);
+
+    HRESULT readFS(const LocationInfo &locInfo);
+    HRESULT readS3(TaskOVF *pTask);
 
     void convertDiskAttachmentValues(const HardDiskController &hdc,
@@ -131 +131 @@
     HRESULT importImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
 
-    static DECLCALLBACK(int) taskThreadImportOVF(RTTHREAD aThread, void *pvUser);
-
-    int importFS(TaskImportOVF *pTask);
-    int importS3(TaskImportOVF *pTask);
+    HRESULT importFS(const LocationInfo &locInfo, ComObjPtr<Progress> &aProgress);
+    HRESULT importS3(TaskOVF *pTask);
 
     HRESULT writeImpl(OVFFormat aFormat, const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
-
-    struct TaskExportOVF; /* Worker threads for export */
-    static DECLCALLBACK(int) taskThreadWriteOVF(RTTHREAD aThread, void *pvUser);
 
     struct XMLStack;
@@ -147 +142 @@
                                      XMLStack &stack);
 
-    int writeFS(TaskExportOVF *pTask);
-    int writeS3(TaskExportOVF *pTask);
+    HRESULT writeFS(const LocationInfo &locInfo, const OVFFormat enFormat, ComObjPtr<Progress> &pProgress);
+    HRESULT writeS3(TaskOVF *pTask);
 
     friend class Machine;

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

@@ -89 +89 @@
 struct Appliance::TaskOVF
 {
-    TaskOVF(Appliance *aThat)
+    enum TaskType
+    {
+        Read,
+        Import,
+        Write
+    };
+
+    TaskOVF(Appliance *aThat,
+            TaskType aType,
+            LocationInfo aLocInfo,
+            ComObjPtr<Progress> &aProgress)
       : pAppliance(aThat),
+        taskType(aType),
+        locInfo(aLocInfo),
+        pProgress(aProgress),
+        enFormat(unspecified),
         rc(S_OK)
     {}
@@ -96 +110 @@
     static int updateProgress(unsigned uPercent, void *pvUser);
 
-    LocationInfo locInfo;
-    Appliance *pAppliance;
-    ComObjPtr<Progress> progress;
-    HRESULT rc;
-};
-
-struct Appliance::TaskImportOVF : Appliance::TaskOVF
-{
-    enum TaskType
-    {
-        Read,
-        Import
-    };
-
-    TaskImportOVF(Appliance *aThat)
-        : TaskOVF(aThat),
-          taskType(Read)
-    {}
-
     int startThread();
 
+    Appliance *pAppliance;
     TaskType taskType;
-};
+    const LocationInfo locInfo;
+    ComObjPtr<Progress> pProgress;
 
-struct Appliance::TaskExportOVF : Appliance::TaskOVF
-{
-    enum TaskType
-    {
-        Write
-    };
+    OVFFormat enFormat;
 
-    TaskExportOVF(Appliance *aThat)
-        : TaskOVF(aThat),
-          taskType(Write)
-    {}
-
-    int startThread();
-
-    TaskType taskType;
-    OVFFormat enFormat;
+    HRESULT rc;
 };