semian_extension 0.11.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2fbd05996a9e15b84c54519a393a2ce1bf453d38552a7b22e80a831721f285f4
+  data.tar.gz: fcd1fa08aa00fd91a7cf0384bafff8c531de237995df5b7b252b2142335afd21
+SHA512:
+  metadata.gz: e28e4d4566e503178e0540bf487addc96a7693fd125bbf8d2e1b51edc1d5249caa5b4911c5364e95e4539ee88140f3c20899c8f786f5a2fb1216dde77da6e8d1
+  data.tar.gz: 2e366ace3707305ed07f2f61461a7aed93909cafa42500161f3ca356da2f70239202fa27ee32a688e8b3216e72942461a07cdbedc1f7bf3961e0120465df350b

data/ext/semian/extconf.rb

@@ -0,0 +1,33 @@
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+
+require 'semian/platform'
+
+unless Semian.sysv_semaphores_supported?
+  File.write "Makefile", <<MAKEFILE
+all:
+clean:
+install:
+MAKEFILE
+  exit
+end
+
+require 'mkmf'
+
+abort 'openssl is missing. please install openssl.' unless find_header('openssl/sha.h')
+abort 'openssl is missing. please install openssl.' unless find_library('crypto', 'SHA1')
+
+have_header 'sys/ipc.h'
+have_header 'sys/sem.h'
+have_header 'sys/types.h'
+
+have_func 'rb_thread_blocking_region'
+have_func 'rb_thread_call_without_gvl'
+
+$CFLAGS = "-D_GNU_SOURCE -Werror -Wall "
+if ENV.key?('DEBUG')
+  $CFLAGS << "-O0 -g -DDEBUG"
+else
+  $CFLAGS << "-O3"
+end
+
+create_makefile('semian/semian')

data/ext/semian/resource.c

@@ -0,0 +1,394 @@
+#include "resource.h"
+
+// Ruby variables
+ID id_wait_time;
+ID id_timeout;
+int system_max_semaphore_count;
+
+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);
+
+static long
+check_permissions_arg(VALUE permissions);
+
+static const
+char *check_id_arg(VALUE id);
+
+static double
+check_default_timeout_arg(VALUE default_timeout);
+
+static void
+ms_to_timespec(long ms, struct timespec *ts);
+
+static const rb_data_type_t
+semian_resource_type;
+
+VALUE
+semian_resource_acquire(int argc, VALUE *argv, VALUE self)
+{
+  semian_resource_t *self_res = NULL;
+  semian_resource_t res = { 0 };
+
+  if (!rb_block_given_p()) {
+    rb_raise(rb_eArgError, "acquire requires a block");
+  }
+
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, self_res);
+  res = *self_res;
+
+  /* allow the default timeout to be overridden by a "timeout" param */
+  if (argc == 1 && TYPE(argv[0]) == T_HASH) {
+    VALUE timeout = rb_hash_aref(argv[0], ID2SYM(id_timeout));
+    if (TYPE(timeout) != T_NIL) {
+      if (TYPE(timeout) != T_FLOAT && TYPE(timeout) != T_FIXNUM) {
+        rb_raise(rb_eArgError, "timeout parameter must be numeric");
+      }
+      ms_to_timespec(NUM2DBL(timeout) * 1000, &res.timeout);
+    }
+  } else if (argc > 0) {
+    rb_raise(rb_eArgError, "invalid arguments");
+  }
+
+  /* release the GVL to acquire the semaphore */
+  acquire_semaphore_without_gvl(&res);
+  if (res.error != 0) {
+    if (res.error == EAGAIN) {
+      rb_raise(eTimeout, "timed out waiting for resource '%s'", res.name);
+    } else {
+      raise_semian_syscall_error("semop()", res.error);
+    }
+  }
+
+  VALUE wait_time = Qnil;
+  if (res.wait_time >= 0) {
+    wait_time = LONG2NUM(res.wait_time);
+  }
+
+  return rb_ensure(rb_yield, wait_time, cleanup_semian_resource_acquire, 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);
+  }
+
+  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)
+{
+  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_TICKETS, GETVAL);
+  if (ret == -1) {
+    raise_semian_syscall_error("semctl()", errno);
+  }
+
+  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)
+{
+  semian_resource_t *res = NULL;
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  return LONG2FIX(res->sem_id);
+}
+
+VALUE
+semian_resource_key(VALUE self)
+{
+  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;
+  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);
+  c_timeout = check_default_timeout_arg(default_timeout);
+
+  // Build semian resource structure
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+
+  // Populate struct fields
+  ms_to_timespec(c_timeout * 1000, &res->timeout);
+  res->name = strdup(c_id_str);
+  res->quota = c_quota;
+  res->wait_time = -1;
+
+  // Initialize the semaphore set
+  initialize_semaphore_set(res, c_id_str, c_permissions, c_tickets, c_quota);
+
+  return self;
+}
+
+VALUE
+semian_resource_alloc(VALUE klass)
+{
+  semian_resource_t *res;
+  VALUE obj = TypedData_Make_Struct(klass, semian_resource_t, &semian_resource_type, res);
+  return obj;
+}
+
+VALUE
+semian_resource_in_use(VALUE self)
+{
+  return Qtrue;
+}
+
+static VALUE
+cleanup_semian_resource_acquire(VALUE self)
+{
+  semian_resource_t *res = NULL;
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  if (perform_semop(res->sem_id, SI_SEM_TICKETS, 1, SEM_UNDO, NULL) == -1) {
+    res->error = errno;
+  }
+  return Qnil;
+}
+
+static long
+check_permissions_arg(VALUE permissions)
+{
+  Check_Type(permissions, T_FIXNUM);
+  return FIX2LONG(permissions);
+}
+
+static void
+check_tickets_xor_quota_arg(VALUE tickets, VALUE quota)
+{
+  if (tickets == Qnil && quota == Qnil) {
+    rb_raise(rb_eArgError, "Semian configuration require either the :ticket or :quota parameter, you provided neither");
+  }
+  if (tickets != Qnil && quota != Qnil) {
+    rb_raise(rb_eArgError, "Semian configuration require either the :ticket or :quota parameter, you provided both");
+  }
+}
+
+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)
+{
+  int c_tickets;
+
+  if (TYPE(tickets) != T_NIL) {
+    if (TYPE(tickets) == T_FLOAT) {
+      rb_warn("semian ticket value %f is a float, converting to fixnum", RFLOAT_VALUE(tickets));
+      tickets = INT2FIX((int) RFLOAT_VALUE(tickets));
+    }
+    Check_Type(tickets, T_FIXNUM);
+
+    if (FIX2LONG(tickets) < 0 || FIX2LONG(tickets) > system_max_semaphore_count) {
+      rb_raise(rb_eArgError, "ticket count must be a non-negative value and less than %d", system_max_semaphore_count);
+    }
+    c_tickets = FIX2LONG(tickets);
+  } else {
+    c_tickets = -1;
+  }
+
+  return c_tickets;
+}
+
+static const char*
+check_id_arg(VALUE id)
+{
+  const char *c_id_str = NULL;
+
+  if (TYPE(id) != T_SYMBOL && TYPE(id) != T_STRING) {
+    rb_raise(rb_eTypeError, "id must be a symbol or string");
+  }
+  if (TYPE(id) == T_SYMBOL) {
+    c_id_str = rb_id2name(rb_to_id(id));
+  } else if (TYPE(id) == T_STRING) {
+    c_id_str = RSTRING_PTR(id);
+  }
+
+  return c_id_str;
+}
+
+static double
+check_default_timeout_arg(VALUE default_timeout)
+{
+  if (TYPE(default_timeout) != T_FIXNUM && TYPE(default_timeout) != T_FLOAT) {
+    rb_raise(rb_eTypeError, "expected numeric type for default_timeout");
+  }
+
+  if (NUM2DBL(default_timeout) < 0) {
+    rb_raise(rb_eArgError, "default timeout must be non-negative value");
+  }
+  return NUM2DBL(default_timeout);
+}
+
+static void
+ms_to_timespec(long ms, struct timespec *ts)
+{
+  ts->tv_sec = ms / 1000;
+  ts->tv_nsec = (ms % 1000) * 1000000;
+}
+
+static inline void
+semian_resource_mark(void *ptr)
+{
+  /* noop */
+}
+
+static inline void
+semian_resource_free(void *ptr)
+{
+  semian_resource_t *res = (semian_resource_t *) ptr;
+  if (res->name) {
+    free(res->name);
+    res->name = NULL;
+  }
+  xfree(res);
+}
+
+static inline size_t
+semian_resource_memsize(const void *ptr)
+{
+  return sizeof(semian_resource_t);
+}
+
+static const rb_data_type_t
+semian_resource_type = {
+  "semian_resource",
+  {
+    semian_resource_mark,
+    semian_resource_free,
+    semian_resource_memsize
+  },
+  NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+};

data/ext/semian/resource.h

@@ -0,0 +1,133 @@
+/*
+For core semian resource functions exposed directly to ruby.
+
+Functions here are associated with rubyland operations.
+*/
+#ifndef SEMIAN_RESOURCE_H
+#define SEMIAN_RESOURCE_H
+
+#include "types.h"
+#include "sysv_semaphores.h"
+
+// Ruby variables
+extern ID id_wait_time;
+extern ID id_timeout;
+extern int system_max_semaphore_count;
+
+/*
+ * call-seq:
+ *    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 quota, VALUE permissions, VALUE default_timeout);
+
+/*
+ * call-seq:
+ *    resource.acquire(timeout: default_timeout) { ... }  -> result of the block
+ *
+ * Acquires a resource. The call will block for <code>timeout</code> seconds if a ticket
+ * is not available. If no ticket is available within the timeout period, Semian::TimeoutError
+ * will be raised.
+ *
+ * If no timeout argument is provided, the default timeout passed to Semian.register will be used.
+ *
+ */
+VALUE
+semian_resource_acquire(int argc, VALUE *argv, VALUE self);
+
+/*
+ * call-seq:
+ *   resource.destroy() -> true
+ *
+ * Destroys a resource. This method will destroy the underlying SysV semaphore.
+ * If there is any code in other threads or processes blocking or using the resource
+ * they will likely raise.
+ *
+ * Use this method very carefully.
+ */
+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
+ *
+ * Returns the current ticket count for a resource.
+ */
+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);
+
+// Returns true if the resource is in use
+VALUE
+semian_resource_in_use(VALUE self);
+
+#endif //SEMIAN_RESOURCE_H

data/ext/semian/semian.c

@@ -0,0 +1,72 @@
+#include "semian.h"
+
+VALUE eSyscall, eTimeout, eInternal;
+
+void Init_semian()
+{
+  VALUE cSemian, cResource;
+  struct seminfo info_buf;
+
+  cSemian = rb_const_get(rb_cObject, rb_intern("Semian"));
+
+  /*
+   * Document-class: Semian::Resource
+   *
+   *  Resource is the fundamental class of Semian. It is essentially a wrapper around a
+   *  SystemV semaphore.
+   *
+   *  You should not create this class directly, it will be created indirectly via Semian.register.
+   */
+  cResource = rb_const_get(cSemian, rb_intern("Resource"));
+
+  /* Document-class: Semian::SyscallError
+   *
+   * Represents a Semian error that was caused by an underlying syscall failure.
+   */
+  eSyscall = rb_const_get(cSemian, rb_intern("SyscallError"));
+  rb_global_variable(&eSyscall);
+
+  /* Document-class: Semian::TimeoutError
+   *
+   * Raised when a Semian operation timed out.
+   */
+  eTimeout = rb_const_get(cSemian, rb_intern("TimeoutError"));
+  rb_global_variable(&eTimeout);
+
+  /* Document-class: Semian::InternalError
+   *
+   * An internal Semian error. These errors should be typically never be raised. If
+   * they do, there's a high likelyhood that the underlying SysV semaphore set
+   * has been corrupted.
+   *
+   * If this happens, a strong course of action would be to delete the semaphores
+   * using the <code>ipcrm</code> command line tool. Semian will re-initialize
+   * the semaphore in this case.
+   */
+  eInternal = rb_const_get(cSemian, rb_intern("InternalError"));
+  rb_global_variable(&eInternal);
+
+  rb_define_alloc_func(cResource, semian_resource_alloc);
+  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);
+  rb_define_method(cResource, "in_use?", semian_resource_in_use, 0);
+
+  id_wait_time = rb_intern("wait_time");
+  id_timeout = rb_intern("timeout");
+
+  if (semctl(0, 0, SEM_INFO, &info_buf) == -1) {
+    rb_raise(eInternal, "unable to determine maximum semaphore count - semctl() returned %d: %s ", errno, strerror(errno));
+  }
+  system_max_semaphore_count = info_buf.semvmx;
+
+  /* Maximum number of tickets available on this system. */
+  rb_define_const(cSemian, "MAX_TICKETS", INT2FIX(system_max_semaphore_count));
+}

data/ext/semian/semian.h

@@ -0,0 +1,14 @@
+/*
+System, 3rd party, and project includes
+
+Implements Init_semian, which is used as C/Ruby entrypoint.
+*/
+
+#ifndef SEMIAN_H
+#define SEMIAN_H
+
+#include "resource.h"
+
+void Init_semian();
+
+#endif //SEMIAN_H