roby 0.8.0 → 3.0.0

data/lib/roby/interface/async/job_monitor.rb

@@ -0,0 +1,213 @@
+module Roby
+    module Interface
+        module Async
+            # Asynchronous monitoring of a job
+            #
+            # This is usually not created directly, but either by calling
+            # {Interface#on_job} or {Interface#find_all_jobs}. The jobs created by
+            # these two methods not listening for the job's progress, you must
+            # call {#start} on them to start tracking the job progress.
+            #
+            # Then call {#stop} to remove the monitor.
+            class JobMonitor
+                include Roby::Hooks
+                include Roby::Hooks::InstanceHooks
+
+                JOB_REACHABLE = :reachable
+
+                # @!group Hooks
+
+                # @!method on_progress
+                #   Hook called when there is an upcoming notification
+                #
+                #   @yieldparam [Symbol] state the new job state
+                #   @return [void]
+                define_hooks :on_progress
+
+                # @!method on_planning_failed
+                #   Hook called when we receive a planning failed exception for
+                #   this job
+                #
+                #   @yieldparam (see ExecutionEngine#on_exception)
+                #   @return [void]
+                define_hooks :on_planning_failed
+
+                # @!method on_exception
+                #   Hook called when we receive an exception involving this job
+                #   Note that a planning failed exception is both received by
+                #   this handler and by {#on_planning_failed}
+                #
+                #   @yieldparam (see ExecutionEngine#on_exception)
+                #   @return [void]
+                define_hooks :on_exception
+
+                # @!endgroup
+
+                # @return [Interface] the async interface we are bound to
+                attr_reader :interface
+
+                # @return [Integer] the job ID
+                attr_reader :job_id
+
+                # @return [Roby::Task] the job's main task
+                attr_reader :task
+
+                # @return [Roby::Task] the job's placeholder task
+                attr_reader :placeholder_task
+
+                # @return [Symbol] the job's current state
+                attr_reader :state
+
+                def initialize(interface, job_id, state: JOB_REACHABLE, task: nil, placeholder_task: task)
+                    @interface = interface
+                    @job_id = job_id
+                    @success = false
+                    @failed = false
+                    @has_ran = false
+                    @planning_finished = false
+                    update_state(state)
+                    @task = task
+                    @placeholder_task = placeholder_task
+                end
+
+                # Kill this job and start an equivalent one
+                #
+                # @return [JobMonitor] the monitor object for the new job. It is
+                #   not listening to the new job yet, call {#start} for that
+                def restart
+                    batch = interface.client.create_batch
+                    if !terminated?
+                        batch.kill_job(job_id)
+                    end
+                    batch.start_job(action_name, action_arguments)
+                    job_id = batch.__process.started_jobs_id.first
+                    interface.monitor_job(job_id)
+                end
+
+                # The job's action model
+                #
+                # @return [Roby::Actions::Model::Action,nil]
+                def action_model
+                    task && task.action_model
+                end
+
+                # Returns the job's action name
+                #
+                # @return [String,nil]
+                def action_name
+                    task && task.action_model.name
+                end
+
+                # Returns the arguments that were passed to the action
+                def action_arguments
+                    task && task.action_arguments
+                end
+
+                # @api private
+                #
+                # Called when the placeholder task got replaced
+                #
+                # @param [Roby::Task] new_task the new task
+                def replaced(new_task)
+                    @placeholder_task = new_task
+                end
+
+                # @api private
+                def inspect
+                    "#<JobMonitor #{interface} job_id=#{job_id} state=#{state} task=#{task}>"
+                end
+
+                # @api private
+                #
+                # Triggers {#on_exception} and {#on_planning_failed} hooks
+                def notify_exception(kind, exception)
+                    if exception.exception.kind_of?(PlanningFailedError)
+                        if job_id = exception.exception.planning_task.arguments[:job_id]
+                            if job_id == self.job_id
+                                run_hook :on_planning_failed, kind, exception
+                            end
+                        end
+                    end
+                    run_hook :on_exception, kind, exception
+                end
+
+                # @api private
+                #
+                # Called by {Interface} to update the job's state
+                def update_state(state)
+                    @state = state
+                    if state != JOB_REACHABLE
+                        @planning_finished ||= Roby::Interface.planning_finished_state?(state)
+                        @success ||= Roby::Interface.success_state?(state)
+                        @failed  ||= Roby::Interface.error_state?(state)
+                        @has_ran ||= (Roby::Interface.planning_finished_state?(state) &&
+                                      state != JOB_READY && state != JOB_PLANNING_FAILED)
+                    end
+                    run_hook :on_progress, state
+                end
+
+                # Tests whether planning finished
+                def planning_finished?
+                    @planning_finished
+                end
+
+                # Tests whether this job is running
+                def running?
+                    Roby::Interface.running_state?(state)
+                end
+
+                # Tests whether this job ran successfully
+                def success?
+                    @success
+                end
+
+                # Tests whether this job ran and failed
+                def failed?
+                    @failed
+                end
+
+                # Tests whether this job ran and finished
+                def finished?
+                    @has_ran && terminated?
+                end
+
+                # Tests whether this job is terminated
+                def terminated?
+                    Roby::Interface.terminal_state?(state)
+                end
+                
+                # Tests whether this job has been finalized
+                def finalized?
+                    Roby::Interface.finalized_state?(state)
+                end
+
+                # Whether this job monitor is still active
+                def active?
+                    interface.active_job_monitor?(self)
+                end
+
+                # Start monitoring this job's state
+                def start
+                    update_state(state)
+                    interface.add_job_monitor(self)
+                end
+
+                # Stop monitoring this job's state
+                def stop
+                    interface.remove_job_monitor(self)
+                end
+
+                # Send a command to drop this job
+                def drop
+                    interface.client.drop_job(job_id)
+                end
+
+                # Send a command to kill this job
+                def kill
+                    interface.client.kill_job(job_id)
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/interface/async/log.rb

@@ -0,0 +1,238 @@
+require 'roby/droby/plan_rebuilder'
+require 'roby/droby/logfile/server'
+require 'roby/droby/logfile/client'
+
+module Roby
+    module Interface
+        module Async
+            # Asynchronous access to the log stream
+            #
+            # Roby logs are purely incremental information, which means that on
+            # connection one must process the whole existing log before being
+            # able to provide the current state. From a user perspective, this
+            # init phase is really overhead, so it's better to avoid updating
+            # the UI while the data is being processed. For this reason, the
+            # class provides {#on_init_progress} and {#on_init_done} to provide
+            # progress information to the user, and start normal processing when
+            # init is finished.
+            #
+            # It must be integrated into your application's event loop by
+            # calling {#poll}.
+            class Log
+                extend Logger::Hierarchy
+
+                # The plan rebuilder object, which processes the log stream to
+                # rebuild {#plan}
+                #
+                # @return [Roby::DRoby::PlanRebuilder]
+                attr_reader :plan_rebuilder
+
+                # The plan self is working on
+                #
+                # @return [Roby::Plan]
+                def plan; plan_rebuilder.plan end
+
+                # Information about the scheduler state
+                #
+                # @return [Schedulers::State]
+                def scheduler_state; plan.consolidated_scheduler_state end
+
+                include Hooks
+                include Hooks::InstanceHooks
+
+                # @!group Hooks
+
+                # @!method on_reachable()
+                #   Hooks called when we successfully connected
+                #   @return [void]
+                define_hooks :on_reachable
+                # @!method on_unreachable()
+                #   Hooks called when we got disconnected
+                #   @return [void]
+                define_hooks :on_unreachable
+                # @!method on_init_progress
+                #   (see Roby::DRoby::Logfile::Client#on_init_progress)
+                define_hooks :on_init_progress
+                # @!method on_init_done
+                #   (see Roby::DRoby::Logfile::Client#on_init_done)
+                define_hooks :on_init_done
+                # @!method on_update
+                #   Hooks called when the plan rebuilder processed an update
+                #
+                #   @yieldparam [Integer] cycle_index
+                #   @yieldparam [Time] cycle_time
+                #   @return [void]
+                define_hooks :on_update
+
+                # @!endgroup
+
+                attr_reader :host
+                attr_reader :port
+                # @return [Roby::DRoby::Logfile::Client,nil] the object used to communicate
+                #   to the server, or nil if we have not managed to connect yet
+                attr_reader :client
+                # The future used to connect to the remote process without blocking
+                # the main event loop
+                attr_reader :connection_future
+
+                DEFAULT_HOST = "localhost"
+                DEFAULT_PORT = Roby::DRoby::Logfile::Server::DEFAULT_PORT
+
+                # @api private
+                #
+                # Create a plan rebuilder for use in the async object
+                def default_plan_rebuilder
+                    DRoby::PlanRebuilder.new
+                end
+
+                def initialize(host = DEFAULT_REMOTE_NAME, port: DEFAULT_PORT, connect: true,
+                               plan_rebuilder: default_plan_rebuilder)
+                    @host = host
+                    @port = port
+                    @plan_rebuilder = plan_rebuilder
+                    @first_connection_attempt = true
+                    @closed = false
+                    if connect
+                        attempt_connection
+                    end
+                end
+
+                def connected?
+                    !!client
+                end
+
+                # Start a connection attempt
+                def attempt_connection
+                    @connection_future = Concurrent::Future.new do
+                        Roby::DRoby::Logfile::Client.new(host, port)
+                    end
+                    connection_future.execute
+                end
+
+                STATE_DISCONNECTED = :disconnected
+                STATE_CONNECTED    = :connected
+                STATE_PENDING_DATA = :pending_data
+
+                # Active part of the async. This has to be called regularly within
+                # the system's main event loop (e.g. Roby's, Vizkit's or Qt's)
+                #
+                # @return [(Boolean,Boolean)] true if we are connected to the remote server
+                #   and false otherwise
+                def poll(max: 0.1)
+                    if connected?
+                        if client.read_and_process_pending(max: max)
+                            return STATE_PENDING_DATA
+                        else return STATE_CONNECTED
+                        end
+                    elsif !closed?
+                        poll_connection_attempt
+                        return STATE_DISCONNECTED
+                    end
+                rescue Interrupt
+                    close
+                    raise
+
+                rescue ComError
+                    Log.info "link closed, trying to reconnect"
+                    unreachable!
+                    if !closed?
+                        attempt_connection
+                    end
+                    false
+                rescue Exception => e
+                    Log.warn "error while polling connection, trying to reconnect"
+                    Roby.log_exception_with_backtrace(e, Log, :warn)
+                    unreachable!
+                    if !closed?
+                        attempt_connection
+                    end
+                    false
+                end
+
+                def unreachable!
+                    if client
+                        client.close if !client.closed?
+                        @client = nil
+                        run_hook :on_unreachable
+                    end
+                end
+
+                def closed?
+                    !!@closed
+                end
+
+                def close
+                    @closed = true
+                    unreachable!
+                    plan_rebuilder.clear
+                end
+
+                # True if we are connected to a client
+                def reachable?
+                    !!client
+                end
+
+                def cycle_index
+                    plan_rebuilder && plan_rebuilder.cycle_index
+                end
+
+                def cycle_start_time
+                    plan_rebuilder && plan_rebuilder.cycle_start_time
+                end
+
+                def init_done?
+                    client && client.init_done?
+                end
+
+                # Verify the state of the last connection attempt
+                #
+                # It checks on the last connection attempt, and sets {#client}
+                # if it was successful, as well as call the callbacks registered
+                # with {#on_reachable}
+                def poll_connection_attempt
+                    return if client
+                    return if closed?
+
+                    if connection_future.complete?
+                        case e = connection_future.reason
+                        when ConnectionError, ComError
+                            Interface.info "Async::Log failed connection attempt: #{e}"
+                            attempt_connection
+                            if @first_connection_attempt
+                                @first_connection_attempt = false
+                                run_hook :on_unreachable
+                            end
+                            nil
+                        when NilClass
+                            Interface.info "successfully connected"
+                            @client = connection_future.value
+                            plan_rebuilder.clear
+                            run_hook :on_reachable
+
+                            client.on_init_progress do |received, expected|
+                                run_hook :on_init_progress, received, expected
+                            end
+                            client.on_init_done do
+                                run_hook :on_init_done
+                            end
+                            client.on_data do |data|
+                                plan_rebuilder.process_one_cycle(data)
+                                cycle = plan_rebuilder.cycle_index
+                                time  = plan_rebuilder.cycle_start_time
+                                Interface.debug "Async update(#{cycle}, #{time})"
+                                run_hook :on_update, cycle, time
+                            end
+                        else
+                            raise connection_future.reason
+                        end
+                    end
+                end
+
+                def clear_integrated
+                    plan_rebuilder.clear_integrated
+                end
+            end
+        end
+    end
+end
+