roby 0.7

data/lib/roby/distributed/proxy.rb

@@ -0,0 +1,343 @@
+require 'roby'
+require 'roby/distributed/protocol'
+module Roby
+    class BasicObject::DRoby
+        # The set of remote siblings for that object, as known by the peer who
+        # called #droby_dump. This is used to match object identity among plan
+        # managers.
+	attr_reader :remote_siblings
+        # The set of owners for that object.
+        attr_reader :owners
+        # Create a BasicObject::DRoby object with the given information
+	def initialize(remote_siblings, owners)
+	    @remote_siblings, @owners = remote_siblings, owners
+	end
+
+	def remote_siblings_to_s # :nodoc:
+	    "{ " << remote_siblings.map { |peer, id| id.to_s(peer) }.join(", ") << " }"
+	end
+	def owners_to_s # :nodoc:
+	    "[ " << owners.map { |peer| peer.name }.join(", ") << " ]"
+	end
+	def to_s # :nodoc:
+            "#<dRoby:BasicObject#{remote_siblings_to_s} owners=#{owners_to_s}>" 
+        end
+
+        # If we know of a sibling on +peer+, return it. Otherwise, raises RemotePeerMismatch.
+	def sibling_on(peer)
+	    remote_siblings.each do |m_peer, remote_id|
+		if m_peer.peer_id == peer.remote_id
+		    return remote_id
+		end
+	    end
+	    raise RemotePeerMismatch, "#{self} has no known sibling on #{peer}"
+	end
+
+        # Update an existing proxy, using the information stored in this DRoby
+        # object.
+	def update(peer, proxy)
+	    proxy.owners.clear
+	    owners.each do |m_owner|
+		proxy.owners << peer.local_object(m_owner)
+	    end
+
+	    remote_siblings.each do |m_peer_sibling, remote_id|
+		peer_sibling = peer.local_object(m_peer_sibling)
+
+		if current = proxy.remote_siblings[peer_sibling]
+		    if current != remote_id && peer_sibling != Roby::Distributed
+			raise "inconsistency for sibling on #{peer_sibling}: #{proxy} has #{current} while #{self} has #{remote_id}"
+		    end
+		else
+		    proxy.sibling_of(remote_id, peer_sibling)
+		end
+	    end
+	end
+    end
+
+    # Base class for all marshalled plan objects.
+    class PlanObject::DRoby < BasicObject::DRoby
+        # The model for this plan object
+	attr_reader :model
+        # The plan of this object
+        attr_reader :plan
+
+        # Create a DRoby object with the given information.  See also
+        # BasicObject::DRoby
+	def initialize(remote_siblings, owners, model, plan)
+	    super(remote_siblings, owners)
+	    @model, @plan = model, plan
+	end
+
+	def to_s # :nodoc:
+            "#<dRoby:#{model.ancestors.first.first}#{remote_siblings_to_s} plan=#{plan} owners=#{owners_to_s}>" 
+        end
+
+        # Update an existing proxy, using the information stored in this DRoby
+        # object.
+	def update(peer, proxy)
+	    super(peer, proxy)
+
+	    if proxy.root_object?
+		if self.plan
+		    plan = peer.local_object(self.plan)
+		    return if proxy.plan == plan
+		    Distributed.update_all([plan, proxy]) do
+			plan.discover(proxy)
+		    end
+		end
+	    end
+	end
+    end
+
+    class EventGenerator
+	def _dump(lvl) # :nodoc:
+            Marshal.dump(remote_id) 
+        end
+	def self._load(str) # :nodoc:
+            Marshal.load(str) 
+        end
+
+        # Returns an intermediate representation of +self+ suitable to be sent
+        # to the +dest+ peer.
+	def droby_dump(dest)
+	    DRoby.new(remote_siblings.droby_dump(dest), owners.droby_dump(dest),
+		      model.droby_dump(dest),  plan.droby_dump(dest), 
+		      controlable?, happened?)
+	end
+
+        # An intermediate representation of EventGenerator objects suitable to
+        # be sent to our peers.
+	class DRoby < PlanObject::DRoby
+            # True if the generator is controlable
+	    attr_reader :controlable
+            # True if the generator has already been emitted once at the time
+            # EventGenerator#droby_dump has been called.
+            attr_reader :happened
+
+            # Create a DRoby object with the given information.  See also
+            # PlanObject::DRoby
+	    def initialize(remote_siblings, owners, model, plan, controlable, happened)
+		super(remote_siblings, owners, model, plan)
+		@controlable, @happened = controlable, happened
+	    end
+
+            # Create a new proxy which maps the object of +peer+ represented by
+            # this communication intermediate.
+	    def proxy(peer)
+		local_object = peer.local_object(model).new
+		if controlable
+		    local_object.command = lambda { } 
+		end
+		local_object
+	    end
+
+            # Updates an already existing proxy using the information contained
+            # in this object.
+	    def update(peer, proxy)
+		super
+		if happened && !proxy.happened?
+		    proxy.instance_eval { @happened = true }
+		end
+	    end
+	end
+    end
+
+    class TaskEventGenerator
+	def _dump(lvl) # :nodoc:
+            Marshal.dump(remote_id) 
+        end
+	def self._load(str) # :nodoc:
+            Marshal.load(str) 
+        end
+        
+        # Returns an intermediate representation of +self+ suitable to be sent
+        # to the +dest+ peer.
+	def droby_dump(dest)
+	    DRoby.new(controlable?, happened?, Distributed.format(task, dest), symbol)
+	end
+
+        # An intermediate representation of TaskEventGenerator objects suitable
+        # to be sent to our peers.
+	class DRoby
+            # True if the generator is controlable
+            attr_reader :controlable
+            # True if the generator has already emitted once at the time
+            # TaskEventGenerator#droby_dump has been called.
+            attr_reader :happened
+            # An object representing the task of this generator on our remote
+            # peer.
+            attr_reader :task
+            # The event name
+            attr_reader :symbol
+
+            # Create a new DRoby object with the given information
+	    def initialize(controlable, happened, task, symbol)
+		@controlable = controlable
+		@happened = happened
+		@task   = task
+		@symbol = symbol
+	    end
+
+	    def to_s # :nodoc:
+		if task.respond_to?(:model)
+		    "#<dRoby:#{task.model.ancestors.first.first}/#{symbol}#{task.remote_siblings_to_s} task_arguments=#{task.arguments} plan=#{task.plan} owners=#{task.owners_to_s}>"
+		else
+		    "#<dRoby:#{task}/#{symbol}>"
+		end
+	    end
+
+            # Create a new proxy which maps the object of +peer+ represented by
+            # this communication intermediate.
+	    def proxy(peer)
+		task = peer.local_object(self.task)
+		unless task.has_event?(symbol)
+		    Roby::Distributed.debug { "ignoring #{self}: #{symbol} is not known on #{task}" }
+		    Roby::Distributed.ignore!
+		end
+		event = task.event(symbol)
+		
+		if happened && !event.happened?
+		    event.instance_eval { @happened = true }
+		end
+		event
+	    end
+	end
+    end
+
+    class Task
+	def _dump(lvl) # :nodoc:
+            Marshal.dump(remote_id) 
+        end
+	def self._load(str) # :nodoc:
+            Marshal.load(str) 
+        end
+        
+        # Returns an intermediate representation of +self+ suitable to be sent
+        # to the +dest+ peer.
+	def droby_dump(dest)
+	    DRoby.new(remote_siblings.droby_dump(dest), owners.droby_dump(dest),
+		      model.droby_dump(dest),  plan.droby_dump(dest), 
+		      Distributed.format(arguments, dest), Distributed.format(data, dest),
+		      :mission => mission?, :started => started?, 
+		      :finished => finished?, :success => success?)
+	end
+
+        # An intermediate representation of Task objects suitable
+        # to be sent to our peers.
+	class DRoby < PlanObject::DRoby
+            # The set of dRoby-formatted arguments
+	    attr_reader :arguments
+            # The task's internal data
+            attr_reader :data
+            # A set of boolean flags which describe the task's status. It is a
+            # symbol => bool flag where the following parameters are save:
+            # started:: if the task has started
+            # finished:: if the task has finished
+            # success:: if the task has finished with success
+            # mission:: if the task is a mission in its plan
+            attr_reader :flags
+
+            # Create a new DRoby object with the given information
+            # See also PlanObject::DRoby.new
+	    def initialize(remote_siblings, owners, model, plan, arguments, data, flags)
+		super(remote_siblings, owners, model, plan)
+		@arguments, @data, @flags = arguments, data, flags
+	    end
+
+	    def to_s # :nodoc:
+		"#<dRoby:#{model.ancestors.first.first}#{remote_siblings_to_s} plan=#{plan} owners=#{owners_to_s} arguments=#{arguments}>"
+	    end
+
+            # Create a new proxy which maps the object of +peer+ represented by
+            # this communication intermediate.
+	    def proxy(peer)
+		arguments = peer.local_object(self.arguments)
+		peer.local_object(model).new(arguments) do
+		    Roby::Distributed.updated_objects << self
+		end
+
+	    ensure
+		Roby::Distributed.updated_objects.delete(self)
+	    end
+
+            # Updates an already existing proxy using the information contained
+            # in this object.
+	    def update(peer, task)
+		super
+
+		task.started  = flags[:started]
+		task.finished = flags[:finished]
+		task.success  = flags[:success]
+
+		if task.mission? != flags[:mission]
+		    plan = peer.local_object(self.plan) || Roby.plan
+		    if plan.owns?(task)
+			if flags[:mission]
+			    plan.insert(task)
+			else
+			    plan.discard(task)
+			end
+		    else
+			task.mission = flags[:mission]
+		    end
+		end
+
+		task.arguments.merge!(peer.proxy(arguments))
+		task.instance_variable_set("@data", peer.proxy(data))
+	    end
+	end
+    end
+
+    class Plan
+        # Returns an intermediate representation of +self+ suitable to be sent
+        # to the +dest+ peer.
+	def droby_dump(dest)
+	    @__droby_marshalled__ ||= DRoby.new(Roby::Distributed.droby_dump(dest), remote_id)
+	end
+
+        # An intermediate representation of Plan objects suitable to be sent to
+        # our peers.
+        #
+        # FIXME: It assumes that the only Plan object sent to the peers is
+        # actually the main plan of the plan manager. We must fix that.
+	class DRoby
+            # The peer which manages this plan
+	    attr_accessor :peer
+            # The plan remote_id
+            attr_accessor :id
+            # Create a DRoby representation of a plan object with the given
+            # parameters
+	    def initialize(peer, id); @peer, @id = peer, id end
+            # Create a new proxy which maps the object of +peer+ represented by
+            # this communication intermediate.
+	    def proxy(peer); peer.connection_space.plan end
+	    def to_s # :nodoc:
+                "#<dRoby:Plan #{id.to_s(peer)}>" 
+            end
+            # The set of remote siblings for that object. This is used to avoid
+            # creating proxies when not needed. See
+            # PlanObject::DRoby#remote_siblings.
+	    def remote_siblings; @remote_siblings ||= Hash[peer, id] end
+            # If +peer+ is the plan's owner, returns #id. Otherwise, raises
+            # RemotePeerMismatch. This is used to avoid creating proxies when not
+            # needed. See BasicObject::DRoby#sibling_on.
+	    def sibling_on(peer)
+		if peer.remote_id == self.peer.peer_id then id
+		else raise RemotePeerMismatch, "no known sibling for #{self} on #{peer}"
+		end
+	    end
+	end
+    end
+
+    module Distributed
+	# Builds a remote proxy model for +object_model+. +object_model+ is
+	# either a string or a class. In the first case, it is interpreted
+	# as a constant name.
+	def self.RemoteProxyModel(object_model)
+	    object_model
+	end
+
+    end
+end
+

data/lib/roby/distributed/subscription.rb

@@ -0,0 +1,311 @@
+
+module Roby
+    module Distributed
+	class << self
+            # Yields the peers which are interested in at least one of the
+            # objects in +objects+.
+	    def each_updated_peer(*objects)
+		for obj in objects
+		    return if !obj.distribute?
+		end
+
+		for _, peer in Distributed.peers
+		    next unless peer.connected?
+		    for obj in objects
+			if obj.update_on?(peer)
+			    yield(peer)
+			    break
+			end
+		    end
+		end
+	    end
+	end
+
+	class PeerServer
+	    # Called by the peer to subscribe on +object+. Returns an array which
+	    # is to be fed to #demux to update the object relations on the remote
+	    # host
+	    #
+	    # In case of distributed transaction, it is forbidden to subscribe to a
+	    # proxy without having subscribed to the proxied object first. This
+	    # method will thus subscribe to both at the same time. Peer#subscribe
+	    # is supposed to do the same
+	    def subscribe_plan_object(object)
+		if Transactions::Proxy === object && object.__getobj__.self_owned?
+		    subscribe_plan_object(object.__getobj__)
+		end
+		set_relations_commands(object)
+	    end
+
+	    # The peer wants to subscribe to our main plan
+	    def subscribe_plan(sibling)
+		added_sibling(Roby.plan.remote_id, sibling)
+		peer.transmit(:subscribed_plan, Roby.plan.remote_id)
+		subscribe(Roby.plan)
+	    end
+
+	    # Called by our peer because it has subscribed us to its main plan
+	    def subscribed_plan(remote_plan_id)
+		peer.proxies[remote_plan_id] = Roby.plan
+		peer.remote_plan = remote_plan_id
+	    end
+
+	    # Subscribe the remote peer to changes on +object+. +object+ must be
+	    # an object owned locally.
+	    def subscribe(m_object)
+		if !(local_object = peer.local_object(m_object, false))
+		    raise OwnershipError, "no object for #{m_object}"
+		elsif !local_object.self_owned?
+		    raise OwnershipError, "not owner of #{local_object}"
+		end
+
+		# We put the subscription process outside the communication
+		# thread so that the remote peer can send back the siblings it
+		# has created
+		peer.queueing do
+		    peer.transmit(:subscribed, [local_object])
+
+		    case local_object
+		    when PlanObject
+			if !local_object.root_object?
+			    raise ArgumentError, "cannot subscribe to non-root objects"
+			end
+			subscribe_plan_object(local_object)
+
+		    when Plan
+			tasks, events = local_object.known_tasks, local_object.free_events
+			tasks.delete_if    { |t| !t.distribute? }
+			events.delete_if   { |t| !t.distribute? }
+
+			peer.transmit(:discover_plan, local_object, tasks, events)
+			tasks.each  { |obj| subscribe_plan_object(obj) }
+			events.each { |obj| subscribe_plan_object(obj) }
+		    end
+		end
+
+		local_object.remote_id
+	    end
+	    
+	    # Called by the remote host because it has subscribed us to a plan
+	    # (a set of tasks and events).
+	    def discover_plan(marshalled_plan, m_tasks, m_events)
+		plan = peer.local_object(marshalled_plan)
+		Distributed.update(plan) do
+		    peer.local_object(m_tasks)
+		    peer.local_object(m_events)
+		end
+		nil
+	    end
+
+	    # Called by the remote peer to announce that it has created the
+	    # given siblings. +siblings+ is a remote_drbobject => local_object
+	    # hash
+	    #
+	    # It is also used by BasicObject#sibling_of to register a new
+	    # sibling
+	    def added_sibling(local_id, remote_id)
+		local_id.local_object.add_sibling_for(peer, remote_id)
+		nil
+	    end
+
+	    # Called by the remote peer to announce that it has removed the
+	    # given siblings. +objects+ is the list of local objects.
+	    #
+	    # It is also used by BasicObject#forget_peer to remove references
+	    # to an old sibling
+	    def removed_sibling(local_id, remote_id)
+		local_object = local_id.local_object
+		sibling = local_object.remove_sibling_for(peer, remote_id)
+
+		# It is fine to remove a sibling twice: you nay for instance
+		# decide in both sides that the sibling should be removed (for
+		# instance during the disconnection process)
+		if sibling && sibling != remote_id
+		    raise "removed sibling #{sibling} for #{local_id} on peer #{peer} does not match the provided remote id (#{remote_id})"
+		end
+
+		unless local_object.remotely_useful?
+		    Distributed.removed_objects.delete(local_object)
+		end
+	    end
+
+	    # Called by the remote peer to announce that is has subscribed us to +objects+
+	    def subscribed(objects)
+		# Register the subscription
+		objects.each do |object|
+		    peer.subscriptions << peer.remote_object(object)
+		end
+		# Create the proxies
+		peer.local_object(objects)
+		nil
+	    end
+
+	    # Sends to the peer the set of relations needed to copy the state of +plan_object+
+	    # on the remote peer.
+	    def set_relations_commands(plan_object)
+		peer.transmit(:set_relations, plan_object, Distributed.relations_of(plan_object))
+
+		if plan_object.respond_to?(:each_plan_child)
+		    plan_object.each_plan_child do |plan_child|
+			peer.transmit(:set_relations, plan_child, Distributed.relations_of(plan_child))
+		    end
+		end
+	    end
+
+	    # Sets the relation of +objects+ according to the description in +relations+.
+	    # See #relations_of for how +relations+ is formatted
+	    #
+	    # Note that any relation not listed in +relations+ will actually be
+	    # *removed* from the plan. Therefore, if +relations+ is empty, then
+	    # all relations of +object+ are removed.
+	    def set_relations(object, relations)
+		object    = peer.local_object(object)
+		relations = peer.local_object(relations)
+
+		Distributed.update(object.root_object) do
+		    all_parents  = Hash.new { |h, k| h[k] = ValueSet.new }
+		    all_children = Hash.new { |h, k| h[k] = ValueSet.new }
+		    
+		    # Add or update existing relations
+		    relations.each_slice(3) do |graph, parents, children|
+			all_objects = parents.map { |p, _| p } + children.map { |c, _| c }
+			Distributed.update_all(all_objects) do
+			    parents.each_slice(2) do |parent, info|
+				next unless parent
+				all_parents[graph] << parent
+
+				if graph.linked?(parent, object)
+				    parent[object, graph] = info
+				else
+				    Distributed.update(parent.root_object) do
+					parent.add_child_object(object, graph, info)
+				    end
+				end
+			    end
+			    children.each_slice(2) do |child, info|
+				next unless child
+				all_children[graph] << child
+
+				if graph.linked?(object, child)
+				    object[child, graph] = info
+				else
+				    Distributed.update(child.root_object) do
+					object.add_child_object(child, graph, info)
+				    end
+				end
+			    end
+			end
+		    end
+
+		    Distributed.each_object_relation(object) do |rel|
+			# Remove relations that do not exist anymore
+			#
+			# If the other end of this relation cannot be seen by
+			# our remote peer, keep it: it means that the relation
+			# is a local-only annotation this pDB has added to the
+			# task
+			(object.parent_objects(rel).to_value_set - all_parents[rel]).each do |p|
+			    # See comment above
+			    next unless p.distribute?
+			    Distributed.update_all([p.root_object, object.root_object]) do
+				p.remove_child_object(object, rel)
+			    end
+			end
+			(object.child_objects(rel).to_value_set - all_children[rel]).each do |c|
+			    # See comment above
+			    next unless c.distribute?
+			    Distributed.update_all([c.root_object, object.root_object]) do
+				object.remove_child_object(c, rel)
+			    end
+			end
+		    end
+		end
+
+		nil
+	    end
+
+	end
+
+	class Peer
+	    # The set of remote objects we *want* notifications on, as
+	    # RemoteID objects. This does not include automatically susbcribed
+	    # objects, but only those explicitely subscribed to by calling
+	    # Peer#subscribe
+	    #
+	    # See also #subscribe, #subscribed? and #unsubscribe
+	    #
+	    #--
+	    # DO NOT USE a ValueSet here. RemoteIDs must be compared using #==
+	    #++
+	    attribute(:subscriptions) { Set.new }
+
+	    # Explicitely subscribe to #object
+	    #
+	    # See also #subscriptions, #subscribed? and #unsubscribe
+	    def subscribe(object)
+		while object.respond_to?(:__getobj__)
+		    object = object.__getobj__
+		end
+
+		if remote_object = (remote_object(object) rescue nil)
+		    if !subscriptions.include?(remote_object)
+			remote_object = nil
+		    end
+		end
+
+		unless remote_object
+		    remote_sibling = object.sibling_on(self)
+		    remote_object = call(:subscribe, remote_sibling)
+		    synchro_point
+		end
+		local_object = local_object(remote_object)
+	    end
+
+	    # Make our peer subscribe to +object+
+	    def push_subscription(object)
+		local_server.subscribe(object)
+		synchro_point
+	    end
+
+	    # The RemoteID for the peer main plan
+	    attr_accessor :remote_plan
+
+	    # Subscribe to the remote plan
+	    def subscribe_plan
+		call(:subscribe_plan, connection_space.plan.remote_id)
+		synchro_point
+	    end
+
+	    # Unsubscribe from the remote plan
+	    def unsubscribe_plan
+		proxies.delete(remote_plan)
+		subscriptions.delete(remote_plan)
+		if connected?
+		    call(:removed_sibling, @remote_plan, connection_space.plan.remote_id)
+		end
+	    end
+	    
+	    def subscribed_plan?; remote_plan && subscriptions.include?(remote_plan) end
+
+	    # True if we are explicitely subscribed to +object+. Automatically
+	    # subscribed objects will not be included here, but
+	    # BasicObject#updated? will return true for them
+	    #
+	    # See also #subscriptions, #subscribe and #unsubscribe
+	    def subscribed?(object)
+		subscriptions.include?(remote_object(object))
+	    rescue RemotePeerMismatch
+		false
+	    end
+
+	    # Remove an explicit subscription. See also #subscriptions,
+	    # #subscribe and #subscribed?
+	    #
+	    # See also #subscriptions, #subscribe and #subscribed?
+	    def unsubscribe(object)
+		subscriptions.delete(remote_object(object))
+	    end
+	end
+    end
+end
+