I don't think it's safe to use map.iteritems() in the various poll
routines. I got some errors "dictionary changed size during
iteration" when running ZEO tests on machine while doing heavy
forground work in another window, and thinking about it, I believe
that it should be okay if readable() or writable() modifies the map.
I also finally made all the spacing conform to the Python style guide:
no space between a function/method name and the following left
parenthesis (fixed lots of occurrences), spaces around assignment
operators (fixed a few, always of the form "map=..."), and a blank
line between the class statement and the first method definition (a
few).
diff --git a/Lib/asyncore.py b/Lib/asyncore.py
index 180a189..e491f4d 100644
--- a/Lib/asyncore.py
+++ b/Lib/asyncore.py
@@ -90,12 +90,12 @@
except:
obj.handle_error()
-def poll (timeout=0.0, map=None):
+def poll(timeout=0.0, map=None):
if map is None:
map = socket_map
if map:
r = []; w = []; e = []
- for fd, obj in map.iteritems():
+ for fd, obj in map.items():
if obj.readable():
r.append(fd)
if obj.writable():
@@ -118,40 +118,40 @@
continue
write(obj)
-def poll2 (timeout=0.0, map=None):
+def poll2(timeout=0.0, map=None):
import poll
if map is None:
- map=socket_map
+ map = socket_map
if timeout is not None:
# timeout is in milliseconds
timeout = int(timeout*1000)
if map:
l = []
- for fd, obj in map.iteritems():
+ for fd, obj in map.items():
flags = 0
if obj.readable():
flags = poll.POLLIN
if obj.writable():
flags = flags | poll.POLLOUT
if flags:
- l.append ((fd, flags))
- r = poll.poll (l, timeout)
+ l.append((fd, flags))
+ r = poll.poll(l, timeout)
for fd, flags in r:
obj = map.get(fd)
if obj is None:
continue
readwrite(obj, flags)
-def poll3 (timeout=0.0, map=None):
+def poll3(timeout=0.0, map=None):
# Use the poll() support added to the select module in Python 2.0
if map is None:
- map=socket_map
+ map = socket_map
if timeout is not None:
# timeout is in milliseconds
timeout = int(timeout*1000)
pollster = select.poll()
if map:
- for fd, obj in map.iteritems():
+ for fd, obj in map.items():
flags = 0
if obj.readable():
flags = select.POLLIN
@@ -160,7 +160,7 @@
if flags:
pollster.register(fd, flags)
try:
- r = pollster.poll (timeout)
+ r = pollster.poll(timeout)
except select.error, err:
if err[0] != EINTR:
raise
@@ -171,12 +171,12 @@
continue
readwrite(obj, flags)
-def loop (timeout=30.0, use_poll=0, map=None):
+def loop(timeout=30.0, use_poll=0, map=None):
if map is None:
map = socket_map
if use_poll:
- if hasattr (select, 'poll'):
+ if hasattr(select, 'poll'):
poll_fun = poll3
else:
poll_fun = poll2
@@ -184,20 +184,21 @@
poll_fun = poll
while map:
- poll_fun (timeout, map)
+ poll_fun(timeout, map)
class dispatcher:
+
debug = 0
connected = 0
accepting = 0
closing = 0
addr = None
- def __init__ (self, sock=None, map=None):
+ def __init__(self, sock=None, map=None):
if sock:
- self.set_socket (sock, map)
+ self.set_socket(sock, map)
# I think it should inherit this anyway
- self.socket.setblocking (0)
+ self.socket.setblocking(0)
self.connected = 1
# XXX Does the constructor require that the socket passed
# be connected?
@@ -209,53 +210,53 @@
else:
self.socket = None
- def __repr__ (self):
+ def __repr__(self):
status = [self.__class__.__module__+"."+self.__class__.__name__]
if self.accepting and self.addr:
- status.append ('listening')
+ status.append('listening')
elif self.connected:
- status.append ('connected')
+ status.append('connected')
if self.addr is not None:
try:
- status.append ('%s:%d' % self.addr)
+ status.append('%s:%d' % self.addr)
except TypeError:
- status.append (repr(self.addr))
- return '<%s at %#x>' % (' '.join (status), id (self))
+ status.append(repr(self.addr))
+ return '<%s at %#x>' % (' '.join(status), id(self))
- def add_channel (self, map=None):
- #self.log_info ('adding channel %s' % self)
+ def add_channel(self, map=None):
+ #self.log_info('adding channel %s' % self)
if map is None:
- map=socket_map
+ map = socket_map
map [self._fileno] = self
- def del_channel (self, map=None):
+ def del_channel(self, map=None):
fd = self._fileno
if map is None:
- map=socket_map
- if map.has_key (fd):
- #self.log_info ('closing channel %d:%s' % (fd, self))
+ map = socket_map
+ if map.has_key(fd):
+ #self.log_info('closing channel %d:%s' % (fd, self))
del map [fd]
- def create_socket (self, family, type):
+ def create_socket(self, family, type):
self.family_and_type = family, type
- self.socket = socket.socket (family, type)
+ self.socket = socket.socket(family, type)
self.socket.setblocking(0)
self._fileno = self.socket.fileno()
self.add_channel()
- def set_socket (self, sock, map=None):
+ def set_socket(self, sock, map=None):
self.socket = sock
## self.__dict__['socket'] = sock
self._fileno = sock.fileno()
- self.add_channel (map)
+ self.add_channel(map)
- def set_reuse_addr (self):
+ def set_reuse_addr(self):
# try to re-use a server port if possible
try:
- self.socket.setsockopt (
+ self.socket.setsockopt(
socket.SOL_SOCKET, socket.SO_REUSEADDR,
- self.socket.getsockopt (socket.SOL_SOCKET,
- socket.SO_REUSEADDR) | 1
+ self.socket.getsockopt(socket.SOL_SOCKET,
+ socket.SO_REUSEADDR) | 1
)
except socket.error:
pass
@@ -266,33 +267,33 @@
# to pass to select().
# ==================================================
- def readable (self):
+ def readable(self):
return True
if os.name == 'mac':
# The macintosh will select a listening socket for
# write if you let it. What might this mean?
- def writable (self):
+ def writable(self):
return not self.accepting
else:
- def writable (self):
+ def writable(self):
return True
# ==================================================
# socket object methods.
# ==================================================
- def listen (self, num):
+ def listen(self, num):
self.accepting = 1
if os.name == 'nt' and num > 5:
num = 1
- return self.socket.listen (num)
+ return self.socket.listen(num)
- def bind (self, addr):
+ def bind(self, addr):
self.addr = addr
- return self.socket.bind (addr)
+ return self.socket.bind(addr)
- def connect (self, address):
+ def connect(self, address):
self.connected = 0
err = self.socket.connect_ex(address)
if err in (EINPROGRESS, EALREADY, EWOULDBLOCK):
@@ -304,7 +305,7 @@
else:
raise socket.error, err
- def accept (self):
+ def accept(self):
# XXX can return either an address pair or None
try:
conn, addr = self.socket.accept()
@@ -315,9 +316,9 @@
else:
raise socket.error, why
- def send (self, data):
+ def send(self, data):
try:
- result = self.socket.send (data)
+ result = self.socket.send(data)
return result
except socket.error, why:
if why[0] == EWOULDBLOCK:
@@ -326,9 +327,9 @@
raise socket.error, why
return 0
- def recv (self, buffer_size):
+ def recv(self, buffer_size):
try:
- data = self.socket.recv (buffer_size)
+ data = self.socket.recv(buffer_size)
if not data:
# a closed connection is indicated by signaling
# a read condition, and having recv() return 0.
@@ -344,27 +345,27 @@
else:
raise socket.error, why
- def close (self):
+ def close(self):
self.del_channel()
self.socket.close()
# cheap inheritance, used to pass all other attribute
# references to the underlying socket object.
- def __getattr__ (self, attr):
- return getattr (self.socket, attr)
+ def __getattr__(self, attr):
+ return getattr(self.socket, attr)
# log and log_info maybe overriden to provide more sophisitcated
# logging and warning methods. In general, log is for 'hit' logging
# and 'log_info' is for informational, warning and error logging.
- def log (self, message):
- sys.stderr.write ('log: %s\n' % str(message))
+ def log(self, message):
+ sys.stderr.write('log: %s\n' % str(message))
- def log_info (self, message, type='info'):
+ def log_info(self, message, type='info'):
if __debug__ or type != 'info':
print '%s: %s' % (type, message)
- def handle_read_event (self):
+ def handle_read_event(self):
if self.accepting:
# for an accepting socket, getting a read implies
# that we are connected
@@ -378,26 +379,26 @@
else:
self.handle_read()
- def handle_write_event (self):
+ def handle_write_event(self):
# getting a write implies that we are connected
if not self.connected:
self.handle_connect()
self.connected = 1
self.handle_write()
- def handle_expt_event (self):
+ def handle_expt_event(self):
self.handle_expt()
- def handle_error (self):
+ def handle_error(self):
nil, t, v, tbinfo = compact_traceback()
# sometimes a user repr method will crash.
try:
- self_repr = repr (self)
+ self_repr = repr(self)
except:
- self_repr = '<__repr__ (self) failed for object at %0x>' % id(self)
+ self_repr = '<__repr__(self) failed for object at %0x>' % id(self)
- self.log_info (
+ self.log_info(
'uncaptured python exception, closing channel %s (%s:%s %s)' % (
self_repr,
t,
@@ -408,23 +409,23 @@
)
self.close()
- def handle_expt (self):
- self.log_info ('unhandled exception', 'warning')
+ def handle_expt(self):
+ self.log_info('unhandled exception', 'warning')
- def handle_read (self):
- self.log_info ('unhandled read event', 'warning')
+ def handle_read(self):
+ self.log_info('unhandled read event', 'warning')
- def handle_write (self):
- self.log_info ('unhandled write event', 'warning')
+ def handle_write(self):
+ self.log_info('unhandled write event', 'warning')
- def handle_connect (self):
- self.log_info ('unhandled connect event', 'warning')
+ def handle_connect(self):
+ self.log_info('unhandled connect event', 'warning')
- def handle_accept (self):
- self.log_info ('unhandled accept event', 'warning')
+ def handle_accept(self):
+ self.log_info('unhandled accept event', 'warning')
- def handle_close (self):
- self.log_info ('unhandled close event', 'warning')
+ def handle_close(self):
+ self.log_info('unhandled close event', 'warning')
self.close()
# ---------------------------------------------------------------------------
@@ -432,25 +433,26 @@
# [for more sophisticated usage use asynchat.async_chat]
# ---------------------------------------------------------------------------
-class dispatcher_with_send (dispatcher):
- def __init__ (self, sock=None):
- dispatcher.__init__ (self, sock)
+class dispatcher_with_send(dispatcher):
+
+ def __init__(self, sock=None):
+ dispatcher.__init__(self, sock)
self.out_buffer = ''
- def initiate_send (self):
+ def initiate_send(self):
num_sent = 0
- num_sent = dispatcher.send (self, self.out_buffer[:512])
+ num_sent = dispatcher.send(self, self.out_buffer[:512])
self.out_buffer = self.out_buffer[num_sent:]
- def handle_write (self):
+ def handle_write(self):
self.initiate_send()
- def writable (self):
+ def writable(self):
return (not self.connected) or len(self.out_buffer)
- def send (self, data):
+ def send(self, data):
if self.debug:
- self.log_info ('sending %s' % repr(data))
+ self.log_info('sending %s' % repr(data))
self.out_buffer = self.out_buffer + data
self.initiate_send()
@@ -458,11 +460,11 @@
# used for debugging.
# ---------------------------------------------------------------------------
-def compact_traceback ():
+def compact_traceback():
t,v,tb = sys.exc_info()
tbinfo = []
while 1:
- tbinfo.append ((
+ tbinfo.append((
tb.tb_frame.f_code.co_filename,
tb.tb_frame.f_code.co_name,
str(tb.tb_lineno)
@@ -478,9 +480,9 @@
info = '[' + '] ['.join(map(lambda x: '|'.join(x), tbinfo)) + ']'
return (file, function, line), t, v, info
-def close_all (map=None):
+def close_all(map=None):
if map is None:
- map=socket_map
+ map = socket_map
for x in map.values():
x.socket.close()
map.clear()
@@ -504,35 +506,37 @@
class file_wrapper:
# here we override just enough to make a file
# look like a socket for the purposes of asyncore.
- def __init__ (self, fd):
+
+ def __init__(self, fd):
self.fd = fd
- def recv (self, *args):
+ def recv(self, *args):
return os.read(self.fd, *args)
- def send (self, *args):
+ def send(self, *args):
return os.write(self.fd, *args)
read = recv
write = send
- def close (self):
- return os.close (self.fd)
+ def close(self):
+ return os.close(self.fd)
- def fileno (self):
+ def fileno(self):
return self.fd
- class file_dispatcher (dispatcher):
- def __init__ (self, fd):
- dispatcher.__init__ (self)
+ class file_dispatcher(dispatcher):
+
+ def __init__(self, fd):
+ dispatcher.__init__(self)
self.connected = 1
# set it to non-blocking mode
- flags = fcntl.fcntl (fd, fcntl.F_GETFL, 0)
+ flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0)
flags = flags | os.O_NONBLOCK
- fcntl.fcntl (fd, fcntl.F_SETFL, flags)
- self.set_file (fd)
+ fcntl.fcntl(fd, fcntl.F_SETFL, flags)
+ self.set_file(fd)
- def set_file (self, fd):
+ def set_file(self, fd):
self._fileno = fd
- self.socket = file_wrapper (fd)
+ self.socket = file_wrapper(fd)
self.add_channel()