posix_mq 0.3.1 → 0.4.0

data/README

@@ -109,3 +109,13 @@ don't email the git mailing list or maintainer with posix_mq patches.
 
 All feedback (bug reports, user/development discussion, patches, pull
 requests) go to the mailing list: mailto:ruby.posix.mq@librelist.com
+
+== Mailing List Archives
+
+In addition to the rsync-able archives provided by http://librelist.com/, we
+are also mirrored to
+{Gmane}[http://gmane.org/info.php?group=gmane.comp.lang.ruby.posix-mq.general]
+and maintain our own mbox mirrors downloadable via HTTP.
+
+* nntp://news.gmane.org/gmane.comp.lang.ruby.posix-mq.general
+* http://bogomips.org/ruby_posix_mq/archives/

data/ext/posix_mq/posix_mq.c

@@ -23,7 +23,6 @@
 #elif defined(HAVE___MQ_OSHANDLE) /* FreeBSD */
 #  define MQD_TO_FD(mqd) __mq_oshandle(mqd)
 #else
-#  warning mqd_t is not select()-able on your OS
 #  define MQ_IO_MARK(mq) ((void)(0))
 #  define MQ_IO_SET(mq,val) ((void)(0))
 #endif
@@ -35,7 +34,7 @@
 
 struct posix_mq {
 	mqd_t des;
-	long msgsize;
+	struct mq_attr attr;
 	VALUE name;
 	VALUE thread;
 #ifdef MQD_TO_FD
@@ -127,14 +126,14 @@ struct rw_args {
 /* hope it's there..., TODO: a better version that works in rbx */
 struct timeval rb_time_interval(VALUE);
 
-static struct timespec *convert_timeout(struct timespec *dest, VALUE time)
+static struct timespec *convert_timeout(struct timespec *dest, VALUE t)
 {
 	struct timeval tv, now;
 
-	if (NIL_P(time))
+	if (NIL_P(t))
 		return NULL;
 
-	tv = rb_time_interval(time); /* aggregate return :( */
+	tv = rb_time_interval(t); /* aggregate return :( */
 	gettimeofday(&now, NULL);
 	dest->tv_sec = now.tv_sec + tv.tv_sec;
 	dest->tv_nsec = (now.tv_usec + tv.tv_usec) * 1000;
@@ -147,7 +146,7 @@ static struct timespec *convert_timeout(struct timespec *dest, VALUE time)
 	return dest;
 }
 
-/* runs without GVL */
+/* (may) run without GVL */
 static VALUE xopen(void *ptr)
 {
 	struct open_args *x = ptr;
@@ -187,14 +186,6 @@ static VALUE xrecv(void *ptr)
 	return (VALUE)mq_receive(x->des, x->msg_ptr, x->msg_len, &x->msg_prio);
 }
 
-/* runs without GVL, path resolution may be slow */
-static VALUE xunlink(void *ptr)
-{
-	VALUE name = (VALUE)ptr;
-
-	return (VALUE)mq_unlink(RSTRING_PTR(name));
-}
-
 /* called by GC */
 static void mark(void *ptr)
 {
@@ -227,7 +218,10 @@ static VALUE alloc(VALUE klass)
 	VALUE rv = Data_Make_Struct(klass, struct posix_mq, mark, _free, mq);
 
 	mq->des = MQD_INVALID;
-	mq->msgsize = -1;
+	mq->attr.mq_flags = 0;
+	mq->attr.mq_maxmsg = 0;
+	mq->attr.mq_msgsize = -1;
+	mq->attr.mq_curmsgs = 0;
 	mq->name = Qnil;
 	mq->thread = Qnil;
 	MQ_IO_SET(mq, Qnil);
@@ -358,11 +352,13 @@ static VALUE init(int argc, VALUE *argv, VALUE self)
 		         RSTRING_PTR(rb_inspect(attr)));
 	}
 
-	mq->des = (mqd_t)rb_thread_blocking_region(xopen, &x, RUBY_UBF_IO, 0);
+	mq->des = (mqd_t)xopen(&x);
 	if (mq->des == MQD_INVALID)
 		rb_sys_fail("mq_open");
 
 	mq->name = rb_str_dup(name);
+	if (x.oflags & O_NONBLOCK)
+		mq->attr.mq_flags = O_NONBLOCK;
 
 	return self;
 }
@@ -377,12 +373,11 @@ static VALUE init(int argc, VALUE *argv, VALUE self)
 static VALUE s_unlink(VALUE self, VALUE name)
 {
 	mqd_t rv;
-	void *ptr = (void *)name;
 
 	if (TYPE(name) != T_STRING)
 		rb_raise(rb_eArgError, "argument must be a string");
 
-	rv = (mqd_t)rb_thread_blocking_region(xunlink, ptr, RUBY_UBF_IO, 0);
+	rv = mq_unlink(RSTRING_PTR(name));
 	if (rv == MQD_INVALID)
 		rb_sys_fail("mq_unlink");
 
@@ -403,11 +398,10 @@ static VALUE _unlink(VALUE self)
 {
 	struct posix_mq *mq = get(self, 0);
 	mqd_t rv;
-	void *ptr = (void *)mq->name;
 
 	assert(TYPE(mq->name) == T_STRING && "mq->name is not a string");
 
-	rv = (mqd_t)rb_thread_blocking_region(xunlink, ptr, RUBY_UBF_IO, 0);
+	rv = mq_unlink(RSTRING_PTR(mq->name));
 	if (rv == MQD_INVALID)
 		rb_sys_fail("mq_unlink");
 
@@ -446,7 +440,11 @@ static VALUE _send(int argc, VALUE *argv, VALUE self)
 	x.timeout = convert_timeout(&expire, timeout);
 	x.msg_prio = NIL_P(prio) ? 0 : NUM2UINT(prio);
 
-	rv = (mqd_t)rb_thread_blocking_region(xsend, &x, RUBY_UBF_IO, 0);
+	if (mq->attr.mq_flags & O_NONBLOCK)
+		rv = (mqd_t)xsend(&x);
+	else
+		rv = (mqd_t)rb_thread_blocking_region(xsend, &x,
+		                                      RUBY_UBF_IO, 0);
 	if (rv == MQD_INVALID)
 		rb_sys_fail("mq_send");
 
@@ -471,7 +469,12 @@ static VALUE send0(VALUE self, VALUE buffer)
 	x.timeout = NULL;
 	x.msg_prio = 0;
 
-	rv = (mqd_t)rb_thread_blocking_region(xsend, &x, RUBY_UBF_IO, 0);
+	if (mq->attr.mq_flags & O_NONBLOCK)
+		rv = (mqd_t)xsend(&x);
+	else
+		rv = (mqd_t)rb_thread_blocking_region(xsend, &x,
+		                                      RUBY_UBF_IO, 0);
+
 	if (rv == MQD_INVALID)
 		rb_sys_fail("mq_send");
 
@@ -484,7 +487,7 @@ static VALUE send0(VALUE self, VALUE buffer)
  *	mq.to_io	=> IO
  *
  * Returns an IO.select-able +IO+ object.  This method is only available
- * under Linux and is not intended to be portable.
+ * under Linux and FreeBSD and is not intended to be portable.
  */
 static VALUE to_io(VALUE self)
 {
@@ -498,16 +501,6 @@ static VALUE to_io(VALUE self)
 }
 #endif
 
-static void get_msgsize(struct posix_mq *mq)
-{
-	struct mq_attr attr;
-
-	if (mq_getattr(mq->des, &attr) < 0)
-		rb_sys_fail("mq_getattr");
-
-	mq->msgsize = attr.mq_msgsize;
-}
-
 static VALUE _receive(int wantarray, int argc, VALUE *argv, VALUE self);
 
 /*
@@ -559,25 +552,32 @@ static VALUE _receive(int wantarray, int argc, VALUE *argv, VALUE self)
 	ssize_t r;
 	struct timespec expire;
 
-	if (mq->msgsize < 0)
-		get_msgsize(mq);
+	if (mq->attr.mq_msgsize < 0) {
+		if (mq_getattr(mq->des, &mq->attr) < 0)
+			rb_sys_fail("mq_getattr");
+	}
 
 	rb_scan_args(argc, argv, "02", &buffer, &timeout);
 	x.timeout = convert_timeout(&expire, timeout);
 
 	if (NIL_P(buffer)) {
-		buffer = rb_str_new(0, mq->msgsize);
+		buffer = rb_str_new(0, mq->attr.mq_msgsize);
 	} else {
 		StringValue(buffer);
 		rb_str_modify(buffer);
-		rb_str_resize(buffer, mq->msgsize);
+		rb_str_resize(buffer, mq->attr.mq_msgsize);
 	}
 	OBJ_TAINT(buffer);
 	x.msg_ptr = RSTRING_PTR(buffer);
-	x.msg_len = (size_t)mq->msgsize;
+	x.msg_len = (size_t)mq->attr.mq_msgsize;
 	x.des = mq->des;
 
-	r = (ssize_t)rb_thread_blocking_region(xrecv, &x, RUBY_UBF_IO, 0);
+	if (mq->attr.mq_flags & O_NONBLOCK) {
+		r = (ssize_t)xrecv(&x);
+	} else {
+		r = (ssize_t)rb_thread_blocking_region(xrecv, &x,
+		                                       RUBY_UBF_IO, 0);
+	}
 	if (r < 0)
 		rb_sys_fail("mq_receive");
 
@@ -599,19 +599,18 @@ static VALUE _receive(int wantarray, int argc, VALUE *argv, VALUE self)
 static VALUE getattr(VALUE self)
 {
 	struct posix_mq *mq = get(self, 1);
-	struct mq_attr attr;
 	VALUE astruct;
 	VALUE *ptr;
 
-	if (mq_getattr(mq->des, &attr) < 0)
+	if (mq_getattr(mq->des, &mq->attr) < 0)
 		rb_sys_fail("mq_getattr");
 
 	astruct = rb_struct_alloc_noinit(cAttr);
 	ptr = RSTRUCT_PTR(astruct);
-	ptr[0] = LONG2NUM(attr.mq_flags);
-	ptr[1] = LONG2NUM(attr.mq_maxmsg);
-	ptr[2] = LONG2NUM(attr.mq_msgsize);
-	ptr[3] = LONG2NUM(attr.mq_curmsgs);
+	ptr[0] = LONG2NUM(mq->attr.mq_flags);
+	ptr[1] = LONG2NUM(mq->attr.mq_maxmsg);
+	ptr[2] = LONG2NUM(mq->attr.mq_msgsize);
+	ptr[3] = LONG2NUM(mq->attr.mq_curmsgs);
 
 	return astruct;
 }
@@ -686,7 +685,7 @@ static VALUE name(VALUE self)
 {
 	struct posix_mq *mq = get(self, 0);
 
-	return mq->name;
+	return rb_str_dup(mq->name);
 }
 
 static int lookup_sig(VALUE sig)
@@ -725,10 +724,13 @@ static void thread_notify_fd(union sigval sv)
 	while ((write(fd, "", 1) < 0) && (errno == EINTR || errno == EAGAIN));
 }
 
+/*
+ * TODO: Under Linux, we could just use netlink directly
+ * the same way glibc does...
+ */
 static void setup_notify_io(struct sigevent *not, VALUE io)
 {
-	VALUE fileno = rb_funcall(io, id_fileno, 0, 0);
-	int fd = NUM2INT(fileno);
+	int fd = NUM2INT(rb_funcall(io, id_fileno, 0, 0));
 	pthread_attr_t attr;
 	int e;
 
@@ -738,8 +740,6 @@ static void setup_notify_io(struct sigevent *not, VALUE io)
 		goto err;
 #ifdef PTHREAD_STACK_MIN
 	(void)pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
-#else
-#  warning PTHREAD_STACK_MIN not available,
 #endif
 	not->sigev_notify = SIGEV_THREAD;
 	not->sigev_notify_function = thread_notify_fd;
@@ -824,15 +824,9 @@ static VALUE setnotify(VALUE self, VALUE arg)
  */
 static VALUE getnonblock(VALUE self)
 {
-	struct mq_attr attr;
 	struct posix_mq *mq = get(self, 1);
 
-	if (mq_getattr(mq->des, &attr) < 0)
-		rb_sys_fail("mq_getattr");
-
-	mq->msgsize = attr.mq_msgsize; /* optimization */
-
-	return attr.mq_flags & O_NONBLOCK ? Qtrue : Qfalse;
+	return mq->attr.mq_flags & O_NONBLOCK ? Qtrue : Qfalse;
 }
 
 /*
@@ -846,7 +840,7 @@ static VALUE getnonblock(VALUE self)
  */
 static VALUE setnonblock(VALUE self, VALUE nb)
 {
-	struct mq_attr newattr, oldattr;
+	struct mq_attr newattr;
 	struct posix_mq *mq = get(self, 1);
 
 	if (nb == Qtrue)
@@ -856,10 +850,10 @@ static VALUE setnonblock(VALUE self, VALUE nb)
 	else
 		rb_raise(rb_eArgError, "must be true or false");
 
-	if (mq_setattr(mq->des, &newattr, &oldattr) < 0)
+	if (mq_setattr(mq->des, &newattr, &mq->attr) < 0)
 		rb_sys_fail("mq_setattr");
 
-	mq->msgsize = oldattr.mq_msgsize; /* optimization */
+	mq->attr.mq_flags = newattr.mq_flags;
 
 	return nb;
 }

data/lib/posix_mq.rb

@@ -1,8 +1,8 @@
 # -*- encoding: binary -*-
 class POSIX_MQ
 
-  # version of POSIX_MQ, currently 0.3.1
-  VERSION = '0.3.1'
+  # version of POSIX_MQ, currently 0.4.0
+  VERSION = '0.4.0'
 
   # An analogous Struct to "struct mq_attr" in C.
   # This may be used in arguments for POSIX_MQ.new and
@@ -47,7 +47,7 @@ class POSIX_MQ
     block.arity == 1 or
       raise ArgumentError, "arity of notify block must be 1"
     r, w = IO.pipe
-    thr = Thread.new(r, w, self) do |r, w, mq|
+    self.notify_thread = Thread.new(r, w, self) do |r, w, mq|
       begin
         begin
           r.read(1) or raise Errno::EINTR
@@ -62,10 +62,21 @@ class POSIX_MQ
       end
     end
     self.notify = w
-    self.notify_thread = thr
     nil
   end if RUBY_PLATFORM =~ /linux/
 
+  # There's no point in ever duping a POSIX_MQ object.
+  # All send/receive operations are atomic and only one
+  # native thread may be notified at a time
+  def dup
+    self
+  end
+
+  # There's no point in ever cloning a POSIX_MQ object.
+  # All send/receive operations are atomic and only one
+  # native thread may be notified at a time
+  alias clone dup
+
 end
 
 require 'posix_mq_ext'

data/test/test_posix_mq.rb

@@ -27,6 +27,23 @@ class Test_POSIX_MQ < Test::Unit::TestCase
     assert @mq.closed?
   end
 
+  def test_name_clobber_proof
+    @mq = POSIX_MQ.new(@path, :rw)
+    tmp = @mq.name
+    tmp.freeze
+    assert_nothing_raised { @mq.name.gsub!(/\A/, "foo") }
+    assert_equal tmp, @mq.name
+    assert tmp.object_id != @mq.name.object_id
+  end
+
+  def test_dup_clone
+    @mq = POSIX_MQ.new(@path, :rw)
+    dup = @mq.dup
+    assert_equal @mq.object_id, dup.object_id
+    clone = @mq.clone
+    assert_equal @mq.object_id, clone.object_id
+  end
+
   def test_timed_receive
     interval = 0.01
     @mq = POSIX_MQ.new(@path, :rw)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: posix_mq
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors: 
 - Ruby POSIX MQ hackers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-13 00:00:00 +00:00
+date: 2010-03-13 00:00:00 +00:00
 default_executable: 
 dependencies: []