dango 0.0.25 → 0.0.26

data/lib/dango/client_framework.rb

@@ -12,20 +12,20 @@ class DangoClientFramework
   
   SendReceiveSleepIntervalSec = 0.1 # データ送信後の順の際のタイムアウトチェック間隔秒
   
-  # cs_client_send_receive_data用の共有メモリ
-  def send_receive_shared_init
-    @send_receive_shared = SharedMemoryStore.new
+  # send_action_return_notice用の共有メモリ
+  def send_return_shared_init
+    @send_return_shared = SharedMemoryStore.new
   end
-  def send_receive_shared
-    @send_receive_shared
+  def send_return_shared
+    @send_return_shared
   end
   
   # 起動処理
-  def cs_client_init
+  def dango_client_init
   end
   
   # セッションが切れると呼ばれる処理
-  def cs_session_closed
+  def dango_session_closed
   end
   
   # メイン処理
@@ -54,20 +54,20 @@ class DangoClientFramework
       exit!
     end
     
-    cs_client_init() # 初期設定読み込み
+    dango_client_init() # 初期設定読み込み
     
     @log_file = @connection_client_log_file
     @log_level = @connection_client_log_level
     
     # loggerの準備
-    cs_logger.debug("-------client initialize")
+    logger.debug("-------client initialize")
     
     # データ送受信用の共有メモリ初期化
-    send_receive_shared_init()
+    send_return_shared_init()
     @send_receive_mutex = Mutex.new # 送受信用の排他処理
     
     # 通知共有メモリの初期化
-    cs_client_notice_shared_init()
+    dango_client_notice_shared_init()
     
     # ソケットの準備
     @sock = nil
@@ -83,7 +83,7 @@ class DangoClientFramework
     @sock.binmode
     @sock.sync = true
     @tmutex = Mutex.new # sockの排他処理用
-    cs_logger.debug("addr:#{@sock.addr.inspect}")
+    logger.debug("addr:#{@sock.addr.inspect}")
     
     @sid = nil # 接続して決まるsidを保持
     
@@ -99,44 +99,44 @@ class DangoClientFramework
       loop do
         begin
           if @sock
-            cs_logger.debug "start receive_data #{@sid}"
+            logger.debug "start dango_receive_data #{@sid}"
             ret_obj = nil
             begin
-              ret_obj = cs_receive_data(@sock) # データ受信処理
+              ret_obj = dango_receive_data(@sock) # データ受信処理
             rescue DangoFrameworkConnectionError
-              cs_logger.debug "sock error #{@sid}:#{error_message($!, 'u')}"
+              logger.debug "sock error #{@sid}:#{error_message($!, 'u')}"
               throw(:session_closed)
             rescue DangoFrameworkError
-              cs_logger.debug "sock error #{@sid}:#{error_message($!, 'u')}"
+              logger.debug "sock error #{@sid}:#{error_message($!, 'u')}"
               throw(:session_closed)
             end
-            cs_logger.debug "finished cs_receive_data:#{ret_obj.inspect} #{@sid}"
+            logger.debug "finished dango_receive_data:#{ret_obj.inspect} #{@sid}"
             
             if !(ret_obj && ret_obj["notice"])
-              cs_logger.info "no notice:#{ret_obj["notice"].inspect} #{@sid}"
+              logger.info "no notice:#{ret_obj["notice"].inspect} #{@sid}"
             end
             
             # メソッド呼び出し
-            cs_logger.info "calling method=#{ret_obj["notice"].inspect} #{@sid} #{Time.now_to_s}"
+            logger.info "calling method=#{ret_obj["notice"].inspect} #{@sid} #{Time.now_to_s}"
             begin
-              __send__("cs_receive_#{ret_obj["notice"]}", ret_obj)
+              __send__("dango_receive_#{ret_obj["notice"]}", ret_obj)
             rescue
-              cs_logger.error "error in cs_receive_#{ret_obj["notice"]} #{@sid} #{Time.now_to_s}\n#{error_message($!, 'u')}"
+              logger.error "error in dango_receive_#{ret_obj["notice"]} #{@sid} #{Time.now_to_s}\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 "response_notice_name=#{response_notice_name.inspect} #{@sid} #{Time.now_to_s}"
+              send_action(response_notice_name, send_obj)
+              logger.debug "response_notice_name=#{response_notice_name.inspect} #{@sid} #{Time.now_to_s}"
             end
-            cs_logger.debug "called method=#{ret_obj["notice"].inspect} #{@sid} #{Time.now_to_s}"
+            logger.debug "called method=#{ret_obj["notice"].inspect} #{@sid} #{Time.now_to_s}"
             
           else
             sleep 0.01
           end
           
         rescue Exception
-          cs_logger.debug "#{@sid}:#{error_message($!, 'u')}"
+          logger.debug "#{@sid}:#{error_message($!, 'u')}"
         end
       end
     end
@@ -146,16 +146,16 @@ class DangoClientFramework
   private :thread_main
   
   # 接続直後のsid通知なら
-  def cs_receive__notice_sid(rec_obj)
+  def dango_receive__notice_sid(rec_obj)
     @sid = rec_obj["_sid"]
   end
   
   # システムからのメッセージ通知なら
-  def cs_receive__notice_system_message(rec_obj)
+  def dango_receive__notice_system_message(rec_obj)
   end
   
   # ユーザーが終了させたい時に呼び出すメソッド（セッションを切る）
-  def cs_client_close
+  def dango_client_close
     client_quit() # クライアントの終了処理
   end
   
@@ -165,13 +165,13 @@ class DangoClientFramework
       begin
         @sock.close if @sock
       rescue
-        cs_logger.debug "sock close failed. #{$!}"
+        logger.debug "sock close failed. #{$!}"
       end
       @sock = nil
       
       @is_session_closed = true
-      cs_logger.info "calling cs_session_closed()"
-      cs_session_closed() # セッションが切れると呼ばれる処理
+      logger.info "calling dango_session_closed()"
+      dango_session_closed() # セッションが切れると呼ばれる処理
       
       @is_close = true
     end
@@ -179,54 +179,54 @@ class DangoClientFramework
   private :client_quit
   
   # クライアントの暗号化処理
-  def cs_client_send_encrypt(str) # 継承用
+  def dango_client_send_encrypt(str) # 継承用
     str
   end
-  def cs_send_encrypt(str) # フレームワークから呼ばれる部分
-    cs_client_send_encrypt(str)
+  def dango_send_encrypt(str) # フレームワークから呼ばれる部分
+    dango_client_send_encrypt(str)
   end
   
   # クライアントの復号化処理
-  def cs_client_receive_decrypt(str) # 継承用
+  def dango_client_receive_decrypt(str) # 継承用
     str
   end
-  def cs_receive_decrypt(str) # フレームワークから呼ばれる部分
-    cs_client_receive_decrypt(str)
+  def dango_receive_decrypt(str) # フレームワークから呼ばれる部分
+    dango_client_receive_decrypt(str)
   end
   
   # クライアントからサーバーへのデータ送信
-  def cs_client_send_data(action_name, send_obj)
-    cs_logger.debug "cs_client_send_data(#{action_name.inspect}, #{send_obj['_id']}) #{Time.now_to_s}"
+  def send_action(action_name, send_obj)
+    logger.debug "send_action(#{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)
+    dango_send_data(@sock, send_obj_dup)
   end
   
   # サーバーからクライアントへのデータ送信
-  # 自動でreturn_nameに対応したcs_receive_メソッドが出来上がるので注意
+  # 自動でreturn_nameに対応したdango_receive_メソッドが出来上がるので注意
   # options = {:return_name=> :timeout => }
   # return_nameは省略時は、action_nameの頭にreturnを付けたもののシンボルになる
   # timeoutは省略時は6秒
-  def cs_client_send_receive_data(action_name, send_obj, options = {})
-#    cs_logger.debug "cs_client_send_receive_data(#{action_name.inspect})"
-#    cs_logger.debug "cs_client_send_receive_data(#{action_name.inspect}, #{send_obj.inspect}, #{options.inspect})"
+  def send_action_return_notice(action_name, send_obj, options = {})
+#    logger.debug "send_action_return_notice(#{action_name.inspect})"
+#    logger.debug "send_action_return_notice(#{action_name.inspect}, #{send_obj.inspect}, #{options.inspect})"
     
     return_name = options[:return_name] || ("return_" + action_name.to_s).to_sym
     timeout = options[:timeout] || 6
     
     @send_receive_mutex.synchronize do
-      send_receive_shared[action_name] = nil
+      send_return_shared[action_name] = nil
       
       receive_thread = nil
       end_reserved_time = Time.now + timeout
       
       # 戻ってきたデータのチェック
       action_name_sym = (action_name.class == Symbol) ? (":"+action_name.to_s) : ('"'+action_name+'"')
-      instance_method_name = "cs_receive_#{return_name}"
+      instance_method_name = "dango_receive_#{return_name}"
       expr = <<-EOF
         def self.#{instance_method_name}(ret_obj)
-#          cs_logger.debug "ret_obj:" + ret_obj.inspect
-          send_receive_shared[#{action_name_sym}] = ret_obj
+#          logger.debug "ret_obj:" + ret_obj.inspect
+          send_return_shared[#{action_name_sym}] = ret_obj
         end
       EOF
       instance_eval expr
@@ -238,26 +238,26 @@ class DangoClientFramework
         # 送信スレッドが開始していなければ開始
         if !receive_thread
           receive_thread = Thread.start(action_name, send_obj) do
-            cs_client_send_data(action_name, send_obj)
+            send_action(action_name, send_obj)
           end
         end
         
         # 戻ってきたデータがあれば
-        if send_receive_shared[action_name]
-          cs_logger.debug "action_name:#{send_receive_shared[action_name].inspect}"
+        if send_return_shared[action_name]
+          logger.debug "action_name:#{send_return_shared[action_name].inspect}"
           break 
         end
         
         sleep SendReceiveSleepIntervalSec # スリープ
       end
       
-      if !send_receive_shared[action_name] # 戻ってきたデータがあるかどうかチェック
+      if !send_return_shared[action_name] # 戻ってきたデータがあるかどうかチェック
         raise(DangoFrameworkError, "received data is none") 
       end
       
       #remove_method(instance_method_name) # 定義したインスタンスメソッドを削除しておく
       
-      send_receive_shared[action_name]
+      send_return_shared[action_name]
     end
   end
   
@@ -270,15 +270,15 @@ class DangoClientFramework
     def []=(key, value) # キーに対する書き込み（読み込みはないぞ）
       action_name = "action_notice_shared_#{key}"
       send_obj = {:data => value}
-      @parent.cs_client_send_data(action_name, send_obj)
+      @parent.send_action(action_name, send_obj)
     end
   end
   
-  def cs_client_notice_shared_init # 通知共有メモリの初期化
+  def dango_client_notice_shared_init # 通知共有メモリの初期化
     @client_notice_shared = ClientNoticeShared.new(self)
   end
   
-  def cs_client_notice_shared # 通知共有メモリ
+  def dango_client_notice_shared # 通知共有メモリ
     @client_notice_shared
   end
   

data/lib/dango/framework_base.rb

@@ -106,33 +106,33 @@ module DangoFrameworkModule
   # 2 = Marshal
   
   # デバッグ出力用のメソッド
-  def cs_debug_print(str)
-    cs_logger.debug str
+  def debug_print(str)
+    logger.debug str
     puts str if $VERBOSE
   end
   
   # ロガーの定義
-  def cs_logger
-#   if !@cs_logger                                            # これだと警告が出てうざいので
-    if !self.instance_variables.find{|iv| iv == '@cs_logger'} # @cs_loggerが未定義なら
+  def logger
+#   if !@logger                                            # これだと警告が出てうざいので
+    if !self.instance_variables.find{|iv| iv == '@logger'} # @loggerが未定義なら
       if @log_file != ""
         log_dir = File.dirname(@log_file)
         Dir.mkdir(log_dir) if !File.exist?(log_dir)
-        @cs_logger = Logger.new(@log_file)
-        @cs_logger.level = @log_level
-        @cs_logger.datetime_format = "%Y-%m-%dT%H:%M:%S"
-#        @cs_logger.datetime_format = "aaaaa"
-        @cs_logger.progname = "toid=#{Thread.current.object_id}"
+        @logger = Logger.new(@log_file)
+        @logger.level = @log_level
+        @logger.datetime_format = "%Y-%m-%dT%H:%M:%S"
+#        @logger.datetime_format = "aaaaa"
+        @logger.progname = "toid=#{Thread.current.object_id}"
       end
     end
-    @cs_logger
+    @logger
   end
 
   # データ受信処理
-  def cs_receive_data(sock)
+  def dango_receive_data(sock)
     ret_data = ""
     
-#    cs_logger.debug "receive_data(#{sock})"
+#    logger.debug "dango_receive_data(#{sock})"
     
     begin
 #      size_str = sock.readpartial(CommMaxDigit + 1)
@@ -152,9 +152,9 @@ module DangoFrameworkModule
     
     ## Flash のpolicyファイルだった場合（特殊）
     if size_str == "<polic"
-      cs_logger.debug "size_str=#{size_str.inspect}"
+      logger.debug "size_str=#{size_str.inspect}"
       receive_data = sock.recv(18)
-      cs_logger.debug "receive_data=#{receive_data}"
+      logger.debug "dango_receive_data:receive_data=#{receive_data}"
       raise(DangoFrameworkFlashPolicyError) 
     end
     
@@ -171,7 +171,7 @@ module DangoFrameworkModule
       raise(DangoFrameworkConnectionError, "too big... size=#{size}:size_str=#{size_str.inspect}")
     end
     
-#    cs_logger.debug "size=#{size}:size_str=#{size_str.inspect}"
+#    logger.debug "size=#{size}:size_str=#{size_str.inspect}"
     
     ret_data_orig = ""
     
@@ -186,16 +186,16 @@ module DangoFrameworkModule
       end
       
       ret_data_orig += this_ret_data_orig
-#      cs_logger.debug "size:#{size.inspect}:this_ret_data_orig:#{this_ret_data_orig.inspect}"
+#      logger.debug "size:#{size.inspect}:this_ret_data_orig:#{this_ret_data_orig.inspect}"
       
       size -= this_ret_data_orig.size
-#      cs_logger.debug "size:#{size.inspect}"
+#      logger.debug "size:#{size.inspect}"
     end
     
-#    cs_logger.debug "ret_data_orig:#{ret_data_orig.inspect}"
+#    logger.debug "ret_data_orig:#{ret_data_orig.inspect}"
     
-    ret_data = cs_receive_decrypt(ret_data_orig[0..-2])
-#    cs_logger.debug "ret_data:#{ret_data.inspect}"
+    ret_data = dango_receive_decrypt(ret_data_orig[0..-2])
+#    logger.debug "ret_data:#{ret_data.inspect}"
     
     @recv_count += 1 if @recv_count # 受信回数カウント
     
@@ -215,8 +215,8 @@ module DangoFrameworkModule
   end
   
   # データ送信処理
-  def cs_send_data(sock, send_obj, options = {})
-#    cs_logger.debug "cs_send_data:send_obj=#{send_obj.inspect}"
+  def dango_send_data(sock, send_obj, options = {})
+#    logger.debug "dango_send_data:send_obj=#{send_obj.inspect}"
     
     dtype = options[:type] || DefaultDataType
     
@@ -230,11 +230,11 @@ module DangoFrameworkModule
       send_data_orig = Marshal.dump(send_obj)
     end
     
-    send_data = cs_send_encrypt(send_data_orig) + "\n"
-#    send_data = cs_send_encrypt(send_data_orig) + "\r\n"
-#    send_data = cs_send_encrypt(send_data_orig) + "\015\012"
+    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"
     
-#    cs_logger.debug "start send_data:#{send_data.inspect}"
+#    logger.debug "start dango_send_data:#{send_data.inspect}"
     
     size = send_data.size
     
@@ -246,10 +246,10 @@ module DangoFrameworkModule
 #    size_str = sprintf("%0#{CommMaxDigit}d", size)
     
     size_str = [dtype, size].pack("cN")
-#    cs_logger.debug "size=#{size}:size_str=#{size_str.inspect}"
+#    logger.debug "size=#{size}:size_str=#{size_str.inspect}"
     
     send_buf = size_str + "\n" + send_data
-#    cs_logger.debug "send_buf:#{send_buf.inspect}"
+#    logger.debug "send_buf:#{send_buf.inspect}"
     
     begin
       sock.write send_buf
@@ -263,8 +263,8 @@ module DangoFrameworkModule
     end
     
     @send_count += 1 if @send_count # 受信回数カウント
-#    cs_logger.debug "finish send_data:#{send_data.inspect}"
-#    cs_logger.debug "finish send_data:#{Time.now_to_s}:toid=#{Thread.current.object_id} #{sock} #{sock.closed?}"
+#    logger.debug "finish dango_send_data:#{send_data.inspect}"
+#    logger.debug "finish dango_send_data:#{Time.now_to_s}:toid=#{Thread.current.object_id} #{sock} #{sock.closed?}"
 
     sock
   end

data/lib/dango/monitor/dango_monitor_client.rb

@@ -25,7 +25,7 @@ class DangoMonitorClient < DangoClientFramework
   public
   
   # 起動処理
-  def cs_client_init
+  def dango_client_init
     # ログ出力情報
     @connection_client_log_file = "#{RAILS_ROOT}/log/dango_monitor_#{@env}.log"
     @connection_client_log_level = Logger::DEBUG
@@ -37,44 +37,50 @@ class DangoMonitorClient < DangoClientFramework
   
   # サーバーの全情報取得
   def get_all_info
-    cs_logger.debug "DangoMonitorClient:get_all_info:#{ENV['RAILS_ROOT']}"
+    logger.debug "DangoMonitorClient:get_all_info:#{ENV['RAILS_ROOT']}"
     begin
-      ret_obj = cs_client_send_receive_data('_monitor_all_info', {})
+      ret_obj = send_action_return_notice('_monitor_all_info', {})
+      raise("code is not 0 (faild). :code=#{ret_obj['code']}") if ret_obj['code'] != 0
+      return(ret_obj['all_info'])
     rescue DangoFrameworkConnectionError
       raise("monitor_all_info Connection error")
     rescue DangoFrameworkTimeoutError
       raise("monitor_all_info Timeout error")
+    ensure
+      dango_client_close
     end
-    raise("code is not 0 (faild). :code=#{ret_obj['code']}") if ret_obj['code'] != 0
-    ret_obj['all_info']
   end
   
   # サーバーのデータリロード
   def server_reload
-    cs_logger.debug "DangoMonitorClient:server_reload"
+    logger.debug "DangoMonitorClient:server_reload"
     begin
-      ret_obj = cs_client_send_receive_data('_monitor_server_reload', {})
+      ret_obj = send_action_return_notice('_monitor_server_reload', {})
+      raise("code is not 0 (faild). :code=#{ret_obj['code']}") if ret_obj['code'] != 0
+      return(true)
     rescue DangoFrameworkConnectionError
       raise("monitor_server_reload Connection error")
     rescue DangoFrameworkTimeoutError
       raise("monitor_server_reload Timeout error")
+    ensure
+      dango_client_close
     end
-    raise("code is not 0 (faild). :code=#{ret_obj['code']}") if ret_obj['code'] != 0
-    true
   end
   
   # システムメッセージの送信
   def send_system_message(message = "")
-    cs_logger.debug "DangoMonitorClient:send_system_message"
+    logger.debug "DangoMonitorClient:send_system_message"
     begin
-      ret_obj = cs_client_send_receive_data('_monitor_send_system_message', {:message=>message})
+      ret_obj = send_action_return_notice('_monitor_send_system_message', {:message=>message})
+      raise("code is not 0 (faild). :code=#{ret_obj['code']}") if ret_obj['code'] != 0
+      return(true)
     rescue DangoFrameworkConnectionError
       raise("monitor_send_system_message Connection error")
     rescue DangoFrameworkTimeoutError
       raise("monitor_send_system_message Timeout error")
+    ensure
+      dango_client_close
     end
-    raise("code is not 0 (faild). :code=#{ret_obj['code']}") if ret_obj['code'] != 0
-    true
   end
 end
 

data/lib/dango/monitor/server_monitor_action.rb

@@ -12,7 +12,7 @@ class ServerMonitorAction
     @parent = parent
     @config = config
     
-    @cs_logger     = @parent.cs_logger
+    @logger     = @parent.logger
     @shared        = @parent.shared
     @session       = @parent.session
     @socket_list   = @parent.socket_list
@@ -21,30 +21,30 @@ class ServerMonitorAction
     # アクション名
     action_name = ret_obj["action"].to_s
     
-    cs_check_monitor_error(sock, action_name)
+    dango_check_monitor_error(sock, action_name)
     
     if action_name == '_monitor_all_info' # メンテナンスアクション名なら
-      cs_server_monitor_all_info(ret_obj)
+      dango_server_monitor_all_info(ret_obj)
       
     elsif action_name == '_monitor_server_reload' # メンテナンスアクション名なら
-      cs_server_monitor_server_reload(ret_obj)
+      dango_server_monitor_server_reload(ret_obj)
       
     elsif action_name == '_monitor_send_system_message' # メンテナンスアクション名なら
-      cs_server_monitor_send_system_message(ret_obj)
+      dango_server_monitor_send_system_message(ret_obj)
       
     else
     end
   end
   
-  attr_reader(:cs_logger, :shared, :session, :socket_list, :session_list)
+  attr_reader(:logger, :shared, :session, :socket_list, :session_list)
   
   private
   
   # メンテナンスコマンド：エラーの場合
-  def cs_check_monitor_error(sock, action_name)
+  def dango_check_monitor_error(sock, action_name)
     peerhost, peeraddr = sock.peeraddr[2, 2]
     backdoor_host = @config['server']['backdoor_host']
-    cs_logger.debug "cs_check_monitor_error:peerhost=#{peerhost.inspect} peeraddr=#{peeraddr.inspect} backdoor_host=#{backdoor_host.inspect}"
+    logger.debug "dango_check_monitor_error:peerhost=#{peerhost.inspect} peeraddr=#{peeraddr.inspect} backdoor_host=#{backdoor_host.inspect}"
     
     match = false
     if peerhost == backdoor_host # ホスト名で書いてある時の一致確認
@@ -62,14 +62,14 @@ class ServerMonitorAction
     if !match
       notice_name = "return_" + action_name
       send_obj = {'code'=>1, 'message'=>"error your ip address"}
-      @parent.cs_server_send_data(session[:sid], notice_name, send_obj, :type=>2)
+      @parent.send_notice(session[:sid], notice_name, send_obj, :type=>2)
       raise(DangoFrameworkMonitorSecurityError)
     end
   end
   
   # メンテナンスコマンド：サーバーからクライアントへのデータ送信
-  def cs_server_monitor_all_info(ret_obj)
-    cs_logger.debug "cs_server_monitor_all_info:#{ret_obj.inspect}"
+  def dango_server_monitor_all_info(ret_obj)
+    logger.debug "dango_server_monitor_all_info:#{ret_obj.inspect}"
     all_info = {
       'shareds'       => shared.to_hash,
       'socket_list'   => socket_list.keys,
@@ -86,31 +86,31 @@ class ServerMonitorAction
     }
     
     send_obj = {'code'=>0, 'all_info'=>all_info}
-    @parent.cs_server_send_data(session[:sid], 'return__monitor_all_info', send_obj, :type=>2)
+    @parent.send_notice(session[:sid], 'return__monitor_all_info', send_obj, :type=>2)
   end
   
   # メンテナンスコマンド：サーバーデータ再読み込み
-  def cs_server_monitor_server_reload(ret_obj)
-    cs_logger.debug "cs_server_monitor_server_reload"
+  def dango_server_monitor_server_reload(ret_obj)
+    logger.debug "dango_server_monitor_server_reload"
     @server_reload = true
-    cs_logger.debug "@server_reload=#{@server_reload.inspect}"
+    logger.debug "@server_reload=#{@server_reload.inspect}"
     send_obj = {'code'=>0, 'message'=>'success'}
-    @parent.cs_server_send_data(session[:sid], 'return__monitor_server_reload', send_obj, :type=>2)
+    @parent.send_notice(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}"
+  def dango_server_monitor_send_system_message(ret_obj)
+    logger.debug "dango_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"] }
-      @parent.cs_server_send_data(sid, '_notice_system_message', send_obj)
+      @parent.send_notice(sid, '_notice_system_message', send_obj)
     end
     
     send_obj = {'code'=>0, }
-    @parent.cs_server_send_data(session[:sid], 'return__monitor_send_system_message', send_obj, :type=>2)
+    @parent.send_notice(session[:sid], 'return__monitor_send_system_message', send_obj, :type=>2)
   end
   
 end

data/lib/dango/server_framework.rb

@@ -81,12 +81,12 @@ class DangoServerFramework
   def server_start()
     set_server_variables()                # 各種サーバー仕様の変数設定
     
-    cs_logger.debug("===== server initialize =====") # loggerの準備
-    cs_logger.debug("#{Time.now_to_s}")
-    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}")
+    logger.debug("===== server initialize =====") # loggerの準備
+    logger.debug("#{Time.now_to_s}")
+    logger.debug("Process.pid=#{Process.pid}")
+    logger.debug("port=#{@connection_server_port}")
+    logger.debug("host=#{@connection_server_host}")
+    logger.debug("max_connections=#{@connection_server_max_connections}")
     
     open("tmp/pids/dango.pid", "wb"){|fh| fh.write Process.pid.to_s }
     
@@ -96,7 +96,7 @@ class DangoServerFramework
     socket_list_init()                    # ソケット一覧を初期化
     mutex_socket_list_init()              # ソケット毎用のmutexを初期化
     @mutex_proc_thread = Mutex.new        # スレッドが同時起動しないようにするためのMutex
-    cs_server_init()                      # 初期設定読み込み
+    dango_server_init()                      # 初期設定読み込み
     heart_beat_thread_start()             # ハートビートスレッドの開始
     
     @mutex_send_response = Mutex.new      # 送信レスポンス用のMutex
@@ -111,7 +111,7 @@ class DangoServerFramework
       @gserver.start
     rescue Exception
       error_msg = "#{$!.class} #{$!.message} #{$!.backtrace.pretty_inspect}"
-      cs_logger.error error_msg
+      logger.error error_msg
       puts error_msg
     end
   end
@@ -125,9 +125,9 @@ class DangoServerFramework
         puts "-- stopping server"
         
         # 強制的に接続しているsocketをクローズ
-        cs_logger.debug "socket_list.keys:#{socket_list.keys.inspect}"
+        logger.debug "socket_list.keys:#{socket_list.keys.inspect}"
         socket_list.keys.each do |sk|
-          cs_logger.debug "sk:#{socket_list[sk].inspect}"
+          logger.debug "sk:#{socket_list[sk].inspect}"
           socket_list[sk].close if ! socket_list[sk].closed?
           socket_list[sk]
         end
@@ -138,7 +138,7 @@ class DangoServerFramework
         while(!@gserver.stopped?) do
          sleep 1
           puts "waiting... #{@gserver.stopped?}"
-          cs_logger.debug "waiting... #{@gserver.stopped?} #{@gserver.connections}"
+          logger.debug "waiting... #{@gserver.stopped?} #{@gserver.connections}"
         end
         
         @gserver = nil
@@ -177,26 +177,26 @@ class DangoServerFramework
         server_start() # サーバー開始
       end
     rescue Exception
-      cs_logger.error "#{$!.class}:#{$!.message}\n#{$!.backtrace.pretty_inspect}"
+      logger.error "#{$!.class}:#{$!.message}\n#{$!.backtrace.pretty_inspect}"
     end
   end
   
   # gserver接続開始処理
   def connecting(sock)
-    cs_logger.debug "connecting:sock=#{sock} peeraddr=#{sock.peeraddr.inspect} addr=#{sock.addr.inspect}"
-#    cs_logger.debug "getpeername=#{Socket.unpack_sockaddr_in(sock.getpeername).inspect} getsockname=#{Socket.unpack_sockaddr_in(sock.getsockname).inspect}"
+    logger.debug "connecting:sock=#{sock} peeraddr=#{sock.peeraddr.inspect} addr=#{sock.addr.inspect}"
+#    logger.debug "getpeername=#{Socket.unpack_sockaddr_in(sock.getpeername).inspect} getsockname=#{Socket.unpack_sockaddr_in(sock.getsockname).inspect}"
   end
   
   # gserver接続開始処理
   def disconnecting(port)
-    cs_logger.debug "disconnecting:port=#{port} #{Time.now_to_s}"
+    logger.debug "disconnecting:port=#{port} #{Time.now_to_s}"
   end
   
   # gserverのserveメソッド：スレッド開始処理
   def thread_main(sock)
-    cs_logger.debug "thread_main:start"
-#    cs_logger.debug "#{sock} is accepted. thread.current=#{Thread.current.object_id} sock_id=#{sock.object_id}"
-    cs_logger.debug "#{sock} is accepted. thread.current=#{Thread.current.object_id}"
+    logger.debug "thread_main:start"
+#    logger.debug "#{sock} is accepted. thread.current=#{Thread.current.object_id} sock_id=#{sock.object_id}"
+    logger.debug "#{sock} is accepted. thread.current=#{Thread.current.object_id}"
     
     begin
       sock.binmode
@@ -208,12 +208,12 @@ class DangoServerFramework
       socket_list.add(sid, sock)
       mutex_socket_list.add(sid)
       
-      cs_connect() # 接続時メソッド呼び出し
+      dango_connect() # 接続時メソッド呼び出し
       
       # 接続直後のsid通知
       send_obj = {"_sid"=>sid}
-      cs_server_send_data(sid, "_notice_sid", send_obj)
-      cs_logger.debug "_notice_sid #{sid} #{Time.now_to_s}"
+      send_notice(sid, "_notice_sid", send_obj)
+      logger.debug "_notice_sid #{sid} #{Time.now_to_s}"
       
       # 誰かが接続したときに60秒以上経った@arr_send_responseを削除
       @mutex_send_response.synchronize do
@@ -223,33 +223,33 @@ class DangoServerFramework
       # メインループ入り
       loop do
         if sock.closed?
-          cs_logger.debug "#{sock.inspect}:sock is closed..."
+          logger.debug "#{sock.inspect}:sock is closed..."
           break
         end
         
         ret_obj = nil
         begin
-          ret_obj = cs_receive_data(sock) # データ受信処理
+          ret_obj = dango_receive_data(sock) # データ受信処理
           is_flash_policy_file = false
         rescue DangoFrameworkFlashPolicyError
           is_flash_policy_file = true
         end
         
         if is_flash_policy_file && @policy_file_request # Flashのポリシーファイルが来たら
-          cs_logger.debug "is_flash_policy_file #{sid} #{Time.now_to_s}"
+          logger.debug "is_flash_policy_file #{sid} #{Time.now_to_s}"
           policy_data = '<?xml version="1.0"?><cross-domain-policy><allow-access-from domain="*" to-ports="*" /></cross-domain-policy>' + "\0" + "\n"
-          cs_logger.debug policy_data
+          logger.debug policy_data
           sock.write policy_data
           sock.flush
           sleep 1
           raise(DangoFrameworkFlashPolicyError, "policy file sent. disconnectiong...")
           
         elsif ret_obj == {} # 受信データがなければ
-#          cs_logger.debug "ret_obj is empty. #{Time.now_to_s}"
+#          logger.debug "ret_obj is empty. #{Time.now_to_s}"
           
         else # 受信データがあれば
           if !(ret_obj && ret_obj["action"]) # actionが無い場合はエラー
-            cs_logger.error "no action error:#{ret_obj.inspect}"
+            logger.error "no action error:#{ret_obj.inspect}"
             raise(DangoFrameworkError, "no action error") 
           end
           
@@ -259,19 +259,19 @@ class DangoServerFramework
           @mutex_proc_thread.synchronize do
             
             if action_name == '_response' # 送信パケットの返事なら
-#              cs_logger.debug "action_name=#{action_name} #{Time.now_to_s}"
+#              logger.debug "action_name=#{action_name} #{Time.now_to_s}"
               action_name_is_response(ret_obj)
               
             elsif action_name[0, 9] == '_monitor_' # メンテナンスアクション名なら
               ServerMonitorAction.new(self, @config, sock, ret_obj)
               
             else # メンテナンスコマンド以外のユーザーアクション名なら
-              cs_logger.debug "action_name=#{action_name} #{sid} #{Time.now_to_s}"
+              logger.debug "action_name=#{action_name} #{sid} #{Time.now_to_s}"
               begin
-                __send__("cs_receive_#{action_name}", ret_obj)
+                __send__("dango_receive_#{action_name}", ret_obj)
               rescue NoMethodError
                 @recv_fail_count += 1 if @recv_fail_count # 受信失敗回数カウント
-                cs_logger.error "not find action #{action_name}:#{sid}:#{error_message($!, 'u')}"
+                logger.error "not find action #{action_name}:#{sid}:#{error_message($!, 'u')}"
               end
             end
             
@@ -281,41 +281,41 @@ class DangoServerFramework
       end # loop
       
     rescue DangoFrameworkFlashPolicyError
-      cs_logger.debug "Flash policy file send. #{sid} #{Time.now_to_s}"
+      logger.debug "Flash policy file send. #{sid} #{Time.now_to_s}"
       
     rescue DangoFrameworkMonitorSecurityError
-      cs_logger.debug "Monitor Security Error #{sid} #{Time.now_to_s}"
+      logger.debug "Monitor Security Error #{sid} #{Time.now_to_s}"
       
     rescue DangoFrameworkReadNoDataError
-      cs_logger.debug "read no data. maybe client closed. #{sid} #{Time.now_to_s}"
+      logger.debug "read no data. maybe client closed. #{sid} #{Time.now_to_s}"
       
     rescue DangoFrameworkConnectionError
       @recv_fail_count += 1 if @recv_fail_count # 受信失敗回数カウント
-      cs_logger.debug "connection error. #{sid} #{Time.now_to_s}\n#{error_message($!, 'u')}"
+      logger.debug "connection error. #{sid} #{Time.now_to_s}\n#{error_message($!, 'u')}"
       
     rescue DangoFrameworkError
-      cs_logger.debug "DangoFrameworkError. #{sid} #{Time.now_to_s}\n#{error_message($!, 'u')}"
+      logger.debug "DangoFrameworkError. #{sid} #{Time.now_to_s}\n#{error_message($!, 'u')}"
       
     rescue Exception
-      cs_logger.error "Exception #{sid} #{Time.now_to_s} #{error_message($!, 'u')}"
+      logger.error "Exception #{sid} #{Time.now_to_s} #{error_message($!, 'u')}"
       
     ensure
-      cs_logger.debug "#{sock.inspect} #{sid} is gone"
+      logger.debug "#{sock.inspect} #{sid} is gone"
       
       @mutex_proc_thread.synchronize do
         begin
-          cs_close() # 接続解除時に呼び出されるメソッド
+          dango_close() # 接続解除時に呼び出されるメソッド
         rescue Exception
-          cs_logger.error "#{error_message($!, 'u')}"
+          logger.error "#{sock.inspect} #{sid} ERROR\n#{error_message($!, 'u')}"
         ensure
           socket_list.delete(sid)     # ソケットリストから削除
           begin
             sock.close if !sock.closed?           # ソケットを閉じる
           rescue IOError
-            cs_logger.debug "IOError #{sock} #{sid}"
+            logger.debug "IOError #{sock} #{sid}"
           end
           
-          cs_logger.debug "#{sock.inspect} #{sid} is gone 2"
+          logger.debug "#{sock.inspect} #{sid} is gone 2"
         end
         
       end
@@ -326,7 +326,7 @@ class DangoServerFramework
   
   # action_nameが送信パケットの返事なら
   def action_name_is_response(ret_obj)
-#    cs_logger.warn "action_name_is_response:#{ret_obj['_id']} #{session[:sid]} #{Time.now_to_s}" 
+#    logger.warn "action_name_is_response:#{ret_obj['_id']} #{session[:sid]} #{Time.now_to_s}" 
     @mutex_send_response.synchronize do
       @arr_send_response.push({:_id => ret_obj["_id"], :time => Time.now})
     end
@@ -372,7 +372,7 @@ class DangoServerFramework
   
   attr_reader(:start_time, :recv_count, :send_count, :recv_fail_count, :send_fail_count)
   
-  def cs_server_init # 初期設定
+  def dango_server_init # 初期設定
   end
   
   # コンフィグのshared_database_managerによる使用クラスの選択
@@ -449,10 +449,10 @@ class DangoServerFramework
         
         self[key] = value
         
-        @parent.cs_logger.debug "self.get_connectables(key):#{self.get_connectables(key).inspect}"
+        @parent.logger.debug "self.get_connectables(key):#{self.get_connectables(key).inspect}"
         
         self.get_connectables(key).each do |sid|
-          @parent.cs_server_send_data(sid, "notice_shared_#{key}".to_sym, value)
+          @parent.send_notice(sid, "notice_shared_#{key}".to_sym, value)
         end
       end
       
@@ -508,26 +508,28 @@ class DangoServerFramework
   attr_accessor(:mutex_socket_list)
   
   # 接続時に呼び出されるメソッド
-  def cs_connect; end
+  def dango_connect
+  end
   
   # 接続解除時に呼び出されるメソッド
-  def cs_close; end
+  def dango_close
+  end
   
   
   # サーバーの暗号化処理
-  def cs_server_send_encrypt(str) # 継承用
+  def dango_server_send_encrypt(str) # 継承用
     str
   end
-  def cs_send_encrypt(str) # フレームワークから呼ばれる部分
-    cs_server_send_encrypt(str)
+  def dango_send_encrypt(str) # フレームワークから呼ばれる部分
+    dango_server_send_encrypt(str)
   end
   
   # サーバーの復号化処理
-  def cs_server_receive_decrypt(str) # 継承用
+  def dango_server_receive_decrypt(str) # 継承用
     str
   end
-  def cs_receive_decrypt(str) # フレームワークから呼ばれる部分
-    cs_server_receive_decrypt(str)
+  def dango_receive_decrypt(str) # フレームワークから呼ばれる部分
+    dango_server_receive_decrypt(str)
   end
   
   # ハートビートスレッドの開始
@@ -538,29 +540,29 @@ class DangoServerFramework
           sleep @herat_beat_interval_sec
           
           if ! @gserver.stopped? # gserverが起動していれば
-            cs_logger.debug "heart_beat_thread_start #{Time.now_to_s}"
+            logger.debug "heart_beat_thread_start #{Time.now_to_s}"
             
             # 全員へheart_beatパケットを送信
             socket_list.keys.each do |sid|
 #              sock = socket_list[sid]
-#              cs_logger.debug "heart_beat_thread_start:sid=#{sid} #{sock} #{sock.closed?}"
-#              cs_send_data(sock, {})
-              cs_logger.debug "heart_beat_thread_start:sid=#{sid}"
-              cs_server_send_data(sid, "_heart_beat", {}, {:timeout=>@heart_beat_response_wait_sec})
+#              logger.debug "heart_beat_thread_start:sid=#{sid} #{sock} #{sock.closed?}"
+#              dango_send_data(sock, {})
+              logger.debug "heart_beat_thread_start:sid=#{sid}"
+              send_notice(sid, "_heart_beat", {}, {:timeout=>@heart_beat_response_wait_sec})
             end
           end
           
         rescue
-          cs_logger.error "Exception heart_beat_thread_start #{Time.now_to_s} #{error_message($!, 'u')}"
+          logger.error "Exception heart_beat_thread_start #{Time.now_to_s} #{error_message($!, 'u')}"
         end
       end
     end
   end
   
   # サーバーからクライアントへのデータ送信
-  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})"
+  def send_notice(sid, notice_name, send_obj, options = {})
+    logger.debug "send_notice(#{sid.inspect}, #{notice_name.inspect}) #{Time.now_to_s}"
+#    logger.debug "send_notice(#{sid.inspect}, #{notice_name.inspect}, #{send_obj.inspect}, #{options.inspect})"
     
     raise(DangoFrameworkError, "send_obj is not Hash.") if ! send_obj.is_a?(Hash)
     
@@ -569,8 +571,8 @@ class DangoServerFramework
     
     sock = socket_list[sid]
     if !sock || sock.closed? # sockがないという事はすでに切断済み
-      cs_logger.info "cs_server_send_data:already closed socket. sid=#{sid.inspect} sock=#{sock.inspect} #{Time.now_to_s}"
-      return
+      logger.info "send_notice:already closed socket. sid=#{sid.inspect} sock=#{sock.inspect} #{Time.now_to_s}"
+      return(self)
     end
     
     # sidの通知の場合はレスポンスを気にしない
@@ -581,8 +583,8 @@ class DangoServerFramework
       send_obj_dup = send_obj.deep_dup
       send_obj_dup["notice"] = notice_name.to_s
       
-      cs_send_data(sock, send_obj_dup, :type=>dtype) # データ送信
-#      cs_logger.debug "cs_server_send_data:finish send data notice_name=#{notice_name.inspect}\n"
+      dango_send_data(sock, send_obj_dup, :type=>dtype) # データ送信
+#      logger.debug "send_notice:finish send data notice_name=#{notice_name.inspect}\n"
     else
       Thread.start(sid, notice_name, send_obj, dtype, timeout, sock) do
         begin
@@ -593,7 +595,7 @@ class DangoServerFramework
           send_obj_dup["notice"] = notice_name.to_s
           
           mutex_socket_list.synchronize(sid) do
-#            cs_logger.debug "mutex_socket_list:synchronize:#{notice_name} #{sid} #{Time.now_to_s}"
+#            logger.debug "mutex_socket_list:synchronize:#{notice_name} #{sid} #{Time.now_to_s}"
             
             digest_key = sid.to_s + notice_name.to_s + Time.now.to_f.to_s + rand().to_s
             send_obj_dup["_id"] = Digest::MD5.hexdigest(digest_key)
@@ -601,31 +603,31 @@ class DangoServerFramework
             
             receive_thread = Thread.start(sock, send_obj_dup, dtype) do
               begin
-                cs_send_data(sock, send_obj_dup, :type=>dtype) # データ送信
-#                cs_logger.debug "cs_server_send_data:sent:notice_name=#{send_obj_dup['_id']} #{notice_name.inspect} #{sid} #{Time.now_to_s}"
+                dango_send_data(sock, send_obj_dup, :type=>dtype) # データ送信
+#                logger.debug "send_notice:sent:notice_name=#{send_obj_dup['_id']} #{notice_name.inspect} #{sid} #{Time.now_to_s}"
               rescue DangoFrameworkConnectionError
-                cs_logger.debug "cs_server_send_data:DangoFrameworkConnectionError:notice_name=#{notice_name.inspect} #{sid} #{Time.now_to_s}"
+                logger.debug "send_notice:DangoFrameworkConnectionError:notice_name=#{notice_name.inspect} #{sid} #{Time.now_to_s}"
               rescue DangoFrameworkError
-                cs_logger.debug "ERROR:cs_server_send_data:DangoFrameworkError:notice_name=#{notice_name.inspect} #{sid} #{Time.now_to_s}\n #{error_message($!, 'u')}"
+                logger.debug "ERROR:send_notice:DangoFrameworkError:notice_name=#{notice_name.inspect} #{sid} #{Time.now_to_s}\n #{error_message($!, 'u')}"
               end
             end
             
             # データ送信スレッドの終了待ち
             if !receive_thread.join(@send_timeout_sec)
               # タイムアウトの場合は
-              cs_logger.warn "cs_server_send_data:send timeout:#{notice_name} #{sid} #{Time.now_to_s}" 
+              logger.warn "send_notice:send timeout:#{notice_name} #{sid} #{Time.now_to_s}" 
             else
-#              cs_logger.warn "cs_server_send_data:sent after join:#{notice_name} #{sid} #{Time.now_to_s}" 
+#              logger.warn "send_notice:sent after join:#{notice_name} #{sid} #{Time.now_to_s}" 
               end_reserved_time = Time.now + timeout
               
               # タイムアウトチェック
               catch(:send_timeout) do
                 (timeout.to_f / @send_receive_sleep_interval_sec).to_i.times do
                   if Time.now > end_reserved_time
-                    cs_logger.debug "cs_server_send_data:receive timeout:#{notice_name}" 
+                    logger.debug "send_notice:receive timeout:#{notice_name}" 
                     
                     if notice_name.to_s == "_heart_beat" # heart beatだったらsockを止める
-                      cs_logger.info "!!!! cs_server_send_data:heart_beat timeout" 
+                      logger.info "!!!! send_notice:heart_beat timeout" 
                       sock.close if !sock.closed?
                     end
                     break
@@ -635,7 +637,7 @@ class DangoServerFramework
                     find_res = @arr_send_response.find{|r| r[:_id] == send_obj_dup["_id"]}
                     
                     if find_res
-                      cs_logger.debug "cs_server_send_data:find_res _heart_beat #{sid}" if notice_name.to_s == "_heart_beat"
+                      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
@@ -648,12 +650,12 @@ class DangoServerFramework
               end # catch 終わり
               
               if !have_came_response # 戻ってきたデータがあるかどうかチェック
-                cs_logger.warn "!!! received data is none:#{notice_name} #{sid} #{Time.now_to_s}"
+                logger.warn "!!! received data is none:#{notice_name} #{sid} #{Time.now_to_s}"
               end
             end
           end # mutex
         rescue
-          cs_logger.debug "send_response_thread error:#{error_message($!, 'u')}"
+          logger.debug "send_response_thread error:#{error_message($!, 'u')}"
         end
       end # Thread:end
       
@@ -664,31 +666,31 @@ class DangoServerFramework
   
   # 必要に応じて追加するメソッド
   def method_missing(name, *args)
-    if name.to_s =~ /^cs_receive_action_notice_shared_(.+)/ # 共有メモリ変更通知なら
+    if name.to_s =~ /^dango_receive_action_notice_shared_(.+)/ # 共有メモリ変更通知なら
       key = $1
       method_action_notice_shared(key, name, *args)
     else
-      cs_logger.info "method not found. #{name.inspect} #{args.inspect}"
+      logger.info "method not found. #{name.inspect} #{args.inspect}"
       raise(NameError, "method not found. #{name.inspect} #{args.inspect}")
     end
   end
   
   # 共有メモリ変更通知のメソッド
   def method_action_notice_shared(key, name, *args) 
-    cs_logger.debug "method_name:#{name}"
+    logger.debug "method_name:#{name}"
     send_obj = args[0]
     notice_shared.notice_change(key.to_sym, send_obj) 
   end
   
   # メインループ用の定義をするためのメソッド
   def flameloop_thread(loop_method, options={})
-    cs_logger.debug "flameloop_thread options:#{options.inspect}"
+    logger.debug "flameloop_thread options:#{options.inspect}"
 
     options = options.deep_dup
     options[:rate] ||= 10
     
     wait_sec = 1.0 / options[:rate]
-    cs_logger.debug "flameloop_thread wait_sec:#{wait_sec.inspect}"
+    logger.debug "flameloop_thread wait_sec:#{wait_sec.inspect}"
     
     Thread.new do 
       loop do
@@ -696,7 +698,7 @@ class DangoServerFramework
           begin
             __send__(loop_method)
           rescue
-            cs_logger.debug "flameloop_thread error:#{error_message($!, 'u')}"
+            logger.debug "flameloop_thread error:#{error_message($!, 'u')}"
           end
         end
         sleep wait_sec

data/lib/dango/tasks/dango_rake.rb

@@ -72,7 +72,7 @@ namespace :dango do
       begin
         dm = DangoMonitorClient.new()
         p dm.server_reload()
-        dm.cs_client_close
+        dm.dango_client_close
       rescue
         p $!.class
         p $!.message
@@ -99,7 +99,7 @@ namespace :dango do
       begin
         dm = DangoMonitorClient.new()
         p dm.send_system_message(message)
-        dm.cs_client_close
+        dm.dango_client_close
       rescue
         p $!.class
         p $!.message

data/lib/dango/tester/dango_tester_client.rb

@@ -90,14 +90,14 @@ class TestClient < DangoClientFramework
   
   attr_accessor(:client_name)
   
-  # cs_client_send_receive_data用の共有メモリ
+  # dango_client_send_receive_data用の共有メモリ
   def send_receive_shared_init
     @send_receive_shared = SharedMemoryStore.new
   end
   attr_reader(:send_receive_shared)
   
   # 起動処理
-  def cs_client_init
+  def dango_client_init
     # サーバー接続情報など
     @connection_client_host = @config["network"]["host"] # 自動でこのホスト名でサーバー開始
     @connection_client_port = @config["network"]["port"] # 自動でこのポートでサーバー開始
@@ -109,40 +109,40 @@ class TestClient < DangoClientFramework
   
   # テストサーバー
   def send(name, send_obj = {})
-    cs_logger.debug("tester.send:send_obj=#{send_obj.inspect} #{Time.now_to_s}")
-    cs_client_send_data(name, send_obj)
+    logger.debug("tester.send:send_obj=#{send_obj.inspect} #{Time.now_to_s}")
+    send_action(name, send_obj)
   end
   
   # trap_receive
-  def trap_receive(receive_name, options = {})
-    cs_logger.debug "trap_receive_data:#{receive_name}:#{Time.now_to_s}"
+  def trap_receive(notice_name, options = {})
+    logger.debug "trap_receive_data:#{notice_name}:#{Time.now_to_s}"
     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)
     
     # 戻ってきたデータのチェックメソッド
-    receive_name_sym = (receive_name.class == Symbol) ? (":"+receive_name.to_s) : ('"'+receive_name+'"')
+    notice_name_sym = (notice_name.class == Symbol) ? (":"+notice_name.to_s) : ('"'+notice_name+'"')
     
-    if ! @receive_methods.include?(receive_name_sym)
-      instance_method_name = "cs_receive_#{receive_name}"
+    if ! @receive_methods.include?(notice_name_sym)
+      instance_method_name = "dango_receive_#{notice_name}"
       expr = <<-EOF
         def self.#{instance_method_name}(ret_obj)
-          cs_logger.debug "ret_obj:" + ret_obj.inspect + " " + Time.now_to_s
-          send_receive_shared[#{receive_name_sym}] = ret_obj
+          logger.debug "ret_obj:" + ret_obj.inspect + " " + Time.now_to_s
+          send_receive_shared[#{notice_name_sym}] = ret_obj
         end
       EOF
       instance_eval expr
-      @receive_methods.push(receive_name_sym)
+      @receive_methods.push(notice_name_sym)
     end
     
     # @trap_thread_hashにスレッド登録
-    if ! @trap_thread_hash.has_key?(receive_name)
+    if ! @trap_thread_hash.has_key?(notice_name)
       
       # スレッド開始
-      th = Thread.start(receive_name, timeout, trap_proc, trap_loop) do
+      th = Thread.start(notice_name, timeout, trap_proc, trap_loop) do
         loop do
-          send_receive_shared[receive_name] = nil
+          send_receive_shared[notice_name] = nil
           if timeout == 0
             end_reserved_time = Time.at(0)         # 0ならepochを入れる
           else
@@ -152,12 +152,12 @@ class TestClient < DangoClientFramework
           # タイムアウトチェック
           loop do
             if end_reserved_time != Time.at(0) && end_reserved_time < Time.now
-              raise(DangoFrameworkTimeoutError, "timeout:timeout_sec=#{timeout}:\nclient_name=#{@client_name}(#{self.sid}):\nreceive_name=#{receive_name} \n#{Time.now_to_s}") 
+              raise(DangoFrameworkTimeoutError, "timeout:timeout_sec=#{timeout}:\nclient_name=#{@client_name}(#{self.sid}):\nnotice_name=#{notice_name} \n#{Time.now_to_s}") 
             end
             
             # 戻ってきたデータがあれば
-            if send_receive_shared[receive_name]
-              cs_logger.debug "receive_name:#{send_receive_shared[receive_name].inspect} #{Time.now_to_s}"
+            if send_receive_shared[notice_name]
+              logger.debug "notice_name:#{send_receive_shared[notice_name].inspect} #{Time.now_to_s}"
               break 
             end
             
@@ -165,21 +165,21 @@ class TestClient < DangoClientFramework
           end
           
           # 戻ってきたデータがあるかどうかチェック
-          if !send_receive_shared[receive_name] 
-            raise(DangoFrameworkError, "received data is none. sid=#{self.sid} receive_name=#{receive_name}")
+          if !send_receive_shared[notice_name] 
+            raise(DangoFrameworkError, "received data is none. sid=#{self.sid} notice_name=#{notice_name}")
           end
           
           # :procが設定されている場合は、それを呼び出す
           if trap_proc
-            cs_logger.debug "trap_receive_data:trap_proc:#{trap_proc.inspect} #{Time.now_to_s}"
-            trap_proc.call(send_receive_shared[receive_name])
+            logger.debug "trap_receive_data:trap_proc:#{trap_proc.inspect} #{Time.now_to_s}"
+            trap_proc.call(send_receive_shared[notice_name])
             break if ! trap_loop # loopする必要がなければスレッド終了
             
           # :procが設定されていなければ、wait用に@receive_arrに入れておく
           else
             @receive_mutex.synchronize do
-              cs_logger.debug "receive_name:#{receive_name}:#{send_receive_shared[receive_name].inspect} #{Time.now_to_s}"
-              @receive_arr.push([receive_name, send_receive_shared[receive_name]])
+              logger.debug "notice_name:#{notice_name}:#{send_receive_shared[notice_name].inspect} #{Time.now_to_s}"
+              @receive_arr.push([notice_name, send_receive_shared[notice_name]])
             end
             break # スレッド終了
             
@@ -187,26 +187,32 @@ class TestClient < DangoClientFramework
         end # loop
       end # Thread
       
-      @trap_thread_hash[receive_name] = th
+      @trap_thread_hash[notice_name] = th
     else
       
-      cs_logger.debug "trap_receive_data:already register trap:receive_name:#{receive_name} #{Time.now_to_s}"
+      logger.debug "trap_receive_data:already register trap:notice_name:#{notice_name} #{Time.now_to_s}"
     end
     
   end
   
   # cancel trap_receive
-  def cancel_trap_receive(receive_name, options = {})
-    cs_logger.debug "cancel_trap_receive:#{receive_name}:#{Time.now_to_s}"
+  def cancel_trap_receive(notice_name, options = {})
+    logger.debug "cancel_trap_receive:#{notice_name}:#{Time.now_to_s}"
     
-    @trap_thread_hash[receive_name].kill
+    # trapスレッドの削除
+    if @trap_thread_hash[notice_name] 
+      @trap_thread_hash[notice_name].kill
+      @trap_thread_hash[notice_name].join
+      
+      @trap_thread_hash.delete(notice_name)
+    end
     
-    @trap_thread_hash.delete(receive_name)
+    send_receive_shared[notice_name] = nil # 受信データのごみを削除
   end
   
   # wait_receive
-  def wait_receive(receive_name, options = {})
-    cs_logger.debug "wait_receive_data:#{receive_name}:#{Time.now_to_s}"
+  def wait_receive(notice_name, options = {})
+    logger.debug "wait_receive_data:#{notice_name}:#{Time.now_to_s}"
     timeout = options[:timeout] || ReceiveWaitTimeoutSec
     
     # データ受信待ち
@@ -216,7 +222,7 @@ class TestClient < DangoClientFramework
     
     loop do
       @receive_mutex.synchronize do
-        receive_data = @receive_arr.find{|r| r[0] == receive_name}.deep_dup
+        receive_data = @receive_arr.find{|r| r[0] == notice_name}.deep_dup
       end
       
       break if receive_data != nil
@@ -227,15 +233,15 @@ class TestClient < DangoClientFramework
     
     # タイムアウトなら
     if receive_data == nil
-      raise(DangoFrameworkTimeoutError, "timeout:timeout_sec=#{timeout}:\nclient_name=#{@client_name}(#{self.sid})\:receive_name=#{receive_name} \n#{Time.now_to_s}") 
+      raise(DangoFrameworkTimeoutError, "timeout:timeout_sec=#{timeout}:\nclient_name=#{@client_name}(#{self.sid})\:notice_name=#{notice_name} \n#{Time.now_to_s}") 
     end
     
     # 結果を削除しておく
     @receive_mutex.synchronize do
-      @receive_arr.delete_if{|r| r[0] == receive_name}
+      @receive_arr.delete_if{|r| r[0] == notice_name}
     end
     
-    @trap_thread_hash.delete(receive_name)
+    @trap_thread_hash.delete(notice_name)
     
     receive_data[1]
   end

data/lib/dango/version.rb

@@ -2,7 +2,7 @@ module Dango #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 25
+    TINY  = 26
 
     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.25
-date: 2007-10-31 00:00:00 +09:00
+  version: 0.0.26
+date: 2007-11-03 00:00:00 +09:00
 summary: Realtime communications network framework for Ruby and Flash on Rails.
 require_paths: 
 - lib