dango 0.2.3 → 0.2.4

data/lib/dango/framework_base.rb

@@ -225,7 +225,7 @@ module DangoFrameworkModule
   
   # データ送信処理
   def dango_send_data(sock, send_objs, options = {})
-#    logger.debug "dango_send_data:send_objs=#{send_objs.inspect}"
+#    logger.debug "dango_send_data:sock=#{sock.inspect} dtype=#{dtype}"
     
     dtype = options[:type] || DefaultDataType
     
@@ -239,6 +239,9 @@ module DangoFrameworkModule
       send_data_orig = Marshal.dump(send_objs)
     end
     
+#    logger.debug "dango_send_data:#{send_data_orig.inspect}"
+#    logger.debug "dango_send_data:#{dango_send_encrypt(send_data_orig).inspect}"
+    
     send_data = dango_send_encrypt(send_data_orig) + "\n"
 #    send_data = dango_send_encrypt(send_data_orig) + "\r\n"
 #    send_data = dango_send_encrypt(send_data_orig) + "\015\012"

data/lib/dango/server_framework.rb

@@ -9,14 +9,16 @@ require 'digest/md5'
 
 require "dango/framework_base"
 require "dango/socket_list"
+require "dango/version"
 require "dango/mutex_socket_list"
+require "dango/session_manager"
 require "dango/monitor/server_monitor_action"
 
 # フレームワーククラス
 class DangoServerFramework
   include DangoFrameworkModule
   
-  env = ENV['RAILS_ENV'] || 'development'
+  RAILS_ENV = ENV['RAILS_ENV'] || 'development'
   
   ### 以下すべてデフォルト値
   DefaultNetworkPort = 15000          # デフォルトのポート番号
@@ -24,7 +26,7 @@ class DangoServerFramework
   DefaultServerHost = 'localhost'     # 接続制限ホスト "0.0.0.0"にすれば全接続オッケイ
   DefaultMaxConnections = 10          # デフォルトの最大接続人数
   
-  DefaultLogFile     = "log/dango_#{env}.log"
+  DefaultLogFile     = "log/dango_#{RAILS_ENV}.log"
   DefaultLogLevel    = Logger::INFO
   DefaultLogMaxSize  = 1048576
   DefaultLogShiftAge = 99
@@ -38,9 +40,11 @@ class DangoServerFramework
 #  HeartBeatResponseWaitSec = 10.0     # S=>Cのheart beatの返信待ち秒数
   HeartBeatReceiveWaitSec = 30.0      # C=>Sのheart beatの受信待ち秒数
   GCIntervalSec = 5.0                 # GCの発生タイミング
+  StatisticsProcessMemoryCount = 100  # GCがこの回数起きた時に統計を取る
   
   ServerStopWait = 0.2                # サーバー停止時のGServerの確認待ち時間
   
+  
   class DangoGServer < GServer
     def initialize(parent, *args)
       @parent = parent
@@ -76,6 +80,7 @@ class DangoServerFramework
       logger.info "socket_list.keys:#{socket_list.keys.inspect}"
       socket_list.keys.each do |sk|
         logger.debug "sk:#{socket_list[sk].inspect}"
+        next if ! socket_list[sk]
         socket_list[sk].close if ! socket_list[sk].closed?
         socket_list[sk]
       end
@@ -158,16 +163,17 @@ class DangoServerFramework
     set_server_variables()                # 各種サーバー仕様の変数設定
     
     logger.warn("===== server initialize =====") # loggerの準備
-    logger.warn("ENV['RAILS_ENV']=#{ENV['RAILS_ENV']}")
-    logger.warn("Process.pid=#{Process.pid}")
     logger.warn("network_port=#{@network_port}")
     logger.warn("network_host=#{@network_host}")
     logger.warn("server_host=#{@server_host}")
     logger.warn("max_connections=#{@server_max_connections}")
+    logger.warn("RAILS_ENV=#{RAILS_ENV}")
+    logger.warn("Process.pid=#{Process.pid}")
+    logger.warn("Dango Version=#{Dango::VERSION::STRING}")
+#    logger.debug("$LOADED_FEATURES=#{$LOADED_FEATURES.pretty_inspect}")
     
-    session_init()                        # セッション情報の初期化
+    @session_manager = SessionManager.new # セッション情報の初期化
     shared_init()                         # 共有メモリを初期化
-    notice_shared_init()                  # 通知共有メモリを初期化
     socket_list_init()                    # ソケット一覧を初期化
     mutex_socket_list_init()              # ソケット毎用のmutexを初期化
     @mutex_proc_thread = Mutex.new        # スレッドが同時起動しないようにするためのMutex
@@ -280,7 +286,7 @@ class DangoServerFramework
   
   # gserverのserveメソッド：スレッド開始処理
   def thread_main(sock)
-    logger.info "#{sock} is accepted. thread.current=#{Thread.current.object_id} "
+    logger.info "thread_main:connect. sock=#{sock} thread.current=#{Thread.current.object_id}"
     
     @thr_gr_gserver_serve.add(Thread.current) # スレッドグループに登録
     
@@ -288,9 +294,11 @@ class DangoServerFramework
       sock.binmode
       sock.sync = true
       
-      sid = Thread.current.object_id.deep_dup
-#      sid = sock.object_id
-      session[:sid] = sid
+      @session_manager.start_session() # sessionの開始処理 sidは自動生成
+      sid = session[:sid]
+      
+      logger.debug "thread_main:start_session. sid=#{sid} sock=#{sock} thread.current=#{Thread.current.object_id}"
+      
       socket_list.add(sid, sock)
       mutex_socket_list.add(sid)
       
@@ -357,8 +365,8 @@ EOF
             send_notice("_notice_sid", sid, send_obj)
             logger.debug "_notice_sid #{sid} "
             
-            session[:connected] = true
             dango_connect() # 接続時メソッド呼び出し
+            session[:connected] = true
           end
           
           ret_objs.each do |ret_obj| # 受信データループ
@@ -436,7 +444,9 @@ EOF
         begin
           if !is_flash_policy_file # Flash Policy Fileなら切断処理不要
             logger.info "#{sock.inspect} #{sid} is closing"
-            dango_close() # 接続解除時に呼び出されるメソッド
+            if session[:connected] # dango_connect()が実行済みなら
+              dango_close() # 接続解除時に呼び出されるメソッド
+            end
           end
         rescue Exception
           logger.error "#{sock.inspect} #{sid} ERROR\n#{error_message($!, 'u')}"
@@ -452,8 +462,9 @@ EOF
         end
       end
       
-      session_del() # @mutex_proc_thread.synchronizeの中だとうまくいかない
+      @session_manager.close_session() # sessionの終了処理
     end
+    
   end
   
   # action_nameが送信パケットの返事なら
@@ -494,6 +505,8 @@ EOF
     @policy_file_allow_domain          = @config['server']['policy_file_allow_domain']
     @policy_file_allow_domain          = [@network_host] if @policy_file_allow_domain.class != Array
 
+    @statistics_process_memory         = @config['server']['statistics_process_memory'] || false # プロセスのメモリ使用量統計を取る
+
     # ログレベルの設定
     log_level_hash = {
       "FATAL" => Logger::FATAL, 
@@ -540,118 +553,12 @@ EOF
   end
   attr_accessor(:shared)
   
-  # 通知共有メモリ
-  def notice_shared_init
-#   @notice_shared = NoticeShared.new(self)
-    @notice_shared = select_shared_database_manager()
-    
-    class << @notice_shared ## 各種メソッド追加
-      def initialize2(parent)
-        @parent = parent
-        self[:notice_list] = {}
-      end
-
-      def init_key(key) # そのキーを作成する
-        if self[:notice_list].has_key?(key) || key == :notice_list # キーがすでにあるか予約語なら
-          raise(DangoFrameworkError, "notice_list already has key. key=#{key.inspect}")
-        end
-        
-        self.transaction(:notice_list) do |notice_list|
-          notice_list[key] = []
-          notice_list
-        end
-      end
-      
-      def add_connectable(key, sid) # 接続許可にする
-        if !self[:notice_list].has_key?(key) # キーがなければ
-          raise(DangoFrameworkError, "notice_list not has key. key=#{key.inspect}")
-        end
-        
-        self.transaction(:notice_list) do |notice_list|
-          notice_list[key] << sid
-          notice_list
-        end
-      end
-      
-      def remove_connectable(key, sid) # 接続を不許可にする
-        if !self[:notice_list].has_key?(key) # キーがなければ
-          raise(DangoFrameworkError, "notice_list not has key. key=#{key.inspect}")
-        end
-        
-        self.transaction(:notice_list) do |notice_list|
-          notice_list[key].delete(sid)
-          notice_list
-        end
-      end
-      
-      def get_connectables(key) # 接続許可一覧を返す
-        if !self[:notice_list].has_key?(key) # キーがなければ
-          raise(DangoFrameworkError, "notice_list not has key. key=#{key.inspect}")
-        end
-        
-        self[:notice_list][key]
-      end
-      
-      def notice_change(key, value) # 変更時に通知する変更
-        if !self[:notice_list].has_key?(key) # キーがなければ
-          raise(DangoFrameworkError, "notice_list not has key. key=#{key.inspect}")
-        end
-        
-        self[key] = value
-        
-        @parent.logger.debug "self.get_connectables(key):#{self.get_connectables(key).inspect}"
-        
-        self.get_connectables(key).each do |sid|
-          @parent.send_notice("notice_shared_#{key}", sid, value)
-        end
-      end
-      
-      def not_notice_change(key, value) # 変更時に通知しない変更
-        if !self[:notice_list].has_key?(key) # キーがなければ
-          raise(DangoFrameworkError, "notice_list not has key. key=#{key.inspect}")
-        end
-        
-        self[key] = value
-      end
-      
-      def []=(key, value) # データの変更
-        if key != :notice_list && !self[:notice_list].has_key?(key) # キーがなければ
-          raise(DangoFrameworkError, "notice_list not has key. key=#{key.inspect}")
-        end
-        
-        super(key, value) # データの変更
-      end
-    end
-  end
-  attr_accessor(:notice_shared)
   
   # セッション
-  def session_init # セッション情報の初期化
-    @session_list = {}
-#    @session_th_list = {}
-  end
   def session
-    if !Thread.current[:session]
-      Thread.current[:session] = {}
-      @session_list[Thread.current.object_id] = Thread.current[:session]
-#      @session_th_list[Thread.current.object_id] = Thread.current
-    end
-    Thread.current[:session]
-#    sid = Thread.current.object_id
-#    @session[sid] = Session.new if !@session[sid]
-#    @session[sid]
-  end
-  def session_del # セッション情報の初期化
-    begin
-      @session_list.delete(Thread.current.object_id)
-#    @session_th_list.delete(Thread.current)
-    rescue Exception
-      logger.error "ERROR\n#{error_message($!, 'u')}"
-    end
+    @session_manager.session
   end
   
-  attr_reader(:session_list)
-#  attr_reader(:session_th_list)
   
   # ソケットとIDの対応
   def socket_list_init
@@ -665,6 +572,7 @@ EOF
   end
   attr_accessor(:mutex_socket_list)
   
+  
   # 接続時に呼び出されるメソッド
   def dango_connect
   end
@@ -690,7 +598,7 @@ EOF
     dango_server_receive_decrypt(str)
   end
   
-  # GCスレッドの開始
+  # GCスレッドの開始(メモリ使用量統計も含む)
   def gc_thread_start
     th = Thread.start do
       loop do
@@ -703,9 +611,29 @@ EOF
           GC.enable
           GC.start 
           GC.disable
-          logger.info "GC end #{Time.now - gc_start_time}sec "
+          logger.debug "GC end #{Time.now - gc_start_time}sec "
 #          Thread.critical = false
           
+          # メモリ使用量統計
+          if @statistics_process_memory 
+            memory_usage = 0
+            if RUBY_PLATFORM == 'i386-mswin32'
+              require "win32ole"
+              locator = WIN32OLE.new("WbemScripting.SWbemLocator.1") #(A)
+              service = locator.ConnectServer                        #(B)
+              set = service.ExecQuery("select * from Win32_Process WHERE ProcessId = #{Process.pid}") #(C)
+              set.each do |process| 
+                memory_usage = process.PageFileUsage.to_i
+              end
+            else
+              stat = `cat /proc/#{Process.pid}/stat`.split(" ")
+              memory_usage = stat[22].to_i
+            end
+            
+            open("log/dango_stat_proc_mem_#{RAILS_ENV}.log", "ab"){|fh| fh.write "#{Time.now_to_s},#{memory_usage},#{@thr_gr_gserver_serve.list.length}\n" }
+            logger.debug "statistics_process_memory file add."
+          end
+          
         rescue Exception
           logger.error "Exception gc_thread_start  #{error_message($!, 'u')}"
         end
@@ -733,6 +661,7 @@ EOF
             # 全員へheart_beatパケットを送信
             socket_list.keys.each do |sid|
               sock = socket_list[sid]
+              next if ! sock
 #              logger.debug "heart_beat_thread_start:sid=#{sid} #{sock} #{sock.closed?}"
 #              send_notice("_heart_beat", sid, {}, {:timeout=>@heart_beat_response_wait_sec})
               
@@ -811,32 +740,7 @@ EOF
 #      send_id = Digest::MD5.hexdigest(sid.to_s + notice_name.to_s + Time.now.to_f.to_s + rand().to_s)
       send_obj_dup["_id"] = send_id
       
-=begin
-      sock = socket_list[sid]
-      if !sock || sock.closed? # sockがないという事はすでに切断済み
-        logger.info "send_notice:already closed socket. sid=#{sid.inspect} sock=#{sock.inspect} #{sock ? sock.closed? : nil} "
-        return(self)
-      end
-      
-#      if !sock
-#        logger.info "send_notice:not found sid=#{sid}"
-#        is_error = true
-#      end
-      
-#      if sock.closed?
-#        logger.info "send_notice:socket closed. sid=#{sid}"
-#        is_error = true
-#      end
-      
-      # sidの通知の場合はレスポンスを気にしない
-#      if notice_name.to_s == "_notice_sid"
-        dango_send_data(sock, [send_obj_dup], :type=>dtype) # データ送信
-#      else
-#        send_notice_thread(sid, notice_name, send_obj_dup, dtype, timeout, sock) # thread for notice send
-#      end
-=end
-      
-      @queue_send_notice.push([sid, send_obj_dup, dtype])
+      @queue_send_notice.push([sid, send_obj_dup, dtype].deep_dup)
     end # end sids.each
     
 #    raise(DangoFrameworkConnectionError, "send_notice:error happened.") if is_error
@@ -850,7 +754,7 @@ EOF
       begin
         send_data_list = []
         send_data_list.push(@queue_send_notice.pop) # Queueデータ待ち
-        logger.debug "thread_send_notice_queue:sending data"
+#        logger.debug "thread_send_notice_queue:sending data"
         while(! @queue_send_notice.empty?) do       # 残りのデータもQueueに入れていく
           send_data_list.push(@queue_send_notice.pop)
         end
@@ -880,7 +784,12 @@ EOF
           end
           
           begin
+            logger.debug "thread_send_notice_queue:dango_send_data:sid=#{sid} sock=#{sock.inspect} #{one_send_data_sid.collect{|d| d['notice'] + ','}}"
+            
+#            logger.debug one_send_data_sid.pretty_inspect
+            
             dango_send_data(sock, one_send_data_sid, :type=>send_data_dtype_list[sid]) # データ送信
+            
           rescue DangoFrameworkConnectionError
             logger.info "thread_send_notice_queue:failed send. sid=#{sid} sock=#{sock.inspect} #{$!.class}"
           end
@@ -894,80 +803,6 @@ EOF
     end
   end
   
-=begin
-  # thread for notice send
-  def send_notice_thread(sid, notice_name, send_obj_dup, dtype, timeout, sock)
-    Thread.start(sid, notice_name, send_obj_dup, dtype, timeout, sock) do
-      begin
-        @thr_gr_send_notice.add(Thread.current) # send_noticeスレッドグループに登録
-        
-        mutex_socket_list.synchronize(sid) do
-          have_came_response = nil
-          
-          receive_thread = Thread.start(sock, send_obj_dup, dtype) do
-            begin
-              @thr_gr_send_data.add(Thread.current) # send_dataスレッドグループに登録
-              
-              dango_send_data(sock, [send_obj_dup], :type=>dtype) # データ送信
-            rescue DangoFrameworkConnectionError
-              logger.warn "send_notice:DangoFrameworkConnectionError:notice_name=#{notice_name.inspect} #{sid} "
-            rescue DangoFrameworkError
-              logger.warn "ERROR:send_notice:DangoFrameworkError:notice_name=#{notice_name.inspect} #{sid} \n #{error_message($!, 'u')}"
-            rescue Exception
-              logger.warn "ERROR:send_notice:Exception:notice_name=#{notice_name.inspect} #{sid} \n #{error_message($!, 'u')}"
-            end
-          end
-          
-          # データ送信スレッドの終了待ち
-          if !receive_thread.join(@send_timeout_sec)
-            # タイムアウトの場合は
-            logger.warn "send_notice:send timeout:#{notice_name} #{sid} " 
-          else
-            end_reserved_time = Time.now + timeout
-            
-            # タイムアウトチェック
-            catch(:send_timeout) do
-              (timeout.to_f / @send_receive_sleep_interval_sec).to_i.times do
-                sleep @send_receive_sleep_interval_sec # スリープ
-                
-                @mutex_send_response.synchronize do # データ送信の返信が来たかどうかの確認
-                  find_res = @arr_send_response.find{|r| r[:_id] == send_obj_dup["_id"] && r[:_sid] == sid }
-                  
-                  if find_res
-                    logger.debug "send_notice:find_res _heart_beat #{sid}" if notice_name.to_s == "_heart_beat"
-                    
-                    @arr_send_response.delete(find_res)
-                    have_came_response = true
-                    throw(:send_timeout)
-                  end
-                end
-                
-                if Time.now > end_reserved_time
-                  logger.debug "send_notice:receive timeout:#{notice_name} #{sid}  #{end_reserved_time}" 
-                  
-                  # このコードは不要なはずだが念の為取っておいてある、安定したことが確認できたら削除する
-                  if notice_name.to_s == "_heart_beat" # heart beatだったらsockを止める
-                    logger.info "!!!! send_notice:heart_beat timeout" 
-                    sock.close if !sock.closed?
-                  end
-                  break
-                end
-                
-              end # タイムアウト処理終わり
-            end # catch 終わり
-            
-            if !have_came_response # 戻ってきたデータがあるかどうかチェック
-              logger.warn "!!! received data is none:#{notice_name} #{sid} #{send_obj_dup['_id']} "
-            end
-          end
-        end # mutex
-      rescue Exception
-        logger.error "send_response_thread error:#{error_message($!, 'u')}"
-      end
-    end # Thread:end
-  end
-=end
-
   # 必要に応じて追加するメソッド
   def method_missing(name, *args)
     if name.to_s =~ /^dango_receive_action_notice_shared_(.+)/ # 共有メモリ変更通知なら

data/lib/dango/session_manager.rb

@@ -0,0 +1,61 @@
+#!ruby -Ku
+
+# sessionとsidの管理（１セッションごとにインスタンス化される）
+class SessionManager
+  MaxSidCounter = 999999
+
+  def initialize
+    @session_list = {}
+    @session_mutex = Mutex.new
+    
+    @sid_counter = 0
+    @sid_list = {}
+  end
+  
+  
+  # session開始
+  def start_session()
+    @session_mutex.synchronize do
+      sid = generate_sid()
+      @session_list[Thread.current.object_id] = {:sid => sid}
+    end
+  end
+  
+  # session終了
+  def close_session()
+    @session_mutex.synchronize do
+      drop_sid()
+      @session_list[Thread.current.object_id] = nil
+    end
+  end
+  
+  # sessionへのアクセス
+  def session
+    @session_mutex.synchronize do
+      @session_list[Thread.current.object_id]
+    end
+  end
+  
+  
+  private
+  
+  # sid情報作成
+  def generate_sid()
+    sid = nil
+    while(sid == nil) do
+      @sid_counter += 1
+      @sid_counter = 1 if @sid_counter > MaxSidCounter
+      sid = @sid_counter if ! @sid_list.has_key?(@sid_counter)
+    end
+    
+    @sid_list[sid] = Thread.current.object_id
+    sid
+  end
+  
+  # sid削除
+  def drop_sid()
+    @sid_list.delete_if{|sid, oid| oid == Thread.current.object_id }
+    self
+  end
+  
+end

data/lib/dango/tester/dango_tester_client.rb

@@ -142,7 +142,7 @@ class TestClient < DangoClientFramework
     @connection_client_port = @config["network"]["port"] # 自動でこのポートでサーバー開始
     
     # ログ出力情報
-    @connection_client_log_file = "log/tester_#{@client_name}.log" # 自動でこのログファイル名を使う
+    @connection_client_log_file = "log/tester_#{Process.pid}_#{@client_name}.log" # 自動でこのログファイル名を使う
     @connection_client_log_level = Logger::DEBUG # 自動でこのログレベルになる
   end
   
@@ -174,124 +174,6 @@ class TestClient < DangoClientFramework
   end
   
   
-=begin
-  # trap_receive
-  def trap_receive(notice_name, options = {})
-    logger.debug "trap_receive_data:#{notice_name}:"
-    timeout = options[:timeout] || ReceiveTrapTimeoutSec
-    trap_proc = options[:proc] || nil
-    trap_loop = options[:loop] || nil # procがある場合のみ有効なフラグ
-    raise(ArgumentError, ":proc is not Proc class.") if trap_proc && ! trap_proc.is_a?(Proc)
-    
-    # 戻ってきたデータのチェックメソッド
-    
-#    if ! @receive_methods.include?(notice_name_sym)
-      notice_name_sym = (notice_name.class == Symbol) ? (":"+notice_name.to_s) : ('"'+notice_name+'"')
-      instance_method_name = "dango_receive_#{notice_name}"
-      expr = <<-EOF
-        def self.#{instance_method_name}(ret_obj)
-          logger.debug "ret_obj:#{notice_name_sym}:" + ret_obj.inspect + " " + Time.now_to_s
-          send_receive_shared[#{notice_name_sym}] = ret_obj
-        end
-      EOF
-      instance_eval expr
-#      @receive_methods.push(notice_name_sym)
-#    end
-    
-    # @trap_thread_hashにスレッド登録
-    if ! @trap_thread_hash.has_key?(notice_name)
-      
-      # スレッド開始
-      th = Thread.start(notice_name, timeout, trap_proc, trap_loop) do
-        loop do
-          send_receive_shared[notice_name] = nil
-          if timeout == 0
-            end_reserved_time = Time.at(0)         # 0ならepochを入れる
-          else
-            end_reserved_time = Time.now + timeout # 0以上ならタイムアウト時間決定
-          end
-          
-          # タイムアウトチェック
-          loop do
-            if end_reserved_time != Time.at(0) && end_reserved_time < Time.now
-              raise(DangoFrameworkTimeoutError, "timeout:timeout_sec=#{timeout}: \n client_name=#{@client_name}(#{self.sid}): \n notice_name=#{notice_name}") 
-            end
-            
-            # 戻ってきたデータがあれば
-            if send_receive_shared[notice_name]
-              logger.debug "notice_name:#{notice_name}:#{send_receive_shared[notice_name].inspect} "
-              break 
-            end
-            
-            sleep SendReceiveSleepIntervalSec # スリープ
-          end
-          
-          # 戻ってきたデータがあるかどうかチェック
-          if !send_receive_shared[notice_name] 
-            raise(DangoFrameworkError, "received data is none. sid=#{self.sid} notice_name=#{notice_name}")
-          end
-          
-          # :procが設定されている場合は、それを呼び出す
-          if trap_proc
-            logger.debug "trap_receive_data:trap_proc:#{trap_proc.inspect} "
-            trap_proc.call(send_receive_shared[notice_name])
-            send_receive_shared[notice_name] = nil
-            break if ! trap_loop # loopする必要がなければスレッド終了
-            
-          # :procが設定されていなければ、wait用に@receive_arrに入れておく
-          else
-            @receive_mutex.synchronize do
-              logger.debug "notice_name:#{notice_name}:#{send_receive_shared[notice_name].inspect} "
-              @receive_arr.push([notice_name.deep_dup, send_receive_shared[notice_name].deep_dup])
-              send_receive_shared[notice_name] = nil
-            end
-            break # スレッド終了
-            
-          end
-        end # loop
-        
-        # メソッドの削除
-        instance_method_name = "dango_receive_#{notice_name}"
-        expr = <<-EOF
-          def self.#{instance_method_name}(ret_obj); end
-        EOF
-        instance_eval expr
-        
-      end # Thread
-      
-      @trap_thread_hash[notice_name] = th
-    else
-      
-      logger.debug "trap_receive_data:already register trap:notice_name:#{notice_name} "
-    end
-    
-    logger.debug "trap_receive_data:registered:#{notice_name}:"
-  end
-  
-  # cancel trap_receive
-  def cancel_trap_receive(notice_name, options = {})
-    logger.debug "cancel_trap_receive:#{notice_name}:"
-    
-    # trapスレッドの削除
-    if @trap_thread_hash[notice_name] 
-      logger.debug "cancel_trap_receive:#{@trap_thread_hash[notice_name].status }:"
-      @trap_thread_hash[notice_name].kill
-      logger.debug "cancel_trap_receive:#{@trap_thread_hash[notice_name].status }:"
-      @trap_thread_hash[notice_name].join
-      logger.debug "cancel_trap_receive:#{@trap_thread_hash[notice_name].status }:"
-      
-      @trap_thread_hash.delete(notice_name)
-    end
-    
-    # 受信データのごみを削除
-    send_receive_shared[notice_name] = nil 
-    
-    @receive_mutex.synchronize do
-      @receive_arr.delete_if{|r| r[0] == notice_name}
-    end
-  end
-=end
-  
   # wait_receive
   def wait_receive(notice_name, options = {})
     logger.debug "wait_receive_data:#{notice_name}:"
@@ -334,51 +216,19 @@ class TestClient < DangoClientFramework
     receive_data[1]
   end
   
-=begin
-  def wait_receive(notice_name, options = {})
+  # clear_receive notice_nameを省略するとchacheにあるものすべて削除
+  def clear_receive(notice_name = nil, options = {})
     logger.debug "wait_receive_data:#{notice_name}:"
-    timeout = options[:timeout] || ReceiveWaitTimeoutSec
-    
-    # データ受信待ち
-    receive_data = nil
-    
-    end_reserved_time = Time.now + timeout # 0以上ならタイムアウト時間決定
-    
-    loop do
-      @receive_mutex.synchronize do
-        receive_data = @receive_arr.find{|r| r[0] == notice_name}.deep_dup
-      end
-      
-      break if receive_data != nil
-      break if end_reserved_time < Time.now
-      
-      sleep SendReceiveSleepIntervalSec # スリープ
-    end
-    
-    # タイムアウトなら
-    if receive_data == nil
-      raise(DangoFrameworkTimeoutError, "timeout:timeout_sec=#{timeout}: \n client_name=#{@client_name}(#{self.sid}) \n :notice_name=#{notice_name} \n") 
-    end
     
     # 結果を削除しておく
-    @receive_mutex.synchronize do
-      @receive_arr.delete_if{|r| r[0] == notice_name}
+    send_receive_shared.transaction(:receive_cache) do |receive_cache|
+      receive_cache.delete_if do |one_rec_data|
+        true if (! notice_name) || (notice_name && one_rec_data[0] == notice_name)
+      end
+      receive_cache
     end
-    
-    @trap_thread_hash.delete(notice_name)
-    
-    receive_data[1]
   end
   
-  # receive_arrの状態確認
-  def receive_arr
-    receive_arr = nil
-    @receive_mutex.synchronize do
-      receive_arr = @receive_arr.deep_dup
-    end
-    receive_arr
-  end
-=end
   
 end
 

data/lib/dango/version.rb

@@ -2,7 +2,7 @@ module Dango #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 2
-    TINY  = 3
+    TINY  = 4
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dango
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors: 
 - Keisuke Minami
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-01 00:00:00 +09:00
+date: 2008-05-19 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,6 +46,7 @@ files:
 - lib/dango/server_framework.rb
 - lib/dango/mutex_socket_list.rb
 - lib/dango/socket_list.rb
+- lib/dango/session_manager.rb
 - lib/dango/monitor/dango_monitor_client.rb
 - lib/dango/monitor/server_monitor_action.rb
 - lib/dango/script/dango_server.rb
@@ -86,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: dango
-rubygems_version: 1.0.1
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
 summary: Realtime communications network framework for Ruby and Flash on Rails.