Unable to Reconnect Back to Server

[laeig]

I have a script running locally on my pc and a server hosted on Replit. My project uses socketio to send screenshots of my desktop to essentially stream my desktop to a website. However, when the Replit server shuts down or restarts, the program still runs emit() without throwing any errors. I tried re-establishing the connection using

socket = socketio.Client()
socket.connect('<url>')

but after re-establishing the connection, nothing happens, no errors and my program still emits events that aren't being received by the server.

I can detect when the server shuts down by having the server send a heartbeat to my script and checking if the time between the heartbeats has been over x seconds an this works fine. However after detecting the server down and repeatedly trying to establish a connection again, the connection attempt appears to work but no connection is actually established. The reason I say appears is because there are no errors when emitting and the connect() function doesn't throw any errors either. The weirdest part is that when the server is down, nothing happens on the client, it's still able to emit(). However, after I turn the server back on, the server doesn't receive anything from the client even though the client isn't throwing any errors. Additionally, If I restart the client it can make the requests like normal and they're received by the server.

To sum it up, the client doesn't throw errors after the server stops, and after the server turns back on, it can't receive anything from the client. Sorry if this post has been confusing.

Here is the code on the server

from flask_socketio import SocketIO
from flask import render_template
from threading import Thread
from flask import Flask
import time

app = Flask(__name__)
socketio = SocketIO(app)

@app.route('/')
def app_index():
  return render_template('index.html')

@socketio.on('ScreenshotSend')
def handle_screenshot_full(data):
  socketio.emit('TransferScreenshot', data)

def send_heartbeats():
  while True:
    socketio.emit('ack')
    time.sleep(5)

Thread(target=send_heartbeats).start()
socketio.run(app, host='0.0.0.0', port=8080)

Here is the code running on the client (local python)

from threading import Thread
from PIL import Image
import pyautogui
import socketio
import requests
import base64
import dxcam
import time
import gzip
import sys
import os
import io

socket = socketio.Client()
LAST_HEARTBEAT = time.time()
DISCONNECTED = False

@socket.on('connect')
def on_connect():
    print('Connected to server')

@socket.on('ack')
def ack():
    global LAST_HEARTBEAT
    LAST_HEARTBEAT = time.time()

def check_connection():
    global socket, DISCONNECTED
    while True:
        if time.time()-LAST_HEARTBEAT > 7:
            if not DISCONNECTED:
                print('Disconnected from server!')
            DISCONNECTED = True
            socket = socketio.Client()
            socket.connect('<url>')
        time.sleep(1)

if __name__ == '__main__':
    resolution = 4
    socket.connect('<url>')
    Thread(target=check_connection).start()
    camera = dxcam.create()
    camera.start()

    while True:
        screenshot = Image.fromarray(camera.get_latest_frame())
        width, height = screenshot.size
        screenshot = screenshot.resize((width // resolution, height // resolution))

        buffer = io.BytesIO()
        screenshot.save(buffer, format="WEBP")
        screenshot_base64 = base64.b64encode(gzip.compress(buffer.getvalue())).decode('utf-8')

        socket.emit('ScreenshotSend', {'data': screenshot_base64})

[miguelgrinberg]

The Socket.IO client has its own reconnection logic, you do not need to do anything. The disconnect handler is called when the connection with the server breaks, so that is your cue to stop sending screenshots. The client will attempt to reconnect, and as soon as it succeeds your connect handler will be invoked, and you can resume sending.

Alternatively, you may want to look into using the SimpleClient class, which will simplify your client code a bit.

[laeig]

The reason why I wrote my own reconnection logic is because the built-in one didn't seem to work for me. I have tried and am using this code now:

    resolution = 4
    socket.connect('<url>')
    camera = dxcam.create()
    camera.start()

    while True:
        screenshot = Image.fromarray(camera.get_latest_frame())
        width, height = screenshot.size
        screenshot = screenshot.resize((width // resolution, height // resolution))

        buffer = io.BytesIO()
        screenshot.save(buffer, format="WEBP")
        screenshot_base64 = base64.b64encode(gzip.compress(buffer.getvalue())).decode('utf-8')

        socket.emit('ScreenshotSend', {'data': screenshot_base64})

After I stop the server, no errors occur and the program stops. However, upon restarting the server, the server is unable to receive any of the data from the client even though the client is still running.

[miguelgrinberg]

The program stops? How does it stop? What makes your while True loop exit?

[laeig]

Sorry for the late reply. To clarify what I mean by 'stops' is it stops running the emit function correctly so that the server receives it. Even after the server is back up again, the emit function in the program has no effect. I added print statements to before and after to see if my program was even sending them but it was emitting data, the server just couldn't receive it. However upon restarting the program, emit worked again.