require 'roby'
require 'roby/distributed'
require 'roby/planning'
require 'roby/log'
require 'roby/log/event_stream'

require 'roby/robot'
require 'yaml'

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
    # system-wide configuration and takes care of file loading and system-wide
    # setup (#setup). A Roby application can be started in multiple modes. The
    # first and most important mode is the runtime mode
    # (<tt>scripts/run</tt>). Other modes are the testing mode (#testing?
    # returns true, entered through <tt>scripts/test</tt>) and the shell mode
    # (#shell? returns true, entered through <tt>scripts/shell</tt>). Usually,
    # user code does not have to take the modes into account, but it is
    # sometime useful.
    #
    # Finally, in both testing and runtime mode, the code can be started in
    # simulation or live setups (see #simulation?). Specific plugins can for
    # instance start and set up a simulation system in simulation mode, and as
    # well set up some simulation-specific configuration for the functional
    # layer of the architecture.
    #
    # == Configuration files
    #
    # In all modes, a specific set of configuration files are loaded.  The
    # files that are actually loaded are defined by the robot name and type, as
    # specified to #robot. The loaded files are, in order, the following:
    # [config/app.yml]
    #   the application configuration as a YAML file. See the comments in that
    #   file for more details.
    # [config/init.rb]
    #   Ruby code for the common configuration of all robots
    # [config/ROBOT_NAME.rb or config/ROBOT_TYPE.rb]
    #   Ruby code for the configuration of either all robots of the same type,
    #   or a specific robot. It is one or the other. If a given robot needs to
    #   inherit the configuration of its type, explicitely require the
    #   ROBOT_TYPE.rb file in config/ROBOT_NAME.rb.
    #
    # == Runtime mode (<tt>scripts/run</tt>)
    # Then, in runtime mode the robot controller
    # <tt>controller/ROBOT_NAME.rb</tt> or <tt>controller/ROBOT_TYPE.rb</tt> is
    # loaded. The same rules than for the configuration file
    # <tt>config/ROBOT_NAME.rb</tt> apply.
    #
    # == Testing mode (<tt>scripts/test</tt>)
    # This mode is used to run test suites in the +test+ directory. See
    # Roby::Test::TestCase for a description of Roby-specific tests.
    class Application
	include Singleton

	# The plain option hash saved in config/app.yml
	attr_reader :options

	# Logging options.
	# events:: save a log of all events in the system. This log can be read using scripts/replay
	#          If this value is 'stats', only the data necessary for timing statistics is saved.
	# levels:: a component => level hash of the minimum level of the messages that 
	#	   should be displayed on the console. The levels are DEBUG, INFO, WARN and FATAL.
	#	     Roby: FATAL
	#	     Roby::Distributed: INFO
	# 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
	
	# A [name, dir, file, module] array of available plugins, where 'name'
	# is the plugin name, 'dir' the directory in which it is installed,
	# 'file' the file which should be required to load the plugin and
	# 'module' the Application-compatible module for configuration of the
	# plug-in
	attr_reader :available_plugins
	# An [name, module] array of the loaded plugins
	attr_reader :plugins

	# The discovery options in multi-robot mode
	attr_reader :discovery
	# The robot's dRoby options
	# period:: the period of neighbour discovery
	# max_errors:: disconnect from a peer if there is more than +max_errors+ consecutive errors
	#              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

	# An array of directories in which to search for plugins
	attr_reader :plugin_dirs

	# True if user interaction is disabled during tests
	attr_predicate :automatic_testing?, true

	# True if all logs should be kept after testing
	attr_predicate :testing_keep_logs?, true

	# True if all logs should be kept after testing
	attr_predicate :testing_overwrites_logs?, true

	# True if we should remove the framework code from the error backtraces
	def filter_backtraces?; log['filter_backtraces'] end
	def filter_backtraces=(value); log['filter_backtraces'] = value end

	def initialize
	    @plugins = Array.new
	    @available_plugins = Array.new
	    @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 ]

	    @automatic_testing = true
	    @testing_keep_logs = false

	    @plugin_dirs = []
	end

	# Adds +dir+ in the list of directories searched for plugins
	def plugin_dir(dir)
	    dir = File.expand_path(dir)
	    @plugin_dirs << dir
	    $LOAD_PATH.unshift File.expand_path(dir)

	    Dir.new(dir).each do |subdir|
		subdir = File.join(dir, subdir)
		next unless File.directory?(subdir)
		appfile = File.join(subdir, "app.rb")
		next unless File.file?(appfile)

		begin
		    require appfile
		rescue
		    Roby.warn "cannot load plugin in #{subdir}: #{$!.full_message}\n"
		end
		Roby.info "loaded plugin in #{subdir}"
	    end
	end

	# Returns true if +name+ is a loaded plugin
	def loaded_plugin?(name)
	    plugins.any? { |plugname, _| plugname == name }
	end

	# Returns the [name, dir, file, module] array definition of the plugin
	# +name+, or nil if +name+ is not a known plugin
	def plugin_definition(name)
	    available_plugins.find { |plugname, *_| plugname == name }
	end

	# True if +name+ is a plugin known to us
	def defined_plugin?(name)
	    available_plugins.any? { |plugname, *_| plugname == name }
	end

	def each_plugin(on_available = false)
	    plugins = self.plugins
	    if on_available
		plugins = available_plugins.map { |name, _, mod, _| [name, mod] }
	    end
	    plugins.each do |_, mod|
		yield(mod)
	    end
	end

	# Yields each extension modules that respond to +method+
	def each_responding_plugin(method, on_available = false)
	    each_plugin do |mod|
		yield(mod) if mod.respond_to?(method)
	    end
	end
	
	# Call +method+ on each loaded extension module which define it, with
	# arguments +args+
	def call_plugins(method, *args)
	    each_responding_plugin(method) do |config_extension|
		config_extension.send(method, *args)
	    end
	end

	# Load configuration from the given option hash
	def load_yaml(options)
	    options = options.dup

	    if robot_name && (robot_config = options['robots'])
		if robot_config = robot_config[robot_name]
		    robot_config.each do |section, values|
			if options[section]
			    options[section].merge! values
			else
			    options[section] = values
			end
		    end
		    options.delete('robots')
		end
	    end

	    @options = options

	    load_option_hashes(options, %w{log control discovery droby})
	    call_plugins(:load, self, options)
	end

	def load_option_hashes(options, names)
	    names.each do |optname|
		if options[optname]
		    send(optname).merge! options[optname]
		end
	    end
	end

	# Loads the plugins whose name are listed in +names+
	def using(*names)
	    names.each do |name|
		name = name.to_s
		unless plugin = plugin_definition(name)
		    raise ArgumentError, "#{name} is not a known plugin (#{available_plugins.map { |n, *_| n }.join(", ")})"
		end
		name, dir, mod, init = *plugin
		if plugins.find { |n, m| n == name && m == mod }
		    next
		end

		if init
		    begin
			$LOAD_PATH.unshift dir
			init.call
			mod.reset(self) if mod.respond_to?(:reset)
		    rescue Exception => e
			Roby.fatal "cannot load plugin #{name}: #{e.full_message}"
			exit(1)
		    ensure
			$LOAD_PATH.shift
		    end
		end

		plugins << [name, mod]
		extend mod
		# If +load+ has already been called, call it on the module
		if mod.respond_to?(:load) && options
		    mod.load(self, options)
		end
	    end
	end

	def reset
	    if defined? State
		State.clear
	    else
		Roby.const_set(:State, StateSpace.new)
	    end
	    call_plugins(:reset, self)
	end

        # The robot name
	attr_reader :robot_name
        # The robot type
        attr_reader :robot_type
        # Sets up the name and type of the robot. This can be called only once
        # in a given Roby controller.
	def robot(name, type = name)
	    if @robot_name
		if name != @robot_name && type != @robot_type
		    raise ArgumentError, "the robot is already set to #{name}, of type #{type}"
		end
		return
	    end
	    @robot_name = name
	    @robot_type = type
	end

	# The directory in which logs are to be saved
	# Defaults to APP_DIR/log
	def log_dir
	    File.expand_path(log['dir'] || 'log', APP_DIR)
	end

	# A path => File hash, to re-use the same file object for different
	# logs
	attribute(:log_files) { Hash.new }

	# The directory in which results should be saved
	# Defaults to APP_DIR/results
	def results_dir
	    File.expand_path(log['results'] || 'results', APP_DIR)
	end

        # Returns a unique directory name as a subdirectory of
        # +base_dir+, based on +path_spec+. The generated name
        # is of the form
        #   <base_dir>/a/b/c/YYYYMMDD-basename
        # if <tt>path_spec = "a/b/c/basename"</tt>. A .<number> suffix
        # is appended if the path already exists.
	def self.unique_dirname(base_dir, path_spec)
	    if path_spec =~ /\/$/
		basename = ""
		dirname = path_spec
	    else
		basename = File.basename(path_spec)
		dirname  = File.dirname(path_spec)
	    end

	    date = Date.today
	    date = "%i%02i%02i" % [date.year, date.month, date.mday]
	    if basename && !basename.empty?
		basename = date + "-" + basename
	    else
		basename = date
	    end

	    # Check if +basename+ already exists, and if it is the case add a
	    # .x suffix to it
	    full_path = File.expand_path(File.join(dirname, basename), base_dir)
	    base_dir  = File.dirname(full_path)

	    unless File.exists?(base_dir)
		FileUtils.mkdir_p(base_dir)
	    end

	    final_path, i = full_path, 0
	    while File.exists?(final_path)
		i += 1
		final_path = full_path + ".#{i}"
	    end

	    final_path
	end

        # Sets up all the default loggers. It creates the logger for the Robot
        # module (accessible through Robot.logger), and sets up log levels as
        # specified in the <tt>config/app.yml</tt> file.
	def setup_loggers
	    # Create the robot namespace
	    STDOUT.sync = true
	    Robot.logger = Logger.new(STDOUT)
	    Robot.logger.level = Logger::INFO
	    Robot.logger.formatter = Roby.logger.formatter
	    Robot.logger.progname = robot_name

	    # Set up log levels
	    log['levels'].each do |name, value|
		name = name.camelize
		if value =~ /^(\w+):(.+)$/
		    level, file = $1, $2
		    level = Logger.const_get(level)
		    file = file.gsub('ROBOT', robot_name) if robot_name
		else
		    level = Logger.const_get(value)
		end

		new_logger = if file
				 path = File.expand_path(file, log_dir)
				 io   = (log_files[path] ||= File.open(path, 'w'))
				 Logger.new(io)
			     else Logger.new(STDOUT)
			     end
		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
	    end
	end

	def setup_dirs
	    Dir.mkdir(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')
		end
	    end

	    Roby::State.datadirs = []
	    datadir = File.join(APP_DIR, "data")
	    if File.directory?(datadir)
		Roby::State.datadirs << datadir
	    end
	end

        # Loads the models, based on the given robot name and robot type
	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'))

	    # Load robot-specific configuration
	    planner_dir = File.join(APP_DIR, 'planners')
	    models_search = [planner_dir]
	    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

	    # Load the other planners
	    models_search.each do |base_dir|
		next unless File.directory?(base_dir)
		Dir.new(base_dir).each do |file|
		    if File.file?(file) && file =~ /\.rb$/ && file !~ 'main\.rb$'
			require file
		    end
		end
	    end
	end

	def setup
	    reset

	    $LOAD_PATH.unshift(APP_DIR) unless $LOAD_PATH.include?(APP_DIR)

	    # Get the application-wide configuration
	    file = File.join(APP_DIR, 'config', 'app.yml')
	    file = YAML.load(File.open(file))
	    load_yaml(file)
	    if File.exists?(initfile = File.join(APP_DIR, 'config', 'init.rb'))
		load initfile
	    end

	    setup_dirs
	    setup_loggers

	    # Import some constants directly at toplevel before loading the
	    # user-defined models
	    unless Object.const_defined?(:Application)
		Object.const_set(:Application, Roby::Application)
		Object.const_set(:State, Roby::State)
	    end

	    require_models

	    # MainPlanner is always included in the planner list
	    Roby.control.planners << MainPlanner
	   
	    # 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'
		each_plugin do |mod|
		    if mod.const_defined?(:Test)
			Roby::Test::TestCase.include mod.const_get(:Test)
		    end
		end
	    end
	end

	def run(&block)
	    # Set up dRoby, setting an Interface object as front server, for shell access
	    host = droby['host'] || ""
	    if host !~ /:\d+$/
		host << ":#{Distributed::DEFAULT_DROBY_PORT}"
	    end

	    if single? || !robot_name
		host =~ /:(\d+)$/
		DRb.start_service "druby://:#{$1 || '0'}", Interface.new(Roby.control)
	    else
		DRb.start_service "druby://#{host}", Interface.new(Roby.control)
		droby_config = { :ring_discovery => !!discovery['ring'],
		    :name => robot_name, 
		    :plan => Roby.plan, 
		    :period => discovery['period'] || 0.5 }

		if discovery['tuplespace']
		    droby_config[:discovery_tuplespace] = DRbObject.new_with_uri("druby://#{discovery['tuplespace']}")
		end
		Roby::Distributed.state = Roby::Distributed::ConnectionSpace.new(droby_config)

		if discovery['ring']
		    Roby::Distributed.publish discovery['ring']
		end
		Roby::Control.every(discovery['period'] || 0.5) do
		    Roby::Distributed.state.start_neighbour_discovery
		end
	    end

	    @robot_name ||= 'common'
	    @robot_type ||= 'common'

	    control_config = self.control
	    control = Roby.control
	    options = { :detach => true, :cycle => control_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.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

	    plugins = self.plugins.map { |_, mod| mod if mod.respond_to?(:run) }.compact
	    run_plugins(plugins, &block)

        rescue Exception => e
            if e.respond_to?(:pretty_print)
                pp e
            else
                pp e.full_message
            end
	end
	def run_plugins(mods, &block)
	    control = Roby.control

	    if mods.empty?
		yield
		control.join
	    else
		mod = mods.shift
		mod.run(self) do
		    run_plugins(mods, &block)
		end
	    end

	rescue Exception => e
	    if Roby.control.running?
		control.quit
		control.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]

	# Starts services needed for distributed operations. These services are
	# supposed to be started only once for a whole system
	#
	# If you have external servers to start for every robot, plug it into
	# #start_server
	def start_distributed
	    Thread.abort_on_exception = true

	    if !File.exists?(log_dir)
		Dir.mkdir(log_dir)
	    end

	    unless single? || !discovery['tuplespace']
		ts = Rinda::TupleSpace.new


		discovery['tuplespace'] =~ /(:\d+)$/
		DRb.start_service "druby://#{$1}", ts

		new_db  = ts.notify('write', DISCOVERY_TEMPLATE)
		take_db = ts.notify('take', DISCOVERY_TEMPLATE)

		Thread.start do
		    new_db.each { |_, t| STDERR.puts "new host #{t[1]}" }
		end
		Thread.start do
		    take_db.each { |_, t| STDERR.puts "host #{t[1]} has disconnected" }
		end
		Roby.warn "Started service discovery on #{discovery['tuplespace']}"
	    end

	    call_plugins(:start_distributed, self)
	end

	# Stop services needed for distributed operations. See #start_distributed
	def stop_distributed
	    DRb.stop_service

	    call_plugins(:stop_distributed, self)
	rescue Interrupt
	end

	attr_reader :log_server
	attr_reader :log_sources

	# Start services that should exist for every robot in the system. Services that
	# are needed only once for all robots should be started in #start_distributed
	def start_server
	    Thread.abort_on_exception = true

	    # Start a log server if needed, and poll the log directory for new
	    # data sources
	    if log_server = (log.has_key?('server') ? log['server'] : true)
		require 'roby/log/server'
		port = if log_server.kind_of?(Hash) && log_server['port']
			   Integer(log_server['port'])
		       end

		@log_server  = Log::Server.new(port ||= Log::Server::RING_PORT)
		Roby::Log::Server.info "log server published on port #{port}"
		@log_streams = []
		@log_streams_poll = Thread.new do
		    begin
			loop do
			    Thread.exclusive do
				known_streams = @log_server.streams
				streams	  = data_streams

				(streams - known_streams).each do |s|
				    Roby::Log::Server.info "new stream found #{s.name} [#{s.type}]"
				    s.open
				    @log_server.added_stream(s)
				end
				(known_streams - streams).each do |s|
				    Roby::Log::Server.info "end of stream #{s.name} [#{s.type}]"
				    s.close
				    @log_server.removed_stream(s)
				end
			    end
			    sleep(5)
			end
		    rescue Interrupt
		    rescue
			Roby::Log::Server.fatal $!.full_message
		    end
		end
	    end

	    call_plugins(:start_server, self)
	end

	# Stop server. See #start_server
	def stop_server
	    if @log_server
		@log_streams_poll.raise Interrupt, "quitting"
		@log_streams_poll.join

		@log_server.quit
		@log_streams.clear
	    end

	    call_plugins(:stop_server, self)
	end

	# Require all files in +dirname+
	def require_dir(dirname)
	    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)
	    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)
	    return unless robot_name && robot_type

	    [robot_name, robot_type].each do |name|
		dirname = pattern.gsub(/ROBOT/, name)
		require_dir(dirname) 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)
	    return unless robot_name && robot_type

	    robot_config = pattern.gsub(/ROBOT/, robot_name)
	    if File.file?(robot_config)
		Kernel.send(method, robot_config)
		true
	    else
		robot_config = pattern.gsub(/ROBOT/, robot_type)
		if File.file?(robot_config)
		    Kernel.send(method, robot_config)
		    true
		else
		    false
		end
	    end
	end

	attr_predicate :simulation?, true
	def simulation; self.simulation = true end

	attr_predicate :testing?, true
	def testing; self.testing = true end
	attr_predicate :shell?, true
	def shell; self.shell = true end
	def single?; @single || discovery.empty? end
	def single;  @single = true end

	# Guesses the type of +filename+ if it is a source suitable for
	# data display in this application
	def data_streams_of(filenames)
	    if filenames.size == 1
		path = filenames.first
		path = if path =~ /-(events|timings)\.log$/
			   $`
		       elsif File.exists?("#{path}-events.log")
			   path
		       end
		if path
		    return [Roby::Log::EventStream.new(path)]
		end
	    end

	    each_responding_plugin(:data_streams_of, true) do |config|
		if streams = config.data_streams_of(filenames)
		    return streams
		end
	    end
	    nil
	end

	# Returns the list of data streams suitable for data display known
	# to the application
	def data_streams(log_dir = nil)
	    log_dir ||= self.log_dir
	    streams = []
	    Dir.glob(File.join(log_dir, '*-events.log*')).each do |file|
		next unless file =~ /-events\.log$/
		streams << Roby::Log::EventStream.new($`)
	    end
	    each_responding_plugin(:data_streams, true) do |config|
		if s = config.data_streams(log_dir)
		    streams += s
		end
	    end
	    streams
	end

	def self.find_data(name)
	    Roby::State.datadirs.each do |dir|
		path = File.join(dir, name)
		return path if File.exists?(path)
	    end
	    raise Errno::ENOENT, "no file #{name} found in #{Roby::State.datadirs.join(":")}"
	end

	def self.register_plugin(name, mod, &init)
	    caller(1)[0] =~ /^([^:]+):\d/
	    dir  = File.expand_path(File.dirname($1))
	    Roby.app.available_plugins << [name, dir, mod, init]
	end

	@@reload_model_filter = []
	# Add a filter to model reloading. A task or planner model is
	# reinitialized only if all filter blocks return true for it
	def self.filter_reloaded_models(&block)
	    @@reload_model_filter << block
	end

	def model?(model)
	    (model <= Roby::Task) || (model.kind_of?(Roby::TaskModelTag)) || 
		(model <= Planning::Planner) || (model <= Planning::Library)
	end

	def reload_model?(model)
	    @@reload_model_filter.all? { |filter| filter[model] }
	end

	def app_file?(path)
	    (path =~ %r{(^|/)#{APP_DIR}(/|$)}) ||
		((path[0] != ?/) && File.file?(File.join(APP_DIR, path)))
	end
	def framework_file?(path)
	    if path =~ /roby\/.*\.rb$/
		true
	    else
		Roby.app.plugins.any? do |name, _|
		    _, dir, _, _ = Roby.app.plugin_definition(name)
		    path =~ %r{(^|/)#{dir}(/|$)}
		end
	    end
	end

	def reload
	    # Always reload this file first. This ensure that one can use #reload
	    # to fix the reload code itself
	    load __FILE__

	    # Clear all event definitions in task models that are filtered out by
	    # Application.filter_reloaded_models
	    ObjectSpace.each_object(Class) do |model|
		next unless model?(model)
		next unless reload_model?(model)

		model.clear_model
	    end

	    # Remove what we want to reload from LOADED_FEATURES and use
	    # require. Do not use 'load' as the reload order should be the
	    # require order.
	    needs_reload = []
	    $LOADED_FEATURES.delete_if do |feature|
		if framework_file?(feature) || app_file?(feature)
		    needs_reload << feature
		end
	    end

	    needs_reload.each do |feature|
		begin
		    require feature.gsub(/\.rb$/, '')
		rescue Exception => e
		    STDERR.puts e.full_message
		end
	    end
	end
    end

    # Load the plugins 'main' files
    Roby.app.plugin_dir File.join(ROBY_ROOT_DIR, 'plugins')
    if plugin_path = ENV['ROBY_PLUGIN_PATH']
	plugin_path.split(':').each do |dir|
	    if File.directory?(dir)
		Roby.app.plugin_dir File.expand_path(dir)
	    end
	end
    end
end