celluloid-io 0.7.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,4 @@
+--color 
+--format documentation 
+--backtrace
+--default_path spec

data/.travis.yml

@@ -0,0 +1,8 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+#  - rbx # crashing :(
+  - jruby
+  - ruby-head
+
+env: "JRUBY_OPTS=--1.9"

data/CHANGES.md

@@ -0,0 +1,3 @@
+0.7.0
+-----
+* Initial release forked from Celluloid

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Tony Arcieri
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+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.

data/README.md

@@ -0,0 +1,80 @@
+Celluloid::IO
+=============
+[![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.
+
+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).
+
+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:
+
+    require 'celluloid/io'
+
+	class MyServer
+	  include Celluloid::IO
+
+	  # Bind a TCP server to the given host and port
+	  def initialize(host, port)
+	    @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
+	  end
+
+	  # Terminate this server
+	  def terminate
+	    @server.close
+	    super
+	  end
+
+	  # Called whenever a new connection is opened
+	  def on_connect(connection)
+	    connection.close
+	  end
+	end
+
+Contributing to Celluloid::IO
+-----------------------------
+
+* Fork Celluloid 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
+
+License
+-------
+
+Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/celluloid-io.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/celluloid/io/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tony Arcieri"]
+  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.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "celluloid-io"
+  gem.require_paths = ["lib"]
+  gem.version       = Celluloid::IO::VERSION
+
+  gem.add_development_dependency('celluloid', '>= 0.7.0')
+  
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('rspec', ['>= 2.7.0'])
+end

data/lib/celluloid/io.rb

@@ -0,0 +1,27 @@
+require 'celluloid/io/version'
+
+require 'celluloid'
+require 'celluloid/io/mailbox'
+require 'celluloid/io/reactor'
+require 'celluloid/io/waker'
+
+module Celluloid
+  # Actors with evented IO support
+  module IO
+    def self.included(klass)
+      klass.send :include, Celluloid
+      klass.use_mailbox Celluloid::IO::Mailbox
+    end
+
+    # Wait for the given IO object to become readable
+    def wait_readable(io, &block)
+      # Law of demeter be damned!
+      current_actor.mailbox.reactor.wait_readable(io, &block)
+    end
+
+    # Wait for the given IO object to become writeable
+    def wait_writeable(io, &block)
+      current_actor.mailbox.reactor.wait_writeable(io, &block)
+    end
+  end
+end

data/lib/celluloid/io/mailbox.rb

@@ -0,0 +1,72 @@
+module Celluloid
+  module IO
+    # An alternative implementation of Celluloid::Mailbox using Wakers
+    class Mailbox < Celluloid::Mailbox
+      attr_reader :reactor, :waker
+
+      def initialize
+        @messages = []
+        @lock  = Mutex.new
+        @waker = Waker.new
+        @reactor = Reactor.new(@waker)
+      end
+
+      # Add a message to the Mailbox
+      def <<(message)
+        @lock.synchronize do
+          @messages << message
+          @waker.signal
+        end
+        nil
+      rescue DeadWakerError
+        raise MailboxError, "dead recipient"
+      end
+
+      # Add a high-priority system event to the Mailbox
+      def system_event(event)
+        @lock.synchronize do
+          @messages.unshift event
+
+          begin
+            @waker.signal
+          rescue DeadWakerError
+            # Silently fail if messages are sent to dead actors
+          end
+        end
+        nil
+      end
+
+      # Receive a message from the Mailbox
+      def receive(timeout = nil, &block)
+        message = nil
+
+        begin
+          if timeout
+             now = Time.now
+             wait_until ||= now + timeout
+             wait_interval = wait_until - now
+             return if wait_interval < 0
+           else
+             wait_interval = nil
+           end
+
+          @reactor.run_once(wait_interval) do
+            @waker.wait
+            message = next_message(&block)
+          end
+        end until message
+
+        message
+      rescue IOError, DeadWakerError
+        shutdown # force shutdown of the mailbox
+        raise MailboxShutdown, "mailbox shutdown called during receive"
+      end
+
+      # Cleanup any IO objects this Mailbox may be using
+      def shutdown
+        @waker.cleanup
+        super
+      end
+    end
+  end
+end

data/lib/celluloid/io/reactor.rb

@@ -0,0 +1,63 @@
+module Celluloid
+  module IO
+    # React to external I/O events. This is kinda sorta supposed to resemble the
+    # Reactor design pattern.
+    class Reactor
+      def initialize(waker)
+        @waker = waker
+        @readers = {}
+        @writers = {}
+      end
+
+      # Wait for the given IO object to become readable
+      def wait_readable(io)
+        wait_for_io io, @readers
+      end
+
+      # Wait for the given IO object to become writeable
+      def wait_writeable(io)
+        wait_for_io io, @writers
+      end
+
+      # Run the reactor, waiting for events, and calling the given block if
+      # the reactor is awoken by the waker
+      def run_once(timeout = nil)
+        readers, writers = select(@readers.keys << @waker.io, @writers.keys, [], timeout)
+        return unless readers
+
+        yield if readers.include? @waker.io
+
+        [[readers, @readers], [writers, @writers]].each do |ios, registered|
+          ios.each do |io|
+            task = registered.delete io
+            task.resume if task
+          end
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def wait_for_io(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
+            io = io.to_io
+          else raise TypeError, "can't convert #{io.class} into IO"
+          end
+        end
+
+        if set.has_key? io
+          raise ArgumentError, "another method is already waiting on #{io.inspect}"
+        else
+          set[io] = Task.current
+        end
+
+        Task.suspend
+      end
+    end
+  end
+end

data/lib/celluloid/io/version.rb

@@ -0,0 +1,5 @@
+module Celluloid
+  module IO
+    VERSION = "0.7.0"
+  end
+end

data/lib/celluloid/io/waker.rb

@@ -0,0 +1,43 @@
+module Celluloid
+  module IO
+    class DeadWakerError < StandardError; end # You can't wake the dead
+
+    # Wakes up sleepy threads so that they can check their mailbox
+    # Works like a ConditionVariable, except it's implemented as an IO object so
+    # that it can be multiplexed alongside other IO objects.
+    class Waker
+      PAYLOAD = "\0" # the payload doesn't matter. each byte is a signal
+      def initialize
+        @receiver, @sender = ::IO.pipe
+      end
+
+      # Wakes up the thread that is waiting for this Waker
+      def signal
+        @sender << PAYLOAD
+        nil
+      rescue IOError, Errno::EPIPE, Errno::EBADF
+        raise DeadWakerError, "waker is already dead"
+      end
+
+      # Wait for another thread to signal this Waker
+      def wait
+          byte = @receiver.read(1)
+          raise DeadWakerError, "can't wait on a dead waker" unless byte == PAYLOAD
+      rescue IOError, RuntimeError
+          raise DeadWakerError, "can't wait on a dead waker"
+      end
+
+      # Return the IO object which will be readable when this Waker is signaled
+      def io
+        @receiver
+      end
+
+      # Clean up the IO objects associated with this waker
+      def cleanup
+        @receiver.close rescue nil
+        @sender.close rescue nil
+        nil
+      end
+    end
+  end
+end

data/spec/celluloid/io/actor_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Celluloid::IO do
+  it_behaves_like "a Celluloid Actor", Celluloid::IO
+end

data/spec/celluloid/io/mailbox_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Celluloid::IO::Mailbox do
+  it_behaves_like "a Celluloid Mailbox"
+end

data/spec/celluloid/io/waker_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Celluloid::IO::Waker do
+  it "blocks until awoken" do
+    waker = Celluloid::IO::Waker.new
+    thread = Thread.new do
+      waker.wait
+      :done
+    end
+
+    # Assert that the thread can't be joined at this point
+    thread.join(0).should be_nil
+
+    waker.signal
+    thread.value.should == :done
+  end
+
+  it "returns an IO object that can be multiplexed with IO.select" do
+    waker = Celluloid::IO::Waker.new
+    waker.io.should be_an_instance_of(IO)
+
+    thread = Thread.new do
+      readable, _, _ = select [waker.io]
+      waker.wait
+      :done
+    end
+
+    # Assert that the thread can't be joined at this point
+    thread.join(0).should be_nil
+
+    waker.signal
+    thread.value.should == :done
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'celluloid/io'
+require 'celluloid/rspec'

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: celluloid-io
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+  prerelease: 
+platform: ruby
+authors:
+- Tony Arcieri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: &70176481988080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *70176481988080
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70176481987440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70176481987440
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70176481986860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *70176481986860
+description: Evented IO for Celluloid actors
+email:
+- tony.arcieri@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGES.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- celluloid-io.gemspec
+- lib/celluloid/io.rb
+- lib/celluloid/io/mailbox.rb
+- lib/celluloid/io/reactor.rb
+- lib/celluloid/io/version.rb
+- lib/celluloid/io/waker.rb
+- spec/celluloid/io/actor_spec.rb
+- spec/celluloid/io/mailbox_spec.rb
+- spec/celluloid/io/waker_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/tarcieri/celluloid-io
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+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/mailbox_spec.rb
+- spec/celluloid/io/waker_spec.rb
+- spec/spec_helper.rb