Several Websocket servers (in the same process)

In WebsocketServer class, the clients attribute is defined at the class level, not as an instance attribute. Is there any good reason for this design?

This means that when you use several WebsocketServer (on different ports) and use the send_message_to_all method on a server instance, the message is sent to all clients, including the clients that connected to another server !

The fix is trivial and I can make a Pull Request if this could be changed.

Thanks for this very useful lib BTW ! 😄

[kdschlosser]

all code blocks are pseudo code. They have not been tested specifically in the websocket_server library

OK so this an idea that works in a test setup of simple class instances and it should as well in the websocket_server lib.

class API():

    def run_forever(self):
        try:
            logger.info("Listening on port %d for clients.." % self.port)
            self.serve_forever()
        except KeyboardInterrupt:
            self.server_close()
            logger.info("Server terminated.")
        except Exception as e:
            logger.error(str(e), exc_info=True)
            exit(1)

    def new_client(self, client, server):
        pass

    def client_left(self, client, server):
        pass

    def message_received(self, client, server, message):
        pass

    def set_fn_new_client(self, fn):
        self.new_client = fn

    def set_fn_client_left(self, fn):
        self.client_left = fn

    def set_fn_message_received(self, fn):
        self.message_received = fn

    def send_message(self, client, msg):
        self._unicast_(client, msg)

    @classmethod
    def send_message_to_all(cls, msg):
        self._multicast_(msg)


class WebsocketServer(ThreadingMixIn, TCPServer, API):
    allow_reuse_address = True
    daemon_threads = True  # comment to keep threads alive until finished

    clients = []
    id_counter = 0

    def __init__(self, port, host='127.0.0.1', loglevel=logging.WARNING):
        self.send_message_to_all = self.__send_message_to_all
        logger.setLevel(loglevel)
        TCPServer.__init__(self, (host, port), WebSocketHandler)
        self.port = self.socket.getsockname()[1]

    def __send_message_to_all(self, msg):
        for client in self.clients:
            if client['server'] == self:
                self._unicast_(client, msg)

    def _message_received_(self, handler, msg):
        self.message_received(self.handler_to_client(handler), self, msg)

    def _ping_received_(self, handler, msg):
        handler.send_pong(msg)

    def _pong_received_(self, handler, msg):
        pass

    def _new_client_(self, handler):
        self.id_counter += 1
        client = {
            'id': self.id_counter,
            'handler': handler,
            'address': handler.client_address,
            'server': self
        }
        self.clients.append(client)
        self.new_client(client, self)

    def _client_left_(self, handler):
        client = self.handler_to_client(handler)
        self.client_left(client, self)
        if client in self.clients:
            self.clients.remove(client)

    def _unicast_(self, to_client, msg):
        to_client['handler'].send_message(msg)

    def _multicast_(self, msg):
        for client in self.clients:
            self._unicast_(client, msg)

    def handler_to_client(self, handler):
        for client in self.clients:
            if client['handler'] == handler:
                return client

Now what i did here was I had the instance override the class method of the parent class. This way it can be used both ways.

from websocket_server import WebsocketServer

instance1 = WebsocketServer(1234)
instance2 = WebsocketServer(4321)

instance1.send_message_to_all('message sent to only instance1 clients')
WebsocketServer.send_message_to_all('message sent to all clients on all websocket servers')

I think this would be the most elegant solution. and the one that makes the most sense.

being able to access one instance of a websocket server from another instance I do not believe is the best idea. You may even consider changing the clients container to have a mangled name. Then add a property that will iterate the mangled name container and only return clients that pertain to it.

In the original code there was no way to tell what client belong to what websocket connection even if you iterated over the devices container. No marker that was easily had. Without really digging into it but I think that client[‘handler’].server might point back to the websocket instance, but I am not sure. Event if you do not make clients a mangled name at least make it a private one.

This adds the mangled name which offers protection against inadvertently sending data to the wrong websocket connection if accessed from a websocket instance.

class WebsocketServer(ThreadingMixIn, TCPServer, API):
    allow_reuse_address = True
    daemon_threads = True  # comment to keep threads alive until finished

    __clients = []
    id_counter = 0

    def __init__(self, port, host='127.0.0.1', loglevel=logging.WARNING):
        self.send_message_to_all = self.__send_message_to_all
        logger.setLevel(loglevel)
        TCPServer.__init__(self, (host, port), WebSocketHandler)
        self.port = self.socket.getsockname()[1]
    
    @property
    def clients(self):
        return list(
            client for client in self.__clients
            if client['server'] == self
        )    

    def __send_message_to_all(self, msg):
        for client in self.clients:
            self._unicast_(client, msg)

    def _message_received_(self, handler, msg):
        self.message_received(self.handler_to_client(handler), self, msg)

    def _ping_received_(self, handler, msg):
        handler.send_pong(msg)

    def _pong_received_(self, handler, msg):
        pass

    def _new_client_(self, handler):
        self.id_counter += 1
        client = {
            'id': self.id_counter,
            'handler': handler,
            'address': handler.client_address,
            'server': self
        }
        self.__clients.append(client)
        self.new_client(client, self)

    def _client_left_(self, handler):
        client = self.handler_to_client(handler)
        self.client_left(client, self)
        if client in self.__clients:
            self.__clients.remove(client)

    def _unicast_(self, to_client, msg):
        to_client['handler'].send_message(msg)

    def _multicast_(self, msg):
        for client in self.__clients:
            self._unicast_(client, msg)

    def handler_to_client(self, handler):
        for client in self.__clients:
            if client['handler'] == handler:
                return client

[Pithikos]

So the original design simply dealt with a single instance. But all this makes sense so v0.5.1 should have this fixed.