cool.io 0.9.0

data/ext/cool.io/stat_watcher.c

@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2009-10 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include "ruby.h"
+#include "ev_wrap.h"
+
+#include "cool.io.h"
+#include "watcher.h"
+
+static VALUE mCoolio = Qnil;
+static VALUE cCoolio_Watcher = Qnil;
+static VALUE cCoolio_StatWatcher = Qnil;
+static VALUE cCoolio_Loop = Qnil;
+
+static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE Coolio_StatWatcher_attach(VALUE self, VALUE loop);
+static VALUE Coolio_StatWatcher_detach(VALUE self);
+static VALUE Coolio_StatWatcher_enable(VALUE self);
+static VALUE Coolio_StatWatcher_disable(VALUE self);
+static VALUE Coolio_StatWatcher_on_change(VALUE self);
+static VALUE Coolio_StatWatcher_path(VALUE self);
+
+static void Coolio_StatWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_stat *stat, int revents);
+static void Coolio_StatWatcher_dispatch_callback(VALUE self, int revents);
+
+/*
+ * Coolio::StatWatcher lets you create either one-shot or periodic stats which
+ * run within Coolio's event loop.  It's useful for creating timeouts or
+ * events which fire periodically.
+ */
+void Init_coolio_stat_watcher()
+{ 
+  mCoolio = rb_define_module("Coolio");
+  cCoolio_Watcher = rb_define_class_under(mCoolio, "Watcher", rb_cObject);
+  cCoolio_StatWatcher = rb_define_class_under(mCoolio, "StatWatcher", cCoolio_Watcher);
+  cCoolio_Loop = rb_define_class_under(mCoolio, "Loop", rb_cObject);
+
+  rb_define_method(cCoolio_StatWatcher, "initialize", Coolio_StatWatcher_initialize, -1);
+  rb_define_method(cCoolio_StatWatcher, "attach", Coolio_StatWatcher_attach, 1);
+  rb_define_method(cCoolio_StatWatcher, "detach", Coolio_StatWatcher_detach, 0);
+  rb_define_method(cCoolio_StatWatcher, "enable", Coolio_StatWatcher_enable, 0);
+  rb_define_method(cCoolio_StatWatcher, "disable", Coolio_StatWatcher_disable, 0);
+  rb_define_method(cCoolio_StatWatcher, "on_change", Coolio_StatWatcher_on_change, 0);
+  rb_define_method(cCoolio_StatWatcher, "path", Coolio_StatWatcher_path, 0);
+}
+
+/**
+ *  call-seq:
+ *    Coolio::StatWatcher.initialize(path, interval = 0) -> Coolio::StatWatcher
+ * 
+ * Create a new Coolio::StatWatcher for the given path.  This will monitor the
+ * given path for changes at the filesystem level.  The interval argument
+ * specified how often in seconds the path should be polled for changes.
+ * Setting interval to zero uses an "automatic" value (typically around 5
+ * seconds) which optimizes performance.  Otherwise, values less than
+ * 0.1 are not particularly meaningful.  Where available (at present, on Linux)
+ * high performance file monitoring interfaces will be used instead of polling.
+ */
+static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self)
+{
+	VALUE path, interval;
+  struct Coolio_Watcher *watcher_data;
+
+  rb_scan_args(argc, argv, "11", &path, &interval);
+  if(interval != Qnil)
+    interval = rb_convert_type(interval, T_FLOAT, "Float", "to_f");
+
+  path = rb_String(path);
+  rb_iv_set(self, "@path", path);
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  watcher_data->dispatch_callback = Coolio_StatWatcher_dispatch_callback;
+  ev_stat_init(
+      &watcher_data->event_types.ev_stat, 
+      Coolio_StatWatcher_libev_callback, 
+      RSTRING_PTR(path), 
+      interval == Qnil ? 0 : NUM2DBL(interval)
+  );  
+  watcher_data->event_types.ev_stat.data = (void *)self;
+
+  return Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::StatWatcher.attach(loop) -> Coolio::StatWatcher
+ * 
+ * Attach the stat watcher to the given Coolio::Loop.  If the watcher is already
+ * attached to a loop, detach it from the old one and attach it to the new one.
+ */
+static VALUE Coolio_StatWatcher_attach(VALUE self, VALUE loop)
+{
+  ev_tstamp interval, timeout;
+  struct Coolio_Loop *loop_data;
+  struct Coolio_Watcher *watcher_data;
+    
+	if(!rb_obj_is_kind_of(loop, cCoolio_Loop))
+		rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop");
+
+  Data_Get_Struct(loop, struct Coolio_Loop, loop_data);
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  if(watcher_data->loop != Qnil)
+    Coolio_StatWatcher_detach(self);
+
+  watcher_data->loop = loop;
+
+  ev_stat_start(loop_data->ev_loop, &watcher_data->event_types.ev_stat);
+	rb_call_super(1, &loop);
+
+  return self;  
+}
+
+/**
+ *  call-seq:
+ *    Coolio::StatWatcher.detach -> Coolio::StatWatcher
+ * 
+ * Detach the stat watcher from its current Coolio::Loop.
+ */
+static VALUE Coolio_StatWatcher_detach(VALUE self)
+{
+  Watcher_Detach(stat, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::StatWatcher.enable -> Coolio::StatWatcher
+ * 
+ * Re-enable a stat watcher which has been temporarily disabled.  See the
+ * disable method for a more thorough explanation.
+ */
+static VALUE Coolio_StatWatcher_enable(VALUE self)
+{
+  Watcher_Enable(stat, self);
+
+  return self;  
+}
+
+/**
+ *  call-seq:
+ *    Coolio::StatWatcher.disable -> Coolio::StatWatcher
+ * 
+ * Temporarily disable a stat watcher which is attached to a loop.  
+ * This is useful if you wish to toggle event monitoring on and off.  
+ */
+static VALUE Coolio_StatWatcher_disable(VALUE self)
+{
+  Watcher_Disable(stat, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::StatWatcher#on_change -> nil
+ * 
+ * Called whenever the status of the given path changes
+ */
+static VALUE Coolio_StatWatcher_on_change(VALUE self)
+{
+  return Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::StatWatcher#path -> String
+ * 
+ * Retrieve the path associated with this StatWatcher
+ */
+static VALUE Coolio_StatWatcher_path(VALUE self)
+{
+  return rb_iv_get(self, "@path");
+}
+
+/* libev callback */
+static void Coolio_StatWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_stat *stat, int revents)
+{
+  Coolio_Loop_process_event((VALUE)stat->data, revents);
+}
+
+/* Coolio::Loop dispatch callback */
+static void Coolio_StatWatcher_dispatch_callback(VALUE self, int revents)
+{ 
+  rb_funcall(self, rb_intern("on_change"), 0, 0);
+}

data/ext/cool.io/timer_watcher.c

@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 2007 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include "ruby.h"
+#include "ev_wrap.h"
+
+#include "cool.io.h"
+#include "watcher.h"
+
+static VALUE mCoolio = Qnil;
+static VALUE cCoolio_Watcher = Qnil;
+static VALUE cCoolio_TimerWatcher = Qnil;
+static VALUE cCoolio_Loop = Qnil;
+
+static VALUE Coolio_TimerWatcher_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE Coolio_TimerWatcher_attach(VALUE self, VALUE loop);
+static VALUE Coolio_TimerWatcher_detach(VALUE self);
+static VALUE Coolio_TimerWatcher_enable(VALUE self);
+static VALUE Coolio_TimerWatcher_disable(VALUE self);
+static VALUE Coolio_TimerWatcher_reset(VALUE self);
+static VALUE Coolio_TimerWatcher_on_timer(VALUE self);
+
+static void Coolio_TimerWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents);
+static void Coolio_TimerWatcher_dispatch_callback(VALUE self, int revents);
+
+/*
+ * Coolio::TimerWatcher lets you create either one-shot or periodic timers which
+ * run within Coolio's event loop.  It's useful for creating timeouts or
+ * events which fire periodically.
+ */
+void Init_coolio_timer_watcher()
+{ 
+  mCoolio = rb_define_module("Coolio");
+  cCoolio_Watcher = rb_define_class_under(mCoolio, "Watcher", rb_cObject);
+  cCoolio_TimerWatcher = rb_define_class_under(mCoolio, "TimerWatcher", cCoolio_Watcher);
+  cCoolio_Loop = rb_define_class_under(mCoolio, "Loop", rb_cObject);
+
+  rb_define_method(cCoolio_TimerWatcher, "initialize", Coolio_TimerWatcher_initialize, -1);
+  rb_define_method(cCoolio_TimerWatcher, "attach", Coolio_TimerWatcher_attach, 1);
+  rb_define_method(cCoolio_TimerWatcher, "detach", Coolio_TimerWatcher_detach, 0);
+  rb_define_method(cCoolio_TimerWatcher, "enable", Coolio_TimerWatcher_enable, 0);
+  rb_define_method(cCoolio_TimerWatcher, "disable", Coolio_TimerWatcher_disable, 0);
+  rb_define_method(cCoolio_TimerWatcher, "reset", Coolio_TimerWatcher_reset, 0);
+  rb_define_method(cCoolio_TimerWatcher, "on_timer", Coolio_TimerWatcher_on_timer, 0);
+}
+
+/**
+ *  call-seq:
+ *    Coolio::TimerWatcher.initialize(interval, repeating = false) -> Coolio::TimerWatcher
+ * 
+ * Create a new Coolio::TimerWatcher for the given IO object and add it to the 
+ * given Coolio::Loop.  Interval defines a duration in seconds to wait for events,
+ * and can be specified as an Integer or Float.  Repeating is a boolean 
+ * indicating whether the timer is one shot or should fire on the given 
+ * interval.
+ */
+static VALUE Coolio_TimerWatcher_initialize(int argc, VALUE *argv, VALUE self)
+{
+	VALUE interval, repeating;
+  struct Coolio_Watcher *watcher_data;
+
+	rb_scan_args(argc, argv, "11", &interval, &repeating);
+  interval = rb_convert_type(interval, T_FLOAT, "Float", "to_f");
+
+  rb_iv_set(self, "@interval", interval);
+  rb_iv_set(self, "@repeating", repeating);
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  watcher_data->dispatch_callback = Coolio_TimerWatcher_dispatch_callback;
+  ev_timer_init(
+      &watcher_data->event_types.ev_timer, 
+      Coolio_TimerWatcher_libev_callback, 
+      NUM2DBL(interval), 
+      repeating == Qtrue ? NUM2DBL(interval) : 0
+  );  
+  watcher_data->event_types.ev_timer.data = (void *)self;
+
+  return Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::TimerWatcher.attach(loop) -> Coolio::TimerWatcher
+ * 
+ * Attach the timer watcher to the given Coolio::Loop.  If the watcher is already
+ * attached to a loop, detach it from the old one and attach it to the new one.
+ */
+static VALUE Coolio_TimerWatcher_attach(VALUE self, VALUE loop)
+{
+  ev_tstamp interval, timeout;
+  struct Coolio_Loop *loop_data;
+  struct Coolio_Watcher *watcher_data;
+    
+	if(!rb_obj_is_kind_of(loop, cCoolio_Loop))
+		rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop");
+
+  Data_Get_Struct(loop, struct Coolio_Loop, loop_data);
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  if(watcher_data->loop != Qnil)
+    Coolio_TimerWatcher_detach(self);
+
+  watcher_data->loop = loop;
+  
+  /* Calibrate timeout to account for potential drift */
+	interval = NUM2DBL(rb_iv_get(self, "@interval"));
+  timeout = interval + ev_time() - ev_now(loop_data->ev_loop);
+  
+  ev_timer_set(
+    &watcher_data->event_types.ev_timer, 
+    timeout, 
+    rb_iv_get(self, "@repeating") == Qtrue ? interval : 0
+  );
+
+  ev_timer_start(loop_data->ev_loop, &watcher_data->event_types.ev_timer);
+	rb_call_super(1, &loop);
+
+  return self;  
+}
+
+/**
+ *  call-seq:
+ *    Coolio::TimerWatcher.detach -> Coolio::TimerWatcher
+ * 
+ * Detach the timer watcher from its current Coolio::Loop.
+ */
+static VALUE Coolio_TimerWatcher_detach(VALUE self)
+{
+  Watcher_Detach(timer, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::TimerWatcher.enable -> Coolio::TimerWatcher
+ * 
+ * Re-enable a timer watcher which has been temporarily disabled.  See the
+ * disable method for a more thorough explanation.
+ */
+static VALUE Coolio_TimerWatcher_enable(VALUE self)
+{
+  Watcher_Enable(timer, self);
+
+  return self;  
+}
+
+/**
+ *  call-seq:
+ *    Coolio::TimerWatcher.disable -> Coolio::TimerWatcher
+ * 
+ * Temporarily disable a timer watcher which is attached to a loop.  
+ * This is useful if you wish to toggle event monitoring on and off.  
+ */
+static VALUE Coolio_TimerWatcher_disable(VALUE self)
+{
+  Watcher_Disable(timer, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::TimerWatcher#reset -> Coolio::TimerWatcher
+ * 
+ * Reset the TimerWatcher.  This behaves differently depending on if it's repeating.
+ *
+ * If the timer is pending, its pending status is cleared.
+ * 
+ * If the timer is attached but nonrepeating, stop it (as if it timed out)
+ *
+ * If the timer is repeating, reset it so it will fire again after its given interval
+ */
+static VALUE Coolio_TimerWatcher_reset(VALUE self)
+{
+  struct Coolio_Watcher *watcher_data;
+  struct Coolio_Loop *loop_data;
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  if(watcher_data->loop == Qnil)
+    rb_raise(rb_eRuntimeError, "not attached to a loop");
+
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+
+  ev_timer_again(loop_data->ev_loop, &watcher_data->event_types.ev_timer);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::TimerWatcher#on_timer -> nil
+ * 
+ * Called whenever the TimerWatcher fires
+ */
+static VALUE Coolio_TimerWatcher_on_timer(VALUE self)
+{
+  return Qnil;
+}
+
+/* libev callback */
+static void Coolio_TimerWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
+{
+  Coolio_Loop_process_event((VALUE)timer->data, revents);
+}
+
+/* Coolio::Loop dispatch callback */
+static void Coolio_TimerWatcher_dispatch_callback(VALUE self, int revents)
+{ 
+  if(revents & EV_TIMEOUT)
+    rb_funcall(self, rb_intern("on_timer"), 0, 0);
+  else
+    rb_raise(rb_eRuntimeError, "unknown revents value for ev_timer: %d", revents);
+}

data/ext/cool.io/utils.c

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2007 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include "ruby.h"
+
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
+
+#ifdef HAVE_SYS_SYSCTL_H
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#endif
+
+static VALUE mCoolio = Qnil;
+static VALUE cCoolio_Utils = Qnil;
+
+static VALUE Coolio_Utils_ncpus(VALUE self);
+static VALUE Coolio_Utils_maxfds(VALUE self);
+static VALUE Coolio_Utils_setmaxfds(VALUE self, VALUE max);
+
+/*
+ * Assorted utility routines
+ */
+void Init_coolio_utils()
+{
+  mCoolio = rb_define_module("Coolio");
+  cCoolio_Utils = rb_define_module_under(mCoolio, "Utils");
+
+  rb_define_singleton_method(cCoolio_Utils, "ncpus", Coolio_Utils_ncpus, 0);
+  rb_define_singleton_method(cCoolio_Utils, "maxfds", Coolio_Utils_maxfds, 0);
+  rb_define_singleton_method(cCoolio_Utils, "maxfds=", Coolio_Utils_setmaxfds, 1);
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Utils.ncpus -> Integer
+ * 
+ * Return the number of CPUs in the present system
+ */
+static VALUE Coolio_Utils_ncpus(VALUE self)
+{
+  int ncpus = 0;
+
+#ifdef HAVE_LINUX_PROCFS
+#define HAVE_COOLIO_UTILS_NCPUS
+  char buf[512];
+  FILE *cpuinfo;
+  
+  if(!(cpuinfo = fopen("/proc/cpuinfo", "r")))
+    rb_sys_fail("fopen");
+
+  while(fgets(buf, 512, cpuinfo)) {
+    if(!strncmp(buf, "processor", 9))
+      ncpus++;
+  }
+#endif
+
+#ifdef HAVE_SYSCTLBYNAME
+#define HAVE_COOLIO_UTILS_NCPUS
+  size_t size = sizeof(int);
+
+  if(sysctlbyname("hw.ncpu", &ncpus, &size, NULL, 0)) 
+    return INT2NUM(1);
+#endif
+
+#ifndef HAVE_COOLIO_UTILS_NCPUS
+  rb_raise(rb_eRuntimeError, "operation not supported");
+#endif
+
+  return INT2NUM(ncpus);
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Utils.maxfds -> Integer
+ * 
+ * Return the maximum number of files descriptors available to the process
+ */
+static VALUE Coolio_Utils_maxfds(VALUE self)
+{
+#ifdef HAVE_SYS_RESOURCE_H
+  struct rlimit rlim;
+
+  if(getrlimit(RLIMIT_NOFILE, &rlim) < 0)
+    rb_sys_fail("getrlimit");
+
+  return INT2NUM(rlim.rlim_cur);
+#endif
+
+#ifndef HAVE_SYS_RESOURCE_H
+  rb_raise(rb_eRuntimeError, "operation not supported");
+#endif
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Utils.maxfds=(count) -> Integer
+ * 
+ * Set the number of file descriptors available to the process.  May require
+ * superuser privileges.
+ */
+static VALUE Coolio_Utils_setmaxfds(VALUE self, VALUE max)
+{
+#ifdef HAVE_SYS_RESOURCE_H
+  struct rlimit rlim;
+
+  rlim.rlim_cur = NUM2INT(max);
+
+  if(setrlimit(RLIMIT_NOFILE, &rlim) < 0)
+    rb_sys_fail("setrlimit");
+
+  return max;
+#endif
+
+#ifndef HAVE_SYS_RESOURCE_H
+  rb_raise(rb_eRuntimeError, "operation not supported");
+#endif
+}