DeepConnect 0.4.06

data/lib/deep-connect/conf.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+#
+#   conf.rb - 
+#   	Copyright (C) 1996-2010 Keiju ISHITSUKA
+#				(Penta Advanced Labrabries, Co.,Ltd)
+#
+
+module DeepConnect
+  class Config
+    def initialize
+
+      # enable distributed garbage collection.
+      @ENABLE_GC = false
+
+      @KEEP_ALIVE_INTERVAL = 60
+      @MON_INTERVAL = 10
+
+      # debugging attributes.
+      @DISABLE_INFO = false
+
+      @DISPLAY_MESSAGE_TRACE = false
+      @MESSAGE_DISPLAY = false
+      @DEBUG = false
+      @DISPLAY_METHOD_SPEC = false
+      @DISPLAY_MONITOR_MESSAGE = false
+      @DISPLAY_KEEP_ALIVE = false
+
+      @DEBUG_REFERENCE = false
+      @DISPLAY_GC = false
+    end
+
+    attr_accessor :ENABLE_GC
+    attr_accessor :KEEP_ALIVE_INTERVAL
+    attr_accessor :MON_INTERVAL
+
+    attr_accessor :DISPLAY_MESSAGE_TRACE
+    attr_accessor :MESSAGE_DISPLAY
+    attr_accessor :DEBUG
+    attr_accessor :DISPLAY_METHOD_SPEC
+    attr_accessor :DISPLAY_MONITOR_MESSAGE
+    attr_accessor :DISPLAY_KEEP_ALIVE
+
+    attr_accessor :DEBUG_REFERENCE
+    attr_accessor :DISPLAY_GC
+
+    attr_accessor :DISABLE_INFO
+  end
+end

data/lib/deep-connect/cron.rb

@@ -0,0 +1,91 @@
+# encoding: UTF-8
+#
+#   cron.rb - 
+#   	Copyright (C) 1996-2010 Keiju ISHITSUKA
+#				(Penta Advanced Labrabries, Co.,Ltd)
+#
+
+@RCS_ID='-$Id:  $-'
+
+module DeepConnect
+
+  class Cron
+
+    TAB = [
+      [10, proc{|org, cron, t| cron.mon_10sec}],
+      [60, proc{|org, cron, t| cron.mon_min}],
+      [3060, proc{|org, cron, t| cron.mon_hour}],
+      [Conf.KEEP_ALIVE_INTERVAL, proc{|org, cron, t| org.keep_alive}],
+    ]
+
+    def initialize(organizer)
+      @organizer = organizer
+
+      @timer = 0
+      @last_exec_times = {}
+
+      @mon_mutex = Mutex.new
+
+      @prev_message10s = nil
+    end
+
+    attr_reader :timer
+    alias tick timer
+
+    def start
+      Thread.start do 
+	loop do
+	  sleep Conf.MON_INTERVAL
+	  @timer += Conf.MON_INTERVAL
+	  
+	  Thread.start do
+	    @mon_mutex.synchronize do
+	      for tab in TAB
+		last_time = @last_exec_times[tab]
+		last_time = 0 unless last_time
+		if @timer >= last_time + tab[0] 
+		  @last_exec_times[tab] = @timer
+		  tab[1].call @organizer, self, @timer
+		end
+	      end
+	    end
+	  end
+	end
+      end
+    end
+
+    def mon_10sec
+      return if @organizer.deep_spaces.size == 0
+
+      if Conf.DISPLAY_MONITOR_MESSAGE
+	str = ""
+	str.concat "Connect DeepSpaces: BEGIN\n"
+	for peer_id, ds in @organizer.deep_spaces.dup
+	  str.concat "#{peer_id.inspect} => \n"
+	  str.concat "\t#{ds}\n"
+	end
+	str.concat "Connect DeepSpaces: END\n"
+
+	if @prev_message10s != str
+	  @prev_message10s = str
+	  puts "MON 10SEC: #{@timer}\n", str
+	end
+      end
+    end
+
+    def mon_min
+      if Conf.DISPLAY_MONITOR_MESSAGE
+	puts "MON MIN: #{@timer}"
+      end
+    end
+
+    def mon_hour
+      if Conf.DISPLAY_MONITOR_MESSAGE
+	puts "MON HOUR: #{@timer}"
+      end
+    end
+  end
+end
+
+
+

data/lib/deep-connect/deep-fork.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+#
+#   deep-fork.rb - 
+#   	Copyright (C) 1996-2010 Keiju ISHITSUKA
+#				(Penta Advanced Labrabries, Co.,Ltd)
+#
+
+@RCS_ID='-$Id:  $-'
+
+
+require "thread"
+
+module DeepConnect
+
+  class DeepFork
+
+    def initialize(dc1, service = 0, except_closing_io = [STDIN, STDOUT, STDERR], &block)
+      @dc1 = dc1
+
+      @peer_pid = nil
+      @peer_deep_space = nil
+      @peer_deep_space_mx = Mutex.new
+      @peer_deep_space_cv = ConditionVariable.new
+
+      exp = "DeepFork_#{format("%0xd", self.object_id)}"
+      @dc1.export(exp, self)
+
+      @peer_pid = Process.fork {
+	ionos = except_closing_io.collect{|io| io.fileno}
+
+	ObjectSpace.each_object(IO) do |io|
+	  begin
+	    unless ionos.include?(io.fileno)
+	      io.close
+	    end
+	  rescue
+	  end
+	end
+	dc2 = DeepConnect.start(service)
+	ds2 = dc2.open_deepspace("localhost", @dc1.local_id)
+	df1 = ds2.import(exp)
+	df1.connect(self, $$)
+	block.call(dc2, ds2)
+      }
+
+      @peer_deep_space_mx.synchronize do
+	until @peer_deep_space
+	  @peer_deep_space_cv.wait(@peer_deep_space_mx)
+	end
+      end
+      self
+    end
+    
+    attr_reader :peer_deep_space
+    attr_reader :peer_pid
+
+    def connect(df2, peer_pid)
+      @peer_deep_space_mx.synchronize do
+	if @peer_pid == peer_pid
+	  @peer_deep_space = df2.deep_space
+	  @peer_deep_space_cv.signal
+	end
+      end
+    end
+
+    class <<self
+      alias fork new
+    end
+  end
+end

data/lib/deep-connect/deep-mq.rb

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+#
+#   deep-mq.rb - 
+#   	Copyright (C) 1996-2010 Keiju ISHITSUKA
+#				(Penta Advanced Labrabries, Co.,Ltd)
+#
+
+@RCS_ID='-$Id:  $-'
+
+
+require "thread"
+
+module DeepConnect
+  module DeepMQ
+    class SV
+      def initialize(org)
+        @organizer = org
+        @event_q = Queue.new
+        start
+      end
+
+      def enq(session, ev)
+        begin
+          @event_q.push [session, ev]
+          session.accept ev.reply(nil)
+        rescue SystemExit
+          raise
+        rescue Exception
+	  session.accept event.reply(ret, $!)
+        end
+      end
+
+      def start
+        Thread.start do
+          loop do
+            evaluate_request(*@event_q.pop)
+          end
+        end
+      end
+
+      def evaluate_request(session, ev)
+        receiver = ev.args.first
+        method = ev.args[1]
+        args = ev.args[2..-1]
+        callback = ev.callback
+        ev0 = Event::Request.request(session, receiver, method, args)
+        @organizer.evaluator.evaluate_mq_request(session, ev0, callback)
+      end
+    end
+
+    class CL
+      def initialize(sv)
+        @sv = sv
+      end
+
+      def push(ref, method, *arg, &callback)
+        @sv.deep_space.session.mq_send_to(@sv, :push, [ref, method, *arg], callback)
+      end
+#      Organizer::def_method_spec(SV, "push(DEFAULT, DEFAULT, VAL)")
+    end
+  end
+end

data/lib/deep-connect/deep-space.rb

@@ -0,0 +1,403 @@
+# encoding: UTF-8
+#
+#   deep-space.rb - 
+#   	Copyright (C) 1996-2010 Keiju ISHITSUKA
+#				(Penta Advanced Labrabries, Co.,Ltd)
+#
+
+require "thread"
+require "forwardable"
+
+require "ipaddr"
+
+require "deep-connect/session"
+require "deep-connect/class-spec-space"
+
+module DeepConnect
+  class DeepSpace
+    extend Forwardable
+
+    def initialize(org, port, local_id = nil)
+      @status = :INITIALIZE
+
+      @organizer = org
+      @session = Session.new(self, port, local_id)
+
+      unless local_id
+	local_id = port.peeraddr[1]
+      end
+
+      addr = port.peeraddr[3]
+      ipaddr = IPAddr.new(addr)
+#      ipaddr = ipaddr.ipv4_mapped if ipaddr.ipv4?
+      ipaddr = ipaddr.native
+
+      @peer_uuid = [ipaddr.to_s, local_id]
+
+      init_class_spec_feature
+      init_export_feature
+      init_import_feature
+    end
+
+    attr_reader :status
+    attr_reader :organizer
+    attr_reader :session
+    attr_reader :peer_uuid
+    alias peer_id peer_uuid
+
+    def close
+      @organizer.close_deepspace(self)
+    end
+
+    def connect
+      @session.start
+
+      @deregister_reference_thread = start_deregister_reference
+
+      @status = :SERVICING
+    end
+
+    def disconnect(*opts)
+      org_status = @status
+      @status = :SERVICE_STOP
+      
+      @session.stop_service(*opts)
+      if !opts.include?(:SESSION_CLOSED) && !opts.include?(:REQUEST_FROM_PEER)
+	@session.send_disconnect
+      end
+      @session.stop
+
+      @deregister_reference_thread.exit if org_status == :SERVICING
+      @import_reference = nil
+      @export_roots = nil
+    end
+
+    def import(name, waitp = false)
+      @session.get_service(name, waitp)
+    end
+    alias get_service import 
+
+    def import_mq(name, waitp = false)
+      sv = @session.import_mq(name, waitp)
+      DeepMQ::CL.new(sv)
+    end
+    alias get_mq import_mq
+
+    #
+    # class spec feature
+    #
+    def init_class_spec_feature
+      # class spec
+      @class_spec_space = ClassSpecSpace.new(:remote)
+    end
+
+    def_delegator :@class_spec_space, :class_specs=
+    def_delegator :@class_spec_space, :method_spec
+    def_delegator :@class_spec_space, :class_spec_id_of
+    alias csid_of class_spec_id_of
+    
+    def my_method_spec(obj, method)
+      Organizer::method_spec(obj, method)
+    end
+
+    def my_csid_of(obj)
+      Organizer::class_spec_id_of(obj)
+    end
+
+    def recv_class_spec(cspecs)
+      cspecs.each{|cspec| add_class_spec(cspec)}
+      make_class_spec_cache(cspecs.first)
+    end
+
+    def make_class_spec_cache(cspec)
+      cache = ClassSpec.new
+    end
+
+    #
+    # export root 関連メソッド
+    #
+    def init_export_feature
+      # exportしているオブジェクト
+      @export_roots_mutex = Mutex.new
+      @export_roots = {}
+    end
+
+    def release_object(obj)
+      @export_roots_mutex.synchronize do
+	@export_roots.delete(obj.object_id)
+      end
+    end
+
+    def set_root(root)
+#if root.kind_of?(Proc)
+#  puts "SET_ROOT: #{root}\n #{caller(0)}"
+#end
+      @export_roots_mutex.synchronize do
+	if pair = @export_roots[root.object_id]
+	  pair[1] += 1
+	else
+	  @export_roots[root.object_id] = [root, 1]
+	end
+	root.object_id
+      end
+    end
+    alias set_export_root set_root
+    
+    def root(id)
+      @export_roots_mutex.synchronize do
+	pair = @export_roots.fetch(id){return IllegalObject.new(id)}
+	pair.first
+	#@export_roots.fetch(id){:__DEEPCONNECT_NO_VALUE__}
+      end
+    end
+    alias export_root root
+
+    def register_root_from_other_session(id)
+      obj = @organizer.id2obj(id)
+      @export_roots_mutex.synchronize do
+	if pair = @export_roots[id]
+	  pair[1] += 1
+	else
+	  @export_roots[id] = [obj, 1]
+	end
+      end
+      obj
+    end
+
+    def delete_roots(pairs)
+      @export_roots_mutex.synchronize do
+	pairs.each_slice(2) do |id, refcount|
+	  if pair = @export_roots[id]
+#	    puts "#{$$}: GC: #{id} #{refcount} #{pair.first.class} #{pair.last}"
+
+	    if (pair[1] -= refcount) == 0
+	      obj = @export_roots.delete(id)
+	      if Conf.DISPLAY_GC
+		puts "#{$$}: GC: delete root: #{id} #{obj.first.to_s}"
+	      end
+	    else
+	      if Conf.DISPLAY_GC
+		puts "#{$$}: GC: derefcount root: #{id} #{pair.first.to_s} #{pair[1]}"
+		if pair.first.kind_of?(Exception)
+		  p pair.first
+		  p pair.first.backtrace
+		end
+	      end
+	    end
+	  else
+	    if Conf.DISPLAY_GC
+	      puts "#{$$}: GC: warn already deleted root: #{id.inspect}"
+	    end
+	  end
+	end
+      end
+    end
+
+    #
+    # import 関連メソッド
+    #
+    def init_import_feature
+      # importしているオブジェクト
+      # peer_id => ref_id
+      @import_reference = {}
+      @rev_import_reference = {}
+
+      @import_reference_mutex = Mutex.new
+      @import_reference_cv = ConditionVariable.new
+      @deregister_reference_queue = []
+
+      @deregister_thread = nil
+    end
+
+    def import_reference(peer_id)
+      return import_reference_for_disable_gc(peer_id) unless Conf.ENABLE_GC
+
+      status = GC.disable
+      begin
+	@import_reference_mutex.synchronize do
+	  if pair = @import_reference[peer_id]
+	    begin
+	      ObjectSpace._id2ref(pair.first)
+	    rescue
+	      ref_id = @import_reference.delete(peer_id)
+	      @rev_import_reference.delete(ref_id)
+	      @deregister_reference_queue.concat [peer_id, 1]
+	      return nil
+	    end
+	  else
+	    nil
+	  end
+	end
+      ensure
+	GC.enable unless status
+      end
+    end
+
+    def import_reference_for_disable_gc(peer_id)
+      @import_reference_mutex.synchronize do
+	if pair = @import_reference[peer_id]
+	  pair.first
+	else
+	  nil
+	end
+      end
+    end
+
+    def register_import_reference(ref)
+      return register_import_reference_for_disable_gc(ref) unless Conf.ENABLE_GC
+
+      status = GC.disable
+      begin
+	@import_reference_mutex.synchronize do
+	  if pair = @import_reference[ref.peer_id]
+	    pair[1] += 1
+	  else
+	    @import_reference[ref.peer_id] = [ref.object_id, 1]
+	    @rev_import_reference[ref.object_id] = ref.peer_id
+	  end
+	end
+	ObjectSpace.define_finalizer(ref, deregister_import_reference_proc)
+      ensure
+	GC.enable unless status
+      end
+    end
+
+    def register_import_reference_for_disable_gc(ref)
+      @import_reference_mutex.synchronize do
+	if pair = @import_reference[ref.peer_id]
+	  pair[1] += 1
+	else
+	  @import_reference[ref.peer_id] = [ref, 1]
+	end
+      end
+    end
+
+    def deregister_import_reference(ref)
+      return deregister_import_reference_for_disable_gc(ref) unless Conf.ENABLE_GC
+      status = GC.disable
+      begin
+	@import_reference_mutex.synchronize do
+	  pair = @import_reference.delete(ref.peer_id)
+	  @rev_import_reference.delete(pair.first)
+	  @deregister_reference_queue.concat [ref.peer_id, pair.last]
+	end
+      ensure
+	GC.enable unless status
+	@deregister_thread.wakeup
+      end
+    end
+
+    def deregister_import_reference_for_disable_gc(ref)
+      status = GC.disable
+      begin
+	@import_reference_mutex.synchronize do
+	  pair = @import_reference.delete(ref.peer_id)
+	  @deregister_reference_queue.concat [ref.peer_id, pair.last]
+	end
+      ensure
+	GC.enable unless status
+	@deregister_thread.wakeup
+      end
+    end
+ 
+    def deregister_import_reference_proc
+      proc do |ref_id|
+	if @status == :SERVICING
+	  puts "#{$$}: GC: gced id: #{ref_id}" if Conf.DISPLAY_GC
+	  peer_id = @rev_import_reference.delete(ref_id)
+	  pair = @import_reference.delete(peer_id)
+	  @deregister_reference_queue.concat [peer_id, pair.last]
+	  @deregister_thread.wakeup
+	end
+      end
+    end
+
+    def start_deregister_reference_org
+      @deregister_thread  = Thread.start {
+	ids = []
+	while ids.push @deregister_reference_queue.pop
+	  begin
+	    while ids.push @deregister_reference_queue.pop(true); end
+	  rescue ThreadError
+	    deregister_roots_to_peer(ids) if @status == :SERVICING
+	  end
+	end
+      }
+    end
+
+    def start_deregister_reference
+      @deregister_thread  = Thread.start {
+	ids = []
+	loop do
+	  Thread.stop
+	  Thread.exit unless @status == :SERVICING
+
+	  ids = []
+	  @import_reference_mutex.synchronize do
+	    status = GC.disable
+	    begin
+	      ids = @deregister_reference_queue.dup
+	      @deregister_reference_queue.clear
+	    ensure
+	      GC.enable unless status
+	    end
+	  end
+	  unless ids.empty?
+	    deregister_roots_to_peer(ids) 
+	  end
+	  sleep 1
+	end
+      }
+    end
+
+    def register_root_to_peer(id)
+      unless import_reference(id)
+	@session.register_root_to_peer(id)
+      end
+    end
+
+    def deregister_roots_to_peer(ids)
+      puts "#{$$}: GC: send deregister id: #{ids.join(' ')}" if Conf.DISPLAY_GC
+      @session.deregister_root_to_peer(ids)
+    end
+    
+  end
+
+  class DeepSpaceNoConnection
+    def initialize(peer_id)
+      @peer_id = peer_id
+    end
+
+    attr_reader :peer_id
+    alias peer_uuid peer_id
+
+    def session
+      DC::Raise ConnectionRefused, @peer_id
+    end
+    def register_import_reference(r)
+      nil
+    end
+
+    def import_reference(r)
+      nil
+    end
+
+    def register_root_to_peer(object_id)
+      # do nothing
+    end
+
+  end
+
+  class IllegalObject
+    def initialize(id)
+      @id = id
+    end
+
+    def send(*opts)
+      DC.Raise IllegalReference, @id, opts.first
+    end
+    alias __send__ send
+    alias __public_send__ send
+  end
+end
+