[image] Filter unsupported images at manifest parsing

deepakshirkem · deepakshirkem · commit 07dc88035fc1 · 2026-02-25T01:08:21.000+05:30
diff --git a/include/multipass/exceptions/unsupported_image_exception.h b/include/multipass/exceptions/unsupported_image_exception.h
diff --git a/include/multipass/image_host/custom_image_host.h b/include/multipass/image_host/custom_image_host.h
@@ -44,8 +44,7 @@ class CustomVMImageHost final : public BaseVMImageHost
 
     std::optional<VMImageInfo> info_for(const Query& query) override;
     std::vector<std::pair<std::string, VMImageInfo>> all_info_for(const Query& query) override;
-    std::vector<VMImageInfo> all_images_for(const std::string& remote_name,
-                                            const bool allow_unsupported) override;
+    std::vector<VMImageInfo> all_images_for(const std::string& remote_name) override;
     std::vector<std::string> supported_remotes() override;
 
 private:
diff --git a/include/multipass/image_host/ubuntu_image_host.h b/include/multipass/image_host/ubuntu_image_host.h
@@ -40,8 +40,7 @@ class UbuntuVMImageHost final : public BaseVMImageHost
 
     std::optional<VMImageInfo> info_for(const Query& query) override;
     std::vector<std::pair<std::string, VMImageInfo>> all_info_for(const Query& query) override;
-    std::vector<VMImageInfo> all_images_for(const std::string& remote_name,
-                                            const bool allow_unsupported) override;
+    std::vector<VMImageInfo> all_images_for(const std::string& remote_name) override;
     std::vector<std::string> supported_remotes() override;
 
 private:
diff --git a/include/multipass/image_host/vm_image_host.h b/include/multipass/image_host/vm_image_host.h
@@ -39,8 +39,7 @@ class VMImageHost : private DisabledCopyMove
     virtual std::optional<VMImageInfo> info_for(const Query& query) = 0;
     virtual std::vector<std::pair<std::string, VMImageInfo>> all_info_for(const Query& query) = 0;
     virtual VMImageInfo info_for_full_hash(const std::string& full_hash) = 0;
-    virtual std::vector<VMImageInfo> all_images_for(const std::string& remote_name,
-                                                    const bool allow_unsupported) = 0;
+    virtual std::vector<VMImageInfo> all_images_for(const std::string& remote_name) = 0;
     virtual void for_each_entry_do(const Action& action) = 0;
     virtual std::vector<std::string> supported_remotes() = 0;
     virtual void update_manifests(const bool force_update) = 0;
diff --git a/include/multipass/query.h b/include/multipass/query.h
@@ -36,6 +36,5 @@ class Query
     bool persistent;
     std::string remote_name;
     Type query_type;
-    bool allow_unsupported{false};
 };
 } // namespace multipass
diff --git a/src/client/cli/cmd/find.cpp b/src/client/cli/cmd/find.cpp
@@ -72,8 +72,6 @@ mp::ParseCode cmd::Find::parse_args(mp::ArgParser* parser)
         "then search ‘daily‘. <string> can be a partial image hash or a "
         "release version, codename or alias.",
         "[<remote:>][<string>]");
-    QCommandLineOption unsupportedOption("show-unsupported",
-                                         "Show unsupported cloud images as well");
     QCommandLineOption formatOption("format",
                                     "Output list in the requested format.\nValid formats are: "
                                     "table (default), json, csv and yaml",
@@ -82,7 +80,7 @@ mp::ParseCode cmd::Find::parse_args(mp::ArgParser* parser)
     const QCommandLineOption force_manifest_network_download(
         "force-update",
         "Force the image information to update from the network");
-    parser->addOptions({unsupportedOption, formatOption, force_manifest_network_download});
+    parser->addOptions({formatOption, force_manifest_network_download});
 
     auto status = parser->commandParse(this);
 
@@ -116,8 +114,7 @@ mp::ParseCode cmd::Find::parse_args(mp::ArgParser* parser)
             request.set_search_string(search_string.toStdString());
         }
     }
-
-    request.set_allow_unsupported(parser->isSet(unsupportedOption));
+    
     request.set_force_manifest_network_download(parser->isSet(force_manifest_network_download));
 
     status = handle_format_option(parser, &chosen_formatter, cerr);
diff --git a/src/daemon/daemon.cpp b/src/daemon/daemon.cpp
@@ -127,7 +127,7 @@ mp::Query query_from(const mp::LaunchRequest* request, const std::string& name)
     else if (QString::fromStdString(image).startsWith("http"))
         query_type = mp::Query::Type::HttpDownload;
 
-    return {name, image, false, request->remote_name(), query_type, true};
+    return {name, image, false, request->remote_name(), query_type};
 }
 
 auto make_cloud_init_vendor_config(const mp::SSHKeyProvider& key_provider,
@@ -282,7 +282,7 @@ auto fetch_image_for(const std::string& name,
     auto stub_prepare = [](const mp::VMImage&) -> mp::VMImage { return {}; };
     auto stub_progress = [](int download_type, int progress) { return true; };
 
-    mp::Query query{name, "", false, "", mp::Query::Type::Alias, false};
+    mp::Query query{name, "", false, "", mp::Query::Type::Alias};
 
     return vault.fetch_image(factory.fetch_type(),
                              query,
@@ -1621,8 +1621,7 @@ try
                                                           request->search_string(),
                                                           false,
                                                           request->remote_name(),
-                                                          Query::Type::Alias,
-                                                          request->allow_unsupported()});
+                                                          Query::Type::Alias});
         }
         catch (const std::exception& e)
         {
@@ -1658,7 +1657,7 @@ try
             auto action = [&images_found, request, &response](const std::string& remote,
                                                               const mp::VMImageInfo& info) {
                 if (remote != mp::snapcraft_remote &&
-                    (info.supported || request->allow_unsupported()) && !info.aliases.empty() &&
+                    !info.aliases.empty() &&
                     images_found.find(info.release_title.toStdString()) == images_found.end())
                 {
                     add_aliases(response.mutable_images_info(), remote, info);
@@ -1675,7 +1674,7 @@ try
             request->force_manifest_network_download());
         const auto& remote = request->remote_name();
         auto image_host = config->vault->image_host_for(remote);
-        auto vm_images_info = image_host->all_images_for(remote, request->allow_unsupported());
+        auto vm_images_info = image_host->all_images_for(remote);
 
         for (const auto& info : vm_images_info)
             add_aliases(response.mutable_images_info(), remote, info);
diff --git a/src/daemon/default_vm_image_vault.cpp b/src/daemon/default_vm_image_vault.cpp
@@ -20,7 +20,6 @@
 #include <multipass/exceptions/aborted_download_exception.h>
 #include <multipass/exceptions/create_image_exception.h>
 #include <multipass/exceptions/image_vault_exceptions.h>
-#include <multipass/exceptions/unsupported_image_exception.h>
 #include <multipass/file_ops.h>
 #include <multipass/format.h>
 #include <multipass/json_utils.h>
@@ -564,10 +563,6 @@ void mp::DefaultVMImageVault::update_images(const FetchType& fetch_type,
                     keys_to_update.push_back(record.first);
                 }
             }
-            catch (const mp::UnsupportedImageException& e)
-            {
-                mpl::warn(category, "Skipping update: {}", e.what());
-            }
             catch (const mp::ImageNotFoundException& e)
             {
                 mpl::warn(category, "Skipping update: {}", e.what());
diff --git a/src/image_host/custom_image_host.cpp b/src/image_host/custom_image_host.cpp
@@ -166,8 +166,7 @@ std::vector<std::pair<std::string, mp::VMImageInfo>> mp::CustomVMImageHost::all_
     return images;
 }
 
-std::vector<mp::VMImageInfo> mp::CustomVMImageHost::all_images_for(const std::string& remote_name,
-                                                                   const bool allow_unsupported)
+std::vector<mp::VMImageInfo> mp::CustomVMImageHost::all_images_for(const std::string& remote_name)
 {
     if (auto custom_manifest = manifest_from(remote_name))
         return custom_manifest->products;
diff --git a/src/image_host/ubuntu_image_host.cpp b/src/image_host/ubuntu_image_host.cpp
@@ -19,7 +19,6 @@
 #include <multipass/exceptions/download_exception.h>
 #include <multipass/exceptions/image_not_found_exception.h>
 #include <multipass/exceptions/manifest_exceptions.h>
-#include <multipass/exceptions/unsupported_image_exception.h>
 #include <multipass/image_host/ubuntu_image_host.h>
 #include <multipass/platform.h>
 #include <multipass/query.h>
@@ -110,9 +109,6 @@ std::vector<std::pair<std::string, mp::VMImageInfo>> mp::UbuntuVMImageHost::all_
 
         if (const auto* info = match_alias(key, *manifest); info)
         {
-            if (!info->supported && !query.allow_unsupported)
-                throw mp::UnsupportedImageException(query.release);
-
             images.emplace_back(remote_name, *info);
         }
         else
@@ -121,7 +117,7 @@ std::vector<std::pair<std::string, mp::VMImageInfo>> mp::UbuntuVMImageHost::all_
 
             for (const auto& entry : manifest->products)
             {
-                if (entry.id.startsWith(key) && (entry.supported || query.allow_unsupported) &&
+                if (entry.id.startsWith(key) &&
                     found_hashes.find(entry.id.toStdString()) == found_hashes.end())
                 {
                     images.emplace_back(remote_name, entry);
@@ -150,18 +146,14 @@ mp::VMImageInfo mp::UbuntuVMImageHost::info_for_full_hash_impl(const std::string
     throw mp::ImageNotFoundException(full_hash);
 }
 
-std::vector<mp::VMImageInfo> mp::UbuntuVMImageHost::all_images_for(const std::string& remote_name,
-                                                                   const bool allow_unsupported)
+std::vector<mp::VMImageInfo> mp::UbuntuVMImageHost::all_images_for(const std::string& remote_name)                                                                  
 {
     std::vector<mp::VMImageInfo> images;
     auto manifest = manifest_from(remote_name);
 
     for (const auto& entry : manifest->products)
     {
-        if (entry.supported || allow_unsupported)
-        {
-            images.push_back(entry);
-        }
+        images.push_back(entry);       
     }
 
     if (images.empty())
diff --git a/src/simplestreams/simple_streams_manifest.cpp b/src/simplestreams/simple_streams_manifest.cpp
@@ -135,7 +135,10 @@ std::unique_ptr<mp::SimpleStreamsManifest> mp::SimpleStreamsManifest::fromJson(
         const auto supported =
             product["supported"].toBool() || product_aliases.contains("devel") ||
             (product["os"] == "ubuntu-core" && product["image_type"] == "stable");
-
+        
+        if (!supported)
+            continue;
+        
         const auto versions = product["versions"].toObject();
         if (versions.isEmpty())
             continue;
diff --git a/tests/unit/stub_image_host.h b/tests/unit/stub_image_host.h
@@ -42,8 +42,7 @@ struct StubVMImageHost final : public multipass::VMImageHost
         return {{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, -1, {}};
     };
 
-    std::vector<multipass::VMImageInfo> all_images_for(const std::string& remote_name,
-                                                       const bool allow_unsupported) override
+    std::vector<multipass::VMImageInfo> all_images_for(const std::string& remote_name) override
     {
         return {};
     };
diff --git a/tests/unit/test_cli_client.cpp b/tests/unit/test_cli_client.cpp
@@ -3247,13 +3247,6 @@ TEST_F(Client, deleteCmdWrongVmState)
     EXPECT_THAT(send_command({"delete", "foo"}), Eq(mp::ReturnCode::CommandFail));
 }
 
-// find cli tests
-TEST_F(Client, findCmdUnsupportedOptionOk)
-{
-    EXPECT_CALL(mock_daemon, find(_, _));
-    EXPECT_THAT(send_command({"find", "--show-unsupported"}), Eq(mp::ReturnCode::Ok));
-}
-
 TEST_F(Client, findCmdForceUpdateOk)
 {
     EXPECT_CALL(mock_daemon, find(_, _));
diff --git a/tests/unit/test_image_vault.cpp b/tests/unit/test_image_vault.cpp
@@ -1099,34 +1099,6 @@ TEST_F(ImageVault, allInfoForNoImagesReturnsEmpty)
     EXPECT_TRUE(vault.all_info_for({"", name, false, "", mp::Query::Type::Alias, true}).empty());
 }
 
-TEST_F(ImageVault, updateImagesLogsWarningOnUnsupportedImage)
-{
-    mpt::MockLogger::Scope logger_scope = mpt::MockLogger::inject(mpl::Level::warning);
-    mp::DefaultVMImageVault vault{hosts,
-                                  &url_downloader,
-                                  cache_dir.path(),
-                                  data_dir.path(),
-                                  mp::days{1}};
-    vault.fetch_image(mp::FetchType::ImageOnly,
-                      default_query,
-                      stub_prepare,
-                      stub_monitor,
-                      std::nullopt,
-                      instance_dir);
-
-    EXPECT_CALL(host, info_for(_))
-        .WillOnce(Throw(mp::UnsupportedImageException(default_query.release)));
-
-    logger_scope.mock_logger->screen_logs(mpl::Level::warning);
-    EXPECT_CALL(*logger_scope.mock_logger,
-                log(mpl::Level::warning,
-                    StrEq("image vault"),
-                    StrEq(fmt::format("Skipping update: The {} release is no longer supported.",
-                                      default_query.release))));
-
-    EXPECT_NO_THROW(vault.update_images(mp::FetchType::ImageOnly, stub_prepare, stub_monitor));
-}
-
 TEST_F(ImageVault, updateImagesLogsWarningOnEmptyVault)
 {
     mpt::MockLogger::Scope logger_scope = mpt::MockLogger::inject(mpl::Level::warning);
diff --git a/tests/unit/test_ubuntu_image_host.cpp b/tests/unit/test_ubuntu_image_host.cpp
@@ -410,15 +410,6 @@ TEST_F(UbuntuImageHost, handlesAndRecoversFromIndependentServerFailures)
     }
 }
 
-TEST_F(UbuntuImageHost, throwsUnsupportedImageWhenImageNotSupported)
-{
-    mp::UbuntuVMImageHost host{all_remote_specs, &url_downloader};
-    host.update_manifests(false);
-
-    EXPECT_THROW(host.info_for(make_query("artful", release_remote_spec.first)),
-                 mp::UnsupportedImageException);
-}
-
 TEST_F(UbuntuImageHost, develRequestWithNoRemoteReturnsExpectedInfo)
 {
     mp::UbuntuVMImageHost host{all_remote_specs, &url_downloader};
@@ -481,19 +472,6 @@ TEST_F(UbuntuImageHost, allInfoForNoRemoteQueryDefaultsToRelease)
     EXPECT_EQ(images_info.size(), expected_matches);
 }
 
-TEST_F(UbuntuImageHost, allInfoForUnsupportedImageThrow)
-{
-    mp::UbuntuVMImageHost host{all_remote_specs, &url_downloader};
-    host.update_manifests(false);
-
-    const std::string release{"artful"};
-
-    MP_EXPECT_THROW_THAT(
-        host.all_info_for(make_query(release, release_remote_spec.first)),
-        mp::UnsupportedImageException,
-        mpt::match_what(StrEq(fmt::format("The {} release is no longer supported.", release))));
-}
-
 TEST_F(UbuntuImageHost, infoForFullHashFindsImage)
 {
     mp::UbuntuVMImageHost host{all_remote_specs, &url_downloader};

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@`
`20`	`20`	`#include <multipass/exceptions/aborted_download_exception.h>`
`21`	`21`	`#include <multipass/exceptions/create_image_exception.h>`
`22`	`22`	`#include <multipass/exceptions/image_vault_exceptions.h>`
`23`		`-#include <multipass/exceptions/unsupported_image_exception.h>`
`24`	`23`	`#include <multipass/file_ops.h>`
`25`	`24`	`#include <multipass/format.h>`
`26`	`25`	`#include <multipass/json_utils.h>`
`@@ -564,10 +563,6 @@ void mp::DefaultVMImageVault::update_images(const FetchType& fetch_type,`
`564`	`563`	`keys_to_update.push_back(record.first);`
`565`	`564`	`}`
`566`	`565`	`}`
`567`		`- catch (const mp::UnsupportedImageException& e)`
`568`		`- {`
`569`		`- mpl::warn(category, "Skipping update: {}", e.what());`
`570`		`- }`
`571`	`566`	`catch (const mp::ImageNotFoundException& e)`
`572`	`567`	`{`
`573`	`568`	`mpl::warn(category, "Skipping update: {}", e.what());`
Original file line number	Diff line number	Diff line change
`@@ -166,8 +166,7 @@ std::vector<std::pair<std::string, mp::VMImageInfo>> mp::CustomVMImageHost::all_`
`166`	`166`	`return images;`
`167`	`167`	`}`
`168`	`168`
`169`		`-std::vector<mp::VMImageInfo> mp::CustomVMImageHost::all_images_for(const std::string& remote_name,`
`170`		`- const bool allow_unsupported)`
	`169`	`+std::vector<mp::VMImageInfo> mp::CustomVMImageHost::all_images_for(const std::string& remote_name)`
`171`	`170`	`{`
`172`	`171`	`if (auto custom_manifest = manifest_from(remote_name))`
`173`	`172`	`return custom_manifest->products;`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,6 @@`
`19`	`19`	`#include <multipass/exceptions/download_exception.h>`
`20`	`20`	`#include <multipass/exceptions/image_not_found_exception.h>`
`21`	`21`	`#include <multipass/exceptions/manifest_exceptions.h>`
`22`		`-#include <multipass/exceptions/unsupported_image_exception.h>`
`23`	`22`	`#include <multipass/image_host/ubuntu_image_host.h>`
`24`	`23`	`#include <multipass/platform.h>`
`25`	`24`	`#include <multipass/query.h>`
`@@ -110,9 +109,6 @@ std::vector<std::pair<std::string, mp::VMImageInfo>> mp::UbuntuVMImageHost::all_`
`110`	`109`
`111`	`110`	`if (const auto* info = match_alias(key, *manifest); info)`
`112`	`111`	`{`
`113`		`- if (!info->supported && !query.allow_unsupported)`
`114`		`- throw mp::UnsupportedImageException(query.release);`
`115`		`-`
`116`	`112`	`images.emplace_back(remote_name, *info);`
`117`	`113`	`}`
`118`	`114`	`else`
`@@ -121,7 +117,7 @@ std::vector<std::pair<std::string, mp::VMImageInfo>> mp::UbuntuVMImageHost::all_`
`121`	`117`
`122`	`118`	`for (const auto& entry : manifest->products)`
`123`	`119`	`{`
`124`		`- if (entry.id.startsWith(key) && (entry.supported \|\| query.allow_unsupported) &&`
	`120`	`+ if (entry.id.startsWith(key) &&`
`125`	`121`	`found_hashes.find(entry.id.toStdString()) == found_hashes.end())`
`126`	`122`	`{`
`127`	`123`	`images.emplace_back(remote_name, entry);`
`@@ -150,18 +146,14 @@ mp::VMImageInfo mp::UbuntuVMImageHost::info_for_full_hash_impl(const std::string`
`150`	`146`	`throw mp::ImageNotFoundException(full_hash);`
`151`	`147`	`}`
`152`	`148`
`153`		`-std::vector<mp::VMImageInfo> mp::UbuntuVMImageHost::all_images_for(const std::string& remote_name,`
`154`		`- const bool allow_unsupported)`
	`149`	`+std::vector<mp::VMImageInfo> mp::UbuntuVMImageHost::all_images_for(const std::string& remote_name)`
`155`	`150`	`{`
`156`	`151`	`std::vector<mp::VMImageInfo> images;`
`157`	`152`	`auto manifest = manifest_from(remote_name);`
`158`	`153`
`159`	`154`	`for (const auto& entry : manifest->products)`
`160`	`155`	`{`
`161`		`- if (entry.supported \|\| allow_unsupported)`
`162`		`- {`
`163`		`- images.push_back(entry);`
`164`		`- }`
	`156`	`+ images.push_back(entry);`
`165`	`157`	`}`
`166`	`158`
`167`	`159`	`if (images.empty())`