monero_rpc_connection.h

 
#pragma once
 
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/condition_variable.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"
#include "net/http.h"
#include "daemon/monero_daemon_model.h"

namespace monero {

  struct monero_request_params : public serializable_struct {
    monero_request_params() { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };

  struct monero_rpc_request : public serializable_struct {
    boost::optional<std::string> m_id;
    boost::optional<std::string> m_version;
    boost::optional<std::string> m_method;
    std::shared_ptr<serializable_struct> m_params;
 
    monero_rpc_request() { }
    monero_rpc_request(const std::string& method, const std::shared_ptr<serializable_struct>& params, bool json_rpc = true);
 
    bool is_json_rpc() const { return m_id != boost::none && m_version != boost::none; }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };

  struct monero_rpc_response {
    boost::optional<std::string> m_jsonrpc;
    boost::optional<boost::property_tree::ptree> m_result;
    boost::optional<boost::property_tree::ptree> m_response;
    boost::optional<std::string> m_binary;
  };

  class monero_rpc_connection : public serializable_struct {
  public:
    boost::optional<std::string> m_uri;
    boost::optional<std::string> m_username;
    boost::optional<std::string> m_password;
    boost::optional<std::string> m_proxy_uri;
    bool m_ssl_verify = true;                    // verify TLS certificates and hostnames
    boost::optional<std::string> m_zmq_uri;      // TODO: implement zmq listener
    boost::optional<uint32_t> m_timeout_ms;      // RPC request timeout in milliseconds
    boost::optional<uint64_t> m_response_time;   // automatically set by calling check_connection()
    int m_priority;                              // priority relative to other connections where 1 is highest, then 2, etc, and 0 is lowest (default)
 
    static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_rpc_connection>& connection);
    static std::shared_ptr<monero_rpc_connection> deserialize(const std::string& json);

    static bool compare(int p1, int p2);

    monero_rpc_connection(const std::string& uri = "", const std::string& username = "", const std::string& password = "", const std::string& proxy_uri = "", const std::string& zmq_uri = "", int priority = 0, const boost::optional<uint32_t>& timeout_ms = boost::none);

    monero_rpc_connection(const monero_rpc_connection& rpc);

    bool is_onion() const;

    bool is_i2p() const;

    void set_credentials(const std::string& username, const std::string& password);

    void set_attribute(const std::string& key, const std::string& val);

    std::string get_attribute(const std::string& key) const;

    boost::optional<bool> is_online() const;

    boost::optional<bool> is_authenticated() const;

    boost::optional<bool> is_connected() const;

    bool check_connection(const boost::optional<uint32_t>& timeout_ms = boost::none);

    boost::property_tree::ptree send_json_request(const std::string& path, const std::shared_ptr<serializable_struct>& params = nullptr, const boost::optional<uint32_t>& timeout_ms = boost::none) const;

    monero_rpc_response send_json_request(const monero_rpc_request &request, const boost::optional<uint32_t>& timeout_ms = boost::none) const;

    boost::property_tree::ptree send_path_request(const std::string& path, const std::shared_ptr<serializable_struct>& params = nullptr, const boost::optional<uint32_t>& timeout_ms = boost::none) const;

    monero_rpc_response send_path_request(const monero_rpc_request &request, const boost::optional<uint32_t>& timeout_ms = boost::none) const;

    monero_rpc_response send_binary_request(const monero_rpc_request &request, const boost::optional<uint32_t>& timeout_ms = boost::none) const;
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
 
  protected:
    // instance variables
    mutable boost::recursive_mutex m_mutex;
    boost::optional<bool> m_is_online;
    boost::optional<bool> m_is_authenticated;
    mutable std::unique_ptr<epee::net_utils::http::abstract_http_client> m_http_client;
    std::unordered_map<std::string, std::string> m_attributes;
    mutable std::tuple<std::string, std::string, std::string, std::string, bool> m_applied{"", "", "", "", true};
 
    void ensure_configured() const;
    std::string invoke_post(const boost::string_ref uri, const std::string& body, const boost::optional<uint32_t>& timeout_ms = boost::none) const;
    void send_rpc_request(const boost::string_ref uri, const monero_rpc_request& request, monero_rpc_response& response, const boost::optional<uint32_t>& timeout_ms = boost::none, bool binary = false) const;
  };
 
}