posix-mqueue 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43c80748fbbdc131f1949149a5046213b1d8ad4c
-  data.tar.gz: acd93be843908dead256dc96cb4680fa8f045abf
+  metadata.gz: a832068cb72094db986882a2f8799204decdb27d
+  data.tar.gz: 4f7d8fb462a26bcb476a1fc3114e03910d864993
 SHA512:
-  metadata.gz: 764bb288fad4342bcc2bc99c69c5b5b1c12f2ee3f37367f5302f58eb1a8af285e2359fcd88a2c1db7ba4c183d857e87b77cab535285fc355bce47c78819d3427
-  data.tar.gz: 13506b7fabd6bee22da907f807bddd7bbdadc494e0d7a313e86c888048d0a2297e361a0728736763d248ba49b8a7dfcb190167ac6b44854c0d7a62c9af441f38
+  metadata.gz: 89f33cce3c747f8096af5ac3bc4a872b0162add9e8f6e300975a67ac67c19112f4638954ac48629d15d591d7ca95caad7901b2560d1f23a64399a41f06c34115
+  data.tar.gz: 7a4c6d6466be7c9a508b5dfeee9a7ccd316f1959d54f80e49b9c71f6fcad5e3c3a2dadf312cef00cdd7ef2d09278bb9f2de8dc1438c813f5eaf889021be09b67

data/README.md

@@ -28,6 +28,31 @@ fork { POSIX::Mqueue.new("/whatever").send("world") }
 # Blocks until the forked process pushes to the queue
 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:
+
+assert_raises POSIX::Mqueue::QueueFull do
+  m.timedsend(0, 0, "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
+assert_raises POSIX::Mqueue::QueueEmpty do
+  m.timedreceive(0, 0)
+end
+
 ```
 
 ## mqueue
@@ -37,11 +62,14 @@ about the behavior of `posix-mqueue`.
 
 ## /proc interfaces
 
-1. `/proc/sys/fs/mqueue/msg_max`. Contains the maximum number of messages in
-   queue. Defaults to 10. You should increase that number. `#send` will throw an
-   exception if the queue is full (instead of blocking).
+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.
 2. `/proc/sys/fs/mqueue/msgsize_max`. Maximum size of a single message. Defaults
-   to 8192 bytes. `posix-mqueue` defaults to 4096 bytes. You'll be able to
+   to 8192 bytes. `posix-mqueue` allows up to 4096 bytes. You'll be able to
    change this, soon!
 3. `/proc/sys/fs/mqueue/queues_max`. Maximum number of queues on the system.
    Defaults to 256. Which is probably enough.
@@ -51,30 +79,35 @@ about the behavior of `posix-mqueue`.
 The message queue is created as a virtual file system. That means you can mount
 it:
 
-    # sudo mkdir /dev/queue
-    # sudo mount -t mqueue none /dev/queue
+```bash
+# sudo mkdir /dev/queue
+# sudo mount -t mqueue none /dev/queue
+```
 
-Add a queue and a few tasks, count the characters and you'll see it's a total of 19 bytes:
+Add a queue and a few tasks, count the characters (19):
 
-    $ irb
-    > require 'posix/mqueue'
-    => true
-    > m = POSIX::Mqueue.new("/queue")
-    => #<POSIX::Mqueue:0xb8c9fe88>
-    > m.send "narwhal"
-    => true
-    > m.send "walrus"
-    => true
-    > m.send "ponies"
-    => true
-    > exit
+```ruby
+$ irb
+> require 'posix/mqueue'
+=> true
+> m = POSIX::Mqueue.new("/queue")
+=> #<POSIX::Mqueue:0xb8c9fe88>
+> m.send "narwhal"
+=> true
+> m.send "walrus"
+=> true
+> m.send "ponies"
+=> true
+```
 
 Inspect the mounted filesystem:
 
-    $ ls /dev/queue/
-    important  mails  queue
-    $ cat /dev/queue/queue
-    QSIZE:19         NOTIFY:0     SIGNO:0     NOTIFY_PID:0
+```bash
+$ ls /dev/queue/
+important  mails  queue
+$ cat /dev/queue/queue
+QSIZE:19         NOTIFY:0     SIGNO:0     NOTIFY_PID:0
+```
 
 Here `QSIZE` is the bytes of data in the queue. The other flags are about
 notifications which `posix-mqueue` does not support currently, read about them

data/Rakefile

@@ -2,6 +2,7 @@ require "bundler/gem_tasks"
 
 require 'rake/testtask'
 Rake::TestTask.new do |t|
+  `cd ext/posix && ruby extconf.rb && make`
   t.libs << "test"
   t.pattern = "test/**/*_test.rb"
 end

data/ext/posix/mqueue.c

@@ -4,10 +4,14 @@
 #include <mqueue.h>
 #include <fcntl.h>
 #include <errno.h>
+#include <time.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 
+VALUE rb_cQueueFull = Qnil;
+VALUE rb_cQueueEmpty = Qnil;
+
 typedef struct {
   mqd_t fd;
   struct mq_attr attr;
@@ -68,7 +72,7 @@ VALUE posix_mqueue_unlink(VALUE self)
   TypedData_Get_Struct(self, mqueue_t, &mqueue_type, data);
 
   if (mq_unlink(data->queue) == -1) {
-    rb_sys_fail("Message queue unlinking failed");
+    rb_sys_fail("Message queue unlinking failed, please consume mq_unlink(3)");
   }
 
   return Qtrue;
@@ -89,7 +93,89 @@ VALUE posix_mqueue_send(VALUE self, VALUE message)
   err = mq_send(data->fd, RSTRING_PTR(message), RSTRING_LEN(message), 10);
 
   if (err < 0) {
-    rb_sys_fail("Message sending failed");
+    rb_sys_fail("Message sending failed, please consult mq_send(3)");
+  }
+  
+  return Qtrue;
+}
+
+VALUE posix_mqueue_timedreceive(VALUE self, VALUE seconds, VALUE nanoseconds)
+{
+  int err;
+  mqueue_t* data;
+  size_t buf_size;
+  char *buf;
+  struct timespec timeout;
+  VALUE str;
+
+  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(nanoseconds, T_FIXNUM)) { 
+    rb_raise(rb_eTypeError, "First argument must be a fixnum"); 
+  }
+
+  timeout.tv_sec  = FIX2ULONG(seconds);
+  timeout.tv_nsec = FIX2ULONG(nanoseconds);
+
+  buf_size = data->attr.mq_msgsize + 1;
+
+  // Make sure the buffer is capable
+  buf = (char*)malloc(buf_size);
+
+  // TODO: Specify priority
+  err = mq_timedreceive(data->fd, buf, buf_size, NULL, &timeout);
+
+  if (err < 0) {
+    if(errno == 110) {
+      rb_raise(rb_cQueueEmpty, "Queue empty");
+    } else {
+      rb_sys_fail("Message sending failed, please consult mq_send(3)");
+    }
+  }
+
+  str = rb_str_new(buf, err);
+  free(buf);
+
+  return str;
+  
+  return Qtrue;
+}
+
+VALUE posix_mqueue_timedsend(VALUE self, VALUE seconds, VALUE nanoseconds, VALUE message)
+{
+  int err;
+  mqueue_t* data;
+  struct timespec timeout;
+
+  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(nanoseconds, 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"); 
+  }
+
+  timeout.tv_sec  = FIX2ULONG(seconds);
+  timeout.tv_nsec = FIX2ULONG(nanoseconds);
+
+  err = mq_timedsend(data->fd, RSTRING_PTR(message), RSTRING_LEN(message), 10, &timeout);
+
+  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.");
+    } else {
+      rb_sys_fail("Message sending failed, please consult mq_send(3)");
+    }
   }
   
   return Qtrue;
@@ -115,7 +201,7 @@ VALUE posix_mqueue_receive(VALUE self)
   err = mq_receive(data->fd, buf, buf_size, NULL);
 
   if (err < 0) {
-    rb_sys_fail("Message retrieval failed");
+    rb_sys_fail("Message retrieval failed, please consult mq_receive(3)");
   }
 
   str = rb_str_new(buf, err);
@@ -146,10 +232,10 @@ VALUE posix_mqueue_initialize(VALUE self, VALUE queue)
   data->attr = attr;
   data->queue_len = RSTRING_LEN(queue);
   data->queue = ruby_strdup(StringValueCStr(queue));
-  data->fd = mq_open(data->queue, O_CREAT | O_RDWR, S_IRWXU | S_IRWXO | S_IRWXG, &data->attr);
+  data->fd = mq_open(data->queue, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &data->attr);
 
   if (data->fd == (mqd_t)-1) {
-    rb_sys_fail("Failed opening the message queue");
+    rb_sys_fail("Failed opening the message queue, please consult mq_open(3)");
   }
 
   return self;
@@ -159,10 +245,15 @@ void Init_mqueue()
 {
   VALUE posix = rb_define_module("POSIX");
   VALUE mqueue = rb_define_class_under(posix, "Mqueue", rb_cObject);
+  rb_cQueueFull = rb_define_class_under(mqueue, "QueueFull", rb_eStandardError);
+  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, "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, "unlink", posix_mqueue_unlink, 0);
 }
 

data/lib/posix/mqueue/version.rb

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

data/test/mqueue_test.rb

@@ -45,11 +45,23 @@ class MqueueTest < MiniTest::Unit::TestCase
     other.unlink
   end
 
-  # def test_send_raises_exception_instead_of_blocking
-  #   10.times { @queue.send "walrus" }
+  def test_timedsend_raises_exception_instead_of_blocking
+    10.times { @queue.timedsend 0, 0, "walrus" }
 
-  #   assert_raises Exception do
-  #     @queue.send "hi"
-  #   end
-  # end
+    assert_raises POSIX::Mqueue::QueueFull do
+      @queue.timedsend(0, 0, "hi")
+    end
+  end
+
+  def test_timedreceive_raises_exception_instead_of_blocking
+    assert_raises POSIX::Mqueue::QueueEmpty do
+      @queue.timedreceive(0, 0)
+    end
+  end
+
+  def test_errors_when_queue_name_is_not_slash_prefixed
+    assert_raises Errno::EINVAL do
+      POSIX::Mqueue.new("notvalid")
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: posix-mqueue
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Simon Eskildsen