OSDN Git Service

* No loger use Dependencies.rb in Rails.
[shogi-server/shogi-server.git] / 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   #[ShogiServer::League::Floodgate, ShogiServer::Pairing].each do |klass|
224   #  Dependencies.unloadable klass
225   #end
226
227   setup_watchdog_for_giant_lock
228
229   $options = parse_command_line
230   if (ARGV.length != 2)
231     usage
232     exit 2
233   end
234   if $options["player-log-dir"]
235     $options["player-log-dir"] = File.expand_path($options["player-log-dir"])
236   end
237   if $options["player-log-dir"] && 
238      !File.directory?($options["player-log-dir"])
239     usage
240     exit 3
241   end
242
243   LEAGUE.event = ARGV.shift
244   port = ARGV.shift
245
246   dir = $options["daemon"]
247   dir = File.expand_path(dir) if dir
248   if dir && ! File.exist?(dir)
249     FileUtils.mkdir(dir)
250   end
251
252   log_file = dir ? File.join(dir, "shogi-server.log") : STDOUT
253   $logger = setup_logger(log_file)
254
255   LEAGUE.dir = dir || File.dirname(__FILE__)
256   LEAGUE.setup_players_database
257
258   config = {}
259   config[:Port]       = port
260   config[:ServerType] = WEBrick::Daemon if $options["daemon"]
261   config[:Logger]     = $logger
262
263   fg_thread = nil
264   config[:StartCallback] = Proc.new do
265     if $options["pid-file"]
266       write_pid_file($options["pid-file"])
267     end
268     fg_thread = setup_floodgate
269   end
270
271   config[:StopCallback] = Proc.new do
272     if $options["pid-file"]
273       FileUtils.rm(pid_file, :force => true)
274     end
275   end
276
277   server = WEBrick::GenericServer.new(config)
278   ["INT", "TERM"].each do |signal| 
279     trap(signal) do
280       LEAGUE.shutdown
281       server.shutdown
282       fg_thread.kill if fg_thread
283     end
284   end
285   trap("HUP") do
286     LEAGUE.shutdown
287     Dependencies.clear
288   end
289   $stderr.puts("server started as a deamon [Revision: #{ShogiServer::Revision}]") if $options["daemon"] 
290   log_message("server started [Revision: #{ShogiServer::Revision}]")
291
292   server.start do |client|
293       # client.sync = true # this is already set in WEBrick 
294       client.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
295         # Keepalive time can be set by /proc/sys/net/ipv4/tcp_keepalive_time
296       player, login = login_loop(client) # loop
297       next unless player
298
299       log_message(sprintf("user %s login", player.name))
300       login.process
301       player.setup_logger($options["player-log-dir"]) if $options["player-log-dir"]
302       player.run(login.csa_1st_str) # loop
303       $mutex.lock
304       begin
305         if (player.game)
306           player.game.kill(player)
307         end
308         player.finish # socket has been closed
309         LEAGUE.delete(player)
310         log_message(sprintf("user %s logout", player.name))
311       ensure
312         $mutex.unlock
313       end
314   end
315 end
316
317
318 if ($0 == __FILE__)
319   STDOUT.sync = true
320   STDERR.sync = true
321   TCPSocket.do_not_reverse_lookup = true
322   Thread.abort_on_exception = $DEBUG ? true : false
323
324   begin
325   LEAGUE = ShogiServer::League::new
326     main
327   rescue Exception => ex
328     log_error("main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
329   end
330 end