Link Group level logs to instance log directory

So the host orchestrator can find them.

Bug: 444758816

Author: jemoreira

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

@@ -99,6 +99,7 @@ Result<void> DiskImageFlagsVectorization(
       CF_EXPECT(InstanceNumsCalculator().FromGlobalGflags().Calculate());
   for (const auto& num : instance_nums) {
     auto instance = config.ForInstance(num);
+    instance.set_images_dir(system_image_dir.ForIndex(instance_index));
     std::string cur_boot_image = boot_image.BootImageForIndex(instance_index);
     instance.set_boot_image(cur_boot_image);
     instance.set_new_boot_image(cur_boot_image);

base/cvd/cuttlefish/host/commands/start/main.cc

@@ -22,6 +22,7 @@
 #include <android-base/logging.h>
 #include <android-base/no_destructor.h>
 #include <android-base/parseint.h>
+#include <fmt/format.h>
 #include <gflags/gflags.h>
 
 #include "cuttlefish/common/libs/fs/shared_fd.h"
@@ -168,6 +169,36 @@ const std::unordered_set<std::string>& BoolFlags() {
   return *bool_flags;
 }
 
+Result<void> LinkLogs2InstanceDir(
+    const std::string& config_path, const CuttlefishConfig& config,
+    const CuttlefishConfig::InstanceSpecific& instance) {
+  CF_EXPECT(EnsureDirectoryExists(instance.PerInstanceLogPath("")));
+
+  CF_EXPECT(CreateSymLink(
+      config_path,
+      instance.PerInstanceLogPath(android::base::Basename(config_path)),
+      false));
+
+  std::string assemble_cvd_logs = config.AssemblyPath("assemble_cvd.log");
+  CF_EXPECT(CreateSymLink(assemble_cvd_logs,
+                          instance.PerInstanceLogPath("assemble_cvd.log")));
+
+  std::string images_dir = instance.images_dir();
+  std::string fetch_log = fmt::format("{}/{}", images_dir, "fetch.log");
+  if (!FileExists(fetch_log)) {
+    // The fetch.log file can be in the same directory as the downloaded
+    // instances or its parent directory if --target_subdirectory was used.
+    fetch_log =
+        fmt::format("{}/{}", android::base::Dirname(images_dir), "fetch.log");
+  }
+  if (FileExists(fetch_log)) {
+    CF_EXPECT(
+        CreateSymLink(fetch_log, instance.PerInstanceLogPath("fetch.log")));
+  }
+
+  return {};
+}
+
 int CvdInternalStartMain(int argc, char** argv) {
   ::android::base::InitLogging(argv, android::base::StderrLogger);
 
@@ -281,6 +312,12 @@ int CvdInternalStartMain(int argc, char** argv) {
 
   std::vector<Subprocess> runners;
   for (const auto& instance : config->Instances()) {
+    Result<void> link_res =
+        LinkLogs2InstanceDir(conf_path, *config, instance);
+    if (!link_res.ok()) {
+      LOG(ERROR) << "Failed to link logs to instance dir: "
+                 << link_res.error().FormatForEnv();
+    }
     SharedFD runner_stdin = SharedFD::Open("/dev/null", O_RDONLY);
     CHECK(runner_stdin->IsOpen()) << runner_stdin->StrError();
     setenv(kCuttlefishInstanceEnvVarName, instance.id().c_str(),

base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h

@@ -573,6 +573,7 @@ class CuttlefishConfig {
     bool restart_subprocesses() const;
 
     // android artifacts
+    std::string images_dir() const;
     std::string boot_image() const;
     std::string new_boot_image() const;
     std::string init_boot_image() const;
@@ -808,6 +809,7 @@ class CuttlefishConfig {
     void set_restart_subprocesses(bool restart_subprocesses);
 
     // system image files
+    void set_images_dir(const std::string& dir);
     void set_boot_image(const std::string& boot_image);
     void set_new_boot_image(const std::string& new_boot_image);
     void set_init_boot_image(const std::string& init_boot_image);

base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp

@@ -100,6 +100,14 @@ bool CuttlefishConfig::InstanceSpecific::use_bootloader() const {
 };
 
 // vectorized and moved system image files into instance specific
+static constexpr char kImagesDir[] = "images_dir";
+std::string CuttlefishConfig::InstanceSpecific::images_dir() const {
+  return (*Dictionary())[kImagesDir].asString();
+}
+void CuttlefishConfig::MutableInstanceSpecific::set_images_dir(
+    const std::string& dir) {
+  (*Dictionary())[kImagesDir] = dir;
+}
 static constexpr char kBootImage[] = "boot_image";
 std::string CuttlefishConfig::InstanceSpecific::boot_image() const {
   return (*Dictionary())[kBootImage].asString();