You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
114 lines
3.9 KiB
114 lines
3.9 KiB
# Helper class to track client connection status
|
|
import threading
|
|
import time
|
|
import socket
|
|
|
|
from message_queue.Manager import Manager
|
|
import shared_manager
|
|
from utils import manager_callback
|
|
|
|
|
|
def start_discovery_service(port):
|
|
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
sock.bind(('0.0.0.0', port))
|
|
print(f"Discovery service listening on port {port}...")
|
|
|
|
while True:
|
|
data, addr = sock.recvfrom(1024)
|
|
if data.decode() == "DISCOVER_SERVER":
|
|
print(f"Received discovery request from {addr}")
|
|
sock.sendto(b"SERVER_RESPONSE", addr)
|
|
break
|
|
sock.close()
|
|
return addr
|
|
|
|
class ConnectionTracker:
|
|
def __init__(self):
|
|
self.last_message_time = time.time()
|
|
self.timeout = 15 # 15-second timeout
|
|
self.last_client_ip = None # Track last connected client IP
|
|
|
|
def update_last_message_time(self, client_ip=None):
|
|
self.last_message_time = time.time()
|
|
if client_ip:
|
|
self.last_client_ip = client_ip # Update last known client
|
|
|
|
def is_client_active(self):
|
|
"""Check if the last client is still active within the last 15 seconds."""
|
|
return (time.time() - self.last_message_time) < self.timeout
|
|
# Create an instance of ConnectionTracker
|
|
connection_tracker = ConnectionTracker()
|
|
|
|
|
|
class ConnectionThread(threading.Thread):
|
|
def __init__(self,debug = False,core = None):
|
|
super().__init__()
|
|
self.running = True
|
|
self.__debug = debug
|
|
self.__core = core
|
|
|
|
def run(self):
|
|
while self.running:
|
|
time.sleep(0.5)
|
|
|
|
if connection_tracker.last_client_ip:
|
|
|
|
if self.__debug:
|
|
print(f"Checking if last client {connection_tracker.last_client_ip} is still available...")
|
|
|
|
if self.query_last_client(connection_tracker.last_client_ip):
|
|
connection_tracker.update_last_message_time()
|
|
|
|
if self.__debug:
|
|
print(f"Last client {connection_tracker.last_client_ip} responded. Continuing...")
|
|
continue # Skip discovering a new client
|
|
if not connection_tracker.is_client_active():
|
|
|
|
|
|
print("Client inactive for 15 seconds. Searching for another client...")
|
|
cl_ip, _ = start_discovery_service(12345)
|
|
print(f"New client found: {cl_ip}")
|
|
|
|
# Reinitialize the Manager with the new client address
|
|
shared_manager.manager = Manager(f"tcp://{cl_ip}:5558", f"tcp://{cl_ip}:5557")
|
|
shared_manager.manager.start(manager_callback)
|
|
|
|
connection_tracker.update_last_message_time(cl_ip) # Update with new client
|
|
|
|
def query_last_client(self, client_ip):
|
|
"""Send a heartbeat packet to the last known client IP on port 29170 and wait for a response."""
|
|
|
|
if self.__debug:
|
|
print(f"Sending heartbeat to {client_ip}:29170") # Debugging
|
|
|
|
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
sock.settimeout(5) # 5-second timeout
|
|
heartbeat_port = 29170 # New port for heartbeat
|
|
|
|
try:
|
|
sock.sendto(b"HEARTBEAT", (client_ip, heartbeat_port)) # Send heartbeat message
|
|
data, addr = sock.recvfrom(1024) # Wait for response
|
|
|
|
if self.__debug:
|
|
print(f"Received response from {addr}: {data.decode()}") # Debugging
|
|
|
|
if data.decode() == "HEARTBEAT_ACK":
|
|
connection_tracker.update_last_message_time() # Update the last message time
|
|
|
|
if self.__debug:
|
|
print(f"Client {client_ip} is still responding.")
|
|
return True
|
|
|
|
except socket.timeout:
|
|
|
|
print(f"Client {client_ip} did not respond. Marking as inactive.")
|
|
|
|
finally:
|
|
sock.close()
|
|
|
|
return False # Client did not respond
|
|
|
|
|
|
def stop(self):
|
|
self.running = False
|
|
|