shogi-server

   1 #! /usr/bin/env ruby
   2 ## $Id$
   3
   4 ## Copyright (C) 2004 NABEYA Kenichi (aka nanami@2ch)
   5 ## Copyright (C) 2007-2008 Daigo Moriwaki (daigo at debian dot org)
   6 ##
   7 ## This program is free software; you can redistribute it and/or modify
   8 ## it under the terms of the GNU General Public License as published by
   9 ## the Free Software Foundation; either version 2 of the License, or
  10 ## (at your option) any later version.
  11 ##
  12 ## This program is distributed in the hope that it will be useful,
  13 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ## GNU General Public License for more details.
  16 ##
  17 ## You should have received a copy of the GNU General Public License
  18 ## along with this program; if not, write to the Free Software
  19 ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20
  21 $:.unshift File.dirname(__FILE__)
  22 require 'shogi_server'
  23
  24 #################################################
  25 # MAIN
  26 #
  27
  28 ShogiServer.reload
  29
  30 def gets_safe(socket, timeout=nil)
  31   if r = select([socket], nil, nil, timeout)
  32     return r[0].first.gets
  33   else
  34     return :timeout
  35   end
  36 rescue Exception => ex
  37   log_error("gets_safe: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
  38   return :exception
  39 end
  40
  41 def usage
  42     print <<EOM
  43 NAME
  44         shogi-server - server for CSA server protocol
  45
  46 SYNOPSIS
  47         shogi-server [OPTIONS] event_name port_number
  48
  49 DESCRIPTION
  50         server for CSA server protocol
  51
  52 OPTIONS
  53         --pid-file file
  54                 specify filename for logging process ID
  55         --daemon dir
  56                 run as a daemon. Log files will be put in dir.
  57         --player-log-dir dir
  58                 log network messages for each player. Log files
  59                 will be put in the dir.
  60
  61 LICENSE
  62         GPL versoin 2 or later
  63
  64 SEE ALSO
  65
  66 RELEASE
  67         #{ShogiServer::Release}
  68
  69 REVISION
  70         #{ShogiServer::Revision}
  71 EOM
  72 end
  73
  74
  75 def log_debug(str)
  76   $logger.debug(str)
  77 end
  78
  79 def log_message(str)
  80   $logger.info(str)
  81 end
  82
  83 def log_warning(str)
  84   $logger.warn(str)
  85 end
  86
  87 def log_error(str)
  88   $logger.error(str)
  89 end
  90
  91
  92 def parse_command_line
  93   options = Hash::new
  94   parser = GetoptLong.new(
  95     ["--daemon",   GetoptLong::REQUIRED_ARGUMENT],
  96     ["--pid-file", GetoptLong::REQUIRED_ARGUMENT],
  97     ["--player-log-dir", GetoptLong::REQUIRED_ARGUMENT])
  98   parser.quiet = true
  99   begin
 100     parser.each_option do |name, arg|
 101       name.sub!(/^--/, '')
 102       options[name] = arg.dup
 103     end
 104   rescue
 105     usage
 106     raise parser.error_message
 107   end
 108   return options
 109 end
 110
 111 def write_pid_file(file)
 112   open(file, "w") do |fh|
 113     fh.puts "#{$$}"
 114   end
 115 end
 116
 117 def mutex_watchdog(mutex, sec)
 118   sec = 1 if sec < 1
 119   queue = []
 120   while true
 121     if mutex.try_lock
 122       queue.clear
 123       mutex.unlock
 124     else
 125       queue.push(Object.new)
 126       if queue.size > sec
 127         # timeout
 128         log_error("mutex watchdog timeout: %d sec" % [sec])
 129         queue.clear
 130       end
 131     end
 132     sleep(1)
 133   end
 134 end
 135
 136 def login_loop(client)
 137   player = login = nil
 138
 139   while r = select([client], nil, nil, ShogiServer::Login_Time) do
 140     break unless str = r[0].first.gets
 141     $mutex.lock # guards LEAGUE
 142     begin
 143       str =~ /([\r\n]*)$/
 144       eol = $1
 145       if (ShogiServer::Login::good_login?(str))
 146         player = ShogiServer::Player::new(str, client, eol)
 147         login  = ShogiServer::Login::factory(str, player)
 148         if (current_player = LEAGUE.find(player.name))
 149           if (current_player.password == player.password &&
 150               current_player.status != "game")
 151             log_message(sprintf("user %s login forcely", player.name))
 152             current_player.kill
 153           else
 154             login.incorrect_duplicated_player(str)
 155             player = nil
 156             break
 157           end
 158         end
 159         LEAGUE.add(player)
 160         break
 161       else
 162         client.write("LOGIN:incorrect" + eol)
 163         client.write("type 'LOGIN name password' or 'LOGIN name password x1'" + eol) if (str.split.length >= 4)
 164       end
 165     ensure
 166       $mutex.unlock
 167     end
 168   end                       # login loop
 169   return [player, login]
 170 end
 171
 172 def setup_logger(log_file)
 173   logger = Logger.new(log_file, 'daily')
 174   logger.formatter = ShogiServer::Formatter.new
 175   logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO
 176   logger.datetime_format = "%Y-%m-%d %H:%M:%S"
 177   return logger
 178 end
 179
 180 def setup_watchdog_for_giant_lock
 181   $mutex = Mutex::new
 182   Thread::start do
 183     Thread.pass
 184     mutex_watchdog($mutex, 10)
 185   end
 186 end
 187
 188 def setup_floodgate
 189   return Thread.start do
 190     Thread.pass
 191     floodgate = ShogiServer::League::Floodgate.new(LEAGUE)
 192     log_message("Flooddgate reloaded. The next match will start at %s." %
 193                 [floodgate.next_time])
 194
 195     while (true)
 196       begin
 197         diff = floodgate.next_time - Time.now
 198         if diff > 0
 199           sleep(diff/2)
 200           next
 201         end
 202         LEAGUE.reload
 203         floodgate.match_game
 204         floodgate.charge
 205         next_time = floodgate.next_time
 206         $mutex.synchronize do
 207           log_message("Reloading source...")
 208           ShogiServer.reload
 209         end
 210         floodgate = ShogiServer::League::Floodgate.new(LEAGUE, next_time)
 211         log_message("Floodgate will start the next match at %s." %
 212                     [floodgate.next_time])
 213       rescue Exception => ex
 214         # ignore errors
 215         log_error("[in Floodgate's thread] #{ex} #{ex.backtrace}")
 216       end
 217     end
 218   end
 219 end
 220
 221 def main
 222
 223  setup_watchdog_for_giant_lock
 224
 225   $options = parse_command_line
 226   if (ARGV.length != 2)
 227     usage
 228     exit 2
 229   end
 230   if $options["player-log-dir"]
 231     $options["player-log-dir"] = File.expand_path($options["player-log-dir"])
 232   end
 233   if $options["player-log-dir"] &&
 234      !File.directory?($options["player-log-dir"])
 235     usage
 236     exit 3
 237   end
 238
 239   LEAGUE.event = ARGV.shift
 240   port = ARGV.shift
 241
 242   dir = $options["daemon"]
 243   dir = File.expand_path(dir) if dir
 244   if dir && ! File.exist?(dir)
 245     FileUtils.mkdir(dir)
 246   end
 247
 248   log_file = dir ? File.join(dir, "shogi-server.log") : STDOUT
 249   $logger = setup_logger(log_file)
 250
 251   LEAGUE.dir = dir || File.dirname(__FILE__)
 252   LEAGUE.setup_players_database
 253
 254   config = {}
 255   config[:Port]       = port
 256   config[:ServerType] = WEBrick::Daemon if $options["daemon"]
 257   config[:Logger]     = $logger
 258
 259   fg_thread = nil
 260   config[:StartCallback] = Proc.new do
 261     if $options["pid-file"]
 262       write_pid_file($options["pid-file"])
 263     end
 264     fg_thread = setup_floodgate
 265   end
 266
 267   config[:StopCallback] = Proc.new do
 268     if $options["pid-file"]
 269       FileUtils.rm(pid_file, :force => true)
 270     end
 271   end
 272
 273   server = WEBrick::GenericServer.new(config)
 274   ["INT", "TERM"].each do |signal|
 275     trap(signal) do
 276       server.shutdown
 277       fg_thread.kill if fg_thread
 278     end
 279   end
 280   trap("HUP") do
 281     Dependencies.clear
 282   end
 283   $stderr.puts("server started as a deamon [Revision: #{ShogiServer::Revision}]") if $options["daemon"]
 284   log_message("server started [Revision: #{ShogiServer::Revision}]")
 285
 286   server.start do |client|
 287       # client.sync = true # this is already set in WEBrick
 288       client.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
 289         # Keepalive time can be set by /proc/sys/net/ipv4/tcp_keepalive_time
 290       player, login = login_loop(client) # loop
 291       next unless player
 292
 293       log_message(sprintf("user %s login", player.name))
 294       login.process
 295       player.setup_logger($options["player-log-dir"]) if $options["player-log-dir"]
 296       player.run(login.csa_1st_str) # loop
 297       $mutex.lock
 298       begin
 299         if (player.game)
 300           player.game.kill(player)
 301         end
 302         player.finish # socket has been closed
 303         LEAGUE.delete(player)
 304         log_message(sprintf("user %s logout", player.name))
 305       ensure
 306         $mutex.unlock
 307       end
 308   end
 309 end
 310
 311
 312 if ($0 == __FILE__)
 313   STDOUT.sync = true
 314   STDERR.sync = true
 315   TCPSocket.do_not_reverse_lookup = true
 316   Thread.abort_on_exception = $DEBUG ? true : false
 317
 318   begin
 319   LEAGUE = ShogiServer::League::new
 320     main
 321   rescue Exception => ex
 322     log_error("main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
 323   end
 324 end