roby 0.8.0 → 3.0.0

data/lib/roby/distributed/proxy.rb

@@ -1,343 +0,0 @@
-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.add(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(meaningful_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) || peer.connection_space.plan
-		    if plan.owns?(task)
-			if flags[:mission]
-			    plan.add_mission(task)
-			else
-			    plan.remove_mission(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

@@ -1,311 +0,0 @@
-
-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(peer.connection_space.plan.remote_id, sibling)
-		peer.transmit(:subscribed_plan, peer.connection_space.plan.remote_id)
-		subscribe(peer.connection_space.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] = peer.connection_space.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
-