roby 0.7

data/lib/roby/log/gui/runtime.rb

@@ -0,0 +1,130 @@
+require 'Qt4'
+require 'roby/app'
+
+require 'roby/log/gui/replay_controls_ui'
+require 'roby/log/gui/data_displays'
+require 'roby/log/server'
+
+class RemoteStreamListModel < DataStreamListModel
+    attr_reader :known_servers
+    def initialize(streams)
+	super
+	@known_servers = []
+    end
+
+    # Update the list of available servers and streams
+    def update
+	Roby::Log::Server.available_servers.each do |server|
+	    unless known_servers.find { |str| str.server == server }
+		begin
+		    known_servers << Roby::Log::Client.new(server)
+		rescue DRb::DRbConnError
+		end
+	    end
+	end
+
+	known_servers.delete_if { |s| !s.connected? }
+
+	found_streams = []
+	known_servers.delete_if do |server|
+	    begin
+		server.streams.each do |stream|
+		    found_streams << stream
+		    unless streams.include?(stream)
+			server.subscribe(stream)
+			add_new(stream)
+		    end
+		end
+		false
+	    rescue DRb::DRbConnError
+		s.disconnect
+		true
+	    end
+	end
+
+	(streams - found_streams).each do |s|
+	    row = streams.index(s)
+	    removeRow(row, Qt::ModelIndex.new)
+	end
+    end
+end
+
+class RuntimeDisplay < Qt::MainWindow
+    attr_reader :ui_displays
+
+    attr_reader :streams
+    attr_reader :streams_model
+
+    DISPLAY_MINIMUM_DURATION = 5
+
+    def initialize(broadcast, port, period)
+	super()
+
+	# Create the vertical layout for this window
+	central_widget = Qt::Widget.new(self)
+	self.central_widget = central_widget
+	layout = Qt::VBoxLayout.new(central_widget)
+	layout.spacing = 6
+	layout.margin  = 0
+
+	# add GUI for the data streams and display setup
+	@streams	= Array.new
+	@streams_model  = RemoteStreamListModel.new(streams)
+	displays_holder = Qt::Widget.new(central_widget)
+	layout.add_widget displays_holder
+	@ui_displays = Ui_DataDisplays.new
+	ui_displays.setupUi(displays_holder)
+	ui_displays.streams.model = streams_model
+	ui_displays.add_stream.enabled = false
+	ui_displays.remove_stream.enabled = false
+	connect(ui_displays.display_add, SIGNAL("clicked()"), self, SLOT("add_display()"))
+
+	# Set up the stream discovery
+	Roby::Log::Server.enable_discovery(broadcast, port, period)
+
+	# This timer is used to call Thread.pass ... of course needed or Ruby
+	# threads won't be woken up
+	Thread.current.priority = -1
+
+	@threads_timer = Qt::Timer.new(self)
+	connect(@threads_timer, SIGNAL('timeout()')) do
+	    Thread.pass
+	end
+	@threads_timer.start(50)
+
+	@display_timer = Qt::Timer.new(self)
+	connect(@display_timer, SIGNAL('timeout()')) do
+	    streams.each do |s|
+		s.synchronize do
+		    s.display
+		end
+	    end
+	end
+	@display_timer.start(5000)
+
+	sleep(0.5)
+	streams_model.update
+
+	@discovery_timer = Qt::Timer.new(self)
+	connect(@discovery_timer, SIGNAL('timeout()')) do
+	    streams_model.update
+	end
+	@discovery_timer.start(Integer(period * 1000))
+    end
+
+    def add_display(kind = nil)
+	ui_displays.add_display(streams_model, kind)
+    end
+    slots 'add_display()'
+end
+
+if $0 == __FILE__
+    DRb.start_service "druby://:0"
+    Roby::Log::Server.logger.level = Logger::DEBUG
+
+    a = Qt::Application.new(ARGV)
+    w = RuntimeDisplay.new('localhost', Roby::Log::Server::RING_PORT, 5)
+    w.show
+    a.exec
+end
+

data/lib/roby/log/hooks.rb

@@ -0,0 +1,185 @@
+require 'roby/log/logger'
+require 'roby'
+
+module Roby::Log
+    module BasicObjectHooks
+	HOOKS = %w{added_owner removed_owner}
+
+	def added_owner(peer)
+	    super if defined? super
+	    Roby::Log.log(:added_owner) { [self, peer] }
+	end
+
+	def removed_owner(peer)
+	    super if defined? super
+	    Roby::Log.log(:removed_owner) { [self, peer] }
+	end
+    end
+    Roby::BasicObject.include BasicObjectHooks
+
+    module TaskHooks
+	HOOKS = %w{added_task_child removed_task_child}
+
+	def added_child_object(child, relations, info)
+	    super if defined? super
+	    Roby::Log.log(:added_task_child) { [self, relations, child, info] }
+	end
+
+	def removed_child_object(child, relations)
+	    super if defined? super
+	    Roby::Log.log(:removed_task_child) { [self, relations, child] }
+	end
+    end
+    Roby::Task.include TaskHooks
+
+    module PlanHooks
+	HOOKS = %w{inserted_tasks discarded_tasks replaced_tasks 
+		   discovered_tasks discovered_events 
+		   garbage_task finalized_task finalized_event 
+		   added_transaction removed_transaction}
+
+	def inserted(tasks)
+	    super if defined? super
+	    Roby::Log.log(:inserted_tasks) { [self, tasks] }
+	end
+	def discarded(tasks)
+	    super if defined? super
+	    Roby::Log.log(:discarded_tasks) { [self, tasks] }
+	end
+	def replaced(from, to)
+	    super if defined? super
+	    Roby::Log.log(:replaced_tasks) { [self, from, to] }
+	end
+	def discovered_events(tasks)
+	    super if defined? super
+	    Roby::Log.log(:discovered_events) { [self, tasks] }
+	end
+	def discovered_tasks(tasks)
+	    super if defined? super
+	    Roby::Log.log(:discovered_tasks) { [self, tasks] }
+	end
+	def garbage(task)
+	    super if defined? super
+	    Roby::Log.log(:garbage_task) { [self, task] }
+	end
+	def finalized_event(event)
+	    super if defined? super
+	    Roby::Log.log(:finalized_event) { [self, event] }
+	end
+	def finalized_task(task)
+	    super if defined? super
+	    Roby::Log.log(:finalized_task) { [self, task] }
+	end
+
+	def added_transaction(trsc)
+	    super if defined? super
+	    Roby::Log.log(:added_transaction) { [self, trsc] }
+	end
+	def removed_transaction(trsc)
+	    super if defined? super
+	    Roby::Log.log(:removed_transaction) { [self, trsc] }
+	end
+    end
+    Roby::Plan.include PlanHooks
+
+    module TransactionHooks
+	HOOKS = %w{committed_transaction discarded_transaction}
+
+	def committed_transaction
+	    super if defined? super
+	    Roby::Log.log(:committed_transaction) { [self] }
+	end
+	def discarded_transaction
+	    super if defined? super
+	    Roby::Log.log(:discarded_transaction) { [self] }
+	end
+    end
+    Roby::Transaction.include TransactionHooks
+
+    module EventGeneratorHooks
+	HOOKS = %w{added_event_child removed_event_child 
+		   generator_calling generator_called generator_fired
+		   generator_signalling generator_forwarding generator_emitting
+		   generator_postponed}
+
+	def added_child_object(to, relations, info)
+	    super if defined? super
+	    Roby::Log.log(:added_event_child) { [self, relations, to, info] }
+	end
+
+	def removed_child_object(to, relations)
+	    super if defined? super
+	    Roby::Log.log(:removed_event_child) { [self, relations, to] }
+	end
+
+	def calling(context)
+	    super if defined? super
+	    Roby::Log.log(:generator_calling) { [self, Roby::Propagation.source_generators, context.to_s] }
+	end
+
+	def called(context)
+	    super if defined? super
+	    Roby::Log.log(:generator_called) { [self, context.to_s] }
+	end
+
+	def fired(event)
+	    super if defined? super
+	    Roby::Log.log(:generator_fired) { [self, event.object_id, event.time, event.context.to_s] }
+	end
+
+	def signalling(event, to)
+	    super if defined? super
+	    Roby::Log.log(:generator_signalling) { [false, self, to, event.object_id, event.time, event.context.to_s] }
+	end
+
+	def emitting(context)
+	    super if defined? super
+	    Roby::Log.log(:generator_emitting) { [self, Roby::Propagation.source_generators, context.to_s] }
+	end
+
+	def forwarding(event, to)
+	    super if defined? super
+	    Roby::Log.log(:generator_forwarding) { [true, self, to, event.object_id, event.time, event.context.to_s] }
+	end
+
+	def postponed(context, generator, reason)
+	    super if defined? super 
+	    Roby::Log.log(:generator_postponed) { [self, context.to_s, generator, reason.to_s] }
+	end	
+    end
+    Roby::EventGenerator.include EventGeneratorHooks
+
+    module ControlHooks
+	HOOKS = %w{cycle_end}
+
+	def cycle_end(timings)
+	    super if defined? super
+	    Roby::Log.log(:cycle_end) { [timings] }
+	end
+
+	module ClassExtension
+	    HOOKS = %w{fatal_exception handled_exception}
+
+	    def fatal_exception(error, tasks)
+		super if defined? super
+		Roby::Log.log(:fatal_exception) { [error.exception, tasks] }
+	    end
+	    def handled_exception(error, task)
+		super if defined? super
+		Roby::Log.log(:handled_exception) { [error.exception, task] }
+	    end
+	end
+    end
+    Roby::Control.include ControlHooks
+
+    def self.each_hook
+	[TransactionHooks, BasicObjectHooks, TaskHooks,
+	    PlanHooks, EventGeneratorHooks, ControlHooks,
+	    ControlHooks::ClassExtension].each do |klass|
+		klass::HOOKS.each do |m|
+		    yield(klass, m.to_sym)
+		end
+	    end
+    end
+end
+

data/lib/roby/log/logger.rb

@@ -0,0 +1,202 @@
+require 'roby/log/hooks'
+require 'roby/log/file'
+
+module Roby::Log
+    @loggers = Array.new
+    @@logging_thread = nil
+
+    extend Logger::Hierarchy
+    extend Logger::Forward
+
+    class << self
+	# Start the logging framework
+	def logging?
+	    @@logging_thread
+	end
+
+	# Start the logging framework
+	def start_logging # :nodoc:
+	    return if logging?
+	    logged_events.clear
+	    @@logging_thread = Thread.new(&method(:logger_loop))
+	end
+
+	# Stop the logging framework
+	def stop_logging # :nodoc:
+	    return unless logging?
+	    logged_events.push nil
+	    flushed_logger_mutex.synchronize do
+		while @@logging_thread
+		    flushed_logger.wait(flushed_logger_mutex)
+		end
+	    end
+	end
+
+	# Add a logger object in the system
+	def add_logger(logger)
+	    start_logging
+	    @loggers << logger
+	end
+
+	# Remove a logger from the list of loggers
+	def remove_logger(logger)
+	    flush if logging?
+	    if @loggers.size == 1
+		stop_logging
+	    end
+	    @loggers.delete logger
+	end
+
+	# Remove all loggers
+	def clear_loggers
+	    stop_logging
+	    @loggers.clear
+	end
+
+	# Iterates on all the logger objects. If +m+ is given, yields only the loggers
+	# which respond to this method.
+	def each_logger(m = nil)
+	    for l in @loggers
+		if !m || l.respond_to?(m)
+		    yield(l) 
+		end
+	    end
+	end
+
+	# Returns true if there is at least one loggr for the +m+ message
+	def has_logger?(m)
+	    for l in @loggers
+		return true if l.respond_to?(m)
+	    end
+	    false
+	end
+
+	attr_reader :logged_events
+	attr_reader :flushed_logger_mutex
+	attr_reader :flushed_logger
+	attr_reader :known_objects
+
+	def incremental_dump?(object); known_objects.include?(object) end
+
+	# call-seq:
+	#   Log.log(message) { args }
+	#
+	# Logs +message+ with argument +args+. The block is called only once if
+	# there is at least one logger which listens for +message+.
+	def log(m, args = nil)
+	    if m == :discovered_tasks || m == :discovered_events
+		Roby::Control.synchronize do
+		    args ||= yield
+		    objects = args[1].to_value_set
+		    # Do not give a 'peer' argument at Distributed.format, to
+		    # make sure we do a full dump
+		    args = Roby::Distributed.format(args) if has_logger?(m)
+		    known_objects.merge(objects)
+		end
+	    elsif m == :finalized_task || m == :finalized_event
+		Roby::Control.synchronize do
+		    args ||= yield
+		    object = args[1]
+		    args = Roby::Distributed.format(args, self) if has_logger?(m)
+		    known_objects.delete(object)
+		end
+	    end
+
+	    if has_logger?(m)
+		if !args && block_given?
+		    Roby::Control.synchronize do 
+			args = Roby::Distributed.format(yield, self)
+		    end
+		end
+
+		logged_events << [m, Time.now, args]
+	    end
+	end
+
+	# The main logging loop. We use a separate loop to avoid having logging
+	# have too much influence on the control thread. The Log.logged_events
+	# attribute is a sized queue (of size LOGGED_EVENTS_QUEUE_SIZE) in
+	# which all the events needing logging are saved
+	def logger_loop
+	    Thread.current.priority = 2
+	    loop do
+		m, time, args = logged_events.pop
+		break unless m
+
+		each_logger(m) do |logger|
+		    if logger.splat?
+			logger.send(m, time, *args)
+		    else
+			logger.send(m, time, args)
+		    end
+		end
+
+		if m == :flush && logged_events.empty?
+		    flushed_logger_mutex.synchronize do
+			flushed_logger.broadcast
+		    end
+		end
+	    end
+
+	rescue Exception => e
+	    Roby.fatal "logger thread dies with #{e.full_message}" unless e.kind_of?(Interrupt)
+
+	ensure
+	    # Wake up any waiting thread
+	    flushed_logger_mutex.synchronize do
+		@@logging_thread = nil
+		flushed_logger.broadcast
+	    end
+	end
+
+	# Waits for all the events queued in +logged_events+ to be processed by
+	# the logging thread. Also sends the +flush+ message to all loggers
+	# that respond to it
+	def flush
+	    flushed_logger_mutex.synchronize do
+		if !logging?
+		    raise "not logging"
+		end
+
+		logged_events.push [:flush, []]
+		flushed_logger.wait(flushed_logger_mutex)
+	    end
+	end
+
+	# Requires all displays
+	def load_all_displays
+	    require 'roby/log/relations'
+	    require 'roby/log/execution-state'
+	end
+
+	def open(file)
+	    Logfile.open(file)
+	end
+
+	def replay(file, &block)
+	    if file =~ /\.gz$/
+		require 'zlib'
+		require 'roby/log/file'
+		Zlib::GzipReader.open(file) do |io|
+		    FileLogger.replay(io, &block)
+		end
+	    elsif file =~ /\.db$/
+		require 'roby/log/sqlite'
+		SQLiteLogger.replay(file, &block)
+	    else
+		require 'roby/log/file'
+		File.open(file) do |io|
+		    FileLogger.replay(io, &block)
+		end
+	    end
+	end
+    end
+
+    LOGGED_EVENTS_QUEUE_SIZE = 2000
+    @logged_events        = SizedQueue.new(LOGGED_EVENTS_QUEUE_SIZE)
+    @flushed_logger_mutex = Mutex.new
+    @flushed_logger       = ConditionVariable.new
+    @known_objects        = ValueSet.new
+
+end
+