dango 0.0.13 → 0.0.15

data/Manifest.txt

@@ -3,6 +3,8 @@ README.txt
 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/monitor/dango_monitor_client.rb
 lib/dango/script/dango_server.rb
 lib/dango/shared/memory_store.rb

data/lib/dango/client_framework.rb

@@ -98,41 +98,40 @@ class DangoClientFramework
       loop do
         begin
           if @sock
-            cs_logger.debug "#{@sid}:start receive_data"
+            cs_logger.debug "start receive_data #{@sid}"
             ret_obj = nil
             begin
               ret_obj = cs_receive_data(@sock) # データ受信処理
             rescue DangoFrameworkConnectionError
-              cs_logger.debug "#{@sid}:sock error:#{error_message($!, 'u')}"
+              cs_logger.debug "sock error #{@sid}:#{error_message($!, 'u')}"
               throw(:session_closed)
             rescue DangoFrameworkError
-              cs_logger.debug "#{@sid}:sock error:#{error_message($!, 'u')}"
+              cs_logger.debug "sock error #{@sid}:#{error_message($!, 'u')}"
               throw(:session_closed)
             end
-            cs_logger.debug "#{@sid}:finished cs_receive_data:#{ret_obj.inspect}"
+            cs_logger.debug "finished cs_receive_data:#{ret_obj.inspect} #{@sid}"
             
             if !(ret_obj && ret_obj["notice"])
-              cs_logger.info "#{@sid}:no notice:#{ret_obj["notice"].inspect}"
+              cs_logger.info "no notice:#{ret_obj["notice"].inspect} #{@sid}"
             end
             
             # メソッド呼び出し
-            cs_logger.info "#{@sid}:calling method=#{ret_obj["notice"].inspect}"
+            cs_logger.info "calling method=#{ret_obj["notice"].inspect} #{@sid}"
             begin
               __send__("cs_receive_#{ret_obj["notice"]}", ret_obj)
             rescue
-              cs_logger.error "error in cs_receive_#{ret_obj["notice"]}\n#{error_message($!, 'u')}"
+              cs_logger.error "error in cs_receive_#{ret_obj["notice"]} #{@sid}\n#{error_message($!, 'u')}"
             ensure
               # データの受信の送信返し
               response_notice_name = "_response"
               send_obj = {"_id" => ret_obj["_id"]}
               cs_client_send_data(response_notice_name, send_obj)
-              cs_logger.debug "#{@sid}:response_notice_name=#{response_notice_name.inspect}"
+              cs_logger.debug "response_notice_name=#{response_notice_name.inspect} #{@sid}"
             end
-            cs_logger.debug "#{@sid}:called method=#{ret_obj["notice"].inspect}"
-            
+            cs_logger.debug "called method=#{ret_obj["notice"].inspect} #{@sid}"
             
           else
-            sleep 0.1
+            sleep 0.01
           end
           
         rescue Exception
@@ -150,6 +149,10 @@ class DangoClientFramework
     @sid = rec_obj["_sid"]
   end
   
+  # システムからのメッセージ通知なら
+  def cs_receive__notice_system_message(rec_obj)
+  end
+  
   # ユーザーが終了させたい時に呼び出すメソッド（セッションを切る）
   def cs_client_close
     client_quit() # クライアントの終了処理
@@ -188,7 +191,7 @@ class DangoClientFramework
   
   # クライアントからサーバーへのデータ送信
   def cs_client_send_data(action_name, send_obj)
-    cs_logger.debug "cs_client_send_data(#{action_name.inspect}, #{send_obj['_id']}) #{Time.now}"
+    cs_logger.debug "cs_client_send_data(#{action_name.inspect}, #{send_obj['_id']}) #{Time.now_to_s}"
     send_obj_dup = send_obj.dup
     send_obj_dup["action"] = action_name.to_s
     cs_send_data(@sock, send_obj_dup)

data/lib/dango/framework_base.rb

@@ -41,8 +41,10 @@ end
 
 # Timeクラスの表示形式修正
 class Time
-  def to_s
-    self.strftime("%Y-%m-%d %H:%M:%S")
+  def self.now_to_s
+#    self.strftime("%Y-%m-%d %H:%M:%S")
+    now = self.now
+    now.strftime("%Y-%m-%dT%H:%M:%S.") << "%06d " % now.usec
   end
 end
 

data/lib/dango/monitor/dango_monitor_client.rb

@@ -59,7 +59,21 @@ class DangoMonitorClient < DangoClientFramework
       raise("monitor_server_reload Timeout error")
     end
     raise("code is not 0 (faild). :code=#{ret_obj['code']}") if ret_obj['code'] != 0
-    ret_obj['all_info']
+    true
+  end
+  
+  # システムメッセージの送信
+  def send_system_message(message = "")
+    cs_logger.debug "DangoMonitorClient:send_system_message"
+    begin
+      ret_obj = cs_client_send_receive_data('monitor_send_system_message', {:message=>message})
+    rescue DangoFrameworkConnectionError
+      raise("monitor_send_system_message Connection error")
+    rescue DangoFrameworkTimeoutError
+      raise("monitor_send_system_message Timeout error")
+    end
+    raise("code is not 0 (faild). :code=#{ret_obj['code']}") if ret_obj['code'] != 0
+    true
   end
 end
 

data/lib/dango/mutex_socket_list.rb

@@ -0,0 +1,35 @@
+#!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

data/lib/dango/server_framework.rb

@@ -9,6 +9,8 @@ require 'ipaddr'
 require 'digest/md5'
 
 require "dango/framework_base"
+require "dango/socket_list"
+require "dango/mutex_socket_list"
 
 # フレームワーククラス
 class DangoServerFramework
@@ -54,7 +56,7 @@ class DangoServerFramework
     
     loop do # 待ちで無限ループに入る
       sleep 3
-#      p( Time.now.to_s + ":#{@server_reload.inspect}")
+#      p( Time.now_to_s + ":#{@server_reload.inspect}")
       check_reload_class()
     end
   end
@@ -71,14 +73,17 @@ class DangoServerFramework
     set_server_variables()                # 各種サーバー仕様の変数設定
     
     cs_logger.debug("===== server initialize =====") # loggerの準備
+    cs_logger.debug("Process.pid=#{Process.pid}")
     cs_logger.debug("port=#{@connection_server_port}")
     cs_logger.debug("host=#{@connection_server_host}")
     cs_logger.debug("max_connections=#{@connection_server_max_connections}")
     
+    open("tmp/pids/dango.pid", "wb"){|fh| fh.write Process.pid.to_s }
+    
     shared_init()                         # 共有メモリを初期化
     notice_shared_init()                  # 通知共有メモリを初期化
     socket_list_init()                    # ソケット一覧を初期化
-    mutex_socket_list_init(cs_logger())   # ソケット毎用のmutexを初期化
+    mutex_socket_list_init()              # ソケット毎用のmutexを初期化
     @mutex_proc_thread = Mutex.new        # スレッドが同時起動しないようにするためのMutex
     cs_server_init()                      # 初期設定読み込み
     
@@ -175,20 +180,21 @@ class DangoServerFramework
     cs_logger.debug "#{sock} is accepted. key=#{Thread.current.object_id}"
     
     begin
-      session[:session_id] = Thread.current.object_id
-      session_id = session[:session_id]
-      socket_list.add(session_id, sock)
-      mutex_socket_list.add(session_id)
-      
       sock.binmode
       sock.sync = true
       
+      session[:sid] = Thread.current.object_id
+      sid = session[:sid]
+      socket_list.add(sid, sock)
+      mutex_socket_list.add(sid)
+      
       cs_connect() # 接続時メソッド呼び出し
       
       # 接続直後のsid通知
 #      Thread.start do
-        send_obj = {"_sid"=>session_id}
-        cs_server_send_data(session_id, "_notice_sid", send_obj)
+        send_obj = {"_sid"=>sid}
+        cs_server_send_data(sid, "_notice_sid", send_obj)
+        cs_logger.debug "_notice_sid #{sid} #{Time.now_to_s}"
 #      end
       
       # メインループ入り
@@ -225,24 +231,28 @@ class DangoServerFramework
           @mutex_proc_thread.synchronize do
             
             if action_name == '_response' # 送信パケットの返事なら
-#              cs_logger.debug "action_name=#{action_name} #{Time.now}"
+#              cs_logger.debug "action_name=#{action_name} #{Time.now_to_s}"
               action_name_is_response(ret_obj)
               
             elsif action_name == 'monitor_all_info' # メンテナンスアクション名なら
               cs_check_monitor_error(sock, "return_monitor_all_info")
-              cs_server_monitor_all_info()
+              cs_server_monitor_all_info(ret_obj)
               
             elsif action_name == 'monitor_server_reload' # メンテナンスアクション名なら
               cs_check_monitor_error(sock, "return_monitor_server_reload")
-              cs_server_monitor_server_reload()
+              cs_server_monitor_server_reload(ret_obj)
+              
+            elsif action_name == 'monitor_send_system_message' # メンテナンスアクション名なら
+              cs_check_monitor_error(sock, "return_monitor_send_system_message")
+              cs_server_monitor_send_system_message(ret_obj)
               
             else # メンテナンスコマンド以外のユーザーアクション名なら
-              cs_logger.debug "action_name=#{action_name} #{Time.now}"
+              cs_logger.debug "action_name=#{action_name} #{sid} #{Time.now_to_s}"
               begin
                 __send__("cs_receive_#{action_name}", ret_obj)
               rescue NoMethodError
                 @recv_fail_count += 1 if @recv_fail_count # 受信失敗回数カウント
-                cs_logger.error "not find action #{action_name}:#{error_message($!, 'u')}"
+                cs_logger.error "not find action #{action_name}:#{sid}:#{error_message($!, 'u')}"
               end
             end
             
@@ -251,17 +261,17 @@ class DangoServerFramework
       end
       
     rescue DangoFrameworkReadNoDataError
-      cs_logger.debug "read no data. maybe client closed. #{Thread.current.object_id} #{Time.now}"
+      cs_logger.debug "read no data. maybe client closed. #{Thread.current.object_id} #{Time.now_to_s}"
       
     rescue DangoFrameworkConnectionError
       @recv_fail_count += 1 if @recv_fail_count # 受信失敗回数カウント
-      cs_logger.debug "connection error. #{Thread.current.object_id} #{Time.now}\n#{error_message($!, 'u')}"
+      cs_logger.debug "connection error. #{Thread.current.object_id} #{Time.now_to_s}\n#{error_message($!, 'u')}"
       
     rescue DangoFrameworkError
-      cs_logger.debug "DangoFrameworkError. #{Thread.current.object_id} #{Time.now}\n#{error_message($!, 'u')}"
+      cs_logger.debug "DangoFrameworkError. #{Thread.current.object_id} #{Time.now_to_s}\n#{error_message($!, 'u')}"
       
     rescue Exception
-      cs_logger.error "Exception #{Thread.current.object_id} #{Time.now} #{error_message($!, 'u')}"
+      cs_logger.error "Exception #{Thread.current.object_id} #{Time.now_to_s} #{error_message($!, 'u')}"
       
     ensure
       cs_logger.debug "#{sock.inspect} #{Thread.current.object_id} is gone"
@@ -337,12 +347,9 @@ class DangoServerFramework
   def shared_init
     @shared = select_shared_database_manager()
   end
-  def shared
-    @shared
-  end
+  attr_accessor(:shared)
   
   # 通知共有メモリ
-  
   def notice_shared_init
 #   @notice_shared = NoticeShared.new(self)
     @notice_shared = select_shared_database_manager()
@@ -364,24 +371,24 @@ class DangoServerFramework
         end
       end
       
-      def add_connectable(key, session_id) # 接続許可にする
+      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] << session_id
+          notice_list[key] << sid
           notice_list
         end
       end
       
-      def remove_connectable(key, session_id) # 接続を不許可にする
+      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(session_id)
+          notice_list[key].delete(sid)
           notice_list
         end
       end
@@ -403,8 +410,8 @@ class DangoServerFramework
         
         @parent.cs_logger.debug "self.get_connectables(key):#{self.get_connectables(key).inspect}"
         
-        self.get_connectables(key).each do |session_id|
-          @parent.cs_server_send_data(session_id, "notice_shared_#{key}".to_sym, value)
+        self.get_connectables(key).each do |sid|
+          @parent.cs_server_send_data(sid, "notice_shared_#{key}".to_sym, value)
         end
       end
       
@@ -425,10 +432,7 @@ class DangoServerFramework
       end
     end
   end
-  
-  def notice_shared
-    @notice_shared
-  end
+  attr_accessor(:notice_shared)
   
   # セッション
   class Session < Hash
@@ -439,87 +443,16 @@ class DangoServerFramework
   end
   
   # ソケットとIDの対応
-  class SocketList
-    def initialize
-      @sl_hash = Hash.new
-      @sl_mutex = Mutex.new
-    end
-    def keys()
-      @sl_mutex.synchronize do
-        @sl_hash.keys
-      end
-    end
-    def delete(key)
-      @sl_mutex.synchronize do
-        @sl_hash.delete(key)
-      end
-    end
-    def add(key, sock)
-      @sl_mutex.synchronize do
-        raise("already exist key(#{key})") if @sl_hash.has_key?(key) 
-        raise("sock(#{sock.ins}) is not Socket") if sock.kind_of?(Socket)
-        @sl_hash[key] = sock
-      end
-    end
-    def [](key)
-      @sl_mutex.synchronize do
-        raise("not exist key(#{key})") if ! @sl_hash.has_key?(key) 
-        @sl_hash[key]
-      end
-    end
-    def []=(key, sock)
-      @sl_mutex.synchronize do
-        raise("not exist key(#{key})") if ! @sl_hash.has_key?(key) 
-        raise("sock(#{sock.class}) is not Socket") if sock.kind_of?(Socket)
-        @sl_hash[key] = sock
-      end
-    end
-  end
   def socket_list_init
     @socket_list = SocketList.new
   end
-  def socket_list
-    @socket_list
-  end
+  attr_accessor(:socket_list)
   
   # ソケット毎用のmutex
-  class MutexSocketList
-    def initialize(cs_logger)
-      @cs_logger = cs_logger
-      @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) 
-#      @cs_logger.debug("mutex_socket_list starting synchronize. key=#{key}")
-      ret = nil
-      @msl_hash[key].synchronize do
-#        @cs_logger.debug("mutex_socket_list started synchronize. key=#{key}")
-        ret = yield
-#        @cs_logger.debug("mutex_socket_list finished synchronize. key=#{key}")
-      end
-      ret
-    end
-  end
-  def mutex_socket_list_init(cs_logger)
-    @mutex_sock_list = MutexSocketList.new(cs_logger)  # ソケット毎用のmutex
-  end
-  def mutex_socket_list
-    @mutex_sock_list
+  def mutex_socket_list_init()
+    @mutex_socket_list = MutexSocketList.new()  # ソケット毎用のmutex
   end
+  attr_accessor(:mutex_socket_list)
   
   # 接続時に呼び出されるメソッド
   def cs_connect; end
@@ -545,22 +478,23 @@ class DangoServerFramework
   end
   
   # サーバーからクライアントへのデータ送信
-  def cs_server_send_data(session_id, notice_name, send_obj, options = {})
-#    cs_logger.debug "cs_server_send_data(#{session_id.inspect}, #{notice_name.inspect}, #{send_obj.inspect}, #{options.inspect})"
+  def cs_server_send_data(sid, notice_name, send_obj, options = {})
+    cs_logger.debug "cs_server_send_data(#{sid.inspect}, #{notice_name.inspect}) #{Time.now_to_s}"
+#    cs_logger.debug "cs_server_send_data(#{sid.inspect}, #{notice_name.inspect}, #{send_obj.inspect}, #{options.inspect})"
     
     raise(DangoFrameworkError, "send_obj is not Hash.") if ! send_obj.is_a?(Hash)
     
     timeout = options[:timeout] || SendReceiveTimeoutDefaultSec
     dtype = options[:type] || 0
     
-    sock = socket_list[session_id]
-    raise(DangoFrameworkError, "not found session_id=#{session_id}") if !sock
-    raise(DangoFrameworkConnectionError, "socket closed. s_id=#{session_id}") if sock.closed?
+    sock = socket_list[sid]
+    raise(DangoFrameworkError, "not found sid=#{sid}") if !sock
+    raise(DangoFrameworkConnectionError, "socket closed. s_id=#{sid}") if sock.closed?
     
 #    cs_logger.debug "cs_server_send_data:sending data notice_name=#{notice_name.inspect}"
     send_obj_dup = send_obj.deep_dup
     send_obj_dup["notice"] = notice_name.to_s
-    send_obj_dup["_id"] = Digest::MD5.hexdigest(session_id.to_s + Time.now.to_i.to_s)
+    send_obj_dup["_id"] = Digest::MD5.hexdigest(sid.to_s + Time.now.to_i.to_s)
     
     # データ送信時にクライアントからのレスポンスを確認する（Flashのバグらしきもの対策）
 #    if notice_name.to_s =~ /^return_/
@@ -573,22 +507,23 @@ class DangoServerFramework
     else
       Thread.start do
         begin
-          mutex_socket_list.synchronize(session_id) do
+          mutex_socket_list.synchronize(sid) do
+            cs_logger.warn "mutex_socket_list:synchronize:#{notice_name} #{sid} #{Time.now_to_s}" 
             have_came_response = nil
             
             receive_thread = Thread.start do
               begin
                 cs_send_data(sock, send_obj_dup, :type=>dtype) # データ送信
-#                cs_logger.debug "cs_server_send_data:send data notice_name=#{notice_name.inspect} #{send_obj_dup['_id']}"
+                cs_logger.debug "cs_server_send_data:sent:notice_name=#{notice_name.inspect} #{sid} #{Time.now_to_s}"
               rescue DangoFrameworkError
-                cs_logger.debug "cs_server_send_data:DangoFrameworkError:notice_name=#{notice_name.inspect}\n"
+                cs_logger.debug "ERROR:cs_server_send_data:DangoFrameworkError:notice_name=#{notice_name.inspect} #{sid} #{Time.now_to_s}"
               end
             end
             
             # データ送信スレッドの終了待ち
             if !receive_thread.join(SendTimeoutSec)
               # タイムアウトの場合は
-              cs_logger.warn "cs_server_send_data:send timeout:#{notice_name}" 
+              cs_logger.warn "cs_server_send_data:send timeout:#{notice_name} #{sid} #{Time.now_to_s}" 
             else
               end_reserved_time = Time.now + timeout
               
@@ -603,7 +538,7 @@ class DangoServerFramework
                   @mutex_send_response.synchronize do
                     if @arr_send_response.delete(send_obj_dup["_id"])
                       have_came_response = true
-#                      cs_logger.debug "response check ok:#{notice_name} #{send_obj_dup['_id'].inspect}"
+#                      cs_logger.debug "response check ok:#{notice_name} #{sid} #{Time.now_to_s}"
                       throw(:send_timeout)
                     end
                   end
@@ -613,7 +548,7 @@ class DangoServerFramework
               end # catch 終わり
               
               if !have_came_response # 戻ってきたデータがあるかどうかチェック
-                cs_logger.warn "!!! received data is none. #{notice_name} #{send_obj_dup['_id']}"
+                cs_logger.warn "!!! received data is none:#{notice_name} #{sid} #{Time.now_to_s}"
               end
             end
           end
@@ -643,13 +578,13 @@ class DangoServerFramework
     
     if !match
       send_obj = {'code'=>1, 'message'=>"error your ip address"}
-      cs_server_send_data(session[:session_id], return_command, send_obj, :type=>2)
+      cs_server_send_data(session[:sid], return_command, send_obj, :type=>2)
       raise(DangoFrameworkError)
     end
   end
   
   # メンテナンスコマンド：サーバーからクライアントへのデータ送信
-  def cs_server_monitor_all_info()
+  def cs_server_monitor_all_info(ret_obj)
     all_info = {
       'shareds'     => shared.to_hash,
       'socket_list' => socket_list.keys,
@@ -665,16 +600,31 @@ class DangoServerFramework
     }
     
     send_obj = {'code'=>0, 'all_info'=>all_info}
-    cs_server_send_data(session[:session_id], 'return_monitor_all_info', send_obj, :type=>2)
+    cs_server_send_data(session[:sid], 'return_monitor_all_info', send_obj, :type=>2)
   end
   
-  # メンテナンスコマンド：サーバーからクライアントへのデータ送信
-  def cs_server_monitor_server_reload()
+  # メンテナンスコマンド：サーバーデータ再読み込み
+  def cs_server_monitor_server_reload(ret_obj)
     cs_logger.debug "cs_server_monitor_server_reload"
     @server_reload = true
     cs_logger.debug "@server_reload=#{@server_reload.inspect}"
     send_obj = {'code'=>0, 'message'=>'success'}
-    cs_server_send_data(session[:session_id], 'return_monitor_server_reload', send_obj, :type=>2)
+    cs_server_send_data(session[:sid], 'return_monitor_server_reload', send_obj, :type=>2)
+  end
+  
+  # メンテナンスコマンド：接続者全員へメッセージ送信
+  def cs_server_monitor_send_system_message(ret_obj)
+    cs_logger.debug "cs_server_monitor_send_system_message:#{ret_obj.inspect}"
+    
+    # 全員へ_notice_system_messageを通知
+    socket_list.keys.each do |sid|
+      next if session[:sid] == sid
+      send_obj = { "message" => ret_obj["message"] }
+      cs_server_send_data(sid, '_notice_system_message', send_obj)
+    end
+    
+    send_obj = {'code'=>0, }
+    cs_server_send_data(session[:sid], 'return_monitor_send_system_message', send_obj, :type=>2)
   end
   
   # 必要に応じて追加するメソッド
@@ -687,7 +637,8 @@ class DangoServerFramework
     end
   end
   
-  def method_action_notice_shared(key, name, *args) # 共有メモリ変更通知のメソッド
+  # 共有メモリ変更通知のメソッド
+  def method_action_notice_shared(key, name, *args) 
     cs_logger.debug "method_name:#{name}"
     send_obj = args[0]
     notice_shared.notice_change(key.to_sym, send_obj) 
@@ -700,8 +651,8 @@ class DangoServerFramework
     options = options.deep_dup
     options[:rate] ||= 10
     
-    wait_msec = 1.0 / options[:rate]
-    cs_logger.debug "flameloop_thread wait_msec:#{wait_msec.inspect}"
+    wait_sec = 1.0 / options[:rate]
+    cs_logger.debug "flameloop_thread wait_sec:#{wait_sec.inspect}"
     
     Thread.new do 
       loop do
@@ -712,7 +663,7 @@ class DangoServerFramework
             cs_logger.debug "flameloop_thread error:#{error_message($!, 'u')}"
           end
         end
-        sleep wait_msec
+        sleep wait_sec
       end
     end
     

data/lib/dango/socket_list.rb

@@ -0,0 +1,44 @@
+#!ruby -Ku
+
+# ソケットとIDの対応
+class SocketList
+  def initialize
+    @sl_hash = Hash.new
+    @sl_mutex = Mutex.new
+  end
+  
+  def keys()
+    @sl_mutex.synchronize do
+      @sl_hash.keys
+    end
+  end
+  
+  def delete(key)
+    @sl_mutex.synchronize do
+      @sl_hash.delete(key)
+    end
+  end
+  
+  def add(key, sock)
+    @sl_mutex.synchronize do
+      raise("already exist key(#{key})") if @sl_hash.has_key?(key) 
+      raise("sock(#{sock.ins}) is not Socket") if sock.kind_of?(Socket)
+      @sl_hash[key] = sock
+    end
+  end
+  
+  def [](key)
+    @sl_mutex.synchronize do
+      raise("not exist key(#{key})") if ! @sl_hash.has_key?(key) 
+      @sl_hash[key]
+    end
+  end
+  
+  def []=(key, sock)
+    @sl_mutex.synchronize do
+      raise("not exist key(#{key})") if ! @sl_hash.has_key?(key) 
+      raise("sock(#{sock.class}) is not Socket") if sock.kind_of?(Socket)
+      @sl_hash[key] = sock
+    end
+  end
+end

data/lib/dango/tasks/dango_rake.rb

@@ -32,6 +32,33 @@ namespace :dango do
       puts "complete server_reload."
     end
     
+    desc "send_system_message" # システムメッセージ配信
+    task :send_system_message do
+      puts "send_system_message"
+      message_type = ENV["TYPE"]
+      if ! message_type
+        puts "please type. ex. rake dango:monitor:send_system_message TYPE=down_1min"
+        exit
+      end
+      
+      require "yaml"
+      require 'dango/monitor/dango_monitor_client.rb'
+      
+      system_message = YAML.load(open("dango/config/system_message.yml", "rb"){|fh| fh.read})
+      message = system_message[message_type]
+      
+      begin
+        dm = DangoMonitorClient.new()
+        p dm.send_system_message(message)
+        dm.cs_client_close
+      rescue
+        p $!.class
+        p $!.message
+        p $!.backtrace
+      end
+      puts "complete server_reload."
+    end
+    
   end
   
 end

data/lib/dango/tester/dango_tester_client.rb

@@ -43,8 +43,9 @@ end
 
 # テスト接続用のクラス
 class TestClient < DangoClientFramework
-  SendReceiveSleepIntervalSec = 0.001 # データ送信後の順の際のタイムアウトチェック間隔秒
-  SendReceiveTimeoutSec = 10          # データ送信後の順の際のタイムアウトチェック間隔秒
+  SendReceiveSleepIntervalSec = 0.001    # データ送信後の順の際のタイムアウトチェック間隔秒
+  ReceiveWaitTimeoutSec = 10             # データ受信確認の待ち秒数
+  ReceiveTrapTimeoutSec = 0              # データ受信確認のトラップの秒数
   
   def initialize(env, config, c_name)
     @config = config
@@ -55,6 +56,8 @@ class TestClient < DangoClientFramework
     @receive_mutex = Mutex.new # 送受信用の排他処理
     @receive_arr = []
     
+    @receive_methods = []
+    
     send_receive_shared_init()
   end
   
@@ -79,34 +82,50 @@ class TestClient < DangoClientFramework
   
   # テストサーバー
   def send(name, send_obj = {})
-    cs_logger.debug("tester.send:send_obj=#{send_obj.inspect} #{Time.now}")
+    cs_logger.debug("tester.send:send_obj=#{send_obj.inspect} #{Time.now_to_s}")
     cs_client_send_data(name, send_obj)
   end
   
   # trap_receive_data
   def trap_receive_data(receive_name, options = {})
-    cs_logger.debug "trap_receive_data:#{receive_name}:#{Time.now}"
-    timeout = options[:timeout] || SendReceiveTimeoutSec
+    cs_logger.debug "trap_receive_data:#{receive_name}:#{Time.now_to_s}"
+    timeout = options[:timeout] || ReceiveTrapTimeoutSec
+    trap_proc = options[:proc] || nil
+    raise(ArgumentError, ":proc is not Proc class.") if trap_proc && ! trap_proc.is_a?(Proc)
+    
+    cs_logger.debug "trap_receive_data:trap_proc:#{trap_proc.inspect}"
     
     Thread.start do
       send_receive_shared[receive_name] = nil
-      end_reserved_time = Time.now + timeout
+      if timeout == 0
+        end_reserved_time = Time.at(0)         # 0ならepochを入れる
+      else
+        end_reserved_time = Time.now + timeout # 0以上ならタイムアウト時間決定
+      end
       
-      # 戻ってきたデータのチェック
+      # 戻ってきたデータのチェックメソッド
       receive_name_sym = (receive_name.class == Symbol) ? (":"+receive_name.to_s) : ('"'+receive_name+'"')
-      instance_method_name = "cs_receive_#{receive_name}"
-      expr = <<-EOF
-        def self.#{instance_method_name}(ret_obj)
-          cs_logger.debug "ret_obj:" + ret_obj.inspect
-          send_receive_shared[#{receive_name_sym}] = ret_obj
-        end
-      EOF
-      instance_eval expr
+      
+      if ! @receive_methods.include?(receive_name_sym)
+        instance_method_name = "cs_receive_#{receive_name}"
+        expr = <<-EOF
+          def self.#{instance_method_name}(ret_obj)
+            cs_logger.debug "ret_obj:" + ret_obj.inspect
+            send_receive_shared[#{receive_name_sym}] = ret_obj
+          end
+        EOF
+        instance_eval expr
+        @receive_methods.push(receive_name_sym)
+      end
       
       # タイムアウトチェック
-      (timeout.to_f / SendReceiveSleepIntervalSec).to_i.times do
-        if Time.now > end_reserved_time
-          raise(DangoFrameworkTimeoutError, "timeout:client_name=#{@client_name}:receive_name=#{receive_name}") 
+      cs_logger.debug "trap_receive_data:666:#{end_reserved_time}"
+      loop do
+#      (timeout.to_f / SendReceiveSleepIntervalSec).to_i.times do
+#        if end_reserved_time < Time.now
+        
+        if end_reserved_time != Time.at(0) && end_reserved_time < Time.now
+          raise(DangoFrameworkTimeoutError, "timeout:client_name=#{@client_name}:receive_name=#{receive_name} #{Time.now_to_s}") 
         end
         
         # 戻ってきたデータがあれば
@@ -118,21 +137,33 @@ class TestClient < DangoClientFramework
         sleep SendReceiveSleepIntervalSec # スリープ
       end
       
-      if !send_receive_shared[receive_name] # 戻ってきたデータがあるかどうかチェック
+      cs_logger.debug "trap_receive_data:555"
+      # 戻ってきたデータがあるかどうかチェック
+      if !send_receive_shared[receive_name] 
         raise(DangoFrameworkError, "received data is none. sid=#{sid} receive_name=#{receive_name}")
       end
       
-      @receive_mutex.synchronize do
-        cs_logger.debug "receive_name:#{receive_name}:#{send_receive_shared[receive_name].inspect}"
-        @receive_arr.push([receive_name, send_receive_shared[receive_name]])
-#        p @receive_arr
+      # :procが設定されている場合は、それを呼び出す
+      cs_logger.debug "trap_receive_data:222:#{receive_name}:#{trap_proc.inspect}"
+      if trap_proc
+      cs_logger.debug "trap_receive_data:333:#{receive_name}"
+        cs_logger.debug "trap_receive_data:trap_proc is true:#{trap_proc.inspect}"
+        trap_proc.call(send_receive_shared[receive_name])
+        
+      # :procが設定されていなければ、wait用に@receive_arrに入れておく
+      else
+      cs_logger.debug "trap_receive_data:444"
+        @receive_mutex.synchronize do
+          cs_logger.debug "receive_name:#{receive_name}:#{send_receive_shared[receive_name].inspect}"
+          @receive_arr.push([receive_name, send_receive_shared[receive_name]])
+        end
       end
     end
   end
   
   # wait_receive_data
   def wait_receive_data(receive_name, options = {})
-    timeout = options[:timeout] || SendReceiveTimeoutSec
+    timeout = options[:timeout] || ReceiveWaitTimeoutSec
     
     # データ受信待ち
     receive_data = nil
@@ -147,7 +178,7 @@ class TestClient < DangoClientFramework
     
     # タイムアウトなら
     if receive_data == nil
-      raise(DangoFrameworkTimeoutError, "timeout:client_name=#{@client_name}:receive_name=#{receive_name}") 
+      raise(DangoFrameworkTimeoutError, "timeout:client_name=#{@client_name}:receive_name=#{receive_name} #{Time.now_to_s}") 
     end
     
     # 結果を削除しておく

data/lib/dango/version.rb

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

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: dango
 version: !ruby/object:Gem::Version 
-  version: 0.0.13
-date: 2007-10-17 00:00:00 +09:00
+  version: 0.0.15
+date: 2007-10-18 00:00:00 +09:00
 summary: Ruby - Flash conneciton network flamework
 require_paths: 
 - lib
@@ -34,6 +34,8 @@ 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/monitor/dango_monitor_client.rb
 - lib/dango/script/dango_server.rb
 - lib/dango/shared/memory_store.rb