feat(ll-driver-detect): add driver upgrade

1. Add driver upgrade and improves detection accuracy with remote repository integration.
2. Optimize unit tests.

Author: dengbo11

apps/ll-driver-detect/CMakeLists.txt

@@ -16,6 +16,4 @@ pfl_add_executable(
   ./src/dbus_notifier.cpp
   LINK_LIBRARIES
   PRIVATE
-  CLI11::CLI11
-  linglong::linglong
-  linglong::utils)
+  linglong::linglong)

apps/ll-driver-detect/src/driver_detection_manager.cpp

@@ -4,6 +4,7 @@
 
 #include "driver_detection_manager.h"
 
+#include "linglong/utils/cmd.h"
 #include "linglong/utils/log/log.h"
 #include "nvidia_driver_detector.h"
 
@@ -14,9 +15,10 @@ DriverDetectionManager::DriverDetectionManager()
     registerDetectors();
 }
 
-utils::error::Result<DriverDetectionResult> DriverDetectionManager::detectAllDrivers()
+utils::error::Result<std::vector<GraphicsDriverInfo>>
+DriverDetectionManager::detectAvailableDrivers()
 {
-    DriverDetectionResult result;
+    std::vector<GraphicsDriverInfo> detectedDrivers;
 
     for (const auto &detector : detectors_) {
         auto detectionResult = detector->detect();
@@ -27,13 +29,13 @@ utils::error::Result<DriverDetectionResult> DriverDetectionManager::detectAllDri
             continue;
         }
 
-        result.detectedDrivers.emplace_back(*detectionResult);
+        detectedDrivers.emplace_back(*detectionResult);
         LogD("Detected driver: {} version: {}",
              detectionResult->packageName,
-             detectionResult->version);
+             detectionResult->packageVersion);
     }
 
-    return result;
+    return detectedDrivers;
 }
 
 void DriverDetectionManager::registerDetectors()
@@ -46,4 +48,33 @@ void DriverDetectionManager::registerDetectors()
     LogD("Registered {} driver detectors", detectors_.size());
 }
 
+linglong::utils::error::Result<void>
+DriverDetectionManager::installDriverPackage(const std::vector<GraphicsDriverInfo> &drivers)
+{
+    LINGLONG_TRACE("installDriverPackage")
+
+    try {
+        for (const auto &info : drivers) {
+            LogD("Processing driver: Identify={}, Version={}, Package={}",
+                 info.identify,
+                 info.packageVersion,
+                 info.packageName);
+
+            // Execute ll-cli install command to install the package
+            auto packageRef = info.packageName + "/" + info.packageVersion;
+            auto ret = linglong::utils::Cmd("ll-cli").exec(
+              { "install", packageRef, "--repo", info.repoName });
+            if (!ret) {
+                return LINGLONG_ERR("Installation command failed: " + ret.error().message());
+            }
+
+            LogD("Driver package installation command executed successfully: {}", *ret);
+        }
+
+        return LINGLONG_OK;
+    } catch (const std::exception &e) {
+        return LINGLONG_ERR("Failed to install driver package: " + std::string(e.what()));
+    }
+}
+
 } // namespace linglong::driver::detect

apps/ll-driver-detect/src/driver_detection_manager.h

@@ -6,25 +6,11 @@
 
 #include "driver_detector.h"
 
-#include <algorithm>
 #include <memory>
 #include <vector>
 
 namespace linglong::driver::detect {
 
-// Result of driver detection for all available drivers
-struct DriverDetectionResult
-{
-    std::vector<GraphicsDriverInfo> detectedDrivers;
-
-    bool hasAvailableDrivers() const
-    {
-        return std::any_of(detectedDrivers.begin(), detectedDrivers.end(), [](const auto &driver) {
-            return !driver.isInstalled;
-        });
-    }
-};
-
 // Manager class that coordinates detection of multiple graphics drivers
 class DriverDetectionManager
 {
@@ -34,12 +20,12 @@ class DriverDetectionManager
 
     // Detect all available graphics drivers on the system
     // Returns all detected drivers, or empty vector if none found
-    utils::error::Result<DriverDetectionResult> detectAllDrivers();
+    utils::error::Result<std::vector<GraphicsDriverInfo>> detectAvailableDrivers();
+    linglong::utils::error::Result<void> installDriverPackage(const std::vector<GraphicsDriverInfo> &drivers);
 
 protected:
     // Register all available driver detectors
     virtual void registerDetectors();
-
     std::vector<std::unique_ptr<DriverDetector>> detectors_;
 };
 

apps/ll-driver-detect/src/driver_detector.h

@@ -6,16 +6,71 @@
 
 #include "linglong/utils/error/error.h"
 
+#include <algorithm>
+#include <charconv>
 #include <string>
+#include <string_view>
+#include <vector>
 
 namespace linglong::driver::detect {
 
+inline std::vector<int> splitVersion(std::string_view version)
+{
+    constexpr size_t expected_components = 4;
+    std::vector<int> components;
+    components.reserve(expected_components);
+
+    auto convert_part = [](std::string_view part) -> int {
+        int val = 0;
+        auto result = std::from_chars(part.data(), part.data() + part.size(), val);
+        if (result.ec == std::errc::invalid_argument
+            || result.ec == std::errc::result_out_of_range) {
+            throw std::invalid_argument("Invalid version number component");
+        }
+        return val;
+    };
+
+    size_t pos = 0;
+    size_t prev = 0;
+
+    while ((pos = version.find('.', prev)) != std::string_view::npos) {
+        components.push_back(convert_part(version.substr(prev, pos - prev)));
+        prev = pos + 1;
+    }
+
+    if (prev < version.size()) {
+        components.push_back(convert_part(version.substr(prev)));
+    }
+
+    return components;
+}
+
+inline int compareVersions(std::string_view v1, std::string_view v2)
+{
+    auto vec1 = splitVersion(v1);
+    auto vec2 = splitVersion(v2);
+
+    const size_t size1 = vec1.size();
+    const size_t size2 = vec2.size();
+    const size_t max_size = std::max(size1, size2);
+
+    for (size_t i = 0; i < max_size; ++i) {
+        int val1 = (i < size1) ? vec1[i] : 0;
+        int val2 = (i < size2) ? vec2[i] : 0;
+
+        if (val1 != val2) {
+            return (val1 > val2) ? 1 : -1;
+        }
+    }
+    return 0;
+}
+
 struct GraphicsDriverInfo
 {
     std::string identify;
-    std::string version;
     std::string packageName;
-    bool isInstalled = false;
+    std::string packageVersion;
+    std::string repoName{ "stable" };
 };
 
 class DriverDetector
@@ -29,6 +84,9 @@ class DriverDetector
     // Check if the driver package is installed
     virtual utils::error::Result<bool> checkPackageInstalled(const std::string &packageName) = 0;
 
+    // Check if the driver package can upgraded
+    virtual utils::error::Result<bool> checkPackageUpgradable(const std::string &packageName) = 0;
+
     // Get the Identify of driver this detector handles
     virtual std::string getDriverIdentify() const = 0;
 };

apps/ll-driver-detect/src/main.cpp

@@ -9,7 +9,6 @@
 #include "driver_detection_manager.h"
 #include "driver_detector.h"
 #include "linglong/common/global/initialize.h"
-#include "linglong/utils/cmd.h"
 #include "linglong/utils/error/error.h"
 #include "linglong/utils/gettext.h"
 #include "tl/expected.hpp"
@@ -86,41 +85,6 @@ linglong::utils::error::Result<DriverDetectionConfigManager> setupConfigManager(
     return configManager;
 }
 
-linglong::utils::error::Result<void>
-installDriverPackage(const std::vector<GraphicsDriverInfo> &drivers)
-{
-    LINGLONG_TRACE("installDriverPackage")
-
-    try {
-        for (const auto &driverInfo : drivers) {
-            LogD("Processing driver: Identify={}, Version={}, Package={}, Installed={}",
-                 driverInfo.identify,
-                 driverInfo.version,
-                 driverInfo.packageName,
-                 driverInfo.isInstalled);
-
-            if (driverInfo.isInstalled) {
-                LogD("Driver package is already installed: {}", driverInfo.packageName);
-                continue;
-            }
-
-            // Execute ll-cli install command to install the package
-            auto ret = linglong::utils::Cmd("ll-cli").exec({ "install", driverInfo.packageName });
-            if (!ret) {
-                return LINGLONG_ERR("Installation command failed: " + ret.error().message());
-            }
-
-            LogD("Driver package installation command executed successfully: {}", *ret);
-        }
-
-        return LINGLONG_OK;
-    } catch (const std::exception &e) {
-        return LINGLONG_ERR("Failed to install driver package: " + std::string(e.what()));
-    }
-
-    return LINGLONG_OK;
-}
-
 } // namespace
 
 int main(int argc, char *argv[])
@@ -191,7 +155,7 @@ int main(int argc, char *argv[])
     DriverDetectionManager detectionManager;
 
     // Run driver detection and handling for all available drivers
-    auto result = detectionManager.detectAllDrivers();
+    auto result = detectionManager.detectAvailableDrivers();
 
     if (!result) {
         LogF("Driver detection failed: {}", result.error().message());
@@ -201,8 +165,8 @@ int main(int argc, char *argv[])
 
     const auto &detectionResult = *result;
 
-    if (!detectionResult.hasAvailableDrivers()) {
-        std::cout << "No available graphics drivers detected or already installed" << std::endl;
+    if (detectionResult.size() == 0) {
+        LogD("No graphics drivers detected that require installation or upgrade");
         return 0;
     }
 
@@ -211,22 +175,21 @@ int main(int argc, char *argv[])
                      "will be performed."
                   << std::endl;
         std::cout << "Detected drivers:" << std::endl;
-        for (const auto &driverInfo : detectionResult.detectedDrivers) {
+        for (const auto &info : detectionResult) {
             std::cout << "----------------------------------------" << std::endl;
-            std::cout << "  Identify: " << driverInfo.identify << std::endl;
-            std::cout << "  Version: " << driverInfo.version << std::endl;
-            std::cout << "  Package: " << driverInfo.packageName << std::endl;
-            std::cout << "  Installed: " << (driverInfo.isInstalled ? "Yes" : "No") << std::endl;
+            std::cout << "  Identify: " << info.identify << std::endl;
+            std::cout << "  Version: " << info.packageVersion << std::endl;
+            std::cout << "  Package: " << info.packageName << std::endl;
             std::cout << "----------------------------------------" << std::endl;
         }
         return 0;
     }
 
-    LogD("Detected {} graphics driver(s)", detectionResult.detectedDrivers.size());
+    LogD("Detected {} graphics driver(s)", detectionResult.size());
 
     if (options.installOnly) {
         std::cout << "Install-only: installing detected drivers without notifications" << std::endl;
-        auto installResult = installDriverPackage(detectionResult.detectedDrivers);
+        auto installResult = detectionManager.installDriverPackage(detectionResult);
         if (!installResult) {
             LogW("Failed to install driver package {}: {}",
                  options.packageName,
@@ -270,7 +233,7 @@ int main(int argc, char *argv[])
     if (response.action == kActionInstallNow && response.success) {
         LogD("User chose to install graphics driver");
 
-        auto installResult = installDriverPackage(detectionResult.detectedDrivers);
+        auto installResult = detectionManager.installDriverPackage(detectionResult);
         if (!installResult) {
             LogW("Failed to install driver package: {}", installResult.error().message());
             return 1;