revactor 0.1.3 → 0.1.4

data/CHANGES

@@ -1,6 +1,10 @@
+0.1.4:
+
+* Fix bungled 0.1.3 release :(
+
 0.1.3:
 
-* Removed case gem usage in Revactor internals
+* Added the Actorize module for easily using objects as Actors
 
 * Add a guaranteed blocking idle state for the Actor scheduler, fixing a bug
   where an idle root Actor would spin on the scheduler when calling receive

data/examples/chat_server.rb

@@ -14,80 +14,99 @@ PORT = 4321
 
 # Open a listen socket.  All traffic on new connections will be run through
 # the "line" filter, so incoming messages are delimited by newlines.
-
 listener = Actor::TCP.listen(HOST, PORT, :filter => :line)
 puts "Listening on #{HOST}:#{PORT}"
 
-# Spawn the server
-server = Actor.spawn do
-  clients = {}
+# The ClientConenction class handles all network interaction with clients
+# This includes the initial handshake (getting a nickname), processing
+# incoming messages, and writing out enqueued messages
+class ClientConnection
+  # Add .spawn and .spawn_link methods to the singleton
+  extend Actorize
   
-  # A proc to broadcast a message to all connected clients.  If the server
-  # were encapsulated into an object this could be a method
-  broadcast = proc do |msg|
-    clients.keys.each { |client| client << T[:write, msg] }
+  def initialize(dispatcher, sock)
+    @dispatcher, @sock = dispatcher, sock
+    puts "#{sock.remote_addr}:#{sock.remote_port} connected"
+    
+    handshake
+    message_loop
+  rescue EOFError
+    puts "#{sock.remote_addr}:#{sock.remote_port} disconnected"
+    @dispatcher << T[:disconnected, Actor.current]  
   end
   
-  # Server's main loop.  The server handles incoming messages from the
-  # client managers and dispatches them to other client managers.
-  loop do 
-    Actor.receive do |filter|
-      filter.when(T[:register]) do |_, client, nickname|
-        clients[client] = nickname
-        broadcast.call "*** #{nickname} joined"
-        client << T[:write, "*** Users: " + clients.values.join(', ')]
-      end
-
-      filter.when(T[:say]) do |_, client, msg|
-        nickname = clients[client]
-        broadcast.call "<#{nickname}> #{msg}"
-      end
-
-      filter.when(T[:disconnected]) do |_, client|
-        nickname = clients.delete client
-        broadcast.call "*** #{nickname} left" if nickname
-      end
-    end
+  def handshake
+    @sock.write "Please enter a nickname:"
+    nickname = @sock.read
+    @dispatcher << T[:register, Actor.current, nickname]
   end
-end
-
-# The main loop handles incoming connections
-loop do
-  # Spawn a new actor for each incoming connection
-  Actor.spawn(listener.accept) do |sock|
-    puts "#{sock.remote_addr}:#{sock.remote_port} connected"
-
-    # Connection handshaking
-    sock.write "Please enter a nickname:"
-    nickname = sock.read
 
-    server << T[:register, Actor.current, nickname]
-    
+  def message_loop
     # Flip the socket into asynchronous "active" mode
     # This means the Actor can receive messages from
     # the socket alongside other events.
-    sock.controller = Actor.current
-    sock.active = :once
-  
+    @sock.controller = Actor.current
+    @sock.active = :once
+
     # Main message loop
     loop do
       Actor.receive do |filter|
-        filter.when(T[:tcp, sock]) do |_, _, message|
-          server << T[:say, Actor.current, message]
-          sock.active = :once
+        # Handle incoming TCP traffic.  The line filter ensures that all
+        # incoming traffic is filtered down to CRLF-delimited lines of text
+        filter.when(T[:tcp, @sock]) do |_, _, message|
+          @dispatcher << T[:line, Actor.current, message]
+          @sock.active = :once
         end
         
+        # Write a message to the client's socket
         filter.when(T[:write]) do |_, message|
-          sock.write message
+          @sock.write message
         end
-        
-        filter.when(T[:tcp_closed, sock]) do
+
+        # Indicates the client's connection has closed
+        filter.when(T[:tcp_closed, @sock]) do
           raise EOFError
         end
       end
     end
-  rescue EOFError
-    puts "#{sock.remote_addr}:#{sock.remote_port} disconnected"
-    server << T[:disconnected, Actor.current]
   end
 end
+
+class Dispatcher
+  extend Actorize
+  
+  def initialize
+    @clients = {}
+    run
+  end
+  
+  def run
+    loop do
+      Actor.receive do |filter|
+        filter.when(T[:register]) do |_, client, nickname|
+          @clients[client] = nickname
+          broadcast "*** #{nickname} joined"
+          client << T[:write, "*** Users: " + @clients.values.join(', ')]
+        end
+
+        filter.when(T[:line]) do |_, client, msg|
+          nickname = @clients[client]
+          broadcast "<#{nickname}> #{msg}"
+        end
+
+        filter.when(T[:disconnected]) do |_, client|
+          nickname = @clients.delete client
+          broadcast "*** #{nickname} left" if nickname
+        end
+      end
+    end
+  end
+  
+  # Broadcast a message to all connected clients
+  def broadcast(message)
+    @clients.keys.each { |client| client << T[:write, message] }
+  end
+end
+
+dispatcher = Dispatcher.spawn
+loop { ClientConnection.spawn(dispatcher, listener.accept) }

data/lib/revactor.rb

@@ -5,6 +5,7 @@
 #++
 
 require 'rev'
+require 'case'
 
 # This is mostly in hopes of a bright future with Rubinius
 # The recommended container for all datagrams sent between
@@ -26,13 +27,13 @@ end
 T = Tuple unless defined? T
 
 module Revactor
-  Revactor::VERSION = '0.1.3' unless defined? Revactor::VERSION
+  Revactor::VERSION = '0.1.4' unless defined? Revactor::VERSION
   def self.version() VERSION end
 end
 
 %w{
-  actor scheduler mailbox delegator tcp http_client
-  filters/line filters/packet
+  actor scheduler mailbox tcp http_client
+  filters/line filters/packet actorize
 }.each do |file|
   require File.dirname(__FILE__) + '/revactor/' + file
 end
@@ -41,6 +42,5 @@ end
 class Actor
   Actor::TCP = Revactor::TCP unless defined? Actor::TCP
   Actor::Filter = Revactor::Filter unless defined? Actor::Filter
-  Actor::Delegator = Revactor::Delegator unless defined? Actor::Delegator
   Actor::HttpClient = Revactor::HttpClient unless defined? Actor::HttpClient
 end

data/lib/revactor/actor.rb

@@ -4,7 +4,6 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../revactor'
 require 'thread'
 require 'fiber'
 

data/lib/revactor/actorize.rb

@@ -0,0 +1,76 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+# Any class can be "actorized" by extending it with the Actorize module:
+#
+#  class MyClass
+#    extend Actorize
+#  end
+#
+# This will create MyClass.spawn and MyClass.spawn_link instance methods.
+# Now you can create instances of your class which run inside Actors:
+#
+#  actor = MyClass.spawn
+#
+# Actorize defines method_missing for the Actor object, and will delegate
+# any method calls to the Actor to MyClass's call method.  This method
+# should be defined with the following signature:
+#
+#  class MyClass
+#    extend Actorize
+#    
+#    def self.call(actor, meth, *args)
+#      ...
+#    end
+#  end
+#
+# The call method receives the actor the call was made on, the method that
+# was invoked, and the arguments that were passed.  You can then write a
+# simple RPC mechanism to send a message to the actor and receive a response:
+#  
+#  actor << [:call, Actor.current, meth, *args]
+#  Actor.receive do |filter|
+#    filter.when(T[:call_reply, actor]) { |_, _, response| response }
+#  end
+# 
+# Using this approach, you can mix the synchronous approach of Objects with
+# the asynchronous approach of Actors, and effectively duck type Actors
+# to Objects.
+#
+module Actorize
+  def spawn(*args)
+    _actorize Actor.spawn(*args, &method(:new))
+  end
+  
+  def spawn_link(*args)
+    _actorize Actor.spawn_link(*args, &method(:new))
+  end
+  
+  #######
+  private
+  #######
+  
+  def _actorize(actor)
+    actor.extend InstanceMethods
+    actor.instance_variable_set(:@_class, self)
+    actor
+  end
+  
+  module InstanceMethods
+    def method_missing(*args, &block)
+      return super unless @_class.respond_to?(:call)
+      @_class.call(self, *args, &block)
+    end
+    
+    def remote_class
+      @_class
+    end
+    
+    def inspect
+      "#<#{self.class}(#{remote_class}):0x#{object_id.to_s(16)}>"
+    end
+  end
+end

data/lib/revactor/http_client.rb

@@ -4,9 +4,7 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../revactor'
 require 'uri'
-
   
 module Revactor
   # Thrown for all HTTP-specific errors

data/lib/revactor/mailbox.rb

@@ -4,8 +4,6 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../revactor'
-
 class Actor
   # Actor mailbox.  For purposes of efficiency the mailbox also handles 
   # suspending and resuming an actor when no messages match its filter set.
@@ -78,7 +76,7 @@ class Actor
       end
     
       # Otherwise we matched a message, so process it with the action      
-      action.(@queue.delete_at matched_index)
+      action.call @queue.delete_at(matched_index)
     end
     
     # Is the mailbox empty?

data/lib/revactor/mongrel.rb

@@ -1,6 +1,6 @@
-require File.dirname(__FILE__) + '/../revactor'
 require 'mongrel'
-
+require File.dirname(__FILE__) + '/../revactor'
+ 
 class Revactor::TCP::Socket
   # Monkeypatched readpartial routine inserted whenever Revactor's mongrel.rb
   # is loaded.  The value passed to this method is ignored, so it is not

data/lib/revactor/scheduler.rb

@@ -5,7 +5,6 @@
 #++
 
 require 'thread'
-require File.dirname(__FILE__) + '/../revactor'
 
 class Actor
   # The Actor Scheduler maintains a run queue of actors with outstanding

data/lib/revactor/tcp.rb

@@ -4,8 +4,6 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../revactor'
-
 module Revactor
   # The TCP module holds all Revactor functionality related to the
   # Transmission Control Protocol, including drop-in replacements
@@ -346,8 +344,8 @@ module Revactor
       def initialize(host, port, options = {})
         super(host, port)
         opts = {
-          active:     false,
-          controller: Actor.current
+          :active     => false,
+          :controller => Actor.current
         }.merge(options)
         
         @active, @controller = opts[:active], opts[:controller]

data/revactor.gemspec

@@ -2,10 +2,10 @@ require 'rubygems'
 
 GEMSPEC = Gem::Specification.new do |s|
   s.name = "revactor"
-  s.version = "0.1.3"
+  s.version = "0.1.4"
   s.authors = "Tony Arcieri"
   s.email = "tony@medioh.com"
-  s.date = "2008-1-29"
+  s.date = "2008-3-28"
   s.summary = "Revactor is an Actor implementation for writing high performance concurrent programs"
   s.platform = Gem::Platform::RUBY
   s.required_ruby_version = '>= 1.9.0'
@@ -15,6 +15,7 @@ GEMSPEC = Gem::Specification.new do |s|
 
   # Dependencies
   s.add_dependency("rev", ">= 0.2.0")
+  s.add_dependency("case", ">= 0.4")
 
   # RubyForge info
   s.homepage = "http://revactor.org"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: revactor
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Tony Arcieri
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-29 00:00:00 -07:00
+date: 2008-03-28 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,6 +21,15 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.2.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: case
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+    version: 
 description: 
 email: tony@medioh.com
 executables: []
@@ -34,7 +43,7 @@ extra_rdoc_files:
 files: 
 - lib/revactor
 - lib/revactor/actor.rb
-- lib/revactor/delegator.rb
+- lib/revactor/actorize.rb
 - lib/revactor/filters
 - lib/revactor/filters/line.rb
 - lib/revactor/filters/packet.rb

data/lib/revactor/delegator.rb

@@ -1,70 +0,0 @@
-#--
-# 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__) + '/../revactor'
-
-# A Delegator whose delegate runs in a separate Actor.  This allows
-# an easy method for constructing synchronous calls to a separate Actor
-# which cause the current Actor to block until they complete.
-class Revactor::Delegator  
-  # Create a new delegator for the given object
-  def initialize(obj)
-    @obj = obj
-    @running = true
-    @actor = Actor.spawn(&method(:start))
-  end
-  
-  # Stop the delegator Actor
-  def stop
-    @actor << :stop
-    nil
-  end
-  
-  # Send a message to the Actor delegate
-  def send(meth, *args, &block)
-    @actor << T[:call, Actor.current, meth, args, block]
-    Actor.receive do |filter|
-      filter.when(Case[:call_reply, @actor, Object]) { |_, _, reply| reply }
-      filter.when(Case[:call_error, @actor, Object]) { |_, _, ex| raise ex }
-    end
-  end
-  
-  alias_method :method_missing, :send
-  
-  #########
-  protected
-  #########
-  
-  # Start the server
-  def start
-    loop do
-      Actor.receive do |filter|
-        filter.when(:stop)  { |_| return }
-        filter.when(Object) { |message| handle_message(message) }
-      end
-    end
-  end
-  
-  # Dispatch the incoming message to the appropriate handler
-  def handle_message(message)
-    case message.first
-    when :call then handle_call(message)
-    else @obj.__send__(:on_message, message) if @obj.respond_to? :on_message
-    end
-  end
-  
-  # Wrapper for calling the provided object's handle_call method
-  def handle_call(message)
-    _, from, meth, args, block = message
-    
-    begin
-      result = @obj.__send__(meth, *args, &block)
-      from << T[:call_reply, Actor.current, result]
-    rescue => ex
-      from << T[:call_error, Actor.current, ex]
-    end
-  end
-end