roby 0.8.0 → 3.0.0

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

@@ -1,31 +0,0 @@
-require 'roby'
-require 'roby/log/gui/replay'
-app  = Qt::Application.new(ARGV)
-main = Replay.setup(ARGV)
-
-if ARGV.empty?
-    Roby.app.setup
-
-    streams = Roby.app.data_streams(Roby.app.log_dir)
-    streams.each do |stream|
-	stream.open
-	main.add_stream(stream)
-    end
-else
-    ARGV.each do |file|
-	if streams = Roby.app.data_source([file])
-	    streams.each { |s| s.open }
-	    main.add_stream(streams)
-	else
-	    STDERR.puts "WARN: unknown file type #{file}"
-	end
-    end
-end
-
-begin
-    main.show
-    app.exec
-rescue
-    STDERR.puts $!.full_message
-end
-

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

@@ -1,18 +0,0 @@
-require 'roby/log/server'
-
-app = Roby.app
-app.setup
-DRb.start_service "druby://:0"
-
-begin
-    app.start_server
-
-    Roby::Log::Server.info "ready"
-    sleep
-rescue Interrupt
-ensure
-    Roby::Log::Server.info "quitting"
-    app.stop_server
-end
-Roby::Log::Server.info "quit"
-

data/lib/roby/basic_object.rb

@@ -1,151 +0,0 @@
-module Roby
-    class BasicObject
-	include DRbUndumped
-
-	def initialize_copy(old) # :nodoc:
-	    super
-
-	    @remote_siblings = Hash[Distributed, Roby::Distributed::RemoteID.from_object(self)]
-	end
-
-	# The set of Peer objects which own this object
-	attribute(:owners) { [Distributed] }
-	# True if we own this object
-	def self_owned?; owners.include?(Distributed) end
-
-	# Attribute which overrides the #distribute attribute on object classes
-	attr_writer :distribute
-	# True if this object can be seen by remote hosts
-	def distribute?
-	    @distribute || (@distribute.nil? && self.class.distribute?)
-	end
-
-	# True if instances of this class should be seen by remote hosts
-	def self.distribute?; !(@distribute == false) end
-	# Call to make the object of this class never seen by remote hosts
-	def self.local_only; @distribute = false end
-
-	def finalized?; !remote_siblings[Distributed] end
-	
-	# The peer => remote_object hash of known siblings for this peer: if
-	# there is a representation of this object on a peer, then
-	# +remote_siblings+ includes it
-	attribute(:remote_siblings) { Hash[Distributed, remote_id] }
-
-	# True if we know about a sibling on +peer+
-	def has_sibling_on?(peer)
-	    peer == Roby::Distributed || remote_siblings.include?(peer)
-	end
-
-	# Returns the object representation of +self+ on +peer+. The returned
-	# value is either a remote sibling (the DRbObject of the representation 
-	# of +self+ on +peer+), or self if peer is Roby::Distributed
-	def sibling_on(peer)
-	    if sibling = remote_siblings[peer] then sibling
-	    elsif Roby::Distributed == peer then self
-	    else 
-		raise RemotePeerMismatch, "#{self} has no known sibling on #{peer}"
-	    end
-	end
-
-	# Sets +remote_object+ as the remote siblings for +self+ on +peer+, and
-	# notifies peer that +self+ is the remote siblings for +remote_object+
-	def sibling_of(remote_object, peer)
-	    if !distribute?
-		raise ArgumentError, "#{self} is local only"
-	    end
-
-	    add_sibling_for(peer, remote_object)
-	    peer.transmit(:added_sibling, remote_object, remote_id)
-	end
-
-        # Called when all links to +peer+ should be removed.
-	def forget_peer(peer)
-	    if remote_object = remove_sibling_for(peer)
-		peer.removing_proxies[remote_object] << droby_dump(nil)
-
-		if peer.connected?
-		    peer.transmit(:removed_sibling, remote_object, self.remote_id) do
-			set = peer.removing_proxies[remote_object]
-			set.shift
-			if set.empty?
-			    peer.removing_proxies.delete(remote_object)
-			end
-			yield if block_given?
-		    end
-		else
-		    peer.removing_proxies.delete(remote_object)
-		end
-	    end
-	end
-
-	# Registers +remote_object+ as the sibling of +self+ on +peer+. Unlike
-	# #sibling_of, do not notify the peer about it.
-	def add_sibling_for(peer, remote_object)
-	    if old_sibling = remote_siblings[peer]
-		if old_sibling != remote_object
-		    raise ArgumentError, "#{self} has already a sibling for #{peer} (#{old_sibling}) #{remote_siblings}"
-		else
-		    # This is OK. The same sibling information can come from
-		    # different sources.  We only check for inconsistencies
-		    return
-		end
-	    end
-
-	    remote_siblings[peer] = remote_object
-	    peer.proxies[remote_object] = self
-	    Roby::Distributed.debug "added sibling #{remote_object.inspect} for #{self} on #{peer} (#{remote_siblings})"
-	end
-
-	# Remove references about the sibling registered for +peer+ and returns it
-	def remove_sibling_for(peer, id = nil)
-	    if id && remote_siblings[peer] != id
-		return
-	    end
-
-	    if remote_object = remote_siblings.delete(peer)
-		peer.proxies.delete(remote_object)
-		peer.subscriptions.delete(remote_object)
-		Roby::Distributed.debug "removed sibling #{remote_object.inspect} for #{self} on #{peer}"
-		remote_object
-	    end
-	end
-
-	# True if we explicitely want this object to be updated by our peers
-	def subscribed?; owners.any? { |peer| peer.subscribed?(self) if peer != Distributed } end
-
-        # Subscribe to this object on all the peers which own it.
-        #
-        # This is a blocking operation, and cannot be used in the control
-        # thread.
-	def subscribe
-	    if !self_owned? && !subscribed?
-		owners.each do |peer|
-		    peer.subscribe(self) unless peer.subcribed?(self)
-		end
-	    end
-	end
-
-	# True if this object is maintained up-to-date
-	def updated?; self_owned? || owners.any?(&remote_siblings.method(:[])) end
-	# True if +peer+ will send us updates about this object
-	def updated_by?(peer); self_owned? || (remote_siblings[peer] && peer.owns?(self)) end
-	# True if we shall send updates for this object on +peer+
-	def update_on?(peer); (self_owned? || peer.owns?(self)) && remote_siblings[peer] end
-	# The set of peers that will get updates of this object
-	def updated_peers
-	    peers = remote_siblings.keys
-	    peers.delete(Distributed) 
-	    peers
-	end
-
-	# True if this object is useful for our peers
-	def remotely_useful?; self_owned? && remote_siblings.size > 1  end
-	
-	# True if this object can be modified in the current context
-	def read_write?
-	    owners.include?(Distributed) || Distributed.updating?(self)
-	end
-    end
-end
-

data/lib/roby/config.rb

@@ -1,14 +0,0 @@
-if RUBY_VERSION >= "1.9"
-    STDERR.puts <<-EOB
-The stable version of Roby is not compatible with 1.9. If you really want to
-try it on 1.9, checkout the 1.9 branch of the development repository on github
-(see README.txt for URLs)
-    EOB
-    exit(1)
-end
-
-module Roby
-    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/distributed.rb

@@ -1,36 +0,0 @@
-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'
-require 'roby/distributed/notifications'
-require 'roby/distributed/peer'
-require 'roby/distributed/transaction'
-
-# == Communication protocol (and code namespace structure)
-# == Getting remote objects
-# There is actually two ways to get a remote object
-# * the object has been explicitely subscribed to by calling Peer#subscribe
-# * the object has been sent to us because it is linked to an object we own
-#   or an object we are subscribed to
-#
-# In the first case, the object must be referenced in the first place. It can
-# have been sent to us as a query result (see Query), or because it has been
-# involved in a distributed transaction. In the second case, it is either us
-# which have added the relation, or the remote peer. If it is us, we should
-# have subscribed to the object, added the relation, and then we may
-# unsubscribe to the object.
-#
-# We forget about a remote object when Plan#garbage_collect removes it.
-#
-# == Subscription management
-# The pDB gets updated about all objects it is subscribed to.
-module Roby::Distributed
-end
-
-

data/lib/roby/distributed/base.rb

@@ -1,448 +0,0 @@
-require 'drb'
-
-# A thread-safe reference-counting class
-class RefCounting
-    def initialize
-	@values = Hash.new(0)
-	@mutex  = Mutex.new
-    end
-
-    # True if +obj+ is referenced
-    def ref?(obj); @mutex.synchronize { @values[obj] > 0 } end
-    # Dereference +obj+ by one
-    def deref(obj)
-	@mutex.synchronize do
-	    if (@values[obj] -= 1) == 0
-		@values.delete(obj)
-		return true
-	    end
-	end
-	false
-    end
-    # Add +1 to the reference count of +obj+
-    def ref(obj)
-	@mutex.synchronize do
-	    @values[obj] += 1
-	end
-    end
-    # Returns the set of referenced objects
-    def referenced_objects
-	@mutex.synchronize do
-	    @values.keys
-	end
-    end
-    # Remove +object+ from the set of referenced objects, regardless of its
-    # reference count
-    def delete(object)
-	@mutex.synchronize do
-	    @values.delete(object)
-	end
-    end
-end
-
-class Object
-    def initialize_copy(old) # :nodoc:
-	super
-	@__droby_remote_id__ = nil
-    end
-
-    # The Roby::Distributed::RemoteID for this object
-    def remote_id
-	@__droby_remote_id__ ||= Roby::Distributed::RemoteID.from_object(self)
-    end
-end
-
-class DRbObject
-    # We don't want this method to call the remote object.
-    def to_s
-        inspect 
-    end
-    # Converts this DRbObject into Roby::Distributed::RemoteID
-    def remote_id
-	@__droby_remote_id__ ||= Roby::Distributed::RemoteID.new(__drburi, __drbref)
-    end
-end
-
-module Roby
-    module Distributed
-	DISCOVERY_RING_PORT = 48901
-	DEFAULT_DROBY_PORT  = 48902
-
-	class InvalidRemoteOperation < RuntimeError; end
-
-	class InvalidRemoteTaskOperation < InvalidRemoteOperation
-	    attr_reader :task
-	    def initialize(task); @task = task end
-	end
-
-	extend Logger::Hierarchy
-	extend Logger::Forward
-
-	# RemoteID objects are used in dRoby to reference objects on other
-	# peers. It uses the same mechanisms that DRbObject but is not
-	# converted back into a local object automatically, and does not allow
-	# to call remote methods on a remote object.
-	class RemoteID
-	    # The URI of the DRb server
-	    attr_reader :uri
-	    # The reference ID of the object on the DRb server
-	    attr_reader :ref
-
-	    # Creates a new RemoteID with the given URI and ID
-	    def initialize(uri, ref)
-		@uri, @ref = uri, ref.to_int
-		@hash = [uri, ref].hash
-	    end
-
-	    def _dump(lvl) # :nodoc:
-	       	@__droby_marshalled__ ||= Marshal.dump([uri, ref]) 
-	    end
-	    def self._load(str) # :nodoc:
-	       	new(*Marshal.load(str)) 
-	    end
-
-	    def ==(other) # :nodoc:
-		other.kind_of?(RemoteID) && other.ref == ref && other.uri == uri
-	    end
-	    alias :eql? :==
-	    attr_reader :hash
-
-	    # True if this object references a local object
-	    def local?; DRb.here?(uri) end
-	    # If this ID references a local object, returns it. Otherwise, returns self.
-	    def local_object
-		if DRb.here?(uri)
-		    DRb.to_obj(ref)
-		else
-		    self
-		end
-	    end
-
-	    def to_s(peer = nil)
-		if peer
-		    "0x#{Object.address_from_id(ref).to_s(16)}@#{peer.name}"
-		else
-		    "0x#{Object.address_from_id(ref).to_s(16)}@#{uri}"
-		end
-	    end
-	    def inspect; to_s end
-	    def pretty_print(pp); pp.text to_s end
-
-	    def to_local(peer, create)
-		object = local_object
-		if object.kind_of?(RemoteID)
-		    if local_proxy = peer.proxies[object]
-			return peer.proxy_setup(local_proxy)
-		    elsif !create
-			return
-		    elsif peer.removing_proxies.has_key?(object)
-			marshalled_object = peer.removing_proxies[object].last
-			Distributed.debug "reusing marshalled #{marshalled_object} for #{self} from #{peer}"
-			marshalled_object.remote_siblings.delete(Distributed.droby_dump)
-			marshalled_object.remote_siblings[peer.droby_dump] = self
-
-			if marshalled_object.respond_to?(:plan) && !marshalled_object.plan
-			    # Take care of the "proxy is GCed while the peer
-			    # sends us messages about it" case. In this case,
-			    # the object has already been removed when it is
-			    # marshalled (#plan == nil).
-			    #
-			    # This cannot happen in transactions: it only happens
-			    # in plans where one side can remove an object while
-			    # the other side is doing something on it
-			    marshalled_object.instance_variable_set(:@plan, Roby.plan)
-			end
-
-			object = peer.local_object(marshalled_object)
-
-			if object.respond_to?(:plan) && !object.plan
-			    raise "#{object} has no plan !"
-			end
-
-			return object
-		    end
-		    raise ArgumentError, "#{self} has no proxy"
-		else
-		    object
-		end
-	    end
-
-	    private :remote_id
-
-	    # Returns the RemoteID object for +obj+. This is actually
-	    # equivalent to obj.remote_id
-	    def self.from_object(obj)
-		Roby::Distributed::RemoteID.new(DRb.current_server.uri, DRb.to_id(obj) || 0)
-	    end
-
-	    # Creates a DRbObject corresponding to the object referenced by this RemoteID
-	    def to_drb_object
-		DRbObject.new_with(uri, (ref == 0 ? nil : ref))
-	    end
-	end
-
-	@updated_objects = ValueSet.new
-	@allowed_remote_access = Array.new
-	@keep = RefCounting.new
-	@removed_objects = ValueSet.new
-	class << self
-            # The one and only ConnectionSpace object
-	    attr_reader :state
-
-            # Sets the #state attribute for Roby::Distributed
-	    def state=(new_state)
-		if log = logger
-		    if new_state
-			logger.progname = new_state.name
-		    else
-			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
-
-            # True if this plan manager owns +object+
-	    def owns?(object); !state || state.owns?(object) end
-
-	    # The set of objects we should temporarily keep because they are used
-	    # in a callback mechanism (like a remote query or a trigger)
-	    attr_reader :keep
-
-            # Compute the subset of +candidates+ that are to be considered as
-            # useful because of our peers and returns it.
-            #
-            # More specifically, an object will be included in the result if:
-            # * this plan manager is subscribed to it
-            # * the object is directly related to a self-owned object
-            # * if +include_subscriptions_relations+ is true, +object+ is
-            #   directly related to a subscribed object.
-            #
-            # The method takes into account plan children in its computation:
-            # for instance, a task will be included in the result if one of
-            # its events meet the requirements described above.
-            #
-            # If +result+ is non-nil, the method adds the objects to +result+
-            # using #<< and returns it.
-	    def remotely_useful_objects(candidates, include_subscriptions_relations, result = nil)
-		return ValueSet.new if candidates.empty?
-
-		result  ||= Distributed.keep.referenced_objects.to_value_set
-
-		child_set = ValueSet.new
-	        for obj in candidates
-	            if result.include?(obj.root_object)
-			next
-		    elsif obj.subscribed?
-			result << obj
-			next
-		    end
-
-		    not_found = obj.each_relation do |rel|
-	        	next unless rel.distribute? && rel.root_relation?
-
-	        	not_found = obj.each_parent_object(rel) do |parent|
-	        	    parent = parent.root_object
-	        	    if parent.distribute? && 
-				((include_subscriptions_relations && parent.subscribed?) || parent.self_owned?)
-	        		result << obj.root_object
-	        		break
-	        	    end
-	        	end
-	        	break unless not_found
-
-	        	not_found = obj.each_child_object(rel) do |child|
-	        	    child = child.root_object
-	        	    if child.distribute? && 
-				((include_subscriptions_relations && child.subscribed?) || child.self_owned?)
-	        		result << obj.root_object
-	        		break
-	        	    end
-	        	end
-	        	break unless not_found
-	            end
-
-		    if not_found && obj.respond_to?(:each_plan_child)
-			obj.each_plan_child { |plan_child| child_set << plan_child }
-		    end
-	        end
-
-		result.merge remotely_useful_objects(child_set, false, result)
-	    end
-
-	    # The list of objects that are being updated because of remote update
-	    attr_reader :updated_objects
-
-	    # True if we are updating +object+
-	    def updating?(object)
-		updated_objects.include?(object) 
-	    end
-	
-	    # True if we are updating all objects in +objects+
-	    def updating_all?(objects)
-		updated_objects.include_all?(objects.to_value_set)
-	    end
-
-	    # Call the block with the objects in +objects+ added to the
-	    # updated_objects set
-	    def update_all(objects)
-		old_updated_objects = @updated_objects
-		@updated_objects |= objects.to_value_set
-		yield
-	    ensure
-		@updated_objects = old_updated_objects
-	    end
-
-	    # Call the block with the objects in +objects+ added to the
-	    # updated_objects set
-	    def update(object)
-		if object.respond_to?(:__getobj__) && !object.kind_of?(Roby::Transactions::Proxy)
-		    object = object.__getobj__
-		end
-
-		included = unless updated_objects.include?(object)
-			       @updated_objects << object
-			   end
-
-		yield
-	    ensure
-		@updated_objects.delete(object) if included
-	    end
-
-            # Yields the relations of +object+ which are to be distributed
-            # among peers.
-	    def each_object_relation(object)
-		object.each_relation do |rel|
-		    yield(rel) if rel.distribute?
-		end
-	    end
-
-	    # The list of known peers. See ConnectionSpace#peers
-	    def peers
-		if state then state.peers 
-		else {}
-		end
-	    end
-
-	    # The set of objects that have been removed locally, but for which
-	    # there are still references on our peers
-	    attr_reader :removed_objects
-	end
-
-	@cycles_rx             = Queue.new
-	@pending_cycles        = Array.new
-	@pending_remote_events = Array.new
-
-	class << self
-	    # The queue of cycles read by ConnectionSpace#receive and not processed
-	    attr_reader :cycles_rx
-	    # The set of cycles that have been read from #pending_cycles but
-	    # have not been processed yet because the peers have disabled_rx? set
-	    #
-	    # This variable must be accessed only in the control thread
-	    attr_reader :pending_cycles
-	end
-
-	# Extract data received so far from our peers and replays it if
-	# possible. Data can be ignored if RX is disabled with this peer
-	# (through Peer#disable_rx), or delayed if there is event propagation
-	# involved. In that last case, the events will be fired at the
-	# beginning of the next execution cycle and the remaining messages at
-	# the end of that same cycle.
-	def self.process_pending
-	    delayed_cycles = []
-	    while !(pending_cycles.empty? && cycles_rx.empty?)
-		peer, calls = if pending_cycles.empty?
-				  cycles_rx.pop
-			      else pending_cycles.shift
-			      end
-
-		if peer.disabled_rx?
-		    delayed_cycles.push [peer, calls]
-		else
-		    if remaining = process_cycle(peer, calls)
-			delayed_cycles.push [peer, remaining]
-		    end
-		end
-	    end
-
-	ensure
-	    @pending_cycles = delayed_cycles
-	end
-
-        # Process once cycle worth of data from the given peer.
-	def self.process_cycle(peer, calls)
-	    from = Time.now
-	    calls_size = calls.size
-
-	    peer_server = peer.local_server
-	    peer_server.processing = true
-
-	    if !peer.connected?
-		return
-	    end
-
-	    while call_spec = calls.shift
-		return unless call_spec
-
-		is_callback, method, args, critical, message_id = *call_spec
-		Distributed.debug do 
-		    args_s = args.map { |obj| obj ? obj.to_s : 'nil' }
-			"processing #{is_callback ? 'callback' : 'method'} [#{message_id}]#{method}(#{args_s.join(", ")})"
-		end
-
-		result = catch(:ignore_this_call) do
-		    peer_server.queued_completion = false
-		    peer_server.current_message_id = message_id
-		    peer_server.processing_callback = !!is_callback
-
-		    result = begin
-				 peer_server.send(method, *args)
-			     rescue Exception => e
-				 if critical
-				     peer.fatal_error e, method, args
-				 else
-				     peer_server.completed!(e, true)
-				 end
-			     end
-
-		    if !peer.connected?
-			return
-		    end
-		    result
-		end
-
-		if method != :completed && method != :completion_group && !peer.disconnecting? && !peer.disconnected?
-		    if peer_server.queued_completion?
-			Distributed.debug "done and already queued the completion message"
-		    else
-			Distributed.debug { "done, returns #{result || 'nil'}" }
-			peer.queue_call false, :completed, [result, false, message_id]
-		    end
-		end
-
-		if peer.disabled_rx?
-		    return calls
-		end
-
-	    end
-
-	    Distributed.debug "successfully served #{calls_size} calls in #{Time.now - from} seconds"
-	    nil
-
-	rescue Exception => e
-	    Distributed.info "error in dRoby processing: #{e.full_message}"
-	    peer.disconnect
-
-	ensure
-	    peer_server.processing = false
-	end
-    end
-end