cvd: Add --reuse flag to cvd create

Adds `--reuse` 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/BUILD.bazel

@@ -149,6 +149,8 @@ cf_cc_library(
         "//cuttlefish/host/commands/cvd/cli/selector:num_instances_parser",
         "//cuttlefish/host/commands/cvd/cli/selector:selector_common_parser",
         "//cuttlefish/host/commands/cvd/cli/selector:selector_constants",
+        "//cuttlefish/host/commands/cvd/cli/selector",
+        "//cuttlefish/host/commands/cvd/cli:utils",
         "//cuttlefish/host/commands/cvd/fetch:fetch_cvd",
         "//cuttlefish/host/commands/cvd/instances",
         "//cuttlefish/host/commands/cvd/instances:cvd_persistent_data",

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

@@ -17,6 +17,8 @@
 #include "cuttlefish/host/commands/cvd/cli/commands/create.h"
 
 #include <errno.h>
+#include <fmt/core.h>
+#include <fmt/format.h>
 #include <stddef.h>
 
 #include <algorithm>
@@ -25,23 +27,24 @@
 #include <cstring>
 #include <limits>
 #include <memory>
+#include <optional>
+#include <ranges>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include <fmt/core.h>
-#include <fmt/format.h>
 #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"
 #include "cuttlefish/common/libs/utils/files.h"
+#include "cuttlefish/common/libs/utils/users.h"
 #include "cuttlefish/flag_parser/flag.h"
 #include "cuttlefish/flag_parser/gflags_compat.h"
-#include "cuttlefish/common/libs/utils/users.h"
 #include "cuttlefish/host/commands/cvd/cli/command_request.h"
 #include "cuttlefish/host/commands/cvd/cli/commands/command_handler.h"
 #include "cuttlefish/host/commands/cvd/cli/commands/host_tool_target.h"
@@ -50,9 +53,11 @@
 #include "cuttlefish/host/commands/cvd/cli/help_format.h"
 #include "cuttlefish/host/commands/cvd/cli/selector/creation_analyzer.h"
 #include "cuttlefish/host/commands/cvd/cli/selector/num_instances_parser.h"
+#include "cuttlefish/host/commands/cvd/cli/selector/selector.h"
 #include "cuttlefish/host/commands/cvd/cli/selector/selector_common_parser.h"
 #include "cuttlefish/host/commands/cvd/cli/selector/selector_constants.h"
 #include "cuttlefish/host/commands/cvd/cli/types.h"
+#include "cuttlefish/host/commands/cvd/cli/utils.h"
 #include "cuttlefish/host/commands/cvd/instances/cvd_persistent_data.pb.h"
 #include "cuttlefish/host/commands/cvd/instances/instance_manager.h"
 #include "cuttlefish/host/commands/cvd/instances/local_instance_group.h"
@@ -70,8 +75,6 @@ using selector::GroupCreationInfo;
 constexpr char kSummaryHelpText[] =
     "Create a Cuttlefish instance group";
 
-
-
 std::string DefaultHostPath(const cvd_common::Envs& envs) {
   for (const auto& key : {kAndroidHostOut, kAndroidSoongHostOut, "HOME"}) {
     auto it = envs.find(key);
@@ -118,6 +121,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,12 +251,73 @@ std::vector<Flag> BuildSelectorFlagsForCreateHelp(
   };
 }
 
+bool IsDeviceRunning(const LocalInstanceGroup& group) {
+  return std::ranges::any_of(group.Instances(), &LocalInstance::IsActive);
+}
+
+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(
     InstanceManager& instance_manager)
     : instance_manager_(instance_manager) {}
 
+Result<std::optional<LocalInstanceGroup>>
+CvdCreateCommandHandler::TryReuseGroup(
+    const selector::SelectorOptions& selectors, const cvd_common::Envs& envs) {
+  InstanceDatabase::Filter filter =
+      selector::BuildFilterFromSelectors(selectors);
+
+  const std::vector<LocalInstanceGroup> groups =
+      CF_EXPECT(instance_manager_.FindGroups(filter));
+  if (groups.empty()) {
+    return std::nullopt;
+  } else if (groups.size() == 1) {
+    auto target_host_it = envs.find(kAndroidHostOut);
+    CF_EXPECT(target_host_it != envs.end());
+
+    auto target_product_it = envs.find(kAndroidProductOut);
+    CF_EXPECT(target_product_it != envs.end());
+
+    const std::vector<std::string> target_products = ExpandProductPaths(
+        target_product_it->second, num_instances_parser_.NumInstances());
+    bool match = CF_EXPECT(
+        MatchPaths(groups[0], target_host_it->second, target_products));
+    CF_EXPECT(std::move(match),
+              "Trying to change the host paths on an existing group");
+    CF_EXPECT(!IsDeviceRunning(groups[0]),
+              "Group is already running, try `cvd stop`");
+    return groups[0];
+  } else {
+    return CF_ERRF("Unclear which of {} groups to match, try `cvd clear`",
+                   groups.size());
+  }
+}
+
 Result<void> CvdCreateCommandHandler::Handle(const CommandRequest& request) {
   std::vector<std::string> subcmd_args = request.SubcommandArguments();
 
@@ -275,23 +351,23 @@ 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 =
-      CF_EXPECT(CreateGroup(instance_manager_, subcmd_args, envs, request));
 
-  group.SetAllStates(cvd::INSTANCE_STATE_STOPPED);
-  CF_EXPECT(instance_manager_.UpdateInstanceGroup(group));
+  std::optional<LocalInstanceGroup> group;
+  if (own_flags_.reuse) {
+    group = CF_EXPECT(TryReuseGroup(request.Selectors(), envs));
+  }
+  if (!group.has_value()) {
+    group = CF_EXPECT(CreateGroup(subcmd_args, envs, request));
+  }
+  CF_EXPECT(group.has_value());
 
   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
       // when HOME is NOT overridden and selector flags are NOT given.
-      auto symlink_res = CreateSymlinks(group);
+      auto symlink_res = CreateSymlinks(*group);
       if (!symlink_res.ok()) {
         LOG(ERROR) << "Failed to create symlinks for default group: "
                    << symlink_res.error();
@@ -303,7 +379,6 @@ Result<void> CvdCreateCommandHandler::Handle(const CommandRequest& request) {
 }
 
 Result<LocalInstanceGroup> CvdCreateCommandHandler::CreateGroup(
-    InstanceManager& instance_manager,
     const std::vector<std::string>& subcmd_args, const cvd_common::Envs& envs,
     const CommandRequest& request) {
   GroupCreationInfo creation_info = CF_EXPECT(AnalyzeCreation({
@@ -313,15 +388,20 @@ Result<LocalInstanceGroup> CvdCreateCommandHandler::CreateGroup(
       .instance_ids = num_instances_parser_.InstanceIds(),
   }));
 
-  auto groups = CF_EXPECT(instance_manager.FindGroups(
+  auto groups = CF_EXPECT(instance_manager_.FindGroups(
       {.group_name = creation_info.group_creation_params.group_name}));
   CF_EXPECTF(groups.empty(), "Group named '{}' already exists",
              creation_info.group_creation_params.group_name);
-  return instance_manager.CreateInstanceGroup(
+
+  LocalInstanceGroup group = CF_EXPECT(instance_manager_.CreateInstanceGroup(
       std::move(creation_info.group_creation_params),
-      std::move(creation_info.group_directories));
-}
+      std::move(creation_info.group_directories)));
 
+  group.SetAllStates(cvd::INSTANCE_STATE_STOPPED);
+  CF_EXPECT(instance_manager_.UpdateInstanceGroup(group));
+
+  return group;
+}
 
 std::string CvdCreateCommandHandler::SummaryHelp() const {
   return kSummaryHelpText;
@@ -404,6 +484,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 = false;
   std::vector<Flag> flags = num_instances_parser_.Flags(selector_options);
   flags.emplace_back(
       GflagsCompatFlag("host_path", own_flags_.host_path)
@@ -417,6 +498,11 @@ 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", own_flags_.reuse)
+          .Help("Whether to attempt reusing an existing group. Will fail if "
+                "there are multiple matching groups, or the chosen group has a "
+                "host tools / guest image mismatch."));
   return flags;
 }
 

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

@@ -17,6 +17,7 @@
 #pragma once
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -44,13 +45,15 @@ class CvdCreateCommandHandler : public CvdCommandHandler {
     std::string product_path;
     bool start;
     std::string config_file;
+    bool reuse;
   };
 
   std::vector<Flag> ConfigFileModeFlags();
   std::vector<Flag> FlagModeFlags(const cvd_common::Envs& env,
                                   const selector::SelectorOptions&);
+  Result<std::optional<LocalInstanceGroup>> TryReuseGroup(
+      const selector::SelectorOptions& selectors, const cvd_common::Envs& envs);
   Result<LocalInstanceGroup> CreateGroup(
-      InstanceManager& instance_manager,
       const std::vector<std::string>& subcmd_args, const cvd_common::Envs& envs,
       const CommandRequest& request);
 

base/cvd/cuttlefish/host/commands/cvd/cli/selector/BUILD.bazel

@@ -13,10 +13,11 @@ cf_cc_library(
         "//cuttlefish/common/libs/utils:files",
         "//cuttlefish/common/libs/utils:users",
         "//cuttlefish/host/commands/cvd/cli/selector:selector_common_parser",
+        "//cuttlefish/host/commands/cvd/cli:utils",
         "//cuttlefish/host/commands/cvd/instances",
+        "//cuttlefish/host/commands/cvd/instances/lock",
         "//cuttlefish/host/commands/cvd/instances:cvd_persistent_data",
         "//cuttlefish/host/commands/cvd/instances:instance_manager",
-        "//cuttlefish/host/commands/cvd/instances/lock",
         "//cuttlefish/host/commands/cvd/utils:common",
         "//cuttlefish/result",
         "//libbase",

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

@@ -29,6 +29,7 @@
 
 #include "cuttlefish/common/libs/utils/files.h"
 #include "cuttlefish/common/libs/utils/users.h"
+#include "cuttlefish/host/commands/cvd/cli/utils.h"
 #include "cuttlefish/host/commands/cvd/utils/common.h"
 
 namespace cuttlefish {
@@ -82,31 +83,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/cli/selector/selector.cpp

@@ -42,20 +42,6 @@ enum class DisplayBehavior {
   LabelInstance,
 };
 
-Result<InstanceDatabase::Filter> BuildFilterFromSelectors(
-    const SelectorOptions& selectors) {
-  InstanceDatabase::Filter filter;
-  filter.group_name = selectors.group_name;
-  if (selectors.instance_names) {
-    const std::vector<std::string> per_instance_names =
-        selectors.instance_names.value();
-    for (const auto& per_instance_name : per_instance_names) {
-      filter.instance_names.insert(per_instance_name);
-    }
-  }
-  return filter;
-}
-
 std::string GroupDisplay(const std::vector<LocalInstanceGroup>& groups,
                          const DisplayBehavior behavior) {
   std::stringstream result;
@@ -150,10 +136,24 @@ Result<std::pair<LocalInstance, LocalInstanceGroup>> PromptUserForInstance(
 
 }  // namespace
 
+InstanceDatabase::Filter BuildFilterFromSelectors(
+    const SelectorOptions& selectors) {
+  InstanceDatabase::Filter filter;
+  filter.group_name = selectors.group_name;
+  if (selectors.instance_names) {
+    const std::vector<std::string> per_instance_names =
+        selectors.instance_names.value();
+    for (const auto& per_instance_name : per_instance_names) {
+      filter.instance_names.insert(per_instance_name);
+    }
+  }
+  return filter;
+}
+
 Result<LocalInstanceGroup> SelectGroup(const InstanceManager& instance_manager,
                                        const CommandRequest& request) {
   const InstanceDatabase::Filter filter =
-      CF_EXPECT(BuildFilterFromSelectors(request.Selectors()));
+      BuildFilterFromSelectors(request.Selectors());
   std::vector<LocalInstanceGroup> groups =
       CF_EXPECT(instance_manager.FindGroups(filter));
   CF_EXPECT(!groups.empty(), "No instance groups available");
@@ -169,7 +169,7 @@ Result<LocalInstanceGroup> SelectGroup(const InstanceManager& instance_manager,
 Result<std::pair<LocalInstance, LocalInstanceGroup>> SelectInstance(
     const InstanceManager& instance_manager, const CommandRequest& request) {
   const InstanceDatabase::Filter filter =
-      CF_EXPECT(BuildFilterFromSelectors(request.Selectors()));
+      BuildFilterFromSelectors(request.Selectors());
   std::vector<std::pair<LocalInstanceGroup, std::vector<LocalInstance>>>
       found_instances = CF_EXPECT(instance_manager.FindInstances(filter));
   CF_EXPECT(!found_instances.empty(), "No instances available");

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

@@ -27,6 +27,9 @@
 namespace cuttlefish {
 namespace selector {
 
+InstanceDatabase::Filter BuildFilterFromSelectors(
+    const SelectorOptions& selectors);
+
 // Selects a single group based on the request's selector options. Asks the user
 // to manually choose a single group if multiple groups match the selector
 // options and stdin is a terminal.