Add spawn! method which raises when Context initialization fails

opts[:initialized] is also added to be able to inject IVar to be set
after Context Initialization

Author: pitr-ch

lib/concurrent/actress.rb

@@ -7,8 +7,6 @@
 
 module Concurrent
 
-  # TODO broader description with examples
-  #
   # @example ping
   #   class Ping
   #     include Context
@@ -39,8 +37,7 @@ class Root
       include Context
       # to allow spawning of new actors, spawn needs to be called inside the parent Actor
       def on_message(message)
-        case message.first
-        when :spawn
+        if message.is_a?(Array) && message.first == :spawn
           spawn message[1], &message[2]
         else
           # ignore
@@ -52,6 +49,7 @@ def on_message(message)
     ROOT = Core.new(parent: nil, name: '/', class: Root).reference
 
     # @param block for actress_class instantiation
+    # @param args see {#spawn_optionify}
     def self.spawn(*args, &block)
       if Actress.current
         Core.new(spawn_optionify(*args).merge(parent: Actress.current), &block).reference
@@ -60,6 +58,11 @@ def self.spawn(*args, &block)
       end
     end
 
+    # as {#spawn} but it'll raise when Actor not initialized properly
+    def self.spawn!(*args, &block)
+      spawn(spawn_optionify(*args).merge(initialized: ivar = IVar.new), &block).tap { ivar.no_error! }
+    end
+
     # @overload spawn_optionify(actress_class, name, *args)
     #   @param [Context] actress_class to be spawned
     #   @param [String, Symbol] name of the instance, it's used to generate the path of the actor

lib/concurrent/actress/context.rb

@@ -20,6 +20,8 @@ module Context
       # @abstract override to define Actor's behaviour
       # @param [Object] message
       # @return [Object] a result which will be used to set the IVar supplied to Reference#ask
+      # @note self should not be returned (or sent to other actors), {#reference} should be used
+      #   instead
       def on_message(message)
         raise NotImplementedError
       end
@@ -71,12 +73,22 @@ def self.included(base)
       module ClassMethods
         # behaves as {Actress.spawn} but class_name is omitted
         def spawn(name_or_opts, *args, &block)
-          opts = if name_or_opts.is_a? Hash
-                   name_or_opts.merge class: self
-                 else
-                   { class: self, name: name_or_opts, args: args }
-                 end
-          Actress.spawn opts, &block
+          Actress.spawn spawn_optionify(name_or_opts, *args), &block
+        end
+
+        # behaves as {Actress.spawn!} but class_name is omitted
+        def spawn!(name_or_opts, *args, &block)
+          Actress.spawn! spawn_optionify(name_or_opts, *args), &block
+        end
+
+        private
+
+        def spawn_optionify(name_or_opts, *args)
+          if name_or_opts.is_a? Hash
+            name_or_opts.merge class: self
+          else
+            { class: self, name: name_or_opts, args: args }
+          end
         end
       end
     end

lib/concurrent/actress/core.rb

@@ -5,6 +5,8 @@ module Actress
 
     # Core of the actor
     # @api private
+    # @note devel: core should not block on anything, e.g. it cannot wait on children to terminate
+    #   that would eat up all threads in task pool and deadlock
     class Core
       include TypeCheck
       include Concurrent::Logging
@@ -16,6 +18,7 @@ class Core
       # @option opts [Context] actress_class a class to be instantiated defining Actor's behaviour
       # @option opts [Array<Object>] args arguments for actress_class instantiation
       # @option opts [Executor] executor, default is `Concurrent.configuration.global_task_pool`
+      # @option opts [IVar, nil] initialized, if present it'll be set or failed after {Context} initialization
       # @option opts [Proc, nil] logger a proc accepting (level, progname, message = nil, &block) params,
       #   can be used to hook actor instance to any logging system
       # @param [Proc] block for class instantiation
@@ -42,14 +45,17 @@ def initialize(opts = {}, &block)
 
         @actress_class = actress_class = Child! opts.fetch(:class), Context
         args           = opts.fetch(:args, [])
+        initialized    = Type! opts[:initialized], IVar, NilClass
 
         schedule_execution do
           begin
             @actress = actress_class.new *args, &block
             @actress.send :initialize_core, self
+            initialized.set true if initialized
           rescue => ex
             log ERROR, ex
             terminate!
+            initialized.fail ex if initialized
           end
         end
       end

spec/concurrent/actress_spec.rb

@@ -109,6 +109,12 @@ def assert condition
           a.terminated?.should be_true
         end
 
+        it 'terminates on failed initialization and raises with spawn!' do
+          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
           a = AdHoc.spawn(name: :fail, logger: Concurrent.configuration.no_logger) { -> _ { raise } }
           a.ask(nil).wait.rejected?.should be_true