posixtimer 0.1

data/README

@@ -0,0 +1,58 @@
+# posixtimer v0.1
+#
+# caleb@aei-tech.com
+#
+# Released under the Ruby license
+# 12.09.05
+#
+# Things you can do with a posixtimer:
+#
+# timer = Posix::Timer.new
+#
+# Arm the timer for 10 seconds
+#
+# begin
+#  timer.arm(10.0) 
+#  # ..do something
+#  #
+#
+# rescue SignalException
+#  # The timer times out here
+#
+# end
+#
+#
+# Specify which type of SIGNAL to use:
+#
+# Posix::Timer.new("ALRM") # default
+# Posix::Timer.new("USR1") 
+# ...
+#
+# Pass a block, and it will be called upon timeout
+#
+# a = Posix::Timer.new do
+#   puts "hi"
+#   raise MyCustomException
+# end
+#
+# a.arm(5.0)
+# sleep 10.0
+# 
+# => "hi"
+# MyCustomException is raised
+# 
+# 
+#
+# Caveats
+#
+# 
+# The Posix::Timer instance uses POSIX signals to trigger
+# the timeouts.  This may conflict with other signals you wish to
+# use in your application.
+# 
+# Passing a block to the constructor will perform a Signal.trap on
+# the signal.  This may override an existing Signal.trap.  In a future
+# version I intend to rollback the previous trap context.
+# 
+# Multiple timers using the same signal may conflict.
+

data/ext/extconf.rb

@@ -0,0 +1,10 @@
+require 'mkmf'
+        
+if ( ( have_library('c', 'timer_create') or
+     have_library('rt', 'timer_create') ) and
+     have_header('signal.h') and
+     have_header('time.h') )
+
+  enable_config('with-cflags=-restrict', true)        
+  create_makefile ('posixtimer')
+end

data/ext/posixtimer.c

@@ -0,0 +1,228 @@
+#include "ruby.h"
+#include <signal.h>
+#include <time.h>
+
+typedef struct md {
+  clockid_t clock_id;
+  timer_t timer_id;
+  struct itimerspec tspec;
+  struct sigevent se;
+  struct sigevent *sig_event;
+} mydata;
+
+static mydata* create_timer_data()
+{
+  mydata *data;
+
+  data = malloc(sizeof(mydata));
+  data->clock_id = CLOCK_REALTIME;
+  data->sig_event = NULL;
+
+  return data;
+}
+
+void create_new_timer(mydata *data)
+{
+  int err = timer_create(data->clock_id, data->sig_event, &(data->timer_id));
+  
+  if(err == -1)
+    rb_sys_fail("timer_create()");
+}
+
+static void destroy_timer(mydata *p)
+{
+  timer_delete(p->timer_id);
+}
+
+static void free_timer(void *p)
+{
+  destroy_timer(p);
+  free(p);
+}
+
+static VALUE timer_alloc(VALUE klass)
+{
+  mydata *data;
+  data = create_timer_data();
+
+  create_new_timer(data);
+
+  VALUE obj = Data_Wrap_Struct(klass, 0, free_timer, data);
+  
+  return obj;
+}
+
+/* call-seq:
+*     Posix::Timer.new
+*     Posix::Timer.new("ALRM")
+*     Posix::Timer.new("USR1")
+*     Posix::Timer.new { some_block }
+*
+*  Create a new Posix::Timer object.  The argument passed can be any valid
+*  signal type from Signal.list.
+*
+*  If a block is passed, that block will be executed when the Posix::Timer timeout
+*  has expired.  This is done by trapping the signal specified as creation time, so
+*  be careful if you have other uses of that signal in your program.
+*
+*/
+static VALUE timer_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE sigtype, codeblock;
+  rb_scan_args(argc, argv, "01&", &sigtype, &codeblock);
+
+  if(!NIL_P(sigtype)) Check_Type(sigtype, T_STRING);
+  if(NIL_P(sigtype)) sigtype = rb_str_new2("ALRM");
+
+  VALUE xx_mSignal;
+  xx_mSignal = rb_const_get(rb_cObject, rb_intern("Signal"));
+  
+  VALUE sighash = rb_funcall(xx_mSignal, rb_intern("list"), 0);
+
+  VALUE signal = rb_hash_aref(sighash, sigtype);
+
+  if(NIL_P(signal)) rb_raise(rb_eArgError, "Invalid signal type");
+  Check_Type(signal, T_FIXNUM);
+
+  rb_iv_set(self, "@sigblock", codeblock);
+  rb_iv_set(self, "@sigtype", sigtype);
+
+  mydata *data;
+  Data_Get_Struct(self, mydata, data);
+
+  struct sigevent se;
+
+  data->se.sigev_notify = SIGEV_SIGNAL;
+  data->se.sigev_signo = FIX2INT(signal);
+  data->sig_event = &data->se;
+
+  destroy_timer(data);
+  create_new_timer(data);
+
+  return self;
+}
+
+static VALUE timer_new(int argc, VALUE *argv, VALUE self)
+{
+  VALUE obj = rb_funcall(self, rb_intern("allocate"), 0);
+
+  rb_obj_call_init(obj, argc, argv);
+  return obj;
+}
+
+/* call-seq:
+*    timer.arm(float_time_in_seconds) -> true
+*
+*  Arm the timer for timeout.  A value of 0 disarms the timer.
+*
+*  When the timer timeouts, it will raise a SignalException.  If a block was
+*  passed to the initializer, the SignalException will be caught and the block
+*  will execute instead (and no Exception will be raised).
+*
+*/
+
+static VALUE timer_arm(VALUE klass, VALUE arg)
+{
+  mydata *data;
+
+  int sec, usec=0;
+
+  if(TYPE(arg) == T_FIXNUM) {
+    sec = FIX2INT(arg);
+  }
+  else {
+    Check_Type(arg, T_FLOAT);
+    double offset = NUM2DBL(arg);
+    sec = (int)offset;
+    usec = (int)((offset - (double)((int)offset)) * 1000000000);
+  }
+
+  Data_Get_Struct(klass, mydata, data);
+
+  data->tspec.it_value.tv_sec = sec;
+  data->tspec.it_value.tv_nsec = usec;
+
+  if(timer_settime(data->timer_id, 0, &(data->tspec), NULL) == -1)
+    rb_sys_fail("timer_settime()");
+
+  VALUE sigblock = rb_iv_get(klass, "@sigblock");
+  VALUE sigtype  = rb_iv_get(klass, "@sigtype");
+
+  if(!NIL_P(sigblock)) {
+    VALUE xx_mSignal;
+    xx_mSignal = rb_const_get(rb_cObject, rb_intern("Signal"));
+    VALUE prevblock = rb_funcall(xx_mSignal, rb_intern("trap"), 2, sigtype, sigblock);
+    rb_iv_set(klass, "@prevblock", prevblock);
+  }
+
+  return Qtrue;
+}
+
+/* call-seq:
+*    timer.disarm -> true
+*
+*  Disarm an active timer.  Same as timer.arm(0).
+*/
+static VALUE timer_disarm(VALUE klass)
+{
+  return rb_funcall(klass, rb_intern("arm"), 1, INT2FIX(0) );
+}
+
+/* call-seq:
+*    timer.timeout -> Float
+*
+*   Returns the amount of time (in seconds) left before the timer times out.
+*   Returns nil if the timer isn't currently active
+*/
+static VALUE timer_timeout(VALUE klass)
+{
+  mydata *data;
+
+  Data_Get_Struct(klass, mydata, data);
+
+  if(timer_gettime(data->timer_id, &(data->tspec) ) == -1)
+    rb_sys_fail("timer_gettime()");
+
+  if(data->tspec.it_value.tv_sec == 0 && data->tspec.it_value.tv_nsec == 0)
+    return Qnil;
+
+  double timeout = (double)(data->tspec.it_value.tv_sec) + 
+    ((double)(data->tspec.it_value.tv_nsec) / 1000000000);
+
+  return rb_float_new(timeout);
+}
+
+/* call-seq:
+*    timer.armed? -> true
+*
+*   Return true if the timer is currently armed, false otherwise.
+*/
+static VALUE timer_armed(VALUE klass)
+{
+  VALUE ret = rb_funcall(klass, rb_intern("timeout"), 0 );
+  
+  if(NIL_P(ret))
+    return Qfalse;
+  else
+
+  return Qtrue;
+}
+
+/* Interface to the Posix Timer library calls */
+
+void Init_posixtimer() {
+  VALUE posix_mod = rb_define_module("Posix");
+
+  VALUE timer_class =
+    rb_define_class_under(posix_mod, "Timer", rb_cObject);
+
+  rb_define_alloc_func(timer_class, timer_alloc);
+
+  rb_define_singleton_method(timer_class, "new", timer_new, -1);
+
+  rb_define_method(timer_class, "initialize", timer_initialize, -1);
+  rb_define_method(timer_class, "arm", timer_arm, 1);
+  rb_define_method(timer_class, "disarm", timer_disarm, 0);
+  rb_define_method(timer_class, "armed?", timer_armed, 0);
+  rb_define_method(timer_class, "timeout", timer_timeout, 0);
+}

data/test/timertests.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+require 'posixtimer'
+
+class TimerTest < Test::Unit::TestCase
+
+  def test_initialization_methods
+    assert_nothing_raised(ArgumentError) { Posix::Timer.new }
+    assert_nothing_raised(ArgumentError) { Posix::Timer.new("USR1") }
+    assert_nothing_raised(ArgumentError) { Posix::Timer.new("ALRM") }
+
+    assert_nothing_raised(ArgumentError) { Posix::Timer.new { puts "hi" } }
+
+    assert_raise(ArgumentError) { Posix::Timer.new("BLAH") }
+    assert_raise(TypeError) { Posix::Timer.new(10) }
+  end
+
+  def test_initialization_with_block
+  end
+
+  def test_timer_arming
+    a = Posix::Timer.new
+    assert a.armed? == false
+    a.arm(5)
+    assert a.armed? == true
+    a.disarm
+    assert a.armed? == false
+  end
+
+  def test_timer_exception
+    assert_raise(SignalException) do
+      b = Posix::Timer.new
+      b.arm(0.1) 
+      sleep 0.5
+    end
+  end
+
+  def test_timer_with_block
+    i = 5
+    a = Posix::Timer.new { i = 10 }
+    assert_nothing_raised(SignalException) {
+      a.arm(1)
+      sleep(2) 
+    }
+
+    assert i == 10
+  end
+
+end

metadata

@@ -0,0 +1,47 @@
+!ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: posixtimer
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2005-12-09 00:00:00 -05:00
+summary: A class that provides a definable timeout
+require_paths: 
+- .
+email: caleb@aei-tech.com
+homepage: ""
+rubyforge_project: 
+description: 
+autorequire: posixtimer
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Caleb Tennis
+files: 
+- ext/posixtimer.c
+- ext/extconf.rb
+- README
+test_files: 
+- test/timertests.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: 
+- ext/extconf.rb
+requirements: []
+
+dependencies: []
+