Changeset 27918 in vbox

Timestamp:

Mar 31, 2010 5:10:40 PM (14 years ago)

Author:

vboxsync

Message:

Main/OVF: import vbox:Machine XML within OVF, first batch (XML is parsed and machine config created, but COM Machine can't handle it yet)

Location:

trunk

Files:

• include/VBox/settings.h (modified) (3 diffs)
• include/iprt/cpp/xml.h (modified) (2 diffs)
• src/VBox/Main/ApplianceImpl.cpp (modified) (3 diffs)
• src/VBox/Main/ApplianceImplImport.cpp (modified) (6 diffs)
• src/VBox/Main/MachineImpl.cpp (modified) (3 diffs)
• src/VBox/Main/include/ApplianceImpl.h (modified) (2 diffs)
• src/VBox/Main/include/ApplianceImplPrivate.h (modified) (1 diff)
• src/VBox/Main/include/ovfreader.h (modified) (4 diffs)
• src/VBox/Main/xml/Settings.cpp (modified) (3 diffs)
• src/VBox/Main/xml/ovfreader.cpp (modified) (3 diffs)
• src/VBox/Runtime/r3/xml.cpp (modified) (4 diffs)

trunk/include/VBox/settings.h

@@ -350 +350 @@
  };
  typedef std::list<NATRule> NATRuleList;
- 
+
  struct NAT
  {
@@ -824 +824 @@
 {
 public:
+    com::Guid               uuid;
+    com::Utf8Str            strName;
+    bool                    fNameSync;
+    com::Utf8Str            strDescription;
+    com::Utf8Str            strOsType;
+    com::Utf8Str            strStateFile;
+    com::Guid               uuidCurrentSnapshot;
+    com::Utf8Str            strSnapshotFolder;
+    bool                    fTeleporterEnabled;
+    uint32_t                uTeleporterPort;
+    com::Utf8Str            strTeleporterAddress;
+    com::Utf8Str            strTeleporterPassword;
+    bool                    fRTCUseUTC;
+
+    bool                    fCurrentStateModified;      // optional, default is true
+    RTTIMESPEC              timeLastStateChange;        // optional, defaults to now
+    bool                    fAborted;                   // optional, default is false
+
+    Hardware                hardwareMachine;
+    Storage                 storageMachine;
+
+    ExtraDataItemsMap       mapExtraDataItems;
+
+    SnapshotsList           llFirstSnapshot;            // first snapshot or empty list if there's none
+
     MachineConfigFile(const com::Utf8Str *pstrFilename);
 
     bool operator==(const MachineConfigFile &m) const;
 
+    void importMachineXML(const xml::ElementNode &elmMachine);
+
+    void write(const com::Utf8Str &strFilename);
+    void buildMachineXML(xml::ElementNode &elmMachine);
+
+private:
     void readNetworkAdapters(const xml::ElementNode &elmHardware, NetworkAdaptersList &ll);
     void readCpuIdTree(const xml::ElementNode &elmCpuid, CpuIdLeafsList &ll);
@@ -846 +877 @@
     void buildStorageControllersXML(xml::ElementNode &elmParent, const Storage &st);
     void buildSnapshotXML(xml::ElementNode &elmParent, const Snapshot &snap);
-    void buildMachineXML(xml::ElementNode &elmMachine);
 
     void bumpSettingsVersionIfNeeded();
-    void write(const com::Utf8Str &strFilename);
-
-    com::Guid               uuid;
-    com::Utf8Str            strName;
-    bool                    fNameSync;
-    com::Utf8Str            strDescription;
-    com::Utf8Str            strOsType;
-    com::Utf8Str            strStateFile;
-    com::Guid               uuidCurrentSnapshot;
-    com::Utf8Str            strSnapshotFolder;
-    bool                    fTeleporterEnabled;
-    uint32_t                uTeleporterPort;
-    com::Utf8Str            strTeleporterAddress;
-    com::Utf8Str            strTeleporterPassword;
-    bool                    fRTCUseUTC;
-
-    bool                    fCurrentStateModified;      // optional, default is true
-    RTTIMESPEC              timeLastStateChange;        // optional, defaults to now
-    bool                    fAborted;                   // optional, default is false
-
-    Hardware                hardwareMachine;
-    Storage                 storageMachine;
-
-    ExtraDataItemsMap       mapExtraDataItems;
-
-    SnapshotsList           llFirstSnapshot;            // first snapshot or empty list if there's none
-};
-
-
+};
 
 } // namespace settings

trunk/include/iprt/cpp/xml.h

@@ -438 +438 @@
 
     const char* getName() const;
-    bool nameEquals(const char *pcsz) const;
+    bool nameEquals(const char *pcszNamespace, const char *pcsz) const;
+    bool nameEquals(const char *pcsz) const
+    {
+        return nameEquals(NULL, pcsz);
+    }
 
     const char* getValue() const;
@@ -474 +478 @@
                          const char *pcszMatch = NULL) const;
 
-    const ElementNode* findChildElement(const char *pcszMatch) const;
+    const ElementNode* findChildElement(const char *pcszNamespace,
+                                        const char *pcszMatch) const;
+    const ElementNode* findChildElement(const char *pcszMatch) const
+    {
+        return findChildElement(NULL, pcszMatch);
+    }
     const ElementNode* findChildElementFromId(const char *pcszId) const;
 

trunk/src/VBox/Main/ApplianceImpl.cpp

@@ -964 +964 @@
     /* Initialize data */
     m = new Data();
+    m->pConfig = NULL;
 
     /* Confirm a successful initialization */
@@ -976 +977 @@
 void VirtualSystemDescription::uninit()
 {
+    if (m->pConfig)
+        delete m->pConfig;
     delete m;
     m = NULL;
@@ -1323 +1326 @@
 }
 
+/**
+ * Method called from Appliance::Interpret() if the source OVF for a virtual system
+ * contains a <vbox:Machine> element. This method then attempts to parse that and
+ * create a MachineConfigFile instance from it which is stored in this instance data
+ * and can then be used to create a machine.
+ *
+ * This must only be called once per instance.
+ *
+ * This rethrows all XML and logic errors from MachineConfigFile.
+ *
+ * @param elmMachine <vbox:Machine> element with attributes and subelements from some
+ *                  DOM tree.
+ */
+void VirtualSystemDescription::importVboxMachineXML(const xml::ElementNode &elmMachine)
+{
+    settings::MachineConfigFile *pConfig = NULL;
+
+    Assert(m->pConfig == NULL);
+
+    try
+    {
+        pConfig = new settings::MachineConfigFile(NULL);
+        pConfig->importMachineXML(elmMachine);
+
+        m->pConfig = pConfig;
+    }
+    catch (...)
+    {
+        if (pConfig)
+            delete pConfig;
+        throw;
+    }
+}
+
+/**
+ * Returns the machine config created by importVboxMachineXML() or NULL if there's none.
+ * @return
+ */
+const settings::MachineConfigFile* VirtualSystemDescription::getMachineConfig() const
+{
+    return m->pConfig;
+}
+

trunk/src/VBox/Main/ApplianceImplImport.cpp

@@ -42 +42 @@
 #include <VBox/param.h>
 #include <VBox/version.h>
+#include <VBox/settings.h>
 
 using namespace std;
@@ -158 +159 @@
             if (FAILED(rc)) throw rc;
 
+            // if the virtual system in OVF had a <vbox:Machine> element, have the
+            // VirtualBox settings code parse that XML now
+            if (vsysThis.pelmVboxMachine)
+                pNewDesc->importVboxMachineXML(*vsysThis.pelmVboxMachine);
+
             /* Guest OS type */
             Utf8Str strOsTypeVBox,
@@ -254 +260 @@
             if (    ullMemSizeVBox != 0
                  && (    ullMemSizeVBox < MM_RAM_MIN_IN_MB
-                      || ullMemSizeVBox > MM_RAM_MAX_IN_MB)
+                      || ullMemSizeVBox > MM_RAM_MAX_IN_MB
+                    )
                )
             {
@@ -712 +719 @@
 
 /**
- * Worker code for writing out OVF to the cloud. This is called from Appliance::taskThreadImportOrExport()
+ * Worker code for reading OVF from the cloud. This is called from Appliance::taskThreadImportOrExport()
  * in S3 mode and therefore runs on the OVF read worker thread. This then starts a second worker
  * thread to create temporary files (see Appliance::readFS()).
@@ -1075 +1082 @@
         try
         {
+            // there are two ways in which we can create
+
             /* Guest OS type */
             std::list<VirtualSystemDescriptionEntry*> vsdeOS;
@@ -1095 +1104 @@
                                tr("Missing VM name"));
             const Utf8Str &strNameVBox = vsdeName.front()->strVbox;
-            rc = mVirtualBox->CreateMachine(Bstr(strNameVBox), Bstr(strOsTypeVBox),
-                                                 Bstr(), Bstr(), FALSE,
-                                                 pNewMachine.asOutParam());
+            rc = mVirtualBox->CreateMachine(Bstr(strNameVBox),
+                                            Bstr(strOsTypeVBox),
+                                            NULL,
+                                            NULL,
+                                            FALSE,
+                                            pNewMachine.asOutParam());
             if (FAILED(rc)) throw rc;
 

trunk/src/VBox/Main/MachineImpl.cpp

@@ -264 +264 @@
  *  @param aConfigFile  Local file system path to the VM settings file (can
  *                      be relative to the VirtualBox config directory).
- *  @param aMode        Init_New, Init_Existing or Init_Registered
+ *  @param aMode        Init_New: called from VirtualBox::CreateMachine() or VirtualBox::CreateLegacyMachine() to create an empty machine
+ *                      Init_Import: called from VirtualBox::OpenMachine()
+ *                      Init_Registered: called from VirtualBox::initMachines() during startup
  *  @param aName        name for the machine when aMode is Init_New
  *                      (ignored otherwise)
@@ -332 +334 @@
     if (aMode == Init_Registered)
     {
+        // Init_Registered: called from VirtualBox::initMachines() during startup
+
         mData->mRegistered = TRUE;
 
@@ -345 +349 @@
         if (aMode == Init_Import)
         {
+            // Init_Import: called from VirtualBox::OpenMachine()
+
             // we're reading the settings file below
         }
         else if (aMode == Init_New)
         {
+            // Init_New: called from VirtualBox::CreateMachine() or VirtualBox::CreateLegacyMachine() to create an empty machine
+
             /* check for the file existence */
             RTFILE f = NIL_RTFILE;

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

@@ -43 +43 @@
 }
 
+namespace settings
+{
+    class MachineConfigFile;
+}
+
 class ATL_NO_VTABLE Appliance :
     public VirtualBoxBase,
@@ -243 +248 @@
     const VirtualSystemDescriptionEntry* findControllerFromID(uint32_t id);
 
+    void importVboxMachineXML(const xml::ElementNode &elmMachine);
+    const settings::MachineConfigFile* getMachineConfig() const;
+
     /* private instance data */
 private:

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

@@ -143 +143 @@
     std::list<VirtualSystemDescriptionEntry>
                             llDescriptions;     // item descriptions
+
     ComPtr<Machine>         pMachine;           // VirtualBox machine this description was exported from (export only)
+
+    settings::MachineConfigFile
+                            *pConfig;           // machine config created from <vbox:Machine> element if found (import only)
 };
 

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

@@ -230 +230 @@
 
     VirtualHardwareItem()
-        : ulInstanceID(0), fAutomaticAllocation(false), fAutomaticDeallocation(false), ullVirtualQuantity(0), ullReservation(0), ullLimit(0), ullWeight(0), ulBusNumber(0), ulLineNumber(0)
+        : ulInstanceID(0),
+          fAutomaticAllocation(false),
+          fAutomaticDeallocation(false),
+          ullVirtualQuantity(0),
+          ullReservation(0),
+          ullLimit(0),
+          ullWeight(0),
+          ulBusNumber(0),
+          ulLineNumber(0)
     {};
 };
@@ -327 +335 @@
     iprt::MiniString    strVendorUrl;           // product info if any; receives contents of VirtualSystem/ProductSection/VendorUrl
 
+    const xml::ElementNode                      // pointer to <vbox:Machine> element under <VirtualSystem> element or NULL if not present
+                        *pelmVboxMachine;
+
     VirtualSystem()
-        : ullMemorySize(0), cCPUs(1), fHasFloppyDrive(false), fHasCdromDrive(false), fHasUsbController(false)
+        : ullMemorySize(0),
+          cCPUs(1),
+          fHasFloppyDrive(false),
+          fHasCdromDrive(false),
+          fHasUsbController(false),
+          pelmVboxMachine(NULL)
     {
     }
@@ -366 +382 @@
 public:
     OVFReader(const iprt::MiniString &path);
-    ~OVFReader();
 
     void LoopThruSections(const xml::ElementNode *pReferencesElem, const xml::ElementNode *pCurElem);
@@ -374 +389 @@
 
     // 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()
+    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

@@ -1676 +1676 @@
 
 /**
+ * Public routine which allows for importing machine XML from an external DOM tree.
+ * Use this after having called the constructor with a NULL argument.
+ *
+ * This is used by the OVF code if a <vbox:Machine> element has been encountered
+ * in an OVF VirtualSystem element.
+ *
+ * @param elmMachine
+ */
+void MachineConfigFile::importMachineXML(const xml::ElementNode &elmMachine)
+{
+    readMachine(elmMachine);
+}
+
+/**
  * Comparison operator. This gets called from Machine::saveSettings to figure out
  * whether machine settings have really changed and thus need to be written out to disk.
@@ -3331 +3345 @@
                             pelmTFTP->setAttribute("next-server", nic.nat.strTftpNextServer);
                     }
-                    for(NATRuleList::const_iterator rule = nic.nat.llRules.begin(); 
+                    for(NATRuleList::const_iterator rule = nic.nat.llRules.begin();
                             rule != nic.nat.llRules.end(); ++rule)
                     {
@@ -3827 +3841 @@
     if (m->sv < SettingsVersion_v1_10)
     {
-        NetworkAdaptersList::const_iterator netit; 
+        NetworkAdaptersList::const_iterator netit;
         for (netit = hardwareMachine.llNetworkAdapters.begin();
              netit != hardwareMachine.llNetworkAdapters.end(); ++netit)
-            if (    netit->fEnabled 
+            if (    netit->fEnabled
                  && netit->mode == NetworkAttachmentType_NAT
                  && (   netit->nat.u32Mtu != 0

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

@@ -34 +34 @@
 ////////////////////////////////////////////////////////////////////////////////
 
+/**
+ * Constructor. This opens the given XML file and parses it. Throws lots of exceptions
+ * on XML or OVF invalidity.
+ * @param path
+ */
 OVFReader::OVFReader(const MiniString &path)
     : m_strPath(path)
 {
     xml::XmlFileParser parser;
-    xml::Document doc;
     parser.read(m_strPath,
-                doc);
-
-    const xml::ElementNode *pRootElem = doc.getRootElement();
-    if (pRootElem && strcmp(pRootElem->getName(), "Envelope"))
+                m_doc);
+
+    const xml::ElementNode *pRootElem = m_doc.getRootElement();
+    if (    !pRootElem
+         || strcmp(pRootElem->getName(), "Envelope")
+       )
         throw OVFLogicError(N_("Root element in OVF file must be \"Envelope\"."));
 
@@ -63 +69 @@
     // now go though the sections
     LoopThruSections(pReferencesElem, pRootElem);
-}
-
-OVFReader::~OVFReader()
-{
 }
 
@@ -269 +271 @@
     VirtualSystem vsys;
 
+    // peek under the <VirtualSystem> node whether we have a <vbox:Machine> node;
+    // that case case, the caller can completely ignore the OVF but only load the VBox machine XML
+    vsys.pelmVboxMachine = pelmVirtualSystem->findChildElement("vbox", "Machine");
+
+    // now look for real OVF
     const xml::AttributeNode *pIdAttr = pelmVirtualSystem->findAttribute("id");
     if (pIdAttr)

trunk/src/VBox/Runtime/r3/xml.cpp

@@ -506 +506 @@
 }
 
-bool Node::nameEquals(const char *pcsz) const
+/**
+ * Variant of nameEquals that checks the namespace as well.
+ * @param pcszNamespace
+ * @param pcsz
+ * @return
+ */
+bool Node::nameEquals(const char *pcszNamespace, const char *pcsz) const
 {
     if (m->pcszName == pcsz)
@@ -514 +520 @@
     if (pcsz == NULL)
         return false;
-    return !strcmp(m->pcszName, pcsz);
-}
-
+    if (strcmp(m->pcszName, pcsz))
+        return false;
+
+    // name matches: then check namespaces as well
+    if (!pcszNamespace)
+        return true;
+    // caller wants namespace:
+    if (    !m->plibNode->ns
+         || !m->plibNode->ns->prefix
+         || !*m->plibNode->ns->prefix
+       )
+        // but node has no namespace:
+        return false;
+    return !strcmp((const char*)m->plibNode->ns->prefix, pcszNamespace);
+}
 
 /**
@@ -663 +681 @@
 /**
  * Returns the first child element whose name matches pcszMatch.
- * @param pcszMatch
+ *
+ * @param pcszNamespace Namespace prefix (e.g. "vbox") or NULL to match any namespace.
+ * @param pcszMatch Element name to match.
  * @return
  */
-const ElementNode* ElementNode::findChildElement(const char *pcszMatch)
+const ElementNode* ElementNode::findChildElement(const char *pcszNamespace,
+                                                 const char *pcszMatch)
     const
 {
@@ -679 +700 @@
         {
             ElementNode *pelm = static_cast<ElementNode*>((*it).get());
-            if (!strcmp(pcszMatch, pelm->getName())) // the element name matches
+            if (pelm->nameEquals(pcszNamespace, pcszMatch))
                 return pelm;
         }