sysvmq 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d84404b90167dfecfe52eae482a6284f2af9bbc1
+  data.tar.gz: c4b84de9d1fa95c093f953797cd8d794e52e69bb
+SHA512:
+  metadata.gz: 1ad89cfac4699a9f283024e0a75c2587200196b8e91410c5cdb2e10e70df3612d2887ba5ce92c9a9efc81a2dc76fb757446444ae3038f72cf79b0a1d3a50ebcd
+  data.tar.gz: acdf82f69e86f30542da3f98917c8b2ee75f859222bd7f41905d0d8a749d85070801d6fdb5e663dd0cd3add051b96145cadfa4d6cc0761f50df4aff98038d33e

data/.gitignore

@@ -0,0 +1,18 @@
+*.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

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sysv-mq.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Simon Eskildsen
+
+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,26 @@
+# sysvmq
+
+`sysvmq` is a C extension that wraps SysV IPC Message Queues. Only compatible
+with MRI 2.0 and 2.1 currently.
+
+```ruby
+# Create a message queue with a 1024 byte buffer.
+require 'sysvmq'
+mq = SysVMQ.new(0xDEADC0DE, 1024, SysVMQ::IPC_CREAT | 0666)
+
+mq.send "Hellø Wårld!"
+assert_equal 1, mq.stats[:count]
+
+assert_equal "Hellø Wårld!", mq.receive
+
+# Raise an exception instead of blocking until a message is available
+mq.receive(0, SysVMQ::IPC_NOWAIT)
+
+ensure
+# Delete queue
+mq.destroy
+```
+
+## Installation
+
+  gem 'sysv-mq', github: "Sirupsen/sysvmq" # until published to rubygems

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new 'sysvmq' do |ext|
+  ext.ext_dir = 'ext/'
+end
+
+task :default => [:compile, :test]
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end

data/bin/coderay

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'coderay' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('coderay', 'coderay')

data/bin/pry

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'pry' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('pry', 'pry')

data/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rake', 'rake')

data/ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+have_header 'sys/ipc.h'
+have_header 'sys/msg.h'
+have_header 'sys/types.h'
+create_makefile 'sysvmq'

data/ext/sysvmq.c

@@ -0,0 +1,358 @@
+#include <ruby.h>
+#include <ruby/util.h>
+#include <ruby/thread.h>
+#include <ruby/io.h>
+
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/msg.h>
+
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+// This is the buffer passed to msg{rcv,snd,ctl}(2)
+typedef struct {
+  long mtype;
+  char mtext[];
+} 
+sysvmq_msgbuf_t;
+
+// Used for rb_thread_wait_for to signal time between EINTR tries
+struct timeval polling_interval;
+
+// C struct linked to all Ruby objects
+typedef struct {
+  key_t             key;
+  int               id;
+  size_t            buffer_size;
+  sysvmq_msgbuf_t*  msgbuf;
+}
+sysvmq_t;
+
+static void
+sysvmq_mark(void *ptr)
+{
+  // noop, no Ruby objects in the internal struct currently
+}
+
+static void
+sysvmq_free(void *ptr)
+{
+  sysvmq_t* sysv = ptr;
+  xfree(sysv->msgbuf);
+  xfree(sysv);
+}
+
+static size_t
+sysvmq_memsize(const void* ptr)
+{
+  const sysvmq_t* sysv = ptr;
+  return sizeof(sysvmq_t) + sizeof(char) * sysv->buffer_size;
+}
+
+static const rb_data_type_t
+sysvmq_type = {
+  "sysvmq_type",
+  {
+    sysvmq_mark,
+    sysvmq_free,
+    sysvmq_memsize
+  }
+};
+
+static VALUE
+sysvmq_alloc(VALUE klass)
+{
+  sysvmq_t* sysv;
+  VALUE obj = TypedData_Make_Struct(klass, sysvmq_t, &sysvmq_type, sysv);
+
+  sysv->key         = 0;
+  sysv->id          = -1;
+  sysv->buffer_size = 0;
+  sysv->msgbuf      = memset(sysv, 0, sizeof(sysvmq_t));
+
+  return obj;
+}
+
+// int msgctl(int msqid, int cmd, struct msqid_ds *buf);
+// http://man7.org/linux/man-pages/man2/msgctl.2.html
+//
+// Controls the queue with IPC_SET, IPC_INFO and IPC_RMID via msgctl(2). When no
+// argument is passed, it'll return the information about the queue from
+// IPC_INFO. 
+//
+// TODO: IPC_SET is currently not supported.
+static VALUE
+sysvmq_stats(int argc, VALUE *argv, VALUE self)
+{
+  struct msqid_ds info;
+  VALUE info_hash;
+  VALUE cmd;
+  sysvmq_t* sysv;
+
+  // Optional argument handling
+  if (argc > 1) {
+    rb_raise(rb_eArgError, "Wrong number of arguments (0..1)");
+  }
+
+  // Default to IPC_STAT
+  cmd = argc == 1 ? argv[0] : INT2FIX(IPC_STAT);
+
+  TypedData_Get_Struct(self, sysvmq_t, &sysvmq_type, sysv);
+
+  // TODO: Does FIX2INT actually perform this check already?
+  Check_Type(cmd, T_FIXNUM);
+
+  while (msgctl(sysv->id, FIX2INT(cmd), &info) < 0) {
+    if (errno == EINTR) {
+      rb_thread_wait_for(polling_interval);
+      continue;
+    }
+    rb_sys_fail("Failed executing msgctl(2) command.");
+  }
+
+  // Map values from struct to a hash
+  // TODO: Add all the fields
+  // TODO: They are probably not ints..
+  info_hash = rb_hash_new();
+  rb_hash_aset(info_hash, ID2SYM(rb_intern("count")),         INT2FIX(info.msg_qnum));
+  rb_hash_aset(info_hash, ID2SYM(rb_intern("maximum_size")), INT2FIX(info.msg_qbytes)); 
+
+  // TODO: Can probably make a better checker here for whether the struct
+  // actually has the member.
+  // TODO: BSD support?
+#ifdef __linux__
+  rb_hash_aset(info_hash, ID2SYM(rb_intern("size")), INT2FIX(info.__msg_cbytes));
+#elif __APPLE__
+  rb_hash_aset(info_hash, ID2SYM(rb_intern("size")), INT2FIX(info.msg_cbytes));
+#endif
+
+  return info_hash;
+}
+
+// Proxies a call with IPC_RMID to `sysvmq_stats` to remove the queue.
+static VALUE
+sysvmq_destroy(VALUE self)
+{
+  VALUE argv[1];
+  argv[0] = INT2FIX(IPC_RMID);
+  return sysvmq_stats(1, argv, self);
+}
+
+// This is used for passing values between the `maybe_blocking` function and the
+// Ruby function. There's definitely a better way.
+typedef struct {
+  size_t     size;
+  int        flags;
+  int        type;
+  size_t     msg_size; // TODO: typelol
+  sysvmq_t*  sysv;
+
+  int        retval;
+} 
+sysvmq_blocking_call_t;
+
+// Blocking call to msgsnd(2) (see sysvmq_send). This is to be called without
+// the GVL, and must therefore not use any Ruby functions.
+static void*
+sysvmq_maybe_blocking_receive(void *args)
+{
+  sysvmq_blocking_call_t* arguments = (sysvmq_blocking_call_t*) args;
+  arguments->retval = msgrcv(arguments->sysv->id, arguments->sysv->msgbuf, arguments->sysv->buffer_size, arguments->type, arguments->flags);
+
+  return NULL;
+}
+
+// ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
+// http://man7.org/linux/man-pages/man2/msgsnd.2.html
+//
+// Receive a message from the message queue.
+VALUE
+sysvmq_receive(int argc, VALUE *argv, VALUE self)
+{
+  VALUE type  = INT2FIX(0);
+  VALUE flags = INT2FIX(0);
+  sysvmq_t* sysv;
+  sysvmq_blocking_call_t blocking;
+
+  if (argc > 2) {
+    rb_raise(rb_eArgError, "Wrong number of arguments (0..2)");
+  }
+
+  if (argc >= 1) type  = argv[0];
+  if (argc == 2) flags = argv[1];
+
+  TypedData_Get_Struct(self, sysvmq_t, &sysvmq_type, sysv);
+
+  Check_Type(type, T_FIXNUM);
+  Check_Type(flags, T_FIXNUM);
+
+  // Attach blocking call parameters to the struct passed to the blocking
+  // function wrapper.
+  blocking.flags = FIX2INT(flags);
+  blocking.type  = FIX2INT(type);
+  blocking.sysv  = sysv;
+
+  // msgrcv(2) can block sending a message, if IPC_NOWAIT is not passed. 
+  // We unlock the GVL waiting for the call so other threads (e.g. signal
+  // handling) can continue to work. Sets `msg_size` on `blocking` with the size
+  // of the message returned.
+  while (rb_thread_call_without_gvl2(sysvmq_maybe_blocking_receive, &blocking, RUBY_UBF_IO, NULL) == NULL
+          && blocking.retval < 0) {
+    if (errno == EINTR) {
+      rb_thread_check_ints();
+      continue;
+    }
+
+    rb_sys_fail("Failed receiving message from queue");
+  }
+
+  // Reencode with default external encoding
+  return rb_enc_str_new(sysv->msgbuf->mtext, blocking.retval, rb_default_external_encoding());
+}
+
+// Blocking call to msgsnd(2) (see sysvmq_send). This is to be called without
+// the GVL, and must therefore not use any Ruby functions.
+static void*
+sysvmq_maybe_blocking_send(void *data)
+{
+  sysvmq_blocking_call_t* arguments = (sysvmq_blocking_call_t*) data;
+
+  arguments->retval = msgsnd(arguments->sysv->id, arguments->sysv->msgbuf, arguments->size, arguments->flags);
+
+  return NULL;
+}
+
+// int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
+// http://man7.org/linux/man-pages/man2/msgsnd.2.html
+//
+// Sends a message to the message queue.
+VALUE
+sysvmq_send(int argc, VALUE *argv, VALUE self)
+{
+  VALUE message;
+  VALUE priority = INT2FIX(1);
+  VALUE flags = INT2FIX(0);
+  sysvmq_blocking_call_t blocking;
+  sysvmq_t* sysv;
+
+  if (argc > 3 || argc == 0) {
+    rb_raise(rb_eArgError, "Wrong number of arguments (1..3)");
+  }
+
+  message  = argv[0];
+  if (argc >= 2) priority = argv[1];
+  if (argc == 3) flags    = argv[2];
+
+  TypedData_Get_Struct(self, sysvmq_t, &sysvmq_type, sysv);
+
+  Check_Type(flags,    T_FIXNUM);
+  Check_Type(priority, T_FIXNUM);
+  // TODO: Call to_s on message if it responds to
+
+  // Attach blocking call parameters to the struct passed to the blocking
+  // function wrapper.
+  blocking.flags = FIX2INT(flags);
+  blocking.size  = RSTRING_LEN(message);
+  blocking.sysv  = sysv;
+
+  // The buffer can be obtained from `sysvmq_maybe_blocking_send`, instead of
+  // passing it, set it directly on the instance struct.
+  sysv->msgbuf->mtype = FIX2INT(priority);
+
+  if (blocking.size > sysv->buffer_size) {
+    rb_raise(rb_eArgError, "Size of message is bigger than buffer size.");
+  }
+
+  // TODO: Can a string copy be avoided?
+  strncpy(sysv->msgbuf->mtext, StringValueCStr(message), blocking.size);
+
+  // msgsnd(2) can block waiting for a message, if IPC_NOWAIT is not passed. 
+  // We unlock the GVL waiting for the call so other threads (e.g. signal
+  // handling) can continue to work.
+  while (rb_thread_call_without_gvl2(sysvmq_maybe_blocking_send, &blocking, RUBY_UBF_IO, NULL) == NULL
+          && blocking.retval < 0) {
+    if (errno == EINTR) {
+      rb_thread_check_ints();
+      continue;
+    }
+
+    rb_sys_fail("Failed sending message to queue");
+  }
+
+  return message;
+}
+
+// int msgget(key_t key, int msgflg);
+// http://man7.org/linux/man-pages/man2/msgget.2.html
+//
+// Instead of calling `msgget` method directly to get the `msgid` (the return
+// value of `msgget`) from Rubyland and pass it around, it's stored internally
+// in a struct only directly accessible from C-land. It's passed to all the
+// other calls that require a `msgid`, for convienence and to share the buffer.
+VALUE
+sysvmq_initialize(VALUE self, VALUE key, VALUE buffer_size, VALUE flags)
+{
+  sysvmq_t* sysv;
+  size_t msgbuf_size;
+
+  // TODO: Also support string keys, so you can pass '0xDEADC0DE'
+  Check_Type(key,   T_FIXNUM);
+  Check_Type(flags, T_FIXNUM);
+  Check_Type(buffer_size, T_FIXNUM);
+
+  TypedData_Get_Struct(self, sysvmq_t, &sysvmq_type, sysv);
+
+  // TODO: This probably doesn't hold on all platforms.
+  sysv->key = FIX2LONG(key);
+
+  while ((sysv->id = msgget(sysv->key, FIX2INT(flags))) < 0) {
+    if (errno == EINTR) {
+      rb_thread_wait_for(polling_interval); // TODO: Really necessary here?
+      continue;
+    }
+    rb_sys_fail("Failed opening the message queue.");
+  }
+
+  // Allocate the msgbuf buffer once for the instance, to not allocate a buffer
+  // for each message sent. This makes SysVMQ not thread-safe (requiring a
+  // buffer for each thread), but is a reasonable trade-off for now for the
+  // performance.
+  sysv->buffer_size = FIX2INT(buffer_size);
+  msgbuf_size = sysv->buffer_size * sizeof(char) + sizeof(long);
+
+  // Note that this is a zero-length array, so we size the struct to size of the
+  // header (long, the mtype) and then the rest of the space for message buffer.
+  sysv->msgbuf = (sysvmq_msgbuf_t*) xmalloc(msgbuf_size);
+
+  return self;
+}
+
+void Init_sysvmq()
+{
+  VALUE sysvmq = rb_define_class("SysVMQ", rb_cObject);
+
+  // Waiting between blocking calls that have been interrupted outside the GVL,
+  // this is to allow time for signal handlers to process signals.
+  polling_interval.tv_sec  = 0;
+  polling_interval.tv_usec = 5;
+
+  // Define platform specific constants from headers
+  rb_define_const(sysvmq, "IPC_CREAT",  INT2NUM(IPC_CREAT));
+  rb_define_const(sysvmq, "IPC_EXCL",   INT2NUM(IPC_EXCL));
+  rb_define_const(sysvmq, "IPC_NOWAIT", INT2NUM(IPC_NOWAIT));
+  rb_define_const(sysvmq, "IPC_RMID",   INT2NUM(IPC_RMID));
+  rb_define_const(sysvmq, "IPC_SET",    INT2NUM(IPC_SET));
+  rb_define_const(sysvmq, "IPC_STAT",   INT2NUM(IPC_STAT));
+  rb_define_const(sysvmq, "IPC_INFO",   INT2NUM(IPC_INFO));
+
+  // Define the SysVMQ class and its methods
+  rb_define_alloc_func(sysvmq, sysvmq_alloc);
+  rb_define_method(sysvmq, "initialize", sysvmq_initialize, 3);
+  rb_define_method(sysvmq, "send",       sysvmq_send,    -1);
+  rb_define_method(sysvmq, "receive",    sysvmq_receive, -1);
+  rb_define_method(sysvmq, "stats",      sysvmq_stats,   -1);
+  rb_define_method(sysvmq, "destroy",    sysvmq_destroy, 0);
+}

data/sysvmq.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "sysvmq"
+  spec.version       = '0.0.1'
+  spec.authors       = ["Simon Eskildsen"]
+  spec.email         = ["sirup@sirupsen.com"]
+  spec.summary       = %q{Ruby wrapper for SysV Message Queues}
+  spec.description   = %q{Ruby wrapper for SysV Message Queues}
+  spec.homepage      = "https://github.com/Sirupsen/sysvmq"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/extconf.rb"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler", "~> 0.9"
+end

data/test/sysv_mq_test.rb

@@ -0,0 +1,114 @@
+require_relative 'test_helper'
+
+class SysVMQTest < MiniTest::Unit::TestCase
+  def setup
+    @size = 1024
+    @mq = SysVMQ.new(0xDEADC0DE, @size, SysVMQ::IPC_CREAT | 0666)
+  end
+
+  def teardown
+    @mq.destroy
+  end
+
+  def test_send_message
+    @mq.send("Hello world")
+  end
+
+  def test_send_and_receive_message
+    message = "Hello World"
+    @mq.send message
+    assert_equal message, @mq.receive
+  end
+
+  def test_send_and_count_message
+    @mq.send "test"
+    assert_equal 1, @mq.stats[:count]
+    @mq.send "test"
+    assert_equal 2, @mq.stats[:count]
+  end
+
+  def test_send_and_receive_many_times
+    many = 100_000
+    message = "Hello World"
+
+    many.times do
+      @mq.send message
+      assert_equal message, @mq.receive
+    end
+  end
+
+  def test_sends_and_receives_utf8
+    message = "simån hørup"
+    @mq.send message
+    assert_equal message, @mq.receive
+  end
+
+  def test_sending_5_bytes_should_report_5_byte_queue
+    message = "B" * 5
+    @mq.send message
+    assert_equal 5, @mq.stats[:size]
+  end
+
+  def test_sending_utf_should_report_correct_size_queue
+    message = "ø" * 5
+    @mq.send message
+    assert_equal "ø".bytes.size * 5, @mq.stats[:size]
+  end
+
+  def test_receive_on_empty_queue_raises_enomsg_if_ipc_nowait
+    assert_raises Errno::ENOMSG do
+      @mq.receive(0, SysVMQ::IPC_NOWAIT)
+    end
+  end
+
+  def test_send_and_receive_empty_message
+    @mq.send ""
+    assert_equal "", @mq.receive
+  end
+
+  def test_allow_multiple_queues_with_different_sizes
+    mq2 = SysVMQ.new(0xDEADCAFE, 2048, SysVMQ::IPC_CREAT | 0660)
+    mq2.send("B" * 2048)
+    mq2.destroy
+  end
+
+  def test_send_and_receive_with_type
+    @mq.send("10", 10)
+    @mq.send("5", 5)
+
+    assert_equal "5", @mq.receive(5)
+    assert_equal "10", @mq.receive(10)
+  end
+
+  def test_send_and_receive_with_negative_type
+    @mq.send("10", 10)
+    @mq.send("5", 5)
+
+    assert_equal "5", @mq.receive(-7)
+    assert_equal "10", @mq.receive(-10)
+  end
+
+  def test_responds_to_sigint
+    pid = fork { 
+      begin
+        mq = SysVMQ.new(0xDEADCAFE, 2048, SysVMQ::IPC_CREAT | 0660)
+        mq.receive
+      rescue Interrupt
+        mq.destroy
+      end
+    }
+    sleep 0.01
+    Process.kill(:SIGINT, pid)
+    Process.wait(pid)
+  end
+
+  def test_kills_thread_cleanly
+    thread = Thread.new {
+      mq = SysVMQ.new(0xDEADCAFE, 2048, SysVMQ::IPC_CREAT | 0660)
+      mq.receive
+    }
+
+    sleep 0.01
+    thread.kill
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'sysvmq'

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: sysvmq
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Simon Eskildsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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
+  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.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Ruby wrapper for SysV Message Queues
+email:
+- sirup@sirupsen.com
+executables:
+- coderay
+- pry
+- rake
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/coderay
+- bin/pry
+- bin/rake
+- ext/extconf.rb
+- ext/sysvmq.c
+- sysvmq.gemspec
+- test/sysv_mq_test.rb
+- test/test_helper.rb
+homepage: https://github.com/Sirupsen/sysvmq
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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.0
+signing_key: 
+specification_version: 4
+summary: Ruby wrapper for SysV Message Queues
+test_files:
+- test/sysv_mq_test.rb
+- test/test_helper.rb