rev 0.1.0

data/ext/libev/ev_win32.c

@@ -0,0 +1,117 @@
+/*
+ * libev win32 compatibility cruft
+ *
+ * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef _WIN32
+
+#include <sys/timeb.h>
+
+/* note: the comment below could not be substantiated, but what would I care */
+/* MSDN says this is required to handle SIGFPE */
+volatile double SIGFPE_REQ = 0.0f; 
+
+/* oh, the humanity! */
+static int
+ev_pipe (int filedes [2])
+{
+  struct sockaddr_in addr = { 0 };
+  int addr_size = sizeof (addr);
+  SOCKET listener;
+  SOCKET sock [2] = { -1, -1 };
+
+  if ((listener = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) 
+    return -1;
+
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  addr.sin_port = 0;
+
+  if (bind (listener, (struct sockaddr *)&addr, addr_size))
+    goto fail;
+
+  if (getsockname(listener, (struct sockaddr *)&addr, &addr_size))
+    goto fail;
+
+  if (listen (listener, 1))
+    goto fail;
+
+  if ((sock [0] = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) 
+    goto fail;
+
+  if (connect (sock[0], (struct sockaddr *)&addr, addr_size))
+    goto fail;
+
+  if ((sock[1] = accept (listener, 0, 0)) < 0)
+    goto fail;
+
+  closesocket (listener);
+
+#if EV_SELECT_IS_WINSOCKET
+  filedes [0] = _open_osfhandle (sock [0], 0);
+  filedes [1] = _open_osfhandle (sock [1], 0);
+#else
+  /* when select isn't winsocket, we also expect socket, connect, accept etc.
+   * to work on fds */
+  filedes [0] = sock [0];
+  filedes [1] = sock [1];
+#endif
+
+  return 0;
+
+fail:
+  closesocket (listener);
+
+  if (sock [0] != INVALID_SOCKET) closesocket (sock [0]);
+  if (sock [1] != INVALID_SOCKET) closesocket (sock [1]);
+
+  return -1;
+}
+
+#undef pipe
+#define pipe(filedes) ev_pipe (filedes)
+
+static int
+ev_gettimeofday (struct timeval *tv, struct timezone *tz)
+{
+  struct _timeb tb;
+
+  _ftime (&tb);
+
+  tv->tv_sec  = (long)tb.time;
+  tv->tv_usec = ((long)tb.millitm) * 1000;
+
+  return 0;
+}
+
+#undef gettimeofday
+#define gettimeofday(tv,tz) ev_gettimeofday (tv, tz)
+
+#endif
+

data/ext/libev/ev_wrap.h

@@ -0,0 +1,132 @@
+/* DO NOT EDIT, automatically generated by update_ev_wrap */
+#ifndef EV_WRAP_H
+#define EV_WRAP_H
+#define now_floor ((loop)->now_floor)
+#define mn_now ((loop)->mn_now)
+#define rtmn_diff ((loop)->rtmn_diff)
+#define io_blocktime ((loop)->io_blocktime)
+#define timeout_blocktime ((loop)->timeout_blocktime)
+#define backend ((loop)->backend)
+#define activecnt ((loop)->activecnt)
+#define loop_count ((loop)->loop_count)
+#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 curpid ((loop)->curpid)
+#define postfork ((loop)->postfork)
+#define vec_ri ((loop)->vec_ri)
+#define vec_ro ((loop)->vec_ro)
+#define vec_wi ((loop)->vec_wi)
+#define vec_wo ((loop)->vec_wo)
+#define vec_max ((loop)->vec_max)
+#define polls ((loop)->polls)
+#define pollmax ((loop)->pollmax)
+#define pollcnt ((loop)->pollcnt)
+#define pollidxs ((loop)->pollidxs)
+#define pollidxmax ((loop)->pollidxmax)
+#define epoll_events ((loop)->epoll_events)
+#define epoll_eventmax ((loop)->epoll_eventmax)
+#define kqueue_changes ((loop)->kqueue_changes)
+#define kqueue_changemax ((loop)->kqueue_changemax)
+#define kqueue_changecnt ((loop)->kqueue_changecnt)
+#define kqueue_events ((loop)->kqueue_events)
+#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)
+#define timers ((loop)->timers)
+#define timermax ((loop)->timermax)
+#define timercnt ((loop)->timercnt)
+#define periodics ((loop)->periodics)
+#define periodicmax ((loop)->periodicmax)
+#define periodiccnt ((loop)->periodiccnt)
+#define idles ((loop)->idles)
+#define idlemax ((loop)->idlemax)
+#define idlecnt ((loop)->idlecnt)
+#define idleall ((loop)->idleall)
+#define prepares ((loop)->prepares)
+#define preparemax ((loop)->preparemax)
+#define preparecnt ((loop)->preparecnt)
+#define checks ((loop)->checks)
+#define checkmax ((loop)->checkmax)
+#define checkcnt ((loop)->checkcnt)
+#define forks ((loop)->forks)
+#define forkmax ((loop)->forkmax)
+#define forkcnt ((loop)->forkcnt)
+#define fs_fd ((loop)->fs_fd)
+#define fs_w ((loop)->fs_w)
+#define fs_hash ((loop)->fs_hash)
+#else
+#undef EV_WRAP_H
+#undef now_floor
+#undef mn_now
+#undef rtmn_diff
+#undef io_blocktime
+#undef timeout_blocktime
+#undef backend
+#undef activecnt
+#undef loop_count
+#undef backend_fd
+#undef backend_fudge
+#undef backend_modify
+#undef backend_poll
+#undef curpid
+#undef postfork
+#undef vec_ri
+#undef vec_ro
+#undef vec_wi
+#undef vec_wo
+#undef vec_max
+#undef polls
+#undef pollmax
+#undef pollcnt
+#undef pollidxs
+#undef pollidxmax
+#undef epoll_events
+#undef epoll_eventmax
+#undef kqueue_changes
+#undef kqueue_changemax
+#undef kqueue_changecnt
+#undef kqueue_events
+#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
+#undef timers
+#undef timermax
+#undef timercnt
+#undef periodics
+#undef periodicmax
+#undef periodiccnt
+#undef idles
+#undef idlemax
+#undef idlecnt
+#undef idleall
+#undef prepares
+#undef preparemax
+#undef preparecnt
+#undef checks
+#undef checkmax
+#undef checkcnt
+#undef forks
+#undef forkmax
+#undef forkcnt
+#undef fs_fd
+#undef fs_w
+#undef fs_hash
+#endif

data/ext/rev/extconf.rb

@@ -0,0 +1,36 @@
+require 'mkmf'
+
+flags = []
+
+unless have_func('rb_thread_blocking_region') and have_macro('RB_UBF_DFL', 'ruby.h')
+  abort "Rev requires (a fairly recent) Ruby 1.9 or greater"
+end
+
+if have_header('sys/select.h')
+  flags << '-DEV_USE_SELECT'
+end
+
+if have_header('poll.h')
+  flags << '-DEV_USE_POLL'
+end
+
+if have_header('sys/epoll.h')
+  flags << '-DEV_USE_EPOLL'
+end
+
+if have_header('sys/event.h') and have_header('sys/queue.h')
+  flags << '-DEV_USE_KQUEUE'
+end
+
+if have_header('port.h')
+  flags << '-DEV_USE_PORT'
+end
+
+if have_header('sys/inotify.h')
+  flags << '-DEV_USE_INOTIFY'
+end
+
+$CFLAGS << ' ' << flags.join(' ')
+
+dir_config('rev_ext')
+create_makefile('rev_ext')

data/ext/rev/rev.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2007 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#ifndef REV_H
+#define REV_H
+
+#include "ruby.h"
+
+struct Rev_Event
+{
+  /* These values are used to extract events from libev callbacks */
+  VALUE watcher;
+  int revents;
+};
+
+struct Rev_Loop 
+{
+  struct ev_loop *ev_loop;
+  int default_loop;
+
+  int events_received;
+  int eventbuf_size;
+  struct Rev_Event *eventbuf;
+};
+
+struct Rev_Watcher
+{
+  union {
+    struct ev_io ev_io;
+    struct ev_timer ev_timer;
+  } event_types;
+
+  int enabled;
+  VALUE loop;
+
+  void (*dispatch_callback)(VALUE self, int revents);
+};
+
+void Rev_Loop_process_event(VALUE watcher, int revents);
+
+#endif

data/ext/rev/rev_ext.c

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2007 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include "ruby.h"
+
+#define EV_STANDALONE 1
+#include "../libev/ev.c"
+
+#include "rev.h"
+
+static VALUE mRev = Qnil;
+
+void Init_rev_ext() 
+{
+  ev_set_allocator((void *(*)(void *, long))xrealloc);
+  mRev = rb_define_module("Rev");
+
+  /* Make libev version available in Ruby */
+  rb_define_const(mRev, "LIBEV_VERSION", rb_sprintf("%d.%d", ev_version_major(), ev_version_minor()));
+
+  /* Initializers for other modules */
+  Init_rev_loop();
+  Init_rev_watcher();
+  Init_rev_io_watcher();
+  Init_rev_timer_watcher();
+}

data/ext/rev/rev_io_watcher.c

@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2007 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include "ruby.h"
+#include "rubyio.h"
+
+#define EV_STANDALONE 1
+#include "../libev/ev.h"
+
+#include "rev.h"
+#include "rev_watcher.h"
+
+/* Module and object handles */
+static VALUE mRev = Qnil;
+static VALUE cRev_Watcher = Qnil;
+static VALUE cRev_Loop = Qnil;
+static VALUE cRev_IOWatcher = Qnil;
+
+/* Method implementations */
+static VALUE Rev_IOWatcher_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE Rev_IOWatcher_attach(VALUE self, VALUE loop);
+static VALUE Rev_IOWatcher_detach(VALUE self);
+static VALUE Rev_IOWatcher_enable(VALUE self);
+static VALUE Rev_IOWatcher_disable(VALUE self);
+static VALUE Rev_IOWatcher_on_readable(VALUE self);
+static VALUE Rev_IOWatcher_on_writable(VALUE self);
+
+/* Callbacks */
+static void Rev_IOWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
+static void Rev_IOWatcher_dispatch_callback(VALUE self, int revents);
+
+void Init_rev_io_watcher()
+{
+  mRev = rb_define_module("Rev");
+  cRev_Watcher = rb_define_class_under(mRev, "Watcher", rb_cObject);
+  cRev_IOWatcher = rb_define_class_under(mRev, "IOWatcher", cRev_Watcher);
+  cRev_Loop = rb_define_class_under(mRev, "Loop", rb_cObject);
+
+  rb_define_method(cRev_IOWatcher, "initialize", Rev_IOWatcher_initialize, -1);
+  rb_define_method(cRev_IOWatcher, "attach", Rev_IOWatcher_attach, 1);
+  rb_define_method(cRev_IOWatcher, "detach", Rev_IOWatcher_detach, 0);
+  rb_define_method(cRev_IOWatcher, "enable", Rev_IOWatcher_enable, 0);
+  rb_define_method(cRev_IOWatcher, "disable", Rev_IOWatcher_disable, 0);
+  rb_define_method(cRev_IOWatcher, "on_readable", Rev_IOWatcher_on_readable, 0);
+  rb_define_method(cRev_IOWatcher, "on_writable", Rev_IOWatcher_on_writable, 0);
+}
+
+/**
+ *  call-seq:
+ *    Rev::IOWatcher.initialize(IO, events = 'r') -> Rev::IOWatcher
+ * 
+ * Create a new Rev::IOWatcher for the given IO object and add it to the given Rev::Loop
+ */
+static VALUE Rev_IOWatcher_initialize(int argc, VALUE *argv, VALUE self)
+{
+	VALUE io, flags;
+	char *flags_str;
+	int events;
+  rb_io_t *fptr;
+  struct Rev_Watcher *watcher_data;
+
+	rb_scan_args(argc, argv, "11", &io, &flags);
+	
+	if(flags != Qnil)
+		flags_str = RSTRING_PTR(rb_String(flags));
+	else
+		flags_str = "r";
+		
+	if(!strcmp(flags_str, "r"))
+		events = EV_READ;
+	else if(!strcmp(flags_str, "w"))
+		events = EV_WRITE;
+	else if(!strcmp(flags_str, "rw"))
+		events = EV_READ | EV_WRITE;
+	else
+		rb_raise(rb_eArgError, "invalid event type: '%s' (must be 'r', 'w', or 'rw')", flags_str);
+
+  GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+  Data_Get_Struct(self, struct Rev_Watcher, watcher_data);
+
+  watcher_data->dispatch_callback = Rev_IOWatcher_dispatch_callback;
+  ev_io_init(&watcher_data->event_types.ev_io, Rev_IOWatcher_libev_callback, fptr->fd, events);
+  watcher_data->event_types.ev_io.data = (void *)self;
+
+	return Qnil;
+}
+
+static VALUE Rev_IOWatcher_attach(VALUE self, VALUE loop)
+{
+  Watcher_Attach(io, Rev_IOWatcher_detach, self, loop);
+
+  return self;  
+}
+
+static VALUE Rev_IOWatcher_detach(VALUE self)
+{
+  Watcher_Detach(io, self);
+
+  return self;
+}
+
+static VALUE Rev_IOWatcher_enable(VALUE self)
+{
+  Watcher_Enable(io, self);
+
+  return self;  
+}
+
+static VALUE Rev_IOWatcher_disable(VALUE self)
+{
+  Watcher_Disable(io, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Rev::IOWatcher#on_readable -> nil
+ * 
+ * Called whenever the IO object associated with the IOWatcher is readable
+ */
+static VALUE Rev_IOWatcher_on_readable(VALUE self)
+{
+  return Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Rev::IOWatcher#on_writable -> nil
+ * 
+ * Called whenever the IO object associated with the IOWatcher is writable
+ */
+
+static VALUE Rev_IOWatcher_on_writable(VALUE self)
+{
+  return Qnil;
+}
+
+/* libev callback */
+static void Rev_IOWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents)
+{
+  Rev_Loop_process_event((VALUE)io->data, revents);
+}
+
+/* Rev::Loop dispatch callback */
+static void Rev_IOWatcher_dispatch_callback(VALUE self, int revents)
+{   
+  if(revents & EV_READ)
+    rb_funcall(self, rb_intern("on_readable"), 0, 0);
+  else if(revents & EV_WRITE)
+    rb_funcall(self, rb_intern("on_writable"), 0, 0);
+  else
+    rb_raise(rb_eRuntimeError, "unknown revents value for ev_io: %d", revents);
+}