roby 0.7

data/lib/roby/app/rake.rb

@@ -0,0 +1,56 @@
+require 'roby/support'
+
+module Roby
+    # This module contains some tools used in the Rakefile of both Roby core
+    # and plugins
+    module Rake
+        extend Logger::Hierarchy
+        extend Logger::Forward
+
+        # 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']
+                end
+            else
+                File.expand_path('doc/styles/jamis', ROBY_ROOT_DIR)
+            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}"
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/app/run.rb

@@ -0,0 +1,14 @@
+require 'roby/app'
+
+app = Roby.app
+require 'optparse'
+parser = OptionParser.new do |opt|
+    opt.on("--sim", "run in simulation mode") do
+	app.simulation
+    end
+    opt.on("--single", "run in mono-robot mode") do
+	app.single
+    end
+end
+parser.parse!(ARGV)
+

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

@@ -0,0 +1,13 @@
+require 'roby/distributed/connection_space'
+require 'roby/distributed/protocol'
+
+config = Roby.app
+config.setup
+begin
+    config.start_distributed
+    sleep
+rescue Interrupt
+ensure
+    config.stop_distributed
+end
+

data/lib/roby/app/scripts/generate/bookmarks.rb

@@ -0,0 +1,162 @@
+#! /usr/bin/env ruby
+
+require 'roby/log/event_stream'
+STDOUT.sync = true
+
+class Roby::Log::EventMatcher
+    attr_reader :remote_ids
+    attr_reader :predicate_id
+    attr_reader :notifications
+    def initialize
+	@remote_ids = Hash.new
+	@notifications = Hash.new
+	@predicate_id = 0
+    end
+
+    def local_object(remote_id)
+	if remote_id.kind_of?(Roby::Distributed::RemoteID)
+	    unless obj = remote_ids[remote_id]
+		raise "no object for #{remote_id}: #{remote_ids.keys}"
+	    end
+	    obj
+	else
+	    remote_id
+	end
+    end
+
+    def filter(log)
+	while log.has_sample?
+	    log.read_and_decode.each_slice(4) do |m, sec, usec, args|
+		event(m, sec, usec, args)
+	    end
+	end
+    end
+
+    def event(m, sec, usec, args)
+	if m == :discovered_tasks || m == :discovered_events
+	    objects = args[1]
+	    for object in objects
+		for remote_id in object.remote_siblings.values
+		    remote_ids[remote_id] = object
+		end
+	    end
+
+	elsif m == :finalized_task || m == :finalized_event
+	    object = args[1]
+	    remote_ids.delete(object)
+	end
+
+	time = nil
+	if predicate_set = notifications[m]
+	    for p, callback in predicate_set
+		if p.call(args)
+		    time ||= Time.at(sec, usec)
+		    callback.call(time, args)
+		end
+	    end
+	end
+    end
+
+    def parse(expr, &block)
+	case expr
+	when /^(\w+)\((.*)\)$/
+	    method = :generator_fired
+	    task_model = Regexp.new($2)
+	    symbol = $1.to_sym
+	    predicate = lambda do |args|
+		generator = local_object(args[0])
+		if generator.respond_to?(:task) && generator.symbol == symbol
+		    task = local_object(generator.task)
+		    Regexp.new(task_model) === local_object(task).model.ancestors[0][0]
+		end
+	    end
+	end
+
+	if predicate
+	    notifications[method] ||= Array.new
+	    notifications[method] << [predicate, block]
+	end
+    end
+end
+
+config_path = ARGV[0]
+event_path  = ARGV[1]
+unless config_path && event_path
+    STDERR.puts <<-EOU
+Usage: scripts/generate/bookmarks config.yml event_set
+
+  This script generates a bookmark file suitable for roby-log replay based on a
+  log file and on a configuration file. The configuration file format is as
+  follows:
+
+    event_name:
+      - start_point
+      - end_point
+
+  where start_point and end_point are matching expressions. The following
+  expressions are recognized:
+
+    start(task_model)
+    ready(task_model)
+    stop(task_model
+
+  they trigger when, respectively, a task instance of the specified model is
+  started, its ready event has emitted and it stopped. 
+  
+  For instance, to get a 'localization_initialized' bookmark for a Localization
+  task, you would write the following configuration file:
+
+    localization_initialized:
+	- start(Localization)
+	- ready(Localization)
+
+    EOU
+
+    exit(1)
+
+end
+
+# Reverse the config file from a 'bookmark_name => event' into a 'event' =>
+# 'bookmark_name'
+config = YAML.load(File.open(ARGV[0]))
+bookmarks = Hash.new
+
+filter = Roby::Log::EventMatcher.new
+config.each do |name, (start_point, end_point)|
+    bookmarks[name] = []
+    filter.parse(start_point) do |time, args|
+	STDERR.puts "#{time.to_hms} starting point for #{name}"
+	bookmarks[name] << [time]
+    end
+    filter.parse(end_point) do |time, args|
+	if bookmarks[name].last && bookmarks[name].last[0] && !bookmarks[name].last[1]
+	    STDERR.puts "#{time.to_hms} end point for #{name}"
+	    bookmarks[name].last[1] = time
+	end
+    end
+end
+
+log = Roby::Log::EventStream.open(ARGV[1])
+filter.filter(log)
+
+bookmark_data = Hash.new
+bookmarks.each do |name, ranges|
+    if ranges.size == 1
+	bookmark_data[name] = ranges[0].map { |t| t }
+    else
+	ranges.each_with_index do |r, i|
+	    bookmark_data["#{name}-#{i}"] = r.map { |t| t }
+	end
+    end
+end
+
+bookmark_data = 
+
+bookmark_data.sort_by { |n, r| r[0] }.
+    each do |name, range|
+	puts "#{name}:"
+	range.each do |time|
+	    puts "  - \"#{time.to_hms}\""
+	end
+    end
+

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

@@ -0,0 +1,31 @@
+require 'roby'
+require 'roby/log/gui/replay'
+app  = Qt::Application.new(ARGV)
+main = Replay.setup(ARGV)
+
+if ARGV.empty?
+    Roby.app.setup
+
+    streams = Roby.app.data_streams(Roby.app.log_dir)
+    streams.each do |stream|
+	stream.open
+	main.add_stream(stream)
+    end
+else
+    ARGV.each do |file|
+	if streams = Roby.app.data_source([file])
+	    streams.each { |s| s.open }
+	    main.add_stream(streams)
+	else
+	    STDERR.puts "WARN: unknown file type #{file}"
+	end
+    end
+end
+
+begin
+    main.show
+    app.exec
+rescue
+    STDERR.puts $!.full_message
+end
+

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

@@ -0,0 +1,15 @@
+require 'roby'
+Roby.app.setup
+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"
+    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
+

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

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), '..', 'run')
+app = Roby.app
+
+robot_name = ARGV.shift
+app.robot robot_name, (ARGV.shift || robot_name)
+app.setup
+begin
+    app.run do
+	# Load the controller
+	include Roby
+	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"
+end
+

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

@@ -0,0 +1,18 @@
+require 'roby/log/server'
+
+app = Roby.app
+app.setup
+DRb.start_service "druby://:0"
+
+begin
+    app.start_server
+
+    Roby::Log::Server.info "ready"
+    sleep
+rescue Interrupt
+ensure
+    Roby::Log::Server.info "quitting"
+    app.stop_server
+end
+Roby::Log::Server.info "quit"
+

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

@@ -0,0 +1,88 @@
+require 'roby'
+require 'roby/app'
+require 'roby/distributed'
+require 'roby/distributed/protocol'
+require 'optparse'
+
+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
+
+app = Roby.app
+app.shell
+app.single
+
+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}"
+    end
+end
+
+DRb.start_service
+
+require 'irb'
+IRB.setup(nil)
+
+control = Roby::RemoteInterface.new(DRbObject.new_with_uri("druby://#{remote_url}"))
+
+begin
+    # Make control the top-level object
+    bind = control.instance_eval { binding }
+    ws  = IRB::WorkSpace.new(bind)
+    irb = IRB::Irb.new(ws)
+
+    context = irb.context
+    def context.evaluate(*args, &block)
+	Roby.execute do
+	    super
+	end
+    end
+    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
+    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
+	    STDERR.puts $!.full_message
+	ensure
+	    STDERR.puts "message polling died"
+	end
+    end
+
+    catch(:IRB_EXIT) do
+	irb.eval_input
+    end
+end
+

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

@@ -0,0 +1,40 @@
+require 'roby'
+require 'optparse'
+
+testrb_args = []
+parser = OptionParser.new do |opt|
+    opt.on("-s", "--sim", "run tests in simulation mode") do |val|
+	Roby.app.simulation = val
+    end
+    opt.on("-k", "--keep-logs", "keep all logs") do |val|
+	Roby.app.testing_keep_logs = val
+    end
+    opt.on("-o", "--overwrite-oldlogs", "if there are logs for the same test case, overwrite them") do |val|
+	Roby.app.testing_overwrites_logs = val
+    end
+    opt.on("-i", "--interactive", "allow user interaction during tests") do |val|
+	Roby.app.automatic_testing = false
+    end
+    opt.on("-n", "--name NAME", String, "run tests matching NAME") do |name|
+	testrb_args << "-n" << name
+    end
+end
+parser.parse! ARGV
+Roby.app.testing = true
+require 'roby/test/testcase'
+
+app = Roby.app
+app.setup
+
+r = Test::Unit::AutoRunner.new(true)
+r.process_args(ARGV + testrb_args) or
+  abort r.options.banner + " tests..."
+
+if r.filters.empty?
+    r.filters << lambda do |t|
+	t.class != Roby::Test::TestCase
+    end
+end
+
+exit r.run
+