rev 0.1.4 → 0.2.0

data/ext/rev/rev_ssl.c

@@ -0,0 +1,255 @@
+/*
+ * Copyright (C) 2008 Tony Arcieri
+ * Includes portions from the 'OpenSSL for Ruby' project
+ * Copyright (C) 2000-2002  GOTOU Yuuzou <gotoyuzo@notwork.org>
+ * Copyright (C) 2001-2002  Michal Rokos <m.rokos@sh.cvut.cz>
+ * Copyright (C) 2001-2007  Technorama Ltd. <oss-ruby@technorama.net>
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#ifdef HAVE_OPENSSL_SSL_H
+
+#include "ruby.h"
+#include "rubyio.h"
+
+#include <openssl/ssl.h>
+
+static VALUE mOSSL = Qnil;
+static VALUE eOSSLError = Qnil;
+
+static VALUE mSSL = Qnil;
+static VALUE cSSLSocket = Qnil;
+static VALUE eSSLError = Qnil;
+
+static VALUE mRev = Qnil;
+static VALUE mRev_SSL = Qnil;
+static VALUE cRev_SSL_IO = Qnil;
+
+static VALUE eRev_SSL_IO_ReadAgain = Qnil;
+static VALUE eRev_SSL_IO_WriteAgain = Qnil;
+
+static VALUE Rev_SSL_IO_connect_nonblock(VALUE self);
+static VALUE Rev_SSL_IO_accept_nonblock(VALUE self);
+static VALUE Rev_SSL_IO_ssl_setup(VALUE self);
+static VALUE Rev_SSL_IO_ssl_setup_check(VALUE dummy, VALUE error_info);
+static VALUE Rev_SSL_IO_start_ssl(VALUE self, int (*func)(), const char *funcname);
+
+static VALUE Rev_SSL_IO_read_nonblock(int argc, VALUE *argv, VALUE self);
+static VALUE Rev_SSL_IO_write_nonblock(VALUE self, VALUE str);
+
+void Init_rev_ssl()
+{
+  rb_require("openssl");
+
+  mOSSL = rb_define_module("OpenSSL");
+  eOSSLError = rb_define_class_under(mOSSL, "OpenSSLError", rb_eStandardError);
+
+  mSSL = rb_define_module_under(mOSSL, "SSL");
+  cSSLSocket = rb_define_class_under(mSSL, "SSLSocket", rb_cObject);
+  eSSLError = rb_define_class_under(mSSL, "SSLError", eOSSLError);
+
+  mRev = rb_define_module("Rev");
+  mRev_SSL = rb_define_module_under(mRev, "SSL");
+  cRev_SSL_IO = rb_define_class_under(mRev_SSL, "IO", cSSLSocket);
+
+  eRev_SSL_IO_ReadAgain = rb_define_class_under(cRev_SSL_IO, "ReadAgain", rb_eStandardError);
+  eRev_SSL_IO_WriteAgain = rb_define_class_under(cRev_SSL_IO, "WriteAgain", rb_eStandardError);
+
+  rb_define_method(cRev_SSL_IO, "connect_nonblock", Rev_SSL_IO_connect_nonblock, 0);
+  rb_define_method(cRev_SSL_IO, "accept_nonblock", Rev_SSL_IO_accept_nonblock, 0);
+  
+  rb_define_method(cRev_SSL_IO, "read_nonblock", Rev_SSL_IO_read_nonblock, -1);
+  rb_define_method(cRev_SSL_IO, "write_nonblock", Rev_SSL_IO_write_nonblock, 1);
+}
+
+static VALUE
+Rev_SSL_IO_ssl_setup(VALUE self)
+{
+  /*
+   * DANGER WILL ROBINSON!  CRAZY HACKS AHEAD!
+   *
+   * Before we connect or accept we need to call the ossl_ssl_setup() function
+   * in ossl_ssl.c.  For whatever reason this isn't called in 
+   * SSLSocket#initialize but is instead called directly from #connect and
+   * #accept.
+   *
+   * To make things even more awesome, it's a static function, so we can't
+   * call it directly.  However, we can call it indirectly...
+   *
+   * There's one other method within ossl_ssl.c which calls ossl_ssl_setup(),
+   * and that's #session=.  I'm not sure why this calls it, but its author
+   * left this comment to help us figure out:
+   *
+   * "why is ossl_ssl_setup delayed?"
+   *
+   * Why indeed, guy... why indeed.  Well, his function calls ossl_ssl_setup(), 
+   * then typechecks its arguments, which means if we pass a bogus one it will
+   * happily setup SSL for us, then raise an exception.  So we can catch
+   * that exception and be on our merry way.
+   *
+   * I don't even know what this method is supposed to do.  It appears related
+   * to OpenSSL::SSL::Session, which is linked into the OpenSSL library but
+   * never initialized, probably because it's buggy.  Nevertheless, the 
+   * #session= method is still available to use for this hack.  Awesome!
+   */
+   rb_funcall(self, rb_intern("session="), 1, Qnil);
+}
+
+/* Ensure the error raised by calling #session= with a dummy argument is 
+ * the one we were expecting */
+static VALUE 
+Rev_SSL_IO_ssl_setup_check(VALUE dummy, VALUE err)
+{
+  if(!rb_obj_is_kind_of(err, rb_eTypeError))
+    rb_raise(rb_eRuntimeError, "Rev::SSL not supported in this Ruby version, sorry");
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *    ssl.connect => self
+ */
+static VALUE
+Rev_SSL_IO_connect_nonblock(VALUE self)
+{
+  rb_rescue(Rev_SSL_IO_ssl_setup, self, Rev_SSL_IO_ssl_setup_check, Qnil);
+  return Rev_SSL_IO_start_ssl(self, SSL_connect, "SSL_connect");
+}
+
+/*
+ * call-seq:
+ *    ssl.accept => self
+ */
+static VALUE
+Rev_SSL_IO_accept_nonblock(VALUE self)
+{
+  rb_rescue(Rev_SSL_IO_ssl_setup, self, 0, 0);
+  return Rev_SSL_IO_start_ssl(self, SSL_accept, "SSL_accept");
+}
+
+static VALUE
+Rev_SSL_IO_start_ssl(VALUE self, int (*func)(), const char *funcname)
+{
+  SSL *ssl;
+  int ret, ret2;
+
+  Data_Get_Struct(self, SSL, ssl);
+  if(!ssl)
+    rb_raise(rb_eRuntimeError, "SSL never initialized");
+
+  if((ret = func(ssl)) <= 0) {
+    switch((ret2 = SSL_get_error(ssl, ret))) {
+    case SSL_ERROR_WANT_WRITE:
+      rb_raise(eRev_SSL_IO_WriteAgain, "write again");
+    case SSL_ERROR_WANT_READ:
+      rb_raise(eRev_SSL_IO_ReadAgain, "read again");
+    case SSL_ERROR_SYSCALL:
+      if (errno) rb_sys_fail(funcname);
+      rb_raise(eSSLError, "%s SYSCALL returned=%d errno=%d state=%s", 
+        funcname, ret2, errno, SSL_state_string_long(ssl)
+      );
+    default:
+      rb_raise(eSSLError, "%s returned=%d errno=%d state=%s", 
+        funcname, ret2, errno, SSL_state_string_long(ssl)
+      );
+    }
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *    ssl.read_nonblock(length) => string
+ *    ssl.read_nonblock(length, buffer) => buffer
+ *
+ * === Parameters
+ * * +length+ is a positive integer.
+ * * +buffer+ is a string used to store the result.
+ */
+static VALUE
+Rev_SSL_IO_read_nonblock(int argc, VALUE *argv, VALUE self)
+{
+  SSL *ssl;
+  int ilen, nread = 0;
+  VALUE len, str;
+
+  rb_scan_args(argc, argv, "11", &len, &str);
+  ilen = NUM2INT(len);
+  
+  if(NIL_P(str)) 
+    str = rb_str_new(0, ilen);
+  else {
+    StringValue(str);
+    rb_str_modify(str);
+    rb_str_resize(str, ilen);
+  }
+  
+  if(ilen == 0) return str;
+
+  Data_Get_Struct(self, SSL, ssl);
+
+  if (ssl) {
+    nread = SSL_read(ssl, RSTRING_PTR(str), RSTRING_LEN(str));
+    switch(SSL_get_error(ssl, nread)){
+    case SSL_ERROR_NONE:
+      goto end;
+    case SSL_ERROR_ZERO_RETURN:
+      rb_eof_error();
+    case SSL_ERROR_WANT_WRITE:
+      rb_raise(eRev_SSL_IO_WriteAgain, "write again");
+    case SSL_ERROR_WANT_READ:
+      rb_raise(eRev_SSL_IO_ReadAgain, "read again");
+    case SSL_ERROR_SYSCALL:
+      if(ERR_peek_error() == 0 && nread == 0) rb_eof_error();
+      rb_sys_fail(0);
+    default:
+      rb_raise(eSSLError, "SSL_read:");
+    }
+  } else
+    rb_raise(rb_eRuntimeError, "SSL session is not started yet.");
+
+end:
+  rb_str_set_len(str, nread);
+  OBJ_TAINT(str);
+
+  return str;
+}
+
+/*
+ * call-seq:
+ *    ssl.write_nonblock(string) => integer
+ */
+static VALUE
+Rev_SSL_IO_write_nonblock(VALUE self, VALUE str)
+{
+  SSL *ssl;
+  int nwrite = 0;
+
+  StringValue(str);
+  Data_Get_Struct(self, SSL, ssl);
+
+  if (ssl) {
+    nwrite = SSL_write(ssl, RSTRING_PTR(str), RSTRING_LEN(str));
+    switch(SSL_get_error(ssl, nwrite)){
+    case SSL_ERROR_NONE:
+      goto end;
+    case SSL_ERROR_WANT_WRITE:
+      rb_raise(eRev_SSL_IO_WriteAgain, "write again");
+    case SSL_ERROR_WANT_READ:
+      rb_raise(eRev_SSL_IO_ReadAgain, "read again");
+    case SSL_ERROR_SYSCALL:
+      if (errno) rb_sys_fail(0);
+    default:
+      rb_raise(eSSLError, "SSL_write:");
+    }
+  } else
+    rb_raise(rb_eRuntimeError, "SSL session is not started yet.");
+
+end:
+  return INT2NUM(nwrite);
+}
+
+#endif

data/ext/rev/rev_timer_watcher.c

@@ -12,13 +12,11 @@
 #include "rev.h"
 #include "rev_watcher.h"
 
-/* Module and object handles */
 static VALUE mRev = Qnil;
 static VALUE cRev_Watcher = Qnil;
 static VALUE cRev_TimerWatcher = Qnil;
 static VALUE cRev_Loop = Qnil;
 
-/* Method implementations */
 static VALUE Rev_TimerWatcher_initialize(int argc, VALUE *argv, VALUE self);
 static VALUE Rev_TimerWatcher_attach(VALUE self, VALUE loop);
 static VALUE Rev_TimerWatcher_detach(VALUE self);
@@ -27,7 +25,6 @@ static VALUE Rev_TimerWatcher_disable(VALUE self);
 static VALUE Rev_TimerWatcher_reset(VALUE self);
 static VALUE Rev_TimerWatcher_on_timer(VALUE self);
 
-/* Callbacks */
 static void Rev_TimerWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents);
 static void Rev_TimerWatcher_dispatch_callback(VALUE self, int revents);
 
@@ -79,8 +76,8 @@ static VALUE Rev_TimerWatcher_initialize(int argc, VALUE *argv, VALUE self)
   ev_timer_init(
       &watcher_data->event_types.ev_timer, 
       Rev_TimerWatcher_libev_callback, 
-      RFLOAT_VALUE(interval), 
-      repeating == Qtrue ? RFLOAT_VALUE(interval) : 0
+      NUM2DBL(interval), 
+      repeating == Qtrue ? NUM2DBL(interval) : 0
   );  
   watcher_data->event_types.ev_timer.data = (void *)self;
 
@@ -112,7 +109,7 @@ static VALUE Rev_TimerWatcher_attach(VALUE self, VALUE loop)
   watcher_data->loop = loop;
   
   /* Calibrate timeout to account for potential drift */
-	interval = RFLOAT_VALUE(rb_iv_get(self, "@interval"));
+	interval = NUM2DBL(rb_iv_get(self, "@interval"));
   timeout = interval + ev_time() - ev_now(loop_data->ev_loop);
   
   ev_timer_set(

data/ext/rev/rev_utils.c

@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2007 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include "ruby.h"
+
+#include <sys/resource.h>
+
+#ifdef HAVE_SYS_SYSCTL_H
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#endif
+
+static VALUE mRev = Qnil;
+static VALUE cRev_Utils = Qnil;
+
+static VALUE Rev_Utils_ncpus(VALUE self);
+static VALUE Rev_Utils_maxfds(VALUE self);
+static VALUE Rev_Utils_setmaxfds(VALUE self, VALUE max);
+
+/*
+ * Assorted utility routines
+ */
+void Init_rev_utils()
+{
+  mRev = rb_define_module("Rev");
+  cRev_Utils = rb_define_module_under(mRev, "Utils");
+
+  rb_define_singleton_method(cRev_Utils, "ncpus", Rev_Utils_ncpus, 0);
+  rb_define_singleton_method(cRev_Utils, "maxfds", Rev_Utils_maxfds, 0);
+  rb_define_singleton_method(cRev_Utils, "maxfds=", Rev_Utils_setmaxfds, 1);
+}
+
+/**
+ *  call-seq:
+ *    Rev::Utils.ncpus -> Integer
+ * 
+ * Return the number of CPUs in the present system
+ */
+static VALUE Rev_Utils_ncpus(VALUE self)
+{
+  int ncpus = 0;
+
+#ifdef HAVE_LINUX_PROCFS
+#define HAVE_REV_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_REV_UTILS_NCPUS
+  size_t size = sizeof(int);
+
+  if(sysctlbyname("hw.ncpu", &ncpus, &size, NULL, 0)) 
+    return INT2NUM(1);
+#endif
+
+#ifndef HAVE_REV_UTILS_NCPUS
+  rb_raise(rb_eRuntimeError, "operation not supported");
+#endif
+
+  return INT2NUM(ncpus);
+}
+
+/**
+ *  call-seq:
+ *    Rev::Utils.maxfds -> Integer
+ * 
+ * Return the maximum number of files descriptors available to the process
+ */
+static VALUE Rev_Utils_maxfds(VALUE self)
+{
+  struct rlimit rlim;
+
+  if(getrlimit(RLIMIT_NOFILE, &rlim) < 0)
+    rb_sys_fail("getrlimit");
+
+  return INT2NUM(rlim.rlim_cur);
+}
+
+/**
+ *  call-seq:
+ *    Rev::Utils.maxfds=(count) -> Integer
+ * 
+ * Set the number of file descriptors available to the process.  May require
+ * superuser privileges.
+ */
+static VALUE Rev_Utils_setmaxfds(VALUE self, VALUE max)
+{
+  struct rlimit rlim;
+
+  rlim.rlim_cur = NUM2INT(max);
+
+  if(setrlimit(RLIMIT_NOFILE, &rlim) < 0)
+    rb_sys_fail("setrlimit");
+
+  return max;
+}

data/ext/rev/rev_watcher.c

@@ -11,16 +11,13 @@
 
 #include "rev.h"
 
-/* Module and object handles */
 static VALUE mRev = Qnil;
 static VALUE cRev_Watcher = Qnil;
 
-/* Data allocators and deallocators */
 static VALUE Rev_Watcher_allocate(VALUE klass);
 static void Rev_Watcher_mark(struct Rev_Watcher *watcher);
 static void Rev_Watcher_free(struct Rev_Watcher *watcher);
 
-/* Method implementations */
 static VALUE Rev_Watcher_initialize(VALUE self);
 static VALUE Rev_Watcher_attach(VALUE self, VALUE loop);
 static VALUE Rev_Watcher_detach(VALUE self);

data/lib/rev.rb

@@ -9,6 +9,7 @@ require File.dirname(__FILE__) + '/rev/loop'
 require File.dirname(__FILE__) + '/rev/watcher'
 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'
@@ -17,6 +18,6 @@ require File.dirname(__FILE__) + '/rev/server'
 require File.dirname(__FILE__) + '/rev/http_client'
 
 module Rev
-  Rev::VERSION = '0.1.4' unless defined? Rev::VERSION
+  Rev::VERSION = '0.2.0' unless defined? Rev::VERSION
   def self.version() VERSION end
 end

data/lib/rev/async_watcher.rb

@@ -0,0 +1,38 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+module Rev
+  # The AsyncWatcher lets you signal another thread to wake up.  Its
+  # intended use is notifying another thread of events.
+  class AsyncWatcher < IOWatcher
+    def initialize
+      @reader, @writer = ::IO.pipe
+      super(@reader)
+    end
+
+    # Signal the async watcher.  This call is thread safe.
+    def signal
+      # Write a byte to the pipe.  What we write is meaningless, it
+      # merely signals an event has occurred for each byte written.
+      @writer.write "\0"
+    end
+    
+    # Called whenever a signal is received
+    def on_signal; end
+    event_callback :on_signal
+
+    #########
+    protected
+    #########
+
+    def on_readable
+      # Read a byte from the pipe.  This clears readability, unless
+      # another signal is pending
+      @reader.read 1
+      on_signal
+    end
+  end
+end