-
Notifications
You must be signed in to change notification settings - Fork 0
/
shogi-server
executable file
·418 lines (363 loc) · 10.6 KB
/
shogi-server
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
#! /usr/bin/env ruby
# $Id$
#
# Author:: NABEYA Kenichi, Daigo Moriwaki
# Homepage:: http://sourceforge.jp/projects/shogi-server/
#
#--
# Copyright (C) 2004 NABEYA Kenichi (aka nanami@2ch)
# Copyright (C) 2007-2008 Daigo Moriwaki (daigo at debian dot org)
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#++
#
#
$topdir = nil
$league = nil
$logger = nil
$config = nil
$:.unshift File.dirname(__FILE__)
require 'shogi_server'
require 'shogi_server/config'
require 'shogi_server/util'
require 'shogi_server/league/floodgate_thread.rb'
require 'tempfile'
REST_AUTH_SITE_KEY = '070d045a424730a7ffacaff2b85d061749cf1d47'
REST_AUTH_DIGEST_STRETCHES = 10
#################################################
# MAIN
#
ShogiServer.reload
# Return
# - a received string
# - :timeout
# - :exception
# - nil when a socket is closed
#
def gets_safe(socket, timeout=nil)
if r = select([socket], nil, nil, timeout)
return r[0].first.gets
else
return :timeout
end
rescue Exception => ex
log_error("gets_safe: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
return :exception
end
def usage
print <<EOM
NAME
shogi-server - server for CSA server protocol
SYNOPSIS
shogi-server [OPTIONS] event_name port_number
DESCRIPTION
server for CSA server protocol
OPTIONS
--pid-file file
specify filename for logging process ID
--daemon dir
run as a daemon. Log files will be put in dir.
--floodgate-games game_A[,...]
enable Floodgate with various game names.
--player-log-dir dir
log network messages for each player. Log files
will be put in the dir.
LICENSE
GPL versoin 2 or later
SEE ALSO
RELEASE
#{ShogiServer::Release}
REVISION
#{ShogiServer::Revision}
EOM
end
def log_debug(str)
$logger.debug(str)
end
def log_message(str)
$logger.info(str)
end
def log_info(str)
log_message(str)
end
def log_warning(str)
$logger.warn(str)
end
def log_error(str)
$logger.error(str)
end
# Parse command line options. Return a hash containing the option strings
# where a key is the option name without the first two slashes. For example,
# {"pid-file" => "foo.pid"}.
#
def parse_command_line
options = Hash::new
parser = GetoptLong.new(
["--daemon", GetoptLong::REQUIRED_ARGUMENT],
["--floodgate-games", GetoptLong::REQUIRED_ARGUMENT],
["--pid-file", GetoptLong::REQUIRED_ARGUMENT],
["--player-log-dir", GetoptLong::REQUIRED_ARGUMENT])
parser.quiet = true
begin
parser.each_option do |name, arg|
name.sub!(/^--/, '')
options[name] = arg.dup
end
rescue
usage
raise parser.error_message
end
return options
end
# Check command line options.
# If any of them is invalid, exit the process.
#
def check_command_line
if (ARGV.length != 2)
usage
exit 2
end
if $options["daemon"]
$options["daemon"] = File.expand_path($options["daemon"], File.dirname(__FILE__))
unless is_writable_dir? $options["daemon"]
usage
$stderr.puts "Can not create a file in the daemon directory: %s" % [$options["daemon"]]
exit 5
end
end
$topdir = $options["daemon"] || File.expand_path(File.dirname(__FILE__))
if $options["player-log-dir"]
$options["player-log-dir"] = File.expand_path($options["player-log-dir"], $topdir)
unless is_writable_dir?($options["player-log-dir"])
usage
$stderr.puts "Can not write a file in the player log dir: %s" % [$options["player-log-dir"]]
exit 3
end
end
if $options["pid-file"]
$options["pid-file"] = File.expand_path($options["pid-file"], $topdir)
unless ShogiServer::is_writable_file? $options["pid-file"]
usage
$stderr.puts "Can not create the pid file: %s" % [$options["pid-file"]]
exit 4
end
end
if $options["floodgate-games"]
names = $options["floodgate-games"].split(",")
new_names =
names.select do |name|
ShogiServer::League::Floodgate::game_name?(name)
end
if names.size != new_names.size
$stderr.puts "Found a wrong Floodgate game: %s" % [names.join(",")]
exit 6
end
$options["floodgate-games"] = new_names
end
if $options["floodgate-history"]
$stderr.puts "WARNING: --floodgate-history has been deprecated."
$options["floodgate-history"] = nil
end
end
# See if a file can be created in the directory.
# Return true if a file is writable in the directory, otherwise false.
#
def is_writable_dir?(dir)
unless File.directory? dir
return false
end
result = true
begin
temp_file = Tempfile.new("dummy-shogi-server", dir)
temp_file.close true
rescue
result = false
end
return result
end
def write_pid_file(file)
open(file, "w") do |fh|
fh.puts "#{$$}"
end
end
def mutex_watchdog(mutex, sec)
sec = 1 if sec < 1
queue = []
while true
if mutex.try_lock
queue.clear
mutex.unlock
else
queue.push(Object.new)
if queue.size > sec
# timeout
log_error("mutex watchdog timeout: %d sec" % [sec])
queue.clear
end
end
sleep(1)
end
end
def login_loop(client)
player = login = nil
while r = select([client], nil, nil, ShogiServer::Login_Time) do
str = nil
begin
break unless str = r[0].first.gets
rescue Exception => ex
# It is posssible that the socket causes an error (ex. Errno::ECONNRESET)
log_error("login_loop: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
break
end
$mutex.lock # guards $league
begin
str =~ /([\r\n]*)$/
eol = $1
if (ShogiServer::Login::good_login?(str))
player = ShogiServer::Player.find(:one,:from => :authenticate,:params => {:login => str.split[1],:password => str.split[2] })
player.init(str,client,eol)
if player.banned?
player = nil
break
end
login = ShogiServer::Login::factory(str, player)
if (current_player = $league.find(player.name))
if (current_player.password == player.password)
log_message(sprintf("user %s login forcely", player.name))
current_player.override
else
login.incorrect_duplicated_player(str)
player = nil
break
end
end
$league.add(player)
break
else
client.write("LOGIN:incorrect" + eol)
client.write("type 'LOGIN name password' or 'LOGIN name password x1'" + eol) if (str.split.length >= 4)
end
rescue ActiveResource::ResourceInvalid => e
client.write("LOGIN:incorrect login or password" + eol)
ensure
$mutex.unlock
end
end # login loop
return [player, login]
end
def setup_logger(log_file)
logger = ShogiServer::Logger.new(log_file, 'daily')
logger.formatter = ShogiServer::Formatter.new
logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO
logger.datetime_format = "%Y-%m-%d %H:%M:%S"
return logger
end
def setup_watchdog_for_giant_lock
$mutex = Mutex::new
Thread::start do
Thread.pass
mutex_watchdog($mutex, 10)
end
end
def main
$options = parse_command_line
check_command_line
$config = ShogiServer::Config.new $options
$league = ShogiServer::League.new($topdir)
$league.event = ARGV.shift
port = ARGV.shift
log_file = $options["daemon"] ? File.join($options["daemon"], "shogi-server.log") : STDOUT
$logger = setup_logger(log_file)
$server = ShogiServer::Server.find(:one, :from => :with_name, :params => {:name => $league.event})
$server.start_log
$offline_message = Hash::new
$banned = Array::new
$league.dir = $topdir
config = {}
config[:Port] = port
config[:ServerType] = WEBrick::Daemon if $options["daemon"]
config[:Logger] = $logger
setup_floodgate = nil
config[:StartCallback] = Proc.new do
srand
if $options["pid-file"]
write_pid_file($options["pid-file"])
end
setup_watchdog_for_giant_lock
$league.setup_players_database
setup_floodgate = ShogiServer::SetupFloodgate.new($options["floodgate-games"])
setup_floodgate.start
end
config[:StopCallback] = Proc.new do
if $options["pid-file"]
FileUtils.rm($options["pid-file"], :force => true)
end
end
config[:MaxClients] = 1000
srand
server = WEBrick::GenericServer.new(config)
["INT", "TERM"].each do |signal|
trap(signal) do
server.shutdown
setup_floodgate.kill
end
end
unless (RUBY_PLATFORM.downcase =~ /mswin|mingw|cygwin|bccwin/)
trap("HUP") do
Dependencies.clear
end
end
$stderr.puts("server started as a deamon [Revision: #{ShogiServer::Revision}] [port: #{port}] [league: #{$league.event}]") if $options["daemon"]
log_message("server started [Revision: #{ShogiServer::Revision}]")
server.start do |client|
# client.sync = true # this is already set in WEBrick
client.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
# Keepalive time can be set by /proc/sys/net/ipv4/tcp_keepalive_time
client.write("<cross-domain-policy><allow-access-from domain=\"*\" to-ports=\"*\" /></cross-domain-policy>\0")
player, login = login_loop(client) # loop
next unless player
log_message(sprintf("user %s login", player.name))
$server.write_population($league.players.length)
login.process
player.setup_logger($options["player-log-dir"]) if $options["player-log-dir"]
player.run(login.csa_1st_str) # loop
$mutex.lock
begin
player.kill
$league.delete(player)
log_message(sprintf("user %s logout", player.name))
$server.write_population($league.players.length)
ensure
$mutex.unlock
end
end
ensure
$server.write_population(-1) if ($server)
end
if ($0 == __FILE__)
STDOUT.sync = true
STDERR.sync = true
TCPSocket.do_not_reverse_lookup = true
Thread.abort_on_exception = $DEBUG ? true : false
begin
main
rescue Exception => ex
if $logger
log_error("main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
else
$stderr.puts "main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
end
end
end