dango 0.1.0 → 0.2.2

data/lib/dango/client_framework.rb

@@ -42,7 +42,8 @@ class DangoClientFramework
     @connection_client_port = @config['network']['port'] || 15000
     
     @connection_client_log_file = ""              # 未定義時にこのログファイル名を使う
-    @connection_client_log_level = Logger::DEBUG  # 未定義時にこのログレベルになる
+#    @connection_client_log_level = Logger::DEBUG  # 未定義時にこのログレベルになる
+    @connection_client_log_level = Logger::INFO   # 未定義時にこのログレベルになる
     
     @recv_count = 0 # 受信回数
     @send_count = 0 # 送信回数
@@ -53,7 +54,13 @@ class DangoClientFramework
       exit!
     end
     
-    dango_client_init() # 初期設定読み込み
+    begin
+      dango_client_init() # 初期設定読み込み
+    rescue
+      message = "failed in dango_client_init. #{error_message($!, 'u')}"
+      logger.error message
+      raise DangoError, message
+    end
     
     @log_file = @connection_client_log_file
     @log_level = @connection_client_log_level
@@ -104,9 +111,9 @@ class DangoClientFramework
         begin
           if @sock
             logger.debug "start dango_receive_data #{@sid}"
-            ret_obj = nil
+            ret_objs = nil
             begin
-              ret_obj = dango_receive_data(@sock) # データ受信処理
+              ret_objs = dango_receive_data(@sock) # データ受信処理
             rescue DangoFrameworkConnectionError
               logger.debug "sock error #{@sid}:#{error_message($!, 'u')}"
               throw(:session_closed)
@@ -114,26 +121,28 @@ class DangoClientFramework
               logger.debug "sock error #{@sid}:#{error_message($!, 'u')}"
               throw(:session_closed)
             end
-            logger.debug "finished dango_receive_data:#{ret_obj.inspect} #{@sid}"
+            logger.debug "finished dango_receive_data:#{ret_objs.inspect} #{@sid}"
             
-            if !(ret_obj && ret_obj["notice"])
-              logger.info "no notice:#{ret_obj["notice"].inspect} #{@sid}"
-            end
-            
-            # メソッド呼び出し
-            logger.info "calling method=#{ret_obj["notice"].inspect} #{@sid} "
-            begin
-              __send__("dango_receive_#{ret_obj["notice"]}", ret_obj)
-            rescue
-              logger.error "error in dango_receive_#{ret_obj["notice"]} #{@sid} \n#{error_message($!, 'u')}"
-            ensure
-              # データの受信の送信返し
-              response_notice_name = "_response"
-              send_obj = {"_id" => ret_obj["_id"]}
-              send_action(response_notice_name, send_obj)
-              logger.debug "response_notice_name=#{response_notice_name.inspect} #{@sid} "
+            ret_objs.each do |ret_obj|  # 受信データひとつごとに処理
+              if !(ret_obj && ret_obj["notice"])
+                logger.info "no notice:#{ret_obj["notice"].inspect} #{@sid}"
+              end
+              
+              # メソッド呼び出し
+              logger.info "calling method=#{ret_obj["notice"].inspect} #{@sid} "
+              begin
+                __send__("dango_receive_#{ret_obj["notice"]}", ret_obj)
+              rescue
+                logger.error "error in dango_receive_#{ret_obj["notice"]} #{@sid} \n#{error_message($!, 'u')}"
+              ensure
+                # データの受信の送信返し
+                response_notice_name = "_response"
+                send_obj = {"_id" => ret_obj["_id"]}
+                send_action(response_notice_name, send_obj)
+                logger.debug "response_notice_name=#{response_notice_name.inspect} #{@sid} "
+              end
+              logger.debug "called method=#{ret_obj["notice"].inspect} #{@sid} "
             end
-            logger.debug "called method=#{ret_obj["notice"].inspect} #{@sid} "
             
           else
             sleep 0.01
@@ -235,7 +244,7 @@ class DangoClientFramework
     logger.debug "send_action(#{action_name.inspect}, #{send_obj['_id']}) "
     send_obj_dup = send_obj.dup
     send_obj_dup["action"] = action_name.to_s
-    dango_send_data(@sock, send_obj_dup)
+    dango_send_data(@sock, [send_obj_dup])
   end
   
   # サーバーからクライアントへのデータ送信

data/lib/dango/framework_base.rb

@@ -4,7 +4,6 @@
 = コネクションのサーバー、クライアントで使うモジュール
 =end
 
-require "rubygems"
 
 require 'resolv-replace' # 名前解決時のロックがかかってしまう件を解決できるはず
 require 'socket'
@@ -16,6 +15,8 @@ require "stringio"
 require "pp"
 require "kconv"
 require "fcntl"
+
+require "rubygems"
 require "json"
 
 require "dango/shared/memory_store.rb"
@@ -209,7 +210,7 @@ module DangoFrameworkModule
     
     begin
       if ret_data == "" || ret_data == "{}" # データが空ならparseしない
-        data = {}
+        data = []
       elsif dtype == 0
         data = JSON.parse(ret_data)
       elsif dtype == 1
@@ -223,19 +224,19 @@ module DangoFrameworkModule
   end
   
   # データ送信処理
-  def dango_send_data(sock, send_obj, options = {})
-#    logger.debug "dango_send_data:send_obj=#{send_obj.inspect}"
+  def dango_send_data(sock, send_objs, options = {})
+#    logger.debug "dango_send_data:send_objs=#{send_objs.inspect}"
     
     dtype = options[:type] || DefaultDataType
     
-    if send_obj == {}
+    if send_objs == []
       send_data_orig = ""
     elsif dtype == 0
-      send_data_orig = JSON.generate(send_obj)
+      send_data_orig = JSON.generate(send_objs)
     elsif dtype == 1
-      send_data_orig = send_obj.to_yaml
+      send_data_orig = send_objs.to_yaml
     elsif dtype == 2
-      send_data_orig = Marshal.dump(send_obj)
+      send_data_orig = Marshal.dump(send_objs)
     end
     
     send_data = dango_send_encrypt(send_data_orig) + "\n"

data/lib/dango/monitor/server_monitor_action.rb

@@ -71,7 +71,7 @@ class ServerMonitorAction
     if !match
       notice_name = "return_" + action_name
       send_obj = {'code'=>1, 'message'=>"error your ip address"}
-      @parent.send_notice(session[:sid], notice_name, send_obj, :type=>2)
+      @parent.send_notice(notice_name, session[:sid], send_obj, :type=>2)
       raise(DangoFrameworkMonitorSecurityError)
     end
   end
@@ -95,28 +95,28 @@ class ServerMonitorAction
     }
     
     send_obj = {'code'=>0, 'get_server_info'=>get_server_info}
-    @parent.send_notice(session[:sid], 'return__monitor_get_server_info', send_obj, :type=>2)
+    @parent.send_notice('return__monitor_get_server_info', session[:sid], send_obj, :type=>2)
   end
   
   # メンテナンスコマンド：サーバーからクライアントへのデータ送信
   def dango_server_monitor_get_shared(ret_obj)
     logger.debug "dango_server_monitor_get_shared:#{ret_obj.inspect}"
     send_obj = {'code'=>0, 'get_shared'=>shared.to_hash}
-    @parent.send_notice(session[:sid], 'return__monitor_get_shared', send_obj, :type=>2)
+    @parent.send_notice('return__monitor_get_shared', session[:sid], send_obj, :type=>2)
   end
   
   # メンテナンスコマンド：サーバーからクライアントへのデータ送信
   def dango_server_monitor_get_session_list(ret_obj)
     logger.debug "dango_server_monitor_get_session_list:#{ret_obj.inspect}"
     send_obj = {'code'=>0, 'get_session_list'=>session_list}
-    @parent.send_notice(session[:sid], 'return__monitor_get_session_list', send_obj, :type=>2)
+    @parent.send_notice('return__monitor_get_session_list', session[:sid], send_obj, :type=>2)
   end
   
   # メンテナンスコマンド：サーバーからクライアントへのデータ送信
   def dango_server_monitor_get_socket_list(ret_obj)
     logger.debug "dango_server_monitor_get_socket_list:#{ret_obj.inspect}"
     send_obj = {'code'=>0, 'get_socket_list'=>socket_list.keys}
-    @parent.send_notice(session[:sid], 'return__monitor_get_socket_list', send_obj, :type=>2)
+    @parent.send_notice('return__monitor_get_socket_list', session[:sid], send_obj, :type=>2)
   end
   
   # メンテナンスコマンド：サーバーデータ再読み込み
@@ -125,7 +125,7 @@ class ServerMonitorAction
     @server_reload = true
     logger.debug "@server_reload=#{@server_reload.inspect}"
     send_obj = {'code'=>0, 'message'=>'success'}
-    @parent.send_notice(session[:sid], 'return__monitor_server_reload', send_obj, :type=>2)
+    @parent.send_notice('return__monitor_server_reload', session[:sid], send_obj, :type=>2)
   end
   
   # メンテナンスコマンド：接続者全員へメッセージ送信
@@ -136,11 +136,11 @@ class ServerMonitorAction
     socket_list.keys.each do |sid|
       next if session[:sid] == sid
       send_obj = { "message" => ret_obj["message"] }
-      @parent.send_notice(sid, '_notice_system_message', send_obj)
+      @parent.send_notice('_notice_system_message', sid, send_obj)
     end
     
     send_obj = {'code'=>0, }
-    @parent.send_notice(session[:sid], 'return__monitor_send_system_message', send_obj, :type=>2)
+    @parent.send_notice('return__monitor_send_system_message', session[:sid], send_obj, :type=>2)
   end
   
 end

data/lib/dango/script/dango_server.rb

@@ -1,9 +1,11 @@
 #!ruby -Ku
 
-
 require 'yaml'
 require 'pp'
 
+require 'rubygems'
+require 'active_support'
+
 require 'dango/server_framework'
 
 require RAILS_ROOT + '/config/environment'

data/lib/dango/server_framework.rb

@@ -16,23 +16,26 @@ require "dango/monitor/server_monitor_action"
 class DangoServerFramework
   include DangoFrameworkModule
   
+  env = ENV['RAILS_ENV'] || 'development'
+  
   ### 以下すべてデフォルト値
   DefaultNetworkPort = 15000          # デフォルトのポート番号
-  DefaultServerHost = 'localhost'     # デフォルトのホスト名 # 接続制限ホスト "0.0.0.0"にすれば全接続オッケイ
+  DefaultNetworkHost = 'localhost'    # デフォルトのサーバーホスト名
+  DefaultServerHost = 'localhost'     # 接続制限ホスト "0.0.0.0"にすれば全接続オッケイ
   DefaultMaxConnections = 10          # デフォルトの最大接続人数
   
-  DefaultLogFile     = "log/dango_development.log"
+  DefaultLogFile     = "log/dango_#{env}.log"
   DefaultLogLevel    = Logger::INFO
   DefaultLogMaxSize  = 1048576
   DefaultLogShiftAge = 99
   DefaultGServerLogFile     = ""
 
   # ここから先は普通は変更しなくていいだろうというもの
-  SendReceiveSleepIntervalSec = 0.2   # データ送信時のタイムアウトチェック間隔秒
+  SendReceiveSleepIntervalSec = 0.2   # データ送信時の送信間隔秒
   SendReceiveTimeoutDefaultSec = 5.0  # データ送受信時のデフォルトタイムアウト秒数
-  SendTimeoutSec = 4.0                # データ送受信時の送信のタイムアウト秒数
+#  SendTimeoutSec = 4.0                # データ送受信時の送信のタイムアウト秒数
   HeartBeatIntervalSec = 10.0         # heart beatのチェック間隔秒数
-  HeartBeatResponseWaitSec = 10.0     # S=>Cのheart beatの返信待ち秒数
+#  HeartBeatResponseWaitSec = 10.0     # S=>Cのheart beatの返信待ち秒数
   HeartBeatReceiveWaitSec = 30.0      # C=>Sのheart beatの受信待ち秒数
   GCIntervalSec = 5.0                 # GCの発生タイミング
   
@@ -95,6 +98,11 @@ class DangoServerFramework
   
   def exit_process() # プロセス終了処理
     debug_print("shutdown")
+    begin
+      File.delete("tmp/pids/dango.pid")
+    rescue 
+      puts "failed delete file. tmp/pids/dango.pid:#{$!.class}:#{$!.message}"
+    end
     puts "shutdown"
     exit!
   end
@@ -124,6 +132,10 @@ class DangoServerFramework
     @thr_gr_send_notice = ThreadGroup.new
     @thr_gr_send_data = ThreadGroup.new
     
+    # データ送信用スレッドとQueue
+    @queue_send_notice = Queue.new
+    Thread.start{ thread_send_notice_queue() }
+    
     # サーバー開始
     server_start()
     
@@ -146,13 +158,13 @@ class DangoServerFramework
     set_server_variables()                # 各種サーバー仕様の変数設定
     
     logger.warn("===== server initialize =====") # loggerの準備
+    logger.warn("ENV['RAILS_ENV']=#{ENV['RAILS_ENV']}")
     logger.warn("Process.pid=#{Process.pid}")
-    logger.warn("port=#{@server_port}")
-    logger.warn("host=#{@server_host}")
+    logger.warn("network_port=#{@network_port}")
+    logger.warn("network_host=#{@network_host}")
+    logger.warn("server_host=#{@server_host}")
     logger.warn("max_connections=#{@server_max_connections}")
     
-    open("tmp/pids/dango.pid", "wb"){|fh| fh.write Process.pid.to_s }
-    
     session_init()                        # セッション情報の初期化
     shared_init()                         # 共有メモリを初期化
     notice_shared_init()                  # 通知共有メモリを初期化
@@ -169,7 +181,7 @@ class DangoServerFramework
     TCPSocket.do_not_reverse_lookup = true # 逆引きを行わない
 #    TCPSocket.do_not_reverse_lookup = false # 逆引きを行う
     
-    @gserver = DangoGServer.new(self, @server_port, @server_host, @server_max_connections)
+    @gserver = DangoGServer.new(self, @network_port, @server_host, @server_max_connections)
     @gserver.audit = true                 # Turn logging on.
     @gserver.debug = true                 # debug
     
@@ -180,6 +192,8 @@ class DangoServerFramework
     
     GC.disable
     
+    open("tmp/pids/dango.pid", "wb"){|fh| fh.write Process.pid.to_s } # pidをファイルに保存
+    
     begin
       @gserver.start
     rescue Exception
@@ -252,14 +266,14 @@ class DangoServerFramework
   
   # gserver開始処理
   def starting()
-    msg = "#{self.class.to_s} #{@server_host}:#{@server_port}/#{@server_max_connections} start"
+    msg = "#{self.class.to_s} #{@server_host}:#{@network_port}/#{@server_max_connections} start"
     logger.warn msg
     puts "[#{Time.now_to_s}] #{msg}"
   end
   
   # gserver終了処理
   def stopping()
-    msg = "#{self.class.to_s} #{@server_host}:#{@server_port} stop"
+    msg = "#{self.class.to_s} #{@server_host}:#{@network_port} stop"
     logger.warn msg
     puts "[#{Time.now_to_s}] #{msg}"
   end
@@ -280,12 +294,9 @@ class DangoServerFramework
       socket_list.add(sid, sock)
       mutex_socket_list.add(sid)
       
-      dango_connect() # 接続時メソッド呼び出し
+      session[:connected] = nil # まだdango_connectを呼び出していない
       
-      # 接続直後のsid通知
-      send_obj = {"_sid"=>sid}
-      send_notice(sid, "_notice_sid", send_obj)
-      logger.debug "_notice_sid #{sid} "
+      is_flash_policy_file = false
       
       # 誰かが接続したときに60秒以上経った@arr_send_responseを削除
       @mutex_send_response.synchronize do
@@ -299,9 +310,9 @@ class DangoServerFramework
           break
         end
         
-        ret_obj = nil
+        ret_objs = nil
         begin
-          ret_obj = dango_receive_data(sock) # データ受信処理
+          ret_objs = dango_receive_data(sock) # データ受信処理
           is_flash_policy_file = false
         rescue DangoFrameworkFlashPolicyError
           is_flash_policy_file = true
@@ -312,48 +323,72 @@ class DangoServerFramework
           policy_data = <<EOF
 <?xml version="1.0"?>
 <cross-domain-policy>
-<allow-access-from domain="*" to-ports="*" />
+<allow-access-from domain="#{@network_host}" to-ports="#{@network_port}" />
 </cross-domain-policy>
 EOF
-          policy_data += "\0" + "\n"
+
           logger.debug policy_data
           sock.write policy_data
           sock.flush
-          sleep 1
+          sleep 0.1
           raise(DangoFrameworkFlashPolicyError, "policy file sent. disconnectiong...")
           
-        elsif ret_obj == {} # 受信データがなければ
-#          logger.debug "ret_obj is empty. "
+        elsif ret_objs == [] # 受信データがなければ
+#          logger.debug "ret_objs is empty. "
           
         else # 受信データがあれば
-          if !(ret_obj && ret_obj["action"]) # actionが無い場合はエラー
-            logger.warn "no action error:#{ret_obj.inspect}"
-            raise(DangoFrameworkError, "no action error") 
+          if ! session[:connected] # まだdango_connectを呼び出していないなら
+            # 接続直後のsid通知
+            send_obj = {"_sid"=>sid}
+            send_notice("_notice_sid", sid, send_obj)
+            logger.debug "_notice_sid #{sid} "
+            
+            session[:connected] = true
+            dango_connect() # 接続時メソッド呼び出し
           end
           
-          # アクション名
-          action_name = ret_obj["action"].to_s
-          
-          @mutex_proc_thread.synchronize do
+          ret_objs.each do |ret_obj| # 受信データループ
+            if !(ret_obj && ret_obj["action"]) # actionが無い場合はエラー
+              logger.warn "no action error:#{ret_obj.inspect}"
+              raise(DangoFrameworkError, "no action error") 
+            end
             
-            if action_name == '_response' # 送信パケットの返事なら
-#              logger.debug "action_name=#{action_name} #{ret_obj['_id']} "
-              action_name_is_response(ret_obj)
-              
-            elsif action_name[0, 9] == '_monitor_' # メンテナンスアクション名なら
-              ServerMonitorAction.new(self, @config, sock, ret_obj)
-              
-            else # メンテナンスコマンド以外のユーザーアクション名なら
-              logger.info "receive_action:#{sid}:#{action_name}:"
-              begin
-                __send__("dango_receive_#{action_name}", ret_obj)
-              rescue NoMethodError
-                @recv_fail_count += 1 if @recv_fail_count # 受信失敗回数カウント
-                logger.error "not find action #{action_name}:#{sid}:#{error_message($!, 'u')}"
+            # アクション名
+            action_name = ret_obj["action"].to_s
+            session[:_action_name] = action_name
+            
+            # 自動返信用データ
+            session[:_return] = {}
+            ret_obj.each do |key, value|
+              if key =~ /^_return_(.*)$/
+                session[:_return][$1.to_sym] = value
               end
             end
             
-          end # @mutex_proc_thread.synchronize
+            @mutex_proc_thread.synchronize do
+              
+              if action_name[0, 9] == '_monitor_' # メンテナンスアクション名なら
+                ServerMonitorAction.new(self, @config, sock, ret_obj)
+                
+              elsif action_name == '_response' # 送信パケットの返事なら
+                action_name_is_response(ret_obj)
+                
+              else # メンテナンスコマンド以外のユーザーアクション名なら
+                logger.debug "receive_action:#{sid}:#{action_name}:"
+                begin
+                  __send__("dango_receive_#{action_name}", ret_obj)
+                rescue NoMethodError
+                  @recv_fail_count += 1 if @recv_fail_count # 受信失敗回数カウント
+                  logger.error "not find action #{action_name}:#{sid}:#{error_message($!, 'u')}"
+                end
+              end
+              
+            end # @mutex_proc_thread.synchronize
+            
+            # 不要になったセッション内のデータを削除（sidは再利用されるので消さない）
+            session.delete(:_action_name)
+            session.delete(:_return)
+          end
         end
         
       end # loop
@@ -385,8 +420,10 @@ EOF
       
       @mutex_proc_thread.synchronize do
         begin
-          logger.info "#{sock.inspect} #{sid} is closing"
-          dango_close() # 接続解除時に呼び出されるメソッド
+          if !is_flash_policy_file # Flash Policy Fileなら切断処理不要
+            logger.info "#{sock.inspect} #{sid} is closing"
+            dango_close() # 接続解除時に呼び出されるメソッド
+          end
         rescue Exception
           logger.error "#{sock.inspect} #{sid} ERROR\n#{error_message($!, 'u')}"
         ensure
@@ -407,9 +444,9 @@ EOF
   
   # action_nameが送信パケットの返事なら
   def action_name_is_response(ret_obj)
-    logger.debug "action_name_is_response: #{ret_obj['_id']} #{session[:sid]} " 
+    logger.debug "action_name_is_response: #{ret_obj['_id'].inspect} #{session[:sid].inspect}"
     @mutex_send_response.synchronize do
-      @arr_send_response.push({:_id => ret_obj["_id"], :time => Time.now})
+      @arr_send_response.push({:_id => ret_obj["_id"], :_sid => session[:sid], :time => Time.now})
     end
   end
   
@@ -420,7 +457,8 @@ EOF
     Thread.abort_on_exception = true if @server_debug
     
     # 変数の初期設定
-    @server_port                       = @config['network']['port'] || DefaultNetworkPort
+    @network_port                      = @config['network']['port'] || DefaultNetworkPort
+    @network_host                      = @config['network']['host'] || DefaultNetworkHost
     @server_host                       = @config['server']['host'] || DefaultServerHost
     @server_max_connections            = @config['server']['max_connections'] || DefaultMaxConnections
     @log_file                          = @config['server']['log_file'] || DefaultLogFile
@@ -431,9 +469,9 @@ EOF
     @policy_file_request               = @config['server']['policy_file_request'] || true
     @send_receive_sleep_interval_sec   = @config['server']['send_receive_sleep_interval_sec'] || SendReceiveSleepIntervalSec
     @send_receive_timeout_default_sec  = @config['server']['send_receive_timeout_default_sec'] || SendReceiveTimeoutDefaultSec
-    @send_timeout_sec                  = @config['server']['send_timeout_sec'] || SendTimeoutSec
+#    @send_timeout_sec                  = @config['server']['send_timeout_sec'] || SendTimeoutSec
     @herat_beat_interval_sec           = @config['server']['heart_beat_interval_sec'] || HeartBeatIntervalSec
-    @heart_beat_response_wait_sec      = @config['server']['heart_beat_response_wait_sec'] || HeartBeatResponseWaitSec
+#    @heart_beat_response_wait_sec      = @config['server']['heart_beat_response_wait_sec'] || HeartBeatResponseWaitSec
     @heart_beat_receive_wait_sec       = @config['server']['heart_beat_receive_wait_sec'] || HeartBeatReceiveWaitSec
     @gc_interval_sec                   = @config['server']['gc_interval_sec'] || GCIntervalSec
     
@@ -545,7 +583,7 @@ EOF
         @parent.logger.debug "self.get_connectables(key):#{self.get_connectables(key).inspect}"
         
         self.get_connectables(key).each do |sid|
-          @parent.send_notice(sid, "notice_shared_#{key}".to_sym, value)
+          @parent.send_notice("notice_shared_#{key}", sid, value)
         end
       end
       
@@ -646,7 +684,7 @@ EOF
           GC.enable
           GC.start 
           GC.disable
-          logger.debug "GC end #{Time.now - gc_start_time}sec "
+          logger.info "GC end #{Time.now - gc_start_time}sec "
 #          Thread.critical = false
           
         rescue Exception
@@ -677,7 +715,7 @@ EOF
             socket_list.keys.each do |sid|
               sock = socket_list[sid]
 #              logger.debug "heart_beat_thread_start:sid=#{sid} #{sock} #{sock.closed?}"
-#              send_notice(sid, "_heart_beat", {}, {:timeout=>@heart_beat_response_wait_sec})
+#              send_notice("_heart_beat", sid, {}, {:timeout=>@heart_beat_response_wait_sec})
               
               # クライアントから来たハートビートの時間チェックし、古ければsocketを閉じて、threadを殺す
               if heart_beat_time_hash[sid] && heart_beat_time_hash[sid] < Time.now - @heart_beat_receive_wait_sec
@@ -721,119 +759,196 @@ EOF
     end
   end
   
+  # サーバーからクライアントへのデータ返信
+  def send_return(send_obj, options = {})
+    logger.info "send_return(#{session[:sid].inspect}) "
+    
+    raise(DangoFrameworkError, "session[:sid] is not exist.") if ! session[:sid]
+    raise(DangoFrameworkError, "session[:_action_name] is not exist.") if ! session[:_action_name]
+    
+    send_notice("return_#{session[:_action_name]}", session[:sid], send_obj, options)
+  end
+  
   # サーバーからクライアントへのデータ送信
-  def send_notice(sid, notice_name, send_obj, options = {})
-    logger.info "send_notice(#{sid.inspect}, #{notice_name.inspect}) "
-#    logger.debug "send_notice(#{sid.inspect}, #{notice_name.inspect}, #{send_obj.inspect}, #{options.inspect})"
+  def send_notice(notice_name, sids, send_obj, options = {})
+    logger.info "send_notice(#{notice_name.inspect}, #{sids.inspect}) "
     
     raise(DangoFrameworkError, "send_obj is not Hash.") if ! send_obj.is_a?(Hash)
     
-    timeout = options[:timeout] || @send_receive_timeout_default_sec
+    sids = [sids] if sids.is_a?(Integer)
+    raise(DangoFrameworkError, "sids is not Array.") if ! sids.is_a?(Array)
+    
+#    timeout = options[:timeout] || @send_receive_timeout_default_sec
     dtype = options[:type] || 0
     
-    sock = socket_list[sid]
-    if !sock || sock.closed? # sockがないという事はすでに切断済み
-      logger.info "send_notice:already closed socket. sid=#{sid.inspect} sock=#{sock.inspect} #{sock ? sock.closed? : nil} "
-      return(self)
-    end
+#    is_error = false
     
-    # sidの通知の場合はレスポンスを気にしない
-    if notice_name.to_s == "_notice_sid"
-      raise(DangoFrameworkError, "not found sid=#{sid}") if !sock
-      raise(DangoFrameworkConnectionError, "socket closed. sid=#{sid}") if sock.closed?
-      
+    sids.each do |sid|
       send_obj_dup = send_obj.deep_dup
       send_obj_dup["notice"] = notice_name.to_s
       
-      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
-          @thr_gr_send_notice.add(Thread.current) # send_noticeスレッドグループに登録
+#      send_id = sid.to_s + notice_name.to_s + Time.now.to_f.to_s + rand().to_s
+      send_id = notice_name.to_s + Time.now.to_f.to_s + rand().to_s
+#      send_id = Digest::MD5.hexdigest(sid.to_s + notice_name.to_s + Time.now.to_f.to_s + rand().to_s)
+      send_obj_dup["_id"] = send_id
+      
+=begin
+      sock = socket_list[sid]
+      if !sock || sock.closed? # sockがないという事はすでに切断済み
+        logger.info "send_notice:already closed socket. sid=#{sid.inspect} sock=#{sock.inspect} #{sock ? sock.closed? : nil} "
+        return(self)
+      end
+      
+#      if !sock
+#        logger.info "send_notice:not found sid=#{sid}"
+#        is_error = true
+#      end
+      
+#      if sock.closed?
+#        logger.info "send_notice:socket closed. sid=#{sid}"
+#        is_error = true
+#      end
+      
+      # sidの通知の場合はレスポンスを気にしない
+#      if notice_name.to_s == "_notice_sid"
+        dango_send_data(sock, [send_obj_dup], :type=>dtype) # データ送信
+#      else
+#        send_notice_thread(sid, notice_name, send_obj_dup, dtype, timeout, sock) # thread for notice send
+#      end
+=end
+      
+      @queue_send_notice.push([sid, send_obj_dup, dtype])
+    end # end sids.each
+    
+#    raise(DangoFrameworkConnectionError, "send_notice:error happened.") if is_error
+    
+    self
+  end
+  
+  # thread for send_notice_queue
+  def thread_send_notice_queue()
+    loop do
+      begin
+        send_data_list = []
+        send_data_list.push(@queue_send_notice.pop) # Queueデータ待ち
+        logger.debug "thread_send_notice_queue:sending data"
+        while(! @queue_send_notice.empty?) do       # 残りのデータもQueueに入れていく
+          send_data_list.push(@queue_send_notice.pop)
+        end
+        
+        send_data_sid_list = {}
+        send_data_dtype_list = {}
+        send_data_list.each do |one_send_data| # sidごとに分ける
+          sid      = one_send_data[0]
+          send_obj = one_send_data[1]
+          dtype    = one_send_data[2]
+          send_data_sid_list[sid] = [] if ! send_data_sid_list.has_key?(sid)
+          send_data_sid_list[sid].push(send_obj)
+          send_data_dtype_list[sid] = dtype
+        end
+        
+        # sidごとにデータをまとめ送り
+        send_data_sid_list.each do |sid, one_send_data_sid|
+          sock = socket_list[sid]
+          if !sock
+            logger.info "thread_send_notice_queue:not found sid=#{sid} sock=#{sock.inspect}"
+            next
+          end
           
-          raise(DangoFrameworkError, "not found sid=#{sid}") if !sock
-          raise(DangoFrameworkConnectionError, "socket closed. sid=#{sid}") if sock.closed?
+          if sock.closed?
+            logger.info "thread_send_notice_queue:socket closed. sid=#{sid} sock=#{sock.inspect}"
+            next
+          end
           
-          send_obj_dup = send_obj.deep_dup
-          send_obj_dup["notice"] = notice_name.to_s
+          begin
+            dango_send_data(sock, one_send_data_sid, :type=>send_data_dtype_list[sid]) # データ送信
+          rescue DangoFrameworkConnectionError
+            logger.info "thread_send_notice_queue:failed send. sid=#{sid} sock=#{sock.inspect} #{$!.class}"
+          end
+        end
+        
+        sleep @send_receive_sleep_interval_sec # スリープ
+        
+      rescue Exception
+        logger.warn "ERROR:thread_send_notice_queue:Exception:#{error_message($!, 'u')}"
+      end
+    end
+  end
+  
+=begin
+  # thread for notice send
+  def send_notice_thread(sid, notice_name, send_obj_dup, dtype, timeout, sock)
+    Thread.start(sid, notice_name, send_obj_dup, dtype, timeout, sock) do
+      begin
+        @thr_gr_send_notice.add(Thread.current) # send_noticeスレッドグループに登録
+        
+        mutex_socket_list.synchronize(sid) do
+          have_came_response = nil
           
-          mutex_socket_list.synchronize(sid) do
-#            logger.debug "mutex_socket_list:synchronize:#{notice_name} #{sid} "
-            
-            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)
-            have_came_response = nil
-            
-            receive_thread = Thread.start(sock, send_obj_dup, dtype) do
-              begin
-                @thr_gr_send_data.add(Thread.current) # send_dataスレッドグループに登録
-                
-                dango_send_data(sock, send_obj_dup, :type=>dtype) # データ送信
-#                logger.debug "send_notice:sent:notice_name=#{send_obj_dup['_id']} #{notice_name.inspect} #{sid} "
-              rescue DangoFrameworkConnectionError
-                logger.warn "send_notice:DangoFrameworkConnectionError:notice_name=#{notice_name.inspect} #{sid} "
-              rescue DangoFrameworkError
-                logger.warn "ERROR:send_notice:DangoFrameworkError:notice_name=#{notice_name.inspect} #{sid} \n #{error_message($!, 'u')}"
-              rescue Exception
-                logger.warn "ERROR:send_notice:Exception:notice_name=#{notice_name.inspect} #{sid} \n #{error_message($!, 'u')}"
-              end
+          receive_thread = Thread.start(sock, send_obj_dup, dtype) do
+            begin
+              @thr_gr_send_data.add(Thread.current) # send_dataスレッドグループに登録
+              
+              dango_send_data(sock, [send_obj_dup], :type=>dtype) # データ送信
+            rescue DangoFrameworkConnectionError
+              logger.warn "send_notice:DangoFrameworkConnectionError:notice_name=#{notice_name.inspect} #{sid} "
+            rescue DangoFrameworkError
+              logger.warn "ERROR:send_notice:DangoFrameworkError:notice_name=#{notice_name.inspect} #{sid} \n #{error_message($!, 'u')}"
+            rescue Exception
+              logger.warn "ERROR:send_notice:Exception:notice_name=#{notice_name.inspect} #{sid} \n #{error_message($!, 'u')}"
             end
+          end
+          
+          # データ送信スレッドの終了待ち
+          if !receive_thread.join(@send_timeout_sec)
+            # タイムアウトの場合は
+            logger.warn "send_notice:send timeout:#{notice_name} #{sid} " 
+          else
+            end_reserved_time = Time.now + timeout
             
-            # データ送信スレッドの終了待ち
-            if !receive_thread.join(@send_timeout_sec)
-              # タイムアウトの場合は
-              logger.warn "send_notice:send timeout:#{notice_name} #{sid} " 
-            else
-#              logger.warn "send_notice:sent after join:#{notice_name} #{sid} " 
-              end_reserved_time = Time.now + timeout
-              
-              # タイムアウトチェック
-              catch(:send_timeout) do
-                (timeout.to_f / @send_receive_sleep_interval_sec).to_i.times do
-                  sleep @send_receive_sleep_interval_sec # スリープ
+            # タイムアウトチェック
+            catch(:send_timeout) do
+              (timeout.to_f / @send_receive_sleep_interval_sec).to_i.times do
+                sleep @send_receive_sleep_interval_sec # スリープ
+                
+                @mutex_send_response.synchronize do # データ送信の返信が来たかどうかの確認
+                  find_res = @arr_send_response.find{|r| r[:_id] == send_obj_dup["_id"] && r[:_sid] == sid }
                   
-                  @mutex_send_response.synchronize do # データ送信の返信が来たかどうかの確認
-                    find_res = @arr_send_response.find{|r| r[:_id] == send_obj_dup["_id"]}
+                  if find_res
+                    logger.debug "send_notice:find_res _heart_beat #{sid}" if notice_name.to_s == "_heart_beat"
                     
-                    if find_res
-                      logger.debug "send_notice:find_res _heart_beat #{sid}" if notice_name.to_s == "_heart_beat"
-                      
-                      @arr_send_response.delete(find_res)
-                      have_came_response = true
-                      throw(:send_timeout)
-                    end
+                    @arr_send_response.delete(find_res)
+                    have_came_response = true
+                    throw(:send_timeout)
                   end
+                end
+                
+                if Time.now > end_reserved_time
+                  logger.debug "send_notice:receive timeout:#{notice_name} #{sid}  #{end_reserved_time}" 
                   
-                  if Time.now > end_reserved_time
-                    logger.debug "send_notice:receive timeout:#{notice_name} #{sid}  #{end_reserved_time}" 
-                    
-                    # このコードは不要なはずだが念の為取っておいてある、安定したことが確認できたら削除する
-                    if notice_name.to_s == "_heart_beat" # heart beatだったらsockを止める
-                      logger.info "!!!! send_notice:heart_beat timeout" 
-                      sock.close if !sock.closed?
-                    end
-                    break
+                  # このコードは不要なはずだが念の為取っておいてある、安定したことが確認できたら削除する
+                  if notice_name.to_s == "_heart_beat" # heart beatだったらsockを止める
+                    logger.info "!!!! send_notice:heart_beat timeout" 
+                    sock.close if !sock.closed?
                   end
-                  
-                end # タイムアウト処理終わり
-              end # catch 終わり
-              
-              if !have_came_response # 戻ってきたデータがあるかどうかチェック
-                logger.warn "!!! received data is none:#{notice_name} #{sid} #{send_obj_dup['_id']} "
-              end
+                  break
+                end
+                
+              end # タイムアウト処理終わり
+            end # catch 終わり
+            
+            if !have_came_response # 戻ってきたデータがあるかどうかチェック
+              logger.warn "!!! received data is none:#{notice_name} #{sid} #{send_obj_dup['_id']} "
             end
-          end # mutex
-        rescue Exception
-          logger.error "send_response_thread error:#{error_message($!, 'u')}"
-        end
-      end # Thread:end
-      
-    end
-    
-    self
+          end
+        end # mutex
+      rescue Exception
+        logger.error "send_response_thread error:#{error_message($!, 'u')}"
+      end
+    end # Thread:end
   end
-  
+=end
+
   # 必要に応じて追加するメソッド
   def method_missing(name, *args)
     if name.to_s =~ /^dango_receive_action_notice_shared_(.+)/ # 共有メモリ変更通知なら