revactor 0.1.0

data/spec/actor_spec.rb

@@ -0,0 +1,127 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require File.dirname(__FILE__) + '/../lib/revactor/actor'
+
+describe Actor do
+  describe "creation" do
+    it "creates a base Actor with Actor.start" do
+      Actor.start do
+        Fiber.current.should be_an_instance_of(Actor)
+      end
+    end
+  
+    it "allows creation of new Actors with Actor.new" do
+      Actor.new do
+        Fiber.current.should be_an_instance_of(Actor)
+      end
+    end
+    
+    it "allows creation of new Actors with Actor.spawn" do
+      Actor.spawn do
+        Fiber.current.should be_an_instance_of(Actor)
+      end
+    end
+    
+    it "allows arguments to be passed when an Actor is created" do
+      [:new, :spawn].each do |meth|
+        Actor.send(meth, 1, 2, 3) do |foo, bar, baz|
+          [foo, bar, baz].should == [1, 2, 3]
+        end
+      end
+    end
+  end
+  
+  describe "current" do
+    it "allows the current Actor to be retrieved" do
+      Actor.new do
+        Actor.current.should be_an_instance_of(Actor)
+      end
+    end
+  
+    it "disallows retrieving the current Actor unless the Actor environment is started" do
+      proc { Actor.current }.should raise_error(ActorError)
+    end
+  end
+  
+  describe "receive" do
+    before :each do
+      @actor_run = false
+    end
+    
+    it "returns the value of the matching filter action" do
+      actor = Actor.new do
+        Actor.receive do |filter|
+          filter.when(:foo) { |message| :bar }
+        end.should == :bar
+        
+        # Make sure the spec actually ran the actor
+        @actor_run = true
+      end
+      
+      actor << :foo
+      @actor_run.should be_true
+    end
+    
+    it "filters messages with ===" do
+      actor = Actor.new do
+        results = []
+        3.times do
+          results << Actor.receive do |filter|
+            filter.when(/third/) { |m| m }
+            filter.when(/first/) { |m| m }
+            filter.when(/second/) { |m| m }
+          end
+        end
+        results.should == ['first message', 'second message', 'third message']
+        @actor_run = true
+      end
+      
+      ['first message', 'second message', 'third message'].each { |m| actor << m }
+      @actor_run.should be_true
+    end
+        
+    it "times out if a message isn't received after the specifed interval" do
+      actor = Actor.new do
+        Actor.receive do |filter|
+          filter.when(:foo) { :wrong }
+          filter.after(0.01) { :right }
+        end.should == :right
+        @actor_run = true
+      end
+      @actor_run.should be_true
+    end
+    
+    it "matches any message with Object" do
+      actor = Actor.new do
+        result = []
+        3.times do
+          result << Actor.receive do |filter|
+            filter.when(Object) { |m| m }
+          end
+        end
+        
+        result.should == [:foo, :bar, :baz]
+        @actor_run = true
+      end
+      
+      [:foo, :bar, :baz].each { |m| actor << m }
+      @actor_run.should be_true
+    end
+  end
+  
+  it "detects dead actors" do
+    actor = Actor.new do
+      Actor.receive do |filter|
+        filter.when(Object) {}
+      end
+    end
+    
+    actor.dead?.should be_false
+    actor << :foobar
+    actor.dead?.should be_true
+  end
+end

data/spec/line_filter_spec.rb

@@ -0,0 +1,36 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require File.dirname(__FILE__) + '/../lib/revactor/filters/line'
+
+describe Revactor::Filter::Line do
+  before(:each) do
+    @payload = "foo\nbar\r\nbaz\n"
+    @filter = Revactor::Filter::Line.new
+  end
+  
+  it "decodes lines from an input buffer" do
+    @filter.decode(@payload).should == %w{foo bar baz}
+  end
+  
+  it "encodes lines" do
+    @filter.encode(*%w{foo bar baz}).should == "foo\nbar\nbaz\n"
+  end
+    
+  it "reassembles fragmented lines" do
+    msg1 = "foobar\r\n"
+    msg2 = "baz\n"
+    msg3 = "quux\r\n"
+        
+    chunks = []
+    chunks[0] = msg1.slice(0, 1)
+    chunks[1] = msg1.slice(1, msg1.size) << msg2.slice(0, 1)
+    chunks[2] = msg2.slice(1, msg2.size - 1)
+    chunks[3] = msg2.slice(msg2.size, 1) << msg3
+        
+    chunks.reduce([]) { |a, chunk| a + @filter.decode(chunk) }.should == %w{foobar baz quux}
+  end
+end

data/spec/packet_filter_spec.rb

@@ -0,0 +1,59 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require File.dirname(__FILE__) + '/../lib/revactor/filters/packet'
+
+describe Revactor::Filter::Packet do
+  before(:each) do
+    @payload = "A test string"
+  end
+  
+  it "decodes frames with 2-byte prefixes" do
+    filter = Revactor::Filter::Packet.new(2)
+    filter.decode([@payload.length].pack('n') << @payload).should == [@payload]
+  end
+  
+  it "encodes frames with 2-byte prefixes" do
+    filter = Revactor::Filter::Packet.new(2)
+    filter.encode(@payload).should == [@payload.length].pack('n') << @payload
+  end
+    
+  it "decodes frames with 4-byte prefixes" do
+    @filter = Revactor::Filter::Packet.new(4)    
+    @filter.decode([@payload.length].pack('N') << @payload).should == [@payload]
+  end
+  
+  it "encodes frames with 4-byte prefixes" do
+    @filter = Revactor::Filter::Packet.new(4)    
+    @filter.encode(@payload).should == [@payload.length].pack('N') << @payload
+  end
+  
+  it "reassembles fragmented frames" do
+    filter = Revactor::Filter::Packet.new(2)
+    
+    msg1 = 'foobar'
+    msg2 = 'baz'
+    msg3 = 'quux'
+    
+    packet1 = [msg1.length].pack('n') << msg1
+    packet2 = [msg2.length].pack('n') << msg2
+    packet3 = [msg3.length].pack('n') << msg3
+        
+    chunks = []
+    chunks[0] = packet1.slice(0, 1)
+    chunks[1] = packet1.slice(1, packet1.size) << packet2.slice(0, 1)
+    chunks[2] = packet2.slice(1, packet2.size - 1)
+    chunks[3] = packet2.slice(packet2.size, 1) << packet3
+    
+    chunks.reduce([]) { |a, chunk| a + filter.decode(chunk) }.should == [msg1, msg2, msg3]
+  end
+
+  it "raises an exception for overlength frames" do
+    filter = Revactor::Filter::Packet.new(2)
+    payload = 'X' * 65537
+    proc { filter.encode payload }.should raise_error(ArgumentError)
+  end
+end

data/spec/tcp_spec.rb

@@ -0,0 +1,84 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require File.dirname(__FILE__) + '/../lib/revactor/tcp'
+
+TEST_HOST = '127.0.0.1'
+
+# Chosen with dice, guaranteed to be random!
+RANDOM_PORT = 10103
+
+describe Revactor::TCP do
+  before :each do
+    @actor_run = false
+    @server = TCPServer.new(TEST_HOST, RANDOM_PORT)
+  end
+  
+  after :each do
+    @server.close unless @server.closed?
+  end
+  
+  it "connects to remote servers" do
+    Actor.start do
+      sock = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
+      sock.should be_an_instance_of(Revactor::TCP::Socket)
+      @server.accept.should be_an_instance_of(TCPSocket)
+      
+      sock.close
+      @actor_run = true
+    end
+    
+    @actor_run.should be_true
+  end
+  
+  it "listens for remote connections" do
+    @server.close # Don't use it for this one...
+    
+    Actor.start do
+      server = Revactor::TCP.listen(TEST_HOST, RANDOM_PORT)
+      server.should be_an_instance_of(Revactor::TCP::Listener)
+      
+      s1 = TCPSocket.open(TEST_HOST, RANDOM_PORT)
+      s2 = server.accept
+      
+      server.close
+      s2.close
+      @actor_run = true
+    end
+    
+    @actor_run.should be_true
+  end
+  
+  it "reads data" do
+    Actor.start do
+      s1 = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
+      s2 = @server.accept
+    
+      s2.write 'foobar'
+      s1.read(6).should == 'foobar'
+    
+      s1.close
+      @actor_run = true
+    end
+  
+    @actor_run.should be_true
+  end
+
+  it "writes data" do
+    Actor.start do
+      s1 = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
+      s2 = @server.accept
+      
+      s1.write 'foobar'
+      s2.read(6).should == 'foobar'
+      
+      s1.close
+      @actor_run = true
+    end
+    
+    @actor_run.should be_true  
+  end
+end

data/tools/messaging_throughput.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../lib/revactor'
+
+NTIMES=100000
+
+begin_time = Time.now
+
+puts "#{begin_time.strftime('%H:%M:%S')} -- Sending #{NTIMES} messages"
+
+Actor.start do
+  parent = Actor.current
+  child = Actor.spawn do
+    (NTIMES / 2).times do
+      Actor.receive do |f|
+        f.when(:foo) { parent << :bar }
+      end
+    end
+  end
+
+  child << :foo
+  (NTIMES / 2).times do
+    Actor.receive do |f|
+      f.when(:bar) { child << :foo }
+    end
+  end
+end
+
+end_time = Time.now
+duration = end_time - begin_time
+throughput = NTIMES / duration
+
+puts "#{end_time.strftime('%H:%M:%S')} -- Finished"
+puts "Duration:   #{sprintf("%0.2f", duration)} seconds"
+puts "Throughput: #{sprintf("%0.2f", throughput)} messages per second"

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: revactor
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2008-01-15 00:00:00 -07:00
+summary: Revactor is an Actor implementation for writing high performance concurrent programs
+require_paths: 
+- lib
+email: tony@medioh.com
+homepage: http://revactor.org
+rubyforge_project: revactor
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Tony Arcieri
+files: 
+- lib/revactor
+- lib/revactor/actor.rb
+- lib/revactor/behaviors
+- lib/revactor/behaviors/server.rb
+- lib/revactor/filters
+- lib/revactor/filters/line.rb
+- lib/revactor/filters/packet.rb
+- lib/revactor/mongrel.rb
+- lib/revactor/server.rb
+- lib/revactor/tcp.rb
+- lib/revactor.rb
+- examples/echo_server.rb
+- examples/google.rb
+- examples/mongrel.rb
+- tools/messaging_throughput.rb
+- spec/actor_spec.rb
+- spec/line_filter_spec.rb
+- spec/packet_filter_spec.rb
+- spec/tcp_spec.rb
+- Rakefile
+- revactor.gemspec
+- LICENSE
+- README
+- CHANGES
+test_files: []
+
+rdoc_options: 
+- --title
+- Revactor
+- --main
+- README
+- --line-numbers
+extra_rdoc_files: 
+- LICENSE
+- README
+- CHANGES
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rev
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: case
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.3"
+    version: