OSDN Git Service

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