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 pair(self):
"""Start app in pairing mode"""
self.log.setLevel(logging.WARNING)
self.dm = self.init_dm()
code = str(randint(100000, 999999))
print('App running in pairing mode')
print(f'Pair code:\n\n {code[:3]}-{code[3:]} \n')
udp = UDPServer(('0.0.0.0', self.conf['port']), ServerSearchHandler)
udp.app = self
udp.pairing_code = code
udp.paired_uin = None
signal.signal(
signal.SIGINT, lambda a, b: Thread(name='Thread-UDP-Main-Shutdown',
target=udp.shutdown).start())
udp.serve_forever(0.25)
paired_uin = udp.paired_uin
print(f'Successful pairing with device {paired_uin}'
if paired_uin else 'Pairing failed')
udp.server_close()
del udp
sys.exit(0 if paired_uin else 1)
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()
