support for tcp-mode flag

Author: stuqdog

src/viam/examples/modules/simple/main.cpp

@@ -95,9 +95,7 @@ int main(int argc, char** argv) try {
         &MySensor::validate);
 
     std::vector<std::shared_ptr<ModelRegistration>> mrs = {mr};
-    VIAM_SDK_LOG(info) << "making my_mod!";
     auto my_mod = std::make_shared<ModuleService>(argc, argv, mrs);
-    VIAM_SDK_LOG(info) << "about to serve!";
     my_mod->serve();
 
     return EXIT_SUCCESS;

src/viam/sdk/module/service.cpp

@@ -192,7 +192,7 @@ struct ModuleService::ServiceImpl : viam::module::v1::ModuleService::Service {
         const std::lock_guard<std::mutex> lock(parent.lock_);
         const viam::module::v1::HandlerMap hm = to_proto(parent.module_->handles());
         *response->mutable_handlermap() = hm;
-        auto new_parent_addr = parent.parent_addr_protocol_ + request->parent_address();
+        auto new_parent_addr = parent.grpc_conn_protocol_ + request->parent_address();
         if (parent.parent_addr_ != new_parent_addr) {
             parent.parent_addr_ = std::move(new_parent_addr);
             Options opts{0, boost::none};
@@ -234,51 +234,38 @@ std::shared_ptr<Resource> ModuleService::get_parent_resource_(const Name& name)
     return parent_->resource_by_name(name);
 }
 
-namespace {
+ModuleService::ModuleService(std::string addr) : ModuleService(std::move(addr), "unix:") {}
 
-bool tcp_set() {
-    // NOLINTNEXTLINE
-    const char* using_tcp = std::getenv("VIAM_TCP_SOCKETS");
-    if (!using_tcp) {
-        return false;
-    }
-    std::vector<std::string> true_values{"true", "yes", "1", "TRUE", "YES"};
-    return std::any_of(true_values.begin(), true_values.end(), [&](const std::string& v) {
-        return using_tcp == v;
-    });
+ModuleService::ModuleService(std::string addr, std::string grpc_conn_protocol)
+    : module_(std::make_unique<Module>(std::move(addr))),
+      grpc_conn_protocol_(std::move(grpc_conn_protocol)),
+      server_(std::make_unique<Server>()) {
+    impl_ = std::make_unique<ServiceImpl>(*this);
 }
 
-std::string get_parent_addr_protocol() {
-    VIAM_SDK_LOG(info) << "getting protocol!!";
-    // NOLINTNEXTLINE
-    const char* protocol = std::getenv("VIAM_PARENT_ADDR_PROTOCOL");
-    if (!protocol) {
-        if (tcp_set()) {
+namespace {
+std::string get_protocol(int argc, char** argv) {
+    for (int i = 0; i < argc; ++i) {
+        if (strcmp(argv[i], "--tcp-mode") == 0) {
             return "dns:";
         }
-        return "unix:";
     }
-    return std::string(protocol);
+    return "unix:";
 }
 }  // namespace
 
-ModuleService::ModuleService(std::string addr)
-    : module_(std::make_unique<Module>(std::move(addr))),
-      parent_addr_protocol_(get_parent_addr_protocol()),
-      server_(std::make_unique<Server>()) {
-    impl_ = std::make_unique<ServiceImpl>(*this);
-}
-
 ModuleService::ModuleService(int argc,
                              char** argv,
                              const std::vector<std::shared_ptr<ModelRegistration>>& registrations)
-    : ModuleService([argc, argv] {
-          if (argc < 2) {
-              throw Exception(ErrorCondition::k_connection,
-                              "Need socket path as command line argument");
-          }
-          return argv[1];
-      }()) {
+    : ModuleService(
+          [argc, argv] {
+              if (argc < 2) {
+                  throw Exception(ErrorCondition::k_connection,
+                                  "Need socket path as command line argument");
+              }
+              return (argv[1]);
+          }(),
+          get_protocol(argc, argv)) {
     LogManager::get().set_global_log_level(argc, argv);
 
     for (auto&& mr : registrations) {
@@ -302,10 +289,8 @@ ModuleService::~ModuleService() {
 }
 
 void ModuleService::serve() {
-    std::cout << "trying to start serving!!\n\n\n";
-    std::cout << "we have " << parent_addr_protocol_ << " and " << module_->addr();
     server_->register_service(impl_.get());
-    server_->add_listening_port(parent_addr_protocol_ + module_->addr());
+    server_->add_listening_port(grpc_conn_protocol_ + module_->addr());
 
     module_->set_ready();
     server_->start();

src/viam/sdk/module/service.hpp

@@ -33,6 +33,11 @@ class ModuleService {
     /// @param addr Address of socket to serve on.
     explicit ModuleService(std::string addr);
 
+    /// @brief Creates a new ModuleService that can serve on the provided socket.
+    /// @param addr Address of socket to serve on.
+    /// @param grpc_conn_protocol The protocol to connect with (UDS or TCP)
+    explicit ModuleService(std::string addr, std::string grpc_conn_protocol);
+
     /// @brief Creates a new ModuleService. Socket path and log level will be
     /// inferred from passed in command line arguments, and passed in model
     /// registrations will be registered and added to module.
@@ -70,8 +75,7 @@ class ModuleService {
 
     std::shared_ptr<RobotClient> parent_;
     std::string parent_addr_;
-    // CR erodkin: rename to `grpc_conn_protocol`
-    std::string parent_addr_protocol_;
+    std::string grpc_conn_protocol_;
 
     std::unique_ptr<Server> server_;
 

src/viam/sdk/robot/client.cpp

@@ -363,10 +363,7 @@ std::shared_ptr<RobotClient> RobotClient::at_address(const std::string& address,
 
 std::shared_ptr<RobotClient> RobotClient::at_local_socket(const std::string& address,
                                                           const Options& options) {
-    // CR erodkin: this function is now totally pointless, so let's get rid of it
-    // otoh, it's public and someone _could_ be using it... maybe we leave it around just in case?
-    std::cout << "\n\n\n\t\t address is " << address << "\n\n" << std::flush;
-    // auto addr = "unix:" + address;
+    // TODO (RSDK-10720) - refactor/replace `at_local_socket`
     auto robot = RobotClient::with_channel(
         ViamChannel(sdk::impl::create_viam_channel(address, grpc::InsecureChannelCredentials())),
         options);

src/viam/sdk/rpc/dial.cpp

@@ -183,11 +183,11 @@ ViamChannel ViamChannel::dial(const char* uri, const boost::optional<DialOptions
     std::string address;
     if (std::string(proxy_path).find(localhost_prefix) == std::string::npos) {
         // proxy path is not a localhost address and is therefore a unix domain socket (UDS)
-        std::cout << "\n\n\n\t\t\tsomehow this is happening\n\n\n";
+        // TODO (RSDK-10747) - update rust-utils to include this information directly, so that
+        // the SDKs don't have to.
         address += "unix:";
     }
     address += proxy_path;
-    std::cout << "address is " << address << "\n\n";
 
     auto chan =
         ViamChannel(sdk::impl::create_viam_channel(address, grpc::InsecureChannelCredentials()),