celluloid-io 0.9.0 → 0.10.0

data/.travis.yml

@@ -1,10 +1,10 @@
 rvm:
-  - 1.9.2
   - 1.9.3
   - ruby-head
   - jruby-19mode
-  - jruby-head
 
-# Rubies I would like to support, but they deadlock
-#  - rbx-18mode
+# Getting a deadlock in the nonblocking connect code :(
+#  - jruby-head
+
+# See https://github.com/rubinius/rubinius/issues/1611
 #  - rbx-19mode

data/CHANGES.md

@@ -1,3 +1,9 @@
+0.10.0
+------
+* Read/write operations are now atomic across tasks
+* True non-blocking connect support
+* Non-blocking DNS resolution support
+
 0.9.0
 -----
 * TCPServer, TCPSocket, and UDPSocket classes in Celluloid::IO namespace

data/Gemfile

@@ -1,6 +1,6 @@
 source :rubygems
 
-gem 'celluloid', :git => 'git://github.com/tarcieri/celluloid'
+gem 'celluloid', :git => 'git://github.com/celluloid/celluloid'
 
 # Specify your gem's dependencies in celluloid-io.gemspec
 gemspec

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Tony Arcieri
+Copyright (c) 2012 Tony Arcieri
 
 MIT License
 
@@ -19,4 +19,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,12 +1,12 @@
-![Celluloid](https://github.com/tarcieri/celluloid-io/raw/master/logo.png)
+![Celluloid](https://github.com/celluloid/celluloid-io/raw/master/logo.png)
 =============
-[![Build Status](https://secure.travis-ci.org/tarcieri/celluloid-io.png?branch=master)](http://travis-ci.org/tarcieri/celluloid-io)
-[![Dependency Status](https://gemnasium.com/tarcieri/celluloid-io.png)](https://gemnasium.com/tarcieri/celluloid-io)
+[![Build Status](https://secure.travis-ci.org/celluloid/celluloid-io.png?branch=master)](http://travis-ci.org/celluloid/celluloid-io)
+[![Dependency Status](https://gemnasium.com/celluloid/celluloid-io.png)](https://gemnasium.com/celluloid/celluloid-io)
 
 You don't have to choose between threaded and evented IO! Celluloid::IO
 provides an event-driven IO system for building fast, scalable network
 applications that integrates directly with the
-[Celluloid actor library](https://github.com/tarcieri/celluloid), making it
+[Celluloid actor library](https://github.com/celluloid/celluloid), making it
 easy to combine both threaded and evented concepts. Celluloid::IO is ideal for
 servers which handle large numbers of mostly-idle connections, such as Websocket
 servers or chat/messaging systems.
@@ -38,7 +38,9 @@ Like Celluloid::IO? [Join the Google Group](http://groups.google.com/group/cellu
 Supported Platforms
 -------------------
 
-Celluloid::IO works on Ruby 1.9.2+, JRuby 1.6 (in 1.9 mode), and Rubinius 2.0.
+Celluloid::IO requires Ruby 1.9 support on all Ruby VMs.
+
+Supported VMs are Ruby 1.9.3, JRuby 1.6, and Rubinius 2.0.
 
 To use JRuby in 1.9 mode, you'll need to pass the "--1.9" command line option
 to the JRuby executable, or set the "JRUBY_OPTS=--1.9" environment variable.
@@ -85,7 +87,7 @@ end
 The very first thing including *Celluloid::IO* does is also include the
 *Celluloid* module, which promotes objects of this class to concurrent Celluloid
 actors each running in their own thread. Before trying to use Celluloid::IO
-you may want to [familiarize yourself with Celluloid in general](https://github.com/tarcieri/celluloid/).
+you may want to [familiarize yourself with Celluloid in general](https://github.com/celluloid/celluloid/).
 Celluloid actors can each be thought of as being event loops. Celluloid::IO actors
 are heavier but have capabilities similar to other event loop-driven frameworks.
 
@@ -114,7 +116,7 @@ comes in three forms:
 
 * __Reactor + Fibers:__ Celluloid::IO is a combination of Actor and Reactor
   concepts. The blocking mechanism used by the mailboxes of Celluloid::IO
-  actors is an [nio4r-powered reactor](https://github.com/tarcieri/celluloid-io/blob/master/lib/celluloid/io/reactor.rb).
+  actors is an [nio4r-powered reactor](https://github.com/celluloid/celluloid-io/blob/master/lib/celluloid/io/reactor.rb).
   When the current task needs to make a blocking I/O call, it first makes
   a non-blocking attempt, and if the socket isn't ready the current task
   is suspended until the reactor detects the operation is ready and resumes
@@ -149,7 +151,7 @@ Contributing to Celluloid::IO
 License
 -------
 
-Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+Copyright (c) 2012 Tony Arcieri. Distributed under the MIT License. See
 LICENSE.txt for further details.
 
 Contains code originally from the RubySpec project also under the MIT License

data/Rakefile

@@ -1,7 +1,5 @@
 #!/usr/bin/env rake
 require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
+Dir["tasks/**/*.task"].each { |task| load task }
 
-RSpec::Core::RakeTask.new
-
-task :default => :spec
+task :default => :spec

data/benchmarks/actor.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'celluloid/io'
+require 'benchmark/ips'
+
+class ExampleActor
+  include Celluloid::IO
+  def example_method; end
+end
+
+example_actor = ExampleActor.new
+mailbox = Celluloid::Mailbox.new
+
+latch_in, latch_out = Queue.new, Queue.new
+latch = Thread.new do
+  while true
+    n = latch_in.pop
+    for i in 0..n; mailbox.receive; end
+    latch_out << :done
+  end
+end
+
+Benchmark.ips do |ips|
+  ips.report("spawn")       { ExampleActor.new.terminate }
+  ips.report("calls")       { example_actor.example_method }
+  ips.report("async calls") { example_actor.example_method! }
+  
+  ips.report("messages") do |n|
+    latch_in << n
+    for i in 0..n; mailbox << :message; end
+    latch_out.pop
+  end
+end

data/benchmarks/ring.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'celluloid'
+require 'benchmark/ips'
+require File.expand_path("../../examples/ring", __FILE__)
+
+# 512-node ring
+ring = Ring.new 512
+
+Benchmark.ips do |ips|
+  ips.report("ring-around") { |n| ring.run n }
+end

data/celluloid-io.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["tony.arcieri@gmail.com"]
   gem.description   = "Evented IO for Celluloid actors"
   gem.summary       = "Celluloid::IO allows you to monitor multiple IO objects within a Celluloid actor"
-  gem.homepage      = "http://github.com/tarcieri/celluloid-io"
+  gem.homepage      = "http://github.com/celluloid/celluloid-io"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
@@ -15,9 +15,10 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Celluloid::IO::VERSION
 
-  gem.add_dependency 'celluloid', '~> 0.9.0'
+  gem.add_dependency 'celluloid', '~> 0.10.0'
   gem.add_dependency 'nio4r',     '>= 0.3.1'
   
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'benchmark_suite'
 end

data/examples/echo_client.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'celluloid/io'
+
+class EchoClient
+  include Celluloid::IO
+
+  def initialize(host, port)
+    puts "*** Connecting to echo server on #{host}:#{port}"
+
+    @socket = TCPSocket.from_ruby_socket(::TCPSocket.new(host, port))
+  end
+
+  def echo(s)
+    @socket.write(s)
+    actor = Celluloid.current_actor
+    @socket.readpartial(4096)
+  end
+
+end
+
+client = EchoClient.new("127.0.0.1", 1234)
+puts client.echo("TEST FOR ECHO")

data/lib/celluloid/io.rb

@@ -1,8 +1,9 @@
+require 'forwardable'
 require 'celluloid/io/version'
 
-require 'forwardable'
 require 'celluloid'
 require 'celluloid/io/common_methods'
+require 'celluloid/io/dns_resolver'
 require 'celluloid/io/mailbox'
 require 'celluloid/io/reactor'
 
@@ -20,7 +21,7 @@ module Celluloid
 
     extend Forwardable
 
-    # Wait for the given IO object to become readable/writeable
-    def_delegators 'current_actor.mailbox.reactor', :wait_readable, :wait_writeable
+    # Wait for the given IO object to become readable/writable
+    def_delegators 'current_actor.mailbox.reactor', :wait_readable, :wait_writable
   end
 end

data/lib/celluloid/io/common_methods.rb

@@ -19,8 +19,6 @@ module Celluloid
 
       # Wait until the current object is writable
       def wait_writable
-        actor = Thread.current[:actor]
-
         if evented?
           Celluloid.current_actor.wait_writable(self.to_io)
         else
@@ -28,20 +26,60 @@ module Celluloid
         end
       end
 
+      # Request exclusive control for a particular operation
+      # Type should be one of :r (read) or :w (write)
+      def acquire_ownership(type)
+        return unless Thread.current[:actor]
+
+        case type
+        when :r
+          ivar = :@read_owner
+        when :w
+          ivar = :@write_owner
+        else raise ArgumentError, "invalid ownership type: #{type}"
+        end
+
+        Actor.current.wait(self) while instance_variable_get(ivar)
+        instance_variable_set(ivar, Task.current)
+      end
+
+      # Release ownership for a particular operation
+      # Type should be one of :r (read) or :w (write)
+      def release_ownership(type)
+        return unless Thread.current[:actor]
+
+        case type
+        when :r
+          ivar = :@read_owner
+        when :w
+          ivar = :@write_owner
+        else raise ArgumentError, "invalid ownership type: #{type}"
+        end
+
+        raise "not owner" unless instance_variable_get(ivar) == Task.current
+        instance_variable_set(ivar, nil)
+        Actor.current.signal(self)
+      end
+
       def read(length, buffer = nil)
         buffer ||= ''
         remaining = length
 
-        until remaining.zero?
-          begin
-            str = readpartial(remaining)
-          rescue EOFError
-            return if length == remaining
-            return buffer
-          end
+        acquire_ownership :r
+        begin
+          until remaining.zero?
+            begin
+              str = readpartial(remaining)
+            rescue EOFError
+              return if length == remaining
+              return buffer
+            end
 
-          buffer << str
-          remaining -= str.length
+            buffer << str
+            remaining -= str.length
+          end
+        ensure
+          release_ownership :r
         end
 
         buffer
@@ -65,27 +103,24 @@ module Celluloid
         total_written = 0
 
         remaining = string
-        while total_written < length
-          begin
-            written = write_nonblock(remaining)
-          rescue ::IO::WaitWritable
-            wait_writable
-            retry
-          rescue EOFError
-            return total_written
-          end
+        acquire_ownership :w
 
-          total_written += written
-          if written < remaining.length
-            # Avoid mutating string itself, but we can mutate the remaining data
-            if remaining == string
-              # Copy the remaining data so as to avoid mutating string
-              # Note if we have a large amount of data remaining this could be slow
-              remaining = string[written..-1]
-            else
-              remaining.slice!(0, written)
+        begin
+          while total_written < length
+            begin
+              written = write_nonblock(remaining)
+            rescue ::IO::WaitWritable
+              wait_writable
+              retry
+            rescue EOFError
+              return total_written
             end
+
+            total_written += written
+            remaining.slice!(0, written) if written < remaining.length
           end
+        ensure
+          release_ownership :w
         end
 
         total_written

data/lib/celluloid/io/dns_resolver.rb

@@ -0,0 +1,79 @@
+require 'resolv'
+
+module Celluloid
+  module IO
+    # Asynchronous DNS resolver using Celluloid::IO::UDPSocket
+    class DNSResolver
+      RESOLV_CONF = '/etc/resolv.conf'
+      HOSTS       = '/etc/hosts'
+      DNS_PORT    = 53
+      
+      @mutex = Mutex.new
+      @identifier = 1
+      
+      def self.generate_id
+        @mutex.synchronize { @identifier = (@identifier + 1) & 0xFFFF }
+      end
+      
+      def self.nameservers(config = RESOLV_CONF)
+        File.read(config).scan(/^\s*nameserver\s+([0-9.:]+)/).flatten
+      end
+      
+      def self.hosts(hostfile = HOSTS)
+        hosts = {}
+        File.open(hostfile) do |f|
+          f.each_line do |host_entry|
+            entries = host_entry.gsub(/#.*$/, '').gsub(/\s+/, ' ').split(' ')
+            addr = entries.shift
+            entries.each { |e| hosts[e] ||= addr }
+          end
+        end
+        hosts
+      end
+      
+      def initialize
+        @nameservers, @hosts = self.class.nameservers, self.class.hosts
+        
+        # TODO: fall back on other nameservers if the first one is unavailable
+        @server = @nameservers.first
+
+        # The non-blocking secret sauce is here, as this is actually a
+        # Celluloid::IO::UDPSocket
+        @socket = UDPSocket.new
+      end
+      
+      def resolve(hostname)
+        host = @hosts[hostname]
+        if host
+          begin
+            return Resolv::IPv4.create(host)
+          rescue ArgumentError
+          end
+
+          begin
+            return Resolv::IPv6.create(host)
+          rescue ArgumentError
+          end
+          
+          raise Resolv::ResolvError, "invalid entry in hosts file: #{host}"
+        end
+        
+        query = Resolv::DNS::Message.new
+        query.id = self.class.generate_id
+        query.rd = 1
+        query.add_question hostname, Resolv::DNS::Resource::IN::A
+        
+        @socket.send query.encode, 0, @server, DNS_PORT
+        data, _ = @socket.recvfrom(512)
+        response = Resolv::DNS::Message.decode(data)
+        
+        addrs = []
+        response.each_answer { |name, ttl, value| addrs << value.address }
+        
+        return if addrs.empty?
+        return addrs.first if addrs.size == 1
+        addrs
+      end
+    end
+  end
+end

data/lib/celluloid/io/mailbox.rb

@@ -15,7 +15,8 @@ module Celluloid
         @mutex.lock
         begin
           @messages << message
-          @reactor.wakeup
+          current_actor = Thread.current[:actor]
+          @reactor.wakeup unless current_actor && current_actor.mailbox == self
         rescue IOError
           raise MailboxError, "dead recipient"
         ensure @mutex.unlock
@@ -28,7 +29,8 @@ module Celluloid
         @mutex.lock
         begin
           @messages.unshift event
-          @reactor.wakeup
+          current_actor = Thread.current[:actor]
+          @reactor.wakeup unless current_actor && current_actor.mailbox == self
         rescue IOError
           # Silently fail if messages are sent to dead actors
         ensure @mutex.unlock

data/lib/celluloid/io/reactor.rb

@@ -21,8 +21,8 @@ module Celluloid
         wait io, :r
       end
 
-      # Wait for the given IO object to become writeable
-      def wait_writeable(io)
+      # Wait for the given IO object to become writable
+      def wait_writable(io)
         wait io, :w
       end
 
@@ -48,7 +48,7 @@ module Celluloid
       def run_once(timeout = nil)
         @selector.select(timeout) do |monitor|
           task = monitor.value
-          @selector.deregister(monitor.io)
+          monitor.close
 
           if task.running?
             task.resume

data/lib/celluloid/io/tcp_socket.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'resolv'
 
 module Celluloid
   module IO
@@ -8,7 +9,7 @@ module Celluloid
       extend Forwardable
 
       def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?
-      def_delegators :@socket, :addr, :peeraddr
+      def_delegators :@socket, :addr, :peeraddr, :setsockopt
 
       # Convert a Ruby TCPSocket into a Celluloid::IO::TCPSocket
       def self.from_ruby_socket(ruby_socket)
@@ -22,8 +23,51 @@ module Celluloid
       # and local_port are specified, then those parameters are used on the
       # local end to establish the connection.
       def initialize(remote_host, remote_port, local_host = nil, local_port = nil)
-        # FIXME: not using non-blocking connect
-        @socket = ::TCPSocket.new(remote_host, remote_port, local_host, local_port)
+        # Is it an IPv4 address?
+        begin
+          @addr = Resolv::IPv4.create(remote_host)
+        rescue ArgumentError
+        end
+
+        # Guess it's not IPv4! Is it IPv6?
+        unless @addr
+          begin
+            @addr = Resolv::IPv6.create(remote_host)
+          rescue ArgumentError
+          end
+        end
+
+        # Guess it's not an IP address, so let's try DNS
+        unless @addr
+          # TODO: suppport asynchronous DNS
+          # Even EventMachine doesn't do async DNS by default o_O
+          addrs = Array(DNSResolver.new.resolve(remote_host))
+          raise Resolv::ResolvError, "DNS result has no information for #{remote_host}" if addrs.empty?
+          
+          # Pseudorandom round-robin DNS support :/
+          @addr = addrs[rand(addrs.size)]
+        end
+
+        case @addr
+        when Resolv::IPv4
+          family = Socket::AF_INET
+        when Resolv::IPv6
+          family = Socket::AF_INET6
+        else raise ArgumentError, "unsupported address class: #{@addr.class}"
+        end
+
+        @socket = Socket.new(family, Socket::SOCK_STREAM, 0)
+        @socket.bind Addrinfo.tcp(local_host, local_port) if local_host
+
+        begin
+          @socket.connect_nonblock Socket.sockaddr_in(remote_port, @addr.to_s)
+        rescue Errno::EINPROGRESS
+          wait_writable
+          retry
+        rescue Errno::EISCONN
+          # We're now connected! Yay exceptions for flow control
+          # NOTE: This is the approach the Ruby stdlib docs suggest ;_;
+        end
       end
 
       def to_io

data/lib/celluloid/io/version.rb

@@ -1,5 +1,5 @@
 module Celluloid
   module IO
-    VERSION = "0.9.0"
+    VERSION = "0.10.0"
   end
 end

data/spec/celluloid/io/actor_spec.rb

@@ -2,4 +2,4 @@ require 'spec_helper'
 
 describe Celluloid::IO do
   it_behaves_like "a Celluloid Actor", Celluloid::IO
-end
+end

data/spec/celluloid/io/dns_resolver_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Celluloid::IO::DNSResolver do
+  it "resolves domain names" do
+    resolver = Celluloid::IO::DNSResolver.new
+    resolver.resolve("celluloid.io").should == Resolv::IPv4.create("207.97.227.245")
+  end
+end

data/tasks/benchmarks.task

@@ -0,0 +1,19 @@
+require 'timeout'
+
+desc "Run Celluloid benchmarks"
+task :benchmark do
+  # Travis has an out-of-date version of rbx that rashes on the benchmarks
+  exit 0 if ENV['CI'] and RUBY_ENGINE == 'rbx'
+
+  begin
+    Timeout.timeout(120) do
+      glob = File.expand_path("../../benchmarks/*.rb", __FILE__)
+      Dir[glob].each { |benchmark| load benchmark }
+    end
+  rescue Exception, Timeout::Error => ex
+    puts "ERROR: Couldn't complete benchmark: #{ex.class}: #{ex}"
+    puts "  #{ex.backtrace.join("\n  ")}"
+
+    exit 1 unless ENV['CI'] # Hax for running benchmarks on Travis
+  end
+end

data/tasks/rspec.task

@@ -0,0 +1,7 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+RSpec::Core::RakeTask.new(:rcov) do |task|
+  task.rcov = true
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid-io
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-21 00:00:00.000000000 Z
+date: 2012-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
-  requirement: &70287081256280 !ruby/object:Gem::Requirement
+  requirement: &70278839545080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.10.0
   type: :runtime
   prerelease: false
-  version_requirements: *70287081256280
+  version_requirements: *70278839545080
 - !ruby/object:Gem::Dependency
   name: nio4r
-  requirement: &70287081254940 !ruby/object:Gem::Requirement
+  requirement: &70278839544320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 0.3.1
   type: :runtime
   prerelease: false
-  version_requirements: *70287081254940
+  version_requirements: *70278839544320
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70287081253700 !ruby/object:Gem::Requirement
+  requirement: &70278839543940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70287081253700
+  version_requirements: *70278839543940
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70287081251980 !ruby/object:Gem::Requirement
+  requirement: &70278839543480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70287081251980
+  version_requirements: *70278839543480
+- !ruby/object:Gem::Dependency
+  name: benchmark_suite
+  requirement: &70278839543020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70278839543020
 description: Evented IO for Celluloid actors
 email:
 - tony.arcieri@gmail.com
@@ -70,10 +81,14 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/actor.rb
+- benchmarks/ring.rb
 - celluloid-io.gemspec
+- examples/echo_client.rb
 - examples/echo_server.rb
 - lib/celluloid/io.rb
 - lib/celluloid/io/common_methods.rb
+- lib/celluloid/io/dns_resolver.rb
 - lib/celluloid/io/mailbox.rb
 - lib/celluloid/io/reactor.rb
 - lib/celluloid/io/tcp_server.rb
@@ -82,12 +97,15 @@ files:
 - lib/celluloid/io/version.rb
 - logo.png
 - spec/celluloid/io/actor_spec.rb
+- spec/celluloid/io/dns_resolver_spec.rb
 - spec/celluloid/io/mailbox_spec.rb
 - spec/celluloid/io/tcp_server_spec.rb
 - spec/celluloid/io/tcp_socket_spec.rb
 - spec/celluloid/io/udp_socket_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/tarcieri/celluloid-io
+- tasks/benchmarks.task
+- tasks/rspec.task
+homepage: http://github.com/celluloid/celluloid-io
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -107,16 +125,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Celluloid::IO allows you to monitor multiple IO objects within a Celluloid
   actor
 test_files:
 - spec/celluloid/io/actor_spec.rb
+- spec/celluloid/io/dns_resolver_spec.rb
 - spec/celluloid/io/mailbox_spec.rb
 - spec/celluloid/io/tcp_server_spec.rb
 - spec/celluloid/io/tcp_socket_spec.rb
 - spec/celluloid/io/udp_socket_spec.rb
 - spec/spec_helper.rb
-has_rdoc: