roby 0.8.0 → 3.0.0

data/lib/roby/external_process_task.rb

@@ -1,225 +0,0 @@
-module Roby
-    trap 'SIGCHLD' do
-        begin
-            while pid = ::Process.wait(-1, ::Process::WNOHANG)
-                ExternalProcessTask.dead! pid, $?.dup
-            end
-        rescue Errno::ECHILD
-        end
-    end
-
-    # This task class can be used to monitor the execution of an external
-    # process. Among the useful features, it can redirect standard output and
-    # error output to files.
-    #
-    # The events will act as follows:
-    # * the start command starts the process per se. The event is emitted once
-    #   exec() has been called with success
-    # * the signaled event is emitted when the process dies because of a signal
-    # * the failed event is emitted whenever the process exits with a nonzero
-    #   status
-    # * the success event is emitted when the process exits with a zero status
-    # * the stop event is emitted when the process exits
-    class ExternalProcessTask < Roby::Task
-        ##
-        # :attr_reader:
-        # This task argument is an array whose first element is the executable
-        # to start and the rest the arguments that need to be passed to it.
-        #
-        # It can also be set to a simple string, which is interpreted as the
-        # executable name with no arguments.
-        argument :command_line
-
-        ##
-        # :attr_reader:
-        # The working directory. If not set, the current directory is used.
-        argument :working_directory
-
-        # Redirection specification. See #redirect_output
-        attr_reader :redirection
-
-        def initialize(arguments)
-            arguments[:working_directory] ||= nil
-			arguments[:command_line] = [arguments[:command_line]] unless arguments[:command_line].kind_of?(Array)
-            super(arguments)
-        end
-
-        class << self
-            # The set of running ExternalProcessTask instances. It is a mapping
-            # from the PID value to the instances.
-            attr_reader :processes
-        end
-        @processes = Hash.new
-
-        # Called by the SIGCHLD handler to announce that a particular process
-        # has finished. It calls #dead!(result) in the context of the execution
-        # thread, on the corresponding task
-        def self.dead!(pid, result) # :nodoc:
-            task = processes[pid]
-            return if !task
-            if engine = task.plan.engine
-                engine.once { task.dead!(result) }
-            end
-        end
-
-        # Called to announce that this task has been killed. +result+ is the
-        # corresponding Process::Status object.
-        def dead!(result)
-            if result.success?
-                emit :success
-            elsif result.signaled?
-                emit :signaled, result
-            else
-                emit :failed, result
-            end
-        end
-
-        # This event gets emitted if the process died because of a signal
-        event :signaled
-
-        forward :signaled => :failed
-
-        ##
-        # If set to a string, the process' standard output will be redirected to
-        # the given file. The following replacement is done:
-        # * '%p' is replaced by the process PID
-        #
-        # The last form (with nil argument) removes any redirection. A specific
-        # redirection can also be disabled using the hash form:
-        #   redirect_output :stdout => nil
-        #
-        # :call-seq:
-        #   redirect_output "file"
-        #   redirect_output :stdout => "file-out", :stderr => "another-file"
-        #   redirect_output nil
-        #
-        def redirect_output(args)
-            if !args
-                @redirection = nil
-            elsif args.respond_to? :to_str
-                @redirection = args.to_str
-            else
-                args = validate_options args, :stdout => nil, :stderr => nil
-                if args[:stdout] == args[:stderr]
-                    @redirection = args[:stdout].to_str
-                else
-                    @redirection = Hash.new
-                    @redirection[:stdout] = args[:stdout].to_str if args[:stdout]
-                    @redirection[:stderr] = args[:stderr].to_str if args[:stderr]
-                end
-            end
-        end
-
-        # The PID of the child process, or nil if the child process is not
-        # running
-        attr_reader :pid
-
-        # Error codes between the child and the parent. Note that the error
-        # codes must not be greater than 9
-        # :stopdoc:
-        KO_REDIRECTION  = 1
-        KO_NO_SUCH_FILE = 2
-        KO_EXEC         = 3
-        # :startdoc:
-
-        # Returns the file name based on the redirection pattern and the current
-        # PID values. This is called in the child process before exec().
-        def redirection_path(pattern) # :nodoc:
-            pattern.gsub '%p', Process.pid.to_s
-        end
-
-        # Starts the child process
-        def start_process # :nodoc:
-            # Open a pipe to monitor the child startup
-            r, w = IO.pipe
-
-            @pid = fork do
-                # Open the redirection outputs
-                stdout, stderr = nil
-                begin
-                    if redirection.respond_to?(:to_str)
-                        stdout = stderr = File.open(redirection_path(redirection), "w")
-                    elsif redirection
-                        if stdout_file = redirection[:stdout]
-                            stdout = File.open(redirection_path(stdout_file), "w")
-                        end
-                        if stderr_file = redirection[:stderr]
-                            stderr = File.open(redirection_path(stderr_file), "w")
-                        end
-                    end
-                rescue Exception => e
-                    Roby.fatal e.message
-                    w.write("#{KO_REDIRECTION}")
-                    return
-                end
-
-                STDOUT.reopen(stdout) if stdout
-                STDERR.reopen(stderr) if stderr
-
-                r.close
-                w.fcntl(Fcntl::F_SETFD, 1) # set close on exit
-                ::Process.setpgrp
-                begin
-                    exec(*command_line)
-                rescue Errno::ENOENT
-                    w.write("#{KO_NO_SUCH_FILE}")
-                rescue Exception => e
-                    Roby.fatal e.message
-                    w.write("#{KO_EXEC}")
-                end
-            end
-
-            ExternalProcessTask.processes[pid] = self
-
-            is_running = begin
-                             !Process.waitpid(pid, Process::WNOHANG)
-                         rescue Errno::ECHILD
-                             false
-                         end
-            if !is_running
-                raise "child #{command_line.first} died unexpectedly during its startup"
-            end
-
-            w.close
-            control = Integer(r.read(1))
-            if control == KO_REDIRECTION
-                raise "could not start #{command_line.first}: cannot establish output redirections"
-            elsif control == KO_NO_SUCH_FILE
-                raise "could not start #{command_line.first}: provided command does not exist"
-            elsif control == KO_EXEC
-                raise "could not start #{command_line.first}: exec() call failed"
-            end
-
-
-        rescue Exception => e
-            ExternalProcessTask.processes.delete(pid)
-            raise e
-        end
-
-        ##
-        # :method: start!
-        #
-        # Starts the child process. Emits +start+ when the process is actually
-        # started.
-        event :start do |_|
-            if working_directory
-                Dir.chdir(working_directory) do
-                    start_process
-                end
-            else
-                start_process
-            end
-            emit :start
-        end
-
-        # Kills the child process
-        def kill(signo)
-            Process.kill(signo, pid)
-        end
-
-        on :stop do |_|
-            ExternalProcessTask.processes.delete(pid)
-        end
-    end
-end
-

data/lib/roby/graph.rb

@@ -1,160 +0,0 @@
-Utilrb.unless_ext do
-    raise LoadError, "Roby needs Utilrb's C extension to be compiled"
-end
-
-module BGL
-    module Vertex
-	def initialize_copy(old)
-	    super
-	    @__bgl_graphs__ = nil
-	end
-
-	# Removes +self+ from all the graphs it is included in.
-	def clear_vertex
-	    each_graph { |g| g.remove(self) }
-	end
-
-	attribute(:singleton_set) { [self].to_value_set.freeze }
-	# Returns the connected component +self+ is part of in +graph+
-	def component(graph)
-	    graph.components(singleton_set, false).first || singleton_set
-	end
-	# Returns the vertex set which are reachable from +self+ in +graph+
-	def generated_subgraph(graph)
-	    graph.generated_subgraphs(singleton_set, false).first || singleton_set
-	end
-	# Returns the vertex set which can reach +self+ in +graph+
-	def reverse_generated_subgraph(graph)
-	    graph.reverse.generated_subgraphs(singleton_set, false).first || singleton_set
-	end
-
-	# Replace this vertex by +to+ in all graphs. See Graph#replace_vertex.
-	def replace_vertex_by(to)
-	    each_graph { |g| g.replace_vertex(self, to) }
-	end
-
-	# Returns an array of [graph, [parent, child, info], [parent, child,
-	# info], ...] elements for all edges +self+ is involved in
-	def edges
-	    result = []
-	    each_graph do |graph|
-		graph_edges = []
-		each_child_object do |child|
-		    graph_edges << [self, child, self[child, graph]]
-		end
-		each_parent_object do |parent|
-		    graph_edges << [parent, self, parent[self, graph]]
-		end
-		result << [graph, graph_edges]
-	    end
-
-	    result
-	end
-
-	# call-seq:
-	#   neighborhood(distance, graph) => [[graph, v, v1, data], [graph, v2, v, data], ...]
-	#   neighborhood(distance)	    => [[g1, v, v1, data], [g2, v2, v, data], ...]
-	#
-	# Returns a list of [graph, edge] representing all edges at a maximum distance
-	# of +distance+ from +self+. If +graph+ is given, only enumerate the neighborhood
-	# in +graph+.
-	def neighborhood(distance, graph = nil)
-	    if graph
-		graph.neighborhood(self, distance).
-		    map! { |args| args.unshift(graph) }
-	    else
-		edges = []
-		each_graph do |graph|
-		    edges += neighborhood(distance, graph)
-		end
-		edges
-	    end
-	end
-    end
-
-    class Graph
-	# This class is an adaptor which transforms a directed graph by
-	# swapping its edges
-	class Reverse
-	    # Create a directed graph whose edges are the ones of +g+, but with
-	    # source and destination swapped.
-	    def initialize(g)
-		@__bgl_real_graph__ = g
-	    end
-	end
-	attribute(:reverse)    { @reverse = Graph::Reverse.new(self) }
-
-	# This class is a graph adaptor which transforms a directed graph into
-	# an undirected graph
-	class Undirected
-	    # Create an undirected graph which has the same edge set than +g+
-	    def initialize(g)
-		@__bgl_real_graph__ = g
-	    end
-	end
-	attribute(:undirected) { @undirected = Graph::Undirected.new(self) }
-
-	def initialize_copy(source) # :nodoc:
-	    super
-
-	    source.each_vertex { |v| insert(v) }
-	    source.each_edge { |s, t, i| link(s, t, i) }
-	end
-
-	# Replaces +from+ by +to+. This means +to+ takes the role of +from+ in
-	# all edges +from+ is involved in. +from+ is removed from the graph.
-	def replace_vertex(from, to)
-	    from.each_parent_vertex(self) do |parent|
-		link(parent, to, parent[from, self])
-	    end
-	    from.each_child_vertex(self) do |child|
-		link(to, child, from[child, self])
-	    end
-	    remove(from)
-	end
-
-	# Returns a list of [parent, child, info] for all edges that are at a
-	# distance no more than +distance+ from +vertex+.
-	def neighborhood(vertex, distance)
-	    result = []
-	    seen = Set.new
-	    depth = { vertex => 0 }
-	    undirected.each_bfs(vertex, ALL) do |from, to, info, kind|
-		new_depth = depth[from] + 1
-		if kind == TREE
-		    depth[to] = new_depth
-		else
-		    next if seen.include?(to)
-		end
-		seen << from
-
-		if depth[from] > distance
-		    break
-		end
-
-		if new_depth <= distance
-		    if linked?(from, to)
-			result << [from, to, info]
-		    else
-			result << [to, from, info]
-		    end
-		end
-	    end
-	    result
-	end
-
-	# Two graphs are the same if they have the same vertex set
-	# and the same edge set
-	def same_graph?(other)
-	    unless other.respond_to?(:each_vertex) && other.respond_to?(:each_edge)
-		return false
-	    end
-
-	    # cannot use to_value_set for edges since we are comparing arrays (and ValueSet
-	    # bases its comparison on VALUE)
-	    (other.enum_for(:each_vertex).to_value_set == enum_for(:each_vertex).to_value_set) && 
-		(other.enum_for(:each_edge).to_set == enum_for(:each_edge).to_set)
-	end
-    end
-end
-

data/lib/roby/log.rb

@@ -1,3 +0,0 @@
-require 'roby'
-require 'roby/distributed'
-require 'roby/log/logger'

data/lib/roby/log/chronicle.rb

@@ -1,303 +0,0 @@
-require 'roby/log/data_stream'
-require 'roby/log/relations'
-require 'roby/log/gui/chronicle_view'
-
-module Roby
-    module Log
-	class ChronicleDisplay < Qt::Object
-
-	    # y:: the Y of this line in the graphics scene
-	    # item:: the main item, either a free event or a task
-	    # graphic_items:: the array of graphic items
-	    # graphics_group:: a Qt::GraphicsGroup object holding all graphic objects for this line
-	    Line = Struct.new :y, :item, :graphic_items, :graphic_group, :start_time
-	    class Line
-		def add(graphic_item, time)
-		    class << graphic_item; attr_accessor :time end
-		    graphic_item.time = time
-		    graphic_group.add_to_group graphic_item
-
-		    if graphic_items.empty?
-			self.start_time = time
-		    end
-		    graphic_items << graphic_item
-		end
-	    end
-
-	    include DataDisplay
-	    decoder PlanRebuilder
-
-	    include TaskDisplaySupport
-
-	    attr_reader :scene
-	    attr_reader :ui
-
-	    attr_reader :signalled_events
-	    attr_reader :execution_events
-	    attr_reader :graphic_stack
-	    attr_reader :graphic_objects
-	    attr_reader :last_event_graphics
-	    attr_reader :time_scale
-
-	    attr_predicate :display_follows_execution?, true
-	    attr_predicate :display_follows_new_tasks?, true
-
-	    def initialize
-		@scene  = Qt::GraphicsScene.new
-		super()
-
-		@main = Qt::MainWindow.new
-		main.resize 500, 500
-		@ui = Ui::ChronicleView.new
-		ui.setupUi(self, main)
-		ui.graphics.scene = @scene
-
-		@signalled_events    = []
-		@execution_events    = []
-		@graphic_stack       = []
-		@graphic_objects     = Hash.new
-		@last_event_graphics = Hash.new
-		self.show_ownership = false
-
-		connect(ui.graphics.horizontalScrollBar, SIGNAL('valueChanged(int)'), self, SLOT('hscroll()'))
-		connect(ui.graphics.verticalScrollBar, SIGNAL('valueChanged(int)'), self, SLOT('vscroll()'))
-
-		@time_scale = 100.0
-	    end
-
-	    def time_scale=(new_value)
-		@time_scale = new_value
-
-		# For now, we don't relayout event labels
-		graphic_stack.each do |line_info|
-		    base_x = time_to_display(line_info.start_time)
-
-		    line_info.graphic_items.each do |g|
-			g.set_pos(time_to_display(g.time), g.pos.y)
-		    end
-		end
-
-		# call update to update the task width
-		update
-	    end
-
-	    def vscroll(user = true)
-		if user
-		    scrollbar = ui.graphics.verticalScrollBar
-		    @display_follows_new_tasks = (scrollbar.maximum == scrollbar.value)
-		end
-	    end
-	    slots 'vscroll()'
-
-	    def hscroll(user = true)
-		left_side = ui.graphics.mapToScene(0, 0).x
-
-		if user
-		    scrollbar = ui.graphics.horizontalScrollBar
-		    @display_follows_execution = (scrollbar.maximum == scrollbar.value)
-		end
-
-		graphic_stack.each do |line|
-		    item = line.item
-		    next unless item.kind_of?(Roby::Task::DRoby)
-
-		    graphics = graphic_objects[item]
-		    dx = graphics.pos.x - left_side
-		    if dx <= 0
-			graphics.text.set_pos(-dx, graphics.text.pos.y)
-		    else
-			graphics.text.set_pos(0, graphics.text.pos.y)
-		    end
-		end
-	    end
-	    slots 'hscroll()'
-
-	    def time_to_display(time)
-		(time - decoder.start_time) * time_scale
-	    end
-
-	    def create_line(item)
-		group = scene.create_item_group([])
-		graphic_stack << (new_line = Line.new(0, item, [], group))
-		new_line
-	    end
-
-	    def create_or_get_task(item, time)
-		unless g = graphic_objects[item]
-		    pos_x = time_to_display(time)
-
-		    g = graphic_objects[item] = item.display_create(self)
-		    g.rect = Qt::RectF.new(0, 0, 0, Log::DEFAULT_TASK_HEIGHT)
-		    g.move_by pos_x, 0
-		    line = create_line(item)
-		    line.add g, time
-		end
-		g
-	    end
-
-	    def line_of(object)
-		graphic_stack.each_with_index do |line, i|
-		    return i if line.item == object
-		end
-		nil
-	    end
-
-	    def stream=(stream)
-		super
-
-		# Initialize the set of running tasks
-		update_prefixes_removal
-		decoder.tasks.each_key do |task|
-		    if task.current_state == :started
-			create_or_get_task(task, decoder.time)
-		    end
-		end
-	    end
-
-
-	    def append_event(task, event)
-		index = line_of(task)
-		create_or_get_item(event, index)
-	    end
-
-	    def update
-		update_prefixes_removal
-
-		execution_events.each do |flags, time, event|
-		    graphics = event.display_create(self)
-		    graphics.move_by time_to_display(time), 0
-		    y_offset = Log::EVENT_CIRCLE_RADIUS + Log::TASK_EVENT_SPACING
-
-		    if event.respond_to?(:task)
-			task_graphics = create_or_get_task(event.task, time)
-			line = line_of(event.task)
-
-			# Check that the event labels to not collide. If it is
-			# the case, move the current label at the bottom of the
-			# last label found
-			line_info = graphic_stack[line]
-			if line_info.graphic_items.size > 1
-			    last_event = line_info.graphic_items[-1]
-			    last_br    = last_event.text.scene_bounding_rect
-			    current_br = graphics.text.scene_bounding_rect
-			    if last_br.right > current_br.left
-				if event.task.last_event[1] == event
-				    last_event.text.hide
-				else
-				    graphics.text.set_pos(0, last_br.bottom - last_event.scene_pos.y)
-				end
-			    end
-			end
-
-			# Move the right edge of the task to reflect that it is
-			# still running. Then, make sure the rectangle can
-			# contain the event graphics
-			expected_height = graphics.text.bounding_rect.bottom + y_offset
-			if expected_height > task_graphics.rect.height
-			    task_graphics.set_rect(0, 0, time_to_display(time) - time_to_display(line_info.start_time), expected_height)
-			    task_graphics.text.set_pos(task_graphics.text.pos.x, expected_height)
-			end
-			event.task.last_event = [time, event]
-
-		    elsif !(line = line_of(event))
-			group = create_line(event)
-			line = (graphic_stack.size - 1)
-		    end
-
-		    line_info = graphic_stack[line]
-		    graphics.move_by 0, line_info.y + y_offset
-
-		    # Try to handle too-near events gracefully
-		    #old_flag, old_graphics = last_event_graphics[event]
-		    #if old_flag
-		    #    flag = 2 if old_flag == 0 && flag == 1
-		    #    if old_graphics.text.bounding_rect.right > graphics.text.bounding_rect.left
-		    #        old_graphics.text.hide
-		    #    end
-		    #end
-		    #last_event_graphics[event] = [flag, graphics]
-
-		    graphics.brush, graphics.pen = EventGeneratorDisplay.style(event, flags)
-		    if flags & EVENT_EMITTED == 1
-			graphics.z_layer += 1
-		    end
-		    line_info.add graphics, time
-		end
-
-		removed_objects = (graphic_objects.keys - decoder.tasks.keys - decoder.events.keys)
-		removed_objects.each do |obj|
-		    if line = line_of(obj)
-			graphic_objects.delete(obj)
-			scene.remove_item graphic_stack[line].graphic_group
-			graphic_stack.delete_at(line)
-		    end
-		end
-
-		decoder.tasks.each_key do |task|
-		    next unless task_graphics = graphic_objects[task]
-		    line_info = graphic_stack[line_of(task)]
-
-		    old_state = task.displayed_state
-		    task.update_graphics(self, task_graphics)
-
-		    state = task.current_state
-		    rect = task_graphics.rect
-
-		    last_time = if state == :success || state == :finished
-				    task.last_event[0]
-				else decoder.time
-				end
-		    task_graphics.set_rect(0, 0, time_to_display(last_time) - time_to_display(line_info.start_time), rect.height)
-		end
-
-		if display_follows_execution?
-		    scrollbar = ui.graphics.horizontalScrollBar
-		    scrollbar.value = scrollbar.maximum
-		    hscroll(false)
-		end
-
-		if display_follows_new_tasks?
-		    scrollbar = ui.graphics.verticalScrollBar
-		    scrollbar.value = scrollbar.maximum
-		end
-
-		# layout lines
-		y = 0
-		graphic_stack.each do |line|
-		    offset = y - line.y
-		    if offset != 0
-			line.y = y
-			line.graphic_group.move_by 0, offset
-		    end
-
-		    br = line.graphic_group.bounding_rect | line.graphic_group.children_bounding_rect
-		    y += br.bottom + Log::TASK_EVENT_SPACING
-		end
-
-		execution_events.clear
-		signalled_events.clear
-	    end
-
-	    def local_task(obj);   decoder.local_task(obj) end
-	    def local_event(obj);  decoder.local_event(obj) end
-	    def local_plan(obj);   decoder.local_plan(obj) end
-	    def local_object(obj); decoder.local_object(obj) end
-
-	    def generator_called(time, generator, context)
-		execution_events << [EVENT_CALLED, time, local_event(generator)]
-	    end
-	    def generator_fired(time, generator, event_id, event_time, event_context)
-		generator = local_event(generator)
-		execution_events << [EVENT_EMITTED, event_time, generator]
-	    end
-	    def generator_signalling(time, flag, from, to, event_id, event_time, event_context)
-		signalled_events << [flag, local_event(from), local_event(to), event_id]
-	    end
-	    def generator_forwarding(time, flag, from, to, event_id, event_time, event_context)
-		signalled_events << [flag, local_event(from), local_event(to), event_id]
-	    end
-	end
-    end
-end
-
-