Support for mambajs's environment lockfile format (#4085)

Author: Klaim

_typos.toml

@@ -5,3 +5,4 @@ pn = "pn"
 Ome = "Ome"
 haa = "haa"
 "fo" = "fo"
+"ba" = "ba"

libmamba/CMakeLists.txt

@@ -222,6 +222,9 @@ set(
     ${LIBMAMBA_SOURCE_DIR}/core/context.cpp
     ${LIBMAMBA_SOURCE_DIR}/core/download_progress_bar.cpp
     ${LIBMAMBA_SOURCE_DIR}/core/env_lockfile.cpp
+    ${LIBMAMBA_SOURCE_DIR}/core/env_lockfile_impl.hpp
+    ${LIBMAMBA_SOURCE_DIR}/core/env_lockfile_conda.cpp
+    ${LIBMAMBA_SOURCE_DIR}/core/env_lockfile_mambajs.cpp
     ${LIBMAMBA_SOURCE_DIR}/core/environments_manager.cpp
     ${LIBMAMBA_SOURCE_DIR}/core/error_handling.cpp
     ${LIBMAMBA_SOURCE_DIR}/core/execution.cpp

libmamba/include/mamba/core/env_lockfile.hpp

@@ -25,36 +25,38 @@ namespace mamba
     class Context;
     class ChannelContext;
 
-    enum class file_parsing_error_code
+    enum class lockfile_parsing_error_code
     {
-        unknown_failure,      /// Something failed while parsing but we can't identify what.
-        unsupported_version,  /// The version of the file does not matched supported ver.
-        parsing_failure,      /// The content of the file doesnt match the expected format/language
-                              /// structure or constraints.
-        invalid_data,         /// The structure of the data in the file is fine but some fields have
-                              /// invalid values for our purpose.
+        unknown_failure,      ///< Something failed while parsing but we can't identify what.
+        unsupported_version,  ///< The version of the file does not matched supported ver.
+        parsing_failure,  ///< The content of the file doesn't match the expected format/language
+                          ///< structure or constraints.
+        invalid_data,     ///< The structure of the data in the file is fine but some fields have
+                          ///< invalid values for our purpose.
+        not_env_lockfile  ///< The file doesn't seem to be a valid or supported lockfile file
+                          ///< format.
     };
 
-    struct EnvLockFileError
+    struct EnvLockFileError  // TODO: inherit from mamba error
     {
-        file_parsing_error_code parsing_error_code = file_parsing_error_code::unknown_failure;
-        std::optional<std::type_index> yaml_error_type{};
+        lockfile_parsing_error_code parsing_error_code = lockfile_parsing_error_code::unknown_failure;
+        std::optional<std::type_index> error_type{};
 
-        static const EnvLockFileError& get_details(const mamba_error& error)
+        static auto get_details(const mamba_error& error) -> const EnvLockFileError&
         {
             return std::any_cast<const EnvLockFileError&>(error.data());
         }
 
         template <typename StringT>
-        static mamba_error make_error(
-            file_parsing_error_code error_code,
+        static auto make_error(
+            lockfile_parsing_error_code error_code,
             StringT&& msg,
-            std::optional<std::type_index> yaml_error_type = std::nullopt
-        )
+            std::optional<std::type_index> error_type = std::nullopt
+        ) -> mamba_error
         {
             return mamba_error{ std::forward<StringT>(msg),
                                 mamba_error_code::env_lockfile_parsing_failed,
-                                EnvLockFileError{ error_code, yaml_error_type } };
+                                EnvLockFileError{ error_code, error_type } };
         }
     };
 
@@ -64,7 +66,8 @@ namespace mamba
 
         struct Channel
         {
-            std::string url;
+            std::string name;
+            std::vector<std::string> urls;
             std::vector<std::string> used_env_vars;
         };
 
@@ -91,18 +94,62 @@ namespace mamba
         {
         }
 
-        std::vector<specs::PackageInfo> get_packages_for(
-            std::string_view category,
-            std::string_view platform,
-            std::string_view manager
-        ) const;
+        struct PackageFilter
+        {
+            std::optional<std::string> category = std::nullopt;
+            std::optional<std::string> platform = std::nullopt;
+            std::optional<std::string> manager = std::nullopt;
+            bool allow_no_platform = false;  // will match empty platform
+
+            auto matches(const Package& package) const -> bool
+            {
+                bool matches_platform = not platform.has_value() or (package.platform == *platform)
+                                        or (package.platform == "noarch");
+                if (platform.has_value() and not matches_platform and allow_no_platform)
+                {
+                    matches_platform = package.platform.empty();
+                }
+
+                return matches_platform
+                       and (not category.has_value() or (package.category == *category))
+                       and (not manager.has_value() or (package.manager == *manager));
+            }
+
+            auto operator()(const Package& package) const -> bool
+            {
+                return matches(package);
+            }
+        };
+
+        template <typename F>
+            requires std::is_invocable_r_v<bool, F, const Package&>
+        auto get_packages_for(PackageFilter filter, F predicate) const
+            -> std::vector<specs::PackageInfo>
+        {
+            std::vector<specs::PackageInfo> results;
+
+            for (const auto& package : m_packages)
+            {
+                if (filter.matches(package) and predicate(package))
+                {
+                    results.push_back(package.info);
+                }
+            }
+
+            return results;
+        }
+
+        auto get_packages_for(PackageFilter filter) const -> std::vector<specs::PackageInfo>
+        {
+            return get_packages_for(std::move(filter), [](const auto&) { return true; });
+        }
 
-        const std::vector<Package>& get_all_packages() const
+        auto get_all_packages() const -> const std::vector<Package>&
         {
             return m_packages;
         }
 
-        const Meta& get_metadata() const
+        auto get_metadata() const -> const Meta&
         {
             return m_metadata;
         }
@@ -113,14 +160,37 @@ namespace mamba
         std::vector<Package> m_packages;
     };
 
-    /// Read an environment lock YAML file and returns it's structured content or an error if
+    /// Describes a format of environment lockfile file supported by this library.
+    enum class EnvLockfileFormat
+    {
+        undefined,    ///< We don't know the format of the file.
+        conda_yaml,   ///< conda's yaml-based environment lockfile format.
+        mambajs_json  ///< mambajs's json-based environment lockfile format.
+    };
+
+    /// Read an environment lock-file and returns it's structured content or an error if
     /// failed.
-    tl::expected<EnvironmentLockFile, mamba_error>
-    read_environment_lockfile(const mamba::fs::u8path& lockfile_location);
+    ///
+    /// @param lockfile_location The filesystem path to the file to open and read.
+    /// @param file_format The expected file format of the file. If `undefined`, which is the
+    ///        default value, we guess based on the file's extension and content.
+    auto read_environment_lockfile(
+        const fs::u8path& lockfile_location,
+        EnvLockfileFormat file_format = EnvLockfileFormat::undefined
+    ) -> tl::expected<EnvironmentLockFile, mamba_error>;
+
 
+    /// Returns `true` if the filename matches names of files which should be interpreted as conda
+    /// or mambajs environment lockfile.
+    /// NOTE: this does not check if the file exists.
+    auto is_env_lockfile_name(std::string_view filename) -> bool;
 
     /// Returns `true` if the filename matches names of files which should be interpreted as conda
-    /// environment lockfile. NOTE: this does not check if the file exists.
-    bool is_env_lockfile_name(std::string_view filename);
+    /// NOTE: this does not check if the file exists.
+    auto is_conda_env_lockfile_name(std::string_view filename) -> bool;
+
+    /// Deduce the environment lockfile format of a file path based on it's filename.
+    /// TODO: more info?
+    auto deduce_env_lockfile_format(const fs::u8path& lockfile_location) -> EnvLockfileFormat;
 }
 #endif

libmamba/include/mamba/specs/package_info.hpp

@@ -66,6 +66,9 @@ namespace mamba::specs
         PackageType package_type = PackageType::Unknown;
 
         [[nodiscard]] static auto from_url(std::string_view url) -> expected_parse_t<PackageInfo>;
+        [[nodiscard]] auto url_for_channel(std::string_view channel_mirror_url) const -> std::string;
+        [[nodiscard]] auto
+        url_for_channel_platform(std::string_view channel_mirror_platform_url) const -> std::string;
 
         PackageInfo() = default;
         explicit PackageInfo(std::string name);

libmamba/src/api/configuration.cpp

@@ -1628,7 +1628,18 @@ namespace mamba
                        [&](std::vector<std::string>& value)
                        { return detail::file_specs_hook(*this, value); }
                    )
-                   .description("File (yaml, explicit or plain)"));
+                   .description("File providing package specifications (yaml, explicit or plain, or json)")
+                   // clang-format off
+                   .long_description(unindent(R"(
+                        File providing package specifications, either an
+                        environment file (yaml, explicit or plain) or a
+                        an environment lockfile.
+                        Valid environment lockfile formats: conda-lock file
+                        (see https://github.com/conda/conda-lock , file name must end with '-lock.yaml'
+                         or '-lock.yml') or mambajs's lockfile
+                        (see https://github.com/emscripten-forge/mambajs/blob/main/packages/mambajs-core/schema/ )
+                        )")));
+        // clang-format on
 
         insert(Configurable("no_pin", false)
                    .group("Solver")