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
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
|
from tornado.escape import json_encode, json_decode, utf8
import tornado.websocket
import tornado.ioloop
import tornado.template
import os
import subprocess
import logging
import signal
import time, datetime
import codecs
import random
import zlib
import config
import checkoutput
from userdb import *
from util import *
sockets = set()
current_id = 0
shutting_down = False
login_tokens = {}
rand = random.SystemRandom()
def shutdown():
global shutting_down
shutting_down = True
for socket in list(sockets):
socket.shutdown()
def update_global_status():
write_dgl_status_file()
def update_all_lobbys(game):
lobby_entry = game.lobby_entry()
for socket in list(sockets):
if socket.is_in_lobby():
socket.send_message("lobby_entry", **lobby_entry)
def remove_in_lobbys(process):
for socket in list(sockets):
if socket.is_in_lobby():
socket.send_message("lobby_remove", id=process.id)
def write_dgl_status_file():
f = None
try:
f = open(config.dgl_status_file, "w")
for socket in list(sockets):
if socket.username and socket.is_running():
f.write("%s#%s#%s#0x0#%s#%s#\n" %
(socket.username, socket.game_id,
(socket.process.human_readable_where()),
str(socket.process.idle_time()),
str(socket.process.watcher_count())))
except (OSError, IOError) as e:
logging.warning("Could not write dgl status file: %s", e)
finally:
if f: f.close()
def purge_login_tokens():
for token in list(login_tokens):
if datetime.datetime.now() > login_tokens[token]:
del login_tokens[token]
def purge_login_tokens_timeout():
purge_login_tokens()
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_timeout(time.time() + 60 * 60 * 1000,
purge_login_tokens_timeout)
def status_file_timeout():
write_dgl_status_file()
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_timeout(time.time() + config.status_file_update_rate,
status_file_timeout)
def find_user_sockets(username):
for socket in list(sockets):
if socket.username and socket.username.lower() == username.lower():
yield socket
def find_running_game(charname, start):
from process_handler import processes
for process in processes.values():
if (process.where.get("name") == charname and
process.where.get("start") == start):
return process
return None
milestone_file_tailers = []
def start_reading_milestones():
if config.milestone_file is None: return
if isinstance(config.milestone_file, basestring):
files = [config.milestone_file]
else:
files = config.milestone_file
for f in files:
milestone_file_tailers.append(FileTailer(f, handle_new_milestone))
def handle_new_milestone(line):
data = parse_where_data(line)
if "name" not in data: return
game = find_running_game(data.get("name"), data.get("start"))
if game: game.log_milestone(data)
class CrawlWebSocket(tornado.websocket.WebSocketHandler):
def __init__(self, app, req, **kwargs):
tornado.websocket.WebSocketHandler.__init__(self, app, req, **kwargs)
self.username = None
self.timeout = None
self.watched_game = None
self.process = None
self.game_id = None
self.received_pong = None
self.ioloop = tornado.ioloop.IOLoop.instance()
global current_id
self.id = current_id
current_id += 1
self.deflate = True
self._compressobj = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
zlib.DEFLATED,
-zlib.MAX_WBITS)
self.total_message_bytes = 0
self.compressed_bytes_sent = 0
self.uncompressed_bytes_sent = 0
self.message_queue = []
self.subprotocol = None
self.logger = logging.LoggerAdapter(logging.getLogger(), {})
self.logger.process = self._process_log_msg
self.message_handlers = {
"login": self.login,
"token_login": self.token_login,
"set_login_cookie": self.set_login_cookie,
"forget_login_cookie": self.forget_login_cookie,
"play": self.start_crawl,
"pong": self.pong,
"watch": self.watch,
"chat_msg": self.post_chat_message,
"register": self.register,
"go_lobby": self.go_lobby,
"get_rc": self.get_rc,
"set_rc": self.set_rc,
}
client_closed = property(lambda self: (not self.ws_connection) or self.ws_connection.client_terminated)
def _process_log_msg(self, msg, kwargs):
return "#%-5s %s" % (self.id, msg), kwargs
def __hash__(self):
return self.id
def __eq__(self, other):
return self.id == other.id
def allow_draft76(self):
return True
def select_subprotocol(self, subprotocols):
if "no-compression" in subprotocols:
self.deflate = False
self.subprotocol = "no-compression"
return "no-compression"
return None
def open(self):
compression = "on"
if isinstance(self.ws_connection, getattr(tornado.websocket, "WebSocketProtocol76", ())):
# Old Websocket versions don't support binary messages
self.deflate = False
compression = "off, old websockets"
elif self.subprotocol == "no-compression":
compression = "off, client request"
if hasattr(self, "get_extensions"):
if any(s.endswith("deflate-frame") for s in self.get_extensions()):
self.deflate = False
compression = "deflate-frame extension"
self.logger.info("Socket opened from ip %s (fd%s, compression: %s).",
self.request.remote_ip,
self.request.connection.stream.socket.fileno(),
compression)
sockets.add(self)
self.reset_timeout()
if config.max_connections < len(sockets):
self.write_message("connection_closed('The maximum number of connections "
+ "has been reached, sorry :(');")
self.close()
elif shutting_down:
self.close()
else:
if config.dgl_mode:
if hasattr(config, "autologin") and config.autologin:
self.do_login(config.autologin)
self.send_lobby()
else:
self.start_crawl(None)
def idle_time(self):
return self.process.idle_time()
def is_running(self):
return self.process is not None
def is_in_lobby(self):
return not self.is_running() and self.watched_game is None
def send_lobby(self):
self.queue_message("lobby_clear")
from process_handler import processes
for process in processes.values():
self.queue_message("lobby_entry", **process.lobby_entry())
self.send_message("lobby_complete")
def send_game_links(self):
# Rerender Banner
banner_html = self.render_string("banner.html", username = self.username)
self.queue_message("html", id = "banner", content = banner_html)
play_html = self.render_string("game_links.html", games = config.games)
self.send_message("set_game_links", content = play_html)
def reset_timeout(self):
if self.timeout:
self.ioloop.remove_timeout(self.timeout)
self.received_pong = False
self.send_message("ping")
self.timeout = self.ioloop.add_timeout(time.time() + config.connection_timeout,
self.check_connection)
def check_connection(self):
self.timeout = None
if not self.received_pong:
self.logger.info("Connection timed out.")
self.close()
else:
if self.is_running() and self.process.idle_time() > config.max_idle_time:
self.logger.info("Stopping crawl after idle time limit.")
self.process.stop()
if not self.client_closed:
self.reset_timeout()
def start_crawl(self, game_id):
if config.dgl_mode and game_id not in config.games:
self.go_lobby()
return
if config.dgl_mode:
game_params = dict(config.games[game_id])
if self.username == None:
if self.watched_game:
self.stop_watching()
self.send_message("login_required", game = game_params["name"])
return
if self.process:
# ignore multiple requests for the same game, can happen when
# logging in with cookies
if self.game_id != game_id:
self.go_lobby()
return
self.game_id = game_id
import process_handler
if config.dgl_mode:
game_params["id"] = game_id
args = (game_params, self.username, self.logger, self.ioloop)
if (game_params.get("compat_mode") or
"client_prefix" in game_params):
self.process = process_handler.CompatCrawlProcessHandler(*args)
else:
self.process = process_handler.CrawlProcessHandler(*args)
else:
self.process = process_handler.DGLLessCrawlProcessHandler(self.logger, self.ioloop)
self.process.end_callback = self._on_crawl_end
self.process.add_watcher(self)
try:
self.process.start()
except Exception:
self.logger.warning("Exception starting process!", exc_info=True)
self.process = None
self.go_lobby()
else:
if self.process is None: # Can happen if the process creation fails
self.go_lobby()
return
self.send_message("game_started")
if config.dgl_mode:
if self.process.where == {}:
# If location info was found, the lobbys were already
# updated by set_where_data
update_all_lobbys(self.process)
update_global_status()
def _on_crawl_end(self):
if config.dgl_mode:
remove_in_lobbys(self.process)
reason = self.process.exit_reason
message = self.process.exit_message
dump_url = self.process.exit_dump_url
self.process = None
if self.client_closed:
sockets.remove(self)
else:
if shutting_down:
self.close()
else:
# Go back to lobby
self.send_message("game_ended", reason = reason,
message = message, dump = dump_url)
if config.dgl_mode:
if not self.watched_game:
self.send_message("go_lobby")
self.send_lobby()
else:
self.start_crawl(None)
if config.dgl_mode:
update_global_status()
if shutting_down and len(sockets) == 0:
# The last crawl process has ended, now we can go
self.ioloop.stop()
def init_user(self):
with open("/dev/null", "w") as f:
result = subprocess.call([config.init_player_program, self.username],
stdout = f, stderr = subprocess.STDOUT)
return result == 0
def stop_watching(self):
if self.watched_game:
self.logger.info("Stopped watching %s.", self.watched_game.username)
self.watched_game.remove_watcher(self)
self.watched_game = None
def shutdown(self):
if not self.client_closed:
msg = self.render_string("shutdown.html", game=self)
self.send_message("close", reason = msg)
self.close()
if self.is_running():
self.process.stop()
def do_login(self, username):
self.username = username
self.logger.extra["username"] = username
if not self.init_user():
msg = ("Could not initialize your rc and morgue!<br>" +
"This probably means there is something wrong " +
"with the server configuration.")
self.send_message("close", reason = msg)
self.logger.warning("User initialization returned an error for user %s!",
self.username)
self.username = None
self.close()
return
self.queue_message("login_success", username = username)
if self.watched_game:
self.watched_game.update_watcher_description()
else:
self.send_game_links()
def login(self, username, password):
real_username = user_passwd_match(username, password)
if real_username:
self.logger.info("User %s logged in.", real_username)
self.do_login(real_username)
else:
self.logger.warning("Failed login for user %s.", username)
self.send_message("login_fail")
def token_login(self, cookie):
username, _, token = cookie.partition(' ')
try:
token = long(token)
except ValueError:
token = None
if (token, username) in login_tokens:
del login_tokens[(token, username)]
self.logger.info("User %s logged in (via token).", username)
self.do_login(username)
else:
self.logger.warning("Wrong login token for user %s.", username)
self.send_message("login_fail")
def set_login_cookie(self):
if self.username is None: return
token = rand.getrandbits(128)
expires = datetime.datetime.now() + datetime.timedelta(config.login_token_lifetime)
login_tokens[(token, self.username)] = expires
cookie = self.username + " " + str(token)
self.send_message("login_cookie", cookie = cookie,
expires = config.login_token_lifetime)
def forget_login_cookie(self, cookie):
try:
username, _, token = cookie.partition(' ')
try:
token = long(token)
except ValueError:
token = None
if (token, username) in login_tokens:
del login_tokens[(token, username)]
except ValueError:
return
def pong(self):
self.received_pong = True
def rcfile_path(self, game_id):
if game_id not in config.games: return None
if not self.username: return None
path = dgl_format_str(config.games[game_id]["rcfile_path"],
self.username, config.games[game_id])
return os.path.join(path, self.username + ".rc")
def send_json_options(self, game_id, player_name):
def do_send(data, returncode):
if returncode != 0:
# fail silently for returncode 1 for now, probably just an old
# version missing the command line option
if returncode != 1:
self.logger.warning("Error while getting JSON options!")
return
self.write_message('{"msg":"options","watcher":true,"options":'
+ data + '}')
if not self.username: return
if game_id not in config.games: return
game = config.games[game_id]
if not "send_json_options" in game or not game["send_json_options"]:
return
call = [game["crawl_binary"]]
if "pre_options" in game:
call += game["pre_options"]
call += ["-name", player_name,
"-rc", self.rcfile_path(game_id)]
if "options" in game:
call += game["options"]
call.append("-print-webtiles-options")
checkoutput.check_output(call, do_send, self.ioloop)
def watch(self, username):
if self.is_running():
self.process.stop()
from process_handler import processes
procs = [process for process in processes.values()
if process.username.lower() == username.lower()]
if len(procs) >= 1:
process = procs[0]
if self.watched_game:
if self.watched_game == process:
return
self.stop_watching()
self.logger.info("Started watching %s (P%s).", process.username,
process.id)
self.watched_game = process
process.add_watcher(self)
self.send_message("watching_started", username = process.username)
else:
if self.watched_game:
self.stop_watching()
self.go_lobby()
def post_chat_message(self, text):
receiver = None
if self.process:
receiver = self.process
elif self.watched_game:
receiver = self.watched_game
if receiver:
if self.username is None:
self.send_message("chat", content
= 'You need to log in to send messages!')
return
receiver.handle_chat_message(self.username, text)
def register(self, username, password, email):
error = register_user(username, password, email)
if error is None:
self.logger.info("Registered user %s.", username)
self.do_login(username)
else:
self.logger.info("Registration attempt failed for username %s: %s",
username, error)
self.send_message("register_fail", reason = error)
def go_lobby(self):
if self.is_running():
self.process.stop()
elif self.watched_game:
self.stop_watching()
self.send_message("go_lobby")
self.send_lobby()
else:
self.send_message("go_lobby")
def get_rc(self, game_id):
if game_id not in config.games: return
with open(self.rcfile_path(game_id), 'r') as f:
contents = f.read()
self.send_message("rcfile_contents", contents = contents)
def set_rc(self, game_id, contents):
rcfile_path = dgl_format_str(config.games[game_id]["rcfile_path"],
self.username, config.games[game_id])
rcfile_path = os.path.join(rcfile_path, self.username + ".rc")
with open(rcfile_path, 'w') as f:
f.write(contents.encode("utf8"))
def on_message(self, message):
if message.startswith("{"):
try:
obj = json_decode(message)
if obj["msg"] in self.message_handlers:
handler = self.message_handlers[obj["msg"]]
del obj["msg"]
handler(**obj)
elif self.process:
self.process.handle_input(message)
elif not self.watched_game:
self.logger.warning("Didn't know how to handle msg: %s",
obj["msg"])
except Exception:
self.logger.warning("Error while handling JSON message!",
exc_info=True)
elif self.process:
# This is just for compatibility with 0.9, 0.10 only sends
# JSON
self.process.handle_input(message)
def flush_messages(self):
if self.client_closed or len(self.message_queue) == 0:
return
msg = "{\"msgs\":[" + ",".join(self.message_queue) + "]}"
self.message_queue = []
try:
self.total_message_bytes += len(msg)
if self.deflate:
# Compress like in deflate-frame extension:
# Apply deflate, flush, then remove the 00 00 FF FF
# at the end
compressed = self._compressobj.compress(msg)
compressed += self._compressobj.flush(zlib.Z_SYNC_FLUSH)
compressed = compressed[:-4]
self.compressed_bytes_sent += len(compressed)
super(CrawlWebSocket, self).write_message(compressed, binary=True)
else:
self.uncompressed_bytes_sent += len(msg)
super(CrawlWebSocket, self).write_message(msg)
except:
self.logger.warning("Exception trying to send message.", exc_info = True)
if self.ws_connection != None:
self.ws_connection._abort()
def write_message(self, msg, send=True):
if self.client_closed: return
self.message_queue.append(utf8(msg))
if send:
self.flush_messages()
def send_message(self, msg, **data):
"""Sends a JSON message to the client."""
data["msg"] = msg
if not self.client_closed:
self.write_message(json_encode(data))
def queue_message(self, msg, **data):
data["msg"] = msg
if not self.client_closed:
self.write_message(json_encode(data), False)
def on_close(self):
if self.process is None and self in sockets:
sockets.remove(self)
if shutting_down and len(sockets) == 0:
# The last socket has been closed, now we can go
self.ioloop.stop()
elif self.is_running():
self.process.stop()
if self.watched_game:
self.watched_game.remove_watcher(self)
if self.timeout:
self.ioloop.remove_timeout(self.timeout)
if self.total_message_bytes == 0:
comp_ratio = "N/A"
else:
comp_ratio = 100 - 100 * (self.compressed_bytes_sent + self.uncompressed_bytes_sent) / self.total_message_bytes
self.logger.info("Socket closed. (%s bytes sent, compression ratio %s%%)",
self.total_message_bytes, comp_ratio)
|