上一章，我们直接写了一个小例子来从整体讲述twisted运行的大致过程，今天我们首先深入一些概念，在逐渐明白这些概念以后，我们会修改昨天写的例子。
先看下面一张图：
这个系列的第一篇文章，我们已经为大家展示了一张twisted的原理图，那张图，因为我们没有捕获任何socket事件，所以只有一个圈。这张图上面的大圈代表捕获socket事件，这个也是twisted最主要的功能，它已经为我们做了。并且提供了2个函数，transport.write写入事件，dataReceived读取事件。下面的小圈子，也就是我们自己的代码，比如我们昨天的验证、单聊、组聊等功能。大家一定要时时刻刻记住这张图，编写twisted代码的时候，脑子里印着这张图，这就跟我们以前写c代码的时候，一定要记住内存模型一样。
回到这个大圈，transport.write和dataReceived其实是经过很多层封装的函数，它们本质上还是操作select模型中的写文件描述符(write_fd)、读文件描述符(read_fd)，对应twisted的基础类就是IWriteDescriptor和IReadDescriptor，如果我们比较熟悉select模型，我们都知道，每次新来一个连接，都是建立write_fd、read_fd、error_fd，select不停的轮询这些fd，当其中任何一个满足条件时，触发相应的事件，这些所有的东西，twisted都已经帮我们做好了，而且异步化了。我们接受到事件，只管处理就好了。
再看下面一个图，
仔细看上面这个图，再对比之前的图，twisted在socket这块全部为我们做好。
下面我们再讲一下transport这个对象，这个对象在每个Protocol里面都会产生一个，它代表一个连接，这个连接可以是socket，也可以是unix的pipe，twisted已经为我们封装好，一般不会自己去新建它。通常我们会用它来发送数据(write)、获取连接另一方的信息(getPeer)。
再看一下dataReceived这个函数，就是每次接到数据以后触发事件，上面说了，就是每次循环，select检查这些fd，fd被写入就触发。这时候大家想想，如果循环被阻塞，在这个data里面会有很多数据，按照我们昨天的程序，只会处理第一个数据，其他的可能被丢弃掉了。
我们昨天的例子，把客户端运行代码稍微修改一下，在第10秒的时候，同时发送2个数据(粘包)，看看服务器运行情况。
if __name__ == '__main__':
cf = EchoClientFactory()
chat_from = sys.argv[1]
all_phone_numbers = ['', '', '', '']
all_phone_numbers.remove(chat_from)
import random
reactor.callLater(3, cf.p.send_verify, chat_from)
reactor.callLater(10, cf.p.send_single_chat, chat_from, random.choice(all_phone_numbers), '你好,这是单聊')
reactor.callLater(10, cf.p.send_single_chat, chat_from, random.choice(all_phone_numbers), '你好,这是单聊')
# reactor.callLater(11, cf.p.send_group_chat, chat_from, [random.choice(all_phone_numbers), random.choice(all_phone_numbers)], '你好,这是组聊')
# reactor.callLater(12, cf.p.send_broadcast_chat, chat_from, '你好,这是群聊') reactor.connectTCP('127.0.0.1', 8124, cf) reactor.run()
客户端代码已经更改，运行一下，看看服务器结果。
/usr/bin/python2. /home/yudahai/PycharmProjects/blog01/tcpserver/frontTCP.py
-- ::+ [-] Log opened.
-- ::+ [-] ChatFactory starting on
-- ::+ [-] Starting factory <__main__.ChatFactory instance at 0x7f382d908638>
-- ::+ [__main__.ChatFactory] New connection, the info is: IPv4Address(TCP, '127.0.0.1', )
-- ::+ [Chat,,127.0.0.1] 欢迎, !
-- ::+ [Chat,,127.0.0.1] 你好,这是单聊
-- ::+ [Chat,,127.0.0.1] Phone_number: 不在线,不能聊天.
果然，只处理了一个数据，后面一个直接丢弃掉了。
通常来说，我们都会为每个Protocol申请一段内存，每次接受到数据以后，先存放到这段内存中，然后再集中处理，这样，即使循环被blocking住或者客户端粘包，我们也能正确处理。新的代码如下:
# coding:utf-8
from twisted.internet.protocol import Factory, Protocol
from twisted.internet import reactor
import struct
import json
from twisted.python import log
import sys
log.startLogging(sys.stdout) class Chat(Protocol):
def __init__(self, users):
self.users = users
self.phone_number = None
self.state = "VERIFY"
self.version = 0
self.command_func_dict = {
1: self.handle_verify,
2: self.handle_single_chat,
3: self.handle_group_chat,
4: self.handle_broadcast_chat
}
self._data_buffer = bytes() def connectionMade(self):
log.msg("New connection, the info is:", self.transport.getPeer()) def connectionLost(self, reason):
if self.phone_number in self.users:
del self.users[self.phone_number] def dataReceived(self, data):
"""
接受到数据以后的操作
"""
self._data_buffer += data while True:
length, self.version, command_id = struct.unpack('!3I', self._data_buffer[:12]) if length > len(self._data_buffer):
break content = self._data_buffer[12:length] if command_id not in [1, 2, 3, 4]:
return if self.state == "VERIFY" and command_id == 1:
self.handle_verify(content)
else:
self.handle_data(command_id, content) self._data_buffer = self._data_buffer[length:] if len(self._data_buffer) < 12:
break def handle_verify(self, content):
"""
验证函数
"""
content = json.loads(content)
phone_number = content.get('phone_number')
if phone_number in self.users:
log.msg("电话号码<%s>存在老的连接." % phone_number.encode('utf-8'))
self.users[phone_number].connectionLost("")
log.msg("欢迎, %s!" % (phone_number.encode('utf-8'),))
self.phone_number = phone_number
self.users[phone_number] = self
self.state = "DATA" send_content = json.dumps({'code': 1}) self.send_content(send_content, 101, [phone_number]) def handle_data(self, command_id, content):
"""
根据command_id来分配函数
"""
self.command_func_dict[command_id](content) def handle_single_chat(self, content):
"""
单播
"""
content = json.loads(content)
chat_from = content.get('chat_from')
chat_to = content.get('chat_to')
chat_content = content.get('chat_content')
log.msg(chat_content.encode('utf-8'))
send_content = json.dumps(dict(chat_from=chat_from, chat_content=chat_content)) self.send_content(send_content, 102, [chat_to]) def handle_group_chat(self, content):
"""
组播
"""
content = json.loads(content)
chat_from = content.get('chat_from')
chat_to = content.get('chat_to')
chat_content = content.get('chat_content')
send_content = json.dumps(dict(chat_from=chat_from, chat_content=chat_content)) phone_numbers = chat_to
self.send_content(send_content, 103, phone_numbers) def handle_broadcast_chat(self, content):
"""
广播
"""
content = json.loads(content)
chat_from = content.get('chat_from')
chat_content = content.get('chat_content')
send_content = json.dumps(dict(chat_from=chat_from, chat_content=chat_content)) phone_numbers = self.users.keys()
self.send_content(send_content, 104, phone_numbers) def send_content(self, send_content, command_id, phone_numbers):
"""
发送函数
"""
length = 12 + len(send_content)
version = self.version
command_id = command_id
header = [length, version, command_id]
header_pack = struct.pack('!3I', *header)
for phone_number in phone_numbers:
if phone_number in self.users.keys():
self.users[phone_number].transport.write(header_pack + send_content)
else:
log.msg("Phone_number:%s 不在线,不能聊天." % phone_number.encode('utf-8')) class ChatFactory(Factory):
def __init__(self):
self.users = {} def buildProtocol(self, addr):
return Chat(self.users) reactor.listenTCP(8124, ChatFactory())
reactor.run()
我们在构造函数里面，加入了一个字段，这个字段就是self._data_buffer，在每次接受到数据以后，都循环处理这段内存。再看看运行结果，有什么不同。
/usr/bin/python2. /home/yudahai/PycharmProjects/blog01/tcpserver/frontTCP.py
-- ::+ [-] Log opened.
-- ::+ [-] ChatFactory starting on
-- ::+ [-] Starting factory <__main__.ChatFactory instance at 0x7f96860e0680>
-- ::+ [__main__.ChatFactory] New connection, the info is: IPv4Address(TCP, '127.0.0.1', )
-- ::+ [Chat,,127.0.0.1] 欢迎, !
-- ::+ [Chat,,127.0.0.1] 你好,这是单聊
-- ::+ [Chat,,127.0.0.1] Phone_number: 不在线,不能聊天.
-- ::+ [Chat,,127.0.0.1] 你好,这是单聊
-- ::+ [Chat,,127.0.0.1] Phone_number: 不在线,不能聊天.
是不是正确了？接受数据，我们先讲到这，下面我们讲开发tcpserver一定要处理的问题，异常断线
异常断线
异常断线的处理在tcpserver开发过程中必不可少，很多时候，尤其是无线、3G、4G网络，信号不好的时候就断线，由于是网络问题，没有经过tcp结束的4次握手，服务器不可能及时检查到此事件，这时候就有可能出错。通常我们会采取一种心跳包机制，即客户端每隔一段时间就向服务器端发送一个心跳包，服务器端每隔一段时间就检测一下，如果发现客户端连续2次或者多次没有发送心跳包，就认为客户端已经掉线，再采取措施。
好了，说了这么多，先要重新部署一下程序，我把一个客户端发在我的另外一台笔记本上，先连接好，然后拔掉网线，再从服务器端发送一组数据过去，看看会发生什么。
首先，我们把000002放在笔记本上，000001在服务器端，在10秒和20秒的时候，分别发送一个单聊给000002，看看服务器端和000002的情况。
000001的运行代码修改如下:
if __name__ == '__main__':
cf = EchoClientFactory()
chat_from = sys.argv[1]
all_phone_numbers = ['', '', '', '']
all_phone_numbers.remove(chat_from)
import random
reactor.callLater(3, cf.p.send_verify, chat_from)
reactor.callLater(10, cf.p.send_single_chat, chat_from, '', '你好,这是10秒的时候发送')
reactor.callLater(20, cf.p.send_single_chat, chat_from, '', '你好,这是20秒的时候发送') reactor.connectTCP('127.0.0.1', 8124, cf) reactor.run()
10秒和20秒，分别发送数据到服务器端，而000002端，在10秒和20秒的中间，拔掉网线，我们看看发生了什么情况。
首先，服务器端的运行结果如下：
/usr/bin/python2.7 /home/yudahai/PycharmProjects/blog01/tcpserver/frontTCP.py
2016-06-22 11:40:02+0800 [-] Log opened.
2016-06-22 11:40:02+0800 [-] ChatFactory starting on 8124
2016-06-22 11:40:02+0800 [-] Starting factory <__main__.ChatFactory instance at 0x7f9c39f89638>
2016-06-22 11:41:26+0800 [__main__.ChatFactory] New connection, the info is: IPv4Address(TCP, '192.168.5.15', 57150)
2016-06-22 11:41:29+0800 [Chat,0,192.168.5.15] 欢迎, 000002!
2016-06-22 11:41:41+0800 [__main__.ChatFactory] New connection, the info is: IPv4Address(TCP, '127.0.0.1', 49526)
2016-06-22 11:41:44+0800 [Chat,1,127.0.0.1] 欢迎, 000001!
2016-06-22 11:41:51+0800 [Chat,1,127.0.0.1] 你好,这是10秒的时候发送
2016-06-22 11:42:01+0800 [Chat,1,127.0.0.1] 你好,这是20秒的时候发送
它在000002中断了以后，并没有发现000002已经中断，还是照样write下去，其实本质上，它还是把数据发到了write_fd上，然后就是底层的事了。
而000002客户端的结果比较有意思。
-- ::+ [-] Log opened.
-- ::+ [-] Starting factory <__main__.EchoClientFactory instance at 0x7f4e75db7680>
-- ::+ [-] Started to connect
-- ::+ [Uninitialized] Connected.
-- ::+ [Uninitialized] New connection IPv4Address(TCP, '192.168.5.60', )
-- ::+ [EchoClient,client] 验证通过
-- ::+ [EchoClient,client] [单聊][]:你好,这是10秒的时候发送
-- ::+ [EchoClient,client] [单聊][]:你好,这是20秒的时候发送
大家注意到没有，居然还是收到了，但是看时间，时间和原来的是不对的。我后来把网线重新插上去，然后就接受到了。twisted把write_fd的数据重新发送给了客户端，因为客户端没有任何改变，ip和端口都是原来的，网络情况没有改变，所以再次就连接上来。
我们再试一下另外一种情况，也是移动端经常遇到的情况，就是切换网络，比如从4G切换到无线网，看看会发生什么。
yudahai@yu-sony:~/PycharmProjects/flask001$ python frontClient.py 000002
2016-06-22 13:09:34+0800 [-] Log opened.
2016-06-22 13:09:34+0800 [-] Starting factory <__main__.EchoClientFactory instance at 0x7fd8a0408680>
2016-06-22 13:09:34+0800 [-] Started to connect
2016-06-22 13:09:34+0800 [Uninitialized] Connected.
2016-06-22 13:09:34+0800 [Uninitialized] New connection IPv4Address(TCP, '192.168.5.60', 8124)
2016-06-22 13:09:37+0800 [EchoClient,client] 验证通过
2016-06-22 13:09:54+0800 [EchoClient,client] [单聊][000001]:你好,这是10秒的时候发送
客户端再也收不到了，这也是真实情况。通常来说，用户切换网络的时候，都会更改网络信息，这时候移动客户端再也收不到这个信息了，而且服务器端也不会报错(以后要为我们做消息确认机制埋下伏笔。)
既然收不到了，我们就解决这个问题，上面说了，增加心跳包机制，客户端每隔一段时间发送一次心跳包，服务器端收到心跳包以后，记录最近一次接受到的时间。每隔一段时间，服务器整体轮询一次，如果发现某一个客户端很长时间没有接受到心跳包，就判定它为断线，这时候主动切断这个客户端。
心跳包的command_id也要加上，直接为5吧，内容为空。只是心跳包，没有必要写内容了。
新代码如下:
frontTCP.py
# coding:utf-8
from twisted.internet.protocol import Factory, Protocol
from twisted.internet import reactor, task
import struct
import json
from twisted.python import log
import sys
import time
log.startLogging(sys.stdout) class Chat(Protocol):
def __init__(self, users):
self.users = users
self.phone_number = None
self.state = "VERIFY"
self.version = 0
self.last_heartbeat_time = 0
self.command_func_dict = {
1: self.handle_verify,
2: self.handle_single_chat,
3: self.handle_group_chat,
4: self.handle_broadcast_chat,
5: self.handle_heartbeat
}
self._data_buffer = bytes() def connectionMade(self):
log.msg("New connection, the info is:", self.transport.getPeer()) def connectionLost(self, reason):
log.msg("[%s]:断线" % self.phone_number.encode('utf-8'))
if self.phone_number in self.users:
del self.users[self.phone_number] def dataReceived(self, data):
"""
接受到数据以后的操作
"""
self._data_buffer += data while True:
length, self.version, command_id = struct.unpack('!3I', self._data_buffer[:12]) if length > len(self._data_buffer):
break content = self._data_buffer[12:length] if command_id not in [1, 2, 3, 4, 5]:
return if self.state == "VERIFY" and command_id == 1:
self.handle_verify(content)
else:
self.handle_data(command_id, content) self._data_buffer = self._data_buffer[length:] if len(self._data_buffer) < 12:
break def handle_heartbeat(self, content):
"""
处理心跳包
"""
self.last_heartbeat_time = int(time.time()) def handle_verify(self, content):
"""
验证函数
"""
content = json.loads(content)
phone_number = content.get('phone_number')
if phone_number in self.users:
log.msg("电话号码<%s>存在老的连接." % phone_number.encode('utf-8'))
self.users[phone_number].connectionLost("")
log.msg("欢迎, %s!" % (phone_number.encode('utf-8'),))
self.phone_number = phone_number
self.users[phone_number] = self
self.state = "DATA" send_content = json.dumps({'code': 1}) self.send_content(send_content, 101, [phone_number]) def handle_data(self, command_id, content):
"""
根据command_id来分配函数
"""
self.command_func_dict[command_id](content) def handle_single_chat(self, content):
"""
单播
"""
content = json.loads(content)
chat_from = content.get('chat_from')
chat_to = content.get('chat_to')
chat_content = content.get('chat_content')
log.msg(chat_content.encode('utf-8'))
send_content = json.dumps(dict(chat_from=chat_from, chat_content=chat_content)) self.send_content(send_content, 102, [chat_to]) def handle_group_chat(self, content):
"""
组播
"""
content = json.loads(content)
chat_from = content.get('chat_from')
chat_to = content.get('chat_to')
chat_content = content.get('chat_content')
send_content = json.dumps(dict(chat_from=chat_from, chat_content=chat_content)) phone_numbers = chat_to
self.send_content(send_content, 103, phone_numbers) def handle_broadcast_chat(self, content):
"""
广播
"""
content = json.loads(content)
chat_from = content.get('chat_from')
chat_content = content.get('chat_content')
send_content = json.dumps(dict(chat_from=chat_from, chat_content=chat_content)) phone_numbers = self.users.keys()
self.send_content(send_content, 104, phone_numbers) def send_content(self, send_content, command_id, phone_numbers):
"""
发送函数
"""
length = 12 + len(send_content)
version = self.version
command_id = command_id
header = [length, version, command_id]
header_pack = struct.pack('!3I', *header)
for phone_number in phone_numbers:
if phone_number in self.users.keys():
self.users[phone_number].transport.write(header_pack + send_content)
else:
log.msg("Phone_number:%s 不在线,不能聊天." % phone_number.encode('utf-8')) class ChatFactory(Factory):
def __init__(self):
self.users = {} def buildProtocol(self, addr):
return Chat(self.users) def check_users_online(self):
for key, value in self.users.items():
if value.last_heartbeat_time != 0 and int(time.time()) - value.last_heartbeat_time > 4:
log.msg("[%s]没有检测到心跳包,主动切断" % key.encode('utf-8'))
value.transport.abortConnection() cf = ChatFactory() task1 = task.LoopingCall(cf.check_users_online)
task1.start(3, now=False) reactor.listenTCP(8124, cf)
reactor.run()
就像上面所说的，加了一个接受心跳包的检测的函数，handle_heartbeat，每次来一个心跳包，就把它相应的last_heartbeat_time变换一下，这样，整体轮询检测的时候，我只要判断最后一次连接时间和当前连接时间之差，就可以判断它是不是异常断线了。
这里看我异常断线的处理，transport.abortConnection()，从字面意思上，直接丢弃这个连接，它会调用Protocol的connectionLost，而且它不管那个fd里面有没有数据，全部丢弃。这个我们以后用netstat分析连接的时候，会进一步说明这个函数，现在只要记住，它会强行中断这个连接，删除任何缓存在里面的数据即可。
frontClient.py
# coding:utf-8
from twisted.internet import reactor, task
from twisted.internet.protocol import Protocol, ClientFactory
import struct
from twisted.python import log
import sys
import json
log.startLogging(sys.stdout) class EchoClient(Protocol):
def __init__(self):
self.command_func_dict = {
101: self.handle_verify_s,
102: self.handle_single_chat_s,
103: self.handle_group_chat_s,
104: self.handle_broadcast_chat_s
}
self.version = 0
self.state = "VERIFY"
self.phone_number = "" def connectionMade(self):
log.msg("New connection", self.transport.getPeer()) def dataReceived(self, data):
length, self.version, command_id = struct.unpack('!3I', data[:12])
content = data[12:length]
if self.state == "VERIFY" and command_id == 101:
self.handle_verify_s(content)
else:
self.handle_data(command_id, content) def handle_data(self, command_id, pack_data):
self.command_func_dict[command_id](pack_data) def connectionLost(self, reason):
log.msg("connection lost") def handle_verify_s(self, pack_data):
"""
接受验证结果
"""
content = json.loads(pack_data)
code = content.get('code')
if code == 1:
log.msg('验证通过')
self.state = "Data" def handle_single_chat_s(self, pack_data):
"""
接受单聊
"""
content = json.loads(pack_data)
chat_from = content.get('chat_from')
chat_content = content.get('chat_content')
log.msg("[单聊][%s]:%s" % (chat_from.encode('utf-8'), chat_content.encode('utf-8'))) def handle_group_chat_s(self, pack_data):
"""
接受组聊
"""
content = json.loads(pack_data)
chat_from = content.get('chat_from')
chat_content = content.get('chat_content')
log.msg("[组聊][%s]:%s" % (chat_from.encode('utf-8'), chat_content.encode('utf-8'))) def handle_broadcast_chat_s(self, pack_data):
"""
接受广播
"""
content = json.loads(pack_data)
chat_from = content.get('chat_from')
chat_content = content.get('chat_content')
log.msg("[群聊][%s]:%s" % (chat_from.encode('utf-8'), chat_content.encode('utf-8'))) def send_verify(self, phone_number):
"""
发送验证
"""
content = json.dumps(dict(phone_number=phone_number))
self.send_data(content, 1) def send_single_chat(self, chat_from, chat_to, chat_content):
"""
发送单聊内容
"""
content = json.dumps(dict(chat_from=chat_from, chat_to=chat_to, chat_content=chat_content))
self.send_data(content, 2) def send_group_chat(self, chat_from, chat_to, chat_content):
"""
发送组聊内容
"""
content = json.dumps(dict(chat_from=chat_from, chat_to=chat_to, chat_content=chat_content))
self.send_data(content, 3) def send_broadcast_chat(self, chat_from, chat_content):
"""
发送群聊内容
"""
content = json.dumps(dict(chat_from=chat_from, chat_content=chat_content))
self.send_data(content, 4) def send_data(self, send_content, command_id):
"""
发送函数
"""
length = 12 + len(send_content)
version = self.version
command_id = command_id
header = [length, version, command_id]
header_pack = struct.pack('!3I', *header)
self.transport.write(header_pack + send_content) def send_heartbeat(self):
"""
发送心跳包
"""
length = 12
version = self.version
command_id = 5
header = [length, version, command_id]
header_pack = struct.pack('!3I', *header)
self.transport.write(header_pack) class EchoClientFactory(ClientFactory):
def __init__(self):
self.p = EchoClient() def startedConnecting(self, connector):
log.msg("Started to connect") def buildProtocol(self, addr):
log.msg("Connected.")
return self.p def clientConnectionFailed(self, connector, reason):
log.msg("Lost connection. Reason:", reason) def clientConnectionLost(self, connector, reason):
log.msg("Connection failed. Reason:", reason) if __name__ == '__main__':
cf = EchoClientFactory()
chat_from = sys.argv[1]
all_phone_numbers = ['', '', '', '']
all_phone_numbers.remove(chat_from)
import random task_send_heartbeat = task.LoopingCall(cf.p.send_heartbeat)
task_send_heartbeat.start(2, now=False) reactor.callLater(3, cf.p.send_verify, chat_from)
reactor.callLater(10, cf.p.send_single_chat, chat_from, '', '你好,这是10秒的时候发送')
reactor.callLater(20, cf.p.send_single_chat, chat_from, '', '你好,这是20秒的时候发送') reactor.connectTCP('192.168.5.60', 8124, cf) reactor.run()
这边就添加了一个心跳包发送程序，每隔2秒发送一个心跳包。
我在000002的客户端在10秒和20秒之间，拔掉了网线，看看调试效果，
先看服务器端的调试结果。
/usr/bin/python2. /home/yudahai/PycharmProjects/blog01/tcpserver/frontTCP.py
-- ::+ [-] Log opened.
-- ::+ [-] ChatFactory starting on
-- ::+ [-] Starting factory <__main__.ChatFactory instance at 0x7ff3c3615758>
-- ::+ [__main__.ChatFactory] New connection, the info is: IPv4Address(TCP, '192.168.5.15', )
-- ::+ [__main__.ChatFactory] New connection, the info is: IPv4Address(TCP, '192.168.5.60', )
-- ::+ [Chat,,192.168.5.15] 欢迎, !
-- ::+ [Chat,,192.168.5.60] 欢迎, !
-- ::+ [Chat,,192.168.5.60] 你好,这是10秒的时候发送
-- ::+ [-] []没有检测到心跳包,主动切断
-- ::+ [-] []:断线
-- ::+ [Chat,,192.168.5.60] 你好,这是20秒的时候发送
-- ::+ [Chat,,192.168.5.60] Phone_number: 不在线,不能聊天.
看见没有，已经能主动检测到了。
再看一下客户端000002的调试结果
yudahai@yu-sony:~/PycharmProjects/flask001$ python frontClient.py
-- ::+ [-] Log opened.
-- ::+ [-] Starting factory <__main__.EchoClientFactory instance at 0x7f4e3e3d56c8>
-- ::+ [-] Started to connect
-- ::+ [Uninitialized] Connected.
-- ::+ [Uninitialized] New connection IPv4Address(TCP, '192.168.5.60', )
-- ::+ [EchoClient,client] 验证通过
-- ::+ [EchoClient,client] [单聊][]:你好,这是10秒的时候发送
-- ::+ [EchoClient,client] connection lost
-- ::+ [EchoClient,client] Connection failed. Reason: [Failure instance: Traceback (failure with no frames): <class 'twisted.internet.error.ConnectionLost'>: Connection to the other side was lost in a non-clean fashion.
]
-- ::+ [EchoClient,client] Stopping factory <__main__.EchoClientFactory instance at 0x7f4e3e3d56c8>
比较有意思，15:16我中断了连接，没有接受到，这时候服务器主动切断网络，再连接上来的时候，它已经接受到消息，自己被中断了，其实客户端应该有个断线重连机制，不过这是客户端的事，主要看你的业务需求。
到这，利用心跳包来检测异常网络情况就完成了，如果你有更好的方案，欢迎大家跟我讨论，毕竟我不是专门做tcpserver的，很多东西可能没有研究到。
下一章，我们研究twisted连接redis，把一些很状态转移到redis中，这样，其他模块就能共享这个状态了，这在物联网中，用到尤其多，比如设备在线断线状态、报警状态等，前端web可以直接拿来使用了；以后我们还会讲rabbitmq在twisted中的应用。