host/commands/cvd_env/main.cc - device/google/cuttlefish - Git at Google

 /*
  * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <filesystem>
 #include <unordered_map>

 #include <android-base/logging.h>
 #include <android-base/strings.h>
 #include <gflags/gflags.h>
 #include <grpcpp/ext/proto_server_reflection_plugin.h>
 #include <grpcpp/grpcpp.h>
 #include <test/cpp/util/grpc_tool.h>
 #include <test/cpp/util/test_config.h>

 #include "common/libs/utils/contains.h"
 #include "common/libs/utils/result.h"
 #include "host/libs/config/cuttlefish_config.h"

 using grpc::InsecureChannelCredentials;

 namespace cuttlefish {
 namespace {

 constexpr char kCvdEnvHelpMessage[] =
     "cvd env: cuttlefish environment controller\n"
     "Basic usage: cvd [selector options] env [sub_command] [args] [options]\n"
     "Sub commands:\n"
     "  ls: list services and methods for given arguments\n"
     "    Usage: cvd [selector options] env ls [service] [method] [-l]\n"
     "      service(optional) : gRPC service name\n"
     "      method(optional)  : method name for given service\n"
     "      -l(optional)      : Use a long listing format\n"
     "  type: get detailed information for given request/reply type\n"
     "    Usage: cvd [selector options] env type [service] [method] [type]\n"
     "      service           : gRPC service name\n"
     "      method            : method name in given service\n"
     "      type              : Protocol buffer type name in given method\n"
     "  call: request a rpc with given method\n"
     "    Usage: cvd [selector options] env call [service] [method] [request]\n"
     "      service           : gRPC service name\n"
     "      method            : method name in given service\n"
     "      request           : Protobuffer with text format\n\n"
     "* \"cvd [selector_options] env\" can be replaced with:\n"
     "    \"cvd_internal_env [internal device name]\"\n";

 bool PrintStream(std::stringstream* ss, const grpc::string& output) {
   (*ss) << output;
   return true;
 }

 class InsecureCliCredentials final : public grpc::testing::CliCredentials {
  public:
   std::shared_ptr<grpc::ChannelCredentials> GetChannelCredentials()
       const override {
     return InsecureChannelCredentials();
   }
   const grpc::string GetCredentialUsage() const override { return ""; }
 };

 std::vector<char*> ConvertToCharVec(const std::vector<std::string>& str_vec) {
   std::vector<char*> char_vec;
   char_vec.reserve(str_vec.size());
   for (const auto& str : str_vec) {
     char_vec.push_back(const_cast<char*>(str.c_str()));
   }
   return char_vec;
 }

 void RunGrpcCommand(const std::vector<std::string>& arguments,
                     std::stringstream& output_stream) {
   int grpc_cli_argc = arguments.size();
   auto new_arguments = ConvertToCharVec(arguments);
   char** grpc_cli_argv = new_arguments.data();

   grpc::testing::InitTest(&grpc_cli_argc, &grpc_cli_argv, true);
   grpc::testing::GrpcToolMainLib(
       grpc_cli_argc, (const char**)grpc_cli_argv, InsecureCliCredentials(),
       std::bind(PrintStream, &output_stream, std::placeholders::_1));
 }

 std::string RunGrpcCommand(const std::vector<std::string>& arguments) {
   std::stringstream output_stream;
   RunGrpcCommand(arguments, output_stream);
   return output_stream.str();
 }

 std::vector<std::string> GetServiceList(const std::string& server_address) {
   std::vector<std::string> service_list;
   std::stringstream output_stream;

   std::vector<std::string> arguments{"grpc_cli", "ls", server_address};
   RunGrpcCommand(arguments, output_stream);

   std::string service_name;
   while (std::getline(output_stream, service_name)) {
     if (service_name.compare("grpc.reflection.v1alpha.ServerReflection") == 0) {
       continue;
     }
     service_list.emplace_back(service_name);
   }

   return service_list;
 }

 Result<std::string> GetServerAddress(
     const std::vector<std::string>& server_address_list,
     const std::string& service_name) {
   std::vector<std::string> candidates;
   for (const auto& server_address : server_address_list) {
     for (auto& full_service_name : GetServiceList(server_address)) {
       if (android::base::EndsWith(full_service_name, service_name)) {
         candidates.emplace_back(server_address);
         break;
       }
     }
   }

   CF_EXPECT(candidates.size() > 0, service_name + " is not found.");
   CF_EXPECT(candidates.size() < 2, service_name + " is ambiguous.");

   return candidates[0];
 }

 Result<std::string> GetFullServiceName(const std::string& server_address,
                                        const std::string& service_name) {
   std::vector<std::string> candidates;
   for (auto& full_service_name : GetServiceList(server_address)) {
     if (android::base::EndsWith(full_service_name, service_name)) {
       candidates.emplace_back(full_service_name);
     }
   }

   CF_EXPECT(candidates.size() > 0, service_name + " is not found.");
   CF_EXPECT(candidates.size() < 2, service_name + " is ambiguous.");

   return candidates[0];
 }

 Result<std::string> GetFullMethodName(const std::string& server_address,
                                       const std::string& service_name,
                                       const std::string& method_name) {
   const auto& full_service_name =
       CF_EXPECT(GetFullServiceName(server_address, service_name));
   return full_service_name + "/" + method_name;
 }

 Result<std::string> GetFullTypeName(const std::string& server_address,
                                     const std::string& service_name,
                                     const std::string& method_name,
                                     const std::string& type_name) {
   // Run grpc_cli ls -l for given method to extract full type name.
   // Example output:
   //   rpc OpenwrtIpaddr(google.protobuf.Empty) returns
   //   (openwrtcontrolserver.OpenwrtIpaddrReply) {}
   const auto& full_method_name =
       CF_EXPECT(GetFullMethodName(server_address, service_name, method_name));
   std::vector<std::string> grpc_arguments{"grpc_cli", "ls", "-l",
                                           server_address, full_method_name};
   auto grpc_result = RunGrpcCommand(grpc_arguments);

   std::vector<std::string> candidates;
   for (auto& full_type_name : android::base::Split(grpc_result, "()")) {
     if (android::base::EndsWith(full_type_name, type_name)) {
       candidates.emplace_back(full_type_name);
     }
   }

   CF_EXPECT(candidates.size() > 0, service_name + " is not found.");
   CF_EXPECT(candidates.size() < 2, service_name + " is ambiguous.");

   return candidates[0];
 }

 Result<void> HandleLsCmd(const std::vector<std::string>& server_address_list,
                          const std::vector<std::string>& args,
                          const std::vector<std::string>& options) {
   CF_EXPECT(args.size() < 3, "too many arguments");

   if (args.size() > 0) {
     std::vector<std::string> grpc_arguments{"grpc_cli", "ls"};

     const auto& service_name = args[0];
     const auto& server_address =
         CF_EXPECT(GetServerAddress(server_address_list, service_name));
     grpc_arguments.push_back(server_address);
     if (args.size() > 1) {
       // ls subcommand with 2 arguments; service_name and method_name
       const auto& method_name = args[1];
       const auto& full_method_name = CF_EXPECT(
           GetFullMethodName(server_address, service_name, method_name));
       grpc_arguments.push_back(full_method_name);
     } else {
       // ls subcommand with 1 argument; service_name
       const auto& full_service_name =
           CF_EXPECT(GetFullServiceName(server_address, service_name));
       grpc_arguments.push_back(full_service_name);
     }
     grpc_arguments.insert(grpc_arguments.end(), options.begin(), options.end());

     std::cout << RunGrpcCommand(grpc_arguments);
   } else {
     // ls subcommand with no arguments
     for (const auto& server_address : server_address_list) {
       std::vector<std::string> grpc_arguments{"grpc_cli", "ls", server_address};
       grpc_arguments.insert(grpc_arguments.end(), options.begin(),
                             options.end());

       std::cout << RunGrpcCommand(grpc_arguments);
     }
   }

   return {};
 }

 Result<void> HandleTypeCmd(const std::vector<std::string>& server_address_list,
                            const std::vector<std::string>& args,
                            const std::vector<std::string>& options) {
   CF_EXPECT(args.size() > 2,
             "need to specify a service name, a method name, and type_name");
   CF_EXPECT(args.size() < 4, "too many arguments");

   std::vector<std::string> grpc_arguments{"grpc_cli", "type"};
   const auto& service_name = args[0];
   const auto& method_name = args[1];
   const auto& type_name = args[2];

   const auto& server_address =
       CF_EXPECT(GetServerAddress(server_address_list, service_name));
   grpc_arguments.push_back(server_address);
   const auto& full_type_name = CF_EXPECT(
       GetFullTypeName(server_address, service_name, method_name, type_name));
   grpc_arguments.push_back(full_type_name);

   grpc_arguments.insert(grpc_arguments.end(), options.begin(), options.end());

   std::cout << RunGrpcCommand(grpc_arguments);

   return {};
 }

 Result<void> HandleCallCmd(const std::vector<std::string>& server_address_list,
                            const std::vector<std::string>& args,
                            const std::vector<std::string>& options) {
   CF_EXPECT(args.size() > 2,
             "need to specify a service name, a method name, and text-formatted "
             "proto");
   CF_EXPECT(args.size() < 4, "too many arguments");

   std::vector<std::string> grpc_arguments{"grpc_cli", "call"};
   // TODO(b/265384449): support the case without text-formatted proto.
   const auto& service_name = args[0];
   const auto& method_name = args[1];
   const auto& proto_text_format = args[2];

   const auto& server_address =
       CF_EXPECT(GetServerAddress(server_address_list, service_name));
   grpc_arguments.push_back(server_address);
   const auto& full_method_name =
       CF_EXPECT(GetFullMethodName(server_address, service_name, method_name));
   grpc_arguments.push_back(full_method_name);
   grpc_arguments.push_back(proto_text_format);

   grpc_arguments.insert(grpc_arguments.end(), options.begin(), options.end());

   std::cout << RunGrpcCommand(grpc_arguments);

   return {};
 }

 bool ContainHelpOption(int argc, char** argv) {
   for (int i = 0; i < argc; i++) {
     if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-help") == 0) {
       return true;
     }
   }
   return false;
 }

 Result<void> CvdEnvMain(int argc, char** argv) {
   ::android::base::InitLogging(argv, android::base::StderrLogger);
   if (ContainHelpOption(argc, argv)) {
     std::cout << kCvdEnvHelpMessage;
     return {};
   }

   CF_EXPECT(argc >= 3, " need to specify a receiver and a command");
   const auto& receiver = argv[1];
   const auto& cmd = argv[2];

   std::vector<std::string> options;
   std::vector<std::string> args;
   for (int i = 3; i < argc; i++) {
     if (android::base::StartsWith(argv[i], '-')) {
       options.push_back(argv[i]);
     } else {
       args.push_back(argv[i]);
     }
   }

   const auto* config = CuttlefishConfig::Get();
   CF_EXPECT(config != nullptr, "Unable to find the config");
   std::vector<std::string> server_address_list;
   const auto& instances = config->Instances();
   auto receiver_instance = std::find_if(
       begin(instances), end(instances), [&receiver](const auto& instance) {
         return receiver == instance.instance_name();
       });

   CF_EXPECT(receiver_instance != std::end(instances),
             "there is no instance of which name is "
                 << receiver << ". please check instance name by cvd fleet");

   for (const auto& entry : std::filesystem::directory_iterator(
            receiver_instance->grpc_socket_path())) {
     LOG(DEBUG) << "loading " << entry.path();
     server_address_list.emplace_back("unix:" + entry.path().string());
   }

   auto command_map =
       std::unordered_map<std::string, std::function<Result<void>(
                                           const std::vector<std::string>&,
                                           const std::vector<std::string>&,
                                           const std::vector<std::string>&)>>{{
           {"call", HandleCallCmd},
           {"ls", HandleLsCmd},
           {"type", HandleTypeCmd},
       }};

   CF_EXPECT(Contains(command_map, cmd), cmd << " isn't supported");

   CF_EXPECT(command_map[cmd](server_address_list, args, options));

   return {};
 }

 }  // namespace
 }  // namespace cuttlefish

 int main(int argc, char** argv) {
   const auto& ret = cuttlefish::CvdEnvMain(argc, argv);
   CHECK(ret.ok()) << ret.error().Message();
   return 0;
 }
	/*
	* Copyright (C) 2022 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <filesystem>
	#include <unordered_map>

	#include <android-base/logging.h>
	#include <android-base/strings.h>
	#include <gflags/gflags.h>
	#include <grpcpp/ext/proto_server_reflection_plugin.h>
	#include <grpcpp/grpcpp.h>
	#include <test/cpp/util/grpc_tool.h>
	#include <test/cpp/util/test_config.h>

	#include "common/libs/utils/contains.h"
	#include "common/libs/utils/result.h"
	#include "host/libs/config/cuttlefish_config.h"

	using grpc::InsecureChannelCredentials;

	namespace cuttlefish {
	namespace {

	constexpr char kCvdEnvHelpMessage[] =
	"cvd env: cuttlefish environment controller\n"
	"Basic usage: cvd [selector options] env [sub_command] [args] [options]\n"
	"Sub commands:\n"
	" ls: list services and methods for given arguments\n"
	" Usage: cvd [selector options] env ls [service] [method] [-l]\n"
	" service(optional) : gRPC service name\n"
	" method(optional) : method name for given service\n"
	" -l(optional) : Use a long listing format\n"
	" type: get detailed information for given request/reply type\n"
	" Usage: cvd [selector options] env type [service] [method] [type]\n"
	" service : gRPC service name\n"
	" method : method name in given service\n"
	" type : Protocol buffer type name in given method\n"
	" call: request a rpc with given method\n"
	" Usage: cvd [selector options] env call [service] [method] [request]\n"
	" service : gRPC service name\n"
	" method : method name in given service\n"
	" request : Protobuffer with text format\n\n"
	"* \"cvd [selector_options] env\" can be replaced with:\n"
	" \"cvd_internal_env [internal device name]\"\n";

	bool PrintStream(std::stringstream* ss, const grpc::string& output) {
	(*ss) << output;
	return true;
	}

	class InsecureCliCredentials final : public grpc::testing::CliCredentials {
	public:
	std::shared_ptr<grpc::ChannelCredentials> GetChannelCredentials()
	const override {
	return InsecureChannelCredentials();
	}
	const grpc::string GetCredentialUsage() const override { return ""; }
	};

	std::vector<char*> ConvertToCharVec(const std::vector<std::string>& str_vec) {
	std::vector<char*> char_vec;
	char_vec.reserve(str_vec.size());
	for (const auto& str : str_vec) {
	char_vec.push_back(const_cast<char*>(str.c_str()));
	}
	return char_vec;
	}

	void RunGrpcCommand(const std::vector<std::string>& arguments,
	std::stringstream& output_stream) {
	int grpc_cli_argc = arguments.size();
	auto new_arguments = ConvertToCharVec(arguments);
	char** grpc_cli_argv = new_arguments.data();

	grpc::testing::InitTest(&grpc_cli_argc, &grpc_cli_argv, true);
	grpc::testing::GrpcToolMainLib(
	grpc_cli_argc, (const char**)grpc_cli_argv, InsecureCliCredentials(),
	std::bind(PrintStream, &output_stream, std::placeholders::_1));
	}

	std::string RunGrpcCommand(const std::vector<std::string>& arguments) {
	std::stringstream output_stream;
	RunGrpcCommand(arguments, output_stream);
	return output_stream.str();
	}

	std::vector<std::string> GetServiceList(const std::string& server_address) {
	std::vector<std::string> service_list;
	std::stringstream output_stream;

	std::vector<std::string> arguments{"grpc_cli", "ls", server_address};
	RunGrpcCommand(arguments, output_stream);

	std::string service_name;
	while (std::getline(output_stream, service_name)) {
	if (service_name.compare("grpc.reflection.v1alpha.ServerReflection") == 0) {
	continue;
	}
	service_list.emplace_back(service_name);
	}

	return service_list;
	}

	Result<std::string> GetServerAddress(
	const std::vector<std::string>& server_address_list,
	const std::string& service_name) {
	std::vector<std::string> candidates;
	for (const auto& server_address : server_address_list) {
	for (auto& full_service_name : GetServiceList(server_address)) {
	if (android::base::EndsWith(full_service_name, service_name)) {
	candidates.emplace_back(server_address);
	break;
	}
	}
	}

	CF_EXPECT(candidates.size() > 0, service_name + " is not found.");
	CF_EXPECT(candidates.size() < 2, service_name + " is ambiguous.");

	return candidates[0];
	}

	Result<std::string> GetFullServiceName(const std::string& server_address,
	const std::string& service_name) {
	std::vector<std::string> candidates;
	for (auto& full_service_name : GetServiceList(server_address)) {
	if (android::base::EndsWith(full_service_name, service_name)) {
	candidates.emplace_back(full_service_name);
	}
	}

	CF_EXPECT(candidates.size() > 0, service_name + " is not found.");
	CF_EXPECT(candidates.size() < 2, service_name + " is ambiguous.");

	return candidates[0];
	}

	Result<std::string> GetFullMethodName(const std::string& server_address,
	const std::string& service_name,
	const std::string& method_name) {
	const auto& full_service_name =
	CF_EXPECT(GetFullServiceName(server_address, service_name));
	return full_service_name + "/" + method_name;
	}

	Result<std::string> GetFullTypeName(const std::string& server_address,
	const std::string& service_name,
	const std::string& method_name,
	const std::string& type_name) {
	// Run grpc_cli ls -l for given method to extract full type name.
	// Example output:
	// rpc OpenwrtIpaddr(google.protobuf.Empty) returns
	// (openwrtcontrolserver.OpenwrtIpaddrReply) {}
	const auto& full_method_name =
	CF_EXPECT(GetFullMethodName(server_address, service_name, method_name));
	std::vector<std::string> grpc_arguments{"grpc_cli", "ls", "-l",
	server_address, full_method_name};
	auto grpc_result = RunGrpcCommand(grpc_arguments);

	std::vector<std::string> candidates;
	for (auto& full_type_name : android::base::Split(grpc_result, "()")) {
	if (android::base::EndsWith(full_type_name, type_name)) {
	candidates.emplace_back(full_type_name);
	}
	}

	CF_EXPECT(candidates.size() > 0, service_name + " is not found.");
	CF_EXPECT(candidates.size() < 2, service_name + " is ambiguous.");

	return candidates[0];
	}

	Result<void> HandleLsCmd(const std::vector<std::string>& server_address_list,
	const std::vector<std::string>& args,
	const std::vector<std::string>& options) {
	CF_EXPECT(args.size() < 3, "too many arguments");

	if (args.size() > 0) {
	std::vector<std::string> grpc_arguments{"grpc_cli", "ls"};

	const auto& service_name = args[0];
	const auto& server_address =
	CF_EXPECT(GetServerAddress(server_address_list, service_name));
	grpc_arguments.push_back(server_address);
	if (args.size() > 1) {
	// ls subcommand with 2 arguments; service_name and method_name
	const auto& method_name = args[1];
	const auto& full_method_name = CF_EXPECT(
	GetFullMethodName(server_address, service_name, method_name));
	grpc_arguments.push_back(full_method_name);
	} else {
	// ls subcommand with 1 argument; service_name
	const auto& full_service_name =
	CF_EXPECT(GetFullServiceName(server_address, service_name));
	grpc_arguments.push_back(full_service_name);
	}
	grpc_arguments.insert(grpc_arguments.end(), options.begin(), options.end());

	std::cout << RunGrpcCommand(grpc_arguments);
	} else {
	// ls subcommand with no arguments
	for (const auto& server_address : server_address_list) {
	std::vector<std::string> grpc_arguments{"grpc_cli", "ls", server_address};
	grpc_arguments.insert(grpc_arguments.end(), options.begin(),
	options.end());

	std::cout << RunGrpcCommand(grpc_arguments);
	}
	}

	return {};
	}

	Result<void> HandleTypeCmd(const std::vector<std::string>& server_address_list,
	const std::vector<std::string>& args,
	const std::vector<std::string>& options) {
	CF_EXPECT(args.size() > 2,
	"need to specify a service name, a method name, and type_name");
	CF_EXPECT(args.size() < 4, "too many arguments");

	std::vector<std::string> grpc_arguments{"grpc_cli", "type"};
	const auto& service_name = args[0];
	const auto& method_name = args[1];
	const auto& type_name = args[2];

	const auto& server_address =
	CF_EXPECT(GetServerAddress(server_address_list, service_name));
	grpc_arguments.push_back(server_address);
	const auto& full_type_name = CF_EXPECT(
	GetFullTypeName(server_address, service_name, method_name, type_name));
	grpc_arguments.push_back(full_type_name);

	grpc_arguments.insert(grpc_arguments.end(), options.begin(), options.end());

	std::cout << RunGrpcCommand(grpc_arguments);

	return {};
	}

	Result<void> HandleCallCmd(const std::vector<std::string>& server_address_list,
	const std::vector<std::string>& args,
	const std::vector<std::string>& options) {
	CF_EXPECT(args.size() > 2,
	"need to specify a service name, a method name, and text-formatted "
	"proto");
	CF_EXPECT(args.size() < 4, "too many arguments");

	std::vector<std::string> grpc_arguments{"grpc_cli", "call"};
	// TODO(b/265384449): support the case without text-formatted proto.
	const auto& service_name = args[0];
	const auto& method_name = args[1];
	const auto& proto_text_format = args[2];

	const auto& server_address =
	CF_EXPECT(GetServerAddress(server_address_list, service_name));
	grpc_arguments.push_back(server_address);
	const auto& full_method_name =
	CF_EXPECT(GetFullMethodName(server_address, service_name, method_name));
	grpc_arguments.push_back(full_method_name);
	grpc_arguments.push_back(proto_text_format);

	grpc_arguments.insert(grpc_arguments.end(), options.begin(), options.end());

	std::cout << RunGrpcCommand(grpc_arguments);

	return {};
	}

	bool ContainHelpOption(int argc, char** argv) {
	for (int i = 0; i < argc; i++) {
	if (strcmp(argv[i], "--help") == 0 \|\| strcmp(argv[i], "-help") == 0) {
	return true;
	}
	}
	return false;
	}

	Result<void> CvdEnvMain(int argc, char** argv) {
	::android::base::InitLogging(argv, android::base::StderrLogger);
	if (ContainHelpOption(argc, argv)) {
	std::cout << kCvdEnvHelpMessage;
	return {};
	}

	CF_EXPECT(argc >= 3, " need to specify a receiver and a command");
	const auto& receiver = argv[1];
	const auto& cmd = argv[2];

	std::vector<std::string> options;
	std::vector<std::string> args;
	for (int i = 3; i < argc; i++) {
	if (android::base::StartsWith(argv[i], '-')) {
	options.push_back(argv[i]);
	} else {
	args.push_back(argv[i]);
	}
	}

	const auto* config = CuttlefishConfig::Get();
	CF_EXPECT(config != nullptr, "Unable to find the config");
	std::vector<std::string> server_address_list;
	const auto& instances = config->Instances();
	auto receiver_instance = std::find_if(
	begin(instances), end(instances), [&receiver](const auto& instance) {
	return receiver == instance.instance_name();
	});

	CF_EXPECT(receiver_instance != std::end(instances),
	"there is no instance of which name is "
	<< receiver << ". please check instance name by cvd fleet");

	for (const auto& entry : std::filesystem::directory_iterator(
	receiver_instance->grpc_socket_path())) {
	LOG(DEBUG) << "loading " << entry.path();
	server_address_list.emplace_back("unix:" + entry.path().string());
	}

	auto command_map =
	std::unordered_map<std::string, std::function<Result<void>(
	const std::vector<std::string>&,
	const std::vector<std::string>&,
	const std::vector<std::string>&)>>{{
	{"call", HandleCallCmd},
	{"ls", HandleLsCmd},
	{"type", HandleTypeCmd},
	}};

	CF_EXPECT(Contains(command_map, cmd), cmd << " isn't supported");

	CF_EXPECT(command_map[cmd](server_address_list, args, options));

	return {};
	}

	} // namespace
	} // namespace cuttlefish

	int main(int argc, char** argv) {
	const auto& ret = cuttlefish::CvdEnvMain(argc, argv);
	CHECK(ret.ok()) << ret.error().Message();
	return 0;
	}