self_msgproto 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b41848085e3168bb4fcd9d40ec312c386bf6e0d21e6ad0514bd78e458e65e7eb
-  data.tar.gz: 293c5a942344da9edfe27f0d9b542c2d03a5037f117cb0ce69990c0e0e4e6550
+  metadata.gz: 0baf544ea5fe7c0ad5637477ab27b796e72beed265becd71c1c818bf1833b78c
+  data.tar.gz: 78c6d570bd15dd6a3d226330c75dacada63a9a2f43cb1047e37a09d81780345a
 SHA512:
-  metadata.gz: 7d0e4d5ed89740b736a2944e5a5f4c29e50254bdcda810ada5ada42677fece84a5a423accd1a9a7d6ed5c3a9073551094c5997e37481215cd9885f2bd0acd584
-  data.tar.gz: 9146689eecc6e9b025c6fc7e85918608bd6d1fde76aa5b9b81e39254012c02cb8a3536bb1a9c41e32ddb0719fe083a3e2b457959d04e3f874d5fcdbf27bcbb74
+  metadata.gz: e75f88b0a97c4c77227df0a7a45719a0cdd5afbdc6a007561e690ad104dfec6a3f08b1b7219e90dcc73c2051eaff3c833ed5b60dbc8bf803c89ed41ff5eb7e7d
+  data.tar.gz: 1aeb9e4cfc1deb833dbbd14ed10e4f0caa782dc20cf24f212fe3947f17e9d8e3fa581dda4b9e88dbb281cc1c743bdb2c2ad4d568614b2a10da8cf87227502e7d

data/ext/self_msgproto/msgproto/message_generated.h

@@ -51,7 +51,8 @@ struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_PRIORITY = 20,
     VT_MESSAGE_TYPE = 22,
     VT_COLLAPSE_KEY = 24,
-    VT_NOTIFICATION_PAYLOAD = 26
+    VT_NOTIFICATION_PAYLOAD = 26,
+    VT_AUTHORIZATION = 28
   };
   const flatbuffers::String *id() const {
     return GetPointer<const flatbuffers::String *>(VT_ID);
@@ -86,6 +87,9 @@ struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const flatbuffers::Vector<uint8_t> *notification_payload() const {
     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_NOTIFICATION_PAYLOAD);
   }
+  const flatbuffers::Vector<uint8_t> *authorization() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_AUTHORIZATION);
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
@@ -106,6 +110,8 @@ struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            verifier.VerifyVector(collapse_key()) &&
            VerifyOffset(verifier, VT_NOTIFICATION_PAYLOAD) &&
            verifier.VerifyVector(notification_payload()) &&
+           VerifyOffset(verifier, VT_AUTHORIZATION) &&
+           verifier.VerifyVector(authorization()) &&
            verifier.EndTable();
   }
 };
@@ -147,6 +153,9 @@ struct MessageBuilder {
   void add_notification_payload(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> notification_payload) {
     fbb_.AddOffset(Message::VT_NOTIFICATION_PAYLOAD, notification_payload);
   }
+  void add_authorization(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> authorization) {
+    fbb_.AddOffset(Message::VT_AUTHORIZATION, authorization);
+  }
   explicit MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -171,8 +180,10 @@ inline flatbuffers::Offset<Message> CreateMessage(
     uint32_t priority = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message_type = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> collapse_key = 0,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> notification_payload = 0) {
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> notification_payload = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> authorization = 0) {
   MessageBuilder builder_(_fbb);
+  builder_.add_authorization(authorization);
   builder_.add_notification_payload(notification_payload);
   builder_.add_collapse_key(collapse_key);
   builder_.add_message_type(message_type);
@@ -199,7 +210,8 @@ inline flatbuffers::Offset<Message> CreateMessageDirect(
     uint32_t priority = 0,
     const std::vector<uint8_t> *message_type = nullptr,
     const std::vector<uint8_t> *collapse_key = nullptr,
-    const std::vector<uint8_t> *notification_payload = nullptr) {
+    const std::vector<uint8_t> *notification_payload = nullptr,
+    const std::vector<uint8_t> *authorization = nullptr) {
   auto id__ = id ? _fbb.CreateString(id) : 0;
   auto sender__ = sender ? _fbb.CreateString(sender) : 0;
   auto recipient__ = recipient ? _fbb.CreateString(recipient) : 0;
@@ -207,6 +219,7 @@ inline flatbuffers::Offset<Message> CreateMessageDirect(
   auto message_type__ = message_type ? _fbb.CreateVector<uint8_t>(*message_type) : 0;
   auto collapse_key__ = collapse_key ? _fbb.CreateVector<uint8_t>(*collapse_key) : 0;
   auto notification_payload__ = notification_payload ? _fbb.CreateVector<uint8_t>(*notification_payload) : 0;
+  auto authorization__ = authorization ? _fbb.CreateVector<uint8_t>(*authorization) : 0;
   return SelfMessaging::CreateMessage(
       _fbb,
       id__,
@@ -219,7 +232,8 @@ inline flatbuffers::Offset<Message> CreateMessageDirect(
       priority,
       message_type__,
       collapse_key__,
-      notification_payload__);
+      notification_payload__,
+      authorization__);
 }
 
 inline const SelfMessaging::Message *GetMessage(const void *buf) {

data/ext/self_msgproto/msgproto/status_generated.h

@@ -0,0 +1,149 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_STATUS_SELFMESSAGING_H_
+#define FLATBUFFERS_GENERATED_STATUS_SELFMESSAGING_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "types_generated.h"
+
+namespace SelfMessaging {
+
+struct Status;
+struct StatusBuilder;
+
+struct Status FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef StatusBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ID = 4,
+    VT_MSGTYPE = 6,
+    VT_RECIPIENT = 8,
+    VT_ONLINE = 10,
+    VT_LAST_SEEN = 12
+  };
+  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 *recipient() const {
+    return GetPointer<const flatbuffers::String *>(VT_RECIPIENT);
+  }
+  bool online() const {
+    return GetField<uint8_t>(VT_ONLINE, 0) != 0;
+  }
+  int64_t last_seen() const {
+    return GetField<int64_t>(VT_LAST_SEEN, 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_RECIPIENT) &&
+           verifier.VerifyString(recipient()) &&
+           VerifyField<uint8_t>(verifier, VT_ONLINE) &&
+           VerifyField<int64_t>(verifier, VT_LAST_SEEN) &&
+           verifier.EndTable();
+  }
+};
+
+struct StatusBuilder {
+  typedef Status Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_id(flatbuffers::Offset<flatbuffers::String> id) {
+    fbb_.AddOffset(Status::VT_ID, id);
+  }
+  void add_msgtype(SelfMessaging::MsgType msgtype) {
+    fbb_.AddElement<int8_t>(Status::VT_MSGTYPE, static_cast<int8_t>(msgtype), 0);
+  }
+  void add_recipient(flatbuffers::Offset<flatbuffers::String> recipient) {
+    fbb_.AddOffset(Status::VT_RECIPIENT, recipient);
+  }
+  void add_online(bool online) {
+    fbb_.AddElement<uint8_t>(Status::VT_ONLINE, static_cast<uint8_t>(online), 0);
+  }
+  void add_last_seen(int64_t last_seen) {
+    fbb_.AddElement<int64_t>(Status::VT_LAST_SEEN, last_seen, 0);
+  }
+  explicit StatusBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<Status> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Status>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Status> CreateStatus(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> id = 0,
+    SelfMessaging::MsgType msgtype = SelfMessaging::MsgType_MSG,
+    flatbuffers::Offset<flatbuffers::String> recipient = 0,
+    bool online = false,
+    int64_t last_seen = 0) {
+  StatusBuilder builder_(_fbb);
+  builder_.add_last_seen(last_seen);
+  builder_.add_recipient(recipient);
+  builder_.add_id(id);
+  builder_.add_online(online);
+  builder_.add_msgtype(msgtype);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Status> CreateStatusDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *id = nullptr,
+    SelfMessaging::MsgType msgtype = SelfMessaging::MsgType_MSG,
+    const char *recipient = nullptr,
+    bool online = false,
+    int64_t last_seen = 0) {
+  auto id__ = id ? _fbb.CreateString(id) : 0;
+  auto recipient__ = recipient ? _fbb.CreateString(recipient) : 0;
+  return SelfMessaging::CreateStatus(
+      _fbb,
+      id__,
+      msgtype,
+      recipient__,
+      online,
+      last_seen);
+}
+
+inline const SelfMessaging::Status *GetStatus(const void *buf) {
+  return flatbuffers::GetRoot<SelfMessaging::Status>(buf);
+}
+
+inline const SelfMessaging::Status *GetSizePrefixedStatus(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<SelfMessaging::Status>(buf);
+}
+
+inline bool VerifyStatusBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<SelfMessaging::Status>(nullptr);
+}
+
+inline bool VerifySizePrefixedStatusBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<SelfMessaging::Status>(nullptr);
+}
+
+inline void FinishStatusBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<SelfMessaging::Status> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedStatusBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<SelfMessaging::Status> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace SelfMessaging
+
+#endif  // FLATBUFFERS_GENERATED_STATUS_SELFMESSAGING_H_

data/ext/self_msgproto/msgproto/types_generated.h

@@ -8,48 +8,15 @@
 
 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 {
+enum ErrType : int8_t {
   ErrType_ErrConnection = 0,
   ErrType_ErrBadRequest = 1,
   ErrType_ErrInternal = 2,
   ErrType_ErrMessage = 3,
   ErrType_ErrAuth = 4,
-  ErrType_ErrACL = 5,
+  ErrType_ErrWatch = 6,
   ErrType_MIN = ErrType_ErrConnection,
-  ErrType_MAX = ErrType_ErrACL
+  ErrType_MAX = ErrType_ErrWatch
 };
 
 inline const ErrType (&EnumValuesErrType())[6] {
@@ -59,70 +26,75 @@ inline const ErrType (&EnumValuesErrType())[6] {
     ErrType_ErrInternal,
     ErrType_ErrMessage,
     ErrType_ErrAuth,
-    ErrType_ErrACL
+    ErrType_ErrWatch
   };
   return values;
 }
 
 inline const char * const *EnumNamesErrType() {
-  static const char * const names[7] = {
+  static const char * const names[8] = {
     "ErrConnection",
     "ErrBadRequest",
     "ErrInternal",
     "ErrMessage",
     "ErrAuth",
-    "ErrACL",
+    "",
+    "ErrWatch",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameErrType(ErrType e) {
-  if (flatbuffers::IsOutRange(e, ErrType_ErrConnection, ErrType_ErrACL)) return "";
+  if (flatbuffers::IsOutRange(e, ErrType_ErrConnection, ErrType_ErrWatch)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesErrType()[index];
 }
 
-enum MsgType {
+enum MsgType : int8_t {
   MsgType_MSG = 0,
   MsgType_ACK = 1,
   MsgType_ERR = 2,
   MsgType_AUTH = 3,
-  MsgType_ACL = 4,
+  MsgType_WTC = 5,
+  MsgType_STS = 6,
   MsgType_MIN = MsgType_MSG,
-  MsgType_MAX = MsgType_ACL
+  MsgType_MAX = MsgType_STS
 };
 
-inline const MsgType (&EnumValuesMsgType())[5] {
+inline const MsgType (&EnumValuesMsgType())[6] {
   static const MsgType values[] = {
     MsgType_MSG,
     MsgType_ACK,
     MsgType_ERR,
     MsgType_AUTH,
-    MsgType_ACL
+    MsgType_WTC,
+    MsgType_STS
   };
   return values;
 }
 
 inline const char * const *EnumNamesMsgType() {
-  static const char * const names[6] = {
+  static const char * const names[8] = {
     "MSG",
     "ACK",
     "ERR",
     "AUTH",
-    "ACL",
+    "",
+    "WTC",
+    "STS",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameMsgType(MsgType e) {
-  if (flatbuffers::IsOutRange(e, MsgType_MSG, MsgType_ACL)) return "";
+  if (flatbuffers::IsOutRange(e, MsgType_MSG, MsgType_STS)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesMsgType()[index];
 }
 
-enum MsgSubType {
+enum MsgSubType : uint16_t {
   MsgSubType_Unknown = 0,
   MsgSubType_AuthenticationReq = 1,
   MsgSubType_AuthenticationResp = 2,

data/ext/self_msgproto/msgproto/watch_generated.h

@@ -0,0 +1,137 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_WATCH_SELFMESSAGING_H_
+#define FLATBUFFERS_GENERATED_WATCH_SELFMESSAGING_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "types_generated.h"
+
+namespace SelfMessaging {
+
+struct Watch;
+struct WatchBuilder;
+
+struct Watch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef WatchBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ID = 4,
+    VT_MSGTYPE = 6,
+    VT_RECIPIENT = 8,
+    VT_WATCH = 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 *recipient() const {
+    return GetPointer<const flatbuffers::String *>(VT_RECIPIENT);
+  }
+  bool watch() const {
+    return GetField<uint8_t>(VT_WATCH, 0) != 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_RECIPIENT) &&
+           verifier.VerifyString(recipient()) &&
+           VerifyField<uint8_t>(verifier, VT_WATCH) &&
+           verifier.EndTable();
+  }
+};
+
+struct WatchBuilder {
+  typedef Watch Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_id(flatbuffers::Offset<flatbuffers::String> id) {
+    fbb_.AddOffset(Watch::VT_ID, id);
+  }
+  void add_msgtype(SelfMessaging::MsgType msgtype) {
+    fbb_.AddElement<int8_t>(Watch::VT_MSGTYPE, static_cast<int8_t>(msgtype), 0);
+  }
+  void add_recipient(flatbuffers::Offset<flatbuffers::String> recipient) {
+    fbb_.AddOffset(Watch::VT_RECIPIENT, recipient);
+  }
+  void add_watch(bool watch) {
+    fbb_.AddElement<uint8_t>(Watch::VT_WATCH, static_cast<uint8_t>(watch), 0);
+  }
+  explicit WatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<Watch> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Watch>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Watch> CreateWatch(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> id = 0,
+    SelfMessaging::MsgType msgtype = SelfMessaging::MsgType_MSG,
+    flatbuffers::Offset<flatbuffers::String> recipient = 0,
+    bool watch = false) {
+  WatchBuilder builder_(_fbb);
+  builder_.add_recipient(recipient);
+  builder_.add_id(id);
+  builder_.add_watch(watch);
+  builder_.add_msgtype(msgtype);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Watch> CreateWatchDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *id = nullptr,
+    SelfMessaging::MsgType msgtype = SelfMessaging::MsgType_MSG,
+    const char *recipient = nullptr,
+    bool watch = false) {
+  auto id__ = id ? _fbb.CreateString(id) : 0;
+  auto recipient__ = recipient ? _fbb.CreateString(recipient) : 0;
+  return SelfMessaging::CreateWatch(
+      _fbb,
+      id__,
+      msgtype,
+      recipient__,
+      watch);
+}
+
+inline const SelfMessaging::Watch *GetWatch(const void *buf) {
+  return flatbuffers::GetRoot<SelfMessaging::Watch>(buf);
+}
+
+inline const SelfMessaging::Watch *GetSizePrefixedWatch(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<SelfMessaging::Watch>(buf);
+}
+
+inline bool VerifyWatchBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<SelfMessaging::Watch>(nullptr);
+}
+
+inline bool VerifySizePrefixedWatchBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<SelfMessaging::Watch>(nullptr);
+}
+
+inline void FinishWatchBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<SelfMessaging::Watch> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedWatchBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<SelfMessaging::Watch> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace SelfMessaging
+
+#endif  // FLATBUFFERS_GENERATED_WATCH_SELFMESSAGING_H_

data/ext/self_msgproto/self_msgproto.cpp

@@ -3,7 +3,6 @@
 
 using namespace Rice;
 
-void acl_init();
 void auth_init();
 void header_init();
 void message_init();
@@ -13,7 +12,6 @@ void notification_init();
 extern "C"
 void Init_self_msgproto()
 {
-    acl_init();
     auth_init();
     header_init();
     message_init();

data/lib/self_msgproto/version.rb

@@ -2,6 +2,6 @@
 
 module SelfMsg
 
-  VERSION="0.0.10"
+  VERSION="0.0.11"
 
 end

data/lib/self_msgproto.rb

@@ -1,7 +1,6 @@
 # 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'
@@ -14,10 +13,7 @@ module SelfMsg
   MsgTypeACK = 1
   MsgTypeERR = 2
   MsgTypeAUTH = 3
-  MsgTypeACL = 4
-
-  AclCommandLIST = 0
-  AclCommandPERMIT = 1 
-  AclCommandREVOKE = 2 
+  MsgTypeWatch = 5
+  MsgTypeStatus = 6
   
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: self_msgproto
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Tom Bevan
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-16 00:00:00.000000000 Z
+date: 2023-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -80,7 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: ops@joinself.com
 executables: []
 extensions:
@@ -88,28 +88,26 @@ extensions:
 extra_rdoc_files: []
 files:
 - Rakefile
-- ext/self_msgproto/acl.cpp
 - ext/self_msgproto/auth.cpp
 - ext/self_msgproto/extconf.rb
 - ext/self_msgproto/header.cpp
 - ext/self_msgproto/message.cpp
-- ext/self_msgproto/msgproto/acl_generated.h
 - ext/self_msgproto/msgproto/auth_generated.h
 - ext/self_msgproto/msgproto/header_generated.h
 - ext/self_msgproto/msgproto/message_generated.h
 - ext/self_msgproto/msgproto/notification_generated.h
+- ext/self_msgproto/msgproto/status_generated.h
 - ext/self_msgproto/msgproto/types_generated.h
+- ext/self_msgproto/msgproto/watch_generated.h
 - ext/self_msgproto/notification.cpp
 - ext/self_msgproto/self_msgproto.cpp
 - lib/self_msgproto.rb
-- lib/self_msgproto/acl.rb
 - lib/self_msgproto/auth.rb
 - lib/self_msgproto/header.rb
 - lib/self_msgproto/message.rb
 - lib/self_msgproto/notification.rb
 - lib/self_msgproto/version.rb
 - test/spec/test_message.rb
-- test/unit/test_acl.rb
 - test/unit/test_auth.rb
 - test/unit/test_header.rb
 - test/unit/test_message.rb
@@ -118,7 +116,7 @@ homepage: https://github.com/joinself/self-msgproto-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -133,13 +131,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.3.15
+signing_key:
 specification_version: 4
 summary: Bindings for Self's Flatbuffer messaging protocol
 test_files:
 - test/spec/test_message.rb
-- test/unit/test_acl.rb
 - test/unit/test_auth.rb
 - test/unit/test_header.rb
 - test/unit/test_message.rb

data/ext/self_msgproto/acl.cpp

@@ -1,133 +0,0 @@
-#include <iostream>
-#include "rice/rice.hpp"
-#include "flatbuffers/flatbuffers.h"
-#include "msgproto/acl_generated.h"
-
-using namespace SelfMessaging;
-
-VALUE acl_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, "acl data must be kind of String");
-        }
-
-        const uint8_t *data_ptr = (uint8_t *)RSTRING_PTR(data);
-        long data_len = RSTRING_LEN(data);
-
-        auto acl = GetACL(data_ptr);
-
-        flatbuffers::Verifier verifier(data_ptr, data_len);
-
-        if (!VerifyACLBuffer(verifier)) {
-            rb_raise(rb_eStandardError, "acl buffer is invalid");
-        }
-
-        auto id = acl->id()->c_str();
-        auto mtype = acl->msgtype();
-        auto command = acl->command();
-        auto payload = acl->payload();
-
-        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 commandint = rb_int2inum(command);
-        rb_ivar_set(self, rb_intern("@command"), commandint);
-
-        if (payload != NULL) {
-            const u_char *payloaddata = payload->data();
-            long payloadsize = payload->size();
-
-            VALUE payloadstr = rb_str_new((const char *)payloaddata, payloadsize);
-            rb_ivar_set(self, rb_intern("@payload"), payloadstr);
-        }
-    }
-
-    return self;
-}
-
-VALUE acl_to_fb(VALUE self)
-{
-    VALUE idv = rb_ivar_get(self, rb_intern("@id"));
-    char *idstr = RSTRING_PTR(idv);
-
-    VALUE commandv = rb_ivar_get(self, rb_intern("@command"));
-    int64_t commandint = NUM2INT(commandv);
-
-    ACLCommand command;
-
-    switch(commandint) {
-    case 0:
-        command = ACLCommand_LIST;
-        break;
-    case 1:
-        command = ACLCommand_PERMIT;
-        break;
-    case 2:
-        command = ACLCommand_REVOKE;
-        break;
-    default:
-        rb_raise(rb_eStandardError, "acl command is invalid");
-    }
-
-    VALUE payloadv = rb_ivar_get(self, rb_intern("@payload"));
-
-    u_char *payloadstr;
-    long payloadlen;
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> payload;
-
-    if (payloadv != Qnil) {
-        payloadstr = (u_char *)RSTRING_PTR(payloadv);
-        payloadlen = RSTRING_LEN(payloadv);
-    }
-
-    flatbuffers::FlatBufferBuilder builder(1024);
-
-    auto id = builder.CreateString(idstr);
-
-    if (payloadv != Qnil) {
-        payload = builder.CreateVector(payloadstr, payloadlen);
-    }
-
-    ACLBuilder acl_builder(builder);
-
-    acl_builder.add_id(id);
-    acl_builder.add_msgtype(MsgType_ACL);
-    acl_builder.add_command(command);
-
-    if (payloadv != Qnil) {
-        acl_builder.add_payload(payload);
-    }
-
-    auto acl = acl_builder.Finish();
-    builder.Finish(acl);
-
-    uint8_t *buf = builder.GetBufferPointer();
-    int size = builder.GetSize();
-
-    VALUE data = rb_str_new((char *)buf, size);
-
-    builder.Release();
-
-    return data;
-}
-
-void acl_init() {
-    VALUE cRubySelfMsg = rb_define_module("SelfMsg");
-    VALUE cAcl = rb_define_class_under(cRubySelfMsg, "Acl", rb_cObject);
-
-    rb_define_method(cAcl, "initialize", reinterpret_cast< VALUE ( * ) ( ... ) >(acl_initialize), -1);
-    rb_define_method(cAcl, "to_fb", reinterpret_cast< VALUE ( * ) ( ... ) >(acl_to_fb), 0);
-}
-

data/ext/self_msgproto/msgproto/acl_generated.h

@@ -1,137 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_ACL_SELFMESSAGING_H_
-#define FLATBUFFERS_GENERATED_ACL_SELFMESSAGING_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-#include "types_generated.h"
-
-namespace SelfMessaging {
-
-struct ACL;
-struct ACLBuilder;
-
-struct ACL FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  typedef ACLBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_ID = 4,
-    VT_MSGTYPE = 6,
-    VT_COMMAND = 8,
-    VT_PAYLOAD = 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));
-  }
-  SelfMessaging::ACLCommand command() const {
-    return static_cast<SelfMessaging::ACLCommand>(GetField<int8_t>(VT_COMMAND, 0));
-  }
-  const flatbuffers::Vector<uint8_t> *payload() const {
-    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PAYLOAD);
-  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_ID) &&
-           verifier.VerifyString(id()) &&
-           VerifyField<int8_t>(verifier, VT_MSGTYPE) &&
-           VerifyField<int8_t>(verifier, VT_COMMAND) &&
-           VerifyOffset(verifier, VT_PAYLOAD) &&
-           verifier.VerifyVector(payload()) &&
-           verifier.EndTable();
-  }
-};
-
-struct ACLBuilder {
-  typedef ACL Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  void add_id(flatbuffers::Offset<flatbuffers::String> id) {
-    fbb_.AddOffset(ACL::VT_ID, id);
-  }
-  void add_msgtype(SelfMessaging::MsgType msgtype) {
-    fbb_.AddElement<int8_t>(ACL::VT_MSGTYPE, static_cast<int8_t>(msgtype), 0);
-  }
-  void add_command(SelfMessaging::ACLCommand command) {
-    fbb_.AddElement<int8_t>(ACL::VT_COMMAND, static_cast<int8_t>(command), 0);
-  }
-  void add_payload(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> payload) {
-    fbb_.AddOffset(ACL::VT_PAYLOAD, payload);
-  }
-  explicit ACLBuilder(flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  flatbuffers::Offset<ACL> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<ACL>(end);
-    return o;
-  }
-};
-
-inline flatbuffers::Offset<ACL> CreateACL(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::String> id = 0,
-    SelfMessaging::MsgType msgtype = SelfMessaging::MsgType_MSG,
-    SelfMessaging::ACLCommand command = SelfMessaging::ACLCommand_LIST,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> payload = 0) {
-  ACLBuilder builder_(_fbb);
-  builder_.add_payload(payload);
-  builder_.add_id(id);
-  builder_.add_command(command);
-  builder_.add_msgtype(msgtype);
-  return builder_.Finish();
-}
-
-inline flatbuffers::Offset<ACL> CreateACLDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    const char *id = nullptr,
-    SelfMessaging::MsgType msgtype = SelfMessaging::MsgType_MSG,
-    SelfMessaging::ACLCommand command = SelfMessaging::ACLCommand_LIST,
-    const std::vector<uint8_t> *payload = nullptr) {
-  auto id__ = id ? _fbb.CreateString(id) : 0;
-  auto payload__ = payload ? _fbb.CreateVector<uint8_t>(*payload) : 0;
-  return SelfMessaging::CreateACL(
-      _fbb,
-      id__,
-      msgtype,
-      command,
-      payload__);
-}
-
-inline const SelfMessaging::ACL *GetACL(const void *buf) {
-  return flatbuffers::GetRoot<SelfMessaging::ACL>(buf);
-}
-
-inline const SelfMessaging::ACL *GetSizePrefixedACL(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<SelfMessaging::ACL>(buf);
-}
-
-inline bool VerifyACLBuffer(
-    flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<SelfMessaging::ACL>(nullptr);
-}
-
-inline bool VerifySizePrefixedACLBuffer(
-    flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<SelfMessaging::ACL>(nullptr);
-}
-
-inline void FinishACLBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<SelfMessaging::ACL> root) {
-  fbb.Finish(root);
-}
-
-inline void FinishSizePrefixedACLBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<SelfMessaging::ACL> root) {
-  fbb.FinishSizePrefixed(root);
-}
-
-}  // namespace SelfMessaging
-
-#endif  // FLATBUFFERS_GENERATED_ACL_SELFMESSAGING_H_

data/lib/self_msgproto/acl.rb

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

data/test/unit/test_acl.rb

@@ -1,23 +0,0 @@
-require 'minitest/autorun'
-require 'base64'
-require 'self_msgproto'
-
-class TestMessage < Minitest::Test
-
-  include SelfMsg
-
-  def test_new_acl
-    d = Base64.decode64('EAAAAAwAFAAMABMACwAEAAwAAAAQAAAAAAAAARQAAAAAAAAEBwAAAHBheWxvYWQAJAAAADk5NDliMWEzLWRhN2QtNGQzYy05OTMxLTlkYzkzMTJhZWI4YQAAAAA')
-    h = SelfMsg::Acl.new(data: d)
-    p h.id
-    p h.type
-    p h.command
-    p h.payload
-
-    p h.command = SelfMsg::AclCommandPERMIT
-    p h.to_fb
-  end
-
-end
-
-#EAAAAAwAFAAMABMACwAEAAwAAAAQAAAAAAAAAQwAAAAAAAAEAAAAACQAAAA4M2I1Zjg3Zi0yYTYxLTRiM2YtOWU2Zi0yOTk5OTk3ZDdhNDgAAAAA