roby 0.7.3 → 0.8.0

data/lib/roby.rb

@@ -3,9 +3,12 @@
 # [Roby] core namespace for the Roby kernel
 # [Roby::Distributed] parts that are very specific to distributed plan management
 # [Roby::Planning] basic tools for plan generation
-# [Roby::Transactions] implementation of transactions
-# [Roby::EventStructure] event relations
-# [Roby::TaskStructure] task relations
+# [Roby::Transactions] implementation of transactions. Transactions represent a
+# change in the main plan, and can be distributed among different plan managers.
+# [Roby::EventStructure] main namespace for event relations. The methods listed
+# in the documentation of EventStructure are actually methods of Roby::EventGenerator
+# [Roby::TaskStructure] main namespace for task relations. The methods listed in
+# the documentation of TaskStructure are actually methods of Roby::Task
 module Roby
     class BasicObject; end
     class PlanObject < BasicObject; end
@@ -15,28 +18,60 @@ module Roby
     class Task < PlanObject; end
 end
 
-require 'roby/support'
-require 'roby/task'
-require 'roby/event'
-require 'roby/standard_errors'
+require 'drb'
+require 'utilrb/weakref'
+require 'pp'
+require 'thread'
+require 'set'
+require 'yaml'
+require 'utilrb/value_set'
+require 'utilrb/object/attribute'
+require 'utilrb/module/ancestor_p'
+require 'utilrb/kernel/options'
+require 'utilrb/module/attr_enumerable'
+require 'utilrb/module/attr_predicate'
+require 'utilrb/module/inherited_enumerable'
+require 'utilrb/module/include'
+require 'utilrb/kernel/arity'
+require 'utilrb/kernel/swap'
+require 'utilrb/exception/full_message'
+require 'utilrb/unbound_method/call'
 
-require 'roby/plan'
-require 'roby/query'
-require 'roby/control'
-require 'roby/decision_control'
+require 'roby/config.rb'
+require 'roby/support.rb'
+require 'roby/basic_object.rb'
+require 'roby/standard_errors.rb'
+require 'roby/exceptions.rb'
+require 'roby_bgl'
+require 'roby/graph.rb'
+require 'roby/relations.rb'
 
-require 'roby/propagation'
-require 'roby/relations/events'
-require 'roby/relations/hierarchy'
-require 'roby/relations/influence'
-require 'roby/relations/planned_by'
-require 'roby/relations/executed_by'
-require 'roby/relations/ensured'
+require 'roby/plan-object.rb'
+require 'roby/event.rb'
+require 'roby/task.rb'
+require 'roby/task-operations.rb'
 
-require 'roby/state'
-require 'roby/interface'
+require 'roby/relations/conflicts.rb'
+require 'roby/relations/ensured.rb'
+require 'roby/relations/error_handling.rb'
+require 'roby/relations/events.rb'
+require 'roby/relations/executed_by.rb'
+require 'roby/relations/dependency.rb'
+require 'roby/relations/influence.rb'
+require 'roby/relations/planned_by.rb'
 
-require 'roby/distributed/protocol'
+require 'roby/task_index.rb'
+require 'roby/plan.rb'
+require 'roby/transactions/proxy.rb'
+require 'roby/transactions.rb'
+require 'roby/query.rb'
 
-require 'roby/app'
+require 'roby/distributed/base'
+require 'roby/decision_control.rb'
+require 'roby/execution_engine.rb'
+require 'roby/app.rb'
+
+require 'roby/robot.rb'
+require 'roby/planning.rb'
+require 'roby/state.rb'
 

data/lib/roby/app.rb

@@ -1,16 +1,5 @@
-require 'roby'
-require 'roby/distributed'
-require 'roby/planning'
-require 'roby/log'
-require 'roby/log/event_stream'
-
-require 'roby/robot'
-require 'yaml'
-
+require 'singleton'
 module Roby
-    # Returns the only one Application object
-    def self.app; Application.instance end
-
     # = Roby Applications
     #
     # There is one and only one Application object, which holds mainly the
@@ -56,6 +45,9 @@ module Roby
     # Roby::Test::TestCase for a description of Roby-specific tests.
     class Application
 	include Singleton
+        
+	# A set of planners declared in this application
+	attr_reader :planners
 
 	# The plain option hash saved in config/app.yml
 	attr_reader :options
@@ -70,6 +62,9 @@ module Roby
 	# dir:: the log directory. Uses APP_DIR/log if not set
 	# filter_backtraces:: true if the framework code should be removed from the error backtraces
 	attr_reader :log
+
+        # ExecutionEngine setup
+        attr_reader :engine
 	
 	# A [name, dir, file, module] array of available plugins, where 'name'
 	# is the plugin name, 'dir' the directory in which it is installed,
@@ -88,12 +83,10 @@ module Roby
 	#              detected
 	attr_reader :droby
 	
-	# Configuration of the control loop
-	# abort_on_exception:: if the control loop should abort if an uncaught task or event exception is received. Defaults
-	#                      to false
-	# abort_on_application_exception:: if the control should abort if an uncaught application exception (not originating
-	#                                  from a task or event) is caught. Defaults to true.
-	attr_reader :control
+	# If true, abort if an unhandled exception is found
+	attr_predicate :abort_on_exception, true
+	# If true, abort if an application exception is found
+	attr_predicate :abort_on_application_exception, true
 
 	# An array of directories in which to search for plugins
 	attr_reader :plugin_dirs
@@ -117,13 +110,13 @@ module Roby
 	    @log = Hash['events' => 'stats', 'levels' => Hash.new, 'filter_backtraces' => true] 
 	    @discovery = Hash.new
 	    @droby     = Hash['period' => 0.5, 'max_errors' => 1] 
-	    @control   = Hash[ 'abort_on_exception' => false, 
-		'abort_on_application_exception' => true ]
+            @engine    = Hash.new
 
 	    @automatic_testing = true
 	    @testing_keep_logs = false
 
 	    @plugin_dirs = []
+            @planners    = []
 	end
 
 	# Adds +dir+ in the list of directories searched for plugins
@@ -207,7 +200,7 @@ module Roby
 
 	    @options = options
 
-	    load_option_hashes(options, %w{log control discovery droby})
+	    load_option_hashes(options, %w{log engine discovery droby})
 	    call_plugins(:load, self, options)
 	end
 
@@ -349,7 +342,7 @@ module Roby
 
 	    # Set up log levels
 	    log['levels'].each do |name, value|
-		name = name.camelize
+		name = name.camelcase(true)
 		if value =~ /^(\w+):(.+)$/
 		    level, file = $1, $2
 		    level = Logger.const_get(level)
@@ -367,19 +360,18 @@ module Roby
 		new_logger.level     = level
 		new_logger.formatter = Roby.logger.formatter
 
-		if (mod = name.constantize rescue nil)
-		    if robot_name
-			new_logger.progname = "#{name} #{robot_name}"
-		    else
-			new_logger.progname = name
-		    end
-		    mod.logger = new_logger
-		end
+                mod = Kernel.constant(name)
+                if robot_name
+                    new_logger.progname = "#{name} #{robot_name}"
+                else
+                    new_logger.progname = name
+                end
+                mod.logger = new_logger
 	    end
 	end
 
 	def setup_dirs
-	    Dir.mkdir(log_dir) unless File.exists?(log_dir)
+	    FileUtils.mkdir_p(log_dir) unless File.exists?(log_dir)
 	    if File.directory?(libdir = File.join(APP_DIR, 'lib'))
 		if !$LOAD_PATH.include?(libdir)
 		    $LOAD_PATH.unshift File.join(APP_DIR, 'lib')
@@ -397,22 +389,17 @@ module Roby
 	def require_models
 	    # Require all common task models and the task models specific to
 	    # this robot
-	    require_dir(File.join(APP_DIR, 'tasks'))
-	    require_robotdir(File.join(APP_DIR, 'tasks', 'ROBOT'))
+            list_dir('tasks') { |p| require(p) }
+            list_robotdir('tasks', 'ROBOT') { |p| require(p) }
 
 	    # Load robot-specific configuration
-	    planner_dir = File.join(APP_DIR, 'planners')
-	    models_search = [planner_dir]
+	    models_search = ['planners']
 	    if robot_name
-		load_robotfile(File.join(APP_DIR, 'config', "ROBOT.rb"))
-
-		models_search << File.join(planner_dir, robot_name) << File.join(planner_dir, robot_type)
-		if !require_robotfile(File.join(APP_DIR, 'planners', 'ROBOT', 'main.rb'))
-		    require File.join(APP_DIR, "planners", "main")
-		end
-	    else
-		require File.join(APP_DIR, "planners", "main")
-	    end
+		models_search << File.join('planners', robot_name) << File.join('planners', robot_type)
+                file = robotfile('planners', 'ROBOT', 'main.rb')
+            end
+            file ||= File.join("planners", "main")
+            require file if File.file?(file)
 
 	    # Load the other planners
 	    models_search.each do |base_dir|
@@ -423,10 +410,19 @@ module Roby
 		    end
 		end
 	    end
+
+	    # Set up the loaded plugins
+	    call_plugins(:require_models, self)
 	end
 
 	def setup
+            if !Roby.plan
+                Roby.instance_variable_set :@plan, Plan.new
+            end
+
 	    reset
+            require 'roby/planning'
+            require 'roby/interface'
 
 	    $LOAD_PATH.unshift(APP_DIR) unless $LOAD_PATH.include?(APP_DIR)
 
@@ -448,14 +444,21 @@ module Roby
 		Object.const_set(:State, Roby::State)
 	    end
 
+	    # Set up the loaded plugins
+	    call_plugins(:setup, self)
+
 	    require_models
 
+            if file = robotfile(APP_DIR, 'config', "ROBOT.rb")
+                load file
+            end
+
+
 	    # MainPlanner is always included in the planner list
-	    Roby.control.planners << MainPlanner
+            if defined? MainPlanner
+                self.planners << MainPlanner
+            end
 	   
-	    # Set up the loaded plugins
-	    call_plugins(:setup, self)
-
 	    # If we are in test mode, import the test extensions from plugins
 	    if testing?
 		require 'roby/test/testcase'
@@ -468,6 +471,8 @@ module Roby
 	end
 
 	def run(&block)
+            setup_global_singletons
+
 	    # Set up dRoby, setting an Interface object as front server, for shell access
 	    host = droby['host'] || ""
 	    if host !~ /:\d+$/
@@ -476,9 +481,9 @@ module Roby
 
 	    if single? || !robot_name
 		host =~ /:(\d+)$/
-		DRb.start_service "druby://:#{$1 || '0'}", Interface.new(Roby.control)
+		DRb.start_service "druby://:#{$1 || '0'}", Interface.new(Roby.engine)
 	    else
-		DRb.start_service "druby://#{host}", Interface.new(Roby.control)
+		DRb.start_service "druby://#{host}", Interface.new(Roby.engine)
 		droby_config = { :ring_discovery => !!discovery['ring'],
 		    :name => robot_name, 
 		    :plan => Roby.plan, 
@@ -492,7 +497,7 @@ module Roby
 		if discovery['ring']
 		    Roby::Distributed.publish discovery['ring']
 		end
-		Roby::Control.every(discovery['period'] || 0.5) do
+		Roby.every(discovery['period'] || 0.5) do
 		    Roby::Distributed.state.start_neighbour_discovery
 		end
 	    end
@@ -500,27 +505,18 @@ module Roby
 	    @robot_name ||= 'common'
 	    @robot_type ||= 'common'
 
-	    control_config = self.control
-	    control = Roby.control
-	    options = { :detach => true, :cycle => control_config['cycle'] || 0.1 }
+	    engine_config = self.engine
+	    engine = Roby.engine
+	    options = { :cycle => engine_config['cycle'] || 0.1 }
 	    
-	    # Add an executive if one is defined
-	    if control_config['executive']
-		self.executive = control_config['executive']
-	    end
-
 	    if log['events']
 		require 'roby/log/file'
 		logfile = File.join(log_dir, robot_name)
-		logger  = Roby::Log::FileLogger.new(logfile)
+		logger  = Roby::Log::FileLogger.new(logfile, :plugins => plugins.map { |n, _| n })
 		logger.stats_mode = log['events'] == 'stats'
 		Roby::Log.add_logger logger
 	    end
-	    control.abort_on_exception = 
-		control_config['abort_on_exception']
-	    control.abort_on_application_exception = 
-		control_config['abort_on_application_exception']
-	    control.run options
+	    engine.run options
 
 	    plugins = self.plugins.map { |_, mod| mod if mod.respond_to?(:run) }.compact
 	    run_plugins(plugins, &block)
@@ -533,11 +529,11 @@ module Roby
             end
 	end
 	def run_plugins(mods, &block)
-	    control = Roby.control
+	    engine = Roby.engine
 
 	    if mods.empty?
 		yield
-		control.join
+		engine.join
 	    else
 		mod = mods.shift
 		mod.run(self) do
@@ -546,30 +542,15 @@ module Roby
 	    end
 
 	rescue Exception => e
-	    if Roby.control.running?
-		control.quit
-		control.join
+	    if Roby.engine.running?
+		engine.quit
+		engine.join
 		raise e, e.message, e.backtrace
 	    else
 		raise
 	    end
 	end
 
-	attr_reader :executive
-
-	def executive=(name)
-	    if executive
-		Control.event_processing.delete(executive.method(:initial_events))
-		@executive = nil
-	    end
-	    return unless name
-
-	    full_name = "roby/executives/#{name}"
-	    require full_name
-	    @executive = full_name.camelize.constantize.new
-	    Control.event_processing << executive.method(:initial_events)
-	end
-
 	def stop; call_plugins(:stop, self) end
 
 	DISCOVERY_TEMPLATE = [:droby, nil, nil]
@@ -583,7 +564,7 @@ module Roby
 	    Thread.abort_on_exception = true
 
 	    if !File.exists?(log_dir)
-		Dir.mkdir(log_dir)
+		FileUtils.mkdir_p(log_dir)
 	    end
 
 	    unless single? || !discovery['tuplespace']
@@ -678,52 +659,49 @@ module Roby
 	    call_plugins(:stop_server, self)
 	end
 
-	# Require all files in +dirname+
-	def require_dir(dirname)
+        def list_dir(*path)
+            if !block_given?
+                return enum_for(:list_dir, *path)
+            end
+
+            dirname = File.join(*path)
 	    Dir.new(dirname).each do |file|
 		file = File.join(dirname, file)
-		file = file.gsub(/^#{Regexp.quote(APP_DIR)}\//, '')
-		require file if file =~ /\.rb$/ && File.file?(file)
+                if file =~ /\.rb$/ && File.file?(file)
+                    file = file.gsub(/^#{Regexp.quote(APP_DIR)}\//, '')
+                    yield(file) 
+                end
 	    end
-	end
+        end
 
 	# Require all files in the directories matching +pattern+. If +pattern+
 	# contains the word ROBOT, it is replaced by -- in order -- the robot
 	# name and then the robot type
-	def require_robotdir(pattern)
+	def list_robotdir(*path, &block)
+            if !block_given?
+                return enum_for(:list_robotdir, *path)
+            end
+
 	    return unless robot_name && robot_type
 
-	    [robot_name, robot_type].each do |name|
+            pattern = File.expand_path(File.join(*path), APP_DIR)
+	    [robot_name, robot_type].uniq.each do |name|
 		dirname = pattern.gsub(/ROBOT/, name)
-		require_dir(dirname) if File.directory?(dirname)
+		list_dir(dirname, &block) if File.directory?(dirname)
 	    end
 	end
 
-	# Loads the first file found matching +pattern+
-	#
-	# See #require_robotfile
-	def load_robotfile(pattern)
-	    require_robotfile(pattern, :load)
-	end
-
-	# Requires or loads (according to the value of +method+) the first file
-	# found matching +pattern+. +pattern+ can contain the word ROBOT, in
-	# which case the file is first checked against the robot name and then
-	# against the robot type
-	def require_robotfile(pattern, method = :require)
+	def robotfile(*path) # :nodoc
 	    return unless robot_name && robot_type
 
+            pattern = File.join(*path)
 	    robot_config = pattern.gsub(/ROBOT/, robot_name)
 	    if File.file?(robot_config)
-		Kernel.send(method, robot_config)
-		true
+		robot_config
 	    else
 		robot_config = pattern.gsub(/ROBOT/, robot_type)
 		if File.file?(robot_config)
-		    Kernel.send(method, robot_config)
-		    true
-		else
-		    false
+		    robot_config
 		end
 	    end
 	end
@@ -738,6 +716,34 @@ module Roby
 	def single?; @single || discovery.empty? end
 	def single;  @single = true end
 
+        def setup_global_singletons
+            if !Roby.plan
+                Roby.instance_variable_set :@plan, Plan.new
+            end
+
+            if !Roby.engine && Roby.plan.engine
+                # This checks coherence with Roby.control, and sets it
+                # accordingly
+                Roby.engine  = Roby.plan.engine
+            elsif !Roby.control
+                Roby.control = DecisionControl.new
+            end
+
+            if !Roby.engine
+                Roby.engine  = ExecutionEngine.new(Roby.plan, Roby.control)
+            end
+
+            if Roby.control != Roby.engine.control
+                raise "inconsistency between Roby.control and Roby.engine.control"
+            elsif Roby.engine != Roby.plan.engine
+                raise "inconsistency between Roby.engine and Roby.plan.engine"
+            end
+
+            if !Roby.engine.scheduler && Roby.scheduler
+                Roby.engine.scheduler = Roby.scheduler
+            end
+        end
+
 	# Guesses the type of +filename+ if it is a source suitable for
 	# data display in this application
 	def data_streams_of(filenames)
@@ -857,6 +863,20 @@ module Roby
 	end
     end
 
+    @app = Application.instance
+    class << self
+        # The one and only Application object
+        attr_reader :app
+
+        # The scheduler object to be used during execution. See
+        # ExecutionEngine#scheduler.
+        #
+        # This is only used during the configuration of the application, and
+        # not afterwards. It is also possible to set per-engine through
+        # ExecutionEngine#scheduler=
+        attr_accessor :scheduler
+    end
+
     # Load the plugins 'main' files
     Roby.app.plugin_dir File.join(ROBY_ROOT_DIR, 'plugins')
     if plugin_path = ENV['ROBY_PLUGIN_PATH']