roby 0.7

data/lib/roby/exceptions.rb

@@ -0,0 +1,234 @@
+class Exception
+    def pretty_print(pp)
+        pp.text "#{message} (#{self.class.name})"
+        pp.breakable
+        Roby.pretty_print_backtrace(pp, backtrace)
+    end
+    
+    # True if +obj+ is involved in this error
+    def involved_plan_object?(obj)
+        false
+    end
+end
+
+module Roby
+    class ConfigError < RuntimeError; end
+    class ModelViolation < RuntimeError; end
+
+    # ExecutionException objects are used during the exception handling stage
+    # to keep information about the propagation. 
+    #
+    # When a propagation fork is found (for instance, a task with two parents),
+    # two or more siblings are created with #fork. If at some point two
+    # siblings are to be handled by the same task, coming for instance from two
+    # different children, then they are merged with #merge to from one single
+    # ExecutionException object.
+    class ExecutionException
+	# The propagation trace. Because of forks and merges, this should be a
+	# graph.  We don't use graph properties (at least not yet), so consider
+	# this as the list of objects which did not handle the exeption. Only
+	# trace.last and trace.first have a definite meaning: the former
+	# is the last object(s) that handled the propagation and the latter
+	# is the object from which the exception originated. They can be 
+	# accessed through #task and #origin.
+	attr_reader :trace
+	# The last object(s) that handled the exception. This is either a
+	# single object or an array
+	def task; trace.last end
+	# The object from which the exception originates
+	def origin; trace.first end
+    
+	# The exception siblings (the ExecutionException objects
+	# that come from the same exception object)
+	attr_reader :siblings
+	# The origin EventGenerator if there is one
+	attr_reader :generator
+	# The exception object
+	attr_reader :exception
+
+	# If this specific exception has been marked has handled
+	attr_accessor :handled
+	# If this exception or one of its siblings has been marked as handled
+	def handled?
+	    siblings.find { |s| s.handled }
+	end
+	# Enumerates this exception's siblings
+	def each_sibling
+	    for e in siblings
+		yield(e) unless e == self
+	    end
+	end
+
+	# Creates a new execution exception object with the specified source
+	# If +source+ is nil, tries to guess the source from +exception+: if
+	# +exception+ responds to #task or #generator we use either #task or
+	# call #generator.task
+	def initialize(exception)
+	    @exception = exception
+	    @trace = Array.new
+	    @siblings = [self]
+
+	    if task = exception.failed_task
+		@trace << exception.failed_task
+	    end
+	    if generator = exception.failed_generator
+		@generator = exception.failed_generator
+	    end
+
+	    if !task && !generator
+		raise ArgumentError, "invalid exception specification: cannot get the exception source"
+	    end
+	end
+
+	# Create a sibling from this exception
+	def fork
+	    sibling = dup
+	    self.siblings << sibling
+	    sibling
+	end
+
+	# Merges +sibling+ into this object
+	def merge(sibling)
+	    siblings.delete(sibling)
+
+	    topstack   = trace.pop
+	    s_topstack = sibling.trace.pop
+
+	    origin     = trace.shift
+	    s_origin   = sibling.trace.shift
+	    origin     = origin || s_origin || topstack
+
+	    new_top    = *(Array[*topstack] | Array[*s_topstack])
+	    @trace = [origin] + (trace | sibling.trace) << new_top
+	end
+
+	def initialize_copy(from)
+	    super
+	    @trace = from.trace.dup
+	end
+    end
+
+    # This module is to be included in all objects that are
+    # able to handle exception. These objects should define
+    #   #each_exception_handler { |matchers, handler| ... }
+    #
+    # See Task::on_exception and Task#on_exception
+    module ExceptionHandlingObject
+        # To be used in exception handlers themselves. Passes the exception to
+        # the next matching exception handler
+	def pass_exception
+	    throw :next_exception_handler
+	end
+
+	# Calls the exception handlers defined in this task for +exception_object.exception+
+	# Returns true if the exception has been handled, false otherwise
+	def handle_exception(exception_object)
+	    each_exception_handler do |matchers, handler|
+		if matchers.find { |m| m === exception_object.exception }
+		    catch(:next_exception_handler) do 
+			begin
+			    handler.call(self, exception_object)
+			    return true
+			rescue Exception => e
+			    if self == Roby
+				Propagation.add_framework_error(e, 'global exception handling')
+			    else
+				Propagation.add_error(FailedExceptionHandler.new(e, self, exception_object))
+			    end
+			end
+		    end
+		end
+	    end
+	    return false
+	end
+    end
+
+    RX_IN_FRAMEWORK = /^((?:\s*\(druby:\/\/.+\)\s*)?#{Regexp.quote(ROBY_LIB_DIR)}\/)/
+    def self.filter_backtrace(original_backtrace)
+	if Roby.app.filter_backtraces? && original_backtrace
+            app_dir = if defined? APP_DIR then Regexp.quote(APP_DIR) end
+
+            original_backtrace = original_backtrace.dup
+            backtrace_bottom   = []
+            while !original_backtrace.empty? && original_backtrace.last !~ RX_IN_FRAMEWORK
+                backtrace_bottom.unshift original_backtrace.pop
+            end
+
+            backtrace = original_backtrace.enum_for(:each_with_index).map do |line, idx|
+                case line
+                when /in `poll_handler'$/
+                    line.gsub /:in.*/, ':in the polling handler'
+                when /in `event_command_(\w+)'$/
+                    line.gsub /:in.*/, ":in command for '#{$1}'"
+                when /in `event_handler_(\w+)_(?:[a-f0-9]+)'$/
+                    line.gsub /:in.*/, ":in event handler for '#{$1}'"
+                else
+                    if original_backtrace.size > idx + 4 &&
+                        original_backtrace[idx + 1] =~ /in `call'$/ &&
+                        original_backtrace[idx + 2] =~ /in `call_handlers'$/ &&
+                        original_backtrace[idx + 3] =~ /`each'$/ &&
+                        original_backtrace[idx + 4] =~ /`each_handler'$/
+
+                        line.gsub /:in /, ":in event handler, "
+                    else
+                        case line
+                        when /in `(gem_original_)?require'$/
+                        when /^((?:\s*\(druby:\/\/.+\)\s*)?#{Regexp.quote(ROBY_LIB_DIR)}\/)/
+                        when /^(#{app_dir}\/)?scripts\//
+                        when /^\(eval\):\d+:in `each(?:_handler)?'/
+                        else
+                            line
+                        end
+                    end
+                end
+            end
+
+            while !backtrace.empty? && !backtrace.last
+                backtrace.pop
+            end
+            backtrace.each_with_index do |line, i|
+                backtrace[i] = line || original_backtrace[i]
+            end
+
+            if app_dir
+                backtrace = backtrace.map do |line|
+                    line.gsub /^#{app_dir}\/?/, './'
+                end
+            end
+            backtrace.concat backtrace_bottom
+	end
+	backtrace || original_backtrace || []
+    end
+
+    def self.pretty_print_backtrace(pp, backtrace)
+        if backtrace && !backtrace.empty?
+            pp.group(2) do
+                pp.seplist(filter_backtrace(backtrace)) { |line| pp.text line }
+            end
+        end
+    end
+
+    def self.format_exception(exception)
+        message = begin
+                      PP.pp(exception, "")
+                  rescue Exception => formatting_error
+                      begin
+                          "error formatting exception\n" +
+                              exception.full_message +
+                          "\nplease report the formatting error: \n" + 
+                              formatting_error.full_message
+                      rescue Exception => formatting_error
+                          "\nerror formatting exception\n" +
+                              formatting_error.full_message
+                      end
+                  end
+        message.split("\n")
+    end
+
+    def self.log_exception(e, logger, level)
+        format_exception(e).each do |line|
+            logger.send(level, line)
+        end
+    end
+end
+

data/lib/roby/executives/simple.rb

@@ -0,0 +1,30 @@
+module Roby
+    module Executives
+	class Simple
+	    attr_reader :query
+	    def initialize
+		@query = Roby.plan.find_tasks.
+		    executable.
+		    pending.
+		    self_owned
+	    end
+	    def initial_events
+		query.reset.each do |task|
+		    next unless task.event(:start).root? && task.event(:start).controlable?
+		    root_task = task.enum_for(:each_relation).all? do |rel|
+			if task.root?(rel)
+			    true
+			elsif rel == TaskStructure::PlannedBy 
+			    task.planned_tasks.all? { |t| !t.executable? }
+			end
+		    end
+
+		    if root_task
+			task.start!
+		    end
+		end
+	    end
+	end
+    end
+end
+

data/lib/roby/graph.rb

@@ -0,0 +1,166 @@
+require 'utilrb/module'
+require 'utilrb/kernel'
+require 'utilrb/enumerable'
+require 'utilrb/value_set'
+require 'roby_bgl'
+
+Utilrb.unless_ext do
+    raise LoadError, "Roby needs Utilrb's C extension to be compiled"
+end
+
+module BGL
+    module Vertex
+	def initialize_copy(old)
+	    super
+	    @__bgl_graphs__ = nil
+	end
+
+	# Removes +self+ from all the graphs it is included in.
+	def clear_vertex
+	    each_graph { |g| g.remove(self) }
+	end
+
+	attribute(:singleton_set) { [self].to_value_set.freeze }
+	# Returns the connected component +self+ is part of in +graph+
+	def component(graph)
+	    graph.components(singleton_set, false).first || singleton_set
+	end
+	# Returns the vertex set which are reachable from +self+ in +graph+
+	def generated_subgraph(graph)
+	    graph.generated_subgraphs(singleton_set, false).first || singleton_set
+	end
+	# Returns the vertex set which can reach +self+ in +graph+
+	def reverse_generated_subgraph(graph)
+	    graph.reverse.generated_subgraphs(singleton_set, false).first || singleton_set
+	end
+
+	# Replace this vertex by +to+ in all graphs. See Graph#replace_vertex.
+	def replace_vertex_by(to)
+	    each_graph { |g| g.replace_vertex(self, to) }
+	end
+
+	# Returns an array of [graph, [parent, child, info], [parent, child,
+	# info], ...] elements for all edges +self+ is involved in
+	def edges
+	    result = []
+	    each_graph do |graph|
+		graph_edges = []
+		each_child_object do |child|
+		    graph_edges << [self, child, self[child, graph]]
+		end
+		each_parent_object do |parent|
+		    graph_edges << [parent, self, parent[self, graph]]
+		end
+		result << [graph, graph_edges]
+	    end
+
+	    result
+	end
+
+	# call-seq:
+	#   neighborhood(distance, graph) => [[graph, v, v1, data], [graph, v2, v, data], ...]
+	#   neighborhood(distance)	    => [[g1, v, v1, data], [g2, v2, v, data], ...]
+	#
+	# Returns a list of [graph, edge] representing all edges at a maximum distance
+	# of +distance+ from +self+. If +graph+ is given, only enumerate the neighborhood
+	# in +graph+.
+	def neighborhood(distance, graph = nil)
+	    if graph
+		graph.neighborhood(self, distance).
+		    map! { |args| args.unshift(graph) }
+	    else
+		edges = []
+		each_graph do |graph|
+		    edges += neighborhood(distance, graph)
+		end
+		edges
+	    end
+	end
+    end
+
+    class Graph
+	# This class is an adaptor which transforms a directed graph by
+	# swapping its edges
+	class Reverse
+	    # Create a directed graph whose edges are the ones of +g+, but with
+	    # source and destination swapped.
+	    def initialize(g)
+		@__bgl_real_graph__ = g
+	    end
+	end
+	attribute(:reverse)    { @reverse = Graph::Reverse.new(self) }
+
+	# This class is a graph adaptor which transforms a directed graph into
+	# an undirected graph
+	class Undirected
+	    # Create an undirected graph which has the same edge set than +g+
+	    def initialize(g)
+		@__bgl_real_graph__ = g
+	    end
+	end
+	attribute(:undirected) { @undirected = Graph::Undirected.new(self) }
+
+	def initialize_copy(source) # :nodoc:
+	    super
+
+	    source.each_vertex { |v| insert(v) }
+	    source.each_edge { |s, t, i| link(s, t, i) }
+	end
+
+	# Replaces +from+ by +to+. This means +to+ takes the role of +from+ in
+	# all edges +from+ is involved in. +from+ is removed from the graph.
+	def replace_vertex(from, to)
+	    from.each_parent_vertex(self) do |parent|
+		link(parent, to, parent[from, self])
+	    end
+	    from.each_child_vertex(self) do |child|
+		link(to, child, from[child, self])
+	    end
+	    remove(from)
+	end
+
+	# Returns a list of [parent, child, info] for all edges that are at a
+	# distance no more than +distance+ from +vertex+.
+	def neighborhood(vertex, distance)
+	    result = []
+	    seen = Set.new
+	    depth = { vertex => 0 }
+	    undirected.each_bfs(vertex, ALL) do |from, to, info, kind|
+		new_depth = depth[from] + 1
+		if kind == TREE
+		    depth[to] = new_depth
+		else
+		    next if seen.include?(to)
+		end
+		seen << from
+
+		if depth[from] > distance
+		    break
+		end
+
+		if new_depth <= distance
+		    if linked?(from, to)
+			result << [from, to, info]
+		    else
+			result << [to, from, info]
+		    end
+		end
+	    end
+	    result
+	end
+
+	# Two graphs are the same if they have the same vertex set
+	# and the same edge set
+	def same_graph?(other)
+	    unless other.respond_to?(:each_vertex) && other.respond_to?(:each_edge)
+		return false
+	    end
+
+	    # cannot use to_value_set for edges since we are comparing arrays (and ValueSet
+	    # bases its comparison on VALUE)
+	    (other.enum_for(:each_vertex).to_value_set == enum_for(:each_vertex).to_value_set) && 
+		(other.enum_for(:each_edge).to_set == enum_for(:each_edge).to_set)
+	end
+    end
+end
+

data/lib/roby/interface.rb

@@ -0,0 +1,390 @@
+require 'thread'
+require 'roby'
+require 'roby/planning'
+require 'facets/basicobject'
+require 'utilrb/column_formatter'
+require 'stringio'
+require 'roby/robot'
+
+module Robot
+    def self.prepare_action(name, arguments)
+	control = Roby.control
+
+	# Check if +name+ is a planner method, and in that case
+	# add a planning method for it and plan it
+	planner_model = control.planners.find do |planner_model|
+	    planner_model.has_method?(name)
+	end
+	if !planner_model
+	    raise ArgumentError, "no such planning method #{name}"
+	end
+
+	m = planner_model.model_of(name, arguments)
+
+	# HACK: m.returns should not be nil, but it sometimes happen
+	returns_model = (m.returns if m && m.returns) || Task
+
+	if returns_model.kind_of?(Roby::TaskModelTag)
+	    task = Roby::Task.new
+	    task.extend returns_model
+	else
+	    # Create an abstract task which will be planned
+	    task = returns_model.new
+	end
+
+	planner = Roby::PlanningTask.new(:planner_model => planner_model, :method_name => name, :method_options => arguments)
+	task.planned_by planner
+	return task, planner
+    end
+
+    def self.method_missing(name, *args)
+	if name.to_s =~ /!$/
+	    name = $`.to_sym
+	else
+	    super
+	end
+
+	if args.size > 1
+	    raise ArgumentError, "wrong number of arguments (#{args.size} for 1) in #{name}!"
+	end
+
+	options = args.first || {}
+	task, planner = Robot.prepare_action(name, options)
+	Roby.control.plan.insert(task)
+
+	return task, planner
+    end
+end
+
+module Roby
+    # An augmented DRbObject which allow to properly interface with remotely
+    # running plan objects.
+    class RemoteObjectProxy < DRbObject
+	attr_accessor :remote_interface
+
+	def to_s
+            __method_missing__(:to_s) 
+        end
+	def pretty_print(pp)
+	    pp.text to_s
+	end
+
+	alias __method_missing__ method_missing
+	def method_missing(*args, &block)
+	    if remote_interface
+		remote_interface.call(self, *args, &block)
+	    else
+		super
+	    end
+	end
+    end
+
+    # RemoteInterface objects are used as local representation of remote
+    # interface objects.  They offer a seamless interface to a remotely running
+    # Roby controller.
+    class RemoteInterface
+        # Create a RemoteInterface object for the remote object represented by
+        # +interface+, where +interface+ is a DRbObject for a remote Interface
+        # object.
+	def initialize(interface)
+	    @interface = interface
+	end
+
+        # Returns a Query object which can be used to interactively query the
+        # running plan
+	def find_tasks(model = nil, args = nil)
+	    q = Query.new(self)
+	    if model
+		q.which_fullfills(model, args)
+	    end
+	    q
+	end
+
+        # Defined for remotes queries to work
+	def query_result_set(query) # :nodoc:
+	    @interface.remote_query_result_set(Distributed.format(query)).each do |t|
+		t.remote_interface = self
+	    end
+	end
+        # Defined for remotes queries to work
+	def query_each(result_set) # :nodoc:
+	    result_set.each do |t|
+		yield(t)
+	    end
+	end
+        # Defined for remotes queries to work
+	def query_roots(result_set, relation) # :nodoc:
+	    @interface.remote_query_roots(result_set, Distributed.format(relation)).each do |t|
+		t.remote_interface = self
+	    end
+	end
+
+        # Returns the DRbObject for the remote controller state object
+	def state
+	    remote_constant('State')
+	end
+
+	def instance_methods(include_super = false) # :nodoc:
+	    Interface.instance_methods(false).
+		actions.map { |name| "#{name}!" }
+	end
+	    
+
+	def method_missing(m, *args) # :nodoc:
+	    result = @interface.send(m, *args)
+	    if result.kind_of?(RemoteObjectProxy)
+		result.remote_interface = @interface
+	    end
+	    result
+
+	rescue Exception => e
+	    raise e, e.message, Roby.filter_backtrace(e.backtrace)
+	end
+    end
+
+    # This class is used to interface with the Roby event loop and plan. It is the
+    # main front object when accessing a Roby core remotely
+    class Interface
+	module GatherExceptions
+            # The set of Interface objects that have been registered to us
+	    attribute(:interfaces) { Array.new }
+
+            # Register a new Interface object so that it gets feedback information
+            # from the running controller.
+	    def register_interface(iface)
+		Roby::Control.synchronize do
+		    interfaces << iface
+		end
+	    end 
+
+            # Pushes a exception message to all the already registered remote interfaces.
+	    def push_exception_message(name, error, tasks)
+		Roby::Control.synchronize do
+                    msg = Roby.format_exception(error.exception).join("\n")
+		    msg << "\nThe following tasks have been killed:\n"
+		    tasks.each do |t|
+                        msg << "  "
+                        if error.exception.involved_plan_object?(t)
+                            msg << "#{t.class}:0x#{t.address.to_s(16)}\n"
+                        else
+                            PP.pp(t, msg)
+                        end
+                    end
+
+		    interfaces.each do |iface|
+			iface.pending_messages << msg
+		    end
+		end
+	    end
+
+            # Pushes an exception information on all remote interfaces connected to us
+	    def handled_exception(error, task)
+		super if defined? super
+		push_exception_message("exception", error, [task])
+	    end
+
+            # Pushes an exception information on all remote interfaces connected to us
+	    def fatal_exception(error, tasks)
+		super if defined? super
+		push_exception_message("fatal exception", error, tasks)
+	    end
+	end
+
+        # The Roby::Control object this interface is working on
+	attr_reader :control
+        # The set of pending messages that are to be displayed on the remote interface
+	attr_reader :pending_messages
+        # Creates a local server for a remote interface, acting on +control+
+	def initialize(control)
+	    @control	      = control
+	    @pending_messages = Queue.new
+
+	    Roby::Control.extend GatherExceptions
+	    Roby::Control.register_interface self
+	end
+
+	# Clear the current plan: remove all running and permanent tasks.
+	def clear
+	    Roby.execute do
+		plan.missions.dup.each  { |t| plan.discard(t) }
+		plan.keepalive.dup.each { |t| plan.auto(t) }
+	    end
+	end
+
+	# Make the Roby event loop quit
+	def stop; control.quit; nil end
+	# The Roby plan
+	def plan; Roby.plan end
+
+        # Synchronously call +m+ on +tasks+ with the given arguments. This,
+        # along with the implementation of RemoteInterface#method_missing,
+        # ensures that no interactive operations are performed outside the
+        # control thread.
+	def call(task, m, *args)
+	    Roby.execute do
+                if m.to_s =~ /!$/
+                    event_name = $`
+                    # Check if the called event is terminal. If it is the case,
+                    # discard the task before calling it, and make sure the user
+                    # will get a message
+                    #
+                    if task.event(event_name).terminal?
+                        plan.discard(task)
+                        task.on(:stop) { |ev| pending_messages << "task #{ev.task} stopped by user request" }
+                    else
+                        task.on(event_name) { |ev| pending_messages << "done emitting #{ev.generator}" }
+                    end
+                end
+
+		task.send(m, *args)
+	    end
+	end
+
+	def find_tasks(model = nil, args = nil)
+	    plan.find_tasks(model, args)
+	end
+
+        # For using Query on Interface objects
+	def remote_query_result_set(m_query) # :nodoc:
+	    plan.query_result_set(m_query.to_query(plan)).
+		map { |t| RemoteObjectProxy.new(t) }
+	end
+        # For using Query on Interface objects
+	def remote_query_roots(result_set, m_relation) # :nodoc:
+	    plan.query_roots(result_set, m_relation.proxy(nil)).
+		map { |t| RemoteObjectProxy.new(t) }
+	end
+
+        # Returns a DRbObject on the given named constant. Use this to get a
+        # remote interface to a given object, not taking into account its
+        # 'marshallability'
+	def remote_constant(name)
+	    DRbObject.new(name.to_s.constantize)
+	end
+
+	# Reload the Roby framework code
+        #
+        # WARNING: does not work for now
+	def reload
+	    Roby.app.reload
+	    nil
+	end
+
+        # Displays the set of models as well as their superclasses
+	def models
+	    task_models = []
+	    Roby.execute do
+		ObjectSpace.each_object(Class) do |obj|
+		    task_models << obj if obj <= Roby::Task && obj.name !~ /^Roby::/
+		end
+	    end
+
+	    task_models.map do |model|
+		"#{model} #{model.superclass}"
+	    end
+	end
+
+        # Displays the set of actions which are available through the planners
+        # registered on #control. See Control#planners
+	def actions
+	    control.planners.
+		map { |p| p.planning_methods_names.to_a }.
+		flatten.
+		sort
+	end
+
+        # Pretty-prints a set of tasks
+	def task_set_to_s(task_set) # :nodoc:
+	    if task_set.empty?
+		return "no tasks"
+	    end
+
+	    task = task_set.map do |task|
+		state_name = %w{pending starting running finishing finished}.find do |state_name|
+		    task.send("#{state_name}?")
+		end
+
+		start_event = task.history.find { |ev| ev.symbol == :start }
+                since = if start_event then start_event.time
+                        else 'N/A'
+                        end
+		{ 'Task' => task.to_s, 'Since' => since, 'State' => state_name }
+	    end
+
+	    io = StringIO.new
+	    ColumnFormatter.from_hashes(task, io) { %w{Task Since State} }
+	    "\n#{io.string}"
+	end
+
+        # Returns a string representing the set of running tasks
+	def running_tasks
+	    Roby.execute do
+		task_set_to_s(Roby.plan.find_tasks.running.to_a)
+	    end
+	end
+
+        # Returns a string representing the set of missions
+	def missions
+	    Roby.execute do
+		task_set_to_s(control.plan.missions)
+	    end
+	end
+
+        # Returns a string representing the set of tasks present in the plan
+	def tasks
+	    Roby.execute do 
+		task_set_to_s(Roby.plan.known_tasks)
+	    end
+	end
+
+	def methods
+	    result = super
+	    result + actions.map { |n| "#{n}!" }
+	end
+
+        # Called every once in a while by RemoteInterface to read and clear the
+        # set of pending messages.
+	def poll_messages
+	    result = []
+	    while !pending_messages.empty?
+		msg = pending_messages.pop
+		result << msg
+	    end
+	    result
+	end
+
+	# Tries to find a planner method which matches +name+ with +args+. If it finds
+	# one, creates a task planned by a planning task and yields both
+	def method_missing(name, *args)
+	    if name.to_s =~ /!$/
+		name = $`.to_sym
+	    else
+		super
+	    end
+
+	    if args.size > 1
+		raise ArgumentError, "wrong number of arguments (#{args.size} for 1) in #{name}!"
+	    end
+
+	    options = args.first || {}
+	    task, planner = Robot.prepare_action(name, options)
+	    begin
+		Roby.wait_until(planner.event(:success)) do
+		    control.plan.insert(task)
+		    yield(task, planner) if block_given?
+		end
+	    rescue Roby::UnreachableEvent
+		raise RuntimeError, "cannot start #{name}: #{planner.terminal_event.context.first}"
+	    end
+
+            Roby.execute do
+                result = planner.result
+                result.on(:failed) { |ev| pending_messages << "task #{ev.task} failed" }
+                result.on(:success) { |ev| pending_messages << "task #{ev.task} finished successfully" }
+                RemoteObjectProxy.new(result)
+            end
+	end
+    end
+end
+
+