semian 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b36c09e6dccc4e072f3aac227c2cdb9d34310342
-  data.tar.gz: 8aae6e974ae678aa7f9cd97ec33addbb893c354b
+  metadata.gz: 04219b7eea123cad23d49905ec52c376484013fb
+  data.tar.gz: 4922f4c4f148425ebb7d1ced40dc8bf6fc3454ec
 SHA512:
-  metadata.gz: 1f13efc113b4bd1cf589ce12f8a2528df8e9d68e671e6ced785eac20e1deb97e523bc9057b01024cee7c5e41fc7045755846471108bf2b1d971e13d86e19d01f
-  data.tar.gz: 0280c4d59e8af8307c6f46c5bbb91c2f631b27ae306dd8c7009d583c6470b7cb74eee74b60e96b7db68d6ae53c8a4dc92dbf310fc806acffe01b395565c2a85d
+  metadata.gz: 896373f2c1401134888a8ac3d503663bcbec528f7d304173196310ec7a585f3e5c01faa0c92ce199ba935b8324e4fa57a1f177f77503bfcd59219e64f576952e
+  data.tar.gz: ea74197c538ba50e31c01a518570f3bb94f60d5f28be77554616dc9c2595cbf4be24e280cff612d66ef0c970737f025971f93316c2c6a9a3d9a83e1472698e20

data/.gitignore

@@ -3,3 +3,4 @@
 /lib/semian/*.bundle
 /tmp/*
 *.gem
+/html/

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    semian (0.0.2)
+    semian (0.0.4)
 
 GEM
   remote: https://rubygems.org/

data/Rakefile

@@ -30,3 +30,11 @@ Rake::TestTask.new 'test' do |t|
   t.test_files = FileList['test/test_*.rb']
 end
 task :test => :build
+
+# ==========================================================
+# Documentation
+# ==========================================================
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_files.include("lib/*.rb", "ext/semian/*.c")
+end

data/ext/semian/extconf.rb

@@ -1,9 +1,7 @@
 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')
+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'
@@ -12,4 +10,11 @@ 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.has_key?('DEBUG')
+  $CFLAGS << "-O0 -g"
+else
+  $CFLAGS << "-O3"
+end
+
 create_makefile('semian/semian')

data/ext/semian/semian.c

@@ -1,6 +1,7 @@
 #include <sys/types.h>
 #include <sys/ipc.h>
 #include <sys/sem.h>
+#include <sys/time.h>
 #include <errno.h>
 #include <string.h>
 
@@ -12,6 +13,14 @@
 
 #include <stdio.h>
 
+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) */
+};
+
 #if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && defined(HAVE_RUBY_THREAD_H)
 // 2.0
 #include <ruby/thread.h>
@@ -23,7 +32,14 @@ typedef VALUE (*my_blocking_fn_t)(void*);
 #endif
 
 static ID id_timeout;
-static VALUE eSyscall, eTimeout;
+static VALUE eSyscall, eTimeout, eInternal;
+static int system_max_sempahore_count;
+
+static const int kIndexTickets = 0;
+static const int kIndexTicketMax = 1;
+static const int kIndexLock = 2;
+
+static const int kNumSemaphores = 3;
 
 typedef struct {
   int sem_id;
@@ -35,10 +51,13 @@ typedef struct {
 static key_t
 generate_key(const char *name)
 {
-  char digest[SHA_DIGEST_LENGTH];
-  SHA1(name, strlen(name), digest);
+  union {
+    unsigned char str[SHA_DIGEST_LENGTH];
+    key_t key;
+  } digest;
+  SHA1((const unsigned char *) name, strlen(name), digest.str);
   /* TODO: compile-time assertion that sizeof(key_t) > SHA_DIGEST_LENGTH */
-  return *((key_t *) digest);
+  return digest.key;
 }
 
 static void
@@ -96,11 +115,168 @@ semian_resource_alloc(VALUE klass)
   return obj;
 }
 
+static void
+set_sempahore_permissions(int sem_id, int 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);
+  }
+}
+
+static const int kInternalTimeout = 5; /* seconds */
+
+static int
+get_max_tickets(int sem_id)
+{
+  int ret = semctl(sem_id, kIndexTicketMax, GETVAL);
+  if (ret == -1) {
+    rb_raise(eInternal, "error getting max ticket count, errno: %d (%s)", errno, strerror(errno));
+  }
+  return ret;
+}
+
+static int
+perform_semop(int sem_id, short index, short op, short flags, struct timespec *ts)
+{
+  struct sembuf buf = { 0 };
+
+  buf.sem_num = index;
+  buf.sem_op  = op;
+  buf.sem_flg = flags;
+
+  if (ts) {
+    return semtimedop(sem_id, &buf, 1, ts);
+  } else {
+    return semop(sem_id, &buf, 1);
+  }
+}
+
+typedef struct {
+  int sem_id;
+  int tickets;
+} update_ticket_count_t;
+
+static VALUE
+update_ticket_count(update_ticket_count_t *tc)
+{
+  short delta;
+  struct timespec ts = { 0 };
+  ts.tv_sec = kInternalTimeout;
+
+  if (get_max_tickets(tc->sem_id) != tc->tickets) {
+    delta = tc->tickets - get_max_tickets(tc->sem_id);
+
+    if (perform_semop(tc->sem_id, kIndexTickets, delta, 0, &ts) == -1) {
+      rb_raise(eInternal, "error setting ticket count, errno: %d (%s)", errno, strerror(errno));
+    }
+
+    if (semctl(tc->sem_id, kIndexTicketMax, SETVAL, tc->tickets) == -1) {
+      rb_raise(eInternal, "error updating max ticket count, errno: %d (%s)", errno, strerror(errno));
+    }
+  }
+
+  return Qnil;
+}
+
+static void
+configure_tickets(int sem_id, int tickets, int should_initialize)
+{
+  struct timespec ts = { 0 };
+  unsigned short init_vals[kNumSemaphores];
+  struct timeval start_time, cur_time;
+  update_ticket_count_t tc;
+  int state;
+
+  if (should_initialize) {
+    init_vals[kIndexTickets] = init_vals[kIndexTicketMax] = tickets;
+    init_vals[kIndexLock] = 1;
+    if (semctl(sem_id, 0, SETALL, init_vals) == -1) {
+      raise_semian_syscall_error("semctl()", errno);
+    }
+  } else if (tickets > 0) {
+    /* it's possible that we haven't actually initialized the
+       sempahore structure yet - wait a bit in that case */
+    if (get_max_tickets(sem_id) == 0) {
+      gettimeofday(&start_time, NULL);
+      while (get_max_tickets(sem_id) == 0) {
+        usleep(10000); /* 10ms */
+        gettimeofday(&cur_time, NULL);
+        if ((cur_time.tv_sec - start_time.tv_sec) > kInternalTimeout) {
+          rb_raise(eInternal, "timeout waiting for semaphore initialization");
+        }
+      }
+    }
+
+    /*
+       If the current max 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_max_tickets) to the semaphore value.
+    */
+    if (get_max_tickets(sem_id) != tickets) {
+      ts.tv_sec = kInternalTimeout;
+
+      if (perform_semop(sem_id, kIndexLock, -1, SEM_UNDO, &ts) == -1) {
+        raise_semian_syscall_error("error acquiring internal semaphore lock, semtimedop()", errno);
+      }
+
+      tc.sem_id = sem_id;
+      tc.tickets = tickets;
+      rb_protect((VALUE (*)(VALUE)) update_ticket_count, (VALUE) &tc, &state);
+
+      if (perform_semop(sem_id, kIndexLock, 1, SEM_UNDO, NULL) == -1) {
+        raise_semian_syscall_error("error releasing internal semaphore lock, semop()", errno);
+      }
+
+      if (state) {
+        rb_jump_tag(state);
+      }
+    }
+  }
+}
+
+static int
+create_semaphore(int key, int permissions, int *created)
+{
+  int semid = 0;
+  int flags = 0;
+
+  *created = 0;
+  flags = IPC_EXCL | IPC_CREAT | FIX2LONG(permissions);
+
+  semid = semget(key, kNumSemaphores, flags);
+  if (semid >= 0) {
+    *created = 1;
+  } else if (semid == -1 && errno == EEXIST) {
+    flags &= ~IPC_EXCL;
+    semid = semget(key, kNumSemaphores, flags);
+  }
+  return semid;
+}
+
+static int
+get_semaphore(int key)
+{
+  return semget(key, kNumSemaphores, 0);
+}
+
+/*
+ * call-seq:
+ *    Semian::Resource.new(id, tickets, permissions, default_timeout) -> resource
+ *
+ * Creates a new Resource. Do not create resources directly. Use Semian.register.
+ */
 static VALUE
-semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE default_timeout)
+semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE permissions, VALUE default_timeout)
 {
   key_t key;
-  int flags = S_IRUSR | S_IWUSR;
+  int created = 0;
   semian_resource_t *res = NULL;
   const char *id_str = NULL;
 
@@ -108,11 +284,12 @@ semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE default_ti
     rb_raise(rb_eTypeError, "id must be a symbol or string");
   }
   Check_Type(tickets, T_FIXNUM);
+  Check_Type(permissions, 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 (FIX2LONG(tickets) < 0 || FIX2LONG(tickets) > system_max_sempahore_count) {
+    rb_raise(rb_eArgError, "ticket count must be a non-negative value and less than %d", system_max_sempahore_count);
   }
   if (NUM2DBL(default_timeout) < 0) {
     rb_raise(rb_eArgError, "default timeout must be non-negative value");
@@ -128,19 +305,14 @@ semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE default_ti
   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);
+  res->sem_id = FIX2LONG(tickets) == 0 ? get_semaphore(key) : create_semaphore(key, permissions, &created);
   if (res->sem_id == -1) {
     raise_semian_syscall_error("semget()", errno);
   }
 
-  if (FIX2LONG(tickets) != 0
-      && semctl(res->sem_id, 0, SETVAL, FIX2LONG(tickets)) == -1) {
-    raise_semian_syscall_error("semctl()", errno);
-  }
+  configure_tickets(res->sem_id, FIX2LONG(tickets), created);
+
+  set_sempahore_permissions(res->sem_id, FIX2LONG(permissions));
 
   return self;
 }
@@ -150,8 +322,7 @@ 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, SEM_UNDO };
-  if (semop(res->sem_id, &buf, 1) == -1) {
+  if (perform_semop(res->sem_id, kIndexTickets, 1, SEM_UNDO, NULL) == -1) {
     res->error = errno;
   }
   return Qnil;
@@ -161,14 +332,24 @@ 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) {
+  if (perform_semop(res->sem_id, kIndexTickets, -1, SEM_UNDO, &res->timeout) == -1) {
     res->error = errno;
   }
   return NULL;
 }
 
+/*
+ * 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.
+ *
+ */
 static VALUE
 semian_resource_acquire(int argc, VALUE *argv, VALUE self)
 {
@@ -208,6 +389,16 @@ semian_resource_acquire(int argc, VALUE *argv, VALUE self)
   return rb_ensure(rb_yield, self, cleanup_semian_resource_acquire, 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.
+ */
 static VALUE
 semian_resource_destroy(VALUE self)
 {
@@ -221,6 +412,12 @@ semian_resource_destroy(VALUE self)
   return Qtrue;
 }
 
+/*
+ * call-seq:
+ *    resource.count -> count
+ *
+ * Returns the current ticket count for a resource.
+ */
 static VALUE
 semian_resource_count(VALUE self)
 {
@@ -236,21 +433,81 @@ semian_resource_count(VALUE self)
   return LONG2FIX(ret);
 }
 
+/*
+ * call-seq:
+ *    resource.semid -> id
+ *
+ * Returns the SysV semaphore id of a resource.
+ */
+static 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);
+}
+
 void Init_semian()
 {
   VALUE cSemian, cResource, eBaseError;
+  struct seminfo info_buf;
 
   cSemian = rb_define_class("Semian", rb_cObject);
-  cResource = rb_define_class("Resource", cSemian);
+
+  /*
+   * 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_define_class_under(cSemian, "Resource", rb_cObject);
+
+  /* Document-class: Semian::BaseError
+   *
+   * Base error class for all other Semian errors.
+   */
   eBaseError = rb_define_class_under(cSemian, "BaseError", rb_eStandardError);
+
+  /* Document-class: Semian::SyscallError
+   *
+   * Represents a Semian error that was caused by an underlying syscall failure.
+   */
   eSyscall = rb_define_class_under(cSemian, "SyscallError", eBaseError);
+
+  /* Document-class: Semian::TimeoutError
+   *
+   * Raised when a Semian operation timed out.
+   */
   eTimeout = rb_define_class_under(cSemian, "TimeoutError", eBaseError);
 
+  /* 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_define_class_under(cSemian, "InternalError", eBaseError);
+
   rb_define_alloc_func(cResource, semian_resource_alloc);
-  rb_define_method(cResource, "initialize", semian_resource_initialize, 3);
+  rb_define_method(cResource, "initialize", semian_resource_initialize, 4);
   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, "destroy", semian_resource_destroy, 0);
 
   id_timeout = rb_intern("timeout");
+
+  if (semctl(0, 0, SEM_INFO, &info_buf) == -1) {
+    rb_raise(eInternal, "unable to determine maximum sempahore count - semctl() returned %d: %s ", errno, strerror(errno));
+  }
+  system_max_sempahore_count = info_buf.semvmx;
+
+  /* Maximum number of tickets available on this system. */
+  rb_define_const(cSemian, "MAX_TICKETS", INT2FIX(system_max_sempahore_count));
 }

data/lib/semian/version.rb

@@ -1,3 +1,3 @@
 class Semian
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/semian.rb

@@ -1,16 +1,84 @@
 require 'semian/semian'
 
+#
+# === Overview
+#
+# Semian is a library that can be used to control access to external services.
+#
+# It's desirable to control access to external services so that in the case that one
+# is slow or not responding, the performance of an entire system is not compromised.
+#
+# Semian uses the concept of a "resource" as an identifier that controls access
+# to some external service. So for example, "mysql" or "redis" would be considered
+# resources. If a system is sharded, like a database, you would typically create
+# a resource for every shard.
+#
+# Resources are visible across an IPC namespace. This means that you can register a
+# resource in one process and access it from another. This is useful in application
+# servers like Unicorn that are multi-process. A resource is persistent. It will
+# continue to exist even after the application exits, and will only be destroyed by
+# manually removing it with the <code>ipcrm</code> command, calling Resource.destroy,
+# or rebooting the machine.
+#
+# Each resource has a configurable number of tickets. Tickets are what controls
+# access to the external service. If a client does not have a ticket, it cannot access
+# a service. If there are no tickets available, the client will block for a configurable
+# amount of time until a ticket is available. If there are no tickets available after
+# the timeout period has elapsed, the client will be unable to access the service and
+# an error will be raised.
+#
+# A resource is registered by using the Semian.register method.
+#
+# ==== Examples
+#
+# ===== Registering a resource
+#
+#    Semian.register :mysql_shard0, tickets: 10, timeout: 0.5
+#
+# This registers a new resource called <code>:mysql_shard0</code> that has 10 tickets andd a default timeout of 500 milliseconds.
+#
+# ===== Using a resource
+#
+#    Semian[:mysql_shard0].acquire do
+#      # Perform a MySQL query here
+#    end
+#
+# This acquires a ticket for the <code>:mysql_shard0</code> resource. If we use the example above, the ticket count would
+# be lowered to 9 when block is executed, then raised to 10 when the block completes.
+#
+# ===== Overriding the default timeout
+#
+#    Semian[:mysql_shard0].acquire(timeout: 1) do
+#      # Perform a MySQL query here
+#    end
+#
+# This is the same as the previous example, but overrides the timeout from the default value of 500 milliseconds to 1 second.
+#
 class Semian
   class << self
-    def register(name, tickets: 0, timeout: 1)
-      resource = Resource.new(name, tickets, timeout)
+    # Registers a resource.
+    #
+    # +name+: Name of the resource - this can be either a string or symbol.
+    #
+    # +tickets+: Number of tickets. If this value is 0, the ticket count will not be set,
+    # but the resource must have been previously registered otherwise an error will be raised.
+    #
+    # +permissions+: Octal permissions of the resource.
+    #
+    # +timeout+: Default timeout in seconds.
+    #
+    # Returns the registered resource.
+    def register(name, tickets: 0, permissions: 0600, timeout: 1)
+      resource = Resource.new(name, tickets, permissions, timeout)
       resources[name] = resource
     end
 
+    # Retrieves a resource by name.
     def [](name)
       resources[name]
     end
 
+    # Retrieves a hash of all registered resources.
     def resources
       @resources ||= {}
     end

data/test/test_semian.rb

@@ -15,6 +15,16 @@ class TestSemian < Test::Unit::TestCase
     assert_raises ArgumentError do
       Semian.register :testing, tickets: -1
     end
+    assert_raises ArgumentError do
+      Semian.register :testing, tickets: 1_000_000
+    end
+    assert_raises TypeError do
+      Semian.register :testing, permissions: "test"
+    end
+  end
+
+  def test_max_tickets
+    assert Semian::MAX_TICKETS > 0
   end
 
   def test_register
@@ -177,4 +187,113 @@ class TestSemian < Test::Unit::TestCase
     end
   end
 
+  def test_permissions
+    Semian.register :testing, permissions: 0600, tickets: 1
+    semid = Semian[:testing].semid
+    `ipcs -s `.lines.each do |line|
+      if /\s#{semid}\s/.match(line)
+        assert_equal '600', line.split[3]
+      end
+    end
+
+    Semian.register :testing, permissions: 0660, tickets: 1
+    semid = Semian[:testing].semid
+    `ipcs -s `.lines.each do |line|
+      if /\s#{semid}\s/.match(line)
+        assert_equal '660', line.split[3]
+      end
+    end
+  end
+
+  def test_resize_tickets_increase
+    Semian.register :testing, tickets: 1
+
+    acquired = false
+    m = Monitor.new
+    cond = m.new_cond
+
+    t = Thread.start do
+      m.synchronize do
+        cond.wait_until { acquired }
+
+        Semian.register :testing, tickets: 5
+        assert_equal 4, Semian[:testing].count
+      end
+    end
+
+    assert_equal 1, Semian[:testing].count
+
+    Semian[:testing].acquire do
+      acquired = true
+      m.synchronize { cond.signal }
+      sleep 0.2
+    end
+
+    t.join
+
+    assert_equal 5, Semian[:testing].count
+  end
+
+  def test_resize_tickets_decrease
+    Semian.register :testing, tickets: 5
+
+    acquired = false
+    m = Monitor.new
+    cond = m.new_cond
+
+    t = Thread.start do
+      m.synchronize do
+        cond.wait_until { acquired }
+
+        Semian.register :testing, tickets: 1
+        assert_equal 0, Semian[:testing].count
+      end
+    end
+
+    assert_equal 5, Semian[:testing].count
+
+    Semian[:testing].acquire do
+      acquired = true
+      m.synchronize { cond.signal }
+      sleep 0.2
+    end
+
+    t.join
+
+    assert_equal 1, Semian[:testing].count
+  end
+
+  def test_multiple_register_with_fork
+    f = Tempfile.new('semian_test')
+
+    begin
+      f.flock(File::LOCK_EX)
+
+      children = []
+      5.times do
+        children << fork do
+          acquired = false
+
+          f.flock(File::LOCK_SH)
+          Semian.register(:testing, tickets: 5).acquire do |resource|
+            assert resource.count < 5
+            acquired = true
+          end
+          assert acquired
+        end
+      end
+      children.compact!
+
+      f.flock(File::LOCK_UN)
+
+      while children.any? do
+        children.delete(Process.wait)
+      end
+
+      assert_equal 5, Semian.register(:testing).count
+    ensure
+      f.close!
+    end
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semian
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Scott Francis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-29 00:00:00.000000000 Z
+date: 2014-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler