server_twisted.py

python + wxpython + twisted 服务器和客户端demo代码

from twisted.internet.protocol import ServerFactory
from twisted.internet import reactor,defer
from twisted.protocols import basic
from sys import stdout
from twisted.internet import stdio
import re

frame=None
class MyChat(basic.LineReceiver):

    def connectionMade(self):
        print "Got new client!"
        self.factory.clients.append(self)

    def connectionLost(self, reason):
        print "Lost a client!"
        self.factory.clients.remove(self)

    def lineReceived(self, line):
        print "received", repr(line)
        for c in self.factory.clients:
            c.message(line)

    def message(self, message):
        self.transport.write(message + '\n')

class xdServerProtocol(basic.LineReceiver):

    inused=0
    loginMessage=""
    connectuser=""
    connectpassword=""
    destinationAddress=""
    sourceAddress=""
    messageContents=""

    def connectionMade(self):
        print("Get a new client!\r\n")
        self.factory.clients.append(self)
        self.factory.clientConnect[self.connectuser]=self
        self.factory.deferred.callback("Connected!")

    def connectionLost(self, reason):
        print("Lost a client!\n")
        self.factory.clients.remove(self)
        self.factory.clientConnect[self.connectuser]=0
        self.factory.deferred.errback(reason)

    def dataSend(self, data=""):
        if self.messageCheck(data)==1:
            if self.factory.clientConnect[self.destinationAddress]!=0:
                print "dataSend data: "+data+"\r\n"
                self.factory.clientConnect[self.destinationAddress].transport.write(data)

    def messageCheck(self,message):
        ''''''
        patternStr="mesS desS (\S*) desE souS (\S*) souE conS (.*) conE mesE"
        pattern=re.compile(patternStr)
        try:
            messageGroups=re.search(pattern, message).groups()
        except:
            return 0

        self.destinationAddress=messageGroups[0]
        self.sourceAddress=messageGroups[1]
        self.messageContents=messageGroups[2]

        if self.factory.user.has_key(self.sourceAddress)==True:
            if self.factory.user.has_key(self.destinationAddress)==True:
                return 1

    def userCheck(self, usermessage):
        '''The first message form the client is user message ,it include user name and use password'''

        patternStr="userstart (\S*) userend,passwordstart (\S*) passwordend"
        pattern=re.compile(patternStr)
        try:
            user_and_password=re.search(pattern, usermessage).groups()
        except:
            return 0

        self.connectuser=user_and_password[0]
        self.connectpassword=user_and_password[1]

        if self.factory.user.has_key(self.connectuser)==True:
            pass
        else:
            self.sendLine("user name is not right\r\n")
            self.transport.loseConnection()

        if self.factory.user[self.connectuser]==self.connectpassword:
            pass
        else:
            self.sendLine("user password is not right\r\n")
            self.transport.loseConnection()

        self.factory.clients.append(self)
        self.factory.clientConnect[self.connectuser]=self
        self.inused=1
        self.sendLine("user and password is right\r\n")

    def lineReceived(self, line):
        print "received", repr(line)
        global frame

        if self.inused==0:
            self.userCheck(line)

        if self.inused==1:
            if "quit"==line:
                self.sendLine("Goodbye.")
                self.transport.loseConnection()
            else:
                #self.sendLine("You said: " + line)
                self.dataSend(line)
                stdout.write(line+"\r\n")
        try:
            frame.receMessageText.SetValue(line)
        except:
            pass


class xdServerFactory(ServerFactory):
    protocol = xdServerProtocol
    clients = []
    user ={"xd":"apples","cvs":"apples"}
    clientConnect={"xd":0,"cvs":0}
    def __init__(self):
        self.deferred=defer.Deferred()

def runServer(port):
    print "****Server is running at port:%d ****\r\n"%(port)
    Server=xdServerFactory()
    reactor.listenTCP(port,Server)
    return Server.deferred

def handelSuccess(result,port):
    print "Connected from port %i"%port
    #reactor.stop()

def handelFailure(failure,port):
    print "Error: connectin from port %i: %s\r\n"%(
          port,failure.getErrorMessage())
    #reactor.stop()

if __name__ =="__main__":
    port=8001
    connecting=runServer(port)
    connecting.addCallback(handelSuccess,port)
    connecting.addErrback(handelFailure,port)
    reactor.run()