Merge branch 'OpenAtom-Linyaps:master' into master

Author: myml

.pre-commit-config.yaml

@@ -35,7 +35,7 @@ repos:
       - id: check-xml
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v21.1.5
+    rev: v21.1.8
     hooks:
       - id: clang-format
         name: clang-format (C/C++)

api/schema/v1.json

@@ -1034,7 +1034,8 @@
       "description": "package manager update result",
       "required": [
         "packages",
-        "depsOnly"
+        "depsOnly",
+        "appOnly"
       ],
       "properties": {
         "packages": {
@@ -1047,6 +1048,10 @@
         "depsOnly": {
           "type": "boolean",
           "description": "upgrade dependencies only"
+        },
+        "appOnly": {
+          "type": "boolean",
+          "description": "upgrade applications only"
         }
       }
     },

api/schema/v1.yaml

@@ -792,6 +792,7 @@ $defs:
     required:
       - packages
       - depsOnly
+      - appOnly
     properties:
       packages:
         type: array
@@ -801,6 +802,9 @@ $defs:
       depsOnly:
         type: boolean
         description: upgrade dependencies only
+      appOnly:
+        type: boolean
+        description: upgrade applications only
   PackageManager1ModifyRepoParameters:
     type: object
     required:

apps/ll-cli/src/main.cpp

@@ -32,6 +32,7 @@
 #include <cstddef>
 #include <functional>
 #include <memory>
+#include <string_view>
 #include <thread>
 
 #include <fcntl.h>
@@ -67,36 +68,13 @@ void startProcess(const QString &program, const QStringList &args = {})
 std::vector<std::string> transformOldExec(int argc, char **argv) noexcept
 {
     std::vector<std::string> res;
-    std::reverse_copy(argv + 1, argv + argc, std::back_inserter(res));
-    if (std::find(res.rbegin(), res.rend(), "run") == res.rend()) {
-        return res;
-    }
-
-    auto exec = std::find(res.rbegin(), res.rend(), "--exec");
-    if (exec == res.rend()) {
-        return res;
-    }
 
-    if ((exec + 1) == res.rend() || (exec + 2) != res.rend()) {
-        *exec = "--";
-        LogD("replace `--exec` with `--`");
-        return res;
-    }
-
-    wordexp_t words;
-    auto _ = linglong::utils::finally::finally([&]() {
-        wordfree(&words);
-    });
-
-    if (auto ret = wordexp((exec + 1)->c_str(), &words, 0); ret != 0) {
-        LogE("wordexp on {} failed with {} transform old exec arguments failed.", *(exec + 1), ret);
-        return res;
-    }
-
-    auto it = res.erase(res.rend().base(), exec.base());
-    res.emplace(it, "--");
-    for (decltype(words.we_wordc) i = 0; i < words.we_wordc; ++i) {
-        res.emplace(res.begin(), words.we_wordv[i]);
+    for (int i = argc - 1; i > 0; --i) {
+        if (std::string_view(argv[i]) == "--exec") {
+            res.emplace_back("--");
+        } else {
+            res.emplace_back(argv[i]);
+        }
     }
 
     return res;
@@ -355,9 +333,11 @@ void addUpgradeCommand(CLI::App &commandParser,
                    _("Specify the application ID. If it not be specified, all "
                      "applications will be upgraded"))
       ->check(validatorString);
-    cliUpgrade->add_flag("--deps-only",
-                         upgradeOptions.depsOnly,
-                         _("Only upgrade dependencies of application"));
+    auto depsOnly = cliUpgrade->add_flag("--deps-only",
+                                         upgradeOptions.depsOnly,
+                                         _("Only upgrade dependencies of application"));
+    cliUpgrade->add_flag("--app-only", upgradeOptions.appOnly, _("Only upgrade application"))
+      ->excludes(depsOnly);
 }
 
 // Function to add the search subcommand

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_config.cpp

@@ -42,8 +42,9 @@ bool DriverDetectionConfigManager::loadConfig()
     }
 
     // Parse configuration
-    if (jsonConfig.contains("neverRemind") && jsonConfig["neverRemind"].is_boolean()) {
-        config.neverRemind = jsonConfig["neverRemind"];
+    auto neverRemindIter = jsonConfig.find("neverRemind");
+    if (neverRemindIter != jsonConfig.end() && neverRemindIter->is_boolean()) {
+        config.neverRemind = *neverRemindIter;
     }
 
     return true;

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,13 @@ 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

@@ -13,9 +13,9 @@ namespace linglong::driver::detect {
 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 +29,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;