oscquery_mirror.hpp

#pragma once
 
#include <ossia/detail/json_fwd.hpp>
#include <ossia/detail/lockfree_queue.hpp>
#include <ossia/network/base/listening.hpp>
#include <ossia/network/base/protocol.hpp>
#include <ossia/network/oscquery/host_info.hpp>
 
#include <atomic>
 
namespace osc
{
template <typename T>
class sender;
class receiver;
}
 
namespace oscpack
{
class ReceivedMessage;
class IpEndpointName;
}
 
namespace ossia
{
namespace net
{
struct parameter_data;
class websocket_client;
}
namespace oscquery
{
struct osc_outbound_visitor;
struct http_client_context;
struct http_responder;
 
class OSSIA_EXPORT oscquery_mirror_protocol final : public ossia::net::protocol_base
{
public:
  oscquery_mirror_protocol(std::string host, uint16_t local_osc_port = 10203);
  ~oscquery_mirror_protocol() override;
 
  bool pull(net::parameter_base&) override;
  std::future<void> pull_async(net::parameter_base&) override;
  void request(net::parameter_base&) override;
  bool push(const net::parameter_base&, const ossia::value& v) override;
  bool push_raw(const ossia::net::full_parameter_data& parameter_base) override;
  bool push_bundle(const std::vector<const ossia::net::parameter_base*>&) override;
  bool push_raw_bundle(const std::vector<ossia::net::full_parameter_data>&) override;
  bool observe(net::parameter_base&, bool) override;
  bool observe_quietly(net::parameter_base&, bool) override;
  bool update(net::node_base& b) override;
  bool echo_incoming_message(
      const ossia::net::message_origin_identifier& id,
      const ossia::net::parameter_base& addr, const value& val) override;
 
  std::future<void> update_async(net::node_base& b) override;
 
  void stop() override;
  void set_device(net::device_base& dev) override;
  ossia::net::device_base& get_device() const { return *m_device; }
 
  void run_commands();
 
  void set_command_callback(std::function<void()>);
 
  void request_add_node(net::node_base&, const ossia::net::parameter_data&);
 
  void request_remove_node(net::node_base&);
 
  void request_rename_node(net::node_base& node, const std::string& new_name);
 
  void set_zombie_on_remove(bool zombie_on_remove)
  {
    m_zombie_on_remove = zombie_on_remove;
  }
 
  bool get_zombie_on_remove() const noexcept { return m_zombie_on_remove; }
 
  host_info get_host_info() const noexcept;
 
  bool connected() const noexcept override { return m_hasWS; }
  void connect() override;
 
private:
  friend struct http_answer;
 
  void init();
  using connection_handler = std::weak_ptr<void>;
  bool on_WSMessage(connection_handler hdl, const std::string& message);
  bool on_BinaryWSMessage(connection_handler hdl, const std::string& message);
  void
  on_OSCMessage(const oscpack::ReceivedMessage& m, const oscpack::IpEndpointName& ip);
 
  void cleanup_connections();
 
  void http_send_message(const std::string& str);
  void http_send_message(const rapidjson::StringBuffer& str);
 
  void ws_send_message(const std::string& str);
  void ws_send_binary_message(const std::string& str);
  void ws_send_message(const rapidjson::StringBuffer& str);
  bool query_connected();
  void query_stop();
 
  void on_nodeRenamed(const ossia::net::node_base& n, std::string oldname);
 
  void start_http();
 
  void on_ws_disconnected() { m_hasWS = false; }
 
  std::unique_ptr<osc::sender<oscquery::osc_outbound_visitor>> m_oscSender;
  std::unique_ptr<osc::receiver> m_oscServer;
  std::unique_ptr<ossia::net::websocket_client> m_websocketClient;
  std::atomic_bool m_hasWS{};
 
  // Listening status of the local software
  net::listened_parameters m_listening;
 
  ossia::net::device_base* m_device{};
 
  std::promise<void> m_namespacePromise;
 
  struct get_osc_promise
  {
    std::promise<void> promise;
    ossia::net::parameter_base* address{};
  };
  struct get_ws_promise
  {
    get_ws_promise() = default;
    get_ws_promise(const get_ws_promise&) = delete;
    get_ws_promise(get_ws_promise&&) noexcept = default;
    get_ws_promise& operator=(const get_ws_promise&) = delete;
    get_ws_promise& operator=(get_ws_promise&&) noexcept = default;
 
    get_ws_promise(std::promise<void>&& p, const std::string& addr)
        : promise{std::move(p)}
        , address{addr}
    {
    }
    std::promise<void> promise;
    std::string address{};
  };
 
  ossia::spsc_queue<get_ws_promise> m_getWSPromises;
  ossia::spsc_queue<std::function<void()>> m_functionQueue;
  std::function<void()> m_commandCallback;
 
  std::thread m_wsThread;
  std::string m_queryHost;
  std::string m_queryPort;
  std::string m_httpHost;
  int m_osc_port{};
 
  std::unique_ptr<http_client_context> m_http;
  host_info m_host_info;
  mutable std::mutex m_host_info_mutex;
 
  ossia::net::message_origin_identifier m_id;
 
  bool m_zombie_on_remove{true};
};
 
OSSIA_EXPORT void load_oscquery_device(ossia::net::device_base& dev, std::string json);
}
}