TransportConfig.hpp

#ifndef _DITTO_TRANSPORT_CONFIG_
#define _DITTO_TRANSPORT_CONFIG_
 
#include <chrono>
#include <set>
#include <string>
 
#include "Helpers.hpp"
#include "json.hpp"
 
namespace ditto {

class TcpListenConfig {
public:
  bool enabled = false;

  std::string interface_ip = "[::]";

  uint16_t port = 4040;
 
  bool operator==(const TcpListenConfig &other) const {
    return (enabled == other.enabled && interface_ip == other.interface_ip &&
            port == other.port);
  }
  bool operator!=(const TcpListenConfig &other) const {
    return !operator==(other);
  }
 
  NLOHMANN_DEFINE_TYPE_INTRUSIVE(TcpListenConfig, enabled, interface_ip, port)
};

class HttpListenConfig {
public:
  bool enabled = false;

  std::string interface_ip = "[::]";

  uint16_t port = 80;

  bool websocket_sync = false;
 
  // TODO(v5): This should somehow be optional so that it doesn't default to an
  // empty string but instead defaults to `nullptr`, or something like that
  std::string static_content_path;
 
  // TODO(v5): This should somehow be optional so that it doesn't default to an
  // empty string but instead defaults to `nullptr`, or something like that
  std::string tls_key_path;
 
  // TODO(v5): This should somehow be optional so that it doesn't default to an
  // empty string but instead defaults to `nullptr`, or something like that
  std::string tls_certificate_path;
 
  bool operator==(const HttpListenConfig &other) const {
    return (enabled == other.enabled && interface_ip == other.interface_ip &&
            port == other.port && websocket_sync == other.websocket_sync &&
            static_content_path == other.static_content_path &&
            tls_key_path == other.tls_key_path &&
            tls_certificate_path == other.tls_certificate_path);
  }
  bool operator!=(const HttpListenConfig &other) const {
    return !operator==(other);
  }
};
 
void from_json(const nlohmann::json &j, HttpListenConfig &c);
void to_json(nlohmann::json &j, const HttpListenConfig &c);

class Listen {
public:
  TcpListenConfig tcp;
  HttpListenConfig http;
 
  bool operator==(const Listen &other) const {
    return tcp == other.tcp && http == other.http;
  }
  bool operator!=(const Listen &other) const { return !operator==(other); }
 
  NLOHMANN_DEFINE_TYPE_INTRUSIVE(Listen, tcp, http)
};

class BluetoothLeConfig {
public:
  bool enabled = false;
 
  bool operator==(const BluetoothLeConfig &other) const {
    return enabled == other.enabled;
  }
  bool operator!=(const BluetoothLeConfig &other) const {
    return !operator==(other);
  }
 
  NLOHMANN_DEFINE_TYPE_INTRUSIVE(BluetoothLeConfig, enabled)
};
 
// Allowing deprecated use of multicast_enabled
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
class LanConfig {
public:
  bool enabled = false;
  bool mdns_enabled = true;
  bool multicast_enabled = true;
  LanConfig();
  bool operator==(const LanConfig &other) const;
  bool operator!=(const LanConfig &other) const { return !operator==(other); }
};
 
void from_json(const nlohmann::json &j, LanConfig &c);
void to_json(nlohmann::json &j, const LanConfig &c);
#pragma clang diagnostic pop

class AwdlConfig {
public:
  bool enabled = false;
 
  bool operator==(const AwdlConfig &other) const {
    return enabled == other.enabled;
  }
  bool operator!=(const AwdlConfig &other) const { return !operator==(other); }
 
  NLOHMANN_DEFINE_TYPE_INTRUSIVE(AwdlConfig, enabled)
};

class WiFiAwareConfig {
public:
  bool enabled = false;
 
  bool operator==(const WiFiAwareConfig &other) const {
    return enabled == other.enabled;
  }
  bool operator!=(const WiFiAwareConfig &other) const {
    return !operator==(other);
  }
 
  NLOHMANN_DEFINE_TYPE_INTRUSIVE(WiFiAwareConfig, enabled)
};

class PeerToPeer {
public:
  BluetoothLeConfig bluetooth_le;

  LanConfig lan;

  AwdlConfig awdl;

  WiFiAwareConfig wifi_aware;
 
  bool operator==(const PeerToPeer &other) const {
    return bluetooth_le == other.bluetooth_le && lan == other.lan &&
           awdl == other.awdl && wifi_aware == other.wifi_aware;
  }
  bool operator!=(const PeerToPeer &other) const { return !operator==(other); }
 
  NLOHMANN_DEFINE_TYPE_INTRUSIVE(PeerToPeer, bluetooth_le, lan, awdl,
                                 wifi_aware)
};

class Connect {
public:
  std::set<std::string> tcp_servers;

  std::set<std::string> websocket_urls;

  std::chrono::duration<uint32_t, std::milli> retry_interval{5000};
 
  bool operator==(const Connect &other) const {
    return tcp_servers == other.tcp_servers &&
           websocket_urls == other.websocket_urls &&
           retry_interval == other.retry_interval;
  }
  bool operator!=(const Connect &other) const { return !operator==(other); }
};
 
void from_json(const nlohmann::json &j, Connect &c);
void to_json(nlohmann::json &j, const Connect &c);
 
const uint32_t NO_PREFERRED_ROUTE_HINT = 0;

class Global {
public:
  uint32_t sync_group = 0;

  uint32_t routing_hint = NO_PREFERRED_ROUTE_HINT;
 
  bool operator==(const Global &other) const {
    return sync_group == other.sync_group && routing_hint == other.routing_hint;
  }
  bool operator!=(const Global &other) const { return !operator==(other); }
 
  NLOHMANN_DEFINE_TYPE_INTRUSIVE(Global, sync_group, routing_hint)
};

class TransportConfig {
public:
  PeerToPeer peer_to_peer;

  Connect connect;

  Listen listen;

  Global global;

  void enable_all_peer_to_peer() {
    peer_to_peer.bluetooth_le.enabled = true;
    peer_to_peer.lan.enabled = true;
    peer_to_peer.awdl.enabled = true;
    peer_to_peer.wifi_aware.enabled = true;
  }
 
  bool operator==(const TransportConfig &other) const {
    return peer_to_peer == other.peer_to_peer && connect == other.connect &&
           listen == other.listen && global == other.global;
  }
  bool operator!=(const TransportConfig &other) const {
    return !operator==(other);
  }
 
  NLOHMANN_DEFINE_TYPE_INTRUSIVE(TransportConfig, peer_to_peer, connect, listen,
                                 global)
};
} // namespace ditto
 
#endif // _DITTO_TRANSPORT_CONFIG_