jlog 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c76ce9ecf9b6d897f60f7905da4f4a7f0d7fac3
+  data.tar.gz: 885cdc3455c73676a3e2c72af8edccb8fca615fc
+SHA512:
+  metadata.gz: e4577db9d3d9bd21d4f0a841143820aadb56871729ae91180ff340127b0718f13afec51d52d0f94d55b3a6dc9dbf568080e6b8abbc0a4c4c9646e918fe50bd5a
+  data.tar.gz: 2912450e7590c18c5416f53c5abfba9935e9456955dc0db47b06313d9f2ad89ddbf6081ae69d2e0ff17b72858ee6f8e3d135048c917bb7bef7aa10a985a9237c

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'pry', require: false
+  gem 'rake-compiler', '~> 0.9'
+  gem 'minitest'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ezekiel Templin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# JLog
+
+Ruby C-bindings for OmniTI Labs' [Jlog](https://github.com/omniti-labs/jlog). Founded upon [work](https://github.com/mbainter/ruby-jlog/) by Mark Bainter (@mbainter.)
+
+> JLog is short for "journaled log" and this package is really an API and implementation that is libjlog. What is libjlog? libjlog is a pure C, very simple durable message queue with multiple subscribers and publishers (both thread and multi-process safe). The basic concept is that publishers can open a log and write messages to it while subscribers open the log and consume messages from it. "That sounds easy." libjlog abstracts away the need to perform log rotation or maintenance by publishing into fixed size log buffers and eliminating old log buffers when there are no more consumers pending.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jlog'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jlog
+
+## Usage
+
+```ruby
+log = Jlog.new('/var/log/logname')
+log.add_subscriber 'LogSubscriber'
+log.close
+
+writer = Jlog::Writer.new('/var/log/logname')
+
+writer.open
+writer.write 'This is the first log message'
+writer.write 'This is the second log message'
+writer.write "This is the third log message, created at #{Time.now}"
+writer.close
+
+reader = Jlog::Reader.new '/var/log/logname'
+reader.open 'LogSubscriber'
+
+first = reader.read
+second = reader.read
+reader.rewind
+
+if reader.read == second
+  puts "Rewind sets log position to last checkpoint."
+end
+
+reader.checkpoint
+
+third = reader.read
+reader.rewind
+third_full = reader.read_message
+
+if third == third_msg[:message]
+  ts = third_msg[:timestamp]
+  puts "#{third} and logged #{Time.at(ts)} (or #{ts} seconds since epoch)"
+end
+
+reader.checkpoint
+reader.close
+```
+
+## Requirements
+
+* [Jlog](https://github.com/omniti-labs/jlog)

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+spec = Gem::Specification.new("jlog.gemspec")
+
+task :test => [:clobber, :compile] do
+  $LOAD_PATH.unshift('lib', 'spec')
+  Dir.glob('./spec/**/*_spec.rb') { |f| require f }
+end
+
+task :default => :test
+task :spec => :test
+
+Rake::ExtensionTask.new do |ext|
+  ext.name = "jlog"
+  ext.ext_dir = "ext/jlog"
+  ext.lib_dir = "lib/jlog"
+  ext.tmp_dir = "tmp"
+  ext.source_pattern = "*.c"
+  ext.config_options << '-Wall'
+  ext.gem_spec = spec
+end

data/ext/jlog/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+have_library('jlog')
+have_header('jlog.h')
+create_makefile('jlog/jlog')

data/ext/jlog/jlog.c

@@ -0,0 +1,590 @@
+#include <ruby.h>
+#include <jlog.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/time.h>
+
+typedef struct {
+   jlog_ctx *ctx;
+   char *path;
+   jlog_id start;
+   jlog_id last;
+   jlog_id prev;
+   jlog_id end;
+   int auto_checkpoint;
+   int error;
+} jlog_obj;
+
+typedef jlog_obj * Jlog;
+typedef jlog_obj * Jlog_Writer;
+typedef jlog_obj * Jlog_Reader;
+
+VALUE cJlog;
+VALUE cJlogWriter;
+VALUE cJlogReader;
+VALUE eJlog;
+
+static VALUE message_sym;
+static VALUE timestamp_sym;
+
+void rJlog_populate_subscribers(VALUE);
+
+void rJlog_mark(Jlog jo) { }
+
+void rJlog_free(Jlog jo) {
+   if(jo->ctx) {
+      jlog_ctx_close(jo->ctx);
+   }
+
+   if(jo->path) {
+      xfree(jo->path);
+   }
+
+   if(jo) {
+     xfree(jo);
+   }
+}
+
+void rJlog_raise(Jlog jo, const char* mess)
+{
+   VALUE e = rb_exc_new2(eJlog, mess);
+   rb_iv_set(e, "error", INT2FIX(jlog_ctx_err(jo->ctx)));
+   rb_iv_set(e, "errstr", rb_str_new2(jlog_ctx_err_string(jo->ctx)));
+   rb_iv_set(e, "errno", INT2FIX(jlog_ctx_errno(jo->ctx)));
+
+   rb_raise(eJlog, "%s: %d %s", mess, jlog_ctx_err(jo->ctx), jlog_ctx_err_string(jo->ctx));
+}
+
+VALUE rJlog_initialize(int argc, VALUE* argv, VALUE klass) 
+{
+   int options;
+   Jlog jo;
+   jlog_id zeroed = {0,0};
+   VALUE path;
+   VALUE optarg;
+   VALUE size;
+
+   rb_scan_args(argc, argv, "12", &path, &optarg, &size);
+
+   if(NIL_P(optarg)) {
+      options = O_CREAT;
+   } else {
+      options = (int)NUM2INT(optarg);
+   }
+
+   if(NIL_P(size)) {
+      size = (size_t)INT2FIX(0);
+   }
+
+   Data_Get_Struct(klass, jlog_obj, jo);
+
+   jo->ctx = jlog_new(StringValuePtr(path));
+   jo->path = strdup(StringValuePtr(path));
+   jo->auto_checkpoint = 0;
+   jo->start = zeroed;
+   jo->prev = zeroed;
+   jo->last = zeroed;
+   jo->end = zeroed;
+
+
+   if(!jo->ctx) {
+      rJlog_free(jo);
+      rb_raise(eJlog, "jlog_new(%s) failed", StringValuePtr(path));
+   }
+
+   if(options & O_CREAT) {
+      if(jlog_ctx_init(jo->ctx) != 0) {
+         if(jlog_ctx_err(jo->ctx) == JLOG_ERR_CREATE_EXISTS) {
+            if(options & O_EXCL) {
+               rJlog_free(jo);
+               rb_raise(eJlog, "file already exists: %s", StringValuePtr(path));
+            }
+         }else {
+            rJlog_raise(jo, "Error initializing jlog");
+         }
+      }
+      jlog_ctx_close(jo->ctx);
+      jo->ctx = jlog_new(StringValuePtr(path));
+      if(!jo->ctx) {
+         rJlog_free(jo);
+         rb_raise(eJlog, "jlog_new(%s) failed after successful init", StringValuePtr(path));
+      }
+      rJlog_populate_subscribers(klass);
+   } 
+
+   if(!jo) { 
+      rb_raise(eJlog, "jo wasn't initialized.");
+   }
+
+   return klass;
+}
+
+static VALUE rJlog_s_alloc(VALUE klass)
+{
+   Jlog jo = ALLOC(jlog_obj);
+
+   return Data_Wrap_Struct(klass, rJlog_mark, rJlog_free, jo);
+}
+
+VALUE rJlog_add_subscriber(int argc, VALUE* argv, VALUE self)
+{
+   VALUE s;
+   VALUE w;
+   unsigned int whence;
+   Jlog jo;
+
+   rb_scan_args(argc, argv, "11", &s, &w);
+
+   if(NIL_P(w)) {
+      whence = 0;
+   } else {
+      whence = NUM2UINT(w);
+   }
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx || jlog_ctx_add_subscriber(jo->ctx, StringValuePtr(s), whence) != 0) {
+      return Qfalse;
+   }
+
+   rJlog_populate_subscribers(self);
+
+   return Qtrue;
+}
+
+
+VALUE rJlog_remove_subscriber(VALUE self, VALUE subscriber)
+{
+   Jlog jo;
+   int res;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+   res = jlog_ctx_remove_subscriber(jo->ctx, StringValuePtr(subscriber));
+   if(!jo || !jo->ctx || res != 0)
+   {
+      return res;
+   }
+
+   rJlog_populate_subscribers(self);
+
+   return Qtrue;
+}
+
+void rJlog_populate_subscribers(VALUE self)
+{
+   char **list;
+   int i;
+   Jlog jo;
+   VALUE subscribers = rb_ary_new();
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx)
+   {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+
+   jlog_ctx_list_subscribers(jo->ctx, &list);
+   for(i=0; list[i]; i++ ) {
+      rb_ary_push(subscribers, rb_str_new2(list[i]));
+   }
+   jlog_ctx_list_subscribers_dispose(jo->ctx, list);
+
+   rb_iv_set(self, "@subscribers", subscribers);
+}
+
+VALUE rJlog_list_subscribers(VALUE self)
+{
+   Jlog jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx)
+   {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+
+   rJlog_populate_subscribers(self);
+
+   return rb_iv_get(self, "@subscribers");
+}
+
+VALUE rJlog_raw_size(VALUE self)
+{
+   size_t size;
+   Jlog jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+   size = jlog_raw_size(jo->ctx);
+
+   return INT2NUM(size);
+}
+
+VALUE rJlog_close(VALUE self)
+{
+   Jlog jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) return Qnil;
+
+   jlog_ctx_close(jo->ctx);
+   jo->ctx = NULL;
+
+   return Qtrue;
+}
+
+VALUE rJlog_inspect(VALUE self)
+{
+   Jlog jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) return Qnil;
+
+   // XXX Fill in inspect call data 
+
+   return Qtrue;
+}
+
+VALUE rJlog_destroy(VALUE self)
+{
+   Jlog jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo) return Qnil;
+
+   rJlog_free(jo);
+
+   return Qtrue;
+}
+
+VALUE rJlog_W_open(VALUE self)
+{
+   Jlog_Writer jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+
+   if(jlog_ctx_open_writer(jo->ctx) != 0) {
+      rJlog_raise(jo, "jlog_ctx_open_writer failed");
+   }
+
+   return Qtrue;
+}
+
+VALUE rJlog_W_write(VALUE self, VALUE msg)
+{
+   int err;
+   Jlog_Writer jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+
+#if !defined(RSTRING_LEN)
+#  define RSTRING_LEN(x) (RSTRING(x)->len)
+#endif
+   err = jlog_ctx_write(jo->ctx, StringValuePtr(msg), (size_t) RSTRING_LEN(msg));
+   if(err != 0) {
+      return Qfalse;
+   } else {
+      return Qtrue;
+   }
+}
+
+
+VALUE rJlog_R_open(VALUE self, VALUE subscriber)
+{
+   Jlog_Reader jo;
+   int err;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+
+   err = jlog_ctx_open_reader(jo->ctx, StringValuePtr(subscriber));
+
+   if(err != 0) {
+      rJlog_raise(jo, "jlog_ctx_open_reader failed");
+   }
+
+   return Qtrue;
+}
+
+
+VALUE rJlog_R_read(VALUE self)
+{
+   const jlog_id epoch = {0, 0};
+   jlog_id cur = {0, 0};
+   jlog_message message;
+   int cnt;
+   Jlog_Reader jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+
+   // If start is unset, read the interval
+   if(jo->error || !memcmp(&jo->start, &epoch, sizeof(jlog_id)))
+   {
+      jo->error = 0;
+      cnt = jlog_ctx_read_interval(jo->ctx, &jo->start, &jo->end);
+      if(cnt == 0 || (cnt == -1 && jlog_ctx_err(jo->ctx) == JLOG_ERR_FILE_OPEN)) {
+         jo->start = epoch;
+         jo->end = epoch;
+         return Qnil;
+      }
+      else if(cnt == -1)
+         rJlog_raise(jo, "jlog_ctx_read_interval_failed");
+   }
+
+   // If last is unset, start at the beginning
+   if(!memcmp(&jo->last, &epoch, sizeof(jlog_id))) {
+      cur = jo->start;
+   } else {
+      // if we've already read the end, return; otherwise advance
+      cur = jo->last;
+      if(!memcmp(&jo->prev, &jo->end, sizeof(jlog_id))) {
+         jo->start = epoch;
+         jo->end = epoch;
+         return Qnil;
+      }
+      jlog_ctx_advance_id(jo->ctx, &jo->last, &cur, &jo->end);
+      if(!memcmp(&jo->last, &cur, sizeof(jlog_id))) {
+            jo->start = epoch;
+            jo->end = epoch;
+            return Qnil;
+      }
+   }
+
+   if(jlog_ctx_read_message(jo->ctx, &cur, &message) != 0) {
+      if(jlog_ctx_err(jo->ctx) == JLOG_ERR_FILE_OPEN) {
+         jo->error = 1;
+         rJlog_raise(jo, "jlog_ctx_read_message failed");
+         return Qnil;
+      }
+
+      // read failed; raise error but recover if read is retried
+      jo->error = 1;
+      rJlog_raise(jo, "read failed");
+   }
+
+   if(jo->auto_checkpoint) {
+      if(jlog_ctx_read_checkpoint(jo->ctx, &cur) != 0)
+         rJlog_raise(jo, "checkpoint failed");
+
+      // must reread the interval after a checkpoint
+      jo->last = epoch;
+      jo->prev = epoch;
+      jo->start = epoch;
+      jo->end = epoch;
+   } else {
+      // update last
+      jo->prev = jo->last;
+      jo->last = cur;
+   }
+
+   return rb_str_new2(message.mess);
+}
+
+VALUE rJlog_R_read_message(VALUE self)
+{
+   const jlog_id epoch = {0, 0};
+   jlog_id cur = {0, 0};
+   jlog_message message;
+   int cnt;
+   double ts;
+   Jlog_Reader jo;
+   VALUE message_hash;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+
+   // If start is unset, read the interval
+   if(jo->error || !memcmp(&jo->start, &epoch, sizeof(jlog_id)))
+   {
+      jo->error = 0;
+      cnt = jlog_ctx_read_interval(jo->ctx, &jo->start, &jo->end);
+      if(cnt == 0 || (cnt == -1 && jlog_ctx_err(jo->ctx) == JLOG_ERR_FILE_OPEN)) {
+         jo->start = epoch;
+         jo->end = epoch;
+         return Qnil;
+      }
+      else if(cnt == -1)
+         rJlog_raise(jo, "jlog_ctx_read_interval_failed");
+   }
+
+   // If last is unset, start at the beginning
+   if(!memcmp(&jo->last, &epoch, sizeof(jlog_id))) {
+      cur = jo->start;
+   } else {
+      // if we've already read the end, return; otherwise advance
+      cur = jo->last;
+      if(!memcmp(&jo->prev, &jo->end, sizeof(jlog_id))) {
+         jo->start = epoch;
+         jo->end = epoch;
+         return Qnil;
+      }
+      jlog_ctx_advance_id(jo->ctx, &jo->last, &cur, &jo->end);
+      if(!memcmp(&jo->last, &cur, sizeof(jlog_id))) {
+            jo->start = epoch;
+            jo->end = epoch;
+            return Qnil;
+      }
+   }
+
+   if(jlog_ctx_read_message(jo->ctx, &cur, &message) != 0) {
+      if(jlog_ctx_err(jo->ctx) == JLOG_ERR_FILE_OPEN) {
+         jo->error = 1;
+         rJlog_raise(jo, "jlog_ctx_read_message failed");
+         return Qnil;
+      }
+
+      // read failed; raise error but recover if read is retried
+      jo->error = 1;
+      rJlog_raise(jo, "read failed");
+   }
+
+   if(jo->auto_checkpoint) {
+      if(jlog_ctx_read_checkpoint(jo->ctx, &cur) != 0)
+         rJlog_raise(jo, "checkpoint failed");
+
+      // must reread the interval after a checkpoint
+      jo->last = epoch;
+      jo->prev = epoch;
+      jo->start = epoch;
+      jo->end = epoch;
+   } else {
+      // update last
+      jo->prev = jo->last;
+      jo->last = cur;
+   }
+
+   ts = message.header->tv_sec+(message.header->tv_usec/1000000.0);
+
+   message_hash = rb_hash_new();
+   rb_hash_aset(message_hash, message_sym, rb_str_new2(message.mess));
+   rb_hash_aset(message_hash, timestamp_sym, rb_float_new(ts));
+
+   
+   return message_hash;
+}
+
+
+VALUE rJlog_R_rewind(VALUE self)
+{
+   Jlog_Reader jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+
+   jo->last = jo->prev;
+
+   return Qtrue;
+}
+
+
+VALUE rJlog_R_checkpoint(VALUE self)
+{
+   jlog_id epoch = { 0, 0 };
+   Jlog_Reader jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+
+   if(memcmp(&jo->last, &epoch, sizeof(jlog_id)))
+   {
+      jlog_ctx_read_checkpoint(jo->ctx, &jo->last);
+
+      // re-read the interval
+      jo->last = epoch;
+      jo->start = epoch;
+      jo->end = epoch;
+   }
+
+   return Qtrue;
+}
+
+
+VALUE rJlog_R_auto_checkpoint(int argc, VALUE *argv, VALUE self)
+{
+   Jlog jo;
+
+   Data_Get_Struct(self, jlog_obj, jo);
+
+   if(!jo || !jo->ctx) {
+      rb_raise(eJlog, "Invalid jlog context");
+   }
+
+   if(argc > 0) {
+      int ac = FIX2INT(argv[0]);
+      jo->auto_checkpoint = ac;
+   }
+
+   return INT2FIX(jo->auto_checkpoint);
+}
+
+
+void Init_jlog(void) {
+   message_sym = ID2SYM(rb_intern("message"));
+   timestamp_sym = ID2SYM(rb_intern("timestamp"));
+
+   cJlog = rb_define_class("Jlog", rb_cObject);
+   cJlogWriter = rb_define_class_under(cJlog, "Writer", cJlog);
+   cJlogReader = rb_define_class_under(cJlog, "Reader", cJlog);
+
+   eJlog = rb_define_class_under(cJlog, "Error", rb_eStandardError);
+
+   rb_define_method(cJlog, "initialize", rJlog_initialize, -1);
+   rb_define_alloc_func(cJlog, rJlog_s_alloc);
+
+   rb_define_method(cJlog, "add_subscriber", rJlog_add_subscriber, -1);
+   rb_define_method(cJlog, "remove_subscriber", rJlog_remove_subscriber, 1);
+   rb_define_method(cJlog, "list_subscribers", rJlog_list_subscribers, 0);
+   rb_define_method(cJlog, "raw_size", rJlog_raw_size, 0);
+   rb_define_method(cJlog, "close", rJlog_close, 0);
+   rb_define_method(cJlog, "destroy", rJlog_destroy, 0);
+   rb_define_method(cJlog, "inspect", rJlog_inspect, 0);
+
+   rb_define_alias(cJlog, "size", "raw_size");
+
+   rb_define_method(cJlogWriter, "initialize", rJlog_initialize, -1);
+   rb_define_alloc_func(cJlogWriter, rJlog_s_alloc);
+
+   rb_define_method(cJlogWriter, "open", rJlog_W_open, 0);
+   rb_define_method(cJlogWriter, "write", rJlog_W_write, 1);
+
+   rb_define_method(cJlogReader, "initialize", rJlog_initialize, -1);
+   rb_define_alloc_func(cJlogReader, rJlog_s_alloc);
+
+   rb_define_method(cJlogReader, "open", rJlog_R_open, 1);
+   rb_define_method(cJlogReader, "read", rJlog_R_read, 0);
+   rb_define_method(cJlogReader, "read_message", rJlog_R_read_message, 0);
+   rb_define_method(cJlogReader, "rewind", rJlog_R_rewind, 0);
+   rb_define_method(cJlogReader, "checkpoint", rJlog_R_checkpoint, 0);
+   rb_define_method(cJlogReader, "auto_checkpoint", rJlog_R_auto_checkpoint, -1);
+}

data/jlog.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jlog/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jlog"
+  spec.version       = Jlog::VERSION
+  spec.authors       = ["Ezekiel Templin", "Tyler McMullen"]
+  spec.email         = ["ezekiel@fastly.com", "tyler@fastly.com"]
+  spec.description   = %q{Ruby C-extension for JLog}
+  spec.summary       = %q{A Ruby C-extenion for using JLog}
+  spec.homepage      = "https://github.com/fastly/jlog-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.extensions    = ['ext/jlog/extconf.rb']
+  spec.test_files    = ["spec"]
+  spec.require_paths = ["lib", "ext"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "minitest", "~> 5.0.8"
+end

data/lib/jlog.rb

@@ -0,0 +1,5 @@
+require "jlog/version"
+require "jlog/jlog"
+
+class Jlog
+end

data/lib/jlog/version.rb

@@ -0,0 +1,3 @@
+class Jlog
+  VERSION = "0.1.0"
+end

data/spec/jlog/reader_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe "Jlog::Reader" do
+  let(:jlog)   { Jlog.new('/tmp/junit.log') }
+  let(:reader) { Jlog::Reader.new('/tmp/junit.log') }
+
+  before do
+    jlog.add_subscriber('TestSub')
+    writer = Jlog::Writer.new('/tmp/junit.log')
+
+    writer.open
+    1.upto(10) do |n|
+      writer.write("Test Unit #{n}")
+    end
+    writer.close
+  end
+
+  it "should be able to access a reader subscribed to a log" do
+    reader.open('TestSub')
+    reader.close
+  end
+
+  it "should read a hash" do
+    reader.open('TestSub')
+    msg = reader.read_message
+    reader.checkpoint
+
+    assert_kind_of String, msg[:message]
+    assert_kind_of Float, msg[:timestamp]
+  end
+
+  it "should read from the proper checkpoint" do
+    reader.open('TestSub')
+    first_entry = reader.read
+    reader.close
+
+    reader = Jlog::Reader.new('/tmp/junit.log')
+    reader.open('TestSub')
+    assert_equal first_entry, reader.read, "Message wasn't appropriately checkpointed"
+    reader.close
+  end
+
+  it "should be able to rewind" do
+    reader.open('TestSub')
+    res1 = reader.read
+    reader.rewind
+    res2 = reader.read
+
+    assert_equal res1, res2, "Messages do not match"
+
+    reader.checkpoint
+    reader.close
+  end
+
+  it "should be able to checkpoint" do
+    reader.open('TestSub')
+    res1 = reader.read
+    reader.checkpoint
+    reader.rewind
+    res2 = reader.read
+
+    refute_equal res1, res2, "Checkpointed messages should not match"
+
+    reader.close
+  end
+end

data/spec/jlog/writer_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'Jlog::Writer' do
+  let(:writer) { Jlog::Writer.new('/tmp/junit.log') }
+
+  it "it should be able to open a log for writing" do
+    assert_kind_of Jlog::Writer, writer, "Jlog::Writer Object creation failed"
+    writer.open
+    writer.close
+  end
+
+  it "should be able to write to an open log" do
+    writer.open
+
+    1.upto(10) do |n|
+      writer.write("Test Unit #{n}")
+    end
+
+    writer.close
+  end
+end

data/spec/jlog_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Jlog' do
+  let(:jlog) { Jlog.new('/tmp/junit.log') }
+
+  it "should work" do
+    assert_kind_of Jlog, jlog, "JLog Object creation failed"
+    jlog.close
+  end
+
+  it "should be able to add subscribers" do
+    jlog.add_subscriber("TestSub")
+    jlog.add_subscriber("TestSubRemove")
+
+    subscribers = jlog.list_subscribers
+    subscribers.delete_if do |sub|
+      sub =~ /^TestSub/
+    end
+
+    assert_equal 0, subscribers.size
+    jlog.close
+  end
+
+  it "should be able to remove subscribers" do
+    jlog.remove_subscriber("TestSubRemove")
+    jlog.close
+
+    jlog = Jlog.new('/tmp/junit.log')
+    jlog.list_subscribers.each do |s|
+      refute_equal "TestSubRemove", s, "Test Subscriber was not removed"
+    end
+    jlog.close
+  end
+
+  it "should be able to see subscribers added by others" do
+    assert_equal 0, jlog.list_subscribers.size
+    new_jlog = Jlog.new('/tmp/junit.log')
+    new_jlog.add_subscriber('NewSubscriber')
+    assert_equal 1, jlog.list_subscribers.size
+    assert_equal 1, new_jlog.list_subscribers.size
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+
+#require File.expand_path('../../lib/jlog', __FILE__)
+require 'jlog'
+
+class Minitest::Spec
+  after do
+    if File.exists?('/tmp/junit.log')
+      system 'rm -rf /tmp/junit.log'
+    end
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: jlog
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ezekiel Templin
+- Tyler McMullen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.8
+description: Ruby C-extension for JLog
+email:
+- ezekiel@fastly.com
+- tyler@fastly.com
+executables: []
+extensions:
+- ext/jlog/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/jlog/extconf.rb
+- ext/jlog/jlog.c
+- jlog.gemspec
+- lib/jlog.rb
+- lib/jlog/version.rb
+- spec/jlog/reader_spec.rb
+- spec/jlog/writer_spec.rb
+- spec/jlog_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/fastly/jlog-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A Ruby C-extenion for using JLog
+test_files: []