Changeset 20044 in vbox for trunk

Timestamp:

May 26, 2009 3:38:55 PM (16 years ago)

Author:

vboxsync

Message:

Main-S3: initial code for the export of OVF's to an S3 server

Location:

trunk/src/VBox/Main

Files:

• ApplianceImpl.cpp (modified) (28 diffs)
• Makefile.kmk (modified) (1 diff)
• VFSExplorerImpl.cpp (added)
• idl/VirtualBox.xidl (modified) (3 diffs)
• include/ApplianceImpl.h (modified) (2 diffs)
• include/VFSExplorerImpl.h (added)
• xpcom/server.cpp (modified) (2 diffs)

trunk/src/VBox/Main/ApplianceImpl.cpp

@@ -21 +21 @@
  */
 
-#include <VBox/param.h>
 #include <iprt/stream.h>
 #include <iprt/path.h>
 #include <iprt/dir.h>
 #include <iprt/file.h>
+#include <iprt/s3.h>
+
+#include <VBox/param.h>
+#include <VBox/version.h>
 
 #include "ApplianceImpl.h"
+#include "VFSExplorerImpl.h"
 #include "VirtualBoxImpl.h"
 #include "GuestOSTypeImpl.h"
@@ -460 +464 @@
  * @return
  */
-
 HRESULT Appliance::init(VirtualBox *aVirtualBox)
 {
@@ -2501 +2504 @@
 struct Appliance::TaskWriteOVF
 {
-    TaskWriteOVF(Appliance *aThat, Progress *aProgress)
-        : pAppliance(aThat),
-          enFormat(unspecified),
-          progress(aProgress),
+    enum OVFFormat
+    {
+        unspecified,
+        OVF_0_9,
+        OVF_1_0
+    };
+    enum TaskType
+    {
+        Write
+    };
+
+    TaskWriteOVF(OVFFormat aFormat, Appliance *aThat)
+        : taskType(Write),
+          storageType(VFSType_File),
+          enFormat(aFormat),
+          pAppliance(aThat),
           rc(S_OK)
     {}
     ~TaskWriteOVF() {}
 
-    HRESULT startThread();
-
+    int startThread();
+    static int uploadProgress(unsigned uPercent, void *pvUser);
+
+    TaskType taskType;
+    VFSType_T storageType;
+    Utf8Str filepath;
+    Utf8Str hostname;
+    Utf8Str username;
+    Utf8Str password;
+    OVFFormat enFormat;
     Appliance *pAppliance;
-    enum { unspecified, OVF_0_9, OVF_1_0 }
-        enFormat;
-
     ComObjPtr<Progress> progress;
     HRESULT rc;
 };
 
-HRESULT Appliance::TaskWriteOVF::startThread()
+int Appliance::TaskWriteOVF::startThread()
 {
     int vrc = RTThreadCreate(NULL, Appliance::taskThreadWriteOVF, this,
                              0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
                              "Appliance::Task");
+
     ComAssertMsgRCRet(vrc,
-                      ("Could not create taskThreadExportOVF (%Rrc)\n", vrc), E_FAIL);
-
-    return S_OK;
+                      ("Could not create taskThreadWriteOVF (%Rrc)\n", vrc), E_FAIL);
+
+    return vrc;
 }
 
+/* static */
+int Appliance::TaskWriteOVF::uploadProgress(unsigned uPercent, void *pvUser)
+{
+    Appliance::TaskWriteOVF* pTask = *(Appliance::TaskWriteOVF**)pvUser;
+
+    if (pTask &&
+        !pTask->progress.isNull())
+    {
+        BOOL fCanceled;
+        pTask->progress->COMGETTER(Canceled)(&fCanceled);
+        if (fCanceled)
+            return -1;
+        pTask->progress->setCurrentOperationProgress(uPercent);
+    }
+    RTPrintf ("%u%%\n", uPercent);
+    return VINF_SUCCESS;
+}
+
+STDMETHODIMP Appliance::CreateVFSExplorer(IN_BSTR aURI, IVFSExplorer **aExplorer)
+{
+    HRESULT rc = S_OK;
+
+    CheckComArgOutPointerValid(aExplorer);
+
+    AutoCaller autoCaller(this);
+    CheckComRCReturnRC(autoCaller.rc());
+
+    AutoReadLock(this);
+
+    Utf8Str uri(aURI);
+    /* Check which kind of export the user has requested */
+    VFSType_T type = VFSType_File;
+    Utf8Str strProtocol = "";
+    /* Check the URI for the target format */
+    if (uri.startsWith("SunCloud://", Utf8Str::CaseInsensitive)) /* Sun Cloud service */
+    {
+        type = VFSType_S3;
+        strProtocol = "SunCloud://";
+    }
+    else if (uri.startsWith("S3://", Utf8Str::CaseInsensitive)) /* S3 service */
+    {
+        type = VFSType_S3;
+        strProtocol = "S3://";
+    }
+    else if (uri.startsWith("webdav://", Utf8Str::CaseInsensitive)) /* webdav service */
+        throw E_NOTIMPL;
+
+    Utf8Str strFilepath;
+    Utf8Str strHostname;
+    Utf8Str strUsername;
+    Utf8Str strPassword;
+    parseURI(uri, strProtocol, strFilepath, strHostname, strUsername, strPassword);
+
+    ComObjPtr<VFSExplorer> explorer;
+    explorer.createObject();
+
+    rc = explorer->init(type, strFilepath, strHostname, strUsername, strPassword, mVirtualBox);
+
+    if (SUCCEEDED(rc))
+        /* Return explorer to the caller */
+        explorer.queryInterfaceTo(aExplorer);
+
+    return rc;
+}
+
 STDMETHODIMP Appliance::Write(IN_BSTR format, IN_BSTR path, IProgress **aProgress)
 {
@@ -2537 +2623 @@
 
     AutoCaller autoCaller(this);
-    if (FAILED(rc = autoCaller.rc())) return rc;
+    CheckComRCReturnRC(autoCaller.rc());
 
     AutoWriteLock(this);
 
     // see if we can handle this file; for now we insist it has an ".ovf" extension
-    m->strPath = path;
-    if (!m->strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
+    Utf8Str strPath = path;
+    if (!strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
         return setError(VBOX_E_FILE_ERROR,
                         tr("Appliance file must have .ovf extension"));
 
     ComObjPtr<Progress> progress;
-    try
-    {
-        Bstr progressDesc = BstrFmt(tr("Export appliance '%s'"),
-                                    m->strPath.raw());
-        rc = setUpProgress(progress, progressDesc);
-        if (FAILED(rc)) throw rc;
-
-        /* Initialize our worker task */
-        std::auto_ptr<TaskWriteOVF> task(new TaskWriteOVF(this, progress));
-        //AssertComRCThrowRC (task->autoCaller.rc());
-
-        Utf8Str strFormat(format);
-        if (strFormat == "ovf-0.9")
-            task->enFormat = TaskWriteOVF::OVF_0_9;
-        else if (strFormat == "ovf-1.0")
-            task->enFormat = TaskWriteOVF::OVF_1_0;
-        else
-            return setError(VBOX_E_FILE_ERROR,
-                            tr("Invalid format \"%s\" specified"), strFormat.c_str());
-
-        rc = task->startThread();
-        CheckComRCThrowRC(rc);
-
-        task.release();
-    }
-    catch (HRESULT aRC)
-    {
-        rc = aRC;
-    }
+    Utf8Str strFormat(format);
+    TaskWriteOVF::OVFFormat ovfF;
+    if (strFormat == "ovf-0.9")
+        ovfF = TaskWriteOVF::OVF_0_9;
+    else if (strFormat == "ovf-1.0")
+        ovfF = TaskWriteOVF::OVF_1_0;
+    else
+        return setError(VBOX_E_FILE_ERROR,
+                        tr("Invalid format \"%s\" specified"), strFormat.c_str());
+
+    rc = writeImpl(ovfF, strPath, progress);
 
     if (SUCCEEDED(rc))
@@ -2583 +2651 @@
 
     return rc;
+}
+
+void Appliance::parseURI(Utf8Str strUri, const Utf8Str &strProtocol, Utf8Str &strFilepath, Utf8Str &strHostname, Utf8Str &strUsername, Utf8Str &strPassword)
+{
+    /* Remove the protocol */
+    if (strUri.startsWith(strProtocol, Utf8Str::CaseInsensitive))
+        strUri = strUri.substr(strProtocol.length());
+    size_t uppos = strUri.find("@");
+    if (uppos != Utf8Str::npos)
+    {
+        strUsername = strUri.substr(0, uppos);
+        strUri = strUri.substr(uppos + 1);
+        size_t upos = strUsername.find(":");
+        if (upos != Utf8Str::npos)
+        {
+            strPassword = strUsername.substr(upos + 1);
+            strUsername = strUsername.substr(0, upos);
+        }
+    }
+    size_t hpos = strUri.find("/");
+    if (hpos != Utf8Str::npos)
+    {
+        strHostname = strUri.substr(0, hpos);
+        strUri = strUri.substr(hpos);
+    }
+    strFilepath = strUri;
+    RTPrintf("%s - %s - %s - %s\n", strUsername.c_str(), strPassword.c_str(), strHostname.c_str(), strFilepath.c_str());
+}
+
+HRESULT Appliance::writeImpl(int aFormat, Utf8Str aPath, ComObjPtr<Progress> &aProgress)
+{
+    HRESULT rc = S_OK;
+    try
+    {
+        m->strPath = aPath;
+
+        /* Initialize our worker task */
+        std::auto_ptr<TaskWriteOVF> task(new TaskWriteOVF((TaskWriteOVF::OVFFormat)aFormat, this));
+
+        /* Check which kind of export the user has requested */
+        Utf8Str strProtocol = "";
+        /* Check the URI for the target format */
+        if (m->strPath.startsWith("SunCloud://", Utf8Str::CaseInsensitive)) /* Sun Cloud service */
+        {
+            task->storageType = VFSType_S3;
+            strProtocol = "SunCloud://";
+        }
+        else if (m->strPath.startsWith("S3://", Utf8Str::CaseInsensitive)) /* S3 service */
+        {
+            task->storageType = VFSType_S3;
+            strProtocol = "S3://";
+        }
+        else if (m->strPath.startsWith("webdav://", Utf8Str::CaseInsensitive)) /* webdav service */
+            throw E_NOTIMPL;
+
+        parseURI(m->strPath, strProtocol, task->filepath, task->hostname, task->username, task->password);
+        Bstr progressDesc = BstrFmt(tr("Export appliance '%s'"),
+                                    task->filepath.c_str());
+
+        /* todo: This progress init stuff should be done a little bit more generic */
+        if (task->storageType == VFSType_S3)
+            rc = setUpProgressUpload(aProgress, progressDesc);
+        else
+            rc = setUpProgress(aProgress, progressDesc);
+        if (FAILED(rc)) throw rc;
+
+        task->progress = aProgress;
+
+        rc = task->startThread();
+        CheckComRCThrowRC(rc);
+
+        task.release();
+    }
+    catch (HRESULT aRC)
+    {
+        rc = aRC;
+    }
+
+    return rc;
+}
+
+DECLCALLBACK(int) Appliance::taskThreadWriteOVF(RTTHREAD /* aThread */, void *pvUser)
+{
+    std::auto_ptr<TaskWriteOVF> task(static_cast<TaskWriteOVF*>(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 TaskWriteOVF::Write:
+        {
+            if (task->storageType == VFSType_File)
+                rc = pAppliance->writeFS(task.get());
+            else if (task->storageType == VFSType_S3)
+                rc = pAppliance->writeS3(task.get());
+            break;
+        }
+    }
+
+    task->rc = rc;
+
+    LogFlowFunc(("rc=%Rhrc\n", rc));
+    LogFlowFuncLeave();
+
+    return VINF_SUCCESS;
 }
 
@@ -2591 +2770 @@
  */
 /* static */
-DECLCALLBACK(int) Appliance::taskThreadWriteOVF(RTTHREAD /* aThread */, void *pvUser)
-{
-    std::auto_ptr<TaskWriteOVF> task(static_cast<TaskWriteOVF*>(pvUser));
-    AssertReturn(task.get(), VERR_GENERAL_FAILURE);
-
-    Appliance *pAppliance = task->pAppliance;
-
+int Appliance::writeFS(TaskWriteOVF *pTask)
+{
     LogFlowFuncEnter();
-    LogFlowFunc(("Appliance %p\n", pAppliance));
-
-    AutoCaller autoCaller(pAppliance);
+    LogFlowFunc(("Appliance %p\n", this));
+
+    AutoCaller autoCaller(this);
     CheckComRCReturnRC(autoCaller.rc());
 
-    AutoWriteLock appLock(pAppliance);
+    AutoWriteLock appLock(this);
 
     HRESULT rc = S_OK;
-
-    ComPtr<IVirtualBox> pVirtualBox(pAppliance->mVirtualBox);
 
     try
@@ -2615 +2787 @@
         xml::ElementNode *pelmRoot = doc.createRootElement("Envelope");
 
-        pelmRoot->setAttribute("ovf:version", (task->enFormat == TaskWriteOVF::OVF_1_0) ? "1.0" : "0.9");
+        pelmRoot->setAttribute("ovf:version", (pTask->enFormat == TaskWriteOVF::OVF_1_0) ? "1.0" : "0.9");
         pelmRoot->setAttribute("xml:lang", "en-US");
 
@@ -2624 +2796 @@
         pelmRoot->setAttribute("xmlns:ovf", strNamespace);
 
-//         pelmRoot->setAttribute("xmlns:ovfstr", "http://schema.dmtf.org/ovf/strings/1");
+         pelmRoot->setAttribute("xmlns:ovfstr", "http://schema.dmtf.org/ovf/strings/1");
         pelmRoot->setAttribute("xmlns:rasd", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData");
         pelmRoot->setAttribute("xmlns:vssd", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData");
         pelmRoot->setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
-//         pelmRoot->setAttribute("xsi:schemaLocation", "http://schemas.dmtf.org/ovf/envelope/1 ../ovf-envelope.xsd");
+         pelmRoot->setAttribute("xsi:schemaLocation", "http://schemas.dmtf.org/ovf/envelope/1 ../ovf-envelope.xsd");
 
         // <Envelope>/<References>
@@ -2639 +2811 @@
             </DiskSection> */
         xml::ElementNode *pelmDiskSection;
-        if (task->enFormat == TaskWriteOVF::OVF_0_9)
+        if (pTask->enFormat == TaskWriteOVF::OVF_0_9)
         {
             // <Section xsi:type="ovf:DiskSection_Type">
@@ -2662 +2834 @@
             </NetworkSection> */
         xml::ElementNode *pelmNetworkSection;
-        if (task->enFormat == TaskWriteOVF::OVF_0_9)
+        if (pTask->enFormat == TaskWriteOVF::OVF_0_9)
         {
             // <Section xsi:type="ovf:NetworkSection_Type">
@@ -2684 +2856 @@
         // one machine, it seems
         xml::ElementNode *pelmToAddVirtualSystemsTo;
-        if (pAppliance->m->virtualSystemDescriptions.size() > 1)
+        if (m->virtualSystemDescriptions.size() > 1)
         {
-            if (task->enFormat == TaskWriteOVF::OVF_0_9)
+            if (pTask->enFormat == TaskWriteOVF::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"));
@@ -2698 +2870 @@
         list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
         /* Iterate through all virtual systems of that appliance */
-        for (it = pAppliance->m->virtualSystemDescriptions.begin();
-             it != pAppliance->m->virtualSystemDescriptions.end();
+        for (it = m->virtualSystemDescriptions.begin();
+             it != m->virtualSystemDescriptions.end();
              ++it)
         {
@@ -2705 +2877 @@
 
             xml::ElementNode *pelmVirtualSystem;
-            if (task->enFormat == TaskWriteOVF::OVF_0_9)
+            if (pTask->enFormat == TaskWriteOVF::OVF_0_9)
             {
                 // <Section xsi:type="ovf:NetworkSection_Type">
@@ -2749 +2921 @@
                 </Section> */
                 xml::ElementNode *pelmAnnotationSection;
-                if (task->enFormat == TaskWriteOVF::OVF_0_9)
+                if (pTask->enFormat == TaskWriteOVF::OVF_0_9)
                 {
                     // <Section ovf:required="false" xsi:type="ovf:ProductSection_Type">
@@ -2781 +2953 @@
                     </Section> */
                 xml::ElementNode *pelmAnnotationSection;
-                if (task->enFormat == TaskWriteOVF::OVF_0_9)
+                if (pTask->enFormat == TaskWriteOVF::OVF_0_9)
                 {
                     // <Section ovf:required="false" xsi:type="ovf:AnnotationSection_Type">
@@ -2804 +2976 @@
                    </EulaSection> */
                 xml::ElementNode *pelmEulaSection;
-                if (task->enFormat == TaskWriteOVF::OVF_0_9)
+                if (pTask->enFormat == TaskWriteOVF::OVF_0_9)
                 {
                     pelmEulaSection = pelmVirtualSystem->createChild("Section");
@@ -2826 +2998 @@
                 </OperatingSystemSection> */
             xml::ElementNode *pelmOperatingSystemSection;
-            if (task->enFormat == TaskWriteOVF::OVF_0_9)
+            if (pTask->enFormat == TaskWriteOVF::OVF_0_9)
             {
                 pelmOperatingSystemSection = pelmVirtualSystem->createChild("Section");
@@ -2842 +3014 @@
             // <VirtualHardwareSection ovf:id="hw1" ovf:transport="iso">
             xml::ElementNode *pelmVirtualHardwareSection;
-            if (task->enFormat == TaskWriteOVF::OVF_0_9)
+            if (pTask->enFormat == TaskWriteOVF::OVF_0_9)
             {
                 // <Section xsi:type="ovf:VirtualHardwareSection_Type">
@@ -2868 +3040 @@
             // <vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
             const char *pcszHardware = "virtualbox-2.2";
-            if (task->enFormat == TaskWriteOVF::OVF_0_9)
+            if (pTask->enFormat == TaskWriteOVF::OVF_0_9)
                 // pretend to be vmware compatible then
                 pcszHardware = "vmx-6";
@@ -3226 +3398 @@
                         // <rasd:InstanceID>1</rasd:InstanceID>
                         xml::ElementNode *pelmInstanceID;
-                        if (task->enFormat == TaskWriteOVF::OVF_0_9)
+                        if (pTask->enFormat == TaskWriteOVF::OVF_0_9)
                             pelmInstanceID = pItem->createChild("rasd:InstanceId");
                         else
@@ -3302 +3474 @@
             const Utf8Str &strTargetFileNameOnly = pDiskEntry->strOvf;
             // target path needs to be composed from where the output OVF is
-            Utf8Str strTargetFilePath = stripFilename(pAppliance->m->strPath);
+            Utf8Str strTargetFilePath = stripFilename(m->strPath);
             strTargetFilePath.append("/");
             strTargetFilePath.append(strTargetFileNameOnly);
@@ -3312 +3484 @@
 
             Log(("Finding source disk \"%ls\"\n", bstrSrcFilePath.raw()));
-            rc = pVirtualBox->FindHardDisk(bstrSrcFilePath, pSourceDisk.asOutParam());
+            rc = mVirtualBox->FindHardDisk(bstrSrcFilePath, pSourceDisk.asOutParam());
             if (FAILED(rc)) throw rc;
 
@@ -3320 +3492 @@
             // create a new hard disk interface for the destination disk image
             Log(("Creating target disk \"%s\"\n", strTargetFilePath.raw()));
-            rc = pVirtualBox->CreateHardDisk(bstrSrcFormat, Bstr(strTargetFilePath), pTargetDisk.asOutParam());
+            rc = mVirtualBox->CreateHardDisk(bstrSrcFormat, Bstr(strTargetFilePath), pTargetDisk.asOutParam());
             if (FAILED(rc)) throw rc;
 
@@ -3332 +3504 @@
 
                 // advance to the next operation
-                if (!task->progress.isNull())
-                    task->progress->setNextOperation(BstrFmt(tr("Exporting virtual disk image '%s'"), strSrcFilePath.c_str()),
+                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);
 
                 // now wait for the background disk operation to complete; this throws HRESULTs on error
-                pAppliance->waitForAsyncProgress(task->progress, pProgress2);
+                waitForAsyncProgress(pTask->progress, pProgress2);
             }
             catch (HRESULT rc3)
@@ -3344 +3516 @@
                 // it'll stick in the registry forever
                 pTargetDisk->Close();
-                throw rc3;
+                throw;
             }
 
@@ -3381 +3553 @@
         // now go write the XML
         xml::XmlFileWriter writer(doc);
-        writer.write(pAppliance->m->strPath.c_str());
+        writer.write(m->strPath.c_str());
     }
     catch(xml::Error &x)
@@ -3393 +3565 @@
     }
 
-    task->rc = rc;
-
-    if (!task->progress.isNull())
-        task->progress->notifyComplete(rc);
+    pTask->rc = rc;
+
+    if (!pTask->progress.isNull())
+        pTask->progress->notifyComplete(rc);
+
+    LogFlowFunc(("rc=%Rhrc\n", rc));
+    LogFlowFuncLeave();
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Worker thread implementation for Upload() (ovf uploader).
+ * @param aThread
+ * @param pvUser
+ */
+/* static */
+int Appliance::writeS3(TaskWriteOVF *pTask)
+{
+    LogFlowFuncEnter();
+    LogFlowFunc(("Appliance %p\n", this));
+
+    AutoCaller autoCaller(this);
+    CheckComRCReturnRC(autoCaller.rc());
+
+    HRESULT rc = S_OK;
+
+    AutoWriteLock appLock(this);
+
+    /* Buckets are S3 specific. So parse the bucket out of the file path */
+    Utf8Str tmpPath = pTask->filepath;
+    if (!tmpPath.startsWith("/"))
+        return setError(E_INVALIDARG,
+                        tr("The path '%s' must start with /"), tmpPath.c_str());
+    Utf8Str bucket;
+    size_t bpos = tmpPath.find("/", 1);
+    if (bpos != Utf8Str::npos)
+    {
+        bucket = tmpPath.substr(1, bpos - 1); /* The bucket without any slashes */
+        tmpPath = tmpPath.substr(bpos); /* The rest of the file path */
+    }
+    /* If there is no bucket name provided reject the upload */
+    if (bucket.isEmpty())
+        return setError(E_INVALIDARG,
+                        tr("You doesn't provide a bucket name in the URI"), tmpPath.c_str());
+
+    int vrc = VINF_SUCCESS;
+    RTS3 hS3 = NULL;
+    char szOSTmpDir[RTPATH_MAX];
+    RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
+    /* The template for the temporary directory created below */
+    char *pszTmpDir;
+    RTStrAPrintf(&pszTmpDir, "%s/vbox-ovf-XXXXXX", szOSTmpDir);
+    list< pair<Utf8Str, ULONG> > filesList;
+
+    // todo:
+    // - getting the tmp directory (especially on win)
+    // - usable error codes
+    // - seems snapshot filenames are problematic {uuid}.vdi
+    try
+    {
+        /* We need a temporary directory which we can put the OVF file & all
+         * disk images in */
+        if (!mkdtemp(pszTmpDir))
+            throw setError(VBOX_E_FILE_ERROR,
+                           tr("Cannot create temporary directory '%s'"), pszTmpDir);
+
+        /* The temporary name of the target OVF file */
+        Utf8StrFmt strTmpOvf("%s/%s", pszTmpDir, RTPathFilename(tmpPath));
+
+        /* Prepare the temporary writing of the OVF */
+        ComObjPtr<Progress> progress;
+        rc = writeImpl(pTask->enFormat, strTmpOvf.c_str(), progress);
+        if (FAILED(rc)) throw rc;
+
+        /* Unlock the appliance for the writing thread */
+        appLock.unlock();
+        /* Wait until the writing is done, but report the progress back to the
+           caller */
+        ComPtr<IProgress> progressInt(progress);
+        waitForAsyncProgress(pTask->progress, progressInt); /* Any errors will be thrown */
+
+        /* Again lock the appliance for the next steps */
+        appLock.lock();
+
+        vrc = RTPathExists(strTmpOvf.c_str()); /* Paranoid check */
+        if(RT_FAILURE(vrc))
+            throw setError(VBOX_E_FILE_ERROR,
+                           tr("Cannot find source file '%s'"), strTmpOvf.c_str());
+        /* Add the OVF file */
+        filesList.push_back(pair<Utf8Str, ULONG>(strTmpOvf, m->ulWeightPerOperation)); /* Use 1% of the total for the OVF 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 = stripFilename(m->strPath);
+                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'"), strTargetFilePath.c_str());
+                filesList.push_back(pair<Utf8Str, ULONG>(strTargetFilePath, (*itH)->ulSizeMB));
+            }
+        }
+        /* Next we have to upload the OVF & all disk images */
+        vrc = RTS3Create(&hS3, pTask->username.c_str(), pTask->password.c_str(), pTask->hostname.c_str(), "virtualbox-agent/"VBOX_VERSION_STRING);
+        if(RT_FAILURE(vrc))
+            throw setError(VBOX_E_IPRT_ERROR,
+                           tr("Cannot create S3 service handler"));
+        RTS3SetProgressCallback(hS3, pTask->uploadProgress, &pTask);
+
+        /* Upload all files */
+        for (list< pair<Utf8Str, ULONG> >::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1)
+        {
+            const pair<Utf8Str, ULONG> &s = (*it1);
+            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);
+            vrc = RTS3PutKey(hS3, bucket.c_str(), pszFilename, s.first.c_str());
+            if (RT_FAILURE(vrc))
+            {
+                if(vrc == VERR_S3_CANCELED)
+                    break;
+                else if(vrc == VERR_S3_ACCESS_DENIED)
+                    throw setError(E_ACCESSDENIED,
+                                   tr("Cannot upload file '%s' to S3 storage server (Access denied)"), pszFilename);
+                else if(vrc == VERR_S3_NOT_FOUND)
+                    throw setError(VBOX_E_FILE_ERROR,
+                                   tr("Cannot upload file '%s' to S3 storage server (File not found)"), pszFilename);
+                else
+                    throw setError(VBOX_E_IPRT_ERROR,
+                                   tr("Cannot upload file '%s' to S3 storage server (%Rrc)"), pszFilename, vrc);
+            }
+        }
+
+    }
+    catch(HRESULT aRC)
+    {
+        rc = aRC;
+    }
+    /* Cleanup */
+    if (hS3)
+        RTS3Destroy(hS3);
+    /* Delete all files which where temporary created */
+    for (list< pair<Utf8Str, ULONG> >::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1)
+    {
+        const pair<Utf8Str, ULONG> &s = (*it1);
+        vrc = RTFileDelete(s.first.c_str());
+        if(RT_FAILURE(vrc))
+            rc = setError(VBOX_E_FILE_ERROR,
+                          tr("Cannot delete file '%s'"), s.first.c_str());
+    }
+    /* 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'"), pszTmpDir);
+    }
+    if (pszTmpDir)
+        RTStrFree(pszTmpDir);
+
+    pTask->rc = rc;
+
+    if (!pTask->progress.isNull())
+        pTask->progress->notifyComplete(rc);
 
     LogFlowFunc(("rc=%Rhrc\n", rc));
@@ -3542 +3891 @@
                          bstrDescription, // CBSTR bstrFirstOperationDescription,
                          m->ulWeightPerOperation); // ULONG ulFirstOperationWeight,
+    return rc;
+}
+
+HRESULT Appliance::setUpProgressUpload(ComObjPtr<Progress> &pProgress, const Bstr &bstrDescription)
+{
+    HRESULT rc;
+
+    /* Create the progress object */
+    pProgress.createObject();
+
+    // weigh the disk images according to their sizes
+    uint32_t ulTotalMB = 0;
+    uint32_t cDisks = 0;
+    list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
+    for (it = m->virtualSystemDescriptions.begin();
+         it != m->virtualSystemDescriptions.end();
+         ++it)
+    {
+        ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
+        /* One for every hard disk of the Virtual System */
+        std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
+        std::list<VirtualSystemDescriptionEntry*>::const_iterator itH;
+        for (itH = avsdeHDs.begin();
+             itH != avsdeHDs.end();
+             ++itH)
+        {
+            const VirtualSystemDescriptionEntry *pHD = *itH;
+            ulTotalMB += pHD->ulSizeMB;
+            ++cDisks;
+        }
+    }
+
+    ULONG cOperations = 1 + 1 + cDisks;     // one op per disk plus 1 for the OVF & 1 plus to the temporary creation */
+
+    ULONG ulTotalOperationsWeight;
+    if (ulTotalMB)
+    {
+        m->ulWeightPerOperation = (ULONG)((double)ulTotalMB * 1  / 100);    // use 1% of the progress for OVF file upload (we didn't know the size at this point)
+        ulTotalOperationsWeight = ulTotalMB + m->ulWeightPerOperation;
+    }
+    else
+    {
+        // no disks to export:
+        ulTotalOperationsWeight = 1;
+        m->ulWeightPerOperation = 1;
+    }
+    ULONG ulOVFCreationWeight = ((double)ulTotalOperationsWeight * 50.0 / 100.0); /* Use 50% for the creation of the OVF & the disks */
+    ulTotalOperationsWeight += ulOVFCreationWeight;
+
+    Log(("Setting up progress object: ulTotalMB = %d, cDisks = %d, => cOperations = %d, ulTotalOperationsWeight = %d, m->ulWeightPerOperation = %d\n",
+         ulTotalMB, cDisks, cOperations, ulTotalOperationsWeight, m->ulWeightPerOperation));
+
+    rc = pProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
+                         bstrDescription,
+                         TRUE /* aCancelable */,
+                         cOperations, // ULONG cOperations,
+                         ulTotalOperationsWeight, // ULONG ulTotalOperationsWeight,
+                         bstrDescription, // CBSTR bstrFirstOperationDescription,
+                         ulOVFCreationWeight); // ULONG ulFirstOperationWeight,
     return rc;
 }

trunk/src/VBox/Main/Makefile.kmk

@@ -285 +285 @@
         VirtualBoxImplExtra.cpp \
         ApplianceImpl.cpp \
+        VFSExplorerImpl.cpp \
         MachineImpl.cpp \
         SnapshotImpl.cpp \

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

@@ -2890 +2890 @@
     </method>
 
+  </interface>
+
+  <!--
+  // IVFSExplorer
+  /////////////////////////////////////////////////////////////////////////
+  -->
+
+  <enum
+    name="VFSType"
+    uuid="813999ba-b949-48a8-9230-aadc6285e2f2"
+  >
+    <desc>
+    </desc>
+
+    <const name="File" value="1" />
+    <const name="Cloud" value="2" />
+    <const name="S3" value="3" />
+    <const name="WebDav" value="4" />
+  </enum>
+
+  <enum
+    name="FileType"
+    uuid="714333cd-44e2-415f-a245-d378fa9b1242"
+  >
+    <desc>
+    </desc>
+
+    <const name="Unknown" value="1" />
+    <const name="Fifo" value="2" />
+    <const name="DevChar" value="3" />
+    <const name="Directory" value="4" />
+    <const name="DevBlock" value="5" />
+    <const name="File" value="6" />
+    <const name="SymLink" value="7" />
+    <const name="Socket" value="8" />
+    <const name="WhiteOut" value="9" />
+  </enum>
+
+  <interface
+     name="IVFSExplorer" extends="$unknown"
+     uuid="fd7da337-80ef-4a5c-9122-918435e33003"
+     wsmap="managed"
+     >
+    <desc />
+
+    <attribute name="path" type="wstring" readonly="yes">
+      <desc />
+    </attribute>
+
+    <attribute name="type" type="VFSType" readonly="yes">
+      <desc />
+    </attribute>
+
+    <method name="update">
+      <desc />
+
+      <param name="aProgress" type="IProgress" dir="return">
+        <desc />
+      </param>
+    </method>
+
+    <method name="entryList">
+      <desc />
+
+      <param name="aNames" type="wstring" safearray="yes" dir="out">
+        <desc />
+      </param>
+
+      <param name="aTypes" type="unsigned long" safearray="yes" dir="out">
+        <desc />
+      </param>
+    </method>
+
+    <method name="exists">
+      <desc />
+
+      <param name="aNames" type="wstring" safearray="yes" dir="in">
+        <desc />
+      </param>
+
+      <param name="aExists" type="wstring" safearray="yes" dir="return">
+        <desc />
+      </param>
+    </method>
+
+    <method name="remove">
+      <desc />
+
+      <param name="aNames" type="wstring" safearray="yes" dir="in">
+        <desc />
+      </param>
+
+      <param name="aProgress" type="IProgress" dir="return">
+        <desc />
+      </param>
+    </method>
+    
   </interface>
 
@@ -3043 +3140 @@
   <interface
      name="IAppliance" extends="$unknown"
-     uuid="30bfa6b8-9eda-4b0a-b218-a86813248ccd"
+     uuid="07495095-d16c-4911-8964-5914341ced5d"
      wsmap="managed"
      >
@@ -3226 +3323 @@
       <param name="aProgress" type="IProgress" dir="return">
         <desc></desc>
+      </param>
+    </method>
+
+    <method name="createVFSExplorer">
+      <desc />
+
+      <param name="aUri" type="wstring" dir="in">
+        <desc />
+      </param>
+
+      <param name="aExplorer" type="IVFSExplorer" dir="return">
+        <desc />
       </param>
     </method>

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

@@ -75 +75 @@
 
     /* IAppliance methods */
+    /* Import methods */
     STDMETHOD(Read)(IN_BSTR path);
     STDMETHOD(Interpret)(void);
     STDMETHOD(ImportMachines)(IProgress **aProgress);
+    /* Export methods */
+    STDMETHOD(CreateVFSExplorer)(IN_BSTR aURI, IVFSExplorer **aExplorer);
     STDMETHOD(Write)(IN_BSTR format, IN_BSTR path, IProgress **aProgress);
+
     STDMETHOD(GetWarnings)(ComSafeArrayOut(BSTR, aWarnings));
 
@@ -99 +103 @@
     HRESULT searchUniqueDiskImageFilePath(Utf8Str& aName) const;
     HRESULT setUpProgress(ComObjPtr<Progress> &pProgress, const Bstr &bstrDescription);
+    HRESULT setUpProgressUpload(ComObjPtr<Progress> &pProgress, const Bstr &bstrDescription);
     void waitForAsyncProgress(ComObjPtr<Progress> &pProgressThis, ComPtr<IProgress> &pProgressAsync);
     void addWarning(const char* aWarning, ...);
 
+    void parseURI(Utf8Str strUri, const Utf8Str &strProtocol, Utf8Str &strFilepath, Utf8Str &strHostname, Utf8Str &strUsername, Utf8Str &strPassword);
+    HRESULT writeImpl(int aFormat, Utf8Str aPath, ComObjPtr<Progress> &aProgress);
+
     struct TaskImportMachines;  /* Worker thread for import */
     static DECLCALLBACK(int) taskThreadImportMachines(RTTHREAD thread, void *pvUser);
 
-    struct TaskWriteOVF;       /* Worker thread for export */
-    static DECLCALLBACK(int) taskThreadWriteOVF(RTTHREAD thread, void *pvUser);
+    struct TaskWriteOVF;        /* Worker threads for export */
+    static DECLCALLBACK(int) taskThreadWriteOVF(RTTHREAD aThread, void *pvUser);
+
+    int writeFS(TaskWriteOVF *pTask);
+    int writeS3(TaskWriteOVF *pTask);
 
     friend class Machine;

trunk/src/VBox/Main/xpcom/server.cpp

@@ -74 +74 @@
 #include <VirtualBoxImpl.h>
 #include <MachineImpl.h>
+#include <VFSExplorerImpl.h>
 #include <ApplianceImpl.h>
 #include <SnapshotImpl.h>
@@ -110 +111 @@
 NS_DECL_CLASSINFO(Machine)
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Machine, IMachine)
+
+NS_DECL_CLASSINFO(VFSExplorer)
+NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VFSExplorer, IVFSExplorer)
 
 NS_DECL_CLASSINFO(Appliance)