OSDN Git Service

Pieces in hands are correctly recognized now.
[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 TOP_DIR = File.expand_path(File.dirname(__FILE__))
22 $:.unshift File.dirname(__FILE__)
23 require 'shogi_server'
24
25 #################################################
26 # MAIN
27 #
28
29 ShogiServer.reload
30
31 def gets_safe(socket, timeout=nil)
32   if r = select([socket], nil, nil, timeout)
33     return r[0].first.gets
34   else
35     return :timeout
36   end
37 rescue Exception => ex
38   log_error("gets_safe: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
39   return :exception
40 end
41
42 def usage
43     print <<EOM
44 NAME
45         shogi-server - server for CSA server protocol
46
47 SYNOPSIS
48         shogi-server [OPTIONS] event_name port_number
49
50 DESCRIPTION
51         server for CSA server protocol
52
53 OPTIONS
54         --pid-file file
55                 specify filename for logging process ID
56         --daemon dir
57                 run as a daemon. Log files will be put in dir.
58         --player-log-dir dir
59                 log network messages for each player. Log files
60                 will be put in the dir.
61         --floodgate-history
62                 file name to record Floodgate game history
63                 default: './floodgate_history.yaml'
64
65 LICENSE
66         GPL versoin 2 or later
67
68 SEE ALSO
69
70 RELEASE
71         #{ShogiServer::Release}
72
73 REVISION
74         #{ShogiServer::Revision}
75 EOM
76 end
77
78
79 def log_debug(str)
80   $logger.debug(str)
81 end
82
83 def log_message(str)
84   $logger.info(str)
85 end
86 def log_info(str)
87   log_message(str)
88 end
89
90 def log_warning(str)
91   $logger.warn(str)
92 end
93
94 def log_error(str)
95   $logger.error(str)
96 end
97
98
99 def parse_command_line
100   options = Hash::new
101   parser = GetoptLong.new(
102     ["--daemon",            GetoptLong::REQUIRED_ARGUMENT],
103     ["--pid-file",          GetoptLong::REQUIRED_ARGUMENT],
104     ["--player-log-dir",    GetoptLong::REQUIRED_ARGUMENT],
105     ["--floodgate-history", GetoptLong::REQUIRED_ARGUMENT])
106   parser.quiet = true
107   begin
108     parser.each_option do |name, arg|
109       name.sub!(/^--/, '')
110       options[name] = arg.dup
111     end
112   rescue
113     usage
114     raise parser.error_message
115   end
116   return options
117 end
118
119 def write_pid_file(file)
120   open(file, "w") do |fh|
121     fh.puts "#{$$}"
122   end
123 end
124
125 def mutex_watchdog(mutex, sec)
126   sec = 1 if sec < 1
127   queue = []
128   while true
129     if mutex.try_lock
130       queue.clear
131       mutex.unlock
132     else
133       queue.push(Object.new)
134       if queue.size > sec
135         # timeout
136         log_error("mutex watchdog timeout: %d sec" % [sec])
137         queue.clear
138       end
139     end
140     sleep(1)
141   end
142 end
143
144 def login_loop(client)
145   player = login = nil
146  
147   while r = select([client], nil, nil, ShogiServer::Login_Time) do
148     break unless str = r[0].first.gets
149     $mutex.lock # guards LEAGUE
150     begin
151       str =~ /([\r\n]*)$/
152       eol = $1
153       if (ShogiServer::Login::good_login?(str))
154         player = ShogiServer::Player::new(str, client, eol)
155         login  = ShogiServer::Login::factory(str, player)
156         if (current_player = LEAGUE.find(player.name))
157           if (current_player.password == player.password &&
158               current_player.status != "game")
159             log_message(sprintf("user %s login forcely", player.name))
160             current_player.kill
161           else
162             login.incorrect_duplicated_player(str)
163             player = nil
164             break
165           end
166         end
167         LEAGUE.add(player)
168         break
169       else
170         client.write("LOGIN:incorrect" + eol)
171         client.write("type 'LOGIN name password' or 'LOGIN name password x1'" + eol) if (str.split.length >= 4)
172       end
173     ensure
174       $mutex.unlock
175     end
176   end                       # login loop
177   return [player, login]
178 end
179
180 def setup_logger(log_file)
181   logger = Logger.new(log_file, 'daily')
182   logger.formatter = ShogiServer::Formatter.new
183   logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO  
184   logger.datetime_format = "%Y-%m-%d %H:%M:%S"
185   return logger
186 end
187
188 def setup_watchdog_for_giant_lock
189   $mutex = Mutex::new
190   Thread::start do
191     Thread.pass
192     mutex_watchdog($mutex, 10)
193   end
194 end
195
196 def setup_floodgate
197   return Thread.start do 
198     Thread.pass
199     floodgate = ShogiServer::League::Floodgate.new(LEAGUE)
200     log_message("Flooddgate reloaded. The next match will start at %s." % 
201                 [floodgate.next_time])
202
203     while (true)
204       begin
205         diff = floodgate.next_time - Time.now
206         if diff > 0
207           sleep(diff/2)
208           next
209         end
210         LEAGUE.reload
211         floodgate.match_game
212         floodgate.charge
213         next_time = floodgate.next_time
214         $mutex.synchronize do
215           log_message("Reloading source...")
216           ShogiServer.reload
217         end
218         floodgate = ShogiServer::League::Floodgate.new(LEAGUE, next_time)
219         log_message("Floodgate: The next match will start at %s." % 
220                     [floodgate.next_time])
221       rescue Exception => ex 
222         # ignore errors
223         log_error("[in Floodgate's thread] #{ex} #{ex.backtrace}")
224       end
225     end
226   end
227 end
228
229 def main
230   
231   $options = parse_command_line
232   if (ARGV.length != 2)
233     usage
234     exit 2
235   end
236   if $options["player-log-dir"]
237     $options["player-log-dir"] = File.expand_path($options["player-log-dir"])
238   end
239   if $options["player-log-dir"] && 
240      !File.directory?($options["player-log-dir"])
241     usage
242     exit 3
243   end
244   if $options["pid-file"] 
245     $options["pid-file"] = File.expand_path($options["pid-file"])
246   end
247   $options["floodgate-history"] ||= File.join(File.dirname(__FILE__), "floodgate_history.yaml")
248   $options["floodgate-history"] = File.expand_path($options["floodgate-history"])
249
250   LEAGUE.event = ARGV.shift
251   port = ARGV.shift
252
253   dir = $options["daemon"]
254   dir = File.expand_path(dir) if dir
255   if dir && ! File.exist?(dir)
256     FileUtils.mkdir(dir)
257   end
258
259   log_file = dir ? File.join(dir, "shogi-server.log") : STDOUT
260   $logger = setup_logger(log_file)
261
262   LEAGUE.dir = dir || TOP_DIR
263
264   config = {}
265   config[:Port]       = port
266   config[:ServerType] = WEBrick::Daemon if $options["daemon"]
267   config[:Logger]     = $logger
268
269   fg_thread = nil
270
271   config[:StartCallback] = Proc.new do
272     srand
273     if $options["pid-file"]
274       write_pid_file($options["pid-file"])
275     end
276     setup_watchdog_for_giant_lock
277     LEAGUE.setup_players_database
278     fg_thread = setup_floodgate
279   end
280
281   config[:StopCallback] = Proc.new do
282     if $options["pid-file"]
283       FileUtils.rm($options["pid-file"], :force => true)
284     end
285   end
286
287   srand
288   server = WEBrick::GenericServer.new(config)
289   ["INT", "TERM"].each do |signal| 
290     trap(signal) do
291       server.shutdown
292       fg_thread.kill if fg_thread
293     end
294   end
295   trap("HUP") do
296     Dependencies.clear
297   end
298   $stderr.puts("server started as a deamon [Revision: #{ShogiServer::Revision}]") if $options["daemon"] 
299   log_message("server started [Revision: #{ShogiServer::Revision}]")
300
301   server.start do |client|
302       # client.sync = true # this is already set in WEBrick 
303       client.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
304         # Keepalive time can be set by /proc/sys/net/ipv4/tcp_keepalive_time
305       player, login = login_loop(client) # loop
306       next unless player
307
308       log_message(sprintf("user %s login", player.name))
309       login.process
310       player.setup_logger($options["player-log-dir"]) if $options["player-log-dir"]
311       player.run(login.csa_1st_str) # loop
312       $mutex.lock
313       begin
314         if (player.game)
315           player.game.kill(player)
316         end
317         player.finish # socket has been closed
318         LEAGUE.delete(player)
319         log_message(sprintf("user %s logout", player.name))
320       ensure
321         $mutex.unlock
322       end
323   end
324 end
325
326
327 if ($0 == __FILE__)
328   STDOUT.sync = true
329   STDERR.sync = true
330   TCPSocket.do_not_reverse_lookup = true
331   Thread.abort_on_exception = $DEBUG ? true : false
332
333   begin
334     LEAGUE = ShogiServer::League.new(TOP_DIR)
335     main
336   rescue Exception => ex
337     if $logger
338       log_error("main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
339     else
340       $stderr.puts "main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
341     end
342   end
343 end