roby 0.7

data/lib/roby/distributed/protocol.rb

@@ -0,0 +1,529 @@
+require 'drb'
+require 'set'
+require 'rinda/tuplespace'
+require 'utilrb/value_set'
+require 'roby_marshalling'
+
+require 'roby'
+
+class NilClass
+    def droby_dump(dest); nil end
+end
+class Array
+    def proxy(peer) # :nodoc:
+	map do |element| 
+	    catch(:ignore_this_call) { peer.proxy(element) }
+	end
+    end
+end
+class Hash
+    def proxy(peer) # :nodoc:
+	inject({}) do |h, (k, v)| 
+	    h[peer.proxy(k)] = catch(:ignore_this_call) { peer.proxy(v) }
+	    h
+	end
+    end
+end
+class Set
+    def proxy(peer) # :nodoc:
+	map do |element| 
+	    catch(:ignore_this_call) { peer.proxy(element) }
+	end.to_set
+    end
+end
+class ValueSet
+    def proxy(peer) # :nodoc:
+	map do |element| 
+	    catch(:ignore_this_call) { peer.proxy(element) }
+	end.to_value_set
+    end
+end
+
+class Module
+    def droby_dump(dest)
+	raise "can't dump modules"
+    end
+end
+class Class
+    def droby_dump(dest)
+	raise "can't dump class #{self}"
+    end
+end
+
+module Roby
+    class TaskModelTag
+	@@local_to_remote = Hash.new
+	@@remote_to_local = Hash.new
+	def self.local_to_remote; @@local_to_remote end
+	def self.remote_to_local; @@remote_to_local end
+
+	class DRoby
+	    attr_reader :tagdef
+	    def initialize(tagdef); @tagdef = tagdef end
+	    def _dump(lvl); @__droby_marshalled__ ||= Marshal.dump(tagdef) end
+	    def self._load(str); DRoby.new(Marshal.load(str)) end
+
+	    def proxy(peer)
+		including = []
+		tagdef.each do |name, remote_tag|
+		    tag = DRoby.local_tag(name, remote_tag) do |tag|
+			including.each { |mod| tag.include mod }
+		    end
+		    including << tag
+		end
+		including.last
+	    end
+
+	    def self.local_tag(name, remote_tag)
+		if !remote_tag.kind_of?(Distributed::RemoteID)
+		    remote_tag
+		elsif local_model = TaskModelTag.remote_to_local[remote_tag]
+		    local_model
+		else
+		    if name && !name.empty?
+			local_model = constant(name) rescue nil
+		    end
+		    unless local_model
+			local_model = Roby::TaskModelTag.new do
+			    define_method(:name) { name }
+			end
+			TaskModelTag.remote_to_local[remote_tag] = local_model
+			TaskModelTag.local_to_remote[local_model] = [name, remote_tag]
+			yield(local_model) if block_given?
+		    end
+		    local_model
+		end
+	    end
+
+	    def ==(other)
+		other.kind_of?(DRoby) && 
+		    tagdef.zip(other.tagdef).all? { |a, b| a == b }
+	    end
+	end
+
+	def droby_dump(dest)
+	    unless @__droby_marshalled__
+		tagdef = ancestors.map do |mod|
+		    if mod.instance_of?(Roby::TaskModelTag)
+			unless id = TaskModelTag.local_to_remote[mod]
+			    id = [mod.name, mod.remote_id]
+			end
+			id
+		    end
+		end
+		tagdef.compact!
+		@__droby_marshalled__ = DRoby.new(tagdef.reverse)
+	    end
+	    @__droby_marshalled__
+	end
+    end
+
+    class TaskMatcher
+        # An intermediate representation of TaskMatcher objects suitable to be
+        # sent to our peers.
+	class DRoby
+	    attr_reader :args
+	    def initialize(args); @args = args end
+	    def _dump(lvl) # :nodoc:
+                Marshal.dump(args) 
+            end
+
+	    def self._load(str) # :nodoc:
+		setup_matcher(TaskMatcher.new, Marshal.load(str))
+	    end
+
+            # Common initialization of a TaskMatcher object from the given
+            # argument set. This is to be used by DRoby-dumped versions of
+            # subclasses of TaskMatcher.
+	    def self.setup_matcher(matcher, args)
+		model, args, improves, needs, predicates, neg_predicates, owners = *args
+		model  = model.proxy(nil) if model
+		owners = owners.map { |peer| peer.proxy(nil) } if owners
+		args   = args
+
+		matcher = matcher.with_model(model).with_arguments(args || {}).
+		    which_improves(*improves).which_needs(*needs)
+		matcher.predicates.merge(predicates)
+		matcher.owners.concat(owners)
+		matcher
+	    end
+	end
+
+        # Returns an intermediate representation of +self+ suitable to be sent
+        # to the +dest+ peer. +klass+ is the actual class of the intermediate
+        # representation. It is used for code reuse by subclasses of
+        # TaskMatcher.
+	def droby_dump(dest, klass = DRoby)
+	    args = [model, arguments, improved_information, needed_information, predicates, neg_predicates, owners]
+	    klass.new args.droby_dump(dest)
+	end
+    end
+    class Query
+        # An intermediate representation of Query objects suitable to be sent
+        # to our peers.
+	class DRoby # :nodoc:
+	    attr_reader :plan_predicates, :neg_plan_predicates, :matcher
+	    def initialize(plan_predicates, neg_plan_predicates, matcher)
+		@plan_predicates, @neg_plan_predicates, @matcher = 
+		    plan_predicates, neg_plan_predicates, matcher
+	    end
+
+	    def _dump(lvl) # :nodoc:
+		Marshal.dump([plan_predicates, neg_plan_predicates, matcher])
+	    end
+
+	    def self._load(str) # :nodoc:
+		DRoby.new(*Marshal.load(str))
+	    end
+
+	    def to_query(plan)
+		query = TaskMatcher::DRoby.setup_matcher(plan.find_tasks, matcher)
+		query.plan_predicates.concat(plan_predicates)
+		query.neg_plan_predicates.concat(neg_plan_predicates)
+		query
+	    end
+
+	    def proxy(peer)
+		to_query(peer.connection_space.plan)
+	    end
+	end
+	
+        # Returns an intermediate representation of +self+ suitable to be sent
+        # to the +dest+ peer.
+	def droby_dump(dest)
+	    marshalled_matcher = super
+	    DRoby.new(plan_predicates, neg_plan_predicates, marshalled_matcher.args)
+	end
+    end
+
+    class OrTaskMatcher
+        # An intermediate representation of OrTaskMatcher objects suitable to
+        # be sent to our peers.
+	class DRoby < TaskMatcher::DRoby
+	    def self._load(str) # :nodoc:
+		args = Marshal.load(str)
+		ops  = args.pop
+		setup_matcher(OrTaskMatcher.new(*ops), args)
+	    end
+	end
+	
+        # Returns an intermediate representation of +self+ suitable to be sent
+        # to the +dest+ peer.
+	def droby_dump(dest)
+	    m = super(dest, OrTaskMatcher::DRoby)
+	    m.args << @ops
+	    m
+	end
+    end
+    class AndTaskMatcher
+        # An intermediate representation of AndTaskMatcher objects suitable to
+        # be sent to our peers.
+	class DRoby < TaskMatcher::DRoby
+	    def self._load(str) # :nodoc:
+		args = Marshal.load(str)
+		ops  = args.pop
+		setup_matcher(AndTaskMatcher.new(*ops), args)
+	    end
+	end
+	
+        # Returns an intermediate representation of +self+ suitable to be sent
+        # to the +dest+ peer.
+	def droby_dump(dest)
+	    m = super(dest, AndTaskMatcher::DRoby)
+	    m.args << @ops
+	    m
+	end
+    end
+    class NegateTaskMatcher
+        # An intermediate representation of NegateTaskMatcher objects suitable to
+        # be sent to our peers.
+	class DRoby < TaskMatcher::DRoby
+	    def self._load(str) # :nodoc:
+		args = Marshal.load(str)
+		op  = args.pop
+		setup_matcher(NegateTaskMatcher.new(op), args)
+	    end
+	end
+	
+        # Returns an intermediate representation of +self+ suitable to be sent
+        # to the +dest+ peer.
+	def droby_dump(dest)
+	    m = super(dest, NegateTaskMatcher::DRoby)
+	    m.args << @op
+	    m
+	end
+    end
+end
+
+module Roby
+    module Distributed
+        # If set to true, enable some consistency-checking code in the
+        # communication code.
+	DEBUG_MARSHALLING = false
+
+	class Peer
+            # An intermediate representation of Peer objects suitable to be
+            # sent to our peers.
+	    class DRoby # :nodoc:
+		attr_reader :name, :peer_id
+		def initialize(name, peer_id); @name, @peer_id = name, peer_id end
+		def hash; peer_id.hash end
+		def eql?(obj); obj.respond_to?(:peer_id) && peer_id == obj.peer_id end
+		alias :== :eql?
+
+		def to_s; "#<dRoby:Peer #{name} #{peer_id}>" end 
+		def proxy(peer)
+		    if peer = Distributed.peer(peer_id)
+			peer
+		    else
+			raise "unknown peer ID #{peer_id}, known peers are #{Distributed.peers}"
+		    end
+		end
+	    end
+	
+            # Returns an intermediate representation of +self+ suitable to be sent
+            # to the +dest+ peer.
+	    def droby_dump(dest = nil)
+		@__droby_marshalled__ ||= DRoby.new(remote_name, remote_id)
+	    end
+	end
+
+        # Dumps a constant by using its name. On reload, #proxy searches for a
+        # constant with the same name, and raises ArgumentError if none exists.
+	class DRobyConstant
+	    @@valid_constants = Hash.new
+	    def self.valid_constants; @@valid_constants end
+	    def to_s; "#<dRoby:Constant #{name}>" end
+
+            # Generic implementation of the constant-dumping method. This is to
+            # be included in all kind of classes which should be dumped by their
+            # constant name (for intance RelationGraph).
+	    module Dump
+                # Returns a DRobyConstant object which references +self+. It
+                # checks that +self+ can actually be referenced locally by
+                # calling <tt>constant(name)</tt>, or raises ArgumentError if
+                # it is not the case.
+		def droby_dump(dest)
+		    unless DRobyConstant.valid_constants[self]
+			if const_obj = (constant(name) rescue nil)
+			    DRobyConstant.valid_constants[self] = DRobyConstant.new(name)
+			else
+			    raise ArgumentError, "invalid constant name #{obj.name}"
+			end
+		    end
+		    DRobyConstant.valid_constants[self]
+		end
+	    end
+
+            # The constant name
+	    attr_reader :name
+	    def initialize(name); @name = name end
+            # Returns the local object which can be referenced by this name, or
+            # raises ArgumentError.
+	    def proxy(peer); constant(name) end
+	end
+
+	class Roby::RelationGraph
+	    include Roby::Distributed::DRobyConstant::Dump
+	end
+
+	# Dumps a model (an event, task or planner class). When unmarshalling,
+	# it tries to search for the same model. If it does not find it, it
+	# rebuilds the same hierarchy using anonymous classes, basing itself on
+	# the less abstract class known to both the remote and local sides.
+	class DRobyModel
+	    @@remote_to_local = Hash.new
+	    @@local_to_remote = Hash.new
+
+	    # A name -> class map which maps remote models to local anonymous classes
+	    # Remote models are always identified by their name
+	    def self.remote_to_local; @@remote_to_local end
+	    # A class => ID object which maps the anonymous classes we built for remote
+	    # models to the remote ID of these remote models
+	    def self.local_to_remote; @@local_to_remote end
+	    def to_s # :nodoc:
+                "#<dRoby:Model #{ancestors.first.first}"
+            end
+
+            # Generic implementation of #droby_dump for all classes which
+            # should be marshalled as DRobyModel.
+            module Dump
+                # Creates a DRobyModel object which can be used to reference
+                # +self+ in the communication protocol. It properly takes into
+                # account the anonymous models we have created to map remote
+                # unknown models.
+		def droby_dump(dest)
+		    unless @__droby_marshalled__
+			formatted = ancestors.map do |klass| 
+			    if klass.instance_of?(Class) && !klass.is_singleton? 
+				if result = DRobyModel.local_to_remote[klass]
+				    result
+				else
+				    [klass.name, klass.remote_id]
+				end
+			    end
+			end
+			formatted.compact!
+			@__droby_marshalled__ = DRobyModel.new(formatted)
+		    end
+		    @__droby_marshalled__
+		end
+	    end
+
+            # The set of ancestors for the model, as a [name, remote_id] array
+	    attr_reader :ancestors
+
+            # Initialize a DRobyModel object with the given set of ancestors
+	    def initialize(ancestors); @ancestors  = ancestors end
+	    def _dump(lvl) # :nodoc:
+                @__droby_marshalled__ ||= Marshal.dump(@ancestors) 
+            end
+	    def self._load(str) # :nodoc:
+                DRobyModel.new(Marshal.load(str))
+            end
+            # Returns a local Class object which maps the given model. 
+            #
+            # See DRobyModel.local_model
+	    def proxy(peer)
+	       	DRobyModel.local_model(ancestors.map { |name, id| [name, id.local_object] }) 
+	    end
+
+            # True if the two objects reference the same model
+	    def ==(other)
+		other.kind_of?(DRobyModel) &&
+		    ancestors == other.ancestors
+	    end
+	    
+            # Returns a local representation of the given model. If the model
+            # itself is known to us (i.e. there is a constant with the same
+            # name), it is returned. Otherwise, the model hierarchy is
+            # re-created using anonymous classes, branching the inheritance
+            # chain at a point commonly known between the local plan manager
+            # and the remote one.
+	    def self.local_model(ancestors)
+		name, id = ancestors.shift
+		if !id.kind_of?(Distributed::RemoteID)
+		    # this is a local task model
+		    id
+		elsif !name.empty? && model = (constant(name) rescue nil)
+		    model
+		elsif model = @@remote_to_local[id]
+		    model
+		elsif !ancestors.empty?
+		    parent_model = local_model(ancestors)
+		    model = Class.new(parent_model) do
+			singleton_class.class_eval do
+			    define_method(:remote_name) { name }
+			    define_method(:name) { "AnonModel(#{remote_name})" }
+			end
+		    end
+		    @@remote_to_local[id] = model
+		    @@local_to_remote[model] = [name, id]
+
+		    model
+		else
+		    raise ArgumentError, "cannot find a root class"
+		end
+	    end
+	end
+	Roby::EventGenerator.extend Distributed::DRobyModel::Dump
+	Roby::Planning::Planner.extend Distributed::DRobyModel::Dump
+
+        # Dumping intermediate for Task classes. This dumps both the ancestor
+        # list via DRobyModel and the list of task tags.
+	class DRobyTaskModel < DRobyModel
+            # Set of task tags the task model was referring to
+	    attr_reader :tags
+            # Create a DRobyTaskModel with the given tags and ancestor list
+	    def initialize(tags, ancestors)
+		super(ancestors)
+		@tags = tags
+	    end
+
+            # Generic implementation of #droby_dump for all classes which
+            # should be marshalled as DRobyTaskModel.
+	    module Dump
+		include DRobyModel::Dump
+
+                # This augments DRobyModel::Dump#droby_dump by taking into
+                # account TaskModelTag modules in the ancestors list.
+		def droby_dump(dest)
+		    unless @__droby_marshalled__
+			formatted_class = super
+			tags = ancestors.map do |mod|
+			    if mod.instance_of?(Roby::TaskModelTag)
+				mod.droby_dump(dest)
+			    end
+			end
+			tags.compact!
+			@__droby_marshalled__ = DRobyTaskModel.new(tags.reverse, formatted_class.ancestors)
+		    end
+		    @__droby_marshalled__
+		end
+	    end
+
+            # True if +other+ describes the same task model than +self+
+	    def ==(other)
+		super &&
+		    tags == other.tags
+	    end
+
+	    def _dump(lvl) # :nodoc:
+                @__droby_marshalled__ ||= Marshal.dump([tags, ancestors])
+            end
+	    def self._load(str) # :nodoc:
+                DRobyTaskModel.new(*Marshal.load(str)) 
+            end
+
+            # Returns or creates a Task-subclass which matches the task model
+            # described by this object
+	    def proxy(peer)
+		model = super
+		tags.each do |tag|
+		    tag = tag.proxy(nil)
+		    model.include tag unless model < tag
+		end
+
+		model
+	    end
+	end
+	Roby::Task.extend Distributed::DRobyTaskModel::Dump
+    end
+end
+
+Exception.extend Roby::Distributed::DRobyModel::Dump
+class Exception
+    # An intermediate representation of Exception objects suitable to
+    # be sent to our peers.
+    class DRoby
+	attr_reader :model, :message
+	def initialize(model, message); @model, @message = model, message end
+
+        # Returns a local representation of the exception object +self+
+        # describes. If the real exception message is not available, it reuses
+        # the more-specific exception class which is available.
+	def proxy(peer)
+	    error_model = model.proxy(peer)
+	    error_model.exception(self.message)
+
+	rescue ArgumentError
+	    # try to get a less-specific error model which does allow a simple
+	    # message. In the worst case, we will fall back to Exception itself
+	    #
+	    # However, include the real model name in the message
+	    message = "#{self.message} (#{model.ancestors.first.first})"
+	    for model in error_model.ancestors
+		next unless model.kind_of?(Class)
+		begin
+		    return model.exception(message)
+		rescue ArgumentError
+		end
+	    end
+	end
+    end
+
+    # Returns an intermediate representation of +self+ suitable to be sent to
+    # the +dest+ peer.
+    def droby_dump(dest); DRoby.new(self.class.droby_dump(dest), message) end
+end
+