roby 0.7

data/test/distributed/test_mixed_plan.rb

@@ -0,0 +1,341 @@
+$LOAD_PATH.unshift File.expand_path('../..', File.dirname(__FILE__))
+require 'roby/test/distributed'
+require 'roby/test/tasks/simple_task'
+
+# This testcase tests buildings plans where local tasks are interacting with remote tasks
+#
+# Naming scheme:
+#   test_r<type of remote object>_realizes_l<type of local object>(_dynamic)
+#
+# For instance,  test_rproxy_realizes_lproxy means that we are building a
+# transaction where a remote transaction proxy is linked to a local transaction
+# proxy. If _dynamic is appended, #propose is called when the transaction is still
+# empty. Otherwise, #propose is called after all modifications have been put into
+# the transaction (propose then build or build then propose)
+#
+# The transaction is always built locally
+class TC_DistributedMixedPlan < Test::Unit::TestCase
+    include Roby::Distributed::Test
+
+    # Creates in +plan+ a task which is a child in a realized_by relation and a parent
+    # in a planned_by relation. All tasks have an ID of "#{name}-#{number}", with
+    # 2 for the central task, 1 for its parent task and 3 for its planning task.
+    #
+    # Returns [-1, -2, -3]
+    def add_tasks(plan, name)
+	t1, t2, t3 = (1..3).map { |i| SimpleTask.new(:id => "#{name}-#{i}") }
+	t1.realized_by t2
+	t2.planned_by t3
+	plan.insert(t1)
+	plan.discover(t2)
+	plan.discover(t3)
+
+	[t1, t2, t3]
+    end
+
+    def check_local_center_structure(node, removed_planner)
+	if node.respond_to?(:__getobj__)
+	    assert_equal(["remote-2"], node.parents.map { |obj| obj.arguments[:id] })
+	else
+	    assert_equal(["local-1", "remote-2"].to_set, node.parents.map { |obj| obj.arguments[:id] }.to_set)
+	    unless removed_planner
+		assert_equal(["local-3"], node.enum_for(:each_planning_task).map { |obj| obj.arguments[:id] })
+	    end
+	end
+    end
+
+    def check_remote_center_structure(node, removed_planner)
+	assert_equal(["local-2"], node.children.map { |obj| obj.arguments[:id] })
+	unless node.respond_to?(:__getobj__)
+	    assert_equal(["remote-1"], node.parents.map { |obj| obj.arguments[:id] })
+	    unless removed_planner
+		assert_equal(["remote-3"], node.enum_for(:each_planning_task).map { |obj| obj.arguments[:id] })
+	    end
+	end
+    end
+
+    # Checks that +plan+ has all 6 tasks with remote-2 and local-2 linked as
+    # expected +plan+ may be either the transaction or the plan
+    #
+    # Tests are in two parts: first we build the transaction and check the
+    # relations of the resulting proxies. Then, we remove all relations of
+    # tasks *in the plan*.  Since we have added a realized_by between the
+    # central tasks, the realized_by relations are kept inside the transaction.
+    # However, this is not the case for planning relations.  Thus, the planning
+    # relation does not exist anymore in the transaction after they have been
+    # removed from the plan.
+    def check_resulting_plan(plan, removed_planner)
+	assert(remote_center_node = plan.known_tasks.find { |t| t.arguments[:id] == "remote-2" }, plan.known_tasks)
+	check_remote_center_structure(remote_center_node, removed_planner)
+	assert(local_center_node  = plan.known_tasks.find { |t| t.arguments[:id] == "local-2" }, plan.known_tasks)
+	check_local_center_structure(local_center_node, removed_planner)
+    end
+
+    def assert_cleared_relations(plan)
+	if remote_center_node = plan.known_tasks.find { |t| t.arguments[:id] == "remote-2" }
+	    assert_equal([], remote_center_node.enum_for(:each_planning_task).to_a)
+	end
+
+	if local_center_node = plan.known_tasks.find { |t| t.arguments[:id] == "local-2" }
+	    assert_equal([], local_center_node.enum_for(:each_planning_task).to_a)
+	end
+    end
+
+    # Common setup of the remote peer
+    def common_setup(propose_first)
+	peer2peer(true) do |remote|
+	    testcase = self
+	    remote.singleton_class.class_eval do
+		define_method(:add_tasks) do |plan|
+		    plan = local_peer.proxy(plan)
+		    plan.edit do
+			testcase.add_tasks(plan, "remote") 
+		    end
+		end
+		define_method(:check_resulting_plan) do |plan, removed_planner|
+		    plan = local_peer.proxy(plan)
+		    plan.edit do
+			testcase.check_resulting_plan(local_peer.proxy(plan), removed_planner) 
+		    end
+		end
+		define_method(:assert_cleared_relations) do |plan|
+		    plan = local_peer.proxy(plan)
+		    plan.edit do
+			testcase.assert_cleared_relations(local_peer.proxy(plan))
+		    end
+		end
+		def remove_relations(t2)
+		    plan.edit do
+			t2 = local_peer.local_object(t2)
+			raise unless t3 = t2.planning_task
+			t2.remove_planning_task(t3)
+		    end
+		end
+		def subscribe(remote_task)
+		    local_peer.subscribe(remote_task)
+		end
+	    end
+	end
+
+	# Create the transaction, and do the necessary modifications
+	trsc = Distributed::Transaction.new(plan, :conflict_solver => SolverIgnoreUpdate.new)
+
+	trsc.add_owner remote_peer
+	trsc.self_owned
+	trsc.propose(remote_peer) if propose_first
+
+	yield(trsc)
+
+	# Check the transaction is still valid, regardless of the
+	# changes we made to the plan
+	check_resulting_plan(trsc, true)
+	trsc.release(false)
+	remote.check_resulting_plan(Distributed.format(trsc), true)
+	trsc.edit
+
+	# Commit and check the result
+	trsc.commit_transaction
+
+	check_resulting_plan(plan, true)
+	remote.check_resulting_plan(Distributed.format(plan), true)
+    end
+
+    def test_rproxy_realizes_lproxy(propose_first = false)
+	common_setup(propose_first) do |trsc|
+	    # First, add relations between two nodes that are already existing
+	    remote.add_tasks(Distributed.format(plan))
+	    r_t2 = subscribe_task(:id => 'remote-2')
+	    assert(1, r_t2.parents.to_a.size)
+	    r_t1 = r_t2.parents.find { true }
+	    t1, t2, t3 = Control.synchronize { add_tasks(plan, "local") }
+
+	    assert(plan.useful_task?(r_t1))
+	    trsc[r_t2].realized_by trsc[t2]
+	    trsc[r_t2].on(:start, trsc[t2])
+	    assert(plan.useful_task?(r_t1))
+	    check_resulting_plan(trsc, false)
+	    if propose_first
+		trsc.release(false)
+		remote.check_resulting_plan(Distributed.format(trsc), false)
+		trsc.edit
+	    end
+
+	    # Remove the relations in the real tasks (not the proxies)
+	    Control.synchronize do
+		t2.remove_planning_task(t3)
+	    end
+	    remote.remove_relations(Distributed.format(r_t2))
+	    remote.subscribe(Distributed.format(t2))
+
+	    process_events
+	    assert(plan.useful_task?(r_t1))
+	    assert_cleared_relations(plan)
+
+	    unless propose_first
+		trsc.propose(remote_peer)
+	    end
+
+	    process_events
+	    remote.assert_cleared_relations(Distributed.format(plan))
+	end
+    end
+    def test_rproxy_realizes_lproxy_dynamic; test_rproxy_realizes_lproxy(true) end
+
+    def test_rproxy_realizes_ltask(propose_first = false)
+	common_setup(propose_first) do |trsc|
+	    remote.add_tasks(Distributed.format(plan))
+	    r_t2 = subscribe_task(:id => 'remote-2')
+	    t1, t2, t3 = Control.synchronize { add_tasks(trsc, "local") }
+
+	    trsc[r_t2].realized_by t2
+	    trsc[r_t2].on(:start, t2)
+	    check_resulting_plan(trsc, false)
+	    process_events
+	    if propose_first
+		remote_peer.push_subscription(t2)
+		trsc.release(false)
+		remote.check_resulting_plan(Distributed.format(trsc), false)
+		trsc.edit
+	    end
+
+	    # remove the relations in the real tasks (not the proxies)
+	    remote.remove_relations(Distributed.format(r_t2))
+
+	    unless propose_first
+		trsc.propose(remote_peer)
+		remote_peer.push_subscription(t2)
+	    end
+	    process_events
+	    remote.assert_cleared_relations(Distributed.format(plan))
+	end
+    end
+    def test_rproxy_realizes_ltask_dynamic; test_rproxy_realizes_ltask(true) end
+
+    # no non-dynamic version for that since we need the transactio to be
+    # present on both sides if we want to have remote tasks in it
+    def test_rtask_realizes_lproxy
+	common_setup(true) do |trsc|
+	    trsc.release(false)
+	    r_t1, r_t2, r_t3 = remote.add_tasks(Distributed.format(trsc)).map { |t| remote_peer.proxy(t) }
+	    trsc.edit
+
+	    assert(r_t2.subscribed?)
+	    t1, t2, t3 = Control.synchronize { add_tasks(plan, "local") }
+	    r_t2.realized_by trsc[t2]
+	    r_t2.on(:start, trsc[t2])
+	    remote_peer.subscribe(r_t2)
+	    remote_peer.push_subscription(t2)
+
+	    check_resulting_plan(trsc, false)
+	    trsc.release(false)
+	    remote.check_resulting_plan(Distributed.format(trsc), false)
+	    trsc.edit
+
+	    # remove the relations in the real tasks (not the proxies)
+	    t2.remove_planning_task(t3)
+	    process_events
+	    remote.assert_cleared_relations(Distributed.format(plan))
+	end
+    end
+
+    def test_garbage_collect
+	peer2peer(true) do |remote|
+	    remote.plan.insert(SimpleTask.new(:id => 'remote-1'))
+	    def remote.insert_children(trsc, root_task)
+		trsc = local_peer.local_object(trsc)
+		root_task = local_peer.local_object(root_task)
+		trsc.edit
+
+		root_task.realized_by(r2 = SimpleTask.new(:id => 'remote-2'))
+		r2.realized_by(r3 = SimpleTask.new(:id => 'remote-3'))
+		trsc.release(false)
+	    end
+	end
+
+	r1 = subscribe_task(:id => 'remote-1')
+	assert(!plan.unneeded_tasks.include?(r1))
+
+	t1 = SimpleTask.new
+
+	# Add a local child to r1. This local child, and r1, must be kept event
+	# we are not subscribed to r1 anymore
+	trsc = Distributed::Transaction.new(plan)
+	trsc.add_owner(remote_peer)
+	trsc[r1].realized_by t1
+	Roby::Control.synchronize do
+	    remote_peer.unsubscribe(r1)
+	    assert(!plan.unneeded_tasks.include?(r1))
+	end
+
+	trsc.propose(remote_peer)
+	trsc.commit_transaction
+	assert(!plan.unneeded_tasks.include?(r1))
+	assert(!plan.unneeded_tasks.include?(t1), plan.unneeded_tasks)
+
+	# Ok, we now create a r1 => t1 => t2 => t3 chain
+	#   * t2 and t3 are kept because they are useful for r1
+	t2, t3 = nil
+	Roby::Control.synchronize do
+	    t1.realized_by(t2 = SimpleTask.new)
+	    assert(!plan.unneeded_tasks.include?(t2))
+	    t2.realized_by(t3 = SimpleTask.new)
+	    assert(!plan.unneeded_tasks.include?(t3))
+	end
+
+	# Now, create a t3 => r2 => r3 chain
+	# * r2 should be kept since it is related to a task which is kept
+	# * r3 should not be kept
+	trsc = Distributed::Transaction.new(plan)
+	trsc.add_owner(remote_peer)
+	trsc.propose(remote_peer)
+	trsc.release
+	remote.insert_children(Distributed.format(trsc), Distributed.format(trsc[t3]))
+	trsc.edit
+	trsc.commit_transaction
+	process_events
+
+	r2 = remote_task(:id => 'remote-2')
+	Roby::Control.synchronize do
+	    assert(r2.plan && !plan.unneeded_tasks.include?(r2))
+	    assert(t3.child_object?(r2, TaskStructure::Hierarchy))
+	end
+
+	r3 = remote_task(:id => 'remote-3')
+	Roby::Control.synchronize do
+	    assert(!r3.plan || plan.unneeded_tasks.include?(r3))
+	end
+    end
+
+    # This tests that the race condition between transaction commit and plan GC
+    # is handled properly: if a task inside a transaction will be GCed just
+    # after the commit, there is a race condition possibility if the other
+    # peers do not have committed the transaction yet
+    def test_commit_race_condition
+	peer2peer(true) do |remote|
+	    def remote.add_task(trsc)
+		trsc = local_peer.local_object(trsc)
+		trsc.edit
+		trsc.discover(SimpleTask.new(:id => 'remote'))
+		trsc.release(false)
+	    end
+	end
+	
+	# Create an empty transaction and send it to our peer
+	# The peer will then discover a task, which 
+	# will be GCed as soon as the transaction is committed
+	trsc = Distributed::Transaction.new(plan)
+	trsc.add_owner(remote_peer)
+	trsc.propose(remote_peer)
+	trsc.release
+	remote.add_task(Distributed.format(trsc))
+	trsc.edit
+	
+	assert_nothing_raised do
+	    trsc.commit_transaction
+	    process_events
+	end
+	assert(remote_peer.connected?)
+    end
+end
+
+

data/test/distributed/test_plan_notifications.rb

@@ -0,0 +1,238 @@
+$LOAD_PATH.unshift File.expand_path('../..', File.dirname(__FILE__))
+require 'roby/test/distributed'
+require 'roby/test/tasks/simple_task'
+require 'flexmock'
+
+class TC_DistributedPlanNotifications < Test::Unit::TestCase
+    include Roby::Distributed::Test
+
+    def test_triggers
+	peer2peer(true) do |remote|
+	    def remote.new_task(kind, args)
+		Roby.execute do
+		    new_task = kind.proxy(local_peer).new(args)
+		    yield(new_task.remote_id) if block_given?
+		    plan.insert(new_task)
+		end
+		nil
+	    end
+	end
+
+	notification = TaskMatcher.new.
+	    with_model(SimpleTask).
+	    with_arguments(:id => 2)
+
+	FlexMock.use do |mock|
+	    remote_peer.on(notification) do |task|
+		assert(plan.useful_task?(task))
+		assert(task.plan)
+		mock.notified(task.sibling_on(remote_peer))
+		nil
+	    end
+
+	    simple_task = Distributed.format(SimpleTask)
+	    roby_task   = Distributed.format(Roby::Task)
+
+	    remote.new_task(simple_task, :id => 3)
+	    remote.new_task(roby_task, :id => 2)
+	    remote.new_task(simple_task, :id => 2) do |inserted_id|
+		mock.should_receive(:notified).with(inserted_id).once.ordered
+		nil
+	    end
+
+	    remote.new_task(simple_task, :id => 3)
+	    remote.new_task(roby_task, :id => 2)
+	    remote.new_task(simple_task, :id => 2) do |inserted_id|
+		mock.should_receive(:notified).with(inserted_id).once.ordered
+		nil
+	    end
+
+	    remote_peer.synchro_point
+	end
+    end
+
+    def test_trigger_subscribe
+	peer2peer(true) do |remote|
+	    def remote.new_task
+		plan.insert(SimpleTask.new(:id => 1))
+		nil
+	    end
+	end
+
+	notification = TaskMatcher.new.
+	    with_model(SimpleTask).
+	    with_arguments(:id => 1)
+
+	task = nil
+	remote_peer.on(notification) do |t|
+	    remote_peer.subscribe(t)
+	    task = t
+	end
+	remote.new_task
+	while !task
+	    remote_peer.synchro_point
+	end
+
+	assert(task)
+	assert_equal([task], plan.find_tasks.with_arguments(:id => 1).to_a)
+    end
+
+    def test_subscribe_plan
+	peer2peer(true) do |remote|
+	    plan.insert(mission = Task.new(:id => 'mission'))
+	    subtask = Task.new :id => 'subtask'
+	    plan.insert(next_mission = Task.new(:id => 'next_mission'))
+	    mission.realized_by subtask
+	    mission.on(:start, next_mission, :start)
+	end
+
+	# Subscribe to the remote plan
+	remote_peer.subscribe_plan
+	assert(remote_peer.subscribed_plan?)
+
+	# Check that the remote plan has been mapped locally
+	process_events
+	tasks = plan.known_tasks
+	assert_equal(4, tasks.size)
+	assert(p_mission = tasks.find { |t| t.arguments[:id] == 'mission' })
+	assert(p_subtask = tasks.find { |t| t.arguments[:id] == 'subtask' })
+	assert(p_next_mission = tasks.find { |t| t.arguments[:id] == 'next_mission' })
+
+	assert(p_mission.child_object?(p_subtask, TaskStructure::Hierarchy))
+	assert(p_mission.event(:start).child_object?(p_next_mission.event(:start), EventStructure::Signal))
+    end
+
+    def test_plan_updates
+	peer2peer(true) do |remote|
+	    class << remote
+		attr_reader :mission, :subtask, :next_mission, :free_event
+		def create_mission
+		    @mission = Roby::Task.new :id => 'mission'
+		    plan.insert(mission)
+		end
+		def create_subtask
+		    plan.permanent(@subtask = Roby::Task.new(:id => 'subtask'))
+		    mission.realized_by subtask
+		end
+		def create_next_mission
+		    @next_mission = Roby::Task.new :id => 'next_mission'
+		    mission.on(:start, next_mission, :start)
+		    plan.insert(next_mission)
+		end
+		def create_free_event
+		    @free_event = Roby::EventGenerator.new(true)
+		    # Link the event to a task to protect it from GC
+		    @next_mission.on(:start, @free_event)
+		    plan.discover(free_event)
+		end
+		def remove_free_event
+		    plan.remove_object(free_event)
+		end
+		def unlink_next_mission; mission.event(:start).remove_signal(next_mission.event(:start)) end
+		def remove_next_mission; plan.remove_object(next_mission) end
+		def unlink_subtask; mission.remove_child(subtask) end
+		def remove_subtask; plan.remove_object(subtask) end
+		def discard_mission 
+		    plan.permanent(mission)
+		    plan.discard(mission) 
+		end
+		def remove_mission; plan.remove_object(mission) end
+	    end
+	end
+
+	# Subscribe to the remote plan
+	remote_peer.subscribe_plan
+
+	remote.create_mission
+	process_events
+	p_mission = remote_task(:id => 'mission')
+	# NOTE: the count is always remote_tasks + 1 since we have the ConnectionTask for our connection
+	assert_equal(2, plan.size, plan.known_tasks.to_a)
+	assert(p_mission.mission?)
+	process_events
+	assert(p_mission.plan)
+
+	remote.create_subtask
+	process_events
+	p_subtask = remote_task(:id => 'subtask')
+	assert_equal(3, plan.size)
+	assert(p_mission.child_object?(p_subtask, TaskStructure::Hierarchy))
+
+	remote.create_next_mission
+	process_events
+	p_next_mission = remote_task(:id => 'next_mission')
+	assert_equal(4, plan.size)
+	assert(p_mission.event(:start).child_object?(p_next_mission.event(:start), EventStructure::Signal))
+
+	remote.create_free_event
+	process_events
+	assert_equal(1, plan.free_events.size)
+	process_events
+	assert_equal(1, plan.free_events.size)
+
+	remote.remove_free_event
+	process_events
+	assert_equal(0, plan.free_events.size)
+
+	remote.unlink_next_mission
+	process_events
+	assert_equal(4, plan.size)
+	assert(!p_mission.event(:start).child_object?(p_next_mission.event(:start), EventStructure::Signal))
+
+	remote.remove_next_mission
+	process_events
+	assert_equal(3, plan.size)
+	assert(!p_next_mission.plan)
+
+	remote.unlink_subtask
+	assert(p_subtask.subscribed?)
+	process_events
+	assert_equal(3, plan.size, plan.known_tasks)
+	assert(!p_mission.child_object?(p_subtask, TaskStructure::Hierarchy))
+
+	remote.remove_subtask
+	process_events
+	assert_equal(2, plan.size)
+	assert(!p_subtask.plan)
+
+	remote.discard_mission
+	process_events
+	assert(!p_mission.mission?)
+
+	remote.remove_mission
+	process_events
+	assert_equal(1, plan.size)
+	assert(!p_mission.plan)
+    end
+
+    def test_unsubscribe_plan
+	peer2peer(true) do |remote|
+	    remote.plan.insert(Task.new(:id => 'remote-1'))
+	    remote.plan.insert(Task.new(:id => 'remote-2'))
+
+	    def remote.new_task
+		plan.insert(Task.new(:id => 'remote-3'))
+	    end
+	end
+
+	remote_peer.subscribe_plan
+	assert_equal(3, plan.size)
+
+	# Subscribe to the remote-1 task and unsubscribe to the plan
+	r1 = *plan.find_tasks.with_arguments(:id => 'remote-1').to_a
+	remote_peer.subscribe(r1)
+
+	remote_peer.unsubscribe_plan
+	assert(!remote_peer.subscribed_plan?)
+
+	# Start plan GC, the subscribed task should remain
+	process_events
+	assert_equal(2, plan.size, plan.known_tasks)
+
+	# Add a new task in the remote plan, check we do not get the updates
+	# anymore
+	remote.new_task
+	process_events
+	assert_equal(2, plan.size)
+    end
+end