Add atomic linking

`AnActor.spawn name: 'an', link: true` will be linked before any
message is received.

Author: pitr-ch

lib/concurrent/actor/core.rb

@@ -33,6 +33,7 @@ class Core
       # @option opts [Context] actor_class a class to be instantiated defining Actor's behaviour
       # @option opts [Array<Object>] args arguments for actor_class instantiation
       # @option opts [Executor] executor, default is `Concurrent.configuration.global_task_pool`
+      # @option opts [true, false] link, atomically link the actor to its parent
       # @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
@@ -69,11 +70,18 @@ def initialize(opts = {}, &block)
         args        = opts.fetch(:args, [])
         initialized = Type! opts[:initialized], IVar, NilClass
 
+        messages = []
+        messages << :link if opts[:link]
+
         schedule_execution do
           begin
             @context.send :initialize_core, self
             @context.send :initialize, *args, &block
 
+            messages.each do |message|
+              handle_envelope Envelope.new(message, nil, parent, reference)
+            end
+
             initialized.set true if initialized
           rescue => ex
             log ERROR, ex
@@ -117,10 +125,7 @@ def remove_child(child)
       # can be called from other alternative Reference implementations
       # @param [Envelope] envelope
       def on_envelope(envelope)
-        schedule_execution do
-          log DEBUG, "received #{envelope.message.inspect} from #{envelope.sender}"
-          @first_behaviour.on_envelope envelope
-        end
+        schedule_execution { handle_envelope envelope }
         nil
       end
 
@@ -178,6 +183,13 @@ def behaviour(klass)
       def behaviour!(klass)
         @behaviours.fetch klass
       end
+
+      private
+
+      def handle_envelope(envelope)
+        log DEBUG, "received #{envelope.message.inspect} from #{envelope.sender}"
+        @first_behaviour.on_envelope envelope
+      end
     end
   end
 end

spec/concurrent/actor_spec.rb

@@ -246,15 +246,33 @@ def on_message(message)
 
       it 'links' do
         queue   = Queue.new
-        failure = AdHoc.spawn(:failure) { -> m { m } }
+        failure = nil
         # failure = AdHoc.spawn(:failure) { -> m { terminate! } } # FIXME this leads to weird message processing ordering
         monitor = AdHoc.spawn(:monitor) do
+          failure = AdHoc.spawn(:failure) { -> m { m } }
           failure << :link
           -> m { queue << [m, envelope.sender] }
         end
         failure << :hehe
         failure << :terminate!
         expect(queue.pop).to eq [:terminated, failure]
+
+        terminate_actors monitor
+      end
+
+      it 'links atomically' do
+        queue   = Queue.new
+        failure = nil
+        monitor = AdHoc.spawn(:monitor) do
+          failure = AdHoc.spawn(name: :failure, link: true) { -> m { m } }
+          -> m { queue << [m, envelope.sender] }
+        end
+
+        failure << :hehe
+        failure << :terminate!
+        expect(queue.pop).to eq [:terminated, failure]
+
+        terminate_actors monitor
       end
 
     end