roby 0.8.0 → 3.0.0

data/lib/roby/decision_control.rb

@@ -2,14 +2,10 @@ module Roby
     class DecisionControl
         # Called when there is a conflict between a set of running tasks and a
         # task that should have been started. The default operation is to
-        # postpone starting the task until all the conflicting tasks are
-        # finished
-	def conflict(starting_task, running_tasks)
-	    for t in running_tasks
-		starting_task.event(:start).postpone t.event(:stop)
-		return
-	    end
-	end
+        # add an error about it
+        def conflict(starting_task, running_tasks)
+            starting_task.failed_to_start! TaskStructure::ConflictError.new(starting_task, running_tasks)
+        end
 
         # Called when a transaction/execution conflict occured, where a task
         # included in the transaction has been removed from the plan.
@@ -33,7 +29,7 @@ def finalized_plan_task(transaction, proxy)
         #
         # The default action is to do nothing
         def finalized_plan_event(transaction, proxy)
-	end
+        end
 
         # Called when a transaction/execution conflict occured, where relations
         # have been added in the plan and are not present in the transaction.
@@ -43,8 +39,8 @@ def finalized_plan_event(transaction, proxy)
         # invalidated prior to this call
         #
         # The default action is to do nothing
-	def adding_plan_relation(transaction, parent, child, relations, info)
-	end
+        def adding_plan_relation(transaction, parent, child, relations, info)
+        end
 
         # Called when a transaction/execution conflict occured, where relations
         # have been removed from the plan, which were present in the
@@ -55,21 +51,37 @@ def adding_plan_relation(transaction, parent, child, relations, info)
         # prior to this call
         #
         # The default action is to do nothing
-	def removing_plan_relation(transaction, parent, child, relations)
+        def removing_plan_relation(transaction, parent, child, relations)
         end
-    end
 
-    class << self
-	attr_reader :control
+        # Called when a child failed a dependency relation, but the parent is
+        # not running
+        #
+        # It must return true if the dependency failure is considered an error,
+        # and false otherwise.
+        #
+        # The default policy is to mark the parent as failed to start
+        def pending_dependency_failed(parent, child, reason)
+            parent.failed_to_start!(reason)
+            true
+        end
 
-        def control=(new)
-            if control
-                raise ArgumentError, "cannot change the decision control object"
-            elsif engine && new != engine.control
-                raise ArgumentError, "must have Roby.control == Roby.engine.control"
+        # Called when an execution agent fails to start.
+        #
+        # The default policy is to mark all executed tasks as failed to start
+        def pending_executed_by_failed(agent, tasks)
+            tasks.each do |t|
+                t.failed_to_start!(agent.failure_reason || agent.terminal_event)
             end
+        end
 
-            @control = new
+        # Called when an execution agent fails to start.
+        #
+        # The default policy is to mark all executed tasks as failed to start
+        def execution_agent_failed_to_start(agent, tasks, reason = nil)
+            tasks.each do |t|
+                t.failed_to_start!(reason || agent.failure_reason || agent.terminal_event)
+            end
         end
     end
 end

data/lib/roby/distributed_object.rb

@@ -0,0 +1,76 @@
+module Roby
+    class ::Class
+        # If true, this model will never get sent to remote peers.
+        def private_model?
+            if !@private_model.nil?
+                @private_model
+            else
+                klass = superclass
+                if superclass.respond_to?(:private_model?)
+                    superclass.private_model?
+                end
+            end
+        end
+
+        # Declares that neither this model nor its subclasses should be sent to
+        # remote peers.
+        #
+        # I.e., from the point of view of our peers, instances of this model are
+        # actually instances of its superclass.
+        def private_model; @private_model = true end
+    end
+
+    class ::Module
+        # There are currently no way to make a module private
+        def private_model?; false end
+    end
+
+    # Base class for most plan-related objects (Plan, PlanObject, ...)
+    #
+    # This class contains the information and manipulation attributes that are
+    # at the core of Roby object management. In particular, it maintains the
+    # distributed object information (needed in multi-Roby setups).
+    class DistributedObject
+        # The ID of the local process
+        attr_reader :local_owner_id
+        # The set of Peer objects which own this object
+        attr_reader :owners
+
+        attr_predicate :self_owned?
+        
+        def initialize # :nodoc:
+            @owners = Array.new
+            @self_owned = true
+        end
+
+        def initialize_copy(old) # :nodoc:
+            super
+            @owners = Array.new
+        end
+
+        def add_owner(owner)
+            @owners << owner
+            @self_owned = @owners.include?(local_owner_id)
+        end
+
+        def remove_owner(owner)
+            @owners.delete(owner)
+            @self_owned = @owners.empty? || @owners.include?(local_owner_id)
+        end
+
+        # True if the given peer owns this object
+        def owned_by?(peer_id)
+            if peer_id == local_owner_id
+                self_owned?
+            else
+                owners.include?(peer_id)
+            end
+        end
+
+        def clear_owners
+            owners.clear
+            @self_owned = true
+        end
+    end
+end
+

data/lib/roby/droby.rb

@@ -0,0 +1,17 @@
+require 'roby/droby/identifiable'
+require 'roby/droby/v5'
+require 'roby/droby/droby_id'
+require 'roby/droby/peer_id'
+require 'roby/droby/remote_droby_id'
+require 'roby/droby/object_manager'
+require 'roby/droby/marshal'
+require 'roby/droby/event_logging'
+require 'roby/droby/null_event_logger'
+
+module Roby
+    module DRoby
+        extend Logger::Hierarchy
+        extend Logger::Forward
+    end
+end
+

data/lib/roby/droby/droby_id.rb

@@ -0,0 +1,6 @@
+module Roby
+    module DRoby
+        DRobyID = V5::DRobyID
+    end
+end
+

data/lib/roby/droby/enable.rb

@@ -0,0 +1,153 @@
+require 'roby/droby'
+
+Exception.extend  Roby::DRoby::V5::Builtins::ClassDumper
+Exception.extend  Roby::DRoby::Identifiable
+Exception.include Roby::DRoby::V5::Builtins::ExceptionDumper
+Array.include     Roby::DRoby::V5::Builtins::ArrayDumper
+Hash.include      Roby::DRoby::V5::Builtins::HashDumper
+Set.include       Roby::DRoby::V5::Builtins::SetDumper
+Thread.include    Roby::DRoby::Identifiable
+
+class Module
+    def droby_dump(dest)
+        raise "can't dump modules (#{self})"
+    end
+end
+class Class
+    def droby_dump(dest)
+        raise "can't dump class #{self}"
+    end
+end
+
+class NilClass
+    def droby_id
+    end
+end
+
+module Roby
+    class ExceptionBase
+        include DRoby::V5::ExceptionBaseDumper
+    end
+    class LocalizedError
+        include DRoby::V5::LocalizedErrorDumper
+    end
+    class PlanningFailedError
+        include DRoby::V5::PlanningFailedErrorDumper
+    end
+    class ExecutionException
+        include DRoby::V5::ExecutionExceptionDumper
+    end
+    module Relations
+        class BidirectionalDirectedAdjacencyGraph
+            include DRoby::V5::BidirectionalGraphDumper
+        end
+        class Graph
+            extend DRoby::Identifiable
+            extend DRoby::V5::DRobyConstant::Dump
+        end
+    end
+    module Models
+        class TaskServiceModel
+            include DRoby::Identifiable
+            include DRoby::V5::Models::TaskServiceModelDumper
+        end
+    end
+    class Event
+        include DRoby::V5::EventDumper
+    end
+
+    class PlanObject
+        include DRoby::Identifiable
+    end
+
+    class EventGenerator
+        extend DRoby::Identifiable
+        extend DRoby::V5::DRobyConstant::Dump
+        include DRoby::V5::EventGeneratorDumper
+    end
+
+    class TaskArguments
+        include DRoby::V5::TaskArgumentsDumper
+    end
+
+    class Task
+        extend DRoby::Identifiable
+        extend DRoby::V5::Models::TaskDumper
+        include DRoby::V5::TaskDumper
+    end
+    class TaskEventGenerator
+        include DRoby::V5::TaskEventGeneratorDumper
+    end
+    class DefaultArgument
+        include DRoby::V5::DefaultArgumentDumper
+    end
+    class DelayedArgumentFromObject
+        extend DRoby::V5::Builtins::ClassDumper
+        include DRoby::V5::DelayedArgumentFromObjectDumper
+    end
+    class Plan
+        include DRoby::Identifiable
+        include DRoby::V5::PlanDumper
+    end
+
+    module Actions
+        class Action
+            include DRoby::V5::Actions::ActionDumper
+        end
+        class Interface
+            extend DRoby::Identifiable
+            extend DRoby::V5::ModelDumper
+        end
+        module Models
+            class Action
+                include DRoby::V5::Actions::Models::ActionDumper
+                class Argument
+                    include DRoby::V5::Actions::Models::Action::ArgumentDumper
+                end
+            end
+
+            class MethodAction
+                include DRoby::V5::Actions::Models::MethodActionDumper
+            end
+
+            class CoordinationAction
+                include DRoby::V5::Actions::Models::CoordinationActionDumper
+            end
+        end
+    end
+
+    module Queries
+        class AndMatcher
+            include DRoby::V5::Queries::AndMatcherDumper
+        end
+
+        class ExecutionExceptionMatcher
+            include DRoby::V5::Queries::ExecutionExceptionMatcherDumper
+        end
+
+        class LocalizedErrorMatcher
+            include DRoby::V5::Queries::LocalizedErrorMatcherDumper
+        end
+
+        class NotMatcher
+            include DRoby::V5::Queries::NotMatcherDumper
+        end
+
+        class OrMatcher
+            include DRoby::V5::Queries::OrMatcherDumper
+        end
+
+        class PlanObjectMatcher
+            include DRoby::V5::Queries::PlanObjectMatcherDumper
+        end
+
+        class TaskMatcher
+            include DRoby::V5::Queries::TaskMatcherDumper
+        end
+
+        class Query
+            include DRoby::V5::Queries::QueryDumper
+        end
+    end
+end
+

data/lib/roby/droby/event_logger.rb

@@ -0,0 +1,189 @@
+module Roby
+    module DRoby
+        # Object that acts as an observer for ExecutablePlan, handling
+        # the droby marshalling/demarshalling. Dumping to IO is delegated to
+        # {#logfile}, a separate object that must provide a #dump method the way
+        # {Logfile::Writer} does
+        class EventLogger
+            # The object that will be given the cycles to be written
+            #
+            # @return [#dump]
+            attr_reader :logfile
+
+            # The set of events for the current cycle. This is dumped only
+            # when the +cycle_end+ event is received
+            attr_reader :current_cycle
+
+            # The object manager
+            #
+            # @return [DRoby::ObjectManager]
+            attr_reader :object_manager
+
+            # The marshalling object
+            #
+            # @return [DRoby::Marshal]
+            attr_reader :marshal
+
+            # The time spent logging so far
+            attr_reader :dump_time
+
+            # @!method stats_mode?
+            # @!method stats_mode=(flag)
+            #
+            # Controls whether the logger should only dump statistics, or the
+            # full set of plan events
+            attr_predicate :stats_mode, true
+
+            # @!method sync?
+            # @!method sync=(flag)
+            #
+            # Controls whether log data should be flushed on disk after each
+            # cycle. It is set by default. Disable for improved performance
+            # if the data will not be displayed live
+            #
+            # {Roby::Application} disables it by default if the log server is
+            # disabled
+            attr_predicate :sync?, true
+
+            # @param [#dump] marshal the object that transforms the arguments
+            #   into droby-compatible objects
+            # @param [Integer] queue_size if non-zero, the access to I/O will
+            #   be done in a separate thread, and this parameter is the maximum
+            #   amount of cycles that can be queued in a backlog until the
+            #   main thread waits on the logger
+            def initialize(logfile, queue_size: 50)
+                @stats_mode = false
+                @logfile = logfile
+                @object_manager = ObjectManager.new(nil)
+                @marshal = Marshal.new(object_manager, nil)
+                @current_cycle = Array.new
+                @sync = true
+                @dump_time = 0
+                @mutex = Mutex.new
+                if queue_size > 0
+                    @dump_queue  = SizedQueue.new(queue_size)
+                    @dump_thread = Thread.new(&method(:dump_loop))
+                end
+            end
+
+            def synchronize(&block)
+                @mutex.synchronize(&block)
+            end
+
+            def log_queue_size
+                if threaded? then @dump_queue.size
+                else 0
+                end
+            end
+
+            def threaded?
+                !!@dump_queue
+            end
+
+            def flush
+                if threaded?
+                    @dump_queue.push nil
+                    @dump_thread.join
+                    logfile.flush
+                    @dump_thread = Thread.new(&method(:dump_loop))
+                else
+                    logfile.flush
+                end
+            end
+
+            # Close this logger, flushing the remaining data to I/O
+            def close
+                dump(:cycle_end, Time.now, [Hash.new])
+                if threaded?
+                    @dump_queue.push nil
+                    @dump_thread.join
+                end
+
+            ensure
+                logfile.close
+            end
+
+            def append_message(m, time, args)
+                if m == :merged_plan
+                    plan_id, merged_plan = *args
+
+                    merged_plan.tasks.each do |t|
+                        object_manager.register_object(t)
+                    end
+                    merged_plan.free_events.each do |e|
+                        object_manager.register_object(e)
+                    end
+                    merged_plan.task_events.each do |e|
+                        object_manager.register_object(e)
+                    end
+                    args = [plan_id, merged_plan.droby_dump(marshal)]
+                elsif m == :finalized_task
+                    task = args[1]
+                    args = marshal.dump(args)
+                    object_manager.deregister_object(task)
+                elsif m == :finalized_event
+                    event = args[1]
+                    args = marshal.dump(args)
+                    object_manager.deregister_object(event)
+                else
+                    args = marshal.dump(args)
+                end
+
+                @current_cycle << m << time.tv_sec << time.tv_usec << args
+            end
+
+            def dump_timepoint(event, time, args)
+                return if stats_mode?
+
+                synchronize do
+                    @current_cycle << event << time.tv_sec << time.tv_usec << args
+                end
+            end
+
+            # Dump one log message
+            def dump(m, time, args)
+                return if stats_mode?
+
+                start = Time.now
+                synchronize do
+                    append_message(m, time, args)
+                end
+            ensure @dump_time += (Time.now - start)
+            end
+
+            def flush_cycle(*last_message)
+                start = Time.now
+                if threaded?
+                    if !@dump_thread.alive?
+                        @dump_thread.value
+                    end
+
+                    synchronize do
+                        append_message(*last_message)
+                        @dump_queue << @current_cycle
+                        @current_cycle = Array.new
+                    end
+                else
+                    append_message(*last_message)
+                    logfile.dump(@current_cycle)
+                    if sync?
+                        logfile.flush
+                    end
+                    @current_cycle.clear
+                end
+            ensure @dump_time += (Time.now - start)
+            end
+
+            # Main dump loop if the logger is threaded
+            def dump_loop
+                while cycle = @dump_queue.pop
+                    logfile.dump(cycle)
+                    if sync?
+                        logfile.flush
+                    end
+                end
+            end
+        end
+    end
+end
+