Changeset 2029 in vbox for trunk/src/VBox

Timestamp:

Apr 11, 2007 1:23:03 PM (18 years ago)

Author:

vboxsync

Message:

Main: Added IVirtualBox::findHardDisk().
VBoxSDL: Fixed so that .vmdk images can be passed using the -hda switch.

Location:

trunk/src/VBox

Files:

• Frontends/VBoxSDL/VBoxSDL.cpp (modified) (1 diff)
• Main/VirtualBoxImpl.cpp (modified) (3 diffs)
• Main/idl/VirtualBox.xidl (modified) (3 diffs)
• Main/include/VirtualBoxImpl.h (modified) (3 diffs)
• Main/testcase/tstAPI.cpp (modified) (1 diff)

trunk/src/VBox/Frontends/VBoxSDL/VBoxSDL.cpp

@@ -1330 +1330 @@
         Bstr hdaFileBstr = hdaFile;
         ComPtr<IHardDisk> hardDisk;
-        ComPtr<IVirtualDiskImage> vdi;
-        virtualBox->FindVirtualDiskImage(hdaFileBstr, vdi.asOutParam());
-        if (vdi)
-        {
-            vdi.queryInterfaceTo (hardDisk.asOutParam());
-        }
-        else
+        virtualBox->FindHardDisk(hdaFileBstr, hardDisk.asOutParam());
+        if (!hardDisk)
         {
             /* we've not found the image */
             RTPrintf("Registering hard disk image %s\n", hdaFile);
-            virtualBox->OpenVirtualDiskImage (hdaFileBstr, vdi.asOutParam());
-            if (vdi)
-            {
-                vdi.queryInterfaceTo (hardDisk.asOutParam());
+            virtualBox->OpenHardDisk (hdaFileBstr, hardDisk.asOutParam());
+            if (hardDisk)
                 virtualBox->RegisterHardDisk (hardDisk);
-            }
         }
         /* do we have the right image now? */

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -1082 +1082 @@
     Guid id = aId;
     ComObjPtr <HardDisk> hd;
-    HRESULT rc = findHardDisk (id, true /* setError */, &hd);
+    HRESULT rc = findHardDisk (&id, NULL, true /* setError */, &hd);
 
     /* the below will set *aHardDisk to NULL if hd is null */
     hd.queryInterfaceTo (aHardDisk);
+
+    return rc;
+}
+
+/** @note Locks objects! */
+STDMETHODIMP VirtualBox::FindHardDisk (INPTR BSTR aLocation,
+                                       IHardDisk **aHardDisk)
+{
+   if (!aLocation)
+        return E_INVALIDARG;
+   if (!aHardDisk)
+        return E_POINTER;
+
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    Utf8Str location = aLocation;
+    if (strncmp (location, "iscsi:", 6) == 0)
+    {
+        /* nothing special */
+    }
+    else
+    {
+        /* For locations represented by file paths, append the default path if
+         * only a name is given, and then get the full path. */
+        if (!RTPathHavePath (location))
+        {
+            AutoLock propsLock (mData.mSystemProperties);
+            location = Utf8StrFmt ("%ls%c%s",
+                                   mData.mSystemProperties->defaultVDIFolder().raw(),
+                                   RTPATH_DELIMITER,
+                                   location.raw());
+        }
+
+        /* get the full file name */
+        char buf [RTPATH_MAX];
+        int vrc = RTPathAbsEx (mData.mHomeDir, location, buf, sizeof (buf));
+        if (VBOX_FAILURE (vrc))
+            return setError (E_FAIL, tr ("Invalid hard disk location '%ls' (%Vrc)"),
+                             aLocation, vrc);
+        location = buf;
+    }
+
+    ComObjPtr <HardDisk> hardDisk;
+    HRESULT rc = findHardDisk (NULL, Bstr (location), true /* setError */,
+                               &hardDisk);
+
+    /* the below will set *aHardDisk to NULL if hardDisk is null */
+    hardDisk.queryInterfaceTo (aHardDisk);
 
     return rc;
@@ -1146 +1195 @@
     Guid id = aId;
     ComObjPtr <HardDisk> hd;
-    HRESULT rc = findHardDisk (id, true /* setError */, &hd);
+    HRESULT rc = findHardDisk (&id, NULL, true /* setError */, &hd);
     CheckComRCReturnRC (rc);
 
@@ -2962 +3011 @@
 }
 
-/** @note Locks this object for reading. */
-HRESULT VirtualBox::findHardDisk (const Guid &aId, bool aSetError,
-                                  ComObjPtr <HardDisk> *aHardDisk /* = NULL */)
-{
-    AutoCaller autoCaller (this);
-    AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
+/**
+ *  Searches for a HardDisk object with the given ID or location specification
+ *  in the collection of registered hard disks. If both ID and location are
+ *  specified, the first object that matches either of them (not necessarily
+ *  both) is returned.
+ *
+ *  @param aId          ID of the hard disk (NULL when unused)
+ *  @param aLocation    full location specification (NULL when unused)
+ *  @param aSetError    if TRUE, the appropriate error info is set in case when
+ *                      the disk is not found and only one search criteria (ID
+ *                      or file name) is specified.
+ *  @param aHardDisk    where to store the found hard disk object (can be NULL)
+ *
+ *  @return
+ *      S_OK when found or E_INVALIDARG when not found
+ *
+ *  @note Locks objects for reading!
+ */
+HRESULT VirtualBox::
+findHardDisk (const Guid *aId, const BSTR aLocation,
+              bool aSetError, ComObjPtr <HardDisk> *aHardDisk /* = NULL */)
+{
+    ComAssertRet (aId || aLocation, E_INVALIDARG);
 
     AutoReaderLock alock (this);
 
-    HardDiskMap::const_iterator it = mData.mHardDiskMap.find (aId);
-
-    if (it != mData.mHardDiskMap.end())
-    {
-        if (aHardDisk)
-            *aHardDisk = (*it).second;
-        return S_OK;
-    }
-
-    if (aSetError)
-    {
-        setError (E_INVALIDARG,
-            tr ("Could not find a registered hard disk with UUID {%Vuuid}"),
-            aId.raw());
-    }
-
-    return E_INVALIDARG;
-}
-
-/**
+    /* first lookup the map by UUID if UUID is provided */
+    if (aId)
+    {
+        HardDiskMap::const_iterator it = mData.mHardDiskMap.find (*aId);
+        if (it != mData.mHardDiskMap.end())
+        {
+            if (aHardDisk)
+                *aHardDisk = (*it).second;
+            return S_OK;
+        }
+    }
+
+    /* then iterate and find by location */
+    bool found = false;
+    if (aLocation)
+    {
+        Utf8Str location = aLocation;
+
+        for (HardDiskMap::const_iterator it = mData.mHardDiskMap.begin();
+             !found && it != mData.mHardDiskMap.end();
+             ++ it)
+        {
+            const ComObjPtr <HardDisk> &hd = (*it).second;
+            AutoReaderLock hdLock (hd);
+
+            if (hd->storageType() == HardDiskStorageType_VirtualDiskImage ||
+                hd->storageType() == HardDiskStorageType_VMDKImage)
+            {
+                /* locations of VDI and VMDK hard disks for now are just
+                 * file paths */
+                found = RTPathCompare (location, 
+                                       Utf8Str (hd->toString
+                                                (false /* aShort */))) == 0;
+            }
+            else
+            {
+                found = aLocation == hd->toString (false /* aShort */);
+            }
+
+            if (found && aHardDisk)
+                *aHardDisk = hd;
+        }
+    }
+
+    HRESULT rc = found ? S_OK : E_INVALIDARG;
+
+    if (aSetError && !found)
+    {
+        if (aId && !aLocation)
+            setError (rc, tr ("Could not find a registered hard disk "
+                              "with UUID {%Vuuid}"), aId->raw());
+        else if (aLocation && !aId)
+            setError (rc, tr ("Could not find a registered hard disk "
+                              "with location '%ls'"), aLocation);
+    }
+
+    return rc;
+}
+
+/**
+ *  @deprecated Use #findHardDisk() instead.
+ *
  *  Searches for a HVirtualDiskImage object with the given ID or file path in the
  *  collection of registered hard disks. If both ID and file path are specified,

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

@@ -617 +617 @@
     <interface
         name="IVirtualBox" extends="$dispatched"
-        uuid="00f4e8eb-d737-4c88-9ccb-b434edf8b912"
+        uuid="ce54ff3d-0e46-41ae-a0de-202ed0c3c668"
     >
       <desc> The main interface exposed by the product that provides virtual
@@ -969 +969 @@
                 until <link to="#registerHardDisk()"/> is called.
 
+                @deprecated Use <link to="#openHardDisk()"/> instead.
+
                 <note>Opening differencing images is not supported.</note>
 
@@ -1016 +1018 @@
         </method>
 
+        <method name="findHardDisk">
+            <desc>
+
+                Returns a registered hard disk that uses the given location to
+                store data. The search is done by comparing the
+                value of the @a location argument to the
+                <link to="IHardDisk::location"/> attribute of each registered
+                hard disk.
+
+                For locations repesented by file paths (such as VDI and VMDK
+                images), the specified location can be either an absolute file
+                path or a path relative to
+                the <link to="IVirtualBox::homeFolder"> VirtualBox home
+                directory</link>. If only a file name without any path is
+                given, the <link to="ISystemProperties::defaultVDIFolder">
+                default VDI folder</link> will be used as a path to construct
+                the absolute image file name to search for. Note that on host
+                systems with case sensitive filesystems, a case sensitive
+                comparison is performed, otherwise the case of symbols in the
+                file path is ignored.
+
+            </desc>
+            <param name="location" type="wstring" dir="in">
+                <desc>Hard disk location specification to search for.</desc>
+            </param>
+            <param name="hardDisk" type="IHardDisk" dir="return">
+                <desc>Found hard disk object.</desc>
+            </param>
+        </method>
+
         <method name="findVirtualDiskImage">
             <desc>
 
                 Returns a registered hard disk that uses the given image file.
+
+                @deprecated Use <link to="#findHardDisk()"/> instead.
 
                 <note>The specified file path can be absolute (full path) or

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

@@ -141 +141 @@
     STDMETHOD(OpenVirtualDiskImage) (INPTR BSTR aFilePath, IVirtualDiskImage **aImage);
     STDMETHOD(RegisterHardDisk) (IHardDisk *aHardDisk);
-    STDMETHOD(GetHardDisk) (INPTR GUIDPARAM id, IHardDisk **hardDisk);
+    STDMETHOD(GetHardDisk) (INPTR GUIDPARAM aId, IHardDisk **aHardDisk);
+    STDMETHOD(FindHardDisk) (INPTR BSTR aLocation, IHardDisk **aHardDisk);
     STDMETHOD(FindVirtualDiskImage) (INPTR BSTR aFilePath, IVirtualDiskImage **aImage);
     STDMETHOD(UnregisterHardDisk) (INPTR GUIDPARAM aId, IHardDisk **aHardDisk);
@@ -229 +230 @@
     HRESULT getHardDisk (const Guid &aId, ComObjPtr <HardDisk> &aHardDisk)
     {
-        return findHardDisk (aId, true /* aDoSetError */, &aHardDisk);
+        return findHardDisk (&aId, NULL, true /* aDoSetError */, &aHardDisk);
     }
 
@@ -274 +275 @@
                          ComObjPtr <Machine> *machine = NULL);
 
-    HRESULT findHardDisk (const Guid &aId, bool aSetError,
-                          ComObjPtr <HardDisk> *aHardDisk = NULL);
+    HRESULT findHardDisk (const Guid *aId, const BSTR aLocation,
+                          bool aSetError, ComObjPtr <HardDisk> *aHardDisk = NULL);
 
     HRESULT findVirtualDiskImage (const Guid *aId, const BSTR aFilePathFull,

trunk/src/VBox/Main/testcase/tstAPI.cpp

@@ -448 +448 @@
             vdi->COMGETTER(FilePath) (dst.asOutParam());
             RTPrintf ("Actual clone path is '%ls'\n", dst.raw());
+        }
+    }
+    while (FALSE);
+    printf ("\n");
+#endif
+
+#if 1
+    // find a registered hard disk by location
+    ///////////////////////////////////////////////////////////////////////////
+    do
+    {
+        ComPtr <IHardDisk> hd;
+        static wchar_t *Names[] =
+        {
+#ifndef __LINUX__
+            L"E:/Develop/innotek/images/thinker/freedos.vdi",
+            L"E:/Develop/innotek/images/thinker/fReeDoS.vDI",
+            L"E:/Develop/innotek/images/vmdk/haiku.vmdk",
+#else
+            L"/mnt/host/common/Develop/innotek/images/maggot/freedos.vdi",
+            L"/mnt/host/common/Develop/innotek/images/maggot/fReeDoS.vDI",
+#endif
+        };
+        for (size_t i = 0; i < ELEMENTS (Names); ++ i)
+        {
+            Bstr src = Names [i];
+            printf ("Searching for hard disk '%ls'...\n", src.raw());
+            rc = virtualBox->FindHardDisk (src, hd.asOutParam());
+            if (SUCCEEDED (rc))
+            {
+                Guid id;
+                Bstr location;
+                CHECK_ERROR_BREAK (hd, COMGETTER(Id) (id.asOutParam()));
+                CHECK_ERROR_BREAK (hd, COMGETTER(Location) (location.asOutParam()));
+                printf ("Found, UUID={%Vuuid}, location='%ls'.\n",
+                        id.raw(), location.raw());
+            }
+            else
+            {
+                PRINT_ERROR_INFO (com::ErrorInfo (virtualBox));
+            }
         }
     }