concurrent-ruby-edge 0.1.0.pre2

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

@@ -0,0 +1,51 @@
+require 'concurrent/concern/logging'
+
+module Concurrent
+  module Actor
+    module Behaviour
+      class Abstract
+        include TypeCheck
+        include InternalDelegations
+        include Concern::Logging
+
+        attr_reader :core, :subsequent
+
+        def initialize(core, subsequent, core_options)
+          @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(public, event)
+          subsequent.on_event public, event if subsequent
+        end
+
+        # broadcasts event to all behaviours and context
+        # @see #on_event
+        # @see AbstractContext#on_event
+        def broadcast(public, event)
+          core.broadcast(public, event)
+        end
+
+        def reject_envelope(envelope)
+          envelope.reject! ActorTerminated.new(reference)
+          dead_letter_routing << envelope unless envelope.future
+          log DEBUG, "rejected #{envelope.message} from #{envelope.sender_path}"
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,21 @@
+module Concurrent
+  module Actor
+    module Behaviour
+
+      # Accepts `:await` messages. Which allows to wait on Actor to process all previously send
+      # messages.
+      #
+      #     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

@@ -0,0 +1,56 @@
+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 effectively means that messages handled by
+      # behaviours before buffer have higher priority and they can be processed
+      # before messages arriving into buffer. This allows for the processing of
+      # internal actor messages like (`:link`, `:supervise`) first.
+      class Buffer < Abstract
+        def initialize(core, subsequent, core_options)
+          super core, subsequent, core_options
+          @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(public, event)
+          event_name, _ = event
+          case event_name
+          when :terminated, :restarted
+            @buffer.each { |envelope| reject_envelope envelope }
+            @buffer.clear
+          end
+          super public, event_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,17 @@
+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(public, event)
+          context.on_event(event)
+          super public, event
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Concurrent
+  module Actor
+    module Behaviour
+      # TODO track what is linked, clean when :terminated
+      #   send :linked/:unlinked messages back to build the array of linked actors
+
+      # Links the actor to other actors and sends actor's events to them,
+      # like: `:terminated`, `:paused`, `:resumed`, errors, etc.
+      # Linked actor needs to handle those messages.
+      #
+      #     listener = AdHoc.spawn name: :listener do
+      #       lambda do |message|
+      #         case message
+      #         when Reference
+      #           if message.ask!(:linked?)
+      #             message << :unlink
+      #           else
+      #             message << :link
+      #           end
+      #         else
+      #           puts "got event #{message.inspect} from #{envelope.sender}"
+      #         end
+      #       end
+      #     end
+      #
+      #     an_actor = AdHoc.spawn name: :an_actor, supervise: true, behaviour_definition: Behaviour.restarting_behaviour_definition do
+      #       lambda { |message| raise 'failed'}
+      #     end
+      #
+      #     # link the actor
+      #     listener.ask(an_actor).wait
+      #     an_actor.ask(:fail).wait
+      #     # unlink the actor
+      #     listener.ask(an_actor).wait
+      #     an_actor.ask(:fail).wait
+      #     an_actor << :terminate!
+      #
+      # produces only two events, other events happened after unlinking
+      #
+      #     got event #<RuntimeError: failed> from #<Concurrent::Actor::Reference /an_actor (Concurrent::Actor::Utils::AdHoc)>
+      #     got event :reset from #<Concurrent::Actor::Reference /an_actor (Concurrent::Actor::Utils::AdHoc)>
+      class Linking < Abstract
+        def initialize(core, subsequent, core_options)
+          super core, subsequent, core_options
+          @linked = Set.new
+          @linked.add Actor.current if core_options[:link] != false
+        end
+
+        def on_envelope(envelope)
+          case envelope.message
+          when :link
+            link envelope.sender
+          when :unlink
+            unlink envelope.sender
+          when :linked?
+            @linked.include? envelope.sender
+          when :linked
+            @linked.to_a
+          else
+            pass envelope
+          end
+        end
+
+        def link(ref)
+          @linked.add(ref)
+          true
+        end
+
+        def unlink(ref)
+          @linked.delete(ref)
+          true
+        end
+
+        def on_event(public, event)
+          event_name, _ = event
+          @linked.each { |a| a << event } if public
+          @linked.clear if event_name == :terminated
+          super public, event
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+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.
+      # @note TODO missing example
+      class Pausing < Abstract
+        def initialize(core, subsequent, core_options)
+          super core, subsequent, core_options
+          @paused   = false
+          @deferred = []
+        end
+
+        def paused?
+          @paused
+        end
+
+        def on_envelope(envelope)
+          case envelope.message
+          when :pause!
+            pause!
+          when :paused?
+            paused?
+          when :resume!
+            resume!
+          when :reset!
+            reset!
+          when :restart!
+            restart!
+          else
+            if paused?
+              @deferred << envelope
+              MESSAGE_PROCESSED
+            else
+              pass envelope
+            end
+          end
+        end
+
+        def pause!(error = nil)
+          do_pause
+          broadcast true, error || :paused
+          true
+        end
+
+        def resume!
+          return false unless paused?
+          do_resume
+          broadcast(true, :resumed)
+          true
+        end
+
+        def reset!
+          return false unless paused?
+          broadcast(false, :resetting)
+          do_reset
+          broadcast(true, :reset)
+          true
+        end
+
+        def restart!
+          return false unless paused?
+          broadcast(false, :restarting)
+          do_restart
+          broadcast(true, :restarted)
+          true
+        end
+
+        def on_event(public, event)
+          event_name, _ = event
+          reject_deferred if event_name == :terminated
+          super public, event
+        end
+
+        private
+
+        def do_pause
+          @paused = true
+          nil
+        end
+
+        def do_resume
+          @paused = false
+          reschedule_deferred
+          nil
+        end
+
+        def do_reset
+          rebuild_context
+          do_resume
+          reschedule_deferred
+          nil
+        end
+
+        def do_restart
+          rebuild_context
+          reject_deferred
+          do_resume
+          nil
+        end
+
+        def rebuild_context
+          core.allocate_context
+          core.build_context
+          nil
+        end
+
+        def reschedule_deferred
+          @deferred.each { |envelope| core.schedule_execution { core.process_envelope envelope } }
+          @deferred.clear
+        end
+
+        def reject_deferred
+          @deferred.each { |envelope| reject_envelope envelope }
+          @deferred.clear
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+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

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

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

@@ -0,0 +1,39 @@
+module Concurrent
+  module Actor
+    module Behaviour
+
+      # Handles supervised actors. Handle configures what to do with failed child: :terminate!, :resume!, :reset!,
+      # or :restart!. Strategy sets :one_for_one (restarts just failed actor) or :one_for_all (restarts all child actors).
+      # @note TODO missing example
+      # @note this will change in next version to support supervision trees better
+      class Supervising < Abstract
+        def initialize(core, subsequent, core_options, handle, strategy)
+          super core, subsequent, core_options
+          @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