dango 0.4.8 → 0.5.0

data/lib/dango/session_manager.rb

@@ -3,13 +3,14 @@
 # sessionとsidの管理（１セッションごとにインスタンス化される）
 class SessionManager
   MaxSidCounter = 999999
-
+  
+  # initialize
   def initialize(shared, rails_env)
     @shared = shared
     @rails_env = rails_env
     
     @session_list = {}
-    @session_mutex = Mutex.new
+    @session_mutex = DangoMutex.new(:session_mutex)
     
     @shared[:_session_manager] = {}
   end
@@ -17,26 +18,30 @@ class SessionManager
   
   # session開始
   def start_session()
-    @session_mutex.synchronize do
+    sid = nil
+    @session_mutex.timeout_sync(3, :start_session) do
       sid = generate_sid()
-      @session_list[Thread.current.object_id] = {:sid => sid}
     end
+    @session_list[Thread.current.object_id] = {:sid => sid}
   end
   
   # session終了
   def close_session(sid)
-    @session_mutex.synchronize do
+    @session_mutex.timeout_sync(3, :close_session) do
       drop_sid()
-#      @session_list[Thread.current.object_id] = nil
-      @session_list.delete(Thread.current.object_id)
     end
+#    @session_list[Thread.current.object_id] = nil
+    @session_list.delete(Thread.current.object_id)
   end
   
   # sessionへのアクセス
   def session
-    @session_mutex.synchronize do
-      @session_list[Thread.current.object_id]
-    end
+    @session_list[Thread.current.object_id]
+  end
+  
+  # session_listへのアクセス
+  def session_list
+    @session_list
   end
   
   

data/lib/dango/shared/memory_store.rb

@@ -12,7 +12,7 @@ module DangoFrameworkModule
       @config = config
       @data = {}
       @mutex = {}
-#      @mutex = Mutex.new
+#      @mutex = DangoMutex.new(:shared_mutex)
       
       @transact_key = {}
       @transact_thread = {}
@@ -42,8 +42,8 @@ module DangoFrameworkModule
         raise(DangoFrameworkException, "Shared key is not exist.")
       end
       
-#      @mutex[key].synchronize do
-      @mutex.synchronize do
+#      @mutex[key].timeout_sync(3, "transaction_old #{key}") do
+      @mutex.timeout_sync(3, "transaction_old") do
 #        data = yield(@data[key].deep_dup)
         data = yield(@data[key])
         @data[key] = data.deep_dup
@@ -66,8 +66,8 @@ module DangoFrameworkModule
         raise(DangoFrameworkException, "Shared key is not exist.")
       end
       
-      @mutex[key].synchronize do
-#      @mutex.synchronize do
+      @mutex[key].timeout_sync(3, "transaction #{key}") do
+#      @mutex.timeout_sync(3, "transaction") do
         @transact_key[Thread.current] = key # 違うスレッドからcommitできないように
         
         raise("nested transaction #{key}") if @transact_thread.has_key?(key)
@@ -148,8 +148,8 @@ module DangoFrameworkModule
 #        raise(DangoFrameworkException, "Shared key is not exist.")
       end
       
-      @mutex[key].synchronize do
-#      @mutex.synchronize do
+      @mutex[key].timeout_sync(3, "[] #{key}") do
+#      @mutex.timeout_sync(3, "[]") do
         @data[key].deep_dup
       end
     end
@@ -165,12 +165,12 @@ module DangoFrameworkModule
       
       # 未定義なら定義する
       if !@data.has_key?(key)
-        @mutex[key] = Mutex.new
+        @mutex[key] = DangoMutex.new("shared_mutex_#{key}")
       end
       
       # ロックしてデータを入れる
-      @mutex[key].synchronize do
-#      @mutex.synchronize do
+      @mutex[key].timeout_sync(3, "[]= #{key}") do
+#      @mutex.timeout_sync(3, "[]=") do
         @data[key] = value.deep_dup
       end
       

data/lib/dango/socket_list.rb

@@ -4,23 +4,23 @@
 class SocketList
   def initialize
     @sl_hash = Hash.new
-    @sl_mutex = Mutex.new
+    @sl_mutex = DangoMutex.new(:socket_list_mutex)
   end
   
   def all_sid()
-    @sl_mutex.synchronize do
+    @sl_mutex.timeout_sync(4, :all_sid) do
       @sl_hash.keys
     end
   end
   
   def delete(sid)
-    @sl_mutex.synchronize do
+    @sl_mutex.timeout_sync(4, :delete) do
       @sl_hash.delete(sid)
     end
   end
   
   def add(sid, sock)
-    @sl_mutex.synchronize do
+    @sl_mutex.timeout_sync(4, :add) do
       raise("already exist sid(#{sid.inspect})") if @sl_hash.has_key?(sid) 
       raise("sock(#{sock.inspect}) is not Socket") if sock.kind_of?(Socket)
       @sl_hash[sid] = sock
@@ -28,7 +28,7 @@ class SocketList
   end
   
   def [](sid)
-    @sl_mutex.synchronize do
+    @sl_mutex.timeout_sync(4, "[]") do
 #      raise("not exist sid(#{sid.inspect})") if ! @sl_hash.has_key?(sid) 
       return(nil) if ! @sl_hash.has_key?(sid) 
       @sl_hash[sid]

data/lib/dango/tasks/dango_rake.rb

@@ -3,251 +3,464 @@ ENV['RAILS_ENV'] = ENV['RAILS_ENV'] || 'development'
 
 require "pp"
 require "timeout"
+require "yaml"
+require "find"
 
 
-# verboseモードのフラグを立てる処理
-def check_verbose_mode()
-  $is_verbose = (ENV["verbose"] == "true" || ENV["verbose"] == "on") ? true : false
-end
+require "dango/framework_base"
+
+class DangoRakeUtil
+  CheckConnectLogFile = "log/check_dango_connect.log" # テスト接続のログ
 
-# pid保存ファイルの読み出し
-def get_dango_pid()
-  begin
-    pid = open("tmp/pids/dango.#{ENV['RAILS_ENV']}.pid", "rb"){|fh| fh.read }.to_i
-  rescue
-    pid = nil
+  include DangoUtilModule
+
+  def initialize
+    @log = ""
   end
-  puts "pid=#{pid.inspect}" if $is_verbose
-  pid
-end
+  attr_accessor(:log)
 
-# pidのプロセスがあるかどうかのチェック
-def check_exist_dango_process(pid)
-  puts "check_exist_dango_process(pid=#{pid})" if $is_verbose
-  
-  # そのpidのプロセスがあるかのチェック
-  is_pid_exist = nil
-  
-  if RUBY_PLATFORM == 'i386-mswin32'
-    # WbemからProcessIDを取得
-    require "win32ole"
+  # verboseモードのフラグを立てる処理
+  def check_verbose_mode()
+    $is_verbose = (ENV["verbose"] == "true" || ENV["verbose"] == "on") ? true : false
+  end
+
+  # 出力＋ログ
+  def puts_noverbose(str)
+    @log += "#{Time.now_to_s} #{str.to_s}\n"
+    puts str.to_s
+  end
+
+  # 出力＋ログ（verbose）
+  def puts_verbose(str)
+    @log += "#{Time.now_to_s} #{str.to_s}\n"
+    puts str.to_s if $is_verbose
+  end
+
+  # pid保存ファイルの読み出し
+  def get_dango_pid()
     begin
-      n_locator = WIN32OLE.new("WbemScripting.SWbemLocator.1")
-      n_service = n_locator.ConnectServer
+      pid = open("tmp/pids/dango.#{ENV['RAILS_ENV']}.pid", "rb"){|fh| fh.read }.to_i
     rescue
-      puts "failed connect to Wbem:#{$!.inspect}" if $is_verbose
-      return
+      pid = nil
     end
+    puts_verbose "pid=#{pid.inspect}"
+    pid
+  end
+
+  # pidのプロセスがあるかどうかのチェック
+  def check_exist_dango_process(pid)
+    puts_verbose "check_exist_dango_process(pid=#{pid})"
     
-    set = n_service.ExecQuery("select Caption, ProcessID from Win32_Process where ProcessID = #{pid}")
-    set.each do |one|
-#      puts(sprintf("Win32_Process %8d %s", one.ProcessID, one.Caption))
-      if one.ProcessID == pid
-        is_pid_exist = true
+    # そのpidのプロセスがあるかのチェック
+    is_pid_exist = nil
+    
+    if RUBY_PLATFORM == 'i386-mswin32'
+      # WbemからProcessIDを取得
+      require "win32ole"
+      begin
+        n_locator = WIN32OLE.new("WbemScripting.SWbemLocator.1")
+        n_service = n_locator.ConnectServer
+      rescue
+        puts_verbose "failed connect to Wbem:#{$!.inspect}"
+        return
+      end
+      
+      set = n_service.ExecQuery("select Caption, ProcessID from Win32_Process where ProcessID = #{pid}")
+      set.each do |one|
+        puts_verbose(sprintf("Win32_Process %8d %s", one.ProcessID, one.Caption))
+        if one.ProcessID == pid
+          is_pid_exist = true
+        end
       end
+      
+    else ## i386-mswin32以外
+      is_pid_exist = FileTest.exist?("/proc/#{pid}")
     end
     
-  else ## i386-mswin32以外
-    is_pid_exist = FileTest.exist?("/proc/#{pid}")
+    if is_pid_exist
+      puts_verbose "dango_process is exist."
+    else
+      puts_verbose "dango_process is not exist."
+    end
+    
+    is_pid_exist
   end
-  
-  if is_pid_exist
-    puts "dango_process is exist." if $is_verbose
-  else
-    puts "dango_process is not exist." if $is_verbose
+
+  # プロセス停止
+  def stop_process(pid)
+    puts_verbose "stop process (pid=#{pid})"
+    
+    if RUBY_PLATFORM == 'i386-mswin32'
+      # WbemからProcessIDを取得
+      require "win32ole"
+      begin
+        n_locator = WIN32OLE.new("WbemScripting.SWbemLocator.1")
+        n_service = n_locator.ConnectServer
+      rescue
+        puts_verbose "failed connect to Wbem:#{$!.inspect}"
+        return
+      end
+      
+      set = n_service.ExecQuery("select Caption, name, ProcessID from Win32_Process where ProcessID = '#{pid}'")
+      set.each do |process|
+        puts_verbose "stopping #{process.Caption} #{process.name} #{process.ProcessID}"
+        process.Terminate 0
+      end
+      
+    else ## i386-mswin32以外
+  #    system("kill #{pid}")
+      ret_kill = Process.kill("TERM", pid) rescue nil
+      puts_verbose "kill TERM ret_kill=#{ret_kill.inspect}"
+      
+      
+      # きちんと落ちたかチェック
+      is_kill = false
+      20.times do
+        sleep 1
+        if !File.exist?("/proc/#{pid}")
+          is_kill = true
+          break
+        end
+      end
+      
+      if !is_kill # 落ちていなければ、-9で終了
+  #      system("kill -9 #{pid}")
+        begin
+          Process.kill("KILL", pid)
+        rescue
+          puts_verbose "process pid(#{pid}) is exist. but failed kill -9 #{pid}"
+        end
+      end
+    end
   end
-  
-  is_pid_exist
-end
 
-# プロセス停止
-def stop_process(pid)
-  puts "stop process (pid=#{pid})" if $is_verbose
-  
-  if RUBY_PLATFORM == 'i386-mswin32'
-    # WbemからProcessIDを取得
-    require "win32ole"
+  # サーバーへの通信を使ったチェック
+  def check_dango_connect()
+    require 'dango/tester/dango_tester_client'
+    
+    # コンフィグから check_dango_process_cmd を取得
+    config = YAML.load(open("#{RAILS_ROOT}/config/dango/#{ENV['RAILS_ENV']}.yml", "rb"){|fh| fh.read})
+    
+    serv_info = {}
+    serv_info["host"] = config['network']['host'] || 'localhost'
+    serv_info["port"] = config['network']['port'] || 15000
+    serv_info["log_file"] = CheckConnectLogFile
+    serv_info["log_level"] = Logger::DEBUG
+    serv_info["log_max_size"] = 10000000
+    serv_info["log_shift_age"] = 1
+    
+  #  pp serv_info
+    
+    sid = nil
+    
     begin
-      n_locator = WIN32OLE.new("WbemScripting.SWbemLocator.1")
-      n_service = n_locator.ConnectServer
-    rescue
-      puts "failed connect to Wbem:#{$!.inspect}" if $is_verbose
-      return
+      tester = DangoTesterClient.new # 開始
+      tester1 = nil
+      timeout(12) do
+        tester1 = tester.new_client("tester1", serv_info) # テスター１
+        
+        10.times do |i|
+          sleep 1
+          sid = tester1.sid.deep_dup
+          tester1.logger.warn "count=#{i} sid=#{sid}"
+          break if sid
+        end
+      end
+    rescue TimeoutError
+      sid = nil
+      ret_kill "DangoTesterClient.TimeoutError" if $is_verbose
+    ensure
+      tester1.dango_client_close if tester1.respond_to?(:dango_client_close)
+      tester1 = nil
+      tester.gc_thread_stop
     end
     
-    set = n_service.ExecQuery("select Caption, name, ProcessID from Win32_Process where ProcessID = '#{pid}'")
-    set.each do |process|
-      puts "stopping #{process.Caption} #{process.name} #{process.ProcessID}" if $is_verbose
-      process.Terminate 0
+    puts_verbose "sid=#{sid.inspect}"
+    
+    if sid
+      is_alive_server = true
+    else
+      is_alive_server = false
     end
     
-  else ## i386-mswin32以外
-#    system("kill -9 #{pid}")
-    system("kill #{pid}")
+    is_alive_server
   end
-end
 
-# サーバーへの通信を使ったチェック
-def check_dango_connect()
-  require 'dango/tester/dango_tester_client'
-  
-  # コンフィグから check_dango_process_cmd を取得
-  config = YAML.load(open("config/dango/#{ENV['RAILS_ENV']}.yml", "rb"){|fh| fh.read})
-  
-  serv_info = {}
-  serv_info["host"] = config['network']['host'] || 'localhost'
-  serv_info["port"] = config['network']['port'] || 15000
-  serv_info["log_file"] = ""
-  serv_info["log_level"] = Logger::WARN
-  serv_info["log_max_size"] = 10000000
-  serv_info["log_shift_age"] = 10
+  # drbからのサーバー呼び出し
+  def drb_call(method_name, arg = nil)
+    config = YAML.load(open("#{RAILS_ROOT}/config/dango/#{ENV['RAILS_ENV']}.yml", "rb"){|fh| fh.read})
+    
+    raise("backdoor_run_drb_server is false.") if !config['server']['backdoor_run_drb_server']
+    
+    if ENV['url']
+      drb_uri = ENV['url']
+    else
+      drb_uri = config['server']['backdoor_run_drb_url']
+    end
+    puts_verbose drb_uri
+    
+    ret = nil
+    begin
+      timeout(3) do
+        drb_obj = DRbObject.new_with_uri(drb_uri)
+        ret = drb_obj.__send__(method_name.to_s, arg)
+      end
+    rescue Exception
+      raise("DRbError:#{$!.class} #{$!.message} #{$!.backtrace.pretty_inspect}")
+    end
+    ret
+  end
 
-#  pp serv_info
-  
-  tester = DangoTesterClient.new # 開始
-  
-  begin
-    tester1 = nil
-    sid = nil
-    timeout(8) do
-      tester1 = tester.new_client("tester1", serv_info) # テスター１
+  # 落ちた時の情報収集処理
+  def get_trouble_status(config, pid = nil)
+    # フォルダ作成
+    time_str = Time.now.strftime('%Y%m%d_%H%M%S')
+    dir_name = "log/#{time_str}_#{ENV['RAILS_ENV']}"
+    FileUtils.mkdir(dir_name) rescue nil
+    
+    # サーバーログの保管
+    old_file = config['server']['log_file'].to_s
+    if File.file?(old_file)
+      new_file = "#{dir_name}/#{File.basename(old_file)}"
+      puts_verbose "copy #{old_file} #{new_file}"
+      FileUtils.copy(old_file, new_file) rescue nil
+    end
+    
+    # 接続ログの保管
+    if File.file?(CheckConnectLogFile)
+      new_file = "#{dir_name}/#{File.basename(CheckConnectLogFile)}"
+      puts_verbose "copy #{CheckConnectLogFile} #{new_file}"
+      FileUtils.copy(CheckConnectLogFile, new_file) rescue nil
+    end
+    
+    # スレッド情報と排他処理情報収集
+    begin
+      open("#{dir_name}/thread_status.txt", "wb") do |fh|
+        
+        fh.puts "==== log"
+        fh.puts log
+        
+        fh.puts "==== get_process_info"
+        fh.puts get_process_info(pid)
+        
+        fh.puts "==== get_server_info"
+        fh.puts drb_call(:_monitor_get_server_info).pretty_inspect
+        
+        fh.puts "==== thread_list"
+        fh.puts drb_call(:_monitor_thread_status).pretty_inspect
+        
+        fh.puts "==== mutex_list"
+        fh.puts drb_call(:_monitor_mutex_status).pretty_inspect
+        
+        fh.puts "==== get_socket_list"
+        fh.puts drb_call(:_monitor_get_socket_list).pretty_inspect
+        
+        fh.puts "==== get_shared"
+        fh.puts drb_call(:_monitor_get_shared).pretty_inspect
+        
+      end
+    rescue Exception
+      puts_verbose "failed get thread_status."
+    end
+    
+    # モード変更
+    FileUtils.chmod_R(0777, [dir_name]) rescue nil
+    
+    # ファイルの圧縮
+    begin
+      require "zip/zip"
+      can_zip = true
+    rescue LoadError
+      can_zip = false
+    end
+    
+    if can_zip
+      outzipfile = "log/#{time_str}_#{ENV['RAILS_ENV']}.zip"
       
-      sleep 3
-      loop do
-        sid = tester1.sid
-        break if sid
-        sleep 1
+      files = []
+      Find.find(dir_name) do |filename|
+        if FileTest::readable?(filename) and FileTest::file?(filename)
+          files.push(filename)
+        end
+      end
+      
+      Zip::ZipOutputStream.open(outzipfile) do |zos|
+        files.each do |name|
+          zos.put_next_entry(name)
+          File.open(name, "rb"){|f| zos.puts(f.read) }
+        end
       end
+      
+      FileUtils.rm_f(files) rescue nil
+      FileUtils.remove_entry(dir_name, true) rescue nil
+      
+      FileUtils.chmod_R(0666, [outzipfile]) rescue nil
     end
-  rescue TimeoutError
-    sid = nil
-  ensure
-    tester1.dango_client_close if tester1.respond_to?(:dango_client_close)
-    tester1 = nil
-    tester.gc_thread_stop
-  end
-  
-  puts "sid=#{sid.inspect}" if $is_verbose
-  
-  if sid
-    is_alive_server = true
-  else
-    is_alive_server = false
+    
   end
-  
-  is_alive_server
 end
 
 
+################ rakeコマンドの指定 ##################
+
 namespace :dango do
 #  desc "make swf"
 #  task :make_swf do
-#    puts "complete make_swf." if $is_verbose
+#    dru.puts_noverbose "complete make_swf."
 #  end
 
   desc "stop dango process"
   task :stop_dango_process do
-    check_verbose_mode() # verboseモードのフラグを立てる処理
+    dru = DangoRakeUtil.new
+    dru.check_verbose_mode() # verboseモードのフラグを立てる処理
     
-    pid = get_dango_pid()
-    stop_process(pid) if pid # pidがあればプロセス停止
-    puts "complete stop dango process." if $is_verbose
+    pid = dru.get_dango_pid()
+    dru.stop_process(pid) if pid # pidがあればプロセス停止
+    dru.puts_noverbose "complete stop dango process."
   end
 
   desc "check dango process"
   task :check_dango_process do
-    check_verbose_mode() # verboseモードのフラグを立てる処理
+    dru = DangoRakeUtil.new
+    dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+    dru.puts_noverbose "check_dango_process"
     
-    pid = get_dango_pid()                                    # pidのチェック
-    is_pid_exist = check_exist_dango_process(pid)            # pidのプロセスがあるかどうかのチェック
-    is_alive_server = check_dango_connect() if is_pid_exist  # サーバーへの通信を使ったチェック
+    pid = dru.get_dango_pid()                                    # pidのチェック
+    is_pid_exist = dru.check_exist_dango_process(pid)            # pidのプロセスがあるかどうかのチェック
+    is_alive_server = dru.check_dango_connect() if is_pid_exist  # サーバーへの通信を使ったチェック
     
     # コンフィグから check_dango_process_cmd を取得
-    config = YAML.load(open("config/dango/#{ENV['RAILS_ENV']}.yml", "rb"){|fh| fh.read})
+    config = YAML.load(open("#{RAILS_ROOT}/config/dango/#{ENV['RAILS_ENV']}.yml", "rb"){|fh| fh.read})
     check_dango_process_cmd = config['server']['check_dango_process_cmd'] || nil
     
     # is_pid_existがないならcheck_dango_process_cmd実行
     if check_dango_process_cmd && (! is_alive_server) 
-      stop_process(pid) if pid # pidがあればプロセス停止
+      if pid # pidがあればプロセス停止
+        dru.get_trouble_status(config, pid) # 落ちた時の情報収集処理
+        
+        dru.stop_process(pid) 
+      end
+    end
+    
+    # テスト接続のログがあればそれを削除する
+    if File.file?(DangoRakeUtil::CheckConnectLogFile)
+      FileUtils.rm_f([DangoRakeUtil::CheckConnectLogFile])
     end
     
     # サーバーが止まっているので起動処理をかける
     if check_dango_process_cmd && ((! is_pid_exist) || (! is_alive_server)) 
-      puts "check_dango_process_cmd=#{check_dango_process_cmd}" if $is_verbose
+      dru.puts_verbose "check_dango_process_cmd=#{check_dango_process_cmd}"
+      
+      # tmp/pidsから
+      config = YAML.load(open("#{RAILS_ROOT}/config/dango/#{ENV['RAILS_ENV']}.yml", "rb"){|fh| fh.read})
+      check_dango_process_cmd = config['server']['check_dango_process_cmd'] || nil
+      
       system(check_dango_process_cmd)
     end
     
-    puts "complete check_dango_process." if $is_verbose
+    dru.puts_noverbose "complete check_dango_process."
+  end
+
+  desc "get_trouble_status"
+  task :get_trouble_status do
+    dru = DangoRakeUtil.new
+    dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+    dru.puts_noverbose "get_trouble_status"
+    
+    config = YAML.load(open("#{RAILS_ROOT}/config/dango/#{ENV['RAILS_ENV']}.yml", "rb"){|fh| fh.read})
+    pid = dru.get_dango_pid()                                    # pidのチェック
+    dru.get_trouble_status(config, pid) # 落ちた時の情報収集処理
+    dru.puts_noverbose "complete get_trouble_status."
   end
 
   namespace :monitor do
     desc "get server info"
     task :get_server_info do
-      check_verbose_mode() # verboseモードのフラグを立てる処理
-      
-      puts "server_reload"
-      require 'dango/monitor/dango_monitor_client.rb'
-      begin
-        dm = DangoMonitorClient.new()
-        pp dm.get_server_info()
-        dm.dango_client_close
-        puts "complete get_server_info."
-      rescue
-        pp $!.class
-        pp $!.message
-        pp $!.backtrace
-        puts "failed get_server_info."
+      dru = DangoRakeUtil.new
+      dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+      dru.puts_noverbose "get_server_info"
+      pp dru.drb_call(:_monitor_get_server_info)
+    end
+    
+    desc "thread_status"
+    task :thread_status do
+      dru = DangoRakeUtil.new
+      dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+      dru.puts_noverbose "thread_status"
+      pp dru.drb_call(:_monitor_thread_status)
+    end
+    
+    desc "mutex_status"
+    task :mutex_status do
+      dru = DangoRakeUtil.new
+      dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+      dru.puts_noverbose "mutex_status"
+      pp dru.drb_call(:_monitor_mutex_status)
+    end
+    
+    desc "get_shared"
+    task :get_shared do
+      dru = DangoRakeUtil.new
+      dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+      dru.puts_noverbose "get_shared"
+      pp dru.drb_call(:_monitor_get_shared)
+    end
+    
+    desc "write_shared"
+    task :write_shared do
+      dru = DangoRakeUtil.new
+      dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+      dru.puts_noverbose "write_shared"
+      key   = ENV["KEY"]
+      value = ENV["VALUE"]
+      if ! key || ! value
+        dru.puts_noverbose "please VALUE. ex. rake dango:monitor:write_shared KEY=room VALUE=true"
+        exit
       end
-      
+      pp dru.drb_call(:_monitor_write_shared, {"key"=>key, "value"=>value})
+    end
+    
+    desc "get_socket_list"
+    task :get_socket_list do
+      dru = DangoRakeUtil.new
+      dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+      dru.puts_noverbose "get_socket_list"
+      pp dru.drb_call(:_monitor_get_socket_list)
+    end
+    
+    desc "get_session_list"
+    task :get_session_list do
+      dru = DangoRakeUtil.new
+      dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+      dru.puts_noverbose "get_session_list"
+      pp dru.drb_call(:_monitor_get_session_list)
     end
     
     desc "server_reload" # サーバーのリロード処理
     task :server_reload do
-      check_verbose_mode() # verboseモードのフラグを立てる処理
-      
-      puts "server_reload"
-      require 'dango/monitor/dango_monitor_client.rb'
-      begin
-        dm = DangoMonitorClient.new()
-        pp dm.server_reload()
-        dm.dango_client_close
-        puts "complete server_reload."
-      rescue
-        pp $!.class
-        pp $!.message
-        pp $!.backtrace
-        puts "failed server_reload."
-      end
+      dru = DangoRakeUtil.new
+      dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+      dru.puts_noverbose "server_reload"
+      pp dru.drb_call(:_monitor_server_reload)
     end
     
     desc "send_system_message" # システムメッセージ配信
     task :send_system_message do
-      check_verbose_mode() # verboseモードのフラグを立てる処理
+      dru = DangoRakeUtil.new
+      dru.check_verbose_mode() # verboseモードのフラグを立てる処理
+      dru.puts_noverbose "send_system_message"
       
-      puts "send_system_message" if $is_verbose
       message_type = ENV["TYPE"]
       if ! message_type
-        puts "please type. ex. rake dango:monitor:send_system_message TYPE=down_1min"
+        dru.puts_noverbose "please type. ex. rake dango:monitor:send_system_message TYPE=down_1min"
         exit
       end
       
-      require "yaml"
-      require 'dango/monitor/dango_monitor_client.rb'
-      
       system_message = YAML.load(open("config/dango/system_message.yml", "rb"){|fh| fh.read})
       message = system_message[message_type]
       
-      begin
-        dm = DangoMonitorClient.new()
-        pp dm.send_system_message(message)
-        dm.dango_client_close
-        puts "complete send_system_message."
-      rescue
-        pp $!.class
-        pp $!.message
-        pp $!.backtrace
-        puts "failed send_system_message."
-      end
+      dru.drb_call(:_monitor_send_system_message, {"message" => message})
+      dru.puts_noverbose "complete send_system_message."
     end
     
   end