roby 0.8.0 → 3.0.0

data/lib/roby/transactions/proxy.rb

@@ -1,325 +0,0 @@
-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)
-            if plan
-                plan.disable_proxying { super }
-            else
-                super
-            end
-	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 to_s; "tProxy(#{__getobj__.name})#{arguments}" end
-
-	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 :same_state?
-
-        def each_plan_child(only_wrapped = false, &block)
-            each_event(only_wrapped, &block)
-        end
-
-        def each_event(only_wrapped = false)
-            __getobj__.each_event(only_wrapped) do |ev|
-                if proxy = plan[ev, !only_wrapped]
-                    yield(proxy)
-                end
-            end
-            self
-        end
-
-        def kind_of?(klass)
-            super || __getobj__.kind_of?(klass)
-        end
-
-	# Remove all relations in which +self+ or its event are involved
-	def clear_relations
-            each_event(true) do |ev|
-                ev.clear_relations
-            end
-            super(false)
-            self
-	end
-
-        # 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 
-                if new_plan.plan != __getobj__.plan
-                    raise "invalid plan #{new_plan}"
-                elsif !new_plan.kind_of?(Roby::Transaction)
-                    raise "trying to insert a transaction proxy in something else than a transaction (#{new_plan})"
-                end
-            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/plugins/fault_injection/History.txt

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

data/plugins/fault_injection/README.txt

@@ -1,34 +0,0 @@
-= 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.
-

data/plugins/fault_injection/Rakefile

@@ -1,12 +0,0 @@
-if ENV['ROBY_ROOT_DIR']
-    $LOAD_PATH << File.join(ENV['ROBY_ROOT_DIR'], 'lib')
-end
-require 'roby/app/plugins/rake'
-
-Roby::Rake.plugin_doc("fault_injection") do |rdoc|
-  rdoc.title    = "Fault injection plugin for Roby"
-  rdoc.options << '--main' << 'README.txt'
-  rdoc.rdoc_files.include('README.txt', 'TODO.txt', 'History.txt')
-  rdoc.rdoc_files.include('fault_injection.rb', 'app.rb')
-end
-

data/plugins/fault_injection/app.rb

@@ -1,52 +0,0 @@
-
-module Roby
-    # Fault injection plugin for Roby
-    #
-    # Roby::FaultInjection::Application#fault_models defines a set of
-    # probabilistic models of emission for task events. It maps task model
-    # events to emission models, and during execution will randomly emit
-    # events.
-    #
-    # Fault injection applies only on tasks which are running and interruptible.
-    module FaultInjection
-	# This module gets included in Roby::Application when the plugin is activated
-	module Application
-	    # The set of fault models defined for this application. More specifically,
-	    # the emission model for an event +ev+ of a task model +model+ is given by
-	    #
-	    #   emission_model = Roby.app.fault_models[model][ev]
-	    #
-	    # where +ev+ is a symbol.
-	    attribute(:fault_models) do
-		Hash.new { |h, k| h[k] = Hash.new }
-	    end
-
-	    # call-seq:
-	    #   Roby.app.fault_model task_model, emission_model, ev1, ev2, ...
-	    #
-	    # Defines +emission_model+ as the emission model for the listed
-	    # events of task +task_model+. +ev1+, +ev2+ are symbols.
-	    #
-	    # Emission models are objects which must respond to #fault?(task).
-	    # If this predicate returns true for the running task +task+, then
-	    # the emission of the tested event will be simulated. The emission
-	    # models are tested every one second.
-	    #
-	    # See Roby::FaultInjection::Rate for an example.
-	    def add_fault_model(task_model, *args)
-		fault_model = args.pop
-		args.each do |ev|
-		    fault_models[task_model][ev.to_sym] = fault_model
-		end
-	    end
-	end
-    end
-
-    Application.register_plugin('fault_injection', Roby::FaultInjection::Application) do
-	require 'fault_injection'
-	Roby.every(1) do
-	    FaultInjection.apply(Roby.app.fault_models, Roby.plan)
-	end
-    end
-end
-

data/plugins/fault_injection/fault_injection.rb

@@ -1,89 +0,0 @@
-module Roby
-    class Task
-	# Returns for how many seconds this task is running.  Returns nil if
-	# the task is not running.
-	def lifetime
-	    if running?
-		Time.now - history.first.time
-	    end
-	end
-    end
-
-    module FaultInjection
-	extend Logger::Hierarchy
-	extend Logger::Forward
-	
-	# This fault model is based on a constant fault rate, defined upon the
-	# mean-time-to-failure of the task.
-	#
-	# In this model, the probability of having a fault for task t at any
-	# given instant is
-	#
-	#   p(fault) = max * (1.0 - exp(- task.lifetime / mttf))
-	#
-	class Rate
-	    attr_reader :mttf, :max
-	    def initialize(mttf, max = 1.0)
-		@mttf, @max = mttf, max
-	    end
-
-	    def fault?(task)
-		f = max * (1.0 - Math.exp(- task.lifetime / mttf))
-		rand <= f
-	    end
-	end
-
-	# Apply the given fault models to the main Roby plan
-	def self.apply(fault_models, plan)
-	    injected_faults = Array.new
-
-	    for model, faults in fault_models
-		for ev, p in faults
-		    plan.find_tasks(model).
-			running.not_finishing.
-			interruptible.each do |task|
-			    if p.fault?(task)
-				FaultInjection.info "injecting fault #{ev} on #{task}"
-				injected_faults << [task, ev, task.inject_fault(ev)]
-			    end
-			end
-		end
-	    end
-
-	    injected_faults
-	end
-    end
-
-    class Task
-	# Makes the plan behave as if this task had failed by emitting the
-	# event +event+ with context +context+.
-	#
-	# The task must be running and interruptible, and +event+ must be
-	# terminal. The default implementation creates a duplicate of this task
-	# by using #dup and forwards the +stop+ event of the old task to
-	# +event+ on the new one.
-	#
-	# It returns a new task which replaced this one in the plan. This is
-	# the task on which +event+ will actually be emitted.
-	def inject_fault(event, context = nil)
-	    if !running?
-		raise ArgumentError, "this task is not running"
-	    elsif finishing?
-		raise ArgumentError, "this task is being stopped"
-	    elsif !interruptible?
-		raise ArgumentError, "fault injection works only on interruptible tasks"
-	    elsif !event(event).terminal?
-		raise ArgumentError, "the injected fault must be a terminal event"
-	    end
-
-	    new_task = dup
-	    old_task = self
-
-	    plan.replace_task(old_task, new_task)
-	    old_task.event(:stop).filter(context).forward_to new_task.event(event)
-
-	    new_task
-	end
-    end
-end
-