pingproxy.py

#!/usr/bin/env python3

# PingProxy.py
# Connect multiple udp clients to a single serial device

from brping import PingParser
import serial
import socket
import time
from collections import deque
import errno


class PingClient(object):
    def __init__(self):
        ## Queued messages received from client
        self.rx_msgs = deque([])

        ## Parser to verify client comms
        self.parser = PingParser()

    ## Digest incoming client data
    # @return None
    def parse(self, data):
        for b in bytearray(data):
            if self.parser.parse_byte(b) == PingParser.NEW_MESSAGE:
                self.rx_msgs.append(self.parser.rx_msg)

    ## Dequeue a message received from client
    # @return None: if there are no comms in the queue
    # @return PingMessage: the next ping message in the queue
    def dequeue(self):
        if len(self.rx_msgs) == 0:
            return None
        return self.rx_msgs.popleft()


class PingProxy(object):
    def __init__(self, device=None, port=None):
        ## A serial object for ping device comms
        self.device = device

        ## UDP port number for server
        self.port = port

        if self.device is None:
            raise Exception("A device is required")

        if self.port is None:
            raise Exception("A port is required")

        ## Connected client dictionary
        self.clients = {}

        ## Socket to serve on
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.socket.setblocking(False)
        self.socket.bind(('0.0.0.0', self.port))

    ## Run proxy tasks
    # @return None
    def run(self):
        try:
            data, address = self.socket.recvfrom(4096)

            # new client
            if address not in self.clients:
                self.clients[address] = PingClient()

            # digest data coming in from client
            self.clients[address].parse(data)

        except Exception as e:
            if isinstance(e, OSError) and e.errno == errno.EAGAIN:
                pass  # waiting for data
            else:
                print("Error reading data", e)

        # read ping device
        device_data = self.device.read(self.device.in_waiting)

        # send ping device data to all clients
        if device_data:  # don't write empty data
            for client in self.clients:
                # print("writing to client", client)
                self.socket.sendto(device_data, client)

        # send all client comms to ping device
        for client in self.clients:
            c = self.clients[client]
            msg = c.dequeue()
            while msg is not None:
                self.device.write(msg.msg_data)
                msg = c.dequeue()


if __name__ == '__main__':
    import argparse

    parser = argparse.ArgumentParser(description="Ping udp proxy server.")
    parser.add_argument('--device', action="store", required=True, type=str, help="Ping device serial port.")
    parser.add_argument('--baudrate', action="store", type=int, default=115200, help="Ping device baudrate.")
    parser.add_argument('--port', action="store", type=int, default=9090, help="Server udp port.")
    args = parser.parse_args()

    s = serial.Serial(args.device, args.baudrate, exclusive=True)
    proxy = PingProxy(s, args.port)

    while True:
        proxy.run()
        time.sleep(0.001)