shogi-server

   1 #! /usr/bin/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-2012 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.expand_path(__FILE__)))
  33 require 'shogi_server'
  34 require 'shogi_server/config'
  35 require 'shogi_server/util'
  36 require 'shogi_server/league/floodgate_thread.rb'
  37 require 'tempfile'
  38
  39 #################################################
  40 # MAIN
  41 #
  42
  43 ONE_DAY = 3600 * 24   # in seconds
  44
  45 ShogiServer.reload
  46
  47 # Return
  48 #   - a received string
  49 #   - :timeout
  50 #   - :exception
  51 #   - nil when a socket is closed
  52 #
  53 def gets_safe(socket, timeout=nil)
  54   if r = select([socket], nil, nil, timeout)
  55     return r[0].first.gets
  56   else
  57     return :timeout
  58   end
  59 rescue Exception => ex
  60   log_error("gets_safe: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
  61   return :exception
  62 end
  63
  64 def usage
  65     print <<EOM
  66 NAME
  67         shogi-server - server for CSA server protocol
  68
  69 SYNOPSIS
  70         shogi-server [OPTIONS] event_name port_number
  71
  72 DESCRIPTION
  73         server for CSA server protocol
  74
  75 OPTIONS
  76         event_name
  77                 a prefix of record files.
  78         port_number
  79                 a port number for the server to listen.
  80                 4081 is often used.
  81         --least-time-per-move n
  82                 Least time in second per move: 0, 1 (default 1).
  83                   - 0: The new rule that CSA introduced in November 2014.
  84                   - 1: The old rule before it.
  85         --max-identifier n
  86                 maximum length of an identifier
  87         --max-moves n
  88                 when a game with the n-th move played does not end, make the game a draw.
  89                 Default 256. 0 disables this feature.
  90         --pid-file file
  91                 a file path in which a process ID will be written.
  92                 Use with --daemon option.
  93         --daemon dir
  94                 run as a daemon. Log files will be put in dir.
  95         --floodgate-games game_A[,...]
  96                 enable Floodgate with various game names (separated by a comma)
  97         --player-log-dir dir
  98                 enable to log network messages for players. Log files
  99                 will be put in the dir.
 100
 101 EXAMPLES
 102
 103         1. % ./shogi-server test 4081
 104            Run the shogi-server. Then clients can connect to port#4081.
 105            The server output logs to the stdout.
 106
 107         2. % ./shogi-server --max-moves 0 --least-time-per-move 1 test 4081
 108            Run the shogi-server in compliance with CSA Protocol V1.1.2 or before.
 109
 110         3. % ./shogi-server --daemon . --pid-file ./shogi-server.pid \
 111                             --player-log-dir ./player-logs \
 112                             test 4081
 113            Run the shogi-server as a daemon. The server outputs regular logs
 114            to shogi-server.log located in the current directory and network
 115            messages in ./player-logs directory.
 116
 117         4. % ./shogi-server --daemon . --pid-file ./shogi-server.pid \
 118                             --player-log-dir ./player-logs \
 119                             --floodgate-games floodgate-900-0,floodgate-3600-0 \
 120                             test 4081
 121            Run the shogi-server with two groups of Floodgate games.
 122            Configuration files allow you to schedule starting times. Consult
 123            floodgate-0-240.conf.sample or shogi_server/league/floodgate.rb
 124            for format details.
 125
 126 GRACEFUL SHUTDOWN
 127
 128         A file named "STOP" in the base directory prevents the server from
 129         starting new games including Floodgate matches.
 130         When you want to stop the server gracefully, first, create a STOP file
 131
 132           $ touch STOP
 133
 134         then wait for a while until all the running games complete.
 135         Now you can stop the process with no game interruptted by the 'kill'
 136         command.
 137
 138         Note that when a server gets started, a STOP file, if any, will be
 139         deleted automatically.
 140
 141 FLOODGATE SCHEDULE CONFIGURATIONS
 142
 143             You need to set starting times of floodgate groups in
 144             configuration files under the top directory. Each floodgate
 145             group requires a corresponding configuration file named
 146             "<game_name>.conf". The file will be re-read once just after a
 147             game starts.
 148
 149             For example, a floodgate-3600-30 game group requires
 150             floodgate-3600-30.conf.  However, for floodgate-900-0 and
 151             floodgate-3600-0, which were default enabled in previous
 152             versions, configuration files are optional if you are happy with
 153             default time settings.
 154             File format is:
 155               Line format:
 156                 # This is a comment line
 157                 DoW Time
 158                 ...
 159               where
 160                 DoW := "Sun" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" |
 161                        "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" |
 162                        "Friday" | "Saturday"
 163                 Time := HH:MM
 164
 165               For example,
 166                 Sat 13:00
 167                 Sat 22:00
 168                 Sun 13:00
 169
 170             PAREMETER SETTING
 171
 172             In addition, this configuration file allows to set parameters
 173             for the specific Floodaget group. A list of parameters is the
 174             following:
 175
 176             * pairing_factory:
 177               Specifies a factory function name generating a pairing
 178               method which will be used in a specific Floodgate game.
 179               ex. set pairing_factory floodgate_zyunisen
 180             * sacrifice:
 181               Specifies a sacrificed player.
 182               ex. set sacrifice gps500+e293220e3f8a3e59f79f6b0efffaa931
 183
 184 LICENSE
 185         GPL versoin 2 or later
 186
 187 SEE ALSO
 188
 189 REVISION
 190         #{ShogiServer::Revision}
 191
 192 EOM
 193 end
 194
 195
 196 def log_debug(str)
 197   $logger.debug(str)
 198 end
 199
 200 def log_message(str)
 201   $logger.info(str)
 202 end
 203 def log_info(str)
 204   log_message(str)
 205 end
 206
 207 def log_warning(str)
 208   $logger.warn(str)
 209 end
 210
 211 def log_error(str)
 212   $logger.error(str)
 213 end
 214
 215
 216 # Parse command line options. Return a hash containing the option strings
 217 # where a key is the option name without the first two slashes. For example,
 218 # {"pid-file" => "foo.pid"}.
 219 #
 220 def parse_command_line
 221   options = Hash::new
 222   parser = GetoptLong.new(
 223     ["--daemon",              GetoptLong::REQUIRED_ARGUMENT],
 224     ["--floodgate-games",     GetoptLong::REQUIRED_ARGUMENT],
 225     ["--least-time-per-move", GetoptLong::REQUIRED_ARGUMENT],
 226     ["--max-identifier",      GetoptLong::REQUIRED_ARGUMENT],
 227     ["--max-moves",           GetoptLong::REQUIRED_ARGUMENT],
 228     ["--pid-file",            GetoptLong::REQUIRED_ARGUMENT],
 229     ["--player-log-dir",      GetoptLong::REQUIRED_ARGUMENT])
 230   parser.quiet = true
 231   begin
 232     parser.each_option do |name, arg|
 233       name.sub!(/^--/, '')
 234       options[name] = arg.dup
 235     end
 236   rescue
 237     usage
 238     raise parser.error_message
 239   end
 240   return options
 241 end
 242
 243 # Check command line options.
 244 # If any of them is invalid, exit the process.
 245 #
 246 def check_command_line
 247   if (ARGV.length != 2)
 248     usage
 249     exit 2
 250   end
 251
 252   if $options["daemon"]
 253     $options["daemon"] = File.expand_path($options["daemon"], File.dirname(__FILE__))
 254     unless is_writable_dir? $options["daemon"]
 255       usage
 256       $stderr.puts "Can not create a file in the daemon directory: %s" % [$options["daemon"]]
 257       exit 5
 258     end
 259   end
 260
 261   $topdir = $options["daemon"] || File.expand_path(File.dirname(__FILE__))
 262
 263   if $options["player-log-dir"]
 264     $options["player-log-dir"] = File.expand_path($options["player-log-dir"], $topdir)
 265     unless is_writable_dir?($options["player-log-dir"])
 266       usage
 267       $stderr.puts "Can not write a file in the player log dir: %s" % [$options["player-log-dir"]]
 268       exit 3
 269     end
 270   end
 271
 272   if $options["pid-file"]
 273     $options["pid-file"] = File.expand_path($options["pid-file"], $topdir)
 274     unless ShogiServer::is_writable_file? $options["pid-file"]
 275       usage
 276       $stderr.puts "Can not create the pid file: %s" % [$options["pid-file"]]
 277       exit 4
 278     end
 279   end
 280
 281   if $options["floodgate-games"]
 282     names = $options["floodgate-games"].split(",")
 283     new_names =
 284       names.select do |name|
 285         ShogiServer::League::Floodgate::game_name?(name)
 286       end
 287     if names.size != new_names.size
 288       $stderr.puts "Found a wrong Floodgate game: %s" % [names.join(",")]
 289       exit 6
 290     end
 291     $options["floodgate-games"] = new_names
 292   end
 293
 294   if $options["floodgate-history"]
 295     $stderr.puts "WARNING: --floodgate-history has been deprecated."
 296     $options["floodgate-history"] = nil
 297   end
 298
 299   $options["max-moves"] ||= ShogiServer::Default_Max_Moves
 300   $options["max-moves"] = $options["max-moves"].to_i
 301
 302   $options["max-identifier"] ||= ShogiServer::Default_Max_Identifier_Length
 303   $options["max-identifier"] = $options["max-identifier"].to_i
 304
 305   $options["least-time-per-move"] ||= ShogiServer::Default_Least_Time_Per_Move
 306   $options["least-time-per-move"] = $options["least-time-per-move"].to_i
 307 end
 308
 309 # See if a file can be created in the directory.
 310 # Return true if a file is writable in the directory, otherwise false.
 311 #
 312 def is_writable_dir?(dir)
 313   unless File.directory? dir
 314     return false
 315   end
 316
 317   result = true
 318
 319   begin
 320     temp_file = Tempfile.new("dummy-shogi-server", dir)
 321     temp_file.close true
 322   rescue
 323     result = false
 324   end
 325
 326   return result
 327 end
 328
 329 def write_pid_file(file)
 330   open(file, "w") do |fh|
 331     fh.puts "#{$$}"
 332   end
 333 end
 334
 335 def mutex_watchdog(mutex, sec)
 336   sec = 1 if sec < 1
 337   queue = []
 338   while true
 339     if mutex.try_lock
 340       queue.clear
 341       mutex.unlock
 342     else
 343       queue.push(Object.new)
 344       if queue.size > sec
 345         # timeout
 346         log_error("mutex watchdog timeout: %d sec" % [sec])
 347         queue.clear
 348       end
 349     end
 350     sleep(1)
 351   end
 352 end
 353
 354 def login_loop(client)
 355   player = login = nil
 356
 357   while r = select([client], nil, nil, ShogiServer::Login_Time) do
 358     str = nil
 359     begin
 360       break unless str = r[0].first.gets
 361     rescue Exception => ex
 362       # It is posssible that the socket causes an error (ex. Errno::ECONNRESET)
 363       log_error("login_loop: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
 364       break
 365     end
 366     $mutex.lock # guards $league
 367     begin
 368       str =~ /([\r\n]*)$/
 369       eol = $1
 370       if (ShogiServer::Login::good_login?(str))
 371         player = ShogiServer::Player::new(str, client, eol)
 372         login  = ShogiServer::Login::factory(str, player)
 373         if (current_player = $league.find(player.name))
 374           # Even if a player is in the 'game' state, when the status of the
 375           # player has not been updated for more than a day, it is very
 376           # likely that the player is stalling. In such a case, a new player
 377           # can override the current player.
 378           if (current_player.password == player.password &&
 379               (current_player.status != "game" ||
 380                Time.now - current_player.last_command_at > ONE_DAY))
 381             log_message("player %s login forcibly, nudging the former player" % [player.name])
 382             log_message("  the former player was in %s and received the last command at %s" % [current_player.status, current_player.last_command_at])
 383             current_player.kill
 384           else
 385             login.incorrect_duplicated_player(str)
 386             player = nil
 387             break
 388           end
 389         end
 390         $league.add(player)
 391         break
 392       else
 393         client.write("LOGIN:incorrect" + eol)
 394         client.write("type 'LOGIN name password' or 'LOGIN name password x1'" + eol) if (str.split.length >= 4)
 395       end
 396     ensure
 397       $mutex.unlock
 398     end
 399   end                       # login loop
 400   return [player, login]
 401 end
 402
 403 def setup_logger(log_file)
 404   logger = ShogiServer::Logger.new(log_file, 'daily')
 405   logger.formatter = ShogiServer::Formatter.new
 406   logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO
 407   logger.datetime_format = "%Y-%m-%d %H:%M:%S"
 408   return logger
 409 end
 410
 411 def setup_watchdog_for_giant_lock
 412   $mutex = Mutex::new
 413   Thread::start do
 414     Thread.pass
 415     mutex_watchdog($mutex, 10)
 416   end
 417 end
 418
 419 def main
 420
 421   $options = parse_command_line
 422   check_command_line
 423   $config = ShogiServer::Config.new $options
 424
 425   $league = ShogiServer::League.new($topdir)
 426
 427   $league.event = ARGV.shift
 428   port = ARGV.shift
 429
 430   log_file = $options["daemon"] ? File.join($options["daemon"], "shogi-server.log") : STDOUT
 431   $logger = setup_logger(log_file)
 432
 433   $league.dir = $topdir
 434
 435   config = {}
 436   config[:BindAddress] = "0.0.0.0"
 437   config[:Port]       = port
 438   config[:ServerType] = WEBrick::Daemon if $options["daemon"]
 439   config[:Logger]     = $logger
 440
 441   setup_floodgate = nil
 442
 443   config[:StartCallback] = Proc.new do
 444     srand
 445     if $options["pid-file"]
 446       write_pid_file($options["pid-file"])
 447     end
 448     setup_watchdog_for_giant_lock
 449     $league.setup_players_database
 450     setup_floodgate = ShogiServer::SetupFloodgate.new($options["floodgate-games"])
 451     setup_floodgate.start
 452   end
 453
 454   config[:StopCallback] = Proc.new do
 455     if $options["pid-file"]
 456       FileUtils.rm($options["pid-file"], :force => true)
 457     end
 458   end
 459
 460   srand
 461   server = WEBrick::GenericServer.new(config)
 462   ["INT", "TERM"].each do |signal|
 463     trap(signal) do
 464       server.shutdown
 465       setup_floodgate.kill
 466     end
 467   end
 468   unless (RUBY_PLATFORM.downcase =~ /mswin|mingw|cygwin|bccwin/)
 469     trap("HUP") do
 470       Dependencies.clear
 471     end
 472   end
 473   $stderr.puts("server started as a deamon [Revision: #{ShogiServer::Revision}]") if $options["daemon"]
 474   log_message("server started [Revision: #{ShogiServer::Revision}]")
 475
 476   if ShogiServer::STOP_FILE.exist?
 477     log_message("Deleted the STOP file")
 478     ShogiServer::STOP_FILE.delete
 479   end
 480
 481   server.start do |client|
 482     begin
 483       # client.sync = true # this is already set in WEBrick
 484       client.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
 485         # Keepalive time can be set by /proc/sys/net/ipv4/tcp_keepalive_time
 486       player, login = login_loop(client) # loop
 487       unless player
 488         log_error("Detected a timed out login attempt")
 489         next
 490       end
 491
 492       log_message(sprintf("user %s login", player.name))
 493       login.process
 494       player.setup_logger($options["player-log-dir"]) if $options["player-log-dir"]
 495       player.run(login.csa_1st_str) # loop
 496       $mutex.lock
 497       begin
 498         if (player.game)
 499           player.game.kill(player)
 500         end
 501         player.finish
 502         $league.delete(player)
 503         log_message(sprintf("user %s logout", player.name))
 504       ensure
 505         $mutex.unlock
 506       end
 507       player.wait_write_thread_finish(1000) # milliseconds
 508     rescue Exception => ex
 509       log_error("server.start: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
 510     end
 511   end
 512 end
 513
 514
 515 if ($0 == __FILE__)
 516   STDOUT.sync = true
 517   STDERR.sync = true
 518   TCPSocket.do_not_reverse_lookup = true
 519   Thread.abort_on_exception = $DEBUG ? true : false
 520
 521   begin
 522     main
 523   rescue Exception => ex
 524     if $logger
 525       log_error("main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
 526     else
 527       $stderr.puts "main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
 528     end
 529   end
 530 end