cool.io 0.9.0

data/ext/cool.io/watcher.c

@@ -0,0 +1,264 @@
+/*
+ * Copyright (C) 2007-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"
+
+static VALUE mCoolio = Qnil;
+static VALUE cCoolio_Watcher = Qnil;
+
+static VALUE Coolio_Watcher_allocate(VALUE klass);
+static void Coolio_Watcher_mark(struct Coolio_Watcher *watcher);
+static void Coolio_Watcher_free(struct Coolio_Watcher *watcher);
+
+static VALUE Coolio_Watcher_initialize(VALUE self);
+static VALUE Coolio_Watcher_attach(VALUE self, VALUE loop);
+static VALUE Coolio_Watcher_detach(VALUE self);
+static VALUE Coolio_Watcher_enable(VALUE self);
+static VALUE Coolio_Watcher_disable(VALUE self);
+static VALUE Coolio_Watcher_evloop(VALUE self);
+static VALUE Coolio_Watcher_attached(VALUE self);
+static VALUE Coolio_Watcher_enabled(VALUE self);
+
+/* 
+ * Watchers are Coolio's event observers.  They contain a set of callback
+ * methods prefixed by on_* which fire whenever events occur.
+ *
+ * In order for a watcher to fire events it must be attached to a running
+ * loop.  Every watcher has an attach and detach method to control which
+ * loop it's associated with.
+ *
+ * Watchers also have an enable and disable method.  This allows a watcher
+ * to temporarily ignore certain events while remaining attached to a given
+ * loop.  This is good for watchers which need to be toggled on and off.
+ */
+void Init_coolio_watcher()
+{
+  mCoolio = rb_define_module("Coolio");
+  cCoolio_Watcher = rb_define_class_under(mCoolio, "Watcher", rb_cObject);
+  rb_define_alloc_func(cCoolio_Watcher, Coolio_Watcher_allocate);
+
+  rb_define_method(cCoolio_Watcher, "initialize", Coolio_Watcher_initialize, 0);
+  rb_define_method(cCoolio_Watcher, "attach", Coolio_Watcher_attach, 1);
+  rb_define_method(cCoolio_Watcher, "detach", Coolio_Watcher_detach, 0);
+  rb_define_method(cCoolio_Watcher, "enable", Coolio_Watcher_enable, 0);
+  rb_define_method(cCoolio_Watcher, "disable", Coolio_Watcher_disable, 0);
+  rb_define_method(cCoolio_Watcher, "evloop", Coolio_Watcher_evloop, 0);
+  rb_define_method(cCoolio_Watcher, "attached?", Coolio_Watcher_attached, 0);
+  rb_define_method(cCoolio_Watcher, "enabled?", Coolio_Watcher_enabled, 0);
+}
+
+static VALUE Coolio_Watcher_allocate(VALUE klass)
+{
+  struct Coolio_Watcher *watcher_data = (struct Coolio_Watcher *)xmalloc(sizeof(struct Coolio_Watcher));
+
+  watcher_data->loop = Qnil;
+  watcher_data->enabled = 0;
+
+  return Data_Wrap_Struct(klass, Coolio_Watcher_mark, Coolio_Watcher_free, watcher_data);
+}
+
+static void Coolio_Watcher_mark(struct Coolio_Watcher *watcher_data)
+{
+  if(watcher_data->loop != Qnil)
+    rb_gc_mark(watcher_data->loop);
+}
+
+static void Coolio_Watcher_free(struct Coolio_Watcher *watcher_data)
+{
+  xfree(watcher_data);
+}
+
+static VALUE Coolio_Watcher_initialize(VALUE self)
+{
+  rb_raise(rb_eRuntimeError, "watcher base class should not be initialized directly");
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.attach(loop) -> Coolio::Watcher
+ * 
+ * Attach the 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_Watcher_attach(VALUE self, VALUE loop)
+{
+  VALUE loop_watchers, active_watchers;
+  struct Coolio_Watcher *watcher_data;
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data->enabled = 1;
+    
+  loop_watchers = rb_iv_get(loop, "@watchers");
+
+  if(loop_watchers == Qnil) {
+    /* we should never get here */
+    loop_watchers = rb_hash_new();
+    rb_iv_set(loop, "@watchers", loop_watchers);
+  }
+
+  /* Add us to the loop's array of active watchers.  This is mainly done
+   * to keep the VM from garbage collecting watchers that are associated
+   * with a loop (and also lets you see within Ruby which watchers are
+   * associated with a given loop), but isn't really necessary for any 
+   * other reason */
+  rb_hash_aset(loop_watchers, self, Qtrue);
+
+  active_watchers = rb_iv_get(loop, "@active_watchers");
+  if(active_watchers == Qnil)
+    active_watchers = INT2NUM(1);
+  else
+    active_watchers = INT2NUM(NUM2INT(active_watchers) + 1);
+  rb_iv_set(loop, "@active_watchers", active_watchers);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.detach -> Coolio::Watcher
+ * 
+ * Detach the watcher from its current Coolio::Loop.
+ */
+static VALUE Coolio_Watcher_detach(VALUE self)
+{
+  struct Coolio_Watcher *watcher_data;
+  struct Coolio_Loop *loop_data;
+  VALUE loop_watchers;
+  int i;
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  if(watcher_data->loop == Qnil)
+    rb_raise(rb_eRuntimeError, "not attached to a loop");
+
+  loop_watchers = rb_iv_get(watcher_data->loop, "@watchers");
+
+  /* Remove us from the loop's array of active watchers.  This likely
+   * has negative performance and scalability characteristics as this
+   * isn't an O(1) operation.  Hopefully there's a better way...
+   * Trying a hash for now... */
+  rb_hash_delete(loop_watchers, self);
+
+  if(watcher_data->enabled) {
+    rb_iv_set(
+        watcher_data->loop, 
+        "@active_watchers",
+        INT2NUM(NUM2INT(rb_iv_get(watcher_data->loop, "@active_watchers")) - 1)
+    );
+  }
+
+  watcher_data->enabled = 0;
+
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+
+  /* Iterate through the events in the loop's event buffer.  If there
+   * are any pending events from this watcher, mark them NULL.  The
+   * dispatch loop will skip them.  This prevents watchers earlier
+   * in the event buffer from detaching others which may have pending
+   * events in the buffer but get garbage collected in the meantime */
+  for(i = 0; i < loop_data->events_received; i++) {
+    if(loop_data->eventbuf[i].watcher == self)
+      loop_data->eventbuf[i].watcher = Qnil;
+  }
+
+  watcher_data->loop = Qnil;
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.enable -> Coolio::Watcher
+ * 
+ * Re-enable a watcher which has been temporarily disabled.  See the
+ * disable method for a more thorough explanation.
+ */
+static VALUE Coolio_Watcher_enable(VALUE self)
+{
+  struct Coolio_Watcher *watcher_data;
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  if(watcher_data->enabled)
+    rb_raise(rb_eRuntimeError, "already enabled");
+
+  watcher_data->enabled = 1;
+
+  rb_iv_set(
+      watcher_data->loop, 
+      "@active_watchers",
+      INT2NUM(NUM2INT(rb_iv_get(watcher_data->loop, "@active_watchers")) + 1)
+  );
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.disable -> Coolio::Watcher
+ * 
+ * Temporarily disable an event watcher which is attached to a loop.  
+ * This is useful if you wish to toggle event monitoring on and off.  
+ */
+static VALUE Coolio_Watcher_disable(VALUE self)
+{
+  struct Coolio_Watcher *watcher_data;
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  if(!watcher_data->enabled)
+    rb_raise(rb_eRuntimeError, "already disabled");
+
+  watcher_data->enabled = 0;
+
+  rb_iv_set(
+      watcher_data->loop, 
+      "@active_watchers",
+      INT2NUM(NUM2INT(rb_iv_get(watcher_data->loop, "@active_watchers")) - 1)
+  );
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.evloop -> Coolio::Loop
+ * 
+ * Return the loop to which we're currently attached
+ */
+static VALUE Coolio_Watcher_evloop(VALUE self)
+{
+  struct Coolio_Watcher *watcher_data;
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  return watcher_data->loop;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.attached? -> Boolean
+ * 
+ * Is the watcher currently attached to an event loop?
+ */
+static VALUE Coolio_Watcher_attached(VALUE self)
+{
+  return Coolio_Watcher_evloop(self) != Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Watcher.enabled? -> Boolean
+ * 
+ * Is the watcher currently enabled?
+ */
+static VALUE Coolio_Watcher_enabled(VALUE self)
+{
+	struct Coolio_Watcher *watcher_data;
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  
+	return watcher_data->enabled ? Qtrue : Qfalse;
+}

data/ext/cool.io/watcher.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2007-10 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#ifndef WATCHER_H
+#define WATCHER_H
+
+#define Watcher_Attach(watcher_type, detach_func, watcher, loop) \
+  struct Coolio_Watcher *watcher_data; \
+  struct Coolio_Loop *loop_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(watcher, struct Coolio_Watcher, watcher_data); \
+  Data_Get_Struct(loop, struct Coolio_Loop, loop_data); \
+  \
+  if(watcher_data->loop != Qnil) \
+    detach_func(watcher); \
+  \
+  watcher_data->loop = loop; \
+  ev_##watcher_type##_start(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  rb_call_super(1, &loop)
+
+#define Watcher_Detach(watcher_type, watcher) \
+  struct Coolio_Watcher *watcher_data; \
+  struct Coolio_Loop *loop_data; \
+  \
+  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  \
+  if(watcher_data->loop == Qnil) \
+    rb_raise(rb_eRuntimeError, "not attached to a loop"); \
+  \
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
+  \
+  ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  rb_call_super(0, 0)
+
+#define Watcher_Enable(watcher_type, watcher) \
+  struct Coolio_Watcher *watcher_data; \
+  struct Coolio_Loop *loop_data; \
+  \
+  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  \
+  if(watcher_data->loop == Qnil) \
+    rb_raise(rb_eRuntimeError, "not attached to a loop"); \
+  \
+  rb_call_super(0, 0); \
+  \
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
+  \
+  ev_##watcher_type##_start(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type)
+
+#define Watcher_Disable(watcher_type, watcher) \
+  struct Coolio_Watcher *watcher_data; \
+  struct Coolio_Loop *loop_data; \
+  \
+  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  \
+  if(watcher_data->loop == Qnil) \
+    rb_raise(rb_eRuntimeError, "not attached to a loop"); \
+  \
+  rb_call_super(0, 0); \
+  \
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
+  \
+  ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type)
+
+#endif

data/ext/http11_client/.gitignore

@@ -0,0 +1,5 @@
+Makefile
+mkmf.log
+*.o
+*.so
+*.bundle

data/ext/http11_client/ext_help.h

@@ -0,0 +1,14 @@
+#ifndef ext_help_h
+#define ext_help_h
+
+#define RAISE_NOT_NULL(T) if(T == NULL) rb_raise(rb_eArgError, "NULL found for " # T " when shouldn't be.");
+#define DATA_GET(from,type,name) Data_Get_Struct(from,type,name); RAISE_NOT_NULL(name);
+#define REQUIRE_TYPE(V, T) if(TYPE(V) != T) rb_raise(rb_eTypeError, "Wrong argument type for " # V " required " # T);
+
+#ifdef DEBUG
+#define TRACE()  fprintf(stderr, "> %s:%d:%s\n", __FILE__, __LINE__, __FUNCTION__)
+#else
+#define TRACE() 
+#endif
+
+#endif

data/ext/http11_client/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+dir_config("http11_client")
+have_library("c", "main")
+
+create_makefile("http11_client")

data/ext/http11_client/http11_client.c

@@ -0,0 +1,300 @@
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+
+#include "ruby.h"
+#include "ext_help.h"
+#include <assert.h>
+#include <string.h>
+#include "http11_parser.h"
+#include <ctype.h>
+
+static VALUE mCoolio;
+static VALUE cHttpClientParser;
+static VALUE eHttpClientParserError;
+
+#define  id_reason rb_intern("@http_reason")
+#define  id_status rb_intern("@http_status")
+#define  id_version rb_intern("@http_version")
+#define  id_body rb_intern("@http_body")
+#define  id_chunk_size rb_intern("@http_chunk_size")
+#define  id_last_chunk rb_intern("@last_chunk")
+
+void client_http_field(void *data, const char *field, size_t flen, const char *value, size_t vlen)
+{
+  char *ch, *end;
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+  VALUE f = Qnil;
+
+  v = rb_str_new(value, vlen);
+  f = rb_str_new(field, flen);
+
+  /* Yes Children, rb_str_upcase_bang isn't even available as an intern.h function.
+   * how incredibly handy to not have that.  Nope, I have to do it by hand.*/
+  for(ch = RSTRING_PTR(f), end = ch + RSTRING_LEN(f); ch < end; ch++) {
+    if(*ch == '-') {
+      *ch = '_';
+    } else {
+      *ch = toupper(*ch);
+    }
+  }
+
+  rb_hash_aset(req, f, v);
+}
+
+void client_reason_phrase(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+
+  v = rb_str_new(at, length);
+
+  rb_ivar_set(req, id_reason, v);
+}
+
+void client_status_code(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+
+  v = rb_str_new(at, length);
+
+  rb_ivar_set(req, id_status, v);
+}
+
+void client_http_version(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+
+  v = rb_str_new(at, length);
+
+  rb_ivar_set(req, id_version, v);
+}
+
+/** Finalizes the request header to have a bunch of stuff that's
+  needed. */
+void client_header_done(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+
+  v = rb_str_new(at, length);
+  rb_ivar_set(req, id_body, v);
+}
+
+void client_chunk_size(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+
+  if(length <= 0) {
+    rb_raise(eHttpClientParserError, "Chunked Encoding gave <= 0 chunk size.");
+  }
+
+  v = rb_str_new(at, length);
+
+  rb_ivar_set(req, id_chunk_size, v);
+}
+
+void client_last_chunk(void *data, const char *at, size_t length) {
+  VALUE req = (VALUE)data;
+  rb_ivar_set(req, id_last_chunk,Qtrue);
+}
+
+
+void HttpClientParser_free(void *data) {
+  TRACE();
+
+  if(data) {
+    free(data);
+  }
+}
+
+
+VALUE HttpClientParser_alloc(VALUE klass)
+{
+  VALUE obj;
+  httpclient_parser *hp = ALLOC_N(httpclient_parser, 1);
+  TRACE();
+  hp->http_field = client_http_field;
+  hp->status_code = client_status_code;
+  hp->reason_phrase = client_reason_phrase;
+  hp->http_version = client_http_version;
+  hp->header_done = client_header_done;
+  hp->chunk_size = client_chunk_size;
+  hp->last_chunk = client_last_chunk;
+  httpclient_parser_init(hp);
+
+  obj = Data_Wrap_Struct(klass, NULL, HttpClientParser_free, hp);
+
+  return obj;
+}
+
+
+/**
+ * call-seq:
+ *    parser.new -> parser
+ *
+ * Creates a new parser.
+ */
+VALUE HttpClientParser_init(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+  httpclient_parser_init(http);
+
+  return self;
+}
+
+
+/**
+ * call-seq:
+ *    parser.reset -> nil
+ *
+ * Resets the parser to it's initial state so that you can reuse it
+ * rather than making new ones.
+ */
+VALUE HttpClientParser_reset(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+  httpclient_parser_init(http);
+
+  return Qnil;
+}
+
+
+/**
+ * call-seq:
+ *    parser.finish -> true/false
+ *
+ * Finishes a parser early which could put in a "good" or bad state.
+ * You should call reset after finish it or bad things will happen.
+ */
+VALUE HttpClientParser_finish(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+  httpclient_parser_finish(http);
+
+  return httpclient_parser_is_finished(http) ? Qtrue : Qfalse;
+}
+
+
+/**
+ * call-seq:
+ *    parser.execute(req_hash, data, start) -> Integer
+ *
+ * Takes a Hash and a String of data, parses the String of data filling in the Hash
+ * returning an Integer to indicate how much of the data has been read.  No matter
+ * what the return value, you should call HttpClientParser#finished? and HttpClientParser#error?
+ * to figure out if it's done parsing or there was an error.
+ * 
+ * This function now throws an exception when there is a parsing error.  This makes 
+ * the logic for working with the parser much easier.  You can still test for an 
+ * error, but now you need to wrap the parser with an exception handling block.
+ *
+ * The third argument allows for parsing a partial request and then continuing
+ * the parsing from that position.  It needs all of the original data as well 
+ * so you have to append to the data buffer as you read.
+ */
+VALUE HttpClientParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
+{
+  httpclient_parser *http = NULL;
+  int from = 0;
+  char *dptr = NULL;
+  long dlen = 0;
+
+  REQUIRE_TYPE(req_hash, T_HASH);
+  REQUIRE_TYPE(data, T_STRING);
+  REQUIRE_TYPE(start, T_FIXNUM);
+
+  DATA_GET(self, httpclient_parser, http);
+
+  from = FIX2INT(start);
+  dptr = RSTRING_PTR(data);
+  dlen = RSTRING_LEN(data);
+
+  if(from >= dlen) {
+    rb_raise(eHttpClientParserError, "Requested start is after data buffer end.");
+  } else {
+    http->data = (void *)req_hash;
+    httpclient_parser_execute(http, dptr, dlen, from);
+
+    if(httpclient_parser_has_error(http)) {
+      rb_raise(eHttpClientParserError, "Invalid HTTP format, parsing fails.");
+    } else {
+      return INT2FIX(httpclient_parser_nread(http));
+    }
+  }
+}
+
+
+
+/**
+ * call-seq:
+ *    parser.error? -> true/false
+ *
+ * Tells you whether the parser is in an error state.
+ */
+VALUE HttpClientParser_has_error(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+
+  return httpclient_parser_has_error(http) ? Qtrue : Qfalse;
+}
+
+
+/**
+ * call-seq:
+ *    parser.finished? -> true/false
+ *
+ * Tells you whether the parser is finished or not and in a good state.
+ */
+VALUE HttpClientParser_is_finished(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+
+  return httpclient_parser_is_finished(http) ? Qtrue : Qfalse;
+}
+
+
+/**
+ * call-seq:
+ *    parser.nread -> Integer
+ *
+ * Returns the amount of data processed so far during this processing cycle.  It is
+ * set to 0 on initialize or reset calls and is incremented each time execute is called.
+ */
+VALUE HttpClientParser_nread(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+
+  return INT2FIX(http->nread);
+}
+
+
+
+void Init_http11_client()
+{
+
+  mCoolio = rb_define_module("Coolio");
+
+  eHttpClientParserError = rb_define_class_under(mCoolio, "HttpClientParserError", rb_eIOError);
+
+  cHttpClientParser = rb_define_class_under(mCoolio, "HttpClientParser", rb_cObject);
+  rb_define_alloc_func(cHttpClientParser, HttpClientParser_alloc);
+  rb_define_method(cHttpClientParser, "initialize", HttpClientParser_init,0);
+  rb_define_method(cHttpClientParser, "reset", HttpClientParser_reset,0);
+  rb_define_method(cHttpClientParser, "finish", HttpClientParser_finish,0);
+  rb_define_method(cHttpClientParser, "execute", HttpClientParser_execute,3);
+  rb_define_method(cHttpClientParser, "error?", HttpClientParser_has_error,0);
+  rb_define_method(cHttpClientParser, "finished?", HttpClientParser_is_finished,0);
+  rb_define_method(cHttpClientParser, "nread", HttpClientParser_nread,0);
+}