allow adding image with sqfs file from internal store (#125)

Author: finkandreas

src/cli/add_remove.cpp

@@ -7,6 +7,7 @@
 #include <fmt/std.h>
 #include <spdlog/spdlog.h>
 
+#include <uenv/env.h>
 #include <uenv/parse.h>
 #include <uenv/print.h>
 #include <uenv/repository.h>
@@ -77,12 +78,33 @@ int image_add(const image_add_args& args, const global_settings& settings) {
 
     spdlog::info("image_add: label {}", *label);
 
-    auto sqfs = uenv::validate_squashfs_image(args.squashfs);
-    if (!sqfs) {
-        term::error("invalid squashfs file {}: {}", args.squashfs,
-                    sqfs.error());
+    const auto env = concretise_env(args.squashfs, {}, settings.config.repo,
+                                    settings.calling_environment);
+    if (!env) {
+        term::error("{}", env.error());
         return 1;
     }
+    if (env->uenvs.size() != 1) {
+        term::error("Too many arguments provided for source squashfs file");
+        return 1;
+    }
+
+    auto concrete_uenv = env->uenvs.begin()->second;
+    bool from_label = concrete_uenv.label.has_value();
+
+    util::expected<squashfs_image, std::string> sqfs;
+    if (from_label) {
+        sqfs.emplace(concrete_uenv.sqfs_path, concrete_uenv.meta_path,
+                     concrete_uenv.digest.value());
+    } else {
+        sqfs =
+            uenv::validate_squashfs_image(env->uenvs.begin()->second.sqfs_path);
+        if (!sqfs) {
+            term::error("invalid squashfs file {}: {}", args.squashfs,
+                        sqfs.error());
+            return 1;
+        }
+    }
     spdlog::info("image_add: squashfs {}", sqfs.value());
 
     //
@@ -144,67 +166,82 @@ int image_add(const image_add_args& args, const global_settings& settings) {
     }
 
     const auto uenv_paths = store->uenv_paths(sqfs->hash);
-
-    //
-    // create the path inside the repo
-    //
-    std::error_code ec;
-    // if the path exists, delete it, as it might contain a partial download
-    if (fs::exists(uenv_paths.store)) {
-        spdlog::debug("image_add: remove the target path {} before copying",
-                      uenv_paths.store.string());
-        fs::remove_all(uenv_paths.store);
-    }
     uenv::uenv_date date{*util::file_creation_date(sqfs->sqfs)};
 
-    fs::create_directories(uenv_paths.store, ec);
-    if (ec) {
-        spdlog::error("unable to create path {}: {}", uenv_paths.store.string(),
-                      ec.message());
-        term::error("unable to add the uenv");
+    bool source_in_repo =
+        util::is_child(sqfs->sqfs, settings.config.repo.value());
+
+    // If an sqfs file is already in repo, and it was pulled from a repository
+    // then there is a digest mismatch. Do not try to add this image
+    // Such images should be retaged with the command:
+    // uenv image add <new-label> <existing-label>
+    if (source_in_repo && !existing_hash) {
+        term::error("image_add: Trying to add a squashfs file which is already "
+                    "in the repository, but the hashes do not match");
         return 1;
     }
 
-    //
-    // copy the meta data into the repo
-    //
-    if (sqfs->meta) {
-        fs::copy_options options{};
-        options |= fs::copy_options::recursive;
-        fs::copy(sqfs->meta.value(), uenv_paths.meta, options, ec);
-        if (ec) {
-            spdlog::error("unable to copy meta data to {}: {}",
-                          uenv_paths.meta.string(), ec.message());
-            term::error("unable to add the uenv");
-            return 1;
+    if (!source_in_repo) {
+        //
+        // create the path inside the repo
+        //
+        std::error_code ec;
+        // if the path exists, delete it, as it might contain a partial download
+        if (fs::exists(uenv_paths.store)) {
+            spdlog::debug("image_add: remove the target path {} before copying",
+                          uenv_paths.store.string());
+            fs::remove_all(uenv_paths.store);
         }
-    }
 
-    // copy or move the
-    if (!args.move) {
-        fs::copy_file(sqfs->sqfs, uenv_paths.squashfs, ec);
+        fs::create_directories(uenv_paths.store, ec);
         if (ec) {
-            spdlog::error("unable to copy squashfs image {} to {}: {}",
-                          sqfs->sqfs.string(), uenv_paths.squashfs.string(),
-                          ec.message());
+            spdlog::error("unable to create path {}: {}",
+                          uenv_paths.store.string(), ec.message());
             term::error("unable to add the uenv");
             return 1;
         }
-    } else {
-        fs::rename(sqfs->sqfs, uenv_paths.squashfs, ec);
-        if (ec) {
-            spdlog::error("unable to move squashfs image {} to {}: {}",
-                          sqfs->sqfs.string(), uenv_paths.squashfs.string(),
-                          ec.message());
-            term::error(
-                "unable to add the uenv\n{}",
-                help::item{help::block{
-                    help::block::admonition::note,
-                    fmt::format(
-                        "check that the file {} is on the same filesystem as "
-                        "the repository, and that you have write access to it.",
-                        sqfs->sqfs.string())}});
-            return 1;
+
+        //
+        // copy the meta data into the repo
+        //
+        if (sqfs->meta) {
+            fs::copy_options options{};
+            options |= fs::copy_options::recursive;
+            fs::copy(sqfs->meta.value(), uenv_paths.meta, options, ec);
+            if (ec) {
+                spdlog::error("unable to copy meta data to {}: {}",
+                              uenv_paths.meta.string(), ec.message());
+                term::error("unable to add the uenv");
+                return 1;
+            }
+        }
+
+        // copy or move the
+        if (!args.move) {
+            fs::copy_file(sqfs->sqfs, uenv_paths.squashfs, ec);
+            if (ec) {
+                spdlog::error("unable to copy squashfs image {} to {}: {}",
+                              sqfs->sqfs.string(), uenv_paths.squashfs.string(),
+                              ec.message());
+                term::error("unable to add the uenv");
+                return 1;
+            }
+        } else {
+            fs::rename(sqfs->sqfs, uenv_paths.squashfs, ec);
+            if (ec) {
+                spdlog::error("unable to move squashfs image {} to {}: {}",
+                              sqfs->sqfs.string(), uenv_paths.squashfs.string(),
+                              ec.message());
+                term::error("unable to add the uenv\n{}",
+                            help::item{help::block{
+                                help::block::admonition::note,
+                                fmt::format("check that the file {} is on the "
+                                            "same filesystem as "
+                                            "the repository, and that you have "
+                                            "write access to it.",
+                                            sqfs->sqfs.string())}});
+                return 1;
+            }
         }
     }
 

src/util/fs.cpp

@@ -246,4 +246,10 @@ read_single_line_file(const std::filesystem::path& path) {
     return std::nullopt;
 }
 
+bool is_child(const std::filesystem::path& child,
+              const std::filesystem::path& parent) {
+    auto rel = child.lexically_relative(parent);
+    return !rel.empty() && *rel.begin() != "..";
+}
+
 } // namespace util

src/util/fs.h

@@ -63,4 +63,8 @@ file_level file_access_level(const std::filesystem::path& path);
 std::optional<std::string>
 read_single_line_file(const std::filesystem::path& path);
 
+// return if a path is inside a directory, i.e. direct or indirect child
+bool is_child(const std::filesystem::path& child,
+              const std::filesystem::path& parent);
+
 } // namespace util

test/integration/cli.bats

@@ -372,6 +372,30 @@ EOF
     assert_line --partial 'quokka/24:v1'
     [ "${#lines[@]}" -eq "4" ]
 
+    # trying to add the same image with a different label pointing to an SQFS file inside the repo should generate a warning
+    run uenv --repo=$RP image add wombat/24:replica@arapiles%zen3 $(uenv --repo=$RP image inspect --format='{sqfs}' wombat/24:v1@arapiles%zen3)
+    assert_success
+    assert_output --partial "warning"
+    assert_output --partial "a uenv with the same sha"
+
+    run uenv --repo=$RP image ls --no-header
+    assert_success
+    assert_line --partial 'wombat/24:v1'
+    assert_line --partial 'wombat/24:replica'
+    [ "${#lines[@]}" -eq "5" ]
+
+    # trying to add the same image by label
+    run uenv --repo=$RP image add numbat/24:replica@arapiles%zen3 numbat/24:v1
+    assert_success
+    assert_output --partial "warning"
+    assert_output --partial "a uenv with the same sha"
+
+    run uenv --repo=$RP image ls --no-header
+    assert_success
+    assert_line --partial 'numbat/24:v1'
+    assert_line --partial 'numbat/24:replica'
+    [ "${#lines[@]}" -eq "6" ]
+
     # TODO:
     # - check a read-only repo
 }

test/unit/fs.cpp

@@ -119,3 +119,26 @@ TEST_CASE("read_single_line_file", "[fs]") {
         REQUIRE(r.value() == "hello world");
     }
 }
+
+TEST_CASE("is_child", "[fs]") {
+    // direct child
+    {
+        const std::filesystem::path child = "/path/to/child";
+        const std::filesystem::path parent = "/path/to";
+        REQUIRE(util::is_child(child, parent));
+    }
+
+    // indirect child
+    {
+        const std::filesystem::path child = "/path/to/child";
+        const std::filesystem::path parent = "/path";
+        REQUIRE(util::is_child(child, parent));
+    }
+
+    // not a child
+    {
+        const std::filesystem::path child = "/path/to/child";
+        const std::filesystem::path parent = "/tmp";
+        REQUIRE(!util::is_child(child, parent));
+    }
+}