Thread's, async_chat and asyncore

[Jos]

Hello.

I'm using the asyncore and _chat modules to create a network server. I
also have, running in a separate thread(s), a "producer" which needs to
"push" data onto the network connection(s). (This is all for a
multi-player game server, so the threads would be individual games,
that need to update the players when new events happen in the game)

I currently have a module level list of async_chat instances, which the
thread then reads and uses the 'push' method of async_chat.

I've done some very quick tests, but wanted to know more formally if
the async_chat.push() method is thread safe?

ie. can i be sure that the data that the thread pushes onto the
connection will always be complete, and never "over-written" by another
thread?

Here is an example, which creates a whack of threads, which push their
message down the first connection made to the server. I just use a
telnet client to test it. I haven't seen any over-writing of values,
but this is a very basic test/example of what i'm doing. I just want to
make sure that this _is_ ok, or if i should be using a Queue...

<file>
import asynchat
import asyncore
import socket
from threading import Thread
import time
import random

clients = []

class pulse_thread(Thread):
    def __init__(self, string):
        Thread.__init__(self)
        self.msg = string

    def run(self):
        while True:
            time.sleep(random.random())
            if(len(clients)):
                clients[0].push(self.msg)

class Chat(asynchat.async_chat):

    def __init__(self, sock, addr, terminator="\r\n", name="me"):

        asynchat.async_chat.__init__(self, conn=sock)

        self.rmq = []
        self.terminator = terminator
        self.set_terminator(self.terminator)
    # push self onto module client list, so threads can access me
        clients.append(self)

    def collect_incoming_data(self, data):
        """Buffer the data"""
        self.rmq.append(data)

    def found_terminator(self):
        print "".join(self.rmq)
        self.rmq = []

class cServer(asyncore.dispatcher):

    # constructor method
    def __init__(self, addr, terminator="\r\n"):

        # initalize asyncore
        asyncore.dispatcher.__init__(self)

        self.terminator = terminator

        # create a socket to listen on
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)

        # bind the socket to the ip/port
        self.bind(addr)

        # listen ??? don't know about the 5 ????
        self.listen(50)

    # EVENT handle_accept - fired when server accepts an new connection
    def handle_accept (self):
        # fire the accept method > returns a connection object
        conn, addr = self.accept()

        # extend the connection with cSock Class (another asyncore)
        #cSock(conn, addr)
        Chat(conn,addr,self.terminator)


if __name__ == '__main__':

    for i in range(1,99):
        x = pulse_thread(":%02d:\n\r" % (i,))
        x.start()

    myserver = cServer(('127.0.0.1',7000))

    asyncore.loop()
</file>

Please let me know if this is totally the _wrong_ way to do it!

Thanks,
Jos