reaper_server.py

from sws_python import *
from socket import *
from select import select
import pickle
import struct

# debug_mode = False
debug_mode = True


def console_message(*args, sep=' ', end='\n'):
    if debug_mode:
        RPR_ShowConsoleMsg(f'{sep.join(map(str, args))}{end}')


port = 9009

server_socket = socket(AF_INET, SOCK_STREAM)
server_socket.setblocking(False)
server_socket.settimeout(0)

while True:
    try:
        server_socket.bind(('localhost', port))
        break
    except OSError:
        port += 1

console_message('Server opened on port', port)
RPR_SetExtState('server', 'port', port, False)
server_socket.listen(5)

client_sockets = []
empty_list = []

def loop():
    # accept a new client if available
    try:
        new_client_socket, new_client_address = server_socket.accept()
        console_message('New connection from:', new_client_address)
        client_sockets.append(new_client_socket)
        console_message('clients:', *map(lambda client: client.getpeername(), client_sockets))

    except BlockingIOError:
        pass

    # process a request, if available
    if len(client_sockets):
        ready_clients, _, _ = select(client_sockets, empty_list, empty_list, 0)
        for client_socket in ready_clients: # type: socket
            #console_message('ready clients:', ready_clients)
            try:
                message_size = client_socket.recv(4)
                if message_size:
                    message_size = struct.unpack('<I', message_size)[0]
                else:
                    raise ConnectionError

                message = client_socket.recv(message_size)
                if message:
                    console_message('Message from', client_socket.getpeername(), '-', message)
                    result = None
                    try:
                        result = eval(message)
                        result = pickle.dumps(result, protocol=pickle.HIGHEST_PROTOCOL)

                    except Exception as e:
                        result = pickle.dumps(e, protocol=pickle.HIGHEST_PROTOCOL)

                    client_socket.send(struct.pack('<I', len(result)) + result)
                else:
                    raise ConnectionError

            except ConnectionError:
                console_message("Client", client_socket.getpeername(), "disconnected.")
                client_socket.close()
                client_sockets.remove(client_socket)
                console_message('clients:', *map(lambda client: client.getpeername(), client_sockets))
                continue
            break

    # enqueue next cycle
    RPR_defer('loop()')

if __name__ == '__main__':
    console_message('Awaiting connections...')
    #RPR_atexit('server_socket.close()')
    RPR_defer('loop()')