semian 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5952a089360c3f99f037dd49e4bfdec80e010d3b
-  data.tar.gz: e1862220b675cba619fdddbdde1cccce6c24cd87
+  metadata.gz: '084b4a21e0290cba65079b0490496da902f49b4c'
+  data.tar.gz: 07b2fda101604725efad2e5b9c6d478af5792b6b
 SHA512:
-  metadata.gz: 4d6024b8df7dd42b1a6eb517cb8619c8138f20074529a0ffb1f7181dd5d81f9cdeeb9e2b7752ca7d234f400de2880a1d84ff592affc8f92806e2ce15f6d72f28
-  data.tar.gz: c7f64858fb8fc83a51b6f43a729cdc2dab9f24633c2a9016b50f3be945921de2893f9bea0eec4ae8419577eb715f108e70bae45ab44134be96b7161e75b6743b
+  metadata.gz: 3c351bf24c90d6ccd7b4b15e055451543d218608f663dc229b99fd533a06f731606ecabf93a101f206938b7f39113d447dbb35b234a5ba6b31d603154b1e3c06
+  data.tar.gz: cc23e70d1c25cb10ed075a35b1f184caf07d5c5939e98ad5412cfd4da5a36bb5364811e46e020fbe2a56d93036cf3c0606e14d975519aca3bc391d5d6195a43f

data/ext/semian/extconf.rb

@@ -25,7 +25,7 @@ have_func 'rb_thread_call_without_gvl'
 
 $CFLAGS = "-D_GNU_SOURCE -Werror -Wall "
 if ENV.key?('DEBUG')
-  $CFLAGS << "-O0 -g"
+  $CFLAGS << "-O0 -g -DDEBUG"
 else
   $CFLAGS << "-O3"
 end

data/ext/semian/resource.c

@@ -3,6 +3,12 @@
 static VALUE
 cleanup_semian_resource_acquire(VALUE self);
 
+static void
+check_tickets_xor_quota_arg(VALUE tickets, VALUE quota);
+
+static double
+check_quota_arg(VALUE quota);
+
 static int
 check_tickets_arg(VALUE tickets);
 
@@ -48,7 +54,7 @@ semian_resource_acquire(int argc, VALUE *argv, VALUE self)
   }
 
   /* release the GVL to acquire the semaphore */
-  WITHOUT_GVL(acquire_semaphore_without_gvl, &res, RUBY_UBF_IO, NULL); // FIXME - replace with wrapped version
+  acquire_semaphore_without_gvl(&res);
   if (res.error != 0) {
     if (res.error == EAGAIN) {
       rb_raise(eTimeout, "timed out waiting for resource '%s'", res.name);
@@ -63,9 +69,20 @@ semian_resource_acquire(int argc, VALUE *argv, VALUE self)
 VALUE
 semian_resource_destroy(VALUE self)
 {
+  struct timespec ts = { 0 };
+  ts.tv_sec = INTERNAL_TIMEOUT;
+
   semian_resource_t *res = NULL;
 
   TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+
+  // Prevent a race to deletion
+  if (perform_semop(res->sem_id, SI_SEM_LOCK, -1, 0, &ts) == -1) {
+    if (errno == EINVAL || errno == EIDRM) {
+      return Qtrue;
+    }
+  }
+
   if (semctl(res->sem_id, SI_NUM_SEMAPHORES, IPC_RMID) == -1) {
     raise_semian_syscall_error("semctl()", errno);
   }
@@ -73,6 +90,49 @@ semian_resource_destroy(VALUE self)
   return Qtrue;
 }
 
+VALUE
+semian_resource_reset_workers(VALUE self)
+{
+  int ret;
+  semian_resource_t *res = NULL;
+
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+
+  sem_meta_lock(res->sem_id);
+  // This SETVAL will purge the SEM_UNDO table
+  ret = semctl(res->sem_id, SI_SEM_REGISTERED_WORKERS, SETVAL, 0);
+  sem_meta_unlock(res->sem_id);
+
+  if (ret == -1) {
+    raise_semian_syscall_error("semctl()", errno);
+  }
+
+  return Qtrue;
+}
+
+VALUE
+semian_resource_unregister_worker(VALUE self)
+{
+  int ret;
+  semian_resource_t *res = NULL;
+
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+
+  sem_meta_lock(res->sem_id);
+  ret = perform_semop(res->sem_id, SI_SEM_REGISTERED_WORKERS, -1, IPC_NOWAIT | SEM_UNDO, NULL);
+  sem_meta_unlock(res->sem_id);
+
+  if ( ret == -1) {
+    // Allow EAGAIN with IPC_NOWAIT, as this signals that all workers were unregistered
+    // Otherwise, we might block forever or throw an unintended timeout
+    if (errno != EAGAIN) {
+      rb_raise(eInternal, "error decreasing registered workers, errno: %d (%s)", errno, strerror(errno));
+    }
+  }
+
+  return Qtrue;
+}
+
 VALUE
 semian_resource_count(VALUE self)
 {
@@ -88,6 +148,36 @@ semian_resource_count(VALUE self)
   return LONG2FIX(ret);
 }
 
+VALUE
+semian_resource_tickets(VALUE self)
+{
+  int ret;
+  semian_resource_t *res = NULL;
+
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  ret = semctl(res->sem_id, SI_SEM_CONFIGURED_TICKETS, GETVAL);
+  if (ret == -1) {
+    raise_semian_syscall_error("semctl()", errno);
+  }
+
+  return LONG2FIX(ret);
+}
+
+VALUE
+semian_resource_workers(VALUE self)
+{
+  int ret;
+  semian_resource_t *res = NULL;
+
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  ret = semctl(res->sem_id, SI_SEM_REGISTERED_WORKERS, GETVAL);
+  if (ret == -1) {
+    raise_semian_syscall_error("semctl()", errno);
+  }
+
+  return LONG2FIX(ret);
+}
+
 VALUE
 semian_resource_id(VALUE self)
 {
@@ -97,17 +187,26 @@ semian_resource_id(VALUE self)
 }
 
 VALUE
-semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE permissions, VALUE default_timeout)
+semian_resource_key(VALUE self)
 {
-  key_t key;
-  int c_permissions;
+  semian_resource_t *res = NULL;
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  return rb_str_new_cstr(res->strkey);
+}
+
+VALUE
+semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE quota, VALUE permissions, VALUE default_timeout)
+{
+  long c_permissions;
   double c_timeout;
+  double c_quota;
   int c_tickets;
-  int created = 0;
   semian_resource_t *res = NULL;
   const char *c_id_str = NULL;
 
   // Check and cast arguments
+  check_tickets_xor_quota_arg(tickets, quota);
+  c_quota = check_quota_arg(quota);
   c_tickets = check_tickets_arg(tickets);
   c_permissions = check_permissions_arg(permissions);
   c_id_str = check_id_arg(id);
@@ -119,19 +218,10 @@ semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE permission
   // Populate struct fields
   ms_to_timespec(c_timeout * 1000, &res->timeout);
   res->name = strdup(c_id_str);
+  res->quota = c_quota;
 
-  // Get or create semaphore set
-  //  note that tickets = 0 will be used to acquire a semaphore set after it's been created elswhere
-  key = generate_key(c_id_str);
-  res->sem_id = c_tickets == 0 ? get_semaphore(key) : create_semaphore(key, c_permissions, &created);
-  if (res->sem_id == -1) {
-    raise_semian_syscall_error("semget()", errno);
-  }
-
-  set_semaphore_permissions(res->sem_id, c_permissions);
-
-  // Configure semaphore ticket counts
-  configure_tickets(res->sem_id, c_tickets, created);
+  // Initialize the semaphore set
+  initialize_semaphore_set(res, c_id_str, c_permissions, c_tickets, c_quota);
 
   return self;
 }
@@ -162,6 +252,33 @@ check_permissions_arg(VALUE permissions)
   return FIX2LONG(permissions);
 }
 
+static void
+check_tickets_xor_quota_arg(VALUE tickets, VALUE quota)
+{
+  if ((TYPE(tickets) == T_NIL && TYPE(quota) == T_NIL) ||(TYPE(tickets) != T_NIL && TYPE(quota) != T_NIL)){
+    rb_raise(rb_eArgError, "Must pass exactly one of ticket or quota");
+  }
+}
+
+static double
+check_quota_arg(VALUE quota)
+{
+  double c_quota;
+
+  if (TYPE(quota) != T_NIL) {
+    if (TYPE(quota) != T_FIXNUM && TYPE(quota) != T_FLOAT) {
+      rb_raise(rb_eTypeError, "expected decimal type for quota");
+    }
+    if (NUM2DBL(quota) <= 0 || NUM2DBL(quota) > 1) {
+      rb_raise(rb_eArgError, "quota must be a decimal between 0 and 1");
+    }
+    c_quota = NUM2DBL(quota);
+  } else {
+    c_quota = -1.0f;
+  }
+  return c_quota;
+}
+
 static int
 check_tickets_arg(VALUE tickets)
 {

data/ext/semian/resource.h

@@ -7,7 +7,6 @@ Functions here are associated with rubyland operations.
 #define SEMIAN_RESOURCE_H
 
 #include "types.h"
-#include "tickets.h"
 #include "sysv_semaphores.h"
 
 // Ruby variables
@@ -16,12 +15,12 @@ int system_max_semaphore_count;
 
 /*
  * call-seq:
- *    Semian::Resource.new(id, tickets, permissions, default_timeout) -> resource
+ *    Semian::Resource.new(id, tickets, quota, permissions, default_timeout) -> resource
  *
  * Creates a new Resource. Do not create resources directly. Use Semian.register.
  */
 VALUE
-semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE permissions, VALUE default_timeout);
+semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE quota, VALUE permissions, VALUE default_timeout);
 
 /*
  * call-seq:
@@ -50,6 +49,18 @@ semian_resource_acquire(int argc, VALUE *argv, VALUE self);
 VALUE
 semian_resource_destroy(VALUE self);
 
+/*
+ * call-seq:
+ *   resource.reset_registered_workers!() -> true
+ *
+ * Unregisters all registered workers for a resource, forcefully setting the worker count back to 0.
+ * This will purge the SEM_UNDO table.
+ *
+ * Use this method very carefully.
+ */
+VALUE
+semian_resource_reset_workers(VALUE self);
+
 /*
  * call-seq:
  *    resource.count -> count
@@ -59,15 +70,57 @@ semian_resource_destroy(VALUE self);
 VALUE
 semian_resource_count(VALUE self);
 
+/*
+ * call-seq:
+ *    resource.tickets -> count
+ *
+ * Returns the configured number of tickets for a resource.
+ */
+VALUE
+semian_resource_tickets(VALUE self);
+
+/*
+ * call-seq:
+ *    resource.registered_workers -> count
+ *
+ * Returns the number of workers (processes) registered to use the resource
+ */
+VALUE
+semian_resource_workers(VALUE self);
+
 /*
  * call-seq:
  *    resource.semid -> id
  *
  * Returns the SysV semaphore id of a resource.
+ * Note: This value varies from system to system, and between
+ * instances of semian.
  */
 VALUE
 semian_resource_id(VALUE self);
 
+/*
+ * call-seq:
+ *    resource.key -> id
+ *
+ * Returns the hex string representation of SysV semaphore key of a resource.
+ * Note: This is a unique identifier that is portable across system
+ * and instances of semian.
+ */
+VALUE
+semian_resource_key(VALUE self);
+
+/*
+ * call-seq:
+ *   resource.unregister_worker() -> true
+ *
+ * Unregisters a worker, which will affect quota calculations.
+ *
+ * Be careful to call this only once per process.
+*/
+VALUE
+semian_resource_unregister_worker(VALUE self);
+
 // Allocate a semian_resource_type struct for ruby memory management
 VALUE
 semian_resource_alloc(VALUE klass);

data/ext/semian/semian.c

@@ -42,11 +42,16 @@ void Init_semian()
   eInternal = rb_const_get(cSemian, rb_intern("InternalError"));
 
   rb_define_alloc_func(cResource, semian_resource_alloc);
-  rb_define_method(cResource, "initialize_semaphore", semian_resource_initialize, 4);
+  rb_define_method(cResource, "initialize_semaphore", semian_resource_initialize, 5);
   rb_define_method(cResource, "acquire", semian_resource_acquire, -1);
   rb_define_method(cResource, "count", semian_resource_count, 0);
   rb_define_method(cResource, "semid", semian_resource_id, 0);
+  rb_define_method(cResource, "key", semian_resource_key, 0);
+  rb_define_method(cResource, "tickets", semian_resource_tickets, 0);
+  rb_define_method(cResource, "registered_workers", semian_resource_workers, 0);
   rb_define_method(cResource, "destroy", semian_resource_destroy, 0);
+  rb_define_method(cResource, "reset_registered_workers!", semian_resource_reset_workers, 0);
+  rb_define_method(cResource, "unregister_worker", semian_resource_unregister_worker, 0);
 
   id_timeout = rb_intern("timeout");
 

data/ext/semian/sysv_semaphores.c

@@ -1,4 +1,21 @@
-#include <sysv_semaphores.h>
+#include "sysv_semaphores.h"
+
+static key_t
+generate_key(const char *name);
+
+static void *
+acquire_semaphore(void *p);
+
+static int
+wait_for_new_semaphore_set(key_t key, long permissions);
+
+static void
+initialize_new_semaphore_values(int sem_id, long permissions);
+
+// Generate string rep for sem indices for debugging puproses
+static const char *SEMINDEX_STRING[] = {
+    FOREACH_SEMINDEX(GENERATE_STRING)
+};
 
 void
 raise_semian_syscall_error(const char *syscall, int error_num)
@@ -6,28 +23,45 @@ raise_semian_syscall_error(const char *syscall, int error_num)
   rb_raise(eSyscall, "%s failed, errno: %d (%s)", syscall, error_num, strerror(error_num));
 }
 
-key_t
-generate_key(const char *name)
+void
+initialize_semaphore_set(semian_resource_t* res, const char* id_str, long permissions, int tickets, double quota)
 {
-  char semset_size_key[20];
-  char *uniq_id_str;
 
-  // It is necessary for the cardinatily of the semaphore set to be part of the key
-  // or else sem_get will complain that we have requested an incorrect number of sems
-  // for the desired key, and have changed the number of semaphores for a given key
-  sprintf(semset_size_key, "_NUM_SEMS_%d", SI_NUM_SEMAPHORES);
-  uniq_id_str = malloc(strlen(name)+strlen(semset_size_key)+1);
-  strcpy(uniq_id_str, name);
-  strcat(uniq_id_str, semset_size_key);
+  res->key = generate_key(id_str);
+  res->strkey = (char*)  malloc((2 /*for 0x*/+ sizeof(uint64_t) /*actual key*/+ 1 /*null*/) * sizeof(char));
+  sprintf(res->strkey, "0x%08x", (unsigned int) res->key);
+  res->sem_id = semget(res->key, SI_NUM_SEMAPHORES, IPC_CREAT | IPC_EXCL | permissions);
+
+  /*
+  This approach is based on http://man7.org/tlpi/code/online/dist/svsem/svsem_good_init.c.html
+  which avoids race conditions when initializing semaphore sets.
+  */
+  if (res->sem_id != -1) {
+    // Happy path - we are the first worker, initialize the semaphore set.
+    initialize_new_semaphore_values(res->sem_id, permissions);
+  } else {
+    // Something went wrong
+    if (errno != EEXIST) {
+      raise_semian_syscall_error("semget() failed to initialize semaphore values", errno);
+    } else {
+      // The semaphore set already exists, ensure it is initialized
+      res->sem_id = wait_for_new_semaphore_set(res->key, permissions);
+    }
+  }
 
-  union {
-    unsigned char str[SHA_DIGEST_LENGTH];
-    key_t key;
-  } digest;
-  SHA1((const unsigned char *) uniq_id_str, strlen(uniq_id_str), digest.str);
-  free(uniq_id_str);
-  /* TODO: compile-time assertion that sizeof(key_t) > SHA_DIGEST_LENGTH */
-  return digest.key;
+  set_semaphore_permissions(res->sem_id, permissions);
+
+  /*
+    Ensure that a worker for this process is registered.
+    Note that from ruby we ensure that at most one worker may be registered per process.
+  */
+  if (perform_semop(res->sem_id, SI_SEM_REGISTERED_WORKERS, 1, SEM_UNDO, NULL) == -1) {
+    rb_raise(eInternal, "error incrementing registered workers, errno: %d (%s)", errno, strerror(errno));
+  }
+
+  sem_meta_lock(res->sem_id); // Sets otime for the first time by acquiring the sem lock
+  configure_tickets(res->sem_id, tickets,  quota);
+  sem_meta_unlock(res->sem_id);
 }
 
 void
@@ -45,26 +79,6 @@ set_semaphore_permissions(int sem_id, long permissions)
   }
 }
 
-int
-create_semaphore(int key, long permissions, int *created)
-{
-  int semid = 0;
-  int flags = 0;
-
-  *created = 0;
-  flags = IPC_EXCL | IPC_CREAT | permissions;
-
-  semid = semget(key, SI_NUM_SEMAPHORES, flags);
-  if (semid >= 0) {
-    *created = 1;
-  } else if (semid == -1 && errno == EEXIST) {
-    flags &= ~IPC_EXCL;
-    semid = semget(key, SI_NUM_SEMAPHORES, flags);
-  }
-  return semid;
-}
-
-
 int
 perform_semop(int sem_id, short index, short op, short flags, struct timespec *ts)
 {
@@ -82,11 +96,11 @@ perform_semop(int sem_id, short index, short op, short flags, struct timespec *t
 }
 
 int
-get_max_tickets(int sem_id)
+get_sem_val(int sem_id, int sem_index)
 {
-  int ret = semctl(sem_id, SI_SEM_CONFIGURED_TICKETS, GETVAL);
+  int ret = semctl(sem_id, sem_index, GETVAL);
   if (ret == -1) {
-    rb_raise(eInternal, "error getting max ticket count, errno: %d (%s)", errno, strerror(errno));
+    rb_raise(eInternal, "error getting value of %s for sem %d, errno: %d (%s)", SEMINDEX_STRING[sem_index], sem_id, errno, strerror(errno));
   }
   return ret;
 }
@@ -118,11 +132,102 @@ get_semaphore(int key)
 
 void *
 acquire_semaphore_without_gvl(void *p)
+{
+  WITHOUT_GVL(acquire_semaphore, p, RUBY_UBF_IO, NULL);
+  return NULL;
+}
+
+static void *
+acquire_semaphore(void *p)
 {
   semian_resource_t *res = (semian_resource_t *) p;
   res->error = 0;
+#ifdef DEBUG
+  print_sem_vals(res->sem_id);
+#endif
   if (perform_semop(res->sem_id, SI_SEM_TICKETS, -1, SEM_UNDO, &res->timeout) == -1) {
     res->error = errno;
   }
   return NULL;
 }
+
+static key_t
+generate_key(const char *name)
+{
+  char semset_size_key[20];
+  char *uniq_id_str;
+
+  // It is necessary for the cardinatily of the semaphore set to be part of the key
+  // or else sem_get will complain that we have requested an incorrect number of sems
+  // for the desired key, and have changed the number of semaphores for a given key
+  sprintf(semset_size_key, "_NUM_SEMS_%d", SI_NUM_SEMAPHORES);
+  uniq_id_str = malloc(strlen(name)+strlen(semset_size_key)+1);
+  strcpy(uniq_id_str, name);
+  strcat(uniq_id_str, semset_size_key);
+
+  union {
+    unsigned char str[SHA_DIGEST_LENGTH];
+    key_t key;
+  } digest;
+  SHA1((const unsigned char *) uniq_id_str, strlen(uniq_id_str), digest.str);
+  free(uniq_id_str);
+  /* TODO: compile-time assertion that sizeof(key_t) > SHA_DIGEST_LENGTH */
+  return digest.key;
+}
+
+
+static void
+initialize_new_semaphore_values(int sem_id, long permissions)
+{
+  unsigned short init_vals[SI_NUM_SEMAPHORES];
+
+  init_vals[SI_SEM_TICKETS] = init_vals[SI_SEM_CONFIGURED_TICKETS] = 0;
+  init_vals[SI_SEM_REGISTERED_WORKERS] = 0;
+  init_vals[SI_SEM_LOCK] = 1;
+
+  if (semctl(sem_id, 0, SETALL, init_vals) == -1) {
+    raise_semian_syscall_error("semctl()", errno);
+  }
+#ifdef DEBUG
+  print_sem_vals(sem_id);
+#endif
+}
+
+static int
+wait_for_new_semaphore_set(key_t key, long permissions)
+{
+  int i;
+  int sem_id = -1;
+  union semun sem_opts;
+  struct semid_ds sem_ds;
+
+  sem_opts.buf = &sem_ds;
+  sem_id = semget(key, 1, permissions);
+
+  if (sem_id == -1){
+      raise_semian_syscall_error("semget()", errno);
+  }
+
+  for (i = 0; i < ((INTERNAL_TIMEOUT * MICROSECONDS_IN_SECOND) / INIT_WAIT); i++) {
+
+    if (semctl(sem_id, 0, IPC_STAT, sem_opts) == -1) {
+      raise_semian_syscall_error("semget()", errno);
+    }
+
+    // If a semop has been performed by someone else, the values must be initialized
+    if (sem_ds.sem_otime != 0) {
+      break;
+    }
+
+#ifdef DEBUG
+    printf("Waiting for another process to initialize semaphore values, checked: %d times\n", i);
+#endif
+    usleep(INIT_WAIT);
+  }
+
+  if (sem_ds.sem_otime == 0) {
+    rb_raise(eTimeout, "error: timeout waiting for semaphore values to initialize after %d checks", INTERNAL_TIMEOUT);
+  }
+
+  return sem_id;
+}