cool.io 1.4.1-x64-mingw32

data/Rakefile

@@ -0,0 +1,79 @@
+require 'bundler/gem_tasks'
+require 'rake/clean'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+RSpec::Core::RakeTask.new(:rcov) do |task|
+  task.rcov = true
+end
+
+task :default => %w(compile spec)
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cool.io #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/extensiontask'
+
+spec = eval(File.read("cool.io.gemspec"))
+
+def configure_cross_compilation(ext)
+  unless RUBY_PLATFORM =~ /mswin|mingw/
+    ext.cross_compile = true
+    ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
+  end
+end
+
+Rake::ExtensionTask.new('iobuffer_ext', spec) do |ext|
+  ext.ext_dir = 'ext/iobuffer'
+  configure_cross_compilation(ext)
+end
+
+Rake::ExtensionTask.new('cool.io_ext', spec) do |ext|
+  ext.ext_dir = 'ext/cool.io'
+  configure_cross_compilation(ext)
+end
+
+# Note that this rake-compiler-dock rake task dose not support bundle install(1) --path option.
+# Please use bundle install instead when you execute this rake task.
+namespace :build do
+  desc 'Build gems for Windows per rake-compiler-dock'
+  task :windows do
+    require 'rake_compiler_dock'
+    RakeCompilerDock.sh <<-CROSS
+      bundle
+      rake cross native gem RUBY_CC_VERSION='2.0.0:2.1.6:2.2.2'
+    CROSS
+  end
+end
+
+# adapted from http://flavoriffic.blogspot.com/2009/06/easily-valgrind-gdb-your-ruby-c.html
+def specs_command
+  require "find"
+  files = []
+  Find.find("spec") do |f|
+    files << f if File.basename(f) =~ /.*spec.*\.rb$/
+  end
+  cmdline = "#{RUBY} -I.:lib:ext:spec \
+               -e '%w[#{files.join(' ')}].each { |f| require f }'"
+end
+
+namespace :spec do
+  desc "run specs with valgrind"
+  task :valgrind => :compile do
+    system "valgrind --num-callers=15 \
+      --partial-loads-ok=yes --undef-value-errors=no \
+      --tool=memcheck --leak-check=yes --track-fds=yes \
+      --show-reachable=yes #{specs_command}"
+  end
+end
+
+CLEAN.include "**/*.rbc", "**/*.o", "**/*.so", "**/*.bundle"
+CLEAN.exclude "vendor/**/*.rbc", "vendor/**/*.o", "vendor/**/*.so", "vendor/**/*.bundle"

data/cool.io.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cool.io/version"
+
+module Cool
+  # Allow Coolio module to be referenced as Cool.io
+  def self.io; Coolio; end
+end
+
+Gem::Specification.new do |s|
+  s.name        = "cool.io"
+  s.version     = Coolio::VERSION
+  s.authors     = ["Tony Arcieri", "Masahiro Nakagawa"]
+  s.email       = ["tony.arcieri@gmail.com", "repeatedly@gmail.com"]
+  s.homepage    = "http://coolio.github.com"
+  s.summary     = "A cool framework for doing high performance I/O in Ruby"
+  s.description = "Cool.io provides a high performance event framework for Ruby which uses the libev C library"
+  s.extensions = ["ext/cool.io/extconf.rb", "ext/iobuffer/extconf.rb"]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency "rake-compiler", "~> 0.9.5"
+  s.add_development_dependency "rake-compiler-dock", "~> 0.4.3"
+  s.add_development_dependency "rspec", ">= 2.13.0"
+  s.add_development_dependency "rdoc", ">= 3.6.0"
+end

data/examples/callbacked_echo_server.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'cool.io'
+
+ADDR = '127.0.0.1'
+PORT = 4321
+
+event_loop = Cool.io::Loop.default
+server = Cool.io::TCPServer.new(ADDR, PORT) do |connection|
+  puts "#{connection.remote_addr}:#{connection.remote_port} connected"
+
+  connection.on_close do
+    puts "#{connection.remote_addr}:#{connection.remote_port} disconnected"
+  end
+
+  connection.on_read do |data|
+    connection.write data
+  end
+end
+server.attach(event_loop)
+
+puts "Echo server listening on #{ADDR}:#{PORT}"
+event_loop.run

data/examples/dslified_echo_client.rb

@@ -0,0 +1,34 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'cool.io'
+
+ADDR = '127.0.0.1'
+PORT = 4321
+
+cool.io.connect ADDR, PORT do
+  on_connect do
+    puts "Connected to #{remote_host}:#{remote_port}"
+    write "bounce this back to me"
+  end
+
+  on_close do
+    puts "Disconnected from #{remote_host}:#{remote_port}"
+  end
+
+  on_read do |data|
+    puts "Got: #{data}"
+    close
+  end
+
+  on_resolve_failed do
+    puts "Error: Couldn't resolve #{remote_host}"
+  end
+
+  on_connect_failed do
+    puts "Error: Connection refused to #{remote_host}:#{remote_port}"
+  end
+end
+
+puts "Echo client connecting to #{ADDR}:#{PORT}..."
+cool.io.run 

data/examples/dslified_echo_server.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'cool.io'
+
+ADDR = '127.0.0.1'
+PORT = 4321
+
+cool.io.server ADDR, PORT do
+  on_connect do
+    puts "#{remote_addr}:#{remote_port} connected"
+  end
+
+  on_close do
+    puts "#{remote_addr}:#{remote_port} disconnected"
+  end
+
+  on_read do |data|
+    write data
+  end
+end
+
+puts "Echo server listening on #{ADDR}:#{PORT}"
+cool.io.run

data/examples/echo_client.rb

@@ -0,0 +1,38 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'cool.io'
+
+ADDR = '127.0.0.1'
+PORT = 4321
+
+class ClientConnection < Cool.io::TCPSocket
+  def on_connect
+    puts "#{remote_addr}:#{remote_port} connected"
+    write "bounce this back to me"
+  end
+
+  def on_close
+    puts "#{remote_addr}:#{remote_port} disconnected"
+  end
+
+  def on_read(data)
+    print "got #{data}"
+    close
+  end
+
+  def on_resolve_failed
+    print "DNS resolve failed"
+  end
+
+  def on_connect_failed
+    print "connect failed, meaning our connection to their port was rejected"
+  end
+
+end
+
+event_loop = Cool.io::Loop.default
+client = ClientConnection.connect(ADDR, PORT)
+client.attach(event_loop)
+puts "Echo client connecting to #{ADDR}:#{PORT}..."
+event_loop.run 

data/examples/echo_server.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'cool.io'
+
+ADDR = '127.0.0.1'
+PORT = 4321
+
+class EchoServerConnection < Cool.io::TCPSocket
+  def on_connect
+    puts "#{remote_addr}:#{remote_port} connected"
+  end
+
+  def on_close
+    puts "#{remote_addr}:#{remote_port} disconnected"
+  end
+
+  def on_read(data)
+    write data
+  end
+end
+
+event_loop = Cool.io::Loop.default
+Cool.io::TCPServer.new(ADDR, PORT, EchoServerConnection).attach(event_loop)
+
+puts "Echo server listening on #{ADDR}:#{PORT}"
+event_loop.run

data/examples/google.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'cool.io'
+
+l = Coolio::Loop.default
+c = Coolio::HttpClient.connect("www.google.com", 80).attach(l)
+c.request('GET', '/search', :query => { :q => 'feces'})
+l.run

data/ext/cool.io/.gitignore

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

data/ext/cool.io/cool.io.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2007-10 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#ifndef COOLIO_H
+#define COOLIO_H
+
+#include "ruby.h"
+#include "rubyio.h"
+
+#ifdef GetReadFile
+#define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
+#else
+
+#if !HAVE_RB_IO_T || (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
+#define FPTR_TO_FD(fptr) fileno(fptr->f)
+#else
+#define FPTR_TO_FD(fptr) fptr->fd
+#endif
+
+#endif
+
+struct Coolio_Event
+{
+  /* These values are used to extract events from libev callbacks */
+  VALUE watcher;
+  int revents;
+};
+
+struct Coolio_Loop 
+{
+  struct ev_loop *ev_loop;
+  struct ev_timer timer; /* for timeouts */
+
+  int running;
+  int events_received;
+  int eventbuf_size;
+  struct Coolio_Event *eventbuf;
+};
+
+struct Coolio_Watcher
+{
+  union {
+    struct ev_io ev_io;
+    struct ev_timer ev_timer;
+    struct ev_stat ev_stat;
+  } event_types;
+
+  int enabled;
+  VALUE loop;
+
+  void (*dispatch_callback)(VALUE self, int revents);
+};
+
+void Coolio_Loop_process_event(VALUE watcher, int revents);
+
+#endif

data/ext/cool.io/cool.io_ext.c

@@ -0,0 +1,25 @@
+/*
+ * 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;
+
+/* Initialize the coolness */
+void Init_cool() 
+{
+  /* Initializers for other modules */
+  Init_coolio_loop();
+  Init_coolio_watcher();
+  Init_coolio_iowatcher();
+  Init_coolio_timer_watcher();
+  Init_coolio_stat_watcher();
+  Init_coolio_utils();
+}

data/ext/cool.io/ev_wrap.h

@@ -0,0 +1,10 @@
+#define EV_STANDALONE              /* keeps ev from requiring config.h */
+
+#ifdef _WIN32
+#define EV_SELECT_IS_WINSOCKET 1   /* configure libev for windows select */
+#define EV_USE_MONOTONIC 0
+#define EV_USE_REALTIME 0
+#endif
+
+#include "../libev/ev.h"
+

data/ext/cool.io/extconf.rb

@@ -0,0 +1,61 @@
+require 'mkmf'
+
+libs = []
+
+$defs << "-DRUBY_VERSION_CODE=#{RUBY_VERSION.gsub(/\D/, '')}"
+
+have_func('rb_thread_blocking_region')
+have_func('rb_thread_call_without_gvl')
+have_func('rb_thread_alone')
+have_func('rb_str_set_len')
+have_library('rt', 'clock_gettime')
+
+if have_header('sys/select.h')
+  $defs << '-DEV_USE_SELECT'
+end
+
+if have_header('poll.h')
+  $defs << '-DEV_USE_POLL'
+end
+
+if have_header('sys/epoll.h')
+  $defs << '-DEV_USE_EPOLL'
+end
+
+if have_header('sys/event.h') and have_header('sys/queue.h')
+  $defs << '-DEV_USE_KQUEUE'
+end
+
+if have_header('port.h')
+  $defs << '-DEV_USE_PORT'
+end
+
+have_header('sys/resource.h')
+
+# ncpu detection specifics
+case RUBY_PLATFORM
+when /linux/
+  $defs << '-DHAVE_LINUX_PROCFS'
+else
+  if have_func('sysctlbyname', ['sys/param.h', 'sys/sysctl.h'])
+    $defs << '-DHAVE_SYSCTLBYNAME'
+  end
+end
+
+$LIBS << ' ' << libs.join(' ')
+
+dir_config('cool.io_ext')
+create_makefile('cool.io_ext')
+
+# 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|mswin/
+  makefile_contents = File.read 'Makefile'
+
+  # "Init_cool could not be found" when loading cool.io.so.
+  # I'm not sure why this is needed. But this line causes "1114 A dynamic link library (DLL) initialization routine failed." So I commented out this line.
+  #makefile_contents.gsub! 'DLDFLAGS = ', 'DLDFLAGS = -export-all '
+
+  makefile_contents.gsub! /LIBS = (.*) (\S*ws2_32\S*)/i, 'LIBS = \\2 \\1'
+  File.open('Makefile', 'w') { |f| f.write makefile_contents }
+end
+

data/ext/cool.io/iowatcher.c

@@ -0,0 +1,189 @@
+/*
+ * 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 "rubyio.h"
+
+#include "ev_wrap.h"
+
+#include "cool.io.h"
+#include "watcher.h"
+
+static VALUE mCoolio = Qnil;
+static VALUE cCoolio_Watcher = Qnil;
+static VALUE cCoolio_Loop = Qnil;
+static VALUE cCoolio_IOWatcher = Qnil;
+
+static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE Coolio_IOWatcher_attach(VALUE self, VALUE loop);
+static VALUE Coolio_IOWatcher_detach(VALUE self);
+static VALUE Coolio_IOWatcher_enable(VALUE self);
+static VALUE Coolio_IOWatcher_disable(VALUE self);
+static VALUE Coolio_IOWatcher_on_readable(VALUE self);
+static VALUE Coolio_IOWatcher_on_writable(VALUE self);
+
+static void Coolio_IOWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
+static void Coolio_IOWatcher_dispatch_callback(VALUE self, int revents);
+
+/*
+ * Coolio::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.
+ */
+void Init_coolio_iowatcher()
+{
+  mCoolio = rb_define_module("Coolio");
+  cCoolio_Watcher = rb_define_class_under(mCoolio, "Watcher", rb_cObject);
+  cCoolio_IOWatcher = rb_define_class_under(mCoolio, "IOWatcher", cCoolio_Watcher);
+  cCoolio_Loop = rb_define_class_under(mCoolio, "Loop", rb_cObject);
+
+  rb_define_method(cCoolio_IOWatcher, "initialize", Coolio_IOWatcher_initialize, -1);
+  rb_define_method(cCoolio_IOWatcher, "attach", Coolio_IOWatcher_attach, 1);
+  rb_define_method(cCoolio_IOWatcher, "detach", Coolio_IOWatcher_detach, 0);
+  rb_define_method(cCoolio_IOWatcher, "enable", Coolio_IOWatcher_enable, 0);
+  rb_define_method(cCoolio_IOWatcher, "disable", Coolio_IOWatcher_disable, 0);
+  rb_define_method(cCoolio_IOWatcher, "on_readable", Coolio_IOWatcher_on_readable, 0);
+  rb_define_method(cCoolio_IOWatcher, "on_writable", Coolio_IOWatcher_on_writable, 0);
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher.initialize(IO, events = 'r') -> Coolio::IOWatcher
+ * 
+ * Create a new Coolio::IOWatcher for the given IO object and add it to the given Coolio::Loop
+ */
+static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE io, flags;
+  char *flags_str;
+  int events;
+  struct Coolio_Watcher *watcher_data;
+#if HAVE_RB_IO_T
+  rb_io_t *fptr;
+#else
+  OpenFile *fptr;
+#endif
+
+  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);
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+
+  watcher_data->dispatch_callback = Coolio_IOWatcher_dispatch_callback;
+  ev_io_init(&watcher_data->event_types.ev_io, Coolio_IOWatcher_libev_callback, FPTR_TO_FD(fptr), events);
+  watcher_data->event_types.ev_io.data = (void *)self;
+
+  return Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher.attach(loop) -> Coolio::IOWatcher
+ * 
+ * Attach the IO 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_IOWatcher_attach(VALUE self, VALUE loop)
+{
+  Watcher_Attach(io, Coolio_IOWatcher_detach, self, loop);
+
+  return self;  
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher.detach -> Coolio::IOWatcher
+ * 
+ * Detach the IO watcher from its current Coolio::Loop.
+ */
+static VALUE Coolio_IOWatcher_detach(VALUE self)
+{
+  Watcher_Detach(io, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher.enable -> Coolio::IOWatcher
+ * 
+ * Re-enable an IO watcher which has been temporarily disabled.  See the
+ * disable method for a more thorough explanation.
+ */
+static VALUE Coolio_IOWatcher_enable(VALUE self)
+{
+  Watcher_Enable(io, self);
+
+  return self;  
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher.disable -> Coolio::IOWatcher
+ * 
+ * Temporarily disable an IO watcher which is attached to a loop.  
+ * This is useful if you wish to toggle event monitoring on and off.  
+ */
+static VALUE Coolio_IOWatcher_disable(VALUE self)
+{
+  Watcher_Disable(io, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher#on_readable -> nil
+ * 
+ * Called whenever the IO object associated with the IOWatcher is readable
+ */
+static VALUE Coolio_IOWatcher_on_readable(VALUE self)
+{
+  return Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher#on_writable -> nil
+ * 
+ * Called whenever the IO object associated with the IOWatcher is writable
+ */
+
+static VALUE Coolio_IOWatcher_on_writable(VALUE self)
+{
+  return Qnil;
+}
+
+/* libev callback */
+static void Coolio_IOWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents)
+{
+  Coolio_Loop_process_event((VALUE)io->data, revents);
+}
+
+/* Coolio::Loop dispatch callback */
+static void Coolio_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);
+}