DeepConnect 0.4.06

data/lib/deep-connect/serialize.rb

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+#
+#   serialize.rb - 
+#   	Copyright (C) 1996-2010 Keiju ISHITSUKA
+#				(Penta Advanced Labrabries, Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+require "deep-connect/reference"
+
+module DeepConnect
+  UNSERIALIZABLE_CLASSES = [
+    Binding,
+    UnboundMethod,
+    Method,
+    Proc,
+    Dir,
+    File,
+    IO,
+    ThreadGroup,
+    Thread,
+    Data,
+#    Class,
+#    Module,
+  ]
+  if defined?(Continuation)
+    UNSERIALIZABLE_CLASSES.push Continuation
+  end
+  if defined?(StopIteration)
+    UNSERIALIZABLE_CLASSES.push StopIteration
+  end
+  if defined?(Enumerable::Enumerator)
+    UNSERIALIZABLE_CLASSES.push Enumerable::Enumerator
+  end
+
+  UNSERIALIZABLE_CLASS_SET = {}
+  UNSERIALIZABLE_CLASSES.each do|k|
+    UNSERIALIZABLE_CLASS_SET[k] = k
+  end
+end
+
+class Object 
+  def self.deep_connect_materialize_val(deep_space, value)
+    obj = allocate
+    value.each do |v, o|
+      obj.instance_variable_set(v, DeepConnect::Reference.materialize(deep_space, *o))
+    end
+    obj
+  end
+
+  def deep_connect_serialize_val(deep_space)
+    if DeepConnect::UNSERIALIZABLE_CLASS_SET.include?(self.class)
+      DeepConnect.Raise CantSerializable, self.class.name
+    end
+    vnames = instance_variables
+    vnames.collect{|v| 
+      [v, 
+	DeepConnect::Reference.serialize(deep_space, instance_variable_get(v))]}
+  end
+
+  def deep_connect_dup
+    if DeepConnect::UNSERIALIZABLE_CLASS_SET.include?(self.class)
+      DeepConnect.Raise CantDup, self.class.name
+    end
+    self
+  end
+  alias dc_dup deep_connect_dup
+  DeepConnect.def_method_spec(self, :rets=>"VAL", :method=>:deep_connect_dup)
+  DeepConnect.def_method_spec(self, :rets=>"VAL", :method=>:dc_dup)
+
+  def deep_connect_deep_copy
+    if DeepConnect::UNSERIALIZABLE_CLASS_SET.include?(self.class)
+      DeepConnect.Raise CantDeepCopy, self.class.name
+    end
+    self
+  end
+  alias dc_deep_copy deep_connect_deep_copy
+  DeepConnect.def_method_spec(self, :rets=>"DVAL", :method=>:deep_connect_deep_copy)
+  DeepConnect.def_method_spec(self, :rets=>"DVAL", :method=>:dc_deep_copy)
+end
+
+class Array
+  def self.deep_connect_materialize_val(deep_space, value)
+    ary = new
+    value.each{|e| ary.push DeepConnect::Reference.materialize(deep_space, *e)}
+    ary
+  end
+
+  def deep_connect_serialize_val(deep_space)
+    collect{|e| DeepConnect::Reference.serialize(deep_space, e)}
+  end
+
+end
+
+class Hash
+  def self.deep_connect_materialize_val(deep_space, value)
+    hash = new
+    value.each do |k, v| 
+      key = DeepConnect::Reference.materialize(deep_space, *k)
+      value = DeepConnect::Reference.materialize(deep_space, *v)
+      hash[key] = value
+    end
+    hash
+  end
+
+  def deep_connect_serialize_val(deep_space)
+    collect{|k, v| 
+      [DeepConnect::Reference.serialize(deep_space, k), 
+	DeepConnect::Reference.serialize(deep_space, v)]}
+  end
+
+end
+
+class Struct
+  def self.deep_connect_materialize_val(deep_space, value)
+    new(*value.collect{|e| DeepConnect::Reference.materialize(deep_space, *e)})
+  end
+
+  def deep_connect_serialize_val(deep_space)
+    to_a.collect{|e| DeepConnect::Reference.serialize(deep_space, e)}
+  end
+end
+
+

data/lib/deep-connect/session.rb

@@ -0,0 +1,348 @@
+# encoding: UTF-8
+#
+#   session.rb - 
+#   	Copyright (C) 1996-2010 Keiju ISHITSUKA
+#				(Penta Advanced Labrabries, Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+require "thread"
+#require "mutex_m"
+require "weakref"
+
+require "ipaddr"
+
+require "deep-connect/exceptions"
+
+module DeepConnect
+  class Session
+
+    def initialize(deep_space, port, local_id = nil)
+      @status = :INITIALIZE
+
+      @organizer = deep_space.organizer
+      @deep_space = deep_space
+      @port = port
+
+      @export_queue = Queue.new
+
+      @waiting = Hash.new
+      @waiting_mutex = Mutex.new
+      @next_request_event_id = 0
+      @next_request_event_id_mutex = Mutex.new
+
+      @last_keep_alive = nil
+    end
+
+    attr_reader :organizer
+    attr_reader :deep_space
+
+    def peer_uuid
+      @deep_space.peer_uuid
+    end
+    alias peer_id peer_uuid
+
+    def start
+      @last_keep_alive = @organizer.tick
+
+      @status = :SERVICING
+      send_class_specs
+
+      @import_thread = Thread.start {
+	loop do
+	  begin
+	    ev = @port.import
+	    @last_keep_alive = @organizer.tick
+	  rescue EOFError, DC::DisconnectClient
+	    # EOFError: クライアントが閉じていた場合
+	    # DisconnectClient: 通信中にクライアント接続が切れた
+	    Thread.start do
+	      @organizer.disconnect_deep_space(@deep_space, :SESSION_CLOSED)
+	    end
+	    Thread.stop
+	  rescue DC::ProtocolError
+	    # 何らかの障害のためにプロトコルが正常じゃなくなった
+	  end
+	  if @status == :SERVICING
+	    receive(ev)
+	  else
+	    puts "INFO: service is stoped, imported event abandoned(#{ev.inspect})" 
+	  end
+	end
+      }
+
+      @export_thread = Thread.start {
+	loop do
+	  ev = @export_queue.pop
+	  if @status == :SERVICING
+	    begin
+	      # export中にexportが発生するとデッドロックになる
+	      # threadが欲しいか?
+#	      Thread.start do
+	      @port.export(ev)
+#	      end
+	    rescue Errno::EPIPE, DC::DisconnectClient
+	      # EPIPE: クライアントが終了している
+	      # DisconnectClient: 通信中にクライアント接続が切れた
+	      Thread.start do
+		@organizer.disconnect_deep_space(@deep_space, :SESSION_CLOSED)
+	      end
+	      Thread.stop
+	    end
+	  else
+	    puts "INFO: service is stoped, export event abandoned(#{ev.inspect})" 
+	  end
+	end
+      }
+      self
+    end
+
+    def stop_service(*opts)
+      unless Conf.DISABLE_INFO
+	puts "INFO: STOP_SERVICE: Session: #{self.peer_uuid} #{opts.join(' ')} "
+      end
+      org_status = @status
+      @status = :SERVICE_STOP
+      
+      if !opts.include?(:SESSION_CLOSED)
+	@port.shutdown_reading
+      end
+
+      if org_status == :SERVICING
+	@import_thread.exit
+	@export_thread.exit
+      
+	@waiting_mutex.synchronize do
+	  waiting_events = @waiting.sort{|s1, s2| s1[0] <=> s2[0]}
+	  for seq, ev in waiting_events
+	    begin
+	      p ev
+	      DC.Raise SessionServiceStopped
+	    rescue
+	      ev.result = ev.reply(nil, $!)
+	    end
+	  end
+	  @waiting.clear
+	end
+      end
+
+    end
+
+    def stop(*opts)
+      begin
+	@port.close
+      rescue IOError
+	puts "WARN: #{$!}"
+      end
+    end
+
+    # peerからの受取り
+    def receive(ev)
+      case ev
+      when Event::MQRequest
+#	Thread.start{ev.receiver.enq(self, ev)}
+	ev.receiver.enq(self, ev)
+      when Event::IteratorCallBackRequest
+        Thread.start{@organizer.evaluator.evaluate_block_yield(self, ev)}
+      when Event::IteratorRequest
+        Thread.start{@organizer.evaluator.evaluate_iterator_request(self, ev)}
+      when Event::Request
+        Thread.start{@organizer.evaluator.evaluate_request(self, ev)}
+      else
+	req = nil
+	@waiting_mutex.synchronize do
+	  req = @waiting.delete(ev.seq)
+	end
+	unless req
+	  DC.InternalError "対応する request eventがありません(#{ev.inspect})"
+	end
+	req.result = ev
+      end
+    end
+
+    # イベントの受け取り
+    def accept(ev)
+      @export_queue.push ev
+    end
+
+    # イベントの生成/送信
+    def send_to(ref, method, args=[], &block)
+      unless @status == :SERVICING
+	DC.Raise SessionServiceStopped
+      end
+      if iterator?
+	ev = Event::IteratorRequest.request(self, ref, method, args, block)
+      else
+	ev = Event::Request.request(self, ref, method, args)
+      end
+      @waiting_mutex.synchronize do
+	@waiting[ev.seq] = ev
+      end
+      @export_queue.push ev
+      ev.result
+    end
+
+    def block_yield(event, args)
+      ev = Event::IteratorCallBackRequest.call_back_event(event, args)
+      @waiting_mutex.synchronize do
+	@waiting[ev.seq] = ev
+      end
+      @export_queue.push ev
+      ev
+    end
+
+    def asynchronus_send_to(ref, method, args=[], callback=nil)
+      unless @status == :SERVICING
+	DC.Raise SessionServiceStopped
+      end
+      ev = Event::AsyncronusRequest.request(self, ref, method, args, callback)
+      @waiting_mutex.synchronize do
+	@waiting[ev.seq] = ev
+      end
+      @export_queue.push ev
+      nil
+    end
+    alias asyncronus_send_to asynchronus_send_to
+
+    def mq_send_to(ref, method, args=[], callback=nil)
+      unless @status == :SERVICING
+	DC.Raise SessionServiceStopped
+      end
+      ev = Event::MQRequest.request(self, ref, method, args, callback)
+      @waiting_mutex.synchronize do
+	@waiting[ev.seq] = ev
+      end
+      @export_queue.push ev
+      ev.result
+    end
+
+    # イベントID取得
+    def next_request_event_id
+      @next_request_event_id_mutex.synchronize do
+	@next_request_event_id += 1
+      end
+    end
+
+    def send_peer_session(req, *args)
+      ev = Event::SessionRequest.request(self, (req.id2name+"_impl").intern, args)
+      @waiting_mutex.synchronize do
+	@waiting[ev.seq] = ev
+      end
+      @export_queue.push ev
+      ev.result
+    end
+
+    def send_peer_session_no_recv(req, *args)
+      ev = Event::SessionRequestNoReply.request(self, (req.id2name+"_impl").intern, args)
+      @export_queue.push ev
+    end
+
+    def send_disconnect
+      return unless  @status == :SERVICING
+
+      ev = Event::SessionRequestNoReply.request(self, :recv_disconnect)
+      @port.export(ev)
+    end
+
+    def recv_disconnect
+      @organizer.disconnect_deep_space(@deep_space, :REQUEST_FROM_PEER)
+    end
+    Organizer.def_interface(self, :recv_disconnect)
+
+
+    def get_service(name, waitp = false)
+      if (sv = send_peer_session(:get_service, name, waitp)) == :DEEPCONNECT_NO_SUCH_SERVICE
+	DC.Raise NoServiceError, name
+      end
+      sv
+    end
+
+    def get_service_impl(name, waitp = false)
+      @organizer.service(name, waitp)
+    end
+    Organizer.def_interface(self, :get_service_impl)
+
+    def import_mq(name, waitp = false)
+      unless sv = send_peer_session(:import_mq, name, waitp)
+        DC.Raise NoServiceError, name
+      end
+      sv
+    end
+
+    def import_mq_impl(name, waitp = false)
+      @organizer.get_mq(name, waitp)
+    end
+    Organizer.def_interface(self, :import_mq_impl)
+
+
+    def register_root_to_peer(id)
+      # 同期を取るためにno_recvはNG
+      send_peer_session(:register_root, id)
+    end
+
+    def register_root_impl(id)
+      @deep_space.register_root_from_other_session(id)
+    end
+    Organizer.def_interface(self, :register_root_impl)
+
+    def deregister_root_to_peer(ids)
+      idsdump = Marshal.dump(ids)
+      send_peer_session_no_recv(:deregister_root, idsdump)
+    end
+
+    def deregister_root_impl(idsdump)
+      ids = Marshal.load(idsdump)
+      @deep_space.delete_roots(ids)
+      nil
+    end
+    Organizer.def_interface(self, :deregister_root_impl)
+
+    def send_class_specs
+      specs_dump = Marshal.dump(Organizer::class_specs)
+      send_peer_session_no_recv(:recv_class_specs, specs_dump)
+    end
+
+    def recv_class_specs_impl(specs_dump)
+      specs = Marshal.load(specs_dump)
+      @deep_space.class_specs = specs
+#p specs
+    end
+    Organizer.def_interface(self, :recv_class_specs_impl)
+
+
+#     def send_class_specs(cspecs)
+#       specs_dump = Marshal.dump(cspecs)
+#       ret = send_peer_session(:send_class_specs_impl, cspecs)
+#     end
+
+#     def send_class_specs_impl(spec_dump)
+#       specs = Marshal.load(spec_dump)
+#       @object_space.recv_class_specs(specs)
+#     end
+
+    def keep_alive
+      now = @organizer.tick
+      if now > @last_keep_alive + Conf.KEEP_ALIVE_INTERVAL*10
+	puts "KEEP ALIVE: session #{self} is dead." if Conf.DISPLAY_KEEP_ALIVE
+	false
+      else
+	if Conf.DISPLAY_KEEP_ALIVE
+	  puts "KEEP ALIVE: session #{self} is alive(INT: #{now - @last_keep_alive})."
+	  puts "KEEP ALIVE: send #{self} to keep alive."
+	end
+	send_peer_session_no_recv(:recv_keep_alive)
+	true
+      end
+    end
+
+    def recv_keep_alive_impl
+      puts "RECV_KEEP_ALIVE"  if Conf.DISPLAY_KEEP_ALIVE
+      @last_keep_alive = @organizer.tick
+    end
+    Organizer.def_interface(self, :recv_keep_alive_impl)
+  end
+end
+