OSDN Git Service

Improved stability of the test result.
[shogi-server/shogi-server.git] / 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 'tempfile'
36
37 #################################################
38 # MAIN
39 #
40
41 ShogiServer.reload
42
43 def gets_safe(socket, timeout=nil)
44   if r = select([socket], nil, nil, timeout)
45     return r[0].first.gets
46   else
47     return :timeout
48   end
49 rescue Exception => ex
50   log_error("gets_safe: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
51   return :exception
52 end
53
54 def usage
55     print <<EOM
56 NAME
57         shogi-server - server for CSA server protocol
58
59 SYNOPSIS
60         shogi-server [OPTIONS] event_name port_number
61
62 DESCRIPTION
63         server for CSA server protocol
64
65 OPTIONS
66         --pid-file file
67                 specify filename for logging process ID
68         --daemon dir
69                 run as a daemon. Log files will be put in dir.
70         --player-log-dir dir
71                 log network messages for each player. Log files
72                 will be put in the dir.
73         --floodgate-history
74                 file name to record Floodgate game history
75                 default: './floodgate_history.yaml'
76
77 LICENSE
78         GPL versoin 2 or later
79
80 SEE ALSO
81
82 RELEASE
83         #{ShogiServer::Release}
84
85 REVISION
86         #{ShogiServer::Revision}
87
88 EOM
89 end
90
91
92 def log_debug(str)
93   $logger.debug(str)
94 end
95
96 def log_message(str)
97   $logger.info(str)
98 end
99 def log_info(str)
100   log_message(str)
101 end
102
103 def log_warning(str)
104   $logger.warn(str)
105 end
106
107 def log_error(str)
108   $logger.error(str)
109 end
110
111
112 # Parse command line options. Return a hash containing the option strings
113 # where a key is the option name without the first two slashes. For example,
114 # {"pid-file" => "foo.pid"}.
115 #
116 def parse_command_line
117   options = Hash::new
118   parser = GetoptLong.new(
119     ["--daemon",            GetoptLong::REQUIRED_ARGUMENT],
120     ["--pid-file",          GetoptLong::REQUIRED_ARGUMENT],
121     ["--player-log-dir",    GetoptLong::REQUIRED_ARGUMENT],
122     ["--floodgate-history", GetoptLong::REQUIRED_ARGUMENT])
123   parser.quiet = true
124   begin
125     parser.each_option do |name, arg|
126       name.sub!(/^--/, '')
127       options[name] = arg.dup
128     end
129   rescue
130     usage
131     raise parser.error_message
132   end
133   return options
134 end
135
136 # Check command line options.
137 # If any of them is invalid, exit the process.
138 #
139 def check_command_line
140   if (ARGV.length != 2)
141     usage
142     exit 2
143   end
144
145   if $options["daemon"]
146     $options["daemon"] = File.expand_path($options["daemon"], File.dirname(__FILE__))
147     unless is_writable_dir? $options["daemon"]
148       usage
149       $stderr.puts "Can not create a file in the daemon directory: %s" % [$options["daemon"]]
150       exit 5
151     end
152   end
153
154   $topdir = $options["daemon"] || File.expand_path(File.dirname(__FILE__))
155
156   if $options["player-log-dir"]
157     $options["player-log-dir"] = File.expand_path($options["player-log-dir"], $topdir)
158     unless is_writable_dir?($options["player-log-dir"])
159       usage
160       $stderr.puts "Can not write a file in the player log dir: %s" % [$options["player-log-dir"]]
161       exit 3
162     end 
163   end
164
165   if $options["pid-file"] 
166     $options["pid-file"] = File.expand_path($options["pid-file"], $topdir)
167     unless is_writable_file? $options["pid-file"]
168       usage
169       $stderr.puts "Can not create the pid file: %s" % [$options["pid-file"]]
170       exit 4
171     end
172   end
173
174   $options["floodgate-history"] ||= File.join($topdir, "floodgate_history.yaml")
175   $options["floodgate-history"] = File.expand_path($options["floodgate-history"], $topdir)
176   unless is_writable_file? $options["floodgate-history"]
177     usage
178     $stderr.puts "Can not create the floodgate history file: %s" % [$options["floodgate-history"]]
179     exit 6
180   end
181 end
182
183 # See if the file is writable. The file will be created if it does not exist
184 # yet.
185 # Return true if the file is writable, otherwise false.
186 #
187 def is_writable_file?(file)
188   if File.exist?(file)
189     if FileTest.file?(file)
190       return FileTest.writable_real?(file)
191     else
192       return false
193     end
194   end
195   
196   begin
197     open(file, "w") {|fh| } 
198     FileUtils.rm file
199   rescue
200     return false
201   end
202
203   return true
204 end
205
206 # See if a file can be created in the directory.
207 # Return true if a file is writable in the directory, otherwise false.
208 #
209 def is_writable_dir?(dir)
210   unless File.directory? dir
211     return false
212   end
213
214   result = true
215
216   begin
217     temp_file = Tempfile.new("dummy-shogi-server", dir)
218     temp_file.close true
219   rescue
220     result = false
221   end
222
223   return result
224 end
225
226 def write_pid_file(file)
227   open(file, "w") do |fh|
228     fh.puts "#{$$}"
229   end
230 end
231
232 def mutex_watchdog(mutex, sec)
233   sec = 1 if sec < 1
234   queue = []
235   while true
236     if mutex.try_lock
237       queue.clear
238       mutex.unlock
239     else
240       queue.push(Object.new)
241       if queue.size > sec
242         # timeout
243         log_error("mutex watchdog timeout: %d sec" % [sec])
244         queue.clear
245       end
246     end
247     sleep(1)
248   end
249 end
250
251 def login_loop(client)
252   player = login = nil
253  
254   while r = select([client], nil, nil, ShogiServer::Login_Time) do
255     break unless str = r[0].first.gets
256     $mutex.lock # guards $league
257     begin
258       str =~ /([\r\n]*)$/
259       eol = $1
260       if (ShogiServer::Login::good_login?(str))
261         player = ShogiServer::Player::new(str, client, eol)
262         login  = ShogiServer::Login::factory(str, player)
263         if (current_player = $league.find(player.name))
264           if (current_player.password == player.password &&
265               current_player.status != "game")
266             log_message(sprintf("user %s login forcely", player.name))
267             current_player.kill
268           else
269             login.incorrect_duplicated_player(str)
270             player = nil
271             break
272           end
273         end
274         $league.add(player)
275         break
276       else
277         client.write("LOGIN:incorrect" + eol)
278         client.write("type 'LOGIN name password' or 'LOGIN name password x1'" + eol) if (str.split.length >= 4)
279       end
280     ensure
281       $mutex.unlock
282     end
283   end                       # login loop
284   return [player, login]
285 end
286
287 def setup_logger(log_file)
288   logger = ShogiServer::Logger.new(log_file, 'daily')
289   logger.formatter = ShogiServer::Formatter.new
290   logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO  
291   logger.datetime_format = "%Y-%m-%d %H:%M:%S"
292   return logger
293 end
294
295 def setup_watchdog_for_giant_lock
296   $mutex = Mutex::new
297   Thread::start do
298     Thread.pass
299     mutex_watchdog($mutex, 10)
300   end
301 end
302
303 def setup_floodgate
304   return Thread.start do 
305     Thread.pass
306     floodgate = ShogiServer::League::Floodgate.new($league)
307     log_message("Flooddgate reloaded. The next match will start at %s." % 
308                 [floodgate.next_time])
309
310     while (true)
311       begin
312         diff = floodgate.next_time - Time.now
313         if diff > 0
314           sleep(diff/2)
315           next
316         end
317         $league.reload
318         floodgate.match_game
319         floodgate.charge
320         next_time = floodgate.next_time
321         $mutex.synchronize do
322           log_message("Reloading source...")
323           ShogiServer.reload
324         end
325         floodgate = ShogiServer::League::Floodgate.new($league, next_time)
326         log_message("Floodgate: The next match will start at %s." % 
327                     [floodgate.next_time])
328       rescue Exception => ex 
329         # ignore errors
330         log_error("[in Floodgate's thread] #{ex} #{ex.backtrace}")
331       end
332     end
333   end
334 end
335
336 def main
337   
338   $options = parse_command_line
339   check_command_line
340   $config = ShogiServer::Config.new $options
341
342   $league = ShogiServer::League.new($topdir)
343
344   $league.event = ARGV.shift
345   port = ARGV.shift
346
347   log_file = $options["daemon"] ? File.join($options["daemon"], "shogi-server.log") : STDOUT
348   $logger = setup_logger(log_file)
349
350   $league.dir = $topdir
351
352   config = {}
353   config[:Port]       = port
354   config[:ServerType] = WEBrick::Daemon if $options["daemon"]
355   config[:Logger]     = $logger
356
357   fg_thread = nil
358
359   config[:StartCallback] = Proc.new do
360     srand
361     if $options["pid-file"]
362       write_pid_file($options["pid-file"])
363     end
364     setup_watchdog_for_giant_lock
365     $league.setup_players_database
366     fg_thread = setup_floodgate
367   end
368
369   config[:StopCallback] = Proc.new do
370     if $options["pid-file"]
371       FileUtils.rm($options["pid-file"], :force => true)
372     end
373   end
374
375   srand
376   server = WEBrick::GenericServer.new(config)
377   ["INT", "TERM"].each do |signal| 
378     trap(signal) do
379       server.shutdown
380       fg_thread.kill if fg_thread
381     end
382   end
383   trap("HUP") do
384     Dependencies.clear
385   end
386   $stderr.puts("server started as a deamon [Revision: #{ShogiServer::Revision}]") if $options["daemon"] 
387   log_message("server started [Revision: #{ShogiServer::Revision}]")
388
389   server.start do |client|
390       # client.sync = true # this is already set in WEBrick 
391       client.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
392         # Keepalive time can be set by /proc/sys/net/ipv4/tcp_keepalive_time
393       player, login = login_loop(client) # loop
394       next unless player
395
396       log_message(sprintf("user %s login", player.name))
397       login.process
398       player.setup_logger($options["player-log-dir"]) if $options["player-log-dir"]
399       player.run(login.csa_1st_str) # loop
400       $mutex.lock
401       begin
402         if (player.game)
403           player.game.kill(player)
404         end
405         player.finish # socket has been closed
406         $league.delete(player)
407         log_message(sprintf("user %s logout", player.name))
408       ensure
409         $mutex.unlock
410       end
411   end
412 end
413
414
415 if ($0 == __FILE__)
416   STDOUT.sync = true
417   STDERR.sync = true
418   TCPSocket.do_not_reverse_lookup = true
419   Thread.abort_on_exception = $DEBUG ? true : false
420
421   begin
422     main
423   rescue Exception => ex
424     if $logger
425       log_error("main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
426     else
427       $stderr.puts "main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
428     end
429   end
430 end