Skip to content
Snippets Groups Projects
Commit 939bcd44 authored by Paul-Winpenny's avatar Paul-Winpenny
Browse files

OOPified the wifi handler.

parent 7680cd6e
No related branches found
No related tags found
No related merge requests found
import queue
import socket
import threading
import time
UDP_IP = "255.255.255.255"
UDP_PORT = 5005
LISTEN_PORT = 5006
def broadcast_presence():
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
while True:
message = b"ROBOBIN_PRESENT"
sock.sendto(message, (UDP_IP, UDP_PORT))
print("Broadcasting: {}".format(message.decode()))
time.sleep(5)
def handle_ping(client_socket):
print("Received PING from client.")
response = b"PONG"
print("Sending PONG to client.")
client_socket.sendall(response)
def handle_time_request(client_socket):
current_time = time.ctime().encode()
print(f"Sending current time: {current_time.decode()}")
client_socket.sendall(current_time)
def handle_custom_message(client_socket, message):
response = f"Received custom message: {message}".encode()
print(f"Custom handler response: {response.decode()}")
client_socket.sendall(response)
def handle_unknown_message(client_socket):
response = b"I don't know this message."
print("Sending response to unknown message.")
client_socket.sendall(response)
message_handlers = {
"PING": handle_ping,
"TIME": handle_time_request,
"CUSTOM": handle_custom_message,
}
def handle_client_connection(client_socket):
try:
while True:
request = client_socket.recv(1024)
if not request:
print("No request received, closing connection.")
break
message = request.decode()
print("Received from client: {}".format(message))
parts = message.split(" ", 1)
message_type = parts[0]
message_data = parts[1] if len(parts) > 1 else None
if message_type in message_handlers:
if message_type == "CUSTOM" and message_data:
message_handlers[message_type](client_socket, message_data)
else:
message_handlers[message_type](client_socket)
else:
handle_unknown_message(client_socket)
except ConnectionResetError:
print("Client connection was forcibly closed.")
except Exception as e:
print(f"An error occurred while handling the client connection: {e}")
finally:
client_socket.close()
print("Client disconnected.")
def listen_for_connections():
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(('', LISTEN_PORT))
while True:
class RoboBinConnectionHandler:
def __init__(self, udp_ip="255.255.255.255", udp_port=5005, listen_port=5006):
self.queue = queue.Queue(10)
self.UDP_IP = udp_ip
self.UDP_PORT = udp_port
self.LISTEN_PORT = listen_port
self.stop_event = threading.Event()
self.message_handlers = {
"PING": self.handle_ping,
"TIME": self.handle_time_request,
"CALLOVER" : self.handle_call_over,
"CUSTOM": self.handle_custom_message,
}
self.udp_sock = None
self.tcp_socket = None #
def broadcast_presence(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
while not self.stop_event.is_set():
message = b"ROBOBIN_PRESENT"
try:
sock.sendto(message, (self.UDP_IP, self.UDP_PORT))
print("Broadcasting: {}".format(message.decode()))
except OSError as e:
print(f"Broadcast error: {e}")
break
time.sleep(5)
sock.close()
print("Broadcasting stopped.")
def handle_ping(self, client_socket):
print("Received PING from client.")
response = b"PONG"
print("Sending PONG to client.")
client_socket.sendall(response)
def handle_time_request(self, client_socket):
current_time = time.ctime().encode()
print(f"Sending current time: {current_time.decode()}")
client_socket.sendall(current_time)
def handle_custom_message(self, client_socket, message):
response = f"Received custom message: {message}".encode()
print(f"Custom handler response: {response.decode()}")
client_socket.sendall(response)
def handle_call_over(self, client_socket, message):
response = f"User has requested node: {message}".encode()
print(f"Call over handler response: {response.decode()}")
client_socket.sendall(response)
def handle_unknown_message(self, client_socket):
response = b"I don't know this message."
print("Sending response to unknown message.")
client_socket.sendall(response)
def handle_client_connection(self, client_socket):
try:
data, addr = sock.recvfrom(1024)
if data.decode() == "CONNECT":
print("Received connection request from {}".format(addr))
while not self.stop_event.is_set():
client_socket.settimeout(1)
try:
request = client_socket.recv(1024)
except socket.timeout:
continue
except OSError as e:
print(f"Client socket error: {e}")
break
if not request:
print("No request received, closing connection.")
break
message = request.decode()
print("Received from client: {}".format(message))
parts = message.split(" ", 1)
message_type = parts[0]
message_data = parts[1] if len(parts) > 1 else None
if message_type in self.message_handlers:
if message_data:
self.message_handlers[message_type](client_socket, message_data)
else:
self.message_handlers[message_type](client_socket)
else:
self.handle_unknown_message(client_socket)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as tcp_socket:
tcp_socket.bind(('', 5006))
tcp_socket.listen(1)
except ConnectionResetError:
print("Client connection was forcibly closed.")
except Exception as e:
print(f"An error occurred while handling the client connection: {e}")
finally:
client_socket.close()
print("Client disconnected.")
def listen_for_connections(self):
self.udp_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.udp_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.udp_sock.bind(('', self.LISTEN_PORT))
while not self.stop_event.is_set():
try:
self.udp_sock.settimeout(1) # Timeout for blocking recvfrom call
data, addr = self.udp_sock.recvfrom(1024)
if data.decode() == "CONNECT":
print("Received connection request from {}".format(addr))
self.tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.tcp_socket.bind(('', self.LISTEN_PORT))
self.tcp_socket.listen(1)
print("Listening for TCP connection...")
client_socket, client_addr = tcp_socket.accept()
client_socket, client_addr = self.tcp_socket.accept()
print("Client connected from {}".format(client_addr))
threading.Thread(target=handle_client_connection, args=(client_socket,)).start()
except Exception as e:
print(f"An error occurred while listening for connections: {e}")
# Start broadcasting and listening threads
broadcast_thread = threading.Thread(target=broadcast_presence)
listen_thread = threading.Thread(target=listen_for_connections)
broadcast_thread.start()
listen_thread.start()
broadcast_thread.join()
listen_thread.join()
threading.Thread(target=self.handle_client_connection, args=(client_socket,)).start()
except socket.timeout:
continue
except OSError as e:
print(f"UDP socket no longer open (likely due to stop event):" )
break
except Exception as e:
print(f"An error occurred while listening for connections: {e}")
# Close sockets if stop event is set
if self.udp_sock:
self.udp_sock.close()
if self.tcp_socket:
self.tcp_socket.close()
print("Listening stopped.")
def start(self):
self.broadcast_thread = threading.Thread(target=self.broadcast_presence)
self.listen_thread = threading.Thread(target=self.listen_for_connections)
self.broadcast_thread.start()
self.listen_thread.start()
def stop(self):
print("Stopping server...")
self.stop_event.set()
# Safely close the sockets to prevent further operations on closed sockets
if self.udp_sock:
self.udp_sock.close()
if self.tcp_socket:
self.tcp_socket.close()
self.broadcast_thread.join()
self.listen_thread.join()
print("Server stopped.")
# Instantiate and start the handler
if __name__ == "__main__":
robobin_handler = RoboBinConnectionHandler()
robobin_handler.start()
print("Server started. Type 'stop' to shut down.")
# Main loop to accept CLI input
while True:
command = input("Enter command: ")
if command.strip().lower() == "stop":
robobin_handler.stop()
elif command.strip().lower() == "status":
print("Server is running.")
#printstatus() # Funciton will be added later
break
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment