roby 0.8.0 → 3.0.0

data/plugins/fault_injection/test/test_fault_injection.rb

@@ -1,78 +0,0 @@
-$LOAD_PATH.unshift File.expand_path( '..', File.dirname(__FILE__))
-require 'test/unit'
-require 'roby'
-require 'roby/test/common'
-require 'roby/test/tasks/simple_task'
-require 'fault_injection'
-
-class TC_FaultInjection < Test::Unit::TestCase
-    include Roby::Test
-    include Roby::Test::Assertions
-
-    def test_inject_fault
-        model = Class.new(Roby::Test::SimpleTask) do
-            event :specialized_fault
-            forward :specialized_fault => :failed
-        end
-        plan.add_permanent(task = model.new)
-
-        engine.run
-
-        assert_any_event(task.start_event) do
-	    assert_raises(ArgumentError) { task.inject_fault(:start) }
-	    task.start!
-	end
-
-	fake_task = nil
-	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
-
-	assert(fake_task.finished?)
-	assert(fake_task.event(:specialized_fault).happened?)
-    end
-
-    def test_apply
-	model = Class.new(Roby::Test::SimpleTask) do
-	    event :specialized_fault
-	    forward :specialized_fault => :failed
-	end
-
-	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
-	
-        engine.run
-
-        assert_any_event(both_started) do
-	    simple.start!
-	    specialized.start!
-	end
-
-        fake_specialized = engine.execute do
-	    result = Roby::FaultInjection.apply(fault_models, plan)
-	    assert_equal(1, result.size)
-	    result.first.last
-	end
-	engine.wait_one_cycle
-
-	assert(simple.running?)
-	assert(specialized.finished?)
-	assert(fake_specialized.finished?)
-	assert(fake_specialized.event(:specialized_fault).happened?)
-    end
-
-    def test_task_lifetime
-	plan.discover(task = Roby::Test::SimpleTask.new)
-	task.start!
-	sleep(0.5)
-	assert(task.lifetime > 0.5)
-    end
-end
-

data/plugins/subsystems/README.txt

@@ -1,37 +0,0 @@
-= Subsystems plugin for Roby
-
-This is a plugin for the Roby robotic control framework. It allows to generate
-an initial plan in which a set of common subsystems (sensors, localization,
-...) are already initialized, easing later the writing and management of the
-planning methods for other, more dynamical actions.
-
-== Usage
-
-A set of services can be defined on <tt>State.services</tt> like this:
-
-  State.services.localization = 'pom'
-  State.services.camera = 'cam'
-
-Then, at controller initialization and before the controller file is actually
-loaded, the corresponding planning methods are called to generate a plan in which those
-subsystems are present:
-
-  planner.localization(:id => 'pom')
-  planner.camera(:id => 'cam')
-
-The returned tasks are also started, in order. The controller file gets loaded
-only when the subsystems are ready (i.e. their start events are emitted).
-
-== 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 'subsystems'
-
-== 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/subsystems/Rakefile

@@ -1,13 +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("subsystems") do |rdoc|
-  rdoc.title    = "Subsystems plugin for Roby"
-  rdoc.template = Roby::Rake.rdoc_template
-  rdoc.options << '--main' << 'README.txt'
-  rdoc.rdoc_files.include('README.txt')
-  rdoc.rdoc_files.include('app.rb')
-end
-

data/plugins/subsystems/app.rb

@@ -1,182 +0,0 @@
-
-module Roby
-    # Subsystem plugin for Roby
-    #
-    # This plugin manages a set of services that should be available at all
-    # times (for instance: localization). For now, it makes Roby start them at
-    # initialization time, allowing to consider that they are always available
-    # during plan generation afterwards.
-    #
-    # == Subsystems at initialization
-    # The set of subsystems that should be considered is to be set through the State.services
-    # configuration object:
-    #
-    #   State.services do |sys|
-    #	  sys.localization = 'pom'
-    #	  sys.laser_ranges = 'sick'
-    #	end
-    #
-    # The subsystem plugin will then use <tt>MainPlanner#subsystem_name(:id =>
-    # 'subsystem_selected')</tt> to generate the subsystems' plans. In the
-    # example above, the initial plan will be made using
-    #
-    #   planner.localization(:id => 'pom')
-    #   planner.laser_ranges(:id => 'sick')
-    #
-    # The resulting plan is then started one subsystem after the other
-    # <b>before</b> the controller is loaded
-    #
-    # == Subsystems and state update
-    #
-    # If the main tasks representing the subsystem -- the one returned by the
-    # planning methods, respond to update_<sysname>(state), that method is
-    # called, provided that the task is running, at every cycle with the
-    # system's state representation as an argument.
-    #
-    # For instance, the Localization task which represents the localization
-    # subsystems can have a #update_localization method which takes an
-    # argument. This method would update at each cycle the system's position in
-    # the state representation.
-    module Subsystems
-	module Application
-	    def self.setup_main_planner
-		MainPlanner.class_eval do
-		    Roby::State.services.each_member do |name, value|
-			filter(name) do |options, method|
-			    options[:id] || method.id.to_s == value.to_s
-			end
-		    end
-		end
-	    end
-
-	    # This method generates the initial plan built upon the set of
-	    # required subsystems.
-	    def self.initialize_plan(plan)
-		setup_main_planner
-		trsc = Transaction.new(plan)
-
-		# Event which is emitted when all subsystems are properly
-		# initialized
-		ready = AndGenerator.new
-
-		# Create the one task for each subsystem. +ready+ is an event
-		# which is fired when all subsystems are properly initialized
-		planner = MainPlanner.new(trsc)
-
-		tasks = Array.new
-		task_objects = ValueSet.new
-		State.services.each_member do |name, value|
-		    next if name == 'tasks'
-		    new_task = begin
-				   planner.send(name)
-			       rescue Planning::NotFound => e
-				   raise RuntimeError, e.full_message
-			       end
-
-		    State.services.tasks.send("#{name}=", new_task)
-
-		    trsc.add_permanent(new_task)
-		    started_with = if new_task.has_event?(:ready) then :ready
-				   else :start
-				   end
-
-		    ready << new_task.event(started_with)
-
-		    new_task.on(started_with) do
-			Robot.info "#{name} subsystem started (#{value})"
-		    end
-		    new_task.on(:stop) do
-			Robot.info "#{name} subsystem stopped (#{value})"
-		    end
-
-		    tasks << [name, value, new_task]
-		    task_objects << new_task
-		end
-
-		# We make sure each subsystem is started only when all the
-		# other subsystems it depends on are started and ready.
-		# +start_with+ is the event which should be called to start
-		# everything
-		starting_point = EventGenerator.new(true)
-		tasks.each do |name, type, task|
-		    children = task.generated_subgraph(TaskStructure::Hierarchy) & task_objects
-		    children.delete(task)
-
-		    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
-						else :start
-						end
-				 ev << child.event(started_with)
-			     end
-			 end
-
-		    ev.on { Robot.info "starting subsystem #{name} (#{type})" }
-		    ev.signals task.event(:start)
-		end
-
-		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(app, &block)
-		unless Roby::State.services? && !Roby::State.services.empty?
-		    Robot.info "No subsystems defined"
-		    return yield
-		end
-
-		Robot.info "Starting subsystems ..."
-
-		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
-                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
-
-    Application.register_plugin('subsystems', Roby::Subsystems::Application) do
-	# Call the #update_ methods for the subsystems tasks which define it.
-	Roby.each_cycle do
-	    srv = Roby::State.services
-	    srv.each_member do |name, value|
-		task = srv.tasks.send(name)
-		next unless task.running?
-		if task.has_event?(:ready)
-		    next unless task.event(:ready).happened?
-		end
-
-		if task.respond_to?("update_#{name}")
-		    begin
-			task.send("update_#{name}", State)
-		    rescue Exception => e
-			Roby.warn "update_#{name} failed on #{task} with #{e}"
-		    end
-		end
-	    end
-	end
-    end
-end

data/plugins/subsystems/test/app/README

@@ -1,24 +0,0 @@
-== Directories
-A basic Roby application has the following directories:
-config:: configuration files. config/init.rb is the main configuration file (loaded
-	 by all robots). Robot-specific configuration is in config/ROBOTNAME.rb.
-	 The main Roby configuration file is config/roby.yml. The default file
-         describes all available configuration options.
-planners:: planner models. Global planners (shared by all robots) are in
-	   planners/. Robot-specific planners are in planners/ROBOTNAME/
-controllers:: robot controllers. These files are supposed to start the basic robot
-	      services, to make the robot ready. A robot shall have a controllers/ROBOTNAME.rb
-	      file which does that.
-tasks:: task models
-data:: where all data files are. See #find_data.
-scripts:: various scripts needed to run and debug a Roby application
-
-The basic directory structure, and the global files, are installed by <tt>roby init</tt>. Basic
-robot files can be added by <tt>roby robot ROBOTNAME</tt>
-
-== Genom/Pocosim integration
-An application can use the Genom/Pocosim integration by calling <tt>roby init --module genom</tt>.
-The following files and directories are added:
-config/ROBOTNAME-genom.rb:: Genom-specific configuration for ROBOTNAME
-tasks/genom/:: per-Genom module tasks
-

data/plugins/subsystems/test/app/Rakefile

@@ -1,8 +0,0 @@
-require 'rake/rdoctask'
-
-Rake::RDocTask.new('doc') do |doc|
-    doc.rdoc_files.include 'README'
-    doc.rdoc_files.include 'tasks/**/*.rb'
-    doc.rdoc_files.include 'planners/**/*.rb'
-    doc.rdoc_files.include 'controllers/**/*.rb'
-end

data/plugins/subsystems/test/app/config/app.yml

@@ -1,71 +0,0 @@
-# dRoby neighbour discovery
-discovery:
-  # The host:port at which we can connect to a discovery tuplespace
-  # (default: no discovery tuplespace)
-  # tuplespace: "localhost:29568"
-  # The port at which we do ring discovery (default: disabled)
-  # ring: 42865
-
-# dRoby host configuration
-droby:
-  # How many errors are allowed before disconnecting from a peer
-  # (default: 10)
-  # max_errors: 1
-  # The ring discovery period if we do ring discovery (default: 0.5)
-  # period: 0.5
-
-# Pocosim configuration
-pocosim:
-  # The host of the GDHE display
-  # display: localhost
-
-  # An initialization script to display the scene on GDHE. The file is searched
-  # in the data/ director
-  # gdhe: lousa.gdhe
-  
-  # The Gazebo world file for pocosim/gazebo simulations. The file is searched
-  # in the data/ directory 
-  # gazebo: lousa.world
-
-# Logging configuration
-log:
-  # Log system events (default: false)
-  # events: true
-  
-  # Disables the log server (default: enabled)
-  # server: false
-  #
-  # ... or configure it
-  # server:
-  #     # The port to listen on (for service discovery)
-  #     port: 48933
-  #     # The discovery period
-  #     period: 10
-
-  # Logging levels. It is a hash of Component: level (where level
-  # is one of DEBUG, INFO, WARN and FATAL).
-  # levels:
-  #   Roby: INFO
-  #   Genom: INFO
-
-# Control configuration
-control:
-  # Abort if a task/event exception is not caught (default: false)
-  # abort_on_exception: true
-  # Abort if an application exception occurs (default: false)
-  # abort_on_application_exception: true
-  
-  # If the GC should be run at each control loop (default: false)
-  # WARNING: for now, the performance hit for GCing at each control loop
-  # WARNING: is too high
-  # control_gc: false
-
-
-# Per-robot configuration. In these, you can override global options, or set
-# new options.
-# dala:
-#   droby:
-#     # The host:port at which this robot listens
-#     host: "localhost:1287"
-
-# vim: sw=2

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

@@ -1,12 +0,0 @@
-# This file is called to do application-global configuration. For configuration
-# specific to a robot, edit config/NAME.rb, where NAME is the robot name.
-
-# Require Roby components
-#
-# Roby.app.using 'planning'
-# Roby.app.using 'distributed'
-# Roby.app.using 'genom'
-
-require 'roby/schedulers/basic'
-Roby.scheduler = Roby::Schedulers::Basic.new
-

data/plugins/subsystems/test/app/config/roby.yml

@@ -1,3 +0,0 @@
---- 
-plugins: 
-- subsystems

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

@@ -1,20 +0,0 @@
-# The main planner. A planner of this model is automatically added in the
-# Interface planner list.
-class MainPlanner < Roby::Planning::Planner
-    method(:navigation, :returns => Services::Navigation)
-    method(:localization, :returns => Services::Localization)
-
-    method(:localization, :id => 'test') do
-	Services::Localization.new(:id => 'localization')
-    end
-    method(:localization, :id => 'another') do
-	Services::Localization.new(:id => 'another_localization')
-    end
-
-    method(:navigation, :id => 'test') do
-	root = Services::Navigation.new
-	root.depends_on(loc = localization)
-	root
-    end
-end
-