session.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_NETWORK_SESSION_H_
#define INCLUDE_FUNAPI_NETWORK_SESSION_H_

#include <boost/noncopyable.hpp>
#include <boost/unordered_set.hpp>
#include <funapi/common/json.h>
#include <funapi/common/json_schema.h>
#include <funapi/distribution/rpc.h>
#include <funapi/network/fun_message.pb.h>
#include <funapi/time/monotonic_clock.h>
#include <funapi/time/wall_clock.h>
#include <funapi/types.h>

#include <vector>

#ifndef _WIN32
#include <cxxabi.h>
#endif  // _WIN32


namespace fun {

typedef Uuid SessionId;


enum TransportProtocol {
  kDefaultProtocol = 0,
  kTcp,
  kUdp,
  kHttp,
  kWebSocket,
};


enum EncodingScheme {
  kUnknownEncoding = 0,
  kJsonEncoding,
  kProtobufEncoding,
};


enum Encryption {
  kDefaultEncryption = 100,
  kDummyEncryption,
  kIFunEngine1Encryption,
  kIFunEngine2Encryption,
  kChacha20Encryption,
  kAes128Encryption,
};


enum SessionCloseReason {
  kClosedForServerDid = 0,          
  kClosedForIdle = 1,               
  kClosedForUnknownSessionId = 2,   
  kClosedForEventTimeout = 3,       
  kClosedForClientRequested = 4,    
  kClosedForRedirection =5,         
};


class ProtobufExtensionIdentifier;


class FUNAPI_DLL_VISIBILITY Session : private boost::noncopyable {
 public:
  DECLARE_CLASS_PTR(Session);

  typedef boost::unordered_set<Ptr<Session> > SessionsSet;
  typedef std::pair<MonotonicClock::Duration /*ping_time*/,
                    size_t /*sample_count*/> Ping;

  static Ptr<Session> Find(const SessionId &session_id);

  static SessionsSet FindWithTag(const string &key);

  static size_t CountWithTag(const string &key);

  static void BroadcastLocally(const string &message_type,
                               const Json &message,
                               Encryption encryption,
                               TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastLocally(const string &message_type,
                               const Ptr<FunMessage> &message,
                               Encryption encryption,
                               TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastLocally(int32_t message_type,
                               const Ptr<FunMessage> &message,
                               Encryption encryption,
                               TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastLocally(const ProtobufExtensionIdentifier &message_type,
                               const Ptr<FunMessage> &message,
                               Encryption encryption,
                               TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastGlobally(const string &message_type,
                                const Json &message,
                                const Rpc::Tag &server_tag,
                                Encryption encryption,
                                TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastGlobally(const string &message_type,
                                const Ptr<FunMessage> &message,
                                const Rpc::Tag &server_tag,
                                Encryption encryption,
                                TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastGlobally(int32_t message_type,
                                const Ptr<FunMessage> &message,
                                const Rpc::Tag &server_tag,
                                Encryption encryption,
                                TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastGlobally(const ProtobufExtensionIdentifier &message_type,
                                const Ptr<FunMessage> &message,
                                const Rpc::Tag &server_tag,
                                Encryption encryption,
                                TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastGlobally(const string &message_type,
                                const Json &message,
                                const Rpc::PeerMap &servers,
                                Encryption encryption,
                                TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastGlobally(const string &message_type,
                                const Ptr<FunMessage> &message,
                                const Rpc::PeerMap &servers,
                                Encryption encryption,
                                TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastGlobally(int32_t message_type,
                                const Ptr<FunMessage> &message,
                                const Rpc::PeerMap &servers,
                                Encryption encryption,
                                TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  static void BroadcastGlobally(const ProtobufExtensionIdentifier &message_type,
                                const Ptr<FunMessage> &message,
                                const Rpc::PeerMap &servers,
                                Encryption encryption,
                                TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  virtual ~Session();


  virtual bool IsRestored() const = 0;

  virtual const SessionId &id() const = 0;

  virtual bool GetRemoteEndPoint(TransportProtocol protocol,
                                 string *ip,
                                 uint16_t *port = NULL) const = 0;

  virtual const string &LastReceivedMessageType() const = 0;

  virtual const string &LastSentMessageType() const = 0;

  virtual bool GetLastReceiveTime(const string &message_type,
                                  WallClock::Value *receive_time) const = 0;

  virtual bool GetLastSendTime(const string &message_type,
                               WallClock::Value *send_time) const = 0;

  virtual WallClock::Value GetExpirationTime() const = 0;

  //
  virtual bool IsTransportAttached() const = 0;

  virtual bool IsTransportAttached(TransportProtocol protocol) const = 0;

  virtual void CloseTransport() = 0;

  virtual bool CloseTransport(TransportProtocol protocol) = 0;

  virtual void SendMessage(
      const string &message_type,
      Encryption encryption = kDefaultEncryption,
      TransportProtocol protocol = kDefaultProtocol) = 0 ASSERT_NO_ROLLBACK;

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

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

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


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

  virtual void SendBackMessage(
      const Json &message,
      Encryption encryption = kDefaultEncryption,
      TransportProtocol protocol = kDefaultProtocol) = 0 ASSERT_NO_ROLLBACK;

  virtual void SendBackMessage(
      const Ptr<FunMessage> &message,
      Encryption encryption = kDefaultEncryption,
      TransportProtocol protocol = kDefaultProtocol) = 0 ASSERT_NO_ROLLBACK;

  virtual void Close() = 0;

  //
  virtual bool IsOpened() const = 0;

  virtual void Tag(const string &tag) = 0;

  virtual void Untag(const string &tag) = 0;

  virtual bool HasTag(const string &tag) const = 0;

  virtual std::set<string> GetTags() const = 0;

  // @param ctxt Json instance containting a context.
  virtual void SetContext(const Json &ctxt) = 0;

  virtual const Json &GetContext() const = 0;

  virtual Json &GetContext() = 0;

  virtual void AddToContext(const string &key, const string &value) = 0;
  virtual void AddToContext(const string &key, const int64_t &value) = 0;
  virtual bool GetFromContext(const string &key, string *ret) const = 0;
  virtual bool GetFromContext(const string &key, int64_t *ret) const = 0;
  virtual bool DeleteFromContext(const string &key) = 0;

  virtual boost::mutex &GetContextMutex() = 0;
  virtual operator boost::mutex &() const = 0;

  virtual void LockContext() = 0;
  virtual void UnlockContext() = 0;

  virtual void SetPingSamplingInterval(size_t seconds) = 0;
  virtual void SetPingSamplingInterval(size_t seconds,
                                       TransportProtocol protocol) = 0;

  virtual size_t GetPingSamplingInterval() const = 0;
  virtual size_t GetPingSamplingInterval(TransportProtocol protocol) const = 0;

  virtual void SetPingTimeout(size_t seconds) = 0;
  virtual void SetPingTimeout(size_t seconds, TransportProtocol protocol) = 0;

  virtual size_t GetPingTimeout() const = 0;
  virtual size_t GetPingTimeout(TransportProtocol protocol) const = 0;

  virtual Ping GetPing() const = 0;
  virtual Ping GetPing(TransportProtocol protocol) const = 0;

 protected:
  Session();
};


FUNAPI_DLL_VISIBILITY void SetTransport(TransportProtocol protocol);

FUNAPI_DLL_VISIBILITY
void SetTransport(TransportProtocol protocol, const string &msgtype);


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

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

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

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

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

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

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

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

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

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


class FUNAPI_DLL_VISIBILITY HandlerRegistry {
 public:
  static void Install();
  static void Install2(const SessionOpenedHandler &opened_handler,
                       const SessionClosedHandler2 &closed_handler);
  static void Uninstall();

  static void RegisterTcpTransportAttachedHandler(
      const TcpTransportAttachedHandler &tcp_attached_handler);

  static void RegisterTcpTransportDetachedHandler(
      const TcpTransportDetachedHandler &tcp_detached_handler);

  static void RegisterWebSocketTransportAttachedHandler(
      const WebSocketTransportAttachedHandler &websocket_attached_handler);

  static void RegisterWebSocketTransportDetachedHandler(
      const WebSocketTransportDetachedHandler &websocket_detached_handler);

  static void RegisterSessionRestoredHandler(
      const SessionRestoredHandler &restored_handler);

  static void Register(const string &message_type,
                       const MessageHandler &message_handler);
  static void Register(const string &message_type,
                       const MessageHandler &message_handler,
                       const JsonSchema &message_schema);
  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);

  // Belows have been deprecated.
  // Consider using alternatives.
  DEPRECATED(static void Install(const SessionOpenedHandler &opened_handler, \
                                 const SessionClosedHandler &closed_handler));
};


typedef function<void(const Ptr<Session> &/*session*/,
                      const Ptr<const FunMessage> &/*message*/,
                      const string &/*message_type*/,
                      size_t message_size)> ProtobufMessageSendHook;
typedef function<void(const Ptr<Session> &/*session*/,
                      const Json &/*message*/,
                      const string &/*message_type*/,
                      size_t message_size)> JsonMessageSendHook;


FUNAPI_DLL_VISIBILITY
void InstallProtobufMessageSendHook(const ProtobufMessageSendHook &hook);

FUNAPI_DLL_VISIBILITY
void InstallJsonMessageSendHook(const JsonMessageSendHook &hook);


typedef function<bool(
    const Ptr<Session> &/*session*/,
    const Ptr<const FunMessage> &/*message*/,
    const string &/*message type*/)> ProtobufPreMessageHandlerHook;
typedef function<void(
    const Ptr<Session> &/*session*/,
    const Ptr<const FunMessage> &/*message*/,
    const string &/*message type*/)> ProtobufPostMessageHandlerHook;
typedef function<bool(
    const Ptr<Session> &/*session*/,
    const Ptr<const FunMessage> &/*message*/,
    const int32_t /*message_type*/)> ProtobufPreMessageHandlerHook2;
typedef function<void(
    const Ptr<Session> &/*session*/,
    const Ptr<const FunMessage> &/*message*/,
    const int32_t /*message_type*/)> ProtobufPostMessageHandlerHook2;
typedef function<bool(
    const Ptr<Session> &/*session*/,
    const Json &/*message*/,
    const string & /*message type*/)> JsonPreMessageHandlerHook;
typedef function<void(
    const Ptr<Session> &/*session*/,
    const Json &/*message*/,
    const string &/*message type*/)> JsonPostMessageHandlerHook;


FUNAPI_DLL_VISIBILITY void InstallProtobufMessageHandlerHook(
    const ProtobufPreMessageHandlerHook &protobuf_pre_message_handler_hook,
    const ProtobufPostMessageHandlerHook &protobuf_post_message_handler_hook);

FUNAPI_DLL_VISIBILITY void InstallProtobufMessageHandlerHook2(
    const ProtobufPreMessageHandlerHook2 &protobuf_pre_message_handler_hook,
    const ProtobufPostMessageHandlerHook2 &protobuf_post_message_handler_hook);

FUNAPI_DLL_VISIBILITY void InstallJsonMessageHandlerHook(
    const JsonPreMessageHandlerHook &json_pre_message_handler_hook,
    const JsonPostMessageHandlerHook &json_post_message_handler_hook);

// Overrides 'session_timeout_in_second' value in MANIFEST.json.
// if the 'timeout_in_ms' value is 0, timeout will be disabled
// for the specified session.
FUNAPI_DLL_VISIBILITY void OverrideSessionTimeout(
    const Ptr<Session> &session, const int64_t timeout_in_ms);


class FUNAPI_DLL_VISIBILITY ProtobufExtensionIdentifier {
 public:
  template <typename ExtendeeType, typename TraitsType,
           ::google::protobuf::internal::FieldType field_type, bool is_packed>
  ProtobufExtensionIdentifier(
      const ::google::protobuf::internal::ExtensionIdentifier<ExtendeeType,
          TraitsType, field_type, is_packed> &extension_identifier) {
    field_tag_number_ = extension_identifier.number();
    ExtractFieldTagName(typeid(TraitsType).name());
  }

  inline int32_t field_tag_number() const { return field_tag_number_; }
  inline string field_tag_name() const { return field_tag_name_; }

 private:
  void ExtractFieldTagName(const string &type_name);
  int32_t field_tag_number_;
  string field_tag_name_;
};


FUNAPI_DLL_VISIBILITY inline bool operator==(
    const int32_t lhs, const ProtobufExtensionIdentifier &rhs) {
  return lhs == rhs.field_tag_number();
}


FUNAPI_DLL_VISIBILITY inline bool operator==(
    const ProtobufExtensionIdentifier lhs, const int32_t &rhs) {
  return lhs.field_tag_number() == rhs;
}

}  // namespace fun

#endif  // INCLUDE_FUNAPI_NETWORK_SESSION_H_