roby 0.8.0 → 3.0.0

data/lib/roby/app/autotest_console_reporter.rb

@@ -0,0 +1,138 @@
+module Roby
+    module App
+        # Reporter class for the Roby autotest, that outputs on an IO object
+        class AutotestConsoleReporter
+            # @return [#puts] the IO on which reporting should be done
+            attr_reader :io
+
+            # @return [App::TestServer] the test server
+            attr_reader :server
+
+            # @return [Autorespawn::Manager] the autorespawn slave manager
+            attr_reader :manager
+
+            # @return [Hash<Autorespawn::Slave,Integer>] mapping from
+            #   a slave to the unique ID associated with it
+            attr_reader :slave_to_id
+            
+            # @return [Hash<Integer,Autorespawn::Slave>] mapping from
+            #   a process ID to the slave object
+            attr_reader :pid_to_slave
+
+            # @api private
+            #
+            # Converts a slave object to the string displayed to the user
+            def slave_to_s(slave)
+                slave.name.sort_by(&:first).map { |k, v| "#{k}: #{v}" }
+            end
+
+            # @api private
+            #
+            # Register a new slave
+            #
+            # @return [Integer] the unique slave ID
+            def register_slave(slave)
+                if slave_to_id[slave]
+                    raise ArgumentError, "#{slave} is already registered"
+                end
+                slave_to_id[slave] = (@slave_id += 1)
+            end
+
+            # @api private
+            #
+            # Register a new slave-to-PID mapping
+            #
+            # @param [Autorespawn::Slave] slave a slave whose #pid is valid
+            # @return [Integer] the slave's unique slave ID
+            # @raise [ArgumentError] if the slave has not been registered with
+            #   {#register_slave} first
+            def register_slave_pid(slave)
+                if slave_id = slave_to_id[slave]
+                    pid_to_slave[slave.pid] = slave
+                    return slave_id
+                else
+                    raise ArgumentError, "#{slave} has not been registered with #register_slave"
+                end
+            end
+            
+            # @api private
+            #
+            # Returns a slave from its PID
+            #
+            # @param [Integer] pid the PID
+            # @return [(Autorespawn::Slave,Integer)] the slave and its unique
+            #   slave ID
+            # @raise [ArgumentError] if no slave is registered for this PID
+            def slave_from_pid(pid)
+                if slave = pid_to_slave[pid]
+                    return slave, slave_to_id[slave]
+                else
+                    raise ArgumentError, "no slave registered for PID #{pid}"
+                end
+            end
+
+            # @api private
+            #
+            # Deregisters a slave-to-PID mapping
+            #
+            # @return [(Autorespawn::Slave,Integer)] the slave object and unique
+            #   slave ID that were associated with the slave
+            # @raise [ArgumentError] if there is no slave associated with the
+            #   PID
+            def deregister_slave_pid(pid)
+                if slave = pid_to_slave.delete(pid)
+                    return slave, slave_to_id[slave]
+                else
+                    raise ArgumentError, "no slave known for #{pid}"
+                end
+            end
+
+            def initialize(server, manager, io: STDOUT)
+                @io = io
+                @slave_id = 0
+                @slave_to_id = Hash.new
+                @pid_to_slave = Hash.new
+                manager.on_slave_new do |slave|
+                    slave_id = register_slave(slave)
+                    io.puts "[##{slave_id}] new slave #{slave_to_s(slave)}"
+                end
+                manager.on_slave_start do |slave|
+                    slave_id = register_slave_pid(slave)
+                    io.puts "[##{slave_id}] slave #{slave_to_s(slave)} started (PID=#{slave.pid})"
+                end
+                manager.on_slave_finished do |slave|
+                    slave, slave_id = deregister_slave_pid(slave.pid)
+                    io.puts "[##{slave_id}] slave #{slave_to_s(slave)} finished (PID=#{slave.pid})"
+                end
+                server.on_exception do |pid, exception|
+                    slave, slave_id = slave_from_pid(pid)
+                    io.puts "[##{slave_id}] #{slave_to_s(slave)} reports exception"
+                    Roby.display_exception(io, exception)
+                end
+                server.on_discovery_start do |pid|
+                    slave, slave_id = slave_from_pid(pid)
+                    io.puts "[##{slave_id}] #{slave_to_s(slave)} started discovery"
+                end
+                server.on_discovery_finished do |pid|
+                    slave, slave_id = slave_from_pid(pid)
+                    io.puts "[##{slave_id}] #{slave_to_s(slave)} finished discovery"
+                end
+                server.on_test_start do |pid|
+                    slave, slave_id = slave_from_pid(pid)
+                    io.puts "[##{slave_id}] #{slave_to_s(slave)} started testing"
+                end
+                server.on_test_result do |pid, file, test_case_name, test_name, failures, assertions, time|
+                    slave, slave_id = slave_from_pid(pid)
+                    io.puts "[##{slave_id}] #{test_case_name}##{test_name}: #{failures.size} failures and #{assertions.size} assertions (#{time})"
+                    failures.each do |e|
+                        Roby.display_exception(io, e)
+                    end
+                end
+                server.on_test_finished do |pid|
+                    slave, slave_id = slave_from_pid(pid)
+                    io.puts "[##{slave_id}] #{slave_to_s(slave)} finished testing"
+                end
+            end
+        end
+    end
+end

data/lib/roby/app/base.rb

@@ -0,0 +1,21 @@
+module Roby
+    module App
+        DEFAULT_ROBOT_NAME = 'default'
+        DEFAULT_ROBOT_TYPE = 'default'
+
+        # Resolves the ROBOT keyword in the given path
+        #
+        # @param [String] path
+        # @param [String] robot_name
+        # @return [String]
+        def self.resolve_robot_in_path(path, robot_name = Roby.app.robot_name)
+            if robot_name == DEFAULT_ROBOT_NAME
+                robot_name = ""
+            end
+            robot_name ||= ""
+
+            path.gsub(/ROBOT/, robot_name).
+                gsub(/\/\//, '/')
+        end
+    end
+end

data/lib/roby/app/cucumber.rb

@@ -0,0 +1,2 @@
+require 'roby/app/cucumber/helpers'
+require 'roby/app/cucumber/controller'

data/lib/roby/app/cucumber/controller.rb

@@ -0,0 +1,439 @@
+require 'roby/interface/async'
+
+module Roby
+    module App
+        module Cucumber
+            # API that starts and communicates with a Roby controller for the
+            # benefit of a Cucumber scenario
+            class Controller
+                class InvalidState < RuntimeError; end
+
+                # The PID of the started Roby process
+                #
+                # @return [Integer,nil]
+                attr_reader :roby_pid
+
+                # The object used to communicate with the Roby instance
+                #
+                # It is set only after {#roby_wait} was called (or after a
+                # {#roby_start} whose wait parameter was set to true)
+                #
+                # @return [Roby::Interface::Client,nil]
+                attr_reader :roby_interface
+
+                # The set of jobs started by {#start_monitoring_job}
+                attr_reader :background_jobs
+
+                # The batch that gathers all the interface operations that will
+                # be executed at the next #run_job
+                attr_reader :current_batch
+
+                # Actions that would be started by {#current_batch}
+                attr_reader :pending_actions
+
+                # Whether the process should abort when an error is detected, or
+                # keep running the actions as-is. The latter is useful for
+                # debugging
+                #
+                # Active the keep running mode by setting CUCUMBER_KEEP_RUNNING
+                # to 1
+                attr_predicate :keep_running?, true
+
+                # Whether we run the jobs, or only validate their existence and
+                # arguments
+                #
+                # The validation mode is activated by setting
+                # ROBY_VALIDATE_STEPS to '1'
+                attr_predicate :validation_mode?, true
+
+                # Whether this started a Roby controller
+                def roby_running?
+                    !!@roby_pid
+                end
+
+                # Whether we have a connection to the started Roby controller
+                def roby_connected?
+                    roby_interface.connected?
+                end
+
+                def initialize(port: Roby::Interface::DEFAULT_PORT,
+                               keep_running: (ENV['CUCUMBER_KEEP_RUNNING'] == '1'),
+                               validation_mode: (ENV['ROBY_VALIDATE_STEPS'] == '1'))
+                    @roby_pid = nil
+                    @roby_interface = Roby::Interface::Async::Interface.
+                        new('localhost', port: port)
+                    @background_jobs = Array.new
+                    @keep_running = keep_running
+                    @validation_mode = validation_mode
+                    @pending_actions = []
+                end
+
+                # Start a Roby controller
+                # 
+                # @param [String] robot_name the name of the robot configuration
+                # @param [String] robot_type the type of the robot configuration
+                # @param [Boolean] wait whether the method should wait for a
+                #   successful connection to the Roby application
+                # @param [Boolean] controller whether the configuration's controller
+                #   blocks should be executed
+                # @param [Hash] state initial values for the state
+                #
+                # @raise InvalidState if a controller is already running
+                def roby_start(robot_name, robot_type, connect: true, controller: true, app_dir: Dir.pwd, log_dir: nil, state: Hash.new, **spawn_options)
+                    if roby_running?
+                        raise InvalidState, "a Roby controller is already running, call #roby_stop and #roby_join first"
+                    end
+
+                    options = Array.new
+                    if log_dir
+                        options << "--log-dir=#{log_dir}"
+                    end
+                    @roby_pid = spawn Gem.ruby, File.join(Roby::BIN_DIR, "roby"), 'run',
+                        "--robot=#{robot_name},#{robot_type}",
+                        '--controller',
+                        '--quiet',
+                        *options,
+                        *state.map { |k, v| "--set=#{k}=#{v}" },
+                        chdir: app_dir,
+                        pgroup: 0,
+                        **spawn_options
+                    if connect
+                        roby_connect
+                    end
+                    roby_pid
+                end
+
+                # Try connecting to the Roby controller
+                #
+                # It sets {#roby_interface} on success
+                #
+                # @return [Roby::Interface::Client,nil] a valid interface object
+                #   if the connection was successful, and nil otherwise
+                def roby_try_connect
+                    if !roby_interface.connecting? && !roby_interface.connected?
+                        roby_interface.attempt_connection
+                    end
+                    roby_interface.poll
+                    roby_interface.connected?
+                end
+
+                # Wait for the Roby controller started with {#roby_start} to be
+                # available
+                def roby_connect
+                    if roby_connected?
+                        raise InvalidState, "already connected"
+                    end
+
+                    while !roby_connected?
+                        roby_try_connect
+                        _, status = Process.waitpid2(roby_pid, Process::WNOHANG)
+                        if status
+                            raise InvalidState, "remote Roby controller quit before we could get a connection"
+                        end
+                        roby_interface.wait
+                    end
+                    @current_batch = @roby_interface.create_batch
+                end
+
+                # Disconnect the interface to the controller, but does not stop
+                # the controller
+                def roby_disconnect
+                    if !roby_connected?
+                        raise InvalidState, "not connected"
+                    end
+
+                    @roby_interface.close
+                end
+
+                # Stops an already started Roby controller
+                #
+                # @raise InvalidState if no controllers were started
+                def roby_stop(join: true)
+                    if !roby_running?
+                        raise InvalidState, "cannot call #roby_stop if no controllers were started"
+                    elsif !roby_connected?
+                        raise InvalidState, "you need to successfully connect to the Roby controller with #roby_connect before you can call #roby_stop"
+                    end
+
+                    begin
+                        roby_interface.quit
+                    rescue Interface::ComError
+                    ensure
+                        roby_interface.close
+                    end
+
+                    roby_join if join
+                end
+
+                # Kill the Roby controller process
+                def roby_kill(join: true)
+                    if !roby_running?
+                        raise InvalidState, "cannot call #roby_stop if no controllers were started"
+                    end
+
+                    Process.kill('INT', roby_pid)
+                    roby_join if join
+                end
+
+
+                # Wait for the remote process to quit
+                def roby_join
+                    if !roby_running?
+                        raise InvalidState, "cannot call #roby_join without a running Roby controller"
+                    end
+
+                    _, status = Process.waitpid2(roby_pid)
+                    @roby_pid = nil
+                    status
+                rescue Errno::ECHILD
+                    @roby_pid = nil
+                end
+
+                # Wait for the remote process to quit
+                #
+                # It raises an exception if the process does not terminate
+                # successfully
+                def roby_join!
+                    if (status = roby_join) && !status.success?
+                        raise InvalidState, "Roby process exited with status #{status}"
+                    end
+                rescue Errno::ENOCHILD
+                    @roby_pid = nil
+                end
+
+                # Enable or disable backtrace filtering on the Roby instance
+                def roby_enable_backtrace_filtering(enable: true)
+                    if !roby_connected?
+                        raise InvalidState, "you need to successfully connect to the Roby controller with #roby_connect before you can call #roby_enable_backtrace_filtering"
+                    end
+                    roby_interface.client.enable_backtrace_filtering(enable: enable)
+                end
+
+                # The log dir of the Roby app
+                #
+                # Since the roby app is local, this is a valid local path
+                def roby_log_dir
+                    roby_interface.client.log_dir
+                end
+
+                # Exception raised when an monitor failed while an action was
+                # running
+                class FailedBackgroundJob < RuntimeError; end
+
+                # Exception raised when an action finished with any other state
+                # than 'success'
+                class FailedAction < RuntimeError; end
+
+                BackgroundJob = Struct.new :action_monitor, :description, :monitoring do
+                    def job_id
+                        action_monitor.job_id
+                    end
+                    def success?
+                        action_monitor.success?
+                    end
+                    def terminated?
+                        action_monitor.terminated?
+                    end
+                    def monitoring?
+                        monitoring
+                    end
+                end
+
+                # The job ID of the last started 
+                #
+                # @return [nil,Integer] nil if the job has not yet been started,
+                #   and the ID otherwise. It's the caller responsibility to call
+                #   {#apply_current_batch}
+                def last_main_job_id
+                    if job = each_main_job.to_a.last
+                        job.job_id
+                    end
+                end
+
+                # Start a job in the background
+                #
+                # Its failure will make the next #run_job step fail. Unlike a
+                # job created by {#start_monitoring_job}, it will not be stopped
+                # when {#run_job} is called.
+                def start_job(description, m, arguments = Hash.new)
+                    if @has_run_job
+                        drop_all_jobs if !validation_mode?
+                        @has_run_job = false
+                    end
+                    __start_job(description, m, arguments, false)
+                end
+
+                # Start a background action whose failure will make the next
+                # #run_job step fail
+                #
+                # This action will be stopped at the end of the next {#run_job}
+                def start_monitoring_job(description, m, arguments = Hash.new)
+                    __start_job(description, m, arguments, true)
+                end
+
+                # @api private
+                #
+                # Helper job-starting method
+                def __start_job(description, m, arguments, monitoring)
+                    if validation_mode?
+                        validate_job(m, arguments)
+                        return
+                    end
+
+                    action = Interface::Async::ActionMonitor.new(roby_interface, m, arguments)
+                    action.restart(batch: current_batch)
+                    pending_actions << action
+                    background_jobs << BackgroundJob.new(action, description, monitoring)
+                    action
+                end
+
+                # Enumerate all jobs started with {#start_monitoring_job}
+                def each_monitoring_job
+                    return enum_for(__method__) if !block_given?
+                    background_jobs.each do |job|
+                        yield(job) if job.monitoring?
+                    end
+                end
+
+                # Enumerate all jobs started with {#start_job}
+                #
+                # These jobs are usually the job-under-test, hence the 'main'
+                # moniker
+                def each_main_job
+                    return enum_for(__method__) if !block_given?
+                    background_jobs.each do |job|
+                        yield(job) if !job.monitoring?
+                    end
+                end
+
+                # Find one monitoring job that failed
+                def find_failed_monitoring_job
+                    each_monitoring_job.find do |background_job|
+                        background_job.terminated? && !background_job.success?
+                    end
+                end
+
+                # @api private
+                #
+                # Poll the interface until the block returns a truthy value
+                def roby_poll_interface_until
+                    while !(result = yield)
+                        if defined?(::Cucumber) && ::Cucumber.wants_to_quit
+                            raise Interrupt, "Interrupted"
+                        end
+                        roby_interface.poll
+                        roby_interface.wait
+                    end
+                    result
+                end
+
+                def apply_current_batch(*actions, sync: true)
+                    return if current_batch.empty?
+
+                    batch_result = current_batch.__process
+                    if sync
+                        roby_poll_interface_until do
+                            (pending_actions + actions).all? { |act| act.async }
+                        end
+                    end
+                    batch_result
+                ensure
+                    @current_batch = roby_interface.create_batch
+                    @pending_actions = Array.new
+                end
+
+                # Start an action
+                def run_job(m, arguments = Hash.new)
+                    if validation_mode?
+                        validate_job(m, arguments)
+                        return
+                    end
+
+                    action = Interface::Async::ActionMonitor.new(roby_interface, m, arguments)
+                    action.restart(batch: current_batch)
+                    apply_current_batch(action)
+                    @has_run_job = true
+
+                    failed_monitor = roby_poll_interface_until do
+                        if action.terminated?
+                            break
+                        else
+                            find_failed_monitoring_job
+                        end
+                    end
+
+                    if action.success?
+                        return
+                    elsif failed_monitor
+                        if keep_running?
+                            STDERR.puts
+                            STDERR.puts "FAILED: monitoring job #{failed_monitor.description} failed"
+                            STDERR.puts "In 'keep running' mode. Interrupt with CTRL+C"
+                            roby_poll_interface_until { false }
+                        else
+                            raise FailedBackgroundJob, "monitoring job #{failed_monitor.description} failed"
+                        end
+                    else
+                        if keep_running?
+                            STDERR.puts
+                            STDERR.puts "FAILED: action #{m} failed"
+                            STDERR.puts "In 'keep running' mode. Interrupt with CTRL+C"
+                            roby_poll_interface_until { false }
+                        else
+                            raise FailedAction, "action #{m} failed"
+                        end
+                    end
+
+                ensure
+                    # Kill the monitoring actions as well as the main actions
+                    drop_monitoring_jobs(*Array(action))
+                end
+
+                # Raised when validating the jobs
+                class InvalidJob < ArgumentError; end
+
+                # @api private
+                #
+                # Validate that the given action name and arguments match the
+                # interface's description
+                def validate_job(m, arguments)
+                    if !(action = roby_interface.client.find_action_by_name(m))
+                        raise InvalidJob, "no action is named '#{m}'"
+                    end
+                    arguments = arguments.dup
+                    action.arguments.each do |arg|
+                        arg_sym = arg.name.to_sym
+                        has_arg = arguments.has_key?(arg_sym)
+                        if !has_arg && arg.required?
+                            raise InvalidJob, "#{m} requires an argument named #{arg.name} which is not provided"
+                        end
+                        arguments.delete(arg_sym)
+                    end
+                    if !arguments.empty?
+                        raise InvalidJob, "arguments #{arguments.keys.map(&:to_s).sort.join(", ")} are not declared arguments of #{m}"
+                    end
+                end
+
+                def drop_all_jobs(*extra_jobs)
+                    jobs, @background_jobs =
+                        background_jobs, Array.new
+                    drop_jobs(*extra_jobs, *jobs.map(&:action_monitor))
+                end
+
+                def drop_monitoring_jobs(*extra_jobs)
+                    monitoring_jobs, @background_jobs =
+                        background_jobs.partition { |j| j.monitoring? }
+                    drop_jobs(*extra_jobs, *monitoring_jobs.map(&:action_monitor))
+                end
+
+                def drop_jobs(*jobs)
+                    jobs.each do |act|
+                        if !act.terminated? && act.async
+                            act.drop(batch: current_batch)
+                        end
+                    end
+                end
+            end
+        end
+    end
+end