X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=server_%2Fio.py;h=c8f6114514b460ed0ccf3101ce09dd7185f02649;hb=a455c9f392345a42c0dec745db3b65080172db77;hp=7a4c3b0fc5717bca8ece750f5c62d111b3302c4f;hpb=52a7b4e9b1ef3e38701409d963f49033c23d4eaf;p=plomrogue2-experiments diff --git a/server_/io.py b/server_/io.py index 7a4c3b0..c8f6114 100644 --- a/server_/io.py +++ b/server_/io.py @@ -4,21 +4,18 @@ import queue import sys sys.path.append('../') import parser +from server_.game_error import GameError # 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) + def __init__(self, queue, port, *args, **kwargs): + super().__init__(('localhost', port), IO_Handler, *args, **kwargs) self.queue_out = queue self.daemon_threads = True # Else, server's threads have daemon=False. @@ -48,45 +45,39 @@ class IO_Handler(socketserver.BaseRequestHandler): 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): + def send_queue_messages(plom_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) + plom_socket.send(msg, True) import uuid + import plom_socket + plom_socket = plom_socket.PlomSocket(self.request) 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)) + args=(plom_socket, queue_in, thread_alive)) t.start() - for message in plom_socket_io.recv(self.request): + for message in plom_socket.recv(): if message is None: - caught_send(self.request, 'BAD MESSAGE') + plom_socket.send('BAD MESSAGE', True) elif 'QUIT' == message: - caught_send(self.request, 'BYE') + plom_socket.send('BYE', True) 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() + plom_socket.socket.close() class GameIO(): @@ -126,6 +117,31 @@ class GameIO(): elif command_type == 'COMMAND': self.handle_input(content, connection_id) + def run_loop_with_server(self): + """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 self.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). 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=self.loop, daemon=True, args=(q,)) + c.start() + server = Server(q, 5000) + try: + server.serve_forever() + except KeyboardInterrupt: + pass + finally: + print('Killing server') + server.server_close() + def handle_input(self, input_, connection_id=None, store=True): """Process input_ to command grammar, call command handler if found.""" from inspect import signature @@ -138,21 +154,21 @@ class GameIO(): print(msg) try: - command = self.parser.parse(input_) + command, args = self.parser.parse(input_) if command is None: answer(connection_id, 'UNHANDLED_INPUT') else: if 'connection_id' in list(signature(command).parameters): - command(connection_id=connection_id) + command(*args, connection_id=connection_id) else: - command() - if store: + command(*args) + if store and not hasattr(command, 'dont_save'): with open(self.game_file_name, 'a') as f: f.write(input_ + '\n') except parser.ArgError as e: - answer(connection_id, 'ARGUMENT_ERROR ' + self.quote(str(e))) - except server_.game.GameError as e: - answer(connection_id, 'GAME_ERROR ' + self.quote(str(e))) + answer(connection_id, 'ARGUMENT_ERROR ' + quote(str(e))) + except GameError as e: + answer(connection_id, 'GAME_ERROR ' + quote(str(e))) def send(self, msg, connection_id=None): """Send message msg to server's client(s) via self.queues_out. @@ -168,40 +184,19 @@ class GameIO(): for connection_id in self.queues_out: self.queues_out[connection_id].put(msg) - def quote(self, string): - """Quote & escape string so client interprets it as single token.""" - # FIXME: Don't do this as a method, makes no sense. - quoted = [] - quoted += ['"'] - for c in string: - if c in {'"', '\\'}: - quoted += ['\\'] - quoted += [c] - quoted += ['"'] - return ''.join(quoted) - - -def run_server_with_io_loop(game): - """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 Game.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). 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=game.io.loop, daemon=True, args=(q,)) - c.start() - server = Server(q) - try: - server.serve_forever() - except KeyboardInterrupt: - pass - finally: - print('Killing server') - server.server_close() + +def quote(string): + """Quote & escape string so client interprets it as single token.""" + quoted = [] + quoted += ['"'] + for c in string: + if c in {'"', '\\'}: + quoted += ['\\'] + quoted += [c] + quoted += ['"'] + return ''.join(quoted) + + +def stringify_yx(tuple_): + """Transform tuple (y,x) into string 'Y:'+str(y)+',X:'+str(x).""" + return 'Y:' + str(tuple_[0]) + ',X:' + str(tuple_[1])