semian 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 569ed1de876236ee7b8aee71e9325fd609f6a65c
+  data.tar.gz: 1308dfeea5b5f554d97397a5eb79bfca484d6854
+SHA512:
+  metadata.gz: 1e4e89901bc8654a0003e2a097984520508cf4143735d2d8dd35c0c9112ad292d0ca044f7471e54947a2ec974d07322719174d15226e7ce147140c63cac597c7
+  data.tar.gz: ecf5a1656a9bc1f51111eb9274ebb73844e40161e67894f1abe57dfbd59364e2007d7b5c5b6c5de652b6063d597741f372895b6251fef95316d790c4560022ca

data/.gitignore

@@ -0,0 +1,5 @@
+/.bundle/
+/lib/semian/*.so
+/lib/semian/*.bundle
+/tmp/*
+*.gem

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.1

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    semian (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.3.2)
+    rake-compiler (0.9.3)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake-compiler (~> 0.9)
+  semian!

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Scott Francis <scott.francis@shopify.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+## Semian
+
+[![Build Status](https://travis-ci.org/csfrancis/semian.svg?branch=master)](https://travis-ci.org/csfrancis/semian)
+
+Inspired by the bulkhead resource isolation pattern used in [Hystrix](https://github.com/Netflix/Hystrix/wiki/How-it-Works#Isolation), Semian aims to provide a Ruby API that can be used to control access to external resources.
+
+This can be used with a forking Ruby application server like Unicorn to prevent app server starvation when a resource is slow or not responding.
+
+### Usage
+
+In a master process, register a resource with a specified number of tickets (number of concurrent clients):
+```ruby
+require 'semian'
+
+Semian.register(:mysql_master, tickets: 3, timeout: 0.5)
+```
+
+Then in your child processes, you can use the resource:
+```ruby
+Semian[:mysql_master].acquire do
+	# Query mysql and do things
+end
+```
+
+If you have a process that does not fork, you can still use the same namespace to control access to a shared resource:
+```ruby
+Semian.register(:mysql_master, timeout: 0.5)
+Semian[:mysql_master].acquire do
+	# Query mysql and do things
+end
+```

data/Rakefile

@@ -0,0 +1,32 @@
+task :default => :test
+
+# ==========================================================
+# Packaging
+# ==========================================================
+
+GEMSPEC = eval(File.read('semian.gemspec'))
+
+require 'rubygems/package_task'
+Gem::PackageTask.new(GEMSPEC) do |pkg|
+end
+
+# ==========================================================
+# Ruby Extension
+# ==========================================================
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('semian', GEMSPEC) do |ext|
+  ext.ext_dir = 'ext/semian'
+  ext.lib_dir = 'lib/semian'
+end
+task :build => :compile
+
+# ==========================================================
+# Testing
+# ==========================================================
+
+require 'rake/testtask'
+Rake::TestTask.new 'test' do |t|
+  t.test_files = FileList['test/test_*.rb']
+end
+task :test => :build

data/ext/semian/extconf.rb

@@ -0,0 +1,15 @@
+require 'mkmf'
+
+$CFLAGS = "-O3"
+
+abort 'openssl is missing. please install openssl.' unless find_header('openssl/md5.h')
+abort 'openssl is missing. please install openssl.' unless find_library('crypto', 'MD5_Init')
+
+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'
+
+create_makefile('semian/semian')

data/ext/semian/semian.c

@@ -0,0 +1,248 @@
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/sem.h>
+#include <errno.h>
+#include <string.h>
+
+#include <ruby.h>
+#include <ruby/util.h>
+#include <ruby/io.h>
+
+#include <openssl/sha.h>
+
+#include <stdio.h>
+
+#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
+
+static ID id_timeout;
+static VALUE eTimeout;
+
+typedef struct {
+  int sem_id;
+  struct timespec timeout;
+  int error;
+  char *name;
+} semian_resource_t;
+
+static key_t
+generate_key(const char *name)
+{
+  char digest[SHA_DIGEST_LENGTH];
+  SHA1(name, strlen(name), digest);
+  /* TODO: compile-time assertion that sizeof(key_t) > SHA_DIGEST_LENGTH */
+  return *((key_t *) digest);
+}
+
+static void
+ms_to_timespec(long ms, struct timespec *ts)
+{
+  ts->tv_sec = ms / 1000;
+  ts->tv_nsec = (ms % 1000) * 1000000;
+}
+
+static void
+semian_resource_mark(void *ptr)
+{
+  /* noop */
+}
+
+static 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 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
+};
+
+static 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;
+}
+
+static VALUE
+semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE default_timeout)
+{
+  key_t key;
+  int flags = S_IRUSR | S_IWUSR;
+  semian_resource_t *res = NULL;
+  const char *id_str = NULL;
+
+  if (TYPE(id) != T_SYMBOL && TYPE(id) != T_STRING) {
+    rb_raise(rb_eTypeError, "id must be a symbol or string");
+  }
+  Check_Type(tickets, T_FIXNUM);
+  if (TYPE(default_timeout) != T_FIXNUM && TYPE(default_timeout) != T_FLOAT) {
+    rb_raise(rb_eTypeError, "expected numeric type for default_timeout");
+  }
+  if (FIX2LONG(tickets) < 0) {
+    rb_raise(rb_eArgError, "ticket count must be a non-negative value");
+  }
+  if (NUM2DBL(default_timeout) < 0) {
+    rb_raise(rb_eArgError, "default timeout must be non-negative value");
+  }
+
+  if (TYPE(id) == T_SYMBOL) {
+    id_str = rb_id2name(rb_to_id(id));
+  } else if (TYPE(id) == T_STRING) {
+    id_str = RSTRING_PTR(id);
+  }
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  key = generate_key(id_str);
+  ms_to_timespec(NUM2DBL(default_timeout) * 1000, &res->timeout);
+  res->name = strdup(id_str);
+
+  if (FIX2LONG(tickets) != 0) {
+    flags |= IPC_CREAT;
+  }
+
+  res->sem_id = semget(key, 1, flags);
+  if (res->sem_id == -1) {
+    rb_sys_fail("semget");
+  }
+
+  if (FIX2LONG(tickets) != 0
+      && semctl(res->sem_id, 0, SETVAL, FIX2LONG(tickets)) == -1) {
+    rb_sys_fail("semctl");
+  }
+
+  return self;
+}
+
+static VALUE
+cleanup_semian_resource_acquire(VALUE self)
+{
+  semian_resource_t *res = NULL;
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  struct sembuf buf = { 0, 1, 0 };
+  if (semop(res->sem_id, &buf, 1) == -1) {
+    res->error = errno;
+  }
+  return Qnil;
+}
+
+static void *
+acquire_sempahore_without_gvl(void *p)
+{
+  semian_resource_t *res = (semian_resource_t *) p;
+  struct sembuf buf = { 0, -1, SEM_UNDO };
+  res->error = 0;
+  if (semtimedop(res->sem_id, &buf, 1, &res->timeout) == -1) {
+    res->error = errno;
+  }
+  return NULL;
+}
+
+static 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 */
+  WITHOUT_GVL(acquire_sempahore_without_gvl, &res, RUBY_UBF_IO, NULL);
+  if (res.error != 0) {
+    if (res.error == EAGAIN) {
+      rb_raise(eTimeout, "timed out waiting for resource '%s'", res.name);
+    } else {
+      rb_raise(rb_eRuntimeError, "semop() error: %s (%d)", strerror(res.error), res.error);
+    }
+  }
+
+  return rb_ensure(rb_yield, self, cleanup_semian_resource_acquire, self);
+}
+
+static VALUE
+semian_resource_destroy(VALUE self)
+{
+  semian_resource_t *res = NULL;
+
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  if (semctl(res->sem_id, 0, IPC_RMID) == -1) {
+    rb_sys_fail("semctl");
+  }
+
+  return Qtrue;
+}
+
+static 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, 0, GETVAL);
+  if (ret == -1) {
+    rb_raise(rb_eRuntimeError, "semctl() error: %s (%d)", strerror(errno), errno);
+  }
+
+  return LONG2FIX(ret);
+}
+
+void Init_semian()
+{
+  VALUE cSemian, cResource;
+
+  cSemian = rb_define_class("Semian", rb_cObject);
+  cResource = rb_define_class("Resource", cSemian);
+  eTimeout = rb_define_class_under(cSemian, "Timeout", rb_eStandardError);
+
+  rb_define_alloc_func(cResource, semian_resource_alloc);
+  rb_define_method(cResource, "initialize", semian_resource_initialize, 3);
+  rb_define_method(cResource, "acquire", semian_resource_acquire, -1);
+  rb_define_method(cResource, "count", semian_resource_count, 0);
+  rb_define_method(cResource, "destroy", semian_resource_destroy, 0);
+
+  id_timeout = rb_intern("timeout");
+}

data/lib/semian.rb

@@ -0,0 +1,18 @@
+require 'semian/semian'
+
+class Semian
+  class << self
+    def register(name, tickets: 0, timeout: 1)
+      resource = Resource.new(name, tickets, timeout)
+      resources[name] = resource
+    end
+
+    def [](name)
+      resources[name]
+    end
+
+    def resources
+      @resources ||= {}
+    end
+  end
+end

data/semian.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = 'semian'
+  s.version = '0.0.1'
+  s.summary = 'SysV semaphore based library for shared resource control'
+  s.description = <<-DOC
+    A Ruby C extention that is used to control access to shared resources
+    across process boundaries.
+  DOC
+  s.homepage = 'https://github.com/csfrancis/semian'
+  s.authors = 'Scott Francis'
+  s.email   = 'scott.francis@shopify.com'
+  s.license = 'MIT'
+
+  s.files = `git ls-files`.split("\n")
+  s.extensions = ['ext/semian/extconf.rb']
+  s.add_development_dependency 'rake-compiler', '~> 0.9'
+end

data/test/test_semian.rb

@@ -0,0 +1,166 @@
+require 'test/unit'
+require 'semian'
+require 'tempfile'
+require 'fileutils'
+
+class TestSemian < Test::Unit::TestCase
+  def setup
+    Semian[:testing].destroy rescue RuntimeError
+  end
+
+  def test_register_invalid_args
+    assert_raises TypeError do
+      Semian.register 123
+    end
+    assert_raises ArgumentError do
+      Semian.register :testing, tickets: -1
+    end
+  end
+
+  def test_register
+    Semian.register :testing, tickets: 2
+  end
+
+  def test_register_with_no_tickets_raises
+    assert_raises Errno::ENOENT do
+      Semian.register :testing
+    end
+  end
+
+  def test_acquire
+    acquired = false
+    Semian.register :testing, tickets: 1
+    Semian[:testing].acquire { acquired = true }
+    assert acquired
+  end
+
+  def test_acquire_return_val
+    Semian.register :testing, tickets: 1
+    val = Semian[:testing].acquire { 1234 }
+    assert_equal 1234, val
+  end
+
+  def test_acquire_timeout
+    Semian.register :testing, tickets: 1, timeout: 0.05
+
+    acquired = false
+    m = Monitor.new
+    cond = m.new_cond
+
+    t = Thread.start do
+      m.synchronize do
+        cond.wait_until { acquired }
+        assert_raises Semian::Timeout do
+          Semian[:testing].acquire { refute true }
+        end
+      end
+    end
+
+    Semian[:testing].acquire do
+      acquired = true
+      m.synchronize { cond.signal }
+      sleep 0.2
+    end
+
+    t.join
+
+    assert acquired
+  end
+
+  def test_acquire_timeout_override
+    Semian.register :testing, tickets: 1, timeout: 0.01
+
+    acquired = false
+    thread_acquired = false
+    m = Monitor.new
+    cond = m.new_cond
+
+    t = Thread.start do
+      m.synchronize do
+        cond.wait_until { acquired }
+        Semian[:testing].acquire(timeout: 1) { thread_acquired = true }
+      end
+    end
+
+    Semian[:testing].acquire do
+      acquired = true
+      m.synchronize { cond.signal }
+      sleep 0.2
+    end
+
+    t.join
+
+    assert acquired
+    assert thread_acquired
+  end
+
+  def test_acquire_with_fork
+    Semian.register :testing, tickets: 2, timeout: 0.5
+
+    Semian[:testing].acquire do
+      pid = fork do
+        Semian.register :testing, timeout: 0.5
+        Semian[:testing].acquire do
+          assert_raises Semian::Timeout do
+            Semian[:testing].acquire {  }
+          end
+        end
+      end
+
+      Process.wait
+    end
+  end
+
+  def test_acquire_releases_on_kill
+    begin
+      Semian.register :testing, tickets: 1, timeout: 0.1
+      acquired = false
+
+      # Ghetto process synchronization
+      file = Tempfile.new('semian')
+      path = file.path
+      file.close!
+
+      pid = fork do
+        Semian[:testing].acquire do
+          FileUtils.touch(path)
+          sleep 1000
+        end
+      end
+
+      sleep 0.1 until File.exists?(path)
+      assert_raises Semian::Timeout do
+        Semian[:testing].acquire {}
+      end
+
+      Process.kill("KILL", pid)
+      Semian[:testing].acquire { acquired = true }
+      assert acquired
+
+      Process.wait
+    ensure
+      FileUtils.rm_f(path) if path
+    end
+  end
+
+  def test_count
+    Semian.register :testing, tickets: 2
+    acquired = false
+
+    Semian[:testing].acquire do
+      acquired = true
+      assert_equal 1, Semian[:testing].count
+    end
+
+    assert acquired
+  end
+
+  def test_destroy
+    Semian.register :testing, tickets: 1
+    Semian[:testing].destroy
+    assert_raises RuntimeError do
+      Semian[:testing].acquire { }
+    end
+  end
+
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: semian
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Scott Francis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: |2
+      A Ruby C extention that is used to control access to shared resources
+      across process boundaries.
+email: scott.francis@shopify.com
+executables: []
+extensions:
+- ext/semian/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- ext/semian/extconf.rb
+- ext/semian/semian.c
+- lib/semian.rb
+- semian.gemspec
+- test/test_semian.rb
+homepage: https://github.com/csfrancis/semian
+licenses:
+- MIT
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: SysV semaphore based library for shared resource control
+test_files: []