network.h

Go to the documentation of this file.

// Copyright (C) 2013-2020 iFunFactory Inc. All Rights Reserved.
//
// This work is confidential and proprietary to iFunFactory Inc. and
// must not be used, disclosed, copied, or distributed without the prior
// consent of iFunFactory Inc.

#ifndef INCLUDE_FUNAPI_TEST_NETWORK_H_
#define INCLUDE_FUNAPI_TEST_NETWORK_H_

#include <boost/asio.hpp>
#include <funapi/network/session.h>
#include <funapi/types.h>

namespace fun {

namespace funtest {

class Session;


typedef function<void(const Ptr<Session> &/*session*/)> SessionOpenedHandler;

typedef function<void(const Ptr<Session> &/*session*/,
                      SessionCloseReason /*reason*/)> SessionClosedHandler;

typedef function<void (const Ptr<Session> &/*session*/, bool /*success*/)>
    TcpTransportAttachedHandler;

typedef function<void (const Ptr<Session> &/*session*/)>
    TcpTransportDetachedHandler;

typedef function<void (const Ptr<Session> &/*session*/, bool /*success*/)>
    WebSocketTransportAttachedHandler;

typedef function<void (const Ptr<Session> &/*session*/)>
    WebSocketTransportDetachedHandler;

typedef function<void (const Ptr<Session> &/*session*/,
                       const Json &/*message*/)> MessageHandler;

typedef function<void (const Ptr<Session> &/*session*/,
                       const Ptr<FunMessage> &/*message*/)> MessageHandler2;

typedef function<void (const Ptr<Session> &session)> SessionRedirectedHandler;


class FUNAPI_DLL_VISIBILITY Network {
 public:
  struct FUNAPI_DLL_VISIBILITY Option {
    struct FUNAPI_DLL_VISIBILITY Compression {
      Compression() : type("none"), threshold(128) {
      }
      string type;
      string dictionary;
      size_t threshold;
    };

    explicit Option(size_t io_threads_size = 4);

    size_t io_threads_size;
    bool use_session_reliability;
    bool send_session_id_only_once;
    bool disable_tcp_nagle;

    Compression tcp_compression;
    Compression udp_compression;
    Compression websocket_compression;

    string server_encryption_public_key;
  };

  static void Install(const SessionOpenedHandler &opened_handler,
                      const SessionClosedHandler &closed_handler,
                      const Option &option);

  static void RegisterTcpTransportHandler(
      const TcpTransportAttachedHandler &tcp_attached_handler,
      const TcpTransportDetachedHandler &tcp_detached_handler);

  static void RegisterWebSocketTransportHandler(
      const WebSocketTransportAttachedHandler &websocket_attached_handler,
      const WebSocketTransportDetachedHandler &websocket_detached_handler);

  static void Register(const string &message_type,
                       const MessageHandler &message_handler);
  static void Register2(const string &message_type,
                        const MessageHandler2 &message_handler);
  static void Register2(int32_t message_type,
                        const MessageHandler2 &message_handler);
  static void Register2(const ProtobufExtensionIdentifier &message_type,
                        const MessageHandler2 &message_handler);

  static void RegisterRedirectionHandler(
      const SessionRedirectedHandler &redirection_handler);
};


class FUNAPI_DLL_VISIBILITY Session {
 public:
  DECLARE_CLASS_PTR(Session);

  enum State {
    kOpening,
    kOpened,
    kClosed,
    kRedirecting,
  };

  static Ptr<Session> Create();

  virtual ~Session();

  virtual void ConnectTcp(const string &ip, uint16_t port,
                          EncodingScheme encoding, bool use_ssl = false) = 0;
  virtual void ConnectTcp(const boost::asio::ip::tcp::endpoint &endpoint,
                          EncodingScheme encoding, bool use_ssl = false) = 0;

  virtual void ConnectUdp(const string &ip, uint16_t port,
                          EncodingScheme encoding) = 0;
  virtual void ConnectUdp(const boost::asio::ip::udp::endpoint &endpoint,
                          EncodingScheme encoding) = 0;

  virtual void ConnectHttp(const string &url, EncodingScheme encoding) = 0;
  virtual void ConnectHttp(const string &ip, uint16_t port,
                           EncodingScheme encoding) = 0;
  virtual void ConnectHttp(const boost::asio::ip::tcp::endpoint &endpoint,
                           EncodingScheme encoding) = 0;

  virtual void ConnectWebSocket(const string &url, EncodingScheme encoding) = 0;
  virtual void ConnectWebSocket(const string &ip, uint16_t port,
                                EncodingScheme encoding) = 0;
  virtual void ConnectWebSocket(const boost::asio::ip::tcp::endpoint &endpoint,
                                EncodingScheme encoding) = 0;

  virtual const SessionId &id() const = 0;
  virtual State state() const = 0;

  virtual bool IsTransportAttached() const = 0;
  virtual bool IsTransportAttached(TransportProtocol protocol) const = 0;

  virtual bool IsRedirected() const = 0;

  virtual void SendMessage(const string &message_type, const Json &message,
                           TransportProtocol protocol) = 0;

  virtual void SendMessage(const string &message_type,
                           const Ptr<FunMessage> &message,
                           TransportProtocol protocol) = 0;
  virtual void SendMessage(int32_t message_type,
                           const Ptr<FunMessage> &message,
                           TransportProtocol protocol) = 0;
  virtual void SendMessage(const ProtobufExtensionIdentifier &message_type,
                           const Ptr<FunMessage> &message,
                           TransportProtocol protocol) = 0;

  virtual void SendMessage(const string &message_type, const Json &message,
                           Encryption encryption,
                           TransportProtocol protocol) = 0;

  virtual void SendMessage(const string &message_type,
                           const Ptr<FunMessage> &message,
                           Encryption encryption,
                           TransportProtocol protocol) = 0;
  virtual void SendMessage(int32_t message_type,
                           const Ptr<FunMessage> &message,
                           Encryption encryption,
                           TransportProtocol protocol) = 0;
  virtual void SendMessage(const ProtobufExtensionIdentifier &message_type,
                           const Ptr<FunMessage> &message,
                           Encryption encryption,
                           TransportProtocol protocol) = 0;

  virtual void CloseTransport() = 0;
  virtual void CloseTransport(TransportProtocol protocol) = 0;

  virtual void Close() = 0;
  virtual void CloseRequest() = 0;

  virtual void SetContext(const Json &ctxt) = 0;
  virtual Json &GetContext() = 0;
  virtual const Json &GetContext() const = 0;
  virtual boost::mutex &GetContextMutex() const = 0;
  virtual operator boost::mutex &() const = 0;

 protected:
  Session();
};

}  // namespace funtest

}  // namespace fun

#endif  // INCLUDE_FUNAPI_TEST_NETWORK_H_