OSDN Git Service

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