Twisted 框架 初印象

 

上面是twisted官网推荐的书籍，从封面可以看到，是一堆大蟒(python)纠缠在一起，这里可以说明twisted是一个基于pyhton语言，支持各种网络协议(包括UDP,TCP,TLS和其他应用层协议，比如HTTP，SMTP，NNTM，IRC，XMPP/Jabber。)使用(纠缠)的较低层的通信框架，twisted框架已经实现了这些协议，我们只需要使用就行了。另外twisted框架是基于事件驱动

 

下面是搬运官网的例子：

 

TCP服务器

from twisted.internet import protocol, reactor, endpoints class Echo(protocol.Protocol): 
    def dataReceived(self, data): 
        self.transport.write(data) 
class EchoFactory(protocol.Factory): 
    def buildProtocol(self, addr): 
       return Echo()

endpoints.serverFromString(reactor, "tcp:1234").listen(EchoFactory()) reactor.run()        

　　

web服务器

from twisted.web import server, resource 
from twisted.internet import reactor, endpoints class Counter(resource.Resource): 
    isLeaf = True 
    numberRequests = 0 
    def render_GET(self, request): 
        self.numberRequests += 1 
        request.setHeader(b"content-type", b"text/plain") 
        content = u"I am request #{}\n".format(self.numberRequests)                                                                              
        return content.encode("ascii") endpoints.serverFromString(reactor, "tcp:8080").listen(server.Site(Counter()))                                               

reactor.run()                

 

聊天室

from twisted.internet import reactor, protocol, endpoints
from twisted.protocols import basic

class PubProtocol(basic.LineReceiver):
    def __init__(self, factory):
        self.factory = factory

    def connectionMade(self):
        self.factory.clients.add(self)

    def connectionLost(self, reason):
        self.factory.clients.remove(self)

    def lineReceived(self, line):
        for c in self.factory.clients:
            source = u"<{}> ".format(self.transport.getHost()).encode("ascii")
            c.sendLine(source + line)

class PubFactory(protocol.Factory):
    def __init__(self):
        self.clients = set()

    def buildProtocol(self, addr):
        return PubProtocol(self)

endpoints.serverFromString(reactor, "tcp:1025").listen(PubFactory())
reactor.run()

你可以使用打开两个命令行终端，使用 telnet localhost 1025， 然后在每个终端输入。

 

邮件客户端

twisted 包含了一个复杂的 imap4 客户端库

from __future__ import print_function

import sys

from twisted.internet import protocol, defer, endpoints, task
from twisted.mail import imap4
from twisted.python import failure

@defer.inlineCallbacks
def main(reactor, username="alice", password="secret",
         strport="tls:example.com:993"):
    endpoint = endpoints.clientFromString(reactor, strport)
    factory = protocol.Factory.forProtocol(imap4.IMAP4Client)
    try:
        client = yield endpoint.connect(factory)
        yield client.login(username, password)
        yield client.select('INBOX')
        info = yield client.fetchEnvelope(imap4.MessageSet(1))
        print('First message subject:', info[1]['ENVELOPE'][1])
    except:
        print("IMAP4 client interaction failed")
        failure.Failure().printTraceback()

task.react(main, sys.argv[1:])

 

总结

twisted 是一个封装了各个网络协议，基于事件循环驱动的框架。

1. 要使用twisted框架，需实现一个twisted Protocol类的客户端或服务器类，重写其dataReceived，

定义接受到对端数据时的处理方法。

2. 对于服务器类(客户端类)，还要实现一个twisted Factory(ClientFactory)类，用来管理Protocol类,当有新的客户端连接时，框架调用

Factory.buildProtocol()返回Protocol类去处理相应连接。

3. 使用twisted  相应的listen/connect方法，监听/连接对端服务。

4. 最后，调用twisted的事件循环处理类reactor.run()，启动事件循环。

 

 

下面是twisted的关键术语：

BaseProtocol

twisted框架所有协议类的基类，其实现了两个关键方法， makeConnection和connectionMade。

makeConnection继承给子类，一般我们不使用此方法；

connctionsMade继承给子类，子类重写该方法。在客户端连接建立时调用，可以做一些鉴权之类的操作，也可以限制客户端的连接总数。

 

class BaseProtocol:
"""
This is the abstract superclass of all protocols.
 
Some methods have helpful default implementations here so that they can
easily be shared, but otherwise the direct subclasses of this class are more
interesting, L{Protocol} and L{ProcessProtocol}.
"""
connected = 0
transport = None
 
def makeConnection(self, transport):
"""Make a connection to a transport and a server.
 
This sets the 'transport' attribute of this Protocol, and calls the
connectionMade() callback.
"""
self.connected = 1
self.transport = transport
self.connectionMade()
 
def connectionMade(self):
"""Called when a connection is made.
 
This may be considered the initializer of the protocol, because
it is called when the connection is completed. For clients,
this is called once the connection to the server has been
established; for servers, this is called after an accept() call
stops blocking and a socket has been received. If you need to
send any greeting or initial message, do it here.

　　

Protocol

from twisted.internet.protocol import Protocol

twisted框架为基于TCP协议等上层协议定义的基类(基于UDP协议的是DatagramProtocol，from twisted.internet.protocol import Protocol),服务端和客户端都需继承此类。

其api十分简单，重写dataReceived方法支持客户端有数据发送时的逻辑；重写connectionLost方法，可以根据失败原因做一些错误处理。

 
class Protocol(BaseProtocol):
"""
This is the base class for streaming connection-oriented protocols.
 
If you are going to write a new connection-oriented protocol for Twisted,
start here. Any protocol implementation, either client or server, should
be a subclass of this class.
 
The API is quite simple. Implement L{dataReceived} to handle both
event-based and synchronous input; output can be sent through the
'transport' attribute, which is to be an instance that implements
L{twisted.internet.interfaces.ITransport}. Override C{connectionLost} to be
notified when the connection ends.
 
Some subclasses exist already to help you write common types of protocols:
see the L{twisted.protocols.basic} module for a few of them.
"""
 
def logPrefix(self):
"""
Return a prefix matching the class name, to identify log messages
related to this protocol instance.
"""
return self.__class__.__name__
 
 
def dataReceived(self, data):
"""Called whenever data is received.
 
Use this method to translate to a higher-level message. Usually, some
callback will be made upon the receipt of each complete protocol
message.
 
@param data: a string of indeterminate length. Please keep in mind
that you will probably need to buffer some data, as partial
(or multiple) protocol messages may be received! I recommend
that unit tests for protocols call through to this method with
differing chunk sizes, down to one byte at a time.
"""
 
def connectionLost(self, reason=connectionDone):
"""Called when the connection is shut down.
 
Clear any circular references here, and any external references
to this Protocol. The connection has been closed.
 
@type reason: L{twisted.python.failure.Failure}

　　

Factory

from twisted.internet.protocol import Factory

twisted中的Factory子类起到对Protocol类的管理作用，当有新的客户端连接时，框架会调用Factory.buildProtocol(),此时，用户需在此时将自定义的Protocol实例传进去，并且作为该函数的返回值。

 

ClientFactory

from twisted.internet.protocol import ClientFactory

实现客户端连接程序管理的工厂类，需用reactors.connectXXX(如connectTCP) 指定与使用哪种网络协议的服务器通信。

ClientFactory继承自Factory类，但是比Factory多了3个可以重写的事件响应函数，即startedConnecting()在建立连接时被调用；clientConnectionLost()在连接断开时被调用；

clientConnectionFailed()在连接建立失败时被调用。

 

转载于:https://www.cnblogs.com/linyihai/p/7395875.html