posix-mqueue 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a832068cb72094db986882a2f8799204decdb27d
-  data.tar.gz: 4f7d8fb462a26bcb476a1fc3114e03910d864993
+  metadata.gz: 1ca2c22ede6eec604fc5c61e311fc94036dda433
+  data.tar.gz: b4bc3c44253878f51ebcae0ddd01d34bbdc89068
 SHA512:
-  metadata.gz: 89f33cce3c747f8096af5ac3bc4a872b0162add9e8f6e300975a67ac67c19112f4638954ac48629d15d591d7ca95caad7901b2560d1f23a64399a41f06c34115
-  data.tar.gz: 7a4c6d6466be7c9a508b5dfeee9a7ccd316f1959d54f80e49b9c71f6fcad5e3c3a2dadf312cef00cdd7ef2d09278bb9f2de8dc1438c813f5eaf889021be09b67
+  metadata.gz: 428afcd5fb9521142d0f65f62381deaf83ef21c18d3b702152bcc9869832535f4253c6735876ad87355a06eaa5ccaeae7177a27aeb1357b4151dcc5620124043
+  data.tar.gz: f1653576e2b418a39021bd4618d0b54b2283b6afc5e36f07ce7171233a2095ff802392d0d405fae0b87a4897d44729a6e23a2adb79369fe6bda29ebaf54bfd6d

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/README.md

@@ -9,18 +9,31 @@ offers:
 * Blocking and non-blocking. Listeners block until a message arrives on the
   queue. No polling. Sending messages doesn't block.
 
-Add `gem 'posix-mqueue'` to your favorite Gemfile.
-
-Still WIP. Not stable. Not everything works as promised.
+Add `gem 'posix-mqueue', :git => "git@github.com:Sirupsen/posix-mqueue.git"` to your favorite Gemfile.
 
 ## Usage
 
+### Important notes
+
+1. This will not work on OS X, but on Linux and probably BSD (not tested).
+2. `send` and `receive` block. `timedsend` and `timedreceive` do not.
+3. The default message size is `4096` bytes.
+4. Linux's default queue size is `10` bytes.
+
+Read on for details.
+
+### Example
+
 ```ruby
 require 'posix/mqueue'
 
-m = POSIX::Mqueue.new("/whatever")
+# On Linux the queue name must be prefixed with a slash. Note it is not a file
+# created at `/whatever`. It's just the name of the queue.
+# Set maximum default Linux options. See next section to push those limits.
+# Default options are msgsize: 10 and maxmsg: 4096
+m = POSIX::Mqueue.new("/whatever", msgsize: 10, maxmsg: 8192)
 m.send "hello"
-puts m.receive
+m.receive
 # => "hello"
 
 fork { POSIX::Mqueue.new("/whatever").send("world") }
@@ -29,50 +42,53 @@ fork { POSIX::Mqueue.new("/whatever").send("world") }
 m.receive
 # => "world"
 
-# Deletes the queue and any messages remaining.
-# None in this case. Otherwise the queue will persist till reboot.
-m.unlink
-
 # Queue is now full by default Linux settings, see below on how to increase it.
 10.times { m.send rand(100).to_s }
 
-# #send will block until something is popped off the queue, but timedsend takes
-# timeout arguments (first one is seconds, second is nanoseconds). If you don't
-# want to block on send, pass 0 for both:
+# #size returns the size of the queue
+m.size
+# => 10
+
+# #send will block until something is popped off the now full queue.  
+# timesend takes timeout arguments (first one is seconds, second is
+# nanoseconds). Pass 0 for for both to not block, this is default.
 
 assert_raises POSIX::Mqueue::QueueFull do
-  m.timedsend(0, 0, "I will fail")
+  m.timedsend "I will fail"
 end
 
 # Empty the queue again
 10.times { m.receive }
 
 # Like timedsend, timedreceive takes timeout arguments and will raise
-# POSIX::Mqueue::Queueempty when it would otherwise block
+# POSIX::Mqueue::Queueempty when it would otherwise block.
 assert_raises POSIX::Mqueue::QueueEmpty do
-  m.timedreceive(0, 0)
+  m.timedreceive
 end
 
+# Deletes the queue and any messages remaining.
+# None in this case. If not unlinked, the queue will persist till reboot.
+m.unlink
+
 ```
 
-## mqueue
+### mqueue
 
 Most important information from the manpages, with a little added information
 about the behavior of `posix-mqueue`.
 
-## /proc interfaces
+### /proc interfaces
 
 Linux has some default limits you can easily change.
 
 1. `/proc/sys/fs/mqueue/msg_max`. Contains the maximum number of messages in a
    single queue. Defaults to 10. You should increase that number. `#send` will
-   eventually throw an exception if the queue is full (instead of blocking). It
-   does not do that right now.
+   eventually block if the queue is full. `#timedsend` will throw `QueueFull`.
 2. `/proc/sys/fs/mqueue/msgsize_max`. Maximum size of a single message. Defaults
-   to 8192 bytes. `posix-mqueue` allows up to 4096 bytes. You'll be able to
-   change this, soon!
+   to 8192 bytes. `posix-mqueue` allows up to 4096 bytes. Overwrite this by
+   passing `{maxmsg: 8192}` as the second argument when initializing.
 3. `/proc/sys/fs/mqueue/queues_max`. Maximum number of queues on the system.
-   Defaults to 256. Which is probably enough.
+   Defaults to 256.
 
 ## Virtual filesystem
 

data/Rakefile

@@ -1,5 +1,7 @@
 require "bundler/gem_tasks"
 
+task :default => [:test]
+
 require 'rake/testtask'
 Rake::TestTask.new do |t|
   `cd ext/posix && ruby extconf.rb && make`

data/ext/posix/mqueue.c

@@ -1,5 +1,6 @@
 #include <ruby.h>
 #include <ruby/util.h>
+#include <ruby/io.h>
 
 #include <mqueue.h>
 #include <fcntl.h>
@@ -89,9 +90,15 @@ VALUE posix_mqueue_send(VALUE self, VALUE message)
     rb_raise(rb_eTypeError, "Message must be a string"); 
   }
 
+  rb_io_wait_writable(data->fd);
+
   // TODO: Custom priority
   err = mq_send(data->fd, RSTRING_PTR(message), RSTRING_LEN(message), 10);
 
+  if(err < 0 && errno == EINTR) {
+    err = mq_send(data->fd, RSTRING_PTR(message), RSTRING_LEN(message), 10);
+  }
+
   if (err < 0) {
     rb_sys_fail("Message sending failed, please consult mq_send(3)");
   }
@@ -99,7 +106,7 @@ VALUE posix_mqueue_send(VALUE self, VALUE message)
   return Qtrue;
 }
 
-VALUE posix_mqueue_timedreceive(VALUE self, VALUE seconds, VALUE nanoseconds)
+VALUE posix_mqueue_timedreceive(VALUE self, VALUE args)
 {
   int err;
   mqueue_t* data;
@@ -107,6 +114,11 @@ VALUE posix_mqueue_timedreceive(VALUE self, VALUE seconds, VALUE nanoseconds)
   char *buf;
   struct timespec timeout;
   VALUE str;
+  VALUE seconds = rb_ary_entry(args, 0);
+  VALUE nanoseconds = rb_ary_entry(args, 1);
+
+  if (seconds == Qnil) seconds = INT2FIX(0);
+  if (nanoseconds == Qnil) nanoseconds = INT2FIX(0);
 
   TypedData_Get_Struct(self, mqueue_t, &mqueue_type, data);
 
@@ -115,7 +127,7 @@ VALUE posix_mqueue_timedreceive(VALUE self, VALUE seconds, VALUE nanoseconds)
   }
 
   if (!RB_TYPE_P(nanoseconds, T_FIXNUM)) { 
-    rb_raise(rb_eTypeError, "First argument must be a fixnum"); 
+    rb_raise(rb_eTypeError, "Second argument must be a Fixnum"); 
   }
 
   timeout.tv_sec  = FIX2ULONG(seconds);
@@ -141,28 +153,32 @@ VALUE posix_mqueue_timedreceive(VALUE self, VALUE seconds, VALUE nanoseconds)
   free(buf);
 
   return str;
-  
-  return Qtrue;
 }
 
-VALUE posix_mqueue_timedsend(VALUE self, VALUE seconds, VALUE nanoseconds, VALUE message)
+VALUE posix_mqueue_timedsend(VALUE self, VALUE args)
 {
   int err;
   mqueue_t* data;
   struct timespec timeout;
+  VALUE message = rb_ary_entry(args, 0);
+  VALUE seconds = rb_ary_entry(args, 1);
+  VALUE nanoseconds = rb_ary_entry(args, 2);
+
+  if (seconds == Qnil) seconds = INT2FIX(0);
+  if (nanoseconds == Qnil) nanoseconds = INT2FIX(0);
 
   TypedData_Get_Struct(self, mqueue_t, &mqueue_type, data);
 
-  if (!RB_TYPE_P(seconds, T_FIXNUM)) { 
-    rb_raise(rb_eTypeError, "First argument must be a Fixnum"); 
+  if (!RB_TYPE_P(message, T_STRING)) { 
+    rb_raise(rb_eTypeError, "Message must be a string"); 
   }
 
-  if (!RB_TYPE_P(nanoseconds, T_FIXNUM)) { 
-    rb_raise(rb_eTypeError, "First argument must be a fixnum"); 
+  if (!RB_TYPE_P(seconds, T_FIXNUM)) {
+    rb_raise(rb_eTypeError, "First argument must be a Fixnum"); 
   }
 
-  if (!RB_TYPE_P(message, T_STRING)) { 
-    rb_raise(rb_eTypeError, "Message must be a string"); 
+  if (!RB_TYPE_P(nanoseconds, T_FIXNUM)) { 
+    rb_raise(rb_eTypeError, "Second argument must be a Fixnum"); 
   }
 
   timeout.tv_sec  = FIX2ULONG(seconds);
@@ -172,7 +188,7 @@ VALUE posix_mqueue_timedsend(VALUE self, VALUE seconds, VALUE nanoseconds, VALUE
 
   if (err < 0) {
     if(errno == 110) {
-      rb_raise(rb_cQueueFull, "Queue full, most likely you wanna bump /proc/sys/fs/mqueue/msg_max from the default maximum queue size of 10.");
+      rb_raise(rb_cQueueFull, "Queue full, most likely you want to bump /proc/sys/fs/mqueue/msg_max from the default maximum queue size of 10.");
     } else {
       rb_sys_fail("Message sending failed, please consult mq_send(3)");
     }
@@ -181,6 +197,34 @@ VALUE posix_mqueue_timedsend(VALUE self, VALUE seconds, VALUE nanoseconds, VALUE
   return Qtrue;
 }
 
+VALUE posix_mqueue_size(VALUE self)
+{
+  mqueue_t* data;
+  struct mq_attr queue;
+
+  TypedData_Get_Struct(self, mqueue_t, &mqueue_type, data);
+
+  if (mq_getattr(data->fd, &queue) < 0) {
+    rb_sys_fail("Failed reading queue attributes, please consult mq_getattr(3)");
+  }
+
+  return INT2FIX(queue.mq_curmsgs);
+}
+
+VALUE posix_mqueue_msgsize(VALUE self)
+{
+  mqueue_t* data;
+  struct mq_attr queue;
+
+  TypedData_Get_Struct(self, mqueue_t, &mqueue_type, data);
+
+  if (mq_getattr(data->fd, &queue) < 0) {
+    rb_sys_fail("Failed reading queue attributes, please consult mq_getattr(3)");
+  }
+
+  return INT2FIX(queue.mq_msgsize);
+}
+
 VALUE posix_mqueue_receive(VALUE self)
 {
   int err;
@@ -197,9 +241,14 @@ VALUE posix_mqueue_receive(VALUE self)
   // Make sure the buffer is capable
   buf = (char*)malloc(buf_size);
 
-  // TODO: Specify priority
+  rb_thread_wait_fd(data->fd);
+
   err = mq_receive(data->fd, buf, buf_size, NULL);
 
+  if(err < 0 && errno == EINTR) {
+    err = mq_receive(data->fd, buf, buf_size, NULL);
+  }
+
   if (err < 0) {
     rb_sys_fail("Message retrieval failed, please consult mq_receive(3)");
   }
@@ -210,14 +259,19 @@ VALUE posix_mqueue_receive(VALUE self)
   return str;
 }
 
-VALUE posix_mqueue_initialize(VALUE self, VALUE queue)
+VALUE posix_mqueue_initialize(VALUE self, VALUE args)
 {
-  // TODO: Modify these options from initialize arguments
-  // TODO: Set nonblock and handle error in #push
+  VALUE options = rb_ary_entry(args, 1);
+  if (options == Qnil) options = rb_hash_new();
+
+  int msgsize = FIX2INT(rb_hash_lookup2(options, ID2SYM(rb_intern("msgsize")), INT2FIX(4096)));
+  int maxmsg = FIX2INT(rb_hash_lookup2(options, ID2SYM(rb_intern("maxmsg")), INT2FIX(10)));
+  VALUE queue = rb_ary_entry(args, 0);
+
   struct mq_attr attr = {
     .mq_flags   = 0,          // Flags, 0 or O_NONBLOCK
-    .mq_maxmsg  = 10,         // Max messages in queue
-    .mq_msgsize = 4096,       // Max message size (bytes)
+    .mq_maxmsg  = maxmsg,     // Max messages in queue
+    .mq_msgsize = msgsize,    // Max message size (bytes)
     .mq_curmsgs = 0           // # currently in queue
   };
 
@@ -249,11 +303,13 @@ void Init_mqueue()
   rb_cQueueEmpty = rb_define_class_under(mqueue, "QueueEmpty", rb_eStandardError);
 
   rb_define_alloc_func(mqueue, posix_mqueue_alloc);
-  rb_define_method(mqueue, "initialize", posix_mqueue_initialize, 1);
+  rb_define_method(mqueue, "initialize", posix_mqueue_initialize, -2);
   rb_define_method(mqueue, "send", posix_mqueue_send, 1);
   rb_define_method(mqueue, "receive", posix_mqueue_receive, 0);
-  rb_define_method(mqueue, "timedsend", posix_mqueue_timedsend, 3);
-  rb_define_method(mqueue, "timedreceive", posix_mqueue_timedreceive, 2);
+  rb_define_method(mqueue, "timedsend", posix_mqueue_timedsend, -2);
+  rb_define_method(mqueue, "timedreceive", posix_mqueue_timedreceive, -2);
+  rb_define_method(mqueue, "msgsize", posix_mqueue_msgsize, 0);
+  rb_define_method(mqueue, "size", posix_mqueue_size, 0);
   rb_define_method(mqueue, "unlink", posix_mqueue_unlink, 0);
 }
 

data/lib/posix/mqueue/version.rb

@@ -1,5 +1,5 @@
 module POSIX
   class Mqueue
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

data/test/mqueue_test.rb

@@ -36,26 +36,25 @@ class MqueueTest < MiniTest::Unit::TestCase
   def test_multiple_queues
     @queue.send "hello"
 
-    other = POSIX::Mqueue.new("/other-test-queue")
-    other.send "world"
+    with_queue "/other-test-queue" do |q|
+      q.send "world"
+      assert_equal "world", q.receive
+    end
 
-    assert_equal "world", other.receive
     assert_equal "hello", @queue.receive
-
-    other.unlink
   end
 
   def test_timedsend_raises_exception_instead_of_blocking
-    10.times { @queue.timedsend 0, 0, "walrus" }
+    10.times { @queue.timedsend "walrus", 0, 0 }
 
     assert_raises POSIX::Mqueue::QueueFull do
-      @queue.timedsend(0, 0, "hi")
+      @queue.timedsend("penguin")
     end
   end
 
   def test_timedreceive_raises_exception_instead_of_blocking
     assert_raises POSIX::Mqueue::QueueEmpty do
-      @queue.timedreceive(0, 0)
+      @queue.timedreceive
     end
   end
 
@@ -64,4 +63,47 @@ class MqueueTest < MiniTest::Unit::TestCase
       POSIX::Mqueue.new("notvalid")
     end
   end
+
+  def test_custom_message_size
+    assert_raises Errno::EMSGSIZE do
+      @queue.send('c' * 4097) # one byte too large
+    end
+
+    # Set to the maximum for Linux
+    with_queue "/big-queue", msgsize: 2 ** 13 do |q|
+      assert_equal 2 ** 13, q.msgsiza
+
+      q.send('c' * (2 ** 13))
+    end
+  end
+
+  def test_custom_max_queue_size
+    with_queue "/small-queue", maxmsg: 2 do |q|
+      2.times { q.send "narwhal" }
+
+      assert_raises POSIX::Mqueue::QueueFull do
+        q.timedsend("narwhal", 0, 0)
+      end
+    end
+  end
+
+  def test_count_in_queue
+    assert_equal 0, @queue.size
+
+    @queue.send "first"
+    @queue.send "second"
+    @queue.send "third"
+
+    assert_equal 3, @queue.size
+  end
+
+  private
+  def with_queue(name, options = {})
+    queue = POSIX::Mqueue.new(name, options)
+    begin
+      yield(queue)
+    ensure
+      queue.unlink
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: posix-mqueue
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Simon Eskildsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-01 00:00:00.000000000 Z
+date: 2013-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -47,6 +47,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md