concurrent-ruby-edge 0.1.0.pre2

data/lib/concurrent/actor/default_dead_letter_handler.rb

@@ -0,0 +1,9 @@
+module Concurrent
+  module Actor
+    class DefaultDeadLetterHandler < RestartingContext
+      def on_message(dead_letter)
+        log INFO, "got dead letter #{dead_letter.inspect}"
+      end
+    end
+  end
+end

data/lib/concurrent/actor/envelope.rb

@@ -0,0 +1,41 @@
+module Concurrent
+  module Actor
+    class Envelope
+      include TypeCheck
+
+      # @!attribute [r] message
+      #   @return [Object] a message
+      # @!attribute [r] future
+      #   @return [Edge::Future] a future 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, :future, :sender, :address
+
+      def initialize(message, future, sender, address)
+        @message = message
+        @future  = Type! future, Edge::CompletableFuture, NilClass
+        @sender  = Type! sender, Reference, Thread
+        @address = Type! address, Reference
+      end
+
+      def sender_path
+        if sender.is_a? Reference
+          sender.path
+        else
+          sender.to_s
+        end
+      end
+
+      def address_path
+        address.path
+      end
+
+      def reject!(error)
+        future.fail error unless future.nil?
+      end
+    end
+  end
+end

data/lib/concurrent/actor/errors.rb

@@ -0,0 +1,27 @@
+module Concurrent
+  module Actor
+    Error = Class.new(StandardError)
+
+    class ActorTerminated < Error
+      include TypeCheck
+
+      attr_reader :reference
+
+      def initialize(reference)
+        @reference = Type! reference, Reference
+        super reference.path
+      end
+    end
+
+    class UnknownMessage < Error
+      include TypeCheck
+
+      attr_reader :envelope
+
+      def initialize(envelope)
+        @envelope = Type! envelope, Envelope
+        super envelope.message.inspect
+      end
+    end
+  end
+end

data/lib/concurrent/actor/internal_delegations.rb

@@ -0,0 +1,59 @@
+module Concurrent
+  module Actor
+    module InternalDelegations
+      include PublicDelegations
+
+      # @see Core#children
+      def children
+        core.children
+      end
+
+      # @see Termination#terminate!
+      def terminate!(reason = nil)
+        behaviour!(Behaviour::Termination).terminate!(reason)
+      end
+
+      # @see Termination#terminated?
+      def terminated?
+        behaviour!(Behaviour::Termination).terminated?
+      end
+
+      # @see Termination#reason
+      def reason
+        behaviour!(Behaviour::Termination).reason
+      end
+
+      # delegates to core.log
+      # @see Logging#log
+      def log(level, message = nil, &block)
+        core.log(level, message, &block)
+      end
+
+      # @see AbstractContext#dead_letter_routing
+      def dead_letter_routing
+        context.dead_letter_routing
+      end
+
+      def redirect(reference, envelope = self.envelope)
+        reference.message(envelope.message, envelope.future)
+        Behaviour::MESSAGE_PROCESSED
+      end
+
+      # @return [AbstractContext]
+      def context
+        core.context
+      end
+
+      # see Core#behaviour
+      def behaviour(behaviour_class)
+        core.behaviour(behaviour_class)
+      end
+
+      # see Core#behaviour!
+      def behaviour!(behaviour_class)
+        core.behaviour!(behaviour_class)
+      end
+
+    end
+  end
+end

data/lib/concurrent/actor/public_delegations.rb

@@ -0,0 +1,40 @@
+module Concurrent
+  module Actor
+
+    # Provides publicly expose-able methods from {Core}.
+    module PublicDelegations
+      # @see Core#name
+      def name
+        core.name
+      end
+
+      # @see Core#path
+      def path
+        core.path
+      end
+
+      # @see Core#parent
+      def parent
+        core.parent
+      end
+
+      # @see Core#reference
+      def reference
+        core.reference
+      end
+
+      # @see Core#executor
+      def executor
+        core.executor
+      end
+
+      # @see Core#context_class
+      def context_class
+        core.context_class
+      end
+
+      alias_method :ref, :reference
+      alias_method :actor_class, :context_class
+    end
+  end
+end

data/lib/concurrent/actor/reference.rb

@@ -0,0 +1,106 @@
+module Concurrent
+  module Actor
+
+    # {Reference} is public interface of Actor instances. It is used for sending messages and can
+    # be freely passed around the application. It also provides some basic information about the actor,
+    # see {PublicDelegations}.
+    #
+    #     AdHoc.spawn('printer') { -> message { puts message } }
+    #     # => #<Concurrent::Actor::Reference:0x7fd0d2883218 /printer (Concurrent::Actor::Utils::AdHoc)>
+    #     #                                   ^object_id     ^path     ^context class
+    class Reference
+      include TypeCheck
+      include PublicDelegations
+
+      attr_reader :core
+      private :core
+
+      # @!visibility private
+      def initialize(core)
+        @core = Type! core, Core
+      end
+
+      # Sends the message asynchronously to the actor and immediately returns
+      # `self` (the reference) allowing to chain message telling.
+      # @param [Object] message
+      # @return [Reference] self
+      # @example
+      #   printer = AdHoc.spawn('printer') { -> message { puts message } }
+      #   printer.tell('ping').tell('pong')
+      #   printer << 'ping' << 'pong'
+      #   # => 'ping'\n'pong'\n'ping'\n'pong'\n
+      def tell(message)
+        message message, nil
+      end
+
+      alias_method :<<, :tell
+
+      # @note it's a good practice to use tell whenever possible. Ask should be used only for
+      # testing and when it returns very shortly. It can lead to deadlock if all threads in
+      # global_io_executor will block on while asking. It's fine to use it form outside of actors and
+      # global_io_executor.
+      #
+      # @note it's a good practice to use {#tell} whenever possible. Results can be send back with other messages.
+      #   Ask should be used only for testing and when it returns very shortly. It can lead to deadlock if all threads in
+      #   global_io_executor will block on while asking. It's fine to use it form outside of actors and
+      #   global_io_executor.
+      # @param [Object] message
+      # @param [Edge::Future] future to be fulfilled be message's processing result
+      # @return [Edge::Future] supplied future
+      # @example
+      #   adder = AdHoc.spawn('adder') { -> message { message + 1 } }
+      #   adder.ask(1).value # => 2
+      #   adder.ask(nil).wait.reason # => #<NoMethodError: undefined method `+' for nil:NilClass>
+      def ask(message, future = Concurrent.future)
+        message message, future
+      end
+
+      # Sends the message synchronously and blocks until the message
+      # is processed. Raises on error.
+      #
+      # @note it's a good practice to use {#tell} whenever possible. Results can be send back with other messages.
+      #   Ask should be used only for testing and when it returns very shortly. It can lead to deadlock if all threads in
+      #   global_io_executor will block on while asking. It's fine to use it form outside of actors and
+      #   global_io_executor.
+      # @param [Object] message
+      # @param [Edge::Future] future to be fulfilled be message's processing result
+      # @return [Object] message's processing result
+      # @raise [Exception] future.reason if future is #failed?
+      # @example
+      #   adder = AdHoc.spawn('adder') { -> message { message + 1 } }
+      #   adder.ask!(1) # => 2
+      def ask!(message, future = Concurrent.future)
+        ask(message, future).value!
+      end
+
+      def map(messages)
+        messages.map { |m| self.ask(m) }
+      end
+
+      # behaves as {#tell} when no future and as {#ask} when future
+      def message(message, future = nil)
+        core.on_envelope Envelope.new(message, future, Actor.current || Thread.current, self)
+        return future ? future.hide_completable : self
+      end
+
+      # @see AbstractContext#dead_letter_routing
+      def dead_letter_routing
+        core.dead_letter_routing
+      end
+
+      def to_s
+        "#<#{self.class}:0x#{'%x' % (object_id << 1)} #{path} (#{actor_class})>"
+      end
+
+      alias_method :inspect, :to_s
+
+      def ==(other)
+        Type? other, self.class and other.send(:core) == core
+      end
+
+      # to avoid confusion with Kernel.spawn
+      undef_method :spawn
+    end
+
+  end
+end

data/lib/concurrent/actor/root.rb

@@ -0,0 +1,37 @@
+module Concurrent
+  module Actor
+    # implements the root actor
+    class Root < AbstractContext
+
+      def initialize
+        # noinspection RubyArgCount
+        @dead_letter_router = Core.new(parent:    reference,
+                                       class:     DefaultDeadLetterHandler,
+                                       supervise: true,
+                                       name:      :default_dead_letter_handler).reference
+      end
+
+      # to allow spawning of new actors, spawn needs to be called inside the parent Actor
+      def on_message(message)
+        case
+        when message.is_a?(Array) && message.first == :spawn
+          Actor.spawn message[1], &message[2]
+        when message == :dead_letter_routing
+          @dead_letter_router
+        else
+          # ignore
+        end
+      end
+
+      def dead_letter_routing
+        @dead_letter_router
+      end
+
+      def behaviour_definition
+        [*Behaviour.base(:just_log),
+         *Behaviour.supervising,
+         *Behaviour.user_messages]
+      end
+    end
+  end
+end

data/lib/concurrent/actor/type_check.rb

@@ -0,0 +1,48 @@
+module Concurrent
+  module Actor
+
+    # taken from Algebrick
+    # supplies type-checking helpers whenever included
+    module TypeCheck
+
+      def Type?(value, *types)
+        types.any? { |t| value.is_a? t }
+      end
+
+      def Type!(value, *types)
+        Type?(value, *types) or
+            TypeCheck.error(value, 'is not', types)
+        value
+      end
+
+      def Match?(value, *types)
+        types.any? { |t| t === value }
+      end
+
+      def Match!(value, *types)
+        Match?(value, *types) or
+            TypeCheck.error(value, 'is not matching', types)
+        value
+      end
+
+      def Child?(value, *types)
+        Type?(value, Class) &&
+            types.any? { |t| value <= t }
+      end
+
+      def Child!(value, *types)
+        Child?(value, *types) or
+            TypeCheck.error(value, 'is not child', types)
+        value
+      end
+
+      private
+
+      def self.error(value, message, types)
+        raise TypeError,
+              "Value (#{value.class}) '#{value}' #{message} any of: #{types.join('; ')}."
+      end
+    end
+  end
+end
+

data/lib/concurrent/actor/utils.rb

@@ -0,0 +1,10 @@
+module Concurrent
+  module Actor
+    module Utils
+      require 'concurrent/actor/utils/ad_hoc'
+      require 'concurrent/actor/utils/broadcast'
+      require 'concurrent/actor/utils/balancer'
+      require 'concurrent/actor/utils/pool'
+    end
+  end
+end

data/lib/concurrent/actor/utils/ad_hoc.rb

@@ -0,0 +1,27 @@
+module Concurrent
+  module Actor
+    module Utils
+
+      module AsAdHoc
+        def initialize(*args, &initializer)
+          @on_message = Type! initializer.call(*args), Proc
+        end
+
+        def on_message(message)
+          instance_exec message, &@on_message
+        end
+      end
+
+      # Allows quick creation of actors with behaviour defined by blocks.
+      # @example ping
+      #   AdHoc.spawn :forward, an_actor do |where|
+      #     # this block has to return proc defining #on_message behaviour
+      #     -> message { where.tell message  }
+      #   end
+      # @note TODO remove in favor of the module
+      class AdHoc < Context
+        include AsAdHoc
+      end
+    end
+  end
+end

data/lib/concurrent/actor/utils/balancer.rb

@@ -0,0 +1,43 @@
+module Concurrent
+  module Actor
+    module Utils
+
+      # Distributes messages between subscribed actors. Each actor'll get only one message then
+      # it's unsubscribed. The actor needs to resubscribe when it's ready to receive next message.
+      # It will buffer the messages if there is no worker registered.
+      # @see Pool
+      class Balancer < RestartingContext
+
+        def initialize
+          @receivers = []
+          @buffer    = []
+        end
+
+        def on_message(message)
+          command, who = message
+          case command
+          when :subscribe
+            @receivers << (who || envelope.sender)
+            distribute
+            true
+          when :unsubscribe
+            @receivers.delete(who || envelope.sender)
+            true
+          when :subscribed?
+            @receivers.include?(who || envelope.sender)
+          else
+            @buffer << envelope
+            distribute
+            Behaviour::MESSAGE_PROCESSED
+          end
+        end
+
+        def distribute
+          while !@receivers.empty? && !@buffer.empty?
+            redirect @receivers.shift, @buffer.shift
+          end
+        end
+      end
+    end
+  end
+end