dial.hpp

#pragma once
 
#include <chrono>
#include <memory>
#include <string>
 
#include <boost/optional.hpp>
 
#include <viam/sdk/common/grpc_fwd.hpp>
 
namespace viam {
namespace sdk {
 
class DialOptions;
class ViamChannel {
    ViamChannel(std::shared_ptr<GrpcChannel> channel, const char* path, void* runtime);
 
   public:
    explicit ViamChannel(std::shared_ptr<GrpcChannel> channel);
 
    ViamChannel(ViamChannel&&) noexcept;
 
    ViamChannel& operator=(ViamChannel&&) noexcept;
 
    ~ViamChannel();
 
    static ViamChannel dial(const char* uri, const boost::optional<DialOptions>& options);
 
    // @brief Dials to a robot at the given URI address, using the provided dial options (or default
    // options is none are provided). Additionally specifies that this dial is an initial connection
    // attempt and so uses the initial connection options.
    static ViamChannel dial_initial(const char* uri, const boost::optional<DialOptions>& options);
 
    const std::shared_ptr<GrpcChannel>& channel() const;
 
    void close();
 
    const char* get_channel_addr() const;
 
   private:
    const char* uri_;
    struct impl;
 
    std::shared_ptr<GrpcChannel> channel_;
 
    std::unique_ptr<impl> pimpl_;
};
 
class Credentials {
   public:
    Credentials(std::string type, std::string payload);
    const std::string& type() const;
    const std::string& payload() const;
 
   private:
    std::string type_;
    std::string payload_;
};
 
class DialOptions {
   public:
    DialOptions();
 
    const boost::optional<Credentials>& credentials() const;
    const boost::optional<std::string>& entity() const;
    bool allows_insecure_downgrade() const;
    const std::chrono::duration<float>& timeout() const;
    int initial_connection_attempts() const;
    std::chrono::duration<float> initial_connection_attempt_timeout() const;
 
    DialOptions& set_entity(boost::optional<std::string> entity);
    DialOptions& set_credentials(boost::optional<Credentials> creds);
    DialOptions& set_allow_insecure_downgrade(bool allow);
    DialOptions& set_timeout(std::chrono::duration<float> timeout);
    DialOptions& set_initial_connection_attempts(int attempts);
    DialOptions& 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
    // `local` uri. We should update dial logic to consider such a flag.
 
    boost::optional<std::string> auth_entity_;
 
    boost::optional<Credentials> credentials_;
 
    bool allow_insecure_downgrade_ = false;
 
    std::chrono::duration<float> timeout_{20};
 
    int initial_connection_attempts_ = 3;
 
    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)) {}
 
    std::chrono::seconds refresh_interval() const;
    std::chrono::seconds check_every_interval() const;
    std::chrono::seconds reconnect_every_interval() const;
 
    Options& set_check_every_interval(std::chrono::seconds interval);
 
    Options& set_reconnect_every_interval(std::chrono::seconds interval);
    const boost::optional<DialOptions>& dial_options() const;
 
   private:
    std::chrono::seconds refresh_interval_{0};
 
    std::chrono::seconds check_every_interval_{0};
 
    std::chrono::seconds reconnect_every_interval_{0};
    boost::optional<DialOptions> dial_options_;
};
 
}  // namespace sdk
}  // namespace viam