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/service.hpp>
 
namespace viam {
 
namespace robot {
namespace v1 {
 
class FrameSystemConfig;
class Operation;
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);
 
    struct frame_system_config {
        WorldState::transform frame;
        ProtoStruct kinematics;
        friend bool operator==(const frame_system_config& lhs, const frame_system_config& rhs);
    };
 
    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);
    };
 
    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 = {});
 
    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);
 
    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::FrameSystemConfig> {
    RobotClient::frame_system_config operator()(const robot::v1::FrameSystemConfig*) const;
};
 
}  // namespace proto_convert_details
}  // namespace sdk
}  // namespace viam