roby 0.8.0 → 3.0.0

data/lib/roby/transaction/event_generator_proxy.rb

@@ -0,0 +1,63 @@
+module Roby
+    class Transaction
+        module EventGeneratorProxy
+            proxy_for EventGenerator
+            
+            def setup_proxy(object, plan)
+                super(object, plan)
+                @handlers.clear
+                @unreachable_handlers.clear
+                if object.controlable?
+                    @command = method(:emit)
+                end
+            end
+
+            def initialize_replacement(event)
+                # Apply recursively all event handlers of this (proxied) event to
+                # the new event
+                #
+                # We have to look at all levels as, in transactions, the "handlers"
+                # set only contains new event handlers
+                real_object = self
+                while real_object.transaction_proxy?
+                    real_object = real_object.__getobj__
+
+                    real_object.handlers.each do |h|
+                        if h.copy_on_replace?
+                            event ||= yield
+                            event.on(h.as_options, &h.block)
+                        end
+                    end
+                    real_object.unreachable_handlers.each do |cancel, h|
+                        if h.copy_on_replace?
+                            event ||= yield
+                            event.if_unreachable(cancel_at_emission: cancel, on_replace: :copy, &h.block)
+                        end
+                    end
+                end
+
+                if event
+                    super(event)
+                else super(nil, &Proc.new)
+                end
+            end
+
+            def commit_transaction
+                super
+
+                handlers.each { |h| __getobj__.on(h.as_options, &h.block) }
+                unreachable_handlers.each do |cancel, h|
+                    on_replace = if h.copy_on_replace? then :copy
+                                 else :drop
+                                 end
+                    __getobj__.if_unreachable(
+                        cancel_at_emission: cancel,
+                        on_replace: on_replace,
+                        &h.block)
+                end
+            end
+        end
+    end
+end
+
+

data/lib/roby/transaction/plan_object_proxy.rb

@@ -0,0 +1,99 @@
+module Roby
+    class Transaction
+        module PlanObjectProxy
+            proxy_for PlanObject
+
+            def setup_proxy(object, plan)
+                super(object, plan)
+                @finalization_handlers.clear
+            end
+
+            # Uses the +enum+ method on this proxy and on the proxied object to get
+            # a set of objects related to this one in both the plan and the
+            # transaction.
+            # 
+            # The block is then given a plan_object => transaction_object hash, the
+            # relation which is being considered, the set of new relations (the
+            # relations that are in the transaction but not in the plan) and the
+            # set of deleted relation (relations that are in the plan but not in
+            # the transaction)
+            def partition_new_old_relations(enum, include_proxies: true) # :yield:
+                trsc_objects = Hash.new
+                each_relation do |rel|
+                    trsc_others = Set.new
+                    send(enum, rel) do |obj|
+                        plan_object =
+                            if obj.transaction_proxy?
+                                next if !include_proxies
+                                obj.__getobj__
+                            else obj
+                            end
+
+                        trsc_objects[plan_object] = obj
+                        trsc_others << plan_object
+                    end
+
+                    plan_others = Set.new
+                    if include_proxies
+                        __getobj__.send(enum, rel) do |child|
+                            if plan[child, create: false]
+                                plan_others << child
+                            end
+                        end
+                    end
+
+                    new = (trsc_others - plan_others)
+                    existing = (trsc_others - new)
+                    del = (plan_others - trsc_others)
+
+                    yield(trsc_objects, rel, new, del, existing)
+                end
+            end
+
+            # Commits the modifications of this proxy. It copies the relations of
+            # the proxy on the proxied object
+            def commit_transaction
+                # The relation graph handling is a bit tricky. We resolve the graphs
+                # exclusively using self (NOT other) because if 'other' was a new
+                # task, it has been already moved to the new plan (and its relation
+                # graph resolution is using the new plan's new graphs already)
+
+
+                super
+
+                if @executable != __getobj__.instance_variable_get(:@executable)
+                    __getobj__.executable = @executable
+                end
+
+                finalization_handlers.each do |handler|
+                    __getobj__.when_finalized(handler.as_options, &handler.block)
+                end
+            end
+
+            def initialize_replacement(object)
+                # Apply recursively all finalization handlers of this (proxied)
+                # object to the object event
+                #
+                # We have to look at all levels as, in transactions, the "handlers"
+                # set only contains new handlers
+                real_object = self
+                while real_object.transaction_proxy?
+                    real_object = real_object.__getobj__
+                    real_object.finalization_handlers.each do |h|
+                        if h.copy_on_replace?
+                            object ||= yield
+                            object.when_finalized(h.as_options, &h.block)
+                        end
+                    end
+                end
+
+                if object
+                    super(object)
+                else super(nil, &Proc.new)
+                end
+            end
+        end
+    end
+end
+
+

data/lib/roby/transaction/plan_service_proxy.rb

@@ -0,0 +1,43 @@
+module Roby
+    class Transaction
+        module PlanServiceProxy
+            proxy_for PlanService
+
+            def task=(new_task)
+                @task = new_task
+            end
+
+            def setup_proxy(object, plan)
+                super
+                finalization_handlers.clear
+                event_handlers.clear
+                plan_status_handlers.clear
+                replacement_handlers.clear
+            end
+
+            def on_plan_status_change(&handler)
+                plan_status_handlers << handler
+            end
+
+            def commit_transaction
+                super
+
+                replacement_handlers.each do |h|
+                    __getobj__.on_replacement(&h)
+                end
+                plan_status_handlers.each do |h|
+                    __getobj__.on_plan_status_change(&h)
+                end
+                event_handlers.each do |event, handlers|
+                    handlers.each do |h|
+                        __getobj__.on(event, &h)
+                    end
+                end
+                finalization_handlers.each do |h|
+                    __getobj__.when_finalized(&h)
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/transaction/proxying.rb

@@ -0,0 +1,120 @@
+class Module
+    # Declare that +proxy_klass+ should be used to wrap objects of +real_klass+.
+    # Order matters: if more than one wrapping matches, we will use the one
+    # defined last.
+    def proxy_for(real_klass)
+        Roby::Transaction::Proxying.define_proxying_module(self, real_klass)
+    end
+end
+
+
+module Roby
+    # In transactions, we do not manipulate plan objects like Task and EventGenerator directly,
+    # but through proxies which make sure that nothing forbidden is done
+    #
+    # The Proxy module define base functionalities for these proxy objects
+    class Transaction < Plan
+        module Proxying
+            module Cache
+                # The module used to transform proxies into call forwarder at commit
+                # time
+                #
+                # It is initialized and used by
+                # {Transaction::Proxying#forwarder_module_for}
+                #
+                # @return [Module,nil]
+                attr_accessor :transaction_forwarder_module
+
+                # The full module used to build transaction proxies for objects of this
+                # model
+                #
+                # It is initialized and used by
+                # {Transaction::Proxying#proxying_module_for}
+                #
+                # @return [Module,nil]
+                attr_accessor :transaction_proxy_module
+            end
+
+            @@proxy_for  = Hash.new
+
+            def to_s; "tProxy(#{__getobj__.to_s})" end
+
+            def self.define_proxying_module(proxying_module, mod)
+                @@proxy_for[mod] = proxying_module
+                nil
+            end
+
+            # Returns the proxying module for +object+
+            def self.proxying_module_for(klass)
+                if proxying_module = klass.transaction_proxy_module
+                    return proxying_module
+                end
+
+                modules = klass.ancestors.map do |ancestor|
+                    if mod_proxy = @@proxy_for[ancestor]
+                        mod_proxy
+                    end
+                end.compact
+                modules << Transaction::Proxying
+
+                proxying_module = Module.new
+                modules.reverse.each do |mod|
+                    proxying_module.include mod
+                end
+                klass.transaction_proxy_module = proxying_module
+            end
+
+            def self.create_forwarder_module(methods)
+                Module.new do
+                    attr_accessor :__getobj__
+                    def transaction_proxy?; true end
+                    methods.each do |name|
+                        next if name =~ /^__.*__$/
+                        next if name == :object_id
+                        define_method(name) do |*args, &block|
+                            __getobj__.send(name, *args, &block)
+                        end
+                    end
+                end
+            end
+
+            # Returns a module that, when used to extend an object, will forward all
+            # the calls to the object's @__getobj__
+            def self.forwarder_module_for(klass)
+                klass.transaction_forwarder_module ||=
+                    create_forwarder_module(klass.instance_methods(true)) 
+            end
+
+            attr_reader :__getobj__
+
+            def transaction_proxy?; true end
+
+            def setup_proxy(object, plan)
+                @__getobj__  = object
+            end
+
+            alias :== :eql?
+
+            def pretty_print(pp)
+                if plan
+                    plan.disable_proxying do
+                        pp.text "TProxy:"
+                        __getobj__.pretty_print(pp)
+                    end
+                else super
+                end
+            end
+
+            def proxying?; plan && plan.proxying? end
+
+            # True if +peer+ has a representation of this object
+            #
+            # In the case of transaction proxies, we know they have siblings if the
+            # transaction is present on the other peer.
+            def has_sibling?(peer)
+                plan.has_sibling?(peer)
+            end
+        end
+    end
+end
+

data/lib/roby/transaction/task_event_generator_proxy.rb

@@ -0,0 +1,19 @@
+module Roby
+    class Transaction
+        # Transaction proxy for Roby::TaskEventGenerator
+        module TaskEventGeneratorProxy
+            proxy_for TaskEventGenerator
+
+            def setup_proxy(object, transaction)
+                super
+                @task = transaction[task]
+                task.bound_events[symbol] = self
+            end
+
+            # Task event generators do not have siblings on remote plan managers.
+            # They are always referenced by their name and task.
+            def has_sibling?(peer); false end
+        end
+    end
+end
+

data/lib/roby/transaction/task_proxy.rb

@@ -0,0 +1,135 @@
+module Roby
+    class Transaction
+        # Transaction proxy for Roby::Task
+        module TaskProxy
+            proxy_for Task
+
+            def to_s; "tProxy(#{__getobj__.name})#{arguments}" end
+
+            STATE_PREDICATES = [:pending?, :running?, :finished?, :success?, :failed?]
+
+            STATE_PREDICATES.each do |predicate_name|
+                attr_predicate predicate_name
+            end
+
+            # Create a new proxy representing +object+ in +transaction+
+            def setup_proxy(object, transaction)
+                super(object, transaction)
+
+                @poll_handlers.clear
+                @execute_handlers.clear
+
+                @arguments = Roby::TaskArguments.new(self)
+                if !bound_events.empty?
+                    raise ArgumentError, "expected bound_events to be empty when setting the proxy up"
+                end
+
+                STATE_PREDICATES.each do |predicate_name|
+                    instance_variable_set "@#{predicate_name[0..-2]}", object.send(predicate_name)
+                end
+
+                object.arguments.each do |key, value|
+                    if value.kind_of?(Roby::PlanObject)
+                        arguments.update!(key, transaction[value])
+                    else
+                        arguments.update!(key, value)
+                    end
+                end
+
+                proxied_events = Array.new
+                events = object.each_event.to_a
+                transaction.plan.each_event_relation_graph do |g|
+                    next if !g.root_relation?
+                    events.delete_if do |event|
+                        should_proxy =
+                            g.each_in_neighbour(event).any? { |e| !e.respond_to?(:task) || e.task != object } ||
+                            g.each_out_neighbour(event).any? { |e| !e.respond_to?(:task) || e.task != object }
+                        if should_proxy
+                            proxied_events << event
+                        end
+                    end
+                    break if events.empty?
+                end
+                proxied_events.each do |ev|
+                    transaction.create_and_register_proxy_event(ev)
+                end
+            end
+
+            def has_event?(name)
+                super || __getobj__.has_event?(name)
+            end
+
+            def event(name)
+                if ev = find_event(name)
+                    ev
+                else
+                    ev = __getobj__.event(name)
+                    bound_events[ev.symbol] = plan.create_and_register_proxy_event(ev)
+                end
+            end
+
+            # Perform the operations needed for the commit to be successful.  In
+            # practice, it updates the task arguments as needed.
+            def commit_transaction
+                super
+                
+                # Update the task arguments. The original
+                # Roby::Task#commit_transaction has already translated the proxy
+                # objects into real objects
+                arguments.each do |key, value|
+                    __getobj__.arguments.update!(key, value)
+                end
+
+                execute_handlers.each do |h|
+                    __getobj__.execute(h.as_options, &h.block)
+                end
+                poll_handlers.each do |h|
+                    __getobj__.poll(h.as_options, &h.block)
+                end
+
+                __getobj__.abstract = self.abstract?
+                if @fullfilled_model
+                    __getobj__.fullfilled_model = @fullfilled_model.dup
+                end
+                __getobj__.do_not_reuse if !@reusable
+            end
+
+            def initialize_replacement(task)
+                super
+
+                seen_events = bound_events.keys.to_set
+
+                # Apply recursively all event handlers of this (proxied) task to
+                # the new task
+                #
+                # We have to look at all levels as, in transactions, the "handlers"
+                # set only contains new event handlers
+                real_object = self
+                while real_object.transaction_proxy?
+                    real_object = real_object.__getobj__
+                    real_object.execute_handlers.each do |h|
+                        if h.copy_on_replace?
+                            task.execute(h.as_options, &h.block)
+                        end
+                    end
+                    real_object.poll_handlers.each do |h|
+                        if h.copy_on_replace?
+                            task.poll(h.as_options, &h.block)
+                        end
+                    end
+
+                    # Do the same for all events that are not present at this level
+                    # of the transaction
+                    real_object.each_event do |event|
+                        if !seen_events.include?(event.symbol)
+                            event.initialize_replacement(nil) { task.event(event.symbol) }
+                            seen_events << event.symbol
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+
+