Changeset 67184 in vbox

Timestamp:

May 31, 2017 8:32:04 PM (8 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

115861

Message:

Main: Reworking IAppliance export to use new TAR creator. Changes protected by VBOX_WITH_NEW_TAR_CREATOR define (currently not defined).

Location:

trunk/src/VBox/Main

Files:

• Makefile.kmk (modified) (1 diff)
• include/ApplianceImpl.h (modified) (3 diffs)
• include/ApplianceImplPrivate.h (modified) (3 diffs)
• include/MediumImpl.h (modified) (1 diff)
• src-server/ApplianceImpl.cpp (modified) (1 diff)
• src-server/ApplianceImplExport.cpp (modified) (19 diffs)
• src-server/ApplianceImplIO.cpp (modified) (2 diffs)
• src-server/ApplianceImplImport.cpp (modified) (4 diffs)
• src-server/MediumImpl.cpp (modified) (7 diffs)

trunk/src/VBox/Main/Makefile.kmk

@@ -373 +373 @@
         $(if $(VBOX_WITH_EHCI),VBOX_WITH_EHCI,) \
         $(if $(VBOX_WITH_NEW_USB_CODE_ON_DARWIN),VBOX_WITH_NEW_USB_CODE_ON_DARWIN,)
+endif
+if defined(VBOX_WITH_NEW_TAR_CREATOR) #|| "$(USERNAME)" == "bird" # temporary
+ VBoxSVC_DEFS += VBOX_WITH_NEW_TAR_CREATOR
 endif
 VBoxSVC_DEFS.win += VBOX_COM_OUTOFPROC_MODULE

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

@@ -148 +148 @@
 
     HRESULT i_findMediumFormatFromDiskImage(const ovf::DiskImage &di, ComObjPtr<MediumFormat>& mf);
+
+    RTVFSIOSTREAM i_manifestSetupDigestCalculationForGivenIoStream(RTVFSIOSTREAM hVfsIos, const char *pszManifestEntry,
+                                                                   bool fRead = true);
     /** @}  */
 
@@ -198 +201 @@
     HRESULT i_preCheckImageAvailability(ImportStack &stack);
     bool    i_importEnsureOvaLookAhead(ImportStack &stack);
-    RTVFSIOSTREAM i_importSetupDigestCalculationForGivenIoStream(RTVFSIOSTREAM hVfsIos, const char *pszManifestEntry);
     RTVFSIOSTREAM i_importOpenSourceFile(ImportStack &stack, Utf8Str const &rstrSrcPath, const char *pszManifestEntry);
     HRESULT i_importCreateAndWriteDestinationFile(Utf8Str const &rstrDstPath,
@@ -217 +219 @@
     HRESULT i_writeFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock);
     HRESULT i_writeFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock);
-    HRESULT i_writeFSImpl(TaskOVF *pTask, AutoWriteLockBase &writeLock, RTVFSFSSTREAM hVfsFss,
-                          PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage);
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+    HRESULT i_writeFSImpl(TaskOVF *pTask, AutoWriteLockBase &writeLock, RTVFSFSSTREAM hVfsFssDst);
+    HRESULT i_writeBufferToFile(RTVFSFSSTREAM hVfsFssDst, const char *pszFilename, const void *pvContent, size_t cbContent);
+#else
+    HRESULT i_writeFSImpl(TaskOVF *pTask, AutoWriteLockBase &writeLock, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage);
+#endif
 
     struct XMLStack;

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

@@ -19 +19 @@
 #define ____H_APPLIANCEIMPLPRIVATE
 
-#ifdef DEBUG_bird
-# define MAIN_WITH_NEW_TAR_CREATOR
-#endif
 
 class VirtualSystemDescription;
@@ -74 +71 @@
       , hOurManifest(NIL_RTMANIFEST)
       , fManifest(true)
+#ifndef VBOX_WITH_NEW_TAR_CREATOR
       , fSha256(false)
+#endif
       , fDeterminedDigestTypes(false)
       , hTheirManifest(NIL_RTMANIFEST)
@@ -163 +162 @@
      * @{ */
     bool                fManifest;      // Create a manifest file on export
+#ifndef VBOX_WITH_NEW_TAR_CREATOR
     bool                fSha256;        // true = SHA256 (OVF 2.0), false = SHA1 (OVF 1.0)
+#endif
     /** @} */
 

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

@@ -207 +207 @@
                          MediumVariant_T aVariant,
                          SecretKeyStore *pKeyStore,
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+                         RTVFSIOSTREAM hVfsIosDst,
+#else
                          PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
+#endif
                          const ComObjPtr<Progress> &aProgress);
     HRESULT i_importFile(const char *aFilename,

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

@@ -872 +872 @@
 
 /**
+ * Setup automatic I/O stream digest calculation, adding it to hOurManifest.
+ *
+ * @returns Passthru I/O stream, of @a hVfsIos if no digest calc needed.
+ * @param   hVfsIos             The stream to wrap. Always consumed.
+ * @param   pszManifestEntry    The manifest entry.
+ * @param   fRead               Set if read stream, clear if write.
+ * @throws  Nothing.
+ */
+RTVFSIOSTREAM Appliance::i_manifestSetupDigestCalculationForGivenIoStream(RTVFSIOSTREAM hVfsIos, const char *pszManifestEntry,
+                                                                          bool fRead /*= true */)
+{
+    int vrc;
+    Assert(!RTManifestPtIosIsInstanceOf(hVfsIos));
+
+    if (m->fDigestTypes == 0)
+        return hVfsIos;
+
+    /* Create the manifest if necessary. */
+    if (m->hOurManifest == NIL_RTMANIFEST)
+    {
+        vrc = RTManifestCreate(0 /*fFlags*/, &m->hOurManifest);
+        AssertRCReturnStmt(vrc, RTVfsIoStrmRelease(hVfsIos), NIL_RTVFSIOSTREAM);
+    }
+
+    /* Setup the stream. */
+    RTVFSIOSTREAM hVfsIosPt;
+    vrc = RTManifestEntryAddPassthruIoStream(m->hOurManifest, hVfsIos, pszManifestEntry, m->fDigestTypes, fRead, &hVfsIosPt);
+
+    RTVfsIoStrmRelease(hVfsIos);        /* always consumed! */
+    if (RT_SUCCESS(vrc))
+        return hVfsIosPt;
+
+    setErrorVrc(vrc, "RTManifestEntryAddPassthruIoStream failed with rc=%Rrc", vrc);
+    return NIL_RTVFSIOSTREAM;
+}
+
+/**
  * Returns true if the appliance is in "idle" state. This should always be the
  * case unless an import or export is currently in progress. Similar to machine

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

@@ -21 +21 @@
 #include <iprt/s3.h>
 #include <iprt/manifest.h>
-#include <iprt/tar.h>
 #include <iprt/stream.h>
+#ifndef VBOX_WITH_NEW_TAR_CREATOR
+# include <iprt/tar.h>
+#else
+# include <iprt/zip.h>
+#endif
 
 #include <VBox/version.h>
@@ -675 +679 @@
                         tr("Appliance file must have .ovf or .ova extension"));
 
-    m->fManifest = m->optListExport.contains(ExportOptions_CreateManifest);
-
     ovf::OVFVersion_T ovfF;
     if (aFormat == "ovf-0.9")
-    {
         ovfF = ovf::OVFVersion_0_9;
-    }
     else if (aFormat == "ovf-1.0")
-    {
         ovfF = ovf::OVFVersion_1_0;
-    }
     else if (aFormat == "ovf-2.0")
-    {
         ovfF = ovf::OVFVersion_2_0;
-    }
     else
         return setError(VBOX_E_FILE_ERROR,
                         tr("Invalid format \"%s\" specified"), aFormat.c_str());
+
+    /* As of OVF 2.0 we have to use SHA-256 in the manifest. */
+    m->fManifest = m->optListExport.contains(ExportOptions_CreateManifest);
+    if (m->fManifest)
+        m->fDigestTypes = ovfF >= ovf::OVFVersion_2_0 ? RTMANIFEST_ATTR_SHA256 : RTMANIFEST_ATTR_SHA1;
+#ifndef VBOX_WITH_NEW_TAR_CREATOR
+    m->fSha256 = ovfF >= ovf::OVFVersion_2_0;
+#endif
+    Assert(m->hOurManifest == NIL_RTMANIFEST);
 
     /* Check whether all passwords are supplied or error out. */
@@ -698 +703 @@
         return setError(VBOX_E_INVALID_OBJECT_STATE,
                         tr("Appliance export failed because not all passwords were provided for all encrypted media"));
-
-    /* as of OVF 2.0 we have to use SHA256 */
-    m->fSha256 = ovfF >= ovf::OVFVersion_2_0;
 
     ComObjPtr<Progress> progress;
@@ -1991 +1993 @@
     LogFlowFuncEnter();
 
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+    HRESULT hrc = E_NOTIMPL;
+    AssertFailed();
+    RT_NOREF(pTask, writeLock);
+
+    /** @todo need a FSS creator wrapper around a directory here.   */
+
+    LogFlowFuncLeave();
+    return hrc;
+
+#else /* VBOX_WITH_NEW_TAR_CREATOR */
     HRESULT rc = S_OK;
 
@@ -2026 +2039 @@
             break;
         }
-        rc = i_writeFSImpl(pTask, writeLock, NIL_RTVFSFSSTREAM, pShaIo, &storage);
+        rc = i_writeFSImpl(pTask, writeLock, pShaIo, &storage);
     } while (0);
 
@@ -2037 +2050 @@
     LogFlowFuncLeave();
     return rc;
+#endif
 }
 
-HRESULT Appliance::i_writeFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock)
+HRESULT Appliance::i_writeFSOVA(TaskOVF *pTask, AutoWriteLockBase &writeLock)
 {
     LogFlowFuncEnter();
+
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+    /*
+     * Open the output file and attach a TAR creator to it.
+     */
+    HRESULT hrc;
+    RTVFSIOSTREAM hVfsIosTar;
+    int vrc = RTVfsIoStrmOpenNormal(pTask->locInfo.strPath.c_str(),
+                                    RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE,
+                                    &hVfsIosTar);
+    if (RT_SUCCESS(vrc))
+    {
+        /** @todo which format does the standard dicate here actually?
+         *  GNU or USTAR/POSIX? */
+        RTVFSFSSTREAM hVfsFssTar;
+        vrc = RTZipTarFsStreamToIoStream(hVfsIosTar, RTZIPTARFORMAT_GNU, 0 /*fFlags*/, &hVfsFssTar);
+        RTVfsIoStrmRelease(hVfsIosTar);
+        if (RT_SUCCESS(vrc))
+        {
+            hrc = i_writeFSImpl(pTask, writeLock, hVfsFssTar);
+            RTVfsFsStrmRelease(hVfsFssTar);
+        }
+        else
+            hrc = setErrorVrc(vrc, tr("Failed create TAR creator for '%s' (%Rrc)"), pTask->locInfo.strPath.c_str(), vrc);
+
+        /* Delete the OVA on failure. */
+        if (FAILED(hrc))
+            RTFileDelete(pTask->locInfo.strPath.c_str());
+    }
+    else
+        hrc = setErrorVrc(vrc, tr("Failed to open '%s' for writing (%Rrc)"), pTask->locInfo.strPath.c_str(), vrc);
+
+    LogFlowFuncLeave();
+    return hrc;
+
+#else /* VBOX_WITH_NEW_TAR_CREATOR */
 
     RTTAR tar;
@@ -2084 +2134 @@
             break;
         }
-        rc = i_writeFSImpl(pTask, writeLock, NIL_RTVFSFSSTREAM, pShaIo, &storage);
+        rc = i_writeFSImpl(pTask, writeLock, pShaIo, &storage);
     } while (0);
 
@@ -2101 +2151 @@
     LogFlowFuncLeave();
     return rc;
+#endif
 }
 
-HRESULT Appliance::i_writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, RTVFSFSSTREAM hVfsFssOut,
-                                 PVDINTERFACEIO pIfIo, PSHASTORAGE pStorage)
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+HRESULT Appliance::i_writeFSImpl(TaskOVF *pTask, AutoWriteLockBase &writeLock, RTVFSFSSTREAM hVfsFssDst)
+#else
+HRESULT Appliance::i_writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pIfIo, PSHASTORAGE pStorage)
+#endif
 {
     LogFlowFuncEnter();
 
     HRESULT rc = S_OK;
-
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+    RTMANIFEST hManifest;
+    int vrc = RTManifestCreate(0 /*fFlags*/, &hManifest);
+
+#else
+    int vrc;
     list<STRPAIR> fileList;
+#endif
     try
     {
-        int vrc;
         // the XML stack contains two maps for disks and networks, which allows us to
         // a) have a list of unique disk names (to make sure the same disk name is only added once)
@@ -2120 +2179 @@
         // Scope this to free the memory as soon as this is finished
         {
-            // Create a xml document
+            /* Construct the OVF name. */
+            Utf8Str strOvfFile(pTask->locInfo.strPath);
+            strOvfFile.stripSuffix().append(".ovf");
+
+            /* Render a valid ovf document into a memory buffer. */
             xml::Document doc;
-            // Now fully build a valid ovf document in memory
             i_buildXML(writeLock, doc, stack, pTask->locInfo.strPath, pTask->enFormat);
-            /* Extract the OVA file name */
-            Utf8Str strOvaFile = pTask->locInfo.strPath;
-            /* Extract the path */
-            Utf8Str strOvfFile = strOvaFile.stripSuffix().append(".ovf");
-            // Create a memory buffer containing the XML. */
-            void *pvBuf = 0;
-            size_t cbSize;
+
+            void *pvBuf = NULL;
+            size_t cbSize = 0;
             xml::XmlMemWriter writer;
             writer.write(doc, &pvBuf, &cbSize);
@@ -2137 +2195 @@
                                tr("Could not create OVF file '%s'"),
                                strOvfFile.c_str());
-            /* Write the ovf file to disk. */
-            if (hVfsFssOut != NIL_RTVFSFSSTREAM)
-                vrc = writeBufferToFile(strOvfFile.c_str(), pvBuf, cbSize, hVfsFssOut);
-            else
-                vrc = writeBufferToFile(strOvfFile.c_str(), pvBuf, cbSize, pIfIo, pStorage);
+
+            /* Write the ovf file to "disk". */
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+            rc = i_writeBufferToFile(hVfsFssDst, strOvfFile.c_str(), pvBuf, cbSize);
+            if (FAILED(rc))
+                throw rc;
+#else
+            vrc = writeBufferToFile(strOvfFile.c_str(), pvBuf, cbSize, pIfIo, pStorage);
             if (RT_FAILURE(vrc))
-
-                throw setError(VBOX_E_FILE_ERROR,
-                               tr("Could not create OVF file '%s' (%Rrc)"),
-                               strOvfFile.c_str(), vrc);
+                throw setErrorVrc(vrc, tr("Could not create OVF file '%s' (%Rrc)"), strOvfFile.c_str(), vrc);
+#endif
+
+#ifndef VBOX_WITH_NEW_TAR_CREATOR
             fileList.push_back(STRPAIR(strOvfFile, pStorage->strDigest));
+#endif
         }
 
@@ -2249 +2311 @@
                     if (FAILED(rc)) throw rc;
 
-                    if (hVfsFssOut != NIL_RTVFSFSSTREAM)
-                        rc = E_NOTIMPL; /** @todo Continue here later. Need to (1) wrap the FSS thing (in the caller?)
-                                         *        and (2) provide a push API for adding streams.  (RTVfsFsStrmAdd is a pull API,
-                                         *        in that it pulls in the data bytes itself.) */
-                    else
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+                    /* For compressed VMDK fun, we let i_exportFile produce the image bytes. */
+                    if (true)
                     {
+                        RTVFSIOSTREAM hVfsIosDst;
+                        vrc = RTVfsFsStrmPushFile(hVfsFssDst, strTargetFilePath.c_str(), UINT64_MAX,
+                                                  NULL /*paObjInfo*/, 0 /*cObjInfo*/, RTVFSFSSTRM_PUSH_F_STREAM, &hVfsIosDst);
+                        if (RT_FAILURE(vrc))
+                            throw setErrorVrc(vrc, tr("RTVfsFsStrmPushFile failed for '%s' (%Rrc)"), strTargetFilePath.c_str(), vrc);
+                        hVfsIosDst = i_manifestSetupDigestCalculationForGivenIoStream(hVfsIosDst, strTargetFilePath.c_str(),
+                                                                                      false /*fRead*/);
+                        if (hVfsIosDst == NIL_RTVFSIOSTREAM)
+                            throw setError(E_FAIL, "i_manifestSetupDigestCalculationForGivenIoStream(%s)", strTargetFilePath.c_str());
+
                         rc = pSourceDisk->i_exportFile(strTargetFilePath.c_str(),
                                                        format,
                                                        MediumVariant_VmdkStreamOptimized,
                                                        m->m_pSecretKeyStore,
-                                                       pIfIo,
-                                                       pStorage,
+                                                       hVfsIosDst,
                                                        pProgress2);
+                        RTVfsIoStrmRelease(hVfsIosDst);
+                        if (FAILED(rc)) throw rc;
                     }
+                    /* When creating sparse raw images, the tar creator stream pulls the data
+                       out of the disk image.  It will scan for empty space first, then copy
+                       the non-empty segments into the tar stream. */
+                    else
+                    {
+                        throw E_NOTIMPL;
+                    }
+#else
+                    rc = pSourceDisk->i_exportFile(strTargetFilePath.c_str(),
+                                                   format,
+                                                   MediumVariant_VmdkStreamOptimized,
+                                                   m->m_pSecretKeyStore,
+                                                   pIfIo,
+                                                   pStorage,
+                                                   pProgress2);
                     if (FAILED(rc)) throw rc;
+#endif
 
                     ComPtr<IProgress> pProgress3(pProgress2);
@@ -2276 +2363 @@
                     Assert(pDiskEntry->type == VirtualSystemDescriptionType_CDROM);
 
-                    if (hVfsFssOut != NIL_RTVFSFSSTREAM)
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+                    /* Open the source image and cast it to a VFS base object. */
+                    RTVFSFILE hVfsSrcFile;
+                    vrc = RTVfsFileOpenNormal(strSrcFilePath.c_str(),
+                                              RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE,
+                                              &hVfsSrcFile);
+                    if (RT_FAILURE(vrc))
+                        throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                           tr("Could not create or open file '%s' (%Rrc)"), strSrcFilePath.c_str(), vrc);
+
+                    RTVFSOBJ hVfsSrc = RTVfsObjFromFile(hVfsSrcFile);
+                    RTVfsFileRelease(hVfsSrcFile);
+                    AssertStmt(hVfsSrc != NIL_RTVFSOBJ, throw VERR_INTERNAL_ERROR);
+
+                    /* Add it to the output stream.  This will pull in all the data from the object. */
+                    vrc = RTVfsFsStrmAdd(hVfsFssDst, strTargetFilePath.c_str(), hVfsSrc, 0 /*fFlags*/);
+                    RTVfsObjRelease(hVfsSrc);
+                    if (RT_FAILURE(vrc))
+                        throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,  tr("Error during copy CD/DVD image '%s' (%Rrc)"),
+                                           strSrcFilePath.c_str(), vrc);
+#else
+                    /* Read the ISO file and add one to OVA/OVF package */
+                    void *pvStorage;
+                    RTFILE pFile = NULL;
+                    void *pvUser = pStorage;
+
+                    vrc = pIfIo->pfnOpen(pvUser, strTargetFilePath.c_str(),
+                                         RTFILE_O_OPEN_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE,
+                                         0,
+                                         &pvStorage);
+                    if (RT_FAILURE(vrc))
+                        throw setError(VBOX_E_FILE_ERROR,
+                                       tr("Could not create or open file '%s' (%Rrc)"),
+                                       strTargetFilePath.c_str(), vrc);
+
+                    vrc = RTFileOpen(&pFile,
+                                     strSrcFilePath.c_str(),
+                                     RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE);
+
+                    if (RT_FAILURE(vrc) || pFile == NULL)
                     {
-                        /* Open the source image and cast it to a VFS base object. */
-                        RTVFSFILE hVfsSrcFile;
-                        vrc = RTVfsFileOpenNormal(strSrcFilePath.c_str(),
-                                                  RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE,
-                                                  &hVfsSrcFile);
-                        if (RT_FAILURE(vrc))
-                            throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
-                                               tr("Could not create or open file '%s' (%Rrc)"), strSrcFilePath.c_str(), vrc);
-
-                        RTVFSOBJ hVfsSrc = RTVfsObjFromFile(hVfsSrcFile);
-                        RTVfsFileRelease(hVfsSrcFile);
-                        AssertStmt(hVfsSrc != NIL_RTVFSOBJ, throw VERR_INTERNAL_ERROR);
-
-                        /* Add it to the output stream.  This will pull in all the data from the object. */
-                        vrc = RTVfsFsStrmAdd(hVfsFssOut, strTargetFilePath.c_str(), hVfsSrc, 0 /*fFlags*/);
-                        RTVfsObjRelease(hVfsSrc);
-                        if (RT_FAILURE(vrc))
-                            throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,  tr("Error during copy CD/DVD image '%s' (%Rrc)"),
-                                               strSrcFilePath.c_str(), vrc);
+                        pIfIo->pfnClose(pvUser, pvStorage);
+                        throw setError(VBOX_E_FILE_ERROR,
+                                       tr("Could not create or open file '%s' (%Rrc)"),
+                                       strSrcFilePath.c_str(), vrc);
                     }
-                    else
+
+                    uint64_t cbFile = 0;
+                    vrc = RTFileGetSize(pFile, &cbFile);
+                    if (RT_SUCCESS(vrc))
                     {
-                        /* Read the ISO file and add one to OVA/OVF package */
-                        void *pvStorage;
-                        RTFILE pFile = NULL;
-                        void *pvUser = pStorage;
-
-                        vrc = pIfIo->pfnOpen(pvUser, strTargetFilePath.c_str(),
-                                             RTFILE_O_OPEN_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE,
-                                             0,
-                                             &pvStorage);
-                        if (RT_FAILURE(vrc))
+                        size_t const cbTmpSize = _1M;
+                        void *pvTmpBuf = RTMemAlloc(cbTmpSize);
+                        if (pvTmpBuf)
+                        {
+                            /* The copy loop. */
+                            uint64_t offDstFile = 0;
+                            for (;;)
+                            {
+                                size_t cbChunk = 0;
+                                vrc = RTFileRead(pFile, pvTmpBuf, cbTmpSize, &cbChunk);
+                                if (RT_FAILURE(vrc) || cbChunk == 0)
+                                    break;
+
+                                size_t cbWritten = 0;
+                                vrc = pIfIo->pfnWriteSync(pvUser,
+                                                          pvStorage,
+                                                          offDstFile,
+                                                          pvTmpBuf,
+                                                          cbChunk,
+                                                          &cbWritten);
+                                if (RT_FAILURE(vrc))
+                                    break;
+                                Assert(cbWritten == cbChunk);
+
+                                offDstFile += cbWritten;
+                            }
+
+                            RTMemFree(pvTmpBuf);
+                        }
+                        else
+                            vrc = VERR_NO_MEMORY;
+                    }
+
+                    pIfIo->pfnClose(pvUser, pvStorage);
+                    RTFileClose(pFile);
+
+                    if (RT_FAILURE(vrc))
+                    {
+                        if (vrc == VERR_EOF)
+                            vrc = VINF_SUCCESS;
+                        else
                             throw setError(VBOX_E_FILE_ERROR,
-                                           tr("Could not create or open file '%s' (%Rrc)"),
-                                           strTargetFilePath.c_str(), vrc);
-
-                        vrc = RTFileOpen(&pFile,
-                                         strSrcFilePath.c_str(),
-                                         RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE);
-
-                        if (RT_FAILURE(vrc) || pFile == NULL)
-                        {
-                            pIfIo->pfnClose(pvUser, pvStorage);
-                            throw setError(VBOX_E_FILE_ERROR,
-                                           tr("Could not create or open file '%s' (%Rrc)"),
+                                           tr("Error during copy CD/DVD image '%s' (%Rrc)"),
                                            strSrcFilePath.c_str(), vrc);
-                        }
-
-                        uint64_t cbFile = 0;
-                        vrc = RTFileGetSize(pFile, &cbFile);
-                        if (RT_SUCCESS(vrc))
-                        {
-                            size_t const cbTmpSize = _1M;
-                            void *pvTmpBuf = RTMemAlloc(cbTmpSize);
-                            if (pvTmpBuf)
-                            {
-                                /* The copy loop. */
-                                uint64_t offDstFile = 0;
-                                for (;;)
-                                {
-                                    size_t cbChunk = 0;
-                                    vrc = RTFileRead(pFile, pvTmpBuf, cbTmpSize, &cbChunk);
-                                    if (RT_FAILURE(vrc) || cbChunk == 0)
-                                        break;
-
-                                    size_t cbWritten = 0;
-                                    vrc = pIfIo->pfnWriteSync(pvUser,
-                                                              pvStorage,
-                                                              offDstFile,
-                                                              pvTmpBuf,
-                                                              cbChunk,
-                                                              &cbWritten);
-                                    if (RT_FAILURE(vrc))
-                                        break;
-                                    Assert(cbWritten == cbChunk);
-
-                                    offDstFile += cbWritten;
-                                }
-
-                                RTMemFree(pvTmpBuf);
-                            }
-                            else
-                                vrc = VERR_NO_MEMORY;
-                        }
-
-                        pIfIo->pfnClose(pvUser, pvStorage);
-                        RTFileClose(pFile);
-
-                        if (RT_FAILURE(vrc))
-                        {
-                            if (vrc == VERR_EOF)
-                                vrc = VINF_SUCCESS;
-                            else
-                                throw setError(VBOX_E_FILE_ERROR,
-                                               tr("Error during copy CD/DVD image '%s' (%Rrc)"),
-                                               strSrcFilePath.c_str(), vrc);
-                        }
                     }
+#endif
                 }
             }
@@ -2387 +2471 @@
             // in the meantime)
             writeLock.acquire();
+#ifndef VBOX_WITH_NEW_TAR_CREATOR
             fileList.push_back(STRPAIR(strTargetFilePath, pStorage->strDigest));
+#endif
         }
 
@@ -2398 +2484 @@
                                                m->ulWeightForManifestOperation);     // operation's weight, as set up
                                                                                      // with the IProgress originally);
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+            /* Create a memory I/O stream and write the manifest to it. */
+            RTVFSIOSTREAM hVfsIosManifest;
+            vrc = RTVfsMemIoStrmCreate(NIL_RTVFSIOSTREAM, _1K, &hVfsIosManifest);
+            if (RT_FAILURE(vrc))
+                throw setErrorVrc(vrc, tr("RTVfsMemIoStrmCreate failed (%Rrc)"), vrc);
+            if (m->hOurManifest != NIL_RTMANIFEST) /* In case it's empty. */
+                vrc = RTManifestWriteStandard(m->hOurManifest, hVfsIosManifest);
+            if (RT_SUCCESS(vrc))
+            {
+                /* Rewind the stream and add it to the output. */
+                size_t cbIgnored;
+                vrc = RTVfsIoStrmReadAt(hVfsIosManifest, 0 /*offset*/, &cbIgnored, 0, true /*fBlocking*/, &cbIgnored);
+                if (RT_SUCCESS(vrc))
+                {
+                    RTVFSOBJ hVfsObjManifest = RTVfsObjFromIoStream(hVfsIosManifest);
+                    vrc = RTVfsFsStrmAdd(hVfsFssDst, strMfFilePath.c_str(), hVfsObjManifest, 0 /*fFlags*/);
+                    if (RT_SUCCESS(vrc))
+                        rc = S_OK;
+                    else
+                        rc = setErrorVrc(vrc, tr("RTVfsFsStrmAdd failed for the manifest (%Rrc)"), vrc);
+                }
+                else
+                    rc = setErrorVrc(vrc, tr("RTManifestWriteStandard failed (%Rrc)"), vrc);
+            }
+            else
+                rc = setErrorVrc(vrc, tr("RTManifestWriteStandard failed (%Rrc)"), vrc);
+            RTVfsIoStrmRelease(hVfsIosManifest);
+            if (FAILED(rc))
+                throw rc;
+#else
             PRTMANIFESTTEST paManifestFiles = (PRTMANIFESTTEST)RTMemAlloc(sizeof(RTMANIFESTTEST) * fileList.size());
             size_t i = 0;
@@ -2420 +2537 @@
             pStorage->fCreateDigest = false;
             /* Write the manifest file to disk. */
-            if (hVfsFssOut != NIL_RTVFSFSSTREAM)
-                vrc = writeBufferToFile(strMfFilePath.c_str(), pvBuf, cbSize, hVfsFssOut);
-            else
-                vrc = writeBufferToFile(strMfFilePath.c_str(), pvBuf, cbSize, pIfIo, pStorage);
+            vrc = writeBufferToFile(strMfFilePath.c_str(), pvBuf, cbSize, pIfIo, pStorage);
             RTMemFree(pvBuf);
             if (RT_FAILURE(vrc))
@@ -2429 +2543 @@
                                tr("Could not create manifest file '%s' (%Rrc)"),
                                strMfFilePath.c_str(), vrc);
+#endif
         }
     }
@@ -2441 +2556 @@
     }
 
+#ifndef VBOX_WITH_NEW_TAR_CREATOR /* done in caller now */
     /* Cleanup on error */
     if (FAILED(rc))
@@ -2450 +2566 @@
              pIfIo->pfnDelete(pStorage, (*it).first.c_str());
     }
+#endif
 
     LogFlowFunc(("rc=%Rhrc\n", rc));
@@ -2457 +2574 @@
 }
 
+
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+/**
+ * Writes a memory buffer to a file in the output file system stream.
+ *
+ * @returns COM status code.
+ * @param   hVfsFssDst      The file system stream to add the file to.
+ * @param   pszFilename     The file name (w/ path if desired).
+ * @param   pvContent       Pointer to buffer containing the file content.
+ * @param   cbContent       Size of the content.
+ */
+HRESULT Appliance::i_writeBufferToFile(RTVFSFSSTREAM hVfsFssDst, const char *pszFilename, const void *pvContent, size_t cbContent)
+{
+    /*
+     * Create a VFS file around the memory, converting it to a base VFS object handle.
+     */
+    HRESULT hrc;
+    RTVFSIOSTREAM hVfsIosSrc;
+    int vrc = RTVfsIoStrmFromBuffer(RTFILE_O_READ, pvContent, cbContent, &hVfsIosSrc);
+    if (RT_SUCCESS(vrc))
+    {
+        hVfsIosSrc = i_manifestSetupDigestCalculationForGivenIoStream(hVfsIosSrc, pszFilename);
+        AssertReturn(hVfsIosSrc != NIL_RTVFSIOSTREAM,
+                     setErrorVrc(vrc, "i_manifestSetupDigestCalculationForGivenIoStream"));
+
+        RTVFSOBJ hVfsObj = RTVfsObjFromIoStream(hVfsIosSrc);
+        RTVfsIoStrmRelease(hVfsIosSrc);
+        AssertReturn(hVfsObj != NIL_RTVFSOBJ, E_FAIL);
+
+        /*
+         * Add it to the stream.
+         */
+        vrc = RTVfsFsStrmAdd(hVfsFssDst, pszFilename, hVfsObj, 0);
+        RTVfsObjRelease(hVfsObj);
+        if (RT_SUCCESS(vrc))
+            hrc = S_OK;
+        else
+            hrc = setErrorVrc(vrc, tr("RTVfsFsStrmAdd failed for '%s' (%Rrc)"), pszFilename, vrc);
+    }
+    else
+        hrc = setErrorVrc(vrc, "RTVfsIoStrmFromBuffer");
+    return hrc;
+}
+#endif
+

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

@@ -1230 +1230 @@
 
 
-/**
- * Writes a memory buffer to a file in the output file system stream.
- *
- * @returns IPRT status code.
- * @param   pszFilename     The file name (w/ path if desired).
- * @param   pvContent       Pointer to buffer containing the file content.
- * @param   cbContent       Size of the content.
- * @param   hVfsFss         The file system stream to add the file to.
- */
-int writeBufferToFile(const char *pszFilename, const void *pvContent, size_t cbContent, RTVFSFSSTREAM hVfsFss)
-{
-    /*
-     * Create a VFS file around the memory, converting it to a base VFS object handle.
-     */
-    RTVFSFILE hVfsFile;
-    int rc = RTVfsFileFromBuffer(RTFILE_O_READ, pvContent, cbContent, &hVfsFile);
-    if (RT_SUCCESS(rc))
-    {
-        RTVFSOBJ hVfsObj = RTVfsObjFromFile(hVfsFile);
-        RTVfsFileRelease(hVfsFile);
-        AssertReturn(hVfsObj != NIL_RTVFSOBJ, VERR_INTERNAL_ERROR_2);
-
-        /*
-         * Add it to the stream.
-         */
-        rc = RTVfsFsStrmAdd(hVfsFss, pszFilename, hVfsObj, 0);
-        RTVfsObjRelease(hVfsObj);
-    }
-
-    return rc;
-}
-
+#ifndef VBOX_WITH_NEW_TAR_CREATOR
 int writeBufferToFile(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pIfIo, void *pvUser)
 {
@@ -1293 +1262 @@
     return rc;
 }
-
+#endif /* !VBOX_WITH_NEW_TAR_CREATOR */
+

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

@@ -856 +856 @@
 
 /**
- * Setup automatic I/O stream digest calculation, adding it to hOurManifest.
- *
- * @returns Passthru I/O stream, of @a hVfsIos if no digest calc needed.
- * @param   hVfsIos             The stream to wrap. Always consumed.
- * @param   pszManifestEntry    The manifest entry.
- * @throws  Nothing.
- */
-RTVFSIOSTREAM Appliance::i_importSetupDigestCalculationForGivenIoStream(RTVFSIOSTREAM hVfsIos, const char *pszManifestEntry)
-{
-    int vrc;
-    Assert(!RTManifestPtIosIsInstanceOf(hVfsIos));
-
-    if (m->fDigestTypes == 0)
-        return hVfsIos;
-
-    /* Create the manifest if necessary. */
-    if (m->hOurManifest == NIL_RTMANIFEST)
-    {
-        vrc = RTManifestCreate(0 /*fFlags*/, &m->hOurManifest);
-        AssertRCReturnStmt(vrc, RTVfsIoStrmRelease(hVfsIos), NIL_RTVFSIOSTREAM);
-    }
-
-    /* Setup the stream. */
-    RTVFSIOSTREAM hVfsIosPt;
-    vrc = RTManifestEntryAddPassthruIoStream(m->hOurManifest, hVfsIos, pszManifestEntry, m->fDigestTypes,
-                                             true /*fReadOrWrite*/, &hVfsIosPt);
-
-    RTVfsIoStrmRelease(hVfsIos);        /* always consumed! */
-    if (RT_SUCCESS(vrc))
-        return hVfsIosPt;
-
-    setErrorVrc(vrc, "RTManifestEntryAddPassthruIoStream failed with rc=%Rrc", vrc);
-    return NIL_RTVFSIOSTREAM;
-}
-
-/**
  * Opens a source file (for reading obviously).
  *
@@ -934 +898 @@
      * Digest calculation filtering.
      */
-    hVfsIosSrc = i_importSetupDigestCalculationForGivenIoStream(hVfsIosSrc, pszManifestEntry);
+    hVfsIosSrc = i_manifestSetupDigestCalculationForGivenIoStream(hVfsIosSrc, pszManifestEntry);
     if (hVfsIosSrc == NIL_RTVFSIOSTREAM)
         throw E_FAIL;
@@ -1445 +1409 @@
      * Set up digest calculation.
      */
-    hVfsIosOvf = i_importSetupDigestCalculationForGivenIoStream(hVfsIosOvf, pszManifestEntry);
+    hVfsIosOvf = i_manifestSetupDigestCalculationForGivenIoStream(hVfsIosOvf, pszManifestEntry);
     if (hVfsIosOvf == NIL_RTVFSIOSTREAM)
         return VBOX_E_FILE_ERROR;
@@ -1543 +1507 @@
     m->fDeterminedDigestTypes = true;
 
+#ifndef VBOX_WITH_NEW_TAR_CREATOR
     m->fSha256 = RT_BOOL(m->fDigestTypes & RTMANIFEST_ATTR_SHA256); /** @todo retire this member */
+#endif
     return S_OK;
 }

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

@@ -660 +660 @@
                MediumVariant_T aVariant,
                SecretKeyStore *pSecretKeyStore,
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+               RTVFSIOSTREAM aVfsIosDst,
+#else
                VDINTERFACEIO *aVDImageIOIf,
                void *aVDImageIOUser,
+#endif
                MediumLockList *aSourceMediumLockList,
                bool fKeepSourceMediumLockList = false)
@@ -675 +679 @@
 
         mVDImageIfaces = aMedium->m->vdImageIfaces;
+
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+        int vrc = VDIfCreateFromVfsStream(aVfsIosDst, RTFILE_O_WRITE, &mpVfsIoIf);
+        AssertRCReturnVoidStmt(vrc, mRC = E_FAIL);
+
+        vrc = VDInterfaceAdd(&mpVfsIoIf->Core, "Medium::ExportTaskVfsIos",
+                             VDINTERFACETYPE_IO, mpVfsIoIf,
+                             sizeof(VDINTERFACEIO), &mVDImageIfaces);
+        AssertRCReturnVoidStmt(vrc, mRC = E_FAIL);
+#else
+
         if (aVDImageIOIf)
         {
@@ -682 +697 @@
             AssertRCReturnVoidStmt(vrc, mRC = E_FAIL);
         }
+#endif
         m_strTaskName = "createExport";
     }
@@ -689 +705 @@
         if (!mfKeepSourceMediumLockList && mpSourceMediumLockList)
             delete mpSourceMediumLockList;
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+        if (mpVfsIoIf)
+        {
+            VDIfDestroyFromVfsStream(mpVfsIoIf);
+            mpVfsIoIf = NULL;
+        }
+#endif
     }
 
@@ -696 +719 @@
     MediumVariant_T mVariant;
     PVDINTERFACE mVDImageIfaces;
+    PVDINTERFACEIO mpVfsIoIf; /**< Pointer to the VFS I/O stream to VD I/O interface wrapper. */
     SecretKeyStore *m_pSecretKeyStore;
 
@@ -6096 +6120 @@
                              MediumVariant_T aVariant,
                              SecretKeyStore *pKeyStore,
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+                             RTVFSIOSTREAM hVfsIosDst,
+#else
                              PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
+#endif
                              const ComObjPtr<Progress> &aProgress)
 {
@@ -6136 +6164 @@
 
         /* setup task object to carry out the operation asynchronously */
-        pTask = new Medium::ExportTask(this, aProgress, aFilename, aFormat,
-                                       aVariant, pKeyStore, aVDImageIOIf,
-                                       aVDImageIOUser, pSourceMediumLockList);
+        pTask = new Medium::ExportTask(this, aProgress, aFilename, aFormat, aVariant,
+#ifdef VBOX_WITH_NEW_TAR_CREATOR
+                                       pKeyStore, hVfsIosDst, pSourceMediumLockList);
+#else
+                                       pKeyStore, aVDImageIOIf, aVDImageIOUser, pSourceMediumLockList);
+#endif
         rc = pTask->rc();
         AssertComRC(rc);