roby 0.8.0 → 3.0.0

data/lib/roby/log/logger.rb

@@ -1,203 +0,0 @@
-require 'roby/log/hooks'
-require 'roby/log/file'
-
-module Roby::Log
-    @loggers = Array.new
-    @@logging_thread = nil
-
-    extend Logger::Hierarchy
-    extend Logger::Forward
-
-    class << self
-	# Start the logging framework
-	def logging?
-	    @@logging_thread
-	end
-
-	# Start the logging framework
-	def start_logging # :nodoc:
-	    return if logging?
-	    logged_events.clear
-	    @@logging_thread = Thread.new(&method(:logger_loop))
-	end
-
-	# Stop the logging framework
-	def stop_logging # :nodoc:
-	    return unless logging?
-	    logged_events.push nil
-	    flushed_logger_mutex.synchronize do
-		while @@logging_thread
-		    flushed_logger.wait(flushed_logger_mutex)
-		end
-	    end
-	end
-
-	# Add a logger object in the system
-	def add_logger(logger)
-	    start_logging
-	    @loggers << logger
-	end
-
-	# Remove a logger from the list of loggers
-	def remove_logger(logger)
-	    flush if logging?
-	    if @loggers.size == 1
-		stop_logging
-	    end
-	    @loggers.delete logger
-            logger.close
-	end
-
-	# Remove all loggers
-	def clear_loggers
-	    stop_logging
-	    @loggers.clear
-	end
-
-	# Iterates on all the logger objects. If +m+ is given, yields only the loggers
-	# which respond to this method.
-	def each_logger(m = nil)
-	    for l in @loggers
-		if !m || l.respond_to?(m)
-		    yield(l) 
-		end
-	    end
-	end
-
-	# Returns true if there is at least one loggr for the +m+ message
-	def has_logger?(m)
-	    for l in @loggers
-		return true if l.logs_message?(m)
-	    end
-	    false
-	end
-
-	attr_reader :logged_events
-	attr_reader :flushed_logger_mutex
-	attr_reader :flushed_logger
-	attr_reader :known_objects
-
-	def incremental_dump?(object); known_objects.include?(object) end
-
-	# call-seq:
-	#   Log.log(message) { args }
-	#
-	# Logs +message+ with argument +args+. The block is called only once if
-	# there is at least one logger which listens for +message+.
-	def log(m, args = nil)
-	    if m == :added_tasks || m == :added_events
-		Roby.synchronize do
-		    args ||= yield
-		    objects = args[1].to_value_set
-		    # Do not give a 'peer' argument at Distributed.format, to
-		    # make sure we do a full dump
-		    args = Roby::Distributed.format(args) if has_logger?(m)
-		    known_objects.merge(objects)
-		end
-	    elsif m == :finalized_task || m == :finalized_event
-		Roby.synchronize do
-		    args ||= yield
-		    object = args[1]
-		    args = Roby::Distributed.format(args, self) if has_logger?(m)
-		    known_objects.delete(object)
-		end
-	    end
-
-	    if has_logger?(m)
-		if !args && block_given?
-		    Roby.synchronize do 
-			args = Roby::Distributed.format(yield, self)
-		    end
-		end
-
-		logged_events << [m, Time.now, args]
-	    end
-	end
-
-	# The main logging loop. We use a separate loop to avoid having logging
-	# have too much influence on the control thread. The Log.logged_events
-	# attribute is a sized queue (of size LOGGED_EVENTS_QUEUE_SIZE) in
-	# which all the events needing logging are saved
-	def logger_loop
-	    Thread.current.priority = 2
-	    loop do
-		m, time, args = logged_events.pop
-		break unless m
-
-		each_logger(m) do |logger|
-		    if logger.splat?
-			logger.send(m, time, *args)
-		    else
-			logger.send(m, time, args)
-		    end
-		end
-
-		if m == :flush && logged_events.empty?
-		    flushed_logger_mutex.synchronize do
-			flushed_logger.broadcast
-		    end
-		end
-	    end
-
-	rescue Exception => e
-	    Roby::Log.fatal "logger thread dies with #{e.full_message}" unless e.kind_of?(Interrupt)
-
-	ensure
-	    # Wake up any waiting thread
-	    flushed_logger_mutex.synchronize do
-		@@logging_thread = nil
-		flushed_logger.broadcast
-	    end
-	end
-
-	# Waits for all the events queued in +logged_events+ to be processed by
-	# the logging thread. Also sends the +flush+ message to all loggers
-	# that respond to it
-	def flush
-	    flushed_logger_mutex.synchronize do
-		if !logging?
-		    raise "not logging"
-		end
-
-		logged_events.push [:flush, []]
-		flushed_logger.wait(flushed_logger_mutex)
-	    end
-	end
-
-	# Requires all displays
-	def load_all_displays
-	    require 'roby/log/relations'
-	    require 'roby/log/execution-state'
-	end
-
-	def open(file)
-	    Logfile.open(file)
-	end
-
-	def replay(file, &block)
-	    if file =~ /\.gz$/
-		require 'zlib'
-		require 'roby/log/file'
-		Zlib::GzipReader.open(file) do |io|
-		    FileLogger.replay(io, &block)
-		end
-	    elsif file =~ /\.db$/
-		require 'roby/log/sqlite'
-		SQLiteLogger.replay(file, &block)
-	    else
-		require 'roby/log/file'
-		File.open(file) do |io|
-		    FileLogger.replay(io, &block)
-		end
-	    end
-	end
-    end
-
-    LOGGED_EVENTS_QUEUE_SIZE = 2000
-    @logged_events        = SizedQueue.new(LOGGED_EVENTS_QUEUE_SIZE)
-    @flushed_logger_mutex = Mutex.new
-    @flushed_logger       = ConditionVariable.new
-    @known_objects        = ValueSet.new
-
-end
-

data/lib/roby/log/notifications.rb

@@ -1,244 +0,0 @@
-require 'roby/log/data_stream'
-
-class Roby::Task::DRoby
-    attr_accessor :mission
-end
-
-module Roby
-    module Log
-	class Notifications < Roby::Log::DataDecoder
-	    GENERATOR_CALL_LIMIT = 0.1
-
-	    attr_reader :tasks
-
-	    attr_reader :histories
-	    def initialize(name)
-		@tasks     = Hash.new
-		@histories = Hash.new { |h, k| h[k] = Array.new }
-		super(name)
-	    end
-
-	    def added_task(task)
-		task.remote_siblings.each_value do |id|
-		    tasks[id] = task
-		end
-	    end
-	    def removed_task(remote_id)
-		task = tasks.delete(remote_id)
-		task.remote_siblings.each_value do |id|
-		    tasks.delete(id)
-		end
-	    end
-
-	    def clear
-		super
-
-		@tasks.clear
-		@histories.clear
-	    end
-
-
-	    def process(data)
-		data.each_slice(4) do |m, sec, usec, args|
-		    time = Time.at(sec, usec)
-		    case m.to_s
-		    when /added_mission/
-			task = tasks[args[1]]
-			task.mission = true
-			event :added_mission, args[0], task
-
-		    when /unmarked_mission/
-			task = tasks[args[1]]
-			task.mission = false
-			event :unmarked_mission, args[0], task
-
-		    when /added_tasks/
-			args[1].each { |t| added_task(t) }
-
-		    when /finalized_task/
-			id = args[1]
-			task = tasks[id]
-			if histories[id].empty?
-			    event :finalized_pending, time, task
-			end
-			histories.delete(task)
-			removed_task(args[1])
-
-		    when /generator_calling/
-			@current_call = [time, args[0]]
-
-		    when /generator_called/
-			if @current_call[1] == args[0]
-			    duration = time - @current_call[0]
-			    if duration > GENERATOR_CALL_LIMIT
-				event :overly_long_call, time, duration, tasks[args[0].task], args[0].symbol, args[1]
-			    end
-			end
-			
-		    when /exception/
-			error, involved_tasks = *args
-			involved_tasks = involved_tasks.map { |id| tasks[id] }
-			event m, time, error, involved_tasks
-		    when /generator_fired/
-			generator = args[0]
-			if generator.respond_to?(:task)
-			    histories[generator.task] << args
-			    if generator.symbol == :failed
-				event :failed_task, time, tasks[generator.task], histories[generator.task]
-			    end
-			end
-		    end
-		end
-	    end
-
-	    def event(name, *args)
-		displays.each do |display|
-		    if display.respond_to?(name)
-			display.send(name, *args)
-		    end
-		end
-	    end
-	end
-
-	class NotificationsDisplay < Qt::TextBrowser
-	    include DataDisplay
-	    decoder Notifications
-
-	    attr_reader :document
-	    attr_reader :text
-
-	    STYLESHEET = <<-EOS
-		    h1 { font-size: large; }
-		    h1 { margin-bottom: 3px; }
-		    h2 { font-size: medium; }
-		    .time { 
-			margin-right: 10px; 
-		    }
-
-		    div.info {
-			color: black;
-			margin-top: 20px;
-			border-top: thin solid black;
-		    }
-		    div.info h1 { margin-top: 0; background-color: #5FB86A; }
-		    div.warn { 
-			color: black;
-			margin-top: 20px;
-			border-top: thin solid black; 
-		    }
-		    div.warn h1 { margin-top: 0; background-color: #B8AC5F; }
-		    div.error { 
-			color: black;
-			margin-top: 20px;
-			border-top: thin solid black; 
-		    }
-		    div.error h1 { margin-top: 0; background-color: #B8937D; }
-	    EOS
-
-	    def initialize
-		super()
-
-		resize(500, 600)
-		@main     = self
-		@document = Qt::TextDocument.new
-
-		self.document = document
-		document.setDefaultStyleSheet(STYLESHEET)
-	    end
-
-
-	    def render_event(kind, time, title)
-		@text = ""
-		text << "\n<div class=#{kind}>\n  <h1><span class=\"time\">#{time.to_hms}</span> #{title}</h1>\n  "
-		yield
-
-	    ensure
-		text << "\n</div>"
-		insertHtml(text)
-		verticalScrollBar.value = verticalScrollBar.maximum
-	    end
-
-	    def render_task(task)
-		remote_siblings = "{ " << task.remote_siblings.map { |peer, id| id.to_s(peer) }.join(", ") << " }"
-		text << "<div class=\"task\">
-		    #{task.model.ancestors.first.first}#{remote_siblings}\n  "
-		
-		unless task.arguments.empty?
-		    text << "<ul class=\"task-arguments\">\n    "
-		    task.arguments.each do |key, value|
-			text << "    <li>#{key}: #{value}<li>\n"
-		    end
-		    text << "  </ul>\n"
-		end
-		text << "</div>"
-	    end
-
-	    def render_history(history)
-		text << "<ul class=\"history\">\n"
-		history.each do |generator, id, time, context|
-		    text << "<li>#{time.to_hms} #{generator.symbol} [#{context}]</li>"
-		end
-		text << "</ul>"
-	    end
-
-	    def clear
-		document.clear
-	    end
-
-	    def finalized_pending(time, task)
-		render_event("warn", time, "Finalized pending task") do
-		    render_task(task)
-		end
-	    end
-	    def added_mission(time, task)
-		render_event("info", time, "New mission") do
-		    render_task(task)
-		end
-	    end
-	    def removed_mission(time, task)
-		render_event("info", time, "Removed mission") do
-		    render_task(task)
-		end
-	    end
-	    def render_error(error, tasks)
-		error = Qt.escape(error.to_s)
-		error = error.split("\n").map do |line|
-		    line.gsub(/^\s+/) { "&nbsp;" * $&.size }
-		end.join("<br>")
-
-		text << error
-		text << "<h2>Involved tasks</h2>"
-		text << "<ul>"
-		tasks.each do |t| 
-		    text << "<li>"
-		    render_task(t) 
-		    text << "</li>"
-		end
-	    end
-
-	    def fatal_exception(time, error, tasks)
-		render_event("error", time, "Fatal exception") do
-		    render_error(error, tasks)
-		end
-	    end
-	    def handled_exception(time, error, tasks)
-		render_event("warn", time, "Handled exception") do
-		    render_error(error, tasks)
-		end
-	    end
-	    def failed_task(time, task, history)
-		render_event("warn", time, "Failed task") do
-		    render_task(task)
-		    render_history(history)
-		end
-	    end
-	    def overly_long_call(time, duration, task, event_name, context)
-		render_event("warn", time, "Overly long call: ") do
-		    text << "Call of #{event_name}(#{context}) lasted #{Integer(duration * 1000)}ms in<br>"
-		    render_task(task)
-		end
-	    end
-	end
-    end
-end
-

data/lib/roby/log/plan_rebuilder.rb

@@ -1,468 +0,0 @@
-require 'roby/distributed/protocol'
-require 'roby/log/data_stream'
-require 'stringio'
-
-module Roby
-    class ObjectIDManager
-	attr_reader :siblings
-	attr_reader :objects
-	def initialize
-	    @siblings = Hash.new
-	    @objects  = Hash.new
-	    @inserted_at = Hash.new
-	end
-
-	def clear
-	    siblings.clear
-	    objects.clear
-	end
-
-	def local_object(object, allow_new = true)
-	    return unless object
-
-	    current_siblings = Set.new
-	    ids = Set.new
-	    if object.kind_of?(Distributed::RemoteID) 
-		ids << object
-		if sibling = siblings[object]
-		    current_siblings << sibling
-		end
-	    else
-		for _, id in object.remote_siblings
-		    ids << id
-		    if sibling = siblings[id]
-			current_siblings << sibling
-		    end
-		end
-	    end
-
-	    if current_siblings.size > 1
-		raise "more than one object matching"
-	    elsif current_siblings.empty?
-		if object.kind_of?(Distributed::RemoteID)
-		    raise "no object for this ID"
-		elsif !allow_new
-		    raise "new object ot type #{object.class} is not allowed here"
-		end
-	    else
-		obj = current_siblings.find { true }
-		if object.kind_of?(Distributed::RemoteID)
-		    object = obj
-		end
-
-		if obj.class != object.class
-		    # Special case: +obj+ is a PlanObject and it is in no plan.
-		    #
-		    # In this case, we just replace it silently. It handles the
-		    # corner case of having a task hanging around because it is
-		    # linked to others, but has not been included in a plan.
-		    #
-		    # Note that this is a hack and should be fixed
-		    if obj.respond_to?(:plan) && !obj.plan
-			for id in objects.delete(obj)
-			    siblings.delete(id)
-			end
-		    else
-			raise "class mismatch #{obj.class} != #{object.class}. Old object is #{obj}"
-		    end
-		elsif block_given?
-		    ids.merge objects.delete(obj)
-		    object = yield(obj)
-		else
-		    object = obj
-		end
-	    end
-
-	    objects[object] ||= Set.new
-	    objects[object].merge ids
-	    for i in ids
-		siblings[i] = object
-	    end
-
-	    object
-	end
-
-	def add_id(object, id)
-	    if siblings[id]
-		raise "there is already an object for this ID"
-	    elsif !id.kind_of(Distributed::RemoteID)
-		raise "#{id} is not a valid RemoteID"
-	    end
-
-	    siblings[id] = object
-	    objects[object] << id
-	end
-
-	def remove_id(id)
-	    if !(object = siblings.delete(id))
-		raise "#{id} does not reference anything"
-	    end
-	    objects[object].delete(id)
-	end
-
-	def remove(object)
-	    object = local_object(object)
-
-	    ids = objects.delete(object)
-	    for i in ids
-		siblings.delete(i)
-	    end
-	end
-    end
-
-    class PlanObject::DRoby
-	include DirectedRelationSupport
-	attr_writer :plan
-
-	def update_from(new)
-	    super if defined? super
-       	end
-    end
-    class TaskEventGenerator::DRoby
-	include DirectedRelationSupport
-	attr_writer :plan
-	attr_writer :task
-
-	def update_from(new)
-	    super if defined? super
-       	end
-    end
-    class Task::DRoby
-	attr_writer :plan
-	attribute(:events) { Hash.new }
-
-	def update_from(new)
-	    super if defined? super
-	    self.flags.merge! new.flags
-	    self.plan  = new.plan
-	end
-    end
-
-    class Transaction::Proxy::DRoby
-	include DirectedRelationSupport
-	attr_writer :transaction
-	attr_accessor :plan
-
-	def events; Hash.new end
-	def update_from(new)
-	    super if defined? super
-       	end
-    end
-
-    module LoggedPlan
-	attribute(:missions)	 { ValueSet.new }
-	attribute(:known_tasks)  { ValueSet.new }
-	attribute(:free_events)  { ValueSet.new }
-	attribute(:transactions) { ValueSet.new }
-	attribute(:finalized_tasks)  { ValueSet.new }
-	attribute(:finalized_events) { ValueSet.new }
-	attribute(:proxies) { ValueSet.new }
-	attr_accessor :parent_plan
-
-	def root_plan?; !parent_plan end
-	def update_from(new); end
-	def clear
-	    transactions.dup.each do |trsc|
-		trsc.clear
-		removed_transaction(trsc)
-	    end
-	    known_tasks.dup.each { |t| finalized_task(t) }
-	    free_events.dup.each { |e| finalized_event(e) }
-	    clear_finalized(finalized_tasks, finalized_events)
-	end
-
-	def finalized_task(task)
-	    missions.delete(task)
-	    known_tasks.delete(task)
-	    proxies.delete(task)
-	    finalized_tasks << task
-	end
-	def finalized_event(event)
-	    free_events.delete(event)
-	    proxies.delete(event)
-	    finalized_events << event unless event.respond_to?(:task)
-	end
-	def clear_finalized(tasks, events)
-	    tasks.each { |task| task.clear_vertex }
-	    @finalized_tasks = finalized_tasks - tasks
-	    events.each { |event| event.clear_vertex }
-	    @finalized_events = finalized_events - events
-	end
-	def removed_transaction(trsc)
-	    transactions.delete(trsc)
-	end
-    end
-
-    class Plan::DRoby
-	include LoggedPlan
-    end
-
-    class Distributed::Transaction::DRoby
-	include LoggedPlan
-	attr_writer :plan
-    end
-
-    module Log
-	# This class rebuilds a plan-like structure from events saved by a
-	# FileLogger object This is compatible with the EventStream data source
-	class PlanRebuilder < DataDecoder
-	    attr_reader :plans
-	    attr_reader :tasks
-	    attr_reader :events
-	    attr_reader :last_finalized
-	    attr_reader :manager
-
-	    attr_reader :start_time
-	    attr_reader :time
-	    def initialize(name)
-		@plans  = ValueSet.new
-		@tasks  = ValueSet.new
-		@events = ValueSet.new
-		@manager = ObjectIDManager.new
-		@last_finalized = Hash.new
-		super(name)
-	    end
-	    
-	    def clear
-		manager.clear
-		super
-
-		plans.dup.each { |p, _| p.clear if p.root_plan? }
-		plans.clear
-		tasks.clear
-		events.clear
-		@start_time = nil
-		@time = nil
-	    end
-
-	    def rewind
-		clear
-	    end
-	    
-            # Processes one cycle worth of data coming from an EventStream, and
-            # builds the corresponding plan representation
-            #
-            # It returns true if there was something noteworthy in there, and
-            # false otherwise.
-	    def process(data)
-		@time = data.last[0][:start]
-	        @start_time ||= @time
-
-                done_something = false
-		data.each_slice(4) do |m, sec, usec, args|
-		    time = Time.at(sec, usec)
-		    reason = catch :ignored do
-			begin
-			    if respond_to?(m)
-				send(m, time, *args)
-                                done_someting = true
-			    end
-			    displays.each do |d|
-                                if d.respond_to?(m)
-                                    done_something = true
-                                    d.send(m, time, *args) 
-                                end
-                            end
-			rescue Exception => e
-			    display_args = args.map do |obj|
-				case obj
-				when NilClass: 'nil'
-				when Time: obj.to_hms
-				when DRbObject: obj.inspect
-				else (obj.to_s rescue "failed_to_s")
-				end
-			    end
-
-			    raise e, "#{e.message} while serving #{m}(#{display_args.join(", ")})", e.backtrace
-			end
-			nil
-		    end
-		    if reason
-			Roby.warn "Ignored #{m}(#{args.join(", ")}): #{reason}"
-		    end
-		end
-                done_something
-	    end
-
-	    def local_object(object)
-		return nil unless object
-
-		object = manager.local_object(object)
-		plan = if block_given?
-			   yield
-		       elsif object.respond_to?(:transaction)
-			   local_plan(object.transaction, false)
-		       elsif object.respond_to?(:plan)
-			   local_plan(object.plan, false)
-		       end
-
-		if plan
-		    object.plan = plan
-		    if object.respond_to?(:transaction)
-			object.transaction = plan
-			plan.proxies << object
-		    end
-		end
-
-		object
-	    end
-
-	    def clear_integrated
-                updated = false
-		plans.each do |plan|
-                    updated = !(plan.finalized_events.empty? && plan.finalized_tasks.empty?)
-		    plan.clear_finalized(plan.finalized_tasks.dup, plan.finalized_events.dup)
-		end
-
-		super_result = super
-                super_result || updated
-	    end
-
-	    def local_plan(plan, allow_new = false)
-	       	plan = manager.local_object(plan, plans.empty? || allow_new)
-		plans << plan if plan
-		plan
-	    end
-	    def local_task(task, &block)
-		local_object(task, &block)
-	    end
-	    def local_event(event, &block)
-		if event.respond_to?(:task)
-		    task = local_task(event.task, &block)
-		    if task.events[event.symbol]
-			task.events[event.symbol]
-		    else
-			event.task = task
-			event.plan = task.plan
-			task.events[event.symbol] = event 
-		    end
-		else
-		    local_object(event, &block) 
-		end
-	    end
-
-	    def inserted_tasks(time, plan, task)
-		plan = local_plan(plan)
-		plan.missions << task
-	    end
-	    def discarded_tasks(time, plan, task)
-		plan = local_plan(plan)
-		plan.missions.delete(task)
-	    end
-	    def replaced_tasks(time, plan, from, to)
-	    end
-	    def added_events(time, plan, events)
-		plan = local_plan(plan)
-		events.each do |ev| 
-		    ev = local_event(ev) { plan }
-		    plan.free_events << ev
-		end
-	    end
-	    def added_tasks(time, plan, tasks)
-		plan = local_plan(plan)
-		tasks.each do |t| 
-		    t = local_task(t) { plan }
-		    plan.known_tasks << t
-		end
-	    end
-	    def garbage_task(time, plan, task)
-	    end
-	    def finalized_event(time, plan, event)
-		event = local_event(event)
-		plan  = local_plan(plan)
-		unless event.respond_to?(:task)
-		    plan.finalized_event(event)
-		    manager.remove(event)
-		end
-	    end
-	    def finalized_task(time, plan, task)
-		task = local_task(task)
-		plan = local_plan(plan)
-		plan.finalized_task(task)
-		manager.remove(task)
-	    end
-	    def added_transaction(time, plan, trsc)
-		plan = local_plan(plan)
-		trsc = local_plan(trsc, true)
-		plan.transactions << trsc
-		trsc.parent_plan  = plan
-	    end
-	    def removed_transaction(time, plan, trsc)
-		plan = local_plan(plan)
-		trsc = local_plan(trsc)
-		    
-		(trsc.known_tasks - plan.known_tasks).each do |obj|
-		    trsc.finalized_task(obj)
-		    manager.remove(obj)
-		end
-		(trsc.free_events - plan.free_events).each do |obj|
-		    trsc.finalized_event(obj)
-		    manager.remove(obj)
-		end
-		trsc.proxies.each do |p|
-		    manager.remove(p)
-		end
-
-		trsc.clear_finalized(trsc.finalized_tasks, trsc.finalized_events)
-		plans.delete(trsc)
-		manager.remove(trsc)
-		plan.transactions.delete(trsc)
-	    end
-
-	    GENERATOR_TO_STATE = { :start => :started,
-		:success => :success,
-		:stop => :finished }
-
-	    def generator_fired(time, generator, id, ev_time, context)
-		generator = local_event(generator)
-		generator.instance_variable_set("@happened", true)
-		if generator.respond_to?(:task) && (state = GENERATOR_TO_STATE[generator.symbol])
-		    generator.task.flags[state] = true
-		end
-	    end
-
-	    def added_task_child(time, parent, rel, child, info)
-		parent = local_task(parent)
-		child  = local_task(child)
-		if !parent   then throw :ignored, "unknown parent"
-		elsif !child then throw :ignored, "unknown child"
-		end
-
-		rel = rel.first if rel.kind_of?(Array)
-		rel    = rel.proxy(nil)
-		parent.add_child_object(child, rel, info)
-	    end
-	    def removed_task_child(time, parent, rel, child)
-		parent = local_task(parent)
-		child  = local_task(child)
-		rel = rel.first if rel.kind_of?(Array)
-		rel    = rel.proxy(nil)
-		parent.remove_child_object(child, rel)
-	    end
-	    def added_event_child(time, parent, rel, child, info)
-		parent = local_event(parent)
-		child  = local_event(child)
-		rel = rel.first if rel.kind_of?(Array)
-		rel    = rel.proxy(nil)
-		parent.add_child_object(child, rel, info)
-	    end
-	    def removed_event_child(time, parent, rel, child)
-		parent = local_event(parent)
-		child  = local_event(child)
-		rel = rel.first if rel.kind_of?(Array)
-		rel    = rel.proxy(nil)
-		parent.remove_child_object(child, rel)
-	    end
-	    def added_owner(time, object, peer)
-		object = local_object(object)
-		object.owners << peer
-	    end
-	    def removed_owner(time, object, peer)
-		object = local_object(object)
-		object.owners.delete(peer)
-	    end
-	end
-
-    end
-end
-