RSDK-10435: Dial direct

CMakeLists.txt

@@ -462,6 +462,10 @@ if (VIAMCPPSDK_GRPCXX_VERSION VERSION_LESS 1.32.0)
   set(VIAMCPPSDK_GRPCXX_LEGACY_FWD 1)
 endif()
 
+if(VIAMCPPSDK_GRPCXX_VERSION VERSION_LESS 1.43.0)
+  set(VIAMCPPSDK_GRPCXX_NO_DIRECT_DIAL 1)
+endif()
+
 include(FetchContent)
 
 FetchContent_Declare(

src/viam/api/CMakeLists.txt

@@ -228,6 +228,10 @@ if (VIAMCPPSDK_USE_DYNAMIC_PROTOS)
     ${PROTO_GEN_DIR}/component/switch/v1/switch.grpc.pb.cc
     ${PROTO_GEN_DIR}/component/switch/v1/switch.grpc.pb.h
     ${PROTO_GEN_DIR}/component/switch/v1/switch.pb.cc
+    ${PROTO_GEN_DIR}/proto/rpc/v1/auth.pb.h
+    ${PROTO_GEN_DIR}/proto/rpc/v1/auth.pb.cc
+    ${PROTO_GEN_DIR}/proto/rpc/v1/auth.grpc.pb.h
+    ${PROTO_GEN_DIR}/proto/rpc/v1/auth.grpc.pb.cc
     ${PROTO_GEN_DIR}/component/switch/v1/switch.pb.h
     ${PROTO_GEN_DIR}/google/api/annotations.pb.cc
     ${PROTO_GEN_DIR}/google/api/annotations.pb.h
@@ -361,6 +365,8 @@ target_sources(viamapi
     ${PROTO_GEN_DIR}/component/servo/v1/servo.pb.cc
     ${PROTO_GEN_DIR}/component/switch/v1/switch.grpc.pb.cc
     ${PROTO_GEN_DIR}/component/switch/v1/switch.pb.cc
+    ${PROTO_GEN_DIR}/proto/rpc/v1/auth.grpc.pb.cc
+    ${PROTO_GEN_DIR}/proto/rpc/v1/auth.pb.cc
     ${PROTO_GEN_DIR}/google/api/annotations.pb.cc
     ${PROTO_GEN_DIR}/google/api/http.pb.cc
     ${PROTO_GEN_DIR}/google/api/httpbody.pb.cc
@@ -425,6 +431,8 @@ target_sources(viamapi
       ${PROTO_GEN_DIR}/../../viam/api/component/servo/v1/servo.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/component/switch/v1/switch.grpc.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/component/switch/v1/switch.pb.h
+      ${PROTO_GEN_DIR}/../../viam/api/proto/rpc/v1/auth.grpc.pb.h
+      ${PROTO_GEN_DIR}/../../viam/api/proto/rpc/v1/auth.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/google/api/annotations.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/google/api/http.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/google/api/httpbody.pb.h

src/viam/examples/camera/example_camera.cpp

@@ -28,14 +28,14 @@ int main() try {
     // dial_options.credentials = credentials;
 
     // This is for an example. Care should be taken before exercising this option in production.
-    dial_options.set_allow_insecure_downgrade(
-        (credentials.type().empty() && credentials.payload().empty()));
+    dial_options.allow_insecure_downgrade =
+        (credentials.type().empty() && credentials.payload().empty());
 
-    // Set the refresh interval of the robot (in seconds) (0 = auto refresh) and the dial
-    // options
-    vs::Options options = vs::Options(1, dial_options);
+    // Pass the scheduled refresh interval of the robot (0 seconds = only on config update) and the
+    // dial options
+    std::shared_ptr<vs::RobotClient> robot =
+        vs::RobotClient::at_address(robot_address, std::chrono::seconds{1}, dial_options);
 
-    std::shared_ptr<vs::RobotClient> robot = vs::RobotClient::at_address(robot_address, options);
     VIAM_SDK_LOG(info) << "Successfully connected to the robot";
 
     std::vector<vs::Name> resource_names = robot->resource_names();

src/viam/examples/dial/example_dial.cpp

@@ -25,14 +25,12 @@ int main() {
     DialOptions dial_options;
     std::string type = "<your authentication type>";
     std::string payload = "<your authentication payload>";
-    Credentials credentials(type, payload);
-    dial_options.set_credentials(credentials);
-    boost::optional<DialOptions> opts(dial_options);
+    dial_options.credentials = Credentials(type, payload);
     std::string address(uri);
-    Options options(1, opts);
 
     // connect to robot, ensure we can refresh it
-    std::shared_ptr<RobotClient> robot = RobotClient::at_address(address, options);
+    std::shared_ptr<RobotClient> robot =
+        RobotClient::at_address(address, std::chrono::seconds{1}, dial_options);
 
     // ensure we can query resources
     std::vector<Name> resource_names = robot->resource_names();

src/viam/examples/dial_api_key/example_dial_api_key.cpp

@@ -27,28 +27,30 @@ int main(int argc, char* argv[]) {
         "uri", po::value<std::string>(), "URI of robot")(
         "entity", po::value<std::string>(), "api key ID")(
         "api-key", po::value<std::string>(), "api key secret");
+
     po::variables_map vm;
     po::store(po::parse_command_line(argc, argv, desc), vm);
+
     if (vm.count("help")) {
         std::cout << desc << std::endl;
         return 0;
     }
-    boost::optional<DialOptions> opts;
+
+    DialOptions opts;
+
     if (vm.count("entity") && vm.count("api-key")) {
-        DialOptions dial_options;
-        dial_options.set_entity(vm["entity"].as<std::string>());
+        opts.auth_entity = vm["entity"].as<std::string>();
         Credentials credentials("api-key", vm["api-key"].as<std::string>());
-        dial_options.set_credentials(credentials);
-        opts = dial_options;
+        opts.credentials = credentials;
     }
-    Options options(1, opts);
 
     // connect to robot, ensure we can refresh it
     std::shared_ptr<RobotClient> robot =
-        RobotClient::at_address(vm["uri"].as<std::string>(), options);
+        RobotClient::at_address(vm["uri"].as<std::string>(), std::chrono::seconds{1}, opts);
 
     // ensure we can query resources
     std::vector<Name> resource_names = robot->resource_names();
+
     VIAM_SDK_LOG(info) << "Resources:";
     for (const Name& resource : resource_names) {
         VIAM_SDK_LOG(info) << resource;

src/viam/examples/mlmodel/example_audio_classification_client.cpp

@@ -243,11 +243,11 @@ int main(int argc, char* argv[]) try {
         // secret. Please see other examples for more details on
         // connecting to robots with the C++ SDK.
         viam::sdk::DialOptions dial_options;
-        dial_options.set_entity(opt_api_key_id.get());
-        dial_options.set_credentials(viam::sdk::Credentials("api-key", opt_api_key.get()));
+        dial_options.auth_entity = opt_api_key_id.get();
+        dial_options.credentials = viam::sdk::Credentials("api-key", opt_api_key.get());
 
-        auto robot =
-            vsdk::RobotClient::at_address(opt_robot_host.get(), {0, {std::move(dial_options)}});
+        auto robot = vsdk::RobotClient::at_address(
+            opt_robot_host.get(), std::chrono::seconds{0}, dial_options);
 
         // Obtain a handle to the MLModelService module on the robot. Note that the string
         // `yamnet_classification_tflite` is arbitrary. It just matches what was used to name the

src/viam/examples/modules/complex/client.cpp

@@ -26,27 +26,25 @@ int main() {
     // any other C++ SDK objects and stays alive until all Viam C++ SDK objects are destroyed.
     Instance inst;
 
-    const char* uri = "http://localhost:8080/";  // replace with your URI if connecting securely
+    std::string address = "http://localhost:8080/";  // replace with your URI if connecting securely
     DialOptions dial_options;
-    dial_options.set_allow_insecure_downgrade(true);  // set to false if connecting securely
+    dial_options.allow_insecure_downgrade = true;  // set to false if connecting securely
 
     // Uncomment and fill out your credentials details if connecting securely
     // std::string type = "<your authentication type>";
     // std::string payload = "<your authentication payload>";
     // Credentials credentials(type, payload);
     // dial_options.set_credentials(credentials);
 
-    boost::optional<DialOptions> opts(dial_options);
-    std::string address(uri);
-    Options options(1, opts);
-
     // Register custom gizmo and summation clients so robot client can access resources
     // of that type from the server.
     Registry::get().register_resource_client<GizmoClient>();
     Registry::get().register_resource_client<SummationClient>();
 
     // Connect to robot.
-    std::shared_ptr<RobotClient> robot = RobotClient::at_address(address, options);
+    std::shared_ptr<RobotClient> robot =
+        RobotClient::at_address(address, std::chrono::seconds{1}, dial_options);
+
     // Print resources.
     VIAM_SDK_LOG(info) << "Resources:";
     std::vector<Name> resource_names = robot->resource_names();

src/viam/examples/modules/complex/gizmo/api.cpp

@@ -24,12 +24,12 @@ API API::traits<Gizmo>::api() {
     return {"viam", "component", "gizmo"};
 }
 
-Gizmo::Gizmo(std::string name) : Component(std::move(name)){};
+Gizmo::Gizmo(std::string name) : Component(std::move(name)) {}
 
 /* Gizmo server methods */
 
 GizmoServer::GizmoServer(std::shared_ptr<ResourceManager> manager)
-    : ResourceServer(std::move(manager)){};
+    : ResourceServer(std::move(manager)) {}
 
 grpc::Status GizmoServer::DoOne(grpc::ServerContext* context,
                                 const DoOneRequest* request,
@@ -169,8 +169,8 @@ grpc::Status GizmoServer::DoTwo(::grpc::ServerContext* context,
 
 /* Gizmo client methods */
 
-GizmoClient::GizmoClient(std::string name, std::shared_ptr<grpc::Channel> channel)
-    : Gizmo(std::move(name)), stub_(GizmoService::NewStub(channel)), channel_(std::move(channel)){};
+GizmoClient::GizmoClient(std::string name, const ViamChannel& channel)
+    : Gizmo(std::move(name)), stub_(GizmoService::NewStub(channel.channel())), channel_(&channel) {}
 
 bool GizmoClient::do_one(std::string arg1) {
     return make_client_helper(this, *stub_, &StubType::DoOne)

src/viam/examples/modules/complex/gizmo/api.hpp

@@ -43,7 +43,11 @@ struct API::traits<Gizmo> {
 class GizmoClient : public Gizmo {
    public:
     using interface_type = Gizmo;
-    GizmoClient(std::string name, std::shared_ptr<grpc::Channel> channel);
+    GizmoClient(std::string name, const ViamChannel& channel);
+
+    const ViamChannel& channel() const {
+        return *channel_;
+    }
 
     bool do_one(std::string arg1) override;
     bool do_one_client_stream(std::vector<std::string> arg1) override;
@@ -54,7 +58,7 @@ class GizmoClient : public Gizmo {
    private:
     using StubType = GizmoService::StubInterface;
     std::unique_ptr<StubType> stub_;
-    std::shared_ptr<grpc::Channel> channel_;
+    const ViamChannel* channel_;
 };
 
 // `GizmoServer` is the gRPC server implementation of a `Gizmo` component.

src/viam/examples/modules/complex/summation/api.cpp

@@ -24,12 +24,12 @@ API API::traits<Summation>::api() {
     return {"viam", "service", "summation"};
 }
 
-Summation::Summation(std::string name) : Service(std::move(name)){};
+Summation::Summation(std::string name) : Service(std::move(name)) {}
 
 /* Summation server methods */
 
 SummationServer::SummationServer(std::shared_ptr<ResourceManager> manager)
-    : ResourceServer(std::move(manager)){};
+    : ResourceServer(std::move(manager)) {}
 
 grpc::Status SummationServer::Sum(grpc::ServerContext* context,
                                   const SumRequest* request,
@@ -55,10 +55,10 @@ grpc::Status SummationServer::Sum(grpc::ServerContext* context,
 
 /* Summation client methods */
 
-SummationClient::SummationClient(std::string name, std::shared_ptr<grpc::Channel> channel)
+SummationClient::SummationClient(std::string name, const ViamChannel& channel)
     : Summation(std::move(name)),
-      stub_(SummationService::NewStub(channel)),
-      channel_(std::move(channel)){};
+      stub_(SummationService::NewStub(channel.channel())),
+      channel_(&channel) {}
 
 double SummationClient::sum(std::vector<double> numbers) {
     return make_client_helper(this, *stub_, &StubType::Sum)

src/viam/examples/modules/complex/summation/api.hpp

@@ -9,6 +9,7 @@
 #include <viam/sdk/config/resource.hpp>
 #include <viam/sdk/registry/registry.hpp>
 #include <viam/sdk/resource/resource_manager.hpp>
+#include <viam/sdk/rpc/dial.hpp>
 #include <viam/sdk/services/service.hpp>
 
 #include "summation.grpc.pb.h"
@@ -43,14 +44,18 @@ struct API::traits<Summation> {
 class SummationClient : public Summation {
    public:
     using interface_type = Summation;
-    SummationClient(std::string name, std::shared_ptr<grpc::Channel> channel);
+    SummationClient(std::string name, const ViamChannel& channel);
+
+    const ViamChannel& channel() const {
+        return *channel_;
+    }
 
     double sum(std::vector<double> numbers) override;
 
    private:
     using StubType = SummationService::StubInterface;
     std::unique_ptr<StubType> stub_;
-    std::shared_ptr<grpc::Channel> channel_;
+    const ViamChannel* channel_;
 };
 
 // `SummationServer` is the gRPC server implementation of a `Summation`

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

@@ -16,21 +16,20 @@ int main() {
     // any other C++ SDK objects and stays alive until all Viam C++ SDK objects are destroyed.
     Instance inst;
 
-    const char* uri = "http://localhost:8080/";  // replace with your URI if connecting securely
+    // replace with your URI if connecting securely
+    std::string address = "http://localhost:8080/";
+
     DialOptions dial_options;
-    dial_options.set_allow_insecure_downgrade(true);  // set to false if connecting securely
+    dial_options.allow_insecure_downgrade = true;  // set to false if connecting securely
 
     // Uncomment and fill out your credentials details if connecting securely
     // std::string type = "<your authentication type>";
     // std::string payload = "<your authentication payload>";
     // Credentials credentials(type, payload);
     // dial_options.set_credentials(credentials);
 
-    boost::optional<DialOptions> opts(dial_options);
-    std::string address(uri);
-    Options options(1, opts);
-
-    std::shared_ptr<RobotClient> robot = RobotClient::at_address(address, options);
+    std::shared_ptr<RobotClient> robot =
+        RobotClient::at_address(address, std::chrono::seconds{1}, dial_options);
 
     // Print resources
     VIAM_SDK_LOG(info) << "Resources";

src/viam/examples/motor/example_motor.cpp

@@ -41,14 +41,14 @@ int main() try {
     // dial_options.credentials = credentials;
 
     // This is for an example. Care should be taken before exercising this option in production.
-    dial_options.set_allow_insecure_downgrade(
-        (credentials.type().empty() && credentials.payload().empty()));
+    dial_options.allow_insecure_downgrade =
+        (credentials.type().empty() && credentials.payload().empty());
 
-    // Set the refresh interval of the robot (in seconds) (0 = auto refresh) and the dial
-    // options
-    vs::Options options = vs::Options(1, dial_options);
+    // Pass the scheduled refresh interval of the robot (0 seconds = only on config update) and the
+    // dial options
+    std::shared_ptr<vs::RobotClient> robot =
+        vs::RobotClient::at_address(robot_address, std::chrono::seconds{1}, dial_options);
 
-    std::shared_ptr<vs::RobotClient> robot = vs::RobotClient::at_address(robot_address, options);
     VIAM_SDK_LOG(info) << "Successfully connected to the robot";
 
     std::vector<vs::Name> resource_names = robot->resource_names();

src/viam/sdk/common/client_helper.cpp

@@ -5,6 +5,7 @@
 #include <grpcpp/client_context.h>
 #include <grpcpp/support/status.h>
 
+#include <viam/sdk/common/private/instance.hpp>
 #include <viam/sdk/common/private/version_metadata.hpp>
 #include <viam/sdk/log/logging.hpp>
 
@@ -32,6 +33,12 @@ ClientContext::ClientContext() : wrapped_context_(std::make_unique<GrpcClientCon
     add_viam_client_version_();
 }
 
+ClientContext::ClientContext(const ViamChannel& channel) : ClientContext() {
+    if (channel.auth_token().has_value()) {
+        wrapped_context_->AddMetadata("authorization", "Bearer " + *channel.auth_token());
+    }
+}
+
 ClientContext::~ClientContext() = default;
 
 ClientContext::operator const GrpcClientContext*() const {

src/viam/sdk/common/client_helper.hpp

@@ -4,6 +4,7 @@
 #include <viam/sdk/common/grpc_fwd.hpp>
 #include <viam/sdk/common/private/utils.hpp>
 #include <viam/sdk/common/proto_value.hpp>
+#include <viam/sdk/rpc/dial.hpp>
 
 namespace viam {
 namespace sdk {
@@ -38,6 +39,8 @@ void set_name(...);
 class ClientContext {
    public:
     ClientContext();
+    ClientContext(const ViamChannel& channel);
+
     ~ClientContext();
 
     void try_cancel();
@@ -110,7 +113,7 @@ class ClientHelper {
     template <typename ResponseHandlerCallable, typename ErrorHandlerCallable>
     auto invoke(ResponseHandlerCallable&& rhc, ErrorHandlerCallable&& ehc) {
         client_helper_details::set_name(&request_, client_);
-        ClientContext ctx;
+        ClientContext ctx(client_->channel());
 
         if (debug_key_ != "") {
             ctx.set_debug_key(debug_key_);
@@ -132,7 +135,7 @@ class ClientHelper {
               typename ErrorHandlerCallable = decltype(default_ehc_)>
     auto invoke_stream(ResponseHandlerCallable rhc, ErrorHandlerCallable&& ehc = default_ehc_) {
         *request_.mutable_name() = client_->name();
-        ClientContext ctx;
+        ClientContext ctx(client_->channel());
 
         auto reader = (stub_->*pfn_)(ctx, request_);
 

src/viam/sdk/common/grpc_fwd.hpp.in

@@ -2,6 +2,16 @@
 
 #cmakedefine VIAMCPPSDK_GRPCXX_LEGACY_FWD
 
+// Preprocessor definition for direct dial support in grpc.
+// For grpc >= 1.43.0 it is possible to dial directly over grpc. For older versions,
+// `VIAMCPPSDK_GRPCXX_NO_DIRECT_DIAL` is defined.
+// The default behavior is for the variable to be undefined, providing the behavior for recent
+// versions. If you are experiencing compilation errors in an installed version of the SDK it may be
+// due to a mismatch with the configured version of this header and the grpc version found by the
+// compiler. You may wish to comment/uncomment the define below as needed, or add the definition
+// with `-D` to the compiler.
+#cmakedefine VIAMCPPSDK_GRPCXX_NO_DIRECT_DIAL
+
 // Forward declaration file grpc client and server types.
 // This file provides includes for recent (>= 1.32.0) versions of grpc or older
 // versions, depending on if `VIAMCPPSDK_GRPCXX_LEGACY_FWD` is defined.