Separate the cache logic from message formatting

Allows the callsites to decide what to output.  Specifically, the auto
prune in fetching can now omit the message if no files are removed.

Test: # populate cache if necessary
Test: cvd fetch --target_directory=/tmp/cvd/fetch_test
--default_build=12924704,12924909,12924919
Test: cvd cache info
Test: cvd fetch --target_directory=/tmp/cvd/fetch_test2
--default_build=12924921 --max_cache_size_GB=2
Test: # only prunes when caching is enabled
Test: cvd fetch --target_directory=/tmp/cvd/fetch_test3
--default_build=12924578 --max_cache_size_GB=0 --enable_caching=false
Test: cvd cache info
Test: cvd cache empty

Author: cjreynol

base/cvd/cuttlefish/host/commands/cvd/cache/cache.cpp

@@ -26,7 +26,6 @@
 
 #include <android-base/strings.h>
 #include <fmt/format.h>
-#include <json/json.h>
 
 #include "common/libs/utils/files.h"
 #include "common/libs/utils/result.h"
@@ -70,37 +69,32 @@ Result<std::vector<std::string>> CacheFilesDesc(
 
 }  // namespace
 
-Result<std::string> EmptyCache(const std::string& cache_directory) {
+Result<void> EmptyCache(const std::string& cache_directory) {
   CF_EXPECT(EnsureDirectoryExists(cache_directory));
   CF_EXPECT(RecursivelyRemoveDirectory(cache_directory));
   CF_EXPECT(EnsureDirectoryExists(cache_directory));
-  return fmt::format("Cache at \"{}\" has been emptied\n", cache_directory);
+  return {};
 }
 
-Result<std::string> GetCacheInfo(const std::string& cache_directory,
-                                 const bool json_formatted) {
+Result<std::size_t> GetCacheSize(const std::string& cache_directory) {
   CF_EXPECT(EnsureDirectoryExists(cache_directory));
-  std::size_t cache_size = CF_EXPECT(GetDiskUsageGigabytes(cache_directory));
-  if (json_formatted) {
-    Json::Value json_output(Json::objectValue);
-    json_output["path"] = cache_directory;
-    json_output["size_in_GB"] = std::to_string(cache_size);
-    return json_output.toStyledString();
-  }
-  return fmt::format("path:{}\nsize in GB:{}\n", cache_directory, cache_size);
+  return CF_EXPECT(GetDiskUsageGigabytes(cache_directory));
 }
 
-Result<std::string> PruneCache(const std::string& cache_directory,
-                               const std::size_t allowed_size_GB) {
+Result<PruneResult> PruneCache(const std::string& cache_directory,
+                               const std::size_t allowed_size_gb) {
   CF_EXPECT(EnsureDirectoryExists(cache_directory));
   std::size_t cache_size = CF_EXPECT(GetDiskUsageGigabytes(cache_directory));
+  PruneResult result{
+      .before = cache_size,
+  };
   // Descending because elements are removed from the back
   std::vector<std::string> cache_files =
       CF_EXPECT(CacheFilesDesc(cache_directory));
-  while (cache_size > allowed_size_GB) {
+  while (cache_size > allowed_size_gb) {
     CHECK(!cache_files.empty()) << fmt::format(
         "Cache size is {} of {}, but there are no more files for pruning.",
-        cache_size, allowed_size_GB);
+        cache_size, allowed_size_gb);
 
     std::string next = cache_files.back();
     cache_files.pop_back();
@@ -109,8 +103,8 @@ Result<std::string> PruneCache(const std::string& cache_directory,
     CF_EXPECT(RecursivelyRemoveDirectory(next));
     cache_size = CF_EXPECT(GetDiskUsageGigabytes(cache_directory));
   }
-  return fmt::format("Cache at \"{}\": ~{}GB of {}GB max\n", cache_directory,
-                     cache_size, allowed_size_GB);
+  result.after = cache_size;
+  return result;
 }
 
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/cvd/cache/cache.h

@@ -25,10 +25,14 @@ namespace cuttlefish {
 
 inline constexpr std::size_t kDefaultCacheSizeGb = 25;
 
-Result<std::string> EmptyCache(const std::string& cache_directory);
-Result<std::string> GetCacheInfo(const std::string& cache_directory,
-                                 bool json_formatted);
-Result<std::string> PruneCache(const std::string& cache_directory,
+struct PruneResult {
+  std::size_t before;
+  std::size_t after;
+};
+
+Result<void> EmptyCache(const std::string& cache_directory);
+Result<std::size_t> GetCacheSize(const std::string& cache_directory);
+Result<PruneResult> PruneCache(const std::string& cache_directory,
                                std::size_t allowed_size_GB);
 
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/cvd/cli/commands/cache.cpp

@@ -18,13 +18,15 @@
 
 #include <cstddef>
 #include <memory>
+#include <sstream>
 #include <string>
 #include <string_view>
 #include <unordered_map>
 #include <vector>
 
 #include <android-base/logging.h>
 #include <fmt/format.h>
+#include <json/json.h>
 
 #include "common/libs/utils/files.h"
 #include "common/libs/utils/flag_parser.h"
@@ -109,21 +111,39 @@ Result<void> CvdCacheCommandHandler::Handle(const CommandRequest& request) {
       CF_EXPECT(ProcessArguments(request.SubcommandArguments()));
   std::string cache_directory = PerUserCacheDir();
   switch (arguments.action) {
-    case Action::Empty:
-      std::cout << CF_EXPECTF(EmptyCache(cache_directory),
-                              "Error emptying cache at {}", cache_directory);
+    case Action::Empty: {
+      CF_EXPECTF(EmptyCache(cache_directory), "Error emptying cache at {}",
+                 cache_directory);
+      fmt::print("Cache at \"{}\" has been emptied\n", cache_directory);
       break;
-    case Action::Info:
-      std::cout << CF_EXPECTF(
-          GetCacheInfo(cache_directory, arguments.json_formatted),
-          "Error retrieving info of cache at {}", cache_directory);
+    }
+    case Action::Info: {
+      const std::size_t cache_size =
+          CF_EXPECTF(GetCacheSize(cache_directory),
+                     "Error retrieving size of cache at {}", cache_directory);
+      if (arguments.json_formatted) {
+        Json::Value json_output(Json::objectValue);
+        json_output["path"] = cache_directory;
+        json_output["size_in_GB"] = std::to_string(cache_size);
+        fmt::print("{}", json_output.toStyledString());
+      } else {
+        fmt::print("path:{}\nsize in GB:{}\n", cache_directory, cache_size);
+      }
       break;
-    case Action::Prune:
-      std::cout << CF_EXPECTF(
-          PruneCache(cache_directory, arguments.allowed_size_gb),
-          "Error pruning cache at {} to {}GB", cache_directory,
-          arguments.allowed_size_gb);
+    }
+    case Action::Prune: {
+      const PruneResult result =
+          CF_EXPECTF(PruneCache(cache_directory, arguments.allowed_size_gb),
+                     "Error pruning cache at {} to {}GB", cache_directory,
+                     arguments.allowed_size_gb);
+      if (result.before > result.after) {
+        fmt::print("Cache pruned from {}GB down to {}GB\n", result.before,
+                   result.after);
+      }
+      fmt::print("Cache at \"{}\": ~{}GB of {}GB max\n", cache_directory,
+                 result.after, arguments.allowed_size_gb);
       break;
+    }
   }
 
   return {};

base/cvd/cuttlefish/host/commands/cvd/cli/commands/fetch.cpp

@@ -65,10 +65,16 @@ Result<void> CvdFetchCommandHandler::Handle(const CommandRequest& request) {
   Result<void> result = FetchCvdMain(flags);
   if (flags.build_api_flags.enable_caching) {
     const std::string cache_directory = PerUserCacheDir();
-    LOG(INFO) << CF_EXPECTF(
+    const PruneResult prune_result = CF_EXPECTF(
         PruneCache(cache_directory, flags.build_api_flags.max_cache_size_gb),
         "Error pruning cache at {} to {}GB", cache_directory,
         flags.build_api_flags.max_cache_size_gb);
+    if (prune_result.before > prune_result.after) {
+      LOG(INFO) << fmt::format(
+          "Cache at \"{}\" pruned from ~{}GB to ~{}GB of {}GB max size",
+          cache_directory, prune_result.before, prune_result.after,
+          flags.build_api_flags.max_cache_size_gb);
+    }
   }
   CF_EXPECT(std::move(result));
   return {};