Changeset 101164 in vbox for trunk/src/VBox/Main/src-server

Timestamp:

Sep 19, 2023 10:01:39 AM (17 months ago)

Author:

vboxsync

Message:

doc/manual,Frontends/VBoxManage,Main/{Global,GuestOSType,VirtualBox.xidl}:
Extend the OSType struct by including a new element named 'variant'
to provide further guest OS details and aid in guest OS categorization
for the GUI when creating VMs. Populate this field in the
Global::sOSTypes[] table for Linux using the distro name and for BSD
using the BSD flavour. Include the variant information in 'VBoxManage
list ostypes' and add a new 'VBoxManage list osvariants' subcommand.
Add new IVirtualBox methods for accessing the guest OS variant
information: getGuestOSVariantsByFamilyId() and getGuestOSDescsByVariant().
bugref:5936

Location:

trunk/src/VBox/Main/src-server

Files:

• GuestOSTypeImpl.cpp (modified) (2 diffs)
• VirtualBoxImpl.cpp (modified) (1 diff)

trunk/src/VBox/Main/src-server/GuestOSTypeImpl.cpp

@@ -113 +113 @@
     unconst(mFamilyID)                  = ostype.familyId;
     unconst(mFamilyDescription)         = ostype.familyDescription;
+    unconst(mOSVariant)                 = ostype.variant;
     unconst(mID)                        = ostype.id;
     unconst(mDescription)               = ostype.description;
@@ -173 +174 @@
 
 
+HRESULT GuestOSType::getVariant(com::Utf8Str &aVariant)
+{
+    /* mOSVariant is constant during life time, no need to lock */
+    aVariant = mOSVariant;
+
+    return S_OK;
+}
+
+
 HRESULT GuestOSType::getId(com::Utf8Str &aId)
 {

trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

@@ -4402 +4402 @@
 
 /**
+ * Walk the list of GuestOSType objects and return a list of all known guest
+ * OS families.
+ *
+ * @param aOSFamilies    Where to store the list of guest OS families.
+ *
+ * @note Locks the guest OS types list for reading.
+ */
+HRESULT VirtualBox::getGuestOSFamilies(std::vector<com::Utf8Str> &aOSFamilies)
+{
+    std::list<com::Utf8Str> allOSFamilies;
+
+    AutoReadLock alock(m->allGuestOSTypes.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    for (GuestOSTypesOList::const_iterator it = m->allGuestOSTypes.begin();
+         it != m->allGuestOSTypes.end(); ++it)
+    {
+        const Utf8Str &familyId = (*it)->i_familyId();
+        AssertMsg(!familyId.isEmpty(), ("familfyId must not be NULL"));
+        allOSFamilies.push_back(familyId);
+    }
+
+    /* throw out any duplicates */
+    allOSFamilies.sort();
+    allOSFamilies.unique();
+
+    aOSFamilies.resize(allOSFamilies.size());
+    size_t i = 0;
+    for (std::list<com::Utf8Str>::const_iterator it = allOSFamilies.begin();
+         it != allOSFamilies.end(); ++it, ++i)
+        aOSFamilies[i] = (*it);
+
+    return S_OK;
+}
+
+/**
+ * Walk the list of GuestOSType objects and return a list of guest OS
+ * variants which correspond to the supplied guest OS family ID.
+ *
+ * @param strOSFamily    Guest OS family ID.
+ * @param aOSVariants    Where to store the list of guest OS variants.
+ *
+ * @note Locks the guest OS types list for reading.
+ */
+HRESULT VirtualBox::getGuestOSVariantsByFamilyId(const Utf8Str &strOSFamily,
+                                                 std::vector<com::Utf8Str> &aOSVariants)
+{
+    std::list<com::Utf8Str> allOSVariants;
+
+    AutoReadLock alock(m->allGuestOSTypes.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    bool fFoundGuestOSType = false;
+    for (GuestOSTypesOList::const_iterator it = m->allGuestOSTypes.begin();
+         it != m->allGuestOSTypes.end(); ++it)
+    {
+        const Utf8Str &familyId = (*it)->i_familyId();
+        AssertMsg(!familyId.isEmpty(), ("familfyId must not be NULL"));
+        if (familyId.compare(strOSFamily, Utf8Str::CaseInsensitive) == 0)
+        {
+            fFoundGuestOSType = true;
+            break;
+        }
+    }
+
+    if (!fFoundGuestOSType)
+       return setError(VBOX_E_OBJECT_NOT_FOUND,
+                       tr("'%s' is not a valid guest OS family identifier."), strOSFamily.c_str());
+
+    for (GuestOSTypesOList::const_iterator it = m->allGuestOSTypes.begin();
+         it != m->allGuestOSTypes.end(); ++it)
+    {
+        const Utf8Str &familyId = (*it)->i_familyId();
+        AssertMsg(!familyId.isEmpty(), ("familfyId must not be NULL"));
+        if (familyId.compare(strOSFamily, Utf8Str::CaseInsensitive) == 0)
+        {
+            const Utf8Str &strOSVariant = (*it)->i_variant();
+            if (!strOSVariant.isEmpty())
+                allOSVariants.push_back(strOSVariant);
+        }
+    }
+
+    /* throw out any duplicates */
+    allOSVariants.sort();
+    allOSVariants.unique();
+
+    aOSVariants.resize(allOSVariants.size());
+    size_t i = 0;
+    for (std::list<com::Utf8Str>::const_iterator it = allOSVariants.begin();
+         it != allOSVariants.end(); ++it, ++i)
+        aOSVariants[i] = (*it);
+
+    return S_OK;
+}
+
+/**
+ * Walk the list of GuestOSType objects and return a list of guest OS
+ * descriptions which correspond to the supplied guest OS variant.
+ *
+ * @param strOSVariant     Guest OS variant.
+ * @param aGuestOSDescs    Where to store the list of guest OS descriptions..
+ *
+ * @note Locks the guest OS types list for reading.
+ */
+HRESULT VirtualBox::getGuestOSDescsByVariant(const Utf8Str &strOSVariant,
+                                             std::vector<com::Utf8Str> &aGuestOSDescs)
+{
+    std::list<com::Utf8Str> allOSDescs;
+
+    AutoReadLock alock(m->allGuestOSTypes.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    bool fFoundGuestOSVariant = false;
+    for (GuestOSTypesOList::const_iterator it = m->allGuestOSTypes.begin();
+         it != m->allGuestOSTypes.end(); ++it)
+    {
+        const Utf8Str &guestOSVariant = (*it)->i_variant();
+        /* Only some guest OS types have a populated variant value. */
+        if (guestOSVariant.isNotEmpty() &&
+            guestOSVariant.compare(strOSVariant, Utf8Str::CaseInsensitive) == 0)
+        {
+            fFoundGuestOSVariant = true;
+            break;
+        }
+    }
+
+    if (!fFoundGuestOSVariant)
+       return setError(VBOX_E_OBJECT_NOT_FOUND,
+                       tr("'%s' is not a valid guest OS variant."), strOSVariant.c_str());
+
+    for (GuestOSTypesOList::const_iterator it = m->allGuestOSTypes.begin();
+         it != m->allGuestOSTypes.end(); ++it)
+    {
+        const Utf8Str &guestOSVariant = (*it)->i_variant();
+        /* Only some guest OS types have a populated variant value. */
+        if (guestOSVariant.isNotEmpty() &&
+            guestOSVariant.compare(strOSVariant, Utf8Str::CaseInsensitive) == 0)
+        {
+            const Utf8Str &strOSDesc = (*it)->i_description();
+            allOSDescs.push_back(strOSDesc);
+        }
+    }
+
+    aGuestOSDescs.resize(allOSDescs.size());
+    size_t i = 0;
+    for (std::list<com::Utf8Str>::const_iterator it = allOSDescs.begin();
+         it != allOSDescs.end(); ++it, ++i)
+        aGuestOSDescs[i] = (*it);
+
+    return S_OK;
+}
+
+/**
  * Returns the constant pseudo-machine UUID that is used to identify the
  * global media registry.