Replace common cases of RunWithManagedStdio with a wrapper call

Bug: b/434043969

Author: Databean

base/cvd/cuttlefish/common/libs/utils/archive.cpp

@@ -69,14 +69,9 @@ Result<std::vector<std::string>> ExtractFiles(
   for (const auto& extract : to_extract) {
     bsdtar_cmd.AddParameter(extract);
   }
-  bsdtar_cmd.RedirectStdIO(Subprocess::StdIOChannel::kStdOut,
-                           Subprocess::StdIOChannel::kStdErr);
-  std::string bsdtar_output;
-  int bsdtar_ret = RunWithManagedStdio(std::move(bsdtar_cmd), nullptr, nullptr,
-                                       &bsdtar_output);
+  std::string bsdtar_output =
+      CF_EXPECT(RunAndCaptureStdout(std::move(bsdtar_cmd)));
   LOG(DEBUG) << bsdtar_output;
-  CF_EXPECTF(bsdtar_ret == 0, "bsdtar extraction failed on '{}', '''{}'''",
-             archive, bsdtar_output);
 
   std::vector<std::string> outputs = android::base::Split(bsdtar_output, "\n");
   for (std::string& output : outputs) {
@@ -135,29 +130,31 @@ std::string ExtractArchiveToMemory(const std::string& archive_filepath,
   bsdtar_cmd.AddParameter(archive_filepath);
   bsdtar_cmd.AddParameter("-O");
   bsdtar_cmd.AddParameter(archive_member);
-  std::string stdout_str;
-  auto ret =
-      RunWithManagedStdio(std::move(bsdtar_cmd), nullptr, &stdout_str, nullptr);
-  if (ret != 0) {
+  Result<std::string> stdout_str = RunAndCaptureStdout(std::move(bsdtar_cmd));
+
+  if (!stdout_str.ok()) {
     LOG(ERROR) << "Could not extract \"" << archive_member << "\" from \""
-               << archive_filepath << "\" to memory.";
+               << archive_filepath
+               << "\" to memory: " << stdout_str.error().FormatForEnv();
     return "";
   }
-  return stdout_str;
+  return *stdout_str;
 }
 
 std::vector<std::string> ArchiveContents(const std::string& archive) {
   Command bsdtar_cmd("/usr/bin/bsdtar");
   bsdtar_cmd.AddParameter("-tf");
   bsdtar_cmd.AddParameter(archive);
-  std::string bsdtar_input, bsdtar_output;
-  auto bsdtar_ret = RunWithManagedStdio(std::move(bsdtar_cmd), &bsdtar_input,
-                                        &bsdtar_output, nullptr);
-  if (bsdtar_ret != 0) {
-    LOG(ERROR) << "`bsdtar -tf \"" << archive << "\"` returned " << bsdtar_ret;
+
+  Result<std::string> bsdtar_output =
+      RunAndCaptureStdout(std::move(bsdtar_cmd));
+  if (bsdtar_output.ok()) {
+    return android::base::Split(*bsdtar_output, "\n");
+  } else {
+    LOG(ERROR) << "`bsdtar -tf '" << archive
+               << "'`failed: " << bsdtar_output.error().FormatForEnv();
+    return {};
   }
-  return bsdtar_ret == 0 ? android::base::Split(bsdtar_output, "\n")
-                         : std::vector<std::string>();
 }
 
 } // namespace cuttlefish

base/cvd/cuttlefish/common/libs/utils/disk_usage.cpp

@@ -41,11 +41,7 @@ Result<std::size_t> GetDiskUsage(const std::string& path,
   du_cmd.AddParameter("--block-size=" + size_arg);
   du_cmd.AddParameter(path);
 
-  std::string out;
-  std::string err;
-  int return_code = RunWithManagedStdio(std::move(du_cmd), nullptr, &out, &err);
-  CF_EXPECTF(return_code == 0, "Failed to run `du` command.  stderr: {}", err);
-  CF_EXPECTF(!out.empty(), "No output read from `du` command. stderr: {}", err);
+  std::string out = CF_EXPECT(RunAndCaptureStdout(std::move(du_cmd)));
   std::vector<std::string> split_out =
       android::base::Tokenize(out, kWhitespaceCharacters);
   CF_EXPECTF(!split_out.empty(),

base/cvd/cuttlefish/common/libs/utils/network.cpp

@@ -128,8 +128,7 @@ std::set<std::string> TapInterfacesInUse() {
     cmd->AddParameter(fdinfo);
   }
 
-  std::string stdout_str, stderr_str;
-  RunWithManagedStdio(std::move(*cmd), nullptr, &stdout_str, &stderr_str);
+  std::string stdout_str = RunAndCaptureStdout(std::move(*cmd)).value_or("");
 
   auto lines = android::base::Split(stdout_str, "\n");
   std::set<std::string> tap_interfaces;

base/cvd/cuttlefish/common/libs/utils/wait_for_unix_socket.cpp

@@ -80,16 +80,9 @@ Result<void> WaitForUnixSocketListeningWithoutConnect(const std::string& path,
     Command lsof("/usr/bin/lsof");
     lsof.AddParameter(/*"format"*/ "-F", /*"connection state"*/ "TST");
     lsof.AddParameter(path);
-    std::string lsof_out;
-    std::string lsof_err;
-    int rval =
-        RunWithManagedStdio(std::move(lsof), nullptr, &lsof_out, &lsof_err);
-    if (rval != 0) {
-      return CF_ERR("Failed to run `lsof`, stderr: " << lsof_err);
-    }
+    std::string lsof_out = CF_EXPECT(RunAndCaptureStdout(std::move(lsof)));
 
     LOG(DEBUG) << "lsof stdout:|" << lsof_out << "|";
-    LOG(DEBUG) << "lsof stderr:|" << lsof_err << "|";
 
     std::smatch socket_state_match;
     if (std::regex_search(lsof_out, socket_state_match, socket_state_regex)) {

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

@@ -104,25 +104,24 @@ Result<void> CleanPriorFiles(const std::vector<std::string>& paths,
   if (!InSandbox() && (!prior_dirs.empty() || !prior_files.empty())) {
     Command lsof("lsof");
     lsof.AddParameter("-t");
+    lsof.AddParameter("-Q");  // ignore failed search terms
     for (const auto& prior_dir : prior_dirs) {
       lsof.AddParameter("+D").AddParameter(prior_dir);
     }
     for (const auto& prior_file : prior_files) {
       lsof.AddParameter(prior_file);
     }
 
-    std::string lsof_out;
-    std::string lsof_err;
-    int rval =
-        RunWithManagedStdio(std::move(lsof), nullptr, &lsof_out, &lsof_err);
-    if (rval != 0 && !lsof_err.empty()) {
-      LOG(ERROR) << "Failed to run `lsof`, received message: " << lsof_err;
+    Result<std::string> lsof_out = RunAndCaptureStdout(std::move(lsof));
+    if (lsof_out.ok()) {
+      std::vector<std::string> pids = android::base::Split(*lsof_out, "\n");
+      CF_EXPECTF(
+          lsof_out->empty(),
+          "Instance directory files in use. Try `cvd reset`? Observed PIDs: {}",
+          fmt::join(pids, ", "));
+    } else {
+      LOG(ERROR) << "Failed to run `lsof`: " << lsof_out.error().FormatForEnv();
     }
-    auto pids = android::base::Split(lsof_out, "\n");
-    CF_EXPECTF(
-        lsof_out.empty(),
-        "Instance directory files in use. Try `cvd reset`? Observed PIDs: {}",
-        fmt::join(pids, ", "));
   }
 
   for (const auto& path : paths) {

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

@@ -539,7 +539,7 @@ GetGraphicsAvailabilityWithSubprocessCheck() {
   auto graphics_detector_binary_result = GraphicsDetectorBinaryPath();
   if (!graphics_detector_binary_result.ok()) {
     LOG(ERROR) << "Failed to run graphics detector, graphics detector path "
-               << " not available: "
+               << " not available: \n"
                << graphics_detector_binary_result.error().FormatForEnv()
                << ". Assuming no availability.";
     return {};
@@ -550,15 +550,15 @@ GetGraphicsAvailabilityWithSubprocessCheck() {
   Command graphics_detector_cmd(graphics_detector_binary_result.value());
   graphics_detector_cmd.AddParameter(graphics_availability_file.path);
 
-  std::string graphics_detector_stdout;
-  auto ret = RunWithManagedStdio(std::move(graphics_detector_cmd), nullptr,
-                                 &graphics_detector_stdout, nullptr);
-  if (ret != 0) {
-    LOG(ERROR) << "Failed to run graphics detector, bad return value: " << ret
-               << ". Assuming no availability.";
+  Result<std::string> graphics_detector_stdout =
+      RunAndCaptureStdout(std::move(graphics_detector_cmd));
+  if (!graphics_detector_stdout.ok()) {
+    LOG(ERROR)
+        << "Failed to run graphics detector, assuming no availability: \n"
+        << graphics_detector_stdout.error().FormatForEnv();
     return {};
   }
-  LOG(DEBUG) << graphics_detector_stdout;
+  LOG(DEBUG) << *graphics_detector_stdout;
 
   auto graphics_availability_content_result =
       ReadFileContents(graphics_availability_file.path);

base/cvd/cuttlefish/host/commands/cvd/acloud/converter.cpp

@@ -81,21 +81,15 @@ static Result<BranchBuildTargetInfo> GetDefaultBranchBuildTarget(
     repo_cmd.SetWorkingDirectory(fd_top);
   }
 
-  std::string repo_stdout;
-  CF_EXPECT_EQ(
-      RunWithManagedStdio(std::move(repo_cmd), nullptr, &repo_stdout, nullptr),
-      0);
+  std::string repo_stdout = CF_EXPECT(RunAndCaptureStdout(std::move(repo_cmd)));
 
   Command git_cmd("git");
   git_cmd.AddParameter("remote");
   if (fd_top->IsOpen()) {
     git_cmd.SetWorkingDirectory(fd_top);
   }
 
-  std::string git_stdout;
-  CF_EXPECT_EQ(
-      RunWithManagedStdio(std::move(git_cmd), nullptr, &git_stdout, nullptr),
-      0);
+  std::string git_stdout = CF_EXPECT(RunAndCaptureStdout(std::move(git_cmd)));
 
   git_stdout.erase(std::remove(git_stdout.begin(), git_stdout.end(), '\n'),
                    git_stdout.cend());
@@ -133,10 +127,7 @@ Result<std::vector<std::string>> BashTokenize(const std::string& str) {
   command.AddParameter("-c");
   command.AddParameter("printf '%s\n' ", str);
 
-  std::string bash_stdout;
-  CF_EXPECT(
-      RunWithManagedStdio(std::move(command), nullptr, &bash_stdout, nullptr),
-      0);
+  std::string bash_stdout = CF_EXPECT(RunAndCaptureStdout(std::move(command)));
 
   return android::base::Split(bash_stdout, "\n");
 }

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

@@ -454,7 +454,6 @@ cf_cc_library(
         "//cuttlefish/common/libs/fs",
         "//cuttlefish/common/libs/utils:result",
         "//cuttlefish/common/libs/utils:subprocess",
-        "//cuttlefish/common/libs/utils:subprocess_managed_stdio",
         "//cuttlefish/host/commands/cvd/acloud",
         "//cuttlefish/host/commands/cvd/cli:command_request",
         "//cuttlefish/host/commands/cvd/cli:types",

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

@@ -32,7 +32,6 @@
 #include "cuttlefish/common/libs/fs/shared_fd.h"
 #include "cuttlefish/common/libs/utils/result.h"
 #include "cuttlefish/common/libs/utils/subprocess.h"
-#include "cuttlefish/common/libs/utils/subprocess_managed_stdio.h"
 #include "cuttlefish/host/commands/cvd/acloud/config.h"
 #include "cuttlefish/host/commands/cvd/acloud/converter.h"
 #include "cuttlefish/host/commands/cvd/acloud/create_converter_parser.h"
@@ -61,12 +60,7 @@ constexpr char kDetailedHelpText[] =
    
     - Or `cvdr` for remote instance management.)";
 
-bool CheckIfCvdrExist() {
-  auto cmd = Command("which").AddParameter(kCvdrBinName);
-  int ret = RunWithManagedStdio(std::move(cmd), nullptr, nullptr, nullptr,
-                                SubprocessOptions());
-  return ret == 0;
-}
+bool CheckIfCvdrExist() { return Execute({"which", kCvdrBinName}) == 0; }
 
 }  // namespace
 

base/cvd/cuttlefish/host/commands/cvd/instances/instance_record.cpp

@@ -104,8 +104,7 @@ Result<Json::Value> LocalInstance::FetchStatus(std::chrono::seconds timeout) {
 }
 
 Result<void> LocalInstance::PressPowerBtn() {
-  auto bin_check = 
-      HostToolTarget(host_artifacts_path()).GetPowerBtnBinPath();
+  auto bin_check = HostToolTarget(host_artifacts_path()).GetPowerBtnBinPath();
   if (bin_check.ok()) {
     return PressPowerBtnLegacy();
   }
@@ -115,18 +114,12 @@ Result<void> LocalInstance::PressPowerBtn() {
                "powerbtn not supported in vm manager " << config->vm_manager());
   auto instance = config->ForInstance(id());
 
-  Command command(instance.crosvm_binary());
-  command.AddParameter("powerbtn");
-  command.AddParameter(instance.CrosvmSocketPath());
+  Command command = Command(instance.crosvm_binary())
+                        .AddParameter("powerbtn")
+                        .AddParameter(instance.CrosvmSocketPath());
 
   LOG(INFO) << "Pressing power button";
-  std::string output;
-  std::string error;
-  auto ret = RunWithManagedStdio(std::move(command), NULL, &output, &error);
-  CF_EXPECT_EQ(ret, 0,
-               "crosvm powerbtn returned: " << ret << "\n"
-                                            << output << "\n"
-                                            << error);
+  CF_EXPECT(RunAndCaptureStdout(std::move(command)));
   return {};
 }