Improved stability of test results.

[shogi-server/shogi-server.git] / shogi-server

diff --git a/shogi-server b/shogi-server
index 4b048bd..7f6d068 100755 (executable)
--- a/shogi-server
+++ b/shogi-server
@@ -1,25 +1,39 @@
 #! /usr/bin/env ruby
 #! /usr/bin/env ruby

-## $Id$
-
-## Copyright (C) 2004 NABEYA Kenichi (aka nanami@2ch)
-## Copyright (C) 2007-2008 Daigo Moriwaki (daigo at debian dot org)
-##
-## This program is free software; you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation; either version 2 of the License, or
-## (at your option) any later version.
-##
-## This program is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-## GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License
-## along with this program; if not, write to the Free Software
-## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# $Id$
+#
+# Author:: NABEYA Kenichi, Daigo Moriwaki
+# Homepage:: http://sourceforge.jp/projects/shogi-server/
+#
+#--
+# Copyright (C) 2004 NABEYA Kenichi (aka nanami@2ch)
+# Copyright (C) 2007-2008 Daigo Moriwaki (daigo at debian dot org)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#++
+#
+#

 
 

+$topdir = nil
+$league = nil
+$logger = nil
+$config = nil

 $:.unshift File.dirname(__FILE__)
 require 'shogi_server'
 $:.unshift File.dirname(__FILE__)
 require 'shogi_server'

+require 'shogi_server/config'
+require 'shogi_server/util'
+require 'tempfile'

 
 #################################################
 # MAIN
 
 #################################################
 # MAIN


@@ -27,6 +41,12 @@ require 'shogi_server'
 
 ShogiServer.reload
 
 
 ShogiServer.reload
 

+# Return
+#   - a received string
+#   - :timeout
+#   - :exception
+#   - nil when a socket is closed
+#

 def gets_safe(socket, timeout=nil)
   if r = select([socket], nil, nil, timeout)
     return r[0].first.gets
 def gets_safe(socket, timeout=nil)
   if r = select([socket], nil, nil, timeout)
     return r[0].first.gets


@@ -68,6 +88,7 @@ RELEASE
 
 REVISION
        #{ShogiServer::Revision}
 
 REVISION
        #{ShogiServer::Revision}

+

 EOM
 end
 
 EOM
 end
 


@@ -79,6 +100,9 @@ end
 def log_message(str)
   $logger.info(str)
 end
 def log_message(str)
   $logger.info(str)
 end

+def log_info(str)
+  log_message(str)
+end

 
 def log_warning(str)
   $logger.warn(str)
 
 def log_warning(str)
   $logger.warn(str)


@@ -89,12 +113,16 @@ def log_error(str)
 end
 
 
 end
 
 

+# Parse command line options. Return a hash containing the option strings
+# where a key is the option name without the first two slashes. For example,
+# {"pid-file" => "foo.pid"}.
+#

 def parse_command_line
   options = Hash::new
   parser = GetoptLong.new(
 def parse_command_line
   options = Hash::new
   parser = GetoptLong.new(

-    ["--daemon",   GetoptLong::REQUIRED_ARGUMENT],
-    ["--pid-file", GetoptLong::REQUIRED_ARGUMENT],
-    ["--player-log-dir", GetoptLong::REQUIRED_ARGUMENT])
+    ["--daemon",            GetoptLong::REQUIRED_ARGUMENT],
+    ["--pid-file",          GetoptLong::REQUIRED_ARGUMENT],
+    ["--player-log-dir",    GetoptLong::REQUIRED_ARGUMENT])

   parser.quiet = true
   begin
     parser.each_option do |name, arg|
   parser.quiet = true
   begin
     parser.each_option do |name, arg|


@@ -108,6 +136,70 @@ def parse_command_line
   return options
 end
 
   return options
 end
 

+# Check command line options.
+# If any of them is invalid, exit the process.
+#
+def check_command_line
+  if (ARGV.length != 2)
+    usage
+    exit 2
+  end
+
+  if $options["daemon"]
+    $options["daemon"] = File.expand_path($options["daemon"], File.dirname(__FILE__))
+    unless is_writable_dir? $options["daemon"]
+      usage
+      $stderr.puts "Can not create a file in the daemon directory: %s" % [$options["daemon"]]
+      exit 5
+    end
+  end
+
+  $topdir = $options["daemon"] || File.expand_path(File.dirname(__FILE__))
+
+  if $options["player-log-dir"]
+    $options["player-log-dir"] = File.expand_path($options["player-log-dir"], $topdir)
+    unless is_writable_dir?($options["player-log-dir"])
+      usage
+      $stderr.puts "Can not write a file in the player log dir: %s" % [$options["player-log-dir"]]
+      exit 3
+    end 
+  end
+
+  if $options["pid-file"] 
+    $options["pid-file"] = File.expand_path($options["pid-file"], $topdir)
+    unless ShogiServer::is_writable_file? $options["pid-file"]
+      usage
+      $stderr.puts "Can not create the pid file: %s" % [$options["pid-file"]]
+      exit 4
+    end
+  end
+
+  if $options["floodgate-history"]
+    $stderr.puts "WARNING: --floodgate-history has been deprecated."
+    $options["floodgate-history"] = nil
+  end
+end
+
+# See if a file can be created in the directory.
+# Return true if a file is writable in the directory, otherwise false.
+#
+def is_writable_dir?(dir)
+  unless File.directory? dir
+    return false
+  end
+
+  result = true
+
+  begin
+    temp_file = Tempfile.new("dummy-shogi-server", dir)
+    temp_file.close true
+  rescue
+    result = false
+  end
+
+  return result
+end
+

 def write_pid_file(file)
   open(file, "w") do |fh|
     fh.puts "#{$$}"
 def write_pid_file(file)
   open(file, "w") do |fh|
     fh.puts "#{$$}"


@@ -137,15 +229,22 @@ def login_loop(client)
   player = login = nil
  
   while r = select([client], nil, nil, ShogiServer::Login_Time) do
   player = login = nil
  
   while r = select([client], nil, nil, ShogiServer::Login_Time) do

-    break unless str = r[0].first.gets
-    $mutex.lock # guards LEAGUE
+    str = nil
+    begin
+      break unless str = r[0].first.gets
+    rescue Exception => ex
+      # It is posssible that the socket causes an error (ex. Errno::ECONNRESET)
+      log_error("login_loop: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
+      break
+    end
+    $mutex.lock # guards $league

     begin
       str =~ /([\r\n]*)$/
       eol = $1
       if (ShogiServer::Login::good_login?(str))
         player = ShogiServer::Player::new(str, client, eol)
         login  = ShogiServer::Login::factory(str, player)
     begin
       str =~ /([\r\n]*)$/
       eol = $1
       if (ShogiServer::Login::good_login?(str))
         player = ShogiServer::Player::new(str, client, eol)
         login  = ShogiServer::Login::factory(str, player)

-        if (current_player = LEAGUE.find(player.name))
+        if (current_player = $league.find(player.name))

           if (current_player.password == player.password &&
               current_player.status != "game")
             log_message(sprintf("user %s login forcely", player.name))
           if (current_player.password == player.password &&
               current_player.status != "game")
             log_message(sprintf("user %s login forcely", player.name))


@@ -156,7 +255,7 @@ def login_loop(client)
             break
           end
         end
             break
           end
         end

-        LEAGUE.add(player)
+        $league.add(player)

         break
       else
         client.write("LOGIN:incorrect" + eol)
         break
       else
         client.write("LOGIN:incorrect" + eol)


@@ -170,7 +269,7 @@ def login_loop(client)
 end
 
 def setup_logger(log_file)
 end
 
 def setup_logger(log_file)

-  logger = Logger.new(log_file, 'daily')
+  logger = ShogiServer::Logger.new(log_file, 'daily')

   logger.formatter = ShogiServer::Formatter.new
   logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO  
   logger.datetime_format = "%Y-%m-%d %H:%M:%S"
   logger.formatter = ShogiServer::Formatter.new
   logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO  
   logger.datetime_format = "%Y-%m-%d %H:%M:%S"


@@ -185,31 +284,65 @@ def setup_watchdog_for_giant_lock
   end
 end
 
   end
 end
 

-def setup_floodgate
-  return Thread.start do 
+def floodgate_reload_log(leagues)
+  floodgate = leagues.min {|a,b| a.next_time <=> b.next_time}
+  diff = floodgate.next_time - Time.now
+  log_message("Floodgate reloaded. The next match will start at %s in %d seconds" % 
+              [floodgate.next_time, diff])
+end
+
+def setup_floodgate(game_names)
+  return Thread.start(game_names) do |game_names|

     Thread.pass
     Thread.pass

-    floodgate = ShogiServer::League::Floodgate.new(LEAGUE)
-    log_message("Flooddgate reloaded. The next match will start at %s." % 
-                [floodgate.next_time])
+    leagues = game_names.collect do |game_name|
+      ShogiServer::League::Floodgate.new($league, 
+                                         {:game_name => game_name})
+    end
+    leagues.delete_if do |floodgate|
+      ret = false
+      unless floodgate.next_time 
+        log_error("Unsupported game name: %s" % floodgate.game_name)
+        ret = true
+      end
+      ret
+    end
+    if leagues.empty?
+      log_error("No valid Floodgate game names found")
+      return # exit from this thread
+    end
+    floodgate_reload_log(leagues)

 
     while (true)
       begin
 
     while (true)
       begin

+        floodgate = leagues.min {|a,b| a.next_time <=> b.next_time}

         diff = floodgate.next_time - Time.now
         if diff > 0
         diff = floodgate.next_time - Time.now
         if diff > 0

+          floodgate_reload_log(leagues) if $DEBUG

           sleep(diff/2)
           next
         end
           sleep(diff/2)
           next
         end

-        LEAGUE.reload
-        floodgate.match_game
-        floodgate.charge
-        next_time = floodgate.next_time
+        next_array = leagues.collect do |floodgate|
+          if (floodgate.next_time - Time.now) > 0
+            [floodgate.game_name, floodgate.next_time]
+          else
+            log_message("Starting Floodgate games...: %s" % [floodgate.game_name])
+            $league.reload
+            floodgate.match_game
+            floodgate.charge
+            [floodgate.game_name, floodgate.next_time] # next_time has been updated
+          end
+        end

         $mutex.synchronize do
           log_message("Reloading source...")
           ShogiServer.reload
         end
         $mutex.synchronize do
           log_message("Reloading source...")
           ShogiServer.reload
         end

-        floodgate = ShogiServer::League::Floodgate.new(LEAGUE, next_time)
-        log_message("Floodgate will start the next match at %s." % 
-                    [floodgate.next_time])
+        # Regenerate floodgate instances after ShogiServer.realod
+        leagues = next_array.collect do |game_name, next_time|
+          floodgate = ShogiServer::League::Floodgate.new($league, 
+                                                         {:game_name => game_name,
+                                                          :next_time => next_time})
+        end
+        floodgate_reload_log(leagues)

       rescue Exception => ex 
         # ignore errors
         log_error("[in Floodgate's thread] #{ex} #{ex.backtrace}")
       rescue Exception => ex 
         # ignore errors
         log_error("[in Floodgate's thread] #{ex} #{ex.backtrace}")


@@ -220,40 +353,19 @@ end
 
 def main
   
 
 def main
   

-  #[ShogiServer::League::Floodgate, ShogiServer::Pairing].each do |klass|
-  #  Dependencies.unloadable klass
-  #end
-
-  setup_watchdog_for_giant_lock
-

   $options = parse_command_line
   $options = parse_command_line

-  if (ARGV.length != 2)
-    usage
-    exit 2
-  end
-  if $options["player-log-dir"]
-    $options["player-log-dir"] = File.expand_path($options["player-log-dir"])
-  end
-  if $options["player-log-dir"] && 
-     !File.directory?($options["player-log-dir"])
-    usage
-    exit 3
-  end
+  check_command_line
+  $config = ShogiServer::Config.new $options

 
 

-  LEAGUE.event = ARGV.shift
-  port = ARGV.shift
+  $league = ShogiServer::League.new($topdir)

 
 

-  dir = $options["daemon"]
-  dir = File.expand_path(dir) if dir
-  if dir && ! File.exist?(dir)
-    FileUtils.mkdir(dir)
-  end
+  $league.event = ARGV.shift
+  port = ARGV.shift

 
 

-  log_file = dir ? File.join(dir, "shogi-server.log") : STDOUT
+  log_file = $options["daemon"] ? File.join($options["daemon"], "shogi-server.log") : STDOUT

   $logger = setup_logger(log_file)
 
   $logger = setup_logger(log_file)
 

-  LEAGUE.dir = dir || File.dirname(__FILE__)
-  LEAGUE.setup_players_database
+  $league.dir = $topdir

 
   config = {}
   config[:Port]       = port
 
   config = {}
   config[:Port]       = port


@@ -261,30 +373,35 @@ def main
   config[:Logger]     = $logger
 
   fg_thread = nil
   config[:Logger]     = $logger
 
   fg_thread = nil

+

   config[:StartCallback] = Proc.new do
   config[:StartCallback] = Proc.new do

+    srand

     if $options["pid-file"]
       write_pid_file($options["pid-file"])
     end
     if $options["pid-file"]
       write_pid_file($options["pid-file"])
     end

-    fg_thread = setup_floodgate
+    setup_watchdog_for_giant_lock
+    $league.setup_players_database
+    fg_thread = setup_floodgate(["floodgate-900-0", "floodgate-3600-0"])

   end
 
   config[:StopCallback] = Proc.new do
     if $options["pid-file"]
   end
 
   config[:StopCallback] = Proc.new do
     if $options["pid-file"]

-      FileUtils.rm(pid_file, :force => true)
+      FileUtils.rm($options["pid-file"], :force => true)

     end
   end
 
     end
   end
 

+  srand

   server = WEBrick::GenericServer.new(config)
   ["INT", "TERM"].each do |signal| 
     trap(signal) do
   server = WEBrick::GenericServer.new(config)
   ["INT", "TERM"].each do |signal| 
     trap(signal) do

-      LEAGUE.shutdown

       server.shutdown
       fg_thread.kill if fg_thread
     end
   end
       server.shutdown
       fg_thread.kill if fg_thread
     end
   end

-  trap("HUP") do
-    LEAGUE.shutdown
-    Dependencies.clear
+  unless (RUBY_PLATFORM.downcase =~ /mswin|mingw|cygwin|bccwin/)
+    trap("HUP") do
+      Dependencies.clear
+    end

   end
   $stderr.puts("server started as a deamon [Revision: #{ShogiServer::Revision}]") if $options["daemon"] 
   log_message("server started [Revision: #{ShogiServer::Revision}]")
   end
   $stderr.puts("server started as a deamon [Revision: #{ShogiServer::Revision}]") if $options["daemon"] 
   log_message("server started [Revision: #{ShogiServer::Revision}]")


@@ -306,7 +423,7 @@ def main
           player.game.kill(player)
         end
         player.finish # socket has been closed
           player.game.kill(player)
         end
         player.finish # socket has been closed

-        LEAGUE.delete(player)
+        $league.delete(player)

         log_message(sprintf("user %s logout", player.name))
       ensure
         $mutex.unlock
         log_message(sprintf("user %s logout", player.name))
       ensure
         $mutex.unlock


@@ -322,9 +439,12 @@ if ($0 == __FILE__)
   Thread.abort_on_exception = $DEBUG ? true : false
 
   begin
   Thread.abort_on_exception = $DEBUG ? true : false
 
   begin

-  LEAGUE = ShogiServer::League::new

     main
   rescue Exception => ex
     main
   rescue Exception => ex

-    log_error("main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
+    if $logger
+      log_error("main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
+    else
+      $stderr.puts "main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
+    end

   end
 end
   end
 end