evio 0.0.0

data/ext/evio/ev.c

@@ -0,0 +1,108 @@
+#include <ruby.h>
+#include <ev.h>
+
+#include "evio.h"
+
+
+static void
+prepare_cb(struct ev_loop *loop, ev_prepare *watcher, int revents)
+{
+  prepare_data *data = watcher->data;
+
+  rb_funcall(data->block, rb_intern("call"), 0);
+  ev_prepare_stop(loop, watcher);
+  rb_gc_unregister_address(&data->block);
+  free(data);
+  free(watcher);
+}
+
+static void
+timer_cb(struct ev_loop *loop, ev_timer *watcher, int revents)
+{
+  timer_data *data = watcher->data;
+  VALUE rv;
+
+  rv = rb_funcall(data->block, rb_intern("call"), 0);
+
+  if (data->repeat == 0 || rv == Qfalse) {
+    // remove watcher from loop
+    ev_timer_stop(loop, watcher);
+    // make the block available for gc collect
+    rb_gc_unregister_address(&data->block);
+    // free resources unmanaged by the gc
+    free(data);
+    free(watcher);
+  }
+}
+
+static VALUE
+set_timer(VALUE self, VALUE delay, VALUE repeat_delay)
+{
+  ev_timer *watcher;
+  timer_data *data;
+  int type;
+  double dl, repeat_dl;
+
+  rb_secure(2);
+
+  if ((type = TYPE(delay)) == T_FLOAT || type == T_FIXNUM)
+    dl = NUM2DBL(delay);
+  else
+    rb_raise(rb_eArgError, "first argument must be a number");
+
+  if ((type = TYPE(repeat_delay)) == T_FLOAT || type == T_FIXNUM)
+    repeat_dl = NUM2DBL(repeat_delay);
+  else
+    rb_raise(rb_eArgError, "second argument must be a number");
+
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "a block is required");
+
+  watcher = ALLOC(ev_timer);
+  data = ALLOC(timer_data);
+  // bind the block to its outer scope and store for later use
+  data->block = rb_block_proc();
+  // don't let the gc collect it
+  rb_gc_register_address(&data->block);
+  watcher->data = data;
+  if (repeat_dl > 0) data->repeat = 1;
+  else data->repeat = 0;
+  ev_timer_init(watcher, timer_cb, dl, repeat_dl);
+  ev_timer_start(loop, watcher);
+
+  return Qnil;
+}
+
+static VALUE
+start_loop(VALUE self)
+{
+  ev_prepare *watcher;
+  prepare_data *data;
+
+  if (rb_block_given_p()) {
+    watcher = ALLOC(ev_prepare);
+    data = ALLOC(prepare_data);
+    data->block = rb_block_proc();
+    rb_gc_register_address(&data->block);
+    watcher->data = data;
+    ev_prepare_init(watcher, prepare_cb);
+    ev_prepare_start(loop, watcher);
+  }
+
+  ev_run(loop, 0);
+  return Qnil;
+}
+
+static VALUE
+stop_loop(VALUE self)
+{
+  ev_break(loop, EVBREAK_ALL);
+  return Qnil;
+}
+
+void init_ev(VALUE module)
+{
+  rb_define_module_function(module, "set_timer", set_timer, 2);
+  rb_define_module_function(module, "start_loop", start_loop, 0);
+  rb_define_module_function(module, "stop_loop", stop_loop, 0);
+}

data/ext/evio/evio.c

@@ -0,0 +1,14 @@
+#include <ruby.h>
+#include <ev.h>
+
+#include "evio.h"
+
+
+void Init_evio()
+{
+  loop = EV_DEFAULT;
+  VALUE module = rb_define_module("Evio");
+  init_ev(module);
+  init_signal(module);
+  init_io(module);
+}

data/ext/evio/evio.h

@@ -0,0 +1,33 @@
+
+typedef struct {
+  int fd;
+  int closed;
+  enum {
+    file,
+    socket
+  } stream_type;
+
+} io_stream;
+
+struct block_wrapper {
+  VALUE block;
+};
+
+typedef struct block_wrapper signal_data;
+typedef struct block_wrapper prepare_data;
+typedef struct {
+  VALUE block;
+  int buffer_size;
+  char *buffer;
+} io_read_data;
+typedef struct {
+  VALUE block;
+  int repeat;
+} timer_data;
+
+struct ev_loop *loop;
+
+void Init_evio();
+void init_ev(VALUE module);
+void init_signal(VALUE module);
+void init_io(VALUE module);

data/ext/evio/extconf.rb

@@ -0,0 +1,29 @@
+ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
+
+require 'mkmf'
+
+HEADER_DIRS = [
+  '/opt/local/include',
+  '/usr/local/include',
+  Config::CONFIG['includedir'],
+  '/usr/include',
+]
+
+LIB_DIRS = [
+  '/opt/local/lib',
+  '/usr/local/lib',
+  Config::CONFIG['libdir'],
+  '/usr/lib',
+]
+
+dir_config('ev', HEADER_DIRS, LIB_DIRS)
+
+unless find_header('ev.h')
+  abort 'cannot find libev headers, install it before continuing'
+end
+
+unless find_library('ev', 'ev_run')
+  abort 'cannot find libev'
+end
+
+create_makefile('evio/evio')

data/ext/evio/io.c

@@ -0,0 +1,170 @@
+#include <errno.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <ruby.h>
+#include <ev.h>
+
+#include "evio.h"
+
+
+VALUE cIO;
+
+static void
+io_free(io_stream *stream)
+{
+  close(stream->fd);
+  free(stream);
+}
+
+static VALUE
+io_open(int argc, VALUE *argv)
+{
+  io_stream *stream;
+  char *path, *mode;
+  int flags, filemode;
+
+  rb_secure(2);
+
+  if (argc < 1 || argc > 3)
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
+
+  if (TYPE(argv[0]) != T_STRING)
+    rb_raise(rb_eArgError, "first argument must be a string");
+
+  path = RSTRING_PTR(rb_str_encode_ospath(argv[0]));
+
+  if (argc > 1) {
+    flags = -1;
+    if (TYPE(argv[1]) != T_STRING)
+      rb_raise(rb_eArgError, "second argument must be a string");
+    mode = RSTRING_PTR(argv[1]);
+    if (mode[0] == 'r') {
+      if (mode[1] == '\0')
+        flags = O_RDONLY;
+      else if (mode[1] == '+' && mode[2] == '\0')
+        flags = O_RDWR;
+    } else if (mode[0] == 'w') {
+      if (mode[1] == '\0')
+        flags = O_WRONLY | O_CREAT;
+      else if (mode[1] == '+' && mode[2] == '\0')
+        flags = O_RDWR | O_CREAT;
+    } else if (mode[0] == 'a') {
+      if (mode[1] == '\0')
+        flags = O_WRONLY | O_CREAT | O_APPEND;
+      else if (mode[1] == '+' && mode[2] == '\0')
+        flags = O_RDWR | O_CREAT | O_APPEND;
+    }
+    if (flags == -1) rb_raise(rb_eArgError, "invalid file mode string");
+  } else {
+    flags = O_RDONLY;
+  }
+
+  if (argc == 3) {
+    if (TYPE(argv[2]) != T_FIXNUM)
+      rb_raise(rb_eArgError, "third argument must be an integer");
+    filemode = FIX2INT(argv[2]);
+  } else {
+    filemode = 0644;
+  }
+
+  flags |= O_NONBLOCK;
+  stream = ALLOC(io_stream);
+  stream->fd = open(path, flags, filemode);
+
+  if (stream->fd == -1)
+    rb_raise(rb_eSystemCallError, "%s", strerror(errno));
+
+  return Data_Wrap_Struct(cIO, 0, io_free, stream);
+}
+
+static void
+io_read_cb(struct ev_loop *loop, ev_io *watcher, int revents)
+{
+  ssize_t read_count;
+  VALUE rv = Qnil;
+  VALUE ex = Qnil;
+  io_read_data *data = watcher->data;
+
+  read_count = read(watcher->fd, data->buffer, data->buffer_size);
+
+  if (read_count == -1) {
+    if (errno == EAGAIN) return;
+    else ex = rb_exc_new2(rb_eSystemCallError, strerror(errno));
+  }
+
+  if (read_count != 0) // not EOF
+    rv = rb_funcall(data->block, rb_intern("call"), 2, ex,
+        rb_str_new(data->buffer, read_count));
+
+  if (read_count == 0 || rv == Qfalse) {
+    ev_io_stop(loop, watcher);
+    rb_gc_unregister_address(&data->block);
+    free(data->buffer);
+    free(data);
+    free(watcher);
+  }
+}
+
+static VALUE
+io_read(int argc, VALUE *argv, VALUE self)
+{
+  ev_io *watcher;
+  io_read_data *data;
+  io_stream *stream;
+  int buffer_size;
+
+  rb_secure(2);
+
+  if (argc > 1)
+    rb_raise(rb_eArgError, "must provide zero or one arguments");
+
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "a block is required");
+
+  if (argc == 1) {
+    if (TYPE(argv[0]) != T_FIXNUM)
+      rb_raise(rb_eArgError, "first argument must be an integer");
+    buffer_size = FIX2INT(argv[0]);
+  } else {
+    buffer_size = 4096;
+  }
+
+  Data_Get_Struct(self, io_stream, stream);
+  watcher = ALLOC(ev_io);
+  data = ALLOC(io_read_data);
+  data->block = rb_block_proc();
+  data->buffer_size = buffer_size;
+  data->buffer = ALLOC_N(char, buffer_size);
+  rb_gc_register_address(&data->block);
+  watcher->data = data;
+  ev_io_init(watcher, io_read_cb, stream->fd, EV_READ);
+  ev_io_start(loop, watcher);
+
+  return Qnil;
+}
+
+static VALUE
+io_close(VALUE self)
+{
+  io_stream *stream;
+
+  Data_Get_Struct(self, io_stream, stream);
+  close(stream->fd);
+
+  return Qnil;
+}
+
+void init_io(VALUE module)
+{
+  cIO = rb_define_class_under(module, "IO", rb_cObject); 
+
+  rb_define_singleton_method(cIO, "open", io_open, -1);
+
+  rb_define_method(cIO, "read", io_read, -1);
+  rb_define_method(cIO, "close", io_close, 0);
+}

data/ext/evio/signal.c

@@ -0,0 +1,308 @@
+#include <ruby.h>
+#include <ev.h>
+
+#include "evio.h"
+
+// mostly copied from signal.c(ruby source)
+
+static const struct signals {
+  const char *signm;
+  int  signo;
+} siglist [] = {
+  {"EXIT", 0},
+#ifdef SIGHUP
+  {"HUP", SIGHUP},
+#endif
+  {"INT", SIGINT},
+#ifdef SIGQUIT
+  {"QUIT", SIGQUIT},
+#endif
+#ifdef SIGILL
+  {"ILL", SIGILL},
+#endif
+#ifdef SIGTRAP
+  {"TRAP", SIGTRAP},
+#endif
+#ifdef SIGIOT
+  {"IOT", SIGIOT},
+#endif
+#ifdef SIGABRT
+  {"ABRT", SIGABRT},
+#endif
+#ifdef SIGEMT
+  {"EMT", SIGEMT},
+#endif
+#ifdef SIGFPE
+  {"FPE", SIGFPE},
+#endif
+#ifdef SIGKILL
+  {"KILL", SIGKILL},
+#endif
+#ifdef SIGBUS
+  {"BUS", SIGBUS},
+#endif
+#ifdef SIGSEGV
+  {"SEGV", SIGSEGV},
+#endif
+#ifdef SIGSYS
+  {"SYS", SIGSYS},
+#endif
+#ifdef SIGPIPE
+  {"PIPE", SIGPIPE},
+#endif
+#ifdef SIGALRM
+  {"ALRM", SIGALRM},
+#endif
+#ifdef SIGTERM
+  {"TERM", SIGTERM},
+#endif
+#ifdef SIGURG
+  {"URG", SIGURG},
+#endif
+#ifdef SIGSTOP
+  {"STOP", SIGSTOP},
+#endif
+#ifdef SIGTSTP
+  {"TSTP", SIGTSTP},
+#endif
+#ifdef SIGCONT
+  {"CONT", SIGCONT},
+#endif
+#ifdef SIGCHLD
+  {"CHLD", SIGCHLD},
+#endif
+#ifdef SIGCLD
+  {"CLD", SIGCLD},
+#else
+# ifdef SIGCHLD
+  {"CLD", SIGCHLD},
+# endif
+#endif
+#ifdef SIGTTIN
+  {"TTIN", SIGTTIN},
+#endif
+#ifdef SIGTTOU
+  {"TTOU", SIGTTOU},
+#endif
+#ifdef SIGIO
+  {"IO", SIGIO},
+#endif
+#ifdef SIGXCPU
+  {"XCPU", SIGXCPU},
+#endif
+#ifdef SIGXFSZ
+  {"XFSZ", SIGXFSZ},
+#endif
+#ifdef SIGVTALRM
+  {"VTALRM", SIGVTALRM},
+#endif
+#ifdef SIGPROF
+  {"PROF", SIGPROF},
+#endif
+#ifdef SIGWINCH
+  {"WINCH", SIGWINCH},
+#endif
+#ifdef SIGUSR1
+  {"USR1", SIGUSR1},
+#endif
+#ifdef SIGUSR2
+  {"USR2", SIGUSR2},
+#endif
+#ifdef SIGLOST
+  {"LOST", SIGLOST},
+#endif
+#ifdef SIGMSG
+  {"MSG", SIGMSG},
+#endif
+#ifdef SIGPWR
+  {"PWR", SIGPWR},
+#endif
+#ifdef SIGPOLL
+  {"POLL", SIGPOLL},
+#endif
+#ifdef SIGDANGER
+  {"DANGER", SIGDANGER},
+#endif
+#ifdef SIGMIGRATE
+  {"MIGRATE", SIGMIGRATE},
+#endif
+#ifdef SIGPRE
+  {"PRE", SIGPRE},
+#endif
+#ifdef SIGGRANT
+  {"GRANT", SIGGRANT},
+#endif
+#ifdef SIGRETRACT
+  {"RETRACT", SIGRETRACT},
+#endif
+#ifdef SIGSOUND
+  {"SOUND", SIGSOUND},
+#endif
+#ifdef SIGINFO
+  {"INFO", SIGINFO},
+#endif
+  {NULL, 0}
+};
+
+static int
+signm2signo(const char *nm)
+{
+  const struct signals *sigs;
+
+  for (sigs = siglist; sigs->signm; sigs++)
+    if (strcmp(sigs->signm, nm) == 0)
+      return sigs->signo;
+  return 0;
+}
+
+static const char*
+signo2signm(int no)
+{
+  const struct signals *sigs;
+
+  for (sigs = siglist; sigs->signm; sigs++)
+    if (sigs->signo == no)
+      return sigs->signm;
+  return 0;
+}
+
+static int
+trap_signm(VALUE vsig)
+{
+  int sig = -1;
+  const char *s;
+
+  switch (TYPE(vsig)) {
+    case T_FIXNUM:
+      sig = FIX2INT(vsig);
+      if (sig < 0 || sig >= NSIG) {
+        rb_raise(rb_eArgError, "invalid signal number (%d)", sig);
+      }
+      break;
+
+    case T_SYMBOL:
+      s = rb_id2name(SYM2ID(vsig));
+      if (!s) rb_raise(rb_eArgError, "bad signal");
+      goto str_signal;
+
+    default:
+      s = StringValuePtr(vsig);
+
+    str_signal:
+      if (strncmp("SIG", s, 3) == 0)
+        s += 3;
+      sig = signm2signo(s);
+      if (sig == 0 && strcmp(s, "EXIT") != 0)
+        rb_raise(rb_eArgError, "unsupported signal SIG%s", s);
+  }
+  return sig;
+}
+
+// TODO do something here
+static void
+default_cb(struct ev_loop *loop, ev_signal *watcher, int revents)
+{
+
+}
+
+static void
+ignore_cb(struct ev_loop *loop, ev_signal *watcher, int revents)
+{
+
+}
+
+static void
+exit_cb(struct ev_loop *loop, ev_signal *watcher, int revents)
+{
+  exit(watcher->signum);
+}
+
+static void
+block_cb(struct ev_loop *loop, ev_signal *watcher, int revents)
+{
+  signal_data *data = watcher->data;
+  VALUE rv;
+
+  rv = rb_funcall(data->block, rb_intern("call"), 1, INT2FIX(watcher->signum));
+
+  if (rv == Qfalse) {
+    ev_signal_stop(loop, watcher);
+    rb_gc_unregister_address(&data->block);
+    free(data);
+    free(watcher);
+  }
+}
+
+static VALUE
+sig_trap(int argc, VALUE *argv)
+{
+  ev_signal *watcher;
+  VALUE cmd;
+  signal_data *data;
+  int sign;
+
+  rb_secure(2);
+
+  if (argc < 1 || argc > 2)
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
+
+  sign = trap_signm(argv[0]);
+  watcher = ALLOC(ev_signal);
+
+  if (argc == 1) {
+    data = ALLOC(signal_data);
+    data->block = rb_block_proc();
+    watcher->data = data;
+    rb_gc_register_address(&data->block);
+    ev_signal_init(watcher, block_cb, sign);
+  } else {
+    cmd = argv[1];
+    if (OBJ_TAINTED(cmd))
+      rb_raise(rb_eSecurityError, "Insecure: tainted signal trap");
+    if (!NIL_P(cmd)) {
+      switch (RSTRING_LEN(cmd)) {
+        case 0:
+          goto sig_ign;
+          break;
+        case 14:
+          if (strncmp(RSTRING_PTR(cmd), "SYSTEM_DEFAULT", 14) == 0) {
+sig_dfl:
+            ev_signal_init(watcher, default_cb, sign);
+          }
+          break;
+        case 7:
+          if (strncmp(RSTRING_PTR(cmd), "SIG_IGN", 7) == 0) {
+sig_ign:
+            ev_signal_init(watcher, ignore_cb, sign);
+          }
+          else if (strncmp(RSTRING_PTR(cmd), "SIG_DFL", 7) == 0) {
+            goto sig_dfl;
+          }
+          else if (strncmp(RSTRING_PTR(cmd), "DEFAULT", 7) == 0) {
+            goto sig_dfl;
+          }
+          break;
+        case 6:
+          if (strncmp(RSTRING_PTR(cmd), "IGNORE", 6) == 0)
+            goto sig_ign;
+          break;
+        case 4:
+          if (strncmp(RSTRING_PTR(cmd), "EXIT", 4) == 0) {
+            ev_signal_init(watcher, exit_cb, sign);
+          }
+          break;
+      }
+    }
+  }
+
+  ev_signal_start(loop, watcher);
+  return Qnil;
+}
+
+void
+init_signal(VALUE module)
+{
+  VALUE signal_module = rb_define_module_under(module, "Signal");
+
+  rb_define_module_function(signal_module, "trap", sig_trap, -1);
+}

data/lib/evio.rb

@@ -0,0 +1,2 @@
+require 'evio/signal'
+require 'evio/evio'

data/lib/evio/signal.rb

@@ -0,0 +1,18 @@
+
+module Evio
+
+  module Signal
+
+    def clear_signal_traps
+      # Remove all default handlers since they cause segfault
+      # with libev handlers
+      Signal.list.values.each do |s|
+        Signal.trap s, 'IGNORE'
+      end
+    end
+
+  end
+
+end
+
+

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: evio
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Thiago de Arruda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: tpadilha84@gmail.com
+executables: []
+extensions:
+- ext/evio/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/evio/signal.rb
+- lib/evio.rb
+- ext/evio/ev.c
+- ext/evio/evio.c
+- ext/evio/io.c
+- ext/evio/signal.c
+- ext/evio/evio.h
+- ext/evio/extconf.rb
+homepage: http://rubygems.org/gems/evio
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Simple non-blocking IO
+test_files: []