roby 0.8.0 → 3.0.0

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

@@ -0,0 +1,2 @@
+require 'roby'
+load File.join(File.expand_path(File.join('..', '..', '..', '..', 'bin', 'roby-display'), File.dirname(__FILE__)))

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

@@ -0,0 +1,52 @@
+require 'roby/app/scripts'
+require 'roby/interface/async'
+
+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
+
+script = Roby::App::Scripts::InterfaceScript.new
+error = Roby.display_exception do
+    script.run do |interface|
+        Robot.info "connected"
+        interface.restart
+        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 current process to quit. Press CTRL+C once more to terminate this script"
+            interface.quit
+            display_notifications(interface)
+        end
+    end
+end
+if error
+    exit 1
+end
+
+host, port = script.host
+async = Roby::Interface::Async::Interface.new(host, port: port)
+start = Time.now
+while !async.connected? && (Time.now - start) < 10
+    async.poll
+    sleep 0.1
+end
+
+if !async.connected?
+    Robot.fatal "timed out"
+else
+    Robot.info "new instance ready"
+end

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

@@ -1,16 +1,25 @@
 require 'roby'
 require 'fileutils'
-Roby.app.setup
+Roby.app.load_base_config
 app = Roby.app
 
-# Check there are actually files in the log/ directory
-if Dir.enum_for(:glob, File.join(app.log_dir, "*")).to_a.empty?
-    puts "no files in #{app.log_dir}, nothing to do"
+if !(name = ARGV.shift)
+    STDERR.puts "calling 'results' with no arguments does nothing anymore"
     exit 0
 end
 
-user_path = ARGV.shift || ''
-final_path = Roby::Application.unique_dirname(Roby.app.results_dir, user_path)
-puts "moving #{app.log_dir} to #{final_path}"
-FileUtils.mv app.log_dir, final_path
+begin
+    src = Roby.app.log_current_dir
+rescue ArgumentError
+    STDERR.puts "no current log directory, nothing to do"
+    exit 0
+end
+
+dest = Roby::Application.unique_dirname(Roby.app.log_base_dir, name, Roby.app.log_read_time_tag)
+FileUtils.mv src, dest
+STDERR.puts "moved current log directory #{src}"
+STDERR.puts "  to #{dest}"
+FileUtils.rm_f File.join(Roby.app.log_base_dir, "current")
+FileUtils.ln_sf dest, File.join(Roby.app.log_base_dir, "current")
+STDERR.puts "the symbolic link logs/current has been updated to the new location"
 

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

@@ -1,31 +1,162 @@
-require File.join(File.dirname(__FILE__), '..', 'run')
+require 'roby'
+require 'optparse'
+
 app = Roby.app
+app.require_app_dir
+app.public_shell_interface = true
+app.public_logs = true
+
+# Reset any disposition about INT, the run behavior depends on its behavior (and
+# this is the CLI)
+trap 'INT', 'DEFAULT'
+
+MetaRuby.keep_definition_location = false
+
+run_controller = false
+options = OptionParser.new do |opt|
+    opt.banner = <<-EOD
+roby run [-r ROBOT] [-c] action action action...
+
+Starts the Roby app, optionally starting the controller script in
+scripts/controllers/ and/or some explicitly given actions
+    EOD
 
-robot_name = ARGV.shift
-app.robot robot_name, (ARGV.shift || robot_name)
-app.setup
-begin
-    app.run do
-        if defined? RUBY_DESCRIPTION
-            Robot.info "loaded Roby #{Roby::VERSION} on #{RUBY_DESCRIPTION}"
+    Roby::Application.common_optparse_setup(opt)
+
+    opt.on '--quiet' do
+        Roby.logger.level = Logger::WARN
+        Robot.logger.level = Logger::WARN
+    end
+    opt.on '--log-dir=DIR', String, "explicitely set the log dir (must exist)" do |dir|
+        app.log_dir = dir
+        app.log_create_current = false
+    end
+    opt.on '--port=PORT', Integer, 'the interface port' do |port|
+        app.shell_interface_port = port
+    end
+    opt.on '--no-interface', "disable the shell interface" do
+        app.public_shell_interface = false
+    end
+    opt.on '--no-logs', "treat the log directory as ephemeral" do
+       app.public_logs = false
+    end
+    opt.on '--rest[=SOCKET_OR_PORT]', String, 'enable the experimental REST API' do |socket|
+        app.public_rest_interface = true
+        if socket =~ /^\d+$/
+            app.rest_interface_port = Integer(socket)
         else
-            Robot.info "loaded Roby #{Roby::VERSION}"
+            app.rest_interface_host = socket
         end
+    end
+    opt.on '--single', "run without connecting to external server. Support for this is plugin-dependent."  do
+        app.single
+    end
+    opt.on '--production', 'run in production mode, disabling all development-related functionality' do
+        app.development_mode = false
+    end
+    opt.on "--simulation", "run in simulation mode. All external tasks will be stubbed internally."  do
+        app.simulation
+    end
+    opt.on '-c', "--controller", "run the controller files and blocks"  do
+        run_controller = true
+    end
+    opt.on '-p', '--plugin=PLUGIN', String, 'load this plugin' do |plugin|
+        Roby.app.using plugin
+    end
+end
 
-	# Load the controller
-	Roby.execute do
-	    begin
-		controller_file = File.join(APP_DIR, "controllers", "#{app.robot_name}.rb")
-		if File.readable?(controller_file)
-		    Robot.info "loading controller file #{controller_file}"
-		    load controller_file
-		end
-		Robot.info "done initialization"
-	    rescue Interrupt
-	    end
-	end
-    end
-rescue Interrupt
-    Roby.fatal "interrupted"
+has_double_dash = false
+extra_args = Array.new
+ARGV.delete_if do |arg|
+    if arg == '--'
+        has_double_dash = true
+    elsif has_double_dash
+        extra_args << arg
+        true
+    else false
+    end
 end
 
+remaining_arguments = options.parse(ARGV)
+additional_controller_files = Array.new
+if !extra_args.empty?
+    additional_controller_files << extra_args.shift
+    ARGV.replace(extra_args)
+end
+
+additional_controller_files.each do |file|
+    if !File.file?(file)
+        Roby.error "#{file}, given as a controller script on the command line, does not exist"
+        exit 1
+    end
+end
+
+additional_model_files = Array.new
+actions = Array.new
+remaining_arguments.each do |arg|
+    if File.file?(arg)
+        additional_model_files << File.expand_path(arg)
+    elsif File.extname(arg) == '.rb'
+        Roby.error "#{arg}, given as a model script on the command line, does not exist"
+        exit 1
+    else actions << arg
+    end
+end
+Roby.app.additional_model_files.concat(additional_model_files)
+
+error = Roby.display_exception(STDERR) do
+    begin
+        app.setup
+        actions = actions.map do |act_name|
+            _, action = Roby.app.find_action_from_name(act_name)
+            if !action
+                Robot.error "#{act_name}, given as an action on the command line, does not exist"
+                exit 1
+            end
+            action
+        end
+
+        Roby.plan.execution_engine.once(description: 'roby run bootup') do
+            Robot.info "loaded Roby on #{RUBY_DESCRIPTION}"
+
+            # Start the requested actions
+            actions.each do |act|
+                Roby.plan.add_mission_task(act.plan_pattern)
+            end
+
+            if run_controller
+                # Load the controller
+                controller_file = Roby.app.find_file("scripts", "controllers", "ROBOT.rb", order: :specific_first) ||
+                    Roby.app.find_file("controllers", "ROBOT.rb", order: :specific_first)
+                if controller_file
+                    Robot.info "loading controller file #{controller_file}"
+                    load controller_file
+                end
+
+                Roby.app.controllers.each do |c|
+                    c.call
+                end
+
+                if Roby.app.controllers.empty? && !controller_file
+                    Robot.info "no controller block registered, and found no controller file to load for #{Roby.app.robot_name}:#{Roby.app.robot_type}"
+                end
+            end
+
+            if additional_controller_files
+                additional_controller_files.each do |c|
+                    Robot.info "loading #{c}"
+                    load c
+                end
+            end
+
+            Robot.info "done initialization"
+            Robot.info "ready"
+        end
+        app.run(thread_priority: -1)
+    ensure
+        app.cleanup
+    end
+end
+if error
+    exit 1
+end

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

@@ -1,45 +1,39 @@
 require 'roby'
-require 'roby/distributed'
 require 'optparse'
-
-require 'pp'
-
-remote_url = nil
-opt = OptionParser.new do |opt|
-    opt.on('--host URL', String, "sets the host to connect to") do |url|
-	remote_url = url
-    end
-end
-opt.parse! ARGV
+require 'rb-readline'
 
 app = Roby.app
+app.guess_app_dir
 app.shell
 app.single
+app.load_base_config
+
+require 'pp'
 
-robot_name = ARGV.shift
-app.robot robot_name, (ARGV.shift || robot_name)
-app.setup
-
-remote_url ||= app.droby['host']
-remote_url ||= 'localhost'
-if remote_url !~ /:\d+$/
-    if app.droby['host'] && app.droby['host'] =~ /(:\d+)$/
-	remote_url << $1
-    else
-	remote_url << ":#{Roby::Distributed::DEFAULT_DROBY_PORT}"
+silent = false
+opt = OptionParser.new do |opt|
+    opt.on '--silent', 'disable notifications (can also be controlled in the shell itself)' do
+        silent = true
     end
 end
 
-DRb.start_service
+host_options = Hash.new
+Roby::Application.host_options(opt, host_options)
+opt.parse! ARGV
+
+host, port = host_options.values_at(:host, :port)
 
 require 'irb'
 require 'irb/ext/save-history'
-IRB.setup(remote_url)
+IRB.setup("#{host}:#{port}")
 IRB.conf[:INSPECT_MODE] = false
-IRB.conf[:IRB_NAME]     = remote_url
+IRB.conf[:IRB_NAME]     = "#{host}:#{port}"
+IRB.conf[:USE_READLINE] = true
 IRB.conf[:PROMPT_MODE]  = :ROBY
 IRB.conf[:AUTO_INDENT] = true
-IRB.conf[:HISTORY_FILE] = File.join(APP_DIR, 'config', 'shell_history')
+if Roby.app.app_dir
+    IRB.conf[:HISTORY_FILE] = File.join(Roby.app.app_dir, 'config', 'shell_history')
+end
 IRB.conf[:SAVE_HISTORY] = 1000
 IRB.conf[:PROMPT][:ROBY] = {
     :PROMPT_I => "%N > ",
@@ -49,53 +43,144 @@
     :RETURN => "=> %s\n"
 }
 
-control = begin
-              Roby::RemoteInterface.new(DRbObject.new_with_uri("druby://#{remote_url}"))
-          rescue DRb::DRbConnError
-              STDERR.puts "cannot connect to a Roby controller at #{remote_url}, is the controller started ?"
-              exit(1)
-          end
+__main_remote_interface__ = 
+    begin
+        Roby::Interface::ShellClient.new("#{host}:#{port}") do
+            Roby::Interface.connect_with_tcp_to(host, port)
+        end
+    rescue Interrupt
+        Roby::Interface.warn "Interrupted by user"
+        exit(1)
+    end
+
+__main_remote_interface__.silent(silent)
+
+module RbReadline
+    def self.puts(msg)
+        if needs_save_and_restore = rl_isstate(RL_STATE_READCMD)
+            saved_point = rl_point
+            rl_maybe_save_line
+            rl_save_prompt
+            rl_kill_full_line(nil, nil)
+            rl_redisplay
+        end
+
+        Kernel.puts msg
+
+        if needs_save_and_restore
+            rl_restore_prompt
+            rl_maybe_replace_line
+            @rl_point = saved_point
+            rl_redisplay
+        end
+    end
+end
+
+class SynchronizedReadlineInput < IRB::ReadlineInputMethod
+    def initialize(mutex)
+        @mutex = mutex
+        super()
+    end
+
+    def gets
+        mutex.synchronize { super }
+    end
+end
+
+Readline.completer_word_break_characters = ""
+Readline.completion_proc = lambda do |string|
+    if string =~ /^\w+$/
+        prefix_match = /^#{string}/
+        actions = __main_remote_interface__.client.actions.find_all do |act|
+            prefix_match === act.name
+        end
+        if !actions.empty?
+            return actions.map { |act| "#{act.name}!" }
+        end
+    end
+    return Array.new
+end
+
+class ShellEvalContext < BasicObject
+    include ::Kernel
+
+    def initialize(interface)
+        @__interface = interface
+        @__send = ::Queue.new
+        @__results = ::Queue.new
+    end
+
+    def respond_to_missing?(m, include_private)
+        @__interface.respond_to?(m, include_private)
+    end
+
+    def method_missing(m, *args, &block)
+        @__send.push(::Kernel.lambda { @__interface.send(m, *args, &block) })
+        result, error = @__results.pop
+        if error
+            raise error
+        else result
+        end
+    end
+
+    def process_pending
+        while true
+            begin
+                command = @__send.pop(true)
+                begin
+                    result = command.call
+                    @__results.push([result, nil])
+                rescue ::Exception => e
+                    @__results.push([nil, e])
+                end
+            rescue ::ThreadError
+                break
+            end
+        end
+    end
+end
 
 begin
-    # Make control the top-level object
-    bind = control.instance_eval { binding }
-    ws  = IRB::WorkSpace.new(bind)
+    # Make __main_remote_interface__ the top-level object
+    __shell_context__ = ShellEvalContext.new(__main_remote_interface__)
+    ws  = IRB::WorkSpace.new(__shell_context__.instance_eval { binding })
     irb = IRB::Irb.new(ws)
 
-    context = irb.context
+    output_sync = Mutex.new
+    context = IRB::Context.new(irb, ws, SynchronizedReadlineInput.new(output_sync))
     context.save_history = 100
     IRB.conf[:MAIN_CONTEXT] = irb.context
 
-    trap("SIGINT") do
-	irb.signal_handle
-    end
-
-    # Create a thread which reads the remote messages and display them if needed
+    to_process, process_result = Queue.new, Queue.new
     Thread.new do
-	begin
-	    loop do
-		sleep(1)
-		
-		msg = begin
-			  control.poll_messages
-		      rescue DRb::DRbConnError
-			  []
-		      end
-
-		if !msg.empty?
-		    STDERR.puts
-		    msg.each do |t| 
-			STDERR.puts "!" + t.split("\n").join("\n!")
-		    end
-		end
-	    end
-	rescue Exception => e
-	    STDERR.puts $!.full_message
-	end
+        begin
+            __main_remote_interface__.notification_loop(0.1) do |connected, messages|
+                __shell_context__.process_pending
+
+                begin
+                    if !__main_remote_interface__.silent?
+                        output_sync.synchronize do
+                            messages.each { |msg| RbReadline.puts(msg) }
+                        end
+                    end
+                rescue Exception => e
+                    puts "Shell notification thread error:"
+                    puts e
+                    puts e.backtrace.join("\n")
+                end
+            end
+        rescue Exception => e
+            puts "Shell notification thread TERMINATED because of exception"
+            puts e
+            puts e.backtrace.join("\n")
+        end
     end
 
+    trap("SIGINT") do
+        irb.signal_handle
+    end
     catch(:IRB_EXIT) do
-	irb.eval_input
+        irb.eval_input
     end
 end