ara 0.0.2 → 0.0.3

data/Gemfile

@@ -2,6 +2,7 @@ source "http://rubygems.org"
 # Add dependencies required to use your gem here.
 # Example:
 #   gem "activesupport", ">= 2.3.5"
+gem "rack", ">= 1.3.1"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.

data/Gemfile.lock

@@ -6,6 +6,7 @@ GEM
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
+    rack (1.3.1)
     rake (0.9.2)
     rcov (0.9.9)
     shoulda (2.11.3)
@@ -16,5 +17,6 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.0.0)
   jeweler (~> 1.6.2)
+  rack (>= 1.3.1)
   rcov
   shoulda

data/README.rdoc

@@ -26,6 +26,15 @@ Because of akka[http://akka.io/] and my two parakeets ;)
       sleep rand(10)
       reply "Thanks @ #{Time.now}!"
     end
+
+    private
+    def pre_start
+      # ...
+    end
+
+    def post_stop
+      # ...
+    end
   end
   
   # This method will receive the actor' replies after sending it an asynchronous message
@@ -99,6 +108,16 @@ Client :
 
 == Changelog
 
+=== 0.0.3
+* Add pre_start and post_stop
+* Change logger
+* BindingOfCaller correction
+* Add Routing
+
+=== 0.0.2
+* Add Scheduler support
+* Add Remote actor support
+
 === 0.0.1
 * Initial version
 

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/ara.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ara}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gregoire Lejeune"]
-  s.date = %q{2011-07-15}
+  s.date = %q{2011-07-17}
   s.description = %q{Ara is a tiny class that’s allow you to use actors in Ruby}
   s.email = %q{gregoire.lejeune@free.fr}
   s.extra_rdoc_files = [
@@ -32,6 +32,7 @@ Gem::Specification.new do |s|
     "examples/async_block.rb",
     "examples/async_meth.rb",
     "examples/logger_actor.rb",
+    "examples/pi.rb",
     "examples/simple_actor.rb",
     "examples/simple_scheduler.rb",
     "examples/sync_actor.rb",
@@ -45,9 +46,10 @@ Gem::Specification.new do |s|
     "lib/ara/logger.rb",
     "lib/ara/remote.rb",
     "lib/ara/remote_actor.rb",
+    "lib/ara/routing.rb",
     "lib/ara/scheduler.rb",
     "lib/ara/simple_actor.rb",
-    "lib/ext/binding_of_caller.rb",
+    "lib/ext/boc.rb",
     "test/helper.rb",
     "test/test_ara.rb"
   ]
@@ -62,17 +64,20 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rack>, [">= 1.3.1"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
       s.add_development_dependency(%q<rcov>, [">= 0"])
     else
+      s.add_dependency(%q<rack>, [">= 1.3.1"])
       s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
       s.add_dependency(%q<rcov>, [">= 0"])
     end
   else
+    s.add_dependency(%q<rack>, [">= 1.3.1"])
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.2"])

data/examples/logger_actor.rb

@@ -1,12 +1,12 @@
 $:.unshift("../lib")
 require 'ara'
 
-Ara.logger = Logger.new("actor.log")
-Ara.logger.debug "Starting..."
+# Ara.logger = Logger.new("actor.log")
+Ara.debug "Starting..."
 
 class MySimpleActor < SimpleActor
   def receive( message )
-    Ara.logger.debug "Actor #{self} receive message : #{message}"
+    Ara.info "Actor #{self} receive message : #{message}"
   end
 end
 
@@ -24,11 +24,11 @@ mySimpleActor.stop
 
 sleep 1
 
-Ara.logger.debug "Ending..."
+Ara.debug "Ending..."
 
 # This will raise an exception
 begin
   mySimpleActor | "Hum..."
 rescue DeadActor => e
-  puts e
+  Ara.fatal e.message
 end

data/examples/pi.rb

@@ -0,0 +1,70 @@
+# VERY UNSTABLE !!!
+
+$:.unshift("../lib")
+require 'ara'
+
+class Worker < Actor
+   def calculate_pi_for(start, nb_of_elements)
+      acc = 0.0
+      (start...(start+nb_of_elements)).to_a.each { |i|
+         acc += 4.0 * (1 - (i % 2) * 2) / (2 * i + 1)
+      }
+      acc
+   end
+
+   def receive(message)
+      r = calculate_pi_for(message[:start], message[:nb_of_elements])
+      reply r
+   end
+end
+
+class Master < Actor
+   def receive(message)
+      nb_of_workers = message[:nb_of_workers]
+      nb_of_elements = message[:nb_of_elements]
+      @nb_of_messages = message[:nb_of_messages]
+
+      @pi = 0.0
+      @nb_of_results = 1
+
+      actors = []
+      nb_of_workers.times { |_|
+         actors << Actors.actor_of(Worker).start
+      }
+
+      router = Routing.load_balancer_actor(actors)
+      @m = Mutex.new
+      
+      @nb_of_messages.times { |i|
+         sleep 0.002
+         m = { :start => i * nb_of_elements, :nb_of_elements => nb_of_elements }
+         router < m
+      }
+   end
+
+   def actor_response(message)
+      @m.synchronize {
+      @pi += message
+      Ara.debug("*** Pi estimate : #{@pi}")
+      @nb_of_results += 1
+      self.stop if @nb_of_results >= @nb_of_messages
+      }
+   end
+
+   def post_stop
+      Ara.debug("Pi estimate : #{@pi}")
+   end
+
+   def pre_start
+   end
+end
+
+def calculate(nb_of_workers, nb_of_elements, nb_of_messages) 
+   master = Actors.actor_of(Master).start
+   m = { :nb_of_workers => nb_of_workers, :nb_of_elements => nb_of_elements, :nb_of_messages => nb_of_messages }
+   master | m
+end
+
+calculate(10, 1000, 100)
+
+10.times { sleep 1 }

data/examples/simple_actor.rb

@@ -5,6 +5,16 @@ class MySimpleActor < SimpleActor
   def receive( message )
     puts "Actor #{self} receive message : #{message}"
   end
+
+  private
+  def pre_start
+     puts "*** in pre_start"
+  end
+
+  private
+  def post_stop
+     puts "*** in post_stop"
+  end
 end
 
 mySimpleActor = Actors.actor_of(MySimpleActor).start

data/examples/sync_actor.rb

@@ -3,7 +3,7 @@ require 'ara'
 
 class MySynchronizedActor < Actor
   def receive(message)
-    puts "Actor #{self} receive message : #{message}"
+    puts "Actor #{self} receive message : #{message} and take a break..."
     sleep rand(10)
     reply "Thanks @ #{Time.now}!"
   end

data/lib/ara.rb

@@ -8,3 +8,4 @@ require 'ara/actors'
 require 'ara/scheduler'
 
 require 'ara/remote'
+require 'ara/routing'

data/lib/ara/actor.rb

@@ -1,4 +1,5 @@
-require 'ara/exception'
+require 'ext/boc'
+#require 'ext/binding_of_caller'
 require 'ara/simple_actor'
 
 # Actor class
@@ -7,6 +8,7 @@ class Actor < SimpleActor
     raise ActorInitializationError, "You can't initialize Actor directly, use Actors.actor_of" if self.class == ::Actor
     super
     @main = Queue.new
+    @mutex = Mutex.new
   end
 
   # Send a synchronous message
@@ -19,7 +21,7 @@ class Actor < SimpleActor
   def <<(message)
     if @thread.alive?
       @actorQueue << message
-      @main.pop
+      @main.shift
     else 
       raise DeadActor, "Actor is dead!"
     end
@@ -34,28 +36,33 @@ class Actor < SimpleActor
   #
   # The code after this call will be executed without waiting the actor. You must add a <tt>result</tt> method to get the actor' reponse.
   def <(message, response_method = nil)
-    if @thread.alive?
-      @actorQueue << message
-      BindingOfCaller.binding_of_caller do |bind|
-         self_of_caller = eval("self", bind)
-         Thread.new do
-            _result = @main.pop
-            begin
-            if block_given?
-              yield _result
-            elsif response_method != nil
-              self_of_caller.send( response_method.to_sym, _result )
-            else
-              self_of_caller.send( :actor_response, _result )
-            end
-            rescue => e
-               raise ActorResponseError, "Error while sending response : #{e}"
-            end
-         end
-      end
-    else
-      raise DeadActor, "Actor is dead!"
-    end
+     _actor = self
+     if @thread.alive?
+        @actorQueue << message
+
+        BindingOfCaller.binding_of_caller do |bind|
+           self_of_caller = eval("self", bind)
+           Thread.new do
+              _result = @main.shift
+              begin
+                 if block_given?
+                    yield _result
+                 elsif response_method != nil
+                    self_of_caller.send( response_method.to_sym, _result )
+                 elsif self_of_caller.respond_to? :actor_response_with_name
+                    self_of_caller.send( :actor_response_with_name, _actor, _result ) 
+                 else
+                    self_of_caller.send( :actor_response, _result )
+                 end
+              rescue => e
+                 Ara.fatal(e)
+                 raise ActorResponseError, "Error while sending response : #{e}"
+              end
+           end
+        end
+     else
+        raise DeadActor, "Actor is dead!"
+     end
   end
   alias :async_message :<
 

data/lib/ara/logger.rb

@@ -10,6 +10,14 @@ module Ara
       L.instance.logger=l
    end
 
+   def self.method_missing(method_sym, *arguments, &block)
+      if self.logger.respond_to?(method_sym)
+         self.logger.send(method_sym, *arguments)
+      else
+         raise NoMethodError, "undefined method `#{method_sym.to_s}' for Ara:Module"
+      end
+   end
+
    class L #:nodoc:
       include Singleton
 

data/lib/ara/routing.rb

@@ -0,0 +1,65 @@
+module Routing 
+   def self.load_balancer_actor(actors)
+      router = Actors.actor_of(Dispatcher).start
+      router | ActorList.new(actors)
+      router
+   end
+
+   def self.Broadcast(message)
+      return B.new(message)
+   end
+
+   class B #:nodoc:
+      def initialize(message)
+         @message = message
+      end
+
+      def message
+         @message
+      end
+   end
+
+   class ActorList #:nodoc:
+      def initialize(actors)
+         @actors = actors
+         @free_actors = Queue.new
+         @actors.each { |actor| @free_actors << actor }
+      end
+
+      def broadcast(message)
+         @actors.each do |actor|
+            actor | message
+         end
+      end
+
+      def get_actor
+         @free_actors.shift
+      end
+
+      def release_actor(actor)
+         @free_actors << actor
+      end
+   end
+
+   class Dispatcher < Actor
+      def receive(message)
+         if message.instance_of? Routing::ActorList
+            @list = message
+         elsif message.instance_of? Routing::B
+            @list.broadcast(message.message)
+         else
+            f = @list.get_actor
+            unless f.nil?
+               f < message
+            else 
+               Ara.debug("No free actor :(")
+            end
+         end
+      end
+
+      def actor_response_with_name(actor, r)
+         @list.release_actor(actor)
+         reply r
+      end
+   end
+end

data/lib/ara/simple_actor.rb

@@ -1,4 +1,3 @@
-require 'ext/binding_of_caller'
 require 'ara/exception'
 
 # This class allow you to create simple actors. 
@@ -13,9 +12,10 @@ class SimpleActor
   #   myActor = Actors.actor_of(MyActor)
   #   myActor.start
   def start
+    self.send(:pre_start) if self.respond_to?(:pre_start, true)
     @thread = Thread.new do 
       loop do
-        receive(@actorQueue.pop)
+        receive(@actorQueue.shift)
       end
     end
 
@@ -29,6 +29,7 @@ class SimpleActor
   #   myActor.stop
   def stop
     @thread.kill
+    self.send(:post_stop) if self.respond_to?(:post_stop, true)
   end
 
   # Send a simple message without expecting any response

data/lib/ext/{binding_of_caller.rb → boc.rb}

@@ -23,21 +23,20 @@
 require 'continuation'
 
 module BindingOfCaller
-VERSION = "0.1.3"
+   VERSION = "0.1.3"
 
-module_function
+   # module_function
 
-def binding_of_caller
-   cont = nil
-   event_count = 0
-
-   tracer = lambda do |event, _, _, _, binding, _|
-      event_count += 1
-      if event_count == 4
-         Thread.current.set_trace_func(nil)
-         case event
+   def self.binding_of_caller
+      cont = nil
+      event_count = 0
+      tracer = lambda do |event, file, line, id, binding, classname|
+         event_count += 1
+         if event_count == 4
+            case event
             when "return", "line", "end"
-               cont.call(nil, binding)
+               yield binding
+               set_trace_func(nil)
             else
                error_msg = "\n" <<
                "Invalid use of binding_of_caller. One of the following:\n" <<
@@ -47,16 +46,14 @@ def binding_of_caller
                "  (3) the method using binding_of_caller is called from the\n" << 
                "      last line of a block or global scope.\n" <<
                "See the documentation for binding_of_caller.\n"
-               cont.call(nil, nil, lambda { raise(ScriptError, error_msg) })
+               cont.call(nil, lambda { raise(ScriptError, error_msg) })
             end
          end
       end
 
-      cont, result, error = callcc { |cc| cc }
+      cont, error = callcc { |cc| cc }
       if cont
-         Thread.current.set_trace_func(tracer)
-      elsif result
-         yield result
+         set_trace_func(tracer)
       else
          error.call 
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ara
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,23 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-15 00:00:00.000000000 +02:00
+date: 2011-07-17 00:00:00.000000000 +02:00
 default_executable: 
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &2154182500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *2154182500
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &2153397620 !ruby/object:Gem::Requirement
+  requirement: &2154182020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153397620
+  version_requirements: *2154182020
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2153396300 !ruby/object:Gem::Requirement
+  requirement: &2154181540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +44,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *2153396300
+  version_requirements: *2154181540
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2153395040 !ruby/object:Gem::Requirement
+  requirement: &2154181060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +55,10 @@ dependencies:
         version: 1.6.2
   type: :development
   prerelease: false
-  version_requirements: *2153395040
+  version_requirements: *2154181060
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &2153393200 !ruby/object:Gem::Requirement
+  requirement: &2154180580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +66,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153393200
+  version_requirements: *2154180580
 description: Ara is a tiny class that’s allow you to use actors in Ruby
 email: gregoire.lejeune@free.fr
 executables: []
@@ -79,6 +90,7 @@ files:
 - examples/async_block.rb
 - examples/async_meth.rb
 - examples/logger_actor.rb
+- examples/pi.rb
 - examples/simple_actor.rb
 - examples/simple_scheduler.rb
 - examples/sync_actor.rb
@@ -92,9 +104,10 @@ files:
 - lib/ara/logger.rb
 - lib/ara/remote.rb
 - lib/ara/remote_actor.rb
+- lib/ara/routing.rb
 - lib/ara/scheduler.rb
 - lib/ara/simple_actor.rb
-- lib/ext/binding_of_caller.rb
+- lib/ext/boc.rb
 - test/helper.rb
 - test/test_ara.rb
 has_rdoc: true