Use fetcher_config.json from the system image dir

cvd fetch saves the fetcher_config.json file in the same directory where
it downloads the images. assemble_cvd was searching for this file only
under $HOME and current directory, which are the default values for
the system_image_dir flag, but not guaranteed to have
fetcher_config.json in all cases.

Bug: 440789112

Author: jemoreira

base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd.cc

@@ -25,7 +25,6 @@
 #include "cuttlefish/common/libs/fs/shared_buf.h"
 #include "cuttlefish/common/libs/fs/shared_fd.h"
 #include "cuttlefish/common/libs/utils/contains.h"
-#include "cuttlefish/common/libs/utils/environment.h"
 #include "cuttlefish/common/libs/utils/files.h"
 #include "cuttlefish/common/libs/utils/flag_parser.h"
 #include "cuttlefish/common/libs/utils/in_sandbox.h"
@@ -65,27 +64,20 @@ namespace {
 
 static constexpr std::string_view kFetcherConfigFile = "fetcher_config.json";
 
-FetcherConfig FindFetcherConfig(const std::vector<std::string>& files) {
-  FetcherConfig fetcher_config;
-  for (const auto& file : files) {
-    if (android::base::EndsWith(file, kFetcherConfigFile)) {
-      std::string home_directory = StringFromEnv("HOME", CurrentDirectory());
-      std::string fetcher_file = file;
-      if (!FileExists(file) &&
-          FileExists(home_directory + "/" + fetcher_file)) {
-        LOG(INFO) << "Found " << fetcher_file << " in HOME directory ('"
-                  << home_directory << "') and not current working directory";
-        fetcher_file = home_directory + "/" + fetcher_file;
-      }
-
-      if (fetcher_config.LoadFromFile(fetcher_file)) {
-        return fetcher_config;
-      }
-      LOG(ERROR) << "Could not load fetcher config file.";
+FetcherConfigs FindFetcherConfigs(
+    const SystemImageDirFlag& system_image_dir) {
+  std::vector<FetcherConfig> fetcher_configs;
+  for (size_t i = 0; i < system_image_dir.Size(); ++i) {
+    std::string fetcher_file =
+        fmt::format("{}/{}", system_image_dir.ForIndex(i), kFetcherConfigFile);
+    FetcherConfig fetcher_config;
+    if (!fetcher_config.LoadFromFile(fetcher_file)) {
+      LOG(DEBUG) << "No valid fetcher_config in '" << fetcher_file
+                 << "', falling back to default";
     }
+    fetcher_configs.emplace_back(std::move(fetcher_config));
   }
-  LOG(DEBUG) << "Could not locate fetcher config file.";
-  return fetcher_config;
+  return FetcherConfigs::Create(std::move(fetcher_configs));
 }
 
 std::string GetLegacyConfigFilePath(const CuttlefishConfig& config) {
@@ -316,8 +308,9 @@ Result<SharedFD> SetLogger(std::string runtime_dir_parent) {
 }
 
 Result<const CuttlefishConfig*> InitFilesystemAndCreateConfig(
-    FetcherConfig fetcher_config, const std::vector<GuestConfig>& guest_configs,
-    fruit::Injector<>& injector, SharedFD log, const BootImageFlag& boot_image,
+    FetcherConfigs fetcher_configs,
+    const std::vector<GuestConfig>& guest_configs, fruit::Injector<>& injector,
+    SharedFD log, const BootImageFlag& boot_image,
     const InitramfsPathFlag& initramfs_path, const KernelPathFlag& kernel_path,
     const SuperImageFlag& super_image,
     const SystemImageDirFlag& system_image_dir,
@@ -330,7 +323,7 @@ Result<const CuttlefishConfig*> InitFilesystemAndCreateConfig(
     // disk.
     auto config = CF_EXPECT(
         InitializeCuttlefishConfiguration(
-            FLAGS_instance_dir, guest_configs, injector, fetcher_config,
+            FLAGS_instance_dir, guest_configs, injector, fetcher_configs,
             boot_image, initramfs_path, kernel_path, super_image,
             system_image_dir, vendor_boot_image, vm_manager_flag),
         "cuttlefish configuration initialization failed");
@@ -517,7 +510,7 @@ Result<const CuttlefishConfig*> InitFilesystemAndCreateConfig(
     }
   }
 
-  CF_EXPECT(CreateDynamicDiskFiles(fetcher_config, *config, system_image_dir));
+  CF_EXPECT(CreateDynamicDiskFiles(fetcher_configs, *config, system_image_dir));
 
   return config;
 }
@@ -557,14 +550,7 @@ fruit::Component<> FlagsComponent(SystemImageDirFlag* system_image_dir) {
       .install(CustomActionsComponent);
 }
 
-} // namespace
-
-Result<int> AssembleCvdMain(int argc, char** argv) {
-  setenv("ANDROID_LOG_TAGS", "*:v", /* overwrite */ 0);
-  ::android::base::InitLogging(argv, android::base::StderrLogger);
-
-  auto log = CF_EXPECT(SetLogger(AbsolutePath(FLAGS_instance_dir)));
-
+Result<void> CheckNoTTY() {
   int tty = isatty(0);
   int error_num = errno;
   CF_EXPECT(tty == 0,
@@ -573,17 +559,33 @@ Result<int> AssembleCvdMain(int argc, char** argv) {
   CF_EXPECT(error_num != EBADF,
             "stdin was not a valid file descriptor, expected to be "
             "passed the output of launch_cvd. Did you mean to run launch_cvd?");
+  return {};
+}
 
+Result<std::vector<std::string>> ReadInputFiles() {
   std::string input_files_str;
-  {
-    auto input_fd = SharedFD::Dup(0);
-    auto bytes_read = ReadAll(input_fd, &input_files_str);
-    CF_EXPECT(bytes_read >= 0, "Failed to read input files. Error was \""
-                                   << input_fd->StrError() << "\"");
-  }
-  std::vector<std::string> input_files = android::base::Split(input_files_str, "\n");
+  auto input_fd = SharedFD::Dup(0);
+  CF_EXPECTF(input_fd->IsOpen(), "Failed to dup stdin: {}",
+             input_fd->StrError());
+  auto bytes_read = ReadAll(input_fd, &input_files_str);
+  CF_EXPECT(bytes_read >= 0, "Failed to read input files. Error was \""
+                                 << input_fd->StrError() << "\"");
+  return android::base::Split(input_files_str, "\n");
+}
+
+} // namespace
+
+Result<int> AssembleCvdMain(int argc, char** argv) {
+  setenv("ANDROID_LOG_TAGS", "*:v", /* overwrite */ 0);
+  ::android::base::InitLogging(argv, android::base::StderrLogger);
 
-  FetcherConfig fetcher_config = FindFetcherConfig(input_files);
+  auto log = CF_EXPECT(SetLogger(AbsolutePath(FLAGS_instance_dir)));
+
+  CF_EXPECT(CheckNoTTY());
+
+  // Read everything that cvd_internal_start writes, but ignore it since
+  // fetcher_config.json will be searched for in the system image directory.
+  (void) CF_EXPECT(ReadInputFiles());
 
   auto args = ArgsToVec(argc - 1, argv + 1);
 
@@ -617,13 +619,15 @@ Result<int> AssembleCvdMain(int argc, char** argv) {
                                          /* remove_flags */ false);
   }
 
-  InitramfsPathFlag initramfs_path =
-      InitramfsPathFlag::FromGlobalGflags(fetcher_config);
-  KernelPathFlag kernel_path = KernelPathFlag::FromGlobalGflags(fetcher_config);
-
   SystemImageDirFlag system_image_dir =
       CF_EXPECT(SystemImageDirFlag::FromGlobalGflags());
 
+  FetcherConfigs fetcher_configs = FindFetcherConfigs(system_image_dir);
+
+  InitramfsPathFlag initramfs_path =
+      InitramfsPathFlag::FromGlobalGflags(fetcher_configs);
+  KernelPathFlag kernel_path = KernelPathFlag::FromGlobalGflags(fetcher_configs);
+
   BootImageFlag boot_image = BootImageFlag::FromGlobalGflags(system_image_dir);
   SuperImageFlag super_image =
       SuperImageFlag::FromGlobalGflags(system_image_dir);
@@ -675,7 +679,7 @@ Result<int> AssembleCvdMain(int argc, char** argv) {
 
   auto config =
       CF_EXPECT(InitFilesystemAndCreateConfig(
-                    std::move(fetcher_config), guest_configs, injector, log,
+                    std::move(fetcher_configs), guest_configs, injector, log,
                     boot_image, initramfs_path, kernel_path, super_image,
                     system_image_dir, vendor_boot_image, vm_manager_flag),
                 "Failed to create config");

base/cvd/cuttlefish/host/commands/assemble_cvd/create_dynamic_disk_files.cc

@@ -73,8 +73,9 @@ static uint64_t AvailableSpaceAtPath(const std::string& path) {
 }
 
 Result<void> CreateDynamicDiskFiles(
-    const FetcherConfig& fetcher_config, const CuttlefishConfig& config,
+    const FetcherConfigs& fetcher_configs, const CuttlefishConfig& config,
     const SystemImageDirFlag& system_image_dir) {
+  size_t instance_index = 0;
   for (const auto& instance : config.Instances()) {
     std::optional<ChromeOsStateImage> chrome_os_state =
         CF_EXPECT(ChromeOsStateImage::CreateIfNecessary(instance));
@@ -84,7 +85,8 @@ Result<void> CreateDynamicDiskFiles(
     CF_EXPECT(BootloaderPresentCheck(instance));
     CF_EXPECT(Gem5ImageUnpacker(config));  // Requires RepackKernelRamdisk
     CF_EXPECT(InitializeEspImage(config, instance));
-    CF_EXPECT(RebuildSuperImageIfNecessary(fetcher_config, instance));
+    CF_EXPECT(RebuildSuperImageIfNecessary(
+        fetcher_configs.ForInstance(instance_index), instance));
 
     CF_EXPECT(InitializeAccessKregistryImage(instance));
     CF_EXPECT(InitializeHwcomposerPmemImage(instance));
@@ -202,6 +204,7 @@ Result<void> CreateDynamicDiskFiles(
       RepackGem5BootImage(instance.PerInstancePath("initrd.img"), boot_config,
                           config.assembly_dir(), instance.initramfs_path());
     }
+    ++instance_index;
   }
 
   return {};

base/cvd/cuttlefish/host/commands/assemble_cvd/create_dynamic_disk_files.h

@@ -23,7 +23,7 @@
 
 namespace cuttlefish {
 
-Result<void> CreateDynamicDiskFiles(const FetcherConfig& fetcher_config,
+Result<void> CreateDynamicDiskFiles(const FetcherConfigs& fetcher_config,
                                     const CuttlefishConfig& config,
                                     const SystemImageDirFlag&);
 

base/cvd/cuttlefish/host/commands/assemble_cvd/disk_image_flags_vectorization.cc

@@ -43,7 +43,7 @@
 namespace cuttlefish {
 
 Result<void> DiskImageFlagsVectorization(
-    CuttlefishConfig& config, const FetcherConfig& fetcher_config,
+    CuttlefishConfig& config, const FetcherConfigs& fetcher_configs,
     const AndroidEfiLoaderFlag& android_efi_loader,
     const BootImageFlag& boot_image, const BootloaderFlag& bootloader,
     const InitramfsPathFlag& initramfs_path, const KernelPathFlag& kernel_path,
@@ -251,7 +251,8 @@ Result<void> DiskImageFlagsVectorization(
     // We will need to rebuild vendor_dlkm if custom ramdisk is specified, as a
     // result super image would need to be rebuilt as well.
     if (CF_EXPECT(SuperImageNeedsRebuilding(
-            fetcher_config, const_instance.default_target_zip(),
+            fetcher_configs.ForInstance(instance_index),
+            const_instance.default_target_zip(),
             const_instance.system_target_zip())) ||
         has_initramfs) {
       const std::string new_super_image_path =

base/cvd/cuttlefish/host/commands/assemble_cvd/disk_image_flags_vectorization.h

@@ -31,7 +31,7 @@
 namespace cuttlefish {
 
 Result<void> DiskImageFlagsVectorization(
-    CuttlefishConfig& config, const FetcherConfig& fetcher_config,
+    CuttlefishConfig& config, const FetcherConfigs& fetcher_configs,
     const AndroidEfiLoaderFlag&, const BootImageFlag&, const BootloaderFlag&,
     const InitramfsPathFlag&, const KernelPathFlag&, const SuperImageFlag&,
     const SystemImageDirFlag&, const VendorBootImageFlag&);

base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc

@@ -25,6 +25,7 @@
 #include <set>
 #include <sstream>
 #include <unordered_map>
+#include <vector>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -317,7 +318,7 @@ std::optional<std::string> InstancesUdsDir() {
 
 Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
     const std::string& root_dir, const std::vector<GuestConfig>& guest_configs,
-    fruit::Injector<>& injector, const FetcherConfig& fetcher_config,
+    fruit::Injector<>& injector, const FetcherConfigs& fetcher_configs,
     const BootImageFlag& boot_image, const InitramfsPathFlag& initramfs_path,
     const KernelPathFlag& kernel_path, const SuperImageFlag& super_image,
     const SystemImageDirFlag& system_image_dir,
@@ -1322,7 +1323,7 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
       guest_configs, system_image_dir, vm_manager_flag));
 
   CF_EXPECT(DiskImageFlagsVectorization(
-      tmp_config_obj, fetcher_config, efi_loader, boot_image, bootloader,
+      tmp_config_obj, fetcher_configs, efi_loader, boot_image, bootloader,
       initramfs_path, kernel_path, super_image, system_image_dir,
       vendor_boot_image));
 

base/cvd/cuttlefish/host/commands/assemble_cvd/flags.h

@@ -16,6 +16,7 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 #include <fruit/fruit.h>
 
@@ -40,12 +41,12 @@ Result<void> SetFlagDefaultsForVmm(
 // Must be called after ParseCommandLineFlags.
 Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
     const std::string& root_dir, const std::vector<GuestConfig>& guest_configs,
-    fruit::Injector<>& injector, const FetcherConfig& fetcher_config,
+    fruit::Injector<>& injector, const FetcherConfigs& fetcher_configs,
     const BootImageFlag&, const InitramfsPathFlag&,
     const KernelPathFlag& kernel_path, const SuperImageFlag&,
     const SystemImageDirFlag&, const VendorBootImageFlag&,
     const VmManagerFlag&);
 
 std::string GetConfigFilePath(const CuttlefishConfig& config);
 
-} // namespace cuttlefish
+}  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/assemble_cvd/flags/initramfs_path.cc

@@ -32,17 +32,20 @@ DEFINE_string(initramfs_path, CF_DEFAULTS_INITRAMFS_PATH,
 namespace cuttlefish {
 
 InitramfsPathFlag InitramfsPathFlag::FromGlobalGflags(
-    const FetcherConfig& fetcher_config) {
+    const FetcherConfigs& fetcher_configs) {
   gflags::CommandLineFlagInfo flag_info =
       gflags::GetCommandLineFlagInfoOrDie("initramfs_path");
 
-  std::string paths_comma_separated =
-      flag_info.is_default
-          ? fetcher_config.FindCvdFileWithSuffix("initramfs.img")
-          : flag_info.current_value;
-
-  std::vector<std::string> initramfs_paths =
-      android::base::Split(paths_comma_separated, ",");
+  std::vector<std::string> initramfs_paths;
+  if (flag_info.is_default) {
+    for (size_t i = 0; i < fetcher_configs.Size(); ++i) {
+      initramfs_paths.emplace_back(
+          fetcher_configs.ForInstance(i).FindCvdFileWithSuffix(
+              "initramfs.img"));
+    }
+  } else {
+    initramfs_paths = android::base::Split(flag_info.current_value, ",");
+  }
 
   return InitramfsPathFlag(std::move(initramfs_paths));
 }

base/cvd/cuttlefish/host/commands/assemble_cvd/flags/initramfs_path.h

@@ -26,7 +26,7 @@ namespace cuttlefish {
 class InitramfsPathFlag {
  public:
   static InitramfsPathFlag FromGlobalGflags(
-      const FetcherConfig& fetcher_config);
+      const FetcherConfigs& fetcher_configs);
 
   std::string InitramfsPathForIndex(size_t index) const;
 

base/cvd/cuttlefish/host/commands/assemble_cvd/flags/kernel_path.cc

@@ -32,16 +32,20 @@ DEFINE_string(kernel_path, CF_DEFAULTS_KERNEL_PATH,
 namespace cuttlefish {
 
 KernelPathFlag KernelPathFlag::FromGlobalGflags(
-    const FetcherConfig& fetcher_config) {
+    const FetcherConfigs& fetcher_configs) {
   gflags::CommandLineFlagInfo flag_info =
       gflags::GetCommandLineFlagInfoOrDie("kernel_path");
 
-  std::string paths_comma_separated =
-      flag_info.is_default ? fetcher_config.FindCvdFileWithSuffix("kernel")
-                           : flag_info.current_value;
+  std::vector<std::string> kernel_paths;
 
-  std::vector<std::string> kernel_paths =
-      android::base::Split(paths_comma_separated, ",");
+  if (flag_info.is_default) {
+    for (size_t i = 0; i < fetcher_configs.Size(); ++i) {
+      kernel_paths.emplace_back(
+          fetcher_configs.ForInstance(i).FindCvdFileWithSuffix("kernel"));
+    }
+  } else {
+    kernel_paths = android::base::Split(flag_info.current_value, ",");
+  }
 
   return KernelPathFlag(std::move(kernel_paths));
 }