psem 0.0.1 → 0.2.1

checksums.yaml

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

data/ext/psem/psem.c

@@ -5,17 +5,65 @@
 #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;
+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;
+}
+
+#ifdef _WIN32
+   #error Windows not supported
+#elif __APPLE__
+// OSX has this deprecated and removed
+VALUE psem_waitmillis(VALUE self, VALUE rbNum_timeoutMillis) {
+    rb_raise(rb_eRuntimeError, "sem_timedwait() is deprecated on OSX");
+}
+// they also broke sem_getvalue to return 0 no matter what on a path
+// to deprecation
+VALUE psem_get_value(VALUE self) {
+    rb_raise(rb_eRuntimeError, "sem_getvalue() is deprecated on OSX");
+}
+#else
+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) {
+      int err = errno;
+      switch (err) {
+          case ETIMEDOUT:
+              return Qfalse;
+          case EINTR:
+              rb_raise(rb_eRuntimeError, "got interrupted by a signal handler (EINTR)");
+              break;
+          case EINVAL:
+              rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore (EINVAL)");
+              break;
+          default:
+              rb_raise(rb_eRuntimeError, "unknown errno: %d", err);
+      }
+  }
+  return Qtrue;
 }
 
-VALUE psem_unlink(VALUE self, VALUE rbStr_semName)
-{
+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, failed with errno: %d", errno);
+  }
+  return INT2NUM(val);
+}
+#endif
+
+VALUE psem_unlink(VALUE self, VALUE rbStr_semName) {
     Check_Type(rbStr_semName, T_STRING);
 
     // Check length and format of semaphore name
@@ -46,8 +94,7 @@ VALUE psem_unlink(VALUE self, VALUE rbStr_semName)
     return Qtrue;
 }
 
-VALUE psem_exists(VALUE self, VALUE rbStr_semName)
-{
+VALUE psem_exists(VALUE self, VALUE rbStr_semName) {
     Check_Type(rbStr_semName, T_STRING);
 
     // Check length and format of semaphore name
@@ -64,7 +111,8 @@ VALUE psem_exists(VALUE self, VALUE rbStr_semName)
         return Qtrue;
     }
     else {
-        switch (errno) {
+        int err = errno;
+        switch (err) {
             case ENOENT:
                 // Does not exist
                 return Qfalse;
@@ -73,20 +121,19 @@ VALUE psem_exists(VALUE self, VALUE rbStr_semName)
                 return Qtrue;
                 break;
             case ENAMETOOLONG:
-                rb_raise(rb_eRuntimeError, "name was too long");
+                rb_raise(rb_eRuntimeError, "name was too long (ENAMETOOLONG)");
                 break;
             case EINVAL:
-                rb_raise(rb_eRuntimeError, "given name consists only of / and nothing else");
+                rb_raise(rb_eRuntimeError, "name consists only of / and nothing else (EINVAL)");
                 break;
             default:
-                rb_raise(rb_eRuntimeError, "unknown error");
+                rb_raise(rb_eRuntimeError, "unknown errno: %d", err);
         }
     }
     return Qnil;
 }
 
-VALUE psem_initialize(VALUE self, VALUE rbStr_semName, VALUE rbNum_initialValue)
-{
+VALUE psem_initialize(VALUE self, VALUE rbStr_semName, VALUE rbNum_initialValue) {
     Check_Type(rbStr_semName, T_STRING);
     Check_Type(rbNum_initialValue, T_FIXNUM);
 
@@ -108,9 +155,7 @@ VALUE psem_initialize(VALUE self, VALUE rbStr_semName, VALUE rbNum_initialValue)
     // 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);
+        rb_raise(rb_eRuntimeError, "sem_open() failed with errno: %d", errno);
     }
 
     // Set inner
@@ -118,123 +163,84 @@ VALUE psem_initialize(VALUE self, VALUE rbStr_semName, VALUE rbNum_initialValue)
     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)
-{
+VALUE psem_post(VALUE self) {
     sem_t* sem = get_current_semaphore(self);
     if (sem_post(sem) == -1) {
-        switch (errno) {
+        int err = errno;
+        switch (err) {
             case EINVAL:
-                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore");
+                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore (EINVAL)");
                 break;
             case EOVERFLOW:
-                rb_raise(rb_eRuntimeError, "maximum allowable value for a semaphore would be exceeded");
+                rb_raise(rb_eRuntimeError, "maximum allowable value for a semaphore would be exceeded (EOVERFLOW)");
                 break;
             default:
-                rb_raise(rb_eRuntimeError, "unknown error");
+                rb_raise(rb_eRuntimeError, "unknown errno: %d", err);
         }
     }
     return Qnil;
 }
 
-VALUE psem_wait(VALUE self)
-{
+VALUE psem_wait(VALUE self) {
     sem_t* sem = get_current_semaphore(self);
     if (sem_wait(sem) == -1) {
-        switch (errno) {
+        int err = errno;
+        switch (err) {
             case EINTR:
-                rb_raise(rb_eRuntimeError, "got interrupted by a signal handler");
+                rb_raise(rb_eRuntimeError, "got interrupted by a signal handler (EINTR)");
                 break;
             case EINVAL:
-                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore");
+                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore (EINVAL)");
                 break;
             default:
-                rb_raise(rb_eRuntimeError, "unknown error");
+                rb_raise(rb_eRuntimeError, "unknown errno: %d", err);
         }
     }
     return Qtrue;
 }
 
-VALUE psem_trywait(VALUE self)
-{
+VALUE psem_trywait(VALUE self) {
     sem_t* sem = get_current_semaphore(self);
     if (sem_trywait(sem) == -1) {
-        switch (errno) {
+        int err = errno;
+        switch (err) {
             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");
+                rb_raise(rb_eRuntimeError, "got interrupted by a signal handler (EINTR)");
                 break;
             case EINVAL:
-                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore");
+                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore (EINVAL)");
                 break;
             default:
-                rb_raise(rb_eRuntimeError, "unknown error");
+                rb_raise(rb_eRuntimeError, "unknown errno: %d", err);
         }
     }
     return Qtrue;
 }
 
-VALUE psem_close(VALUE self)
-{
+VALUE psem_close(VALUE self) {
     sem_t* sem = get_current_semaphore(self);
     if (sem_close(sem) == -1) {
-        switch (errno) {
+        int err = errno;
+        switch (err) {
             case EINVAL:
-                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore");
+                rb_raise(rb_eRuntimeError, "inner semaphore is not a valid semaphore (EINVAL)");
                 break;
             default:
-                rb_raise(rb_eRuntimeError, "unknown error");
+                rb_raise(rb_eRuntimeError, "unknown errno: %d", err);
         }
     }
     return Qnil;
 }
 
-VALUE psem_get_inner(VALUE self)
-{
+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()
-{
+void Init_psem() {
     VALUE psemClass = rb_define_class("PSem", rb_cObject);
 
     // Initialize (does not change the value of the semaphore if it already exists

metadata

@@ -1,19 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: psem
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Can Selcik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-22 00:00:00.000000000 Z
+date: 2019-02-13 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.
+description: Supports named semaphores both on Linux and OSX. "get_value" and "timedwait"
+  is deprecated on OSX but everything else is functional and safe.
 email: selcik.can@gmail.com
 executables: []
 extensions: