initial connection options for cpp

Author: stuqdog

src/viam/sdk/rpc/dial.cpp

@@ -60,10 +60,18 @@ void DialOptions::set_entity(boost::optional<std::string> entity) {
     auth_entity_ = std::move(entity);
 }
 
+void DialOptions::set_initial_connection_attempts(int attempts) {
+    initial_connection_attempts_ = attempts;
+}
+
 void DialOptions::set_timeout(std::chrono::duration<float> timeout) {
     timeout_ = std::move(timeout);
 }
 
+void DialOptions::set_initial_connection_attempt_timeout(std::chrono::duration<float> timeout) {
+    initial_connection_attempt_timeout_ = std::move(timeout);
+}
+
 const boost::optional<std::string>& DialOptions::entity() const {
     return auth_entity_;
 }
@@ -72,10 +80,18 @@ const boost::optional<Credentials>& DialOptions::credentials() const {
     return credentials_;
 }
 
+int DialOptions::initial_connection_attempts() const {
+    return initial_connection_attempts_;
+}
+
 const std::chrono::duration<float>& DialOptions::timeout() const {
     return timeout_;
 }
 
+const std::chrono::duration<float>& DialOptions::initial_connection_attempt_timeout() const {
+    return initial_connection_attempt_timeout_;
+}
+
 void DialOptions::set_allow_insecure_downgrade(bool allow) {
     allow_insecure_downgrade_ = allow;
 }
@@ -84,6 +100,34 @@ bool DialOptions::allows_insecure_downgrade() const {
     return allow_insecure_downgrade_;
 }
 
+std::shared_ptr<ViamChannel> ViamChannel::dial(const char* uri,
+                                               const boost::optional<DialOptions>& options,
+                                               bool initial_attempt) {
+    if (!initial_attempt) {
+        return dial(std::move(uri), options);
+    }
+
+    DialOptions opts = options.get_value_or(DialOptions());
+    auto timeout = opts.timeout();
+    auto attempts_remaining = opts.initial_connection_attempts();
+    if (attempts_remaining == 0) {
+        attempts_remaining = -1;
+    }
+    opts.set_timeout(opts.initial_connection_attempt_timeout());
+
+    while (attempts_remaining > 0) {
+        try {
+            auto connection = dial(uri, opts);
+            opts.set_timeout(timeout);
+            return connection;
+        } catch (...) {
+            attempts_remaining -= 1;
+        }
+    }
+
+    throw Exception(ErrorCondition::k_connection, "Unable to establish connection");
+}
+
 std::shared_ptr<ViamChannel> ViamChannel::dial(const char* uri,
                                                const boost::optional<DialOptions>& options) {
     void* ptr = init_rust_runtime();

src/viam/sdk/rpc/dial.hpp

@@ -16,9 +16,16 @@ class ViamChannel {
    public:
     void close();
     ViamChannel(std::shared_ptr<GrpcChannel> channel, const char* path, void* runtime);
+
     static std::shared_ptr<ViamChannel> dial(const char* uri,
                                              const boost::optional<DialOptions>& options);
 
+    // allows for specifying that this dial is an initial connection attempt, indicating that
+    // initial connection options should be used.
+    static std::shared_ptr<ViamChannel> dial(const char* uri,
+                                             const boost::optional<DialOptions>& options,
+                                             bool initial_attempt);
+
     const std::shared_ptr<GrpcChannel>& channel() const;
 
    private:
@@ -49,11 +56,15 @@ class DialOptions {
     const boost::optional<std::string>& entity() const;
     bool allows_insecure_downgrade() const;
     const std::chrono::duration<float>& timeout() const;
+    int initial_connection_attempts() const;
+    const std::chrono::duration<float>& initial_connection_attempt_timeout() const;
 
     void set_entity(boost::optional<std::string> entity);
     void set_credentials(boost::optional<Credentials> creds);
     void set_allow_insecure_downgrade(bool allow);
     void set_timeout(std::chrono::duration<float> timeout);
+    void set_initial_connection_attempts(int attempts);
+    void set_initial_connection_attempt_timeout(std::chrono::duration<float> timeout);
 
    private:
     // TODO (RSDK-917): We currently don't provide a flag for disabling webRTC, instead relying on a
@@ -72,6 +83,14 @@ class DialOptions {
     /// @brief Duration before the dial connection times out
     /// Set to 20sec to match _defaultOfferDeadline in goutils/rpc/wrtc_call_queue.go
     std::chrono::duration<float> timeout_{20};
+
+    /// @brief Number of attempts to make when initially connecting to a robot
+    /// If set to 0 or a negative integer, will attempt to reconnect forever.
+    int initial_connection_attempts_ = 3;
+
+    /// @brief Timeout of connection attempts when initially dialing a robot
+    /// Defaults to 20sec to match the default timeout duration
+    std::chrono::duration<float> initial_connection_attempt_timeout_{20};
 };
 
 class Options {