roby 0.7

data/plugins/subsystems/test/app/README

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,71 @@
+# 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

@@ -0,0 +1,9 @@
+# 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'
+

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

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

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

@@ -0,0 +1,20 @@
+# 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.realized_by(loc = localization)
+	root
+    end
+end
+

data/plugins/subsystems/test/app/scripts/distributed

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+APP_DIR = File.expand_path('..', File.dirname(__FILE__))
+require 'roby/app/scripts/distributed'

data/plugins/subsystems/test/app/scripts/replay

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+APP_DIR = File.expand_path('..', File.dirname(__FILE__))
+require 'roby/app/scripts/replay'

data/plugins/subsystems/test/app/scripts/results

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+APP_DIR = File.expand_path('..', File.dirname(__FILE__))
+require 'roby/app/scripts/results'

data/plugins/subsystems/test/app/scripts/run

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+APP_DIR = File.expand_path('..', File.dirname(__FILE__))
+require 'roby/app/scripts/run'

data/plugins/subsystems/test/app/scripts/server

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+APP_DIR = File.expand_path('..', File.dirname(__FILE__))
+require 'roby/app/scripts/server'

data/plugins/subsystems/test/app/scripts/shell

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+APP_DIR = File.expand_path('..', File.dirname(__FILE__))
+require 'roby/app/scripts/shell'

data/plugins/subsystems/test/app/scripts/test

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+APP_DIR = File.expand_path('..', File.dirname(__FILE__))
+require 'roby/app/scripts/test'

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

@@ -0,0 +1,15 @@
+require 'roby/test/tasks/simple_task'
+SimpleTask = Roby::Test::SimpleTask
+
+module Services
+    class Navigation < SimpleTask; end
+    class Localization < SimpleTask
+	event :ready, :command => true
+	on :start => :ready
+
+	def update_localization(state)
+	    state.pos += 1
+	end
+    end
+end
+

data/plugins/subsystems/test/test_subsystems.rb

@@ -0,0 +1,71 @@
+require 'test/unit'
+require 'roby'
+require 'roby/app'
+require 'roby/test/common'
+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
+    include Roby::Subsystems
+
+    def setup
+	super
+	DRb.start_service
+	State.pos = 0
+	State.services do |s|
+	    s.localization = 'test'
+	    s.navigation   = 'test'
+	end
+    end
+
+    def nav_loc
+	tasks = plan.known_tasks.to_a
+	assert_equal(2, tasks.size, tasks)
+	if tasks.first.kind_of?(Services::Navigation)
+	    tasks
+	else tasks.reverse
+	end
+    end
+
+    def test_initialize_plan
+	start_with, ready = Application.initialize_plan
+
+	nav, loc = nav_loc
+	assert(plan.permanent?(nav))
+	assert(plan.permanent?(loc))
+	assert(nav.realized_by?(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)
+
+	assert_equal([nav.event(:start), loc.event(:ready)].to_set, ready.parent_objects(EventStructure::Signal).to_set)
+
+    rescue Roby::Planning::NotFound
+	STDERR.puts $!.full_message
+	raise
+    end
+
+    def test_start_subsystems
+	Roby.logger.level = Logger::FATAL
+	Roby.control.run :detach => true
+
+	Application.run(Roby.app) { }
+	nav, loc = nav_loc
+	assert(nav.running?)
+	assert(loc.running?)
+
+	sleep(0.5)
+	assert(State.pos > 0)
+    end
+end
+

data/test/distributed/test_communication.rb

@@ -0,0 +1,178 @@
+require 'test/unit'
+require 'roby/distributed'
+require 'roby/test/distributed'
+require 'flexmock'
+
+class TC_DistributedCommunication < Test::Unit::TestCase
+    include Roby
+    include Roby::Distributed::Test
+
+    attr_reader :local_peer
+    module FakePeerServerMethods
+	def reply(mock, value)
+	    mock.method_called(value) if mock
+	    value
+	end
+	def reply_error(count)
+	    @error_count ||= count
+	    if @error_count == 0
+		return
+	    end
+
+	    @error_count -= 1
+	    raise
+	end
+
+	def reply_with_callback(mock, value)
+	    peer.disable_tx
+	    mock.method_called(value)
+	    peer.transmit(:reply, mock, value + 1)
+	    mock.method_called(value + 2)
+	    peer.enable_tx
+	    value
+	end
+
+	def recursive_callbacks
+	    peer.transmit(:recursive_callbacks)
+	end
+
+	def setup(server); peer.setup(server) end
+	def peer_drb_object; DRbObject.new(peer) end
+    end
+
+    def setup
+	super
+
+	peer2peer(true) do |remote|
+	    def remote.install_fake_methods
+		local_peer.local_server.extend FakePeerServerMethods
+	    end
+	end
+
+	remote_peer.local_server.extend FakePeerServerMethods
+	remote.install_fake_methods
+    end
+
+    def test_transmit
+	FlexMock.use do |mock|
+	    # Check that nothing is sent while the link is not alive
+	    remote_peer.disable_tx
+	    remote_peer.transmit(:reply, DRbObject.new(mock), 42) do |result|
+		mock.block_called(result)
+	    end
+
+	    remote_peer.transmit(:reply, DRbObject.new(mock), 24)
+	    remote_peer.transmit(:reply, DRbObject.new(mock), 24) do |result|
+		mock.block_called(result)
+	    end
+
+	    mock.should_receive(:link_alive).once.ordered
+	    mock.should_receive(:method_called).with(42).once.ordered(:first_call)
+	    mock.should_receive(:method_called).with(24).twice.ordered(:second_calls)
+	    mock.should_receive(:block_called).with(42).once.ordered(:second_calls)
+	    mock.should_receive(:block_called).with(24).once.ordered
+
+	    mock.link_alive
+	    remote_peer.enable_tx
+	    remote_peer.synchro_point
+	end
+    end
+
+    def test_transmit_error
+	FlexMock.use do |mock|
+	    remote_peer.disable_tx
+	    remote_peer.transmit(:reply_error, 2) do |result|
+		mock.block_called
+	    end
+	    mock.should_receive(:block_called).never
+	    remote_peer.enable_tx
+	    assert_raises(Roby::Distributed::DisconnectedError) { remote_peer.synchro_point }
+
+	    assert(!remote_peer.connected?)
+	end
+    end
+    
+    def test_call(value = 42)
+	FlexMock.use do |mock|
+	    mock.should_receive(:method_called).with(value).once
+	    assert_equal(value, remote_peer.call(:reply, DRbObject.new(mock), value))
+	end
+    end
+
+    def test_concurrent_calls
+	remote_peer.disable_tx
+
+	t1 = Thread.new { test_call(42) }
+	# wait for the TX thread to notice the new entry in the queue and
+	# wake up
+	sleep(0.5)
+
+	t2 = Thread.new { test_call(21) }
+	# Wait for +t2+ to insert its entry in the TX queue
+	sleep(0.5)
+
+	remote_peer.enable_tx
+	t1.value
+	t2.value
+    end
+
+    def test_call_raises
+	Roby.logger.level = Logger::FATAL
+	assert_raises(RuntimeError) do
+	    remote_peer.call(:reply_error, 2)
+	end
+    end
+
+    def test_call_disconnects
+	Roby.logger.level = Logger::FATAL
+	remote_peer.disable_tx
+
+	remote_peer.transmit(:reply_error, 2)
+	sleep(0.5)
+
+	Thread.new do
+	    sleep(0.5)
+	    remote_peer.enable_tx
+	end
+	assert_raises(DisconnectedError) { remote_peer.call(:reply, nil, 42) }
+    end
+
+    def test_callback
+	FlexMock.use do |mock|
+	    # Check that nothing is sent while the link is not alive
+	    mock.should_receive(:method_called).with(42).once.ordered
+	    mock.should_receive(:method_called).with(44).once.ordered
+	    mock.should_receive(:method_called).with(43).once.ordered
+
+	    assert_equal(42, remote_peer.call(:reply_with_callback, DRbObject.new(mock), 42))
+	end
+    end
+
+    def test_recursive_callbacks
+	Roby.logger.level = Logger::FATAL
+	assert_raises(DisconnectedError) { remote_peer.call(:recursive_callbacks) }
+    end
+
+    def test_synchro_point
+	remote_peer.disable_tx
+	remote.send_local_peer(:disable_tx)
+	FlexMock.use do |mock|
+	    remote_peer.transmit(:reply, DRbObject.new(mock), 42)
+	    remote_peer.transmit(:reply, DRbObject.new(mock), 21)
+	    remote.send_local_peer(:transmit, :reply, DRbObject.new(mock), 42)
+	    remote.send_local_peer(:transmit, :reply, DRbObject.new(mock), 21)
+
+	    Thread.current.priority = 10
+	    sleep(0.5)
+	    mock.should_receive(:method_called).times(4)
+
+	    remote_peer.enable_tx
+	    remote.send_local_peer(:enable_tx)
+	    remote_peer.synchro_point
+	end
+
+    ensure
+	Thread.current.priority = 0
+    end
+end
+