posix-semaphore 0.5

data/README

@@ -0,0 +1,11 @@
+  .. /\
+  ||/ /
+  |  /
+  | /
+ ___  ___  ___ _____  ___ _ ___                      _
+| _ \/ _ \/ __|_ _\ \/ (_|_) __| ___ _ __  __ _ _ __| |_  ___ _ _ ___
+|  _/ (_) \__ \| | >  < _ _\__ \/ -_) '  \/ _` | '_ \ ' \/ _ \ '_/ -_)
+|_|  \___/|___/___/_/\_(_|_)___/\___|_|_|_\__,_| .__/_||_\___/_| \___|
+                                               |_|
+
+Currently only named semaphores are supported.

data/ext/extconf.rb

@@ -0,0 +1,11 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'posix_semaphore_ext'
+
+# The destination
+dir_config(extension_name)
+
+# Do the work
+create_makefile(extension_name)

data/ext/posix-semaphore.c

@@ -0,0 +1,128 @@
+
+#include "ruby.h"
+#include <semaphore.h>
+#include <time.h>
+#include <errno.h>
+
+VALUE mPOSIX = Qnil;
+
+void Init_posix_semaphore_ext();
+VALUE method_sem_open(int argc, VALUE* argv, VALUE self);
+VALUE method_sem_wait(VALUE self, VALUE semid);
+VALUE method_sem_trywait(VALUE self, VALUE semid);
+VALUE method_sem_timedwait(VALUE self, VALUE semid, VALUE timeout);
+VALUE method_sem_post(VALUE self, VALUE semid);
+VALUE method_sem_close(VALUE self, VALUE semid);
+// VALUE method_sem_getvalue(VALUE self, VALUE semid);
+VALUE method_sem_unlink(VALUE self, VALUE semid);
+
+void Init_posix_semaphore_ext() {
+  mPOSIX = rb_define_module("POSIX");
+  rb_define_singleton_method(mPOSIX, "sem_open", method_sem_open, -1);
+  rb_define_singleton_method(mPOSIX, "sem_wait", method_sem_wait, 1);
+  rb_define_singleton_method(mPOSIX, "sem_trywait", method_sem_trywait, 1);
+  rb_define_singleton_method(mPOSIX, "sem_timedwait", method_sem_timedwait, 2);
+  rb_define_singleton_method(mPOSIX, "sem_post", method_sem_post, 1);
+  rb_define_singleton_method(mPOSIX, "sem_close", method_sem_close, 1);
+  // rb_define_singleton_method(mPOSIX, "sem_getvalue", method_sem_getvalue, 1);
+  rb_define_singleton_method(mPOSIX, "sem_unlink", method_sem_unlink, 1);
+}
+
+VALUE method_sem_open(int argc, VALUE *argv, VALUE self) {
+  if (argc < 2 || argc > 4) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..4)", argc);
+  }
+  VALUE name = argv[0];
+  VALUE oflag = argv[1];
+  Check_Type(name, T_STRING);
+  Check_Type(oflag, T_FIXNUM);
+  sem_t* semaphore;
+  
+  if (argc == 2) {
+    semaphore = sem_open(StringValueCStr(name), FIX2INT(oflag));
+  } else {
+    VALUE mode = argv[2];
+    VALUE value;
+    if (argc == 4) {
+      value = argv[3];
+    } else {
+      value = INT2FIX(1);
+    }
+    Check_Type(mode, T_FIXNUM);
+    Check_Type(value, T_FIXNUM);
+    semaphore = sem_open(StringValueCStr(name), FIX2INT(oflag), FIX2INT(mode), FIX2INT(value));
+  }
+  
+  if (semaphore == SEM_FAILED) {
+    rb_sys_fail(0);
+  }
+  
+  return INT2FIX(semaphore);
+}
+
+VALUE method_sem_wait(VALUE self, VALUE semid) {
+  Check_Type(semid, T_FIXNUM);
+  
+  int result = sem_wait((sem_t*) FIX2LONG(semid));
+  if (result < 0) rb_sys_fail(0);
+  
+  return INT2FIX(result);
+}
+
+VALUE method_sem_trywait(VALUE self, VALUE semid) {
+  Check_Type(semid, T_FIXNUM);
+  
+  int result = sem_trywait((sem_t*) FIX2LONG(semid));
+  if (result < 0) rb_sys_fail(0);
+  
+  return INT2FIX(result);
+}
+
+VALUE method_sem_timedwait(VALUE self, VALUE semid, VALUE timeout) {
+  Check_Type(semid, T_FIXNUM);
+  
+  struct timespec ts = rb_time_timespec(timeout);
+  
+  int result = sem_timedwait((sem_t*) FIX2LONG(semid), &ts);
+  if (result < 0) rb_sys_fail(0);
+  
+  return INT2FIX(result);
+}
+
+VALUE method_sem_post(VALUE self, VALUE semid) {
+  Check_Type(semid, T_FIXNUM);
+ 
+  int result = sem_post((sem_t*) FIX2LONG(semid));
+  if (result < 0) rb_sys_fail(0);
+  
+  return INT2FIX(result);
+}
+
+VALUE method_sem_close(VALUE self, VALUE semid) {
+  Check_Type(semid, T_FIXNUM);
+  
+  int result = sem_close((sem_t*) FIX2LONG(semid));
+  if (result < 0) rb_sys_fail(0);
+  
+  return INT2FIX(result);
+}
+
+// diked out, too buggy
+// VALUE method_sem_getvalue(VALUE self, VALUE semid) {
+//   Check_Type(semid, T_FIXNUM);
+//   int sval;
+//   
+//   int result = sem_getvalue((sem_t*) FIX2LONG(semid), &sval);
+//   if (result < 0) rb_sys_fail(0);
+//   
+//   return INT2FIX(sval);
+// }
+
+VALUE method_sem_unlink(VALUE self, VALUE name) {
+  Check_Type(name, T_STRING);
+  
+  int result = sem_unlink(StringValueCStr(name));
+  if (result < 0) rb_sys_fail(0);
+  
+  return INT2FIX(result);
+}

data/lib/posix-semaphore.rb

@@ -0,0 +1,3 @@
+
+require 'posix/semaphore'
+

data/lib/posix/semaphore.rb

@@ -0,0 +1,66 @@
+
+require 'posix_semaphore_ext'
+require 'posix/semaphore/mutex'
+
+module POSIX
+  class Semaphore
+    attr_reader :id, :name
+    
+    def initialize name, mode=File::CREAT, perms=0611, value=1
+      @id = POSIX.sem_open name, mode, perms, value
+      @name = name
+    end
+    
+    def wait timeout=nil
+      if timeout.nil?
+        POSIX.sem_wait @id
+        true
+      else
+        begin
+          if timeout.is_a? Numeric
+            timeout = Time.now + timeout
+          elsif defined? DateTime and timeout.is_a? DateTime
+            timeout = timeout.to_time
+          end
+          POSIX.sem_timedwait @id, timeout
+        rescue Errno::ETIMEDOUT
+          return false
+        rescue 
+        end
+      end
+    end
+    def wait_nonblock
+      POSIX.sem_trywait @id
+    end
+    
+    def post
+      POSIX.sem_post @id
+    end
+    
+    def close
+      POSIX.sem_close @id
+    end
+    def unlink
+      self.class.unlink @name
+    end
+    
+    def self.unlink name
+      POSIX.sem_unlink name
+    end
+    
+    def zero?
+      begin
+        wait_nonblock
+      rescue Errno::EAGAIN
+        return true
+      end
+      post
+      return false
+    end
+    alias locked? zero?
+    
+    def inspect
+      "#<#{self.class.name}:#@id name:#{@name.inspect}>"
+    end
+  end
+end

data/lib/posix/semaphore/mutex.rb

@@ -0,0 +1,51 @@
+
+module POSIX
+  class Semaphore
+    # Mutex provides a simple wrapper to provide a POSIX-based version
+    # of Ruby's built-in Mutex class.
+    # 
+    # All you need to do to switch from using Ruby's Mutex to using this
+    # is change Mutex.new to POSIX::Semaphore::Mutex.new, providing
+    # options that are the same as those to POSIX::Semaphore.new.
+    class Mutex
+      def initialize *args
+        @semaphore = Semaphore.new *args
+        @have_lock = false
+      end
+      
+      def lock *a
+        raise ThreadError, 'this mutex is already locked to us' if @have_lock
+        @semaphore.wait *a
+        @have_lock = true
+      end
+      def locked?
+        @have_lock or @semaphore.locked?
+      end
+      
+      def synchronize *a
+        lock *a
+        begin
+          yield
+        ensure
+          unlock
+        end
+      end
+      
+      def try_lock
+        raise ThreadError, 'this mutex is already locked to us' if @have_lock
+        begin
+          @semaphore.wait_nonblock
+        rescue Errno::EAGAIN
+          return false
+        end
+        return (@have_lock = true)
+      end
+      
+      def unlock
+        @semaphore.post
+        @have_lock = false
+      end
+    end
+  end
+end
+

data/posix-semaphore.gemspec

@@ -0,0 +1,29 @@
+
+Gem::Specification.new do |s|
+  s.name = 'posix-semaphore'
+  s.version = '0.5'
+  
+  s.summary = 'Access to the POSIX semaphore APIs in Ruby'
+  s.description = 'Cross-thread, cross-process synchronisation made tolerably easy'
+  
+  s.homepage = 'http://github.com/dpkendal/posix-semaphore'
+  
+  s.authors = ['David Kendal']
+  
+  s.extensions = ['ext/extconf.rb']
+  s.require_paths = ['lib']
+  
+  s.files = %w{
+    ext
+    ext/extconf.rb
+    ext/posix-semaphore.c
+    lib
+    lib/posix
+    lib/posix/semaphore
+    lib/posix/semaphore/mutex.rb
+    lib/posix/semaphore.rb
+    lib/posix-semaphore.rb
+    posix-semaphore.gemspec
+    README
+  }
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: posix-semaphore
+version: !ruby/object:Gem::Version
+  version: '0.5'
+  prerelease: 
+platform: ruby
+authors:
+- David Kendal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Cross-thread, cross-process synchronisation made tolerably easy
+email: 
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/extconf.rb
+- ext/posix-semaphore.c
+- lib/posix/semaphore/mutex.rb
+- lib/posix/semaphore.rb
+- lib/posix-semaphore.rb
+- posix-semaphore.gemspec
+- README
+homepage: http://github.com/dpkendal/posix-semaphore
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Access to the POSIX semaphore APIs in Ruby
+test_files: []