roby 0.7.3 → 0.8.0

data/lib/roby/relations/planned_by.rb

@@ -1,5 +1,3 @@
-require 'roby/task'
-
 module Roby::TaskStructure
     relation :PlannedBy, :child_name => :planning_task, 
 	:parent_name => :planned_task, :noinfo => true, :single_child => true do
@@ -21,7 +19,7 @@ module Roby::TaskStructure
 
     # Returns a set of PlanningFailedError exceptions for all abstract tasks
     # for which planning has failed
-    def PlannedBy.check_planning(plan)
+    def PlannedBy.check_structure(plan)
 	result = []
 	Roby::TaskStructure::PlannedBy.each_edge do |planned_task, planning_task, _|
 	    next unless plan == planning_task.plan && planning_task.failed?
@@ -43,21 +41,23 @@ module Roby
 
 	def initialize(planned_task, planning_task)
 	    @planned_task = planned_task
-	    super(planning_task.terminal_event)
+	    super(planning_task.failure_event)
 	end
+        def pretty_print(pp)
+            pp.text "failed to plan "
+            planned_task.pretty_print(pp)
+            pp.breakable
+            pp.breakable
+            pp.text "the following planning task failed with the #{failure_point.symbol} event"
+            pp.breakable
+            failed_task.pretty_print(pp)
+            pp.breakable
 
-	def message # :nodoc:
-	    msg = "failed to plan #{planned_task}.planned_by(#{failed_task}): failed with #{failure_point.symbol}"
 	    if failure_point.context
-		if failure_point.context.first.respond_to?(:full_message)
-		    msg << "\n" << failure_point.context.first.full_message
-		else
-		    msg << "(" << failure_point.context.first.to_s << ")"
-		end
+                pp.breakable
+                failure_point.context.first.pretty_print(pp)
 	    end
-	    msg
-	end
+        end
     end
-    Control.structure_checks << TaskStructure::PlannedBy.method(:check_planning)
 end
 

data/lib/roby/robot.rb

@@ -3,5 +3,51 @@ module Robot
 	attr_accessor :logger
     end
     extend Logger::Forward
+
+    def self.prepare_action(name, arguments)
+	# Check if +name+ is a planner method, and in that case
+	# add a planning method for it and plan it
+	planner_model = Roby.app.planners.find do |planner_model|
+	    planner_model.has_method?(name)
+	end
+	if !planner_model
+	    raise ArgumentError, "no such planning method #{name}"
+	end
+
+	m = planner_model.model_of(name, arguments)
+
+	# HACK: m.returns should not be nil, but it sometimes happen
+	returns_model = (m.returns if m && m.returns) || Task
+
+	if returns_model.kind_of?(Roby::TaskModelTag)
+	    task = Roby::Task.new
+	    task.extend returns_model
+	else
+	    # Create an abstract task which will be planned
+	    task = returns_model.new
+	end
+
+	planner = Roby::PlanningTask.new(:planner_model => planner_model, :method_name => name, :method_options => arguments)
+	task.planned_by planner
+	return task, planner
+    end
+
+    def self.method_missing(name, *args)
+	if name.to_s =~ /!$/
+	    name = $`.to_sym
+	else
+	    super
+	end
+
+	if args.size > 1
+	    raise ArgumentError, "wrong number of arguments (#{args.size} for 1) in #{name}!"
+	end
+
+	options = args.first || {}
+	task, planner = Robot.prepare_action(name, options)
+	Roby.plan.add_mission(task)
+
+	return task, planner
+    end
 end
 

data/lib/roby/schedulers/basic.rb

@@ -0,0 +1,34 @@
+module Roby
+    module Schedulers
+	class Basic
+	    attr_reader :query
+            attr_reader :include_children
+	    def initialize(include_children = false)
+                @include_children = include_children
+		@query = Roby.plan.find_tasks.
+		    executable.
+		    pending.
+		    self_owned
+	    end
+	    def initial_events
+		for task in query.reset
+		    if !(task.event(:start).root? && task.event(:start).controlable?)
+                        next
+                    end
+
+		    root_task =
+                        if task.root?(TaskStructure::Dependency)
+			    true
+                        else
+			    task.planned_tasks.all? { |t| !t.executable? }
+			end
+
+		    if root_task || (include_children && task.parents.any? { |t| t.running? })
+			task.start!
+		    end
+		end
+	    end
+	end
+    end
+end
+

data/lib/roby/standalone.rb

@@ -0,0 +1,4 @@
+require 'roby'
+Dir.chdir(APP_DIR)
+Roby.app.setup_global_singletons
+

data/lib/roby/standard_errors.rb

@@ -1,4 +1,3 @@
-require 'pp'
 module Roby
     # This kind of errors are generated during the plan execution, allowing to
     # blame a fault on a plan object (#failure_point). The precise failure
@@ -76,6 +75,11 @@ module Roby
     # Raised when a consistency check failed in the Roby propagation code
     class PropagationError < InternalError; end
 
+    # Some operations need to be performed in the control thread, and some
+    # other (namely blocking operations) must not. This exception is raised
+    # when this constraint is not met.
+    class PhaseMismatch < RuntimeError; end
+
     # Some operations need to be performed in the control thread, and some
     # other (namely blocking operations) must not. This exception is raised
     # when this constraint is not met.
@@ -136,21 +140,25 @@ module Roby
     # Raised when an event has become unreachable while other parts of the plan
     # where waiting for its emission.
     class UnreachableEvent < LocalizedError
-        # The generator which has become unreachable
-	attr_reader :generator
+        # Why did the generator become unreachable
+        attr_reader :reason
+
         # Create an UnreachableEvent error for the given +generator+. +reason+
         # is supposed to be either nil or a plan object which is the reason why
         # +generator+ has become unreachable.
 	def initialize(generator, reason)
-	    @generator = generator
-	    super(reason || generator)
+            @reason    = reason
+	    super(generator)
 	end
 
 	def pretty_print(pp) # :nodoc:
-            pp.text "#{generator} has become unreachable"
-	    if failure_point
-		pp.breakable ':'
-                failure_point.pretty_print(pp)
+            pp.text "#{failed_generator} has become unreachable"
+	    if reason
+                reason = [*reason]
+                reason.each do |e|
+                    pp.breakable
+                    e.pretty_print(pp)
+                end
             end
 	end
     end
@@ -180,12 +188,10 @@ module Roby
 	attr_reader :from
         # The task which should have replaced #from
         attr_reader :to
-        # A description of the replacement failure
-        attr_reader :error
 
         # Create a new InvalidReplace object
-	def initialize(from, to, error)
-	    @from, @to, @error = from, to, error
+	def initialize(from, to)
+	    @from, @to = from, to
 	end
         def pretty_print(pp) # :nodoc:
             pp.text "invalid replacement: #{message}"
@@ -202,7 +208,7 @@ module Roby
     class MissionFailedError < LocalizedError
         # Create a new MissionFailedError for the given mission
 	def initialize(task)
-	    super(task.terminal_event)
+	    super(task.failure_event || task)
 	end
 
         def pretty_print(pp)
@@ -213,6 +219,6 @@ module Roby
 
     # Exception raised in threads which are waiting for the control thread
     # See for instance Roby.execute
-    class ControlQuitError < RuntimeError; end
+    class ExecutionQuitError < RuntimeError; end
 end
 

data/lib/roby/state/events.rb

@@ -61,15 +61,16 @@ module Roby
         end
     end
 
-    # Registered on Control to call the #poll method of state events
-    def self.poll_state_events # :nodoc:
-        for ev in Roby.plan.free_events
+    # Registered on the execution engines to call the #poll method of state
+    # events
+    def self.poll_state_events(plan) # :nodoc:
+        for ev in plan.free_events
             if ev.kind_of?(StateEvent) && ev.enabled?
                 ev.poll
             end
         end
     end
-    Roby::Control.each_cycle(&Roby.method(:poll_state_events))
+    Roby::ExecutionEngine.propagation_handlers << Roby.method(:poll_state_events)
 
     # A state event is an event which emits when some parameters over the state
     # are reached. See DeltaEvent and TimePointEvent.

data/lib/roby/support.rb

@@ -1,9 +1,6 @@
-require 'active_support/inflector'
-class String # :nodoc: all
-    include ActiveSupport::CoreExtensions::String::Inflections
-end
-
 require 'roby/config'
+require 'facets/string/camelcase'
+require 'facets/string/snakecase'
 require 'facets/kernel/constant'
 require 'utilrb/enumerable'
 require 'utilrb/time/to_hms'
@@ -45,11 +42,11 @@ module Enumerable
 end
 
 class Module
-    # Defines a new constant under a given module
     # :call-seq
     #   define_under(name, value)   ->              value
     #   define_under(name) { ... }  ->              value
     #
+    # Defines a new constant under a given module
     # In the first form, the method gets its value from its argument. 
     # In the second case, it calls the provided block
     def define_under(name, value = nil)
@@ -88,5 +85,109 @@ module Roby
 
     extend Logger::Hierarchy
     extend Logger::Forward
+
+    class Pool < Queue
+	def initialize(klass)
+	    @klass = klass
+            super()
+	end
+
+	def pop
+	    value = super(true) rescue nil
+	    value || @klass.new
+	end
+    end
+
+    @mutexes = Pool.new(Mutex)
+    @condition_variables = Pool.new(ConditionVariable)
+    class << self
+        # A pool of mutexes (as a Queue)
+        attr_reader :mutexes
+        # A pool of condition variables (as a Queue)
+        attr_reader :condition_variables
+    end
+
+    # call-seq:
+    #   condition_variable => cv
+    #   condition_variable(true) => cv, mutex
+    #   condition_variable { |cv| ... } => value returned by the block
+    #   condition_variable(true) { |cv, mutex| ... } => value returned by the block
+    #
+    # Get a condition variable object from the Roby.condition_variables
+    # pool and, if mutex is not true, a Mutex object
+    #
+    # If a block is given, the two objects are yield and returned into the
+    # pool after the block has returned. In that case, the method returns
+    # the value returned by the block
+    def self.condition_variable(mutex = false)
+        cv = condition_variables.pop
+
+        if block_given?
+            begin
+                if mutex
+                    mt = mutexes.pop
+                    yield(cv, mt)
+                else
+                    yield(cv)
+                end
+
+            ensure
+                return_condition_variable(cv, mt)
+            end
+        else
+            if mutex
+                return cv, mutexes.pop
+            else
+                return cv
+            end
+        end
+    end
+
+    # Returns a ConditionVariable and optionally a Mutex into the
+    # Roby.condition_variables and Roby.mutexes pools
+    def self.return_condition_variable(cv, mutex = nil)
+        condition_variables.push cv
+        if mutex
+            mutexes.push mutex
+        end
+        nil
+    end
+
+    @global_lock = Mutex.new
+    class << self
+        # This Mutex object is locked during the event propagation loop, and
+        # unlock while this loop is sleeping. It is used to wait for the
+        # availability of the main plan.
+        attr_reader :global_lock
+    end
+
+    def self.taken_global_lock?; Thread.current[:global_lock_taken] end
+
+    # Implements a recursive behaviour on Roby.mutex
+    def self.synchronize
+        if Thread.current[:global_lock_taken]
+            yield
+        else
+            global_lock.lock
+            begin
+                Thread.current[:global_lock_taken] = true
+                yield
+            ensure
+                Thread.current[:global_lock_taken] = false
+                global_lock.unlock
+            end
+        end
+    end
+
+    class << self
+        attr_accessor :enable_deprecation_warnings
+    end
+    @enable_deprecation_warnings = true
+
+    def self.warn_deprecated(msg)
+        if enable_deprecation_warnings
+            Roby.warn "Deprecation Warning: #{msg} at #{caller[1]}"
+        end
+    end
 end
 

data/lib/roby/task-operations.rb

@@ -1,5 +1,3 @@
-require 'roby/task'
-
 module Roby
     module TaskOperations
         def +(task)
@@ -60,31 +58,34 @@ module Roby
 	def to_task(task = nil)
 	    return super() unless task
 	    task = task.new unless task.kind_of?(Roby::Task)
-	    @tasks.each { |t| task.realized_by t }
+	    @tasks.each { |t| task.depends_on t }
 
-	    task.on(:start, @tasks.first, :start)
-	    @tasks.last.forward(:success, task, :success)
+	    task.signals(:start, @tasks.first, :start)
+	    @tasks.last.forward_to(:success, task, :success)
 
 	    delete
 
 	    task
 	end
+        def child_of(task = nil)
+            to_task(task)
+        end
 
 	def connect_start(task)
 	    if old = @tasks.first
 		event(:start).remove_signal old.event(:start)
-		task.on(:success, old, :start)
+		task.signals(:success, old, :start)
 	    end
 
-	    event(:start).on task.event(:start)
+	    event(:start).signals task.event(:start)
 	end
 
 	def connect_stop(task)
 	    if old = @tasks.last
-		old.on(:success, task, :start)
+		old.signals(:success, task, :start)
 		old.event(:success).remove_forwarding event(:success)
 	    end
-	    task.forward(:success, self)
+	    task.forward_to(:success, self, :success)
 	end
 	private :connect_stop, :connect_start
 
@@ -94,7 +95,7 @@ module Roby
 	    connect_stop(task) if @tasks.empty?
 
             @tasks.unshift(task)
-	    realized_by task
+	    depends_on task
 	    self
         end
 
@@ -104,7 +105,7 @@ module Roby
 	    connect_stop(task)
 	    
 	    @tasks << task
-	    realized_by task
+	    depends_on task
 	    self
         end
 
@@ -121,16 +122,19 @@ module Roby
 	    super
 
 	    @children_success = Roby::AndGenerator.new
-	    @children_success.forward event(:success)
+	    @children_success.forward_to event(:success)
         end
 
+        def child_of(task = nil)
+            to_task(task)
+        end
 	def to_task(task = nil)
 	    return super() unless task
 
 	    task = task.new unless task.kind_of?(Roby::Task)
 	    @tasks.each do |t| 
-		task.realized_by t
-		task.on(:start, t, :start)
+		task.depends_on t
+		task.signals(:start, t, :start)
 	    end
 	    task.event(:success).emit_on children_success
 
@@ -143,8 +147,8 @@ module Roby
 	    raise "trying to change a running parallel task" if running?
             @tasks << task
 
-	    on(:start, task, :start)
-	    realized_by task
+	    signals(:start, task, :start)
+	    depends_on task
 	    children_success << task.event(:success)
 
             self
@@ -162,10 +166,10 @@ module Roby
 
 	    success = AndGenerator.new
 	    tasks.each do |task|
-		realized_by task
-		task.event(:success).on success
+		depends_on task
+		task.event(:success).signals success
 	    end
-	    success.forward event(:success)
+	    success.forward_to event(:success)
 	end
 
 	event :start do