feat: Inject channels+mirrors coming from mambajs env-lockfiles

libmamba/CMakeLists.txt

@@ -301,6 +301,7 @@ set(
     # Filesystem library
     ${LIBMAMBA_INCLUDE_DIR}/mamba/fs/filesystem.hpp
     # Utility library
+    ${LIBMAMBA_INCLUDE_DIR}/mamba/util/algorithm.hpp
     ${LIBMAMBA_INCLUDE_DIR}/mamba/util/build.hpp
     ${LIBMAMBA_INCLUDE_DIR}/mamba/util/cast.hpp
     ${LIBMAMBA_INCLUDE_DIR}/mamba/util/cfile.hpp

libmamba/include/mamba/api/channel_loader.hpp

@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "mamba/core/error_handling.hpp"
+#include "mamba/specs/channel.hpp"
 #include "mamba/solver/libsolv/repo_info.hpp"
 #include "mamba/specs/package_info.hpp"
 #include "mamba/specs/version.hpp"
@@ -113,7 +114,11 @@ namespace mamba
      * Creates and stores channels in the ChannelContext,
      * and mirrors objects in the Context object.
      */
-    void init_channels(Context& context, ChannelContext& channel_context);
+    void init_channels(
+        Context& context,
+        ChannelContext& channel_context,
+        specs::Channel::UrlPriority priority = specs::Channel::UrlPriority::low
+    );
     void init_channels_from_package_urls(
         Context& context,
         ChannelContext& channel_context,

libmamba/include/mamba/core/channel_context.hpp

@@ -58,6 +58,7 @@ namespace mamba
             -> const channel_list&;
 
         [[nodiscard]] auto params() const -> const specs::ChannelResolveParams&;
+        [[nodiscard]] auto zst_channels() const -> const std::vector<Channel>&;
 
         [[nodiscard]] auto has_zst(const Channel& chan) const -> bool;
 

libmamba/include/mamba/core/env_lockfile.hpp

@@ -77,6 +77,8 @@ namespace mamba
             std::vector<Channel> channels;
             std::vector<std::string> platforms;
             std::vector<std::string> sources;
+            bool enable_channels = true;  ///< `true` if we need to take into account the specified
+                                          ///< channels, `false` if we should ignore them.
         };
 
         struct Package

libmamba/include/mamba/core/transaction.hpp

@@ -106,7 +106,8 @@ namespace mamba
     );
 
     MTransaction create_explicit_transaction_from_lockfile(
-        const Context& ctx,
+        Context& ctx,
+        ChannelContext& channel_context,
         solver::libsolv::Database& database,
         const fs::u8path& env_lockfile_path,
         const std::vector<std::string>& categories,

libmamba/include/mamba/download/mirror_map.hpp

@@ -15,6 +15,7 @@
 #include <unordered_map>
 
 #include "mamba/download/mirror.hpp"
+#include "mamba/specs/channel.hpp"
 #include "mamba/util/iterator.hpp"
 
 namespace mamba::download
@@ -47,7 +48,11 @@ namespace mamba::download
 
         // Stores a provided Mirror IFF no other mirror is already registered with the same id for
         // the specified mirror name. Returns true if the mirror has been stored, false otherwise.
-        bool add_unique_mirror(std::string_view mirror_name, mirror_ptr mirror);
+        bool add_unique_mirror(
+            std::string_view mirror_name,
+            mirror_ptr mirror,
+            specs::Channel::UrlPriority priority = specs::Channel::UrlPriority::low
+        );
 
         // Copy mirrors for a given mirror name from another map. Used when building extended
         // mirror maps (e.g. for shard downloads) that need to include channel mirrors.

libmamba/include/mamba/specs/channel.hpp

@@ -32,6 +32,12 @@ namespace mamba::specs
         using platform_list = util::flat_set<std::string>;
         using channel_list = std::vector<Channel>;
 
+        enum class UrlPriority
+        {
+            high,  ///< associated urls will be placed in the front the list of urls
+            low    ///< associated urls will be placed in the back the list of urls
+        };
+
         [[nodiscard]] static auto resolve(  //
             UnresolvedChannel uc,
             const ChannelResolveParams& params
@@ -74,6 +80,13 @@ namespace mamba::specs
         auto clear_display_name() -> std::string;
         void set_display_name(std::string display_name);
 
+        // Adds mirror urls if not already recorded, by default added at the end of the mirrors
+        // list.
+        void add_mirror_urls(
+            const std::vector<CondaURL>& additional_mirrors,
+            UrlPriority priority = UrlPriority::low
+        );
+
         enum struct Match
         {
             No,
@@ -137,11 +150,11 @@ namespace mamba::specs
 
     struct ChannelResolveParamsView
     {
-        const ChannelResolveParams::platform_list& platforms = {};
-        const CondaURL& channel_alias = {};
-        const ChannelResolveParams::channel_map& custom_channels = {};
-        const ChannelResolveParams::multichannel_map& custom_multichannels = {};
-        const AuthenticationDataBase& authentication_db = {};
+        const ChannelResolveParams::platform_list& platforms;
+        const CondaURL& channel_alias;
+        const ChannelResolveParams::channel_map& custom_channels;
+        const ChannelResolveParams::multichannel_map& custom_multichannels;
+        const AuthenticationDataBase& authentication_db;
         std::string_view home_dir = {};
         std::string_view current_working_dir = {};
     };

libmamba/include/mamba/specs/conda_url.hpp

@@ -7,6 +7,7 @@
 #ifndef MAMBA_SPECS_CONDA_URL_HPP
 #define MAMBA_SPECS_CONDA_URL_HPP
 
+#include <concepts>
 #include <functional>
 #include <string_view>
 
@@ -251,6 +252,29 @@ namespace mamba::specs
     {
         auto operator""_cu(const char* str, std::size_t len) -> CondaURL;
     }
+
+    /** Converts any range of `URL` into a view-range of `CondaURL` values. */
+    template <std::ranges::input_range URLRange>
+        requires std::same_as<std::ranges::range_value_t<URLRange>, util::URL>
+    auto as_conda_urls(URLRange&& values)
+    {
+        return std::views::transform(
+            std::forward<URLRange>(values),
+            [](const util::URL& url) { return CondaURL{ url }; }
+        );
+    }
+
+    /** Converts any range of string-like values into a view-range of `CondaURL` values based on
+     * it's constructor. */
+    template <std::ranges::input_range StringRange>
+        requires(
+            not std::same_as<std::ranges::range_value_t<StringRange>, util::URL>
+        )  // TODO: or only string-like types?
+    auto as_conda_urls(StringRange&& values)
+    {
+        return as_conda_urls(util::as_urls(std::forward<StringRange>(values)));
+    }
+
 }
 
 template <>

libmamba/include/mamba/util/algorithm.hpp

@@ -0,0 +1,57 @@
+// Copyright (c) 2025, QuantStack and Mamba Contributors
+//
+// Distributed under the terms of the BSD 3-Clause License.
+//
+// The full license is in the file LICENSE, distributed with this software.
+
+//////////////////////////////////////////////////////////////////////////////
+// This file provides implementations to generic algorithms which are not yet
+// available in our current C++ version and/or implementations.
+//
+// TODO: replace these implementations by standard implementations
+//       once available.
+//
+
+#ifndef MAMBA_UTIL_ALGORITHM_HPP
+#define MAMBA_UTIL_ALGORITHM_HPP
+
+#include <algorithm>
+#include <concepts>
+#include <iterator>
+#include <ranges>
+
+namespace mamba::stdext  // not using mamba::util because of potential conflicts with existing
+                         // tooling
+{
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // see https://en.cppreference.com/w/cpp/algorithm/ranges/contains.html
+    namespace details
+    {
+        struct contains_fn
+        {
+            template <std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity, class T>
+                requires std::indirect_binary_predicate<std::ranges::equal_to, std::projected<I, Proj>, const T*>
+            constexpr bool operator()(I first, S last, const T& value, Proj proj = {}) const
+            {
+                return std::ranges::find(std::move(first), last, value, proj) != last;
+            }
+
+            template <std::ranges::input_range R, class Proj = std::identity, class T>
+                requires std::indirect_binary_predicate<
+                    std::ranges::equal_to,
+                    std::projected<std::ranges::iterator_t<R>, Proj>,
+                    const T*>
+            constexpr bool operator()(R&& r, const T& value, Proj proj = {}) const
+            {
+                return std::ranges::find(std::ranges::begin(r), std::ranges::end(r), value, proj)
+                       != std::ranges::end(r);
+            }
+        };
+    }
+
+    inline constexpr details::contains_fn contains{};
+
+    /////////////////////////////////////////////////////////////////////////////////////////////////
+
+}
+#endif

libmamba/include/mamba/util/url.hpp

@@ -9,6 +9,7 @@
 
 #include <array>
 #include <functional>
+#include <ranges>
 #include <string>
 #include <string_view>
 
@@ -293,6 +294,17 @@ namespace mamba::util
     /** A functional equivalent to ``URL::append_path``. */
     auto operator/(URL const& url, std::string_view subpath) -> URL;
     auto operator/(URL&& url, std::string_view subpath) -> URL;
+
+    /** Converts any range of string-like values into a view-range of `URL` values. */
+    template <std::ranges::input_range StringRange>
+    auto as_urls(StringRange&& values)
+    {
+        return std::views::transform(
+            std::forward<StringRange>(values),
+            [](const auto& url) { return *URL::parse(url); }
+        );
+    }
+
 }
 
 template <>

libmamba/src/api/channel_loader.cpp

@@ -201,7 +201,11 @@ namespace mamba
         }
 
         // Forward declarations for helpers defined later in this namespace.
-        void create_mirrors(const specs::Channel& channel, download::mirror_map& mirrors);
+        void create_mirrors(
+            const specs::Channel& channel,
+            download::mirror_map& mirrors,
+            specs::Channel::UrlPriority priority = specs::Channel::UrlPriority::low
+        );
 
         void create_subdirs(
             Context& ctx,
@@ -1037,17 +1041,19 @@ namespace mamba
             }
         }
 
-        void create_mirrors(const specs::Channel& channel, download::mirror_map& mirrors)
+        void create_mirrors(
+            const specs::Channel& channel,
+            download::mirror_map& mirrors,
+            specs::Channel::UrlPriority priority
+        )
         {
-            if (!mirrors.has_mirrors(channel.id()))
+            for (const specs::CondaURL& url : channel.mirror_urls())
             {
-                for (const specs::CondaURL& url : channel.mirror_urls())
-                {
-                    mirrors.add_unique_mirror(
-                        channel.id(),
-                        download::make_mirror(url.str(specs::CondaURL::Credentials::Show))
-                    );
-                }
+                mirrors.add_unique_mirror(
+                    channel.id(),
+                    download::make_mirror(url.str(specs::CondaURL::Credentials::Show)),
+                    priority
+                );
             }
         }
 
@@ -1164,14 +1170,15 @@ namespace mamba
         );
     }
 
-    void init_channels(Context& context, ChannelContext& channel_context)
+    void
+    init_channels(Context& context, ChannelContext& channel_context, specs::Channel::UrlPriority priority)
     {
         for (const auto& mirror : context.mirrored_channels)
         {
             for (const specs::Channel& channel :
                  channel_context.make_channel(mirror.first, mirror.second))
             {
-                create_mirrors(channel, context.mirrors);
+                create_mirrors(channel, context.mirrors, priority);
             }
         }
 
@@ -1181,7 +1188,7 @@ namespace mamba
             {
                 for (const specs::Channel& channel : channel_context.make_channel(location))
                 {
-                    create_mirrors(channel, context.mirrors);
+                    create_mirrors(channel, context.mirrors, priority);
                 }
             }
         }

libmamba/src/api/install.cpp

@@ -854,6 +854,7 @@ namespace mamba
             {
                 return create_explicit_transaction_from_lockfile(
                     ctx,
+                    channel_context,
                     db,
                     file,
                     categories,
@@ -1254,15 +1255,18 @@ namespace mamba
 
             auto execute_transaction = [&](MTransaction& transaction)
             {
-                if (ctx.output_params.json)
-                {
-                    transaction.log_json();
-                }
-
                 auto prompt_entry = transaction.prompt(ctx, channel_context);
                 if (prompt_entry)
                 {
                     transaction.execute(ctx, channel_context, prefix_data);
+                    if (ctx.output_params.json)
+                    {
+                        transaction.log_json();
+                    }
+                }
+                else if (ctx.output_params.json)
+                {
+                    transaction.log_json();
                 }
                 return prompt_entry;
             };

libmamba/src/api/utils.cpp

@@ -732,10 +732,6 @@ namespace mamba
         const std::function<void()>& on_abort
     )
     {
-        if (ctx.output_params.json)
-        {
-            transaction.log_json();
-        }
         const auto should_execute = transaction.prompt(ctx, channel_context);
         if (should_execute)
         {
@@ -744,14 +740,25 @@ namespace mamba
                 before_execute();
             }
             transaction.execute(ctx, channel_context, prefix_data);
+            if (ctx.output_params.json)
+            {
+                transaction.log_json();
+            }
             if (after_execute)
             {
                 after_execute();
             }
         }
-        else if (on_abort)
+        else
         {
-            on_abort();
+            if (ctx.output_params.json)
+            {
+                transaction.log_json();
+            }
+            if (on_abort)
+            {
+                on_abort();
+            }
         }
         return should_execute;
     }