cool.io 1.2.0-x86-mingw32

data/ext/cool.io/libev.c

@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2007 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include "ev_wrap.h"
+#include "../libev/ev.c"

data/ext/cool.io/loop.c

@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2007-10 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include <assert.h>
+#include "ruby.h"
+#include "rubysig.h"
+#include "ev_wrap.h"
+
+#include "cool.io.h"
+
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#  define Coolio_Loop_may_block_safely() (1)
+#elif defined(HAVE_RB_THREAD_ALONE)
+#  define Coolio_Loop_may_block_safely() (rb_thread_alone())
+#else /* just in case Ruby changes: */
+#  define Coolio_Loop_may_block_safely() (0)
+#endif
+
+static VALUE mCoolio = Qnil;
+static VALUE cCoolio_Loop = Qnil;
+
+static VALUE Coolio_Loop_allocate(VALUE klass);
+static void Coolio_Loop_mark(struct Coolio_Loop *loop);
+static void Coolio_Loop_free(struct Coolio_Loop *loop);
+
+static VALUE Coolio_Loop_initialize(VALUE self);
+static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags);
+static VALUE Coolio_Loop_run_once(VALUE self);
+static VALUE Coolio_Loop_run_nonblock(VALUE self);
+
+static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data);
+static void Coolio_Loop_dispatch_events(struct Coolio_Loop *loop_data);
+
+#define DEFAULT_EVENTBUF_SIZE 32
+#define RUN_LOOP(loop_data, options) \
+  loop_data->running = 1; \
+  ev_loop(loop_data->ev_loop, options); \
+  loop_data->running = 0;
+
+/* 
+ * Coolio::Loop represents an event loop.  Event watchers can be attached and
+ * unattached.  When an event loop is run, all currently attached watchers
+ * are monitored for events, and their respective callbacks are signaled
+ * whenever events occur.
+ */
+void Init_coolio_loop()
+{
+  mCoolio = rb_define_module("Coolio");
+  cCoolio_Loop = rb_define_class_under(mCoolio, "Loop", rb_cObject);
+  rb_define_alloc_func(cCoolio_Loop, Coolio_Loop_allocate);
+ 
+  rb_define_method(cCoolio_Loop, "initialize", Coolio_Loop_initialize, 0);
+  rb_define_private_method(cCoolio_Loop, "ev_loop_new", Coolio_Loop_ev_loop_new, 1);
+  rb_define_method(cCoolio_Loop, "run_once", Coolio_Loop_run_once, 0);
+  rb_define_method(cCoolio_Loop, "run_nonblock", Coolio_Loop_run_nonblock, 0);
+}
+
+static VALUE Coolio_Loop_allocate(VALUE klass)
+{
+  struct Coolio_Loop *loop = (struct Coolio_Loop *)xmalloc(sizeof(struct Coolio_Loop));
+
+  loop->ev_loop = 0;
+  loop->running = 0;
+  loop->events_received = 0;
+  loop->eventbuf_size = DEFAULT_EVENTBUF_SIZE;
+  loop->eventbuf = (struct Coolio_Event *)xmalloc(sizeof(struct Coolio_Event) * DEFAULT_EVENTBUF_SIZE);
+
+  return Data_Wrap_Struct(klass, Coolio_Loop_mark, Coolio_Loop_free, loop);
+}
+
+static void Coolio_Loop_mark(struct Coolio_Loop *loop)
+{
+}
+
+static void Coolio_Loop_free(struct Coolio_Loop *loop)
+{
+  if(!loop->ev_loop)
+    return;
+
+  ev_loop_destroy(loop->ev_loop);
+
+  xfree(loop->eventbuf);
+  xfree(loop);
+}
+
+static VALUE Coolio_Loop_initialize(VALUE self)
+{
+  Coolio_Loop_ev_loop_new(self, INT2NUM(0));
+}
+
+/* Wrapper for populating a Coolio_Loop struct with a new event loop */
+static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags)
+{
+  struct Coolio_Loop *loop_data;
+  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+
+  if(loop_data->ev_loop)
+    rb_raise(rb_eRuntimeError, "loop already initialized");
+
+  loop_data->ev_loop = ev_loop_new(NUM2INT(flags));
+
+  return Qnil;
+}
+
+/* libev callback for receiving events */
+void Coolio_Loop_process_event(VALUE watcher, int revents)
+{
+  struct Coolio_Loop *loop_data;
+  struct Coolio_Watcher *watcher_data;
+
+  /* The Global VM lock isn't held right now, but hopefully
+   * we can still do this safely */
+  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data);
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+
+  /*  Well, what better place to explain how this all works than
+   *  where the most wonky and convoluted stuff is going on!
+   *
+   *  Our call path up to here looks a little something like:
+   *
+   *  -> release GVL -> event syscall -> libev callback
+   *  (GVL = Global VM Lock)             ^^^ You are here
+   *
+   *  We released the GVL in the Coolio_Loop_run_once() function
+   *  so other Ruby threads can run while we make a blocking 
+   *  system call (one of epoll, kqueue, port, poll, or select,
+   *  depending on the platform).
+   *
+   *  More specifically, this is a libev callback abstraction
+   *  called from a real libev callback in every watcher,
+   *  hence this function not being static.  The real libev
+   *  callbacks are event-specific and handled in a watcher.
+   *
+   *  For syscalls like epoll and kqueue, the kernel tells libev
+   *  a pointer (to a structure with a pointer) to the watcher 
+   *  object.  No data structure lookups are required at all
+   *  (beyond structs), it's smooth O(1) sailing the entire way.  
+   *  Then libev calls out to the watcher's callback, which
+   *  calls this function.
+   *
+   *  Now, you may be curious: if the watcher already knew what
+   *  event fired, why the hell is it telling the loop?  Why
+   *  doesn't it just rb_funcall() the appropriate callback?
+   *
+   *  Well, the problem is the Global VM Lock isn't held right
+   *  now, so we can't rb_funcall() anything.  In order to get
+   *  it back we have to:
+   *
+   *  stash event and return -> acquire GVL -> dispatch to Ruby
+   *
+   *  Which is kinda ugly and confusing, but still gives us 
+   *  an O(1) event loop whose heart is in the kernel itself. w00t!
+   *
+   *  So, stash the event in the loop's data struct.  When we return
+   *  the ev_loop() call being made in the Coolio_Loop_run_once_blocking()
+   *  function below will also return, at which point the GVL is
+   *  reacquired and we can call out to Ruby */
+
+  /* Grow the event buffer if it's too small */
+  if(loop_data->events_received >= loop_data->eventbuf_size) {
+    loop_data->eventbuf_size *= 2;
+    loop_data->eventbuf = (struct Coolio_Event *)xrealloc(
+        loop_data->eventbuf, 
+        sizeof(struct Coolio_Event) * loop_data->eventbuf_size
+        );
+  }
+
+  loop_data->eventbuf[loop_data->events_received].watcher = watcher;
+  loop_data->eventbuf[loop_data->events_received].revents = revents;
+
+  loop_data->events_received++;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Loop.run_once -> nil
+ * 
+ * Run the Coolio::Loop once, blocking until events are received.
+ */
+static VALUE Coolio_Loop_run_once(VALUE self)
+{
+  VALUE nevents;
+
+  if (Coolio_Loop_may_block_safely()) {
+    struct Coolio_Loop *loop_data;
+
+    Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+
+    assert(loop_data->ev_loop && !loop_data->events_received);
+
+    Coolio_Loop_ev_loop_oneshot(loop_data);
+    Coolio_Loop_dispatch_events(loop_data);
+
+    nevents = INT2NUM(loop_data->events_received);
+    loop_data->events_received = 0;
+
+  } else {
+    nevents = Coolio_Loop_run_nonblock(self);
+    rb_thread_schedule();
+  }
+
+  return nevents;
+}
+
+/* Ruby 1.9 supports blocking system calls through rb_thread_blocking_region() */
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+#define HAVE_EV_LOOP_ONESHOT
+static VALUE Coolio_Loop_ev_loop_oneshot_blocking(void *ptr) 
+{
+  /* The libev loop has now escaped through the Global VM Lock unscathed! */
+  struct Coolio_Loop *loop_data = (struct Coolio_Loop *)ptr;
+
+  RUN_LOOP(loop_data, EVLOOP_ONESHOT);
+  
+  return Qnil;
+}
+
+static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
+{
+  /* Use Ruby 1.9's rb_thread_blocking_region call to make a blocking system call */
+  rb_thread_blocking_region(Coolio_Loop_ev_loop_oneshot_blocking, loop_data, RUBY_UBF_IO, 0);
+}
+#endif
+
+/* Ruby 1.8 requires us to periodically run the event loop then defer back to
+ * the green threads scheduler */
+#ifndef HAVE_EV_LOOP_ONESHOT
+#define BLOCKING_INTERVAL 0.01 /* Block for 10ms at a time */
+
+/* Stub for scheduler's ev_timer callback */
+static void timer_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
+{
+   ev_timer_again (ev_loop, timer);
+}
+
+/* Run the event loop, calling rb_thread_schedule every 10ms */
+static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
+{
+  struct ev_timer timer;
+  struct timeval tv;
+
+  /* Set up an ev_timer to unblock the loop every 10ms */
+  ev_timer_init(&timer, timer_callback, BLOCKING_INTERVAL, BLOCKING_INTERVAL);
+  ev_timer_start(loop_data->ev_loop, &timer);
+
+  /* Loop until we receive events */
+  while(!loop_data->events_received) {
+    TRAP_BEG;
+    RUN_LOOP(loop_data, EVLOOP_ONESHOT);
+    TRAP_END;
+
+    rb_thread_schedule();
+  }
+
+  ev_timer_stop(loop_data->ev_loop, &timer);
+}
+#endif
+
+/**
+ *  call-seq:
+ *    Coolio::Loop.run_nonblock -> nil
+ * 
+ * Run the Coolio::Loop once, but return immediately if there are no pending events.
+ */
+static VALUE Coolio_Loop_run_nonblock(VALUE self)
+{
+  struct Coolio_Loop *loop_data;
+  VALUE nevents;
+  
+  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+
+  assert(loop_data->ev_loop && !loop_data->events_received);
+
+  RUN_LOOP(loop_data, EVLOOP_NONBLOCK);  
+  Coolio_Loop_dispatch_events(loop_data);
+  
+  nevents = INT2NUM(loop_data->events_received);
+  loop_data->events_received = 0;
+  
+  return nevents;
+}
+
+static void Coolio_Loop_dispatch_events(struct Coolio_Loop *loop_data)
+{
+  int i;
+  struct Coolio_Watcher *watcher_data;
+
+  for(i = 0; i < loop_data->events_received; i++) {
+    /* A watcher with pending events may have been detached from the loop
+     * during the dispatch process.  If so, the watcher clears the pending
+     * events, so skip over them */
+    if(loop_data->eventbuf[i].watcher == Qnil)
+      continue;
+
+    Data_Get_Struct(loop_data->eventbuf[i].watcher, struct Coolio_Watcher, watcher_data);
+    watcher_data->dispatch_callback(loop_data->eventbuf[i].watcher, loop_data->eventbuf[i].revents);
+  }
+}

data/ext/cool.io/stat_watcher.c

@@ -0,0 +1,269 @@
+/*
+ * 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_StatInfo = 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, VALUE previous, VALUE current);
+static VALUE Coolio_StatWatcher_path(VALUE self);
+
+static VALUE Coolio_StatInfo_build(ev_statdata *statdata_struct);
+
+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_StatInfo = rb_struct_define("StatInfo",
+      "mtime",
+      "ctime",
+      "atime",
+      "dev",
+      "ino",
+      "mode",
+      "nlink",
+      "uid",
+      "guid",
+      "rdev",
+      "size",
+      "blksize",
+      "blocks",
+      NULL);
+  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, 2);
+  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, VALUE previous, VALUE current)
+{
+  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)
+{
+  struct Coolio_Watcher *watcher_data;
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  VALUE previous_statdata = Coolio_StatInfo_build(&watcher_data->event_types.ev_stat.prev);
+  VALUE current_statdata = Coolio_StatInfo_build(&watcher_data->event_types.ev_stat.attr);
+  rb_funcall(self, rb_intern("on_change"), 2, previous_statdata, current_statdata);
+}
+
+/**
+ * Convience method to build StatInfo structs given an ev_statdata
+ * */
+static VALUE Coolio_StatInfo_build(ev_statdata *statdata_struct)
+{
+  VALUE at_method = rb_intern("at");
+  VALUE cTime     = rb_const_get(rb_cObject, rb_intern("Time"));
+
+  VALUE mtime     = Qnil;
+  VALUE ctime     = Qnil;
+  VALUE atime     = Qnil;
+  VALUE dev       = Qnil;
+  VALUE ino       = Qnil;
+  VALUE mode      = Qnil;
+  VALUE nlink     = Qnil;
+  VALUE uid       = Qnil;
+  VALUE gid       = Qnil;
+  VALUE rdev      = Qnil;
+  VALUE size      = Qnil;
+  VALUE blksize   = Qnil;
+  VALUE blocks    = Qnil;
+
+  mtime   = rb_funcall(cTime, at_method, 1, INT2NUM(statdata_struct->st_mtime));
+  ctime   = rb_funcall(cTime, at_method, 1, INT2NUM(statdata_struct->st_ctime));
+  atime   = rb_funcall(cTime, at_method, 1, INT2NUM(statdata_struct->st_atime));
+  dev     = INT2NUM(statdata_struct->st_dev);
+  ino     = INT2NUM(statdata_struct->st_ino);
+  mode    = INT2NUM(statdata_struct->st_mode);
+  nlink   = INT2NUM(statdata_struct->st_nlink);
+  uid     = INT2NUM(statdata_struct->st_uid);
+  gid     = INT2NUM(statdata_struct->st_gid);
+  rdev    = INT2NUM(statdata_struct->st_rdev);
+  size    = INT2NUM(statdata_struct->st_size);
+#ifdef HAVE_ST_BLKSIZE
+  blksize = INT2NUM(statdata_struct->st_blksize);
+  blocks  = INT2NUM(statdata_struct->st_blocks);
+#endif
+
+  return rb_struct_new(cCoolio_StatInfo,
+      mtime,
+      ctime,
+      atime,
+      dev,
+      ino,
+      mode,
+      nlink,
+      uid,
+      gid,
+      rdev,
+      size,
+      blksize,
+      blocks,
+      NULL);
+}