shogi-server

   1 #! /usr/bin/env ruby
   2 # $Id$
   3 #
   4 # Author:: NABEYA Kenichi, Daigo Moriwaki
   5 # Homepage:: http://sourceforge.jp/projects/shogi-server/
   6 #
   7 #--
   8 # Copyright (C) 2004 NABEYA Kenichi (aka nanami@2ch)
   9 # Copyright (C) 2007-2008 Daigo Moriwaki (daigo at debian dot org)
  10 #
  11 # This program is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation; either version 2 of the License, or
  14 # (at your option) any later version.
  15 #
  16 # This program is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 # GNU General Public License for more details.
  20 #
  21 # You should have received a copy of the GNU General Public License
  22 # along with this program; if not, write to the Free Software
  23 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24 #++
  25 #
  26 #
  27
  28 $topdir = nil
  29 $league = nil
  30 $logger = nil
  31 $config = nil
  32 $:.unshift File.dirname(__FILE__)
  33 require 'shogi_server'
  34 require 'shogi_server/config'
  35 require 'shogi_server/util'
  36 require 'tempfile'
  37
  38 #################################################
  39 # MAIN
  40 #
  41
  42 ShogiServer.reload
  43
  44 def gets_safe(socket, timeout=nil)
  45   if r = select([socket], nil, nil, timeout)
  46     return r[0].first.gets
  47   else
  48     return :timeout
  49   end
  50 rescue Exception => ex
  51   log_error("gets_safe: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
  52   return :exception
  53 end
  54
  55 def usage
  56     print <<EOM
  57 NAME
  58         shogi-server - server for CSA server protocol
  59
  60 SYNOPSIS
  61         shogi-server [OPTIONS] event_name port_number
  62
  63 DESCRIPTION
  64         server for CSA server protocol
  65
  66 OPTIONS
  67         --pid-file file
  68                 specify filename for logging process ID
  69         --daemon dir
  70                 run as a daemon. Log files will be put in dir.
  71         --player-log-dir dir
  72                 log network messages for each player. Log files
  73                 will be put in the dir.
  74
  75 LICENSE
  76         GPL versoin 2 or later
  77
  78 SEE ALSO
  79
  80 RELEASE
  81         #{ShogiServer::Release}
  82
  83 REVISION
  84         #{ShogiServer::Revision}
  85
  86 EOM
  87 end
  88
  89
  90 def log_debug(str)
  91   $logger.debug(str)
  92 end
  93
  94 def log_message(str)
  95   $logger.info(str)
  96 end
  97 def log_info(str)
  98   log_message(str)
  99 end
 100
 101 def log_warning(str)
 102   $logger.warn(str)
 103 end
 104
 105 def log_error(str)
 106   $logger.error(str)
 107 end
 108
 109
 110 # Parse command line options. Return a hash containing the option strings
 111 # where a key is the option name without the first two slashes. For example,
 112 # {"pid-file" => "foo.pid"}.
 113 #
 114 def parse_command_line
 115   options = Hash::new
 116   parser = GetoptLong.new(
 117     ["--daemon",            GetoptLong::REQUIRED_ARGUMENT],
 118     ["--pid-file",          GetoptLong::REQUIRED_ARGUMENT],
 119     ["--player-log-dir",    GetoptLong::REQUIRED_ARGUMENT])
 120   parser.quiet = true
 121   begin
 122     parser.each_option do |name, arg|
 123       name.sub!(/^--/, '')
 124       options[name] = arg.dup
 125     end
 126   rescue
 127     usage
 128     raise parser.error_message
 129   end
 130   return options
 131 end
 132
 133 # Check command line options.
 134 # If any of them is invalid, exit the process.
 135 #
 136 def check_command_line
 137   if (ARGV.length != 2)
 138     usage
 139     exit 2
 140   end
 141
 142   if $options["daemon"]
 143     $options["daemon"] = File.expand_path($options["daemon"], File.dirname(__FILE__))
 144     unless is_writable_dir? $options["daemon"]
 145       usage
 146       $stderr.puts "Can not create a file in the daemon directory: %s" % [$options["daemon"]]
 147       exit 5
 148     end
 149   end
 150
 151   $topdir = $options["daemon"] || File.expand_path(File.dirname(__FILE__))
 152
 153   if $options["player-log-dir"]
 154     $options["player-log-dir"] = File.expand_path($options["player-log-dir"], $topdir)
 155     unless is_writable_dir?($options["player-log-dir"])
 156       usage
 157       $stderr.puts "Can not write a file in the player log dir: %s" % [$options["player-log-dir"]]
 158       exit 3
 159     end
 160   end
 161
 162   if $options["pid-file"]
 163     $options["pid-file"] = File.expand_path($options["pid-file"], $topdir)
 164     unless ShogiServer::is_writable_file? $options["pid-file"]
 165       usage
 166       $stderr.puts "Can not create the pid file: %s" % [$options["pid-file"]]
 167       exit 4
 168     end
 169   end
 170
 171   if $options["floodgate-history"]
 172     $stderr.puts "WARNING: --floodgate-history has been deprecated."
 173     $options["floodgate-history"] = nil
 174   end
 175 end
 176
 177 # See if a file can be created in the directory.
 178 # Return true if a file is writable in the directory, otherwise false.
 179 #
 180 def is_writable_dir?(dir)
 181   unless File.directory? dir
 182     return false
 183   end
 184
 185   result = true
 186
 187   begin
 188     temp_file = Tempfile.new("dummy-shogi-server", dir)
 189     temp_file.close true
 190   rescue
 191     result = false
 192   end
 193
 194   return result
 195 end
 196
 197 def write_pid_file(file)
 198   open(file, "w") do |fh|
 199     fh.puts "#{$$}"
 200   end
 201 end
 202
 203 def mutex_watchdog(mutex, sec)
 204   sec = 1 if sec < 1
 205   queue = []
 206   while true
 207     if mutex.try_lock
 208       queue.clear
 209       mutex.unlock
 210     else
 211       queue.push(Object.new)
 212       if queue.size > sec
 213         # timeout
 214         log_error("mutex watchdog timeout: %d sec" % [sec])
 215         queue.clear
 216       end
 217     end
 218     sleep(1)
 219   end
 220 end
 221
 222 def login_loop(client)
 223   player = login = nil
 224
 225   while r = select([client], nil, nil, ShogiServer::Login_Time) do
 226     str = nil
 227     begin
 228       break unless str = r[0].first.gets
 229     rescue Exception => ex
 230       # It is posssible that the socket causes an error (ex. Errno::ECONNRESET)
 231       log_error("login_loop: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
 232       break
 233     end
 234     $mutex.lock # guards $league
 235     begin
 236       str =~ /([\r\n]*)$/
 237       eol = $1
 238       if (ShogiServer::Login::good_login?(str))
 239         player = ShogiServer::Player::new(str, client, eol)
 240         login  = ShogiServer::Login::factory(str, player)
 241         if (current_player = $league.find(player.name))
 242           if (current_player.password == player.password &&
 243               current_player.status != "game")
 244             log_message(sprintf("user %s login forcely", player.name))
 245             current_player.kill
 246           else
 247             login.incorrect_duplicated_player(str)
 248             player = nil
 249             break
 250           end
 251         end
 252         $league.add(player)
 253         break
 254       else
 255         client.write("LOGIN:incorrect" + eol)
 256         client.write("type 'LOGIN name password' or 'LOGIN name password x1'" + eol) if (str.split.length >= 4)
 257       end
 258     ensure
 259       $mutex.unlock
 260     end
 261   end                       # login loop
 262   return [player, login]
 263 end
 264
 265 def setup_logger(log_file)
 266   logger = ShogiServer::Logger.new(log_file, 'daily')
 267   logger.formatter = ShogiServer::Formatter.new
 268   logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO
 269   logger.datetime_format = "%Y-%m-%d %H:%M:%S"
 270   return logger
 271 end
 272
 273 def setup_watchdog_for_giant_lock
 274   $mutex = Mutex::new
 275   Thread::start do
 276     Thread.pass
 277     mutex_watchdog($mutex, 10)
 278   end
 279 end
 280
 281 def floodgate_reload_log(leagues)
 282   floodgate = leagues.min {|a,b| a.next_time <=> b.next_time}
 283   diff = floodgate.next_time - Time.now
 284   log_message("Floodgate reloaded. The next match will start at %s in %d seconds" %
 285               [floodgate.next_time, diff])
 286 end
 287
 288 def setup_floodgate(game_names)
 289   return Thread.start(game_names) do |game_names|
 290     Thread.pass
 291     leagues = game_names.collect do |game_name|
 292       ShogiServer::League::Floodgate.new($league,
 293                                          {:game_name => game_name})
 294     end
 295     leagues.delete_if do |floodgate|
 296       ret = false
 297       unless floodgate.next_time
 298         log_error("Unsupported game name: %s" % floodgate.game_name)
 299         ret = true
 300       end
 301       ret
 302     end
 303     if leagues.empty?
 304       log_error("No valid Floodgate game names found")
 305       return # exit from this thread
 306     end
 307     floodgate_reload_log(leagues)
 308
 309     while (true)
 310       begin
 311         floodgate = leagues.min {|a,b| a.next_time <=> b.next_time}
 312         diff = floodgate.next_time - Time.now
 313         if diff > 0
 314           floodgate_reload_log(leagues) if $DEBUG
 315           sleep(diff/2)
 316           next
 317         end
 318         next_array = leagues.collect do |floodgate|
 319           if (floodgate.next_time - Time.now) > 0
 320             [floodgate.game_name, floodgate.next_time]
 321           else
 322             log_message("Starting Floodgate games...: %s" % [floodgate.game_name])
 323             $league.reload
 324             floodgate.match_game
 325             floodgate.charge
 326             [floodgate.game_name, floodgate.next_time] # next_time has been updated
 327           end
 328         end
 329         $mutex.synchronize do
 330           log_message("Reloading source...")
 331           ShogiServer.reload
 332         end
 333         # Regenerate floodgate instances after ShogiServer.realod
 334         leagues = next_array.collect do |game_name, next_time|
 335           floodgate = ShogiServer::League::Floodgate.new($league,
 336                                                          {:game_name => game_name,
 337                                                           :next_time => next_time})
 338         end
 339         floodgate_reload_log(leagues)
 340       rescue Exception => ex
 341         # ignore errors
 342         log_error("[in Floodgate's thread] #{ex} #{ex.backtrace}")
 343       end
 344     end
 345   end
 346 end
 347
 348 def main
 349
 350   $options = parse_command_line
 351   check_command_line
 352   $config = ShogiServer::Config.new $options
 353
 354   $league = ShogiServer::League.new($topdir)
 355
 356   $league.event = ARGV.shift
 357   port = ARGV.shift
 358
 359   log_file = $options["daemon"] ? File.join($options["daemon"], "shogi-server.log") : STDOUT
 360   $logger = setup_logger(log_file)
 361
 362   $league.dir = $topdir
 363
 364   config = {}
 365   config[:Port]       = port
 366   config[:ServerType] = WEBrick::Daemon if $options["daemon"]
 367   config[:Logger]     = $logger
 368
 369   fg_thread = nil
 370
 371   config[:StartCallback] = Proc.new do
 372     srand
 373     if $options["pid-file"]
 374       write_pid_file($options["pid-file"])
 375     end
 376     setup_watchdog_for_giant_lock
 377     $league.setup_players_database
 378     fg_thread = setup_floodgate(["floodgate-900-0", "floodgate-3600-0"])
 379   end
 380
 381   config[:StopCallback] = Proc.new do
 382     if $options["pid-file"]
 383       FileUtils.rm($options["pid-file"], :force => true)
 384     end
 385   end
 386
 387   srand
 388   server = WEBrick::GenericServer.new(config)
 389   ["INT", "TERM"].each do |signal|
 390     trap(signal) do
 391       server.shutdown
 392       fg_thread.kill if fg_thread
 393     end
 394   end
 395   unless (RUBY_PLATFORM.downcase =~ /mswin|mingw|cygwin|bccwin/)
 396     trap("HUP") do
 397       Dependencies.clear
 398     end
 399   end
 400   $stderr.puts("server started as a deamon [Revision: #{ShogiServer::Revision}]") if $options["daemon"]
 401   log_message("server started [Revision: #{ShogiServer::Revision}]")
 402
 403   server.start do |client|
 404       # client.sync = true # this is already set in WEBrick
 405       client.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
 406         # Keepalive time can be set by /proc/sys/net/ipv4/tcp_keepalive_time
 407       player, login = login_loop(client) # loop
 408       next unless player
 409
 410       log_message(sprintf("user %s login", player.name))
 411       login.process
 412       player.setup_logger($options["player-log-dir"]) if $options["player-log-dir"]
 413       player.run(login.csa_1st_str) # loop
 414       $mutex.lock
 415       begin
 416         if (player.game)
 417           player.game.kill(player)
 418         end
 419         player.finish # socket has been closed
 420         $league.delete(player)
 421         log_message(sprintf("user %s logout", player.name))
 422       ensure
 423         $mutex.unlock
 424       end
 425   end
 426 end
 427
 428
 429 if ($0 == __FILE__)
 430   STDOUT.sync = true
 431   STDERR.sync = true
 432   TCPSocket.do_not_reverse_lookup = true
 433   Thread.abort_on_exception = $DEBUG ? true : false
 434
 435   begin
 436     main
 437   rescue Exception => ex
 438     if $logger
 439       log_error("main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
 440     else
 441       $stderr.puts "main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
 442     end
 443   end
 444 end