roby 0.8.0 → 3.0.0

data/lib/roby/app/rake.rb

@@ -1,49 +1,189 @@
+require 'roby'
+require 'rake'
+require 'rake/tasklib'
+
 module Roby
-    # This module contains some tools used in the Rakefile of both Roby core
-    # and plugins
-    module Rake
-        # Returns the rdoc template path the documentation
-        # generation should be using in Rakefile
-        #
-        # Two non-standard templates are provided:
-        # allison[http://blog.evanweaver.com/files/doc/fauna/allison/files/README.html]
-        # and jamis[http://weblog.jamisbuck.org/2005/4/8/rdoc-template]. The
-        # default is jamis. Allison is nicer, but the javascript-based indexes
-        # are slow given the count of classes and methods there is in Roby.
-        def self.rdoc_template
-            if ENV['ROBY_RDOC_TEMPLATE']
-                if ENV['ROBY_RDOC_TEMPLATE'] == 'jamis'
-                    Roby::Rake.info "using in-source jamis template"
-                    File.expand_path('doc/styles/jamis', ROBY_ROOT_DIR)
-                elsif ENV['ROBY_RDOC_TEMPLATE'] == 'allison'
-                    Roby::Rake.info "using in-source allison template"
-                    File.expand_path('doc/styles/allison', ROBY_ROOT_DIR)
-                else
-                    Roby::Rake.info "using the #{ENV['ROBY_RDOC_TEMPLATE']} template"
-                    ENV['ROBY_RDOC_TEMPLATE']
+    module App
+        # Rake task definitions for the Roby apps 
+        module Rake
+            # Rake task to run the Roby tests
+            #
+            # To use, add the following to your Rakefile:
+            #
+            #     require 'roby/app/rake'
+            #     Roby::App::Rake::TestTask.new
+            #
+            # It create a test task per robot configuration, named
+            # "test:${robot_name}". It also creates a test:all-robots task that
+            # runs each robot's configuration in sequence. You can inspect these
+            # tasks with
+            #
+            #     rake --tasks
+            #
+            # and call them with e.g.
+            #
+            #     rake test:default
+            #
+            # The test:all-robots task will fail only at the end of all tests, reporting
+            # which configuration actually failed. To stop at the first failure,
+            # pass a '0' as argument, e.g.
+            #
+            #    rake 'test:all-robots[0]'
+            #
+            # Finally, the 'test:all' target runs syskit test --all (i.e. runs
+            # all tests in the default robot configuration)
+            #
+            # The 'test' target points by default to test:all-robots. See below
+            # to change this.
+            #
+            # The following examples show how to fine-tune the creates tests:
+            #
+            # @example restrict the tests to run only under the
+            #   'only_this_configuration' configuration
+            #
+            #      Roby::App::Rake::TestTask.new do |t|
+            #          t.robot_names = ['only_this_configuration']
+            #      end
+            #
+            # @example create tasks under the roby_tests namespace instead of 'test'
+            #
+            #      Roby::App::Rake::TestCase.new('roby_tests')
+            #
+            # @example make 'test' point to 'test:all'
+            #
+            #      Roby::App::Rake::TestCase.new do |t|
+            #          t.all_by_default = true
+            #      end
+            #
+            class TestTask < ::Rake::TaskLib
+                # The base test task name
+                attr_reader :task_name
+
+                # The app
+                #
+                # It defaults to Roby.app
+                attr_accessor :app
+
+                # The list of robot configurations on which we should run the tests
+                #
+                # Use 'default' for the default configuration. It defaults to all
+                # the robots defined in config/robots/
+                #
+                # @return [Array<String,(String,String)>]
+                attr_accessor :robot_names
+
+                # Patterns matching excluded test files
+                #
+                # It accepts any string that File.fnmatch? accepts
+                #
+                # @return [Array<String>]
+                attr_accessor :excludes
+
+                # Whether the 'test' target should run all robot tests (false, the
+                # default) or the 'all tests' target (true)
+                attr_predicate :all_by_default?, true
+
+                def initialize(task_name = 'test', all_by_default: false)
+                    @task_name = task_name
+                    @app = Roby.app
+                    @all_by_default = all_by_default
+                    @robot_names = discover_robot_names
+                    @excludes = []
+                    yield self if block_given?
+                    define
                 end
-            end
-        end
 
-        # Invoke the given target in all plugins found in plugins/ that define it
-        def self.invoke_plugin_target(target)
-	    ENV['ROBY_ROOT_DIR'] = ROBY_ROOT_DIR
-            Dir.new('plugins').each do |plugin_dir|
-                next if plugin_dir =~ /^\.{1,2}$/
-
-                plugin_dir = File.join('plugins', plugin_dir)
-                if File.file? File.join(plugin_dir, 'Rakefile')
-                    Dir.chdir(plugin_dir) do
-                        task_list = `rake --tasks`.split("\n")
-                        if !task_list.grep(/^rake #{target}(\s|$)/).empty?
-                            if !system 'rake', target
-                                raise "failed to call rake target #{target} in #{plugin_dir}"
+                class Failed < RuntimeError; end
+
+                def define
+                    each_robot do |robot_name, robot_type|
+                        task_name = task_name_for_robot(robot_name, robot_type)
+
+                        desc "run the tests for configuration #{robot_name}:#{robot_type}"
+                        task task_name do
+                            if !run_roby_test('-r', "#{robot_name},#{robot_type}")
+                                raise Failed.new("failed to run tests for #{robot_name}:#{robot_type}")
+                            end
+                        end
+                    end
+
+                    desc "run tests for all known robots"
+                    task "#{task_name}:all-robots", [:keep_going] do |t, args|
+                        failures = Array.new
+                        keep_going = args.fetch(:keep_going, '1') == '1'
+                        each_robot do |robot_name, robot_type|
+                            if !run_roby_test('-r', "#{robot_name},#{robot_type}")
+                                if keep_going
+                                    failures << [robot_name, robot_type]
+                                else
+                                    raise Failed.new("failed to run tests for #{robot_name}:#{robot_type}")
+                                end
                             end
                         end
+                        if !failures.empty?
+                            raise Failed.new("failed to run the following test(s): #{failures.map { |name, type| "#{name}:#{type}" }.join(", ")}")
+                        end
+                    end
+
+                    desc "run all tests"
+                    task "#{task_name}:all" do
+                        if !run_roby_test
+                            raise Failed.new("failed to run tests")
+                        end
+                    end
+
+                    if all_by_default?
+                        desc "run all tests"
+                        task task_name => "#{task_name}:all"
+                    else
+                        desc "run all robot tests"
+                        task task_name => "#{task_name}:all-robots"
+                    end
+                end
+
+                def task_name_for_robot(robot_name, robot_type)
+                    if robot_name == robot_type
+                        "#{task_name}:#{robot_name}"
+                    else
+                        "#{task_name}:#{robot_name}-#{robot_type}" 
                     end
                 end
+
+                def run_roby_test(*args)
+                    args = args + excludes.flat_map do |pattern|
+                        ["--exclude", pattern]
+                    end
+                    run_roby('test', *args)
+                end
+
+                def run_roby(*args)
+                    pid = spawn(Gem.ruby, File.expand_path(File.join('..', '..', '..', 'bin', 'roby'), __dir__),
+                           *args)
+                    begin
+                        _, status = Process.waitpid2(pid)
+                        status.success?
+                    rescue Interrupt
+                        Process.kill pid
+                        Process.waitpid(pid)
+                    end
+                end
+
+                # Enumerate the robots on which tests should be run
+                def each_robot(&block)
+                    robot_names.each(&block)
+                end
+
+                # @api private
+                #
+                # Discover which robots are available on the current app
+                def discover_robot_names
+                    if !app.app_dir
+                        app.guess_app_dir
+                    end
+                    app.setup_robot_names_from_config_dir
+                    app.robots.each.to_a
+                end
             end
         end
     end
 end
-

data/lib/roby/app/robot_config.rb

@@ -0,0 +1,9 @@
+module Roby
+    module App
+        # Class that holds the robot-specific configuration blocks as defined
+        # inside 
+        class RobotConfig
+        end
+    end
+end
+

data/lib/roby/app/robot_names.rb

@@ -0,0 +1,115 @@
+module Roby
+    module App
+        # The part of the configuration related to robot declaration
+        class RobotNames
+            # @return [String,nil] the default robot name
+            attr_reader :default_robot_name
+            # @return [Hash<(String,String)>] the set of declared robots, as
+            #   robot_name => robot_type
+            attr_reader :robots
+            # @return [Hash<String,String>] a set of aliases, i.e. short names
+            #   for robots
+            attr_reader :aliases
+            # @return [Boolean] if true, Roby will generate an error if a
+            #   non-declared robot is used. Otherwise, it will only issue a
+            #   warning
+            attr_predicate :strict?, true
+
+            # Create a RobotConfiguration object based on a hash formatted as-is
+            # from the app.yml file
+            def initialize(options = Hash.new)
+                @robots = options['robots'] || Hash.new
+                @default_robot_name = options['default_robot'] || 'default'
+                if !has_robot?(default_robot_name)
+                    robots[default_robot_name] = default_robot_name
+                end
+
+                @aliases = options['aliases'] || Hash.new
+                aliases.each do |name_alias, name|
+                    if !has_robot?(name)
+                        raise ArgumentError, "cannot use #{name_alias} as an alias to #{name}: #{name} is not a declared robot"
+                    end
+                    if has_robot?(name_alias)
+                        raise ArgumentError, "cannot use #{name_alias} as an alias to #{name}: #{name_alias} is already a declared robot"
+                    end
+                end
+
+                self.strict = !!options['robots']
+            end
+
+            # Declare the type of an existing robot
+            def declare_robot_type(robot_name, robot_type)
+                if strict? && !has_robot?(robot_type)
+                    raise ArgumentError, "#{robot_type} is not a known robot"
+                end
+                robots[robot_name] = robot_type
+            end
+
+            # Enumerate the robot names and types
+            def each(&block)
+                robots.each(&block)
+            end
+
+            # Enumerate the list of known robots
+            #
+            # @yieldparam [String] robot_name the robot name
+            def names
+                robots.keys
+            end
+
+            # @return [String,nil] the type of the default robot
+            def default_robot_type
+                if default_robot_name
+                    robots[default_robot_name]
+                end
+            end
+
+            # Tests whether the given name is a declared robot
+            #
+            # @return [Boolean]
+            def has_robot?(name, type = nil)
+                robots.has_key?(name.to_s) &&
+                    (!type || robots[name.to_s] == type.to_s)
+            end
+
+            # Helper method which either warns or raises depending on the
+            # value of {#strict?}
+            def error(klass, message)
+                if strict?
+                    raise klass, message
+                else
+                    Roby::Application.warn message
+                end
+            end
+
+            # Returns the robot name and type matching the given name
+            #
+            # It resolves aliases
+            #
+            # @param [String] name a robot name or alias
+            # @return [(String,String)]
+            # @raises ArgumentError if the given robot name does not exist
+            def resolve(name, type = nil)
+                robot_name = aliases[name] || name || default_robot_name
+                if !robot_name
+                    error(ArgumentError, "no robot name given and no default name declared in app.yml, defaulting to #{default_robot_name}:#{default_robot_type}")
+                    return default_robot_name, default_robot_type
+                elsif robots.has_key?(robot_name)
+                    robot_type = robots[robot_name]
+                    type ||= robot_type
+                    if type != robot_type
+                        error(ArgumentError, "invalid robot type when resolving #{name}:#{type}, #{name} is declared to be of type #{robot_type}")
+                    end
+                    return robot_name, type
+                else
+                    if !robots.empty? || strict?
+                        error(Application::NoSuchRobot, "#{name} is neither a robot name, nor an alias. Known names: #{robots.keys.sort.join(", ")}, known aliases: #{aliases.keys.join(", ")}")
+                    end
+                    return robot_name, (type || robot_name)
+                end
+            end
+        end
+    end
+end
+
+

data/lib/roby/app/run.rb

@@ -3,11 +3,12 @@
 app = Roby.app
 require 'optparse'
 parser = OptionParser.new do |opt|
+    opt.banner = "#{$0} [options] [robot_name [robot_type]]"
     opt.on("--sim", "run in simulation mode") do
-	app.simulation
+        app.simulation
     end
     opt.on("--single", "run in mono-robot mode") do
-	app.single
+        app.single
     end
 end
 parser.parse!(ARGV)

data/lib/roby/app/scripts.rb

@@ -0,0 +1,72 @@
+require 'optparse'
+require 'roby/standalone'
+require 'roby/interface'
+
+module Roby
+    module App
+        module Scripts
+            # Common implementation for scripts whose main functionality
+            # requires to connect to Roby's remote interface
+            #
+            # @example basic usage
+            #   require 'roby/app/scripts'
+            #   Roby::App::Scripts::InterfaceScript.run(*ARGV) do |interface|
+            #       # Do stuff with the roby interface
+            #   end
+            #    
+            class InterfaceScript
+                attr_reader :app
+                attr_reader :host
+
+                def initialize(app = Roby.app,
+                               default_host: app.shell_interface_host || 'localhost',
+                               default_port: app.shell_interface_port || Interface::DEFAULT_PORT)
+                    @app = app
+                    @host_options = Hash[host: default_host, port: default_port]
+                end
+
+                def setup_option_parser(parser)
+                    Roby::Application.host_options(parser, @host_options)
+                end
+
+                def default_option_parser(banner: "")
+                    parser = OptionParser.new
+                    parser.banner = banner
+                    setup_option_parser(parser)
+                    parser
+                end
+
+                def host
+                    return *@host_options.values_at(:host, :port)
+                end
+
+                def run(*args, banner: "",
+                    option_parser: default_option_parser(banner: banner))
+
+                    app.guess_app_dir
+                    app.shell
+                    app.single
+                    app.load_base_config
+
+                    args = option_parser.parse(args)
+                    host, port = self.host
+                    interface = Roby::Interface.connect_with_tcp_to(host, port)
+                    yield(interface)
+                end
+
+                def self.run(*args, banner: '', &block)
+                    Roby.display_exception do
+                        begin
+                            new.run(*args, banner: banner, &block)
+                        rescue Roby::Interface::ConnectionError => e
+                            Robot.fatal e.message
+                        rescue Interrupt
+                            Robot.warn "Interrupted by user"
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/app/scripts/autotest.rb

@@ -0,0 +1,173 @@
+require 'autorespawn'
+require 'roby'
+require 'roby/test/spec'
+require 'optparse'
+require 'drb'
+
+Robot.logger.level = Logger::WARN
+
+app = Roby.app
+app.require_app_dir
+app.public_logs = false
+app.single = true
+app.simulation = true
+app.testing = true
+app.auto_load_models = false
+
+MetaRuby.keep_definition_location = false
+
+modes = []
+robots = []
+cmdline_args = []
+all_robots = false
+server_pid = nil
+
+parser = OptionParser.new do |opt|
+    opt.on('--verbose', 'display INFO messages') do |val|
+        cmdline_args << "--verbose"
+        Roby.logger.level = Logger::INFO
+    end
+    opt.on('--debug', 'display DEBUG messages') do |val|
+        cmdline_args << "--debug"
+        Roby.logger.level = Logger::DEBUG
+    end
+    opt.on('-s', '--sim', 'run test in simulation (stubbing)') do |val|
+        modes << '--sim'
+    end
+    opt.on("-l", "--live", "run tests in live mode") do |val|
+        modes << '--live'
+    end
+    opt.on '--all-robots', 'run tests for all robots' do
+        all_robots = true
+    end
+    opt.on('-r NAME', '--robot=NAME[,TYPE]', String, 'a robot name and type to add to the test matrix') do |name|
+        robots << name
+    end
+    opt.on("-k", "--keep-logs", "keep all logs") do |val|
+        cmdline_args << '--keep-logs'
+    end
+    opt.on('--server=PID', Integer, 'the minitest server PID (used to generate a drbunix path)') do |pid|
+        server_pid = pid
+        cmdline_args << "--server" << pid.to_s
+    end
+    Roby::Application.common_optparse_setup(opt)
+end
+
+test_files = parser.parse(ARGV)
+
+if !server_pid
+    require 'roby/app/test_server'
+    require 'roby/app/autotest_console_reporter'
+    manager = Autorespawn::Manager.new(name: Hash[cmdline: "#{$0} #{ARGV.join(" ")}"])
+    server_pid = Process.pid
+    server = Roby::App::TestServer.start(Process.pid)
+    server_console_output = Roby::App::AutotestConsoleReporter.new(server, manager)
+    cmdline_args << '--server' << server_pid.to_s
+else
+    DRb.start_service
+    manager = Autorespawn.new
+end
+
+require 'roby/app/test_reporter'
+reporter = Roby::App::TestReporter.new(Process.pid, manager.name, server_pid)
+
+Roby.display_exception do
+    Roby.app.setup_robot_names_from_config_dir
+    if all_robots
+        robots = Roby.app.robots.names
+    end
+
+    process_id = Autorespawn.name || Hash.new
+
+    if robots.size > 1
+        reporter.discovery_start
+        robots.each do |name|
+            spawner.add_slave(
+                Gem.ruby, '-S', $0,
+                'autotest', "--robot=#{name}", *modes, *cmdline_args, *test_files,
+                name: process_id.merge(robot: name))
+        end
+        reporter.discovery_finished
+        manager.run
+        exit 0
+    end
+
+    if robot_name = robots.first
+        process_id = process_id.merge(robot: robot_name)
+        cmdline_args << "--robot=#{robot_name}"
+    end
+
+    if modes.size > 1
+        reporter.discovery_start
+        modes.each do |m|
+            manager.add_slave(
+                Gem.ruby, '-S', $0, 'autotest', m, *cmdline_args, *test_files)
+        end
+        reporter.discovery_finished
+        manager.run
+        exit 0
+    end
+
+    if m = modes.first
+        Roby.app.simulation = (m != '--live')
+        process_id = process_id.merge(mode: m.gsub(/^--/, ''))
+        cmdline_args << m
+    end
+    if robot_name
+        Roby.app.robot robot_name
+    end
+
+    if test_files.size != 1 || !Autorespawn.slave?
+        Roby.app.setup
+        begin
+            reporter.discovery_start
+            if test_files.empty?
+                test_files = Roby.app.each_model.map do |m|
+                    [m, Roby.app.test_file_for(m)]
+                end.compact
+            else
+                test_files = test_files.map { |path| [nil, path] }
+            end
+            test_files.each do |model, path|
+                if model
+                    process_id = process_id.merge(model: model.name)
+                end
+                
+                manager.add_slave(
+                    Gem.ruby, '-S', $0, 'autotest', *cmdline_args, path,
+                    name: process_id.merge(path: path))
+            end
+            reporter.discovery_finished
+            manager.run
+        ensure Roby.app.cleanup
+        end
+        exit 0
+    end
+
+    manager.on_exception do |e|
+        reporter.exception(e)
+    end
+    manager.run do
+        Roby.app.setup
+        require test_files.first
+        reporter.test_start
+        begin
+            Roby.app.prepare
+
+            begin
+                Minitest.__run reporter, Hash.new
+            rescue Interrupt
+                warn "Interrupted. Exiting..."
+            end
+        ensure
+            reporter.test_finished
+            Roby.app.shutdown
+            Roby.app.cleanup
+            if reporter.has_failures?
+                manager.exit_code 1
+            end
+        end
+    end
+end
+
+