concurrent-ruby 0.6.0 → 0.6.1

data/lib/concurrent/actress/core_delegations.rb

@@ -31,7 +31,12 @@ module Concurrent
         core.executor
       end
 
+      def actor_class
+        core.actor_class
+      end
+
       alias_method :ref, :reference
+      alias_method :actress_class, :actor_class
     end
   end
 end

data/lib/concurrent/actress/envelope.rb

@@ -1,12 +1,24 @@
 module Concurrent
   module Actress
-    Envelope = Struct.new :message, :ivar, :sender do
+    class Envelope
       include TypeCheck
 
-      def initialize(message, ivar, sender)
-        super message,
-              (Type! ivar, IVar, NilClass),
-              (Type! sender, Reference, Thread)
+      # @!attribute [r] message
+      #   @return [Object] a message
+      # @!attribute [r] ivar
+      #   @return [IVar] an ivar which becomes resolved after message is processed
+      # @!attribute [r] sender
+      #   @return [Reference, Thread] an actor or thread sending the message
+      # @!attribute [r] address
+      #   @return [Reference] where this message will be delivered
+
+      attr_reader :message, :ivar, :sender, :address
+
+      def initialize(message, ivar, sender, address)
+        @message = message
+        @ivar    = Type! ivar, IVar, NilClass
+        @sender  = Type! sender, Reference, Thread
+        @address = Type! address, Reference
       end
 
       def sender_path
@@ -17,6 +29,10 @@ module Concurrent
         end
       end
 
+      def address_path
+        address.path
+      end
+
       def reject!(error)
         ivar.fail error unless ivar.nil?
       end

data/lib/concurrent/actress/reference.rb

@@ -2,8 +2,8 @@ module Concurrent
   module Actress
 
     # Reference is public interface of Actor instances. It is used for sending messages and can
-    # be freely passed around the program. It also provides some basic information about the actor
-    # see {CoreDelegations}
+    # be freely passed around the program. It also provides some basic information about the actor,
+    # see {CoreDelegations}.
     class Reference
       include TypeCheck
       include CoreDelegations
@@ -43,14 +43,14 @@ module Concurrent
         ask(message, ivar).value!
       end
 
-      # behaves as #tell when no ivar and as #ask when ivar
+      # behaves as {#tell} when no ivar and as {#ask} when ivar
       def message(message, ivar = nil)
-        core.on_envelope Envelope.new(message, ivar, Actress.current || Thread.current)
+        core.on_envelope Envelope.new(message, ivar, Actress.current || Thread.current, self)
         return ivar || self
       end
 
       def to_s
-        "#<#{self.class} #{path}>"
+        "#<#{self.class} #{path} (#{actor_class})>"
       end
 
       alias_method :inspect, :to_s

data/lib/concurrent/agent.rb

@@ -62,14 +62,14 @@ module Concurrent
     # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
     #   returning the value returned from the proc
     def initialize(initial, opts = {})
-      @value              = initial
-      @rescuers           = []
-      @validator          = Proc.new { |result| true }
-      @timeout            = opts.fetch(:timeout, TIMEOUT).freeze
-      self.observers      = CopyOnWriteObserverSet.new
-      @one_by_one         = OneByOne.new
-      @task_executor      = OptionsParser.get_task_executor_from(opts)
-      @operation_executor = OptionsParser.get_operation_executor_from(opts)
+      @value                = initial
+      @rescuers             = []
+      @validator            = Proc.new { |result| true }
+      @timeout              = opts.fetch(:timeout, TIMEOUT).freeze
+      self.observers        = CopyOnWriteObserverSet.new
+      @serialized_execution = SerializedExecution.new
+      @task_executor        = OptionsParser.get_task_executor_from(opts)
+      @operation_executor   = OptionsParser.get_operation_executor_from(opts)
       init_mutex
       set_deref_options(opts)
     end
@@ -180,7 +180,7 @@ module Concurrent
 
     def post_on(executor, &block)
       return nil if block.nil?
-      @one_by_one.post(executor) { work(&block) }
+      @serialized_execution.post(executor) { work(&block) }
       true
     end
 

data/lib/concurrent/configuration.rb

@@ -1,6 +1,7 @@
 require 'thread'
 require 'concurrent/delay'
 require 'concurrent/errors'
+require 'concurrent/atomic/atomic'
 require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/executor/timer_set'
 require 'concurrent/utility/processor_count'
@@ -111,8 +112,12 @@ module Concurrent
   end
 
   # create the default configuration on load
-  @configuration = Configuration.new
-  singleton_class.send :attr_reader, :configuration
+  @configuration = Atomic.new Configuration.new
+
+  # @return [Configuration]
+  def self.configuration
+    @configuration.value
+  end
 
   # Perform gem-level configuration.
   #

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -172,7 +172,6 @@ module Concurrent
 
     # @!visibility private
     def shutdown_execution
-      @queue.clear
       if @pool.empty?
         stopped_event.set
       else

data/lib/concurrent/executor/{one_by_one.rb → serialized_execution.rb}

@@ -1,8 +1,10 @@
+require 'concurrent/logging'
+
 module Concurrent
 
-  # Ensures that jobs are passed to the given executors one by one,
-  # never running at the same time.
-  class OneByOne
+  # Ensures passed jobs in a serialized order never running at the same time.
+  class SerializedExecution
+    include Logging
 
     Job = Struct.new(:executor, :args, :block) do
       def call
@@ -30,10 +32,6 @@ module Concurrent
     # @raise [ArgumentError] if no task is given
     def post(executor, *args, &task)
       return nil if task.nil?
-      # FIXME Agent#send-off will blow up here
-      # if executor.can_overflow?
-      #   raise ArgumentError, 'OneByOne cannot be used in conjunction with executor which may overflow'
-      # end
 
       job = Job.new executor, args, task
 
@@ -56,7 +54,22 @@ module Concurrent
     private
 
     def call_job(job)
-      job.executor.post { work(job) }
+      did_it_run = begin
+        job.executor.post { work(job) }
+        true
+      rescue RejectedExecutionError => ex
+        false
+      end
+
+      # TODO not the best idea to run it myself
+      unless did_it_run
+        begin
+          work job
+        rescue => ex
+          # let it fail
+          log DEBUG, ex
+        end
+      end
     end
 
     # ensures next job is executed if any is stashed

data/lib/concurrent/executor/timer_set.rb

@@ -61,7 +61,12 @@ module Concurrent
 
     end
 
-    alias_method :kill, :shutdown
+    # For a timer, #kill is like an orderly shutdown, except we need to manually
+    # (and destructively) clear the queue first
+    def kill
+      @queue.clear
+      shutdown
+    end
 
     # Calculate an Epoch time with milliseconds at which to execute a
     # task. If the given time is a `Time` object it will be converted

data/lib/concurrent/executors.rb

@@ -6,4 +6,4 @@ require 'concurrent/executor/safe_task_executor'
 require 'concurrent/executor/single_thread_executor'
 require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/executor/timer_set'
-require 'concurrent/executor/one_by_one'
+require 'concurrent/executor/serialized_execution'

data/lib/concurrent/logging.rb

@@ -9,7 +9,7 @@ module Concurrent
     # @param [Integer] level one of Logger::Severity constants
     # @param [String] progname e.g. a path of an Actor
     # @param [String, nil] message when nil block is used to generate the message
-    # @yields_return [String] a message
+    # @yieldreturn [String] a message
     def log(level, progname, message = nil, &block)
       (@logger || Concurrent.configuration.logger).call level, progname, message, &block
     end

data/lib/concurrent/observable.rb

@@ -10,7 +10,7 @@ module Concurrent
       observers.add_observer(*args, &block)
     end
 
-    # as #add_observer but it can be used for chaning
+    # as #add_observer but it can be used for chaining
     # @return [Observable] self
     def with_observer(*args, &block)
       add_observer *args, &block

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
 end

data/spec/concurrent/actress_spec.rb

@@ -3,7 +3,27 @@ require 'concurrent/actress'
 
 module Concurrent
   module Actress
+    i_know_it_is_experimental!
+
+    class Reference
+      def backdoor(&block)
+        core.send :schedule_execution do
+          core.instance_eval &block
+        end
+      end
+    end
+
     describe 'Concurrent::Actress' do
+      prepend_before do
+        do_no_reset!
+      end
+
+      def terminate_actors(*actors)
+        actors.each do |actor|
+          actor.backdoor { terminate! }
+          actor.terminated.wait
+        end
+      end
 
       class Ping
         include Context
@@ -35,82 +55,80 @@ module Concurrent
       #   set_trace_func nil
       # end
 
-      #describe 'stress test' do
-        #pending('may cause deadlock which prevents test run from completing.')
-        #1.times do |i|
-          #it format('run %3d', i) do
-            ## puts format('run %3d', i)
-            #Array.new(10).map do
-              #Thread.new do
-                #10.times do
-                  ## trace! do
-                  #queue = Queue.new
-                  #actor = Ping.spawn :ping, queue
-
-                  ## when spawn returns children are set
-                  #Concurrent::Actress::ROOT.send(:core).instance_variable_get(:@children).should include(actor)
-
-                  #actor << 'a' << 1
-                  #queue.pop.should eq 'a'
-                  #actor.ask(2).value.should eq 2
-
-                  #actor.parent.should eq Concurrent::Actress::ROOT
-                  #Concurrent::Actress::ROOT.path.should eq '/'
-                  #actor.path.should eq '/ping'
-                  #child = actor.ask(:child).value
-                  #child.path.should eq '/ping/pong'
-                  #queue.clear
-                  #child.ask(3)
-                  #queue.pop.should eq 3
-
-                  #actor << :terminate
-                  #actor.ask(:blow_up).wait.should be_rejected
-                #end
-              #end
-            #end.each(&:join)
-          #end
-        #end
-      #end
+      describe 'stress test' do
+        1.times do |i|
+          it format('run %3d', i) do
+            # puts format('run %3d', i)
+            Array.new(10).map do
+              Thread.new do
+                10.times do
+                  # trace! do
+                  queue = Queue.new
+                  actor = Ping.spawn :ping, queue
+
+                  # when spawn returns children are set
+                  Concurrent::Actress::ROOT.send(:core).instance_variable_get(:@children).should include(actor)
+
+                  actor << 'a' << 1
+                  queue.pop.should eq 'a'
+                  actor.ask(2).value.should eq 2
+
+                  actor.parent.should eq Concurrent::Actress::ROOT
+                  Concurrent::Actress::ROOT.path.should eq '/'
+                  actor.path.should eq '/ping'
+                  child = actor.ask(:child).value
+                  child.path.should eq '/ping/pong'
+                  queue.clear
+                  child.ask(3)
+                  queue.pop.should eq 3
+
+                  actor << :terminate
+                  actor.ask(:blow_up).wait.should be_rejected
+                  terminate_actors actor, child
+                end
+              end
+            end.each(&:join)
+          end
+        end
+      end
 
       describe 'spawning' do
-        #describe 'Actress#spawn' do
-          #behaviour = -> v { -> _ { v } }
-          #subjects  = { spawn:                 -> { Actress.spawn(AdHoc, :ping, 'arg', &behaviour) },
-                        #context_spawn:         -> { AdHoc.spawn(:ping, 'arg', &behaviour) },
-                        #spawn_by_hash:         -> { Actress.spawn(class: AdHoc, name: :ping, args: ['arg'], &behaviour) },
-                        #context_spawn_by_hash: -> { AdHoc.spawn(name: :ping, args: ['arg'], &behaviour) } }
-
-          #subjects.each do |desc, subject_definition|
-            #describe desc do
-              #subject &subject_definition
-              #its(:path) { pending('may cause deadlock which prevents test run from completing.'); should eq '/ping' }
-              #its(:parent) { pending('may cause deadlock which prevents test run from completing.'); should eq ROOT }
-              #its(:name) { pending('may cause deadlock which prevents test run from completing.'); should eq 'ping' }
-              #its(:executor) { pending('may cause deadlock which prevents test run from completing.'); should eq Concurrent.configuration.global_task_pool }
-              #its(:reference) { pending('may cause deadlock which prevents test run from completing.'); should eq subject }
-              #it 'returns ars' do
-                #subject.ask!(:anything).should eq 'arg'
-              #end
-            #end
-          #end
-        #end
+        describe 'Actress#spawn' do
+          behaviour = -> v { -> _ { v } }
+          subjects  = { spawn:                 -> { Actress.spawn(AdHoc, :ping, 'arg', &behaviour) },
+                        context_spawn:         -> { AdHoc.spawn(:ping, 'arg', &behaviour) },
+                        spawn_by_hash:         -> { Actress.spawn(class: AdHoc, name: :ping, args: ['arg'], &behaviour) },
+                        context_spawn_by_hash: -> { AdHoc.spawn(name: :ping, args: ['arg'], &behaviour) } }
+
+          subjects.each do |desc, subject_definition|
+            describe desc do
+              subject &subject_definition
+              after { terminate_actors subject }
+              its(:path) { should eq '/ping' }
+              its(:parent) { should eq ROOT }
+              its(:name) { should eq 'ping' }
+              it('executor should be global') { subject.executor.should eq Concurrent.configuration.global_task_pool }
+              its(:reference) { should eq subject }
+              it 'returns ars' do
+                subject.ask!(:anything).should eq 'arg'
+              end
+            end
+          end
+        end
 
         it 'terminates on failed initialization' do
-          pending('may cause deadlock which prevents test run from completing.')
           a = AdHoc.spawn(name: :fail, logger: Concurrent.configuration.no_logger) { raise }
           a.ask(nil).wait.rejected?.should be_true
           a.terminated?.should be_true
         end
 
         it 'terminates on failed initialization and raises with spawn!' do
-          pending('may cause deadlock which prevents test run from completing.')
           expect do
             AdHoc.spawn!(name: :fail, logger: Concurrent.configuration.no_logger) { raise 'm' }
           end.to raise_error(StandardError, 'm')
         end
 
         it 'terminates on failed message processing' do
-          pending('may cause deadlock which prevents test run from completing.')
           a = AdHoc.spawn(name: :fail, logger: Concurrent.configuration.no_logger) { -> _ { raise } }
           a.ask(nil).wait.rejected?.should be_true
           a.terminated?.should be_true
@@ -120,11 +138,11 @@ module Concurrent
       describe 'messaging' do
         subject { AdHoc.spawn(:add) { c = 0; -> v { c = c + v } } }
         specify do
-          pending('may cause deadlock which prevents test run from completing.')
           subject.tell(1).tell(1)
           subject << 1 << 1
           subject.ask(0).value!.should eq 4
         end
+        after { terminate_actors subject }
       end
 
       describe 'children' do
@@ -141,23 +159,24 @@ module Concurrent
         end
 
         it 'has children set after a child is created' do
-          pending('may cause deadlock which prevents test run from completing.')
           child = parent.ask!(:child)
           parent.ask!(nil).should include(child)
           child.ask!(nil).should eq parent
+
+          terminate_actors parent, child
         end
       end
 
       describe 'envelope' do
         subject { AdHoc.spawn(:subject) { -> _ { envelope } } }
         specify do
-          pending('may cause deadlock which prevents test run from completing.')
           envelope = subject.ask!('a')
           envelope.should be_a_kind_of Envelope
           envelope.message.should eq 'a'
           envelope.ivar.should be_completed
           envelope.ivar.value.should eq envelope
           envelope.sender.should eq Thread.current
+          terminate_actors subject
         end
       end
 
@@ -176,13 +195,14 @@ module Concurrent
         end
 
         it 'terminates with all its children' do
-          pending('may cause deadlock which prevents test run from completing.')
           child = subject.ask! :child
           subject.terminated?.should be_false
           subject.ask(:terminate).wait
           subject.terminated?.should be_true
           child.terminated.wait
           child.terminated?.should be_true
+
+          terminate_actors subject, child
         end
       end