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(Th read):
def __init__(self, string):
Thread.__init__ (self)
self.msg = string
def run(self):
while True:
time.sleep(rand om.random())
if(len(clients) ):
clients[0].push(self.msg)
class Chat(asynchat.a sync_chat):
def __init__(self, sock, addr, terminator="\r\ n", name="me"):
asynchat.async_ chat.__init__(s elf, conn=sock)
self.rmq = []
self.terminator = terminator
self.set_termin ator(self.termi nator)
# push self onto module client list, so threads can access me
clients.append( self)
def collect_incomin g_data(self, data):
"""Buffer the data"""
self.rmq.append (data)
def found_terminato r(self):
print "".join(self.rm q)
self.rmq = []
class cServer(asyncor e.dispatcher):
# constructor method
def __init__(self, addr, terminator="\r\ n"):
# initalize asyncore
asyncore.dispat cher.__init__(s elf)
self.terminator = terminator
# create a socket to listen on
self.create_soc ket(socket.AF_I NET, socket.SOCK_STR EAM)
# 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
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(Th read):
def __init__(self, string):
Thread.__init__ (self)
self.msg = string
def run(self):
while True:
time.sleep(rand om.random())
if(len(clients) ):
clients[0].push(self.msg)
class Chat(asynchat.a sync_chat):
def __init__(self, sock, addr, terminator="\r\ n", name="me"):
asynchat.async_ chat.__init__(s elf, conn=sock)
self.rmq = []
self.terminator = terminator
self.set_termin ator(self.termi nator)
# push self onto module client list, so threads can access me
clients.append( self)
def collect_incomin g_data(self, data):
"""Buffer the data"""
self.rmq.append (data)
def found_terminato r(self):
print "".join(self.rm q)
self.rmq = []
class cServer(asyncor e.dispatcher):
# constructor method
def __init__(self, addr, terminator="\r\ n"):
# initalize asyncore
asyncore.dispat cher.__init__(s elf)
self.terminator = terminator
# create a socket to listen on
self.create_soc ket(socket.AF_I NET, socket.SOCK_STR EAM)
# 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
Comment