roby 0.8.0 → 3.0.0

data/lib/roby/cli/log/flamegraph_renderer.rb

@@ -0,0 +1,88 @@
+# inspired by https://github.com/brendangregg/FlameGraph
+require 'base64'
+
+module Roby
+    module CLI
+        class Log
+            class FlamegraphRenderer
+                def initialize(stacks)
+                    @stacks = stacks
+                end
+
+                def graph_html(embed_resources: false)
+                    body = read('flamegraph.html')
+                    body.sub! "/**INCLUDES**/",
+                        if embed_resources
+                            embed("jquery.min.js","d3.min.js","lodash.min.js")
+                    else
+                        '<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.0.8/d3.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.3.1/lodash.min.js"></script>'
+                    end
+
+                    body.sub!("/**DATA**/", ::JSON.generate(graph_data));
+                    body
+                end
+
+                def graph_data
+                    table = []
+                    prev = []
+
+                    x = 0
+                    # a 2d array makes collapsing easy
+                    @stacks.each_with_index do |(stack, duration), pos|
+                        col = []
+                        stack.each_with_index do |frame, i|
+                            if (last_col = prev[i]) && (last_col[0] == frame)
+                                last_col[1] += duration
+                                col << nil
+                            else
+                                prev[i] = [frame, duration]
+                                col << prev[i]
+                            end
+                        end
+                        prev = prev[0..col.length-1].to_a
+                        table << [x, col]
+                        x += duration
+                    end
+
+                    data = []
+
+                    # a 1d array makes rendering easy
+                    col_num = 0
+                    table.each do |x, col|
+                        col.each_with_index do |row, row_num|
+                            next unless row && row.length == 2
+                            data << {
+                                x: x + 1,
+                                y: row_num + 1,
+                                width: row[1],
+                                frame: row[0]
+                            }
+                            col_num += row[1]
+                        end
+                    end
+
+                    data
+                end
+
+                private
+
+                def embed(*files)
+                    out = ""
+                    files.each do |file|
+                        body = read(file)
+                        out << "<script src='data:text/javascript;base64," << Base64.encode64(body) << "'></script>"
+                    end
+                    out
+                end
+
+                def read(file)
+                    IO.read(::File.expand_path(file, ::File.dirname(__FILE__)))
+                end
+
+            end
+        end
+    end
+end
+

data/lib/roby/cli/main.rb

@@ -0,0 +1,153 @@
+require 'thor'
+require 'roby'
+require 'roby/cli/exceptions'
+require 'roby/cli/gen_main'
+
+module Roby
+    module CLI
+        class Main < Thor
+            desc 'add_robot ROBOT_NAME', "Deprecated, use 'gen robot' instead",
+                hide: true # backward-compatibility only
+            def add_robot(robot_name)
+                gen('robot', robot_name)
+            end
+
+            desc 'init [DIR]', "Deprecated, use 'gen app' instead",
+                hide: true # backward-compatibility only
+            def init(*dir)
+                gen('app', *dir)
+            end
+
+            desc 'gen [GEN_MODE]', 'scaffold generation'
+            subcommand :gen, GenMain
+
+            no_commands do
+                def parse_host_option
+                    if url = options[:host]
+                        if url =~ /(.*):(\d+)$/
+                            return Hash[host: $1, port: Integer($2)]
+                        else
+                            return Hash[host: url]
+                        end
+                    elsif url = options[:vagrant]
+                        require 'roby/app/vagrant'
+                        if vagrant_name =~ /(.*):(\d+)$/
+                            vagrant_name, port = $1, Integer($2)
+                        end
+                        return Hash[host: Roby::App::Vagrant.resolve_ip(vagrant_name),
+                                    port: port]
+                    else Hash.new
+                    end
+                end
+
+                def setup_interface(app = Roby.app, retry_connection: false, timeout: nil)
+                    host_port = parse_host_option
+                    host = host_port[:host] || app.shell_interface_host || 'localhost'
+                    port = host_port[:port] || app.shell_interface_port || Interface::DEFAULT_PORT
+
+                    app.guess_app_dir
+                    app.shell
+                    app.single
+                    app.load_base_config
+
+                    interface = nil
+                    if retry_connection && timeout
+                        deadline = Time.now + timeout
+                    end
+                    while true
+                        begin
+                            return Roby::Interface.connect_with_tcp_to(host, port)
+                        rescue Roby::Interface::ConnectionError => e
+                            if deadline && deadline > Time.now
+                                Robot.warn "failed to connect to #{host}:#{port}: #{e.message}, retrying"
+                                sleep 0.05
+                            elsif !retry_connection || deadline
+                                raise
+                            end
+                        rescue Interrupt
+                            raise
+                        end
+                    end
+                end
+                def display_notifications(interface)
+                    while !interface.closed?
+                        interface.poll
+                        while interface.has_notifications?
+                            _, (source, level, message) = interface.pop_notification
+                            Robot.send(level.downcase, message)
+                        end
+                        while interface.has_job_progress?
+                            _, (kind, job_id, job_name) = interface.pop_job_progress
+                            Robot.info "[#{job_id}] #{job_name}: #{kind}"
+                        end
+                        sleep 0.01
+                    end
+                end
+            end
+
+            desc 'quit', 'quits a running Roby application to be available'
+            option :host, desc: 'the host[:port] to connect to',
+                type: :string
+            option :retry,
+                desc: 'retry to connect instead of failing right away',
+                long_desc: "The argument is an optional timeout in seconds.\nThe command will retry forever if not given",
+                type: :numeric, lazy_default: 0
+            def quit
+                timeout = options[:retry] if options[:retry] != 0
+                interface = setup_interface(
+                    retry_connection: !!options[:retry],
+                    timeout: timeout)
+                Robot.info "connected"
+                interface.quit
+                begin
+                    Robot.info "waiting for remote app to terminate"
+                    display_notifications(interface)
+                rescue Roby::Interface::ComError
+                    Robot.info "closed communication"
+                rescue Interrupt
+                    Robot.info "CTRL+C detected, forcing remote quit. Press CTRL+C once more to terminate this script"
+                    interface.quit
+                    display_notifications(interface)
+                end
+            ensure
+                interface.close if interface && !interface.closed?
+            end
+
+            desc 'wait', 'waits for a running Roby application to be available',
+                hide: true
+            option :host, desc: 'the host[:port] to connect to',
+                type: :string
+            option :timeout,
+                desc: 'how long the command should wait, in seconds (default is 10s)',
+                type: :numeric, default: 10
+            def wait
+                interface = setup_interface(
+                    retry_connection: true,
+                    timeout: options[:timeout])
+            ensure
+                interface.close if interface && !interface.closed?
+            end
+
+            desc 'check', 'verifies that the configuration is valid',
+                hide: true
+            long_desc 'This loads the specified robot configuration,'\
+                ' but does not start the app itself.'\
+                ' Use this to validate the current configuration'
+            option :robot, aliases: 'r', desc: 'the robot name', default: 'default'
+            def check(app_dir = nil, *extra_files)
+                app = Roby.app
+                if app_dir
+                    app.app_dir = app_dir
+                end
+                app.require_app_dir
+                app.robot(options[:robot])
+                begin app.setup
+                    extra_files.each do |path|
+                        app.require(File.expand_path(path))
+                    end
+                ensure app.cleanup
+                end
+            end
+        end
+    end
+end

data/lib/roby/coordination.rb

@@ -0,0 +1,60 @@
+module Roby
+    # Namespace for high-level coordination models
+    #
+    # The existing coordination models are:
+    # * Coordination::ActionScript, usually accessed from the #action_script
+    #   stanza in an action interface, defines step-by-step list of instructions
+    #   where each instruction deals with an action (i.e. start, execute, ...)
+    #   and transition are events
+    # * Coordination::ActionStateMachine, usually accessed from the #action_state_machine
+    #   stanza in an action interface, defines state machines where each state
+    #   is realized by a single action, and transition are events
+    # * Coordination::TaskScript, usually accessed from the #task_script stanza
+    #   in a Roby task model, defines step-by-step list of instructions where each
+    #   instruction deals with code blocks and transition are events
+    # * Coordination::TaskStateMachine, usually accessed from the
+    #   #task_state_machine stanza in a task model, defines state machines where each state
+    #   is realized by a code block, and transition are events
+    module Coordination
+    end
+end
+
+require 'binding_of_caller'
+require 'roby/coordination/calculus'
+require 'roby/coordination/models/exceptions'
+require 'roby/coordination/models/task'
+require 'roby/coordination/models/event'
+require 'roby/coordination/models/root'
+require 'roby/coordination/models/variable'
+require 'roby/coordination/models/capture'
+require 'roby/coordination/models/child'
+require 'roby/coordination/models/arguments'
+require 'roby/coordination/models/base'
+require 'roby/coordination/models/task_with_dependencies'
+require 'roby/coordination/models/task_from_instanciation_object'
+require 'roby/coordination/models/task_from_action'
+require 'roby/coordination/models/task_from_variable'
+require 'roby/coordination/models/task_from_as_plan'
+require 'roby/coordination/models/actions'
+require 'roby/coordination/models/action_state_machine'
+require 'roby/coordination/script_instruction'
+require 'roby/coordination/models/script'
+require 'roby/coordination/models/action_script'
+require 'roby/coordination/models/fault_handler'
+require 'roby/coordination/models/fault_response_table'
+
+require 'roby/coordination/base'
+require 'roby/coordination/task_base'
+require 'roby/coordination/task'
+require 'roby/coordination/event'
+require 'roby/coordination/child'
+require 'roby/coordination/script'
+
+require 'roby/coordination/actions'
+require 'roby/coordination/action_state_machine'
+require 'roby/coordination/action_script'
+require 'roby/coordination/task_script'
+require 'roby/coordination/task_state_machine'
+require 'roby/coordination/fault_handling_task'
+require 'roby/coordination/fault_handler'
+require 'roby/coordination/fault_response_table'

data/lib/roby/coordination/action_script.rb

@@ -0,0 +1,25 @@
+module Roby
+    module Coordination
+        class ActionScript < Actions
+            extend Models::ActionScript
+            include Script
+
+            # The list of instructions, instanciated from model.instructions
+            # using {Base#instance_for}
+            attr_reader :instructions
+
+            # The current instruction
+            attr_reader :current_instruction
+
+            def initialize(root_task, arguments = Hash.new)
+                super
+                prepare
+
+                root_task.execute do
+                    step
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/coordination/action_state_machine.rb

@@ -0,0 +1,125 @@
+module Roby
+    module Coordination
+        # A state machine defined on action interfaces
+        #
+        # In such state machine, each state is represented by the task returned
+        # by the corresponding action, and the transitions are events on these
+        # tasks
+        class ActionStateMachine < Actions
+            extend Models::ActionStateMachine
+
+            include Hooks
+            include Hooks::InstanceHooks
+
+            define_hooks :on_transition
+
+            # The current state
+            attr_reader :current_state
+
+            StateInfo = Struct.new :required_tasks, :forwards, :transitions, :captures
+
+            def initialize(root_task, arguments = Hash.new)
+                super(root_task, arguments)
+                @task_info = resolve_state_info
+
+                start_state = model.starting_state
+                if arguments[:start_state]
+                    start_state = model.find_state_by_name(arguments[:start_state])
+                    if !start_state
+                        raise ArgumentError, "The starting state #{arguments[:start_state]} is unkown, make sure its definied in the statemachine #{self}"
+                    end
+                end
+
+                model.each_capture do |capture, (in_state, captured_event)|
+                    if in_state == model.root
+                        captured_event = instance_for(model.root).find_event(captured_event.symbol)
+                        captured_event.resolve.once do |event|
+                            if root_task.running?
+                                resolved_captures[capture] = capture.filter(self, event)
+                            end
+                        end
+                    end
+                end
+
+                root_task.execute do
+                    if start_state
+                        instanciate_state(instance_for(start_state))
+                    end
+                end
+            end
+
+            def resolve_state_info
+                task_info.map_value do |task, task_info|
+                    task_info = StateInfo.new(task_info.required_tasks, task_info.forwards, Set.new, Hash.new)
+                    model.each_transition do |in_state, event, new_state|
+                        in_state = instance_for(in_state)
+                        if in_state == task
+                            task_info.transitions << [instance_for(event), instance_for(new_state)]
+                        end
+                    end
+                    model.each_capture do |capture, (in_state, event)|
+                        in_state = instance_for(in_state)
+                        if in_state == task
+                            task_info.captures[capture] = instance_for(event)
+                        end
+                    end
+                    task_info
+                end
+            end
+
+            def dependency_options_for(toplevel, task, roles)
+                options = super
+                options[:success] = task_info[toplevel].transitions.map do |source, _|
+                    source.symbol.emitted?.from_now if source.task == task
+                end.compact
+                options
+            end
+
+            def instanciate_state(state)
+                begin
+                    start_task(state)
+                rescue Models::Capture::Unbound => e
+                    raise e, "in the action state machine #{model} running on #{root_task} while starting #{state.name}, #{e.message}", e.backtrace
+                end
+
+                state_info = task_info[state]
+                tasks, known_transitions, captures =
+                    state_info.required_tasks,
+                    state_info.transitions,
+                    state_info.captures
+
+                transitioned = false
+                captures.each do |capture, captured_event|
+                    captured_event.resolve.once do |event|
+                        if !transitioned && root_task.running?
+                            resolved_captures[capture] = capture.filter(self, event)
+                        end
+                    end
+                end
+                known_transitions.each do |source_event, new_state|
+                    source_event.resolve.once do |event|
+                        if !transitioned && root_task.running?
+                            transitioned = true
+                            begin
+                                instanciate_state_transition(event.task, new_state)
+                            rescue Exception => e
+                                event.task.plan.add_error(
+                                    ActionStateTransitionFailed.new(root_task, state, event, new_state, e)
+                                )
+                            end
+                        end
+                    end
+                end
+            end
+
+            def instanciate_state_transition(task, new_state)
+                remove_current_task
+                begin
+                    instanciate_state(new_state)
+                end
+                run_hook :on_transition, task, new_state
+            end
+        end
+    end
+end
+