119 lines
4.4 KiB
Python
119 lines
4.4 KiB
Python
import json
|
|
import socket
|
|
import threading
|
|
|
|
from Classes.System.Network.EventHandler import UDPEventHandler, TCPEventHandler
|
|
|
|
class NetworkManager:
|
|
|
|
class UDP:
|
|
__Addr:str
|
|
__Port:str
|
|
__BufferSize:int = 1024
|
|
__udpSocket:socket
|
|
__users:list
|
|
__UDPClientThread:threading.Thread
|
|
__eventHandler: UDPEventHandler
|
|
|
|
def __init__(self, Addr:str, Port:str):
|
|
clientUdpSocket, clientUdpAddress = self.__udpSocket.accept()
|
|
self.__Addr = Addr
|
|
self.__Port = int(Port)
|
|
|
|
self.__users = {}
|
|
self.__udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
self.__udpSocket.bind((self.__Addr, self.__Port))
|
|
self.__eventHandler = UDPEventHandler(clientUdpSocket)
|
|
|
|
self.__UDPClientThread = threading.Thread(target=self.receive)
|
|
self.__UDPClientThread.start()
|
|
|
|
# handles incomming udp data
|
|
def receive(self):
|
|
while True:
|
|
data, address = self.__udpSocket.recvfrom(self.__BufferSize)
|
|
message = data.decode()
|
|
messageJson = json.loads(message)
|
|
user = messageJson.get("user")
|
|
|
|
if user not in self.__users:
|
|
self.__users[user] = address # Storing new user in dictionary
|
|
|
|
# Process the message and handle accordingly
|
|
self.__eventHandler.handleUDPEvents(messageJson)
|
|
print(f"Received message from {address}: {message}")
|
|
|
|
def broadcast(self, payload:dict):
|
|
for user_address in self.__users.values():
|
|
self.__udpSocket.sendto(json.dumps(payload).encode(), user_address)
|
|
|
|
def send(self, payload:dict, user:str):
|
|
if user in self.__users:
|
|
self.__udpSocket.sendto(json.dumps(payload).encode(), self.__users[user])
|
|
|
|
class TCP:
|
|
def __init__(self, Addr: str, Port: str):
|
|
self.__Addr = Addr
|
|
self.__Port = int(Port)
|
|
self.__users = {}
|
|
self.__tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
self.__tcpSocket.bind((self.__Addr, self.__Port))
|
|
self.__tcpSocket.listen()
|
|
|
|
self.__eventHandler = TCPEventHandler()
|
|
|
|
self.__receive_thread = threading.Thread(target=self.accept_connections)
|
|
self.__receive_thread.start()
|
|
|
|
def accept_connections(self):
|
|
while True:
|
|
client_tcp_socket, client_address = self.__tcpSocket.accept()
|
|
print(f"Connected with {client_address}")
|
|
self.__users[client_address] = client_tcp_socket
|
|
client_handler_thread = threading.Thread(target=self.receive, args=(client_tcp_socket, client_address))
|
|
client_handler_thread.start()
|
|
|
|
def receive(self, __tcpSocket: socket.socket, address):
|
|
while True:
|
|
try:
|
|
data = __tcpSocket.recv(1024)
|
|
if not data:
|
|
break
|
|
|
|
message = data.decode()
|
|
message_json = json.loads(message)
|
|
user = message_json.get("user")
|
|
|
|
if user not in self.__users:
|
|
self.__users[user] = address # Storing new user in dictionary
|
|
|
|
# Process the message and handle accordingly
|
|
self.__eventHandler.handleTCPEvents(message_json)
|
|
print(f"Received message from {address}: {message}")
|
|
|
|
except ConnectionResetError:
|
|
print(f"Connection with {address} closed.")
|
|
del self.__users[address]
|
|
break
|
|
|
|
def broadcast(self, payload: dict):
|
|
for user_socket in self.__users.values():
|
|
user_socket.send(json.dumps(payload).encode())
|
|
|
|
def send(self, payload: dict, user_address):
|
|
if user_address in self.__users:
|
|
user_socket = self.__users[user_address]
|
|
user_socket.send(json.dumps(payload).encode())
|
|
else:
|
|
print(f"User {user_address} is not connected.")
|
|
|
|
def close(self):
|
|
self.__tcpSocket.close()
|
|
|
|
tcp: TCP
|
|
udp: UDP
|
|
|
|
def __init__(self, Addr:str, TCPPort:str, UDPPort:str):
|
|
self.tcp = self.TCP(Addr, TCPPort)
|
|
self.udp = self.UDP(Addr, UDPPort)
|