semian_extension 0.11.4.1

data/ext/semian/sysv_semaphores.c

@@ -0,0 +1,271 @@
+#include "sysv_semaphores.h"
+#include <time.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);
+
+static long
+diff_timespec_ms(struct timespec *end, struct timespec *begin);
+
+// 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)
+{
+  rb_raise(eSyscall, "%s failed, errno: %d (%s)", syscall, error_num, strerror(error_num));
+}
+
+void
+initialize_semaphore_set(semian_resource_t* res, const char* id_str, long permissions, int tickets, double quota)
+{
+
+  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);
+    }
+  }
+
+  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));
+  }
+
+  int state = 0;
+  sem_meta_lock(res->sem_id); // Sets otime for the first time by acquiring the sem lock
+
+  configure_tickets_args_t configure_tickets_args = (configure_tickets_args_t){
+    .sem_id = res->sem_id,
+    .tickets = tickets,
+    .quota = quota,
+  };
+  rb_protect(
+    configure_tickets,
+    (VALUE)&configure_tickets_args,
+    &state);
+
+  sem_meta_unlock(res->sem_id);
+  if (state) {
+    rb_jump_tag(state);
+  }
+}
+
+void
+set_semaphore_permissions(int sem_id, long permissions)
+{
+  union semun sem_opts;
+  struct semid_ds stat_buf;
+
+  sem_opts.buf = &stat_buf;
+  semctl(sem_id, 0, IPC_STAT, sem_opts);
+  if ((stat_buf.sem_perm.mode & 0xfff) != permissions) {
+    stat_buf.sem_perm.mode &= ~0xfff;
+    stat_buf.sem_perm.mode |= permissions;
+    semctl(sem_id, 0, IPC_SET, sem_opts);
+  }
+}
+
+int
+perform_semop(int sem_id, short index, short op, short flags, struct timespec *ts)
+{
+  int result;
+  struct sembuf buf = { 0 };
+
+  buf.sem_num = index;
+  buf.sem_op  = op;
+  buf.sem_flg = flags;
+
+  int num_retries = 3;
+
+  do {
+    result = semtimedop(sem_id, &buf, 1, ts);
+  } while (result < 0 && errno == EINTR && num_retries-- > 0);
+
+  return result;
+}
+
+int
+get_sem_val(int sem_id, int sem_index)
+{
+  int ret = semctl(sem_id, sem_index, GETVAL);
+  if (ret == -1) {
+    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;
+}
+
+void
+sem_meta_lock(int sem_id)
+{
+  struct timespec ts = { 0 };
+  ts.tv_sec = INTERNAL_TIMEOUT;
+
+  if (perform_semop(sem_id, SI_SEM_LOCK, -1, SEM_UNDO, &ts) == -1) {
+    raise_semian_syscall_error("error acquiring internal semaphore lock, semtimedop()", errno);
+  }
+}
+
+void
+sem_meta_unlock(int sem_id)
+{
+  if (perform_semop(sem_id, SI_SEM_LOCK, 1, SEM_UNDO, NULL) == -1) {
+    raise_semian_syscall_error("error releasing internal semaphore lock, semop()", errno);
+  }
+}
+
+int
+get_semaphore(int key)
+{
+  return semget(key, SI_NUM_SEMAPHORES, 0);
+}
+
+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;
+  res->wait_time = -1;
+#ifdef DEBUG
+  print_sem_vals(res->sem_id);
+#endif
+
+  struct timespec begin, end;
+  int benchmark_result = clock_gettime(CLOCK_MONOTONIC, &begin);
+  if (perform_semop(res->sem_id, SI_SEM_TICKETS, -1, SEM_UNDO, &res->timeout) == -1) {
+    res->error = errno;
+  }
+  if (benchmark_result == 0) {
+    if (clock_gettime(CLOCK_MONOTONIC, &end) == 0) {
+      res->wait_time = diff_timespec_ms(&end, &begin);
+    }
+  }
+  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("semctl()", 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;
+}
+
+static long
+diff_timespec_ms(struct timespec *end, struct timespec *begin)
+{
+  long end_ms = (end->tv_sec * 1e3) + (end->tv_nsec / 1e6);
+  long begin_ms = (begin->tv_sec * 1e3) + (begin->tv_nsec / 1e6);
+  return end_ms - begin_ms;
+}

data/ext/semian/sysv_semaphores.h

@@ -0,0 +1,122 @@
+/*
+For manipulating the semian's semaphore set
+
+Semian semaphore operations and initialization,
+and functions associated directly weth semops.
+*/
+#ifndef SEMIAN_SEMSET_H
+#define SEMIAN_SEMSET_H
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <openssl/sha.h>
+#include <ruby.h>
+#include <ruby/util.h>
+#include <ruby/io.h>
+
+#include "types.h"
+#include "tickets.h"
+
+// Defines for ruby threading primitives
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && defined(HAVE_RUBY_THREAD_H)
+// 2.0
+#include <ruby/thread.h>
+#define WITHOUT_GVL(fn,a,ubf,b) rb_thread_call_without_gvl((fn),(a),(ubf),(b))
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
+ // 1.9
+typedef VALUE (*my_blocking_fn_t)(void*);
+#define WITHOUT_GVL(fn,a,ubf,b) rb_thread_blocking_region((my_blocking_fn_t)(fn),(a),(ubf),(b))
+#endif
+
+// Time to wait for timed ops to complete
+#define INTERNAL_TIMEOUT 5 /* seconds */
+
+// Time to wait while checking if semaphore has been initialized
+#define INIT_WAIT 10 /* microseconds */
+
+// Helper definition to prevent magic number for conversion of microseconds to seconds
+#define MICROSECONDS_IN_SECOND 1000000
+
+// Here we define an enum value and string representation of each semaphore
+// This allows us to key the sem value and string rep in sync easily
+// utilizing pre-processor macros.
+// If you're unfamiliar with this pattern, this is using "x macros"
+//   SI_SEM_LOCK                metadata lock to act as a mutex, ensuring thread-safety for updating other semaphores
+//   SI_SEM_TICKETS             semaphore for the tickets currently issued
+//   SI_SEM_CONFIGURED_TICKETS  semaphore to track the desired number of tickets available for issue
+//   SI_SEM_REGISTERED_WORKERS  semaphore for the number of workers currently registered
+//   SI_NUM_SEMAPHORES          always leave this as last entry for count to be accurate
+#define FOREACH_SEMINDEX(SEMINDEX) \
+        SEMINDEX(SI_SEM_LOCK)   \
+        SEMINDEX(SI_SEM_TICKETS)   \
+        SEMINDEX(SI_SEM_CONFIGURED_TICKETS)  \
+        SEMINDEX(SI_SEM_REGISTERED_WORKERS)  \
+        SEMINDEX(SI_NUM_SEMAPHORES)  \
+
+#define GENERATE_ENUM(ENUM) ENUM,
+#define GENERATE_STRING(STRING) #STRING,
+
+// Generate enum for sem indices
+enum SEMINDEX_ENUM {
+    FOREACH_SEMINDEX(GENERATE_ENUM)
+};
+
+extern VALUE eSyscall, eTimeout, eInternal;
+
+// Helper for syscall verbose debugging
+void
+raise_semian_syscall_error(const char *syscall, int error_num);
+
+// Initialize the sysv semaphore structure
+void
+initialize_semaphore_set(semian_resource_t* res, const char* id_str, long permissions, int tickets, double quota);
+
+// Set semaphore UNIX octal permissions
+void
+set_semaphore_permissions(int sem_id, long permissions);
+
+// Create a new sysV IPC semaphore set
+int
+create_semaphore(int key, long permissions, int *created);
+
+// Wrapper to performs a semop call
+// The call may be timed or untimed
+int
+perform_semop(int sem_id, short index, short op, short flags, struct timespec *ts);
+
+// Retrieve the current number of tickets in a semaphore by its semaphore index
+int
+get_sem_val(int sem_id, int sem_index);
+
+// Obtain an exclusive lock on the semaphore set critical section
+void
+sem_meta_lock(int sem_id);
+
+// Release an exclusive lock on the semaphore set critical section
+void
+sem_meta_unlock(int sem_id);
+
+// Retrieve a semaphore's ID from its key
+int
+get_semaphore(int key);
+
+// Decrements the ticket semaphore within the semaphore set
+void *
+acquire_semaphore_without_gvl(void *p);
+
+#ifdef DEBUG
+static inline void
+print_sem_vals(int sem_id)
+{
+  printf("lock %d, tickets: %d configured: %d, registered workers %d\n",
+   get_sem_val(sem_id, SI_SEM_LOCK),
+   get_sem_val(sem_id, SI_SEM_TICKETS),
+   get_sem_val(sem_id, SI_SEM_CONFIGURED_TICKETS),
+   get_sem_val(sem_id, SI_SEM_REGISTERED_WORKERS)
+  );
+}
+#endif
+
+#endif // SEMIAN_SEMSET_H

data/ext/semian/tickets.c

@@ -0,0 +1,76 @@
+#include "tickets.h"
+
+// Update the ticket count for static ticket tracking
+static VALUE
+update_ticket_count(int sem_id, int count);
+
+static int
+calculate_quota_tickets(int sem_id, double quota);
+
+// Must be called with the semaphore meta lock already acquired
+VALUE
+configure_tickets(VALUE value)
+{
+  configure_tickets_args_t *args = (configure_tickets_args_t *)value;
+
+  if (args->quota > 0) {
+    args->tickets = calculate_quota_tickets(args->sem_id, args->quota);
+  }
+
+  /*
+    A manually specified ticket count of 0 is special, meaning "don't set"
+    We need to throw an error if we set it to 0 during initialization.
+    Otherwise, we back out of here completely.
+  */
+  if (get_sem_val(args->sem_id, SI_SEM_CONFIGURED_TICKETS) == 0 && args->tickets == 0) {
+    rb_raise(eSyscall, "More than 0 tickets must be specified when initializing semaphore");
+  } else if (args->tickets == 0) {
+    return Qnil;
+  }
+
+  /*
+     If the current configured ticket count is not the same as the requested ticket
+     count, we need to resize the count. We do this by adding the delta of
+     (tickets - current_configured_tickets) to the semaphore value.
+  */
+  if (get_sem_val(args->sem_id, SI_SEM_CONFIGURED_TICKETS) != args->tickets) {
+    update_ticket_count(args->sem_id, args->tickets);
+  }
+
+  return Qnil;
+}
+
+static VALUE
+update_ticket_count(int sem_id, int tickets)
+{
+  short delta;
+  struct timespec ts = { 0 };
+  ts.tv_sec = INTERNAL_TIMEOUT;
+
+  delta = tickets - get_sem_val(sem_id, SI_SEM_CONFIGURED_TICKETS);
+
+#ifdef DEBUG
+  print_sem_vals(sem_id);
+#endif
+  if (perform_semop(sem_id, SI_SEM_TICKETS, delta, 0, &ts) == -1) {
+    if (delta < 0 && errno == EAGAIN) {
+      rb_raise(eTimeout, "timeout while trying to update ticket count");
+    } else {
+      rb_raise(eInternal, "error setting ticket count, errno: %d (%s)", errno, strerror(errno));
+    }
+  }
+
+  if (semctl(sem_id, SI_SEM_CONFIGURED_TICKETS, SETVAL, tickets) == -1) {
+    rb_raise(eInternal, "error configuring ticket count, errno: %d (%s)", errno, strerror(errno));
+  }
+
+  return Qnil;
+}
+
+static int
+calculate_quota_tickets (int sem_id, double quota)
+{
+  int tickets = 0;
+  tickets = (int) ceil(get_sem_val(sem_id, SI_SEM_REGISTERED_WORKERS) * quota);
+  return tickets;
+}

data/ext/semian/tickets.h

@@ -0,0 +1,13 @@
+/*
+For logic specific to manipulating semian ticket counts
+*/
+#ifndef SEMIAN_TICKETS_H
+#define SEMIAN_TICKETS_H
+
+#include "sysv_semaphores.h"
+
+// Set initial ticket values upon resource creation
+VALUE
+configure_tickets(VALUE);
+
+#endif // SEMIAN_TICKETS_H

data/ext/semian/types.h

@@ -0,0 +1,41 @@
+/*
+For custom type definitions specific to semian
+*/
+#ifndef SEMIAN_TYPES_H
+#define SEMIAN_TYPES_H
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/sem.h>
+#include <sys/time.h>
+
+// For sysV semop syscals
+// see man semop
+union semun {
+  int              val;    /* Value for SETVAL */
+  struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
+  unsigned short  *array;  /* Array for GETALL, SETALL */
+  struct seminfo  *__buf;  /* Buffer for IPC_INFO
+                             (Linux-specific) */
+};
+
+typedef struct {
+  int sem_id;
+  int tickets;
+  double quota;
+} configure_tickets_args_t;
+
+// Internal semaphore structure
+typedef struct {
+  int sem_id;
+  struct timespec timeout;
+  double quota;
+  int error;
+  uint64_t key;
+  char *strkey;
+  char *name;
+  long wait_time;
+} semian_resource_t;
+
+#endif // SEMIAN_TYPES_H

data/lib/semian/adapter.rb

@@ -0,0 +1,75 @@
+require 'semian'
+
+module Semian
+  module Adapter
+    def semian_identifier
+      raise NotImplementedError.new("Semian adapters must implement a `semian_identifier` method")
+    end
+
+    def semian_resource
+      @semian_resource ||= case semian_options
+      when false
+        UnprotectedResource.new(semian_identifier)
+      when nil
+        Semian.logger.info("Semian is not configured for #{self.class.name}: #{semian_identifier}")
+        UnprotectedResource.new(semian_identifier)
+      else
+        options = semian_options.dup
+        options.delete(:name)
+        options[:consumer] = self
+        options[:exceptions] ||= []
+        options[:exceptions] += resource_exceptions
+        ::Semian.retrieve_or_register(semian_identifier, **options)
+      end
+    end
+
+    def clear_semian_resource
+      @semian_resource = nil
+    end
+
+    private
+
+    def acquire_semian_resource(scope:, adapter:, &block)
+      return yield if resource_already_acquired?
+      semian_resource.acquire(scope: scope, adapter: adapter, resource: self) do
+        mark_resource_as_acquired(&block)
+      end
+    rescue ::Semian::OpenCircuitError => error
+      last_error = semian_resource.circuit_breaker.last_error
+      message = "#{error.message} caused by #{last_error.message}"
+      last_error = nil unless last_error.is_a?(Exception) # Net::HTTPServerError is not an exception
+      raise self.class::CircuitOpenError.new(semian_identifier, message), cause: last_error
+    rescue ::Semian::BaseError => error
+      raise self.class::ResourceBusyError.new(semian_identifier, error.message)
+    rescue *resource_exceptions => error
+      error.semian_identifier = semian_identifier if error.respond_to?(:semian_identifier=)
+      raise
+    end
+
+    def semian_options
+      return @semian_options if defined? @semian_options
+      options = raw_semian_options
+      @semian_options = options && options.map { |k, v| [k.to_sym, v] }.to_h
+    end
+
+    def raw_semian_options
+      raise NotImplementedError.new("Semian adapters must implement a `raw_semian_options` method")
+    end
+
+    def resource_exceptions
+      []
+    end
+
+    def resource_already_acquired?
+      @resource_acquired
+    end
+
+    def mark_resource_as_acquired
+      previous = @resource_acquired
+      @resource_acquired = true
+      yield
+    ensure
+      @resource_acquired = previous
+    end
+  end
+end