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

Timestamp:

Apr 11, 2010 7:15:06 PM (15 years ago)

Author:

vboxsync

Message:

Main/OVF: import vbox:machine with disks, the rest. Todo some bugfixing.

Location:

trunk/src/VBox/Main

Files:

• ApplianceImpl.cpp (modified) (1 diff)
• ApplianceImplImport.cpp (modified) (11 diffs)
• include/ApplianceImpl.h (modified) (4 diffs)
• include/ovfreader.h (modified) (4 diffs)
• xml/Settings.cpp (modified) (5 diffs)
• xml/ovfreader.cpp (modified) (2 diffs)

trunk/src/VBox/Main/ApplianceImpl.cpp

@@ -564 +564 @@
 
 /**
+ * Little shortcut to SystemProperties::DefaultHardDiskFolder.
+ * @param str
+ * @return
+ */
+HRESULT Appliance::getDefaultHardDiskFolder(Utf8Str &str) const
+{
+    /* We need the default path for storing disk images */
+    ComPtr<ISystemProperties> systemProps;
+    HRESULT rc = mVirtualBox->COMGETTER(SystemProperties)(systemProps.asOutParam());
+    if (FAILED(rc)) return rc;
+    Bstr bstrDefaultHardDiskFolder;
+    rc = systemProps->COMGETTER(DefaultHardDiskFolder)(bstrDefaultHardDiskFolder.asOutParam());
+    if (FAILED(rc)) return rc;
+    str = bstrDefaultHardDiskFolder;
+
+    return S_OK;
+}
+
+/**
  * Called from the import and export background threads to synchronize the second
  * background disk thread's progress object with the current progress object so

trunk/src/VBox/Main/ApplianceImplImport.cpp

@@ -125 +125 @@
     m->virtualSystemDescriptions.clear();
 
-    /* We need the default path for storing disk images */
-    ComPtr<ISystemProperties> systemProps;
-    rc = mVirtualBox->COMGETTER(SystemProperties)(systemProps.asOutParam());
-    if (FAILED(rc)) return rc;
-    Bstr bstrDefaultHardDiskLocation;
-    rc = systemProps->COMGETTER(DefaultHardDiskFolder)(bstrDefaultHardDiskLocation.asOutParam());
+    Utf8Str strDefaultHardDiskFolder;
+    rc = getDefaultHardDiskFolder(strDefaultHardDiskFolder);
     if (FAILED(rc)) return rc;
 
@@ -505 +501 @@
                     //  - we need a url specifier for the vdi format
                     if (   di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#sparse", Utf8Str::CaseInsensitive)
-                        || di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#compressed", Utf8Str::CaseInsensitive))
+                        || di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#compressed", Utf8Str::CaseInsensitive)
+                       )
                     {
                         /* If the href is empty use the VM name as filename */
@@ -512 +509 @@
                             strFilename = Utf8StrFmt("%s.vmdk", nameVBox.c_str());
                         /* Construct a unique target path */
-                        Utf8StrFmt strPath("%ls%c%s",
-                                           bstrDefaultHardDiskLocation.raw(),
+                        Utf8StrFmt strPath("%s%c%s",
+                                           strDefaultHardDiskFolder.raw(),
                                            RTPATH_DELIMITER,
                                            strFilename.c_str());
@@ -531 +528 @@
                                                   pController->ulIndex,
                                                   hd.ulAddressOnParent);
-                        ULONG ulSize = 0;
-                        if (di.iCapacity != -1)
-                            ulSize = (ULONG)(di.iCapacity / _1M);
-                        else if (di.iPopulatedSize != -1)
-                            ulSize = (ULONG)(di.iPopulatedSize / _1M);
-                        else if (di.iSize != -1)
-                            ulSize = (ULONG)(di.iSize / _1M);
-                        if (ulSize == 0)
-                            ulSize = 10000;         // assume 10 GB, this is for the progress bar only anyway
                         pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskImage,
                                            hd.strDiskId,
                                            di.strHref,
                                            strPath,
-                                           ulSize,
+                                           di.ulSuggestedSizeMB,
                                            strExtraConfig);
                     }
@@ -1153 +1141 @@
 
             if (vsdescThis->m->pConfig)
-                importVBoxMachine(vsysThis, vsdescThis, pNewMachine, stack);
+                importVBoxMachine(vsdescThis, pNewMachine, stack);
             else
                 importMachineGeneric(vsysThis, vsdescThis, pNewMachine, stack);
@@ -1230 +1218 @@
 
 /**
- *
- * @param vsysThis OVF virtual system containing the VirtualDisksMap. We don't pass that directly
- *                 because it's a typedef which requires the whole ovfreader.h to be included otherwise.
- * @param vsdeHD
- * @param dstHdVBox
+ * Imports one disk image. This is common code shared between
+ *  --  importMachineGeneric() for the OVF case; in that case the information comes from
+ *      the OVF virtual systems;
+ *  --  importVBoxMachine(); in that case, the information comes from the <vbox:Machine>
+ *      tag.
+ *
+ * Both ways of describing machines use the OVF disk references section, so in both cases
+ * the caller needs to pass in the ovf::DiskImage structure from ovfreader.cpp.
+ *
+ * As a result, in both cases, if di.strHref is empty, we create a new disk as per the OVF
+ * spec, even though this cannot really happen in the vbox:Machine case since such data
+ * would never have been exported.
+ *
+ * This advances stack.pProgress by one operation with the disk's weight.
+ *
+ * @param di ovfreader.cpp structure describing the disk image from the OVF that is to be imported
+ * @param ulSizeMB Size of the disk image (for progress reporting)
+ * @param strTargetPath Where to create the target image.
+ * @param pTargetHD out: The newly created target disk. This also gets pushed on stack.llHardDisksCreated for cleanup.
  * @param stack
  */
 void Appliance::importOneDiskImage(const ovf::DiskImage &di,
-                                   uint32_t ulSizeMB,
                                    const Utf8Str &strTargetPath,
                                    ComPtr<IMedium> &pTargetHD,
@@ -1286 +1287 @@
             // advance to the next operation
             stack.pProgress->SetNextOperation(BstrFmt(tr("Creating virtual disk image '%s'"), strTargetPath.c_str()),
-                                              ulSizeMB);     // operation's weight, as set up with the IProgress originally
+                                              di.ulSuggestedSizeMB);     // operation's weight, as set up with the IProgress originally
         }
         else
@@ -1326 +1327 @@
             /* Advance to the next operation */
             stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), strSrcFilePath.c_str()),
-                                              ulSizeMB);     // operation's weight, as set up with the IProgress originally);
+                                              di.ulSuggestedSizeMB);     // operation's weight, as set up with the IProgress originally);
         }
 
@@ -1845 +1846 @@
                 ComPtr<IMedium> pTargetHD;
                 importOneDiskImage(di,
-                                   vsdeHD->ulSizeMB,
                                    vsdeHD->strVbox,
                                    pTargetHD,
@@ -1910 +1910 @@
  * about what needs cleaning up (to support rollback).
  *
+ * The machine config stored in the settings::MachineConfigFile structure contains the UUIDs of
+ * the disk attachments used by the machine when it was exported. We also add vbox:uuid attributes
+ * to the OVF disks sections so we can look them up. While importing these UUIDs into a second host
+ * will most probably work, reimporting them into the same host will cause conflicts, so we always
+ * generate new ones on import. This involves the following:
+ *
+ *  1)  Scan the machine config for disk attachments.
+ *
+ *  2)  For each disk attachment found, look up the OVF disk image from the disk references section
+ *      and import the disk into VirtualBox, which creates a new UUID for it. In the machine config,
+ *      replace the old UUID with the new one.
+ *
+ *  3)  Create the VirtualBox machine with the modfified machine config.
+ *
  * @param config
  * @param pNewMachine
  * @param stack
  */
-void Appliance::importVBoxMachine(const ovf::VirtualSystem &vsysThis,
-                                  ComObjPtr<VirtualSystemDescription> &vsdescThis,
+void Appliance::importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
                                   ComPtr<IMachine> &pReturnNewMachine,
                                   ImportStack &stack)
 {
     Assert(vsdescThis->m->pConfig);
-    const settings::MachineConfigFile &config = *vsdescThis->m->pConfig;
+
+    // make a deep copy of the machine settings here because we will tinker
+    // with it by replacing disk UUIDs
+    settings::MachineConfigFile config = *vsdescThis->m->pConfig;
+
+    Utf8Str strDefaultHardDiskFolder;
+    HRESULT rc = getDefaultHardDiskFolder(strDefaultHardDiskFolder);
+    if (FAILED(rc)) throw rc;
+
+    // step 1): scan the machine config for UUIDs
+    for (settings::StorageControllersList::iterator sit = config.storageMachine.llStorageControllers.begin();
+         sit != config.storageMachine.llStorageControllers.end();
+         ++sit)
+    {
+        settings::StorageController &sc = *sit;
+
+        for (settings::AttachedDevicesList::iterator dit = sc.llAttachedDevices.begin();
+             dit != sc.llAttachedDevices.end();
+             ++dit)
+        {
+            settings::AttachedDevice &d = *dit;
+
+            if (d.uuid.isEmpty())
+                // empty DVD and floppy media
+                continue;
+
+            // convert the Guid to string
+            Utf8Str strUuid = d.uuid.toString();
+
+            // there must be an image in the OVF disk structs with the same UUID
+            bool fFound = false;
+            for (ovf::DiskImagesMap::const_iterator oit = stack.mapDisks.begin();
+                 oit != stack.mapDisks.end();
+                 ++oit)
+            {
+                const ovf::DiskImage &di = oit->second;
+
+                if (di.uuidVbox == strUuid)
+                {
+                    Utf8Str strTargetPath(strDefaultHardDiskFolder);
+                    strTargetPath.append(RTPATH_DELIMITER);
+                    strTargetPath.append(di.strHref);
+                    searchUniqueDiskImageFilePath(strTargetPath);
+
+                    // step 2): import disks and map the old and new UUIDs
+                    ComPtr<IMedium> pTargetHD;
+                    importOneDiskImage(di,
+                                       strTargetPath,
+                                       pTargetHD,
+                                       stack);
+
+                    Bstr hdId;
+                    rc = pTargetHD->COMGETTER(Id)(hdId.asOutParam());
+                    if (FAILED(rc)) throw rc;
+
+                    // replace the old UUID in the machine config with the new one
+                    d.uuid = hdId;
+                    fFound = true;
+                    break;
+                }
+            }
+
+            // no disk with such a UUID found:
+            if (!fFound)
+                throw setError(E_FAIL,
+                               tr("<vbox:Machine> element in OVF contains a medium attachment for the disk image %s but the OVF describes no such image"),
+                               strUuid.raw());
+        } // for (settings::AttachedDevicesList::const_iterator dit = sc.llAttachedDevices.begin();
+    } // for (settings::StorageControllersList::const_iterator sit = config.storageMachine.llStorageControllers.begin();
+
+    // step 3): create the machine and have it import the config
 
     // use the name that we computed in the OVF fields to avoid duplicates
@@ -1930 +2013 @@
 
     ComObjPtr<Machine> pNewMachine;
-    HRESULT rc = pNewMachine.createObject();
+    rc = pNewMachine.createObject();
     if (FAILED(rc)) throw rc;
 

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

@@ -119 +119 @@
     HRESULT searchUniqueVMName(Utf8Str& aName) const;
     HRESULT searchUniqueDiskImageFilePath(Utf8Str& aName) const;
+    HRESULT getDefaultHardDiskFolder(Utf8Str &str) const;
     void waitForAsyncProgress(ComObjPtr<Progress> &pProgressThis, ComPtr<IProgress> &pProgressAsync);
     void addWarning(const char* aWarning, ...);
@@ -154 +155 @@
     struct ImportStack;
     void importOneDiskImage(const ovf::DiskImage &di,
-                            uint32_t ulSizeMB,
                             const Utf8Str &strTargetPath,
                             ComPtr<IMedium> &pTargetHD,
@@ -162 +162 @@
                               ComPtr<IMachine> &pNewMachine,
                               ImportStack &stack);
-    void importVBoxMachine(const ovf::VirtualSystem &vsysThis,
-                           ComObjPtr<VirtualSystemDescription> &vsdescThis,
+    void importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
                            ComPtr<IMachine> &pNewMachine,
                            ImportStack &stack);
@@ -192 +191 @@
     Utf8Str strExtraConfig;                 // extra configuration key=value strings (type-dependent)
 
-    uint32_t ulSizeMB;                      // hard disk images only: size of the uncompressed image in MB
+    uint32_t ulSizeMB;                      // hard disk images only: a copy of ovf::DiskImage::ulSuggestedSizeMB
 };
 

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

@@ -152 +152 @@
 struct DiskImage
 {
+    // fields from /DiskSection/Disk
     iprt::MiniString strDiskId;     // value from DiskSection/Disk/@diskId
     int64_t iCapacity;              // value from DiskSection/Disk/@capacity;
@@ -160 +161 @@
     iprt::MiniString strFormat;              // value from DiskSection/Disk/@format
                 // typically http://www.vmware.com/specifications/vmdk.html#sparse
+    iprt::MiniString uuidVbox;      // optional; if the file was exported by VirtualBox >= 3.2,
+                                    // then this has the UUID with which the disk was registered
 
     // fields from /References/File; the spec says the file reference from disk can be empty,
@@ -167 +170 @@
     int64_t iChunkSize;             // value from /References/File/@chunkSize (optional, unsupported)
     iprt::MiniString strCompression; // value from /References/File/@compression (optional, can be "gzip" according to spec)
+
+    // additional field which has a descriptive size in megabytes derived from the above; this can be used for progress reports
+    uint32_t ulSuggestedSizeMB;
 };
 
@@ -383 +389 @@
     OVFReader(const iprt::MiniString &path);
 
+    // Data fields
+    iprt::MiniString            m_strPath;            // file name given to constructor
+    DiskImagesMap               m_mapDisks;           // map of DiskImage structs, sorted by DiskImage.strDiskId
+    std::list<VirtualSystem>    m_llVirtualSystems;   // list of virtual systems, created by and valid after read()
+
+private:
+    xml::Document               m_doc;
+
     void LoopThruSections(const xml::ElementNode *pReferencesElem, const xml::ElementNode *pCurElem);
     void HandleDiskSection(const xml::ElementNode *pReferencesElem, const xml::ElementNode *pSectionElem);
     void HandleNetworkSection(const xml::ElementNode *pSectionElem);
     void HandleVirtualSystemContent(const xml::ElementNode *pContentElem);
-
-    // Data fields
-    iprt::MiniString            m_strPath;            // file name given to constructor
-    DiskImagesMap               m_mapDisks;           // map of DiskImage structs, sorted by DiskImage.strDiskId
-    std::list<VirtualSystem>    m_llVirtualSystems;   // list of virtual systems, created by and valid after read()
-
-private:
-    xml::Document               m_doc;
 };
 

trunk/src/VBox/Main/xml/Settings.cpp

@@ -122 +122 @@
 {
     Data()
-        : pParser(NULL),
-          pDoc(NULL),
+        : pDoc(NULL),
           pelmRoot(NULL),
           sv(SettingsVersion_Null),
@@ -137 +136 @@
     bool                    fFileExists;
 
-    xml::XmlFileParser      *pParser;
     xml::Document           *pDoc;
     xml::ElementNode        *pelmRoot;
@@ -164 +162 @@
             pelmRoot = NULL;
         }
-
-        if (pParser)
-        {
-            delete pParser;
-            pParser = NULL;
-        }
     }
 };
@@ -228 +220 @@
         m->strFilename = *pstrFilename;
 
-        m->pParser = new xml::XmlFileParser;
+        xml::XmlFileParser parser;
         m->pDoc = new xml::Document;
-        m->pParser->read(*pstrFilename,
-                        *m->pDoc);
+        parser.read(*pstrFilename,
+                    *m->pDoc);
 
         m->fFileExists = true;
@@ -3942 +3934 @@
     }
 }
+

trunk/src/VBox/Main/xml/ovfreader.cpp

@@ -183 +183 @@
                 d.iPopulatedSize = -1;
 
+            // optional vbox:uuid attribute (if OVF was exported by VirtualBox != 3.2)
+            pelmDisk->getAttributeValue("vbox:uuid", d.uuidVbox);
+
             const char *pcszFileRef;
             if (pelmDisk->getAttributeValue("fileRef", pcszFileRef)) // optional
@@ -227 +230 @@
                                 pcszBad,
                                 pelmDisk->getLineNumber());
+
+        // suggest a size in megabytes to help callers with progress reports
+        d.ulSuggestedSizeMB = 0;
+        if (d.iCapacity != -1)
+            d.ulSuggestedSizeMB = d.iCapacity / _1M;
+        else if (d.iPopulatedSize != -1)
+            d.ulSuggestedSizeMB = d.iPopulatedSize / _1M;
+        else if (d.iSize != -1)
+            d.ulSuggestedSizeMB = d.iSize / _1M;
+        if (d.ulSuggestedSizeMB == 0)
+            d.ulSuggestedSizeMB = 10000;         // assume 10 GB, this is for the progress bar only anyway
 
         m_mapDisks[d.strDiskId] = d;