cool.io 1.4.1-x64-mingw32

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
+}

data/ext/cool.io/watcher.c

@@ -0,0 +1,264 @@
+/*
+ * Copyright (C) 2007-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"
+
+static VALUE mCoolio = Qnil;
+static VALUE cCoolio_Watcher = Qnil;
+
+static VALUE Coolio_Watcher_allocate(VALUE klass);
+static void Coolio_Watcher_mark(struct Coolio_Watcher *watcher);
+static void Coolio_Watcher_free(struct Coolio_Watcher *watcher);
+
+static VALUE Coolio_Watcher_initialize(VALUE self);
+static VALUE Coolio_Watcher_attach(VALUE self, VALUE loop);
+static VALUE Coolio_Watcher_detach(VALUE self);
+static VALUE Coolio_Watcher_enable(VALUE self);
+static VALUE Coolio_Watcher_disable(VALUE self);
+static VALUE Coolio_Watcher_evloop(VALUE self);
+static VALUE Coolio_Watcher_attached(VALUE self);
+static VALUE Coolio_Watcher_enabled(VALUE self);
+
+/* 
+ * Watchers are Coolio's event observers.  They contain a set of callback
+ * methods prefixed by on_* which fire whenever events occur.
+ *
+ * In order for a watcher to fire events it must be attached to a running
+ * loop.  Every watcher has an attach and detach method to control which
+ * loop it's associated with.
+ *
+ * Watchers also have an enable and disable method.  This allows a watcher
+ * to temporarily ignore certain events while remaining attached to a given
+ * loop.  This is good for watchers which need to be toggled on and off.
+ */
+void Init_coolio_watcher()
+{
+  mCoolio = rb_define_module("Coolio");
+  cCoolio_Watcher = rb_define_class_under(mCoolio, "Watcher", rb_cObject);
+  rb_define_alloc_func(cCoolio_Watcher, Coolio_Watcher_allocate);
+
+  rb_define_method(cCoolio_Watcher, "initialize", Coolio_Watcher_initialize, 0);
+  rb_define_method(cCoolio_Watcher, "attach", Coolio_Watcher_attach, 1);
+  rb_define_method(cCoolio_Watcher, "detach", Coolio_Watcher_detach, 0);
+  rb_define_method(cCoolio_Watcher, "enable", Coolio_Watcher_enable, 0);
+  rb_define_method(cCoolio_Watcher, "disable", Coolio_Watcher_disable, 0);
+  rb_define_method(cCoolio_Watcher, "evloop", Coolio_Watcher_evloop, 0);
+  rb_define_method(cCoolio_Watcher, "attached?", Coolio_Watcher_attached, 0);
+  rb_define_method(cCoolio_Watcher, "enabled?", Coolio_Watcher_enabled, 0);
+}
+
+static VALUE Coolio_Watcher_allocate(VALUE klass)
+{
+  struct Coolio_Watcher *watcher_data = (struct Coolio_Watcher *)xmalloc(sizeof(struct Coolio_Watcher));
+
+  watcher_data->loop = Qnil;
+  watcher_data->enabled = 0;
+
+  return Data_Wrap_Struct(klass, Coolio_Watcher_mark, Coolio_Watcher_free, watcher_data);
+}
+
+static void Coolio_Watcher_mark(struct Coolio_Watcher *watcher_data)
+{
+  if(watcher_data->loop != Qnil)
+    rb_gc_mark(watcher_data->loop);
+}
+
+static void Coolio_Watcher_free(struct Coolio_Watcher *watcher_data)
+{
+  xfree(watcher_data);
+}
+
+static VALUE Coolio_Watcher_initialize(VALUE self)
+{
+  rb_raise(rb_eRuntimeError, "watcher base class should not be initialized directly");
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.attach(loop) -> Coolio::Watcher
+ * 
+ * Attach the 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_Watcher_attach(VALUE self, VALUE loop)
+{
+  VALUE loop_watchers, active_watchers;
+  struct Coolio_Watcher *watcher_data;
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data->enabled = 1;
+    
+  loop_watchers = rb_iv_get(loop, "@watchers");
+
+  if(loop_watchers == Qnil) {
+    /* we should never get here */
+    loop_watchers = rb_hash_new();
+    rb_iv_set(loop, "@watchers", loop_watchers);
+  }
+
+  /* Add us to the loop's array of active watchers.  This is mainly done
+   * to keep the VM from garbage collecting watchers that are associated
+   * with a loop (and also lets you see within Ruby which watchers are
+   * associated with a given loop), but isn't really necessary for any 
+   * other reason */
+  rb_hash_aset(loop_watchers, self, Qtrue);
+
+  active_watchers = rb_iv_get(loop, "@active_watchers");
+  if(active_watchers == Qnil)
+    active_watchers = INT2NUM(1);
+  else
+    active_watchers = INT2NUM(NUM2INT(active_watchers) + 1);
+  rb_iv_set(loop, "@active_watchers", active_watchers);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.detach -> Coolio::Watcher
+ * 
+ * Detach the watcher from its current Coolio::Loop.
+ */
+static VALUE Coolio_Watcher_detach(VALUE self)
+{
+  struct Coolio_Watcher *watcher_data;
+  struct Coolio_Loop *loop_data;
+  VALUE loop_watchers;
+  int i;
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  if(watcher_data->loop == Qnil)
+    rb_raise(rb_eRuntimeError, "not attached to a loop");
+
+  loop_watchers = rb_iv_get(watcher_data->loop, "@watchers");
+
+  /* Remove us from the loop's array of active watchers.  This likely
+   * has negative performance and scalability characteristics as this
+   * isn't an O(1) operation.  Hopefully there's a better way...
+   * Trying a hash for now... */
+  rb_hash_delete(loop_watchers, self);
+
+  if(watcher_data->enabled) {
+    rb_iv_set(
+        watcher_data->loop, 
+        "@active_watchers",
+        INT2NUM(NUM2INT(rb_iv_get(watcher_data->loop, "@active_watchers")) - 1)
+    );
+  }
+
+  watcher_data->enabled = 0;
+
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+
+  /* Iterate through the events in the loop's event buffer.  If there
+   * are any pending events from this watcher, mark them NULL.  The
+   * dispatch loop will skip them.  This prevents watchers earlier
+   * in the event buffer from detaching others which may have pending
+   * events in the buffer but get garbage collected in the meantime */
+  for(i = 0; i < loop_data->events_received; i++) {
+    if(loop_data->eventbuf[i].watcher == self)
+      loop_data->eventbuf[i].watcher = Qnil;
+  }
+
+  watcher_data->loop = Qnil;
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.enable -> Coolio::Watcher
+ * 
+ * Re-enable a watcher which has been temporarily disabled.  See the
+ * disable method for a more thorough explanation.
+ */
+static VALUE Coolio_Watcher_enable(VALUE self)
+{
+  struct Coolio_Watcher *watcher_data;
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  if(watcher_data->enabled)
+    rb_raise(rb_eRuntimeError, "already enabled");
+
+  watcher_data->enabled = 1;
+
+  rb_iv_set(
+      watcher_data->loop, 
+      "@active_watchers",
+      INT2NUM(NUM2INT(rb_iv_get(watcher_data->loop, "@active_watchers")) + 1)
+  );
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.disable -> Coolio::Watcher
+ * 
+ * Temporarily disable an event watcher which is attached to a loop.  
+ * This is useful if you wish to toggle event monitoring on and off.  
+ */
+static VALUE Coolio_Watcher_disable(VALUE self)
+{
+  struct Coolio_Watcher *watcher_data;
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  if(!watcher_data->enabled)
+    rb_raise(rb_eRuntimeError, "already disabled");
+
+  watcher_data->enabled = 0;
+
+  rb_iv_set(
+      watcher_data->loop, 
+      "@active_watchers",
+      INT2NUM(NUM2INT(rb_iv_get(watcher_data->loop, "@active_watchers")) - 1)
+  );
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.evloop -> Coolio::Loop
+ * 
+ * Return the loop to which we're currently attached
+ */
+static VALUE Coolio_Watcher_evloop(VALUE self)
+{
+  struct Coolio_Watcher *watcher_data;
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  return watcher_data->loop;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.attached? -> Boolean
+ * 
+ * Is the watcher currently attached to an event loop?
+ */
+static VALUE Coolio_Watcher_attached(VALUE self)
+{
+  return Coolio_Watcher_evloop(self) != Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.enabled? -> Boolean
+ * 
+ * Is the watcher currently enabled?
+ */
+static VALUE Coolio_Watcher_enabled(VALUE self)
+{
+	struct Coolio_Watcher *watcher_data;
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  
+	return watcher_data->enabled ? Qtrue : Qfalse;
+}