#!/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):
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 = {}
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')
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)
--- /dev/null
+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()
projects / plomrogue2-experiments / commitdiff