Merge branch 'main' into conan-test-windows

Author: stuqdog

src/viam/sdk/log/logging.cpp

@@ -105,8 +105,11 @@ void LogManager::set_global_log_level(log_level lvl) {
 }
 
 void LogManager::set_global_log_level(int argc, char** argv) {
-    if (argc >= 3 && strcmp(argv[2], "--log-level=debug") == 0) {
-        set_global_log_level(log_level::debug);
+    for (int i = 0; i < argc; ++i) {
+        if (strcmp(argv[i], "--log-level=debug") == 0) {
+            set_global_log_level(log_level::debug);
+            return;
+        }
     }
 }
 
@@ -147,8 +150,8 @@ void LogManager::enable_console_logging() {
 void LogManager::disable_console_logging() {
     VIAM_SDK_LOG(debug) << "Disabling console logging";
 
-    // Set a filter which ignores all console logs unless they contain a console force flag which is
-    // set to true.
+    // Set a filter which ignores all console logs unless they contain a console force flag
+    // which is set to true.
     console_sink_->set_filter(
         [filter = Filter{this}](const boost::log::attribute_value_set& attrs) {
             auto force = attrs[impl::attr_console_force_type{}];

src/viam/sdk/module/service.cpp

@@ -48,6 +48,17 @@
 namespace viam {
 namespace sdk {
 
+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:";
+}
+}  // namespace
+
 struct ModuleService::ServiceImpl : viam::module::v1::ModuleService::Service {
     ServiceImpl(ModuleService& p) : parent(p) {}
 
@@ -191,7 +202,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 = 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};
@@ -233,21 +244,27 @@ std::shared_ptr<Resource> ModuleService::get_parent_resource_(const Name& name)
     return parent_->resource_by_name(name);
 }
 
-ModuleService::ModuleService(std::string addr)
-    : module_(std::make_unique<Module>(std::move(addr))), server_(std::make_unique<Server>()) {
+ModuleService::ModuleService(std::string addr) : ModuleService(std::move(addr), "unix:") {}
+
+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);
 }
 
 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) {
@@ -272,8 +289,7 @@ ModuleService::~ModuleService() {
 
 void ModuleService::serve() {
     server_->register_service(impl_.get());
-    const std::string address = "unix:" + module_->addr();
-    server_->add_listening_port(address);
+    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,6 +75,7 @@ class ModuleService {
 
     std::shared_ptr<RobotClient> parent_;
     std::string parent_addr_;
+    std::string grpc_conn_protocol_;
 
     std::unique_ptr<Server> server_;
 

src/viam/sdk/robot/client.cpp

@@ -363,9 +363,9 @@ 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) {
-    const std::string addr = "unix:" + address;
+    // TODO (RSDK-10720) - refactor/replace `at_local_socket`
     auto robot = RobotClient::with_channel(
-        ViamChannel(sdk::impl::create_viam_channel(addr, grpc::InsecureChannelCredentials())),
+        ViamChannel(sdk::impl::create_viam_channel(address, grpc::InsecureChannelCredentials())),
         options);
 
     return robot;

src/viam/sdk/rpc/dial.cpp

@@ -183,6 +183,8 @@ 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)
+        // TODO (RSDK-10747) - update rust-utils to include this information directly, so that
+        // the SDKs don't have to.
         address += "unix:";
     }
     address += proxy_path;