ice799-shlock 0.0.2

data/README

@@ -0,0 +1,45 @@
+What is putex ?
+===============
+
+putex is an interproces mutex that uses shared memory (PUTEX = Process mUTEX).
+
+
+Why ?
+=====
+
+If want to synchronize two ruby processes without using those painful file locks, you can use this.
+
+
+Sample Usage:
+=============
+
+process1.rb:
+require 'putex'
+f = Putex.new("/test-mutex")
+f.lock
+puts("locked the mutex once, grabbing lock again to spin-wait; go run process2.rb once locked up...\n")
+f.lock
+puts("got the lock, exiting\n")
+
+
+process2.rb:
+require 'putex'
+f = Putex.new("/text-mutex")
+puts "alive, unlocking"
+f.unlock
+puts "done, exiting"
+f.destroy
+
+
+in your terminal:
+% ruby process1.rb
+
+when it tells you to run process2.rb, in another terminal enter:
+% ruby process2.rb
+
+you should see process2 unlock process1 and allow it to exit.
+
+What's next ?
+=============
+
+Maybe some more process-to-process synchronization primitives?

data/ext/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+if ( (have_library('c', 'shm_open') or
+      have_library('rt', 'shm_open')) and
+     (have_library('pthread', 'pthread_mutex_lock')) and
+     (have_header('pthread.h')))
+   create_makefile ('shlock')
+end

data/ext/shlock.c

@@ -0,0 +1,152 @@
+#define _GNU_SOURCE
+#include "ruby.h"
+#include <sys/types.h>
+#include <pthread.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+struct mutex_info {
+  pthread_mutex_t m;
+  int fd;
+};
+
+struct rwlock_info {
+  pthread_rwlock_t rwlock;
+  int fd;
+};
+
+static int shared_mem_open(const char *name) {
+  int fd = shm_open (name, O_RDWR, S_IRUSR | S_IWUSR);
+  if (fd < 0) {
+    fd = shm_open (name, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+    if (ftruncate(fd, sizeof(struct mutex_info)) == -1) {
+      printf("ftruncate error: %s\n", strerror(errno));
+      return -1;
+    }
+  }
+
+  if (fd < 0) {
+    printf("error: %s\n", strerror(errno));
+    return -1;
+  }
+
+  return fd;
+}
+
+static VALUE rb_putex_new (VALUE self, VALUE name) {
+  struct mutex_info *ms;
+  int fd = shared_mem_open(StringValuePtr(name));
+  if (fd < 0)
+    return Qnil;
+  
+  ms = (struct mutex_info *)mmap(NULL, sizeof(struct mutex_info), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+  if (ms == MAP_FAILED) {
+    printf("mmap error: %s\n", strerror(errno));
+    return Qnil;
+  }
+  ms->fd = fd;
+  fsync(fd);
+  VALUE obj = Data_Wrap_Struct(self, NULL, NULL, ms);
+  return obj;
+}
+
+static VALUE rb_putex_destroy (VALUE self) {
+  struct mutex_info *m;
+  Data_Get_Struct(self, struct mutex_info, m);
+  fsync(m->fd);
+  close(m->fd);
+
+  return Qnil;
+}
+
+static VALUE rb_putex_lock (VALUE self) {
+  struct mutex_info *fs;
+  Data_Get_Struct(self, struct mutex_info, fs);
+  pthread_mutex_lock(&(fs->m));
+
+  return Qnil;
+}
+
+static VALUE rb_putex_unlock (VALUE self) {
+  struct mutex_info *fs;
+  Data_Get_Struct(self, struct mutex_info, fs);
+  pthread_mutex_unlock(&(fs->m));
+
+  return Qnil;
+}
+
+static VALUE rb_rwlock_new (VALUE self, VALUE name) {
+  struct rwlock_info *rws;
+  int fd = shared_mem_open (StringValuePtr(name));
+  if (fd < 0)
+    return Qnil;
+
+  rws = (struct rwlock_info *)mmap(NULL, sizeof(struct rwlock_info), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+  if (rws == MAP_FAILED) {
+    printf("mmap error: %s\n", strerror(errno));
+    return Qnil;
+  }
+  rws->fd = fd;
+  fsync(fd);
+
+  VALUE obj = Data_Wrap_Struct(self, NULL, NULL, rws);
+  return obj;
+}
+
+static VALUE rb_rwlock_destory (VALUE self) {
+  struct rwlock_info *rws;
+  Data_Get_Struct(self, struct rwlock_info, rws);
+  fsync(rws->fd);
+  close(rws->fd);
+
+  return Qnil;
+}
+
+static VALUE rb_rwlock_read_lock (VALUE self) {
+  struct rwlock_info *rws;
+  Data_Get_Struct(self, struct rwlock_info, rws);
+  pthread_rwlock_rdlock(&(rws->rwlock));
+
+  return Qnil;
+}
+
+static VALUE rb_rwlock_write_lock (VALUE self) {
+  struct rwlock_info *rws;
+  Data_Get_Struct (self, struct rwlock_info, rws);
+  pthread_rwlock_wrlock(&(rws->rwlock));
+
+  return Qnil;
+}
+
+static VALUE rb_rwlock_unlock (VALUE self) {
+  struct rwlock_info *rws;
+  Data_Get_Struct (self, struct rwlock_info, rws);
+  int e = pthread_rwlock_unlock(&(rws->rwlock));
+
+  if (e != 0) {
+    printf("error: %d\n", e);
+  }
+  return Qnil;
+}
+
+void Init_shlock() {
+  VALUE shared_lock_module = rb_define_module("Shlock");
+
+  /* Shlock::Putex */
+
+  VALUE putex_class = rb_define_class_under(shared_lock_module, "Putex", rb_cObject);
+  rb_define_singleton_method(putex_class, "new", rb_putex_new, 1);
+  rb_define_method(putex_class, "lock", rb_putex_lock, 0);
+  rb_define_method(putex_class, "unlock", rb_putex_unlock, 0);
+  rb_define_method(putex_class, "destroy", rb_putex_destroy, 0);
+
+  /* Shlock::Prwlock */
+
+  VALUE prwlock_class = rb_define_class_under(shared_lock_module, "Prwlock", rb_cObject);
+  rb_define_singleton_method(prwlock_class, "new", rb_rwlock_new, 1);
+  rb_define_method(prwlock_class, "read_lock", rb_rwlock_read_lock, 0);
+  rb_define_method(prwlock_class, "write_lock", rb_rwlock_write_lock, 0);
+  rb_define_method(prwlock_class, "unlock", rb_rwlock_unlock, 0);
+}

data/shlock.gemspec

@@ -0,0 +1,17 @@
+spec = Gem::Specification.new do |s|
+  s.name = 'shlock'
+  s.version = '0.0.2'
+  s.date = '2009-03-20'
+  s.summary = 'Inter-process synchronization primitives using shared memory'
+  s.email = "ice799@gmail.com"
+  s.homepage = "http://github.com/ice799/putex/tree/master"
+  s.description = "inter-process synchronization primitives using shared memory"
+  s.has_rdoc = false
+  s.authors = ["Joe Damato"]
+  s.extensions = "ext/extconf.rb"
+  s.require_paths << "ext"
+  s.files = ["README",
+             "shlock.gemspec",
+             "ext/shlock.c",
+             "ext/extconf.rb"]
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: ice799-shlock
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Joe Damato
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-20 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: inter-process synchronization primitives using shared memory
+email: ice799@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- README
+- shlock.gemspec
+- ext/shlock.c
+- ext/extconf.rb
+has_rdoc: false
+homepage: http://github.com/ice799/putex/tree/master
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Inter-process synchronization primitives using shared memory
+test_files: []
+