update actor examples

Author: pitr-ch

doc/actor/define.out.rb

@@ -33,5 +33,5 @@ def on_event(event)
 an_actor << :boo << Message.new(:add, 1) 
 an_actor.ask!(Message.new(:value, nil))            # => 1
 an_actor << :terminate!
-    # => #<Concurrent::Actor::Reference:0x7fb6fc9165d0 /an_actor (AnActor)>
+    # => #<Concurrent::Actor::Reference:0x7ff3ab16edc8 /an_actor (AnActor)>
 

doc/actor/io.in.rb

@@ -11,29 +11,29 @@ def on_message(message)
   end
 
   def default_executor
-    Concurrent.configuration.global_operation_pool
+    Concurrent.global_io_executor
   end
 end #
 
 actor_doing_io = ActorDoingIO.spawn :actor_doing_io
-actor_doing_io.executor == Concurrent.configuration.global_operation_pool
+actor_doing_io.executor == Concurrent.global_io_executor
 
 # It can be also built into a pool so there is not too many IO operations
 
-class IOWorker < Concurrent::Actor::Utils::AbstractWorker
-  def work(io_job)
+class IOWorker < Concurrent::Actor::Context
+  def on_message(io_job)
     # do IO work
     sleep 0.1
     puts "#{path} second:#{(Time.now.to_f*100).floor} message:#{io_job}"
   end
 
   def default_executor
-    Concurrent.configuration.global_operation_pool
+    Concurrent.global_io_executor
   end
 end #
 
-pool = Concurrent::Actor::Utils::Pool.spawn('pool', 2) do |balancer, index|
-  IOWorker.spawn(name: "worker-#{index}", args: [balancer])
+pool = Concurrent::Actor::Utils::Pool.spawn('pool', 2) do |index|
+  IOWorker.spawn(name: "worker-#{index}")
 end
 
 pool << 1 << 2 << 3 << 4 << 5 << 6

doc/actor/io.out.rb

@@ -11,36 +11,36 @@ def on_message(message)
   end
 
   def default_executor
-    Concurrent.configuration.global_operation_pool
+    Concurrent.global_io_executor
   end
 end 
 
 actor_doing_io = ActorDoingIO.spawn :actor_doing_io
-    # => #<Concurrent::Actor::Reference:0x7fb6fc906068 /actor_doing_io (ActorDoingIO)>
-actor_doing_io.executor == Concurrent.configuration.global_operation_pool
+    # => #<Concurrent::Actor::Reference:0x7ff3ab176b40 /actor_doing_io (ActorDoingIO)>
+actor_doing_io.executor == Concurrent.global_io_executor
     # => true
 
 # It can be also built into a pool so there is not too many IO operations
 
-class IOWorker < Concurrent::Actor::Utils::AbstractWorker
-  def work(io_job)
+class IOWorker < Concurrent::Actor::Context
+  def on_message(io_job)
     # do IO work
     sleep 0.1
     puts "#{path} second:#{(Time.now.to_f*100).floor} message:#{io_job}"
   end
 
   def default_executor
-    Concurrent.configuration.global_operation_pool
+    Concurrent.global_io_executor
   end
 end 
 
-pool = Concurrent::Actor::Utils::Pool.spawn('pool', 2) do |balancer, index|
-  IOWorker.spawn(name: "worker-#{index}", args: [balancer])
+pool = Concurrent::Actor::Utils::Pool.spawn('pool', 2) do |index|
+  IOWorker.spawn(name: "worker-#{index}")
 end
-    # => #<Concurrent::Actor::Reference:0x7fb6fc964190 /pool (Concurrent::Actor::Utils::Pool)>
+    # => #<Concurrent::Actor::Reference:0x7ff3abaac5c0 /pool (Concurrent::Actor::Utils::Pool)>
 
 pool << 1 << 2 << 3 << 4 << 5 << 6
-    # => #<Concurrent::Actor::Reference:0x7fb6fc964190 /pool (Concurrent::Actor::Utils::Pool)>
+    # => #<Concurrent::Actor::Reference:0x7ff3abaac5c0 /pool (Concurrent::Actor::Utils::Pool)>
 
 # prints two lines each second
 # /pool/worker-0 second:1414677666 message:1

doc/actor/messaging.out.rb

@@ -1,4 +1,4 @@
-require 'algebrick'                                # => false
+require 'algebrick'                                # => true
 
 # Actor message protocol definition with Algebrick
 Protocol = Algebrick.type do
@@ -24,13 +24,13 @@ def on_message(message)
 end 
 
 calculator = Calculator.spawn('calculator')
-    # => #<Concurrent::Actor::Reference:0x7fb6fc915ec8 /calculator (Calculator)>
+    # => #<Concurrent::Actor::Reference:0x7ff3ab0c4f80 /calculator (Calculator)>
 addition = calculator.ask Add[1, 2]
-    # => <#Concurrent::Edge::Future:0x7fb6fc937190 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7ff3ab08e188 pending blocks:[]>
 substraction = calculator.ask Subtract[1, 0.5]
-    # => <#Concurrent::Edge::Future:0x7fb6fc935598 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7ff3ab9de940 pending blocks:[]>
 results = (addition & substraction)
-    # => <#Concurrent::Edge::ArrayFuture:0x7fb6fc967ea8 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7ff3aa0b1b48 pending blocks:[]>
 results.value!                                     # => [3, 0.5]
 
 calculator.ask! :terminate!                        # => true

doc/actor/quick.out.rb

@@ -17,13 +17,13 @@ def on_message(message)
 # `link: true` makes the actor linked to root actor and supervised
 # which is default behavior
 adder = Adder.spawn(name: :adder, link: true, args: [1])
-    # => #<Concurrent::Actor::Reference:0x7fb6fc88ff58 /adder (Adder)>
+    # => #<Concurrent::Actor::Reference:0x7ff3ababf828 /adder (Adder)>
 adder.parent
-    # => #<Concurrent::Actor::Reference:0x7fb6fe0f5db8 / (Concurrent::Actor::Root)>
+    # => #<Concurrent::Actor::Reference:0x7ff3abad7ba8 / (Concurrent::Actor::Root)>
 
 # tell and forget
 adder.tell(:add).tell(:add)
-    # => #<Concurrent::Actor::Reference:0x7fb6fc88ff58 /adder (Adder)>
+    # => #<Concurrent::Actor::Reference:0x7ff3ababf828 /adder (Adder)>
 # ask to get result
 adder.ask!(:add)                                   # => 4
 # fail the actor

doc/actor/supervision_tree.in.rb

@@ -11,7 +11,7 @@ def on_message(msg)
     when :listener
       @listener
     when :reset, :terminated, :resumed, :paused
-      log Logger::DEBUG, " got #{msg} from #{envelope.sender}"
+      log(DEBUG) { " got #{msg} from #{envelope.sender}"}
     else
       pass
     end

doc/actor/supervision_tree.out.rb

@@ -11,7 +11,7 @@ def on_message(msg)
     when :listener
       @listener
     when :reset, :terminated, :resumed, :paused
-      log Logger::DEBUG, " got #{msg} from #{envelope.sender}"
+      log(DEBUG) { " got #{msg} from #{envelope.sender}"}
     else
       pass
     end
@@ -48,22 +48,22 @@ def on_message(msg)
 end 
 
 master   = Master.spawn(name: 'master', supervise: true)
-    # => #<Concurrent::Actor::Reference:0x7fb6fca9caa8 /master (Master)>
+    # => #<Concurrent::Actor::Reference:0x7ff3aa0d1380 /master (Master)>
 listener = master.ask!(:listener)
-    # => #<Concurrent::Actor::Reference:0x7fb6fcabd9b0 /master/listener1 (Listener)>
-listener.ask!(:number)                             # => 53
+    # => #<Concurrent::Actor::Reference:0x7ff3aa8776e8 /master/listener1 (Listener)>
+listener.ask!(:number)                             # => 73
 
 master << :crash
-    # => #<Concurrent::Actor::Reference:0x7fb6fca9caa8 /master (Master)>
+    # => #<Concurrent::Actor::Reference:0x7ff3aa0d1380 /master (Master)>
 
-sleep 0.1                                          # => 0
+sleep 0.1                                          # => 1
 
 # ask for listener again, old one is terminated
 listener.ask!(:terminated?)                        # => true
 listener = master.ask!(:listener)
-    # => #<Concurrent::Actor::Reference:0x7fb6fcb04ef0 /master/listener1 (Listener)>
-listener.ask!(:number)                             # => 71
+    # => #<Concurrent::Actor::Reference:0x7ff3ab147110 /master/listener1 (Listener)>
+listener.ask!(:number)                             # => 48
 
-master.ask!(:terminate!)                           # => true
+master.ask!(:terminate!)                           # => [true, true]
 
 sleep 0.1                                          # => 0