荐书－An_Introduction_To_Event_Driven_Programming_With_Twisted

这个书刚开始看，翻了第一章感觉是在教你如何写类似twisted这样的框架，感觉不错。
异步asyncio 和twisted 对我来说是很复杂的，总感觉是对应c里面的select/epoll
就是多路复用。

但是有些地方略晕,
python3的non-block 会触发的exception 改成了BlockingIOError。
python2里面是socket.error
但我试了下在try exception里面这两种exception 都可以。
except BlockingIOError as e:
或者
except socket.error as e:

另外，该书在github上的代码不全。
我自己敲了第一章20页的完整代码，
该代码会触发MemoryError.

点击(此处)折叠或打开

1. import select
   
2. 
   
3. class Reactor:
   
4.     def __init__(self):
   
5. 
   
6.         self._readers = {}
   
7.         self._writers = {}
   
8.     
   
9.     def addReader(self, readable, handler):
   
10.         self._readers[readable]= handler
    
11.     
    
12.     def addWriter(self, writable, handler):
    
13.         self._writers[writable]=handler
    
14.     
    
15.     def removeReader(self, readable):
    
16.         self._readers.pop(readable, None)
    
17.     
    
18.     
    
19.     def removeWriter(self, writable):
    
20.         self._writers.pop(writable, None)
    
21.     
    
22.     def run(self):
    
23.         while self._readers or self._writers:
    
24.             r, w, _ = select.select(list(self._readers), list(self._writers),[])
    
25.             for readable in r:
    
26.                 self._readers[readable](self, readable)
    
27.             
    
28.             for writable in w:
    
29.                 if writable in self._writers:
    
30.                     self._writers[writable](self, writable)
    
31. 
    
32. import errno
    
33. import socket
    
34. 
    
35. class BuffersWrites:
    
36.     def __init__(self, dataToWrite, onCompletion):
    
37.         self._buffer = dataToWrite
    
38.         self._onCompletion = onCompletion
    
39.     
    
40.     def bufferingWrite(self, reactor, sock):
    
41.         if self._buffer:
    
42.             try:
    
43.                 written = sock.send(self._buffer)
    
44.             except socket.error as e:
    
45.                 if e.errno != errno.EAGAIN:
    
46.                     raise
    
47.                 return
    
48.             else:
    
49.                 print("Wrote", written, ' bytes')
    
50.                 self._buffer = self._buffer[written:]
    
51.         if not self._buffer:
    
52.             reactor.removeWriter(sock)
    
53.             self._onCompletion(reactor, sock)
    
54. 
    
55. 
    
56. def accept(reactor, listener):
    
57.     server, _ = listener.accept()
    
58.     #server.setblocking(False)
    
59.     reactor.addReader(server, read)
    
60. 
    
61. def read(reactor, sock):
    
62.     data = sock.recv(1024)
    
63.     if data:
    
64.         print("Server received", len(data), ' bytes')
    
65.     else:
    
66.         sock.close()
    
67.         print("Server closed")
    
68.         reactor.removeReader(sock)
    
69.         
    
70. 
    
71. DATA=[b'*', b'*']
    
72. def write(reactor, sock):
    
73.     writer = BuffersWrites(b''.join(DATA), onCompletion=write)
    
74.     reactor.addWriter(sock, writer.bufferingWrite)
    
75.     print('Client buffering', len(DATA), ' bytes to write.')
    
76.     DATA.extend(DATA)
    
77. 
    
78. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
79. sock.bind(('127.0.0.1', 0))
    
80. sock.listen(1)
    
81. client= socket.create_connection(sock.getsockname())
    
82. client.setblocking(False)
    
83. 
    
84. loop = Reactor()
    
85. loop.addWriter(client, write)
    
86. loop.addReader(sock, accept)
    
87. loop.run()