Changeset 31676 in vbox for trunk/src/VBox/Main

Timestamp:

Aug 13, 2010 6:40:53 PM (14 years ago)

Author:

vboxsync

Message:

Main/FE/Qt4: add initial OVA support

Location:

trunk/src/VBox/Main

Files:

• ApplianceImpl.cpp (modified) (11 diffs)
• ApplianceImplExport.cpp (modified) (21 diffs)
• ApplianceImplImport.cpp (modified) (15 diffs)
• include/ApplianceImpl.h (modified) (4 diffs)
• include/ApplianceImplPrivate.h (modified) (1 diff)

trunk/src/VBox/Main/ApplianceImpl.cpp

@@ -667 +667 @@
     BOOL fCanceled;
     ULONG currentPercent;
+    ULONG cOp = 0;
     while (SUCCEEDED(pProgressAsync->COMGETTER(Completed(&fCompleted))))
     {
@@ -676 +677 @@
             break;
         }
-
-        rc = pProgressAsync->COMGETTER(Percent(&currentPercent));
+        /* Check if the current operation have changed. It is also possible
+           that in the meantime more than one async operation was finished. So
+           we have to loop as long as we reached the same operation count. */
+        ULONG curOp;
+        for(;;)
+        {
+            rc = pProgressAsync->COMGETTER(Operation(&curOp));
+            if (FAILED(rc)) throw rc;
+            if (cOp != curOp)
+            {
+                Bstr bstr;
+                ULONG currentWeight;
+                rc = pProgressAsync->COMGETTER(OperationDescription(bstr.asOutParam()));
+                if (FAILED(rc)) throw rc;
+                rc = pProgressAsync->COMGETTER(OperationWeight(&currentWeight));
+                if (FAILED(rc)) throw rc;
+                rc = pProgressThis->SetNextOperation(bstr, currentWeight);
+                if (FAILED(rc)) throw rc;
+                ++cOp;
+            }else
+                break;
+        }
+
+        rc = pProgressAsync->COMGETTER(OperationPercent(&currentPercent));
         if (FAILED(rc)) throw rc;
-        if (!pProgressThis.isNull())
-            pProgressThis->SetCurrentOperationProgress(currentPercent);
+        pProgressThis->SetCurrentOperationProgress(currentPercent);
         if (fCompleted)
             break;
@@ -745 +767 @@
 }
 
+#include <iprt/tar.h>
 /**
  * Called from Appliance::importImpl() and Appliance::writeImpl() to set up a
@@ -754 +777 @@
  * @return
  */
-HRESULT Appliance::setUpProgress(ComObjPtr<Progress> &pProgress,
+HRESULT Appliance::setUpProgress(const LocationInfo &locInfo,
+                                 ComObjPtr<Progress> &pProgress,
                                  const Bstr &bstrDescription,
                                  SetUpProgressMode mode)
@@ -785 +809 @@
     }
 
+    bool fOVA = locInfo.strPath.endsWith(".ova", Utf8Str::CaseInsensitive);
     switch (mode)
     {
         case ImportFileNoManifest:
-        break;
-
+        {
+            if (fOVA)
+            {
+                // Another operation for packing
+                ++cOperations;
+
+                // assume that packing the files into the archive has the same weight than creating all files in the ovf exporting step
+                ulTotalOperationsWeight += m->ulTotalDisksMB;
+            }
+            break;
+        }
         case ImportFileWithManifest:
         case WriteFile:
+        {
             ++cOperations;          // another one for creating the manifest
 
-            // assume that checking or creating the manifest will take 10% of the time it takes to export the disks
+            // assume that creating the manifest will take 10% of the time it takes to export the disks
             m->ulWeightForManifestOperation = m->ulTotalDisksMB / 10;
             ulTotalOperationsWeight += m->ulWeightForManifestOperation;
-        break;
-
+            if (fOVA)
+            {
+                // Another operation for packing
+                ++cOperations;
+
+                // assume that packing the files into the archive has the same weight than creating all files in the ovf exporting step
+                ulTotalOperationsWeight += m->ulTotalDisksMB;
+            }
+            break;
+        }
         case ImportS3:
         {
@@ -814 +857 @@
             ULONG ulInitWeight = (ULONG)((double)ulTotalOperationsWeight * 0.1  / 100);  // use 0.1% for init
             ulTotalOperationsWeight += ulInitWeight;
+            break;
         }
-        break;
-
         case WriteS3:
         {
@@ -834 +876 @@
             ULONG ulOVFCreationWeight = (ULONG)((double)ulTotalOperationsWeight * 50.0 / 100.0); /* Use 50% for the creation of the OVF & the disks */
             ulTotalOperationsWeight += ulOVFCreationWeight;
+            break;
         }
-        break;
     }
 
@@ -916 +958 @@
 }
 
-Utf8Str Appliance::manifestFileName(Utf8Str aPath) const
-{
+Utf8Str Appliance::manifestFileName(const Utf8Str& aPath) const
+{
+    Utf8Str strTmpPath = aPath;
     /* Get the name part */
-    char *pszMfName = RTStrDup(RTPathFilename(aPath.c_str()));
+    char *pszMfName = RTStrDup(RTPathFilename(strTmpPath.c_str()));
     /* Strip any extensions */
     RTPathStripExt(pszMfName);
     /* Path without the filename */
-    aPath.stripFilename();
+    strTmpPath.stripFilename();
     /* Format the manifest path */
-    Utf8StrFmt strMfFile("%s/%s.mf", aPath.c_str(), pszMfName);
+    Utf8StrFmt strMfFile("%s/%s.mf", strTmpPath.c_str(), pszMfName);
     RTStrFree(pszMfName);
     return strMfFile;
@@ -973 +1016 @@
         case TaskOVF::Read:
             if (task->locInfo.storageType == VFSType_File)
-                taskrc = pAppliance->readFS(task->locInfo);
+                taskrc = pAppliance->readFS(task->locInfo, task->pProgress);
             else if (task->locInfo.storageType == VFSType_S3)
                 taskrc = pAppliance->readS3(task.get());
@@ -980 +1023 @@
         case TaskOVF::Import:
             if (task->locInfo.storageType == VFSType_File)
-                taskrc = pAppliance->importFS(task->locInfo, task->pProgress);
+                taskrc = pAppliance->importFS(task.get());
             else if (task->locInfo.storageType == VFSType_S3)
                 taskrc = pAppliance->importS3(task.get());
@@ -987 +1030 @@
         case TaskOVF::Write:
             if (task->locInfo.storageType == VFSType_File)
-                taskrc = pAppliance->writeFS(task->locInfo, task->enFormat, task->pProgress);
+                taskrc = pAppliance->writeFS(task.get());
             else if (task->locInfo.storageType == VFSType_S3)
                 taskrc = pAppliance->writeS3(task.get());

trunk/src/VBox/Main/ApplianceImplExport.cpp

@@ -22 +22 @@
 #include <iprt/s3.h>
 #include <iprt/manifest.h>
+#include <iprt/tar.h>
+#include <iprt/stream.h>
 
 #include <VBox/version.h>
@@ -566 +568 @@
     // see if we can handle this file; for now we insist it has an ".ovf" extension
     Utf8Str strPath = path;
-    if (!strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
+    if (!(   strPath.endsWith(".ovf", Utf8Str::CaseInsensitive)
+          || strPath.endsWith(".ova", Utf8Str::CaseInsensitive)))
         return setError(VBOX_E_FILE_ERROR,
-                        tr("Appliance file must have .ovf extension"));
+                        tr("Appliance file must have .ovf or .ova extension"));
 
     Utf8Str strFormat(format);
@@ -613 +616 @@
  *
  * 1) from the public Appliance::Write().
- * 2) from Appliance::writeS3(), which got called from a previous instance of Appliance::taskThreadWriteOVF().
+ *
+ * 2) in a second worker thread; in that case, Appliance::Write() called Appliance::writeImpl(), which
+ *    called Appliance::writeFSOVA(), which called Appliance::writeImpl(), which then called this again.
+ *
+ * 3) from Appliance::writeS3(), which got called from a previous instance of Appliance::taskThreadWriteOVF().
  *
  * @param aFormat
@@ -625 +632 @@
     try
     {
-        rc = setUpProgress(aProgress,
+        rc = setUpProgress(aLocInfo,
+                           aProgress,
                            BstrFmt(tr("Export appliance '%s'"), aLocInfo.strPath.c_str()),
                            (aLocInfo.storageType == VFSType_File) ? WriteFile : WriteS3);
@@ -1310 +1318 @@
 
 /**
- * Actual worker code for writing out OVF to disk. This is called from Appliance::taskThreadWriteOVF()
- * and therefore runs on the OVF write worker thread. This runs in two contexts:
+ * Actual worker code for writing out OVF/OVA to disk. This is called from Appliance::taskThreadWriteOVF()
+ * and therefore runs on the OVF/OVA write worker thread. This runs in two contexts:
  *
  * 1) in a first worker thread; in that case, Appliance::Write() called Appliance::writeImpl();
@@ -1323 +1331 @@
  * @return
  */
-HRESULT Appliance::writeFS(const LocationInfo &locInfo, const OVFFormat enFormat, ComObjPtr<Progress> &pProgress)
+HRESULT Appliance::writeFS(TaskOVF *pTask)
 {
+    if (pTask->locInfo.strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
+        return writeFSOVF(pTask);
+    else
+        return writeFSOVA(pTask);
+}
+
+HRESULT Appliance::writeFSOVF(TaskOVF *pTask)
+{
+    LogFlowFuncEnter();
     LogFlowFunc(("ENTER appliance %p\n", this));
 
@@ -1339 +1356 @@
         xml::ElementNode *pelmRoot = doc.createRootElement("Envelope");
 
-        pelmRoot->setAttribute("ovf:version", (enFormat == OVF_1_0) ? "1.0" : "0.9");
+        pelmRoot->setAttribute("ovf:version", (pTask->enFormat == OVF_1_0) ? "1.0" : "0.9");
         pelmRoot->setAttribute("xml:lang", "en-US");
 
-        Utf8Str strNamespace = (enFormat == OVF_0_9)
+        Utf8Str strNamespace = (pTask->enFormat == OVF_0_9)
             ? "http://www.vmware.com/schema/ovf/1/envelope"     // 0.9
             : "http://schemas.dmtf.org/ovf/envelope/1";         // 1.0
@@ -1364 +1381 @@
             </DiskSection> */
         xml::ElementNode *pelmDiskSection;
-        if (enFormat == OVF_0_9)
+        if (pTask->enFormat == OVF_0_9)
         {
             // <Section xsi:type="ovf:DiskSection_Type">
@@ -1389 +1406 @@
             </NetworkSection> */
         xml::ElementNode *pelmNetworkSection;
-        if (enFormat == OVF_0_9)
+        if (pTask->enFormat == OVF_0_9)
         {
             // <Section xsi:type="ovf:NetworkSection_Type">
@@ -1415 +1432 @@
         if (m->virtualSystemDescriptions.size() > 1)
         {
-            if (enFormat == OVF_0_9)
+            if (pTask->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"));
@@ -1439 +1456 @@
                                         &llElementsWithUuidAttributes,
                                         vsdescThis,
-                                        enFormat,
+                                        pTask->enFormat,
                                         stack);         // disks and networks stack
         }
@@ -1494 +1511 @@
             const Utf8Str &strTargetFileNameOnly = pDiskEntry->strOvf;
             // target path needs to be composed from where the output OVF is
-            Utf8Str strTargetFilePath(locInfo.strPath);
+            Utf8Str strTargetFilePath(pTask->locInfo.strPath);
             strTargetFilePath.stripFilename();
             strTargetFilePath.append("/");
@@ -1518 +1535 @@
 
                 // advance to the next operation
-                pProgress->SetNextOperation(BstrFmt(tr("Exporting to disk image '%s'"), strTargetFilePath.c_str()),
-                                            pDiskEntry->ulSizeMB);     // operation's weight, as set up with the IProgress originally);
+                pTask->pProgress->SetNextOperation(BstrFmt(tr("Exporting to disk image '%s'"), RTPathFilename(strTargetFilePath.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(pProgress, pProgress2);
+                waitForAsyncProgress(pTask->pProgress, pProgress2);
             }
             catch (HRESULT rc3)
@@ -1568 +1585 @@
             pelmDisk->setAttribute("ovf:fileRef", strFileRef);
             pelmDisk->setAttribute("ovf:format",
-                    (enFormat == OVF_0_9)
+                    (pTask->enFormat == OVF_0_9)
                         ?  "http://www.vmware.com/specifications/vmdk.html#sparse"      // must be sparse or ovftool chokes
                         :  "http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized"
@@ -1593 +1610 @@
         // now go write the XML
         xml::XmlFileWriter writer(doc);
-        writer.write(locInfo.strPath.c_str(), false /*fSafe*/);
+        writer.write(pTask->locInfo.strPath.c_str(), false /*fSafe*/);
 
         // Create & write the manifest file
-        Utf8Str strMfFile = manifestFileName(locInfo.strPath.c_str());
+        Utf8Str strMfFile = manifestFileName(pTask->locInfo.strPath.c_str());
         const char *pcszManifestFileOnly = RTPathFilename(strMfFile.c_str());
-        pProgress->SetNextOperation(BstrFmt(tr("Creating manifest file '%s'"), pcszManifestFileOnly),
-                                    m->ulWeightForManifestOperation);     // operation's weight, as set up with the IProgress originally);
+        pTask->pProgress->SetNextOperation(BstrFmt(tr("Creating manifest file '%s'"), pcszManifestFileOnly),
+                                           m->ulWeightForManifestOperation);     // operation's weight, as set up with the IProgress originally);
 
         const char** ppManifestFiles = (const char**)RTMemAlloc(sizeof(char*)*diskList.size() + 1);
-        ppManifestFiles[0] = locInfo.strPath.c_str();
+        ppManifestFiles[0] = pTask->locInfo.strPath.c_str();
         list<Utf8Str>::const_iterator it1;
         size_t i = 1;
@@ -1636 +1653 @@
 }
 
-/**
- * Worker code for writing out OVF to the cloud. This is called from Appliance::taskThreadWriteOVF()
- * in S3 mode and therefore runs on the OVF write worker thread. This then starts a second worker
- * thread to create temporary files (see Appliance::writeFS()).
- *
- * @param pTask
- * @return
- */
-HRESULT Appliance::writeS3(TaskOVF *pTask)
+HRESULT Appliance::writeFSOVA(TaskOVF *pTask)
 {
     LogFlowFuncEnter();
@@ -1657 +1666 @@
 
     int vrc = VINF_SUCCESS;
-    RTS3 hS3 = NIL_RTS3;
+
     char szOSTmpDir[RTPATH_MAX];
     RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
@@ -1663 +1672 @@
     char *pszTmpDir;
     RTStrAPrintf(&pszTmpDir, "%s"RTPATH_SLASH_STR"vbox-ovf-XXXXXX", szOSTmpDir);
-    list< pair<Utf8Str, ULONG> > filesList;
-
-    // todo:
-    // - usable error codes
-    // - seems snapshot filenames are problematic {uuid}.vdi
+    list<Utf8Str> filesList;
+    const char** paFiles = 0;
+
     try
     {
-        /* Extract the bucket */
+        /* Extract the path */
         Utf8Str tmpPath = pTask->locInfo.strPath;
-        Utf8Str bucket;
-        parseBucket(tmpPath, bucket);
+        /* Remove the ova extension */
+        tmpPath.stripExt();
+        tmpPath += ".ovf";
 
         /* We need a temporary directory which we can put the OVF file & all
@@ -1680 +1688 @@
         if (RT_FAILURE(vrc))
             throw setError(VBOX_E_FILE_ERROR,
-                           tr("Cannot create temporary directory '%s'"), pszTmpDir);
+                           tr("Cannot create temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
 
         /* The temporary name of the target OVF file */
@@ -1706 +1714 @@
         if (RT_FAILURE(vrc))
             throw setError(VBOX_E_FILE_ERROR,
-                           tr("Cannot find source file '%s'"), strTmpOvf.c_str());
+                           tr("Cannot find source file '%s' (%Rrc)"), strTmpOvf.c_str(), vrc);
         /* Add the OVF file */
-        filesList.push_back(pair<Utf8Str, ULONG>(strTmpOvf, m->ulWeightForXmlOperation)); /* Use 1% of the total for the OVF file upload */
+        filesList.push_back(strTmpOvf); /* Use 1% of the total for the OVF file upload */
         Utf8Str strMfFile = manifestFileName(strTmpOvf);
-        filesList.push_back(pair<Utf8Str, ULONG>(strMfFile , m->ulWeightForXmlOperation)); /* Use 1% of the total for the manifest file upload */
-
+        filesList.push_back(strMfFile); /* Use 1% of the total for the manifest file upload */
+
+        ULONG ulWeight = 2 * m->ulWeightForXmlOperation;
         /* Now add every disks of every virtual system */
         list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
@@ -1734 +1743 @@
                 if (RT_FAILURE(vrc))
                     throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Cannot find source file '%s'"), strTargetFilePath.c_str());
+                                   tr("Cannot find source file '%s' (%Rrc)"), strTargetFilePath.c_str(), vrc);
+                filesList.push_back(strTargetFilePath);
+                ulWeight += (*itH)->ulSizeMB;
+            }
+        }
+        paFiles = (const char**)RTMemAlloc(sizeof(char*) * filesList.size());
+        int i = 0;
+        for (list<Utf8Str>::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1, ++i)
+            paFiles[i] = (*it1).c_str();
+        pTask->pProgress->SetNextOperation(BstrFmt(tr("Packing into '%s'"), RTPathFilename(pTask->locInfo.strPath.c_str())), ulWeight);
+        /* Create the tar file out of our file list. */
+        vrc = RTTarCreate(pTask->locInfo.strPath.c_str(), paFiles, filesList.size(), pTask->updateProgress, &pTask);
+        if (RT_FAILURE(vrc))
+            throw setError(VBOX_E_FILE_ERROR,
+                           tr("Cannot create OVA file '%s' (%Rrc)"), pTask->locInfo.strPath.c_str(), vrc);
+    }
+    catch(HRESULT aRC)
+    {
+        rc = aRC;
+    }
+
+    /* Delete the temporary files list */
+    if (paFiles)
+        RTMemFree(paFiles);
+    /* Delete all files which where temporary created */
+    for (list<Utf8Str>::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1)
+    {
+        const char *pszFilePath = (*it1).c_str();
+        if (RTPathExists(pszFilePath))
+        {
+            vrc = RTFileDelete(pszFilePath);
+            if (RT_FAILURE(vrc))
+                rc = setError(VBOX_E_FILE_ERROR,
+                              tr("Cannot delete file '%s' (%Rrc)"), pszFilePath, vrc);
+        }
+    }
+    /* Delete the temporary directory */
+    if (RTPathExists(pszTmpDir))
+    {
+        vrc = RTDirRemove(pszTmpDir);
+        if (RT_FAILURE(vrc))
+            rc = setError(VBOX_E_FILE_ERROR,
+                          tr("Cannot delete temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
+    }
+    if (pszTmpDir)
+        RTStrFree(pszTmpDir);
+
+    LogFlowFunc(("rc=%Rhrc\n", rc));
+    LogFlowFuncLeave();
+
+    return rc;
+}
+
+/**
+ * Worker code for writing out OVF to the cloud. This is called from Appliance::taskThreadWriteOVF()
+ * in S3 mode and therefore runs on the OVF write worker thread. This then starts a second worker
+ * thread to create temporary files (see Appliance::writeFS()).
+ *
+ * @param pTask
+ * @return
+ */
+HRESULT Appliance::writeS3(TaskOVF *pTask)
+{
+    LogFlowFuncEnter();
+    LogFlowFunc(("Appliance %p\n", this));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT rc = S_OK;
+
+    AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
+
+    int vrc = VINF_SUCCESS;
+    RTS3 hS3 = NIL_RTS3;
+    char szOSTmpDir[RTPATH_MAX];
+    RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
+    /* The template for the temporary directory created below */
+    char *pszTmpDir;
+    RTStrAPrintf(&pszTmpDir, "%s"RTPATH_SLASH_STR"vbox-ovf-XXXXXX", szOSTmpDir);
+    list< pair<Utf8Str, ULONG> > filesList;
+
+    // todo:
+    // - usable error codes
+    // - seems snapshot filenames are problematic {uuid}.vdi
+    try
+    {
+        /* Extract the bucket */
+        Utf8Str tmpPath = pTask->locInfo.strPath;
+        Utf8Str bucket;
+        parseBucket(tmpPath, bucket);
+
+        /* We need a temporary directory which we can put the OVF file & all
+         * disk images in */
+        vrc = RTDirCreateTemp(pszTmpDir);
+        if (RT_FAILURE(vrc))
+            throw setError(VBOX_E_FILE_ERROR,
+                           tr("Cannot create temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
+
+        /* The temporary name of the target OVF file */
+        Utf8StrFmt strTmpOvf("%s/%s", pszTmpDir, RTPathFilename(tmpPath.c_str()));
+
+        /* Prepare the temporary writing of the OVF */
+        ComObjPtr<Progress> progress;
+        /* Create a temporary file based location info for the sub task */
+        LocationInfo li;
+        li.strPath = strTmpOvf;
+        rc = writeImpl(pTask->enFormat, li, progress);
+        if (FAILED(rc)) throw rc;
+
+        /* Unlock the appliance for the writing thread */
+        appLock.release();
+        /* Wait until the writing is done, but report the progress back to the
+           caller */
+        ComPtr<IProgress> progressInt(progress);
+        waitForAsyncProgress(pTask->pProgress, progressInt); /* Any errors will be thrown */
+
+        /* Again lock the appliance for the next steps */
+        appLock.acquire();
+
+        vrc = RTPathExists(strTmpOvf.c_str()); /* Paranoid check */
+        if (RT_FAILURE(vrc))
+            throw setError(VBOX_E_FILE_ERROR,
+                           tr("Cannot find source file '%s' (%Rrc)"), strTmpOvf.c_str(), vrc);
+        /* Add the OVF file */
+        filesList.push_back(pair<Utf8Str, ULONG>(strTmpOvf, m->ulWeightForXmlOperation)); /* Use 1% of the total for the OVF file upload */
+        Utf8Str strMfFile = manifestFileName(strTmpOvf);
+        filesList.push_back(pair<Utf8Str, ULONG>(strMfFile , m->ulWeightForXmlOperation)); /* Use 1% of the total for the manifest file upload */
+
+        /* Now add every disks of every virtual system */
+        list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
+        for (it = m->virtualSystemDescriptions.begin();
+             it != m->virtualSystemDescriptions.end();
+             ++it)
+        {
+            ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
+            std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
+            std::list<VirtualSystemDescriptionEntry*>::const_iterator itH;
+            for (itH = avsdeHDs.begin();
+                 itH != avsdeHDs.end();
+                 ++itH)
+            {
+                const Utf8Str &strTargetFileNameOnly = (*itH)->strOvf;
+                /* Target path needs to be composed from where the output OVF is */
+                Utf8Str strTargetFilePath(strTmpOvf);
+                strTargetFilePath.stripFilename();
+                strTargetFilePath.append("/");
+                strTargetFilePath.append(strTargetFileNameOnly);
+                vrc = RTPathExists(strTargetFilePath.c_str()); /* Paranoid check */
+                if (RT_FAILURE(vrc))
+                    throw setError(VBOX_E_FILE_ERROR,
+                                   tr("Cannot find source file '%s' (%Rrc)"), strTargetFilePath.c_str(), vrc);
                 filesList.push_back(pair<Utf8Str, ULONG>(strTargetFilePath, (*itH)->ulSizeMB));
             }

trunk/src/VBox/Main/ApplianceImplImport.cpp

@@ -23 +23 @@
 #include <iprt/sha.h>
 #include <iprt/manifest.h>
+#include <iprt/tar.h>
+#include <iprt/stream.h>
 
 #include <VBox/com/array.h>
@@ -77 +79 @@
     // see if we can handle this file; for now we insist it has an ".ovf" extension
     Utf8Str strPath (path);
-    if (!strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
+    if (!(   strPath.endsWith(".ovf", Utf8Str::CaseInsensitive)
+          || strPath.endsWith(".ova", Utf8Str::CaseInsensitive)))
         return setError(VBOX_E_FILE_ERROR,
                         tr("Appliance file must have .ovf extension"));
@@ -599 +602 @@
  * This will then open the OVF with ovfreader.cpp.
  *
- * This is in a separate private method because it is used from two locations:
+ * This is in a separate private method because it is used from three locations:
  *
  * 1) from the public Appliance::Read().
- * 2) from Appliance::readS3(), which got called from a previous instance of Appliance::taskThreadImportOrExport().
+ *
+ * 2) in a second worker thread; in that case, Appliance::ImportMachines() called Appliance::importImpl(), which
+ *    called Appliance::readFSOVA(), which called Appliance::importImpl(), which then called this again.
+ *
+ * 3) from Appliance::readS3(), which got called from a previous instance of Appliance::taskThreadImportOrExport().
  *
  * @param aLocInfo
@@ -658 +665 @@
  * @return
  */
-HRESULT Appliance::readFS(const LocationInfo &locInfo)
+HRESULT Appliance::readFS(const LocationInfo &locInfo, ComObjPtr<Progress> &pProgress)
+{
+    if (locInfo.strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
+        return readFSOVF(locInfo, pProgress);
+    else
+        return readFSOVA(locInfo, pProgress);
+}
+
+HRESULT Appliance::readFSOVF(const LocationInfo &locInfo, ComObjPtr<Progress> & /* pProgress */)
 {
     LogFlowFuncEnter();
@@ -693 +708 @@
         rc = aRC;
     }
+
+    LogFlowFunc(("rc=%Rhrc\n", rc));
+    LogFlowFuncLeave();
+
+    return rc;
+}
+
+HRESULT Appliance::readFSOVA(const LocationInfo &locInfo, ComObjPtr<Progress> &pProgress)
+{
+    LogFlowFuncEnter();
+    LogFlowFunc(("Appliance %p\n", this));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
+
+    HRESULT rc = S_OK;
+    int vrc = VINF_SUCCESS;
+    char szOSTmpDir[RTPATH_MAX];
+    RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
+    /* The template for the temporary directory created below */
+    char *pszTmpDir;
+    RTStrAPrintf(&pszTmpDir, "%s"RTPATH_SLASH_STR"vbox-ovf-XXXXXX", szOSTmpDir);
+    list< pair<Utf8Str, ULONG> > filesList;
+    Utf8Str strTmpOvf;
+
+    try
+    {
+        /* Extract the path */
+        Utf8Str tmpPath = locInfo.strPath;
+        /* Remove the ova extension */
+        tmpPath.stripExt();
+        tmpPath += ".ovf";
+
+        /* We need a temporary directory which we can put the OVF file & all
+         * disk images in */
+        vrc = RTDirCreateTemp(pszTmpDir);
+        if (RT_FAILURE(vrc))
+            DebugBreakThrow(setError(VBOX_E_FILE_ERROR,
+                           tr("Cannot create temporary directory '%s' (%Rrc)"), pszTmpDir, vrc));
+
+        /* The temporary name of the target OVF file */
+        strTmpOvf = Utf8StrFmt("%s/%s", pszTmpDir, RTPathFilename(tmpPath.c_str()));
+
+        /* Next we have to download the OVF */
+        char *papszFile = RTPathFilename(strTmpOvf.c_str());
+        vrc = RTTarExtractFiles(locInfo.strPath.c_str(), pszTmpDir, &papszFile, 1, 0, 0);
+        if (RT_FAILURE(vrc))
+        {
+            if (vrc == VERR_FILE_NOT_FOUND)
+                DebugBreakThrow(setError(VBOX_E_IPRT_ERROR,
+                                         tr("Can't find ovf file '%s' in archive '%s' (%Rrc)"), papszFile, locInfo.strPath.c_str(), vrc));
+            else
+                DebugBreakThrow(setError(VBOX_E_IPRT_ERROR,
+                                         tr("Can't unpack the archive file '%s' (%Rrc)"), locInfo.strPath.c_str(), vrc));
+        }
+
+        // todo: check this out
+//        pTask->pProgress->SetNextOperation(Bstr(tr("Reading")), 1);
+
+        /* Prepare the temporary reading of the OVF */
+        ComObjPtr<Progress> progress;
+        LocationInfo li;
+        li.strPath = strTmpOvf;
+        /* Start the reading from the fs */
+        rc = readImpl(li, progress);
+        if (FAILED(rc)) DebugBreakThrow(rc);
+
+        /* Unlock the appliance for the reading thread */
+        appLock.release();
+        /* Wait until the reading is done, but report the progress back to the
+           caller */
+        ComPtr<IProgress> progressInt(progress);
+        waitForAsyncProgress(pProgress, progressInt); /* Any errors will be thrown */
+
+        /* Again lock the appliance for the next steps */
+        appLock.acquire();
+    }
+    catch(HRESULT aRC)
+    {
+        rc = aRC;
+    }
+    /* Delete all files which where temporary created */
+    if (RTPathExists(strTmpOvf.c_str()))
+    {
+        vrc = RTFileDelete(strTmpOvf.c_str());
+        if (RT_FAILURE(vrc))
+            rc = setError(VBOX_E_FILE_ERROR,
+                          tr("Cannot delete file '%s' (%Rrc)"), strTmpOvf.c_str(), vrc);
+    }
+    /* Delete the temporary directory */
+    if (RTPathExists(pszTmpDir))
+    {
+        vrc = RTDirRemove(pszTmpDir);
+        if (RT_FAILURE(vrc))
+            rc = setError(VBOX_E_FILE_ERROR,
+                          tr("Cannot delete temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
+    }
+    if (pszTmpDir)
+        RTStrFree(pszTmpDir);
 
     LogFlowFunc(("rc=%Rhrc\n", rc));
@@ -939 +1055 @@
  * @return
  */
-HRESULT Appliance::importImpl(const LocationInfo &aLocInfo,
-                              ComObjPtr<Progress> &aProgress)
+HRESULT Appliance::importImpl(const LocationInfo &locInfo,
+                              ComObjPtr<Progress> &progress)
 {
     HRESULT rc = S_OK;
 
     SetUpProgressMode mode;
-    m->strManifestFile.setNull();
-    if (aLocInfo.storageType == VFSType_File)
-    {
-        Utf8Str strMfFile = manifestFileName(aLocInfo.strPath);
-        if (RTPathExists(strMfFile.c_str()))
-        {
-            m->strManifestFile = strMfFile;
-            mode = ImportFileWithManifest;
+    if (locInfo.storageType == VFSType_File)
+    {
+        mode = ImportFileNoManifest;
+        Utf8Str strMfFile = manifestFileName(locInfo.strPath);
+        if (!locInfo.strPath.endsWith(".ova", Utf8Str::CaseInsensitive))
+        {
+            if (RTPathExists(strMfFile.c_str()))
+                mode = ImportFileWithManifest;
         }
         else
-            mode = ImportFileNoManifest;
+        {
+            if (RTTarQueryFileExists(locInfo.strPath.c_str(), RTPathFilename(strMfFile.c_str())) == VINF_SUCCESS)
+                mode = ImportFileWithManifest;
+        }
     }
     else
          mode = ImportS3;
 
-    rc = setUpProgress(aProgress,
-                       BstrFmt(tr("Importing appliance '%s'"), aLocInfo.strPath.c_str()),
+    rc = setUpProgress(locInfo,
+                       progress,
+                       BstrFmt(tr("Importing appliance '%s'"), locInfo.strPath.c_str()),
                        mode);
     if (FAILED(rc)) DebugBreakThrow(rc);
 
     /* Initialize our worker task */
-    std::auto_ptr<TaskOVF> task(new TaskOVF(this, TaskOVF::Import, aLocInfo, aProgress));
+    std::auto_ptr<TaskOVF> task(new TaskOVF(this, TaskOVF::Import, locInfo, progress));
 
     rc = task->startThread();
@@ -993 +1113 @@
     HRESULT rc = S_OK;
 
-    if (!m->strManifestFile.isEmpty())
-    {
-        const char *pcszManifestFileOnly = RTPathFilename(m->strManifestFile.c_str());
+    Utf8Str strManifestFile = manifestFileName(locInfo.strPath);
+    if (!strManifestFile.isEmpty())
+    {
+        const char *pcszManifestFileOnly = RTPathFilename(strManifestFile.c_str());
         pProgress->SetNextOperation(BstrFmt(tr("Verifying manifest file '%s'"), pcszManifestFileOnly),
                                     m->ulWeightForManifestOperation);     // operation's weight, as set up with the IProgress originally
@@ -1043 +1164 @@
         // this call can take a very long time
         size_t cIndexOnError;
-        vrc = RTManifestVerify(m->strManifestFile.c_str(),
+        vrc = RTManifestVerify(strManifestFile.c_str(),
                                pTestList,
                                filesList.size() + 1,
@@ -1075 +1196 @@
  * VirtualSystemScription instances created by Appliance::Interpret().
  *
- * This runs in two contexts:
+ * This runs in three contexts:
  *
  * 1) in a first worker thread; in that case, Appliance::ImportMachines() called Appliance::importImpl();
  *
  * 2) in a second worker thread; in that case, Appliance::ImportMachines() called Appliance::importImpl(), which
- *    called Appliance::importS3(), which called Appliance::importImpl(), which then called this.
+ *    called Appliance::importFSOVA(), which called Appliance::importImpl(), which then called this again.
+ *
+ * 3) in a second worker thread; in that case, Appliance::ImportMachines() called Appliance::importImpl(), which
+ *    called Appliance::importS3(), which called Appliance::importImpl(), which then called this again.
  *
  * @param pTask
  * @return
  */
-HRESULT Appliance::importFS(const LocationInfo &locInfo,
-                            ComObjPtr<Progress> &pProgress)
+HRESULT Appliance::importFS(TaskOVF *pTask)
+{
+    if (!Utf8Str(RTPathExt(pTask->locInfo.strPath.c_str())).compare(".ovf", Utf8Str::CaseInsensitive))
+        return importFSOVF(pTask);
+    else
+        return importFSOVA(pTask);
+}
+
+HRESULT Appliance::importFSOVF(TaskOVF *pTask)
 {
     LogFlowFuncEnter();
@@ -1094 +1225 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    Assert(!pProgress.isNull());
+    Assert(!pTask->pProgress.isNull());
 
     // Change the appliance state so we can safely leave the lock while doing time-consuming
@@ -1112 +1243 @@
 
     // rollback for errors:
-    ImportStack stack(locInfo, reader.m_mapDisks, pProgress);
+    ImportStack stack(pTask->locInfo, reader.m_mapDisks, pTask->pProgress);
 
     // clear the list of imported machines, if any
@@ -1120 +1251 @@
     {
         // if a manifest file exists, verify the content; we then need all files which are referenced by the OVF & the OVF itself
-        rc = manifestVerify(locInfo, reader, pProgress);
+        rc = manifestVerify(pTask->locInfo, reader, pTask->pProgress);
         if (FAILED(rc)) DebugBreakThrow(rc);
 
@@ -1255 +1386 @@
 }
 
+HRESULT Appliance::importFSOVA(TaskOVF *pTask)
+{
+    LogFlowFuncEnter();
+    LogFlowFunc(("Appliance %p\n", this));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
+
+    int vrc = VINF_SUCCESS;
+    char szOSTmpDir[RTPATH_MAX];
+    RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
+    /* The template for the temporary directory created below */
+    char *pszTmpDir;
+    RTStrAPrintf(&pszTmpDir, "%s"RTPATH_SLASH_STR"vbox-ovf-XXXXXX", szOSTmpDir);
+    list< pair<Utf8Str, ULONG> > filesList;
+    const char** paFiles = 0;
+
+    HRESULT rc = S_OK;
+    try
+    {
+        /* Extract the path */
+        Utf8Str tmpPath = pTask->locInfo.strPath;
+        /* Remove the ova extension */
+        tmpPath.stripExt();
+        tmpPath += ".ovf";
+
+        /* We need a temporary directory which we can put the all disk images
+         * in */
+        vrc = RTDirCreateTemp(pszTmpDir);
+        if (RT_FAILURE(vrc))
+            DebugBreakThrow(setError(VBOX_E_FILE_ERROR,
+                                     tr("Cannot create temporary directory '%s' (%Rrc)"), pszTmpDir, vrc));
+
+        /* Provide a OVF file (haven't to exist) so the import routine can
+         * figure out where the disk images/manifest file are located. */
+        Utf8StrFmt strTmpOvf("%s/%s", pszTmpDir, RTPathFilename(tmpPath.c_str()));
+        /* Add the manifest file to the list of files to extract, but only if
+           one is in the archive. */
+        Utf8Str strManifestFile = manifestFileName(strTmpOvf);
+        vrc = RTTarQueryFileExists(pTask->locInfo.strPath.c_str(), RTPathFilename(strManifestFile.c_str()));
+        if (RT_SUCCESS(vrc))
+            filesList.push_back(pair<Utf8Str, ULONG>(strManifestFile.c_str(), 1));
+
+        ULONG ulWeight = m->ulWeightForXmlOperation;
+        /* Add every disks of every virtual system to an internal list */
+        list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
+        for (it = m->virtualSystemDescriptions.begin();
+             it != m->virtualSystemDescriptions.end();
+             ++it)
+        {
+            ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
+            std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
+            std::list<VirtualSystemDescriptionEntry*>::const_iterator itH;
+            for (itH = avsdeHDs.begin();
+                 itH != avsdeHDs.end();
+                 ++itH)
+            {
+                const Utf8Str &strTargetFile = (*itH)->strOvf;
+                if (!strTargetFile.isEmpty())
+                {
+                    /* The temporary name of the target disk file */
+                    Utf8StrFmt strTmpDisk("%s/%s", pszTmpDir, RTPathFilename(strTargetFile.c_str()));
+                    filesList.push_back(pair<Utf8Str, ULONG>(strTmpDisk, (*itH)->ulSizeMB));
+                    ulWeight += (*itH)->ulSizeMB;
+                }
+            }
+        }
+
+        /* Download all files */
+        paFiles = (const char**)RTMemAlloc(sizeof(char*) * filesList.size());
+        int i = 0;
+        for (list< pair<Utf8Str, ULONG> >::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1, ++i)
+            paFiles[i] = RTPathFilename((*it1).first.c_str());
+        if (!pTask->pProgress.isNull())
+            pTask->pProgress->SetNextOperation(BstrFmt(tr("Unpacking file '%s'"), RTPathFilename(pTask->locInfo.strPath.c_str())), ulWeight);
+        vrc = RTTarExtractFiles(pTask->locInfo.strPath.c_str(), pszTmpDir, paFiles, filesList.size(), pTask->updateProgress, &pTask);
+        if (RT_FAILURE(vrc))
+            throw setError(VBOX_E_FILE_ERROR,
+                           tr("Cannot unpack archive file '%s' (%Rrc)"), pTask->locInfo.strPath.c_str(), vrc);
+
+//        if (!pTask->pProgress.isNull())
+//            pTask->pProgress->SetNextOperation(BstrFmt(tr("Importing appliance")), m->ulWeightForXmlOperation);
+
+        ComObjPtr<Progress> progress;
+        /* Import the whole temporary OVF & the disk images */
+        LocationInfo li;
+        li.strPath = strTmpOvf;
+        rc = importImpl(li, progress);
+        if (FAILED(rc)) DebugBreakThrow(rc);
+
+        /* Unlock the appliance for the fs import thread */
+        appLock.release();
+        /* Wait until the import is done, but report the progress back to the
+           caller */
+        ComPtr<IProgress> progressInt(progress);
+        waitForAsyncProgress(pTask->pProgress, progressInt); /* Any errors will be thrown */
+
+        /* Again lock the appliance for the next steps */
+        appLock.acquire();
+    }
+    catch(HRESULT aRC)
+    {
+        rc = aRC;
+    }
+    /* Delete the temporary files list */
+    if (paFiles)
+        RTMemFree(paFiles);
+    /* Delete all files which where temporary created */
+    for (list< pair<Utf8Str, ULONG> >::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1)
+    {
+        const char *pszFilePath = (*it1).first.c_str();
+        if (RTPathExists(pszFilePath))
+        {
+            vrc = RTFileDelete(pszFilePath);
+            if (RT_FAILURE(vrc))
+                rc = setError(VBOX_E_FILE_ERROR,
+                              tr("Cannot delete file '%s' (%Rrc)"), pszFilePath, vrc);
+        }
+    }
+    /* Delete the temporary directory */
+    if (RTPathExists(pszTmpDir))
+    {
+        vrc = RTDirRemove(pszTmpDir);
+        if (RT_FAILURE(vrc))
+            rc = setError(VBOX_E_FILE_ERROR,
+                          tr("Cannot delete temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
+    }
+    if (pszTmpDir)
+        RTStrFree(pszTmpDir);
+
+    LogFlowFunc(("rc=%Rhrc\n", rc));
+    LogFlowFuncLeave();
+
+    return rc;
+}
+
 /**
  * Imports one disk image. This is common code shared between
@@ -1365 +1634 @@
 
             /* Advance to the next operation */
-            stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), strSrcFilePath.c_str()),
+            stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), RTPathFilename(strSrcFilePath.c_str())),
                                               di.ulSuggestedSizeMB);     // operation's weight, as set up with the IProgress originally);
         }
@@ -2163 +2432 @@
         if (RT_FAILURE(vrc))
             DebugBreakThrow(setError(VBOX_E_FILE_ERROR,
-                                     tr("Cannot create temporary directory '%s'"), pszTmpDir));
+                                     tr("Cannot create temporary directory '%s' (%Rrc)"), pszTmpDir, vrc));
 
         /* Add every disks of every virtual system to an internal list */

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

@@ -122 +122 @@
 
     void disksWeight();
+    struct LocationInfo;
     enum SetUpProgressMode { ImportFileWithManifest, ImportFileNoManifest, ImportS3, WriteFile, WriteS3 };
-    HRESULT setUpProgress(ComObjPtr<Progress> &pProgress,
+    HRESULT setUpProgress(const LocationInfo &locInfo,
+                          ComObjPtr<Progress> &pProgress,
                           const Bstr &bstrDescription,
                           SetUpProgressMode mode);
 
-    struct LocationInfo;
     void parseURI(Utf8Str strUri, LocationInfo &locInfo) const;
     void parseBucket(Utf8Str &aPath, Utf8Str &aBucket);
-    Utf8Str manifestFileName(Utf8Str aPath) const;
+    Utf8Str manifestFileName(const Utf8Str& aPath) const;
 
     HRESULT readImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
@@ -137 +138 @@
     static DECLCALLBACK(int) taskThreadImportOrExport(RTTHREAD aThread, void *pvUser);
 
-    HRESULT readFS(const LocationInfo &locInfo);
+    HRESULT readFS(const LocationInfo &locInfo, ComObjPtr<Progress> &pProgress);
+    HRESULT readFSOVF(const LocationInfo &locInfo, ComObjPtr<Progress> &pProgress);
+    HRESULT readFSOVA(const LocationInfo &locInfo, ComObjPtr<Progress> &pProgress);
     HRESULT readS3(TaskOVF *pTask);
 
@@ -149 +152 @@
     HRESULT manifestVerify(const LocationInfo &locInfo, const ovf::OVFReader &reader, ComObjPtr<Progress> &pProgress);
 
-    HRESULT importFS(const LocationInfo &locInfo, ComObjPtr<Progress> &aProgress);
+    HRESULT importFS(TaskOVF *pTask);
+    HRESULT importFSOVF(TaskOVF *pTask);
+    HRESULT importFSOVA(TaskOVF *pTask);
 
     struct ImportStack;
@@ -175 +180 @@
                                      XMLStack &stack);
 
-    HRESULT writeFS(const LocationInfo &locInfo, const OVFFormat enFormat, ComObjPtr<Progress> &pProgress);
+    HRESULT writeFS(TaskOVF *pTask);
+    HRESULT writeFSOVF(TaskOVF *pTask);
+    HRESULT writeFSOVA(TaskOVF *pTask);
     HRESULT writeS3(TaskOVF *pTask);
 

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

@@ -72 +72 @@
 
     std::list<Utf8Str>  llWarnings;
-
-    Utf8Str             strManifestFile;    // on import, contains path of manifest file if it exists
 
     ULONG               ulWeightForXmlOperation;