overhaul options and refresh interval

Author: lia-viam

src/viam/examples/camera/example_camera.cpp

@@ -31,11 +31,11 @@ int main() try {
     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

@@ -27,10 +27,10 @@ int main() {
     std::string payload = "<your authentication payload>";
     dial_options.credentials = Credentials(type, payload);
     std::string address(uri);
-    Options options(1, dial_options);
 
     // 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

@@ -46,7 +46,7 @@ int main(int argc, char* argv[]) {
 
     // connect to robot, ensure we can refresh it
     std::shared_ptr<RobotClient> robot =
-        RobotClient::at_address(vm["uri"].as<std::string>(), Options(1, opts));
+        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();

src/viam/examples/mlmodel/example_audio_classification_client.cpp

@@ -246,8 +246,8 @@ int main(int argc, char* argv[]) try {
         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,7 +26,7 @@ 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.allow_insecure_downgrade = true;  // set to false if connecting securely
 
@@ -36,17 +36,15 @@ int main() {
     // 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/simple/client.cpp

@@ -16,7 +16,9 @@ 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.allow_insecure_downgrade = true;  // set to false if connecting securely
 
@@ -26,11 +28,8 @@ int main() {
     // 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

@@ -44,11 +44,11 @@ int main() try {
     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/module/service.cpp

@@ -194,7 +194,8 @@ struct ModuleService::ServiceImpl : viam::module::v1::ModuleService::Service {
         auto new_parent_addr = request->parent_address();
         if (parent.parent_addr_ != new_parent_addr) {
             parent.parent_addr_ = std::move(new_parent_addr);
-            parent.parent_ = RobotClient::at_local_socket(parent.parent_addr_, {0, boost::none});
+            parent.parent_ =
+                RobotClient::at_local_socket(parent.parent_addr_, std::chrono::seconds{0});
             parent.parent_->connect_logging();
         }
         response->set_ready(parent.module_->ready());
@@ -223,7 +224,7 @@ Dependencies ModuleService::get_dependencies_(
 std::shared_ptr<Resource> ModuleService::get_parent_resource_(const Name& name) {
     if (!parent_) {
         // LS: I think maybe this is never hit
-        parent_ = RobotClient::at_local_socket(parent_addr_, {0, boost::none});
+        parent_ = RobotClient::at_local_socket(parent_addr_, std::chrono::seconds{0});
         parent_->connect_logging();
     }
 

src/viam/sdk/robot/client.cpp

@@ -271,9 +271,9 @@ void RobotClient::log(const std::string& name,
 }
 
 std::unique_ptr<RobotClient> RobotClient::with_channel(ViamChannel channel,
-                                                       const Options& options) {
+                                                       std::chrono::seconds refresh_interval) {
     auto robot = std::make_unique<RobotClient>(std::move(channel));
-    robot->refresh_interval_ = std::chrono::seconds{options.refresh_interval()};
+    robot->refresh_interval_ = refresh_interval;
     robot->should_refresh_ = (robot->refresh_interval_ > std::chrono::seconds{0});
     if (robot->should_refresh_) {
         robot->refresh_thread_ = std::thread{&RobotClient::refresh_every, robot.get()};
@@ -284,20 +284,21 @@ std::unique_ptr<RobotClient> RobotClient::with_channel(ViamChannel channel,
 };
 
 std::unique_ptr<RobotClient> RobotClient::at_address(const std::string& address,
-                                                     const Options& options) {
+                                                     std::chrono::seconds refresh_interval,
+                                                     const DialOptions& options) {
     const char* uri = address.c_str();
     auto robot =
-        RobotClient::with_channel(ViamChannel::dial_initial(uri, options.dial_options()), options);
+        RobotClient::with_channel(ViamChannel::dial_initial(uri, options), refresh_interval);
 
     return robot;
 };
 
 std::unique_ptr<RobotClient> RobotClient::at_local_socket(const std::string& address,
-                                                          const Options& options) {
+                                                          std::chrono::seconds refresh_interval) {
     const std::string addr = "unix://" + address;
     auto robot = RobotClient::with_channel(
         ViamChannel(sdk::impl::create_viam_grpc_channel(addr, grpc::InsecureChannelCredentials())),
-        options);
+        refresh_interval);
 
     return robot;
 };

src/viam/sdk/robot/client.hpp

@@ -71,6 +71,11 @@ class RobotClient {
         friend bool operator==(const operation& lhs, const operation& rhs);
     };
 
+    struct options {
+        std::chrono::seconds refresh_interval;
+        boost::optional<DialOptions> dial_options;
+    };
+
     explicit RobotClient(ViamChannel channel);
 
     ~RobotClient();
@@ -90,22 +95,25 @@ class RobotClient {
 
     /// @brief Create a robot client connected to the robot at the provided address.
     /// @param address The address of the robot (IP address, URI, URL, etc.)
-    /// @param options Options for connecting and refreshing.
+    /// @param refresh_interval How often to call refresh.
+    /// @param options Options for dialing to the address.
     static std::unique_ptr<RobotClient> at_address(const std::string& address,
-                                                   const Options& options);
+                                                   std::chrono::seconds refresh_interval,
+                                                   const DialOptions& options);
 
     /// @brief Creates a robot client connected to the robot at the provided local socket.
     /// @param address The local socket of the robot (a .sock file, etc.).
-    /// @param options Options for connecting and refreshing.
+    /// @param refresh_interval How often to call refresh.
     /// Creates a direct connection to the robot using the `unix://` scheme.
     /// Only useful for connecting to robots across Unix sockets.
     static std::unique_ptr<RobotClient> at_local_socket(const std::string& address,
-                                                        const Options& options);
+                                                        std::chrono::seconds refresh_interval);
 
     /// @brief Creates a robot client connected to the provided channel.
     /// @param channel The channel to connect with.
-    /// @param options Options for connecting and refreshing.
-    static std::unique_ptr<RobotClient> with_channel(ViamChannel channel, const Options& options);
+    /// @param refresh_interval How often to call refresh.
+    static std::unique_ptr<RobotClient> with_channel(ViamChannel channel,
+                                                     std::chrono::seconds refresh_interval);
 
     std::vector<Name> resource_names() const;
 

src/viam/sdk/rpc/dial.cpp

@@ -187,14 +187,6 @@ void ViamChannel::close() {
     pimpl_.reset();
 }
 
-unsigned int Options::refresh_interval() const {
-    return refresh_interval_;
-}
-
-const boost::optional<DialOptions>& Options::dial_options() const {
-    return dial_options_;
-}
-
 Credentials::Credentials(std::string payload)
     : type_("robot-location-secret"), payload_(std::move(payload)) {}
 

src/viam/sdk/rpc/dial.hpp

@@ -100,20 +100,5 @@ struct DialOptions {
     std::chrono::duration<float> initial_connection_attempt_timeout{20};
 };
 
-class Options {
-   public:
-    Options(unsigned int refresh_interval, boost::optional<DialOptions> dial_options)
-        : refresh_interval_(std::move(refresh_interval)), dial_options_(std::move(dial_options)) {}
-
-    unsigned int refresh_interval() const;
-    const boost::optional<DialOptions>& dial_options() const;
-
-   private:
-    /// @brief How often to refresh the status/parts of the robot, in seconds. If set to 0, the
-    /// robot will not automatically refresh.
-    unsigned int refresh_interval_;
-    boost::optional<DialOptions> dial_options_;
-};
-
 }  // namespace sdk
 }  // namespace viam

src/viam/sdk/tests/test_robot.cpp

@@ -50,7 +50,7 @@ void robot_client_to_mocks_pipeline(F&& test_case) {
     // in-process gRPC channel.
     auto test_server = TestServer(server);
     auto grpc_channel = test_server.grpc_in_process_channel();
-    auto client = RobotClient::with_channel(ViamChannel(grpc_channel), Options(0, boost::none));
+    auto client = RobotClient::with_channel(ViamChannel(grpc_channel), {});
 
     // Run the passed-in test case on the created stack and give access to the
     // created RobotClient and MockRobotService.