roby 0.8.0 → 3.0.0

data/lib/roby/task-operations.rb

@@ -1,186 +0,0 @@
-module Roby
-    module TaskOperations
-        def +(task)
-            # !!!! + is NOT commutative
-            if task.null?
-                self
-            elsif self.null?
-                task
-            else
-                Sequence.new << self << task
-            end
-        end
-        def |(task)
-            if self.null?
-                task
-            elsif task.null?
-                self
-            else
-                Parallel.new << self << task
-            end
-        end
-            
-    end
-
-    class Task
-        include TaskOperations
-    end
-
-    class TaskAggregator < Roby::Task
-	terminates
-	event(:start, :command => true)
-
-	attr_reader :tasks
-	def initialize(arguments = {}); @tasks = Array.new; super end
-	def each_task(&iterator)
-	    yield(self)
-	    tasks.each(&iterator) 
-	end
-	def empty?; tasks.empty? end
-
-	def delete
-	    @name  = self.name
-	    @tasks = nil
-	    if plan
-		plan.remove_object(self)
-	    else
-		clear_relations
-		freeze 
-	    end
-	end
-    end
-
-    class Sequence < TaskAggregator
-	def name
-	    @name || @tasks.map { |t| t.name }.join("+")
-	end
-
-	def to_task(task = nil)
-	    return super() unless task
-	    task = task.new unless task.kind_of?(Roby::Task)
-	    @tasks.each { |t| task.depends_on t }
-
-	    task.signals(:start, @tasks.first, :start)
-	    @tasks.last.forward_to(:success, task, :success)
-
-	    delete
-
-	    task
-	end
-        def child_of(task = nil)
-            to_task(task)
-        end
-
-	def connect_start(task)
-	    if old = @tasks.first
-		event(:start).remove_signal old.event(:start)
-		task.signals(:success, old, :start)
-	    end
-
-	    event(:start).signals task.event(:start)
-	end
-
-	def connect_stop(task)
-	    if old = @tasks.last
-		old.signals(:success, task, :start)
-		old.event(:success).remove_forwarding event(:success)
-	    end
-	    task.forward_to(:success, self, :success)
-	end
-	private :connect_stop, :connect_start
-
-        def unshift(task)
-            raise "trying to do Sequence#unshift on a running or finished sequence" if (running? || finished?)
-	    connect_start(task)
-	    connect_stop(task) if @tasks.empty?
-
-            @tasks.unshift(task)
-	    depends_on task
-	    self
-        end
-
-        def <<(task)
-	    raise "trying to do Sequence#<< on a finished sequence" if finished?
-	    connect_start(task) if @tasks.empty?
-	    connect_stop(task)
-	    
-	    @tasks << task
-	    depends_on task
-	    self
-        end
-
-        def to_sequence; self end
-    end
-
-    class Parallel < TaskAggregator
-	def name
-	    @name || @tasks.map { |t| t.name }.join("|")
-	end
-
-	attr_reader :children_success
-        def initialize(arguments = {})
-	    super
-
-	    @children_success = Roby::AndGenerator.new
-	    @children_success.forward_to event(:success)
-        end
-
-        def child_of(task = nil)
-            to_task(task)
-        end
-	def to_task(task = nil)
-	    return super() unless task
-
-	    task = task.new unless task.kind_of?(Roby::Task)
-	    @tasks.each do |t| 
-		task.depends_on t
-		task.signals(:start, t, :start)
-	    end
-	    task.event(:success).emit_on children_success
-
-	    delete
-
-	    task
-	end
-
-        def <<(task)
-	    raise "trying to change a running parallel task" if running?
-            @tasks << task
-
-	    signals(:start, task, :start)
-	    depends_on task
-	    children_success << task.event(:success)
-
-            self
-        end
-
-        def to_parallel; self end
-    end
-
-    class Group < Roby::Task
-	def initialize(*tasks)
-	    super()
-	    if tasks.empty? || tasks.first.kind_of?(Hash)
-		return
-	    end
-
-	    success = AndGenerator.new
-	    tasks.each do |task|
-		depends_on task
-		task.event(:success).signals success
-	    end
-	    success.forward_to event(:success)
-	end
-
-	event :start do
-	    children.each do |child|
-		if child.pending? && child.event(:start).root?
-		    child.start!
-		end
-	    end
-	    emit :start
-	end
-	terminates
-    end
-end
-

data/lib/roby/task_index.rb

@@ -1,80 +0,0 @@
-module Roby
-    # TaskIndex objects are used to maintain a set of tasks as classified sets,
-    # speeding up query operations. See Plan#task_index.
-    class TaskIndex
-        # A model => ValueSet map of the tasks for each model
-	attr_reader :by_model
-	# A state => ValueSet map of tasks given their state. The state is
-	# a symbol in [:pending, :starting, :running, :finishing,
-	# :finished]
-	attr_reader :by_state
-	# A peer => ValueSet map of tasks given their owner.
-	attr_reader :by_owner
-	# The set of tasks which have an event which is being repaired
-	attr_reader :repaired_tasks
-
-	STATE_PREDICATES = [:pending?, :running?, :finished?, :success?, :failed?].to_value_set
-
-	def initialize
-	    @by_model = Hash.new { |h, k| h[k] = ValueSet.new }
-	    @by_state = Hash.new
-	    STATE_PREDICATES.each do |state_name|
-		by_state[state_name] = ValueSet.new
-	    end
-	    @by_owner = Hash.new
-	    @task_state = Hash.new
-	    @repaired_tasks = ValueSet.new
-	end
-
-        # Add a new task to this index
-	def add(task)
-	    for klass in task.model.ancestors
-		by_model[klass] << task
-	    end
-	    by_state[:pending?] << task
-	    for owner in task.owners
-		add_owner(task, owner)
-	    end
-	end
-
-        # Updates the index to reflect that +new_owner+ now owns +task+
-	def add_owner(task, new_owner)
-	    (by_owner[new_owner] ||= ValueSet.new) << task
-	end
-
-        # Updates the index to reflect that +peer+ no more owns +task+
-	def remove_owner(task, peer)
-	    if set = by_owner[peer]
-		set.delete(task)
-		if set.empty?
-		    by_owner.delete(peer)
-		end
-	    end
-	end
-
-        # Updates the index to reflect a change of state for +task+
-	def set_state(task, new_state)
-	    for state_set in by_state
-		state_set.last.delete(task)
-	    end
-	    by_state[new_state] << task
-	    if new_state == :success? || new_state == :failed?
-		by_state[:finished?] << task
-	    end
-	end
-
-        # Remove all references of +task+ from the index.
-	def remove(task)
-	    for klass in task.model.ancestors
-		by_model[klass].delete(task)
-	    end
-	    for state_set in by_state
-		state_set.last.delete(task)
-	    end
-	    for owner in task.owners
-		remove_owner(task, owner)
-	    end
-	end
-    end
-end
-

data/lib/roby/test/distributed.rb

@@ -1,230 +0,0 @@
-require 'roby/test/common'
-require 'roby/distributed'
-
-module Roby
-    module Distributed
-	module Test
-	    include ::Roby::Test
-	    include ::Roby::Distributed
-
-	    def setup
-		super
-
-		@old_distributed_logger_level = Distributed.logger.level
-
-		timings[:setup] = Time.now
-
-		# Start the GC so that it does not kick in a test. On slow machines, 
-		# it can trigger timeouts
-		GC.start
-		timings[:gc] = Time.now
-	    end
-
-	    def teardown
-		begin
-		    if remote && remote.respond_to?(:cleanup)
-			remote.cleanup
-		    end
-		rescue DRb::DRbConnError
-		end
-
-		super
-
-		unless Distributed.peers.empty?
-		    Roby::Distributed.warn "  still referencing #{Distributed.peers.keys}"
-		    Distributed.peers.clear
-		end
-
-		# This one is a nasty one ...
-		# The main plan is the only thing which remains. If we do not reset
-		# the cached drb_object, it will be kept in the next test and the forked
-		# child will therefore use it ... And it will fail
-		plan.instance_eval do
-		    @__droby_remote_id__ = nil
-		    @__droby_marshalled__ = nil
-		end
-                Roby.class_eval do
-                    @plan = nil
-                    @engine = nil
-                end
-
-		if local
-		    local.quit
-		end
-
-		timings[:end] = Time.now
-
-	    rescue Exception
-		STDERR.puts "failing teardown: #{$!.full_message}"
-		raise
-
-	    ensure
-		Distributed.logger.level = @old_distributed_logger_level
-	    end
-
-	    module RemotePeerSupport
-		attr_accessor :testcase
-
-		def enable_communication
-		    synchronize do
-			local_peer.enable_rx
-			# make sure we wake up the communication thread
-			finished_discovery.broadcast
-		    end
-		end
-		def disable_communication
-		    local_peer.disable_rx
-		end
-		def flush; local_peer.flush end
-		def process_events; engine.process_events end
-		def local_peer
-		    @local_peer ||= peers.find { true }.last
-		end
-		def reset_local_peer; @local_peer = nil end
-		def send_local_peer(*args); local_peer.send(*args) end
-		def wait_one_cycle; engine.wait_one_cycle end
-		def console_logger=(value); testcase.console_logger = value end
-		def log_level=(value); Roby.logger.level = value end
-		def cleanup
-		    engine.quit
-		    engine.join
-		end
-                def disable_logging
-                    logger = Roby::Distributed.logger
-                    @orig_logger_level = logger.level
-                    logger.level = Logger::UNKNOWN
-                end
-                def enable_logging
-                    logger = Roby::Distributed.logger
-                    logger.level = (@orig_logger_level || Logger::WARN)
-                end
-	    end
-
-	    # Start a central discovery service, a remote connectionspace and a local
-	    # connection space. It yields the remote connection space *in the forked
-	    # child* if a block is given.
-	    def start_peers
-		DRb.stop_service
-		remote_process do
-		    DRb.start_service DISCOVERY_SERVER, Rinda::TupleSpace.new
-		end
-
-		if engine.running?
-		    begin
-			engine.quit
-			engine.join
-		    rescue ControlQuitError
-		    end
-		end
-
-		remote_process do
-		    central_tuplespace = DRbObject.new_with_uri(DISCOVERY_SERVER)
-
-		    cs = ConnectionSpace.new :ring_discovery => false, 
-			:discovery_tuplespace => central_tuplespace, :name => "remote",
-                        :plan => plan
-
-                    getter = Class.new do
-                        attr_accessor :cs
-                        def get; DRbObject.new(cs) end
-                    end.new
-                    getter.cs = cs
-
-                    Distributed.state = cs
-
-                    DRb.start_service REMOTE_SERVER, getter
-
-		    cs.extend RemotePeerSupport
-		    cs.testcase = self
-
-		    def cs.start_control_thread
-			engine.run
-		    end
-
-		    yield(cs) if block_given?
-		end
-
-		DRb.start_service LOCAL_SERVER
-		@central_tuplespace = DRbObject.new_with_uri(DISCOVERY_SERVER)
-		@remote  = DRbObject.new_with_uri(REMOTE_SERVER).get
-		@local   = ConnectionSpace.new :ring_discovery => false, 
-		    :discovery_tuplespace => central_tuplespace, :name => 'local', 
-		    :plan => plan
-                Distributed.state = local
-
-                remote.start_control_thread
-                engine.run
-	    end
-
-	    def setup_connection
-		assert(remote_neighbour = local.neighbours.find { true })
-		Peer.initiate_connection(local, remote_neighbour) do |@remote_peer| end
-
-		while !remote_peer
-		    process_events
-		end
-		assert(remote.send_local_peer(:connected?))
-	    end
-
-	    attr_reader :central_tuplespace, :remote, :remote_peer, :remote_plan, :local
-
-	    # Establishes a peer to peer connection between two ConnectionSpace objects
-	    def peer2peer(&remote_init)
-		timings[:starting_peers] = Time.now
-		start_peers(&remote_init)
-		setup_connection
-		timings[:started_peers] = Time.now
-	    end
-
-	    def process_events
-		if engine.running?
-		    remote.wait_one_cycle
-		    engine.wait_one_cycle
-		elsif remote_peer && !remote_peer.disconnected?
-		    Roby.synchronize do
-			remote.process_events
-			engine.process_events
-		    end
-		else
-		    super
-		end
-	    end
-
-	    def remote_task(match)
-		set_permanent = match.delete(:permanent)
-
-		found = nil
-		remote_peer.find_tasks.with_arguments(match).each do |task|
-		    assert(!found)
-		    if set_permanent
-			plan.add_permanent(task)
-		    end
-
-		    found = if block_given? then yield(task)
-			    else task
-			    end
-		end
-		found
-	    end
-	    def subscribe_task(match)
-		remote_task(match) do |task|
-		    remote_peer.subscribe(task)
-		    task
-		end
-	    end
-
-	    def remote_server(&block)
-		DRb.stop_service
-		remote_process do
-		    server = Class.new do
-			class_eval(&block)
-		    end.new
-		    DRb.start_service REMOTE_SERVER, server
-		end
-
-		DRb.start_service LOCAL_SERVER
-		DRbObject.new_with_uri(REMOTE_SERVER)
-	    end
-	end
-    end
-end