concurrent-ruby 0.8.0 → 0.9.0.pre2

data/lib/concurrent/actor/behaviour/abstract.rb

@@ -1,48 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-      class Abstract
-        include TypeCheck
-        include InternalDelegations
-
-        attr_reader :core, :subsequent
-
-        def initialize(core, subsequent)
-          @core       = Type! core, Core
-          @subsequent = Type! subsequent, Abstract, NilClass
-        end
-
-        # override to add extra behaviour
-        # @note super needs to be called not to break the chain
-        def on_envelope(envelope)
-          pass envelope
-        end
-
-        # @param [Envelope] envelope to pass to {#subsequent} behaviour
-        def pass(envelope)
-          subsequent.on_envelope envelope
-        end
-
-        # override to add extra behaviour
-        # @note super needs to be called not to break the chain
-        def on_event(event)
-          subsequent.on_event event if subsequent
-        end
-
-        # broadcasts event to all behaviours and context
-        # @see #on_event
-        # @see AbstractContext#on_event
-        def broadcast(event)
-          core.broadcast(event)
-        end
-
-        def reject_envelope(envelope)
-          envelope.reject! ActorTerminated.new(reference)
-          dead_letter_routing << envelope unless envelope.ivar
-          log Logging::DEBUG, "rejected #{envelope.message} from #{envelope.sender_path}"
-        end
-      end
-    end
-  end
-end
-

data/lib/concurrent/actor/behaviour/awaits.rb

@@ -1,21 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-
-      # Handles `:await` messages. Which allows to wait on Actor to process all previously send
-      # messages.
-      # @example
-      #   actor << :a << :b
-      #   actor.ask(:await).wait # blocks until :a and :b are processed
-      class Awaits < Abstract
-        def on_envelope(envelope)
-          if envelope.message == :await
-            true
-          else
-            pass envelope
-          end
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/behaviour/buffer.rb

@@ -1,54 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-
-      # Any message reaching this behaviour is buffered. Only one message is is scheduled
-      # at any given time. Others are kept in buffer until another one can be scheduled.
-      # This effective means that messages handled by behaviours before buffer have higher priority
-      # and they can be processed before messages arriving into buffer. This allows to
-      # process internal actor messages like (`:link`, `:supervise`) processed first.
-      class Buffer < Abstract
-        def initialize(core, subsequent)
-          super core, subsequent
-          @buffer                     = []
-          @receive_envelope_scheduled = false
-        end
-
-        def on_envelope(envelope)
-          @buffer.push envelope
-          process_envelopes?
-          MESSAGE_PROCESSED
-        end
-
-        # Ensures that only one envelope processing is scheduled with #schedule_execution,
-        # this allows other scheduled blocks to be executed before next envelope processing.
-        # Simply put this ensures that Core is still responsive to internal calls (like add_child)
-        # even though the Actor is flooded with messages.
-        def process_envelopes?
-          unless @buffer.empty? || @receive_envelope_scheduled
-            @receive_envelope_scheduled = true
-            process_envelope
-          end
-        end
-
-        def process_envelope
-          envelope = @buffer.shift
-          return nil unless envelope
-          pass envelope
-        ensure
-          @receive_envelope_scheduled = false
-          core.schedule_execution { process_envelopes? }
-        end
-
-        def on_event(event)
-          case event
-          when :terminated, :restarted
-            @buffer.each { |envelope| reject_envelope envelope }
-            @buffer.clear
-          end
-          super event
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/behaviour/errors_on_unknown_message.rb

@@ -1,12 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-      # Simply fails when message arrives here. It's usually the last behaviour.
-      class ErrorsOnUnknownMessage < Abstract
-        def on_envelope(envelope)
-          raise UnknownMessage, envelope
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/behaviour/executes_context.rb

@@ -1,18 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-      # Delegates messages and events to {AbstractContext} instance
-      class ExecutesContext < Abstract
-        def on_envelope(envelope)
-          context.on_envelope envelope
-        end
-
-        def on_event(event)
-          context.on_event(event)
-          core.log Logging::DEBUG, "event: #{event.inspect}"
-          super event
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/behaviour/linking.rb

@@ -1,45 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-
-      # Links the actor to other actors and sends actor's events to them,
-      # like: `:terminated`, `:paused`, errors, etc
-      # TODO example
-      class Linking < Abstract
-        def initialize(core, subsequent)
-          super core, subsequent
-          @linked = Set.new
-        end
-
-        def on_envelope(envelope)
-          case envelope.message
-          when :link
-            link envelope.sender
-          when :unlink
-            unlink envelope.sender
-          when :linked?
-            @linked.include? envelope.sender
-          else
-            pass envelope
-          end
-        end
-
-        def link(ref)
-          @linked.add(ref)
-          true
-        end
-
-        def unlink(ref)
-          @linked.delete(ref)
-          true
-        end
-
-        def on_event(event)
-          @linked.each { |a| a << event }
-          @linked.clear if event == :terminated
-          super event
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/behaviour/pausing.rb

@@ -1,77 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-
-      # Allows to pause actors on errors.
-      # When paused all arriving messages are collected and processed after the actor
-      # is resumed or reset. Resume will simply continue with next message.
-      # Reset also reinitialized context.
-      # TODO example
-      class Pausing < Abstract
-        def initialize(core, subsequent)
-          super core, subsequent
-          @paused = false
-          @buffer = []
-        end
-
-        def on_envelope(envelope)
-          case envelope.message
-          when :pause!
-            pause!
-          when :resume!
-            resume!
-          when :reset!
-            reset!
-          when :restart!
-            restart!
-          else
-            if @paused
-              @buffer << envelope
-              MESSAGE_PROCESSED
-            else
-              pass envelope
-            end
-          end
-        end
-
-        def pause!(error = nil)
-          @paused = true
-          broadcast(error || :paused)
-          true
-        end
-
-        def resume!(broadcast = true)
-          @paused = false
-          broadcast(:resumed) if broadcast
-          true
-        end
-
-        def reset!(broadcast = true)
-          core.allocate_context
-          core.build_context
-          resume!(false)
-          broadcast(:reset) if broadcast
-          true
-        end
-
-        def restart!
-          reset! false
-          broadcast(:restarted)
-          true
-        end
-
-        def on_event(event)
-          case event
-          when :terminated, :restarted
-            @buffer.each { |envelope| reject_envelope envelope }
-            @buffer.clear
-          when :resumed, :reset
-            @buffer.each { |envelope| core.schedule_execution { pass envelope } }
-            @buffer.clear
-          end
-          super event
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/behaviour/removes_child.rb

@@ -1,16 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-      # Removes terminated children.
-      class RemovesChild < Abstract
-        def on_envelope(envelope)
-          if envelope.message == :remove_child
-            core.remove_child envelope.sender
-          else
-            pass envelope
-          end
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/behaviour/sets_results.rb

@@ -1,36 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-      # Collects returning value and sets the IVar in the {Envelope} or error on failure.
-      class SetResults < Abstract
-        attr_reader :error_strategy
-
-        def initialize(core, subsequent, error_strategy)
-          super core, subsequent
-          @error_strategy = Match! error_strategy, :just_log, :terminate!, :pause!
-        end
-
-        def on_envelope(envelope)
-          result = pass envelope
-          if result != MESSAGE_PROCESSED && !envelope.ivar.nil?
-            envelope.ivar.set result
-          end
-          nil
-        rescue => error
-          log Logging::ERROR, error
-          case error_strategy
-          when :terminate!
-            terminate!
-          when :pause!
-            behaviour!(Pausing).pause!(error)
-          when :just_log
-            # nothing
-          else
-            raise
-          end
-          envelope.ivar.fail error unless envelope.ivar.nil?
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/behaviour/supervised.rb

@@ -1,59 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-
-      # Sets and holds the supervisor of the actor if any. There is at most one supervisor
-      # for each actor. Each supervisor is automatically linked. Messages:
-      # `:pause!, :resume!, :reset!, :restart!` are accepted only from supervisor.
-      class Supervised < Abstract
-        attr_reader :supervisor
-
-        def initialize(core, subsequent)
-          super core, subsequent
-          @supervisor = nil
-        end
-
-        def on_envelope(envelope)
-          case envelope.message
-          when :supervise
-            supervise envelope.sender
-          when :supervisor
-            supervisor
-          when :un_supervise
-            un_supervise envelope.sender
-          when :pause!, :resume!, :reset!, :restart!
-            # allow only supervisor to control the actor
-            if @supervisor == envelope.sender
-              pass envelope
-            else
-              false
-            end
-          else
-            pass envelope
-          end
-        end
-
-        def supervise(ref)
-          @supervisor = ref
-          behaviour!(Linking).link ref
-          true
-        end
-
-        def un_supervise(ref)
-          if @supervisor == ref
-            behaviour!(Linking).unlink ref
-            @supervisor = nil
-            true
-          else
-            false
-          end
-        end
-
-        def on_event(event)
-          @supervisor = nil if event == :terminated
-          super event
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/behaviour/supervising.rb

@@ -1,34 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-      class Supervising < Abstract
-        def initialize(core, subsequent, handle, strategy)
-          super core, subsequent
-          @handle   = Match! handle, :terminate!, :resume!, :reset!, :restart!
-          @strategy = case @handle
-                      when :terminate!
-                        Match! strategy, nil
-                      when :resume!
-                        Match! strategy, :one_for_one
-                      when :reset!, :restart!
-                        Match! strategy, :one_for_one, :one_for_all
-                      end
-        end
-
-        def on_envelope(envelope)
-          case envelope.message
-          when Exception, :paused
-            receivers = if @strategy == :one_for_all
-                          children
-                        else
-                          [envelope.sender]
-                        end
-            receivers.each { |ch| ch << @handle }
-          else
-            pass envelope
-          end
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/behaviour/terminates_children.rb

@@ -1,13 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-      # Terminates all children when the actor terminates.
-      class TerminatesChildren < Abstract
-        def on_event(event)
-          children.map { |ch| ch.ask :terminate! }.each(&:wait) if event == :terminated
-          super event
-        end
-      end
-    end
-  end
-end