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 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 ViamChannel {
    ViamChannel(std::shared_ptr<GrpcChannel> channel, char* path, void* runtime);
 
   public:
    class Options {
       public:
        Options();
 
        const boost::optional<Credentials>& credentials() const;
        const boost::optional<std::string>& entity() const;
        bool allows_insecure_downgrade() const;
        bool webrtc_disabled() const;
        const std::chrono::duration<float>& timeout() const;
        int initial_connection_attempts() const;
        std::chrono::duration<float> initial_connection_attempt_timeout() const;
 
        Options& set_entity(boost::optional<std::string> entity);
 
        Options& set_credentials(boost::optional<Credentials> creds);
 
        Options& set_allow_insecure_downgrade(bool allow);
 
        Options& set_webrtc_disabled(bool disable_webrtc);
 
        Options& set_timeout(std::chrono::duration<float> timeout);
 
        Options& set_initial_connection_attempts(int attempts);
 
        Options& set_initial_connection_attempt_timeout(std::chrono::duration<float> timeout);
 
       private:
        boost::optional<std::string> auth_entity_;
 
        boost::optional<Credentials> credentials_;
 
        bool allow_insecure_downgrade_ = false;
 
        bool disable_webrtc_ = false;
 
        std::chrono::duration<float> timeout_{20};
 
        int initial_connection_attempts_ = 3;
 
        std::chrono::duration<float> initial_connection_attempt_timeout_{20};
    };
 
    explicit ViamChannel(std::shared_ptr<GrpcChannel> channel);
 
    ViamChannel(ViamChannel&&) noexcept;
 
    ViamChannel& operator=(ViamChannel&&) noexcept;
 
    ~ViamChannel();
 
    static ViamChannel dial(const char* uri, const boost::optional<Options>& options);
 
    static ViamChannel dial_initial(const char* uri, const boost::optional<Options>& options);
 
    const std::shared_ptr<GrpcChannel>& channel() const;
 
    const boost::optional<std::string>& auth_token() const;
 
    const char* get_channel_addr() const;
 
    void close();
 
   private:
    struct impl;
    friend class ViamClient;
 
    static ViamChannel dial_direct(const char* uri, const Options& opts);
 
    const char* uri_;
 
    std::unique_ptr<impl> pimpl_;
};
 
using DialOptions
    [[deprecated("This class is now a member class of ViamChannel::Options. The alias DialOptions "
                 "may be removed in a future version")]] = ViamChannel::Options;
 
using DialOptionsDeprecated = ViamChannel::Options;
 
class Options {
   public:
    Options(unsigned int refresh_interval, boost::optional<ViamChannel::Options> channel_options)
        : refresh_interval_(std::move(refresh_interval)),
          channel_options_(std::move(channel_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);
 
    [[deprecated("Please update your function calls to channel_options")]]  //
    const boost::optional<ViamChannel::Options>&
    dial_options() const;
 
    const boost::optional<ViamChannel::Options>& channel_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<ViamChannel::Options> channel_options_;
};
 
}  // namespace sdk
}  // namespace viam