# Written by Bram Cohen
# see LICENSE.txt for license information
#文件名称：RewServer.py
#读码日记：2004-9-7
#笔 者：zfive5(醉马不肖 之 [孤舟蓑笠翁， 独钓寒江雪])
#
# 分析RawServer类 主要负责socket通讯
| #poll( | [timeout]) |
(fd,
#event) 2-tuples for the descriptors that have events or errors to report.
fd is the file #descriptor, and
event is a bitmask with bits set for the reported events for that descriptor --
#POLLIN for waiting input,
POLLOUT to indicate that the descriptor can be written to, and so #forth. An empty list indicates that the call timed out and no file descriptors had any events to
#report. If
timeout is given, it specifies the length of time in milliseconds which the system will
#wait for events before returning. If
timeout is omitted, negative, or
None, the call will block
#until there is an event for this poll object.
from bisect import insort
import socket
from cStringIO import StringIO
from traceback import print_exc
from errno import EWOULDBLOCK, EINTR
try:
from select import poll, error, POLLIN, POLLOUT, POLLERR, POLLHUP
timemult = 1000
except ImportError:
from selectpoll import poll, error, POLLIN, POLLOUT, POLLERR, POLLHUP
timemult = 1
from threading import Thread, Event
from time import time, sleep
import sys
from random import randrange
all = POLLIN | POLLOUT
#socket类,对基础socket类进行封装,这也是通讯的基础
class SingleSocket:
def __init__(self, raw_server, sock, handler):
self.raw_server = raw_server
self.socket = sock
self.handler = handler
self.buffer = []
self.last_hit = time()
self.fileno = sock.fileno()
self.connected = False
#得到连接对方的ip地址
def get_ip(self):
try:
return self.socket.getpeername()[0]
except socket.error:
return 'no connection'
#关闭socket连接,这里有点像window的closesocket()函数
def close(self):
sock = self.socket
self.socket = None
self.buffer = []
del self.raw_server.single_sockets[self.fileno]
self.raw_server.poll.unregister(sock)
sock.close()
#这就不用说了，是shutdown()了
def shutdown(self, val):
self.socket.shutdown(val)
#判断缓冲区列表是否为空
def is_flushed(self):
return len(self.buffer) == 0
#功能就是把数据写到缓冲区列表中,当列表元素为1时,发送数据
#给连接对方
def write(self, s):
assert self.socket is not None
self.buffer.append(s)
if len(self.buffer) == 1:
self.try_write()
#发送数据给对方
def try_write(self):
if self.connected:
try:
while self.buffer != []:
amount = self.socket.send(self.buffer[0])
if amount != len(self.buffer[0]):
if amount != 0:
self.buffer[0] = self.buffer[0][amount:]
break
del self.buffer[0]
except socket.error, e:
code, msg = e
if code != EWOULDBLOCK:
self.raw_server.dead_from_write.append(self)
return
#缓冲区为空，就只注册读数据事件
if self.buffer == []:
self.raw_server.poll.register(self.socket, POLLIN)
else:
#要不读写都注册
self.raw_server.poll.register(self.socket, all)
#服务器类
class RawServer:
def __init__(self, doneflag, timeout_check_interval, timeout, noisy = True, errorfunc = None):
self.timeout_check_interval = timeout_check_interval
self.timeout = timeout
self.poll = poll()
# {socket: SingleSocket}
self.single_sockets = {}
self.dead_from_write = []
self.doneflag = doneflag
self.noisy = noisy
self.errorfunc = errorfunc
self.funcs = []
self.externally_added = []
self.add_task(self.scan_for_timeouts, timeout_check_interval)
#增加一个任务到任务列表，最后运行时刻为time()+delay
def add_task(self, func, delay):
insort(self.funcs, (time() + delay, func))
#增加一个附加的任务到任务列表，最后运行时刻为time()+delay
def external_add_task(self, func, delay = 0):
self.externally_added.append((func, delay))
#检查服务器超时socket函数，如果超时关掉处理函数
def scan_for_timeouts(self):
self.add_task(self.scan_for_timeouts, self.timeout_check_interval)
t = time() - self.timeout
tokill = []
for s in self.single_sockets.values():
if s.last_hit < t:
tokill.append(s)
for k in tokill:
if k.socket is not None:
self._close_socket(k)
#捆绑一个端口，设置非阻塞方式，服务器socket与事件注册对应
def bind(self, port, bind = '', reuse = False):
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if reuse:
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.setblocking(0)
server.bind((bind, port))
server.listen(5)
self.poll.register(server, POLLIN)
self.server = server
#连接对方，设置非阻塞方式，socket与事件注册对应
def start_connection(self, dns, handler = None):
if handler is None:
handler = self.handler
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setblocking(0)
try:
sock.connect_ex(dns)
except socket.error:
raise
except Exception, e:
raise socket.error(str(e))
self.poll.register(sock, POLLIN)
s = SingleSocket(self, sock, handler)
self.single_sockets[sock.fileno()] = s
return s
#处理服务器和所有与服务器连接的数据请求，events是socket和关心事件对应列表
def handle_events(self, events):
for sock, event in events:
if sock == self.server.fileno():
#错误关闭服务器
if event & (POLLHUP | POLLERR) != 0:
self.poll.unregister(self.server)
self.server.close()
self.errorfunc('lost server socket')
else:
#服务器accept
try:
newsock, addr = self.server.accept()
newsock.setblocking(0)
nss = SingleSocket(self, newsock, self.handler)
self.single_sockets[newsock.fileno()] = nss
#注册读数据事件
self.poll.register(newsock, POLLIN)
self.handler.external_connection_made(nss)
except socket.error:
#accept失败sleep（1），然后继续
sleep(1)
else:
s = self.single_sockets.get(sock)
if s is None:
continue
s.connected = True
#错误关闭socket
if (event & (POLLHUP | POLLERR)) != 0:
self._close_socket(s)
continue
#读数据处理过程
if (event & POLLIN) != 0:
try:
s.last_hit = time()
data = s.socket.recv(100000)
if data == '':
self._close_socket(s)
else:
#调用处理函数
s.handler.data_came_in(s, data)
except socket.error, e:
code, msg = e
if code != EWOULDBLOCK:
self._close_socket(s)
continue
#写数据处理过程
if (event & POLLOUT) != 0 and s.socket is not None and not s.is_flushed():
s.try_write()
if s.is_flushed():
s.handler.connection_flushed(s)
#弹出附加任务
def pop_external(self):
try:
while True:
(a, b) = self.externally_added.pop()
self.add_task(a, b)
except IndexError:
pass
#download里调用的处理函数，这里主要是完成数据处理和调用处理
def listen_forever(self, handler):
self.handler = handler
try:
#如果完成标志被执就退出
while not self.doneflag.isSet():
try:
#加入一个附加任务
self.pop_external()
#任务列表为空
if len(self.funcs) == 0:
period = 2 ** 30
else:
#任务列表不为空
period = self.funcs[0][0] - time()
间隔小于零，就间隔执零
if period < 0:
period = 0
#设置注册事件超时
events = self.poll.poll(period * timemult)
#如果完成标志被执就退出
if self.doneflag.isSet():
return
#调用任务处理函数
while len(self.funcs) > 0 and self.funcs[0][0] <= time():
garbage, func = self.funcs[0]
del self.funcs[0]
try:
func()
except KeyboardInterrupt:
print_exc()
return
except:
if self.noisy:
data = StringIO()
print_exc(file = data)
self.errorfunc(data.getvalue())
#关闭无反映的socket
self._close_dead()
#处理socket请求或数据接收、发送
self.handle_events(events)
#如果完成标志被执就退出
if self.doneflag.isSet():
return
#关闭无反映的socket
self._close_dead()
except error:
if self.doneflag.isSet():
return
except KeyboardInterrupt:
print_exc()
return
except:
data = StringIO()
print_exc(file = data)
self.errorfunc(data.getvalue())
finally:
for ss in self.single_sockets.values():
ss.close()
self.server.close()
#关闭死的连接
def _close_dead(self):
while len(self.dead_from_write) > 0:
old = self.dead_from_write
self.dead_from_write = []
for s in old:
if s.socket is not None:
self._close_socket(s)
#关闭socket连接
def _close_socket(self, s):
sock = s.socket.fileno()
s.socket.close()
self.poll.unregister(sock)
del self.single_sockets[sock]
s.socket = None
s.handler.connection_lost(s)
#下面是测试用例，这里省略不写，接下来Storage类留到下次在分析吧。。。。。
扫一扫
706
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
