roby 0.7.3 → 0.8.0

data/lib/roby/app/plugins/rake.rb

@@ -0,0 +1,21 @@
+require 'roby/app/rake'
+
+module Roby
+    module Rake
+        ROBY_ROOT_DIR = ENV['ROBY_ROOT_DIR']
+
+        def self.plugin_doc(name)
+            require 'rdoc/task'
+
+            RDoc::Task.new("docs") do |rdoc|
+                rdoc.rdoc_dir = "#{ROBY_ROOT_DIR}/doc/html/plugins/#{name}"
+
+                yield(rdoc)
+            end
+        rescue LoadError => e
+            STDERR.puts "cannot generate documentation for #{name}:"
+            STDERR.puts "  #{e.message}"
+        end
+    end
+end
+

data/lib/roby/app/rake.rb

@@ -1,12 +1,7 @@
-require 'roby/support'
-
 module Roby
     # This module contains some tools used in the Rakefile of both Roby core
     # and plugins
     module Rake
-        extend Logger::Hierarchy
-        extend Logger::Forward
-
         # Returns the rdoc template path the documentation
         # generation should be using in Rakefile
         #
@@ -27,8 +22,6 @@ module Roby
                     Roby::Rake.info "using the #{ENV['ROBY_RDOC_TEMPLATE']} template"
                     ENV['ROBY_RDOC_TEMPLATE']
                 end
-            else
-                File.expand_path('doc/styles/jamis', ROBY_ROOT_DIR)
             end
         end
 

data/lib/roby/app/run.rb

@@ -1,4 +1,4 @@
-require 'roby/app'
+require 'roby'
 
 app = Roby.app
 require 'optparse'

data/lib/roby/app/scripts/distributed.rb

@@ -1,5 +1,4 @@
-require 'roby/distributed/connection_space'
-require 'roby/distributed/protocol'
+require 'roby/distributed'
 
 config = Roby.app
 config.setup

data/lib/roby/app/scripts/generate/bookmarks.rb

@@ -33,7 +33,7 @@ class Roby::Log::EventMatcher
     end
 
     def event(m, sec, usec, args)
-	if m == :discovered_tasks || m == :discovered_events
+	if m == :added_tasks || m == :added_events
 	    objects = args[1]
 	    for object in objects
 		for remote_id in object.remote_siblings.values

data/lib/roby/app/scripts/results.rb

@@ -1,4 +1,5 @@
 require 'roby'
+require 'fileutils'
 Roby.app.setup
 app = Roby.app
 
@@ -8,7 +9,7 @@ if Dir.enum_for(:glob, File.join(app.log_dir, "*")).to_a.empty?
     exit 0
 end
 
-user_path = ARGV.shift
+user_path = ARGV.shift || ''
 final_path = Roby::Application.unique_dirname(Roby.app.results_dir, user_path)
 puts "moving #{app.log_dir} to #{final_path}"
 FileUtils.mv app.log_dir, final_path

data/lib/roby/app/scripts/run.rb

@@ -6,9 +6,13 @@ app.robot robot_name, (ARGV.shift || robot_name)
 app.setup
 begin
     app.run do
-        Robot.info "loaded Roby #{Roby::VERSION}"
+        if defined? RUBY_DESCRIPTION
+            Robot.info "loaded Roby #{Roby::VERSION} on #{RUBY_DESCRIPTION}"
+        else
+            Robot.info "loaded Roby #{Roby::VERSION}"
+        end
+
 	# Load the controller
-	include Roby
 	Roby.execute do
 	    begin
 		controller_file = File.join(APP_DIR, "controllers", "#{app.robot_name}.rb")

data/lib/roby/app/scripts/shell.rb

@@ -1,7 +1,5 @@
 require 'roby'
-require 'roby/app'
 require 'roby/distributed'
-require 'roby/distributed/protocol'
 require 'optparse'
 
 require 'pp'
@@ -35,11 +33,14 @@ end
 DRb.start_service
 
 require 'irb'
+require 'irb/ext/save-history'
 IRB.setup(remote_url)
 IRB.conf[:INSPECT_MODE] = false
 IRB.conf[:IRB_NAME]     = remote_url
 IRB.conf[:PROMPT_MODE]  = :ROBY
 IRB.conf[:AUTO_INDENT] = true
+IRB.conf[:HISTORY_FILE] = File.join(APP_DIR, 'config', 'shell_history')
+IRB.conf[:SAVE_HISTORY] = 1000
 IRB.conf[:PROMPT][:ROBY] = {
     :PROMPT_I => "%N > ",
     :PROMPT_N => "%N > ",
@@ -48,7 +49,12 @@ IRB.conf[:PROMPT][:ROBY] = {
     :RETURN => "=> %s\n"
 }
 
-control = Roby::RemoteInterface.new(DRbObject.new_with_uri("druby://#{remote_url}"))
+control = begin
+              Roby::RemoteInterface.new(DRbObject.new_with_uri("druby://#{remote_url}"))
+          rescue DRb::DRbConnError
+              STDERR.puts "cannot connect to a Roby controller at #{remote_url}, is the controller started ?"
+              exit(1)
+          end
 
 begin
     # Make control the top-level object
@@ -57,11 +63,7 @@ begin
     irb = IRB::Irb.new(ws)
 
     context = irb.context
-    def context.evaluate(*args, &block)
-	Roby.execute do
-	    super
-	end
-    end
+    context.save_history = 100
     IRB.conf[:MAIN_CONTEXT] = irb.context
 
     trap("SIGINT") do
@@ -87,10 +89,8 @@ begin
 		    end
 		end
 	    end
-	rescue
+	rescue Exception => e
 	    STDERR.puts $!.full_message
-	ensure
-	    STDERR.puts "message polling died"
 	end
     end
 

data/lib/roby/config.rb

@@ -8,7 +8,7 @@ try it on 1.9, checkout the 1.9 branch of the development repository on github
 end
 
 module Roby
-    VERSION = '0.7.3'
+    VERSION = '0.8.0'
     ROBY_LIB_DIR  = File.expand_path( File.join(File.dirname(__FILE__), '..') )
     ROBY_ROOT_DIR = File.expand_path( File.join(ROBY_LIB_DIR, '..') )
 end

data/lib/roby/decision_control.rb

@@ -1,17 +1,76 @@
 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
+
+        # Called when a transaction/execution conflict occured, where a task
+        # included in the transaction has been removed from the plan.
+        #
+        # +proxy+ is the transaction's representation of the task which has
+        # been removed and +transaction+ the transaction. The transaction has
+        # been invalidated prior to this call, and the task proxy has been
+        # removed from +transaction+.
+        #
+        # The default action is to do nothing
+        def finalized_plan_task(transaction, proxy)
+        end
+
+        # Called when a transaction/execution conflict occured, where a task
+        # included in the transaction has been removed from the plan.
+        #
+        # +proxy+ is the transaction representation of the event which has been
+        # removed and +transaction+ the transaction. The transaction has been
+        # invalidated prior to this call, and the event proxy has been removed
+        # from +transaction+.
+        #
+        # The default action is to do nothing
+        def finalized_plan_event(transaction, proxy)
+	end
+
+        # Called when a transaction/execution conflict occured, where relations
+        # have been added in the plan and are not present in the transaction.
+        #
+        # The new relations are of types +relations+, between +parent+ and
+        # +child+ and with +info+ as info object. The transaction has been
+        # invalidated prior to this call
+        #
+        # The default action is to do nothing
+	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
+        # transaction.
+        #
+        # The relations are of types +relations+, between +parent+ and +child+
+        # and with +info+ as info object. The transaction has been invalidated
+        # prior to this call
+        #
+        # The default action is to do nothing
+	def removing_plan_relation(transaction, parent, child, relations)
+        end
     end
 
     class << self
-	attr_reader :decision_control
-    end
+	attr_reader :control
 
-    @decision_control = DecisionControl.new
+        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"
+            end
+
+            @control = new
+        end
+    end
 end
 

data/lib/roby/distributed.rb

@@ -1,6 +1,10 @@
 require 'roby'
+require 'stringio'
+require 'roby/planning'
+require 'roby_marshalling'
 require 'roby/distributed/drb'
 require 'roby/distributed/protocol'
+require 'roby/distributed/base'
 
 require 'roby/distributed/proxy'
 require 'roby/distributed/connection_space'

data/lib/roby/distributed/base.rb

@@ -198,6 +198,14 @@ module Roby
 			logger.progname = "Roby"
 		    end
 		end
+
+                if !Roby.plan
+                    Roby.instance_variable_set :@plan, new_state.plan
+                    Roby.instance_variable_set :@engine, new_state.plan.engine
+                elsif new_state && Roby.plan != new_state.plan
+                    raise ArgumentError, "plan mismatch between Roby.plan(#{plan}) and new_state.plan(#{new_state.plan}). Cannot set Distributed.state"
+                end
+
 		@state = new_state
 	    end
 

data/lib/roby/distributed/communication.rb

@@ -46,11 +46,11 @@ module Roby
 
 	    # Connect to +neighbour+ and return the corresponding peer. It is a
 	    # blocking method, so it is an error to call it from within the control thread
-	    def self.connect(neighbour)
+	    def self.connect(neighbour, connection_space = Distributed.state)
 		Roby.condition_variable(true) do |cv, mutex|
 		    peer = nil
 		    mutex.synchronize do
-			thread = initiate_connection(Distributed.state, neighbour) do |peer|
+			thread = initiate_connection(connection_space, neighbour) do |peer|
 			    return peer unless thread
 			end
 
@@ -339,7 +339,7 @@ module Roby
 		    socket.close unless socket.closed?
 		end
 
-		Roby.once do
+		engine.once do
 		    task.emit(event)
 		end
 	    end
@@ -560,7 +560,7 @@ module Roby
 		    return yield
 		end
 
-		Roby.execute do
+		peer.engine.execute do
 		    error = nil
 		    begin
 			result = yield
@@ -598,7 +598,7 @@ module Roby
 	    def check_marshallable(object, stack = ValueSet.new)
 		if !object.kind_of?(DRbObject) && object.respond_to?(:each) && !object.kind_of?(String)
 		    if stack.include?(object)
-			Roby.warn "recursive marshalling of #{obj}"
+			Roby::Distributed.warn "recursive marshalling of #{obj}"
 			raise "recursive marshalling"
 		    end
 
@@ -703,6 +703,7 @@ module Roby
 		    Distributed.debug { "#{call_spec.is_callback ? 'adding callback' : 'queueing'} [#{call_spec.message_id}]#{remote_name}.#{call_spec.method}" }
 		    current_cycle    << [call_spec.is_callback, call_spec.method, call_spec.formatted_args, !waiting_thread, call_spec.message_id]
 		    if sync? || CYCLE_END_CALLS.include?(m)
+                        Distributed.debug "transmitting #{@current_cycle.size} calls"
 			send_queue << current_cycle
 			@current_cycle = Array.new
 		    end
@@ -728,7 +729,7 @@ module Roby
             # called in the communication thread when the call succeeds, with
             # the returned value as argument.
 	    def transmit(m, *args, &block)
-		is_callback = Roby.inside_control? && local_server.processing?
+		is_callback = engine.inside_control? && local_server.processing?
 		if is_callback && local_server.processing_callback?
 		    raise RecursiveCallbacksError, "cannot queue callback #{m}(#{args.join(", ")}) while serving one"
 		end
@@ -748,8 +749,8 @@ module Roby
 	    # Note that it is forbidden to use this method in control or
 	    # communication threads, as it would make the application deadlock
 	    def call(m, *args, &block)
-		if !Roby.outside_control? || Roby::Control.taken_mutex?
-		    raise "cannot use Peer#call in control thread or while taking the Roby::Control mutex"
+		if !engine.outside_control? || Roby.taken_global_lock?
+		    raise "cannot use Peer#call in control thread or while taking the Roby global lock"
 		end
 
 		result = nil
@@ -782,6 +783,8 @@ module Roby
 		data   = nil
 		buffer = StringIO.new(" " * 8, 'w')
 
+                Roby::Distributed.debug "starting communication loop to #{self}"
+
 		loop do
 		    data ||= send_queue.shift
 		    return if disconnected?
@@ -789,6 +792,7 @@ module Roby
 		    # Wait for the link to be alive before sending anything
 		    while !link_alive?
 			return if disconnected?
+                        Roby::Distributed.info "#{self} is out of reach. Waiting before transmitting"
 			connection_space.wait_next_discovery
 		    end
 		    return if disconnected?

data/lib/roby/distributed/connection_space.rb

@@ -69,7 +69,7 @@ module Roby
         #
         # This makes Roby::Distributed behave like a Peer object
 	def self.transmit(*args)
-	    Roby::Control.once do
+	    Roby.once do
 		result = Distributed.state.send(*args)
 		yield(result) if block_given?
 	    end
@@ -140,6 +140,8 @@ module Roby
 	    def synchronize; mutex.synchronize { yield } end
 	    # The plan we are publishing, usually Roby.plan
 	    attr_reader :plan
+            # The execution engine tied to +plan+, or nil if there is none
+            def engine; plan.engine end
 
 	    # Our name on the network
 	    attr_reader :name
@@ -190,6 +192,7 @@ module Roby
 		@start_discovery      = ConditionVariable.new
 		@finished_discovery   = ConditionVariable.new
 		@new_neighbours	      = Queue.new
+                @new_neighbours_observers = Array.new
 
 		@connection_listeners = Array.new
 
@@ -222,9 +225,21 @@ module Roby
 		end
 		start_neighbour_discovery(true)
 
-		receive
-
-		Roby::Control.finalizers << method(:quit)
+                @discovery_start_handler = engine.add_propagation_handler do |plan|
+                    start_neighbour_discovery
+                    notify_new_neighbours
+                end
+		engine.finalizers << method(:quit)
+                engine.at_cycle_end do
+                    peers.each_value do |peer|
+                        if peer.connected?
+                            peer.transmit(:state_update, Roby::State) 
+                        end
+                    end
+                end
+
+                # Finally, start the reception thread
+                receive
 	    end
 
 	    # Sets up a separate thread which listens for connection
@@ -357,7 +372,7 @@ module Roby
 		loop do
 		    return if @quit_neighbour_thread
 
-		    Control.synchronize do
+		    Roby.synchronize do
 			old_neighbours, @neighbours = @neighbours, []
 			for new in discovered
 			    unless new.remote_id == remote_id || @neighbours.include?(new)
@@ -380,13 +395,12 @@ module Roby
 			end
 			return if @quit_neighbour_thread
 			discovery_start = @discovery_start
-
-			if ring_discovery? && (!finger || (finger.port != discovery_port))
-			    finger = Rinda::RingFinger.new(ring_broadcast, discovery_port)
-			end
 		    end
 
 		    from = Time.now
+                    if ring_discovery? && (!finger || (finger.port != discovery_port))
+                        finger = Rinda::RingFinger.new(ring_broadcast, discovery_port)
+                    end
 		    if central_discovery?
 			discovery_tuplespace.read_all([:droby, nil, nil]).
 			    each do |n| 
@@ -396,11 +410,11 @@ module Roby
 			    end
 		    end
 
-		    if discovery_period
-			remaining = (@discovery_start + discovery_period) - Time.now
-		    end
-
 		    if ring_discovery?
+                        if discovery_period
+                            remaining = (@discovery_start + discovery_period) - Time.now
+                        end
+
 			finger.lookup_ring(remaining) do |cs|
 			    next if cs == self
 
@@ -422,7 +436,7 @@ module Roby
 		# Force disconnection in case something got wrong in the normal
 		# disconnection process
 		Distributed.peers.values.each do |peer|
-		    peer.disconnected unless peer.disconnected?
+		    peer.disconnected! unless peer.disconnected?
 		end
 
 		synchronize do
@@ -439,7 +453,7 @@ module Roby
 		    end
 
 		    @discovery_start = Time.now
-		    start_discovery.signal
+		    start_discovery.broadcast
 		end
 		wait_discovery if block
 	    end
@@ -464,6 +478,9 @@ module Roby
             # Make the ConnectionSpace quit
 	    def quit
 		Distributed.debug "ConnectionSpace #{self} quitting"
+                if @discovery_start_handler
+                    engine.remove_propagation_handler(@discovery_start_handler)
+                end
 
 		# Remove us from the central tuplespace
 		if central_discovery?
@@ -492,7 +509,7 @@ module Roby
 		    end
 		end
 
-		Roby::Control.finalizers.delete(method(:quit))
+		plan.engine.finalizers.delete(method(:quit))
 		if Distributed.state == self
 		    Distributed.state = nil
 		end
@@ -517,6 +534,30 @@ module Roby
 	    def transaction_discard(trsc) # :nodoc:
 		trsc.discard_transaction(false)
 	    end
+
+            def on_neighbour
+		current = neighbours.dup
+		engine.once { current.each { |n| yield(n) } }
+		new_neighbours_observers << lambda { |_, n| yield(n) }
+	    end
+
+            # The set of proc objects which should be notified when new
+            # neighbours are detected.
+	    attr_reader :new_neighbours_observers
+	    
+            # Called in the neighbour discovery thread to detect new
+            # neighbours. It fills the new_neighbours queue which is read by
+            # notify_new_neighbours to notify application code of new
+            # neighbours in the control thread
+	    def notify_new_neighbours
+		while !new_neighbours.empty?
+		    cs, neighbour = new_neighbours.pop(true)
+		    new_neighbours_observers.each do |obs|
+			obs[cs, neighbour]
+		    end
+		end
+	    end
+
 	end
 
 	class << self
@@ -563,37 +604,13 @@ module Roby
 		else []
 		end
 	    end
-	end
-
-	@new_neighbours_observers = Array.new
-	class << self
-            # The set of proc objects which should be notified when new
-            # neighbours are detected.
-	    attr_reader :new_neighbours_observers
-	    
-            # Called in the neighbour discovery thread to detect new
-            # neighbours. It fills the new_neighbours queue which is read by
-            # notify_new_neighbours to notify application code of new
-            # neighbours in the control thread
-	    def notify_new_neighbours
-		return unless Distributed.state
-		while !new_neighbours.empty?
-		    cs, neighbour = new_neighbours.pop(true)
-		    new_neighbours_observers.each do |obs|
-			obs[cs, neighbour]
-		    end
-		end
-	    end
-
+            
             # Defines a block which should be called when a new neighbour is
             # detected
-	    def on_neighbour
-		current = neighbours.dup
-		Roby::Control.once { current.each { |n| yield(n) } }
-		new_neighbours_observers << lambda { |_, n| yield(n) }
-	    end
+            #
+            # See ConnectionSpace#on_neighbour
+            def on_neighbour(&block); Roby::Distributed.state.on_neighbour(&block) end
 	end
-	Roby::Control.event_processing << method(:notify_new_neighbours)
     end
 end