self_msgproto 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 942aa1cdb3405dedc5c909d8a1e78e748e0b0720f7e18ee312ac21ed599bf069
+  data.tar.gz: 6fb51a8cb6df6d3cb4533c249f3cdc6d09085780048b7982c18e5ed218d37a65
+SHA512:
+  metadata.gz: 4293de44b79d15028271c37adc119f13babc823826dede717c89563508b03396fa5ed2a348c47e66f8862d21968d080aaa40884a47bd200ea05dc85a1a941e9a
+  data.tar.gz: 66cbf37d983e27eb422bd9ccfc3f35c141e1035ebc6f9e66967af8c8e369473223ecdba409e94e2c324970977a9b1fab55de4f580449c1fc88c8da51cba0fa7d

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rake/testtask'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new  do |ext|
+  ext.name = "self_msgproto"
+  ext.ext_dir = "ext/self_msgproto"
+  ext.lib_dir = "lib/self_msgproto"
+end
+
+task :test => :compile
+
+Rake::TestTask.new do |t|
+  t.name = :test
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+  t.verbose = true
+end
+
+task :default => :test

data/ext/self_msgproto/acl.cpp

@@ -0,0 +1,108 @@
+#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);
+
+        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"));
+    uint8_t commandint = NUM2INT(commandv);
+
+    ACLCommand command;
+
+    if (commandint < ACLCommand_MIN || commandint > ACLCommand_MAX) {
+        rb_raise(rb_eStandardError, "acl command is invalid");
+    }
+
+    VALUE payloadv = rb_ivar_get(self, rb_intern("@payload"));
+    u_char *payloadstr = (u_char *)RSTRING_PTR(payloadv);
+    long payloadlen = RSTRING_LEN(payloadv);
+
+    flatbuffers::FlatBufferBuilder builder(1024);
+
+    auto id = builder.CreateString(idstr);
+    auto 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);
+    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", acl_initialize, -1);
+    rb_define_method(cAcl, "to_fb", acl_to_fb, 0);
+}
+

data/ext/self_msgproto/auth.cpp

@@ -0,0 +1,107 @@
+#include <iostream>
+#include "rice/rice.hpp"
+#include "flatbuffers/flatbuffers.h"
+#include "msgproto/auth_generated.h"
+
+using namespace SelfMessaging;
+
+VALUE auth_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, "auth data must be kind of String");
+        }
+
+        const uint8_t *data_ptr = (uint8_t *)RSTRING_PTR(data);
+        long data_len = RSTRING_LEN(data);
+
+        auto auth = GetAuth(data_ptr);
+
+        flatbuffers::Verifier verifier(data_ptr, data_len);
+
+        if (!VerifyAuthBuffer(verifier)) {
+            rb_raise(rb_eStandardError, "auth buffer is invalid");
+        }
+
+        auto id = auth->id()->c_str();
+        auto mtype = auth->msgtype();
+        auto token = auth->token()->c_str();
+        auto device = auth->device()->c_str();
+        auto offset = auth->offset();
+
+        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 offsetint = rb_int2inum(offset);
+        rb_ivar_set(self, rb_intern("@offset"), offsetint);
+
+        VALUE tokenstr = rb_str_new(token, std::strlen(token));
+        rb_ivar_set(self, rb_intern("@token"), tokenstr);
+
+        VALUE devicestr = rb_str_new(device, std::strlen(device));
+        rb_ivar_set(self, rb_intern("@device"), devicestr);
+    }
+
+    return self;
+}
+
+VALUE auth_to_fb(VALUE self) 
+{
+    VALUE idv = rb_ivar_get(self, rb_intern("@id"));
+    char *idstr = RSTRING_PTR(idv);
+
+    VALUE tokenv = rb_ivar_get(self, rb_intern("@token"));
+    char *tokenstr = RSTRING_PTR(tokenv);
+
+    VALUE devicev = rb_ivar_get(self, rb_intern("@device"));
+    char *devicestr = RSTRING_PTR(devicev);
+
+    VALUE offsetv = rb_ivar_get(self, rb_intern("@offset"));
+    int64_t offset = NUM2INT(offsetv);
+
+    flatbuffers::FlatBufferBuilder builder(1024);
+
+    auto id = builder.CreateString(idstr);
+    auto token = builder.CreateString(tokenstr);
+    auto device = builder.CreateString(devicestr);
+
+    AuthBuilder auth_builder(builder);
+
+    auth_builder.add_id(id);
+    auth_builder.add_msgtype(MsgType_AUTH);
+    auth_builder.add_token(token);
+    auth_builder.add_device(device);
+    auth_builder.add_offset(offset);
+
+    auto auth = auth_builder.Finish();
+    builder.Finish(auth);
+
+    uint8_t *buf = builder.GetBufferPointer();
+    int size = builder.GetSize();
+
+    VALUE data = rb_str_new((char *)buf, size);
+
+    builder.Release();
+
+    return data;
+}
+
+void auth_init() {
+    VALUE cRubySelfMsg = rb_define_module("SelfMsg");
+    VALUE cAuth = rb_define_class_under(cRubySelfMsg, "Auth", rb_cObject);
+
+    rb_define_method(cAuth, "initialize", auth_initialize, -1);
+    rb_define_method(cAuth, "to_fb", auth_to_fb, 0);
+}
+

data/ext/self_msgproto/extconf.rb

@@ -0,0 +1,11 @@
+require 'mkmf-rice'
+
+$CFLAGS = " -std=c99"
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+pkg_config('flatbuffers')
+
+abort "Missing flatbuffers" unless have_library("flatbuffers")
+
+create_makefile('self_msgproto/self_msgproto')

data/ext/self_msgproto/header.cpp

@@ -0,0 +1,53 @@
+#include <iostream>
+#include "rice/rice.hpp"
+#include "flatbuffers/flatbuffers.h"
+#include "msgproto/header_generated.h"
+
+using namespace SelfMessaging;
+
+VALUE header_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, "header data must be kind of String");
+        }
+
+        const uint8_t *data_ptr = (uint8_t *)RSTRING_PTR(data);
+        long data_len = RSTRING_LEN(data);
+
+        auto hdr = GetHeader(data_ptr);
+
+        flatbuffers::Verifier verifier(data_ptr, data_len);
+
+        if (!VerifyHeaderBuffer(verifier)) {
+            rb_raise(rb_eStandardError, "header buffer is invalid");
+        }
+
+        auto id = hdr->id()->c_str();
+        auto mtype = hdr->msgtype();
+
+        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);
+    }
+
+    return self;
+}
+
+void header_init() {
+    VALUE cRubySelfMsg = rb_define_module("SelfMsg");
+    VALUE cHeader = rb_define_class_under(cRubySelfMsg, "Header", rb_cObject);
+
+    rb_define_method(cHeader, "initialize", header_initialize, -1);
+}
+

data/ext/self_msgproto/message.cpp

@@ -0,0 +1,131 @@
+#include <iostream>
+#include "rice/rice.hpp"
+#include "flatbuffers/flatbuffers.h"
+#include "msgproto/message_generated.h"
+
+using namespace SelfMessaging;
+
+VALUE message_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, "message data must be kind of String");
+        }
+
+        const uint8_t *data_ptr = (uint8_t *)RSTRING_PTR(data);
+        long data_len = RSTRING_LEN(data);
+
+        auto msg = GetMessage(data_ptr);
+
+        flatbuffers::Verifier verifier(data_ptr, data_len);
+
+        if (!VerifyMessageBuffer(verifier)) {
+            rb_raise(rb_eStandardError, "message buffer is invalid");
+        }
+
+        // std::cout << std::strlen(msg->id()->c_str()) << std::endl;
+
+        auto id = msg->id()->c_str();
+        auto mtype = msg->msgtype();
+        auto stype = msg->subtype();
+        auto sender = msg->sender()->c_str();
+        auto recipient = msg->recipient()->c_str();
+        auto ciphertext = msg->ciphertext();
+        auto metadata = msg->metadata();
+
+        auto offset = metadata->offset();
+        auto timestamp = metadata->timestamp();
+
+        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 stypeint = rb_int2inum(stype);
+        rb_ivar_set(self, rb_intern("@subtype"), stypeint);
+
+        VALUE offsetint = rb_int2inum(offset);
+        rb_ivar_set(self, rb_intern("@offset"), offsetint);
+
+        VALUE timestampint = rb_int2inum(timestamp);
+        rb_ivar_set(self, rb_intern("@timestamp"), timestampint);
+
+        VALUE senderstr = rb_str_new(sender, std::strlen(sender));
+        rb_ivar_set(self, rb_intern("@sender"), senderstr);
+
+        VALUE recipientstr = rb_str_new(recipient, std::strlen(recipient));
+        rb_ivar_set(self, rb_intern("@recipient"), recipientstr);
+
+        const u_char *ciphertextdata = ciphertext->data();
+        long ciphertextsize = ciphertext->size();
+
+        VALUE ciphertextstr = rb_str_new((const char *)ciphertextdata, ciphertextsize);
+        rb_ivar_set(self, rb_intern("@ciphertext"), ciphertextstr);
+    }
+
+    return self;
+}
+
+VALUE message_to_fb(VALUE self) 
+{
+    VALUE idv = rb_ivar_get(self, rb_intern("@id"));
+    char *idstr = RSTRING_PTR(idv);
+
+    VALUE senderv = rb_ivar_get(self, rb_intern("@sender"));
+    char *senderstr = RSTRING_PTR(senderv);
+
+    VALUE recipientv = rb_ivar_get(self, rb_intern("@recipient"));
+    char *recipientstr = RSTRING_PTR(recipientv);
+
+    VALUE ciphertextv = rb_ivar_get(self, rb_intern("@ciphertext"));
+    u_char *ciphertextstr = (u_char *)RSTRING_PTR(ciphertextv);
+    long ciphertextlen = RSTRING_LEN(ciphertextv);
+
+    flatbuffers::FlatBufferBuilder builder(1024);
+
+    auto id = builder.CreateString(idstr);
+    auto sender = builder.CreateString(senderstr);
+    auto recipient = builder.CreateString(recipientstr);
+    auto ciphertext = builder.CreateVector(ciphertextstr, ciphertextlen);
+
+    SelfMessaging::Metadata metadata(0, 0);
+
+    MessageBuilder msg_builder(builder);
+
+    msg_builder.add_id(id);
+    msg_builder.add_msgtype(MsgType_MSG);
+    msg_builder.add_sender(sender);
+    msg_builder.add_recipient(recipient);
+    msg_builder.add_ciphertext(ciphertext);
+    msg_builder.add_metadata(&metadata);
+
+    auto msg = msg_builder.Finish();
+    builder.Finish(msg);
+
+    uint8_t *buf = builder.GetBufferPointer();
+    int size = builder.GetSize();
+
+    VALUE data = rb_str_new((char *)buf, size);
+
+    builder.Release();
+
+    return data;
+}
+
+void message_init() {
+    VALUE cRubySelfMsg = rb_define_module("SelfMsg");
+    VALUE cMessage = rb_define_class_under(cRubySelfMsg, "Message", rb_cObject);
+
+    rb_define_method(cMessage, "initialize", message_initialize, -1);
+    rb_define_method(cMessage, "to_fb", message_to_fb, 0);
+}
+

data/ext/self_msgproto/msgproto/acl_generated.h

@@ -0,0 +1,137 @@
+// 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_