roby 0.7.3 → 0.8.0

data/test/distributed/test_communication.rb

@@ -1,3 +1,4 @@
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
 require 'test/unit'
 require 'roby/distributed'
 require 'roby/test/distributed'
@@ -43,7 +44,7 @@ class TC_DistributedCommunication < Test::Unit::TestCase
     def setup
 	super
 
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    def remote.install_fake_methods
 		local_peer.local_server.extend FakePeerServerMethods
 	    end
@@ -78,6 +79,17 @@ class TC_DistributedCommunication < Test::Unit::TestCase
 	end
     end
 
+    def disable_logging
+        remote.disable_logging
+        logger = Roby::Distributed.logger
+        old_loglevel = logger.level
+        logger.level = Logger::UNKNOWN
+        yield
+    ensure
+        remote.enable_logging
+        logger.level = old_loglevel
+    end
+
     def test_transmit_error
 	FlexMock.use do |mock|
 	    remote_peer.disable_tx
@@ -85,8 +97,10 @@ class TC_DistributedCommunication < Test::Unit::TestCase
 		mock.block_called
 	    end
 	    mock.should_receive(:block_called).never
-	    remote_peer.enable_tx
-	    assert_raises(Roby::Distributed::DisconnectedError) { remote_peer.synchro_point }
+            disable_logging do
+                remote_peer.enable_tx
+                assert_raises(Roby::Distributed::DisconnectedError) { remote_peer.synchro_point }
+            end
 
 	    assert(!remote_peer.connected?)
 	end
@@ -117,24 +131,26 @@ class TC_DistributedCommunication < Test::Unit::TestCase
     end
 
     def test_call_raises
-	Roby.logger.level = Logger::FATAL
-	assert_raises(RuntimeError) do
-	    remote_peer.call(:reply_error, 2)
-	end
+        disable_logging do
+            assert_raises(RuntimeError) do
+                remote_peer.call(:reply_error, 2)
+            end
+        end
     end
 
     def test_call_disconnects
-	Roby.logger.level = Logger::FATAL
 	remote_peer.disable_tx
 
 	remote_peer.transmit(:reply_error, 2)
 	sleep(0.5)
 
-	Thread.new do
-	    sleep(0.5)
-	    remote_peer.enable_tx
-	end
-	assert_raises(DisconnectedError) { remote_peer.call(:reply, nil, 42) }
+        disable_logging do
+            Thread.new do
+                sleep(0.5)
+                remote_peer.enable_tx
+            end
+            assert_raises(DisconnectedError) { remote_peer.call(:reply, nil, 42) }
+        end
     end
 
     def test_callback
@@ -149,8 +165,9 @@ class TC_DistributedCommunication < Test::Unit::TestCase
     end
 
     def test_recursive_callbacks
-	Roby.logger.level = Logger::FATAL
-	assert_raises(DisconnectedError) { remote_peer.call(:recursive_callbacks) }
+        disable_logging do
+            assert_raises(DisconnectedError) { remote_peer.call(:recursive_callbacks) }
+        end
     end
 
     def test_synchro_point

data/test/distributed/test_connection.rb

@@ -1,4 +1,4 @@
-$LOAD_PATH.unshift File.expand_path('../..', File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
 require 'roby/test/distributed'
 require 'roby/test/tasks/simple_task'
 require 'flexmock'
@@ -14,8 +14,8 @@ class TC_DistributedConnection < Test::Unit::TestCase
 	Distributed.state.wait_discovery
 
 	assert(!Distributed.state.discovering?)
-	assert(1, Distributed.neighbours.size)
-	assert(Distributed.neighbours.find(&check), Distributed.neighbours.map { |n| [n.name, n.remote_id] }.to_s)
+	assert(1, local.neighbours.size)
+	assert(local.neighbours.find(&check), local.neighbours.map { |n| [n.name, n.remote_id] }.to_s)
     end
 
     # Test neighbour discovery using a remote central tuplespace as neighbour list
@@ -31,10 +31,11 @@ class TC_DistributedConnection < Test::Unit::TestCase
 	    central_tuplespace = DRbObject.new_with_uri('druby://localhost:1245')
 
 	    Distributed.state = ConnectionSpace.new :ring_discovery => false, 
-		:discovery_tuplespace => central_tuplespace
+		:discovery_tuplespace => central_tuplespace, :plan => plan
 	end
-	Distributed.state = ConnectionSpace.new :ring_discovery => false, 
-	    :discovery_tuplespace => central_tuplespace
+	@local = ConnectionSpace.new :ring_discovery => false, 
+	    :discovery_tuplespace => central_tuplespace, :plan => plan
+        Distributed.state = local
 	assert_has_neighbour { |n| n.name == "#{Socket.gethostname}-#{remote_pid}" }
     end
 
@@ -45,12 +46,13 @@ class TC_DistributedConnection < Test::Unit::TestCase
 
 	remote_pid = remote_process do
 	    DRb.start_service
-	    Distributed.state = ConnectionSpace.new :period => 0.5, :ring_discovery => true, :ring_broadcast => BROADCAST
+	    Distributed.state = ConnectionSpace.new :period => 0.5, :ring_discovery => true, :ring_broadcast => BROADCAST, :plan => plan
 	    Distributed.publish :bind => '127.0.0.2'
 	end
 
 	DRb.start_service
-	Distributed.state = ConnectionSpace.new :period => 0.5, :ring_discovery => true, :ring_broadcast => BROADCAST
+        @local = ConnectionSpace.new :period => 0.5, :ring_discovery => true, :ring_broadcast => BROADCAST, :plan => plan
+	Distributed.state = local
 	Distributed.publish :bind => '127.0.0.1'
 
 	assert_has_neighbour { |n| n.name == "#{Socket.gethostname}-#{remote_pid}" }
@@ -60,10 +62,10 @@ class TC_DistributedConnection < Test::Unit::TestCase
     # Note that #peer2peer is the exact same process
     def test_connect(standalone = true)
 	if standalone
-	    start_peers(true)
+	    start_peers
 
 	    notified = []
-	    Distributed.on_neighbour do |n|
+	    local.on_neighbour do |n|
 		notified << n
 	    end
 	end
@@ -71,24 +73,24 @@ class TC_DistributedConnection < Test::Unit::TestCase
 	assert(local.discovery_thread)
 
 	# Initiate the connection from +local+
-	remote_neighbour = Distributed.neighbours.find { true }
-	Roby.execute do
+	remote_neighbour = local.neighbours.find { true }
+	engine.execute do
 	    did_yield = nil
 	    Peer.initiate_connection(local, remote_neighbour) do |did_yield|
 	    end
 
 	    # Wait for the remote peer to take into account the fact that we
 	    # try connecting
-	    Distributed.state.synchronize do
+	    local.synchronize do
 		remote_id = remote_neighbour.remote_id
-		assert(Distributed.state.pending_connections[remote_id] ||
-		       Distributed.state.peers[remote_id])
+		assert(local.pending_connections[remote_id] ||
+		       local.peers[remote_id])
 	    end
 
 	    sleep(1)
-	    Distributed.state.synchronize do
+	    local.synchronize do
 		remote_id = remote_neighbour.remote_id
-		assert(@remote_peer = Distributed.state.peers[remote_id], Distributed.state.peers)
+		assert(@remote_peer = local.peers[remote_id], local.peers)
 		assert_equal(remote_peer, did_yield)
 	    end
 	    assert(remote_peer.connected?)
@@ -103,7 +105,7 @@ class TC_DistributedConnection < Test::Unit::TestCase
 	    assert_equal(remote_peer, Peer.connect(remote_neighbour))
 	end
 
-	Roby.control.wait_one_cycle
+	engine.wait_one_cycle
 	assert(remote_peer.task.running?)
 	#assert_raises(ArgumentError) { Peer.initiate_connection(local, remote_neighbour) }
 	assert(remote_peer.link_alive?)
@@ -123,7 +125,7 @@ class TC_DistributedConnection < Test::Unit::TestCase
     end
 
     def test_synchronous_connect
-	start_peers(true) do |remote|
+	start_peers do |remote|
 	    def remote.connected?
 		local_peer.connected?
 	    end
@@ -140,7 +142,7 @@ class TC_DistributedConnection < Test::Unit::TestCase
 
     def test_concurrent_connection
 	GC.disable
-	start_peers(true) do |remote|
+	start_peers do |remote|
 	    class << remote
 		def find_neighbour
 		    @neighbour = Roby::Distributed.neighbours.find { true }
@@ -197,11 +199,11 @@ class TC_DistributedConnection < Test::Unit::TestCase
 
     # Test the normal disconnection process
     def test_disconnect
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    def remote.peers_empty?; Distributed.peers.empty? end
 	end
 
-	Roby.control.wait_one_cycle
+	engine.wait_one_cycle
 	assert(remote_peer.task.ready?)
 
 	remote_peer.disconnect
@@ -223,7 +225,7 @@ class TC_DistributedConnection < Test::Unit::TestCase
     # Tests that the remote peer disconnects if #demux raises DisconnectedError
     def test_disconnect_on_error
 	Roby.logger.level = Logger::FATAL
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    class << remote
 		include Test::Unit::Assertions
 		def assert_demux_raises
@@ -246,7 +248,7 @@ class TC_DistributedConnection < Test::Unit::TestCase
     end
 
     def test_socket_reconnect
-	peer2peer(true)
+	peer2peer
 	Distributed.state.synchronize do
 	    remote_peer.socket.close
 	    assert(!remote_peer.link_alive?)
@@ -261,7 +263,7 @@ class TC_DistributedConnection < Test::Unit::TestCase
     end
 
     def test_remote_dies
-	peer2peer(true)
+	peer2peer
 	Process.kill('KILL', remote_processes[1][0])
 
 	sleep(1)
@@ -270,7 +272,7 @@ class TC_DistributedConnection < Test::Unit::TestCase
 
 
     def test_abort_connection
-	peer2peer(true)
+	peer2peer
 	remote_peer.disconnected!
 
 	sleep(1)

data/test/distributed/test_execution.rb

@@ -1,4 +1,4 @@
-$LOAD_PATH.unshift File.expand_path('../..', File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
 require 'roby/test/distributed'
 require 'roby/test/tasks/simple_task'
 require 'flexmock'
@@ -7,22 +7,27 @@ class TC_DistributedExecution < Test::Unit::TestCase
     include Roby::Distributed::Test
     SimpleTask = Roby::Test::SimpleTask
 
+    def setup
+        super
+        Roby.app.filter_backtraces = false
+    end
+
     def test_event_status
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    class << remote
 		attr_reader :controlable
 		attr_reader :contingent
 		def create
 		    # Put the task to avoir having GC clearing the events
-		    plan.insert(t = SimpleTask.new(:id => 'task'))
-		    plan.discover(@controlable = Roby::EventGenerator.new(true))
-		    plan.discover(@contingent = Roby::EventGenerator.new(false))
-		    t.on(:start, controlable)
-		    t.forward(:start, contingent)
+		    plan.add_mission(t = SimpleTask.new(:id => 'task'))
+		    plan.add(@controlable = Roby::EventGenerator.new(true))
+		    plan.add(@contingent = Roby::EventGenerator.new(false))
+		    t.signals(:start, controlable, :start)
+		    t.forward_to(:start, contingent, :start)
 		    nil
 		end
 		def fire
-		    Roby.execute do
+		    engine.execute do
 			controlable.call(nil) 
 			contingent.emit(nil)
 		    end
@@ -38,10 +43,10 @@ class TC_DistributedExecution < Test::Unit::TestCase
 
 	FlexMock.use do |mock|
 	    controlable.on do
-		mock.fired_controlable(Roby::Propagation.gathering?)
+		mock.fired_controlable(engine.gathering?)
 	    end
 	    contingent.on do
-		mock.fired_contingent(Roby::Propagation.gathering?)
+		mock.fired_contingent(engine.gathering?)
 	    end
 
 	    mock.should_receive(:fired_controlable).with(true).once
@@ -55,13 +60,13 @@ class TC_DistributedExecution < Test::Unit::TestCase
     end
 
     def test_signal_establishment
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    Roby::Distributed.on_transaction do |trsc|
 		trsc.edit do
 		    local_task = trsc.find_tasks.which_fullfills(Roby::Test::SimpleTask).to_a.first
 		    t = trsc[SimpleTask.new(:id => 'remote_task')]
-		    local_task.realized_by t
-		    local_task.on :start, t, :start
+		    local_task.depends_on t
+		    local_task.signals :start, t, :start
 		    nil
 		end
 	    end
@@ -71,42 +76,42 @@ class TC_DistributedExecution < Test::Unit::TestCase
 	trsc.add_owner remote_peer
 	trsc.propose(remote_peer)
 
-	plan.insert(local_task = Roby::Test::SimpleTask.new)
+	plan.add_mission(local_task = Roby::Test::SimpleTask.new)
 	trsc[local_task]
 	trsc.release
 	trsc.edit
 	trsc.commit_transaction
 
-	Roby.execute { local_task.start! }
-	Roby.wait_one_cycle
+	engine.execute { local_task.start! }
+	engine.wait_one_cycle
 	remote_peer.synchro_point
 	remote_task = subscribe_task(:id => 'remote_task')
 	assert(remote_task.running?)
 
-	Roby.execute do
-	    plan.discard(local_task)
+	engine.execute do
+	    plan.unmark_mission(local_task)
 	    local_task.stop!
 	end
     end
 
     # This test that the event/plan modification order is kept on a remote host
     def test_keeps_causality
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    class << remote
 		attr_reader :event
 		attr_reader :task
 		def create
 		    # Put the task to avoir having GC clearing the events
-		    plan.insert(@task = SimpleTask.new(:id => 'task'))
-		    plan.discover(@event = Roby::EventGenerator.new(true))
-		    event.on task.event(:start)
+		    plan.add_mission(@task = SimpleTask.new(:id => 'task'))
+		    plan.add(@event = Roby::EventGenerator.new(true))
+		    event.signals task.event(:start)
 		    nil
 		end
 		def fire
-		    Roby.execute do
+		    engine.execute do
 			event.on do
-			    plan.discard(task)
-			    task.event(:start).on task.event(:success)
+			    plan.unmark_mission(task)
+			    task.event(:start).signals task.event(:success)
 			end
 		
 			event.call(nil) 
@@ -135,20 +140,20 @@ class TC_DistributedExecution < Test::Unit::TestCase
     end
 
     def test_task_status
-	Roby.control.abort_on_exception = false
-	peer2peer(true) do |remote|
+	Roby.app.abort_on_exception = false
+	peer2peer do |remote|
 	    class << remote
 		include Test::Unit::Assertions
 		attr_reader :task
 		def create_task
 		    plan.clear
-		    plan.insert(@task = SimpleTask.new(:id => 1))
+		    plan.add_mission(@task = SimpleTask.new(:id => 1))
 		end
-		def start_task; Roby::Control.once { task.start! }; nil end
+		def start_task; engine.once { task.start! }; nil end
 		def stop_task
 		    assert(task.executable?)
-		    Roby::Control.once do
-			plan.discard(task)
+		    engine.once do
+			plan.unmark_mission(task)
 			task.stop!
 		    end
 		    nil
@@ -180,8 +185,8 @@ class TC_DistributedExecution < Test::Unit::TestCase
     end
 
     def test_signalling
-	peer2peer(true) do |remote|
-	    remote.plan.insert(task = SimpleTask.new(:id => 1))
+	peer2peer do |remote|
+	    remote.plan.add_mission(task = SimpleTask.new(:id => 1))
 	    remote.class.class_eval do
 		include Test::Unit::Assertions
 		define_method(:start_task) do
@@ -191,7 +196,7 @@ class TC_DistributedExecution < Test::Unit::TestCase
 		    assert(fev = events.find { |ev| !ev.controlable? })
 		    assert(task.event(:start).child_object?(sev, Roby::EventStructure::Signal))
 		    assert(task.event(:start).child_object?(fev, Roby::EventStructure::Forwarding))
-		    Control.once { task.start! }
+		    engine.once { task.start! }
 		    nil
 		end
 	    end
@@ -210,8 +215,8 @@ class TC_DistributedExecution < Test::Unit::TestCase
 	    forwarded_ev.on { |ev| mock.forward_emitted }
 	    assert(!forwarded_ev.controlable?)
 
-	    p_task.event(:start).on signalled_ev
-	    p_task.event(:start).forward forwarded_ev
+	    p_task.event(:start).signals signalled_ev
+	    p_task.event(:start).forward_to forwarded_ev
 
 	    mock.should_receive(:signal_command).once.ordered('signal')
 	    mock.should_receive(:signal_emitted).once.ordered('signal')
@@ -226,11 +231,11 @@ class TC_DistributedExecution < Test::Unit::TestCase
     end
 
     def test_event_handlers
-	peer2peer(true) do |remote|
-	    remote.plan.insert(task = SimpleTask.new(:id => 1))
+	peer2peer do |remote|
+	    remote.plan.add_mission(task = SimpleTask.new(:id => 1))
 	    def remote.start(task)
 		task = local_peer.local_object(task)
-		Roby::Control.once { task.start! }
+		engine.once { task.start! }
 		nil
 	    end
 	end
@@ -249,13 +254,13 @@ class TC_DistributedExecution < Test::Unit::TestCase
     # Test that we can 'forget' running tasks that was known to us because they
     # were related to subscribed tasks
     def test_forgetting
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    parent, child =
 		SimpleTask.new(:id => 'parent'), 
 		SimpleTask.new(:id => 'child')
-	    parent.realized_by child
+	    parent.depends_on child
 
-	    remote.plan.insert(parent)
+	    remote.plan.add_mission(parent)
 	    child.start!
 	    remote.singleton_class.class_eval do
 		define_method(:remove_link) do
@@ -277,11 +282,11 @@ class TC_DistributedExecution < Test::Unit::TestCase
     # Tests that running remote tasks are aborted and pending tasks GCed if the
     # connection is killed
     def test_disconnect_kills_tasks
-	peer2peer(true) do |remote|
-	    remote.plan.insert(task = SimpleTask.new(:id => 'remote-1'))
+	peer2peer do |remote|
+	    remote.plan.add_mission(task = SimpleTask.new(:id => 'remote-1'))
 	    def remote.start(task)
 		task = local_peer.local_object(task)
-		Roby.execute do
+		engine.execute do
 		    task.start!
 		end
 		nil
@@ -295,7 +300,7 @@ class TC_DistributedExecution < Test::Unit::TestCase
 	assert(task.child_object?(remote_peer.task, TaskStructure::ExecutionAgent))
 	assert(task.subscribed?)
 
-	Roby.execute do
+	engine.execute do
 	    remote_peer.disconnected!
 	end
 	assert(!task.subscribed?)
@@ -321,12 +326,12 @@ class TC_DistributedExecution < Test::Unit::TestCase
     end
 
     def test_code_blocks_owners
-	peer2peer(true) do |remote|
-	    remote.plan.insert(CodeBlocksOwnersMockup.new(:id => 'mockup'))
+	peer2peer do |remote|
+	    remote.plan.add_mission(CodeBlocksOwnersMockup.new(:id => 'mockup'))
 
 	    def remote.call
 		task = plan.find_tasks(CodeBlocksOwnersMockup).to_a.first
-		Roby.execute { task.start! }
+		engine.execute { task.start! }
 	    end
 
 	    def remote.blocks_called
@@ -348,17 +353,17 @@ class TC_DistributedExecution < Test::Unit::TestCase
     # Checks that we get the update fine if +fired+ and +signalled+ are
     # received in the same cycle
     def test_joint_fired_signalled
-	peer2peer(true) do |remote|
-	    remote.plan.insert(task = SimpleTask.new(:id => 'remote-1'))
-	    Roby::Control.once { task.start! }
+	peer2peer do |remote|
+	    remote.plan.add_mission(task = SimpleTask.new(:id => 'remote-1'))
+	    engine.once { task.start! }
 	end
 	    
 	event_time = Time.now
 	remote = subscribe_task(:id => 'remote-1')
-	plan.insert(local = SimpleTask.new(:id => 'local'))
+	plan.add_mission(local = SimpleTask.new(:id => 'local'))
 	remote_peer.synchro_point
 
-	Roby.execute do
+	engine.execute do
 	    remote_peer.local_server.event_fired(remote.event(:success), 0, Time.now, [42])
 	    remote_peer.local_server.event_add_propagation(true, remote.event(:success), local.event(:start), 0, event_time, [42])
 	end