celluloid-io 0.8.0 → 0.9.0

data/.travis.yml

@@ -1,8 +1,10 @@
 rvm:
   - 1.9.2
   - 1.9.3
-#  - rbx crashing :(
-  - jruby
   - ruby-head
+  - jruby-19mode
+  - jruby-head
 
-env: "JRUBY_OPTS=--1.9"
+# Rubies I would like to support, but they deadlock
+#  - rbx-18mode
+#  - rbx-19mode

data/CHANGES.md

@@ -1,3 +1,10 @@
+0.9.0
+-----
+* TCPServer, TCPSocket, and UDPSocket classes in Celluloid::IO namespace
+  with both evented and blocking I/O support
+* Celluloid::IO::Mailbox.new now takes a single parameter to specify an
+  alternative reactor (e.g. Celluloid::ZMQ::Reactor)
+
 0.8.0
 -----
 * Switch to nio4r-based reactor

data/README.md

@@ -1,82 +1,156 @@
-Celluloid::IO
+![Celluloid](https://github.com/tarcieri/celluloid-io/raw/master/logo.png)
 =============
-[![Build Status](http://travis-ci.org/tarcieri/celluloid-io.png)](http://travis-ci.org/tarcieri/celluloid-io)
-
-You don't have to choose between threaded and evented IO! Celluloid::IO provides
-a simple and easy way to wait for IO events inside of a Celluloid actor, which
-runs in its own thread. Any Ruby IO object can be registered and monitored.
-It's a somewhat similar idea to Ruby event frameworks like EventMachine and
-Cool.io, but Celluloid actors automatically wrap up all IO in Fibers,
-resulting in a synchronous API that's duck type compatible with existing IO
-objects.
-
-Unlike EventMachine, you can make as many Celluloid::IO actors as you wish,
-each running their own event loop independently from the others. Using many
-actors allows your program to scale across multiple CPU cores on Ruby
-implementations which don't have a GIL, such as JRuby and Rubinius.
+[![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)
+
+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
+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.
+
+Celluloid::IO provides a different class of actor: one that's slightly slower
+and heavier than standard Celluloid actors, but one which contains a
+high-performance reactor just like EventMachine or Cool.io. This means
+Celluloid::IO actors have the power of both Celluloid actors and evented
+I/O loops. Unlike certain other evented I/O systems which limit you to a
+single event loop per process, Celluloid::IO lets you make as many actors as
+you want, system resources permitting.
+
+Rather than callbacks, Celluloid::IO exposes a synchronous API built on duck
+types of Ruby's own IO classes, such as TCPServer and TCPSocket. These classes
+work identically to their core Ruby counterparts, but in the scope of
+Celluloid::IO actors provide "evented" performance. Since they're drop-in
+replacements for the standard classes, there's no need to rewrite every
+library just to take advantage of Celluloid::IO's event loop and you can
+freely switch between evented and blocking IO even over the lifetime of a
+single connection.
+
+Celluloid::IO uses the [nio4r gem](https://github.com/tarcieri/nio4r)
+to monitor IO objects, which provides cross-platform and cross-Ruby
+implementation access to high-performance system calls such as epoll
+and kqueue.
 
 Like Celluloid::IO? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
 
 Supported Platforms
 -------------------
 
-Celluloid works on Ruby 1.9.2+, JRuby 1.6 (in 1.9 mode), and Rubinius 2.0. JRuby
-or Rubinius are the preferred platforms as they support true hardware-level
-parallelism when running Ruby code, whereas MRI/YARV is constrained by a global
-interpreter lock (GIL).
+Celluloid::IO works on Ruby 1.9.2+, JRuby 1.6 (in 1.9 mode), 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.
 
-Celluloid works on Rubinius in either 1.8 or 1.9 mode.
-
 Usage
 -----
 
-To use Celluloid::IO, define a normal Ruby class that includes Celluloid::IO:
+To use Celluloid::IO, define a normal Ruby class that includes Celluloid::IO.
+The following is an example of an echo server:
 
 ```ruby
 require 'celluloid/io'
 
-class MyServer
+class EchoServer
   include Celluloid::IO
 
-  # Bind a TCP server to the given host and port
   def initialize(host, port)
-    @server = TCPServer.new host, port
+    puts "*** Starting echo server on #{host}:#{port}"
+
+    # Since we included Celluloid::IO, we're actually making a
+    # Celluloid::IO::TCPServer here
+    @server = TCPServer.new(host, port)
     run!
   end
 
-  # Run the TCP server event loop
-  def run
-    while true
-      wait_readable(@server)
-      on_connect @server.accept
-    end
+  def finalize
+    @server.close if @server
   end
 
-  # Terminate this server
-  def terminate
-    @server.close
-    super
+  def run
+    loop { handle_connection! @server.accept }
   end
 
-  # Called whenever a new connection is opened
-  def on_connect(connection)
-    connection.close
+  def handle_connection(socket)
+    _, port, host = socket.peeraddr
+    puts "*** Received connection from #{host}:#{port}"
+    loop { socket.write socket.readpartial(4096) }
+  rescue EOFError
+    puts "*** #{host}:#{port} disconnected"
   end
 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/).
+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.
+
+While this looks like a normal Ruby TCP server, there aren't any threads, so
+you might expect this server can only handle one connection at a time.
+However, this is all you need to do to build servers that handle as many
+connections as you want, and it happens all within a single thread.
+
+The magic in this server which allows it to handle multiple connections
+comes in three forms:
+
+* __Replacement classes:__ Celluloid::IO includes replacements for the core
+  TCPServer and TCPSocket classes which automatically use an evented mode
+  inside of Celluloid::IO actors. They're named Celluloid::IO::TCPServer and
+  Celluloid::IO::TCPSocket, so they're automatically available inside
+  your class when you include Celluloid::IO.
+
+* __Asynchronous method calls:__ You may have noticed that while the methods
+  of EchoServer are named *run* and *handle_connection*, they're invoked as
+  *run!* and *handle_connection!*. This queues these methods to be executed
+  after the current method is complete. You can queue up as many methods as
+  you want, allowing asynchronous operation similar to the "call later" or
+  "next tick" feature of Twisted, EventMachine, and Node. This echo server
+  first kicks off a background task for accepting connections on the server
+  socket, then kicks off a background task for each connection.
+
+* __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).
+  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
+  the suspended task.
+
+The result is an API for doing evented I/O that looks identical to doing
+synchronous I/O. Adapting existing synchronous libraries to using evented I/O
+is as simple as having them use one of Celluloid::IO's provided replacement
+classes instead of the core Ruby TCPSocket and TCPServer classes.
+
+Status
+------
+
+The rudiments of TCPServer and TCPSocket are in place and ready to use.
+Several methods are still missing. Making new connections with
+Celluloid::IO::TCPSocket.new works, however it presently does blocking DNS
+resolution and connect so it can stall the reactor loop.
+
+Basic UDPSocket support is in place. On JRuby, recvfrom makes a blocking call
+as the underlying recvfrom_nonblock call is not supported by JRuby.
+
+No UNIXSocket support yet, sorry (patches welcome!)
+
 Contributing to Celluloid::IO
 -----------------------------
 
-* Fork Celluloid on github
+* Fork this repository on github
 * Make your changes and send me a pull request
-* If I like them I'll merge them and give you commit access to my repository
+* If I like them I'll merge them
+* If I've accepted a patch, feel free to ask for a commit bit!
 
 License
 -------
 
 Copyright (c) 2011 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
+Copyright (c) 2008 Engine Yard, Inc. All rights reserved.

data/celluloid-io.gemspec

@@ -15,9 +15,9 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Celluloid::IO::VERSION
 
-  gem.add_dependency 'celluloid', '~> 0.8.0'
-  gem.add_dependency 'nio4r',     '>= 0.2.2'
+  gem.add_dependency 'celluloid', '~> 0.9.0'
+  gem.add_dependency 'nio4r',     '>= 0.3.1'
   
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec', '~> 2.7.0'
+  gem.add_development_dependency 'rspec'
 end

data/examples/echo_server.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+$:.push File.expand_path('../../lib', __FILE__)
+require 'celluloid/io'
+
+class EchoServer
+  include Celluloid::IO
+
+  def initialize(host, port)
+    puts "*** Starting echo server on #{host}:#{port}"
+
+    # Since we included Celluloid::IO, we're actually making a
+    # Celluloid::IO::TCPServer here
+    @server = TCPServer.new(host, port)
+    run!
+  end
+
+  def finalize
+    @server.close if @server
+  end
+
+  def run
+    loop { handle_connection! @server.accept }
+  end
+
+  def handle_connection(socket)
+    _, port, host = socket.peeraddr
+    puts "*** Received connection from #{host}:#{port}"
+    loop { socket.write socket.readpartial(4096) }
+  rescue EOFError
+    puts "*** #{host}:#{port} disconnected"
+    socket.close
+  end
+end
+
+supervisor = EchoServer.supervise("127.0.0.1", 1234)
+trap("INT") { supervisor.terminate; exit }
+sleep

data/lib/celluloid/io.rb

@@ -2,9 +2,14 @@ require 'celluloid/io/version'
 
 require 'forwardable'
 require 'celluloid'
+require 'celluloid/io/common_methods'
 require 'celluloid/io/mailbox'
 require 'celluloid/io/reactor'
 
+require 'celluloid/io/tcp_server'
+require 'celluloid/io/tcp_socket'
+require 'celluloid/io/udp_socket'
+
 module Celluloid
   # Actors with evented IO support
   module IO

data/lib/celluloid/io/common_methods.rb

@@ -0,0 +1,96 @@
+module Celluloid
+  module IO
+    # Common implementations of methods originall from the IO class
+    module CommonMethods
+      # Are we inside of a Celluloid::IO actor?
+      def evented?
+        actor = Thread.current[:actor]
+        actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
+      end
+
+      # Wait until the current object is readable
+      def wait_readable
+        if evented?
+          Celluloid.current_actor.wait_readable(self.to_io)
+        else
+          Kernel.select([self.to_io])
+        end
+      end
+
+      # 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
+          Kernel.select([], [self.to_io])
+        end
+      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
+
+          buffer << str
+          remaining -= str.length
+        end
+
+        buffer
+      end
+
+      def readpartial(length, buffer = nil)
+        buffer ||= ''
+
+        begin
+          read_nonblock(length, buffer)
+        rescue ::IO::WaitReadable
+          wait_readable
+          retry
+        end
+
+        buffer
+      end
+
+      def write(string)
+        length = string.length
+        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
+
+          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)
+            end
+          end
+        end
+
+        total_written
+      end
+      alias_method :<<, :write
+    end
+  end
+end

data/lib/celluloid/io/mailbox.rb

@@ -4,33 +4,34 @@ module Celluloid
     class Mailbox < Celluloid::Mailbox
       attr_reader :reactor
 
-      def initialize
+      def initialize(reactor = nil)
         @messages = []
-        @lock  = Mutex.new
-        @reactor = Reactor.new
+        @mutex = Mutex.new
+        @reactor = reactor || Reactor.new
       end
 
       # Add a message to the Mailbox
       def <<(message)
-        @lock.synchronize do
+        @mutex.lock
+        begin
           @messages << message
           @reactor.wakeup
+        rescue IOError
+          raise MailboxError, "dead recipient"
+        ensure @mutex.unlock
         end
         nil
-      rescue IOError
-        raise MailboxError, "dead recipient"
       end
 
       # Add a high-priority system event to the Mailbox
       def system_event(event)
-        @lock.synchronize do
+        @mutex.lock
+        begin
           @messages.unshift event
-          
-          begin
-            @reactor.wakeup
-          rescue IOError
-            # Silently fail if messages are sent to dead actors
-          end
+          @reactor.wakeup
+        rescue IOError
+          # Silently fail if messages are sent to dead actors
+        ensure @mutex.unlock
         end
         nil
       end

data/lib/celluloid/io/reactor.rb

@@ -25,29 +25,36 @@ module Celluloid
       def wait_writeable(io)
         wait io, :w
       end
-      
+
       # Wait for the given IO operation to complete
       def wait(io, set)
         # zomg ugly type conversion :(
-        unless io.is_a?(IO)
-          if IO.respond_to? :try_convert
-            io = IO.try_convert(io)
-          elsif io.respond_to? :to_io
+        unless io.is_a?(::IO)
+          if io.respond_to? :to_io
             io = io.to_io
-          else raise TypeError, "can't convert #{io.class} into IO"
+          elsif ::IO.respond_to? :try_convert
+            io = ::IO.try_convert(io)
           end
+
+          raise TypeError, "can't convert #{io.class} into IO" unless io.is_a? IO
         end
-        
+
         monitor = @selector.register(io, set)
         monitor.value = Task.current
         Task.suspend :iowait
       end
-      
+
       # Run the reactor, waiting for events or wakeup signal
       def run_once(timeout = nil)
-        @selector.select_each(timeout) do |monitor|
-          monitor.value.resume
+        @selector.select(timeout) do |monitor|
+          task = monitor.value
           @selector.deregister(monitor.io)
+
+          if task.running?
+            task.resume
+          else
+            Logger.warn("reactor attempted to resume a dead task")
+          end
         end
       end
     end

data/lib/celluloid/io/tcp_server.rb

@@ -0,0 +1,40 @@
+require 'socket'
+
+module Celluloid
+  module IO
+    # TCPServer with combined blocking and evented support
+    class TCPServer
+      extend Forwardable
+      def_delegators :@server, :listen, :sysaccept, :close, :closed?
+
+      def initialize(hostname, port)
+        @server = ::TCPServer.new(hostname, port)
+      end
+
+      def accept
+        actor = Thread.current[:actor]
+
+        if evented?
+          Celluloid.current_actor.wait_readable @server
+          accept_nonblock
+        else
+          Celluloid::IO::TCPSocket.from_ruby_socket @server.accept
+        end
+      end
+
+      def accept_nonblock
+        Celluloid::IO::TCPSocket.from_ruby_socket @server.accept_nonblock
+      end
+
+      def to_io
+        @server
+      end
+
+      # Are we inside a Celluloid ::IO actor?
+      def evented?
+        actor = Thread.current[:actor]
+        actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
+      end
+    end
+  end
+end

data/lib/celluloid/io/tcp_socket.rb

@@ -0,0 +1,34 @@
+require 'socket'
+
+module Celluloid
+  module IO
+    # TCPSocket with combined blocking and evented support
+    class TCPSocket
+      include CommonMethods
+      extend Forwardable
+
+      def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?
+      def_delegators :@socket, :addr, :peeraddr
+
+      # Convert a Ruby TCPSocket into a Celluloid::IO::TCPSocket
+      def self.from_ruby_socket(ruby_socket)
+        # Some hax here, but whatever ;)
+        socket = allocate
+        socket.instance_variable_set(:@socket, ruby_socket)
+        socket
+      end
+
+      # Opens a TCP connection to remote_host on remote_port. If local_host
+      # 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)
+      end
+
+      def to_io
+        @socket
+      end
+    end
+  end
+end

data/lib/celluloid/io/udp_socket.rb

@@ -0,0 +1,48 @@
+module Celluloid
+  module IO
+    # UDPSockets with combined blocking and evented support
+    class UDPSocket
+      extend Forwardable
+      def_delegators :@socket, :bind, :send, :recvfrom_nonblock, :close, :closed?
+
+      def initialize
+        @socket = ::UDPSocket.new
+      end
+
+      # Are we inside of a Celluloid::IO actor?
+      def evented?
+        actor = Thread.current[:actor]
+        actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
+      end
+
+      # Wait until the socket is readable
+      def wait_readable
+        if evented?
+          Celluloid.current_actor.wait_readable(@socket)
+        else
+          Kernel.select([@socket])
+        end
+      end
+
+      # Receives up to maxlen bytes from socket. flags is zero or more of the
+      # MSG_ options. The first element of the results, mesg, is the data
+      # received. The second element, sender_addrinfo, contains
+      # protocol-specific address information of the sender.
+      def recvfrom(maxlen, flags = nil)
+        begin
+          if @socket.respond_to? :recvfrom_nonblock
+            @socket.recvfrom_nonblock(maxlen, flags)
+          else
+            # FIXME: hax for JRuby
+            @socket.recvfrom(maxlen, flags)
+          end
+        rescue ::IO::WaitReadable
+          wait_readable
+          retry
+        end
+      end
+
+      def to_io; @socket; end
+    end
+  end
+end

data/lib/celluloid/io/version.rb

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

data/spec/celluloid/io/tcp_server_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Celluloid::IO::TCPServer do
+  describe "#accept" do
+    let(:payload) { 'ohai' }
+
+    context "inside Celluloid::IO" do
+      it "should be evented" do
+        with_tcp_server do |subject|
+          within_io_actor { subject.evented? }.should be_true
+        end
+      end
+
+      it "accepts a connection and returns a Celluloid::IO::TCPSocket" do
+        with_tcp_server do |subject|
+          thread = Thread.new { TCPSocket.new(example_addr, example_port) }
+          peer = within_io_actor { subject.accept }
+          peer.should be_a Celluloid::IO::TCPSocket
+
+          client = thread.value
+          client.write payload
+          peer.read(payload.size).should eq payload
+        end
+      end
+
+      context "elsewhere in Ruby" do
+        it "should be blocking" do
+          with_tcp_server do |subject|
+            subject.should_not be_evented
+          end
+        end
+
+        it "accepts a connection and returns a Celluloid::IO::TCPSocket" do
+          with_tcp_server do |subject|
+            thread = Thread.new { TCPSocket.new(example_addr, example_port) }
+            peer   = subject.accept
+            peer.should be_a Celluloid::IO::TCPSocket
+
+            client = thread.value
+            client.write payload
+            peer.read(payload.size).should eq payload
+          end
+        end
+      end
+    end
+  end
+end

data/spec/celluloid/io/tcp_socket_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Celluloid::IO::TCPSocket do
+  let(:payload) { 'ohai' }
+
+  context "inside Celluloid::IO" do
+    it "connects to TCP servers" do
+      server = ::TCPServer.new example_addr, example_port
+      thread = Thread.new { server.accept }
+      socket = within_io_actor { Celluloid::IO::TCPSocket.new example_addr, example_port }
+      peer = thread.value
+
+      peer << payload
+      within_io_actor { socket.read(payload.size) }.should eq payload
+
+      server.close
+      socket.close
+      peer.close
+    end
+
+    it "should be evented" do
+      with_connected_sockets do |subject|
+        within_io_actor { subject.evented? }.should be_true
+      end
+    end
+
+    it "reads data" do
+      with_connected_sockets do |subject, peer|
+        peer << payload
+        within_io_actor { subject.read(payload.size) }.should eq payload
+      end
+    end
+
+    it "reads partial data" do
+      with_connected_sockets do |subject, peer|
+        peer << payload * 2
+        within_io_actor { subject.readpartial(payload.size) }.should eq payload
+      end
+    end
+
+    it "writes data" do
+      with_connected_sockets do |subject, peer|
+        within_io_actor { subject << payload }
+        peer.read(payload.size).should eq payload
+      end
+    end
+  end
+
+  context "elsewhere in Ruby" do
+    it "connects to TCP servers" do
+      server = ::TCPServer.new example_addr, example_port
+      thread = Thread.new { server.accept }
+      socket = Celluloid::IO::TCPSocket.new example_addr, example_port
+      peer = thread.value
+
+      peer << payload
+      socket.read(payload.size).should eq payload
+
+      server.close
+      socket.close
+      peer.close
+    end
+
+    it "should be blocking" do
+      with_connected_sockets do |subject|
+        subject.should_not be_evented
+      end
+    end
+
+    it "reads data" do
+      with_connected_sockets do |subject, peer|
+        peer << payload
+        subject.read(payload.size).should eq payload
+      end
+    end
+
+    it "reads partial data" do
+      with_connected_sockets do |subject, peer|
+        peer << payload * 2
+        subject.readpartial(payload.size).should eq payload
+      end
+    end
+
+    it "writes data" do
+      with_connected_sockets do |subject, peer|
+        subject << payload
+        peer.read(payload.size).should eq payload
+      end
+    end
+  end
+end

data/spec/celluloid/io/udp_socket_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Celluloid::IO::UDPSocket do
+  let(:payload) { 'ohai' }
+  subject do
+    Celluloid::IO::UDPSocket.new.tap do |sock|
+      sock.bind example_addr, example_port
+    end
+  end
+
+  after { subject.close }
+
+  context "inside Celluloid::IO" do
+    it "should be evented" do
+      within_io_actor { subject.evented? }.should be_true
+    end
+
+    it "sends and receives packets" do
+      subject.send payload, 0, example_addr, example_port
+      subject.recvfrom(payload.size).first.should == payload
+    end
+  end
+
+  context "elsewhere in Ruby" do
+    it "should be blocking" do
+      subject.should_not be_evented
+    end
+
+    it "sends and receives packets" do
+      subject.send payload, 0, example_addr, example_port
+      subject.recvfrom(payload.size).first.should == payload
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,48 @@
 require 'rubygems'
 require 'bundler/setup'
 require 'celluloid/io'
-require 'celluloid/rspec'
+require 'celluloid/rspec'
+
+class ExampleActor
+  include Celluloid::IO
+
+  def wrap
+    yield
+  end
+end
+
+EXAMPLE_PORT = 10000 + rand(10000)
+
+def example_addr; '127.0.0.1'; end
+def example_port; EXAMPLE_PORT; end
+
+def within_io_actor(&block)
+  actor = ExampleActor.new
+  actor.wrap(&block)
+ensure
+  actor.terminate
+end
+
+def with_tcp_server
+  server = Celluloid::IO::TCPServer.new(example_addr, example_port)
+  begin
+    yield server
+  ensure
+    server.close
+  end
+end
+
+def with_connected_sockets
+  with_tcp_server do |server|
+    # FIXME: client isn't actually a Celluloid::IO::TCPSocket yet
+    client = ::TCPSocket.new(example_addr, example_port)
+    peer = server.accept
+
+    begin
+      yield peer, client
+    ensure
+      client.close
+      peer.close
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid-io
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,33 +9,33 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-24 00:00:00.000000000 Z
+date: 2012-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
-  requirement: &70254645083180 !ruby/object:Gem::Requirement
+  requirement: &70287081256280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.9.0
   type: :runtime
   prerelease: false
-  version_requirements: *70254645083180
+  version_requirements: *70287081256280
 - !ruby/object:Gem::Dependency
   name: nio4r
-  requirement: &70254645082660 !ruby/object:Gem::Requirement
+  requirement: &70287081254940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: 0.3.1
   type: :runtime
   prerelease: false
-  version_requirements: *70254645082660
+  version_requirements: *70287081254940
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70254645082180 !ruby/object:Gem::Requirement
+  requirement: &70287081253700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,18 +43,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70254645082180
+  version_requirements: *70287081253700
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70254645081480 !ruby/object:Gem::Requirement
+  requirement: &70287081251980 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.7.0
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70254645081480
+  version_requirements: *70287081251980
 description: Evented IO for Celluloid actors
 email:
 - tony.arcieri@gmail.com
@@ -71,12 +71,21 @@ files:
 - README.md
 - Rakefile
 - celluloid-io.gemspec
+- examples/echo_server.rb
 - lib/celluloid/io.rb
+- lib/celluloid/io/common_methods.rb
 - lib/celluloid/io/mailbox.rb
 - lib/celluloid/io/reactor.rb
+- lib/celluloid/io/tcp_server.rb
+- lib/celluloid/io/tcp_socket.rb
+- lib/celluloid/io/udp_socket.rb
 - lib/celluloid/io/version.rb
+- logo.png
 - spec/celluloid/io/actor_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
 licenses: []
@@ -106,5 +115,8 @@ summary: Celluloid::IO allows you to monitor multiple IO objects within a Cellul
 test_files:
 - spec/celluloid/io/actor_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: