rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
def __wrap_socket(sock, keyfile=None, certfile=None, **kwargs): if kwargs: ssl = __import__('ssl') return ssl.wrap_socket(sock, keyfile=keyfile, certfile=certfile, **kwargs) from gevent.socket import ssl return ssl(sock, keyfile=keyfile, certfile=certfile) | def __wrap_socket(sock, keyfile=None, certfile=None, **kwargs): if kwargs: ssl = __import__('ssl') # XXX since there is no gevent.ssl yet, cowardly call the blocking function return ssl.wrap_socket(sock, keyfile=keyfile, certfile=certfile, **kwargs) from gevent.socket import ssl return ssl(sock, keyfile=keyfile, certfi... | |
ssl = __import__('ssl') ssl.wrap_socket = __wrap_socket | _ssl = __import__('ssl') | def patch_ssl(): try: ssl = __import__('ssl') ssl.wrap_socket = __wrap_socket except ImportError: pass |
pass | return from gevent.ssl import SSLSocket, wrap_socket, get_server_certificate, sslwrap_simple _ssl.SSLSocket = SSLSocket _ssl.wrap_socket = wrap_socket _ssl.get_server_certificate = get_server_certificate _ssl.sslwrap_simple = sslwrap_simple | def patch_ssl(): try: ssl = __import__('ssl') ssl.wrap_socket = __wrap_socket except ImportError: pass |
raise | MAIN.throw(*sys.exc_info()) | def run(self): global _threadlocal assert self is getcurrent(), 'Do not call run() directly' try: self.keyboard_interrupt_signal = signal(2, core.active_event, MAIN.throw, KeyboardInterrupt) except IOError: pass # no signal() on windows try: loop_count = 0 while True: try: result = core.dispatch() except IOError, ex: l... |
args = [repr(x) for x in self.args] | args = [repr(x)[:50] for x in self.args] | def _formatted_info(self): try: result = getfuncname(self.__dict__['_run']) except Exception: pass else: args = [] if self.args: args = [repr(x) for x in self.args] if self.kwargs: args.extend(['%s=%r' % x for x in self.kwargs.items()]) if args: result += '(' + ', '.join(args) + ')' return result |
modname = node['modname'] classname = node['classname'] | if node.has_key('py:module'): modname = node['py:module'] classname = node['py:class'] else: modname = node['modname'] classname = node['classname'] | def missing_reference(app, env, node, contnode): """Search the index for missing references. For example, resolve :class:`Event` to :class:`Event <gevent.event.Event>`""" # XXX methods and functions resolved by this function miss their () if intersphinx.missing_reference(app, env, node, contnode) is not None: # is the... |
newnode['class'] = 'external-xref' | newnode['py:class'] = 'external-xref' newnode['classname'] = 'external-xref' | def new_reference(refuri, reftitle): newnode = nodes.reference('', '') newnode['refuri'] = refuri newnode['reftitle'] = reftitle newnode['class'] = 'external-xref' newnode.append(contnode) msg = 'Resolved missing-reference: :%5s:`%s` -> %s' % (type, target, refuri) if noisy >= 1 or msg not in message_cache: print msg m... |
if _have_threads: test_support.threading_cleanup(*thread_info) | def test_main(verbose=False): if skip_expected: raise test_support.TestSkipped("No SSL support") global CERTFILE, SVN_PYTHON_ORG_ROOT_CERT CERTFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "keycert.pem") SVN_PYTHON_ORG_ROOT_CERT = os.path.join( os.path.dirname(__file__) or os.curdir, "https_svn_python_or... | |
from gevent.socket import socket, fromfd, ssl, socketpair | from gevent.socket import socket, fromfd, socketpair | def patch_socket(dns=True): from gevent.socket import socket, fromfd, ssl, socketpair _socket = __import__('socket') _socket.socket = socket _socket.fromfd = fromfd _socket.ssl = ssl _socket.socketpair = socketpair if dns: patch_dns() |
_socket.ssl = ssl | def patch_socket(dns=True): from gevent.socket import socket, fromfd, ssl, socketpair _socket = __import__('socket') _socket.socket = socket _socket.fromfd = fromfd _socket.ssl = ssl _socket.socketpair = socketpair if dns: patch_dns() | |
if socktype is not None: | if socktype: | def getaddrinfo(host, port, *args, **kwargs): """*Some* approximation of :func:`socket.getaddrinfo` implemented using :mod:`gevent.dns`. |
if proto is not None: | if proto: | def getaddrinfo(host, port, *args, **kwargs): """*Some* approximation of :func:`socket.getaddrinfo` implemented using :mod:`gevent.dns`. |
def sendto(self, data, addr, flags=0): | def sendto(self, *args): | def sendto(self, data, addr, flags=0): if self._sslobj: raise ValueError("sendto not allowed on instances of %s" % self.__class__) else: return socket.sendto(self, data, addr, flags) |
return socket.sendto(self, data, addr, flags) | return socket.sendto(self, *args) | def sendto(self, data, addr, flags=0): if self._sslobj: raise ValueError("sendto not allowed on instances of %s" % self.__class__) else: return socket.sendto(self, data, addr, flags) |
def recvfrom(self, addr, buflen=1024, flags=0): | def recvfrom(self, *args): | def recvfrom(self, addr, buflen=1024, flags=0): if self._sslobj: raise ValueError("recvfrom not allowed on instances of %s" % self.__class__) else: return socket.recvfrom(self, addr, buflen, flags) |
return socket.recvfrom(self, addr, buflen, flags) def recvfrom_into(self, buffer, nbytes=None, flags=0): | return socket.recvfrom(self, *args) def recvfrom_into(self, *args): | def recvfrom(self, addr, buflen=1024, flags=0): if self._sslobj: raise ValueError("recvfrom not allowed on instances of %s" % self.__class__) else: return socket.recvfrom(self, addr, buflen, flags) |
return socket.recvfrom_into(self, buffer, nbytes, flags) | return socket.recvfrom_into(self, *args) | def recvfrom_into(self, buffer, nbytes=None, flags=0): if self._sslobj: raise ValueError("recvfrom_into not allowed on instances of %s" % self.__class__) else: return socket.recvfrom_into(self, buffer, nbytes, flags) |
local. They are shared across greenlets: | local. They are shared across greenlets:: | ... def squared(self): |
self.server.join() | self.join() | def serve_forever(self): if not self: # XXX will this work: server.start(); server.serve_forever() self.start() self.server.join() |
return getattr(self, '_testMethodName', '') or getattr(self, '__testMethodName') | return getattr(self, '_testMethodName', '') or getattr(self, '_TestCase__testMethodName') | def testname(self): return getattr(self, '_testMethodName', '') or getattr(self, '__testMethodName') |
return getaddrinfo('www.gevent.org', 'http') | for index in range(1000): try: getaddrinfo('www.a%s.com' % index, 'http') except gaierror: pass | def wait(self, timeout): with gevent.Timeout(timeout, False): return getaddrinfo('www.gevent.org', 'http') |
return self._do_read(self.rfile.readlines, hint) | return self.__iter__() | def readlines(self, hint=None): return self._do_read(self.rfile.readlines, hint) |
def __init__(self, family_or_realsock=_socket.AF_INET, *args, **kwargs): | def __init__(self, family_or_realsock=AF_INET, *args, **kwargs): | def __init__(self, family_or_realsock=_socket.AF_INET, *args, **kwargs): if isinstance(family_or_realsock, (int, long)): self.fd = _socket.socket(family_or_realsock, *args, **kwargs) self.timeout = _socket.getdefaulttimeout() else: if hasattr(family_or_realsock, '_sock'): family_or_realsock = family_or_realsock.sock se... |
descriptor.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, descriptor.getsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR) | 1) | descriptor.setsockopt(SOL_SOCKET, SO_REUSEADDR, descriptor.getsockopt(SOL_SOCKET, SO_REUSEADDR) | 1) | def set_reuse_addr(descriptor): try: descriptor.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, descriptor.getsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR) | 1) except error: pass |
for res in getaddrinfo(host, port, 0, _socket.SOCK_STREAM): af, socktype, proto, canonname, sa = res | for res in getaddrinfo_approx(host, port, 0, SOCK_STREAM): af, socktype, proto, _canonname, sa = res | def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT): """Connect to *address* and return the socket object. Convenience function. Connect to *address* (a 2-tuple ``(host, port)``) and return the socket object. Passing the optional *timeout* parameter will set the timeout on the socket instance before atte... |
for res in getaddrinfo(host, port, 0, _socket.SOCK_STREAM): af, socktype, proto, canonname, sa = res | for res in getaddrinfo_approx(host, port, 0, SOCK_STREAM): af, socktype, proto, _canonname, sa = res | def create_connection_ssl(address, timeout=_GLOBAL_DEFAULT_TIMEOUT): """Connect to *address* and return the socket object. Convenience function. Connect to *address* (a 2-tuple ``(host, port)``) and return the socket object. Passing the optional *timeout* parameter will set the timeout on the socket instance before ... |
execfile(arg, globals()) | saved_globals = {'__file__': __file__} try: globals()['__file__'] = arg execfile(arg, globals()) finally: globals().update(saved_globals) | def __new__(cls, *args, **kawrgs): return DatabaseTestRunner(database_path=options.db, runid=options.runid, module_name=module_name, verbosity=options.verbosity) |
data = ['a' * 8192] * 3 | chunks = ['a' * 8192] * 3 | def test_no_chunked_http_1_0(self): fd = self.connect().makefile(bufsize=1) fd.write('GET / HTTP/1.0\r\nHost: localhost\r\nConnection: close\r\n\r\n') response = read_http(fd, version='1.0') self.assertEqual(response.body, self.body()) self.assertEqual(response.headers.get('Transfer-Encoding'), None) content_length = i... |
build.include_dirs[:0] = [bdir, sdir, "%s/include" % sdir] | build.include_dirs[:0] = [bdir, "%s/include" % bdir, sdir, "%s/include" % sdir] | def compile_libevent(build): sdir = libevent_source_path if not sdir: return from distutils import sysconfig configure = os.path.abspath(os.path.join(sdir, "configure")) addlibs = [] bdir = os.path.join(build.build_temp, "libevent") if not os.path.isdir(bdir): os.makedirs(bdir) cwd = os.getcwd() os.chdir(bdir) try: ... |
self = None return | self._reply500() | def handle(self): env = self.prepare_env() try: try: result = self.server.application(env, self.start_response) try: self.data.extend(result) finally: if hasattr(result, 'close'): result.close() except GreenletExit: raise except: traceback.print_exc() try: sys.stderr.write('%s: Failed to handle request:\n request = %s... |
except socket_error: | except socket_error, e: if e[0] != errno.ENOTCONN: raise | def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True): try: sock = sock._sock except AttributeError: pass socket.__init__(self, _sock=sock) |
timeout_error = socket.sslerror | TIMEOUT_ERROR = socket.sslerror | def accept_once(): conn, addr = self.listener.accept() fd = conn.makefile() conn.close() fd.write('hello\n') fd.close() |
if content_length is not None: content_length = int(content_length) | def __init__(self, rfile, content_length, wfile=None, wfile_line=None, chunked_input=False): self.rfile = rfile if content_length is not None: content_length = int(content_length) self.content_length = content_length self.wfile = wfile self.wfile_line = wfile_line self.position = 0 self.chunked_input = chunked_input se... | |
while True: line = self.readline() if not line: | return self def next(self): line = self.readline() if not line: raise StopIteration return line class WSGIHandler(object): protocol_version = 'HTTP/1.1' MessageClass = mimetools.Message def __init__(self, socket, address, server): self.socket = socket self.client_address = address self.server = server self.rfile = ... | def __iter__(self): while True: line = self.readline() if not line: break yield line |
yield line class WSGIHandler(BaseHTTPServer.BaseHTTPRequestHandler): protocol_version = 'HTTP/1.1' | finally: self.__dict__.pop('socket', None) self.__dict__.pop('rfile', None) self.__dict__.pop('wfile', None) def _check_http_version(self): version = self.request_version if not version.startswith("HTTP/"): return False version = tuple(int(x) for x in version[5:].split(".")) if version[1] < 0 or version < (0, 9) or ve... | def __iter__(self): while True: line = self.readline() if not line: break yield line |
self.close_connection = 1 return try: self.raw_requestline = self.rfile.readline(MAX_REQUEST_LINE) if len(self.raw_requestline) == MAX_REQUEST_LINE: self.status = '414' self.wfile.write( "HTTP/1.0 414 Request URI Too Long\r\nConnection: close\r\nContent-length: 0\r\n\r\n") self.close_connection = 1 self.log_request() ... | return raw_requestline = self.rfile.readline(MAX_REQUEST_LINE) if not raw_requestline: return self.response_length = 0 if len(raw_requestline) >= MAX_REQUEST_LINE: return ('414', _REQUEST_TOO_LONG_RESPONSE) try: if not self.read_request(raw_requestline): return ('400', _BAD_REQUEST_RESPONSE) except ValueError, ex: ... | def handle_one_request(self): if self.rfile.closed: self.close_connection = 1 return |
def log_request(self, *args): | def log_request(self): | def log_request(self, *args): log = self.server.log if log is not None: log.write(self.format_request(*args) + '\n') |
log.write(self.format_request(*args) + '\n') def format_request(self, length='-'): | log.write(self.format_request() + '\n') def format_request(self): now = datetime.now().replace(microsecond=0) | def log_request(self, *args): log = self.server.log if log is not None: log.write(self.format_request(*args) + '\n') |
self.log_date_time_string(), | now, | def format_request(self, length='-'): return '%s - - [%s] "%s" %s %s %.6f' % ( self.client_address[0], self.log_date_time_string(), self.requestline, (self.status or '000').split()[0], self.response_length, self.time_finish - self.time_start) |
host, port = self.request.getsockname() | host, port = self.socket.getsockname() | def get_environ(self): env = self.server.get_environ() env['REQUEST_METHOD'] = self.command env['SCRIPT_NAME'] = '' |
for h in self.headers.headers: k, v = h.split(':', 1) k = k.replace('-', '_').upper() v = v.strip() if k in env: continue envk = 'HTTP_' + k if envk in env: env[envk] += ',' + v else: env[envk] = v | for header in self.headers.headers: key, value = header.split(':', 1) key = key.replace('-', '_').upper() if key not in ('CONTENT_TYPE', 'CONTENT_LENGTH'): value = value.strip() key = 'HTTP_' + key if key in env: env[key] += ',' + value else: env[key] = value | def get_environ(self): env = self.server.get_environ() env['REQUEST_METHOD'] = self.command env['SCRIPT_NAME'] = '' |
self.wsgi_input = Input(self.rfile, length, wfile=wfile, wfile_line=wfile_line, chunked_input=chunked) | self.wsgi_input = Input(self.rfile, self.content_length, wfile=wfile, wfile_line=wfile_line, chunked_input=chunked) | def get_environ(self): env = self.server.get_environ() env['REQUEST_METHOD'] = self.command env['SCRIPT_NAME'] = '' |
def finish(self): BaseHTTPServer.BaseHTTPRequestHandler.finish(self) self.connection.close() | def get_environ(self): env = self.server.get_environ() env['REQUEST_METHOD'] = self.command env['SCRIPT_NAME'] = '' | |
env[header] = value | if header in env: if 'COOKIE' in header: env[header] += '; ' + value else: env[header] += ',' + value else: env[header] = value | def prepare_env(self): req = self.request env = self.server.get_environ() if '?' in req.uri: path, query = req.uri.split('?', 1) else: path, query = req.uri, '' path = unquote(path) env.update({'REQUEST_METHOD': req.typestr, 'PATH_INFO': path, 'QUERY_STRING': query, 'SERVER_PROTOCOL': 'HTTP/%d.%d' % req.version, 'REMOT... |
return _fileobject(self, mode, bufsize) | return _fileobject(self, mode, bufsize, close=True) | def makefile(self, mode='r', bufsize=-1): """Make and return a file-like object that works with the SSL connection. Just use the code from the socket module.""" self._makefile_refs += 1 return _fileobject(self, mode, bufsize) |
unittest.TestCase = greentest.TestCase | unittest.TestCase = greentest.TestCase0 | def patch_all(timeout=None): from gevent import monkey monkey.patch_all(aggressive=True) import unittest import greentest unittest.TestCase = greentest.TestCase if timeout is not None: unittest.TestCase.__timeout__ = timeout |
def add(self, greenlet): greenlet.rawlink(self.discard) self.greenlets.add(greenlet) | def add(self, greenlet): greenlet.rawlink(self.discard) self.greenlets.add(greenlet) | |
The function always returns ``None`` and never raises an errir. | The function always returns ``None`` and never raises an error. | def kill(self, exception=GreenletExit, block=True, timeout=None): """Raise the exception in the greenlet. |
if value: self.stderr = value | self.stderr = value | def unhook_stderr(self): if VERBOSE: return try: value = self.new_stderr.getvalue() except AttributeError: return None sys.stderr = self.old_stderr if value: self.stderr = value return value |
left a greenlet unscheduled forever if used incorrectly. Consider using safer | leave a greenlet unscheduled forever if used incorrectly. Consider using safer | def __init__(self, code): self.code = code Exception.__init__(self, code) |
return test_method.__func__.func_code.co_filename | try: return test_method.__func__.func_code.co_filename except AttributeError: return test_method.im_func.func_code.co_filename | def modulename(self): test_method = getattr(self, self.testname) return test_method.__func__.func_code.co_filename |
traceback_count = output.lower().count('traceback') | traceback_count = output.lower().count('Traceback (most recent call last)') | def get_traceback_stats(output): counter = {} traceback_count = output.lower().count('traceback') for warning in get_exceptions(output): counter.setdefault(warning, 0) counter[warning] += 1 traceback_count -= 1 items = counter.items() items.sort(key=lambda (a, b): -b) if traceback_count: items.append(('other traceback'... |
if traceback_count: | if traceback_count>0: | def get_traceback_stats(output): counter = {} traceback_count = output.lower().count('traceback') for warning in get_exceptions(output): counter.setdefault(warning, 0) counter[warning] += 1 traceback_count -= 1 items = counter.items() items.sort(key=lambda (a, b): -b) if traceback_count: items.append(('other traceback'... |
from gevent.socket import socket, fromfd, socketpair, SocketType | from gevent import socket | def patch_socket(dns=True, aggressive=True): from gevent.socket import socket, fromfd, socketpair, SocketType _socket = __import__('socket') _socket.socket = socket.socket _socket.SocketType = socket.SocketType if hasattr(socket, 'socketpair'): _socket.socketpair = socket.socketpair if hasattr(socket, 'fromfd'): _socke... |
except SystemError: | except (SystemError, TypeError): | def testRefCountGetNameInfo(self): # Testing reference count for getnameinfo import sys if hasattr(sys, "getrefcount"): try: # On some versions, this loses a reference orig = sys.getrefcount(__name__) socket.getnameinfo(__name__,0) except SystemError: if sys.getrefcount(__name__) <> orig: self.fail("socket.getnameinfo ... |
if ex is not timer: raise | if ex is timer: return False raise | def acquire(self, blocking=True, timeout=None): if self.counter > 0: self.counter -= 1 return True elif not blocking: return False else: switch = getcurrent().switch self.rawlink(switch) try: timer = Timeout.start_new(timeout) try: try: result = get_hub().switch() assert result is self, 'Invalid switch into Semaphore.a... |
content_length = int(response.headers.get('Content-Length')) | content_length = response.headers.get('Content-Length') | def test_no_chunked_http_1_0(self): fd = self.connect().makefile(bufsize=1) fd.write('GET / HTTP/1.0\r\nHost: localhost\r\nConnection: close\r\n\r\n') response = read_http(fd, version='1.0') self.assertEqual(response.body, self.body()) self.assertEqual(response.headers.get('Transfer-Encoding'), None) content_length = i... |
self.assertEqual(content_length, len(self.body())) | self.assertEqual(content_length, str(len(self.body()))) | def test_no_chunked_http_1_0(self): fd = self.connect().makefile(bufsize=1) fd.write('GET / HTTP/1.0\r\nHost: localhost\r\nConnection: close\r\n\r\n') response = read_http(fd, version='1.0') self.assertEqual(response.body, self.body()) self.assertEqual(response.headers.get('Transfer-Encoding'), None) content_length = i... |
if hasattr(self.result, '__len__') and 'Content-Length' not in self.response_headers_list: self.response_headers.append(('Content-Length', str(sum(len(chunk) for chunk in self.result)))) self.response_headers_list.append('Content-Length') | def write(self, data): towrite = [] if not self.status: raise AssertionError("The application did not call start_response()") if not self.headers_sent: if hasattr(self.result, '__len__') and 'Content-Length' not in self.response_headers_list: self.response_headers.append(('Content-Length', str(sum(len(chunk) for chunk ... | |
if self.request_version != 'HTTP/1.0' and 'Content-Length' not in self.response_headers_list: self.response_use_chunked = True self.response_headers.append(('Transfer-Encoding', 'chunked')) self.response_headers_list.append('Transfer-Encoding') | if self.code not in [204, 304]: if 'Content-Length' not in self.response_headers_list: if hasattr(self.result, '__len__'): self.response_headers.append(('Content-Length', str(sum(len(chunk) for chunk in self.result)))) self.response_headers_list.append('Content-Length') else: if self.request_version != 'HTTP/1.0': sel... | def write(self, data): towrite = [] if not self.status: raise AssertionError("The application did not call start_response()") if not self.headers_sent: if hasattr(self.result, '__len__') and 'Content-Length' not in self.response_headers_list: self.response_headers.append(('Content-Length', str(sum(len(chunk) for chunk ... |
owner = self.__owner | owner = self._owner | def _release_save(self): count = self._count self._count = 0 owner = self.__owner self._owner = None self._block.release() return (count, owner) |
if self.timeout == 0.0: return self._sock.accept() | def accept(self): if self.timeout == 0.0: return self._sock.accept() while True: try: res = self._sock.accept() except error, ex: if ex[0] == errno.EWOULDBLOCK: res = None else: raise if res is not None: client, addr = res return socket(_sock=client), addr wait_read(self._sock.fileno(), timeout=self.timeout) | |
res = self._sock.accept() | client, addr = self._sock.accept() break | def accept(self): if self.timeout == 0.0: return self._sock.accept() while True: try: res = self._sock.accept() except error, ex: if ex[0] == errno.EWOULDBLOCK: res = None else: raise if res is not None: client, addr = res return socket(_sock=client), addr wait_read(self._sock.fileno(), timeout=self.timeout) |
if ex[0] == errno.EWOULDBLOCK: res = None else: | if ex[0] != errno.EWOULDBLOCK or self.timeout == 0.0: | def accept(self): if self.timeout == 0.0: return self._sock.accept() while True: try: res = self._sock.accept() except error, ex: if ex[0] == errno.EWOULDBLOCK: res = None else: raise if res is not None: client, addr = res return socket(_sock=client), addr wait_read(self._sock.fileno(), timeout=self.timeout) |
if res is not None: client, addr = res return socket(_sock=client), addr | def accept(self): if self.timeout == 0.0: return self._sock.accept() while True: try: res = self._sock.accept() except error, ex: if ex[0] == errno.EWOULDBLOCK: res = None else: raise if res is not None: client, addr = res return socket(_sock=client), addr wait_read(self._sock.fileno(), timeout=self.timeout) | |
self.assert_stderr('<Greenlet at 0x[0-9a-f]+: hello> failed with ExpectedError') | self.assert_stderr('<Greenlet at 0x[0-9a-f]+L?: hello> failed with ExpectedError') | def test1(self): try: raise error except: self.hook_stderr() g = gevent.spawn(hello) g.join() self.assert_stderr_traceback(expected_error) self.assert_stderr('<Greenlet at 0x[0-9a-f]+: hello> failed with ExpectedError') if not isinstance(g.exception, ExpectedError): raise g.exception try: raise except Exception, ex: as... |
from gevent.socket import getaddrinfo, getnameinfo, gethostbyname | from gevent.socket import gethostbyname, getaddrinfo | def patch_dns(): from gevent.socket import getaddrinfo, getnameinfo, gethostbyname _socket = __import__('socket') _socket.getaddrinfo = getaddrinfo _socket.getnameinfo = getnameinfo _socket.gethostbyname = gethostbyname |
_socket.getnameinfo = getnameinfo | def patch_dns(): from gevent.socket import getaddrinfo, getnameinfo, gethostbyname _socket = __import__('socket') _socket.getaddrinfo = getaddrinfo _socket.getnameinfo = getnameinfo _socket.gethostbyname = gethostbyname | |
if options.capture: while True: data = popen.stdout.read(1) if not data: break output += data if options.verbosity >= 2: sys.stdout.write(data) retcode.append(popen.wait()) except: popen.kill() raise | try: if options.capture: while True: data = popen.stdout.read(1) if not data: break output += data if options.verbosity >= 2: sys.stdout.write(data) retcode.append(popen.wait()) except: popen.kill() raise | def killer(): retcode.append('TIMEOUT') print >> sys.stderr, 'Killing %s (%s) because of timeout' % (popen.pid, arg) popen.kill() |
g = gevent.Greenlet(func, 0.01, return_value=5) | g = gevent.Greenlet(func, 0.001, return_value=5) | def func(delay, return_value=4): gevent.sleep(delay) error = ExpectedError('test_error_exit') error.myattr = return_value raise error |
gevent.sleep(0.02) | gevent.sleep(0.1) | def func(delay, return_value=4): gevent.sleep(delay) error = ExpectedError('test_error_exit') error.myattr = return_value raise error |
from gevent.socket import socket, fromfd, socketpair | from gevent.socket import socket, fromfd, socketpair, SocketType | def patch_socket(dns=True): from gevent.socket import socket, fromfd, socketpair _socket = __import__('socket') _socket.socket = socket _socket.fromfd = fromfd _socket.socketpair = socketpair try: from gevent.socket import ssl, sslerror _socket.ssl = ssl _socket.sslerror = sslerror except ImportError: pass if dns: patc... |
timeout = self.gettimeout() try: self.settimeout(None) self.do_handshake() finally: self.settimeout(timeout) | self.do_handshake() | def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True): try: sock = sock._sock except AttributeError: pass socket.__init__(self, _sock=sock) |
except Exception: | except Exception, ex: | def send_signal(self, sig): if sys.platform == 'win32': sig = signal.SIGTERM if hasattr(subprocess.Popen, 'send_signal'): try: return subprocess.Popen.send_signal(self, sig) except Exception: sys.stderr.write('send_signal(%s, %s) failed: %s\n' % (self.pid, sig, ex)) self.external_kill() else: if hasattr(os, 'kill'): sy... |
self.external_kill() | self.external_kill(str(ex)) | def send_signal(self, sig): if sys.platform == 'win32': sig = signal.SIGTERM if hasattr(subprocess.Popen, 'send_signal'): try: return subprocess.Popen.send_signal(self, sig) except Exception: sys.stderr.write('send_signal(%s, %s) failed: %s\n' % (self.pid, sig, ex)) self.external_kill() else: if hasattr(os, 'kill'): sy... |
"""]) | """ % setup_4]) | def waitingThread(): x = C() ready.release() time.sleep(100) |
"""]) | """ % setup_3]) | def func(frame, event, arg): threading.current_thread() return func |
"""], | """ % setup_5], | def child(): sleep(1) # As a non-daemon thread we SHOULD wake up and nothing # should be torn down yet print "Woke up, sleep function is:", sleep |
self.assertEqual(stdout.strip(), "Woke up, sleep function is: <built-in function sleep>") | stdout = stdout.strip() assert re.match('^Woke up, sleep function is: <.*?sleep.*?>$', stdout), repr(stdout) | def child(): sleep(1) # As a non-daemon thread we SHOULD wake up and nothing # should be torn down yet print "Woke up, sleep function is:", sleep |
\n""" + script | \n""" % setup_3 + script | def joiningfunc(mainthread): mainthread.join() print 'end of thread' |
data_sent += self.send(buffer(data, data_sent), flags) | data_sent += self.send(_get_memory(data, data_sent), flags) | def sendall(self, data, flags=0): if isinstance(data, unicode): data = data.encode() # this sendall is also reused by SSL subclasses (both from ssl and sslold modules), # so it should not call self._sock methods directly if self.timeout is None: data_sent = 0 while data_sent < len(data): data_sent += self.send(buffer(d... |
data_sent += self.send(buffer(data, data_sent), flags, timeout=timeleft) | data_sent += self.send(_get_memory(data, data_sent), flags, timeout=timeleft) | def sendall(self, data, flags=0): if isinstance(data, unicode): data = data.encode() # this sendall is also reused by SSL subclasses (both from ssl and sslold modules), # so it should not call self._sock methods directly if self.timeout is None: data_sent = 0 while data_sent < len(data): data_sent += self.send(buffer(d... |
if e[0] in (32, 54): | if e[0] in (errno.EPIPE, errno.ECONNRESET): | def handle_one_request(self): if self.server.max_http_version: self.protocol_version = self.server.max_http_version |
if self.timeout is not None: | if getattr(self, 'timeout', None) is not None: | def _formatinfo(self): try: fileno = self.fileno() except Exception, ex: fileno = str(ex) try: sockname = self.getsockname() sockname = '%s:%s' % sockname except Exception: sockname = None try: peername = self.getpeername() peername = '%s:%s' % peername except Exception: peername = None result = 'fileno=%s' % fileno if... |
def __repr__(self): try: fileno = self.fileno() except Exception, ex: fileno = str(ex) args = (type(self).__name__, id(self), fileno, self.timeout, self._sock.state_string()) return '<%s at 0x%X fileno=%s timeout=%s state_string=%r>' % args | def _formatinfo(self): return socket._formatinfo(self) + ' state_string=%r' % self._sock.state_string() | def __repr__(self): try: fileno = self.fileno() except Exception, ex: fileno = str(ex) args = (type(self).__name__, id(self), fileno, self.timeout, self._sock.state_string()) return '<%s at 0x%X fileno=%s timeout=%s state_string=%r>' % args |
return proxy(path, start_response) | return proxy(path, start_response, proxy_url) | def application(env, start_response): method = env['REQUEST_METHOD'] path = env['PATH_INFO'] if env['QUERY_STRING']: path += '?' + env['QUERY_STRING'] path = path.lstrip('/') if (method, path) == ('GET', ''): start_response('200 OK', [('Content-Type', 'text/html')]) return [FORM] elif method == 'GET': return proxy(path... |
start_response('302 Found', [('Location', join(PROXY_URL, unquote(value)))]) | start_response('302 Found', [('Location', join(proxy_url, unquote(value)))]) | def application(env, start_response): method = env['REQUEST_METHOD'] path = env['PATH_INFO'] if env['QUERY_STRING']: path += '?' + env['QUERY_STRING'] path = path.lstrip('/') if (method, path) == ('GET', ''): start_response('200 OK', [('Content-Type', 'text/html')]) return [FORM] elif method == 'GET': return proxy(path... |
def proxy(path, start_response): | def proxy(path, start_response, proxy_url): | def proxy(path, start_response): if '://' not in path: path = 'http://' + path try: try: response = urllib2.urlopen(path) except urllib2.HTTPError, ex: response = ex print '%s: %s %s' % (path, response.code, response.msg) headers = [(k, v) for (k, v) in response.headers.items() if k not in drop_headers] scheme, netloc,... |
data = fix_links(data, PROXY_URL, host) | data = fix_links(data, proxy_url, host) | def proxy(path, start_response): if '://' not in path: path = 'http://' + path try: try: response = urllib2.urlopen(path) except urllib2.HTTPError, ex: response = ex print '%s: %s %s' % (path, response.code, response.msg) headers = [(k, v) for (k, v) in response.headers.items() if k not in drop_headers] scheme, netloc,... |
<input size=80 name=url value="http://www.google.com"/> | <input size=80 name=url value="http://www.gevent.org"/> | def fix_link_cb(m): url = m.group('url') if '://' in url: result = m.group('before') + '"' + join(proxy_url, url) + '"' else: result = m.group('before') + '"' + join(proxy_url, host_url, url) + '"' #print 'replaced %r -> %r' % (m.group(0), result) return result |
has expired (default 1 second), then the currenlty running handlers in the pool are killed.""" | has expired (default 1 second), then the currently running handlers in the pool are killed.""" | def stop(self, timeout=None): """Stop accepting the connections and close the listening socket. |
except socket.timeout: | except self.TIMEOUT_ERROR: | def test_recv_timeout(self): acceptor = gevent.spawn_link_exception(self.listener.accept) client = self.create_connection() client.settimeout(0.1) start = time.time() try: data = client.recv(1024) except socket.timeout: assert 0.1 - 0.01 <= time.time() - start <= 0.1 + 0.1, (time.time() - start) else: raise AssertionEr... |
raise AssertionError('socket.timeout should have been raised, instead recv returned %r' % (data, )) | raise AssertionError('%s should have been raised, instead recv returned %r' % (self.TIMEOUT_ERROR, data, )) | def test_recv_timeout(self): acceptor = gevent.spawn_link_exception(self.listener.accept) client = self.create_connection() client.settimeout(0.1) start = time.time() try: data = client.recv(1024) except socket.timeout: assert 0.1 - 0.01 <= time.time() - start <= 0.1 + 0.1, (time.time() - start) else: raise AssertionEr... |
except socket.timeout: | except self.TIMEOUT_ERROR: | def test_sendall_timeout(self): acceptor = gevent.spawn_link_exception(self.listener.accept) client = self.create_connection() client.settimeout(0.1) start = time.time() send_succeed = False data_sent = 'h' * 100000 try: result = client.sendall(data_sent) except socket.timeout: assert 0.1 - 0.01 <= time.time() - start ... |
def readline(self): | def readline(self, size=None): | def readline(self): return self._do_read(self.rfile.readline) |
raise support.TestFailed("Unexpected SSL error: " + str(x)) | raise test_support.TestFailed("Unexpected SSL error: " + str(x)) | def testAllRecvAndSendMethods(self): |
raise support.TestFailed("Unexpected exception: " + str(x)) | raise test_support.TestFailed("Unexpected exception: " + str(x)) | def testAllRecvAndSendMethods(self): |
raise support.TestFailed( | raise test_support.TestFailed( | def _recvfrom_into(): b = bytearray("\0"*100) count, addr = s.recvfrom_into(b) return b[:count] |
def patch_socket(dns=True): | def patch_socket(dns=True, aggressive=True): | def patch_socket(dns=True): from gevent.socket import socket, fromfd, socketpair, SocketType _socket = __import__('socket') _socket.socket = socket _socket.fromfd = fromfd _socket.socketpair = socketpair _socket.SocketType = SocketType try: from gevent.socket import ssl, sslerror _socket.ssl = ssl _socket.sslerror = ss... |
pass | if aggressive: try: del _socket.ssl except AttributeError: pass | def patch_socket(dns=True): from gevent.socket import socket, fromfd, socketpair, SocketType _socket = __import__('socket') _socket.socket = socket _socket.fromfd = fromfd _socket.socketpair = socketpair _socket.SocketType = SocketType try: from gevent.socket import ssl, sslerror _socket.ssl = ssl _socket.sslerror = ss... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.