roby 0.7

data/lib/roby/transactions/proxy.rb

@@ -0,0 +1,292 @@
+require 'roby/task'
+require 'roby/event'
+require 'delegate'
+require 'forwardable'
+require 'utilrb/module/ancestor_p'
+
+# The Transactions module define all tools needed to implement
+# the Transaction class
+module Roby::Transactions
+    # In transactions, we do not manipulate plan objects like Task and EventGenerator directly,
+    # but through proxies which make sure that nothing forbidden is done
+    #
+    # The Proxy module define base functionalities for these proxy objects
+    module Proxy
+	@@proxy_klass = []
+	@@forwarders  = Hash.new
+
+	def to_s; "tProxy(#{__getobj__.to_s})" end
+
+	# Returns the proxy for +object+. Raises ArgumentError if +object+ is
+	# not an object which should be wrapped
+	def self.proxy_class(object)
+	    proxy_class = @@proxy_klass.find { |_, real_klass| object.kind_of?(real_klass) }
+	    unless proxy_class
+		raise ArgumentError, "no proxy for #{object.class}"
+	    end
+	    proxy_class[0]
+	end
+
+	# Declare that +proxy_klass+ should be used to wrap objects of +real_klass+.
+	# Order matters: if more than one wrapping matches, we will use the one
+	# defined last.
+	def self.proxy_for(proxy_klass, real_klass)
+	    @@proxy_klass.unshift [proxy_klass, real_klass]
+	    proxy_klass.extend Forwardable
+	end
+
+	# Returns a class that forwards every calls to +proxy.__getobj__+
+	def self.forwarder(object)
+	    klass = object.class
+	    @@forwarders[klass] ||= DelegateClass(klass)
+	    @@forwarders[klass].new(object)
+	end
+
+	def initialize(object, transaction)
+	    @distribute  = nil
+	    @transaction = transaction
+	    @__getobj__  = object
+	end
+
+	module ClassExtension
+	    def proxy_for(klass); Proxy.proxy_for(self, klass) end
+
+	    def proxy_code(m)
+		"return unless proxying?
+		args = args.map(&plan.method(:may_unwrap))
+		result = if block_given?
+			     __getobj__.#{m}(*args) do |*objects| 
+				objects.map! { |o| transaction.may_wrap(o) }
+				yield(*objects)
+			     end
+			 else
+			     __getobj__.#{m}(*args)
+			 end
+		transaction.may_wrap(result)"
+	    end
+
+	    def proxy(*methods)
+		methods.each do |m|
+		    class_eval "def #{m}(*args); #{proxy_code(m)} end"
+		end
+	    end
+	end
+
+	attr_reader :transaction
+	attr_reader :__getobj__
+
+	alias :== :eql?
+
+	def pretty_print(pp)
+	    plan.disable_proxying { super }
+	end
+	def proxying?; plan && plan.proxying? end
+
+	# Uses the +enum+ method on this proxy and on the proxied object to get
+	# a set of objects related to this one in both the plan and the
+	# transaction.
+	# 
+	# The block is then given a plan_object => transaction_object hash, the
+	# relation which is being considered, the set of new relations (the
+	# relations that are in the transaction but not in the plan) and the
+	# set of deleted relation (relations that are in the plan but not in
+	# the transaction)
+	def partition_new_old_relations(enum) # :yield:
+	    trsc_objects = Hash.new
+	    each_relation do |rel|
+		trsc_others = send(enum, rel).
+		    map do |obj| 
+			plan_object = plan.may_unwrap(obj)
+			trsc_objects[plan_object] = obj
+			plan_object
+		    end.to_value_set
+
+		plan_others = __getobj__.send(enum, rel).
+		    find_all { |obj| plan[obj, false] }.
+		    to_value_set
+
+		new = (trsc_others - plan_others)
+		del = (plan_others - trsc_others)
+
+		yield(trsc_objects, rel, new, del)
+	    end
+	end
+
+	# Commits the modifications of this proxy. It copies the relations of
+	# the proxy on the proxied object
+	def commit_transaction
+	    real_object = __getobj__
+	    partition_new_old_relations(:parent_objects) do |trsc_objects, rel, new, del|
+		for other in new
+		    other.add_child_object(real_object, rel, trsc_objects[other][self, rel])
+		end
+		for other in del
+		    other.remove_child_object(real_object, rel)
+		end
+	    end
+
+	    partition_new_old_relations(:child_objects) do |trsc_objects, rel, new, del|
+		for other in new
+		    real_object.add_child_object(other, rel, self[trsc_objects[other], rel])
+		end
+		for other in del
+		    real_object.remove_child_object(other, rel)
+		end
+	    end
+
+	    super if defined? super
+	end
+
+	# Discards the transaction by clearing this proxy
+	def discard_transaction
+	    clear_vertex
+	    super if defined? super
+	end
+    end
+
+    # Proxy for Roby::EventGenerator
+    class EventGenerator < Roby::EventGenerator
+	include Proxy
+	proxy_for Roby::EventGenerator
+	
+	def_delegator :@__getobj__, :symbol
+	def_delegator :@__getobj__, :model
+	proxy :can_signal?
+
+	def initialize(object, transaction)
+	    super(object, transaction)
+	    @unreachable_handlers = []
+	    if object.controlable?
+		self.command = method(:emit)
+	    end
+	end
+
+	def commit_transaction
+	    super
+	    handlers.each { |h| __getobj__.on(&h) }
+	end
+
+	def_delegator :@__getobj__, :owners
+	def_delegator :@__getobj__, :distribute?
+	def has_sibling?(peer); plan.has_sibling?(peer) end
+
+	def executable?; false end
+	def unreachable!; end
+    end
+
+    # Transaction proxy for Roby::TaskEventGenerator
+    class TaskEventGenerator < Roby::Transactions::EventGenerator
+	proxy_for Roby::TaskEventGenerator
+
+        # The transaction proxy which represents the event generator's real
+        # task
+	attr_reader :task
+	child_plan_object :task
+
+        # Create a new proxy representing +object+ in +transaction+
+	def initialize(object, transaction)
+	    super(object, transaction)
+	    @task = transaction.wrap(object.task)
+	end
+
+        # Task event generators do not have siblings on remote plan managers.
+        # They are always referenced by their name and task.
+	def has_sibling?(peer); false end
+    end
+
+    # Transaction proxy for Roby::Task
+    class Task < Roby::Task
+	include Proxy
+	proxy_for Roby::Task
+
+	def_delegator :@__getobj__, :running?
+	def_delegator :@__getobj__, :finished?
+	def_delegator :@__getobj__, :pending?
+	def_delegator :@__getobj__, :model
+	def_delegator :@__getobj__, :has_event?
+
+	def_delegator :@__getobj__, :pending?
+	def_delegator :@__getobj__, :running?
+	def_delegator :@__getobj__, :success?
+	def_delegator :@__getobj__, :failed?
+	def_delegator :@__getobj__, :finished?
+
+	proxy :event
+	proxy :each_event
+	alias :each_plan_child :each_event
+	proxy :fullfills?
+	proxy :same_state?
+
+        # Create a new proxy representing +object+ in +transaction+
+	def initialize(object, transaction)
+	    super(object, transaction)
+
+	    @arguments = Roby::TaskArguments.new(self)
+	    object.arguments.each do |key, value|
+		if value.kind_of?(Roby::PlanObject)
+		    arguments.update!(key, transaction[value])
+		else
+		    arguments.update!(key, value)
+		end
+	    end
+	end
+
+        # There is no bound_events map in task proxies. The proxy instead
+        # enumerates the real task's events and create proxies when needed.
+        #
+        # #bound_events is not part of the public API anyways
+	def bound_events; {} end
+
+	def instantiate_model_event_relations # :nodoc:
+	end
+       
+        # Transaction proxies are never executable
+	def executable?; false end
+
+        # Transaction proxies do not have history
+	def history; "" end
+	def plan=(new_plan) # :nodoc:
+	    if new_plan && new_plan.plan != __getobj__.plan
+		raise "invalid plan #{new_plan}"
+	    end
+	    @plan = new_plan
+	end
+
+        # Perform the operations needed for the commit to be successful.  In
+        # practice, it updates the task arguments as needed.
+	def commit_transaction
+	    super
+	    
+	    # Update the task arguments. The original
+	    # Roby::Task#commit_transaction has already translated the proxy
+	    # objects into real objects
+	    arguments.each do |key, value|
+		__getobj__.arguments.update!(key, value)
+	    end
+	end
+
+        # Perform the operations needed for the transaction to be discarded.
+	def discard_transaction
+	    clear_relations
+	end
+
+	def method_missing(m, *args, &block) # :nodoc:
+	    if m.to_s =~ /^(\w+)!$/ && has_event?($1.to_sym)
+		event($1.to_sym).call(*args)
+	    elsif !Roby::Task.method_defined?(m)
+		__getobj__.send(m, *args, &block)
+	    else
+		super
+	    end
+	end
+
+	def_delegator :@__getobj__, :owners
+	def_delegator :@__getobj__, :distribute?
+
+        # True if +peer+ has a representation of this object
+	def has_sibling?(peer)
+	    plan.has_sibling?(peer)
+	end
+    end
+end
+

data/lib/roby/transactions/updates.rb

@@ -0,0 +1,139 @@
+module Roby
+    class SolverInvalidateTransaction
+	def self.finalized_plan_task(trsc, task); end
+	def self.finalized_plan_event(trsc, task); end
+
+	def self.adding_plan_relation(trsc, parent, child, relations, info)
+	end
+	def self.removing_plan_relation(trsc, parent, child, relations)
+	end
+    end
+
+    class SolverUpdateRelations
+	def self.finalized_plan_task(trsc, task)
+	end
+	def self.finalized_plan_event(trsc, task)
+	end
+
+	def self.adding_plan_relation(trsc, parent, child, relations, info)
+	    parent_proxy = trsc.wrap(parent)
+	    child_proxy  = trsc.wrap(child)
+	    for rel in relations
+		rel.link(parent_proxy, child_proxy, info)	   
+	    end
+	    trsc.invalid = false
+	end
+	def self.removing_plan_relation(trsc, parent, child, relations)
+	    parent_proxy = trsc.wrap(parent)
+	    child_proxy  = trsc.wrap(child)
+	    for rel in relations
+		rel.unlink(parent_proxy, child_proxy)
+	    end
+	    trsc.invalid = false
+	end
+    end
+
+    class SolverIgnoreUpdate
+	def finalized_plan_task(trsc, task)
+	    Roby.debug "#{trsc} is valid again"
+	    trsc.invalid = false
+	end
+	def finalized_plan_event(trsc, task)
+	    Roby.debug "#{trsc} is valid again"
+	    trsc.invalid = false
+	end
+
+	def adding_plan_relation(trsc, parent, child, relations, info)
+	    Roby.debug "#{trsc} is valid again"
+	    trsc.invalid = false
+	end
+	def removing_plan_relation(trsc, parent, child, relations)
+	    Roby.debug "#{trsc} is valid again"
+	    trsc.invalid = false
+	end
+    end
+    class Transaction
+	def finalized_plan_task(task)
+	    invalidate("task #{task} has been removed from the plan")
+	    discard_modifications(task)
+	    conflict_solver.finalized_plan_task(self, task)
+	end
+
+	def finalized_plan_event(event)
+	    invalidate("event #{event} has been removed from the plan")
+	    discard_modifications(event)
+	    conflict_solver.finalized_plan_event(self, event)
+	end
+
+	def adding_plan_relation(parent, child, relations, info)
+	    missing_relations = relations.find_all do |rel|
+		!parent.child_object?(child, rel)
+	    end
+	    unless missing_relations.empty?
+		invalidate("plan added a relation #{parent} -> #{child} in #{relations} with info #{info}")
+		conflict_solver.adding_plan_relation(self, parent, child, relations, info)
+	    end
+	end
+
+	def removing_plan_relation(parent, child, relations)
+	    present_relations = relations.find_all do |rel|
+		parent.child_object?(child, rel)
+	    end
+	    unless present_relations.empty?
+		invalidate("plan removed the #{parent} -> #{child} relation in #{relations}")
+		conflict_solver.removing_plan_relation(self, parent, child, relations)
+	    end
+	end
+    end
+
+    module Transactions
+	module PlanUpdates
+	    def self.finalized_object(plan, object) 
+		return unless object.root_object?
+		plan.transactions.each do |trsc|
+		    next unless trsc.proxying?
+
+		    if proxy = trsc.wrap(object, false)
+			yield(trsc, proxy)
+		    end
+		end
+	    end
+	    def finalized_event(event)
+		super if defined? super
+		PlanUpdates.finalized_object(self, event) { |trsc, proxy| trsc.finalized_plan_event(proxy) }
+	    end
+	    def finalized_task(task)
+		super if defined? super
+		PlanUpdates.finalized_object(self, task) { |trsc, proxy| trsc.finalized_plan_task(proxy) }
+	    end
+	end
+	Roby::Plan.include PlanUpdates
+
+	module PlanObjectUpdates
+	    def adding_child_object(child, relations, info)
+		super if defined? super
+		return if !plan
+
+		for trsc in plan.transactions
+		    next unless trsc.proxying?
+		    if (parent_proxy = trsc[self, false]) && (child_proxy = trsc[child, false])
+			trsc.adding_plan_relation(parent_proxy, child_proxy, relations, info) 
+		    end
+		end
+	    end
+	    def removing_child_object(child, relations)
+		super if defined? super
+		return if !plan
+
+		plan.transactions.each do |trsc|
+		    next unless trsc.proxying?
+		    if (parent_proxy = trsc[self, false]) && (child_proxy = trsc[child, false])
+			trsc.removing_plan_relation(parent_proxy, child_proxy, relations) 
+		    end
+		end
+	    end
+	end
+	Roby::PlanObject.include PlanObjectUpdates
+    end
+end
+

data/plugins/fault_injection/History.txt

@@ -0,0 +1,4 @@
+=== 0.1 / 2008-04-15
+
+* First public release, along with Roby 0.7
+

data/plugins/fault_injection/README.txt

@@ -0,0 +1,37 @@
+
+http://rubyforge.org/projects/roby
+
+= Fault injection plugin for Roby
+
+This is a fault injection plugin for the Roby robotic control framework. It
+allows to test the management of rarely occuring events by simulating the
+emission of those events. This plugin relies only on the core Roby library.
+
+== Usage
+
+The fault injection plugin can be used in a system to inject some spurious
+events randomly. To set it up, one must call Application#add_fault_model
+in the configuration files of the application. For instance,
+
+  Roby.app.add_fault_model P3d::Track,
+        :no_path, :blocked,
+        Roby::FaultInjection::Rate.new(500, 0.3)
+  
+Would inject events :no_path and :blocked randomly on any task of the P3d:Track
+model. The probability distribution used is a rate distribution with MTTF of
+500s and base probability of 0.3. See Roby::FaultInjection for the description
+of the available probability distributions.
+
+== Enabling the plugin
+
+The plugin must be enabled in the configuration files (i.e. either in
+<tt>config/init.rb</tt> or in one of the robot-specific files) through a call
+to Roby.app.using:
+
+  Roby.app.using 'fault_injection'
+
+== License:
+
+This work is licensed under the CeCiLL-B license, which is a free software
+license similar to the BSD license. See License.txt for details.
+