Rosbridge Connection & Reconnect

self.direct = not self.jumphost_ip
...
if not self.direct:
    self.url = f"ws://{self.jumphost_ip}:{self.jumphost_port}"   # + x-drone-ip / x-drone-port headers
else:
    self.url = f"ws://{self.drone_ip}:{self.drone_port}"

def send_message(self, message):
    self.outgoing_queue.put(message, timeout=1.0)   # raises queue.Full after 1s

while True and not self.time_to_join:
    try:
        message = self.outgoing_queue.get(timeout=1.0)
        topic = message.lower()
        if "subscri" in topic and "unsubscri" not in topic:
            self.subscriptions.add(message)       # track for replay (add-only!)
        try:
            self.ws.send(message)
        except Exception:
            if self.requeue:                      # REQUEUE env, default false
                self.outgoing_queue.put_nowait(message)
                time.sleep(0.1)
    except queue.Empty:
        pass   # wake every 1s to re-check time_to_join

def on_open(self, ws):
    self.is_live = True
    if not self.consumer_thread.is_alive():
        self.consumer_thread = threading.Thread(target=self.send_buffered_messages)
        self.consumer_thread.start()
    if self.subscriptions:
        for subscription in self.subscriptions:
            self.send_message(subscription)   # re-subscribe
    self.last_connect = time.time()

if self.queues.get(topic) and len(self.queues.get(topic)) <= 10:
    self.queues[topic].append(msg_data)
else:
    self.queues[topic] = []
    self.queues[topic].append(msg_data)

if self.socketio_callback:
    self.socketio_callback(topic, msg_data)   # -> DroneControlService._emit_telemetry

event = threading.Event()
self.pending_service_calls[service_id] = event
self.send_message(message)
if event.wait(timeout):
    response = self.service_responses.pop(service_id, None)
    self.pending_service_calls.pop(service_id, None)
    if response:
        return {"success": response.get("result", False),
                "values": response.get("values", {}),
                "response": response}
    return {"success": False, "error": "Empty response"}
# timed out
return {"success": False, "error": f"Timeout after {timeout}s"}

if the_connection and the_connection.is_expired():
    the_connection.start_connection()   # re-probe + reconnect

def on_reconnect(self):
    if self.last_connect != 0:            # not on the very first connect
        self.outgoing_queue = self._make_send_queue()   # drops whatever was queued
    self.last_reconnect = time.time()