python3 compat: 2to3: except E as e: syntax
First step to Python 3 compatibility "2to3 -w -f except ." See [1] [1] http://docs.python.org/2/library/2to3.html#fixers
This commit is contained in:
committed by
Sergey Shepelev
parent
76c1fcf3e5
commit
80633ab224
@@ -39,7 +39,7 @@ try:
|
||||
TimeoutError = timeout.Timeout
|
||||
exc_after = greenthread.exc_after
|
||||
call_after_global = greenthread.call_after_global
|
||||
except ImportError, e:
|
||||
except ImportError as e:
|
||||
# This is to make Debian packaging easier, it ignores import
|
||||
# errors of greenlet so that the packager can still at least
|
||||
# access the version. Also this makes easy_install a little quieter
|
||||
|
||||
@@ -191,7 +191,7 @@ def named(name):
|
||||
try:
|
||||
obj = __import__(toimport)
|
||||
break
|
||||
except ImportError, err:
|
||||
except ImportError as err:
|
||||
# print 'Import error on %s: %s' % (toimport, err) # debugging spam
|
||||
import_err_strings.append(err.__str__())
|
||||
toimport = '.'.join(toimport.split('.')[:-1])
|
||||
|
||||
@@ -85,7 +85,7 @@ def backdoor_server(sock, locals=None):
|
||||
while True:
|
||||
socketpair = sock.accept()
|
||||
backdoor(socketpair, locals)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
# Broken pipe means it was shutdown
|
||||
if get_errno(e) != errno.EPIPE:
|
||||
raise
|
||||
|
||||
@@ -61,7 +61,7 @@ class GreenConnection(greenio.GreenSocket):
|
||||
write=True,
|
||||
timeout=self.gettimeout(),
|
||||
timeout_exc=socket.timeout)
|
||||
except SysCallError, e:
|
||||
except SysCallError as e:
|
||||
if get_errno(e) == -1 or get_errno(e) > 0:
|
||||
return ''
|
||||
|
||||
|
||||
@@ -52,7 +52,7 @@ class GreenSSLObject(object):
|
||||
else:
|
||||
try:
|
||||
self.connection.do_handshake()
|
||||
except _SSL.SysCallError, e:
|
||||
except _SSL.SysCallError as e:
|
||||
raise _convert_to_sslerror(e)
|
||||
|
||||
def read(self, n=1024):
|
||||
@@ -62,7 +62,7 @@ class GreenSSLObject(object):
|
||||
return self.connection.read(n)
|
||||
except _SSL.ZeroReturnError:
|
||||
return ''
|
||||
except _SSL.SysCallError, e:
|
||||
except _SSL.SysCallError as e:
|
||||
raise _convert_to_sslerror(e)
|
||||
|
||||
def write(self, s):
|
||||
@@ -70,7 +70,7 @@ class GreenSSLObject(object):
|
||||
The return value is the number of bytes written. """
|
||||
try:
|
||||
return self.connection.write(s)
|
||||
except _SSL.SysCallError, e:
|
||||
except _SSL.SysCallError as e:
|
||||
raise _convert_to_sslerror(e)
|
||||
|
||||
def server(self):
|
||||
|
||||
@@ -22,7 +22,7 @@ def fdopen(fd, *args, **kw):
|
||||
raise TypeError('fd should be int, not %r' % fd)
|
||||
try:
|
||||
return greenio.GreenPipe(fd, *args, **kw)
|
||||
except IOError, e:
|
||||
except IOError as e:
|
||||
raise OSError(*e.args)
|
||||
|
||||
__original_read__ = os_orig.read
|
||||
@@ -33,10 +33,10 @@ def read(fd, n):
|
||||
while True:
|
||||
try:
|
||||
return __original_read__(fd, n)
|
||||
except (OSError, IOError), e:
|
||||
except (OSError, IOError) as e:
|
||||
if get_errno(e) != errno.EAGAIN:
|
||||
raise
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if get_errno(e) == errno.EPIPE:
|
||||
return ''
|
||||
raise
|
||||
@@ -51,10 +51,10 @@ def write(fd, st):
|
||||
while True:
|
||||
try:
|
||||
return __original_write__(fd, st)
|
||||
except (OSError, IOError), e:
|
||||
except (OSError, IOError) as e:
|
||||
if get_errno(e) != errno.EAGAIN:
|
||||
raise
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if get_errno(e) != errno.EPIPE:
|
||||
raise
|
||||
hubs.trampoline(fd, write=True)
|
||||
|
||||
@@ -15,7 +15,7 @@ greendns = None
|
||||
if os.environ.get("EVENTLET_NO_GREENDNS",'').lower() != "yes":
|
||||
try:
|
||||
from eventlet.support import greendns
|
||||
except ImportError, ex:
|
||||
except ImportError as ex:
|
||||
pass
|
||||
|
||||
if greendns:
|
||||
@@ -52,7 +52,7 @@ def create_connection(address,
|
||||
sock.connect(sa)
|
||||
return sock
|
||||
|
||||
except error, msg:
|
||||
except error as msg:
|
||||
if sock is not None:
|
||||
sock.close()
|
||||
|
||||
|
||||
@@ -75,7 +75,7 @@ class GreenSSLSocket(__ssl.SSLSocket):
|
||||
while True:
|
||||
try:
|
||||
return func(*a, **kw)
|
||||
except SSLError, exc:
|
||||
except SSLError as exc:
|
||||
if get_errno(exc) == SSL_ERROR_WANT_READ:
|
||||
trampoline(self,
|
||||
read=True,
|
||||
@@ -137,7 +137,7 @@ class GreenSSLSocket(__ssl.SSLSocket):
|
||||
while True:
|
||||
try:
|
||||
return socket.sendall(self, data, flags)
|
||||
except orig_socket.error, e:
|
||||
except orig_socket.error as e:
|
||||
if self.act_non_blocking:
|
||||
raise
|
||||
if get_errno(e) == errno.EWOULDBLOCK:
|
||||
@@ -160,7 +160,7 @@ class GreenSSLSocket(__ssl.SSLSocket):
|
||||
while True:
|
||||
try:
|
||||
return socket.recv(self, buflen, flags)
|
||||
except orig_socket.error, e:
|
||||
except orig_socket.error as e:
|
||||
if self.act_non_blocking:
|
||||
raise
|
||||
if get_errno(e) == errno.EWOULDBLOCK:
|
||||
@@ -206,7 +206,7 @@ class GreenSSLSocket(__ssl.SSLSocket):
|
||||
while True:
|
||||
try:
|
||||
return real_connect(self, addr)
|
||||
except orig_socket.error, exc:
|
||||
except orig_socket.error as exc:
|
||||
if get_errno(exc) in CONNECT_ERR:
|
||||
trampoline(self, write=True)
|
||||
elif get_errno(exc) in CONNECT_SUCCESS:
|
||||
@@ -218,7 +218,7 @@ class GreenSSLSocket(__ssl.SSLSocket):
|
||||
while True:
|
||||
try:
|
||||
real_connect(self, addr)
|
||||
except orig_socket.error, exc:
|
||||
except orig_socket.error as exc:
|
||||
if get_errno(exc) in CONNECT_ERR:
|
||||
trampoline(self, write=True,
|
||||
timeout=end-time.time(), timeout_exc=timeout_exc('timed out'))
|
||||
@@ -262,7 +262,7 @@ class GreenSSLSocket(__ssl.SSLSocket):
|
||||
newsock, addr = socket.accept(self)
|
||||
set_nonblocking(newsock)
|
||||
break
|
||||
except orig_socket.error, e:
|
||||
except orig_socket.error as e:
|
||||
if get_errno(e) != errno.EWOULDBLOCK:
|
||||
raise
|
||||
trampoline(self, read=True, timeout=self.gettimeout(),
|
||||
|
||||
@@ -64,7 +64,7 @@ class Popen(subprocess_orig.Popen):
|
||||
if timeout is not None and time.time() > endtime:
|
||||
raise TimeoutExpired(self.args)
|
||||
eventlet.sleep(check_interval)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
if e.errno == errno.ECHILD:
|
||||
# no child process, this happens if the child process
|
||||
# already died and has been cleaned up
|
||||
|
||||
@@ -273,7 +273,7 @@ class Socket(_Socket):
|
||||
while True:
|
||||
try:
|
||||
return _Socket_send(self, msg, flags, copy, track)
|
||||
except ZMQError, e:
|
||||
except ZMQError as e:
|
||||
if e.errno == EAGAIN:
|
||||
self._eventlet_send_event.block()
|
||||
else:
|
||||
@@ -319,7 +319,7 @@ class Socket(_Socket):
|
||||
while True:
|
||||
try:
|
||||
return _Socket_recv(self, flags, copy, track)
|
||||
except ZMQError, e:
|
||||
except ZMQError as e:
|
||||
if e.errno == EAGAIN:
|
||||
self._eventlet_recv_event.block()
|
||||
else:
|
||||
|
||||
@@ -54,7 +54,7 @@ def socket_accept(descriptor):
|
||||
"""
|
||||
try:
|
||||
return descriptor.accept()
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if get_errno(e) == errno.EWOULDBLOCK:
|
||||
return None
|
||||
raise
|
||||
@@ -210,7 +210,7 @@ class GreenSocket(object):
|
||||
try:
|
||||
trampoline(fd, write=True)
|
||||
socket_checkerr(fd)
|
||||
except socket.error, ex:
|
||||
except socket.error as ex:
|
||||
return get_errno(ex)
|
||||
else:
|
||||
end = time.time() + self.gettimeout()
|
||||
@@ -223,7 +223,7 @@ class GreenSocket(object):
|
||||
trampoline(fd, write=True, timeout=end - time.time(),
|
||||
timeout_exc=socket.timeout(errno.EAGAIN))
|
||||
socket_checkerr(fd)
|
||||
except socket.error, ex:
|
||||
except socket.error as ex:
|
||||
return get_errno(ex)
|
||||
|
||||
def dup(self, *args, **kw):
|
||||
@@ -251,7 +251,7 @@ class GreenSocket(object):
|
||||
while True:
|
||||
try:
|
||||
return fd.recv(buflen, flags)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if get_errno(e) in SOCKET_BLOCKING:
|
||||
pass
|
||||
elif get_errno(e) in SOCKET_CLOSED:
|
||||
@@ -293,7 +293,7 @@ class GreenSocket(object):
|
||||
while 1:
|
||||
try:
|
||||
total_sent += fd.send(data[total_sent:], flags)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if get_errno(e) not in SOCKET_BLOCKING:
|
||||
raise
|
||||
|
||||
@@ -369,7 +369,7 @@ class _SocketDuckForFd(object):
|
||||
try:
|
||||
data = os.read(self._fileno, buflen)
|
||||
return data
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
if get_errno(e) != errno.EAGAIN:
|
||||
raise IOError(*e.args)
|
||||
trampoline(self, read=True)
|
||||
@@ -380,7 +380,7 @@ class _SocketDuckForFd(object):
|
||||
fileno = self._fileno
|
||||
try:
|
||||
total_sent = os_write(fileno, data)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
if get_errno(e) != errno.EAGAIN:
|
||||
raise IOError(*e.args)
|
||||
total_sent = 0
|
||||
@@ -388,7 +388,7 @@ class _SocketDuckForFd(object):
|
||||
trampoline(self, write=True)
|
||||
try:
|
||||
total_sent += os_write(fileno, data[total_sent:])
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
if get_errno(e) != errno. EAGAIN:
|
||||
raise IOError(*e.args)
|
||||
|
||||
@@ -479,7 +479,7 @@ class GreenPipe(_fileobject):
|
||||
n = len(data)
|
||||
try:
|
||||
buf[:n] = data
|
||||
except TypeError, err:
|
||||
except TypeError as err:
|
||||
if not isinstance(buf, array.array):
|
||||
raise err
|
||||
buf[:n] = array.array('c', data)
|
||||
@@ -500,7 +500,7 @@ class GreenPipe(_fileobject):
|
||||
self.flush()
|
||||
try:
|
||||
return os.lseek(self.fileno(), 0, 1) - self._get_readahead_len()
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
raise IOError(*e.args)
|
||||
|
||||
def seek(self, offset, whence=0):
|
||||
@@ -511,7 +511,7 @@ class GreenPipe(_fileobject):
|
||||
offset -= self._get_readahead_len()
|
||||
try:
|
||||
rv = os.lseek(self.fileno(), offset, whence)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
raise IOError(*e.args)
|
||||
else:
|
||||
self._clear_readahead_buf()
|
||||
@@ -524,7 +524,7 @@ class GreenPipe(_fileobject):
|
||||
size = self.tell()
|
||||
try:
|
||||
rv = os.ftruncate(self.fileno(), size)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
raise IOError(*e.args)
|
||||
else:
|
||||
self.seek(size) # move position&clear buffer
|
||||
@@ -533,7 +533,7 @@ class GreenPipe(_fileobject):
|
||||
def isatty(self):
|
||||
try:
|
||||
return os.isatty(self.fileno())
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
raise IOError(*e.args)
|
||||
|
||||
|
||||
@@ -572,7 +572,7 @@ def shutdown_safe(sock):
|
||||
except TypeError:
|
||||
# SSL.Connection
|
||||
return sock.shutdown()
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
# we don't care if the socket is already closed;
|
||||
# this will often be the case in an http server context
|
||||
if get_errno(e) != errno.ENOTCONN:
|
||||
|
||||
@@ -52,7 +52,7 @@ class Hub(poll.Hub):
|
||||
self.register(fileno, new=True)
|
||||
else:
|
||||
self.register(fileno, new=False)
|
||||
except IOError, ex: # ignore EEXIST, #80
|
||||
except IOError as ex: # ignore EEXIST, #80
|
||||
if get_errno(ex) != errno.EEXIST:
|
||||
raise
|
||||
return listener
|
||||
|
||||
@@ -154,7 +154,7 @@ class BaseHub(object):
|
||||
for listener in listeners:
|
||||
try:
|
||||
listener.cb(fileno)
|
||||
except Exception, e:
|
||||
except Exception as e:
|
||||
self.squelch_generic_exception(sys.exc_info())
|
||||
|
||||
def ensure_greenlet(self):
|
||||
@@ -192,7 +192,7 @@ class BaseHub(object):
|
||||
sys.stderr.flush()
|
||||
try:
|
||||
self.remove_descriptor(fileno)
|
||||
except Exception, e:
|
||||
except Exception as e:
|
||||
sys.stderr.write("Exception while removing descriptor! %r\n" % (e,))
|
||||
sys.stderr.flush()
|
||||
|
||||
|
||||
@@ -74,7 +74,7 @@ class Hub(BaseHub):
|
||||
event = self._events[fileno].pop(evtype)
|
||||
try:
|
||||
self._delete_events([event])
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
pass
|
||||
|
||||
def remove_descriptor(self, fileno):
|
||||
@@ -82,9 +82,9 @@ class Hub(BaseHub):
|
||||
try:
|
||||
events = self._events.pop(fileno).values()
|
||||
self._delete_events(events)
|
||||
except KeyError, e:
|
||||
except KeyError as e:
|
||||
pass
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
pass
|
||||
|
||||
def wait(self, seconds=None):
|
||||
|
||||
@@ -82,7 +82,7 @@ class Hub(BaseHub):
|
||||
return
|
||||
try:
|
||||
presult = self.do_poll(seconds)
|
||||
except (IOError, select.error), e:
|
||||
except (IOError, select.error) as e:
|
||||
if get_errno(e) == errno.EINTR:
|
||||
return
|
||||
raise
|
||||
|
||||
@@ -20,7 +20,7 @@ class Hub(BaseHub):
|
||||
for fd in self.listeners[READ].keys() + self.listeners[WRITE].keys():
|
||||
try:
|
||||
select.select([fd], [], [], 0)
|
||||
except select.error, e:
|
||||
except select.error as e:
|
||||
if get_errno(e) in BAD_SOCK:
|
||||
self.remove_descriptor(fd)
|
||||
|
||||
@@ -33,7 +33,7 @@ class Hub(BaseHub):
|
||||
return
|
||||
try:
|
||||
r, w, er = select.select(readers.keys(), writers.keys(), readers.keys() + writers.keys(), seconds)
|
||||
except select.error, e:
|
||||
except select.error as e:
|
||||
if get_errno(e) == errno.EINTR:
|
||||
return
|
||||
elif get_errno(e) in BAD_SOCK:
|
||||
|
||||
@@ -651,7 +651,7 @@ class wrap_errors(object):
|
||||
def __call__(self, *args, **kwargs):
|
||||
try:
|
||||
return self.func(*args, **kwargs)
|
||||
except self.errors, ex:
|
||||
except self.errors as ex:
|
||||
return ex
|
||||
|
||||
def __str__(self):
|
||||
|
||||
@@ -35,7 +35,7 @@ def cooperative_wait(pobj, check_interval=0.01):
|
||||
if status >= 0:
|
||||
return status
|
||||
api.sleep(check_interval)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
if e.errno == errno.ECHILD:
|
||||
# no child process, this happens if the child process
|
||||
# already died and has been cleaned up, or if you just
|
||||
@@ -109,7 +109,7 @@ class Process(object):
|
||||
try:
|
||||
written = self.child_stdin.write(stuff)
|
||||
self.child_stdin.flush()
|
||||
except ValueError, e:
|
||||
except ValueError as e:
|
||||
## File was closed
|
||||
assert str(e) == 'I/O operation on closed file'
|
||||
if written == 0:
|
||||
|
||||
@@ -120,9 +120,9 @@ def resolve(name):
|
||||
if rrset is None or time.time() > rrset.expiration:
|
||||
try:
|
||||
rrset = resolver.query(name)
|
||||
except dns.exception.Timeout, e:
|
||||
except dns.exception.Timeout as e:
|
||||
error = (socket.EAI_AGAIN, 'Lookup timed out')
|
||||
except dns.exception.DNSException, e:
|
||||
except dns.exception.DNSException as e:
|
||||
error = (socket.EAI_NODATA, 'No address associated with hostname')
|
||||
else:
|
||||
pass
|
||||
@@ -147,9 +147,9 @@ def getaliases(host):
|
||||
|
||||
try:
|
||||
answers = dns.resolver.query(host, 'cname')
|
||||
except dns.exception.Timeout, e:
|
||||
except dns.exception.Timeout as e:
|
||||
error = (socket.EAI_AGAIN, 'Lookup timed out')
|
||||
except dns.exception.DNSException, e:
|
||||
except dns.exception.DNSException as e:
|
||||
error = (socket.EAI_NODATA, 'No address associated with hostname')
|
||||
else:
|
||||
for record in answers:
|
||||
@@ -232,10 +232,10 @@ def getnameinfo(sockaddr, flags):
|
||||
if len(rrset) > 1:
|
||||
raise socket.error('sockaddr resolved to multiple addresses')
|
||||
host = rrset[0].target.to_text(omit_final_dot=True)
|
||||
except dns.exception.Timeout, e:
|
||||
except dns.exception.Timeout as e:
|
||||
if flags & socket.NI_NAMEREQD:
|
||||
raise socket.gaierror((socket.EAI_AGAIN, 'Lookup timed out'))
|
||||
except dns.exception.DNSException, e:
|
||||
except dns.exception.DNSException as e:
|
||||
if flags & socket.NI_NAMEREQD:
|
||||
raise socket.gaierror(
|
||||
(socket.EAI_NONAME, 'Name or service not known'))
|
||||
@@ -246,9 +246,9 @@ def getnameinfo(sockaddr, flags):
|
||||
raise socket.error('sockaddr resolved to multiple addresses')
|
||||
if flags & socket.NI_NUMERICHOST:
|
||||
host = rrset[0].address
|
||||
except dns.exception.Timeout, e:
|
||||
except dns.exception.Timeout as e:
|
||||
raise socket.gaierror((socket.EAI_AGAIN, 'Lookup timed out'))
|
||||
except dns.exception.DNSException, e:
|
||||
except dns.exception.DNSException as e:
|
||||
raise socket.gaierror(
|
||||
(socket.EAI_NODATA, 'No address associated with hostname'))
|
||||
|
||||
|
||||
@@ -7,7 +7,7 @@ try:
|
||||
preserves_excinfo = (distutils.version.LooseVersion(greenlet.__version__)
|
||||
>= distutils.version.LooseVersion('0.3.2'))
|
||||
greenlet = greenlet.greenlet
|
||||
except ImportError, e:
|
||||
except ImportError as e:
|
||||
raise
|
||||
try:
|
||||
from py.magic import greenlet
|
||||
@@ -25,5 +25,5 @@ except ImportError, e:
|
||||
from support.stacklesss import greenlet, getcurrent, GreenletExit
|
||||
preserves_excinfo = False
|
||||
(greenlet, getcurrent, GreenletExit) # silence pyflakes
|
||||
except ImportError, e:
|
||||
except ImportError as e:
|
||||
raise ImportError("Unable to find an implementation of greenlet.")
|
||||
|
||||
@@ -140,7 +140,7 @@ def with_timeout(seconds, function, *args, **kwds):
|
||||
try:
|
||||
try:
|
||||
return function(*args, **kwds)
|
||||
except Timeout, ex:
|
||||
except Timeout as ex:
|
||||
if ex is timeout and timeout_value is not _NONE:
|
||||
return timeout_value
|
||||
raise
|
||||
|
||||
@@ -109,7 +109,7 @@ class WebSocketWSGI(object):
|
||||
sock.sendall(handshake_reply)
|
||||
try:
|
||||
self.handler(ws)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if get_errno(e) not in ACCEPTABLE_CLIENT_ERRORS:
|
||||
raise
|
||||
# Make sure we send the closing frame
|
||||
|
||||
@@ -237,7 +237,7 @@ class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler):
|
||||
return
|
||||
except greenio.SSL.ZeroReturnError:
|
||||
self.raw_requestline = ''
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if get_errno(e) not in BAD_SOCK:
|
||||
raise
|
||||
self.raw_requestline = ''
|
||||
@@ -283,7 +283,7 @@ class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler):
|
||||
self.server.outstanding_requests += 1
|
||||
try:
|
||||
self.handle_one_response()
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
# Broken pipe, connection reset by peer
|
||||
if get_errno(e) not in BROKEN_SOCK:
|
||||
raise
|
||||
@@ -518,7 +518,7 @@ class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler):
|
||||
def finish(self):
|
||||
try:
|
||||
BaseHTTPServer.BaseHTTPRequestHandler.finish(self)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
# Broken pipe, connection reset by peer
|
||||
if get_errno(e) not in BROKEN_SOCK:
|
||||
raise
|
||||
@@ -703,7 +703,7 @@ def server(sock, site,
|
||||
" call site to use GreenPool instead" % type(pool),
|
||||
DeprecationWarning, stacklevel=2)
|
||||
pool.execute_async(serv.process_request, client_socket)
|
||||
except ACCEPT_EXCEPTIONS, e:
|
||||
except ACCEPT_EXCEPTIONS as e:
|
||||
if get_errno(e) not in ACCEPT_ERRNO:
|
||||
raise
|
||||
except (KeyboardInterrupt, SystemExit):
|
||||
@@ -717,6 +717,6 @@ def server(sock, site,
|
||||
# that far we might as well not bother closing sock at
|
||||
# all.
|
||||
sock.close()
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if get_errno(e) not in BROKEN_SOCK:
|
||||
traceback.print_exc()
|
||||
|
||||
@@ -13,7 +13,7 @@ def read_chat_forever(writer, reader):
|
||||
if p is not writer: # Don't echo
|
||||
p.write(line)
|
||||
p.flush()
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
# ignore broken pipes, they just mean the participant
|
||||
# closed its connection already
|
||||
if e[0] != 32:
|
||||
|
||||
@@ -21,6 +21,6 @@ conn.write('GET / HTTP/1.0\r\n\r\n')
|
||||
try:
|
||||
for num, line in enumerate(conn):
|
||||
print '%3s %r' % (num, line)
|
||||
except ConnectionClosed, ex:
|
||||
except ConnectionClosed as ex:
|
||||
print ex
|
||||
|
||||
|
||||
@@ -26,7 +26,7 @@ class Chat:
|
||||
for buddy in self.participants:
|
||||
if buddy is not conn:
|
||||
buddy.sendline('from %s: %s' % (peer, line))
|
||||
except Exception, ex:
|
||||
except Exception as ex:
|
||||
print peer, ex
|
||||
else:
|
||||
print peer, 'connection done'
|
||||
|
||||
@@ -36,7 +36,7 @@ def read_chat_forever(reader, pub_socket):
|
||||
|
||||
try:
|
||||
pub_socket.send_pyobj((who, line))
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
# ignore broken pipes, they just mean the participant
|
||||
# closed its connection already
|
||||
if e[0] != 32:
|
||||
|
||||
@@ -66,10 +66,10 @@ class TestGreenSocket(LimitedTestCase):
|
||||
try:
|
||||
gs.connect(('192.0.2.1', 80))
|
||||
self.fail("socket.timeout not raised")
|
||||
except socket.timeout, e:
|
||||
except socket.timeout as e:
|
||||
self.assert_(hasattr(e, 'args'))
|
||||
self.assertEqual(e.args[0], 'timed out')
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
# unreachable is also a valid outcome
|
||||
if not get_errno(e) in (errno.EHOSTUNREACH, errno.ENETUNREACH):
|
||||
raise
|
||||
@@ -84,7 +84,7 @@ class TestGreenSocket(LimitedTestCase):
|
||||
try:
|
||||
gs.accept()
|
||||
self.fail("socket.timeout not raised")
|
||||
except socket.timeout, e:
|
||||
except socket.timeout as e:
|
||||
self.assert_(hasattr(e, 'args'))
|
||||
self.assertEqual(e.args[0], 'timed out')
|
||||
|
||||
@@ -120,7 +120,7 @@ class TestGreenSocket(LimitedTestCase):
|
||||
try:
|
||||
client.recv(8192)
|
||||
self.fail("socket.timeout not raised")
|
||||
except socket.timeout, e:
|
||||
except socket.timeout as e:
|
||||
self.assert_(hasattr(e, 'args'))
|
||||
self.assertEqual(e.args[0], 'timed out')
|
||||
|
||||
@@ -136,7 +136,7 @@ class TestGreenSocket(LimitedTestCase):
|
||||
try:
|
||||
gs.recvfrom(8192)
|
||||
self.fail("socket.timeout not raised")
|
||||
except socket.timeout, e:
|
||||
except socket.timeout as e:
|
||||
self.assert_(hasattr(e, 'args'))
|
||||
self.assertEqual(e.args[0], 'timed out')
|
||||
|
||||
@@ -151,7 +151,7 @@ class TestGreenSocket(LimitedTestCase):
|
||||
try:
|
||||
gs.recvfrom_into(buf)
|
||||
self.fail("socket.timeout not raised")
|
||||
except socket.timeout, e:
|
||||
except socket.timeout as e:
|
||||
self.assert_(hasattr(e, 'args'))
|
||||
self.assertEqual(e.args[0], 'timed out')
|
||||
|
||||
@@ -181,7 +181,7 @@ class TestGreenSocket(LimitedTestCase):
|
||||
try:
|
||||
client.recv_into(buf)
|
||||
self.fail("socket.timeout not raised")
|
||||
except socket.timeout, e:
|
||||
except socket.timeout as e:
|
||||
self.assert_(hasattr(e, 'args'))
|
||||
self.assertEqual(e.args[0], 'timed out')
|
||||
|
||||
@@ -216,7 +216,7 @@ class TestGreenSocket(LimitedTestCase):
|
||||
for x in range(10):
|
||||
total_sent += client.send(msg)
|
||||
self.fail("socket.timeout not raised")
|
||||
except socket.timeout, e:
|
||||
except socket.timeout as e:
|
||||
self.assert_(hasattr(e, 'args'))
|
||||
self.assertEqual(e.args[0], 'timed out')
|
||||
|
||||
@@ -249,7 +249,7 @@ class TestGreenSocket(LimitedTestCase):
|
||||
# want to exceed the size of the OS buffer so it'll block
|
||||
client.sendall(msg)
|
||||
self.fail("socket.timeout not raised")
|
||||
except socket.timeout, e:
|
||||
except socket.timeout as e:
|
||||
self.assert_(hasattr(e, 'args'))
|
||||
self.assertEqual(e.args[0], 'timed out')
|
||||
|
||||
@@ -504,7 +504,7 @@ class TestGreenSocket(LimitedTestCase):
|
||||
while True:
|
||||
try:
|
||||
sock.sendall('hello world')
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if get_errno(e) == errno.EPIPE:
|
||||
return
|
||||
raise
|
||||
@@ -519,7 +519,7 @@ class TestGreenSocket(LimitedTestCase):
|
||||
while True:
|
||||
data = client.recv(1024)
|
||||
self.assert_(data)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
# we get an EBADF because client is closed in the same process
|
||||
# (but a different greenthread)
|
||||
if get_errno(e) != errno.EBADF:
|
||||
@@ -553,7 +553,7 @@ class TestGreenSocket(LimitedTestCase):
|
||||
try:
|
||||
client.recv(1)
|
||||
assert False
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
assert get_errno(e) == errno.EAGAIN
|
||||
|
||||
client.settimeout(0.05)
|
||||
|
||||
@@ -383,7 +383,7 @@ class Stress(tests.LimitedTestCase):
|
||||
while True:
|
||||
try:
|
||||
i = it.next()
|
||||
except StressException, exc:
|
||||
except StressException as exc:
|
||||
i = exc.args[0]
|
||||
except StopIteration:
|
||||
break
|
||||
|
||||
@@ -257,7 +257,7 @@ class TestQueue(LimitedTestCase):
|
||||
def store_result(result, func, *args):
|
||||
try:
|
||||
result.append(func(*args))
|
||||
except Exception, exc:
|
||||
except Exception as exc:
|
||||
result.append(exc)
|
||||
|
||||
|
||||
|
||||
@@ -34,7 +34,7 @@ def get_modules():
|
||||
s.connect(('eventlet.net', 80))
|
||||
s.close()
|
||||
test_modules = test_modules + network_modules
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
print "Skipping network tests"
|
||||
|
||||
return test_modules
|
||||
|
||||
@@ -16,7 +16,7 @@ class TestEvent(LimitedTestCase):
|
||||
try:
|
||||
result = e.wait()
|
||||
log.append(('received', result))
|
||||
except Exception, ex:
|
||||
except Exception as ex:
|
||||
log.append(('catched', ex))
|
||||
spawn(waiter)
|
||||
sleep(0) # let waiter to block on e.wait()
|
||||
|
||||
@@ -39,7 +39,7 @@ class TestGreenness(unittest.TestCase):
|
||||
try:
|
||||
urllib2.urlopen('http://127.0.0.1:%s' % self.port)
|
||||
assert False, 'should not get there'
|
||||
except urllib2.HTTPError, ex:
|
||||
except urllib2.HTTPError as ex:
|
||||
assert ex.code == 501, repr(ex)
|
||||
self.assertEqual(self.server.request_count, 1)
|
||||
|
||||
|
||||
@@ -304,7 +304,7 @@ class TestStuff(LimitedTestCase):
|
||||
b = proc.spawn(lambda : getcurrent().throw(ExpectedError('second')))
|
||||
try:
|
||||
proc.waitall([a, b])
|
||||
except ExpectedError, ex:
|
||||
except ExpectedError as ex:
|
||||
assert 'second' in str(ex), repr(str(ex))
|
||||
sleep(0.2) # sleep to ensure that the other timer is raised
|
||||
|
||||
|
||||
@@ -16,7 +16,7 @@ class TestSocketErrors(unittest.TestCase):
|
||||
try:
|
||||
s.connect(('127.0.0.1', port))
|
||||
self.fail("Shouldn't have connected")
|
||||
except socket.error, ex:
|
||||
except socket.error as ex:
|
||||
code, text = ex.args
|
||||
assert code in [111, 61, 10061], (code, text)
|
||||
assert 'refused' in text.lower(), (code, text)
|
||||
@@ -43,7 +43,7 @@ class TestSocketErrors(unittest.TestCase):
|
||||
try:
|
||||
cs.recv(1024)
|
||||
self.fail("Should have timed out")
|
||||
except socket.timeout, ex:
|
||||
except socket.timeout as ex:
|
||||
assert hasattr(ex, 'args')
|
||||
assert len(ex.args) == 1
|
||||
assert ex.args[0] == 'timed out'
|
||||
|
||||
@@ -7,14 +7,14 @@ class TestDirectRaise(LimitedTestCase):
|
||||
def test_direct_raise_class(self):
|
||||
try:
|
||||
raise timeout.Timeout
|
||||
except timeout.Timeout, t:
|
||||
except timeout.Timeout as t:
|
||||
assert not t.pending, repr(t)
|
||||
|
||||
def test_direct_raise_instance(self):
|
||||
tm = timeout.Timeout()
|
||||
try:
|
||||
raise tm
|
||||
except timeout.Timeout, t:
|
||||
except timeout.Timeout as t:
|
||||
assert tm is t, (tm, t)
|
||||
assert not t.pending, repr(t)
|
||||
|
||||
|
||||
@@ -32,7 +32,7 @@ class Test(LimitedTestCase):
|
||||
try:
|
||||
with Timeout(DELAY) as t:
|
||||
sleep(DELAY*2)
|
||||
except Timeout, ex:
|
||||
except Timeout as ex:
|
||||
assert ex is t, (ex, t)
|
||||
else:
|
||||
raise AssertionError('must raise Timeout')
|
||||
@@ -42,7 +42,7 @@ class Test(LimitedTestCase):
|
||||
try:
|
||||
with Timeout(DELAY, True) as t:
|
||||
sleep(DELAY*2)
|
||||
except Timeout, ex:
|
||||
except Timeout as ex:
|
||||
assert ex is t, (ex, t)
|
||||
else:
|
||||
raise AssertionError('must raise Timeout')
|
||||
@@ -52,7 +52,7 @@ class Test(LimitedTestCase):
|
||||
try:
|
||||
with Timeout(DELAY, IOError("Operation takes way too long")):
|
||||
sleep(DELAY*2)
|
||||
except IOError, ex:
|
||||
except IOError as ex:
|
||||
assert str(ex)=="Operation takes way too long", repr(ex)
|
||||
|
||||
def test_raising_exception_class(self):
|
||||
@@ -119,7 +119,7 @@ class Test(LimitedTestCase):
|
||||
with Timeout(DELAY*2) as t2:
|
||||
try:
|
||||
sleep(DELAY*3)
|
||||
except Timeout, ex:
|
||||
except Timeout as ex:
|
||||
assert ex is t1, (ex, t1)
|
||||
assert not t1.pending, t1
|
||||
assert t2.pending, t2
|
||||
@@ -129,7 +129,7 @@ class Test(LimitedTestCase):
|
||||
with Timeout(DELAY) as t2:
|
||||
try:
|
||||
sleep(DELAY*3)
|
||||
except Timeout, ex:
|
||||
except Timeout as ex:
|
||||
assert ex is t2, (ex, t2)
|
||||
assert t1.pending, t1
|
||||
assert not t2.pending, t2
|
||||
|
||||
@@ -44,7 +44,7 @@ class TestWebSocket(_TestBase):
|
||||
def raiser():
|
||||
try:
|
||||
urllib2.urlopen("http://localhost:%s/echo" % self.port)
|
||||
except urllib2.HTTPError, e:
|
||||
except urllib2.HTTPError as e:
|
||||
self.assertEqual(e.code, 400)
|
||||
raise
|
||||
self.assertRaises(urllib2.HTTPError, raiser)
|
||||
|
||||
@@ -147,7 +147,7 @@ def read_http(sock):
|
||||
fd = sock.makefile()
|
||||
try:
|
||||
response_line = fd.readline()
|
||||
except socket.error, exc:
|
||||
except socket.error as exc:
|
||||
if get_errno(exc) == 10053:
|
||||
raise ConnectionClosed
|
||||
raise
|
||||
@@ -643,7 +643,7 @@ class TestHttpd(_TestBase):
|
||||
try:
|
||||
server_sock_2.accept()
|
||||
# shouldn't be able to use this one anymore
|
||||
except socket.error, exc:
|
||||
except socket.error as exc:
|
||||
self.assertEqual(get_errno(exc), errno.EBADF)
|
||||
self.spawn_server(sock=server_sock)
|
||||
sock = eventlet.connect(('localhost', self.port))
|
||||
@@ -760,7 +760,7 @@ class TestHttpd(_TestBase):
|
||||
try:
|
||||
eventlet.connect(('localhost', self.port))
|
||||
self.fail("Didn't expect to connect")
|
||||
except socket.error, exc:
|
||||
except socket.error as exc:
|
||||
self.assertEquals(get_errno(exc), errno.ECONNREFUSED)
|
||||
|
||||
self.assert_('Invalid argument' in self.logfile.getvalue(),
|
||||
@@ -855,7 +855,7 @@ class TestHttpd(_TestBase):
|
||||
errored[0] = 'SSL handshake error caused wsgi.server to exit.'
|
||||
except greenthread.greenlet.GreenletExit:
|
||||
pass
|
||||
except Exception, e:
|
||||
except Exception as e:
|
||||
errored[0] = 'SSL handshake error raised exception %s.' % e
|
||||
for data in ('', 'GET /non-ssl-request HTTP/1.0\r\n\r\n'):
|
||||
srv_sock = eventlet.wrap_ssl(eventlet.listen(('localhost', 0)),
|
||||
@@ -1217,7 +1217,7 @@ def read_headers(sock):
|
||||
fd = sock.makefile()
|
||||
try:
|
||||
response_line = fd.readline()
|
||||
except socket.error, exc:
|
||||
except socket.error as exc:
|
||||
if get_errno(exc) == 10053:
|
||||
raise ConnectionClosed
|
||||
raise
|
||||
|
||||
@@ -52,7 +52,7 @@ class TestUpstreamDownStream(LimitedTestCase):
|
||||
def assertRaisesErrno(self, errno, func, *args):
|
||||
try:
|
||||
func(*args)
|
||||
except zmq.ZMQError, e:
|
||||
except zmq.ZMQError as e:
|
||||
self.assertEqual(e.errno, errno, "wrong error raised, expected '%s' \
|
||||
got '%s'" % (zmq.ZMQError(errno), zmq.ZMQError(e.errno)))
|
||||
else:
|
||||
|
||||
Reference in New Issue
Block a user