sysvmq 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d84404b90167dfecfe52eae482a6284f2af9bbc1
-  data.tar.gz: c4b84de9d1fa95c093f953797cd8d794e52e69bb
+  metadata.gz: 7705e20450c90577d603ea17aaedd9b00cb361ae
+  data.tar.gz: 90973d795df822f14ce2c0efad3734d58496802b
 SHA512:
-  metadata.gz: 1ad89cfac4699a9f283024e0a75c2587200196b8e91410c5cdb2e10e70df3612d2887ba5ce92c9a9efc81a2dc76fb757446444ae3038f72cf79b0a1d3a50ebcd
-  data.tar.gz: acdf82f69e86f30542da3f98917c8b2ee75f859222bd7f41905d0d8a749d85070801d6fdb5e663dd0cd3add051b96145cadfa4d6cc0761f50df4aff98038d33e
+  metadata.gz: 582fe7249dc328068fe68811443f96a2c8fa7c89269ac06928452d0f28df875263b6b621919559ec656809f4fec4a155f7c31863d6112ebf6f77c1efb3209174
+  data.tar.gz: 06c5acb4e3d6d7fea2d1feaab25fc0600f2083a4188e80e9acf123df77e3ddff9e49d4480f1936d328c9c57eac3932aaec2a5dbda795cb261addf576d879b691

data/.travis.yml

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

data/README.md

@@ -1,7 +1,21 @@
 # sysvmq
 
-`sysvmq` is a C extension that wraps SysV IPC Message Queues. Only compatible
-with MRI 2.0 and 2.1 currently.
+`sysvmq` is a C extension that wraps SysV IPC Message Queues. It's similar to
+the [POSIX MQ Ruby wrapper](https://github.com/Sirupsen/posix-mqueue). Message
+queues are handy for interprocess communication where you want to be able to
+take down either endpoint easily. The main disadvantage of SysV message queues
+over POSIX MQs (on Linux) is that SysV doesn't expose a file descriptor to do
+e.g. `select(2)` on.
+
+## Installation
+
+Add `sysvm` to your Gemfile.
+
+`gem 'sysvmq'`
+
+Currently known to work on Linux (MRI >= 2.0).
+
+## Usage
 
 ```ruby
 # Create a message queue with a 1024 byte buffer.
@@ -21,6 +35,10 @@ ensure
 mq.destroy
 ```
 
-## Installation
+## Todo
 
-  gem 'sysv-mq', github: "Sirupsen/sysvmq" # until published to rubygems
+* Explain messages types
+* Add named params for flags (e.g. `mq.receive(:front, blocking: false)`)
+  instead of ORing flags directly.
+* Add `IPC_INFO` on Linux
+* Add all of `IPC_STAT`

data/ext/sysvmq.c

@@ -11,12 +11,15 @@
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
+#include <assert.h>
+
+#define UNINITIALIZED_ERROR -2
 
 // 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
@@ -81,7 +84,7 @@ sysvmq_alloc(VALUE klass)
 //
 // 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. 
+// IPC_INFO.
 //
 // TODO: IPC_SET is currently not supported.
 static VALUE
@@ -118,7 +121,7 @@ sysvmq_stats(int argc, VALUE *argv, VALUE self)
   // 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)); 
+  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.
@@ -144,14 +147,16 @@ sysvmq_destroy(VALUE self)
 // This is used for passing values between the `maybe_blocking` function and the
 // Ruby function. There's definitely a better way.
 typedef struct {
+  ssize_t    error;
+  ssize_t    length;
+
   size_t     size;
   int        flags;
-  int        type;
-  size_t     msg_size; // TODO: typelol
+  long       type;
   sysvmq_t*  sysv;
 
   int        retval;
-} 
+}
 sysvmq_blocking_call_t;
 
 // Blocking call to msgsnd(2) (see sysvmq_send). This is to be called without
@@ -160,7 +165,10 @@ 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);
+  arguments->error = msgrcv(arguments->sysv->id, arguments->sysv->msgbuf, arguments->sysv->buffer_size, arguments->type, arguments->flags);
+
+  if (arguments->error >= 0)
+    arguments->length = arguments->error;
 
   return NULL;
 }
@@ -191,26 +199,42 @@ sysvmq_receive(int argc, VALUE *argv, VALUE self)
 
   // 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;
+  blocking.flags  = FIX2INT(flags);
+  blocking.type   = FIX2LONG(type);
+  blocking.sysv   = sysv;
+  // Initialize error so it's never a garbage value, if
+  // `sysvmq_maybe_blocking_receive` was interrupted at a non-nice time.
+  blocking.error  = UNINITIALIZED_ERROR;
+  blocking.length = UNINITIALIZED_ERROR;
+
+  if ((blocking.flags & IPC_NOWAIT) == IPC_NOWAIT) {
+    while(sysvmq_maybe_blocking_receive(&blocking) == NULL && blocking.error < 0) {
+      if (errno == EINTR) {
+        continue;
+      }
+
+      rb_sys_fail("Failed recieving message from queue");
+    }
+  } else {
+    // 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 `length` on `blocking` with the size
+    // of the message returned.
+    while (rb_thread_call_without_gvl(sysvmq_maybe_blocking_receive, &blocking, RUBY_UBF_IO, NULL) == NULL
+            && blocking.error < 0) {
+      if (errno == EINTR || blocking.error == UNINITIALIZED_ERROR) {
+        continue;
+      }
+
+      rb_sys_fail("Failed receiving message from queue");
     }
-
-    rb_sys_fail("Failed receiving message from queue");
   }
 
+  // Guard it..
+  assert(blocking.length != UNINITIALIZED_ERROR);
+
   // Reencode with default external encoding
-  return rb_enc_str_new(sysv->msgbuf->mtext, blocking.retval, rb_default_external_encoding());
+  return rb_enc_str_new(sysv->msgbuf->mtext, blocking.length, rb_default_external_encoding());
 }
 
 // Blocking call to msgsnd(2) (see sysvmq_send). This is to be called without
@@ -219,8 +243,7 @@ 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);
+  arguments->error = msgsnd(arguments->sysv->id, arguments->sysv->msgbuf, arguments->size, arguments->flags);
 
   return NULL;
 }
@@ -257,6 +280,9 @@ sysvmq_send(int argc, VALUE *argv, VALUE self)
   blocking.flags = FIX2INT(flags);
   blocking.size  = RSTRING_LEN(message);
   blocking.sysv  = sysv;
+  // See msgrcv(2) wrapper
+  blocking.error  = UNINITIALIZED_ERROR;
+  blocking.length = UNINITIALIZED_ERROR;
 
   // The buffer can be obtained from `sysvmq_maybe_blocking_send`, instead of
   // passing it, set it directly on the instance struct.
@@ -269,17 +295,27 @@ sysvmq_send(int argc, VALUE *argv, VALUE self)
   // 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;
-    }
+  // Non-blocking call, skip the expensive GVL release/acquire
+  if ((blocking.flags & IPC_NOWAIT) == IPC_NOWAIT) {
+    while(sysvmq_maybe_blocking_send(&blocking) == NULL && blocking.error < 0) {
+      if (errno == EINTR) {
+        continue;
+      }
 
-    rb_sys_fail("Failed sending message to queue");
+      rb_sys_fail("Failed sending message to queue");
+    }
+  } else {
+    // 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_gvl(sysvmq_maybe_blocking_send, &blocking, RUBY_UBF_IO, NULL) == NULL
+            && blocking.error < 0) {
+      if (errno == EINTR || blocking.error == UNINITIALIZED_ERROR) {
+        continue;
+      }
+
+      rb_sys_fail("Failed sending message to queue");
+    }
   }
 
   return message;
@@ -305,8 +341,11 @@ sysvmq_initialize(VALUE self, VALUE key, VALUE buffer_size, VALUE flags)
 
   TypedData_Get_Struct(self, sysvmq_t, &sysvmq_type, sysv);
 
-  // TODO: This probably doesn't hold on all platforms.
-  sysv->key = FIX2LONG(key);
+  // (key_t) is a 32-bit integer (int). It's defined as `int` (at least on OS X
+  // and Linux). However, `FIX2INT()` (from Ruby) will complain if the key is
+  // something in the range 2^31-2^32, because of the sign bit. We use UINT to
+  // trick Ruby, so it won't complain.
+  sysv->key = (key_t) FIX2UINT(key);
 
   while ((sysv->id = msgget(sysv->key, FIX2INT(flags))) < 0) {
     if (errno == EINTR) {
@@ -320,7 +359,7 @@ sysvmq_initialize(VALUE self, VALUE key, VALUE buffer_size, VALUE flags)
   // 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);
+  sysv->buffer_size = (size_t) FIX2LONG(buffer_size + 1);
   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
@@ -346,7 +385,9 @@ void Init_sysvmq()
   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));
+#ifdef __linux__
   rb_define_const(sysvmq, "IPC_INFO",   INT2NUM(IPC_INFO));
+#endif
 
   // Define the SysVMQ class and its methods
   rb_define_alloc_func(sysvmq, sysvmq_alloc);

data/script/compile

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -ex
+
+bundle install
+
+if [[ $1 == "final" ]]; then
+  bundle exec rake compile
+fi

data/script/prepare

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -ex
+
+gem install bundler

data/script/run

@@ -0,0 +1,6 @@
+#!/bin/bash -ex
+
+while true; do
+  echo "Hello World!"
+  sleep 5
+done

data/sysvmq.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "sysvmq"
-  spec.version       = '0.0.1'
+  spec.version       = '0.1.0'
   spec.authors       = ["Simon Eskildsen"]
   spec.email         = ["sirup@sirupsen.com"]
   spec.summary       = %q{Ruby wrapper for SysV Message Queues}

data/test/sysv_mq_test.rb

@@ -111,4 +111,10 @@ class SysVMQTest < MiniTest::Unit::TestCase
     sleep 0.01
     thread.kill
   end
+
+  def test_nonblocking_send_and_receive
+    message = "Hello World"
+    @mq.send(message, 1, SysVMQ::IPC_NOWAIT)
+    assert_equal message, @mq.receive(0, SysVMQ::IPC_NOWAIT)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sysvmq
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Simon Eskildsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-16 00:00:00.000000000 Z
+date: 2014-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,10 +55,7 @@ dependencies:
 description: Ruby wrapper for SysV Message Queues
 email:
 - sirup@sirupsen.com
-executables:
-- coderay
-- pry
-- rake
+executables: []
 extensions:
 - ext/extconf.rb
 extra_rdoc_files: []
@@ -69,11 +66,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/coderay
-- bin/pry
-- bin/rake
 - ext/extconf.rb
 - ext/sysvmq.c
+- script/compile
+- script/prepare
+- script/run
 - sysvmq.gemspec
 - test/sysv_mq_test.rb
 - test/test_helper.rb

data/bin/coderay

@@ -1,16 +0,0 @@
-#!/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

@@ -1,16 +0,0 @@
-#!/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

@@ -1,16 +0,0 @@
-#!/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')