# coding=utf-8

 from twisted.internet.protocol import Protocol

 from twisted.internet.protocol import Factory

 from twisted.internet.endpoints import TCP4ServerEndpoint

 from twisted.internet import reactor

 clients = []

 class Spreader(Protocol):  # 派生自协议的协议类

     def __init__(self, factory):

         self.factory = factory

         self._data_buffer = bytes()  # 处理粘包

     def connectionMade(self):

         self.factory.numProtocols = self.factory.numProtocols + 1

         self.transport.write(

             "欢迎来到Spread Site, 你是第%s个客户端用户!\n" % (self.factory.numProtocols)

         )

         clients.append(self)

     def connectionLost(self, reason):

         self.factory.numProtocols = self.factory.numProtocols - 1

         clients.remove(self)

         print "lost connect: %d" % (self.factory.numProtocols)

     def dataReceived(self, data):

         print " ** dataReviced ** "

         print data.decode('utf-8')

         self._data_buffer += data

         print self._data_buffer

         if self._data_buffer.find('close') == -1:

             print "loseConnection..."

             self.transport.loseConnection()

         else:

             # self.transport.write(data + " " + "got it!")

             # print len(clients)

             for client in clients:

                 print "no--lose " + self._data_buffer

                 client.transport.write(self._data_buffer + " " + "got it")

 class SpreadFactory(Factory):  # 继承自Factory的自定义协议工厂类

     def __init__(self):

         self.numProtocols = 0

     def buildProtocol(self, addr):

         return Spreader(self)  # 生成协议

 endpoint = TCP4ServerEndpoint(reactor, 8007)

 endpoint.listen(SpreadFactory())  # 开启监听...

 reactor.run()

 # coding=utf-8

 from twisted.internet.protocol import Protocol, ClientFactory

 from twisted.internet import reactor

 from time import sleep

 import sys

 class Echo(Protocol):

     def __init__(self):

         self.connected = False

     def connectionMade(self):

         self.connected = True

     def connectionLost(self, reason):

         self.connected = False

     # 因为transport是非线程安全的, 多访问下可能会引起错误

     def routine(self, factory, _d):

         # sys.argv[0]获取本身文件路径, 不加索引表示命令行参数  sys.argv其实就是一个元组, 表示用户输入的参数

         sleep(1.5)

         if factory.protocol and factory.protocol.connected:

             print " ** routine ** "

             print _d.decode('utf-8')

             factory.protocol.transport.write(_d)  # transport为非线程安全函数, 最好调用callfromThread

     def dataReceived(self, data):

         print " ** dataReviced ** "

         print data.decode('utf-8')

         for index in range(len(_data)):

             _d = _data[index]

             self.routine(factory, _d)

         # reactor.callFromThread(self.routine, factory, data)

         # routine(factory)

 class EchoClientFactory(ClientFactory):

     def __init__(self):

         self.protocol = None

     def startedConnecting(self, connector):

         print "Start to Connect..."

     def buildProtocol(self, addr):

         print "Connected..."

         self.protocol = Echo()

         return self.protocol

     def clientConnectionLost(self, connector, reason):

         print "Lost connection. Reason: ", reason

     def clientConnectionFailed(self, connector, reason):

         print "Connection is failed, Reason: ", reason

 host = '127.0.0.1'

 port = 8007

 factory = EchoClientFactory()  # 自定义协议工厂对象

 reactor.connectTCP(host, port, factory)  # 开启TCP连接

 # threading.Thread(target=routine, args=(factory,)).start()  # 开启一个线程去执行

 _data = sys.argv[1:4]

 reactor.run()