self_msgproto 0.0.1

data/ext/self_msgproto/msgproto/notification_generated.h

@@ -0,0 +1,137 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_NOTIFICATION_SELFMESSAGING_H_
+#define FLATBUFFERS_GENERATED_NOTIFICATION_SELFMESSAGING_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "types_generated.h"
+
+namespace SelfMessaging {
+
+struct Notification;
+struct NotificationBuilder;
+
+struct Notification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef NotificationBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ID = 4,
+    VT_MSGTYPE = 6,
+    VT_ERROR = 8,
+    VT_ERRTYPE = 10
+  };
+  const flatbuffers::String *id() const {
+    return GetPointer<const flatbuffers::String *>(VT_ID);
+  }
+  SelfMessaging::MsgType msgtype() const {
+    return static_cast<SelfMessaging::MsgType>(GetField<int8_t>(VT_MSGTYPE, 0));
+  }
+  const flatbuffers::String *error() const {
+    return GetPointer<const flatbuffers::String *>(VT_ERROR);
+  }
+  SelfMessaging::ErrType errtype() const {
+    return static_cast<SelfMessaging::ErrType>(GetField<int8_t>(VT_ERRTYPE, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_ID) &&
+           verifier.VerifyString(id()) &&
+           VerifyField<int8_t>(verifier, VT_MSGTYPE) &&
+           VerifyOffset(verifier, VT_ERROR) &&
+           verifier.VerifyString(error()) &&
+           VerifyField<int8_t>(verifier, VT_ERRTYPE) &&
+           verifier.EndTable();
+  }
+};
+
+struct NotificationBuilder {
+  typedef Notification Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_id(flatbuffers::Offset<flatbuffers::String> id) {
+    fbb_.AddOffset(Notification::VT_ID, id);
+  }
+  void add_msgtype(SelfMessaging::MsgType msgtype) {
+    fbb_.AddElement<int8_t>(Notification::VT_MSGTYPE, static_cast<int8_t>(msgtype), 0);
+  }
+  void add_error(flatbuffers::Offset<flatbuffers::String> error) {
+    fbb_.AddOffset(Notification::VT_ERROR, error);
+  }
+  void add_errtype(SelfMessaging::ErrType errtype) {
+    fbb_.AddElement<int8_t>(Notification::VT_ERRTYPE, static_cast<int8_t>(errtype), 0);
+  }
+  explicit NotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<Notification> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Notification>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Notification> CreateNotification(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> id = 0,
+    SelfMessaging::MsgType msgtype = SelfMessaging::MsgType_MSG,
+    flatbuffers::Offset<flatbuffers::String> error = 0,
+    SelfMessaging::ErrType errtype = SelfMessaging::ErrType_ErrConnection) {
+  NotificationBuilder builder_(_fbb);
+  builder_.add_error(error);
+  builder_.add_id(id);
+  builder_.add_errtype(errtype);
+  builder_.add_msgtype(msgtype);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Notification> CreateNotificationDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *id = nullptr,
+    SelfMessaging::MsgType msgtype = SelfMessaging::MsgType_MSG,
+    const char *error = nullptr,
+    SelfMessaging::ErrType errtype = SelfMessaging::ErrType_ErrConnection) {
+  auto id__ = id ? _fbb.CreateString(id) : 0;
+  auto error__ = error ? _fbb.CreateString(error) : 0;
+  return SelfMessaging::CreateNotification(
+      _fbb,
+      id__,
+      msgtype,
+      error__,
+      errtype);
+}
+
+inline const SelfMessaging::Notification *GetNotification(const void *buf) {
+  return flatbuffers::GetRoot<SelfMessaging::Notification>(buf);
+}
+
+inline const SelfMessaging::Notification *GetSizePrefixedNotification(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<SelfMessaging::Notification>(buf);
+}
+
+inline bool VerifyNotificationBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<SelfMessaging::Notification>(nullptr);
+}
+
+inline bool VerifySizePrefixedNotificationBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<SelfMessaging::Notification>(nullptr);
+}
+
+inline void FinishNotificationBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<SelfMessaging::Notification> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedNotificationBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<SelfMessaging::Notification> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace SelfMessaging
+
+#endif  // FLATBUFFERS_GENERATED_NOTIFICATION_SELFMESSAGING_H_

data/ext/self_msgproto/msgproto/types_generated.h

@@ -0,0 +1,208 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_TYPES_SELFMESSAGING_H_
+#define FLATBUFFERS_GENERATED_TYPES_SELFMESSAGING_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace SelfMessaging {
+
+enum ACLCommand {
+  ACLCommand_LIST = 0,
+  ACLCommand_PERMIT = 1,
+  ACLCommand_REVOKE = 2,
+  ACLCommand_MIN = ACLCommand_LIST,
+  ACLCommand_MAX = ACLCommand_REVOKE
+};
+
+inline const ACLCommand (&EnumValuesACLCommand())[3] {
+  static const ACLCommand values[] = {
+    ACLCommand_LIST,
+    ACLCommand_PERMIT,
+    ACLCommand_REVOKE
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesACLCommand() {
+  static const char * const names[4] = {
+    "LIST",
+    "PERMIT",
+    "REVOKE",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameACLCommand(ACLCommand e) {
+  if (flatbuffers::IsOutRange(e, ACLCommand_LIST, ACLCommand_REVOKE)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesACLCommand()[index];
+}
+
+enum ErrType {
+  ErrType_ErrConnection = 0,
+  ErrType_ErrBadRequest = 1,
+  ErrType_ErrInternal = 2,
+  ErrType_ErrMessage = 3,
+  ErrType_ErrAuth = 4,
+  ErrType_ErrACL = 5,
+  ErrType_MIN = ErrType_ErrConnection,
+  ErrType_MAX = ErrType_ErrACL
+};
+
+inline const ErrType (&EnumValuesErrType())[6] {
+  static const ErrType values[] = {
+    ErrType_ErrConnection,
+    ErrType_ErrBadRequest,
+    ErrType_ErrInternal,
+    ErrType_ErrMessage,
+    ErrType_ErrAuth,
+    ErrType_ErrACL
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesErrType() {
+  static const char * const names[7] = {
+    "ErrConnection",
+    "ErrBadRequest",
+    "ErrInternal",
+    "ErrMessage",
+    "ErrAuth",
+    "ErrACL",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameErrType(ErrType e) {
+  if (flatbuffers::IsOutRange(e, ErrType_ErrConnection, ErrType_ErrACL)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesErrType()[index];
+}
+
+enum MsgType {
+  MsgType_MSG = 0,
+  MsgType_ACK = 1,
+  MsgType_ERR = 2,
+  MsgType_AUTH = 3,
+  MsgType_ACL = 4,
+  MsgType_MIN = MsgType_MSG,
+  MsgType_MAX = MsgType_ACL
+};
+
+inline const MsgType (&EnumValuesMsgType())[5] {
+  static const MsgType values[] = {
+    MsgType_MSG,
+    MsgType_ACK,
+    MsgType_ERR,
+    MsgType_AUTH,
+    MsgType_ACL
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesMsgType() {
+  static const char * const names[6] = {
+    "MSG",
+    "ACK",
+    "ERR",
+    "AUTH",
+    "ACL",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameMsgType(MsgType e) {
+  if (flatbuffers::IsOutRange(e, MsgType_MSG, MsgType_ACL)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesMsgType()[index];
+}
+
+enum MsgSubType {
+  MsgSubType_Unknown = 0,
+  MsgSubType_AuthenticationReq = 1,
+  MsgSubType_AuthenticationResp = 2,
+  MsgSubType_AuthenticationQRResp = 3,
+  MsgSubType_AuthenticationDeepLinkResp = 4,
+  MsgSubType_FactReq = 5,
+  MsgSubType_FactResp = 6,
+  MsgSubType_FactQRResp = 7,
+  MsgSubType_FactDeepLinkResp = 8,
+  MsgSubType_EmailSecurityCodeReq = 9,
+  MsgSubType_EmailSecurityCodeResp = 10,
+  MsgSubType_PhoneSecurityCodeReq = 11,
+  MsgSubType_PhoneSecurityCodeResp = 12,
+  MsgSubType_PhoneVerificationReq = 13,
+  MsgSubType_PhoneVerificationResp = 14,
+  MsgSubType_EmailVerificationReq = 15,
+  MsgSubType_EmailVerificationResp = 16,
+  MsgSubType_DocumentVerificationReq = 17,
+  MsgSubType_DocumentVerificationResp = 18,
+  MsgSubType_MIN = MsgSubType_Unknown,
+  MsgSubType_MAX = MsgSubType_DocumentVerificationResp
+};
+
+inline const MsgSubType (&EnumValuesMsgSubType())[19] {
+  static const MsgSubType values[] = {
+    MsgSubType_Unknown,
+    MsgSubType_AuthenticationReq,
+    MsgSubType_AuthenticationResp,
+    MsgSubType_AuthenticationQRResp,
+    MsgSubType_AuthenticationDeepLinkResp,
+    MsgSubType_FactReq,
+    MsgSubType_FactResp,
+    MsgSubType_FactQRResp,
+    MsgSubType_FactDeepLinkResp,
+    MsgSubType_EmailSecurityCodeReq,
+    MsgSubType_EmailSecurityCodeResp,
+    MsgSubType_PhoneSecurityCodeReq,
+    MsgSubType_PhoneSecurityCodeResp,
+    MsgSubType_PhoneVerificationReq,
+    MsgSubType_PhoneVerificationResp,
+    MsgSubType_EmailVerificationReq,
+    MsgSubType_EmailVerificationResp,
+    MsgSubType_DocumentVerificationReq,
+    MsgSubType_DocumentVerificationResp
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesMsgSubType() {
+  static const char * const names[20] = {
+    "Unknown",
+    "AuthenticationReq",
+    "AuthenticationResp",
+    "AuthenticationQRResp",
+    "AuthenticationDeepLinkResp",
+    "FactReq",
+    "FactResp",
+    "FactQRResp",
+    "FactDeepLinkResp",
+    "EmailSecurityCodeReq",
+    "EmailSecurityCodeResp",
+    "PhoneSecurityCodeReq",
+    "PhoneSecurityCodeResp",
+    "PhoneVerificationReq",
+    "PhoneVerificationResp",
+    "EmailVerificationReq",
+    "EmailVerificationResp",
+    "DocumentVerificationReq",
+    "DocumentVerificationResp",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameMsgSubType(MsgSubType e) {
+  if (flatbuffers::IsOutRange(e, MsgSubType_Unknown, MsgSubType_DocumentVerificationResp)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesMsgSubType()[index];
+}
+
+}  // namespace SelfMessaging
+
+#endif  // FLATBUFFERS_GENERATED_TYPES_SELFMESSAGING_H_

data/ext/self_msgproto/notification.cpp

@@ -0,0 +1,57 @@
+#include <iostream>
+#include "rice/rice.hpp"
+#include "flatbuffers/flatbuffers.h"
+#include "msgproto/notification_generated.h"
+
+using namespace SelfMessaging;
+
+VALUE notification_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE opts;
+
+    (void)rb_scan_args(argc, argv, "0:", &opts);
+
+    opts = (opts == Qnil) ? rb_hash_new(): opts;
+
+    VALUE data = rb_hash_aref(opts, ID2SYM(rb_intern("data")));
+
+    if (data != Qnil) {
+        if(rb_obj_is_kind_of(data, rb_cString) != Qtrue){
+            rb_raise(rb_eTypeError, "notification data must be kind of String");
+        }
+
+        const uint8_t *data_ptr = (uint8_t *)RSTRING_PTR(data);
+        long data_len = RSTRING_LEN(data);
+
+        auto ntf = GetNotification(data_ptr);
+
+        flatbuffers::Verifier verifier(data_ptr, data_len);
+
+        if (!VerifyNotificationBuffer(verifier)) {
+            rb_raise(rb_eStandardError, "notification buffer is invalid");
+        }
+
+        auto id = ntf->id()->c_str();
+        auto mtype = ntf->msgtype();
+        auto error = ntf->error()->c_str();
+
+        VALUE idstr = rb_str_new(id, std::strlen(id));
+        rb_ivar_set(self, rb_intern("@id"), idstr);
+
+        VALUE mtypeint = rb_int2inum(mtype);
+        rb_ivar_set(self, rb_intern("@type"), mtypeint);
+
+        VALUE errorstr = rb_str_new(error, std::strlen(error));
+        rb_ivar_set(self, rb_intern("@error"), errorstr);
+    }
+
+    return self;
+}
+
+void notification_init() {
+    VALUE cRubySelfMsg = rb_define_module("SelfMsg");
+    VALUE cHeader = rb_define_class_under(cRubySelfMsg, "Notification", rb_cObject);
+
+    rb_define_method(cHeader, "initialize", notification_initialize, -1);
+}
+

data/ext/self_msgproto/self_msgproto.cpp

@@ -0,0 +1,21 @@
+#include "rice/rice.hpp"
+#include <iostream>
+
+using namespace Rice;
+
+void acl_init();
+void auth_init();
+void header_init();
+void message_init();
+void notification_init();
+
+
+extern "C"
+void Init_self_msgproto()
+{
+    acl_init();
+    auth_init();
+    header_init();
+    message_init();
+    notification_init();
+}

data/lib/self_msgproto.rb

@@ -0,0 +1,12 @@
+# Copyright 2020 Self Group Ltd. All Rights Reserved.
+
+require 'self_msgproto/version'
+require 'self_msgproto/acl'
+require 'self_msgproto/auth'
+require 'self_msgproto/header'
+require 'self_msgproto/message'
+require 'self_msgproto/notification'
+require 'self_msgproto/self_msgproto'
+
+module SelfMsg
+end

data/lib/self_msgproto/acl.rb

@@ -0,0 +1,9 @@
+# Copyright 2021 Self Group Ltd. All Rights Reserved.
+
+module SelfMsg
+
+  class Acl
+    attr_accessor :id, :type, :command, :payload
+  end
+
+end