Image filters

src/windows/service/inc/wslc.idl

@@ -151,14 +151,11 @@ typedef struct _WSLCImageInformation
 typedef enum _WSLCListImagesFlags
 {
     WSLCListImagesFlagsNone = 0,
-    WSLCListImagesFlagsAll = 1,           // Show all images (default hides intermediate images)
-    WSLCListImagesFlagsDigests = 2,       // Include digest information
-    WSLCListImagesFlagsDanglingTrue = 4,  // Show only dangling images (untagged)
-    WSLCListImagesFlagsDanglingFalse = 8, // Show only non-dangling images (tagged)
-    // Note: If neither dangling flag is set, no dangling filter is passed (default: both).
+    WSLCListImagesFlagsAll = 1,     // Show all images (default hides intermediate images)
+    WSLCListImagesFlagsDigests = 2, // Include digest information
 } WSLCListImagesFlags;
 
-cpp_quote("#define WSLCListImagesFlagsValid (WSLCListImagesFlagsAll | WSLCListImagesFlagsDigests | WSLCListImagesFlagsDanglingTrue | WSLCListImagesFlagsDanglingFalse)")
+cpp_quote("#define WSLCListImagesFlagsValid (WSLCListImagesFlagsAll | WSLCListImagesFlagsDigests)")
 
 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(WSLCListImagesFlags);")
 
@@ -181,15 +178,12 @@ typedef KeyValuePair WSLCFilter;
 typedef KeyValuePairInformation WSLCLabelInformation;
 typedef KeyValuePairInformation WSLCDriverOptionInformation;
 
-typedef struct _WSLCListImageOptions
+typedef struct _WSLCListImagesOptions
 {
     DWORD Flags; // WSLCListImagesFlags (can combine with bitwise OR)
-    [unique] LPCSTR Reference; // Filter by reference (name[:tag])
-    [unique] LPCSTR Before; // Filter: show images created before this image
-    [unique] LPCSTR Since; // Filter: show images created since this image
-    [unique, size_is(LabelsCount)] const WSLCLabel* Labels;
-    ULONG LabelsCount;
-} WSLCListImageOptions;
+    [unique, size_is(FiltersCount)] const WSLCFilter* Filters;
+    ULONG FiltersCount;
+} WSLCListImagesOptions;
 
 typedef enum _WSLCProcessFlags
 {
@@ -667,26 +661,6 @@ typedef struct _WSLCPruneContainersResults
     ULONGLONG SpaceReclaimed;
 } WSLCPruneContainersResults;
 
-typedef enum _WSLCPruneImagesFlags
-{
-    WSLCPruneImagesFlagsNone = 0,
-    WSLCPruneImagesFlagsDanglingTrue = 1,  // Only prune dangling (untagged) images.
-    WSLCPruneImagesFlagsDanglingFalse = 2, // Prune all images not used by any container.
-    // Note: If neither dangling flag is set, no dangling filter is passed (Docker defaults to dangling-only).
-} WSLCPruneImagesFlags;
-
-cpp_quote("#define WSLCPruneImagesFlagsValid (WSLCPruneImagesFlagsDanglingTrue | WSLCPruneImagesFlagsDanglingFalse)")
-
-cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(WSLCPruneImagesFlags);")
-
-typedef struct _WSLCPruneImagesOptions
-{
-    DWORD Flags; // WSLCPruneImagesFlags
-    ULONGLONG Until;
-    [unique, size_is(LabelsCount)] const WSLCPruneLabelFilter* Labels;
-    ULONG LabelsCount;
-} WSLCPruneImagesOptions;
-
 typedef enum _WSLCListContainersFlags
 {
     WSLCListContainersFlagsNone = 0,
@@ -744,11 +718,11 @@ interface IWSLCSession : IUnknown
     HRESULT LoadImage([in] WSLCHandle ImageHandle, [in, unique] IProgressCallback* ProgressCallback, [in] ULONGLONG ContentLength);
     HRESULT ImportImage([in] WSLCHandle ImageHandle, [in] LPCSTR ImageName, [in, unique] IProgressCallback* ProgressCallback, [in] ULONGLONG ContentLength);
     HRESULT SaveImage([in] WSLCHandle OutputHandle, [in] LPCSTR ImageNameOrID, [in, unique] IProgressCallback * ProgressCallback, [in, unique, system_handle(sh_event)] HANDLE CancelEvent);
-    HRESULT ListImages([in, unique] const WSLCListImageOptions* Options, [out, size_is(, *Count)] WSLCImageInformation** Images, [out] ULONG* Count);
+    HRESULT ListImages([in, unique] const WSLCListImagesOptions* Options, [out, size_is(, *Count)] WSLCImageInformation** Images, [out] ULONG* Count);
     HRESULT DeleteImage([in] const WSLCDeleteImageOptions* Options, [out, size_is(, *Count)] WSLCDeletedImageInformation** DeletedImages, [out] ULONG* Count);
     HRESULT TagImage([in] const WSLCTagImageOptions* Options);
     HRESULT InspectImage([in] LPCSTR ImageNameOrId, [out] LPSTR* Output);
-    HRESULT PruneImages([in, unique] const WSLCPruneImagesOptions* Options, [out, size_is(, *DeletedImagesCount)] WSLCDeletedImageInformation** DeletedImages, [out] ULONG* DeletedImagesCount, [out] ULONGLONG* SpaceReclaimed);
+    HRESULT PruneImages([in, unique, size_is(FiltersCount)] const WSLCFilter* Filters, [in] ULONG FiltersCount, [out, size_is(, *DeletedImagesCount)] WSLCDeletedImageInformation** DeletedImages, [out] ULONG* DeletedImagesCount, [out] ULONGLONG* SpaceReclaimed);
 
     // Container management.
     HRESULT CreateContainer([in] const WSLCContainerOptions* Options, [out] IWSLCContainer** Container);

src/windows/wslc/services/ImageService.cpp

@@ -299,15 +299,11 @@ void ImageService::Save(wsl::windows::wslc::models::Session& session, const std:
 
 wsl::windows::wslc::models::PruneImagesResult ImageService::Prune(wsl::windows::wslc::models::Session& session, bool all)
 {
-    WSLCPruneImagesOptions options{};
-    if (all)
-    {
-        WI_SetFlag(options.Flags, WSLCPruneImagesFlagsDanglingFalse);
-    }
+    WSLCFilter filter{.Key = "dangling", .Value = all ? "false" : "true"};
 
     wil::unique_cotaskmem_array_ptr<WSLCDeletedImageInformation> deletedImages;
     ULONGLONG spaceReclaimed = 0;
-    THROW_IF_FAILED(session.Get()->PruneImages(&options, &deletedImages, deletedImages.size_address<ULONG>(), &spaceReclaimed));
+    THROW_IF_FAILED(session.Get()->PruneImages(&filter, 1, &deletedImages, deletedImages.size_address<ULONG>(), &spaceReclaimed));
 
     wsl::windows::wslc::models::PruneImagesResult result;
     result.SpaceReclaimed = spaceReclaimed;

src/windows/wslcsession/DockerHTTPClient.cpp

@@ -53,47 +53,6 @@ bool IsResponseChunked(const http::response_parser<http::buffer_body>::value_typ
 
     return true;
 }
-template <typename TFilters>
-nlohmann::json PruneFiltersToJson(const TFilters& filters)
-{
-    nlohmann::json j;
-
-    if constexpr (requires { filters.dangling; })
-    {
-        if (filters.dangling.has_value())
-        {
-            j["dangling"] = nlohmann::json::array({filters.dangling.value() ? "true" : "false"});
-        }
-    }
-
-    if constexpr (requires { filters.all; })
-    {
-        if (filters.all.has_value() && filters.all.value())
-        {
-            j["all"] = nlohmann::json::array({"true"});
-        }
-    }
-
-    if constexpr (requires { filters.until; })
-    {
-        if (filters.until.has_value())
-        {
-            j["until"] = nlohmann::json::array({std::to_string(filters.until.value())});
-        }
-    }
-
-    if (!filters.presentLabels.empty())
-    {
-        j["label"] = filters.presentLabels;
-    }
-
-    if (!filters.absentLabels.empty())
-    {
-        j["label!"] = filters.absentLabels;
-    }
-
-    return j;
-}
 
 } // namespace
 
@@ -231,43 +190,16 @@ std::string DockerHTTPClient::Authenticate(const std::string& serverAddress, con
     return response.IdentityToken.value_or("");
 }
 
-std::vector<docker_schema::Image> DockerHTTPClient::ListImages(bool all, bool digests, const ListImagesFilters& filters)
+std::vector<docker_schema::Image> DockerHTTPClient::ListImages(bool all, bool digests, const std::map<std::string, std::vector<std::string>>& filters)
 {
     auto url = URL::Create("/images/json");
 
     url.SetParameter("all", all);
     url.SetParameter("digests", digests);
 
-    // Build filters JSON if any filters are set
-    nlohmann::json filtersJson;
-
-    if (filters.reference.has_value())
-    {
-        filtersJson["reference"] = nlohmann::json::array({filters.reference.value()});
-    }
-
-    if (filters.before.has_value())
-    {
-        filtersJson["before"] = nlohmann::json::array({filters.before.value()});
-    }
-
-    if (filters.since.has_value())
-    {
-        filtersJson["since"] = nlohmann::json::array({filters.since.value()});
-    }
-
-    if (filters.dangling.has_value())
-    {
-        filtersJson["dangling"] = nlohmann::json::array({filters.dangling.value() ? "true" : "false"});
-    }
-
-    if (!filters.labels.empty())
-    {
-        filtersJson["label"] = filters.labels;
-    }
-
-    if (!filtersJson.empty())
+    if (!filters.empty())
     {
+        nlohmann::json filtersJson = filters;
         url.SetParameter("filters", filtersJson.dump());
     }
 
@@ -295,13 +227,13 @@ std::pair<uint32_t, wil::unique_socket> DockerHTTPClient::SaveImage(const std::s
     return {response.result_int(), std::move(socket)};
 }
 
-docker_schema::PruneImageResult DockerHTTPClient::PruneImages(const PruneImagesFilters& filters)
+docker_schema::PruneImageResult DockerHTTPClient::PruneImages(const std::map<std::string, std::vector<std::string>>& filters)
 {
     auto url = URL::Create("/images/prune");
 
-    auto filtersJson = PruneFiltersToJson(filters);
-    if (!filtersJson.empty())
+    if (!filters.empty())
     {
+        nlohmann::json filtersJson = filters;
         url.SetParameter("filters", filtersJson.dump());
     }
 

src/windows/wslcsession/DockerHTTPClient.h

@@ -152,35 +152,19 @@ class DockerHTTPClient
     common::docker_schema::Network InspectNetwork(const std::string& Name);
 
     // Image management.
-    struct ListImagesFilters
-    {
-        std::optional<std::string> reference;
-        std::optional<std::string> before;
-        std::optional<std::string> since;
-        std::optional<bool> dangling;
-        std::vector<std::string> labels;
-    };
-
-    struct PruneImagesFilters
-    {
-        std::optional<bool> dangling;
-        std::optional<std::uint64_t> until;
-        std::vector<std::string> presentLabels;
-        std::vector<std::string> absentLabels;
-    };
-
     std::unique_ptr<HTTPRequestContext> PullImage(
         const std::string& Repo, const std::optional<std::string>& tagOrDigest, const std::optional<std::string>& registryAuth = std::nullopt);
     std::unique_ptr<HTTPRequestContext> ImportImage(const std::string& Repo, const std::string& Tag, uint64_t ContentLength);
     std::unique_ptr<HTTPRequestContext> LoadImage(uint64_t ContentLength);
     void TagImage(const std::string& Id, const std::string& Repo, const std::string& Tag);
     std::unique_ptr<HTTPRequestContext> PushImage(const std::string& ImageName, const std::optional<std::string>& tag, const std::string& registryAuth);
     std::string Authenticate(const std::string& serverAddress, const std::string& username, const std::string& password);
-    std::vector<common::docker_schema::Image> ListImages(bool all = false, bool digests = false, const ListImagesFilters& filters = {});
+    std::vector<common::docker_schema::Image> ListImages(
+        bool all = false, bool digests = false, const std::map<std::string, std::vector<std::string>>& filters = {});
     common::docker_schema::InspectImage InspectImage(const std::string& NameOrId);
     std::vector<common::docker_schema::DeletedImage> DeleteImage(const char* Image, bool Force, bool NoPrune); // Image can be ID or Repo:Tag.
     std::pair<uint32_t, wil::unique_socket> SaveImage(const std::string& NameOrId);
-    common::docker_schema::PruneImageResult PruneImages(const PruneImagesFilters& filters = {});
+    common::docker_schema::PruneImageResult PruneImages(const std::map<std::string, std::vector<std::string>>& filters = {});
 
     // Exec.
     common::docker_schema::CreateExecResponse CreateExec(const std::string& Container, const common::docker_schema::CreateExec& Request);