Changeset 28110 in vbox for trunk

Timestamp:

Apr 8, 2010 6:07:13 PM (15 years ago)

Author:

vboxsync

Message:

Main: more Machine::init() work to get OVF vbox:Machine import running; works now for machines without media attachments

Location:

trunk/src/VBox/Main

Files:

• ApplianceImplImport.cpp (modified) (5 diffs)
• MachineImpl.cpp (modified) (9 diffs)
• SnapshotImpl.cpp (modified) (1 diff)
• include/ApplianceImpl.h (modified) (1 diff)
• include/MachineImpl.h (modified) (5 diffs)

trunk/src/VBox/Main/ApplianceImplImport.cpp

@@ -34 +34 @@
 #include "GuestOSTypeImpl.h"
 #include "ProgressImpl.h"
+#include "MachineImpl.h"
 
 #include "AutoCaller.h"
@@ -1121 +1122 @@
 
             if (vsdescThis->m->pConfig)
-                importVBoxMachine(*vsdescThis->m->pConfig, pNewMachine, stack);
+                importVBoxMachine(vsdescThis, pNewMachine, stack);
             else
                 importMachineGeneric(vsysThis, vsdescThis, pNewMachine, stack);
         }
-        catch(HRESULT aRC)
+        catch (HRESULT aRC)
         {
             rc = aRC;
@@ -1367 +1368 @@
         size_t a = 0;
         for (nwIt = vsdeNW.begin();
-                (nwIt != vsdeNW.end() && a < SchemaDefs::NetworkAdapterCount);
-                ++nwIt, ++a)
+             (nwIt != vsdeNW.end() && a < SchemaDefs::NetworkAdapterCount);
+             ++nwIt, ++a)
         {
             const VirtualSystemDescriptionEntry* pvsys = *nwIt;
@@ -1529 +1530 @@
     if (FAILED(rc)) throw rc;
 
+    // store new machine for roll-back in case of errors
     Bstr bstrNewMachineId;
     rc = pNewMachine->COMGETTER(Id)(bstrNewMachineId.asOutParam());
     if (FAILED(rc)) throw rc;
-
-    // store new machine for roll-back in case of errors
     stack.llMachinesRegistered.push_back(bstrNewMachineId);
 
@@ -1862 +1862 @@
  * @param stack
  */
-void Appliance::importVBoxMachine(const settings::MachineConfigFile &config,
-                                  ComPtr<IMachine> &pNewMachine,
+void Appliance::importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
+                                  ComPtr<IMachine> &pReturnNewMachine,
                                   ImportStack &stack)
 {
+    Assert(vsdescThis->m->pConfig);
+    const settings::MachineConfigFile &config = *vsdescThis->m->pConfig;
+
+    // use the name that we computed in the OVF fields to avoid duplicates
+    std::list<VirtualSystemDescriptionEntry*> vsdeName = vsdescThis->findByType(VirtualSystemDescriptionType_Name);
+    if (vsdeName.size() < 1)
+        throw setError(VBOX_E_FILE_ERROR,
+                        tr("Missing VM name"));
+    const Utf8Str &strNameVBox = vsdeName.front()->strVbox;
+
+    ComObjPtr<Machine> pNewMachine;
+    HRESULT rc = pNewMachine.createObject();
+    if (FAILED(rc)) throw rc;
+    rc = pNewMachine->init(mVirtualBox, strNameVBox, config);
+    if (FAILED(rc)) throw rc;
+
+    IMachine *p;
+    rc = pNewMachine.queryInterfaceTo(&p);
+    if (FAILED(rc)) throw rc;
+
+    pReturnNewMachine = p;
+
+    rc = mVirtualBox->RegisterMachine(pNewMachine);
+    if (FAILED(rc)) throw rc;
+
+    // store new machine for roll-back in case of errors
+    Bstr bstrNewMachineId;
+    rc = pNewMachine->COMGETTER(Id)(bstrNewMachineId.asOutParam());
+    if (FAILED(rc)) throw rc;
+    stack.llMachinesRegistered.push_back(bstrNewMachineId);
 }
 

trunk/src/VBox/Main/MachineImpl.cpp

@@ -296 +296 @@
     if (FAILED(rc)) return rc;
 
+    rc = tryCreateMachineConfigFile(aOverride);
+    if (FAILED(rc)) return rc;
+
+    if (SUCCEEDED(rc))
+    {
+        // create an empty machine config
+        mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
+
+        rc = initDataAndChildObjects();
+    }
+
+    if (SUCCEEDED(rc))
+    {
+        // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
+        mData->mAccessible = TRUE;
+
+        unconst(mData->mUuid) = aId;
+
+        mUserData->mName = strName;
+        mUserData->mNameSync = aNameSync;
+
+        /* initialize the default snapshots folder
+         * (note: depends on the name value set above!) */
+        rc = COMSETTER(SnapshotFolder)(NULL);
+        AssertComRC(rc);
+
+        if (aOsType)
+        {
+            /* Store OS type */
+            mUserData->mOSTypeId = aOsType->id();
+
+            /* Apply BIOS defaults */
+            mBIOSSettings->applyDefaults(aOsType);
+
+            /* Apply network adapters defaults */
+            for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); ++slot)
+                mNetworkAdapters[slot]->applyDefaults(aOsType);
+
+            /* Apply serial port defaults */
+            for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
+                mSerialPorts[slot]->applyDefaults(aOsType);
+        }
+
+        /* commit all changes made during the initialization */
+        commit();
+    }
+
+    /* Confirm a successful initialization when it's the case */
+    if (SUCCEEDED(rc))
+    {
+        if (mData->mAccessible)
+            autoInitSpan.setSucceeded();
+        else
+            autoInitSpan.setLimited();
+    }
+
+    LogFlowThisFunc(("mName='%ls', mRegistered=%RTbool, mAccessible=%RTbool, rc=%08X\n",
+                     !!mUserData ? mUserData->mName.raw() : NULL,
+                     mData->mRegistered,
+                     mData->mAccessible,
+                     rc));
+
+    LogFlowThisFuncLeave();
+
+    return rc;
+}
+
+/**
+ *  Initializes a new instance with data from machine XML (formerly Init_Registered).
+ *  Gets called in two modes:
+ *      -- from VirtualBox::initMachines() during VirtualBox startup; in that case, the
+ *         UUID is specified and we mark the machine as "registered";
+ *      -- from the public VirtualBox::OpenMachine() API, in which case the UUID is NULL
+ *         and the machine remains unregistered until RegisterMachine() is called.
+ *
+ *  @param aParent      Associated parent object
+ *  @param aConfigFile  Local file system path to the VM settings file (can
+ *                      be relative to the VirtualBox config directory).
+ *  @param aId          UUID of the machine or NULL (see above).
+ *
+ *  @return  Success indicator. if not S_OK, the machine object is invalid
+ */
+HRESULT Machine::init(VirtualBox *aParent,
+                      const Utf8Str &strConfigFile,
+                      const Guid *aId)
+{
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("(Init_Registered) aConfigFile='%s\n", strConfigFile.raw()));
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    HRESULT rc = initImpl(aParent, strConfigFile);
+    if (FAILED(rc)) return rc;
+
+    if (aId)
+    {
+        // loading a registered VM:
+        unconst(mData->mUuid) = *aId;
+        mData->mRegistered = TRUE;
+        // now load the settings from XML:
+        rc = registeredInit();
+            // this calls initDataAndChildObjects() and loadSettings()
+    }
+    else
+    {
+        // opening an unregistered VM (VirtualBox::OpenMachine()):
+        rc = initDataAndChildObjects();
+
+        if (SUCCEEDED(rc))
+        {
+            // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
+            mData->mAccessible = TRUE;
+
+            try
+            {
+                // load and parse machine XML; this will throw on XML or logic errors
+                mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
+
+                // use UUID from machine config
+                unconst(mData->mUuid) = mData->pMachineConfigFile->uuid;
+
+                rc = loadMachineDataFromSettings(*mData->pMachineConfigFile);
+                if (FAILED(rc)) throw rc;
+
+                commit();
+            }
+            catch (HRESULT err)
+            {
+                /* we assume that error info is set by the thrower */
+                rc = err;
+            }
+            catch (...)
+            {
+                rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
+            }
+        }
+    }
+
+    /* Confirm a successful initialization when it's the case */
+    if (SUCCEEDED(rc))
+    {
+        if (mData->mAccessible)
+            autoInitSpan.setSucceeded();
+        else
+            autoInitSpan.setLimited();
+    }
+
+    LogFlowThisFunc(("mName='%ls', mRegistered=%RTbool, mAccessible=%RTbool "
+                      "rc=%08X\n",
+                      !!mUserData ? mUserData->mName.raw() : NULL,
+                      mData->mRegistered, mData->mAccessible, rc));
+
+    LogFlowThisFuncLeave();
+
+    return rc;
+}
+
+/**
+ *  Initializes a new instance from a machine config that is already in memory
+ *  (import OVF import case). Since we are importing, the UUID in the machine
+ *  config is ignored and we always generate a fresh one.
+ *
+ *  @param strName  Name for the new machine; this overrides what is specified in config and is used
+ *                  for the settings file as well.
+ *  @param config   Machine configuration loaded and parsed from XML.
+ *
+ *  @return  Success indicator. if not S_OK, the machine object is invalid
+ */
+HRESULT Machine::init(VirtualBox *aParent,
+                      const Utf8Str &strName,
+                      const settings::MachineConfigFile &config)
+{
+    LogFlowThisFuncEnter();
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    Utf8Str strConfigFile(aParent->getDefaultMachineFolder());
+    strConfigFile.append(Utf8StrFmt("%c%s%c%s.xml",
+                                    RTPATH_DELIMITER,
+                                    strName.c_str(),
+                                    RTPATH_DELIMITER,
+                                    strName.c_str()));
+
+    HRESULT rc = initImpl(aParent, strConfigFile);
+    if (FAILED(rc)) return rc;
+
+    rc = tryCreateMachineConfigFile(FALSE /* aOverride */);
+    if (FAILED(rc)) return rc;
+
+    rc = initDataAndChildObjects();
+
+    if (SUCCEEDED(rc))
+    {
+        // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
+        mData->mAccessible = TRUE;
+
+        // create empty machine config for instance data
+        mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
+
+        // generate fresh UUID, ignore machine config
+        unconst(mData->mUuid).create();
+
+        rc = loadMachineDataFromSettings(config);
+
+        // override VM name as well, it may be different
+        mUserData->mName = strName;
+
+        /* commit all changes made during the initialization */
+        if (SUCCEEDED(rc))
+            commit();
+    }
+
+    /* Confirm a successful initialization when it's the case */
+    if (SUCCEEDED(rc))
+    {
+        if (mData->mAccessible)
+            autoInitSpan.setSucceeded();
+        else
+            autoInitSpan.setLimited();
+    }
+
+    LogFlowThisFunc(("mName='%ls', mRegistered=%RTbool, mAccessible=%RTbool "
+                     "rc=%08X\n",
+                      !!mUserData ? mUserData->mName.raw() : NULL,
+                      mData->mRegistered, mData->mAccessible, rc));
+
+    LogFlowThisFuncLeave();
+
+    return rc;
+}
+
+/**
+ * Shared code between the various init() implementations.
+ * @param aParent
+ * @return
+ */
+HRESULT Machine::initImpl(VirtualBox *aParent,
+                          const Utf8Str &strConfigFile)
+{
+    LogFlowThisFuncEnter();
+
+    AssertReturn(aParent, E_INVALIDARG);
+    AssertReturn(!strConfigFile.isEmpty(), E_INVALIDARG);
+
+    HRESULT rc = S_OK;
+
+    /* share the parent weakly */
+    unconst(mParent) = aParent;
+
+    /* allocate the essential machine data structure (the rest will be
+     * allocated later by initDataAndChildObjects() */
+    mData.allocate();
+
+    /* memorize the config file name (as provided) */
+    mData->m_strConfigFile = strConfigFile;
+
+    /* get the full file name */
+    int vrc1 = mParent->calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
+    if (RT_FAILURE(vrc1))
+        return setError(VBOX_E_FILE_ERROR,
+                        tr("Invalid machine settings file name '%s' (%Rrc)"),
+                        strConfigFile.raw(),
+                        vrc1);
+
+    LogFlowThisFuncLeave();
+
+    return rc;
+}
+
+/**
+ * Tries to create a machine settings file in the path stored in the machine
+ * instance data. Used when a new machine is created to fail gracefully if
+ * the settings file could not be written (e.g. because machine dir is read-only).
+ * @return
+ */
+HRESULT Machine::tryCreateMachineConfigFile(BOOL aOverride)
+{
+    HRESULT rc = S_OK;
+
     // when we create a new machine, we must be able to create the settings file
     RTFILE f = NIL_RTFILE;
@@ -327 +610 @@
                       mData->m_strConfigFileFull.raw(),
                       vrc);
-
-    if (SUCCEEDED(rc))
-    {
-        // create an empty machine config
-        mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
-
-        rc = initDataAndChildObjects();
-    }
-
-    if (SUCCEEDED(rc))
-    {
-        /* set to true now to cause uninit() to call
-         * uninitDataAndChildObjects() on failure */
-        mData->mAccessible = TRUE;
-
-        unconst(mData->mUuid) = aId;
-
-        mUserData->mName = strName;
-        mUserData->mNameSync = aNameSync;
-
-        /* initialize the default snapshots folder
-         * (note: depends on the name value set above!) */
-        rc = COMSETTER(SnapshotFolder)(NULL);
-        AssertComRC(rc);
-
-        if (aOsType)
-        {
-            /* Store OS type */
-            mUserData->mOSTypeId = aOsType->id();
-
-            /* Apply BIOS defaults */
-            mBIOSSettings->applyDefaults(aOsType);
-
-            /* Apply network adapters defaults */
-            for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); ++slot)
-                mNetworkAdapters[slot]->applyDefaults(aOsType);
-
-            /* Apply serial port defaults */
-            for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
-                mSerialPorts[slot]->applyDefaults(aOsType);
-        }
-
-        /* commit all changes made during the initialization */
-        commit();
-    }
-
-    /* Confirm a successful initialization when it's the case */
-    if (SUCCEEDED(rc))
-    {
-        if (mData->mAccessible)
-            autoInitSpan.setSucceeded();
-        else
-            autoInitSpan.setLimited();
-    }
-
-    LogFlowThisFunc(("mName='%ls', mRegistered=%RTbool, mAccessible=%RTbool, rc=%08X\n",
-                     !!mUserData ? mUserData->mName.raw() : NULL,
-                     mData->mRegistered,
-                     mData->mAccessible,
-                     rc));
-
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-/**
- *  Initializes a new instance with data from machine XML (formerly Init_Registered).
- *  Gets called in two modes:
- *      -- from VirtualBox::initMachines() during VirtualBox startup; in that case, the
- *         UUID is specified and we mark the machine as "registered";
- *      -- from the public VirtualBox::OpenMachine() API, in which case the UUID is NULL
- *         and the machine remains unregistered until RegisterMachine() is called.
- *
- *  @param aParent      Associated parent object
- *  @param aConfigFile  Local file system path to the VM settings file (can
- *                      be relative to the VirtualBox config directory).
- *  @param aId          UUID of the machine or NULL (see above).
- *
- *  @return  Success indicator. if not S_OK, the machine object is invalid
- */
-HRESULT Machine::init(VirtualBox *aParent,
-                      const Utf8Str &strConfigFile,
-                      const Guid *aId)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("(Init_Registered) aConfigFile='%s\n", strConfigFile.raw()));
-
-    /* Enclose the state transition NotReady->InInit->Ready */
-    AutoInitSpan autoInitSpan(this);
-    AssertReturn(autoInitSpan.isOk(), E_FAIL);
-
-    HRESULT rc = initImpl(aParent, strConfigFile);
-    if (FAILED(rc)) return rc;
-
-    if (aId)
-    {
-        // loading a registered VM:
-        unconst(mData->mUuid) = *aId;
-        mData->mRegistered = TRUE;
-        // now load the settings from XML:
-        rc = registeredInit();
-            // this calls initDataAndChildObjects() and loadSettings()
-    }
-    else
-    {
-        // opening an unregistered VM (VirtualBox::OpenMachine()):
-        rc = initDataAndChildObjects();
-
-        if (SUCCEEDED(rc))
-        {
-            /* set to true now to cause uninit() to call
-             * uninitDataAndChildObjects() on failure */
-            mData->mAccessible = TRUE;
-
-            rc = loadSettings(false /* aRegistered */);
-
-            /* commit all changes made during the initialization */
-            if (SUCCEEDED(rc))
-                commit();
-        }
-    }
-
-    /* Confirm a successful initialization when it's the case */
-    if (SUCCEEDED(rc))
-    {
-        if (mData->mAccessible)
-            autoInitSpan.setSucceeded();
-        else
-            autoInitSpan.setLimited();
-    }
-
-    LogFlowThisFunc(("mName='%ls', mRegistered=%RTbool, mAccessible=%RTbool "
-                      "rc=%08X\n",
-                      !!mUserData ? mUserData->mName.raw() : NULL,
-                      mData->mRegistered, mData->mAccessible, rc));
-
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-/**
- * Shared code between the various init() implementation.s
- * @param aParent
- * @return
- */
-HRESULT Machine::initImpl(VirtualBox *aParent,
-                          const Utf8Str &strConfigFile)
-{
-    LogFlowThisFuncEnter();
-
-    AssertReturn(aParent, E_INVALIDARG);
-    AssertReturn(!strConfigFile.isEmpty(), E_INVALIDARG);
-
-    HRESULT rc = S_OK;
-
-    /* share the parent weakly */
-    unconst(mParent) = aParent;
-
-    /* allocate the essential machine data structure (the rest will be
-     * allocated later by initDataAndChildObjects() */
-    mData.allocate();
-
-    /* memorize the config file name (as provided) */
-    mData->m_strConfigFile = strConfigFile;
-
-    /* get the full file name */
-    int vrc1 = mParent->calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
-    if (RT_FAILURE(vrc1))
-        return setError(VBOX_E_FILE_ERROR,
-                        tr("Invalid machine settings file name '%s' (%Rrc)"),
-                        strConfigFile.raw(),
-                        vrc1);
-
-    LogFlowThisFuncLeave();
-
     return rc;
 }
@@ -535 +641 @@
         mData->mRegistered = FALSE;
 
-        rc = loadSettings(true /* aRegistered */);
+        try
+        {
+            // load and parse machine XML; this will throw on XML or logic errors
+            mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
+
+            if (mData->mUuid != mData->pMachineConfigFile->uuid)
+                throw setError(E_FAIL,
+                               tr("Machine UUID {%RTuuid} in '%s' doesn't match its UUID {%s} in the registry file '%s'"),
+                               mData->pMachineConfigFile->uuid.raw(),
+                               mData->m_strConfigFileFull.raw(),
+                               mData->mUuid.toString().raw(),
+                               mParent->settingsFilePath().raw());
+
+            rc = loadMachineDataFromSettings(*mData->pMachineConfigFile);
+            if (FAILED(rc)) throw rc;
+        }
+        catch (HRESULT err)
+        {
+            /* we assume that error info is set by the thrower */
+            rc = err;
+        }
+        catch (...)
+        {
+            rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
+        }
 
         /* Restore the registered flag (even on failure) */
@@ -6310 +6440 @@
 
 /**
- *  Loads all the VM settings by walking down the <Machine> node.
- *
- *  @param aRegistered  true when the machine is being loaded on VirtualBox
- *                      startup
- *
- *  @note This method is intended to be called only from init(), so it assumes
- *  all machine data fields have appropriate default values when it is called.
- *
- *  @note Doesn't lock any objects.
+ * Initializes all machine instance data from the given settings structures
+ * from XML. The exception is the machine UUID which needs special handling
+ * depending on the caller's use case, so the caller needs to set that herself.
+ *
+ * @param config
+ * @param fAllowStorage
  */
-HRESULT Machine::loadSettings(bool aRegistered)
-{
-    LogFlowThisFuncEnter();
-    AssertReturn(getClassID() == clsidMachine, E_FAIL);
-
-    AutoCaller autoCaller(this);
-    AssertReturn(autoCaller.state() == InInit, E_FAIL);
-
-    HRESULT rc = S_OK;
-
-    try
-    {
-        Assert(mData->pMachineConfigFile == NULL);
-
-        // load and parse machine XML; this will throw on XML or logic errors
-        mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
-
-        /* If the stored UUID is not empty, it means the registered machine
-         * is being loaded. Compare the loaded UUID with the stored one taken
-         * from the global registry. */
-        if (!mData->mUuid.isEmpty())
-        {
-            if (mData->mUuid != mData->pMachineConfigFile->uuid)
-            {
-                throw setError(E_FAIL,
-                               tr("Machine UUID {%RTuuid} in '%s' doesn't match its UUID {%s} in the registry file '%s'"),
-                               mData->pMachineConfigFile->uuid.raw(),
-                               mData->m_strConfigFileFull.raw(),
-                               mData->mUuid.toString().raw(),
-                               mParent->settingsFilePath().raw());
-            }
-        }
-        else
-            unconst(mData->mUuid) = mData->pMachineConfigFile->uuid;
-
-        /* name (required) */
-        mUserData->mName = mData->pMachineConfigFile->strName;
-
-        /* nameSync (optional, default is true) */
-        mUserData->mNameSync = mData->pMachineConfigFile->fNameSync;
-
-        mUserData->mDescription = mData->pMachineConfigFile->strDescription;
-
-        // guest OS type
-        mUserData->mOSTypeId = mData->pMachineConfigFile->strOsType;
-        /* look up the object by Id to check it is valid */
-        ComPtr<IGuestOSType> guestOSType;
-        rc = mParent->GetGuestOSType(mUserData->mOSTypeId,
-                                     guestOSType.asOutParam());
-        if (FAILED(rc)) throw rc;
-
-        // stateFile (optional)
-        if (mData->pMachineConfigFile->strStateFile.isEmpty())
-            mSSData->mStateFilePath.setNull();
-        else
-        {
-            Utf8Str stateFilePathFull(mData->pMachineConfigFile->strStateFile);
-            int vrc = calculateFullPath(stateFilePathFull, stateFilePathFull);
-            if (RT_FAILURE(vrc))
-                throw setError(E_FAIL,
-                                tr("Invalid saved state file path '%s' (%Rrc)"),
-                                mData->pMachineConfigFile->strStateFile.raw(),
-                                vrc);
-            mSSData->mStateFilePath = stateFilePathFull;
-        }
-
-        /* snapshotFolder (optional) */
-        rc = COMSETTER(SnapshotFolder)(Bstr(mData->pMachineConfigFile->strSnapshotFolder));
-        if (FAILED(rc)) throw rc;
-
-        /* currentStateModified (optional, default is true) */
-        mData->mCurrentStateModified = mData->pMachineConfigFile->fCurrentStateModified;
-
-        mData->mLastStateChange = mData->pMachineConfigFile->timeLastStateChange;
-
-        /* teleportation */
-        mUserData->mTeleporterEnabled  = mData->pMachineConfigFile->fTeleporterEnabled;
-        mUserData->mTeleporterPort     = mData->pMachineConfigFile->uTeleporterPort;
-        mUserData->mTeleporterAddress  = mData->pMachineConfigFile->strTeleporterAddress;
-        mUserData->mTeleporterPassword = mData->pMachineConfigFile->strTeleporterPassword;
-
-        /* RTC */
-        mUserData->mRTCUseUTC = mData->pMachineConfigFile->fRTCUseUTC;
-
-        /*
-         *  note: all mUserData members must be assigned prior this point because
-         *  we need to commit changes in order to let mUserData be shared by all
-         *  snapshot machine instances.
-         */
-        mUserData.commitCopy();
-
-        /* Snapshot node (optional) */
-        size_t cRootSnapshots;
-        if ((cRootSnapshots = mData->pMachineConfigFile->llFirstSnapshot.size()))
-        {
-            // there must be only one root snapshot
-            Assert(cRootSnapshots == 1);
-
-            settings::Snapshot &snap = mData->pMachineConfigFile->llFirstSnapshot.front();
-
-            rc = loadSnapshot(snap,
-                              mData->pMachineConfigFile->uuidCurrentSnapshot,
-                              NULL);        // no parent == first snapshot
-            if (FAILED(rc)) throw rc;
-        }
-
-        /* Hardware node (required) */
-        rc = loadHardware(mData->pMachineConfigFile->hardwareMachine);
-        if (FAILED(rc)) throw rc;
-
-        /* Load storage controllers */
-        rc = loadStorageControllers(mData->pMachineConfigFile->storageMachine, aRegistered);
-        if (FAILED(rc)) throw rc;
-
-        /*
-         *  NOTE: the assignment below must be the last thing to do,
-         *  otherwise it will be not possible to change the settings
-         *  somewehere in the code above because all setters will be
-         *  blocked by checkStateDependency(MutableStateDep).
-         */
-
-        /* set the machine state to Aborted or Saved when appropriate */
-        if (mData->pMachineConfigFile->fAborted)
-        {
-            Assert(!mSSData->mStateFilePath.isEmpty());
-            mSSData->mStateFilePath.setNull();
-
-            /* no need to use setMachineState() during init() */
-            mData->mMachineState = MachineState_Aborted;
-        }
-        else if (!mSSData->mStateFilePath.isEmpty())
-        {
-            /* no need to use setMachineState() during init() */
-            mData->mMachineState = MachineState_Saved;
-        }
-
-        // after loading settings, we are no longer different from the XML on disk
-        mData->flModifications = 0;
-    }
-    catch (HRESULT err)
-    {
-        /* we assume that error info is set by the thrower */
-        rc = err;
-    }
-    catch (...)
-    {
-        rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
-    }
-
-    LogFlowThisFuncLeave();
-    return rc;
+HRESULT Machine::loadMachineDataFromSettings(const settings::MachineConfigFile &config)
+{
+    /* name (required) */
+    mUserData->mName = config.strName;
+
+    /* nameSync (optional, default is true) */
+    mUserData->mNameSync = config.fNameSync;
+
+    mUserData->mDescription = config.strDescription;
+
+    // guest OS type
+    mUserData->mOSTypeId = config.strOsType;
+    /* look up the object by Id to check it is valid */
+    ComPtr<IGuestOSType> guestOSType;
+    HRESULT rc = mParent->GetGuestOSType(mUserData->mOSTypeId,
+                                         guestOSType.asOutParam());
+    if (FAILED(rc)) return rc;
+
+    // stateFile (optional)
+    if (config.strStateFile.isEmpty())
+        mSSData->mStateFilePath.setNull();
+    else
+    {
+        Utf8Str stateFilePathFull(config.strStateFile);
+        int vrc = calculateFullPath(stateFilePathFull, stateFilePathFull);
+        if (RT_FAILURE(vrc))
+            return setError(E_FAIL,
+                            tr("Invalid saved state file path '%s' (%Rrc)"),
+                            config.strStateFile.raw(),
+                            vrc);
+        mSSData->mStateFilePath = stateFilePathFull;
+    }
+
+    /* snapshotFolder (optional) */
+    rc = COMSETTER(SnapshotFolder)(Bstr(config.strSnapshotFolder));
+    if (FAILED(rc)) return rc;
+
+    /* currentStateModified (optional, default is true) */
+    mData->mCurrentStateModified = config.fCurrentStateModified;
+
+    mData->mLastStateChange = config.timeLastStateChange;
+
+    /* teleportation */
+    mUserData->mTeleporterEnabled  = config.fTeleporterEnabled;
+    mUserData->mTeleporterPort     = config.uTeleporterPort;
+    mUserData->mTeleporterAddress  = config.strTeleporterAddress;
+    mUserData->mTeleporterPassword = config.strTeleporterPassword;
+
+    /* RTC */
+    mUserData->mRTCUseUTC = config.fRTCUseUTC;
+
+    /*
+     *  note: all mUserData members must be assigned prior this point because
+     *  we need to commit changes in order to let mUserData be shared by all
+     *  snapshot machine instances.
+     */
+    mUserData.commitCopy();
+
+    /* Snapshot node (optional) */
+    size_t cRootSnapshots;
+    if ((cRootSnapshots = config.llFirstSnapshot.size()))
+    {
+        // there must be only one root snapshot
+        Assert(cRootSnapshots == 1);
+
+        const settings::Snapshot &snap = config.llFirstSnapshot.front();
+
+        rc = loadSnapshot(snap,
+                          config.uuidCurrentSnapshot,
+                          NULL);        // no parent == first snapshot
+        if (FAILED(rc)) return rc;
+    }
+
+    /* Hardware node (required) */
+    rc = loadHardware(config.hardwareMachine);
+    if (FAILED(rc)) return rc;
+
+    /* Load storage controllers */
+    rc = loadStorageControllers(config.storageMachine);
+    if (FAILED(rc)) return rc;
+
+    /*
+        *  NOTE: the assignment below must be the last thing to do,
+        *  otherwise it will be not possible to change the settings
+        *  somewehere in the code above because all setters will be
+        *  blocked by checkStateDependency(MutableStateDep).
+        */
+
+    /* set the machine state to Aborted or Saved when appropriate */
+    if (config.fAborted)
+    {
+        Assert(!mSSData->mStateFilePath.isEmpty());
+        mSSData->mStateFilePath.setNull();
+
+        /* no need to use setMachineState() during init() */
+        mData->mMachineState = MachineState_Aborted;
+    }
+    else if (!mSSData->mStateFilePath.isEmpty())
+    {
+        /* no need to use setMachineState() during init() */
+        mData->mMachineState = MachineState_Saved;
+    }
+
+    // after loading settings, we are no longer different from the XML on disk
+    mData->flModifications = 0;
+
+    return S_OK;
 }
 
@@ -6761 +6844 @@
    */
 HRESULT Machine::loadStorageControllers(const settings::Storage &data,
-                                        bool aRegistered,
                                         const Guid *aSnapshotId /* = NULL */)
 {
@@ -6811 +6893 @@
         rc = loadStorageDevices(pCtl,
                                 ctlData,
-                                aRegistered,
                                 aSnapshotId);
         if (FAILED(rc)) return rc;
@@ -6821 +6902 @@
 /**
  * @param aNode        <HardDiskAttachments> node.
- * @param aRegistered  true when the machine is being loaded on VirtualBox
- *                     startup, or when a snapshot is being loaded (which
- *                     currently can happen on startup only)
+ * @param fAllowStorage if false, we produce an error if the config requests media attachments
+ *                      (used with importing unregistered machines which cannot have media attachments)
  * @param aSnapshotId  pointer to the snapshot ID if this is a snapshot machine
  *
@@ -6830 +6910 @@
 HRESULT Machine::loadStorageDevices(StorageController *aStorageController,
                                     const settings::StorageController &data,
-                                    bool aRegistered,
                                     const Guid *aSnapshotId /*= NULL*/)
 {
@@ -6838 +6917 @@
 
     HRESULT rc = S_OK;
-
-    if (!aRegistered && data.llAttachedDevices.size() > 0)
-        /* when the machine is being loaded (opened) from a file, it cannot
-         * have hard disks attached (this should not happen normally,
-         * because we don't allow to attach hard disks to an unregistered
-         * VM at all */
-        return setError(E_FAIL,
-                        tr("Unregistered machine '%ls' cannot have storage devices attached (found %d attachments)"),
-                        mUserData->mName.raw(),
-                        data.llAttachedDevices.size());
 
     /* paranoia: detect duplicate attachments */

trunk/src/VBox/Main/SnapshotImpl.cpp

@@ -1019 +1019 @@
     HRESULT rc = loadHardware(hardware);
     if (SUCCEEDED(rc))
-        rc = loadStorageControllers(storage, true /* aRegistered */, &mSnapshotId);
+        rc = loadStorageControllers(storage, &mSnapshotId);
 
     if (SUCCEEDED(rc))

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

@@ -148 +148 @@
     HRESULT importFS(const LocationInfo &locInfo, ComObjPtr<Progress> &aProgress);
     struct ImportStack;
-    void importVBoxMachine(const settings::MachineConfigFile &config,
+    void importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
                            ComPtr<IMachine> &pNewMachine,
                            ImportStack &stack);

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

@@ -364 +364 @@
                  const Guid *aId);
 
+    // initializer for machine config in memory (OVF import)
+    HRESULT init(VirtualBox *aParent,
+                 const Utf8Str &strName,
+                 const settings::MachineConfigFile &config);
+
     void uninit();
 
@@ -370 +375 @@
                      const Utf8Str &strConfigFile);
     HRESULT initDataAndChildObjects();
+    HRESULT registeredInit();
+    HRESULT tryCreateMachineConfigFile(BOOL aOverride);
     void uninitDataAndChildObjects();
 
@@ -703 +710 @@
 protected:
 
-    HRESULT registeredInit();
-
     HRESULT checkStateDependency(StateDependency aDepType);
 
@@ -718 +723 @@
 
     HRESULT loadSettings(bool aRegistered);
+    HRESULT loadMachineDataFromSettings(const settings::MachineConfigFile &config);
     HRESULT loadSnapshot(const settings::Snapshot &data,
                          const Guid &aCurSnapshotId,
@@ -723 +729 @@
     HRESULT loadHardware(const settings::Hardware &data);
     HRESULT loadStorageControllers(const settings::Storage &data,
-                                   bool aRegistered,
                                    const Guid *aSnapshotId = NULL);
     HRESULT loadStorageDevices(StorageController *aStorageController,
                                const settings::StorageController &data,
-                               bool aRegistered,
                                const Guid *aSnapshotId = NULL);