dango 0.4.0 → 0.4.1

data/lib/dango/framework_base.rb

@@ -58,6 +58,7 @@ class DangoFrameworkDisconnectException < DangoFrameworkException; end
 class DangoFrameworkReadNoDataException < DangoFrameworkException; end
 class DangoFrameworkFlashPolicyException < DangoFrameworkException; end
 class DangoFrameworkMonitorSecurityException < DangoFrameworkException; end
+class DangoFrameworkTransactionException < DangoFrameworkException; end
 
 # エラー出力用モジュール
 module ErrorMessage

data/lib/dango/server_framework.rb

@@ -9,7 +9,6 @@ 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"
 
@@ -51,12 +50,12 @@ class DangoServerFramework
   def stop_gserver() # gserverの停止
     if @gserver && !@gserver.stopped?
       # 強制的に接続しているsocketをクローズ
-      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]
+      logger.info "socket_list.all_sid:#{socket_list.all_sid.inspect}"
+      socket_list.all_sid.each do |sid|
+        logger.debug "sk:#{socket_list[sid].inspect}"
+        next if ! socket_list[sid]
+        socket_list[sid].close if ! socket_list[sid].closed?
+        socket_list[sid]
       end
       
       # サーバーを停止
@@ -144,24 +143,24 @@ class DangoServerFramework
       logger.warn("Process.pid=#{Process.pid}")
       logger.warn("Dango Version=#{Dango::VERSION::STRING}")
 #    logger.debug("$LOADED_FEATURES=#{$LOADED_FEATURES.pretty_inspect}")
-    
-      @session_manager = SessionManager.new # セッション情報の初期化
-      shared_init()                         # 共有メモリを初期化
-      socket_list_init()                    # ソケット一覧を初期化
-      mutex_socket_list_init()              # ソケット毎用のmutexを初期化
-      @mutex_proc_thread = Mutex.new        # スレッドが同時起動しないようにするためのMutex
-      heart_beat_thread_start()             # ハートビートスレッドの開始
-      gc_thread_start()                     # GCスレッドの開始
-    
-      dango_server_init()                   # 初期設定読み込み
-    
-      @mutex_send_response = Mutex.new      # 送信レスポンス用のMutex
-      @arr_send_response = []               # 送信レスポンス用のキャッシュ
+      
+      shared_init()                                  # 共有メモリを初期化
+      socket_list_init()                             # ソケット一覧を初期化
+      @session_manager = SessionManager.new(shared)  # セッション情報の初期化
+      @mutex_proc_thread = Mutex.new                 # スレッドが同時起動しないようにするためのMutex
+      heart_beat_thread_start()                      # ハートビートスレッドの開始
+      gc_thread_start()                              # GCスレッドの開始
+      
+      dango_server_init()                            # 初期設定読み込み
+      
+      @mutex_send_response = Mutex.new               # 送信レスポンス用のMutex
+      @arr_send_response = []                        # 送信レスポンス用のキャッシュ
+      
       
       TCPSocket.do_not_reverse_lookup = true # 逆引きを行わない
 #     TCPSocket.do_not_reverse_lookup = false # 逆引きを行う
       
-      if @backdoor_run_drb_server # backdoor用のdrbを起動
+      if @backdoor_run_drb_server                    # backdoor用のdrbを起動
         uri = "druby://#{@network_host}:#{@backdoor_run_drb_port}"
         DRb.start_service(uri, self)
         logger.warn("start drb server: uri=#{DRb.uri}")
@@ -283,7 +282,6 @@ class DangoServerFramework
       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)
       
       session[:connected] = nil # まだdango_connectを呼び出していない
       
@@ -574,12 +572,6 @@ EOF
   end
   attr_accessor(:socket_list)
   
-  # ソケット毎用のmutex
-  def mutex_socket_list_init()
-    @mutex_socket_list = MutexSocketList.new()  # ソケット毎用のmutex
-  end
-  attr_accessor(:mutex_socket_list)
-  
   
   # 接続時に呼び出されるメソッド
   def dango_connect
@@ -667,7 +659,7 @@ EOF
             heart_beat_time_hash = shared[:_heart_beat_time_hash]
             
             # 全員分のチェック
-            socket_list.keys.each do |sid|
+            socket_list.all_sid.each do |sid|
               sock = socket_list[sid]
               
               if ! sock # すでにsocketが無い場合は、スキップ
@@ -694,7 +686,7 @@ EOF
           if logger.debug?
             count += 1
             if count % 100 == 0
-              sids = socket_list.keys
+              sids = socket_list.all_sid
               thr_list = @thr_gr_gserver_serve.list.collect{|th| th.object_id }
               
               logger.debug "heart_beat_thread_start:sids=#{sids.inspect}"
@@ -719,6 +711,7 @@ EOF
     shared.transaction(:_heart_beat_time_hash) do |heart_beat_time_hash|
       heart_beat_time_hash[session[:sid]] = Time.now
       heart_beat_time_hash
+      shared.commit(heart_beat_time_hash)
     end
   end
   

data/lib/dango/session_manager.rb

@@ -4,12 +4,13 @@
 class SessionManager
   MaxSidCounter = 999999
 
-  def initialize
+  def initialize(shared)
+    @shared = shared
     @session_list = {}
     @session_mutex = Mutex.new
     
-    @sid_counter = 0
-    @sid_list = {}
+    @shared[:_session_manager] = {}
+    
   end
   
   
@@ -22,7 +23,7 @@ class SessionManager
   end
   
   # session終了
-  def close_session()
+  def close_session(sid)
     @session_mutex.synchronize do
       drop_sid()
       @session_list[Thread.current.object_id] = nil
@@ -42,19 +43,37 @@ class SessionManager
   # 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)
+    @shared.transaction(:_session_manager) do |ses_man|
+      
+      ses_man[:sid_counter] = 0 if ! ses_man[:sid_counter]
+      ses_man[:sid_list] = {} if ! ses_man[:sid_list]
+      
+      while(sid == nil) do
+        ses_man[:sid_counter] += 1
+        ses_man[:sid_counter] = 1 if ses_man[:sid_counter] > MaxSidCounter
+        sid = ses_man[:sid_counter] if ! ses_man[:sid_list].has_key?(ses_man[:sid_counter])
+      end
+      
+      ses_man[:sid_list][ses_man[:sid_counter]] = "#{Process.pid}:#{Thread.current.object_id}"
+      
+      ses_man
+      @shared.commit(ses_man)
     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 }
+    @shared.transaction(:_session_manager) do |ses_man|
+      
+#      ses_man[:sid_list].delete(sid)
+      ses_man[:sid_list].delete_if{|sid, oid| oid == "#{Process.pid}:#{Thread.current.object_id}" }
+      
+      ses_man
+      @shared.commit(ses_man)
+    end
+    
     self
   end
   

data/lib/dango/shared/memory_store.rb

@@ -13,12 +13,19 @@ module DangoFrameworkModule
       @data = {}
       @mutex = {}
       @size = 0
+      
+      @transact_key = {}
+      @transact_thread = {}
+      @transact_commit = {}
+      @transact_rollback = {}
+      @transact_data = {}
     end
     
     def keys
       @data.keys
     end
     
+    # ハッシュ形式で取得
     def to_hash
       hash = {}
       @data.each do |k, v|
@@ -27,18 +34,106 @@ module DangoFrameworkModule
       hash
     end
     
-    def transaction(key) # トランザクション処理ブロックを作る
+=begin
+    # 昔のトランザクション処理ロジック
+    def transaction(key) 
       key = key.to_s
       if !@mutex.has_key?(key) # 未定義キーならエラー
         raise(DangoFrameworkException, "Shared key is not exist.")
       end
+      
       @mutex[key].synchronize do
 #        data = yield(@data[key].deep_dup)
         data = yield(@data[key])
         @data[key] = data.deep_dup
       end
+      
+      self
+    end
+    def commit(key, value) # トランザクションのコミット処理
+      value
+    end
+    def rollback(key) # トランザクションのロールバック処理
+    end
+=end
+
+    # トランザクション処理ブロックを作る（key単位のロック）
+    # このブロックの中でcommitかrollbackか例外発生を行わなければならない
+    def transaction(key) 
+      key = key.to_s
+      if !@mutex.has_key?(key) # 未定義キーならエラー
+        raise(DangoFrameworkException, "Shared key is not exist.")
+      end
+      
+      @mutex[key].synchronize do
+        @transact_key[Thread.current] = key # 違うスレッドからcommitできないように
+        
+        raise("nested transaction #{key}") if @transact_thread.has_key?(key)
+        @transact_thread[key] = Thread.current
+        @transact_commit[key] = false
+        @transact_rollback[key] = false
+        @transact_data[key] = nil
+        
+        begin
+          catch(:memory_store_finish_transaction) do
+            yield(@data[key].deep_dup)
+          end
+        rescue Exception # 例外発生の場合はrollbackとみなして、直前のエラーを再発生
+          @transact_rollback[key] = true
+          raise
+        ensure
+          @transact_thread.delete(key)
+          
+          if @transact_commit[key] # commitされた場合 データ書き込み
+            @data[key] = @transact_data[key].deep_dup
+            
+          elsif @transact_rollback[key] # rollbackがあった場合 何もしない
+            
+          else  # commitもrollbackもしていなければ
+            raise(DangoFrameworkTransactionException, "not found commit and rollback in transaction")
+          end
+          
+          @transact_commit.delete(key)
+          @transact_rollback.delete(key)
+          @transact_data.delete(key)
+          
+          @transact_key.delete(Thread.current)
+        end
+      end
+      
+      self
+    end
+    
+    def commit(value) # トランザクションのコミット処理
+      if ! @transact_key.has_key?(Thread.current)
+        raise(DangoFrameworkTransactionException, "this thread has not transaction #{Thread.current}") 
+      end
+      key = @transact_key[Thread.current]
+      
+      if @transact_thread[key] != Thread.current
+        raise(DangoFrameworkTransactionException, "not in transaction #{key}") 
+      end
+      
+      @transact_commit[key] = true
+      @transact_data[key] = value
+      throw(:memory_store_finish_transaction)
     end
     
+    def rollback() # トランザクションのロールバック処理
+      if ! @transact_key.has_key?(Thread.current)
+        raise(DangoFrameworkTransactionException, "this thread has not transaction #{Thread.current}") 
+      end
+      key = @transact_key[Thread.current]
+      
+      if @transact_thread[key] != Thread.current
+        raise(DangoFrameworkTransactionException, "not in transaction #{key}") 
+      end
+      
+      @transact_rollback[key] = true
+      throw(:memory_store_finish_transaction)
+    end
+    
+    
     def has_key?(key) # キーがあるかどうかを返す
       key = key.to_s
       @data.has_key?(key)
@@ -51,10 +146,13 @@ module DangoFrameworkModule
 #        raise(DangoFrameworkException, "Shared key is not exist.")
       end
       
-      @data[key].deep_dup
+#      @mutex[key].synchronize do
+        @data[key].deep_dup
+#      end
     end
     
     def []=(key, value)
+      key = key.to_s
       # キーはString Symbolのみ
       if key.class != String && key.class != Symbol
         raise(DangoFrameworkException, "Shared key is not String or Symbol.")
@@ -72,7 +170,7 @@ module DangoFrameworkModule
         @data[key] = value.deep_dup
       end
       
-      nil
+      value
     end
   end
   

data/lib/dango/socket_list.rb

@@ -7,39 +7,31 @@ class SocketList
     @sl_mutex = Mutex.new
   end
   
-  def keys()
+  def all_sid()
     @sl_mutex.synchronize do
       @sl_hash.keys
     end
   end
   
-  def delete(key)
+  def delete(sid)
     @sl_mutex.synchronize do
-      @sl_hash.delete(key)
+      @sl_hash.delete(sid)
     end
   end
   
-  def add(key, sock)
+  def add(sid, sock)
     @sl_mutex.synchronize do
-      raise("already exist key(#{key.inspect})") if @sl_hash.has_key?(key) 
+      raise("already exist sid(#{sid.inspect})") if @sl_hash.has_key?(sid) 
       raise("sock(#{sock.inspect}) is not Socket") if sock.kind_of?(Socket)
-      @sl_hash[key] = sock
+      @sl_hash[sid] = sock
     end
   end
   
-  def [](key)
+  def [](sid)
     @sl_mutex.synchronize do
-#      raise("not exist key(#{key.inspect})") if ! @sl_hash.has_key?(key) 
-      return(nil) if ! @sl_hash.has_key?(key) 
-      @sl_hash[key]
-    end
-  end
-  
-  def []=(key, sock)
-    @sl_mutex.synchronize do
-#      raise("not exist key(#{key.inspect})") if ! @sl_hash.has_key?(key) 
-      raise("sock(#{sock.inspect}) is not Socket") if sock.kind_of?(Socket)
-      @sl_hash[key] = sock
+#      raise("not exist sid(#{sid.inspect})") if ! @sl_hash.has_key?(sid) 
+      return(nil) if ! @sl_hash.has_key?(sid) 
+      @sl_hash[sid]
     end
   end
 end

data/lib/dango/tester/dango_tester_client.rb

@@ -218,6 +218,7 @@ class TestClient < DangoClientFramework
       send_receive_shared.transaction(:receive_cache) do |receive_cache|
         receive_cache.push([name, ret_obj, Time.now])
         receive_cache
+        send_receive_shared.commit(receive_cache)
       end
       
     else
@@ -269,14 +270,18 @@ class TestClient < DangoClientFramework
     send_receive_shared.transaction(:receive_cache) do |receive_cache|
       receive_cache.delete_at(receive_idx)
       receive_cache
+      send_receive_shared.commit(receive_cache)
     end
     
     # 古いreceive_cacheを削除しておく
     send_receive_shared.transaction(:receive_cache) do |receive_cache|
-      receive_cache.select do |one_receive_cache|
+      receive_cache = receive_cache.select do |one_receive_cache|
 #        true
         one_receive_cache[2] > Time.now - @receive_cache_auto_delete_sec
       end
+      
+      receive_cache
+      send_receive_shared.commit(receive_cache)
     end
     
     receive_data[1]
@@ -292,6 +297,7 @@ class TestClient < DangoClientFramework
         true if (! notice_name) || (notice_name && one_rec_data[0] == notice_name)
       end
       receive_cache
+      send_receive_shared.commit(receive_cache)
     end
   end
   

data/lib/dango/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dango
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors: 
 - Keisuke Minami
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-11 00:00:00 +09:00
+date: 2008-09-17 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,7 +57,6 @@ files:
 - lib/dango/client_framework.rb
 - lib/dango/framework_base.rb
 - lib/dango/server_framework.rb
-- lib/dango/mutex_socket_list.rb
 - lib/dango/socket_list.rb
 - lib/dango/session_manager.rb
 - lib/dango/dango_g_server.rb

data/lib/dango/mutex_socket_list.rb

@@ -1,35 +0,0 @@
-#!ruby -Ku
-
-# ソケット毎用のmutex
-class MutexSocketList
-  def initialize()
-    @msl_hash = Hash.new
-  end
-  
-  def keys()
-    @msl_hash.keys
-  end
-  
-  def delete(key)
-    @msl_hash.delete(key)
-  end
-  
-  def add(key)
-    @msl_hash[key] = Mutex.new
-  end
-  
-#  def [](key)
-#    raise("not exist key(#{key})") if ! @msl_hash.has_key?(key) 
-#    add(key) if @msl_hash.has_key?(key) 
-#    @msl_hash[key]
-#  end
-  
-  def synchronize(key)
-    raise("not exist key(#{key})") if ! @msl_hash.has_key?(key) 
-    ret = nil
-    @msl_hash[key].synchronize do
-      ret = yield
-    end
-    ret
-  end
-end