rev 0.2.4 → 0.3.0

data/ext/libev/ev_win32.c

@@ -1,7 +1,7 @@
 /*
  * libev win32 compatibility cruft (_not_ a backend)
  *
- * Copyright (c) 2007,2008 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -55,7 +55,7 @@ ev_pipe (int filedes [2])
   struct sockaddr_in addr = { 0 };
   int addr_size = sizeof (addr);
   struct sockaddr_in adr2;
-  int adr2_size;
+  int adr2_size = sizeof (adr2);
   SOCKET listener;
   SOCKET sock [2] = { -1, -1 };
 
@@ -133,22 +133,21 @@ fail:
 
 #undef pipe
 #define pipe(filedes) ev_pipe (filedes)
-
-static int
-ev_gettimeofday (struct timeval *tv, struct timezone *tz)
+  
+#define EV_HAVE_EV_TIME 1
+ev_tstamp
+ev_time (void)
 {
-  struct _timeb tb;
-
-  _ftime (&tb);
+  FILETIME ft;
+  ULARGE_INTEGER ui;
 
-  tv->tv_sec  = (long)tb.time;
-  tv->tv_usec = ((long)tb.millitm) * 1000;
+  GetSystemTimeAsFileTime (&ft);
+  ui.u.LowPart  = ft.dwLowDateTime;
+  ui.u.HighPart = ft.dwHighDateTime;
 
-  return 0;
+  /* msvc cannot convert ulonglong to double... yes, it is that sucky */
+  return (LONGLONG)(ui.QuadPart - 116444736000000000) * 1e-7;
 }
 
-#undef gettimeofday
-#define gettimeofday(tv,tz) ev_gettimeofday (tv, tz)
-
 #endif
 

data/ext/libev/ev_wrap.h

@@ -8,14 +8,23 @@
 #define timeout_blocktime ((loop)->timeout_blocktime)
 #define backend ((loop)->backend)
 #define activecnt ((loop)->activecnt)
-#define loop_count ((loop)->loop_count)
+#define loop_done ((loop)->loop_done)
 #define backend_fd ((loop)->backend_fd)
 #define backend_fudge ((loop)->backend_fudge)
 #define backend_modify ((loop)->backend_modify)
 #define backend_poll ((loop)->backend_poll)
+#define anfds ((loop)->anfds)
+#define anfdmax ((loop)->anfdmax)
+#define pendings ((loop)->pendings)
+#define pendingmax ((loop)->pendingmax)
+#define pendingcnt ((loop)->pendingcnt)
+#define pending_w ((loop)->pending_w)
+#define rfeeds ((loop)->rfeeds)
+#define rfeedmax ((loop)->rfeedmax)
+#define rfeedcnt ((loop)->rfeedcnt)
 #define evfd ((loop)->evfd)
 #define evpipe ((loop)->evpipe)
-#define pipeev ((loop)->pipeev)
+#define pipe_w ((loop)->pipe_w)
 #define curpid ((loop)->curpid)
 #define postfork ((loop)->postfork)
 #define vec_ri ((loop)->vec_ri)
@@ -38,11 +47,6 @@
 #define kqueue_eventmax ((loop)->kqueue_eventmax)
 #define port_events ((loop)->port_events)
 #define port_eventmax ((loop)->port_eventmax)
-#define anfds ((loop)->anfds)
-#define anfdmax ((loop)->anfdmax)
-#define pendings ((loop)->pendings)
-#define pendingmax ((loop)->pendingmax)
-#define pendingcnt ((loop)->pendingcnt)
 #define fdchanges ((loop)->fdchanges)
 #define fdchangemax ((loop)->fdchangemax)
 #define fdchangecnt ((loop)->fdchangecnt)
@@ -65,7 +69,7 @@
 #define forks ((loop)->forks)
 #define forkmax ((loop)->forkmax)
 #define forkcnt ((loop)->forkcnt)
-#define gotasync ((loop)->gotasync)
+#define async_pending ((loop)->async_pending)
 #define asyncs ((loop)->asyncs)
 #define asyncmax ((loop)->asyncmax)
 #define asynccnt ((loop)->asynccnt)
@@ -73,6 +77,16 @@
 #define fs_w ((loop)->fs_w)
 #define fs_2625 ((loop)->fs_2625)
 #define fs_hash ((loop)->fs_hash)
+#define sig_pending ((loop)->sig_pending)
+#define sigfd ((loop)->sigfd)
+#define sigfd_w ((loop)->sigfd_w)
+#define sigfd_set ((loop)->sigfd_set)
+#define loop_count ((loop)->loop_count)
+#define loop_depth ((loop)->loop_depth)
+#define userdata ((loop)->userdata)
+#define release_cb ((loop)->release_cb)
+#define acquire_cb ((loop)->acquire_cb)
+#define invoke_cb ((loop)->invoke_cb)
 #else
 #undef EV_WRAP_H
 #undef now_floor
@@ -82,14 +96,23 @@
 #undef timeout_blocktime
 #undef backend
 #undef activecnt
-#undef loop_count
+#undef loop_done
 #undef backend_fd
 #undef backend_fudge
 #undef backend_modify
 #undef backend_poll
+#undef anfds
+#undef anfdmax
+#undef pendings
+#undef pendingmax
+#undef pendingcnt
+#undef pending_w
+#undef rfeeds
+#undef rfeedmax
+#undef rfeedcnt
 #undef evfd
 #undef evpipe
-#undef pipeev
+#undef pipe_w
 #undef curpid
 #undef postfork
 #undef vec_ri
@@ -112,11 +135,6 @@
 #undef kqueue_eventmax
 #undef port_events
 #undef port_eventmax
-#undef anfds
-#undef anfdmax
-#undef pendings
-#undef pendingmax
-#undef pendingcnt
 #undef fdchanges
 #undef fdchangemax
 #undef fdchangecnt
@@ -139,7 +157,7 @@
 #undef forks
 #undef forkmax
 #undef forkcnt
-#undef gotasync
+#undef async_pending
 #undef asyncs
 #undef asyncmax
 #undef asynccnt
@@ -147,4 +165,14 @@
 #undef fs_w
 #undef fs_2625
 #undef fs_hash
+#undef sig_pending
+#undef sigfd
+#undef sigfd_w
+#undef sigfd_set
+#undef loop_count
+#undef loop_depth
+#undef userdata
+#undef release_cb
+#undef acquire_cb
+#undef invoke_cb
 #endif

data/ext/rev/extconf.rb

@@ -36,7 +36,7 @@ if have_header('port.h')
   $defs << '-DEV_USE_PORT'
 end
 
-if have_header('openssl/ssl.h')
+if have_header('openssl/ssl.h') and RUBY_PLATFORM !~ /mingw|win32/ # win32 and SSL no go currently...needs some help to work
   $defs << '-DHAVE_OPENSSL_SSL_H'
   libs << '-lssl -lcrypto'
 end
@@ -60,11 +60,11 @@ $LIBS << ' ' << libs.join(' ')
 dir_config('rev_ext')
 create_makefile('rev_ext')
 
-if have_header('openssl/ssl.h') and RUBY_PLATFORM =~ /mingw|win32/
-  print "Note--SSL not yet supported on windows--continuing without SSL support"
+# win32 needs to link in "just the right order" for some reason or  ioctlsocket will be mapped to an [inverted] ruby specific version.  See libev mailing list for (not so helpful discussion--true cause I'm not sure, but this overcomes the symptom)
+if RUBY_PLATFORM =~ /mingw|win32/
   makefile_contents = File.read 'Makefile'
-  makefile_contents.gsub!('-DHAVE_OPENSSL_SSL_H', '')
-  makefile_contents.gsub! 'LIBS = $(LIBRUBYARG_SHARED)', 'LIBS = -lws2_32 $(LIBRUBYARG_SHARED)' # for some reason has to come first or ioctlsocket will be mapped to an [inverted] ruby specific version
 
+  makefile_contents.gsub! 'LIBS = $(LIBRUBYARG_SHARED)', 'LIBS = -lws2_32 $(LIBRUBYARG_SHARED)'
   File.open('Makefile', 'w') { |f| f.write makefile_contents }
 end
+

data/ext/rev/rev.h

@@ -44,6 +44,7 @@ struct Rev_Watcher
   union {
     struct ev_io ev_io;
     struct ev_timer ev_timer;
+    struct ev_stat ev_stat;
   } event_types;
 
   int enabled;

data/ext/rev/rev_ext.c

@@ -16,14 +16,12 @@ static VALUE mRev = Qnil;
 
 void Init_rev_ext() 
 {
-  ev_set_allocator((void *(*)(void *, long))xrealloc);
-
   /* Initializers for other modules */
   Init_rev_loop();
   Init_rev_watcher();
   Init_rev_io_watcher();
   Init_rev_timer_watcher();
-  Init_rev_buffer();
+  Init_rev_stat_watcher();
   Init_rev_utils();
   
 #ifdef HAVE_OPENSSL_SSL_H

data/ext/rev/rev_io_watcher.c

@@ -32,8 +32,6 @@ static void Rev_IOWatcher_dispatch_callback(VALUE self, int revents);
  * Rev::IOWatcher monitors Ruby IO objects for readability or writability.
  * This allows your application to block while the kernel is writing out
  * data and fill the read or write buffer whenever there is space available.
- * It's used by the Rev::BufferedIO class to provide high performace I/O
- * which is bound by the kernel's ability to read and write data.
  */
 void Init_rev_io_watcher()
 {

data/ext/rev/rev_stat_watcher.c

@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2009 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 "rev.h"
+#include "rev_watcher.h"
+
+static VALUE mRev = Qnil;
+static VALUE cRev_Watcher = Qnil;
+static VALUE cRev_StatWatcher = Qnil;
+static VALUE cRev_Loop = Qnil;
+
+static VALUE Rev_StatWatcher_initialize(VALUE self, VALUE path);
+static VALUE Rev_StatWatcher_attach(VALUE self, VALUE loop);
+static VALUE Rev_StatWatcher_detach(VALUE self);
+static VALUE Rev_StatWatcher_enable(VALUE self);
+static VALUE Rev_StatWatcher_disable(VALUE self);
+static VALUE Rev_StatWatcher_on_change(VALUE self);
+static VALUE Rev_StatWatcher_path(VALUE self);
+
+static void Rev_StatWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_stat *stat, int revents);
+static void Rev_StatWatcher_dispatch_callback(VALUE self, int revents);
+
+/*
+ * Rev::StatWatcher lets you create either one-shot or periodic stats which
+ * run within Rev's event loop.  It's useful for creating timeouts or
+ * events which fire periodically.
+ */
+void Init_rev_stat_watcher()
+{ 
+  mRev = rb_define_module("Rev");
+  cRev_Watcher = rb_define_class_under(mRev, "Watcher", rb_cObject);
+  cRev_StatWatcher = rb_define_class_under(mRev, "StatWatcher", cRev_Watcher);
+  cRev_Loop = rb_define_class_under(mRev, "Loop", rb_cObject);
+
+  rb_define_method(cRev_StatWatcher, "initialize", Rev_StatWatcher_initialize, 1);
+  rb_define_method(cRev_StatWatcher, "attach", Rev_StatWatcher_attach, 1);
+  rb_define_method(cRev_StatWatcher, "detach", Rev_StatWatcher_detach, 0);
+  rb_define_method(cRev_StatWatcher, "enable", Rev_StatWatcher_enable, 0);
+  rb_define_method(cRev_StatWatcher, "disable", Rev_StatWatcher_disable, 0);
+  rb_define_method(cRev_StatWatcher, "on_change", Rev_StatWatcher_on_change, 0);
+  rb_define_method(cRev_StatWatcher, "path", Rev_StatWatcher_path, 0);
+}
+
+/**
+ *  call-seq:
+ *    Rev::StatWatcher.initialize(path) -> Rev::StatWatcher
+ * 
+ * Create a new Rev::StatWatcher for the given path.  This will monitor the
+ * given path for changes at the filesystem level.
+ */
+static VALUE Rev_StatWatcher_initialize(VALUE self, VALUE path)
+{
+  struct Rev_Watcher *watcher_data;
+
+  path = rb_String(path);
+  rb_iv_set(self, "@path", path);
+
+  Data_Get_Struct(self, struct Rev_Watcher, watcher_data);
+
+  watcher_data->dispatch_callback = Rev_StatWatcher_dispatch_callback;
+  ev_stat_init(
+      &watcher_data->event_types.ev_stat, 
+      Rev_StatWatcher_libev_callback, 
+      RSTRING_PTR(path), 
+      0
+  );  
+  watcher_data->event_types.ev_stat.data = (void *)self;
+
+  return Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Rev::StatWatcher.attach(loop) -> Rev::StatWatcher
+ * 
+ * Attach the stat watcher to the given Rev::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 Rev_StatWatcher_attach(VALUE self, VALUE loop)
+{
+  ev_tstamp interval, timeout;
+  struct Rev_Loop *loop_data;
+  struct Rev_Watcher *watcher_data;
+    
+	if(!rb_obj_is_kind_of(loop, cRev_Loop))
+		rb_raise(rb_eArgError, "expected loop to be an instance of Rev::Loop");
+
+  Data_Get_Struct(loop, struct Rev_Loop, loop_data);
+  Data_Get_Struct(self, struct Rev_Watcher, watcher_data);
+
+  if(watcher_data->loop != Qnil)
+    Rev_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:
+ *    Rev::StatWatcher.detach -> Rev::StatWatcher
+ * 
+ * Detach the stat watcher from its current Rev::Loop.
+ */
+static VALUE Rev_StatWatcher_detach(VALUE self)
+{
+  Watcher_Detach(stat, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Rev::StatWatcher.enable -> Rev::StatWatcher
+ * 
+ * Re-enable a stat watcher which has been temporarily disabled.  See the
+ * disable method for a more thorough explanation.
+ */
+static VALUE Rev_StatWatcher_enable(VALUE self)
+{
+  Watcher_Enable(stat, self);
+
+  return self;  
+}
+
+/**
+ *  call-seq:
+ *    Rev::StatWatcher.disable -> Rev::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 Rev_StatWatcher_disable(VALUE self)
+{
+  Watcher_Disable(stat, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Rev::StatWatcher#on_change -> nil
+ * 
+ * Called whenever the status of the given path changes
+ */
+static VALUE Rev_StatWatcher_on_change(VALUE self)
+{
+  return Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Rev::StatWatcher#path -> String
+ * 
+ * Retrieve the path associated with this StatWatcher
+ */
+static VALUE Rev_StatWatcher_path(VALUE self)
+{
+  return rb_iv_get(self, "@path");
+}
+
+/* libev callback */
+static void Rev_StatWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_stat *stat, int revents)
+{
+  Rev_Loop_process_event((VALUE)stat->data, revents);
+}
+
+/* Rev::Loop dispatch callback */
+static void Rev_StatWatcher_dispatch_callback(VALUE self, int revents)
+{ 
+  rb_funcall(self, rb_intern("on_change"), 0, 0);
+}

data/lib/rev.rb

@@ -10,18 +10,17 @@ begin
 rescue LoadError
 end
 
-require File.dirname(__FILE__) + '/rev_ext'
-require File.dirname(__FILE__) + '/rev/loop'
-require File.dirname(__FILE__) + '/rev/meta'
-require File.dirname(__FILE__) + '/rev/io_watcher'
-require File.dirname(__FILE__) + '/rev/timer_watcher'
-require File.dirname(__FILE__) + '/rev/async_watcher'
-require File.dirname(__FILE__) + '/rev/listener'
-require File.dirname(__FILE__) + '/rev/io'
-require File.dirname(__FILE__) + '/rev/dns_resolver'
-require File.dirname(__FILE__) + '/rev/socket'
-require File.dirname(__FILE__) + '/rev/server'
-require File.dirname(__FILE__) + '/rev/http_client'
+# Pull in iobuffer gem
+require 'rubygems'
+require 'iobuffer'
+
+%w(
+  /rev_ext /rev/loop /rev/meta /rev/io_watcher /rev/timer_watcher 
+  /rev/async_watcher /rev/listener /rev/io /rev/dns_resolver 
+  /rev/socket /rev/server /rev/http_client
+).each do |file|
+  require File.dirname(__FILE__) + file
+end
 
 module Rev
   Rev::VERSION = '0.2.3' unless defined? Rev::VERSION

data/lib/rev/dns_resolver.rb

@@ -24,8 +24,8 @@ module Rev
   # automatically detach themselves from the event loop and cannot be used
   # again.
   class DNSResolver < IOWatcher
-   #--
-   # TODO check if it's caching right
+    #--
+    # TODO check if it's caching right
     RESOLV_CONF = '/etc/resolv.conf'
     HOSTS = '/etc/hosts'
     DNS_PORT = 53
@@ -89,7 +89,7 @@ module Rev
 
     # Called if we don't receive a response, defaults to calling on_failure
     def on_timeout
-	on_failure
+      on_failure
     end
 
     #########
@@ -102,9 +102,8 @@ module Rev
       @nameservers << nameserver # rotate them
       @socket.connect @nameservers.first, DNS_PORT
       begin
-         @socket.send request_message, 0
+        @socket.send request_message, 0
       rescue Errno::EHOSTUNREACH # TODO figure out why it has to be wrapper here, when the other wrapper should be wrapping this one!
-
       end   
     end
 
@@ -112,9 +111,10 @@ module Rev
     def on_readable
       datagram = nil
       begin
-	datagram = @socket.recvfrom_nonblock(DATAGRAM_SIZE).first
+        datagram = @socket.recvfrom_nonblock(DATAGRAM_SIZE).first
       rescue Errno::ECONNREFUSED
       end
+      
       address = response_address datagram rescue nil
       address ? on_success(address) : on_failure
       detach