psem 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0cc49a5c2fb863dab11ff27cfc82f6cdbd4522f77438c0a072b166c32baf08dd
+  data.tar.gz: c34963bdefe3a9024520602c4c7f417c9c5df14f2a653519980f530fb60eb458
+SHA512:
+  metadata.gz: 0def52627a77ed1eddea9e58a9a14907de17465f999a92930f3ff3b00735f9372a7b0cd28bae00beb37000c681f4bb5d2356e70da95640fe217191d68ba09ae4
+  data.tar.gz: 38cd4cbb971fd574cb8fa66295c6250b233a120f66b04a46a5e22cc50ee8839d0466128d9a06ea3facdf162b5b8b324c0a14d7c52c4e862a99503919204b9ce9

data/ext/psem/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+have_header 'pthread.h'
+have_header 'semaphore.h'
+
+create_makefile 'psem/psem'

data/ext/psem/psem.c

@@ -0,0 +1,269 @@
+#include "ruby.h"
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <semaphore.h>
+#include <errno.h>
+#include <time.h>
+
+static inline sem_t* get_current_semaphore(VALUE self)
+{
+    sem_t* sem = (sem_t*)rb_ivar_get(self, rb_intern("inner"));
+    if (sem == NULL) {
+        rb_raise(rb_eRuntimeError, "inner semaphore is not initialized");
+    }
+    return sem;
+}
+
+VALUE psem_unlink(VALUE self, VALUE rbStr_semName)
+{
+    Check_Type(rbStr_semName, T_STRING);
+
+    // Check length and format of semaphore name
+    const char* sem_name = StringValueCStr(rbStr_semName);
+    if (sem_name == NULL || strlen(sem_name) < 2 || sem_name[0] != '/') {
+        rb_raise(rb_eRuntimeError, "invalid name. has to be in the format of '/foobar'");
+    }
+    if (strlen(sem_name) > 253) {
+        rb_raise(rb_eRuntimeError, "name cannot be longer than 253 bytes long");
+    }
+
+    // Unlink the semaphore
+    if (sem_unlink(sem_name) == -1) {
+        switch (errno) {
+            case EACCES:
+                rb_raise(rb_eRuntimeError, "you do not have permission to unlink this semaphore");
+                break;
+            case ENAMETOOLONG:
+                rb_raise(rb_eRuntimeError, "name was too long");
+                break;
+            case ENOENT:
+                rb_raise(rb_eRuntimeError, "no semaphore matching the name");
+                break;
+            default:
+                rb_raise(rb_eRuntimeError, "unknown error");
+        }
+    }
+    return Qtrue;
+}
+
+VALUE psem_exists(VALUE self, VALUE rbStr_semName)
+{
+    Check_Type(rbStr_semName, T_STRING);
+
+    // Check length and format of semaphore name
+    const char* sem_name = StringValueCStr(rbStr_semName);
+    if (sem_name == NULL || strlen(sem_name) < 2 || sem_name[0] != '/') {
+        rb_raise(rb_eRuntimeError, "invalid name. has to be in the format of '/foobar'");
+    }
+    if (strlen(sem_name) > 253) {
+        rb_raise(rb_eRuntimeError, "name cannot be longer than 253 bytes long");
+    }
+
+    // Open the sem without O_CREAT flag so if we don't get a SEM_FAILED, it must exist
+    if (sem_open(sem_name, 0) != SEM_FAILED) {
+        return Qtrue;
+    }
+    else {
+        switch (errno) {
+            case ENOENT:
+                // Does not exist
+                return Qfalse;
+            case EACCES:
+                // Exists but above our priv. level
+                return Qtrue;
+                break;
+            case ENAMETOOLONG:
+                rb_raise(rb_eRuntimeError, "name was too long");
+                break;
+            case EINVAL:
+                rb_raise(rb_eRuntimeError, "given name consists only of / and nothing else");
+                break;
+            default:
+                rb_raise(rb_eRuntimeError, "unknown error");
+        }
+    }
+    return Qnil;
+}
+
+VALUE psem_initialize(VALUE self, VALUE rbStr_semName, VALUE rbNum_initialValue)
+{
+    Check_Type(rbStr_semName, T_STRING);
+    Check_Type(rbNum_initialValue, T_FIXNUM);
+
+    // Check length and format of semaphore name
+    const char* sem_name = StringValueCStr(rbStr_semName);
+    if (sem_name == NULL || strlen(sem_name) < 2 || sem_name[0] != '/') {
+        rb_raise(rb_eRuntimeError, "invalid name. has to be in the format of '/foobar'");
+    }
+    if (strlen(sem_name) > 251) {
+        rb_raise(rb_eRuntimeError, "name cannot be longer than 251 bytes long");
+    }
+
+    // Check initial value is positive
+    int initialValue = FIX2INT(rbNum_initialValue);
+    if (initialValue < 0) {
+        rb_raise(rb_eRuntimeError, "semaphores cannot have negative values");
+    }
+
+    // Create the semaphore
+    sem_t* sem = sem_open(sem_name, O_CREAT, strtol("0644", 0, 8), initialValue);
+    if (sem == SEM_FAILED) {
+        char buf[64];
+        snprintf(buf, 64, "sem_open() failed with errno: %d", errno);
+        rb_raise(rb_eRuntimeError, buf);
+    }
+
+    // Set inner
+    rb_ivar_set(self, rb_intern("inner"), (VALUE)sem);
+    return self;
+}
+
+VALUE psem_get_value(VALUE self)
+{
+    sem_t* sem = get_current_semaphore(self);
+    int val = 0xFFFF;
+    if (sem_getvalue(sem, &val) == -1) {
+        rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore");
+    }
+    return INT2NUM(val);
+}
+
+VALUE psem_post(VALUE self)
+{
+    sem_t* sem = get_current_semaphore(self);
+    if (sem_post(sem) == -1) {
+        switch (errno) {
+            case EINVAL:
+                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore");
+                break;
+            case EOVERFLOW:
+                rb_raise(rb_eRuntimeError, "maximum allowable value for a semaphore would be exceeded");
+                break;
+            default:
+                rb_raise(rb_eRuntimeError, "unknown error");
+        }
+    }
+    return Qnil;
+}
+
+VALUE psem_wait(VALUE self)
+{
+    sem_t* sem = get_current_semaphore(self);
+    if (sem_wait(sem) == -1) {
+        switch (errno) {
+            case EINTR:
+                rb_raise(rb_eRuntimeError, "got interrupted by a signal handler");
+                break;
+            case EINVAL:
+                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore");
+                break;
+            default:
+                rb_raise(rb_eRuntimeError, "unknown error");
+        }
+    }
+    return Qtrue;
+}
+
+VALUE psem_trywait(VALUE self)
+{
+    sem_t* sem = get_current_semaphore(self);
+    if (sem_trywait(sem) == -1) {
+        switch (errno) {
+            case EAGAIN:
+                return Qfalse;
+            case EINTR:
+                rb_raise(rb_eRuntimeError, "got interrupted by a signal handler");
+                break;
+            case EINVAL:
+                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore");
+                break;
+            default:
+                rb_raise(rb_eRuntimeError, "unknown error");
+        }
+    }
+    return Qtrue;
+}
+
+VALUE psem_waitmillis(VALUE self, VALUE rbNum_timeoutMillis)
+{
+    Check_Type(rbNum_timeoutMillis, T_FIXNUM);
+
+    int ms = FIX2INT(rbNum_timeoutMillis);
+    struct timespec ts;
+    ts.tv_sec = ms / 1000;
+    ts.tv_nsec = (ms % 1000) * 1000000;
+
+    sem_t* sem = get_current_semaphore(self);
+    if (sem_timedwait(sem, &ts) == -1) {
+        switch (errno) {
+            case ETIMEDOUT:
+                return Qfalse;
+            case EINTR:
+                rb_raise(rb_eRuntimeError, "got interrupted by a signal handler");
+                break;
+            case EINVAL:
+                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore");
+                break;
+            default:
+                rb_raise(rb_eRuntimeError, "unknown error");
+        }
+    }
+    return Qtrue;
+}
+
+VALUE psem_close(VALUE self)
+{
+    sem_t* sem = get_current_semaphore(self);
+    if (sem_close(sem) == -1) {
+        switch (errno) {
+            case EINVAL:
+                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore");
+                break;
+            default:
+                rb_raise(rb_eRuntimeError, "unknown error");
+        }
+    }
+    return Qnil;
+}
+
+VALUE psem_get_inner(VALUE self)
+{
+    // Get inner as size_t type. Primarily for debugging purposes.
+    size_t cast = (size_t)rb_ivar_get(self, rb_intern("inner"));
+    return INT2NUM(cast);
+}
+
+void Init_psem()
+{
+    VALUE psemClass = rb_define_class("PSem", rb_cObject);
+
+    // Initialize (does not change the value of the semaphore if it already exists
+    // If the initial value is important or if the semaphore's presence is important,
+    // they can be accessed via psem_exists.
+    rb_define_method(psemClass, "initialize", psem_initialize, 2);
+
+    // View the inner sem_t pointer as a BigNum for debugging
+    rb_define_method(psemClass, "get_inner", psem_get_inner, 0);
+
+    // Get current value -- nonblocking but in Linux returns the number
+    // of processes/threads waiting on the semaphore as a negative integer
+    // if it has reached zero already.
+    rb_define_method(psemClass, "get_value", psem_get_value, 0);
+
+    // Increment owned
+    rb_define_method(psemClass, "post", psem_post, 0);
+
+    // Decrement owned
+    rb_define_method(psemClass, "wait", psem_wait, 0);
+    rb_define_method(psemClass, "try_wait", psem_trywait, 0);
+    rb_define_method(psemClass, "wait_millis", psem_waitmillis, 1);
+
+    // Unlink owned
+    rb_define_method(psemClass, "close", psem_close, 0);
+
+    // Unlink by name
+    rb_define_singleton_method(psemClass, "unlink", psem_unlink, 1);
+
+    // Check if exists
+    rb_define_singleton_method(psemClass, "exists", psem_exists, 1);
+}

data/lib/psem.rb

@@ -0,0 +1,5 @@
+require 'psem/psem'
+
+class PSem
+  VERSION = '0.0.1'
+end

data/test/psem_test.rb

@@ -0,0 +1,8 @@
+require 'minitest/autorun'
+require 'psem/psem'
+
+class PSemTest < MiniTest::Unit::TestCase
+  def test_sanity
+    assert_equal 'ok', PSem.new.working
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: psem
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Can Selcik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-22 00:00:00.000000000 Z
+dependencies: []
+description: |
+  A named semaphore is identified by a name of the form /somename; that is, a null-terminated string of up to 251 characters consisting of an initial slash, followed by one or more characters, none of which are slashes. Two processes can operate on the same named semaphore by passing the same name to sem_open.
+
+  The sem_open function creates a new named semaphore or opens an existing named semaphore. After the semaphore has been opened, it can be operated on using sem_post and sem_wait. When a process has finished using the semaphore, it can use sem_close to close the semaphore. When all processes have finished using the semaphore, it can be removed from the system using sem_unlink.
+email: selcik.can@gmail.com
+executables: []
+extensions:
+- ext/psem/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/psem/extconf.rb
+- ext/psem/psem.c
+- lib/psem.rb
+- test/psem_test.rb
+homepage: http://rubygems.org/gems/psem
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/canselcik/psem
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.2
+signing_key: 
+specification_version: 4
+summary: A Simple Ruby Gem for POSIX Named Semaphores
+test_files: []