dango 0.0.1

data/lib/dango/monitor/dango_monitor_client.rb

@@ -0,0 +1,66 @@
+#!ruby -Ku
+
+=begin
+= Dangoサーバーのメンテナンス用モニタ
+=end
+
+#$LOAD_PATH.push("../../../../svn/rubyforge/dango/lib")
+
+#gem "dango"
+
+require 'dango/client_framework' # コネクションサーバーフレームワークの呼び出し
+
+# 
+
+# メインクラス
+class DangoMonitorClient < DangoClientFramework
+  ConnTimeout = 6
+  
+  def initialize()
+    super(ENV['RAILS_ENV'])
+  end
+  
+  public
+  
+  # 起動処理
+  def cs_client_init
+    # ログ出力情報
+    @connection_client_log_file = "log/dango_monitor_#{ENV['RAILS_ENV']}.log"
+    @connection_client_log_level = Logger::DEBUG
+  end
+  
+  # アクセサの定義
+  # 読み込みのみ
+  attr_reader(:is_session_closed) 
+  
+  # サーバーの全情報取得
+  def get_all_info
+    cs_logger.debug "DangoMonitorClient:get_all_info"
+    begin
+      ret_obj = cs_client_send_receive_data('monitor_all_info', {})
+    rescue DangoFrameworkConnectionError
+      raise("monitor_all_info Connection error")
+    rescue DangoFrameworkTimeoutError
+      raise("monitor_all_info Timeout error")
+    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"
+    begin
+      ret_obj = cs_client_send_receive_data('monitor_server_reload', {})
+    rescue DangoFrameworkConnectionError
+      raise("monitor_server_reload Connection error")
+    rescue DangoFrameworkTimeoutError
+      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']
+  end
+end
+
+
+

data/lib/dango/script/dango_server.rb

@@ -0,0 +1,42 @@
+#!ruby -Ku
+
+#module Dango
+	require 'yaml'
+	require 'pp'
+
+	require 'dango/server_framework'
+
+#  require RAILS_ROOT + '/config/boot'
+  require RAILS_ROOT + '/config/environment'
+
+	# 環境によるコンフィグ読み込み
+	env = ENV['RAILS_ENV'] || 'development'
+
+	config = YAML.load(open("dango/config/#{env}.yml", "rb"){|fh| fh.read})
+
+	# serverファイル名一覧を取得
+	load_files = []
+	glob_str = 'dango/server/*.rb'
+	Dir.glob(glob_str) do |srv_file|
+		load_files.push({:file=>srv_file, :mtime=>File.mtime(srv_file)})
+	end
+
+	# ファイル名順にソート
+	load_files = load_files.sort_by{|f| f[:file] }
+	#p load_files
+
+#	config['load_files'] = load_files
+
+	# config:cache_classesによる処理分け
+#	if config['server']['cache_classes'] == true
+#		load_files.each do |f|
+#			require f[:file]
+#		end
+#	else
+		load_files.each do |f|
+			load f[:file]
+		end
+#	end
+
+	DangoServer.start(config)
+#end

data/lib/dango/server_framework.rb

@@ -0,0 +1,661 @@
+#!ruby -Ku
+
+=begin
+= コネクション型サーバーフレームワーク
+=end
+
+require 'gserver'
+require 'ipaddr'
+
+require "dango/framework_base"
+
+# フレームワーククラス
+class DangoServerFramework
+  include DangoFrameworkModule
+  
+  SendReceiveSleepIntervalSec = 0.1 # データ送信後の順の際のタイムアウトチェック間隔秒
+  
+  # cs_client_send_receive_data用の共有メモリ
+  def send_receive_shared_init
+    @send_receive_shared = SharedMemoryStore.new
+  end
+  def send_receive_shared
+    @send_receive_shared
+  end
+  
+  class DangoGServer < GServer
+    def initialize(parent, *args)
+      @parent = parent
+      super(*args)
+    end
+    
+    def serve(sock)
+      @parent.thread_main(sock)
+    end
+    
+    def connecting(sock)
+      @parent.connecting(sock)
+    end
+    
+    def disconnecting(sock)
+      @parent.disconnecting(sock)
+    end
+  end
+  
+  def initialize(config)
+    @config = config
+    
+    @gserver = nil # Gserver用の変数
+    @server_reload = nil # サーバーのリロード用フラグ
+    
+    # SIGINT の捕捉
+    Signal.trap(:INT) do 
+      puts "shutdown"
+      exit!
+    end
+    
+    # サーバー開始
+    server_start()
+    
+    loop do # 待ちで無限ループに入る
+      sleep 3
+#      p( Time.now.to_s + ":#{@server_reload.inspect}")
+      check_reload_class()
+    end
+  end
+  
+  attr_reader(:log_file, :shared) # 読み書き
+  
+  # 起動用のインスタンスメソッド
+  def self.start(config = {})
+    self.new(config)
+  end
+  
+  
+  # サーバー開始処理
+  def server_start()
+    set_server_variables()                # 各種サーバー仕様の変数設定
+    shared_init()                         # 共有メモリを初期化
+    notice_shared_init()                  # 通知共有メモリを初期化
+    socket_list_init()                    # ソケット一覧を初期化
+    mutex_socket_list_init(cs_logger())   # ソケット毎用のmutexを初期化
+    send_receive_shared_init()            # データ送受信用の共有メモリ初期化
+    cs_server_init()                      # 初期設定読み込み
+    
+    cs_logger.debug("===== server initialize =====") # loggerの準備
+    cs_logger.debug("port=#{@connection_server_port}")
+    cs_logger.debug("host=#{@connection_server_host}")
+    cs_logger.debug("max_connections=#{@connection_server_max_connections}")
+    
+    @gserver = DangoGServer.new(self, @connection_server_port, 
+                                @connection_server_host, 
+                                @connection_server_max_connections)
+    @gserver.audit = true                  # Turn logging on.
+    @gserver.start 
+  end
+  
+  # サーバーのループ時のクラス読み直し処理
+  def check_reload_class()
+    begin
+      # @config:cache_classesによる処理分け
+#      if @config['server']['cache_classes'] != true 
+        
+        # ロードファイルの変更確認
+#        changed = false
+#        @config['load_files'].each do |f|
+#          this_mtime = File.mtime(f[:file])
+#          if this_mtime > f[:mtime]
+#            f[:mtime] = this_mtime
+#            changed = true
+#          end
+#        end
+        
+        # 変更していたら
+#        changed = nil
+#        if changed
+        if @server_reload
+          @server_reload = nil
+          
+          puts "-- stopping server"
+          
+          # 強制的に接続しているsocketをクローズ
+          cs_logger.debug "socket_list.keys:#{socket_list.keys.inspect}"
+          socket_list.keys.each do |sk|
+            cs_logger.debug "sk:#{socket_list[sk].inspect}"
+            socket_list[sk].close if ! socket_list[sk].closed?
+            socket_list[sk]
+          end
+          
+          # サーバーを停止
+          @gserver.shutdown
+          @gserver.stop
+          while(!@gserver.stopped?) do
+           sleep 1
+            puts "waiting... #{@gserver.stopped?}"
+            cs_logger.debug "waiting... #{@gserver.stopped?} #{@gserver.connections}"
+          end
+          
+          @gserver = nil
+          
+          puts "-- stopped server"
+          
+          # GCを行う
+          GC.start
+          
+          # サーバーファイルを読み直し
+          puts "-- reload classes"
+          tmp_verbose = $VERBOSE
+          $VERBOSE = nil
+
+          # serverファイル名一覧を取得
+          load_files = []
+          glob_str = 'dango/server/*.rb'
+          Dir.glob(glob_str) do |srv_file|
+            load_files.push({:file=>srv_file, :mtime=>File.mtime(srv_file)})
+          end
+
+          # ファイル名順にソート
+          load_files = load_files.sort_by{|f| f[:file] }
+          load_files.each do |f|
+            begin
+              load f[:file]
+            rescue Exception
+              p $!.class
+              p $!.message
+              p $!.backtrace
+            end
+          end
+
+          $VERBOSE = tmp_verbose
+          
+          # サーバーを再度起動
+          puts "-- start server"
+          server_start() # サーバー開始
+        end
+#      end
+    rescue Exception
+      cs_logger.error "#{$!.class}:#{$!.message}\n#{$!.backtrace.pretty_inspect}"
+    end
+  end
+  
+  # gserver接続開始処理
+  def connecting(sock)
+    cs_logger.debug "connecting:sock=#{sock}"
+  end
+  
+  # gserver接続開始処理
+  def disconnecting(port)
+    cs_logger.debug "disconnecting:port=#{port}"
+  end
+  
+  # gserverのserveメソッド：スレッド開始処理
+  def thread_main(sock)
+    cs_logger.debug "thread_main:start"
+    cs_logger.debug "#{sock} is accepted. key=#{Thread.current.object_id}"
+    
+    begin
+      session[:session_id] = Thread.current.object_id
+      socket_list.add(session[:session_id], sock)
+      mutex_socket_list.add(session[:session_id])
+      
+      sock.binmode
+      sock.sync = true
+      
+      cs_connect() # 接続時メソッド呼び出し
+      
+      # メインループ入り
+      loop do
+        if sock.closed?
+          cs_logger.debug "#{sock.inspect}:sock is closed..."
+          break
+        end
+        
+        cs_logger.debug "start cs_receive_data"
+        ret_obj = nil
+#        mutex_socket_list.synchronize(session[:session_id]) do
+          ret_obj = cs_receive_data(sock) # データ受信処理
+#        end
+        cs_logger.debug "finished cs_receive_data"
+        
+        if ret_obj != {} # 受信データがあれば
+          if !(ret_obj && ret_obj["action"]) # actionが無い場合はエラー
+            cs_logger.error "no action error:#{ret_obj.inspect}"
+            raise(DangoFrameworkError, "no action error") 
+          end
+          
+          # アクション名
+          action_name = ret_obj["action"].to_s
+          cs_logger.debug "action_name=#{action_name}"
+          
+          if action_name == 'monitor_all_info' # メンテナンスアクション名なら
+            cs_check_monitor_error(sock, "return_monitor_all_info")
+            cs_server_monitor_all_info()
+          elsif action_name == 'monitor_server_reload' # メンテナンスアクション名なら
+            cs_check_monitor_error(sock, "return_monitor_server_reload")
+            cs_server_monitor_server_reload()
+          else # メンテナンスコマンド以外のユーザーアクション名なら
+            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')}"
+            end
+          end
+        end
+      end
+      
+    rescue DangoFrameworkConnectionError
+      @recv_fail_count += 1 if @recv_fail_count # 受信失敗回数カウント
+      cs_logger.debug "connection error. \n#{error_message($!, 'u')}"
+      
+    rescue Exception
+      cs_logger.error "#{error_message($!, 'u')}"
+      
+    ensure
+      cs_logger.debug "#{sock.inspect} is gone"
+      
+      begin
+        cs_close() # 接続解除時に呼び出されるメソッド
+      rescue
+        cs_logger.error "#{error_message($!, 'u')}"
+      ensure
+        socket_list.delete(Thread.current.object_id) # ソケットリストから削除
+        sock.close                       # ソケットを閉じる
+        
+        cs_logger.debug "#{sock.inspect} is gone 2"
+      end
+      
+    end
+  end
+  
+  # 各種サーバー仕様の変数設定
+  def set_server_variables() 
+    # 変数の初期設定
+    @connection_server_port            = @config['network']['port'] || 15000
+    @connection_server_host            = @config['server']['host'] || "localhost"
+    @connection_server_max_connections = @config['server']['max_connections'] || 10
+    @log_file                          = @config['server']['log_file'] || ""
+    
+    log_level_hash = {
+      "FATAL" => Logger::FATAL, 
+      "ERROR" => Logger::ERROR, 
+      "WARN"  => Logger::WARN, 
+      "INFO"  => Logger::INFO, 
+      "DEBUG" => Logger::DEBUG, 
+    }
+    @log_level = log_level_hash.find do |level|
+      level == @config['server']['log_level']
+    end
+    @log_level = @connection_server_log_level || Logger::DEBUG
+    
+    @start_time = Time.now # サーバー起動時間
+    @recv_count = 0 # 受信回数
+    @send_count = 0 # 送信回数
+    @recv_fail_count = 0 # 受信失敗回数
+    @send_fail_count = 0 # 送信失敗回数
+  end
+  
+  def cs_server_init # 初期設定
+  end
+  
+  # コンフィグのshared_database_managerによる使用クラスの選択
+  def select_shared_database_manager()
+    if @config['server']['shared_database_manager'] == 'MemoryStore'
+      SharedMemoryStore.new
+    else
+      SharedMemoryStore.new
+    end
+  end
+  
+  # 共有メモリ
+  def shared_init
+    @shared = select_shared_database_manager()
+  end
+  def shared
+    @shared
+  end
+  
+  # 通知共有メモリ
+  
+  def notice_shared_init
+#   @notice_shared = NoticeShared.new(self)
+    @notice_shared = select_shared_database_manager()
+    
+    class << @notice_shared ## 各種メソッド追加
+      def initialize2(parent)
+        @parent = parent
+        self[:notice_list] = {}
+      end
+
+      def init_key(key) # そのキーを作成する
+        if self[:notice_list].has_key?(key) || key == :notice_list # キーがすでにあるか予約語なら
+          raise(DangoFrameworkError, "notice_list already has key. key=#{key.inspect}")
+        end
+        
+        self.transaction(:notice_list) do |notice_list|
+          notice_list[key] = []
+          notice_list
+        end
+      end
+      
+      def add_connectable(key, session_id) # 接続許可にする
+        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
+        end
+      end
+      
+      def remove_connectable(key, session_id) # 接続を不許可にする
+        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
+        end
+      end
+      
+      def get_connectables(key) # 接続許可一覧を返す
+        if !self[:notice_list].has_key?(key) # キーがなければ
+          raise(DangoFrameworkError, "notice_list not has key. key=#{key.inspect}")
+        end
+        
+        self[:notice_list][key]
+      end
+      
+      def notice_change(key, value) # 変更時に通知する変更
+        if !self[:notice_list].has_key?(key) # キーがなければ
+          raise(DangoFrameworkError, "notice_list not has key. key=#{key.inspect}")
+        end
+        
+        self[key] = value
+        
+        @parent.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)
+        end
+      end
+      
+      def not_notice_change(key, value) # 変更時に通知しない変更
+        if !self[:notice_list].has_key?(key) # キーがなければ
+          raise(DangoFrameworkError, "notice_list not has key. key=#{key.inspect}")
+        end
+        
+        self[key] = value
+      end
+      
+      def []=(key, value) # データの変更
+        if key != :notice_list && !self[:notice_list].has_key?(key) # キーがなければ
+          raise(DangoFrameworkError, "notice_list not has key. key=#{key.inspect}")
+        end
+        
+        super(key, value) # データの変更
+      end
+    end
+  end
+  
+  def notice_shared
+    @notice_shared
+  end
+  
+  # セッション
+  class Session < Hash
+  end
+  def session
+    Thread.current[:session] = Session.new if !Thread.current[:session]
+    Thread.current[:session]
+  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
+  
+  # ソケット毎用の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
+  end
+  
+  # 接続時に呼び出されるメソッド
+  def cs_connect; end
+  
+  # 接続解除時に呼び出されるメソッド
+  def cs_close; end
+  
+  
+  # サーバーの暗号化処理
+  def cs_server_send_encrypt(str) # 継承用
+    str
+  end
+  def cs_send_encrypt(str) # フレームワークから呼ばれる部分
+    cs_server_send_encrypt(str)
+  end
+  
+  # サーバーの復号化処理
+  def cs_server_receive_decrypt(str) # 継承用
+    str
+  end
+  def cs_receive_decrypt(str) # フレームワークから呼ばれる部分
+    cs_server_receive_decrypt(str)
+  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})"
+    
+    timeout = options[:timeout] || 6
+    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?
+    
+    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
+    
+    # データ送信時にクライアントからのレスポンスを確認する（Flashのバグらしきもの対策）
+    if notice_name.to_s =~ /^return_/
+      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"
+    else
+      Thread.start do
+        mutex_socket_list.synchronize(session_id) do
+          send_receive_shared[notice_name] = nil
+          
+          receive_thread = nil
+          end_reserved_time = Time.now + timeout
+          
+          # 戻ってきたデータのチェック
+          notice_name_sym = (notice_name.class == Symbol) ? (":"+notice_name.to_s) : ('"'+notice_name+'"')
+          instance_method_name = "cs_receive_response_#{notice_name}"
+          expr = <<-EOF
+            def self.#{instance_method_name}(ret_obj)
+              cs_logger.debug "ret_obj:" + ret_obj.inspect
+              send_receive_shared[#{notice_name_sym}] = ret_obj
+            end
+            cs_logger.debug "defined:#{instance_method_name}"
+          EOF
+          instance_eval expr
+          
+          # タイムアウトチェック
+          (timeout.to_f / SendReceiveSleepIntervalSec).to_i.times do
+            raise(DangoFrameworkTimeoutError, "timeout:#{notice_name}") if Time.now > end_reserved_time
+            
+            # 送信スレッドが開始していなければ開始
+            if !receive_thread
+              receive_thread = Thread.start do
+                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"
+              end
+            end
+            
+            # 戻ってきたデータがあれば
+            if send_receive_shared[notice_name]
+              cs_logger.debug "notice_name:#{send_receive_shared[notice_name].inspect}"
+              break 
+            end
+            
+            cs_logger.debug "sleep:#{SendReceiveSleepIntervalSec}"
+            sleep SendReceiveSleepIntervalSec # スリープ
+          end
+          
+          if !send_receive_shared[notice_name] # 戻ってきたデータがあるかどうかチェック
+            raise(DangoFrameworkError, "received data is none") 
+          end
+          
+          remove_method(instance_method_name) # 定義したインスタンスメソッドを削除しておく
+        end
+      end
+    end
+    
+    self
+  end
+  
+  # メンテナンスコマンド：エラーの場合
+  def cs_check_monitor_error(sock, return_command)
+    peerhost, peeraddr = sock.peeraddr[2, 2]
+    backdoor_host = @config['server']['backdoor_host']
+    match = false
+    if peerhost == backdoor_host # ホスト名で書いてある時の一致確認
+      match = true
+    else
+      begin # IPアドレスの一致確認
+        match = true if IPAddr.new(peeraddr) == IPAddr.new(backdoor_host) 
+      rescue
+      end
+    end
+    
+    if !match
+      send_obj = {'code'=>1, 'message'=>"error your ip address"}
+      cs_server_send_data(session[:session_id], return_command, send_obj, :type=>2)
+      raise(DangoFrameworkError)
+    end
+  end
+  
+  # メンテナンスコマンド：サーバーからクライアントへのデータ送信
+  def cs_server_monitor_all_info()
+    all_info = {
+      'shareds'     => shared.to_hash,
+      'socket_list' => socket_list.keys,
+      
+      'server_start_time' => @start_time.strftime("%Y-%m-%d %H:%M:%S"),
+      'up_time' => Time.now - @start_time,
+      
+      'recv_count' => @recv_count, # 受信回数
+      'send_count' => @send_count, # 送信回数
+      'recv_fail_count' => @recv_fail_count, # 受信失敗回数
+      'send_fail_count' => @send_fail_count, # 送信失敗回数
+#      'dummy' => "dummy "*1000, # ダミー情報
+    }
+    
+    send_obj = {'code'=>0, 'all_info'=>all_info}
+    cs_server_send_data(session[:session_id], 'return_monitor_all_info', send_obj, :type=>2)
+  end
+  
+  # メンテナンスコマンド：サーバーからクライアントへのデータ送信
+  def cs_server_monitor_server_reload()
+    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)
+  end
+  
+  # 必要に応じて追加するメソッド
+  def method_missing(name, *args)
+    if name.to_s =~ /^cs_receive_action_notice_shared_(.+)/ # 共有メモリ変更通知なら
+      key = $1
+      method_action_notice_shared(key, name, *args)
+    else
+#      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}"
+    send_obj = args[0]
+    notice_shared.notice_change(key.to_sym, send_obj) 
+  end
+  
+end
+