client.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <string>
#include <thread>
 
#include <viam/sdk/common/grpc_fwd.hpp>
#include <viam/sdk/common/pose.hpp>
#include <viam/sdk/common/proto_convert.hpp>
#include <viam/sdk/common/utils.hpp>
#include <viam/sdk/common/world_state.hpp>
#include <viam/sdk/components/component.hpp>
#include <viam/sdk/registry/registry.hpp>
#include <viam/sdk/resource/resource.hpp>
#include <viam/sdk/rpc/dial.hpp>
#include <viam/sdk/services/framesystem.hpp>
#include <viam/sdk/services/service.hpp>
 
namespace viam {
 
namespace robot {
namespace v1 {
 
class ConfigStatus;
class GetMachineStatusResponse;
class JobStatus;
class ModuleStatus;
class Operation;
class PackageStatus;
class ResourceStatus;
class SendTracesRequest;
 
}  // namespace v1
}  // namespace robot
 
namespace sdk {
 
namespace impl {
struct LogBackend;
class ParentSendTracesExporter;
}  // namespace impl
 
 
class RobotClient {
   public:
    enum class status : uint8_t {
        k_initializing,
        k_running,
        k_unspecified,
    };
 
    friend std::ostream& operator<<(std::ostream& os, const status& v);
 
    using frame_system_config = FrameSystem::frame_system_config;
 
    struct operation {
        std::string id;
        std::string method;
        boost::optional<std::string> session_id;
        ProtoStruct arguments;
        boost::optional<time_pt> started;
        friend bool operator==(const operation& lhs, const operation& rhs);
    };
 
    struct resource_status {
        enum class resource_state : uint8_t {
            k_unspecified,
            k_unconfigured,
            k_configuring,
            k_ready,
            k_removing,
            k_unhealthy,
        };
 
        Name name;
        resource_state state;
        boost::optional<time_pt> last_updated;
        std::string revision;
        std::string error;
        friend bool operator==(const resource_status& lhs, const resource_status& rhs);
    };
 
    struct config_status {
        std::string revision;
        boost::optional<time_pt> last_updated;
        friend bool operator==(const config_status& lhs, const config_status& rhs);
    };
 
    struct module_status {
        enum class module_state : uint8_t {
            k_unspecified,
            k_pending,
            k_starting,
            k_ready,
            k_unhealthy,
            k_closing,
        };
 
        std::string module_name;
        module_state state;
        boost::optional<time_pt> last_updated;
        std::string error;
        std::uint32_t consecutive_failures;
        friend bool operator==(const module_status& lhs, const module_status& rhs);
    };
 
    struct package_status {
        enum class package_type : uint8_t {
            k_unspecified,
            k_archive,
            k_ml_model,
            k_module,
            k_slam_map,
            k_ml_training,
        };
 
        enum class package_state : uint8_t {
            k_unspecified,
            k_downloading,
            k_loading,
            k_first_run,
            k_ready,
            k_failed,
        };
 
        std::string name;
        package_type type;
        package_state state;
        std::string error;
        boost::optional<time_pt> last_updated;
        std::string version;
        std::uint64_t bytes_downloaded;
        std::uint64_t total_bytes;
        friend bool operator==(const package_status& lhs, const package_status& rhs);
    };
 
    struct job_status {
        std::string job_name;
        std::vector<time_pt> recent_successful_runs;
        std::vector<time_pt> recent_failed_runs;
        friend bool operator==(const job_status& lhs, const job_status& rhs);
    };
 
    struct machine_status {
        status state;
        std::vector<resource_status> resources;
        config_status config;
        std::vector<module_status> modules;
        std::vector<package_status> packages;
        std::vector<job_status> job_statuses;
        friend bool operator==(const machine_status& lhs, const machine_status& rhs);
    };
 
    explicit RobotClient(ViamChannel channel);
 
    ~RobotClient();
 
    void refresh();
 
    void close();
 
    static std::shared_ptr<RobotClient> at_address(const std::string& address,
                                                   const Options& options);
 
    static std::shared_ptr<RobotClient> at_local_socket(const std::string& address,
                                                        const Options& options);
 
    static std::shared_ptr<RobotClient> with_channel(ViamChannel channel, const Options& options);
 
    std::vector<Name> resource_names() const;
 
    std::shared_ptr<Resource> resource_by_name(const Name& name);
 
    template <typename T>
    std::shared_ptr<T> resource_by_name(std::string name) {
        return std::dynamic_pointer_cast<T>(resource_by_name({API::get<T>(), "", std::move(name)}));
    }
 
    std::vector<frame_system_config> get_frame_system_config(
        const std::vector<WorldState::transform>& additional_transforms = {});
 
    std::vector<operation> get_operations();
 
    pose_in_frame transform_pose(
        const pose_in_frame& query,
        std::string destination,
        const std::vector<WorldState::transform>& additional_transforms = {});
 
    std::vector<unsigned char> transform_pcd(const std::vector<unsigned char>& pcd,
                                             const std::string& source,
                                             const std::string& destination);
 
    void block_for_operation(std::string id);
 
    void stop_all();
 
    void stop_all(const std::unordered_map<Name, ProtoStruct>& extra);
 
    void cancel_operation(std::string id);
 
    pose_in_frame get_pose(const std::string& component_name);
 
    pose_in_frame get_pose(const std::string& component_name,
                           const std::string& destination_frame,
                           const std::vector<WorldState::transform>& additional_transforms,
                           const ProtoStruct& extra);
 
    machine_status get_machine_status() const;
 
   private:
    friend class ModuleService;
    friend struct impl::LogBackend;
    friend class impl::ParentSendTracesExporter;
 
    void log(const std::string& name,
             const std::string& level,
             const std::string& message,
             time_pt time,
             const std::string& file,
             unsigned int line);
 
    // Ships a batch of OTLP traces to the parent. Returns true on success.
    bool send_traces(const robot::v1::SendTracesRequest* req);
 
    // Makes this RobotClient manage logging by sending logs over grpc to viam-server.
    // This is private and only ever called by ModuleService; in other words it is only called when
    // viam-server is running a Viam C++ SDK application as a module.
    // Disables console logging so as to avoid log message duplication; console logging is
    // re-enabled on destruction.
    void connect_logging();
 
    // Installs the SDK tracer provider so spans flow back to the parent over this connection.
    // Only called by ModuleService when running as a module.
    void connect_tracing();
 
    void refresh_every();
    void check_connection();
 
    std::thread refresh_thread_;
    std::thread check_connection_thread_;
    std::atomic<bool> should_refresh_;
    std::atomic<bool> should_check_connection_;
    std::chrono::seconds refresh_interval_;
    std::chrono::seconds check_every_interval_;
    std::chrono::seconds reconnect_every_interval_;
 
    ViamChannel viam_channel_;
 
    struct impl;
    std::unique_ptr<impl> impl_;
 
    mutable std::mutex lock_;
 
    std::vector<Name> resource_names_;
    ResourceManager resource_manager_;
};
 
namespace proto_convert_details {
 
template <>
struct from_proto_impl<robot::v1::Operation> {
    RobotClient::operation operator()(const robot::v1::Operation*) const;
};
 
template <>
struct from_proto_impl<robot::v1::ResourceStatus> {
    RobotClient::resource_status operator()(const robot::v1::ResourceStatus*) const;
};
 
template <>
struct from_proto_impl<robot::v1::ConfigStatus> {
    RobotClient::config_status operator()(const robot::v1::ConfigStatus*) const;
};
 
template <>
struct from_proto_impl<robot::v1::ModuleStatus> {
    RobotClient::module_status operator()(const robot::v1::ModuleStatus*) const;
};
 
template <>
struct from_proto_impl<robot::v1::PackageStatus> {
    RobotClient::package_status operator()(const robot::v1::PackageStatus*) const;
};
 
template <>
struct from_proto_impl<robot::v1::JobStatus> {
    RobotClient::job_status operator()(const robot::v1::JobStatus*) const;
};
 
template <>
struct from_proto_impl<robot::v1::GetMachineStatusResponse> {
    RobotClient::machine_status operator()(const robot::v1::GetMachineStatusResponse*) const;
};
 
}  // namespace proto_convert_details
}  // namespace sdk
}  // namespace viam