roby 0.8.0 → 3.0.0

data/lib/roby/droby/logfile/writer.rb

@@ -0,0 +1,114 @@
+require 'roby/droby/logfile'
+
+module Roby
+    module DRoby
+        module Logfile
+            # A class that marshals DRoby cycle events into a log file using
+            # Ruby's Marshal facility
+            class Writer
+                # The current log format version
+                FORMAT_VERSION = 5
+
+                attr_reader :event_io
+                attr_reader :buffer_io
+
+                def initialize(event_io, options = Hash.new)
+                    @event_io = event_io
+                    @buffer_io = StringIO.new('', 'w')
+
+                    Logfile.write_header(event_io, options)
+                end
+
+                def self.open(path, options = Hash.new)
+                    event_io = File.open(path, 'w')
+                    new(event_io, options)
+                end
+
+                def close
+                    event_io.close
+                end
+
+                def dump_object(object, io)
+                    buffer_io.truncate(0)
+                    buffer_io.seek(0)
+                    ::Marshal.dump(object, buffer_io)
+                    io.write([buffer_io.size].pack("L<"))
+                    io.write(buffer_io.string)
+                end
+
+                def flush
+                    event_io.flush
+                end
+
+                def dump(cycle)
+                    dump_object(cycle, event_io)
+
+                rescue
+                    self.class.find_invalid_marshalling_object_in_cycle(cycle)
+                    raise
+                end
+
+                def self.find_invalid_marshalling_object_in_cycle(cycle)
+                    cycle.each_slice(4) do |m, sec, usec, args|
+                        begin
+                            ::Marshal.dump(args)
+                        rescue Exception => e
+                            Roby::DRoby::Logfile.fatal "failed to dump message #{m}: #{e}"
+                            args.each do |obj|
+                                begin
+                                    ::Marshal.dump(obj)
+                                rescue Exception => e
+                                    Roby::DRoby::Logfile.fatal "cannot dump #{obj}"
+                                    Roby::DRoby::Logfile.fatal e.to_s
+                                    obj, exception = find_invalid_marshalling_object(obj)
+                                    if obj
+                                        Roby::DRoby::Logfile.fatal "  it seems that #{obj} can't be marshalled"
+                                        Roby::DRoby::Logfile.fatal "    #{exception.class}: #{exception.message}"
+                                    end
+                                end
+                            end
+                        end
+                    end
+                end
+
+                def self.find_invalid_marshalling_object(obj, stack = Set.new)
+                    if stack.include?(obj)
+                        return
+                    end
+                    stack << obj
+
+                    case obj
+                    when Enumerable
+                        obj.each do |value|
+                            invalid, exception = find_invalid_marshalling_object(value, stack)
+                            if invalid
+                                return "#{invalid}, []", exception
+                            end
+                        end
+                    end
+
+                    # Generic check for instance variables
+                    obj.instance_variables.each do |iv|
+                        value = obj.instance_variable_get(iv)
+                        invalid, exception = find_invalid_marshalling_object(value, stack)
+                        if invalid
+                            return "#{invalid}, #{iv}", exception
+                        end
+                    end
+
+                    begin
+                        ::Marshal.dump(obj)
+                        nil
+                    rescue Exception => e
+                        begin
+                            return "#{obj} (#{obj.class})", e
+                        rescue Exception
+                            return "-- cannot display object, #to_s raised -- (#{obj.class})", e
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/droby/marshal.rb

@@ -0,0 +1,264 @@
+module Roby
+    module DRoby
+        # Handles marshalling and demarshalling objects for a given peer
+        class Marshal
+            # The object that allows to match objects known locally with the
+            # objects transmitted by the peer
+            attr_reader :object_manager
+
+            # @api private
+            #
+            # Objects that are temporarily referenced by IDs
+            #
+            # This is used by {#dump_groups} and {#load_groups}
+            attr_reader :context_objects
+
+            # The ID of the peer that self handles
+            #
+            # @return [PeerID]
+            attr_reader :peer_id
+
+            # Whether {#local_plan} should just create a plan object if an ID
+            # cannot be resolved
+            #
+            # Use this when the purpose of marshalling/demarshalling is to use
+            # Roby objects as information holders, without caring about the
+            # plan structure itself
+            attr_predicate :auto_create_plans?
+
+            def initialize(object_manager = ObjectManager.new(nil), peer_id = nil, auto_create_plans: false)
+                @object_manager = object_manager
+                @peer_id = peer_id
+                @context_objects = Hash.new
+                @auto_create_plans = auto_create_plans
+            end
+
+
+            def with_object(id_to_object)
+                current_context = context_objects.dup
+                id_to_object.each do |id, object|
+                    context_objects[id] = object
+                    context_objects[RemoteDRobyID.new(peer_id, id)] = object
+                end
+
+                yield
+
+            ensure
+                context_objects.replace(current_context)
+            end
+
+            # Temporarily register sets of objects
+            #
+            # Use this method to marshal sets of objects that could be
+            # referencing each other. Using this method ensures that the
+            # cross-references are marshalled using IDs instead of full objects
+            def dump_groups(*groups)
+                current_context = context_objects.dup
+                mappings = groups.map do |collection|
+                    mapping = Array.new
+                    collection.each do |obj|
+                        context_objects[obj] = obj.droby_id
+                        mapping << [obj.droby_id, obj]
+                    end
+                    mapping
+                end
+
+                marshalled = mappings.map do |collection|
+                    collection.flat_map do |obj_id, obj|
+                        [obj_id, obj.droby_dump(self)]
+                    end
+                end
+
+                if block_given?
+                    yield(*marshalled)
+                else return *marshalled
+                end
+
+            ensure
+                context_objects.replace(current_context)
+            end
+
+            # Load groups marshalled with {#dump_groups}
+            def load_groups(*groups)
+                current_context = context_objects.dup
+
+                updates = Array.new
+                local_objects = groups.map do |collection|
+                    collection.each_slice(2).map do |obj_id, marshalled_obj|
+                        proxy = local_object(marshalled_obj)
+                        context_objects[obj_id] = proxy
+
+                        if marshalled_obj.respond_to?(:remote_siblings)
+                            object_manager.register_object(proxy, marshalled_obj.remote_siblings)
+                        end
+                        if marshalled_obj.respond_to?(:update)
+                            updates << [marshalled_obj, proxy]
+                        end
+                        proxy
+                    end
+                end
+
+                updates.each do |marshalled, local|
+                    marshalled.update(self, local, fresh_proxy: true)
+                end
+
+                if block_given?
+                    yield(*local_objects)
+                else return *local_objects
+                end
+            ensure
+                context_objects.replace(current_context)
+            end
+
+            # Dump an object for transmition to the peer
+            def dump(object)
+                if droby_id = context_objects[object]
+                    droby_id
+                elsif object.respond_to?(:droby_dump)
+                    if sibling = object_manager.registered_sibling_on(object, peer_id)
+                        RemoteDRobyID.new(peer_id, sibling)
+                    else
+                        object.droby_dump(self)
+                    end
+                else
+                    object
+                end
+            end
+
+            def dump_model(object)
+                marshalled = dump(object)
+                if !marshalled.kind_of?(RemoteDRobyID) && object.respond_to?(:droby_dump)
+                    register_model(object)
+                end
+                marshalled
+            end
+
+            # Finds a local object that matches the object transmitted by
+            # our peer
+            #
+            # @return [(Boolean,Object)] whether the object was resolved and the
+            #   unmarshalled object
+            def find_local_object(marshalled)
+                if local_object = context_objects[marshalled]
+                    return true, local_object
+                elsif marshalled.kind_of?(DRobyID)
+                    return true, object_manager.fetch_by_id(peer_id, marshalled)
+                elsif marshalled.kind_of?(RemoteDRobyID)
+                    return true, object_manager.fetch_by_id(marshalled.peer_id, marshalled.droby_id)
+                elsif marshalled.respond_to?(:remote_siblings)
+                    marshalled.remote_siblings.each do |peer_id, droby_id|
+                        if local_object = object_manager.find_by_id(peer_id, droby_id)
+                            # In case the remote siblings got updated since
+                            # last time
+                            object_manager.register_siblings(local_object, marshalled.remote_siblings)
+                            if marshalled.respond_to?(:update)
+                                marshalled.update(self, local_object)
+                            end
+                            return true, local_object
+                        end
+                    end
+                    return false, nil
+                elsif !marshalled.respond_to?(:proxy)
+                    return true, marshalled
+                else
+                    return false, nil
+                end
+            end
+
+            # Resolves a marshalled object into a local object
+            #
+            # Unlike {#find_local_object}, it raises if the object cannot be
+            # resolved
+            def local_object(marshalled, create: true)
+                resolved, local_object = find_local_object(marshalled)
+                if resolved 
+                    local_object
+                elsif marshalled.respond_to?(:remote_siblings)
+                    if !create
+                        raise NoLocalObject, "#{marshalled} cannot be resolved into a local object and create is false"
+                    end
+
+                    local_object = marshalled.proxy(self)
+                    if local_object.respond_to?(:droby_id)
+                        object_manager.register_object(local_object, marshalled.remote_siblings)
+                    end
+                    if marshalled.respond_to?(:update)
+                        marshalled.update(self, local_object, fresh_proxy: true)
+                    end
+                    local_object
+                elsif marshalled.respond_to?(:proxy)
+                    marshalled.proxy(self)
+                else
+                    raise NoLocalObject, "#{marshalled} cannot be resolved into a local object"
+                end
+            end
+
+            # Resolve an ID that is known to represent a plan
+            #
+            # It calls {#local_object} by default, but can be overriden for e.g.
+            # environments where rebuilding a plan structure is not important
+            # (e.g. the shell)
+            def local_plan(marshalled)
+                local_object(marshalled)
+            rescue UnknownSibling
+                Plan.new
+            end
+
+            # Find a known model matching the given name
+            #
+            # It is first resolved among the 
+            # models registered with {#register_model} and then resolved in
+            # the process constant hierarchy
+            def find_local_model(marshalled, name: marshalled.name)
+                resolved, local_model = find_local_object(marshalled)
+                if resolved
+                    return local_model
+                elsif name && (local_model = object_manager.find_model_by_name(name))
+                    return local_model
+                elsif !name
+                    return
+                end
+
+                names = name.split('::')
+
+                # Look locally for the constant listed in the name
+                local_object = Object
+                while subname = names.shift
+                    if subname =~ /^[A-Z]\w*$/ && local_object.const_defined_here?(subname)
+                        local_object = local_object.const_get(subname)
+                    else return
+                    end
+                end
+                return local_object
+            end
+
+            def local_model(marshalled, create: true)
+                model = local_object(marshalled, create: create)
+                object_manager.register_model(model)
+                model
+            end
+
+            # (see ObjectManager#find_model_by_name)
+            def find_model_by_name(name)
+                object_manager.find_model_by_name(name)
+            end
+
+            # (see ObjectManager#register_object)
+            def register_object(object, known_siblings = Hash.new)
+                object_manager.register_object(object, known_siblings)
+            end
+
+            # (see ObjectManager#register_model)
+            def register_model(local_model, known_siblings = Hash.new, name: local_model.name)
+                object_manager.register_model(local_model, known_siblings, name: name)
+            end
+
+            # (see ObjectManager#known_siblings_for)
+            def known_siblings_for(object)
+                object_manager.known_siblings_for(object)
+            end
+        end
+    end
+end
+
+

data/lib/roby/droby/marshallable.rb

@@ -0,0 +1,12 @@
+class Object
+    def droby_marshallable?; true end
+end
+
+module Roby
+    module DRoby
+        module Unmarshallable
+            def droby_marshallable?; false end
+        end
+    end
+end
+

data/lib/roby/droby/null_event_logger.rb

@@ -0,0 +1,25 @@
+module Roby
+    module DRoby
+        class NullEventLogger
+            def dump(m, time, *args)
+            end
+
+            def dump_timepoint(m, time, *args)
+            end
+
+            def close
+            end
+
+            def log_queue_size
+                0
+            end
+
+            def dump_time
+                0
+            end
+
+            def flush_cycle(m, *args)
+            end
+        end
+    end
+end

data/lib/roby/droby/object_manager.rb

@@ -0,0 +1,205 @@
+module Roby
+    module DRoby
+        # The object manager manages the IDs of an object among known peers
+        class ObjectManager
+            # The Peer ID of the local Roby instance
+            #
+            # @return [PeerID]
+            attr_reader :local_id
+
+            # Resolution of a remote DRobyID by first the object's local ID and
+            # then the remote PeerID
+            attr_reader :siblings_by_local_object_id
+
+            # Mapping of known objects by peer and droby ID
+            attr_reader :siblings_by_peer
+
+            # Resolution of models by name
+            attr_reader :models_by_name
+
+            def initialize(local_id)
+                @local_id = local_id
+                clear
+            end
+
+            def clear
+                @siblings_by_peer = Hash.new { |h, k| h[k] = Hash.new }
+                @siblings_by_local_object_id = Hash.new { |h, k| h[k] = Hash.new }
+                @models_by_name = Hash.new
+            end
+
+            def find_by_id(peer_id, droby_id)
+                if object_siblings = siblings_by_peer.fetch(peer_id, nil)
+                    object_siblings[droby_id]
+                end
+            end
+
+            def fetch_by_id(peer_id, droby_id)
+                if local_object = find_by_id(peer_id, droby_id)
+                    local_object
+                else
+                    raise UnknownSibling, "there is no known object for #{droby_id}@#{peer_id.inspect} on #{self}"
+                end
+            end
+
+            # The registered ID for this object on a given peer
+            #
+            # @param [#droby_id] local_object
+            # @param [PeerID] peer_id the ID of our peer
+            # @return [DRobyID,nil]
+            def registered_sibling_on(local_object, peer_id)
+                if local_object.respond_to?(:droby_id)
+                    if siblings = siblings_by_local_object_id.fetch(local_object.droby_id, nil)
+                        siblings[peer_id]
+                    end
+                end
+            end
+
+            # The ID this object is known for on the given peer
+            #
+            # @param [#droby_id] local_object
+            # @param [PeerID] peer_id the ID of our peer
+            # @return [DRobyID,nil]
+            def known_sibling_on(local_object, peer_id)
+                if local_object.respond_to?(:droby_id)
+                    if siblings = siblings_by_local_object_id.fetch(local_object.droby_id, nil)
+                        siblings[peer_id]
+                    elsif peer_id == local_id
+                        local_object.droby_id
+                    end
+                end
+            end
+
+            # The set of IDs known for this object
+            #
+            # This returns a mapping from peer IDs to the ID of the provided
+            # object on this peer. The list of siblings is maintained by
+            # {#register_object} and {#deregister_object}
+            #
+            # @param [Object] object
+            # @return [Hash] the siblings. A hash that announces the local ID is
+            #   returned if the object is not registered, and an empty hash if
+            #   it is not DRoby-addressable
+            def known_siblings_for(object)
+                if object.respond_to?(:droby_id)
+                    if siblings = siblings_by_local_object_id.fetch(object.droby_id, nil)
+                        siblings
+                    else Hash[local_id => object.droby_id]
+                    end
+                else Hash.new
+                end
+            end
+
+            # Tests whether self knows about a local object
+            def include?(local_object)
+                siblings_by_local_object_id.has_key?(local_object.droby_id)
+            end
+
+            # Registers siblings for a local object
+            #
+            # Unlike {#register_object}, it does not automatically adds the
+            # local mapping to the set of known siblings
+            def register_siblings(local_object, siblings)
+                local_object_id = local_object.droby_id
+                siblings.each do |peer_id, droby_id|
+                    siblings_by_peer[peer_id][droby_id] = local_object
+                end
+                siblings_by_local_object_id[local_object_id].
+                    merge!(siblings)
+            end
+
+            # Deregisters siblings of a known local object
+            #
+            # If the object has no known siblings left, it is also
+            # deregistered
+            def deregister_siblings(local_object, siblings)
+                local_object_id = local_object.droby_id
+                object_siblings = siblings_by_local_object_id[local_object_id]
+
+                siblings.each do |peer_id, droby_id|
+                    if actual_droby_id = object_siblings.delete(peer_id)
+                        if actual_droby_id != droby_id
+                            raise ArgumentError, "DRobyID of #{local_object} on #{peer_id} mismatches between provided #{droby_id} and registered #{actual_droby_id}"
+                        end
+                        siblings_by_peer[peer_id].delete(droby_id)
+                    end
+                end
+                if object_siblings.empty?
+                    deregister_object(local_object)
+                end
+            end
+
+            # Registers the mappings from object IDs to the corresponding local object
+            #
+            # This registers the mapping for the local process (local_id =>
+            # local_object.droby_id), along with known siblings if provided
+            def register_object(local_object, known_siblings = Hash.new)
+                register_siblings(local_object, local_id => local_object.droby_id)
+                register_siblings(local_object, known_siblings)
+            end
+
+            # Deregisters a mapping from object IDs to a particular object
+            def deregister_object(local_object)
+                siblings = siblings_by_local_object_id.delete(local_object.droby_id)
+                siblings.each do |peer_id, droby_id|
+                    siblings_by_peer[peer_id].delete(droby_id)
+                end
+
+                if local_object.respond_to?(:name)
+                    if local_object == models_by_name[n = local_object.name]
+                        models_by_name.delete(n)
+                    end
+                end
+            end
+
+            # Register a model by name and a list of known siblings for it
+            #
+            # In addition to ID-based resolution, models can also be resolved by
+            # name through {#find_model_by_name}. This registers the name
+            # mapping and then calls {#register_object}
+            def register_model(local_object, known_siblings = Hash.new, name: local_object.name)
+                if name
+                    models_by_name[name] = local_object
+                end
+                register_object(local_object, known_siblings)
+            end
+
+            # Attempts to resolve a registered model by its name
+            #
+            # In addition to ID-based resolution, models registered with
+            # {#register_model} can also be resolved by name.
+            #
+            # This attempts a name-based resolution
+            #
+            # @param [String] name the name of the model to resolve
+            # @return [Object,nil]
+            def find_model_by_name(name)
+                models_by_name[name]
+            end
+
+            def pretty_print(pp)
+                pp.text "Object manager with local ID=#{local_id}"
+                pp.nest(2) do
+                    pp.breakable
+                    pp.text "Registered objects"
+                    siblings_by_peer.each do |peer_id, siblings|
+                        siblings.each do |peer_object_id, object|
+                            pp.breakable
+                            pp.text "  #{peer_object_id}@#{peer_id} "
+                            pp.nest(4) do
+                                object.pretty_print(pp)
+                            end
+                        end
+                    end
+                end
+            end
+
+            def stat
+                Hash[siblings_by_local_object_id: siblings_by_local_object_id.size,
+                     models_by_name: models_by_name.size,
+                     siblings_by_peer: siblings_by_peer.inject(0) { |sum, (_, siblings)| sum += siblings.size }]
+            end
+        end
+    end
+end
+