class UDPServerThread(threading.Thread):
server = None
def run(self):
addr = ("", PORT)
print("UDP server listening on", addr)
self.server = UDPServer(addr, Handler)
self.server.serve_forever()
def shutdown(self):
self.server.shutdown()
class PipelineStatusListener(object):
"""Creates a server to listen for progress updates sent out by the pipeline
callbacks. Note that this should be used as a context manager to start the
server in a background thread and close it automatically::
with PipelineStatusListener(callback):
# do stuff here
pass
Parameters
----------
callback : callable
Callback to execute upon receiving a message. This should take a single
dict argument.
pipeline_id : str or None
Pipeline ID to filter on or None to listen to all.
port : int
Port number to listen on
Notes
-----
Start the server in a separate thread and stop it with the ``shutdown``
method.
"""
def __init__(self, callback, pipeline_id=None, port=50001):
class Handler(DatagramRequestHandler):
def handle(self):
data = self.request[0]
record = logging.makeLogRecord(pickle.loads(data[4:]))
if pipeline_id is not None:
if record.name != pipeline_id:
return
msg = json.loads(record.msg)
callback(msg)
self._handler_class = Handler
self.host = '127.0.0.1'
self.port = port
self.server = None
self._server_thread = None # type: Thread
def __enter__(self):
self.server = UDPServer(('127.0.0.1', self.port), self._handler_class)
self._server_thread = Thread(target=self.server.serve_forever)
self._server_thread.start()
def __exit__(self, type, value, traceback):
self.server.shutdown()
class UDPManager(object):
"""This class starts and stops the sending and receiving threads.
"""
def __init__(self, host_ip):
"""Initializes the attributes
:param host_ip: The ip of the network interface where this service is running.
:return: None
"""
# initializes the Sender Thread
self._sending_thread = UDPSenderThread()
# initializes the udpserver with our ThreadedUDPMulticastRequestHandler
# as arguments for the constructor of the RequestHandler we have to pass
# the update method of the Observable Implementation and the ip-address of the network interface
# where this service is running.
self.udp_server = UDPServer(MULTICAST_GROUP, lambda *args, **keys: ThreadedUDPMulticastRequestHandler(
UDPObservableSingleton.instance.observable.update_received_list,
host_ip, self._sending_thread.expand_timeout, *args, **keys))
self._receiver_thread = Thread(target=self.udp_server.serve_forever, daemon=True)
self._logger = Log.get_logger(self.__class__.__name__)
def start(self):
if not self._sending_thread.is_alive():
self._logger.info("Started SenderThread.")
self._sending_thread.start()
if not self._receiver_thread.is_alive():
self._logger.info("Started UDPServer.")
self._receiver_thread.start()
def stop(self):
if self._sending_thread.is_alive():
self._logger.info("Stopping SenderThread...")
self._sending_thread.stop()
if self._receiver_thread.is_alive():
self._logger.info("Stopping UDPServer...")
self.udp_server.shutdown()
self.udp_server.server_close()
def main():
logging.basicConfig(
format="%(asctime)s - SERVER - %(levelname)s - %(message)s",
level=logging.DEBUG)
# parse host and port args
parser = argparse.ArgumentParser(
description="battleship++ dedicated server")
parser.add_argument('host')
parser.add_argument('port', type=int)
args = parser.parse_args()
# start UPD discovery service
udpdiscovery_server = UDPServer(("", 12345), UDPDiscoveryHandler)
udpdiscovery_server_thread = threading.Thread(
target=udpdiscovery_server.serve_forever)
udpdiscovery_server_thread.daemon = True
udpdiscovery_server_thread.start()
logging.debug("UDP discovery server running in thread: " +
udpdiscovery_server_thread.name)
server = TCPServer((args.host, args.port), RequestHandler)
logging.info("Listening on {}:{}".format(args.host, args.port))
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
logging.debug("Server loop running in thread: " + server_thread.name)
# block until keyboard interrupt or system exit
try:
server_thread.join()
udpdiscovery_server_thread.join()
except (KeyboardInterrupt, SystemExit) as e:
logging.debug(repr(e))
# gracefully kill the server
logging.info("Server shutting down...")
server.shutdown()
server.server_close()
udpdiscovery_server.shutdown()
udpdiscovery_server.server_close()
logging.info("Bye!")
def main():
logging.basicConfig(format="%(asctime)s - SERVER - %(levelname)s - %(message)s", level=logging.DEBUG)
# parse host and port args
parser = argparse.ArgumentParser(description="battleship++ dedicated server")
parser.add_argument('host')
parser.add_argument('port', type=int)
args = parser.parse_args()
# start UPD discovery service
udpdiscovery_server = UDPServer(("", 12345), UDPDiscoveryHandler)
udpdiscovery_server_thread = threading.Thread(target=udpdiscovery_server.serve_forever)
udpdiscovery_server_thread.daemon = True
udpdiscovery_server_thread.start()
logging.debug("UDP discovery server running in thread: " + udpdiscovery_server_thread.name)
server = TCPServer((args.host, args.port), RequestHandler)
logging.info("Listening on {}:{}".format(args.host, args.port))
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
logging.debug("Server loop running in thread: " + server_thread.name)
# block until keyboard interrupt or system exit
try:
server_thread.join()
udpdiscovery_server_thread.join()
except (KeyboardInterrupt, SystemExit) as e:
logging.debug(repr(e))
# gracefully kill the server
logging.info("Server shutting down...")
server.shutdown()
server.server_close()
udpdiscovery_server.shutdown()
udpdiscovery_server.server_close()
logging.info("Bye!")
class IPComms(Comms):
def __init__(
self,
*,
queue: Queue,
server_host: str = HOSTNAME,
server_port: int = PORT,
client_host: str = HOSTNAME,
client_port: int = PORT,
await_response=False,
):
super().__init__(queue=queue)
UDPHandler.queue = self.queue
self.server_address = (server_host, server_port)
self.server = UDPServer(self.server_address, UDPHandler)
self.client_address = (client_host, client_port)
self.await_response = await_response
def read_telemetry_forever(self):
self.server.serve_forever()
def stop(self):
self.server.shutdown()
self.server.server_close()
# XXX
def send_packet(self, packet: bytes):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto(packet, self.client_address)
print(f"Sent packet: {packet}")
if self.await_response:
received_data = str(sock.recv(1024), "utf-8")
print(f"Received: {received_data}")
finally:
sock.close()
