ntl-actor 0.6.2 → 1.0.0.pre1

data/lib/actor/module/dependencies/assertions.rb

@@ -0,0 +1,23 @@
+module Actor
+  module Module
+    module Dependencies
+      module Assertions
+        def dependencies_configured?
+          address_configured? and reader_configured? and writer_configured?
+        end
+
+        def address_configured?
+          address.instance_of? Messaging::Address
+        end
+
+        def reader_configured?
+          reader.instance_of? Messaging::Reader
+        end
+
+        def writer_configured?
+          writer.instance_of? Messaging::Writer
+        end
+      end
+    end
+  end
+end

data/lib/actor/module/handler.rb

@@ -0,0 +1,31 @@
+module Actor
+  module Module
+    module Handler
+      def self.included cls
+        cls.class_exec do
+          extend Macro
+        end
+      end
+
+      def handle message
+        handler_method_name = MethodName.get message
+
+        return unless handler_method_name and respond_to? handler_method_name
+
+        handler_method = method handler_method_name
+
+        if handler_method.arity == 0
+          return_value = handler_method.()
+        else
+          return_value = handler_method.(message)
+        end
+
+        if Messaging::Message === return_value
+          writer.write return_value, address
+        end
+
+        return_value
+      end
+    end
+  end
+end

data/lib/actor/module/handler/macro.rb

@@ -0,0 +1,13 @@
+module Actor
+  module Module
+    module Handler
+      module Macro
+        def handle message_pattern, &handler
+          method_name = MethodName.get message_pattern
+
+          define_method method_name, &handler
+        end
+      end
+    end
+  end
+end

data/lib/actor/module/handler/method_name.rb

@@ -0,0 +1,13 @@
+module Actor
+  module Module
+    module Handler
+      module MethodName
+        def self.get message_pattern
+          message_name = Messaging::Message::Name.get message_pattern
+
+          :"handle_#{message_name}"
+        end
+      end
+    end
+  end
+end

data/lib/actor/module/include_assertions.rb

@@ -0,0 +1,18 @@
+module Actor
+  module Module
+    module IncludeAssertions
+      def self.call assertions_module, receiver
+        receiver.module_exec do
+          unless const_defined? :Assertions, false
+            receiver_assertions_module = ::Module.new
+            const_set :Assertions, receiver_assertions_module
+          end
+
+          receiver_assertions_module ||= const_get :Assertions
+
+          receiver_assertions_module.include assertions_module
+        end
+      end
+    end
+  end
+end

data/lib/actor/module/run_loop.rb

@@ -0,0 +1,19 @@
+module Actor
+  module Module
+    module RunLoop
+      def run_loop &supplemental_action
+        loop do
+          message = reader.read
+
+          handle message
+
+          supplemental_action.() if supplemental_action
+        end
+      end
+
+      def handle_stop(_=nil)
+        raise StopIteration
+      end
+    end
+  end
+end

data/lib/actor/module/start.rb

@@ -0,0 +1,27 @@
+module Actor
+  module Module
+    module Start
+      def start *arguments, include: nil, **keyword_arguments, &block
+        arguments << keyword_arguments if keyword_arguments.any?
+
+        actor, thread = Actor::Start.(self, *arguments, &block)
+
+        address = actor.address
+
+        if include
+          return_values = [address]
+
+          Array(include).each do |label|
+            argument = { :thread => thread, :actor => actor }.fetch label
+
+            return_values << argument
+          end
+
+          return return_values
+        else
+          return address
+        end
+      end
+    end
+  end
+end

data/lib/actor/module/suspend_resume.rb

@@ -0,0 +1,36 @@
+module Actor
+  module Module
+    module SuspendResume
+      def self.included cls
+        cls.class_exec do
+          prepend Configure
+          prepend Handle
+          prepend Initialize
+
+          IncludeAssertions.(Assertions, self)
+        end
+      end
+
+      attr_accessor :suspended
+      attr_writer :suspend_queue
+
+      def handle_suspend
+        self.suspended = true
+      end
+
+      def handle_resume
+        self.suspended = false
+
+        until suspend_queue.empty?
+          deferred_message = suspend_queue.deq
+
+          writer.write deferred_message, address
+        end
+      end
+
+      def suspend_queue
+        @suspend_queue ||= Messaging::Queue::Substitute.build
+      end
+    end
+  end
+end

data/lib/actor/module/suspend_resume/assertions.rb

@@ -0,0 +1,26 @@
+module Actor
+  module Module
+    module SuspendResume
+      module Assertions
+        def message_deferred? message=nil, wait: nil
+          non_block = wait == false
+
+          begin
+            msg = suspend_queue.deq true
+          rescue ThreadError
+          end
+
+          if message.nil?
+            msg ? true : false
+          else
+            msg == message
+          end
+        end
+
+        def suspended?
+          @suspended == true
+        end
+      end
+    end
+  end
+end

data/lib/actor/module/suspend_resume/configure.rb

@@ -0,0 +1,13 @@
+module Actor
+  module Module
+    module SuspendResume
+      module Configure
+        def configure
+          self.suspend_queue = Messaging::Queue.get
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/actor/module/suspend_resume/controls.rb

@@ -0,0 +1,17 @@
+module Actor
+  module Module
+    module SuspendResume
+      module Controls
+        def suspend!
+          self.suspended = true
+        end
+
+        def defer_message *messages
+          messages.each do |message|
+            suspend_queue.enq message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/actor/module/suspend_resume/handle.rb

@@ -0,0 +1,17 @@
+module Actor
+  module Module
+    module SuspendResume
+      module Handle
+        def handle message
+          self.suspended = false if Messages::Resume === message
+
+          if suspended
+            suspend_queue.enq message, true
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/actor/module/suspend_resume/initialize.rb

@@ -0,0 +1,13 @@
+module Actor
+  module Module
+    module SuspendResume
+      module Initialize
+        def initialize *;
+          @suspended = false
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/actor/start.rb

@@ -1,57 +1,57 @@
 module Actor
   class Start
-    attr_writer :supervisor_address
-    attr_writer :thread_class
-    attr_writer :writer
-
-    def self.build supervisor_address: nil
-      supervisor_address ||= Supervisor.address
-
-      instance = new
-      instance.supervisor_address = supervisor_address
-      instance.thread_class = Thread
-      Messaging::Write.configure instance
-      instance
-    end
+    include Messaging::Writer::Dependency
+
+    attr_reader :actor
+    attr_accessor :supervisor_address
 
-    def self.call actor, address, supervisor_address: nil
-      instance = build supervisor_address: supervisor_address
-      instance.(actor, address)
+    def initialize actor
+      @actor = actor
     end
 
-    def call actor, address
-      address ||= Address.build
+    def self.call actor_class, *arguments, &block
+      actor = Build.(actor_class, *arguments, &block)
 
-      start = Messages::Start.new
-      writer.(start, address)
+      instance = new actor
+      instance.writer = Messaging::Writer.new
+      instance.supervisor_address = Supervisor::Address::Get.()
+      instance.()
+    end
 
-      actor_started = Messages::ActorStarted.new address
-      writer.(actor_started, supervisor_address)
+    def call
+      writer.write Messages::Start, address
+
+      thread = Thread.new do
+        actor_started
 
-      thread = thread_class.new do
         begin
-          actor.start
+          actor.run_loop
+          actor_stopped
         rescue => error
-          actor_crashed = Messages::ActorCrashed.new error
-          writer.(actor_crashed, supervisor_address)
+          actor_crashed error
         end
       end
 
-      thread.name = actor.class.name
+      return actor, thread
+    end
 
-      thread
+    def actor_crashed error
+      actor_crashed = Messages::ActorCrashed.new error
+      writer.write actor_crashed, supervisor_address
     end
 
-    def supervisor_address
-      @supervisor_address ||= Address::None
+    def actor_started
+      actor_started = Messages::ActorStarted.new address
+      writer.write actor_started, supervisor_address
     end
 
-    def thread_class
-      @thread_class ||= Substitutes::Thread
+    def actor_stopped
+      actor_stopped = Messages::ActorStopped.new address
+      writer.write actor_stopped, supervisor_address
     end
 
-    def writer
-      @writer ||= Messaging::Write::Substitute.new
+    def address
+      actor.address
     end
   end
 end

data/lib/actor/supervisor.rb

@@ -1,118 +1,107 @@
 module Actor
   class Supervisor
-    include Actor
+    include Module::Dependencies
+    include Module::Handler
+    include Module::RunLoop
 
-    attr_reader :assembly
-    attr_writer :broadcast_address
+    include Messaging::Publisher::Dependency
+
+    attr_accessor :actor_count
+    attr_writer :assembly_block
     attr_accessor :error
     attr_writer :thread_group
-    attr_writer :router_address
 
-    def initialize &assembly
-      @assembly = assembly
+    def initialize
+      @actor_count = 0
     end
 
-    class << self
-      attr_accessor :address
-
-      def run &assembly
-        self.address = Address.build
-
-        _, thread = start include: %i(thread), &assembly
+    def self.build &assembly_block
+      instance = new
+      instance.assembly_block = assembly_block
+      instance.configure
+      instance
+    end
 
-        thread.join
-      end
+    def self.start &assembly_block
+      thread = Thread.new do
+        thread_group = Thread.current.group
 
-      def build &assembly
-        instance = new &assembly
-        instance.configure
-        instance
-      end
+        prior_thread_count = thread_group.list.count
 
-      def start include: nil, &assembly
-        instance = build &assembly
+        instance = build &assembly_block
 
-        start = Messages::Start.new
-        instance.writer.(start, address)
+        thread_count = thread_group.list.count
 
-        thread = Thread.new do
-          instance.start
+        unless thread_count > prior_thread_count
+          raise NoActorsStarted, "Assembly block must start at least one actor"
         end
 
-        thread.name = "Supervisor"
-
-        Destructure.(address, include, { :thread => thread, :actor => instance })
+        instance.run_loop
       end
+
+      thread.join
     end
 
-    handle :start do
-      thread_group.add Thread.current
-      thread_group.enclose
+    def configure
+      self.thread_group = Thread.current.group
 
-      assembly.(self) if assembly
+      Address::Put.(address)
 
-      :continue
-    end
+      assembly_block.(self)
 
-    handle :continue do
-      if actor_threads.empty?
-        raise error if error
+      self.publisher = Messaging::Publisher.build
+    end
 
-        :stop
-      else
-        sleep Duration.millisecond
+    handle Messages::ActorStarted do |message|
+      publisher.register message.address
 
-        :continue
-      end
+      self.actor_count += 1
     end
 
-    handle :actor_started do |message|
-      reader = Messaging::Read.build broadcast_address
-      output_address = message.actor_address
+    handle Messages::ActorStopped do |message|
+      publisher.unregister message.address
 
-      add_route = Router::AddRoute.new reader, output_address
+      self.actor_count -= 1
 
-      writer.(add_route, router_address)
+      if actor_count.zero?
+        Messages::Stop
+      end
     end
 
-    handle :actor_crashed do |message|
+    handle Messages::ActorCrashed do |message|
       self.error ||= message.error
 
-      :shutdown
-    end
-
-    handle :shutdown do
-      stop = Messages::Stop.new
+      self.actor_count -= 1
 
-      writer.(stop, broadcast_address)
-      writer.(stop, router_address)
+      Messages::Shutdown
+    end
 
-      :continue
+    handle Messages::Shutdown do
+      publisher.publish Messages::Stop
     end
 
-    def actor_threads
-      list = thread_group.list
-      list.delete Thread.current
-      list
+    handle Messages::Suspend do |message|
+      publisher.publish message
     end
 
-    def configure
-      self.broadcast_address = Address.build
-      self.router_address = Router.start
-      self.thread_group = ThreadGroup.new
-      self.address = self.class.address
+    handle Messages::Resume do |message|
+      publisher.publish message
     end
 
-    def broadcast_address
-      @broadcast_address ||= Address::None
+    handle Messages::Stop do |stop|
+      raise error if error
+
+      super stop
     end
 
-    def router_address
-      @router_address ||= Address::None
+    def assembly_block
+      @assembly_block ||= proc { }
     end
 
     def thread_group
-      @thread_group ||= Substitutes::ThreadGroup.new
+      @thread_group ||= ThreadGroup::Default
     end
+
+    NoActorsStarted = Class.new StandardError
   end
 end