From: Christian Heller Date: Tue, 15 Jan 2019 00:34:34 +0000 (+0100) Subject: Refactor. X-Git-Url: https://plomlompom.com/repos/?p=plomrogue2-experiments;a=commitdiff_plain;h=6c2138deeea000ebb531203445fa22c1f7a6f0da Refactor. --- diff --git a/server.py b/server.py index 502482f..e17b3e6 100755 --- a/server.py +++ b/server.py @@ -1,90 +1,12 @@ #!/usr/bin/env python3 - -import socketserver -import threading -import queue import sys import os import parser import server_.game +import server_.io import game_common -# Avoid "Address already in use" errors. -socketserver.TCPServer.allow_reuse_address = True - - -class Server(socketserver.ThreadingTCPServer): - """Bind together threaded IO handling server and message queue.""" - - def __init__(self, queue, *args, **kwargs): - super().__init__(*args, **kwargs) - self.queue_out = queue - self.daemon_threads = True # Else, server's threads have daemon=False. - - -class IO_Handler(socketserver.BaseRequestHandler): - - def handle(self): - """Move messages between network socket and main thread via queues. - - On start, sets up new queue, sends it via self.server.queue_out to - main thread, and from then on receives messages to send back from the - main thread via that new queue. - - At the same time, loops over socket's recv to get messages from the - outside via self.server.queue_out into the main thread. Ends connection - once a 'QUIT' message is received from socket, and then also kills its - own queue. - - All messages to the main thread are tuples, with the first element a - meta command ('ADD_QUEUE' for queue creation, 'KILL_QUEUE' for queue - deletion, and 'COMMAND' for everything else), the second element a UUID - that uniquely identifies the thread (so that the main thread knows whom - to send replies back to), and optionally a third element for further - instructions. - """ - import plom_socket_io - - def caught_send(socket, message): - """Send message by socket, catch broken socket connection error.""" - try: - plom_socket_io.send(socket, message) - except plom_socket_io.BrokenSocketConnection: - pass - - def send_queue_messages(socket, queue_in, thread_alive): - """Send messages via socket from queue_in while thread_alive[0].""" - while thread_alive[0]: - try: - msg = queue_in.get(timeout=1) - except queue.Empty: - continue - caught_send(socket, msg) - - import uuid - print('CONNECTION FROM:', str(self.client_address)) - connection_id = uuid.uuid4() - queue_in = queue.Queue() - self.server.queue_out.put(('ADD_QUEUE', connection_id, queue_in)) - thread_alive = [True] - t = threading.Thread(target=send_queue_messages, - args=(self.request, queue_in, thread_alive)) - t.start() - for message in plom_socket_io.recv(self.request): - if message is None: - caught_send(self.request, 'BAD MESSAGE') - elif 'QUIT' == message: - caught_send(self.request, 'BYE') - break - else: - self.server.queue_out.put(('COMMAND', connection_id, message)) - self.server.queue_out.put(('KILL_QUEUE', connection_id)) - thread_alive[0] = False - print('CONNECTION CLOSED FROM:', str(self.client_address)) - self.request.close() - - def fib(n): """Calculate n-th Fibonacci number. Very inefficiently.""" if n in (1, 2): @@ -93,7 +15,7 @@ def fib(n): return fib(n-1) + fib(n-2) -class CommandHandler(game_common.Commander, server_.game.Commander): +class CommandHandler(server_.game.Commander): def __init__(self, game_file_name): self.queues_out = {} @@ -218,41 +140,11 @@ class CommandHandler(game_common.Commander, server_.game.Commander): self.pool_result = self.pool.map_async(fib, (35, 35)) -def io_loop(q, commander): - """Handle commands coming through queue q, send results back. - - Commands from q are expected to be tuples, with the first element either - 'ADD_QUEUE', 'COMMAND', or 'KILL_QUEUE', the second element a UUID, and - an optional third element of arbitrary type. The UUID identifies a - receiver for replies. - - An 'ADD_QUEUE' command should contain as third element a queue through - which to send messages back to the sender of the command. A 'KILL_QUEUE' - command removes the queue for that receiver from the list of queues through - which to send replies. - - A 'COMMAND' command is specified in greater detail by a string that is the - tuple's third element. The commander CommandHandler takes care of processing - this and sending out replies. - """ - while True: - x = q.get() - command_type = x[0] - connection_id = x[1] - content = None if len(x) == 2 else x[2] - if command_type == 'ADD_QUEUE': - commander.queues_out[connection_id] = content - elif command_type == 'COMMAND': - commander.handle_input(content, connection_id) - elif command_type == 'KILL_QUEUE': - del commander.queues_out[connection_id] - - if len(sys.argv) != 2: print('wrong number of arguments, expected one (game file)') exit(1) game_file_name = sys.argv[1] -commander = CommandHandler(game_file_name) +command_handler = CommandHandler(game_file_name) if os.path.exists(game_file_name): if not os.path.isfile(game_file_name): print('game file name does not refer to a valid game file') @@ -262,26 +154,18 @@ if os.path.exists(game_file_name): for i in range(len(lines)): line = lines[i] print("FILE INPUT LINE %s: %s" % (i, line), end='') - commander.handle_input(line, store=False) + command_handler.handle_input(line, store=False) else: - commander.handle_input('MAP_SIZE Y:5,X:5') - commander.handle_input('TERRAIN_LINE 0 "xxxxx"') - commander.handle_input('TERRAIN_LINE 1 "x...x"') - commander.handle_input('TERRAIN_LINE 2 "x.X.x"') - commander.handle_input('TERRAIN_LINE 3 "x...x"') - commander.handle_input('TERRAIN_LINE 4 "xxxxx"') - commander.handle_input('THING_TYPE 0 human') - commander.handle_input('THING_POS 0 Y:3,X:3') - commander.handle_input('THING_TYPE 1 monster') - commander.handle_input('THING_POS 1 Y:1,X:1') -q = queue.Queue() -c = threading.Thread(target=io_loop, daemon=True, args=(q, commander)) -c.start() -server = Server(q, ('localhost', 5000), IO_Handler) -try: - server.serve_forever() -except KeyboardInterrupt: - pass -finally: - print('Killing server') - server.server_close() + command_handler.handle_input('MAP_SIZE Y:5,X:5') + command_handler.handle_input('TERRAIN_LINE 0 "xxxxx"') + command_handler.handle_input('TERRAIN_LINE 1 "x...x"') + command_handler.handle_input('TERRAIN_LINE 2 "x.X.x"') + command_handler.handle_input('TERRAIN_LINE 3 "x...x"') + command_handler.handle_input('TERRAIN_LINE 4 "xxxxx"') + command_handler.handle_input('THING_TYPE 0 human') + command_handler.handle_input('THING_POS 0 Y:3,X:3') + command_handler.handle_input('THING_TYPE 1 monster') + command_handler.handle_input('THING_POS 1 Y:1,X:1') + + +server_.io.run_server_with_io_loop(command_handler) diff --git a/server_/game.py b/server_/game.py index 59df5ae..f596f7b 100644 --- a/server_/game.py +++ b/server_/game.py @@ -186,7 +186,7 @@ class Thing(game_common.Thing): return visible_things -class Commander(): +class Commander(game_common.Commander): def cmd_MOVE(self, direction): """Set player task to 'move' with direction arg, finish player turn.""" diff --git a/server_/io.py b/server_/io.py new file mode 100644 index 0000000..e015b4f --- /dev/null +++ b/server_/io.py @@ -0,0 +1,143 @@ +import socketserver +import threading +import queue + + +# Avoid "Address already in use" errors. +socketserver.TCPServer.allow_reuse_address = True + + +# Our default server port. +SERVER_PORT=5000 + + +class Server(socketserver.ThreadingTCPServer): + """Bind together threaded IO handling server and message queue.""" + + def __init__(self, queue, *args, **kwargs): + super().__init__(('localhost', SERVER_PORT), IO_Handler, *args, **kwargs) + self.queue_out = queue + self.daemon_threads = True # Else, server's threads have daemon=False. + + +class IO_Handler(socketserver.BaseRequestHandler): + + def handle(self): + """Move messages between network socket and game IO loop via queues. + + On start (a new connection from client to server), sets up a + new queue, sends it via self.server.queue_out to the game IO + loop thread, and from then on receives messages to send back + from the game IO loop via that new queue. + + At the same time, loops over socket's recv to get messages + from the outside via self.server.queue_out into the game IO + loop. Ends connection once a 'QUIT' message is received from + socket, and then also calls for a kill of its own queue. + + All messages to the game IO loop are tuples, with the first + element a meta command ('ADD_QUEUE' for queue creation, + 'KILL_QUEUE' for queue deletion, and 'COMMAND' for everything + else), the second element a UUID that uniquely identifies the + thread (so that the game IO loop knows whom to send replies + back to), and optionally a third element for further + instructions. + + """ + import plom_socket_io + + def caught_send(socket, message): + """Send message by socket, catch broken socket connection error.""" + try: + plom_socket_io.send(socket, message) + except plom_socket_io.BrokenSocketConnection: + pass + + def send_queue_messages(socket, queue_in, thread_alive): + """Send messages via socket from queue_in while thread_alive[0].""" + while thread_alive[0]: + try: + msg = queue_in.get(timeout=1) + except queue.Empty: + continue + caught_send(socket, msg) + + import uuid + print('CONNECTION FROM:', str(self.client_address)) + connection_id = uuid.uuid4() + queue_in = queue.Queue() + self.server.queue_out.put(('ADD_QUEUE', connection_id, queue_in)) + thread_alive = [True] + t = threading.Thread(target=send_queue_messages, + args=(self.request, queue_in, thread_alive)) + t.start() + for message in plom_socket_io.recv(self.request): + if message is None: + caught_send(self.request, 'BAD MESSAGE') + elif 'QUIT' == message: + caught_send(self.request, 'BYE') + break + else: + self.server.queue_out.put(('COMMAND', connection_id, message)) + self.server.queue_out.put(('KILL_QUEUE', connection_id)) + thread_alive[0] = False + print('CONNECTION CLOSED FROM:', str(self.client_address)) + self.request.close() + + +def io_loop(q, game_command_handler): + """Handle commands coming through queue q, send results back. + + Commands from q are expected to be tuples, with the first element + either 'ADD_QUEUE', 'COMMAND', or 'KILL_QUEUE', the second element + a UUID, and an optional third element of arbitrary type. The UUID + identifies a receiver for replies. + + An 'ADD_QUEUE' command should contain as third element a queue + through which to send messages back to the sender of the + command. A 'KILL_QUEUE' command removes the queue for that + receiver from the list of queues through which to send replies. + + A 'COMMAND' command is specified in greater detail by a string + that is the tuple's third element. The game_command_handler takes + care of processing this and sending out replies. + + """ + while True: + x = q.get() + command_type = x[0] + connection_id = x[1] + content = None if len(x) == 2 else x[2] + if command_type == 'ADD_QUEUE': + game_command_handler.queues_out[connection_id] = content + elif command_type == 'COMMAND': + game_command_handler.handle_input(content, connection_id) + elif command_type == 'KILL_QUEUE': + del game_command_handler.queues_out[connection_id] + + +def run_server_with_io_loop(command_handler): + """Run connection of server talking to clients and game IO loop. + + We have the TCP server (an instance of Server) and we have the + game IO loop, a thread running io_loop. Both communicate with each + other via a queue.Queue. While the TCP server may spawn parallel + threads to many clients, the IO loop works sequentially through + game commands received from the TCP server's threads (= client + connections to the TCP server), calling command_handler to process + them. A processed command may trigger messages to the commanding + client or to all clients, delivered from the IO loop to the TCP + server via the queue. + + """ + q = queue.Queue() + c = threading.Thread(target=io_loop, daemon=True, args=(q, command_handler)) + c.start() + server = Server(q) + try: + server.serve_forever() + except KeyboardInterrupt: + pass + finally: + print('Killing server') + server.server_close()