OSDN Git Service

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