roby 0.7.3 → 0.8.0

data/lib/roby/distributed/distributed_object.rb

@@ -194,7 +194,7 @@ module Roby
 
 		call(:create_sibling, object)
 		subscriptions << object.sibling_on(self)
-		Roby::Control.synchronize do
+		Roby.synchronize do
 		    local_server.subscribe(object)
 		end
 

data/lib/roby/distributed/notifications.rb

@@ -64,9 +64,9 @@ module Roby
             # Hook called when a new task is marked as mission. It sends a
             # PeerServer#plan_set_mission message to the remote host.
             #
-            # Note that plan will have called the #discovered_tasks hook
+            # Note that plan will have called the #added_tasks hook
             # beforehand
-	    def inserted(task)
+	    def added_mission(task)
 		super if defined? super
 		return unless task.distribute? && task.self_owned?
 
@@ -80,7 +80,7 @@ module Roby
 
             # Hook called when a new task is not a mission anymore. It sends a
             # PeerServer#plan_set_mission message to the remote host.
-	    def discarded(task)
+	    def unmarked_mission(task)
 		super if defined? super
 		return unless task.distribute? && task.self_owned?
 
@@ -91,10 +91,10 @@ module Roby
 		end
 	    end
 
-            # Common implementation for the #discovered_events and
-            # #discovered_tasks hooks. It sends PeerServer#plan_discover for
+            # Common implementation for the #added_events and
+            # #added_tasks hooks. It sends PeerServer#plan_add for
             # all tasks which can be shared among plan managers
-	    def self.discovered_objects(plan, objects)
+	    def self.added_objects(plan, objects)
 		unless Distributed.updating?(plan)
 		    relations = nil
 		    Distributed.each_updated_peer(plan) do |peer|
@@ -105,24 +105,24 @@ module Roby
 			    return if objects.empty?
 			    relations = Distributed.subgraph_of(objects)
 			end
-			peer.transmit(:plan_discover, plan, objects, relations)
+			peer.transmit(:plan_add, plan, objects, relations)
 		    end
 		    Distributed.trigger(*objects)
 		end
 	    end
-            # New tasks have been discovered in the plan.
+            # New tasks have been added in the plan.
             #
-            # See PlanModificationHooks.discovered_objects
-	    def discovered_tasks(tasks)
+            # See PlanModificationHooks.added_objects
+	    def added_tasks(tasks)
 		super if defined? super
-		PlanModificationHooks.discovered_objects(self, tasks)
+		PlanModificationHooks.added_objects(self, tasks)
 	    end
-            # New free events have been discovered in the plan.
+            # New free events have been added in the plan.
             #
-            # See PlanModificationHooks.discovered_objects
-	    def discovered_events(events)
+            # See PlanModificationHooks.added_objects
+	    def added_events(events)
 		super if defined? super
-		PlanModificationHooks.discovered_objects(self, events) 
+		PlanModificationHooks.added_objects(self, events) 
 	    end
 
             # Hook called when +from+ has been replaced by +to+ in the plan.
@@ -190,9 +190,9 @@ module Roby
 		task = peer.local_object(task)
 		if plan.owns?(task)
 		    if flag
-			plan.insert(task)
+			plan.add_mission(task)
 		    else
-			plan.discard(task)
+			plan.remove_mission(task)
 		    end
 		else
 		    task.mission = flag
@@ -201,14 +201,14 @@ module Roby
 	    end
 
             # Message received when the set of tasks +m_tasks+ has been
-            # discovered by the remote plan. +m_relations+ describes the
+            # added by the remote plan. +m_relations+ describes the
             # internal relations between elements of +m_tasks+. It is in a
             # format suitable for PeerServer#set_relations.
-	    def plan_discover(plan, m_tasks, m_relations)
+	    def plan_add(plan, m_tasks, m_relations)
 		Distributed.update(plan = peer.local_object(plan)) do
 		    tasks = peer.local_object(m_tasks).to_value_set
 		    Distributed.update_all(tasks) do 
-			plan.discover(tasks)
+			plan.add(tasks)
 			m_relations.each_slice(2) do |obj, rel|
 			    set_relations(obj, rel)
 			end
@@ -429,7 +429,7 @@ module Roby
 
 		event = event_for(from_generator, event_id, time, context)
 
-		event.send(:propagation_id=, Propagation.propagation_id)
+		event.send(:propagation_id=, from_generator.plan.engine.propagation_id)
 		from_generator.instance_variable_set("@happened", true)
 		from_generator.fired(event)
 		from_generator.call_handlers(event)
@@ -450,7 +450,7 @@ module Roby
 
 		# Only add the signalling if we own +to+
 		if to_generator.self_owned?
-		    Propagation.add_event_propagation(only_forward, [event], to_generator, event.context, nil)
+                    to_generator.plan.engine.add_event_propagation(only_forward, [event], to_generator, event.context, nil)
 		else
 		    # Call #signalling or #forwarding to make
 		    # +from_generator+ look like as if the event was really
@@ -527,13 +527,5 @@ module Roby
 		nil
 	    end
 	end
-
-	Roby::Control.at_cycle_end do
-	    peers.each_value do |peer|
-		if peer.connected?
-		    peer.transmit(:state_update, Roby::State) 
-		end
-	    end
-	end
     end
 end

data/lib/roby/distributed/peer.rb

@@ -10,7 +10,7 @@ require 'roby/distributed/proxy'
 require 'roby/distributed/communication'
 
 module Roby
-    class Control; include DRbUndumped end
+    class ExecutionEngine; include DRbUndumped end
 end
 
 module Roby::Distributed
@@ -149,7 +149,7 @@ module Roby::Distributed
 	# +matcher+ changes
 	def add_trigger(id, matcher)
 	    triggers[id] = [matcher, (triggered = ValueSet.new)]
-	    Roby.info "#{remote_name} wants notification on #{matcher} (#{id})"
+	    Roby::Distributed.info "#{remote_name} wants notification on #{matcher} (#{id})"
 
 	    peer.queueing do
 		matcher.each(plan) do |task|
@@ -164,7 +164,7 @@ module Roby::Distributed
 
 	# Remove the trigger +id+ defined by this peer
 	def remove_trigger(id)
-	    Roby.info "#{remote_name} removed #{id} notification"
+	    Roby::Distributed.info "#{remote_name} removed #{id} notification"
 	    triggers.delete(id)
 	    nil
 	end
@@ -276,6 +276,11 @@ module Roby::Distributed
 	# The remote state
 	attr_accessor :state
 
+        # The plan associated to our connection space
+        def plan; connection_space.plan end
+        # The execution engine associated to #plan
+        def engine; connection_space.plan.engine end
+
 	# Creates a Peer object for the peer connected at +socket+. This peer
 	# is to be managed by +connection_space+ If a block is given, it is
 	# called in the control thread when the connection is finalized
@@ -310,8 +315,8 @@ module Roby::Distributed
 	    local_server.state_update remote_state
 
 	    @task = ConnectionTask.new :peer => self
-	    Roby::Control.once do
-		connection_space.plan.permanent(task)
+	    connection_space.plan.engine.once do
+		connection_space.plan.add_permanent(task)
 		task.start!
 		task.emit(:ready)
 	    end
@@ -362,7 +367,7 @@ module Roby::Distributed
 	    end
 
 	ensure
-	    Roby::Control.synchronize do
+	    Roby.synchronize do
 		if result_set
 		    result_set.each do |task|
 			Roby::Distributed.keep.deref(task)
@@ -407,7 +412,7 @@ module Roby::Distributed
 			trigger.last.call(task)
 		    end
 		rescue Exception
-		    Roby.warn "trigger handler #{trigger.last} failed with #{$!.full_message}"
+		    Roby::Distributed.warn "trigger handler #{trigger.last} failed with #{$!.full_message}"
 		ensure
 		    Roby::Distributed.keep.deref(task)
 		end
@@ -539,7 +544,7 @@ module Roby::Distributed
 
 	    yield(local_object(remote_object(object)))
 
-	    Roby::Control.synchronize do
+	    Roby.synchronize do
 		objects.each { |obj| Roby::Distributed.keep.deref(obj) }
 	    end
 	end

data/lib/roby/distributed/proxy.rb

@@ -83,7 +83,7 @@ module Roby
 		    plan = peer.local_object(self.plan)
 		    return if proxy.plan == plan
 		    Distributed.update_all([plan, proxy]) do
-			plan.discover(proxy)
+			plan.add(proxy)
 		    end
 		end
 	    end
@@ -218,7 +218,7 @@ module Roby
 	def droby_dump(dest)
 	    DRoby.new(remote_siblings.droby_dump(dest), owners.droby_dump(dest),
 		      model.droby_dump(dest),  plan.droby_dump(dest), 
-		      Distributed.format(arguments, dest), Distributed.format(data, dest),
+		      Distributed.format(meaningful_arguments, dest), Distributed.format(data, dest),
 		      :mission => mission?, :started => started?, 
 		      :finished => finished?, :success => success?)
 	end
@@ -271,12 +271,12 @@ module Roby
 		task.success  = flags[:success]
 
 		if task.mission? != flags[:mission]
-		    plan = peer.local_object(self.plan) || Roby.plan
+		    plan = peer.local_object(self.plan) || peer.connection_space.plan
 		    if plan.owns?(task)
 			if flags[:mission]
-			    plan.insert(task)
+			    plan.add_mission(task)
 			else
-			    plan.discard(task)
+			    plan.remove_mission(task)
 			end
 		    else
 			task.mission = flags[:mission]

data/lib/roby/distributed/subscription.rb

@@ -39,14 +39,14 @@ module Roby
 
 	    # The peer wants to subscribe to our main plan
 	    def subscribe_plan(sibling)
-		added_sibling(Roby.plan.remote_id, sibling)
-		peer.transmit(:subscribed_plan, Roby.plan.remote_id)
-		subscribe(Roby.plan)
+		added_sibling(peer.connection_space.plan.remote_id, sibling)
+		peer.transmit(:subscribed_plan, peer.connection_space.plan.remote_id)
+		subscribe(peer.connection_space.plan)
 	    end
 
 	    # Called by our peer because it has subscribed us to its main plan
 	    def subscribed_plan(remote_plan_id)
-		peer.proxies[remote_plan_id] = Roby.plan
+		peer.proxies[remote_plan_id] = peer.connection_space.plan
 		peer.remote_plan = remote_plan_id
 	    end
 

data/lib/roby/distributed/transaction.rb

@@ -133,7 +133,7 @@ module Roby
 		end
 	    end
 
-	    def discover(objects) # :nodoc:
+	    def add(objects) # :nodoc:
 		if objects
 		    events, tasks = partition_event_task(objects)
 		    for object in (events || []) + (tasks || [])
@@ -360,8 +360,8 @@ module Roby
 			begin
 			    Distributed.transaction_handler[trsc] if Distributed.transaction_handler
 			rescue 
-			    Roby.warn "transaction handler for #{trsc} failed"
-			    Roby.warn $!.full_message
+			    Roby::Distributed.warn "transaction handler for #{trsc} failed"
+			    Roby::Distributed.warn $!.full_message
 			    trsc.invalidate("failed transaction handler")
 			end
 		    end

data/lib/roby/event.rb

@@ -1,8 +1,3 @@
-require 'utilrb/weakref'
-require 'roby/plan-object'
-require 'roby/exceptions'
-require 'set'
-
 module Roby
     # Event objects are the objects representing a particular emission in the
     # event propagation process. They represent the common propagation
@@ -22,7 +17,7 @@ module Roby
 	attr_accessor :propagation_id, :context, :time
 	protected :propagation_id=, :context=, :time=
 
-        # The events whose emission triggered this event during the
+        # The events whose emission directly triggered this event during the
         # propagation. The events in this set are subject to Ruby's own
         # garbage collection, which means that if a source event is garbage
         # collected (i.e. if all references to the associated task/event
@@ -108,12 +103,6 @@ module Roby
     # * #forwarding
     #
     class EventGenerator < PlanObject
-	attr_writer :executable
-
-	# True if this event is executable. A non-executable event cannot be
-	# called even if it is controlable
-	def executable?; @executable end
-
 	# Creates a new Event generator which is emitted as soon as one of this
 	# object and +generator+ is emitted
 	def |(generator)
@@ -127,6 +116,7 @@ module Roby
 	end
 
 	attr_enumerable(:handler, :handlers) { Array.new }
+	attr_enumerable(:once_handler, :once_handlers) { Array.new }
 
 	def initialize_copy(old) # :nodoc:
 	    super
@@ -170,7 +160,6 @@ module Roby
 			       end
 	    end
 	    super() if defined? super
-	    @executable = true
 
 	end
 
@@ -187,13 +176,15 @@ module Roby
 	# Checks that the event can be called. Raises various exception
 	# when it is not the case.
 	def check_call_validity
-	    if !self_owned?
-		raise OwnershipError, "not owner"
+            if !plan
+		raise EventNotExecutable.new(self), "#emit called on #{self} which is in no plan"
+            elsif !engine
+		raise EventNotExecutable.new(self), "#emit called on #{self} which is has no associated execution engine"
+            elsif !engine.allow_propagation?
+                raise PhaseMismatch, "call to #emit is not allowed in this context"
 	    elsif !controlable?
 		raise EventNotControlable.new(self), "#call called on a non-controlable event"
-	    elsif !executable?
-		raise EventNotExecutable.new(self), "#call called on #{self} which is non-executable event"
-	    elsif !Roby.inside_control?
+	    elsif !engine.inside_control?
 		raise ThreadMismatch, "#call called while not in control thread"
 	    end
 	end
@@ -202,21 +193,22 @@ module Roby
 	# when it is not the case.
 	def check_emission_validity
 	    if !executable?
-		raise EventNotExecutable.new(self), "#emit called on #{self} which is not executable"
-	    elsif !self_owned?
-		raise OwnershipError, "cannot emit an event we don't own. #{self} is owned by #{owners}"
-	    elsif !Roby.inside_control?
+		raise EventNotExecutable.new(self), "#emit called on #{self} which is a non-executable event"
+            elsif !engine.allow_propagation?
+                raise PhaseMismatch, "call to #emit is not allowed in this context"
+	    elsif !engine.inside_control?
 		raise ThreadMismatch, "#emit called while not in control thread"
 	    end
 	end
 
 	# Returns true if the command has been called and false otherwise
 	# The command won't be called if #postpone() is called within the
-	# #calling hook
+	# #calling hook, in which case the method returns false.
 	#
 	# This is used by propagation code, and should never be called directly
-	def call_without_propagation(context) # :nodoc:
+	def call_without_propagation(context)
             check_call_validity
+            
 	    if !controlable?
 		raise EventNotControlable.new(self), "#call called on a non-controlable event"
 	    end
@@ -225,7 +217,11 @@ module Roby
 		calling(context)
 		@pending = true
 
-		Propagation.propagation_context([self]) do
+                if !executable?
+                    raise EventNotExecutable.new(self), "#call called on #{self} which is a non-executable event"
+                end
+
+		plan.engine.propagation_context([self]) do
 		    command[context]
 		end
 
@@ -252,36 +248,46 @@ module Roby
 	def call(*context)
             check_call_validity
 
+            # This test must not be done in #emit_without_propagation as the
+            # other ones: it is possible, using Distributed.update, to disable
+            # ownership tests, but that does not work if the test is in
+            # #emit_without_propagation
+	    if !self_owned?
+		raise OwnershipError, "not owner"
+            end
+
 	    context.compact!
-	    if Propagation.gathering?
-		Propagation.add_event_propagation(false, Propagation.sources, self, (context unless context.empty?), nil)
-	    else
-		Roby::Control.synchronize do
-		    errors = Propagation.propagate_events do |initial_set|
-			Propagation.add_event_propagation(false, nil, self, (context unless context.empty?), nil)
+            engine = plan.engine
+	    if engine.gathering?
+		engine.add_event_propagation(false, engine.propagation_sources, self, (context unless context.empty?), nil)
+            else
+		Roby.synchronize do
+		    errors = engine.propagate_events do |initial_set|
+			engine.add_event_propagation(false, nil, self, (context unless context.empty?), nil)
 		    end
 		    if errors.size == 1
 			e = errors.first.exception
-			raise e, e.message, e.backtrace
+			raise e.dup, e.message, Roby.filter_backtrace(e.backtrace)
 		    elsif !errors.empty?
 			for e in errors
-			    STDERR.puts e.exception.full_message
+			    pp e.exception
 			end
+			raise "multiple exceptions"
 		    end
 		end
 	    end
 	end
 
-	# Establishes signalling and/or event handlers from this event
-	# generator. 
+	# call-seq:
+        #   on { |event| ... }
         #
-        # If +time+ is given it is either a :delay => time association, or a
-        # :at => time association. In the first case, +time+ is a floating-point
-        # delay in seconds and in the second case it is a Time object which is
-        # the absolute point in time at which this propagation must happen.
+        # Adds an event handler on this generator. The block gets an Event
+        # object which describes the parameters of the emission (context value,
+        # time, ...). See Event for details.
 	def on(signal = nil, time = nil, &handler)
 	    if signal
-		self.signal(signal, time)
+                Roby.warn_deprecated "EventGenerator#on only accepts event handlers now. Use #signals to establish signalling"
+		self.signals(signal, time)
 	    end
 
 	    if handler
@@ -299,14 +305,19 @@ module Roby
         # :at => time association. In the first case, +time+ is a floating-point
         # delay in seconds and in the second case it is a Time object which is
         # the absolute point in time at which this propagation must happen.
-	def signal(generator, timespec = nil)
+        def signals(generator, timespec = nil)
 	    if !generator.controlable?
-		raise EventNotControlable.new(self), "trying to establish a signal between #{self} and #{generator}"
+		raise EventNotControlable.new(self), "trying to establish a signal from #{self} to #{generator} which is not controllable"
 	    end
-	    timespec = Propagation.validate_timespec(timespec)
+	    timespec = ExecutionEngine.validate_timespec(timespec)
 
 	    add_signal generator, timespec
 	    self
+        end
+
+	def signal(generator, timespec = nil)
+            Roby.warn_deprecated "EventGenerator#signal has been renamed into EventGenerator#signals"
+            signals(generator, timespec)
 	end
 
 	# A set of blocks called when this event cannot be emitted again
@@ -338,6 +349,11 @@ module Roby
             @unreachable_event
         end
 
+	def forward(generator, timespec = nil)
+            Roby.warn_deprecated "EventGenerator#forward has been renamed into EventGenerator#forward_to"
+            forward_to(generator, timespec)
+	end
+
         # Emit +generator+ when +self+ is fired, without calling the command of
         # +generator+, if any.
         #
@@ -345,44 +361,57 @@ module Roby
         # :at => time association. In the first case, +time+ is a floating-point
         # delay in seconds and in the second case it is a Time object which is
         # the absolute point in time at which this propagation must happen.
-	def forward(generator, timespec = nil)
-	    timespec = Propagation.validate_timespec(timespec)
+        def forward_to(generator, timespec = nil)
+	    timespec = ExecutionEngine.validate_timespec(timespec)
 	    add_forwarding generator, timespec
 	    self
-	end
+        end
 
 	# Returns an event which is emitted +seconds+ seconds after this one
 	def delay(seconds)
 	    if seconds == 0 then self
 	    else
 		ev = EventGenerator.new
-		forward(ev, :delay => seconds)
+		forward_to(ev, :delay => seconds)
 		ev
 	    end
 	end
 
-	# Signal the +signal+ event the first time this event is emitted.  If
-	# +time+ is non-nil, delay the signalling this many seconds. 
-	def signal_once(signal, time = nil); once(signal, time) end
-
-	# Equivalent to #on, but call the handler and/or signal the target
-	# event only once.
-	def once(signal = nil, time = nil)
-	    handler = nil
-	    on(signal, time) do |context|
-		yield(context) if block_given?
-		self.handlers.delete(handler)
-		remove_signal(signal) if signal
+        # Signals the given target event only once
+	def signals_once(signal, delay = nil)
+            signals(signal, delay)
+            once do |context|
+		remove_signal signal
 	    end
-	    handler = self.handlers.last
+            self
+        end
+
+	# call-seq:
+        #   once { |context| ... }
+        #
+        # Calls the provided event handler only once
+	def once(signal = nil, time = nil, &block)
+            if signal
+                Roby.warn_deprecated "the once(event_name) form has been replaced by #signal_once"
+                signal_once(signal, time)
+            end
+
+            once_handlers << block
+            self
 	end
 
-	# Forwards to +ev+ only once
-	def forward_once(ev)
-	    forward(ev)
-	    once do
+        def forward_once(ev, delay = nil)
+            Roby.warn_deprecated "#forward_once has been renamed into #forward_to_once"
+            forward_to_once(ev)
+        end
+
+	# Forwards to the given target event only once
+	def forward_to_once(ev, delay = nil)
+	    forward_to(ev, delay)
+	    once do |context|
 		remove_forwarding ev
 	    end
+            self
 	end
 
 	def to_event; self end
@@ -401,7 +430,7 @@ module Roby
 	end
 
 	# Create a new event object for +context+
-	def new(context); Event.new(self, Propagation.propagation_id, context, Time.now) end
+	def new(context); Event.new(self, plan.engine.propagation_id, context, Time.now) end
 
 	# Adds a propagation originating from this event to event propagation
 	def add_propagation(only_forward, event, signalled, context, timespec) # :nodoc:
@@ -411,7 +440,7 @@ module Roby
 		raise PropagationError, "trying to signal #{signalled} from #{self}"
 	    end
 
-	    Propagation.add_event_propagation(only_forward, [event], signalled, context, timespec)
+	    plan.engine.add_event_propagation(only_forward, [event], signalled, context, timespec)
 	end
 	private :add_propagation
 
@@ -420,7 +449,7 @@ module Roby
 	#
 	# This method is always called in a propagation context
 	def fire(event)
-	    Propagation.propagation_context([event]) do |result|
+	    plan.engine.propagation_context([event]) do |result|
 		each_signal do |signalled|
 		    add_propagation(false, event, signalled, event.context, self[signalled, EventStructure::Signal])
 		end
@@ -446,9 +475,17 @@ module Roby
 		begin
 		    h.call(event)
 		rescue Exception => e
-                    Propagation.add_error( EventHandlerError.new(e, event) )
+		    plan.engine.add_error( EventHandlerError.new(e, event) )
 		end
 	    end
+            each_once_handler do |h|
+                begin
+                    h.call(event)
+                rescue Exception => e
+                    plan.engine_add_error( EventHandlerError.new(e, event) )
+                end
+            end
+            once_handlers.clear
 	end
 
 	# Raises an exception object when an event whose command has been
@@ -457,30 +494,41 @@ module Roby
 	    what, message = *what
 	    what ||= EmissionFailed
 
-	    if !message && what.respond_to?(:to_str)
+	    if !message && !(what.kind_of?(Class) || what.kind_of?(Exception))
 		message = what.to_str
 		what = EmissionFailed
 	    end
 
-	    failure_message = "failed to emit #{self}: #{message}"
+	    failure_message =
+                if message then "failed to emit #{self}: #{message}"
+                elsif what.respond_to?(:message) then "failed to emit #{self}: #{what.message}"
+                else "failed to emit #{self}: #{message}"
+                end
+
 	    error = if Class === what then what.new(nil, self)
 		    else what
 		    end
-	    error = error.exception failure_message
 
-	    Propagation.add_error(error)
+	    new_error = error.exception failure_message
+            new_error.set_backtrace error.backtrace
+            error = new_error
 
+            if !error.kind_of?(LocalizedError)
+                error = EmissionFailed.new(error, self)
+            end
+
+	    plan.engine.add_error(error)
 	ensure
 	    @pending = false
 	end
 
 	# Emits the event regardless of wether we are in a propagation context
-	# or not Returns true to match the behavior of
-	# #call_without_propagation
+	# or not. Returns true to match the behavior of #call_without_propagation
 	#
 	# This is used by event propagation. Do not call directly: use #call instead
-	def emit_without_propagation(context) # :nodoc:
+	def emit_without_propagation(context)
             check_emission_validity
+            
 	    if !executable?
 		raise EventNotExecutable.new(self), "#emit called on #{self} which is not executable"
 	    end
@@ -492,7 +540,7 @@ module Roby
 	    unless event.respond_to?(:context)
 		raise TypeError, "#{event} is not a valid event object in #{self}"
 	    end
-	    event.sources = Propagation.source_events
+	    event.sources = plan.engine.propagation_source_events
 	    fire(event)
 
 	    true
@@ -505,21 +553,31 @@ module Roby
 	def emit(*context)
             check_emission_validity
 
+            # This test must not be done in #emit_without_propagation as the
+            # other ones: it is possible, using Distributed.update, to disable
+            # ownership tests, but that does not work if the test is in
+            # #emit_without_propagation
+	    if !self_owned?
+		raise OwnershipError, "cannot emit an event we don't own. #{self} is owned by #{owners}"
+            end
+
 	    context.compact!
-	    if Propagation.gathering?
-		Propagation.add_event_propagation(true, Propagation.sources, self, (context unless context.empty?), nil)
-	    else
-		Roby::Control.synchronize do
-		    errors = Propagation.propagate_events do |initial_set|
-			Propagation.add_event_propagation(true, Propagation.sources, self, (context unless context.empty?), nil)
+            engine = plan.engine
+	    if engine.gathering?
+		engine.add_event_propagation(true, engine.propagation_sources, self, (context unless context.empty?), nil)
+            else
+		Roby.synchronize do
+		    errors = engine.propagate_events do |initial_set|
+			engine.add_event_propagation(true, engine.propagation_sources, self, (context unless context.empty?), nil)
 		    end
 		    if errors.size == 1
 			e = errors.first.exception
-			raise e, e.message, e.backtrace
+			raise e.dup, e.message, Roby.filter_backtrace(e.backtrace)
 		    elsif !errors.empty?
-			for e in errors
-			    STDERR.puts e.full_message
-			end
+                        for e in errors
+                            pp e.exception
+                        end
+			raise "multiple exceptions"
 		    end
 		end
 	    end
@@ -528,8 +586,9 @@ module Roby
 	# Deprecated. Instead of using
 	#   dest.emit_on(source)
 	# now use
-	#   source.forward(dest)
+	#   source.forward_to(dest)
 	def emit_on(generator, timespec = nil)
+            Roby.warn_deprecated "a.emit_on(b) has been replaced by b.forward_to(a)"
 	    generator.forward(self, timespec)
 	    self
 	end
@@ -558,15 +617,11 @@ module Roby
 		    self.emit(yield(context))
 		end
 	    else
-		ev.forward_once self
+		ev.forward_to_once self
 	    end
 
 	    ev.if_unreachable(true) do |reason|
-		msg = "#{ev} is unreachable#{ " (#{reason})" if reason }, in #{stack.first}"
-		if ev.respond_to?(:task)
-		    msg << "\n  " << ev.task.history.map { |ev| "#{ev.time.to_hms} #{ev.symbol}: #{ev.context}" }.join("\n  ")
-		end
-		emit_failed(UnreachableEvent.new(self, reason), msg)
+		emit_failed(UnreachableEvent.new(self, reason))
 	    end
 	end
 	# For backwards compatibility. Use #achieve_with.
@@ -597,7 +652,7 @@ module Roby
 	#
 	# A reason string can be provided for debugging purposes
 	def postpone(generator, reason = nil)
-	    generator.on self
+	    generator.signals self
 	    yield if block_given?
 	    throw :postponed, [generator, reason]
 	end
@@ -673,7 +728,7 @@ module Roby
 	# by the given block
 	def filter(*new_context, &block)
 	    filter = FilterGenerator.new(new_context, &block)
-	    self.on(filter)
+	    self.signals(filter)
 	    filter
 	end
 
@@ -682,7 +737,7 @@ module Roby
 	#
 	#   source, ev, limit = (1..3).map { EventGenerator.new(true) }
 	#   ev.until(limit).on { STDERR.puts "FIRED !!!" }
-	#   source.on ev
+	#   source.signals ev
 	#
 	# Will do
 	#
@@ -702,6 +757,19 @@ module Roby
 	    super
 	end
 
+        def added_child_object(child, relations, info) # :nodoc:
+            super if defined? super
+            if relations.include?(Roby::EventStructure::Precedence) && plan && plan.engine
+                plan.engine.event_ordering.clear
+            end
+        end
+        def removed_child_object(child, relations) # :nodoc:
+            super if defined? super
+            if relations.include?(Roby::EventStructure::Precedence) && plan && plan.engine
+                plan.engine.event_ordering.clear
+            end
+        end
+
 	@@event_gathering = Hash.new { |h, k| h[k] = ValueSet.new }
 	# If a generator in +events+ fires, add the fired event in +collection+
 	def self.gather_events(collection, events)
@@ -721,30 +789,28 @@ module Roby
 	# event generators +collection+ is listening for.
 	def self.event_gathering; @@event_gathering end
 
-	# This module is hooked in Roby::Plan to remove from the
-	# event_gathering sets the events that have been finalized
-	module FinalizedEventHook
-	    def finalized_event(event)
-		super if defined? super
-		event.unreachable!
-	    end
-	end
-	Roby::Plan.include FinalizedEventHook
-
 	attr_predicate :unreachable?
+        # If the event became unreachable, this holds the reason for its
+        # unreachability, if that reason is known. This reason is always an
+        # Event instance which represents the emission that triggered this
+        # unreachability.
+        attr_reader :unreachability_reason
 
 	# Called internally when the event becomes unreachable
-	def unreachable!(reason = nil)
+	def unreachable!(reason = nil, plan = self.plan)
 	    return if @unreachable
 	    @unreachable = true
+            @unreachability_reason = reason
 
             EventGenerator.event_gathering.delete(self)
 
 	    unreachable_handlers.each do |_, block|
 		begin
 		    block.call(reason)
+                rescue LocalizedError => e
+		    plan.engine.add_error(e)
 		rescue Exception => e
-		    Propagation.add_error(EventHandlerError.new(e, self))
+		    plan.engine.add_error(EventHandlerError.new(e, self))
 		end
 	    end
 	    unreachable_handlers.clear
@@ -935,8 +1001,8 @@ module Roby
 	    end
 
 	    if source && limit
-		source.forward(self)
-		limit.signal(self)
+		source.forward_to(self)
+		limit.signals(self)
 	    end
 	end
     end