roby 0.8.0 → 3.0.0

data/lib/roby/log/console.rb

@@ -1,74 +0,0 @@
-require 'utilrb/time/to_hms'
-require 'roby/log/logger'
-
-module Roby::Log
-    # A logger object which dumps events in a human-readable form to an IO object. 
-    class ConsoleLogger
-	def splat?; false end
-	def self.filter_names(name)
-	    name.gsub(/Roby::(?:Genom::)?/, '')
-	end
-	# Name of an event generator source
-	def self.gen_source(gen)
-	    if gen.respond_to?(:task) then gen.task.name
-	    else 'toplevel'
-	    end
-	end
-	# Human readable name for event generators
-	def self.gen_name(gen)
-	    if gen.respond_to?(:symbol) then "[#{gen.symbol}]"
-	    else gen.name
-	    end
-	end
-
-	attr_reader :io, :columns
-	def initialize(io)
-	    @io = io
-	    @columns = Hash.new { |h, k| h[k] = Array.new }
-	end
-
-	def arg_to_s(arg)
-	    case arg
-	    when Time then Time.at(arg - @reftime).to_hms
-	    when Array then arg.map { |v| arg_to_s(v) }.to_s
-	    when Hash then arg.map { |k, v| [arg_to_s(k), arg_to_s(v)].join(" => ") }.to_s
-	    else arg.to_s
-	    end
-	end
-
-
-        def logs_message?(m); true end
-        def close; end
-	def dump_method(m, time, *args) # :nodoc:
-	    @reftime ||= time
-
-	    args.map! { |a| arg_to_s(a) }
-	    args.map!(&ConsoleLogger.method(:filter_names))
-	    args.unshift(m).
-		unshift(Time.at(time - @reftime).to_hms)
-		
-	    columns = self.columns[m]
-	    args.each_with_index do |str, i|
-		str = str.to_s
-		if !columns[i] || (str.length > columns[i])
-		    columns[i] = str.length
-		end
-	    end
-
-	    args.each_with_index do |arg, i|
-		w = columns[i]
-		io << ("%-#{w}s  " % arg)
-	    end
-	    io << "\n"
-	rescue
-	    STDERR.puts "#{time} #{m} #{args}"
-	    raise
-	end
-	private :display
-
-	Roby::Log.each_hook do |klass, m|
-	    define_method(m) { |time, args| dump_method(m, time, args) }
-	end
-    end
-end
-

data/lib/roby/log/data_stream.rb

@@ -1,275 +0,0 @@
-require 'roby/log'
-module Roby::Log
-    # == Displaying log data
-    #
-    # Data display is done in three objects:
-    # * a DataStream object which is the data source itself. It gives
-    #   information about available samples, time of samples and extracts raw
-    #   data. An example of data stream is the EventStream object which reads
-    #   Roby's event logs, returning one cycle worth of data at a time.
-    # * a DataDecoder object which takes the raw data returned by a DataStream
-    #   object and turns it into a more usable representation. For instance, the PlanBuilder
-    #   decoder takes an event stream from an EventStream object and rebuilds a plan-like
-    #   structure from it.
-    # * a display which takes its information from the decoder. The RelationDisplay displays
-    #   the information included in the PlanRebuilder decoder and displays it as a graph.
-    class DataStream
-	# The stream ID, which has to be unique on a single Roby core
-	attr_reader :id
-	# The stream name. A [name, type] has to be globally unique
-	attr_reader :name
-	# The stream type, as a string.
-	attr_reader :type
-
-	def self.open(basename)
-	    stream = new(basename)
-	    stream.open
-
-	    if block_given?
-		begin
-		    yield(stream)
-		ensure
-		    stream.logfile.close
-		end
-	    else
-		stream
-	    end
-	end
-
-
-	def initialize(name, type)
-	    @id   = object_id
-	    @name = name
-	    @type = type
-	    @range = [nil, nil]
-
-	    @decoders = []
-	end
-
-        def each_sample
-            while sample = read_and_decode
-                yield(sample)
-            end
-        end
-
-	def to_s; "#{name} [#{type}]" end
-	def open; end
-	def close; end
-
-	def has_sample?; false end
-	attr_predicate :reinit, true
-	def reinit?;  end
-	def reinit!
-	    @range  = [nil, nil]
-	    @reinit = false
-
-	    clear
-	end
-	def read_all; end
-
-	def read_and_decode
-            if raw = read
-                self.class.decode(raw)
-            end
-	end
-
-	# The [min, max] range of available samples. Initially
-	# [nil, nil]
-	attr_reader :range
-
-	# The set of decoders attached to this stream
-	attr_reader :decoders
-
-	def clear
-	    decoders.each { |dec| dec.clear }
-	end
-
-	# True if there is at least one display attached to this data stream
-	def displayed?
-	    decoders.any? do |dec|
-		!dec.displays.empty?
-	    end
-	end
-
-	# Reuse or creates a decoder of the given class for this data
-	# stream
-	def decoder(klass)
-	    if dec = decoders.find { |d| d.kind_of?(klass) }
-		dec
-	    else
-		decoders << (dec = klass.new(name))
-		dec.stream = self
-		added_decoder(dec)
-		dec
-	    end
-	end
-
-	def added_decoder(dec)
-	    super if defined? super
-	end
-
-	# Do a read and decode the data
-        #
-        # It returns false if no decoders have found interesting updates in the
-        # decoded data, and true otherwise. The method relies on the decoder's
-        # #process method to return true/false when required.
-        #
-        # See DataDecoder#process
-        def advance
-	    if data = read_and_decode
-                !decoders.find_all do |dec|
-                    dec.process(data)
-                end.empty?
-            else
-                raise EOFError
-            end
-	end
-
-	def init(data)
-	    self.class.init(data)
-	end
-	def decode(data)
-	    self.class.decode(data)
-	end
-
-        # Displays may have the ability to not display a per-cycle information,
-        # but to add information as it is coming over. This call asks them to
-        # remove the information integrated until now.
-        #
-        # It forwards the call to the decoders' #clear_integrated call. These
-        # methods should return true if a change has been needed on any of their
-        # display, and false otherwise.
-	def clear_integrated
-	    !decoders.find_all do |decoder|
-		decoder.clear_integrated
-	    end.empty?
-	end
-
-	# Update the displays
-        #
-        # It returns false if all decoders have reported that no display update
-        # was required, and true otherwise. The method relies on the decoder's
-        # #display method to return true/false when required.
-        #
-        # See DataDecoder#display
-	def display
-	    decoders.each do |decoder|
-		decoder.display
-	    end
-	end
-
-	def ==(other)
-	    other.kind_of?(DataStream) &&
-		name == other.name &&
-		type == other.type
-	end
-	def eql?(other); self == other end
-	def hash; [name, type].hash end
-    end
-
-    # In the data flow model we're using, a data decoder gets data from a
-    # DataStream object and builds a representation that can be used by
-    # displays.
-    class DataDecoder
-	# The set of displays attached to this decoder
-	attr_reader :displays
-        # The decoder name
-	attr_reader :name
-
-        # The DataStream object we're getting our data from
-	attr_accessor :stream
-
-	def initialize(name)
-	    @name = name
-	    @displays = [] 
-	end
-
-        # Clear the stream data
-	def clear
-	    displays.each { |d| d.clear }
-	end
-
-        # Displays may have the ability to not display a per-cycle information,
-        # but to add information as it is coming over. This call asks them to
-        # remove the information integrated until now.
-        #
-        # It forwards the call to the displays' #clear_integrated call(if any). These
-        # methods should return true if a change has been needed on any of their
-        # display, and false otherwise.
-	def clear_integrated
-	    !displays.find_all do |display|
-                if display.respond_to?(:clear_integrated)
-                    display.clear_integrated 
-                end
-	    end.empty?
-	end
-
-	# Updates the displays that are associated with this decoder. Returns
-        # true if one of the displays have been changed, and false otherwise.
-        #
-        # It relies on the display's #update method to return true if something
-        # has changed on the display and false otherwise.
-	def display
-	    !displays.find_all do |display| 
-		display.update
-	    end.empty?
-	end
-    end
-
-    # This module gets mixed-in the display classes. It creates the necessary
-    # stream => decoder => display link, reusing (if possible) a decoder that
-    # already exists.
-    #
-    # One should use it that way:
-    #
-    # class Display
-    #   include DataDisplay
-    #   decoder DecoderClass
-    # end
-    #
-    # Then, one can do
-    #   display = Display.new
-    #   display.stream = data_stream
-    #
-    # and leave the rest to the DataDisplay implementation.
-    module DataDisplay
-	module ClassExtension
-	    def decoder(new_type = nil)
-		if new_type
-		    @decoder_class = new_type
-		else
-		    @decoder_class
-		end
-	    end
-	end
-
-        # The decoder object. That object gets data from a DataStream object and
-        # decodes it into the format required by the display.
-        #
-        # Examples: PlanRebuilder
-	attr_reader :decoder
-	attr_reader :main
-
-        # The configuration UI object. Usually a subclass of Qt::Widget
-	attr_accessor :config_ui
-
-
-	def splat? #:nodoc:
-            true
-        end
-
-        # Sets the data stream that this display listens to. It creates or gets
-        # the decoder that is necessary between the raw stream and the display
-	def stream=(data_stream)
-	    if decoder
-		clear
-	    end
-
-	    @decoder = data_stream.decoder(self.class.decoder)
-	    decoder.displays << self
-	end
-
-	def clear; end
-    end
-end
-

data/lib/roby/log/dot.rb

@@ -1,279 +0,0 @@
-require 'roby/distributed/protocol'
-require 'roby/log'
-require 'tempfile'
-require 'fileutils'
-
-module Roby
-    module LoggedPlan
-	attr_accessor :layout_level
-	def all_events(display)
-	    known_tasks.inject(free_events.dup) do |events, task|
-		if display.displayed?(task)
-		    events.merge(task.events.values.to_value_set)
-		else
-		    events
-		end
-	    end
-	end
-
-	attr_reader :dot_id
-	def to_dot(display, io, level)
-	    @layout_level = level
-	    id = io.layout_id(self)
-	    @dot_id = "plan_#{id}"
-	    io << "subgraph cluster_#{dot_id} {\n"
-	    (known_tasks | finalized_tasks | free_events | finalized_events).
-		each do |obj|
-		    obj.to_dot(display, io) if display.displayed?(obj)
-		end
-
-	    io << "};\n"
-
-	    transactions.each do |trsc|
-		trsc.to_dot(display, io, level + 1)
-	    end
-
-	    relations_to_dot(display, io, Roby::Log::RelationsDisplay.all_task_relations, known_tasks)
-	end
-
-	def each_displayed_relation(display, relations, objects)
-	    relations.each do |rel|
-		next unless display.relation_enabled?(rel)
-
-		objects.each do |from|
-		    next unless display.displayed?(from)
-		    unless display[from]
-			Roby::Log.warn "no display item for #{from} in #each_displayed_relation"
-			next
-		    end
-
-		    from.each_child_object(rel) do |to|
-			next unless display.displayed?(to)
-			unless display[to]
-			    Roby::Log.warn "no display item for child in #{from} <#{rel}> #{to} in #each_displayed_relation"
-			    next
-			end
-
-			yield(rel, from, to)
-		    end
-		end
-	    end
-	end
-
-	def relations_to_dot(display, io, all_relations, objects)
-	    each_displayed_relation(display, all_relations, objects) do |rel, from, to|
-		from_id, to_id = from.dot_id, to.dot_id
-		if from_id && to_id
-		    io << "  #{from_id} -> #{to_id}\n"
-		else
-		    Roby::Log.warn "ignoring #{from}(#{from.object_id} #{from_id}) -> #{to}(#{to.object_id} #{to_id}) in #{rel} in #{caller(1).join("\n  ")}"
-		end
-	    end
-	end
-
-	def layout_relations(positions, display, all_relations, objects)
-	    each_displayed_relation(display, all_relations, objects) do |rel, from, to|
-		display.task_relation(from, to, rel, from[to, rel])
-	    end
-	end
-
-	# The distance from the root plan
-	attr_reader :depth
-
-	# Computes the plan depths and max_depth for this plan and all its
-	# children. +depth+ is this plan depth
-	#
-	# Returns max_depth
-	def compute_depth(depth)
-	    @depth = depth
-	    child_depth = transactions.
-		map { |trsc| trsc.compute_depth(depth + 1) }.
-		max
-	    child_depth || depth
-	end
-	
-	def apply_layout(bounding_rects, positions, display, max_depth = nil)
-	    max_depth ||= compute_depth(0)
-
-	    if rect = bounding_rects[dot_id]
-		item = display[self]
-                rect[2] *= 1.2
-                rect[3] *= 1.2
-		item.z_value = Log::PLAN_LAYER + depth - max_depth
-		item.set_rect *rect
-	    else
-		Roby::Log.warn "no bounding rectangle for #{self} (#{dot_id})"
-	    end
-
-
-	    (known_tasks | finalized_tasks | free_events | finalized_events).
-		each do |obj|
-		    obj.apply_layout(positions, display)
-		end
-
-	    transactions.each do |trsc|
-		trsc.apply_layout(bounding_rects, positions, display, max_depth)
-	    end
-	    layout_relations(positions, display, Roby::Log::RelationsDisplay.all_task_relations, known_tasks)
-	end
-    end
-
-    module LoggedPlanObject
-	attr_reader :dot_id
-
-	def dot_label(display); display_name(display) end
-
-	# Adds the dot definition for this object in +io+
-	def to_dot(display, io)
-	    return unless display.displayed?(self)
-	    @dot_id ||= "plan_object_#{io.layout_id(self)}"
-	    io << "  #{dot_id}[label=\"#{dot_label(display).split("\n").join('\n')}\"];\n"
-	end
-
-	# Applys the layout in +positions+ to this particular object
-	def apply_layout(positions, display)
-	    return unless display.displayed?(self)
-	    if p = positions[dot_id]
-		raise "no graphics for #{self}" unless graphics_item = display[self]
-		graphics_item.pos = p
-	    else
-		STDERR.puts "WARN: #{self} has not been layouted"
-	    end
-	end
-    end
-
-    class PlanObject::DRoby
-	include LoggedPlanObject
-    end
-
-    class TaskEventGenerator::DRoby
-	def dot_label(display); symbol.to_s end
-	def dot_id; task.dot_id end
-    end
-
-    module LoggedTask
-	include LoggedPlanObject
-	def dot_label(display)
-	    event_names = events.values.find_all { |ev| display.displayed?(ev) }.
-		map { |ev| ev.dot_label(display) }.
-		join(" ")
-
-	    own = super
-	    if own.size > event_names.size then own
-	    else event_names
-	    end
-	end
-    end
-
-    module Log
-	class Layout
-	    @@bkpindex = 0
-
-	    def layout_id(object)
-		id = Object.address_from_id(object.object_id).to_s
-		object_ids[id] = object
-		id
-	    end
-
-	    attribute(:object_ids) { Hash.new }
-	    attr_reader :dot_input
-
-	    def <<(string); dot_input << string end
-	    def layout(display, plan)
-		@@index ||= 0
-		@@index += 1
-
-		# Dot input file
-		@dot_input  = Tempfile.new("roby_dot")
-		# Dot output file
-		dot_output = Tempfile.new("roby_layout")
-
-		dot_input << "digraph relations {\n"
-		display.layout_options.each do |k, v|
-		    dot_input << "  #{k}=#{v};\n"
-		end
-		plan.to_dot(display, self, 0)
-
-		# Take the signalling into account for the layout
-		display.propagated_events.each do |_, sources, to, _|
-		    sources.each do |from|
-			from_id, to_id = from.dot_id, to.dot_id
-			if from_id && to_id
-			    dot_input << "  #{from.dot_id} -> #{to.dot_id}\n"
-			end
-		    end
-		end
-
-		dot_input << "\n};"
-		dot_input.flush
-
-		# Make sure the GUI keeps being updated while dot is processing
-		FileUtils.cp dot_input.path, "/tmp/dot-input-#{@@index}.dot"
-		system("#{display.layout_method} #{dot_input.path} > #{dot_output.path}")
-		#pid = fork do
-		#    exec("#{display.layout_method} #{dot_input.path} > #{dot_output.path}")
-		#end
-		#while !Process.waitpid(pid, Process::WNOHANG)
-		#    if Qt::Application.has_pending_events
-		#	Qt::Application.process_events
-		#    else
-		#	sleep(0.05)
-		#    end
-		#end
-		FileUtils.cp dot_output.path, "/tmp/dot-output-#{@@index}.dot"
-
-		# Load only task bounding boxes from dot, update arrows later
-		current_graph_id = nil
-		bounding_rects = Hash.new
-		object_pos     = Hash.new
-		lines = File.open(dot_output.path) { |io| io.readlines  }
-		full_line = ""
-		lines.each do |line|
-		    line.chomp!
-		    full_line << line
-		    if line[-1] == ?\\
-			full_line.chop!
-			next
-		    end
-
-		    case full_line
-		    when /((?:\w+_)+\d+) \[.*pos="(\d+),(\d+)"/
-			object_pos[$1] = Qt::PointF.new(Integer($2), Integer($3))
-		    when /subgraph cluster_(plan_\d+)/
-			current_graph_id = $1
-		    when /graph \[bb="(\d+),(\d+),(\d+),(\d+)"\]/
-			bb = [$1, $2, $3, $4].map do |c|
-			    c = Integer(c)
-			end
-			bounding_rects[current_graph_id] = [bb[0], bb[1], bb[2] - bb[0], bb[3] - bb[1]]
-		    end
-		    full_line = ""
-		end
-
-		graph_bb = bounding_rects.delete(nil)
-		bounding_rects.each_value do |coords|
-		    coords[0] -= graph_bb[0]
-		    coords[1] = graph_bb[1] - coords[1] - coords[3]
-		end
-		object_pos.each do |id, pos|
-		    pos.x -= graph_bb[0]
-		    pos.y = graph_bb[1] - pos.y
-		end
-
-		@display         = display
-		@plan            = plan
-		@object_pos      = object_pos
-		@bounding_rects  = bounding_rects
-
-	    ensure
-		dot_input.close!  if dot_input
-		dot_output.close! if dot_output
-	    end
-
-	    attr_reader :bounding_rects, :object_pos, :display, :plan
-	    def apply
-		plan.apply_layout(bounding_rects, object_pos, display)
-	    end
-	end
-    end
-end