cvd: Add --reuse_if_possible flag to cvd create

Adds `--reuse_if_possible` flag to `cvd create`. If this flag is provided,
`cvd create` will check if there is an existing instance group with matching
host and product paths. If a matching group is found and it is not in an
active state (preparing, starting, running, stopping), it will delegate
to `cvd start` for that group and skip the rest of the creation logic.

Exposes `ExpandProductPaths` in `cvd` utils to share it between `cvd create`
and `CreationAnalyzer` for consistent product path expansion.

Assisted-by: Jetski:Gemini-Next
Bug: b/519304405
TAG=agy
CONV=34ddc7b8-a695-4937-be99-b796087dd987

Author: Databean

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

@@ -25,6 +25,7 @@
 #include <cstring>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <sstream>
 #include <string>
 #include <utility>
@@ -35,6 +36,7 @@
 #include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/str_split.h"
 
 #include "cuttlefish/common/libs/utils/contains.h"
 #include "cuttlefish/common/libs/utils/environment.h"
@@ -118,6 +120,18 @@ Result<CommandRequest> CreateStartCommand(const LocalInstanceGroup& group,
                        .Build());
 }
 
+Result<void> StartGroup(const LocalInstanceGroup& group,
+                        const std::vector<std::string>& subcmd_args,
+                        const cvd_common::Envs& envs,
+                        InstanceManager& instance_manager) {
+  const CommandRequest start_cmd =
+      CF_EXPECT(CreateStartCommand(group, subcmd_args, envs));
+  std::unique_ptr<CvdCommandHandler> start_handler =
+      NewCvdStartCommandHandler(instance_manager);
+  CF_EXPECT(start_handler->Handle(start_cmd));
+  return {};
+}
+
 Result<cvd_common::Envs> GetEnvs(const CommandRequest& request) {
   cvd_common::Envs envs = request.Env();
   if (auto it = envs.find("HOME"); it != envs.end() && it->second.empty()) {
@@ -236,6 +250,47 @@ std::vector<Flag> BuildSelectorFlagsForCreateHelp(
   };
 }
 
+bool IsActiveState(cvd::InstanceState state) {
+  return state == cvd::INSTANCE_STATE_PREPARING ||
+         state == cvd::INSTANCE_STATE_STARTING ||
+         state == cvd::INSTANCE_STATE_RUNNING ||
+         state == cvd::INSTANCE_STATE_STOPPING;
+}
+
+bool IsGroupReuseable(const LocalInstanceGroup& group) {
+  for (const LocalInstance& instance : group.Instances()) {
+    if (IsActiveState(instance.State())) {
+      return false;
+    }
+  }
+  return true;
+}
+
+Result<bool> MatchPaths(const LocalInstanceGroup& group, const std::string& target_host,
+                        const std::vector<std::string>& target_products) {
+  const std::string real_group_host = CF_EXPECT(RealPath(group.HostArtifactsPath()));
+  const std::string real_target_host = CF_EXPECT(RealPath(target_host));
+
+  if (real_group_host != real_target_host) {
+    return false;
+  }
+
+  const std::vector<std::string> group_products =
+      absl::StrSplit(group.ProductOutPath(), ',');
+
+  std::vector<std::string> real_group_products;
+  for (const auto& path : group_products) {
+    real_group_products.push_back(CF_EXPECT(RealPath(path)));
+  }
+
+  std::vector<std::string> real_target_products;
+  for (const auto& path : target_products) {
+    real_target_products.push_back(CF_EXPECT(RealPath(path)));
+  }
+
+  return real_group_products == real_target_products;
+}
+
 }  // namespace
 
 CvdCreateCommandHandler::CvdCreateCommandHandler(
@@ -275,18 +330,49 @@ Result<void> CvdCreateCommandHandler::Handle(const CommandRequest& request) {
   // CreationAnalyzer needs these to be set in the environment
   envs[kAndroidHostOut] = AbsolutePath(own_flags_.host_path);
   envs[kAndroidProductOut] = AbsolutePath(own_flags_.product_path);
-  auto group =
+
+  if (own_flags_.reuse_if_possible) {
+    const std::string target_host = envs[kAndroidHostOut];
+    const std::string target_product = envs[kAndroidProductOut];
+    const std::vector<std::string> target_products =
+        ExpandProductPaths(target_product, num_instances_parser_.NumInstances());
+
+    const std::vector<LocalInstanceGroup> groups =
+        CF_EXPECT(instance_manager_.FindGroups({}));
+
+    std::optional<LocalInstanceGroup> matched_group;
+    for (const LocalInstanceGroup& g : groups) {
+      const auto match_res = MatchPaths(g, target_host, target_products);
+      if (!match_res.ok()) {
+        continue;
+      }
+      if (*match_res) {
+        matched_group = g;
+        break;
+      }
+    }
+    if (matched_group) {
+      if (IsGroupReuseable(*matched_group)) {
+        LOG(INFO) << "Reusing existing instance group: "
+                  << matched_group->GroupName();
+        CF_EXPECT(StartGroup(*matched_group, subcmd_args, envs, instance_manager_));
+        return {};
+      } else {
+        LOG(WARNING) << "Found matching instance group '"
+                     << matched_group->GroupName()
+                     << "' but it is in active state. Proceding with creation of a new group.";
+      }
+    }
+  }
+
+  LocalInstanceGroup group =
       CF_EXPECT(CreateGroup(instance_manager_, subcmd_args, envs, request));
 
   group.SetAllStates(cvd::INSTANCE_STATE_STOPPED);
   CF_EXPECT(instance_manager_.UpdateInstanceGroup(group));
 
   if (own_flags_.start) {
-    CommandRequest start_cmd =
-        CF_EXPECT(CreateStartCommand(group, subcmd_args, envs));
-    std::unique_ptr<CvdCommandHandler> start_handler =
-        NewCvdStartCommandHandler(instance_manager_);
-    CF_EXPECT(start_handler->Handle(start_cmd));
+    CF_EXPECT(StartGroup(group, subcmd_args, envs, instance_manager_));
 
     if (CF_EXPECT(IsDefaultGroup(request))) {
       // For backward compatibility, we add extra symlink in system wide home
@@ -404,6 +490,7 @@ std::vector<Flag> CvdCreateCommandHandler::FlagModeFlags(
   own_flags_.host_path = DefaultHostPath(env);
   own_flags_.product_path = DefaultProductPath(env);
   own_flags_.start = true;
+  own_flags_.reuse_if_possible = false;
   std::vector<Flag> flags = num_instances_parser_.Flags(selector_options);
   flags.emplace_back(
       GflagsCompatFlag("host_path", own_flags_.host_path)
@@ -417,6 +504,9 @@ std::vector<Flag> CvdCreateCommandHandler::FlagModeFlags(
                 "$ANDROID_PRODUCT_OUT, $HOME or the current directory."));
   flags.emplace_back(GflagsCompatFlag("start", own_flags_.start)
                          .Help("Whether to start the instance group."));
+  flags.emplace_back(
+      GflagsCompatFlag("reuse_if_possible", own_flags_.reuse_if_possible)
+          .Help("Reuse an existing instance group if paths match and it is stopped."));
   return flags;
 }
 

base/cvd/cuttlefish/host/commands/cvd/cli/commands/create.h

@@ -44,6 +44,7 @@ class CvdCreateCommandHandler : public CvdCommandHandler {
     std::string product_path;
     bool start;
     std::string config_file;
+    bool reuse_if_possible;
   };
 
   std::vector<Flag> ConfigFileModeFlags();

base/cvd/cuttlefish/host/commands/cvd/cli/selector/creation_analyzer.cpp

@@ -82,31 +82,23 @@ Result<GroupCreationInfo> AnalyzeCreation(const CreationAnalyzerParam& params) {
       .home = CF_EXPECT(HomeFromEnvironment(params.envs)),
       .host_artifacts_path = CF_EXPECT(AndroidHostPath(params.envs)),
   };
-  group_directories.product_out_paths.reserve(params.num_instances);
-  auto it = params.envs.find(kAndroidProductOut);
+  std::string product_out_val;
+  const auto it = params.envs.find(kAndroidProductOut);
   if (it != params.envs.end()) {
-    std::vector<std::string_view> env_product_out =
-        absl::StrSplit(it->second, ',');
+    product_out_val = it->second;
+    const std::vector<std::string_view> env_product_out =
+        absl::StrSplit(product_out_val, ',');
     if (env_product_out.size() > params.num_instances) {
       LOG(WARNING) << env_product_out.size()
                    << " product paths provided, but only "
                    << params.num_instances << " are going to be created";
-      env_product_out.resize(params.num_instances);
-    }
-    for (auto& env_path : env_product_out) {
-      group_directories.product_out_paths.emplace_back(env_path);
     }
   } else {
-    group_directories.product_out_paths.emplace_back(
-        group_directories.host_artifacts_path);
-  }
-  while (group_directories.product_out_paths.size() < params.num_instances) {
-    // Use the first product path when more instances are required than product
-    // paths provided. This supports creating multiple identical instances from
-    // a single set of images.
-    group_directories.product_out_paths.emplace_back(
-        group_directories.product_out_paths[0]);
+    product_out_val = group_directories.host_artifacts_path.value_or("");
   }
+  const std::vector<std::string> expanded =
+      ExpandProductPaths(product_out_val, params.num_instances);
+  group_directories.product_out_paths.assign(expanded.begin(), expanded.end());
 
   return GroupCreationInfo{
       .group_creation_params = group_params,

base/cvd/cuttlefish/host/commands/cvd/utils/common.cpp

@@ -22,8 +22,9 @@
 #include <unordered_map>
 
 #include <android-base/file.h>
-#include "absl/strings/strip.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/strip.h"
 
 #include "cuttlefish/common/libs/utils/files.h"
 #include "cuttlefish/host/libs/config/config_utils.h"
@@ -146,4 +147,18 @@ std::string AssemblyDirFromHome(const std::string& group_home_dir) {
   return to_ret;
 }
 
+std::vector<std::string> ExpandProductPaths(const std::string& product_path,
+                                            size_t num_instances) {
+  const std::vector<std::string_view> split = absl::StrSplit(product_path, ',');
+  std::vector<std::string> expanded;
+  expanded.reserve(num_instances);
+  for (size_t i = 0; i < std::min(split.size(), num_instances); ++i) {
+    expanded.push_back(std::string(split[i]));
+  }
+  while (expanded.size() < num_instances) {
+    expanded.push_back(expanded[0]);
+  }
+  return expanded;
+}
+
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/cvd/utils/common.h

@@ -56,4 +56,7 @@ std::string AssemblyDirFromHome(const std::string& group_home_dir);
 // variables followed by the current directory.
 Result<std::string> AndroidHostPath(const cvd_common::Envs& env);
 
+std::vector<std::string> ExpandProductPaths(const std::string& product_path,
+                                            size_t num_instances);
+
 }  // namespace cuttlefish