roby 0.7.3 → 0.8.0

data/lib/roby/transactions/proxy.rb

@@ -78,7 +78,11 @@ module Roby::Transactions
 	alias :== :eql?
 
 	def pretty_print(pp)
-	    plan.disable_proxying { super }
+            if plan
+                plan.disable_proxying { super }
+            else
+                super
+            end
 	end
 	def proxying?; plan && plan.proxying? end
 
@@ -199,6 +203,8 @@ module Roby::Transactions
 	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?
@@ -212,11 +218,34 @@ module Roby::Transactions
 	def_delegator :@__getobj__, :finished?
 
 	proxy :event
-	proxy :each_event
-	alias :each_plan_child :each_event
-	proxy :fullfills?
 	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)
@@ -246,9 +275,13 @@ module Roby::Transactions
         # 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
+	    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
 

data/manifest.xml

@@ -0,0 +1,20 @@
+<package>
+  <description brief="advanced supervision framework">
+  </description>
+  <author>Sylvain Joyeux/sylvain.joyeux@m4x.org</author>
+  <copyright>
+      LAAS-CNRS/openrobots@laas.fr
+      DFKI/robotik@dfki.de
+      Sylvain Joyeux/sylvain.joyeux@m4x.org
+  </copyright>
+  <license>CeCILL-B (BSD-like)</license>
+
+  <depend package="utilmm" />
+  <depend package="utilrb" />
+  <rosdep name="flexmock" />
+  <rosdep name="activesupport" />
+  <rosdep name="qtruby" />
+  <rosdep name="boost" />
+  <rosdep name="graphviz" />
+</package>
+

data/plugins/fault_injection/README.txt

@@ -1,6 +1,3 @@
-
-http://rubyforge.org/projects/roby
-
 = Fault injection plugin for Roby
 
 This is a fault injection plugin for the Roby robotic control framework. It

data/plugins/fault_injection/Rakefile

@@ -1,16 +1,10 @@
-rdoc_base_dir = Dir.pwd
 if ENV['ROBY_ROOT_DIR']
     $LOAD_PATH << File.join(ENV['ROBY_ROOT_DIR'], 'lib')
-    rdoc_base_dir = ENV['ROBY_ROOT_DIR']
 end
-require 'rake/rdoctask'
-require 'roby/app/rake'
+require 'roby/app/plugins/rake'
 
-Rake::RDocTask.new("docs") do |rdoc|
-  rdoc.options << "--inline-source" << "--accessor" << "attribute" << "--accessor" << "attr_predicate"
-  rdoc.rdoc_dir = "#{rdoc_base_dir}/doc/rdoc/plugins/fault_injection"
+Roby::Rake.plugin_doc("fault_injection") do |rdoc|
   rdoc.title    = "Fault injection plugin for Roby"
-  rdoc.template = Roby::Rake.rdoc_template
   rdoc.options << '--main' << 'README.txt'
   rdoc.rdoc_files.include('README.txt', 'TODO.txt', 'History.txt')
   rdoc.rdoc_files.include('fault_injection.rb', 'app.rb')

data/plugins/fault_injection/app.rb

@@ -45,7 +45,7 @@ module Roby
     Application.register_plugin('fault_injection', Roby::FaultInjection::Application) do
 	require 'fault_injection'
 	Roby.every(1) do
-	    FaultInjection.apply(Roby.app.fault_models)
+	    FaultInjection.apply(Roby.app.fault_models, Roby.plan)
 	end
     end
 end

data/plugins/fault_injection/fault_injection.rb

@@ -34,12 +34,12 @@ module Roby
 	end
 
 	# Apply the given fault models to the main Roby plan
-	def self.apply(fault_models)
+	def self.apply(fault_models, plan)
 	    injected_faults = Array.new
 
 	    for model, faults in fault_models
 		for ev, p in faults
-		    Roby.plan.find_tasks(model).
+		    plan.find_tasks(model).
 			running.not_finishing.
 			interruptible.each do |task|
 			    if p.fault?(task)
@@ -80,7 +80,7 @@ module Roby
 	    old_task = self
 
 	    plan.replace_task(old_task, new_task)
-	    old_task.event(:stop).filter(context).forward new_task.event(event)
+	    old_task.event(:stop).filter(context).forward_to new_task.event(event)
 
 	    new_task
 	end

data/plugins/fault_injection/test/test_fault_injection.rb

@@ -7,40 +7,35 @@ require 'fault_injection'
 
 class TC_FaultInjection < Test::Unit::TestCase
     include Roby::Test
+    include Roby::Test::Assertions
 
     def test_inject_fault
-	Roby.control.run :detach => true
+        model = Class.new(Roby::Test::SimpleTask) do
+            event :specialized_fault
+            forward :specialized_fault => :failed
+        end
+        plan.add_permanent(task = model.new)
 
-	task = nil
-	Roby.execute do
-	    model = Class.new(Roby::Test::SimpleTask) do
-		event :specialized_fault
-		forward :specialized_fault => :failed
-	    end
+        engine.run
 
-	    plan.permanent(task = model.new)
+        assert_any_event(task.start_event) do
 	    assert_raises(ArgumentError) { task.inject_fault(:start) }
-
 	    task.start!
 	end
-	Roby.wait_one_cycle
 
 	fake_task = nil
-	Roby.execute do
+	assert_any_event(task.stop_event) do
 	    assert_raises(ArgumentError) { task.inject_fault(:updated_data) }
 	    assert_nothing_raised { task.inject_fault(:specialized_fault) }
 	    assert_equal(2, plan.known_tasks.size)
 	    fake_task = plan.known_tasks.find { |t| t != task }
 	end
-	Roby.wait_one_cycle
 
 	assert(fake_task.finished?)
 	assert(fake_task.event(:specialized_fault).happened?)
     end
 
     def test_apply
-	Roby.control.run :detach => true
-
 	model = Class.new(Roby::Test::SimpleTask) do
 	    event :specialized_fault
 	    forward :specialized_fault => :failed
@@ -49,24 +44,23 @@ class TC_FaultInjection < Test::Unit::TestCase
 	fault_models = Hash.new { |h, k| h[k] = Hash.new }
 	fault_models[model][:specialized_fault] = FaultInjection::Rate.new(0.01, 1.0)
 	fault_models[Roby::Test::SimpleTask][:stop] = FaultInjection::Rate.new(1_000_000, 1.0)
+        plan.add_permanent(simple = Roby::Test::SimpleTask.new)
+        plan.add_permanent(specialized = model.new)
+        both_started = simple.start_event & specialized.start_event
 	
-	simple, specialized = nil
-	Roby.execute do
-	    plan.permanent(simple = Roby::Test::SimpleTask.new)
-	    plan.permanent(specialized = model.new)
+        engine.run
+
+        assert_any_event(both_started) do
 	    simple.start!
 	    specialized.start!
 	end
-	Roby.wait_one_cycle
 
-	sleep(0.5)
-	fake_specialized = nil
-	Roby.execute do
-	    result = Roby::FaultInjection.apply(fault_models)
+        fake_specialized = engine.execute do
+	    result = Roby::FaultInjection.apply(fault_models, plan)
 	    assert_equal(1, result.size)
-	    fake_specialized = result.first.last
+	    result.first.last
 	end
-	Roby.wait_one_cycle
+	engine.wait_one_cycle
 
 	assert(simple.running?)
 	assert(specialized.finished?)

data/plugins/subsystems/README.txt

@@ -1,6 +1,3 @@
-
-http://rubyforge.org/projects/roby
-
 = Subsystems plugin for Roby
 
 This is a plugin for the Roby robotic control framework. It allows to generate

data/plugins/subsystems/Rakefile

@@ -1,14 +1,9 @@
-rdoc_base_dir = Dir.pwd
 if ENV['ROBY_ROOT_DIR']
     $LOAD_PATH << File.join(ENV['ROBY_ROOT_DIR'], 'lib')
-    rdoc_base_dir = ENV['ROBY_ROOT_DIR']
 end
-require 'rake/rdoctask'
-require 'roby/app/rake'
+require 'roby/app/plugins/rake'
 
-Rake::RDocTask.new("docs") do |rdoc|
-  rdoc.options << "--inline-source" << "--accessor" << "attribute" << "--accessor" << "attr_predicate"
-  rdoc.rdoc_dir = "#{rdoc_base_dir}/doc/rdoc/plugins/subsystems"
+Roby::Rake.plugin_doc("subsystems") do |rdoc|
   rdoc.title    = "Subsystems plugin for Roby"
   rdoc.template = Roby::Rake.rdoc_template
   rdoc.options << '--main' << 'README.txt'

data/plugins/subsystems/app.rb

@@ -51,9 +51,9 @@ module Roby
 
 	    # This method generates the initial plan built upon the set of
 	    # required subsystems.
-	    def self.initialize_plan
+	    def self.initialize_plan(plan)
 		setup_main_planner
-		plan = Transaction.new(Roby.plan)
+		trsc = Transaction.new(plan)
 
 		# Event which is emitted when all subsystems are properly
 		# initialized
@@ -61,7 +61,7 @@ module Roby
 
 		# Create the one task for each subsystem. +ready+ is an event
 		# which is fired when all subsystems are properly initialized
-		planner = MainPlanner.new(plan)
+		planner = MainPlanner.new(trsc)
 
 		tasks = Array.new
 		task_objects = ValueSet.new
@@ -75,7 +75,7 @@ module Roby
 
 		    State.services.tasks.send("#{name}=", new_task)
 
-		    plan.permanent(new_task)
+		    trsc.add_permanent(new_task)
 		    started_with = if new_task.has_event?(:ready) then :ready
 				   else :start
 				   end
@@ -104,6 +104,11 @@ module Roby
 
 		    ev = if children.empty?
 			     starting_point
+                         elsif children.size == 1
+                             child = children.first
+                             if child.has_event?(:ready) then child.event(:ready)
+                             else child.event(:start)
+                             end
 			 else
 			     children.inject(AndGenerator.new) do |ev, child|
 				 started_with = if child.has_event?(:ready) then :ready
@@ -114,18 +119,18 @@ module Roby
 			 end
 
 		    ev.on { Robot.info "starting subsystem #{name} (#{type})" }
-		    ev.on task.event(:start)
+		    ev.signals task.event(:start)
 		end
 
-		Roby.execute do
-		    plan.commit_transaction
+		plan.execute do
+		    trsc.commit_transaction
 		end
 		[starting_point, ready]
 	    end
 
 	    # Hook to generate the initial plan and start subsystems when the
 	    # application starts.
-	    def self.run(config, &block)
+	    def self.run(app, &block)
 		unless Roby::State.services? && !Roby::State.services.empty?
 		    Robot.info "No subsystems defined"
 		    return yield
@@ -133,16 +138,22 @@ module Roby
 
 		Robot.info "Starting subsystems ..."
 
-		starting_point, ready = initialize_plan
+		starting_point, ready = initialize_plan(Roby.plan)
 		# Start the deepest tasks. The signalling order will do the rest.
 		# The 'ready' event is emitted when all the subsystem tasks are
-		Roby.wait_until(ready) do
-		    Roby.execute do
-			starting_point.call
-		    end
-		end
-
-		yield
+                begin
+                    Roby.wait_until(ready) do
+                        Roby.execute do
+                            starting_point.call
+                        end
+                    end
+                rescue Exception => e
+                    Robot.fatal "failed to start subsystems"
+                    Roby.log_exception(e, Robot, :fatal)
+                    raise
+                end
+
+		yield if block_given?
 	    end
 	end
     end

data/plugins/subsystems/test/app/config/init.rb

@@ -7,3 +7,6 @@
 # Roby.app.using 'distributed'
 # Roby.app.using 'genom'
 
+require 'roby/schedulers/basic'
+Roby.scheduler = Roby::Schedulers::Basic.new
+

data/plugins/subsystems/test/app/planners/main.rb

@@ -13,7 +13,7 @@ class MainPlanner < Roby::Planning::Planner
 
     method(:navigation, :id => 'test') do
 	root = Services::Navigation.new
-	root.realized_by(loc = localization)
+	root.depends_on(loc = localization)
 	root
     end
 end

data/plugins/subsystems/test/app/tasks/services.rb

@@ -5,7 +5,7 @@ module Services
     class Navigation < SimpleTask; end
     class Localization < SimpleTask
 	event :ready, :command => true
-	on :start => :ready
+	signal :start => :ready
 
 	def update_localization(state)
 	    state.pos += 1

data/plugins/subsystems/test/test_subsystems.rb

@@ -7,10 +7,6 @@ require 'roby/test/tasks/simple_task'
 APP_DIR = File.expand_path('app', File.dirname(__FILE__))
 require "#{APP_DIR}/tasks/services"
 require "#{APP_DIR}/planners/main"
-Roby.app.using :subsystems
-
-State = Roby::State
-Robot = Roby
 
 class TC_Subsystems < Test::Unit::TestCase
     include Roby::Test
@@ -18,12 +14,18 @@ class TC_Subsystems < Test::Unit::TestCase
 
     def setup
 	super
+
+        Roby.app.setup_global_singletons
+        Roby.app.using :subsystems
 	DRb.start_service
-	State.pos = 0
-	State.services do |s|
+	Roby::State.pos = 0
+	Roby::State.services do |s|
 	    s.localization = 'test'
 	    s.navigation   = 'test'
 	end
+
+        @plan = Roby.plan
+        @engine = Roby.engine
     end
 
     def nav_loc
@@ -36,17 +38,19 @@ class TC_Subsystems < Test::Unit::TestCase
     end
 
     def test_initialize_plan
-	start_with, ready = Application.initialize_plan
+	start_with, ready = Application.initialize_plan(plan)
 
 	nav, loc = nav_loc
 	assert(plan.permanent?(nav))
 	assert(plan.permanent?(loc))
-	assert(nav.realized_by?(loc))
+	assert(nav.depends_on?(loc))
 
 	assert_equal([loc.event(:start)], start_with.child_objects(EventStructure::Signal).to_a)
 
-	and_gen = loc.event(:ready).child_objects(EventStructure::Signal).to_a.first
-	assert_equal([nav.event(:start)], and_gen.child_objects(EventStructure::Signal).to_a)
+	signalled_events = loc.event(:ready).child_objects(EventStructure::Signal).to_value_set
+        assert_equal 2, signalled_events.size
+        assert_equal([nav.start_event, ready].to_value_set,
+            loc.event(:ready).child_objects(EventStructure::Signal).to_value_set)
 
 	assert_equal([nav.event(:start), loc.event(:ready)].to_set, ready.parent_objects(EventStructure::Signal).to_set)
 
@@ -57,15 +61,18 @@ class TC_Subsystems < Test::Unit::TestCase
 
     def test_start_subsystems
 	Roby.logger.level = Logger::FATAL
-	Roby.control.run :detach => true
+        Robot.logger.level = Logger::FATAL
+        engine.run
+        Subsystems::Application.run(Roby.app)
 
-	Application.run(Roby.app) { }
-	nav, loc = nav_loc
-	assert(nav.running?)
-	assert(loc.running?)
+        Roby.execute do
+            nav, loc = nav_loc
+            assert(nav.running?)
+            assert(loc.running?)
+        end
 
 	sleep(0.5)
-	assert(State.pos > 0)
+	assert(Roby::State.pos > 0)
     end
 end