asyncore asynchat

[Michael Welsh]

In order to learn sockets in Python I am trying to write a simple group chat 
server and client.  I need a little nudge, please.  My question contains some 
GUI but only as decoration.  The root question is asyncore / asynchat.  I 
have read that twisted makes this all simple, but, I wanted to get my hands 
dirty here for educational purposes.

I've managed to build a small echo server with asyncore and asynchat that can 
handle any number of connections and repeat to all clients what was sent in 
by individual clients.   The server seems to work well.

The GUI client, wxPython, creates a socket on open.  The user types some text 
and clicks [SEND].  The send event puts the text out to the socket then reads 
the response and adds it to list control.  Everything works well.  

I'm now ready for the next step, to disconnect the send data from the recieve 
data.  So a user who does not send text, still gets what others may have 
written.  I need to somehow poll the thread so "add to list control" can be 
triggered on recieving the data.

I've tried several approaches and can't seem to get it right.  First I tried 
setting up a separate threading.Thread that created the socket.  This way I 
could put a poll on the socket.  I even created (borrowed) a custom event so 
when data was found, it could notify the GUI and call the "add to list 
control"  But I must have been doing it wrong because it kept locking up in 
the loop..  

I knew from the server side that asynchat has built in helpers with 
collect_incoming_data() and found_terminator().  (my terminator is appended 
when data is sent to the server)  I could then use the asyncore.poll() in my 
threading.Thread to raise the custom event that sends data to the GUI, when 
something comes over the socket.

I think I have the concepts right, but the execution breaks down here.  I 
tried having the threading.Thread create an asyn_chat but I keep getting 
errors that I assume the asyncore.dispatcher takes care of.  So... maybe I 
should use both core and chat on the client as well as the server.  The only 
examples of dispatcher I can find open up an asyn_chat on "listen".  The 
client needs to initiate the communication when it starts.  The server is 
listening and will respond.  I won't know on which port the response will 
come back.

Here's some bits showing what I'm trying to do.  You may find some of it 
familiar.  I hope I didn't clip anything that may have been needed  If anybody 
has time to point out where I'm going wrong it would be very helpful.  Thank 
you if you were patient enough to get this far...

import threading
import time
import socket
import asyncore
import asynchat
from   wxPython.wx import *

# server is listening on ...
REMOTE_HOST = '172.0.0.1' 
REMOTE_PORT = 50001

class MyTest(wxFrame):
    def __init__(self, parent, ID, title):
        # Initialize wxFrame
        wxFrame.__init__(self, .....

        # start the thread
        self.network = NetworkThread(self)
        self.network.start()
        EVT_NETWORK(self,self.OnNetwork)

        # build rest of GUI... works fine


# the network thread communicates back to the main
# GUI thread via this sythetic event
class NetworkEvent(wxPyEvent):
    def __init__(self,msg=""):
        wxPyEvent.__init__(self)
        self.SetEventType(wxEVT_NETWORK)
        self.msg = msg

wxEVT_NETWORK = 2000
def EVT_NETWORK(win, func):
    win.Connect(-1, -1, wxEVT_NETWORK, func)

class NetworkThread(threading.Thread):
    def __init__(self,win):
        threading.Thread.__init__(self)
        self.win = win
        self.keep_going = true
        self.running    = false
        self.MySock = NetworkServer(REMOTE_HOST, REMOTE_PORT, 
self.received_a_line)
        self.event_loop = EventLoop()

    def push(self,msg):
        self.MySock.push(msg)
    def is_running(self):
        return self.running
    def stop(self):
        self.keep_going = 0
    def check_status(self,el,time):
        if not self.keep_going:
            asyncore.close_all()
        else:
            self.event_loop.schedule(1,self.check_status)
    def received_a_line(self,m):
        self.send_event(m)
    def run(self):
        self.running = true
        self.event_loop.schedule(1,self.check_status)
        # loop here checking every 0.5 seconds for shutdowns etc..
        self.event_loop.go(0.5)
        # server has shutdown
        self.send_event("Closed down network")
        time.sleep(1)
        self.running = false

    # send a synthetic event back to our GUI thread
    def send_event(self,m):
        evt = NetworkEvent(m)
        wxPostEvent(self.win,evt)
        del evt

class NetworkServer (asyncore.dispatcher):
    def __init__ (self, host, port, handler=None):
        asyncore.dispatcher.__init__(self)
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.connect((host, port))

    def handle_connect (self):
        # I thought, maybe, the server would trigger this... nope
        ChatSocket (host, port, self.handler)

    def handle_read (self):
        data = self.recv (8192)
        self.send_event(self.data)
        print data

    def writable (self):
        return (len(self.buffer) > 0)

    def handle_write (self):
        sent = self.send (self.buffer)
        self.buffer = self.buffer[sent:]

    # send a synthetic event back to our GUI thread
    def send_event(self,m):
        evt = NetworkEvent(m)
        wxPostEvent(self.win,evt)
        del evt

class ChatSocket(asynchat.async_chat):
    def __init__(self, host, port, handler=None):
        asynchat.async_chat.__init__ (self, port)

    def collect_incoming_data(self, data):
        self.data.append(data)

    def found_terminator(self):
        if self.handler:
            self.send_event(self.data)
        else:
            print 'warning: unhandled message: ', self.data
        self.data = ''

class EventLoop:
    socket_map = asyncore.socket_map
    def __init__ (self):
        self.events = {}

    def go (self, timeout=5.0):
        events = self.events
        while self.socket_map:
            print 'inner-loop'
            now = int(time.time())
            for k,v in events.items():
                if now >= k:
                    v (self, now)
                    del events[k]
            asyncore.poll (timeout)

    def schedule (self, delta, callback):
        now = int (time.time())
        self.events[now + delta] = callback

    def unschedule (self, callback, all=1):
        "unschedule a callback"
        for k,v in self.events:
            if v is callback:
                del self.events[k]
                if not all:
                    break

# -----------------------------------------
# Run App
# -------------------------------------------
class TestApp(wxApp):
    def OnInit(self):
        frame = MyTest(None, -1, "Test APP")
        frame.Show(true)
        self.SetTopWindow(frame)
        return true

app = TestApp(0)
app.MainLoop()